1 /* 2 * Copyright (c) 1997, 2019, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #ifndef SHARE_RUNTIME_SIGNATURE_HPP 26 #define SHARE_RUNTIME_SIGNATURE_HPP 27 28 #include "classfile/symbolTable.hpp" 29 #include "memory/allocation.hpp" 30 #include "oops/method.hpp" 31 32 // SignatureIterators iterate over a Java signature (or parts of it). 33 // (Syntax according to: "The Java Virtual Machine Specification" by 34 // Tim Lindholm & Frank Yellin; section 4.3 Descriptors; p. 89ff.) 35 // 36 // Example: Iterating over ([Lfoo;D)I using 37 // 0123456789 38 // 39 // iterate_parameters() calls: do_array(2, 7); do_double(); 40 // iterate_returntype() calls: do_int(); 41 // iterate() calls: do_array(2, 7); do_double(); do_int(); 42 // 43 // is_return_type() is: false ; false ; true 44 // 45 // NOTE: The new optimizer has an alternate, for-loop based signature 46 // iterator implemented in opto/type.cpp, TypeTuple::make(). 47 48 class SignatureIterator: public ResourceObj { 49 protected: 50 Symbol* _signature; // the signature to iterate over 51 int _index; // the current character index (only valid during iteration) 52 int _parameter_index; // the current parameter index (0 outside iteration phase) 53 BasicType _return_type; 54 55 void expect(char c); 56 int parse_type(); // returns the parameter size in words (0 for void) 57 void check_signature_end(); 58 59 public: 60 // Definitions used in generating and iterating the 61 // bit field form of the signature generated by the 62 // Fingerprinter. 63 enum { 64 static_feature_size = 1, 65 is_static_bit = 1, 66 67 result_feature_size = 4, 68 result_feature_mask = 0xF, 69 parameter_feature_size = 4, 70 parameter_feature_mask = 0xF, 71 72 bool_parm = 1, 73 byte_parm = 2, 74 char_parm = 3, 75 short_parm = 4, 76 int_parm = 5, 77 long_parm = 6, 78 float_parm = 7, 79 double_parm = 8, 80 obj_parm = 9, 81 done_parm = 10, // marker for end of parameters 82 83 // max parameters is wordsize minus 84 // The sign bit, termination field, the result and static bit fields 85 max_size_of_parameters = (BitsPerLong-1 - 86 result_feature_size - parameter_feature_size - 87 static_feature_size) / parameter_feature_size 88 }; 89 90 // Constructors 91 SignatureIterator(Symbol* signature); 92 93 // Iteration 94 void dispatch_field(); // dispatches once for field signatures 95 void iterate_parameters(); // iterates over parameters only 96 void iterate_parameters( uint64_t fingerprint ); 97 void iterate_returntype(); // iterates over returntype only 98 void iterate(); // iterates over whole signature 99 // Returns the word index of the current parameter; 100 int parameter_index() const { return _parameter_index; } 101 bool is_return_type() const { return parameter_index() < 0; } 102 BasicType get_ret_type() const { return _return_type; } 103 104 // Basic types 105 virtual void do_bool () = 0; 106 virtual void do_char () = 0; 107 virtual void do_float () = 0; 108 virtual void do_double() = 0; 109 virtual void do_byte () = 0; 110 virtual void do_short () = 0; 111 virtual void do_int () = 0; 112 virtual void do_long () = 0; 113 virtual void do_void () = 0; 114 115 // Object types (begin indexes the first character of the entry, end indexes the first character after the entry) 116 virtual void do_object(int begin, int end) = 0; 117 virtual void do_valuetype(int begin, int end) = 0; 118 virtual void do_array (int begin, int end) = 0; 119 120 static bool is_static(uint64_t fingerprint) { 121 assert(fingerprint != (uint64_t)CONST64(-1), "invalid fingerprint"); 122 return fingerprint & is_static_bit; 123 } 124 static BasicType return_type(uint64_t fingerprint) { 125 assert(fingerprint != (uint64_t)CONST64(-1), "invalid fingerprint"); 126 return (BasicType) ((fingerprint >> static_feature_size) & result_feature_mask); 127 } 128 }; 129 130 131 // Specialized SignatureIterators: Used to compute signature specific values. 132 133 class SignatureTypeNames : public SignatureIterator { 134 protected: 135 virtual void type_name(const char* name) = 0; 136 137 void do_bool() { type_name("jboolean"); } 138 void do_char() { type_name("jchar" ); } 139 void do_float() { type_name("jfloat" ); } 140 void do_double() { type_name("jdouble" ); } 141 void do_byte() { type_name("jbyte" ); } 142 void do_short() { type_name("jshort" ); } 143 void do_int() { type_name("jint" ); } 144 void do_long() { type_name("jlong" ); } 145 void do_void() { type_name("void" ); } 146 void do_object(int begin, int end) { type_name("jobject" ); } 147 void do_valuetype(int begin, int end) { type_name("jobject"); } 148 void do_array (int begin, int end) { type_name("jobject" ); } 149 150 public: 151 SignatureTypeNames(Symbol* signature) : SignatureIterator(signature) {} 152 }; 153 154 155 class SignatureInfo: public SignatureIterator { 156 protected: 157 bool _has_iterated; // need this because iterate cannot be called in constructor (set is virtual!) 158 bool _has_iterated_return; 159 int _size; 160 161 void lazy_iterate_parameters() { if (!_has_iterated) { iterate_parameters(); _has_iterated = true; } } 162 void lazy_iterate_return() { if (!_has_iterated_return) { iterate_returntype(); _has_iterated_return = true; } } 163 164 virtual void set(int size, BasicType type) = 0; 165 166 void do_bool () { set(T_BOOLEAN_size, T_BOOLEAN); } 167 void do_char () { set(T_CHAR_size , T_CHAR ); } 168 void do_float () { set(T_FLOAT_size , T_FLOAT ); } 169 void do_double() { set(T_DOUBLE_size , T_DOUBLE ); } 170 void do_byte () { set(T_BYTE_size , T_BYTE ); } 171 void do_short () { set(T_SHORT_size , T_SHORT ); } 172 void do_int () { set(T_INT_size , T_INT ); } 173 void do_long () { set(T_LONG_size , T_LONG ); } 174 void do_void () { set(T_VOID_size , T_VOID ); } 175 void do_object(int begin, int end) { set(T_OBJECT_size , T_OBJECT ); } 176 void do_valuetype(int begin, int end) { set(T_VALUETYPE_size, T_VALUETYPE ); } 177 void do_array (int begin, int end) { set(T_ARRAY_size , T_ARRAY ); } 178 179 public: 180 SignatureInfo(Symbol* signature) : SignatureIterator(signature) { 181 _has_iterated = _has_iterated_return = false; 182 _size = 0; 183 _return_type = T_ILLEGAL; 184 } 185 186 }; 187 188 189 // Specialized SignatureIterator: Used to compute the argument size. 190 191 class ArgumentSizeComputer: public SignatureInfo { 192 private: 193 void set(int size, BasicType type) { _size += size; } 194 public: 195 ArgumentSizeComputer(Symbol* signature) : SignatureInfo(signature) {} 196 197 int size() { lazy_iterate_parameters(); return _size; } 198 }; 199 200 201 class ArgumentCount: public SignatureInfo { 202 private: 203 void set(int size, BasicType type) { _size ++; } 204 public: 205 ArgumentCount(Symbol* signature) : SignatureInfo(signature) {} 206 207 int size() { lazy_iterate_parameters(); return _size; } 208 }; 209 210 211 // Specialized SignatureIterator: Used to compute the result type. 212 213 class ResultTypeFinder: public SignatureInfo { 214 private: 215 void set(int size, BasicType type) { _return_type = type; } 216 public: 217 BasicType type() { lazy_iterate_return(); return _return_type; } 218 219 ResultTypeFinder(Symbol* signature) : SignatureInfo(signature) {} 220 }; 221 222 223 // Fingerprinter computes a unique ID for a given method. The ID 224 // is a bitvector characterizing the methods signature (incl. the receiver). 225 class Fingerprinter: public SignatureIterator { 226 private: 227 uint64_t _fingerprint; 228 int _shift_count; 229 methodHandle mh; 230 231 public: 232 233 void do_bool() { _fingerprint |= (((uint64_t)bool_parm) << _shift_count); _shift_count += parameter_feature_size; } 234 void do_char() { _fingerprint |= (((uint64_t)char_parm) << _shift_count); _shift_count += parameter_feature_size; } 235 void do_byte() { _fingerprint |= (((uint64_t)byte_parm) << _shift_count); _shift_count += parameter_feature_size; } 236 void do_short() { _fingerprint |= (((uint64_t)short_parm) << _shift_count); _shift_count += parameter_feature_size; } 237 void do_int() { _fingerprint |= (((uint64_t)int_parm) << _shift_count); _shift_count += parameter_feature_size; } 238 void do_long() { _fingerprint |= (((uint64_t)long_parm) << _shift_count); _shift_count += parameter_feature_size; } 239 void do_float() { _fingerprint |= (((uint64_t)float_parm) << _shift_count); _shift_count += parameter_feature_size; } 240 void do_double() { _fingerprint |= (((uint64_t)double_parm) << _shift_count); _shift_count += parameter_feature_size; } 241 242 void do_object(int begin, int end) { _fingerprint |= (((uint64_t)obj_parm) << _shift_count); _shift_count += parameter_feature_size; } 243 void do_valuetype(int begin, int end) { _fingerprint |= (((uint64_t)obj_parm) << _shift_count); _shift_count += parameter_feature_size; } 244 void do_array (int begin, int end) { _fingerprint |= (((uint64_t)obj_parm) << _shift_count); _shift_count += parameter_feature_size; } 245 246 void do_void() { ShouldNotReachHere(); } 247 248 Fingerprinter(const methodHandle& method) : SignatureIterator(method->signature()) { 249 mh = method; 250 _fingerprint = 0; 251 } 252 253 uint64_t fingerprint() { 254 // See if we fingerprinted this method already 255 if (mh->constMethod()->fingerprint() != CONST64(0)) { 256 return mh->constMethod()->fingerprint(); 257 } 258 259 if (mh->size_of_parameters() > max_size_of_parameters ) { 260 _fingerprint = (uint64_t)CONST64(-1); 261 mh->constMethod()->set_fingerprint(_fingerprint); 262 return _fingerprint; 263 } 264 265 assert( (int)mh->result_type() <= (int)result_feature_mask, "bad result type"); 266 _fingerprint = mh->result_type(); 267 _fingerprint <<= static_feature_size; 268 if (mh->is_static()) _fingerprint |= 1; 269 _shift_count = result_feature_size + static_feature_size; 270 iterate_parameters(); 271 _fingerprint |= ((uint64_t)done_parm) << _shift_count;// mark end of sig 272 mh->constMethod()->set_fingerprint(_fingerprint); 273 return _fingerprint; 274 } 275 }; 276 277 278 // Specialized SignatureIterator: Used for native call purposes 279 280 class NativeSignatureIterator: public SignatureIterator { 281 private: 282 methodHandle _method; 283 // We need separate JNI and Java offset values because in 64 bit mode, 284 // the argument offsets are not in sync with the Java stack. 285 // For example a long takes up 1 "C" stack entry but 2 Java stack entries. 286 int _offset; // The java stack offset 287 int _prepended; // number of prepended JNI parameters (1 JNIEnv, plus 1 mirror if static) 288 int _jni_offset; // the current parameter offset, starting with 0 289 290 void do_bool () { pass_int(); _jni_offset++; _offset++; } 291 void do_char () { pass_int(); _jni_offset++; _offset++; } 292 void do_float () { pass_float(); _jni_offset++; _offset++; } 293 #ifdef _LP64 294 void do_double() { pass_double(); _jni_offset++; _offset += 2; } 295 #else 296 void do_double() { pass_double(); _jni_offset += 2; _offset += 2; } 297 #endif 298 void do_byte () { pass_int(); _jni_offset++; _offset++; } 299 void do_short () { pass_int(); _jni_offset++; _offset++; } 300 void do_int () { pass_int(); _jni_offset++; _offset++; } 301 #ifdef _LP64 302 void do_long () { pass_long(); _jni_offset++; _offset += 2; } 303 #else 304 void do_long () { pass_long(); _jni_offset += 2; _offset += 2; } 305 #endif 306 void do_void () { ShouldNotReachHere(); } 307 void do_object(int begin, int end) { pass_object(); _jni_offset++; _offset++; } 308 void do_array (int begin, int end) { pass_object(); _jni_offset++; _offset++; } 309 void do_valuetype(int begin, int end){ pass_valuetype(); _jni_offset++; _offset++; } 310 311 public: 312 methodHandle method() const { return _method; } 313 int offset() const { return _offset; } 314 int jni_offset() const { return _jni_offset + _prepended; } 315 // int java_offset() const { return method()->size_of_parameters() - _offset - 1; } 316 bool is_static() const { return method()->is_static(); } 317 virtual void pass_int() = 0; 318 virtual void pass_long() = 0; 319 virtual void pass_object() = 0; 320 virtual void pass_valuetype() = 0; 321 virtual void pass_float() = 0; 322 #ifdef _LP64 323 virtual void pass_double() = 0; 324 #else 325 virtual void pass_double() { pass_long(); } // may be same as long 326 #endif 327 328 NativeSignatureIterator(const methodHandle& method) : SignatureIterator(method->signature()) { 329 _method = method; 330 _offset = 0; 331 _jni_offset = 0; 332 333 const int JNIEnv_words = 1; 334 const int mirror_words = 1; 335 _prepended = !is_static() ? JNIEnv_words : JNIEnv_words + mirror_words; 336 } 337 338 // iterate() calles the 2 virtual methods according to the following invocation syntax: 339 // 340 // {pass_int | pass_long | pass_object} 341 // 342 // Arguments are handled from left to right (receiver first, if any). 343 // The offset() values refer to the Java stack offsets but are 0 based and increasing. 344 // The java_offset() values count down to 0, and refer to the Java TOS. 345 // The jni_offset() values increase from 1 or 2, and refer to C arguments. 346 347 void iterate() { iterate(Fingerprinter(method()).fingerprint()); 348 } 349 350 351 // Optimized path if we have the bitvector form of signature 352 void iterate( uint64_t fingerprint ) { 353 354 if (!is_static()) { 355 // handle receiver (not handled by iterate because not in signature) 356 pass_object(); _jni_offset++; _offset++; 357 } 358 359 SignatureIterator::iterate_parameters( fingerprint ); 360 } 361 }; 362 363 364 // Handy stream for iterating over signature 365 366 class SignatureStream : public StackObj { 367 private: 368 Symbol* _signature; 369 int _begin; 370 int _end; 371 BasicType _type; 372 bool _at_return_type; 373 GrowableArray<Symbol*>* _names; // symbols created while parsing signature 374 375 public: 376 bool at_return_type() const { return _at_return_type; } 377 bool is_done() const; 378 void next_non_primitive(int t); 379 void next() { 380 Symbol* sig = _signature; 381 int len = sig->utf8_length(); 382 if (_end >= len) { 383 _end = len + 1; 384 return; 385 } 386 387 _begin = _end; 388 int t = sig->char_at(_begin); 389 switch (t) { 390 case 'B': _type = T_BYTE; break; 391 case 'C': _type = T_CHAR; break; 392 case 'D': _type = T_DOUBLE; break; 393 case 'F': _type = T_FLOAT; break; 394 case 'I': _type = T_INT; break; 395 case 'J': _type = T_LONG; break; 396 case 'S': _type = T_SHORT; break; 397 case 'Z': _type = T_BOOLEAN; break; 398 case 'V': _type = T_VOID; break; 399 default : next_non_primitive(t); 400 return; 401 } 402 _end++; 403 } 404 405 SignatureStream(Symbol* signature, bool is_method = true); 406 ~SignatureStream(); 407 408 bool is_object() const; // True if this argument is an object 409 bool is_array() const; // True if this argument is an array 410 BasicType type() const { return _type; } 411 Symbol* as_symbol(TRAPS); 412 enum FailureMode { ReturnNull, CNFException, NCDFError }; 413 Klass* as_klass(Handle class_loader, Handle protection_domain, FailureMode failure_mode, TRAPS); 414 oop as_java_mirror(Handle class_loader, Handle protection_domain, FailureMode failure_mode, TRAPS); 415 const u1* raw_bytes() { return _signature->bytes() + _begin; } 416 int raw_length() { return _end - _begin; } 417 418 // return same as_symbol except allocation of new symbols is avoided. 419 Symbol* as_symbol_or_null(); 420 421 // count the number of references in the signature 422 int reference_parameter_count(); 423 }; 424 425 class SignatureVerifier : public StackObj { 426 public: 427 // Returns true if the symbol is valid method or type signature 428 static bool is_valid_signature(Symbol* sig); 429 430 static bool is_valid_method_signature(Symbol* sig); 431 static bool is_valid_type_signature(Symbol* sig); 432 private: 433 434 static ssize_t is_valid_type(const char*, ssize_t); 435 static bool invalid_name_char(char); 436 }; 437 438 class SigEntryFilter; 439 typedef GrowableArrayFilterIterator<SigEntry, SigEntryFilter> ExtendedSignature; 440 441 // Used for adapter generation. One SigEntry is used per element of 442 // the signature of the method. Value type arguments are treated 443 // specially. See comment for ValueKlass::collect_fields(). 444 class SigEntry { 445 public: 446 BasicType _bt; 447 int _offset; 448 449 enum { ReservedOffset = -2 }; // Special offset to mark the reserved entry 450 451 SigEntry() 452 : _bt(T_ILLEGAL), _offset(-1) { 453 } 454 SigEntry(BasicType bt, int offset) 455 : _bt(bt), _offset(offset) {} 456 457 SigEntry(BasicType bt) 458 : _bt(bt), _offset(-1) {} 459 460 static int compare(SigEntry* e1, SigEntry* e2) { 461 if (e1->_offset != e2->_offset) { 462 return e1->_offset - e2->_offset; 463 } 464 assert((e1->_bt == T_LONG && (e2->_bt == T_LONG || e2->_bt == T_VOID)) || 465 (e1->_bt == T_DOUBLE && (e2->_bt == T_DOUBLE || e2->_bt == T_VOID)) || 466 e1->_bt == T_VALUETYPE || e2->_bt == T_VALUETYPE || e1->_bt == T_VOID || e2->_bt == T_VOID, "bad bt"); 467 if (e1->_bt == e2->_bt) { 468 assert(e1->_bt == T_VALUETYPE || e1->_bt == T_VOID, "only ones with duplicate offsets"); 469 return 0; 470 } 471 if (e1->_bt == T_VOID || 472 e2->_bt == T_VALUETYPE) { 473 return 1; 474 } 475 if (e1->_bt == T_VALUETYPE || 476 e2->_bt == T_VOID) { 477 return -1; 478 } 479 ShouldNotReachHere(); 480 return 0; 481 } 482 static void add_entry(GrowableArray<SigEntry>* sig, BasicType bt, int offset = -1); 483 static void insert_reserved_entry(GrowableArray<SigEntry>* sig, int i, BasicType bt); 484 static bool is_reserved_entry(const GrowableArray<SigEntry>* sig, int i); 485 static bool skip_value_delimiters(const GrowableArray<SigEntry>* sig, int i); 486 static int fill_sig_bt(const GrowableArray<SigEntry>* sig, BasicType* sig_bt); 487 static TempNewSymbol create_symbol(const GrowableArray<SigEntry>* sig); 488 489 static bool next_is_reserved(ExtendedSignature& sig, BasicType& bt, bool can_be_void = false); 490 }; 491 492 class SigEntryFilter { 493 public: 494 bool operator()(const SigEntry& entry) { return entry._bt != T_VALUETYPE && entry._bt != T_VOID; } 495 }; 496 497 #endif // SHARE_RUNTIME_SIGNATURE_HPP