signature.hpp revision 1601:126ea7725993
1107120Sjulian/* 2107120Sjulian * Copyright (c) 1997, 2006, Oracle and/or its affiliates. All rights reserved. 3107120Sjulian * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4107120Sjulian * 5107120Sjulian * This code is free software; you can redistribute it and/or modify it 6107120Sjulian * under the terms of the GNU General Public License version 2 only, as 7107120Sjulian * published by the Free Software Foundation. 8107120Sjulian * 9107120Sjulian * This code is distributed in the hope that it will be useful, but WITHOUT 10107120Sjulian * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11107120Sjulian * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12107120Sjulian * version 2 for more details (a copy is included in the LICENSE file that 13107120Sjulian * accompanied this code). 14107120Sjulian * 15107120Sjulian * You should have received a copy of the GNU General Public License version 16107120Sjulian * 2 along with this work; if not, write to the Free Software Foundation, 17107120Sjulian * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18107120Sjulian * 19107120Sjulian * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20107120Sjulian * or visit www.oracle.com if you need additional information or have any 21107120Sjulian * questions. 22107120Sjulian * 23107120Sjulian */ 24107120Sjulian 25107120Sjulian// SignatureIterators iterate over a Java signature (or parts of it). 26107120Sjulian// (Syntax according to: "The Java Virtual Machine Specification" by 27107120Sjulian// Tim Lindholm & Frank Yellin; section 4.3 Descriptors; p. 89ff.) 28114878Sjulian// 29107120Sjulian// Example: Iterating over ([Lfoo;D)I using 30107120Sjulian// 0123456789 31107120Sjulian// 32107120Sjulian// iterate_parameters() calls: do_array(2, 7); do_double(); 33122634Semax// iterate_returntype() calls: do_int(); 34107120Sjulian// iterate() calls: do_array(2, 7); do_double(); do_int(); 35107120Sjulian// 36107120Sjulian// is_return_type() is: false ; false ; true 37107120Sjulian// 38107120Sjulian// NOTE: The new optimizer has an alternate, for-loop based signature 39107120Sjulian// iterator implemented in opto/type.cpp, TypeTuple::make(). 40107120Sjulian 41107120Sjulianclass SignatureIterator: public ResourceObj { 42107120Sjulian protected: 43107120Sjulian symbolHandle _signature; // the signature to iterate over 44107120Sjulian int _index; // the current character index (only valid during iteration) 45107120Sjulian int _parameter_index; // the current parameter index (0 outside iteration phase) 46107120Sjulian BasicType _return_type; 47107120Sjulian 48107120Sjulian void expect(char c); 49107120Sjulian void skip_optional_size(); 50107120Sjulian int parse_type(); // returns the parameter size in words (0 for void) 51107120Sjulian void check_signature_end(); 52107120Sjulian 53107120Sjulian public: 54107120Sjulian // Definitions used in generating and iterating the 55107120Sjulian // bit field form of the signature generated by the 56107120Sjulian // Fingerprinter. 57107120Sjulian enum { 58107120Sjulian static_feature_size = 1, 59107120Sjulian result_feature_size = 4, 60107120Sjulian result_feature_mask = 0xF, 61107120Sjulian parameter_feature_size = 4, 62107120Sjulian parameter_feature_mask = 0xF, 63107120Sjulian 64107120Sjulian bool_parm = 1, 65107120Sjulian byte_parm = 2, 66107120Sjulian char_parm = 3, 67107120Sjulian short_parm = 4, 68107120Sjulian int_parm = 5, 69107120Sjulian long_parm = 6, 70107120Sjulian float_parm = 7, 71107120Sjulian double_parm = 8, 72107120Sjulian obj_parm = 9, 73107120Sjulian done_parm = 10, // marker for end of parameters 74107120Sjulian 75107120Sjulian // max parameters is wordsize minus 76107120Sjulian // The sign bit, termination field, the result and static bit fields 77107120Sjulian max_size_of_parameters = (BitsPerLong-1 - 78107120Sjulian result_feature_size - parameter_feature_size - 79107120Sjulian static_feature_size) / parameter_feature_size 80107120Sjulian }; 81107120Sjulian 82107120Sjulian // Constructors 83107120Sjulian SignatureIterator(symbolOop signature); 84107120Sjulian SignatureIterator(Thread *thread, symbolOop signature); 85107120Sjulian SignatureIterator(symbolHandle signature); 86107120Sjulian 87107120Sjulian // Iteration 88107120Sjulian void dispatch_field(); // dispatches once for field signatures 89107120Sjulian void iterate_parameters(); // iterates over parameters only 90107120Sjulian void iterate_parameters( uint64_t fingerprint ); 91107120Sjulian void iterate_returntype(); // iterates over returntype only 92107120Sjulian void iterate(); // iterates over whole signature 93107120Sjulian // Returns the word index of the current parameter; 94107120Sjulian int parameter_index() const { return _parameter_index; } 95107120Sjulian bool is_return_type() const { return parameter_index() < 0; } 96107120Sjulian BasicType get_ret_type() const { return _return_type; } 97107120Sjulian 98107120Sjulian // Basic types 99107120Sjulian virtual void do_bool () = 0; 100107120Sjulian virtual void do_char () = 0; 101107120Sjulian virtual void do_float () = 0; 102107120Sjulian virtual void do_double() = 0; 103107120Sjulian virtual void do_byte () = 0; 104107120Sjulian virtual void do_short () = 0; 105107120Sjulian virtual void do_int () = 0; 106107120Sjulian virtual void do_long () = 0; 107107120Sjulian virtual void do_void () = 0; 108107120Sjulian 109107120Sjulian // Object types (begin indexes the first character of the entry, end indexes the first character after the entry) 110107120Sjulian virtual void do_object(int begin, int end) = 0; 111107120Sjulian virtual void do_array (int begin, int end) = 0; 112107120Sjulian}; 113107120Sjulian 114107120Sjulian 115107120Sjulian// Specialized SignatureIterators: Used to compute signature specific values. 116107120Sjulian 117107120Sjulianclass SignatureTypeNames : public SignatureIterator { 118107120Sjulian protected: 119107120Sjulian virtual void type_name(const char* name) = 0; 120107120Sjulian 121107120Sjulian void do_bool() { type_name("jboolean"); } 122107120Sjulian void do_char() { type_name("jchar" ); } 123107120Sjulian void do_float() { type_name("jfloat" ); } 124107120Sjulian void do_double() { type_name("jdouble" ); } 125107120Sjulian void do_byte() { type_name("jbyte" ); } 126107120Sjulian void do_short() { type_name("jshort" ); } 127107120Sjulian void do_int() { type_name("jint" ); } 128107120Sjulian void do_long() { type_name("jlong" ); } 129107120Sjulian void do_void() { type_name("void" ); } 130107120Sjulian void do_object(int begin, int end) { type_name("jobject" ); } 131107120Sjulian void do_array (int begin, int end) { type_name("jobject" ); } 132107120Sjulian 133107120Sjulian public: 134107120Sjulian SignatureTypeNames(symbolHandle signature) : SignatureIterator(signature) {} 135107120Sjulian}; 136114878Sjulian 137107120Sjulian 138107120Sjulianclass SignatureInfo: public SignatureIterator { 139107120Sjulian protected: 140107120Sjulian bool _has_iterated; // need this because iterate cannot be called in constructor (set is virtual!) 141107120Sjulian bool _has_iterated_return; 142107120Sjulian int _size; 143107120Sjulian 144107120Sjulian void lazy_iterate_parameters() { if (!_has_iterated) { iterate_parameters(); _has_iterated = true; } } 145107120Sjulian void lazy_iterate_return() { if (!_has_iterated_return) { iterate_returntype(); _has_iterated_return = true; } } 146107120Sjulian 147107120Sjulian virtual void set(int size, BasicType type) = 0; 148107120Sjulian 149107120Sjulian void do_bool () { set(T_BOOLEAN_size, T_BOOLEAN); } 150107120Sjulian void do_char () { set(T_CHAR_size , T_CHAR ); } 151107120Sjulian void do_float () { set(T_FLOAT_size , T_FLOAT ); } 152107120Sjulian void do_double() { set(T_DOUBLE_size , T_DOUBLE ); } 153107120Sjulian void do_byte () { set(T_BYTE_size , T_BYTE ); } 154107120Sjulian void do_short () { set(T_SHORT_size , T_SHORT ); } 155107120Sjulian void do_int () { set(T_INT_size , T_INT ); } 156107120Sjulian void do_long () { set(T_LONG_size , T_LONG ); } 157107120Sjulian void do_void () { set(T_VOID_size , T_VOID ); } 158107120Sjulian void do_object(int begin, int end) { set(T_OBJECT_size , T_OBJECT ); } 159107120Sjulian void do_array (int begin, int end) { set(T_ARRAY_size , T_ARRAY ); } 160107120Sjulian 161107120Sjulian public: 162107120Sjulian SignatureInfo(symbolHandle signature) : SignatureIterator(signature) { 163107120Sjulian _has_iterated = _has_iterated_return = false; 164107120Sjulian _size = 0; 165107120Sjulian _return_type = T_ILLEGAL; 166107120Sjulian } 167107120Sjulian 168107120Sjulian}; 169107120Sjulian 170107120Sjulian 171107120Sjulian// Specialized SignatureIterator: Used to compute the argument size. 172107120Sjulian 173107120Sjulianclass ArgumentSizeComputer: public SignatureInfo { 174107120Sjulian private: 175114878Sjulian void set(int size, BasicType type) { _size += size; } 176114878Sjulian public: 177107120Sjulian ArgumentSizeComputer(symbolHandle signature) : SignatureInfo(signature) {} 178107120Sjulian 179107120Sjulian int size() { lazy_iterate_parameters(); return _size; } 180107120Sjulian}; 181107120Sjulian 182107120Sjulian 183107120Sjulianclass ArgumentCount: public SignatureInfo { 184107120Sjulian private: 185107120Sjulian void set(int size, BasicType type) { _size ++; } 186107120Sjulian public: 187107120Sjulian ArgumentCount(symbolHandle signature) : SignatureInfo(signature) {} 188107120Sjulian 189107120Sjulian int size() { lazy_iterate_parameters(); return _size; } 190107120Sjulian}; 191107120Sjulian 192107120Sjulian 193107120Sjulian// Specialized SignatureIterator: Used to compute the result type. 194107120Sjulian 195107120Sjulianclass ResultTypeFinder: public SignatureInfo { 196107120Sjulian private: 197107120Sjulian void set(int size, BasicType type) { _return_type = type; } 198107120Sjulian public: 199107120Sjulian BasicType type() { lazy_iterate_return(); return _return_type; } 200107120Sjulian 201107120Sjulian ResultTypeFinder(symbolHandle signature) : SignatureInfo(signature) {} 202107120Sjulian}; 203107120Sjulian 204107120Sjulian 205107120Sjulian// Fingerprinter computes a unique ID for a given method. The ID 206107120Sjulian// is a bitvector characterizing the methods signature (incl. the receiver). 207107120Sjulianclass Fingerprinter: public SignatureIterator { 208107120Sjulian private: 209107120Sjulian uint64_t _fingerprint; 210107120Sjulian int _shift_count; 211107120Sjulian methodHandle mh; 212107120Sjulian 213107120Sjulian public: 214107120Sjulian 215107120Sjulian void do_bool() { _fingerprint |= (((uint64_t)bool_parm) << _shift_count); _shift_count += parameter_feature_size; } 216107120Sjulian void do_char() { _fingerprint |= (((uint64_t)char_parm) << _shift_count); _shift_count += parameter_feature_size; } 217 void do_byte() { _fingerprint |= (((uint64_t)byte_parm) << _shift_count); _shift_count += parameter_feature_size; } 218 void do_short() { _fingerprint |= (((uint64_t)short_parm) << _shift_count); _shift_count += parameter_feature_size; } 219 void do_int() { _fingerprint |= (((uint64_t)int_parm) << _shift_count); _shift_count += parameter_feature_size; } 220 void do_long() { _fingerprint |= (((uint64_t)long_parm) << _shift_count); _shift_count += parameter_feature_size; } 221 void do_float() { _fingerprint |= (((uint64_t)float_parm) << _shift_count); _shift_count += parameter_feature_size; } 222 void do_double() { _fingerprint |= (((uint64_t)double_parm) << _shift_count); _shift_count += parameter_feature_size; } 223 224 void do_object(int begin, int end) { _fingerprint |= (((uint64_t)obj_parm) << _shift_count); _shift_count += parameter_feature_size; } 225 void do_array (int begin, int end) { _fingerprint |= (((uint64_t)obj_parm) << _shift_count); _shift_count += parameter_feature_size; } 226 227 void do_void() { ShouldNotReachHere(); } 228 229 Fingerprinter(methodHandle method) : SignatureIterator(method->signature()) { 230 mh = method; 231 _fingerprint = 0; 232 } 233 234 Fingerprinter(Thread *thread, methodHandle method) : SignatureIterator(thread, method->signature()) { 235 mh = method; 236 _fingerprint = 0; 237 } 238 239 uint64_t fingerprint() { 240 // See if we fingerprinted this method already 241 if (mh->constMethod()->fingerprint() != CONST64(0)) { 242 return mh->constMethod()->fingerprint(); 243 } 244 245 if (mh->size_of_parameters() > max_size_of_parameters ) { 246 _fingerprint = UCONST64(-1); 247 mh->constMethod()->set_fingerprint(_fingerprint); 248 return _fingerprint; 249 } 250 251 assert( (int)mh->result_type() <= (int)result_feature_mask, "bad result type"); 252 _fingerprint = mh->result_type(); 253 _fingerprint <<= static_feature_size; 254 if (mh->is_static()) _fingerprint |= 1; 255 _shift_count = result_feature_size + static_feature_size; 256 iterate_parameters(); 257 _fingerprint |= ((uint64_t)done_parm) << _shift_count;// mark end of sig 258 mh->constMethod()->set_fingerprint(_fingerprint); 259 return _fingerprint; 260 } 261}; 262 263 264// Specialized SignatureIterator: Used for native call purposes 265 266class NativeSignatureIterator: public SignatureIterator { 267 private: 268 methodHandle _method; 269// We need separate JNI and Java offset values because in 64 bit mode, 270// the argument offsets are not in sync with the Java stack. 271// For example a long takes up 1 "C" stack entry but 2 Java stack entries. 272 int _offset; // The java stack offset 273 int _prepended; // number of prepended JNI parameters (1 JNIEnv, plus 1 mirror if static) 274 int _jni_offset; // the current parameter offset, starting with 0 275 276 void do_bool () { pass_int(); _jni_offset++; _offset++; } 277 void do_char () { pass_int(); _jni_offset++; _offset++; } 278 void do_float () { pass_float(); _jni_offset++; _offset++; } 279#ifdef _LP64 280 void do_double() { pass_double(); _jni_offset++; _offset += 2; } 281#else 282 void do_double() { pass_double(); _jni_offset += 2; _offset += 2; } 283#endif 284 void do_byte () { pass_int(); _jni_offset++; _offset++; } 285 void do_short () { pass_int(); _jni_offset++; _offset++; } 286 void do_int () { pass_int(); _jni_offset++; _offset++; } 287#ifdef _LP64 288 void do_long () { pass_long(); _jni_offset++; _offset += 2; } 289#else 290 void do_long () { pass_long(); _jni_offset += 2; _offset += 2; } 291#endif 292 void do_void () { ShouldNotReachHere(); } 293 void do_object(int begin, int end) { pass_object(); _jni_offset++; _offset++; } 294 void do_array (int begin, int end) { pass_object(); _jni_offset++; _offset++; } 295 296 public: 297 methodHandle method() const { return _method; } 298 int offset() const { return _offset; } 299 int jni_offset() const { return _jni_offset + _prepended; } 300// int java_offset() const { return method()->size_of_parameters() - _offset - 1; } 301 bool is_static() const { return method()->is_static(); } 302 virtual void pass_int() = 0; 303 virtual void pass_long() = 0; 304 virtual void pass_object() = 0; 305 virtual void pass_float() = 0; 306#ifdef _LP64 307 virtual void pass_double() = 0; 308#else 309 virtual void pass_double() { pass_long(); } // may be same as long 310#endif 311 312 NativeSignatureIterator(methodHandle method) : SignatureIterator(method->signature()) { 313 _method = method; 314 _offset = 0; 315 _jni_offset = 0; 316 317 const int JNIEnv_words = 1; 318 const int mirror_words = 1; 319 _prepended = !is_static() ? JNIEnv_words : JNIEnv_words + mirror_words; 320 } 321 322 // iterate() calles the 2 virtual methods according to the following invocation syntax: 323 // 324 // {pass_int | pass_long | pass_object} 325 // 326 // Arguments are handled from left to right (receiver first, if any). 327 // The offset() values refer to the Java stack offsets but are 0 based and increasing. 328 // The java_offset() values count down to 0, and refer to the Java TOS. 329 // The jni_offset() values increase from 1 or 2, and refer to C arguments. 330 331 void iterate() { iterate(Fingerprinter(method()).fingerprint()); 332 } 333 334 335 // Optimized path if we have the bitvector form of signature 336 void iterate( uint64_t fingerprint ) { 337 338 if (!is_static()) { 339 // handle receiver (not handled by iterate because not in signature) 340 pass_object(); _jni_offset++; _offset++; 341 } 342 343 SignatureIterator::iterate_parameters( fingerprint ); 344 } 345}; 346 347 348// Handy stream for iterating over signature 349 350class SignatureStream : public StackObj { 351 private: 352 symbolHandle _signature; 353 int _begin; 354 int _end; 355 BasicType _type; 356 bool _at_return_type; 357 358 public: 359 bool at_return_type() const { return _at_return_type; } 360 bool is_done() const; 361 void next_non_primitive(int t); 362 void next() { 363 symbolOop sig = _signature(); 364 int len = sig->utf8_length(); 365 if (_end >= len) { 366 _end = len + 1; 367 return; 368 } 369 370 _begin = _end; 371 int t = sig->byte_at(_begin); 372 switch (t) { 373 case 'B': _type = T_BYTE; break; 374 case 'C': _type = T_CHAR; break; 375 case 'D': _type = T_DOUBLE; break; 376 case 'F': _type = T_FLOAT; break; 377 case 'I': _type = T_INT; break; 378 case 'J': _type = T_LONG; break; 379 case 'S': _type = T_SHORT; break; 380 case 'Z': _type = T_BOOLEAN; break; 381 case 'V': _type = T_VOID; break; 382 default : next_non_primitive(t); 383 return; 384 } 385 _end++; 386 } 387 388 SignatureStream(symbolHandle signature, 389 bool is_method = true) : 390 _signature(signature), _at_return_type(false) { 391 _begin = _end = (is_method ? 1 : 0); // skip first '(' in method signatures 392 next(); 393 } 394 395 bool is_object() const; // True if this argument is an object 396 bool is_array() const; // True if this argument is an array 397 BasicType type() const { return _type; } 398 symbolOop as_symbol(TRAPS); 399 enum FailureMode { ReturnNull, CNFException, NCDFError }; 400 klassOop as_klass(Handle class_loader, Handle protection_domain, FailureMode failure_mode, TRAPS); 401 oop as_java_mirror(Handle class_loader, Handle protection_domain, FailureMode failure_mode, TRAPS); 402 403 // return same as_symbol except allocation of new symbols is avoided. 404 symbolOop as_symbol_or_null(); 405}; 406 407class SignatureVerifier : public StackObj { 408 public: 409 // Returns true if the symbol is valid method or type signature 410 static bool is_valid_signature(symbolHandle sig); 411 412 static bool is_valid_method_signature(symbolHandle sig); 413 static bool is_valid_type_signature(symbolHandle sig); 414 private: 415 416 static ssize_t is_valid_type(const char*, ssize_t); 417 static bool invalid_name_char(char); 418}; 419