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 #include "precompiled.hpp" 26 #include "classfile/symbolTable.hpp" 27 #include "classfile/systemDictionary.hpp" 28 #include "memory/oopFactory.hpp" 29 #include "memory/resourceArea.hpp" 30 #include "memory/universe.hpp" 31 #include "oops/instanceKlass.hpp" 32 #include "oops/oop.inline.hpp" 33 #include "oops/symbol.hpp" 34 #include "oops/typeArrayKlass.hpp" 35 #include "oops/valueKlass.hpp" 36 #include "runtime/handles.inline.hpp" 37 #include "runtime/signature.hpp" 38 39 // Implementation of SignatureIterator 40 41 // Signature syntax: 42 // 43 // Signature = "(" {Parameter} ")" ReturnType. 44 // Parameter = FieldType. 45 // ReturnType = FieldType | "V". 46 // FieldType = "B" | "C" | "D" | "F" | "I" | "J" | "S" | "Z" | "L" ClassName ";" | "Q" ValueClassName ";" | "[" FieldType. 47 // ClassName = string. 48 49 50 SignatureIterator::SignatureIterator(Symbol* signature) { 51 _signature = signature; 52 _parameter_index = 0; 53 } 54 55 void SignatureIterator::expect(char c) { 56 if (_signature->char_at(_index) != c) fatal("expecting %c", c); 57 _index++; 58 } 59 60 int SignatureIterator::parse_type() { 61 // Note: This function could be simplified by using "return T_XXX_size;" 62 // instead of the assignment and the break statements. However, it 63 // seems that the product build for win32_i486 with MS VC++ 6.0 doesn't 64 // work (stack underflow for some tests) - this seems to be a VC++ 6.0 65 // compiler bug (was problem - gri 4/27/2000). 66 int size = -1; 67 switch(_signature->char_at(_index)) { 68 case 'B': do_byte (); if (_parameter_index < 0 ) _return_type = T_BYTE; 69 _index++; size = T_BYTE_size ; break; 70 case 'C': do_char (); if (_parameter_index < 0 ) _return_type = T_CHAR; 71 _index++; size = T_CHAR_size ; break; 72 case 'D': do_double(); if (_parameter_index < 0 ) _return_type = T_DOUBLE; 73 _index++; size = T_DOUBLE_size ; break; 74 case 'F': do_float (); if (_parameter_index < 0 ) _return_type = T_FLOAT; 75 _index++; size = T_FLOAT_size ; break; 76 case 'I': do_int (); if (_parameter_index < 0 ) _return_type = T_INT; 77 _index++; size = T_INT_size ; break; 78 case 'J': do_long (); if (_parameter_index < 0 ) _return_type = T_LONG; 79 _index++; size = T_LONG_size ; break; 80 case 'S': do_short (); if (_parameter_index < 0 ) _return_type = T_SHORT; 81 _index++; size = T_SHORT_size ; break; 82 case 'Z': do_bool (); if (_parameter_index < 0 ) _return_type = T_BOOLEAN; 83 _index++; size = T_BOOLEAN_size; break; 84 case 'V': do_void (); if (_parameter_index < 0 ) _return_type = T_VOID; 85 _index++; size = T_VOID_size; ; break; 86 case 'L': 87 { int begin = ++_index; 88 Symbol* sig = _signature; 89 while (sig->char_at(_index++) != ';') ; 90 do_object(begin, _index); 91 } 92 if (_parameter_index < 0 ) _return_type = T_OBJECT; 93 size = T_OBJECT_size; 94 break; 95 case 'Q': 96 { int begin = ++_index; 97 Symbol* sig = _signature; 98 while (sig->char_at(_index++) != ';') ; 99 do_valuetype(begin, _index); 100 } 101 if (_parameter_index < 0 ) _return_type = T_VALUETYPE; 102 size = T_VALUETYPE_size; 103 break; 104 case '[': 105 { int begin = ++_index; 106 Symbol* sig = _signature; 107 while (sig->char_at(_index) == '[') { 108 _index++; 109 } 110 if (sig->char_at(_index) == 'L' || sig->char_at(_index) == 'Q') { 111 while (sig->char_at(_index++) != ';') ; 112 } else { 113 _index++; 114 } 115 do_array(begin, _index); 116 if (_parameter_index < 0 ) _return_type = T_ARRAY; 117 } 118 size = T_ARRAY_size; 119 break; 120 default: 121 ShouldNotReachHere(); 122 break; 123 } 124 assert(size >= 0, "size must be set"); 125 return size; 126 } 127 128 129 void SignatureIterator::check_signature_end() { 130 if (_index < _signature->utf8_length()) { 131 tty->print_cr("too many chars in signature"); 132 _signature->print_value_on(tty); 133 tty->print_cr(" @ %d", _index); 134 } 135 } 136 137 138 void SignatureIterator::iterate_parameters() { 139 // Parse parameters 140 _index = 0; 141 _parameter_index = 0; 142 expect('('); 143 while (_signature->char_at(_index) != ')') _parameter_index += parse_type(); 144 expect(')'); 145 _parameter_index = 0; 146 } 147 148 // Optimized version of iterate_parameters when fingerprint is known 149 void SignatureIterator::iterate_parameters( uint64_t fingerprint ) { 150 uint64_t saved_fingerprint = fingerprint; 151 152 // Check for too many arguments 153 if (fingerprint == (uint64_t)CONST64(-1)) { 154 SignatureIterator::iterate_parameters(); 155 return; 156 } 157 158 assert(fingerprint, "Fingerprint should not be 0"); 159 160 _parameter_index = 0; 161 fingerprint = fingerprint >> (static_feature_size + result_feature_size); 162 while ( 1 ) { 163 switch ( fingerprint & parameter_feature_mask ) { 164 case bool_parm: 165 do_bool(); 166 _parameter_index += T_BOOLEAN_size; 167 break; 168 case byte_parm: 169 do_byte(); 170 _parameter_index += T_BYTE_size; 171 break; 172 case char_parm: 173 do_char(); 174 _parameter_index += T_CHAR_size; 175 break; 176 case short_parm: 177 do_short(); 178 _parameter_index += T_SHORT_size; 179 break; 180 case int_parm: 181 do_int(); 182 _parameter_index += T_INT_size; 183 break; 184 case obj_parm: 185 do_object(0, 0); 186 _parameter_index += T_OBJECT_size; 187 break; 188 case long_parm: 189 do_long(); 190 _parameter_index += T_LONG_size; 191 break; 192 case float_parm: 193 do_float(); 194 _parameter_index += T_FLOAT_size; 195 break; 196 case double_parm: 197 do_double(); 198 _parameter_index += T_DOUBLE_size; 199 break; 200 case done_parm: 201 return; 202 default: 203 tty->print_cr("*** parameter is " UINT64_FORMAT, fingerprint & parameter_feature_mask); 204 tty->print_cr("*** fingerprint is " PTR64_FORMAT, saved_fingerprint); 205 ShouldNotReachHere(); 206 break; 207 } 208 fingerprint >>= parameter_feature_size; 209 } 210 } 211 212 213 void SignatureIterator::iterate_returntype() { 214 // Ignore parameters 215 _index = 0; 216 expect('('); 217 Symbol* sig = _signature; 218 // Need to skip over each type in the signature's argument list until a 219 // closing ')' is found., then get the return type. We cannot just scan 220 // for the first ')' because ')' is a legal character in a type name. 221 while (sig->char_at(_index) != ')') { 222 switch(sig->char_at(_index)) { 223 case 'B': 224 case 'C': 225 case 'D': 226 case 'F': 227 case 'I': 228 case 'J': 229 case 'S': 230 case 'Z': 231 case 'V': 232 { 233 _index++; 234 } 235 break; 236 case 'Q': 237 case 'L': 238 { 239 while (sig->char_at(_index++) != ';') ; 240 } 241 break; 242 case '[': 243 { 244 while (sig->char_at(++_index) == '[') ; 245 if (sig->char_at(_index) == 'L' || sig->char_at(_index) == 'Q' ) { 246 while (sig->char_at(_index++) != ';') ; 247 } else { 248 _index++; 249 } 250 } 251 break; 252 default: 253 ShouldNotReachHere(); 254 break; 255 } 256 } 257 expect(')'); 258 // Parse return type 259 _parameter_index = -1; 260 parse_type(); 261 check_signature_end(); 262 _parameter_index = 0; 263 } 264 265 266 void SignatureIterator::iterate() { 267 // Parse parameters 268 _parameter_index = 0; 269 _index = 0; 270 expect('('); 271 while (_signature->char_at(_index) != ')') _parameter_index += parse_type(); 272 expect(')'); 273 // Parse return type 274 _parameter_index = -1; 275 parse_type(); 276 check_signature_end(); 277 _parameter_index = 0; 278 } 279 280 281 // Implementation of SignatureStream 282 SignatureStream::SignatureStream(Symbol* signature, bool is_method) : 283 _signature(signature), _at_return_type(false), _previous_name(NULL), _names(NULL) { 284 _begin = _end = (is_method ? 1 : 0); // skip first '(' in method signatures 285 next(); 286 } 287 288 SignatureStream::~SignatureStream() { 289 // decrement refcount for names created during signature parsing 290 if (_names != NULL) { 291 for (int i = 0; i < _names->length(); i++) { 292 _names->at(i)->decrement_refcount(); 293 } 294 } 295 } 296 297 bool SignatureStream::is_done() const { 298 return _end > _signature->utf8_length(); 299 } 300 301 302 void SignatureStream::next_non_primitive(int t) { 303 switch (t) { 304 case 'L': { 305 _type = T_OBJECT; 306 Symbol* sig = _signature; 307 while (sig->char_at(_end++) != ';'); 308 break; 309 } 310 case 'Q': { 311 _type = T_VALUETYPE; 312 Symbol* sig = _signature; 313 while (sig->char_at(_end++) != ';'); 314 break; 315 } 316 case '[': { 317 _type = T_ARRAY; 318 Symbol* sig = _signature; 319 char c = sig->char_at(_end); 320 while ('0' <= c && c <= '9') c = sig->char_at(_end++); 321 while (sig->char_at(_end) == '[') { 322 _end++; 323 c = sig->char_at(_end); 324 while ('0' <= c && c <= '9') c = sig->char_at(_end++); 325 } 326 switch(sig->char_at(_end)) { 327 case 'B': 328 case 'C': 329 case 'D': 330 case 'F': 331 case 'I': 332 case 'J': 333 case 'S': 334 case 'Z':_end++; break; 335 default: { 336 while (sig->char_at(_end++) != ';'); 337 break; 338 } 339 } 340 break; 341 } 342 case ')': _end++; next(); _at_return_type = true; break; 343 default : ShouldNotReachHere(); 344 } 345 } 346 347 348 bool SignatureStream::is_object() const { 349 return _type == T_OBJECT 350 || _type == T_ARRAY 351 || _type == T_VALUETYPE; 352 } 353 354 bool SignatureStream::is_array() const { 355 return _type == T_ARRAY; 356 } 357 358 Symbol* SignatureStream::as_symbol() { 359 // Create a symbol from for string _begin _end 360 int begin = _begin; 361 int end = _end; 362 363 if ( (_signature->char_at(_begin) == 'L' || _signature->char_at(_begin) == 'Q') 364 && _signature->char_at(_end-1) == ';') { 365 begin++; 366 end--; 367 } 368 369 const char* symbol_chars = (const char*)_signature->base() + begin; 370 int len = end - begin; 371 372 // Quick check for common symbols in signatures 373 assert((vmSymbols::java_lang_String()->utf8_length() == 16 && vmSymbols::java_lang_Object()->utf8_length() == 16), "sanity"); 374 if (len == 16 && 375 strncmp(symbol_chars, "java/lang/", 10) == 0) { 376 if (strncmp("String", symbol_chars + 10, 6) == 0) { 377 return vmSymbols::java_lang_String(); 378 } else if (strncmp("Object", symbol_chars + 10, 6) == 0) { 379 return vmSymbols::java_lang_Object(); 380 } 381 } 382 383 Symbol* name = _previous_name; 384 if (name != NULL && name->equals(symbol_chars, len)) { 385 return name; 386 } 387 388 // Save names for cleaning up reference count at the end of 389 // SignatureStream scope. 390 name = SymbolTable::new_symbol(symbol_chars, len); 391 if (!name->is_permanent()) { 392 if (_names == NULL) { 393 _names = new GrowableArray<Symbol*>(10); 394 } 395 _names->push(name); // save new symbol for decrementing later 396 } 397 _previous_name = name; 398 return name; 399 } 400 401 ValueKlass* SignatureStream::as_value_klass(InstanceKlass* holder) { 402 Thread* THREAD = Thread::current(); 403 Handle class_loader(THREAD, holder->class_loader()); 404 Handle protection_domain(THREAD, holder->protection_domain()); 405 Klass* k = as_klass(class_loader, protection_domain, SignatureStream::ReturnNull, THREAD); 406 assert(k != NULL && !HAS_PENDING_EXCEPTION, "unresolved value klass"); 407 return ValueKlass::cast(k); 408 } 409 410 Klass* SignatureStream::as_klass(Handle class_loader, Handle protection_domain, 411 FailureMode failure_mode, TRAPS) { 412 if (!is_object()) return NULL; 413 Symbol* name = as_symbol(); 414 if (failure_mode == ReturnNull) { 415 return SystemDictionary::resolve_or_null(name, class_loader, protection_domain, THREAD); 416 } else { 417 bool throw_error = (failure_mode == NCDFError); 418 return SystemDictionary::resolve_or_fail(name, class_loader, protection_domain, throw_error, THREAD); 419 } 420 } 421 422 oop SignatureStream::as_java_mirror(Handle class_loader, Handle protection_domain, 423 FailureMode failure_mode, TRAPS) { 424 if (!is_object()) 425 return Universe::java_mirror(type()); 426 Klass* klass = as_klass(class_loader, protection_domain, failure_mode, THREAD); 427 if (klass == NULL) return NULL; 428 if (klass->is_value()) { 429 ValueKlass* vk = ValueKlass::cast(InstanceKlass::cast(klass)); 430 return _type == T_VALUETYPE ? vk->value_mirror() : vk->indirect_mirror(); 431 } else { 432 assert(_type != T_VALUETYPE, "must not be value type"); 433 return klass->java_mirror(); 434 } 435 } 436 437 Symbol* SignatureStream::as_symbol_or_null() { 438 // Create a symbol from for string _begin _end 439 ResourceMark rm; 440 441 int begin = _begin; 442 int end = _end; 443 444 if ( (_signature->char_at(_begin) == 'L' || _signature->char_at(_begin) == 'Q') 445 && _signature->char_at(_end-1) == ';') { 446 begin++; 447 end--; 448 } 449 450 char* buffer = NEW_RESOURCE_ARRAY(char, end - begin); 451 for (int index = begin; index < end; index++) { 452 buffer[index - begin] = _signature->char_at(index); 453 } 454 Symbol* result = SymbolTable::probe(buffer, end - begin); 455 return result; 456 } 457 458 int SignatureStream::reference_parameter_count() { 459 int args_count = 0; 460 for ( ; !at_return_type(); next()) { 461 if (is_object()) { 462 args_count++; 463 } 464 } 465 return args_count; 466 } 467 468 #ifdef ASSERT 469 bool SignatureVerifier::is_valid_method_signature(const Symbol* sig) { 470 const char* method_sig = (const char*)sig->bytes(); 471 ssize_t len = sig->utf8_length(); 472 ssize_t index = 0; 473 if (method_sig != NULL && len > 1 && method_sig[index] == '(') { 474 ++index; 475 while (index < len && method_sig[index] != ')') { 476 ssize_t res = is_valid_type(&method_sig[index], len - index); 477 if (res == -1) { 478 return false; 479 } else { 480 index += res; 481 } 482 } 483 if (index < len && method_sig[index] == ')') { 484 // check the return type 485 ++index; 486 return (is_valid_type(&method_sig[index], len - index) == (len - index)); 487 } 488 } 489 return false; 490 } 491 492 bool SignatureVerifier::is_valid_type_signature(const Symbol* sig) { 493 const char* type_sig = (const char*)sig->bytes(); 494 ssize_t len = sig->utf8_length(); 495 return (type_sig != NULL && len >= 1 && 496 (is_valid_type(type_sig, len) == len)); 497 } 498 499 // Checks to see if the type (not to go beyond 'limit') refers to a valid type. 500 // Returns -1 if it is not, or the index of the next character that is not part 501 // of the type. The type encoding may end before 'limit' and that's ok. 502 ssize_t SignatureVerifier::is_valid_type(const char* type, ssize_t limit) { 503 ssize_t index = 0; 504 505 // Iterate over any number of array dimensions 506 while (index < limit && type[index] == '[') ++index; 507 if (index >= limit) { 508 return -1; 509 } 510 switch (type[index]) { 511 case 'B': case 'C': case 'D': case 'F': case 'I': 512 case 'J': case 'S': case 'Z': case 'V': 513 return index + 1; 514 case 'Q': // fall through 515 case 'L': 516 for (index = index + 1; index < limit; ++index) { 517 char c = type[index]; 518 switch (c) { 519 case ';': 520 return index + 1; 521 case '\0': case '.': case '[': 522 return -1; 523 default: ; // fall through 524 } 525 } 526 // fall through 527 default: ; // fall through 528 } 529 return -1; 530 } 531 #endif // ASSERT 532 533 // Adds an argument to the signature 534 void SigEntry::add_entry(GrowableArray<SigEntry>* sig, BasicType bt, int offset) { 535 sig->append(SigEntry(bt, offset)); 536 if (bt == T_LONG || bt == T_DOUBLE) { 537 sig->append(SigEntry(T_VOID, offset)); // Longs and doubles take two stack slots 538 } 539 } 540 541 // Inserts a reserved argument at position 'i' 542 void SigEntry::insert_reserved_entry(GrowableArray<SigEntry>* sig, int i, BasicType bt) { 543 if (bt == T_OBJECT || bt == T_ARRAY || bt == T_VALUETYPE) { 544 // Treat this as INT to not confuse the GC 545 bt = T_INT; 546 } else if (bt == T_LONG || bt == T_DOUBLE) { 547 // Longs and doubles take two stack slots 548 sig->insert_before(i, SigEntry(T_VOID, SigEntry::ReservedOffset)); 549 } 550 sig->insert_before(i, SigEntry(bt, SigEntry::ReservedOffset)); 551 } 552 553 // Returns true if the argument at index 'i' is a reserved argument 554 bool SigEntry::is_reserved_entry(const GrowableArray<SigEntry>* sig, int i) { 555 return sig->at(i)._offset == SigEntry::ReservedOffset; 556 } 557 558 // Returns true if the argument at index 'i' is not a value type delimiter 559 bool SigEntry::skip_value_delimiters(const GrowableArray<SigEntry>* sig, int i) { 560 return (sig->at(i)._bt != T_VALUETYPE && 561 (sig->at(i)._bt != T_VOID || sig->at(i-1)._bt == T_LONG || sig->at(i-1)._bt == T_DOUBLE)); 562 } 563 564 // Fill basic type array from signature array 565 int SigEntry::fill_sig_bt(const GrowableArray<SigEntry>* sig, BasicType* sig_bt) { 566 int count = 0; 567 for (int i = 0; i < sig->length(); i++) { 568 if (skip_value_delimiters(sig, i)) { 569 sig_bt[count++] = sig->at(i)._bt; 570 } 571 } 572 return count; 573 } 574 575 // Create a temporary symbol from the signature array 576 TempNewSymbol SigEntry::create_symbol(const GrowableArray<SigEntry>* sig) { 577 ResourceMark rm; 578 int length = sig->length(); 579 char* sig_str = NEW_RESOURCE_ARRAY(char, 2*length + 3); 580 int idx = 0; 581 sig_str[idx++] = '('; 582 for (int i = 0; i < length; i++) { 583 BasicType bt = sig->at(i)._bt; 584 if (bt == T_VALUETYPE || bt == T_VOID) { 585 // Ignore 586 } else { 587 if (bt == T_ARRAY) { 588 bt = T_OBJECT; // We don't know the element type, treat as Object 589 } 590 sig_str[idx++] = type2char(bt); 591 if (bt == T_OBJECT) { 592 sig_str[idx++] = ';'; 593 } 594 } 595 } 596 sig_str[idx++] = ')'; 597 sig_str[idx++] = '\0'; 598 return SymbolTable::new_symbol(sig_str); 599 } 600 601 // Increment signature iterator (skips value type delimiters and T_VOID) and check if next entry is reserved 602 bool SigEntry::next_is_reserved(ExtendedSignature& sig, BasicType& bt, bool can_be_void) { 603 assert(can_be_void || bt != T_VOID, "should never see void"); 604 if (sig.at_end() || (can_be_void && type2size[bt] == 2 && (*sig)._offset != SigEntry::ReservedOffset)) { 605 // Don't increment at the end or at a T_LONG/T_DOUBLE which will be followed by a (skipped) T_VOID 606 return false; 607 } 608 assert(bt == T_VOID || type2wfield[bt] == type2wfield[(*sig)._bt], "inconsistent signature"); 609 ++sig; 610 if (!sig.at_end() && (*sig)._offset == SigEntry::ReservedOffset) { 611 bt = (*sig)._bt; 612 return true; 613 } 614 return false; 615 }