1 /*
   2  * Copyright (c) 1997, 2016, 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 "oops/instanceKlass.hpp"
  31 #include "oops/oop.inline.hpp"
  32 #include "oops/symbol.hpp"
  33 #include "oops/typeArrayKlass.hpp"
  34 #include "runtime/signature.hpp"
  35 
  36 // Implementation of SignatureIterator
  37 
  38 // Signature syntax:
  39 //
  40 // Signature  = "(" {Parameter} ")" ReturnType.
  41 // Parameter  = FieldType.
  42 // ReturnType = FieldType | "V".
  43 // FieldType  = "B" | "C" | "D" | "F" | "I" | "J" | "S" | "Z" | "L" ClassName ";" | "[" FieldType.
  44 // ClassName  = string.
  45 
  46 
  47 SignatureIterator::SignatureIterator(Symbol* signature) {
  48   _signature       = signature;
  49   _parameter_index = 0;
  50 }
  51 
  52 void SignatureIterator::expect(char c) {
  53   if (_signature->byte_at(_index) != c) fatal("expecting %c", c);
  54   _index++;
  55 }
  56 
  57 
  58 void SignatureIterator::skip_optional_size() {
  59   Symbol* sig = _signature;
  60   char c = sig->byte_at(_index);
  61   while ('0' <= c && c <= '9') c = sig->byte_at(++_index);
  62 }
  63 
  64 
  65 int SignatureIterator::parse_type() {
  66   // Note: This function could be simplified by using "return T_XXX_size;"
  67   //       instead of the assignment and the break statements. However, it
  68   //       seems that the product build for win32_i486 with MS VC++ 6.0 doesn't
  69   //       work (stack underflow for some tests) - this seems to be a VC++ 6.0
  70   //       compiler bug (was problem - gri 4/27/2000).
  71   int size = -1;
  72   switch(_signature->byte_at(_index)) {
  73     case 'B': do_byte  (); if (_parameter_index < 0 ) _return_type = T_BYTE;
  74               _index++; size = T_BYTE_size   ; break;
  75     case 'C': do_char  (); if (_parameter_index < 0 ) _return_type = T_CHAR;
  76               _index++; size = T_CHAR_size   ; break;
  77     case 'D': do_double(); if (_parameter_index < 0 ) _return_type = T_DOUBLE;
  78               _index++; size = T_DOUBLE_size ; break;
  79     case 'F': do_float (); if (_parameter_index < 0 ) _return_type = T_FLOAT;
  80               _index++; size = T_FLOAT_size  ; break;
  81     case 'I': do_int   (); if (_parameter_index < 0 ) _return_type = T_INT;
  82               _index++; size = T_INT_size    ; break;
  83     case 'J': do_long  (); if (_parameter_index < 0 ) _return_type = T_LONG;
  84               _index++; size = T_LONG_size   ; break;
  85     case 'S': do_short (); if (_parameter_index < 0 ) _return_type = T_SHORT;
  86               _index++; size = T_SHORT_size  ; break;
  87     case 'Z': do_bool  (); if (_parameter_index < 0 ) _return_type = T_BOOLEAN;
  88               _index++; size = T_BOOLEAN_size; break;
  89     case 'V': do_void  (); if (_parameter_index < 0 ) _return_type = T_VOID;
  90               _index++; size = T_VOID_size;  ; break;
  91     case 'L':
  92       { int begin = ++_index;
  93         Symbol* sig = _signature;
  94         while (sig->byte_at(_index++) != ';') ;
  95         do_object(begin, _index);
  96       }
  97       if (_parameter_index < 0 ) _return_type = T_OBJECT;
  98       size = T_OBJECT_size;
  99       break;
 100     case '[':
 101       { int begin = ++_index;
 102         skip_optional_size();
 103         Symbol* sig = _signature;
 104         while (sig->byte_at(_index) == '[') {
 105           _index++;
 106           skip_optional_size();
 107         }
 108         if (sig->byte_at(_index) == 'L') {
 109           while (sig->byte_at(_index++) != ';') ;
 110         } else {
 111           _index++;
 112         }
 113         do_array(begin, _index);
 114        if (_parameter_index < 0 ) _return_type = T_ARRAY;
 115       }
 116       size = T_ARRAY_size;
 117       break;
 118     default:
 119       ShouldNotReachHere();
 120       break;
 121   }
 122   assert(size >= 0, "size must be set");
 123   return size;
 124 }
 125 
 126 
 127 void SignatureIterator::check_signature_end() {
 128   if (_index < _signature->utf8_length()) {
 129     tty->print_cr("too many chars in signature");
 130     _signature->print_value_on(tty);
 131     tty->print_cr(" @ %d", _index);
 132   }
 133 }
 134 
 135 
 136 void SignatureIterator::dispatch_field() {
 137   // no '(', just one (field) type
 138   _index = 0;
 139   _parameter_index = 0;
 140   parse_type();
 141   check_signature_end();
 142 }
 143 
 144 
 145 void SignatureIterator::iterate_parameters() {
 146   // Parse parameters
 147   _index = 0;
 148   _parameter_index = 0;
 149   expect('(');
 150   while (_signature->byte_at(_index) != ')') _parameter_index += parse_type();
 151   expect(')');
 152   _parameter_index = 0;
 153 }
 154 
 155 // Optimized version of iterate_parameters when fingerprint is known
 156 void SignatureIterator::iterate_parameters( uint64_t fingerprint ) {
 157   uint64_t saved_fingerprint = fingerprint;
 158 
 159   // Check for too many arguments
 160   if (fingerprint == (uint64_t)CONST64(-1)) {
 161     SignatureIterator::iterate_parameters();
 162     return;
 163   }
 164 
 165   assert(fingerprint, "Fingerprint should not be 0");
 166 
 167   _parameter_index = 0;
 168   fingerprint = fingerprint >> (static_feature_size + result_feature_size);
 169   while ( 1 ) {
 170     switch ( fingerprint & parameter_feature_mask ) {
 171       case bool_parm:
 172         do_bool();
 173         _parameter_index += T_BOOLEAN_size;
 174         break;
 175       case byte_parm:
 176         do_byte();
 177         _parameter_index += T_BYTE_size;
 178         break;
 179       case char_parm:
 180         do_char();
 181         _parameter_index += T_CHAR_size;
 182         break;
 183       case short_parm:
 184         do_short();
 185         _parameter_index += T_SHORT_size;
 186         break;
 187       case int_parm:
 188         do_int();
 189         _parameter_index += T_INT_size;
 190         break;
 191       case obj_parm:
 192         do_object(0, 0);
 193         _parameter_index += T_OBJECT_size;
 194         break;
 195       case long_parm:
 196         do_long();
 197         _parameter_index += T_LONG_size;
 198         break;
 199       case float_parm:
 200         do_float();
 201         _parameter_index += T_FLOAT_size;
 202         break;
 203       case double_parm:
 204         do_double();
 205         _parameter_index += T_DOUBLE_size;
 206         break;
 207       case done_parm:
 208         return;
 209         break;
 210       default:
 211         tty->print_cr("*** parameter is " UINT64_FORMAT, fingerprint & parameter_feature_mask);
 212         tty->print_cr("*** fingerprint is " PTR64_FORMAT, saved_fingerprint);
 213         ShouldNotReachHere();
 214         break;
 215     }
 216     fingerprint >>= parameter_feature_size;
 217   }
 218   _parameter_index = 0;
 219 }
 220 
 221 
 222 void SignatureIterator::iterate_returntype() {
 223   // Ignore parameters
 224   _index = 0;
 225   expect('(');
 226   Symbol* sig = _signature;
 227   while (sig->byte_at(_index) != ')') _index++;
 228   expect(')');
 229   // Parse return type
 230   _parameter_index = -1;
 231   parse_type();
 232   check_signature_end();
 233   _parameter_index = 0;
 234 }
 235 
 236 
 237 void SignatureIterator::iterate() {
 238   // Parse parameters
 239   _parameter_index = 0;
 240   _index = 0;
 241   expect('(');
 242   while (_signature->byte_at(_index) != ')') _parameter_index += parse_type();
 243   expect(')');
 244   // Parse return type
 245   _parameter_index = -1;
 246   parse_type();
 247   check_signature_end();
 248   _parameter_index = 0;
 249 }
 250 
 251 
 252 // Implementation of SignatureStream
 253 SignatureStream::SignatureStream(Symbol* signature, bool is_method) :
 254                    _signature(signature), _at_return_type(false) {
 255   _begin = _end = (is_method ? 1 : 0);  // skip first '(' in method signatures
 256   _names = new GrowableArray<Symbol*>(10);
 257   next();
 258 }
 259 
 260 SignatureStream::~SignatureStream() {
 261   // decrement refcount for names created during signature parsing
 262   for (int i = 0; i < _names->length(); i++) {
 263     _names->at(i)->decrement_refcount();
 264   }
 265 }
 266 
 267 bool SignatureStream::is_done() const {
 268   return _end > _signature->utf8_length();
 269 }
 270 
 271 
 272 void SignatureStream::next_non_primitive(int t) {
 273   switch (t) {
 274     case 'L': {
 275       _type = T_OBJECT;
 276       Symbol* sig = _signature;
 277       while (sig->byte_at(_end++) != ';');
 278       break;
 279     }
 280     case '[': {
 281       _type = T_ARRAY;
 282       Symbol* sig = _signature;
 283       char c = sig->byte_at(_end);
 284       while ('0' <= c && c <= '9') c = sig->byte_at(_end++);
 285       while (sig->byte_at(_end) == '[') {
 286         _end++;
 287         c = sig->byte_at(_end);
 288         while ('0' <= c && c <= '9') c = sig->byte_at(_end++);
 289       }
 290       switch(sig->byte_at(_end)) {
 291         case 'B':
 292         case 'C':
 293         case 'D':
 294         case 'F':
 295         case 'I':
 296         case 'J':
 297         case 'S':
 298         case 'Z':_end++; break;
 299         default: {
 300           while (sig->byte_at(_end++) != ';');
 301           break;
 302         }
 303       }
 304       break;
 305     }
 306     case ')': _end++; next(); _at_return_type = true; break;
 307     default : ShouldNotReachHere();
 308   }
 309 }
 310 
 311 
 312 bool SignatureStream::is_object() const {
 313   return _type == T_OBJECT
 314       || _type == T_ARRAY;
 315 }
 316 
 317 bool SignatureStream::is_array() const {
 318   return _type == T_ARRAY;
 319 }
 320 
 321 Symbol* SignatureStream::as_symbol(TRAPS) {
 322   // Create a symbol from for string _begin _end
 323   int begin = _begin;
 324   int end   = _end;
 325 
 326   if (   _signature->byte_at(_begin) == 'L'
 327       && _signature->byte_at(_end-1) == ';') {
 328     begin++;
 329     end--;
 330   }
 331 
 332   // Save names for cleaning up reference count at the end of
 333   // SignatureStream scope.
 334   Symbol* name = SymbolTable::new_symbol(_signature, begin, end, CHECK_NULL);
 335   _names->push(name);  // save new symbol for decrementing later
 336   return name;
 337 }
 338 
 339 Klass* SignatureStream::as_klass(Handle class_loader, Handle protection_domain,
 340                                    FailureMode failure_mode, TRAPS) {
 341   if (!is_object())  return NULL;
 342   Symbol* name = as_symbol(CHECK_NULL);
 343   if (failure_mode == ReturnNull) {
 344     return SystemDictionary::resolve_or_null(name, class_loader, protection_domain, THREAD);
 345   } else {
 346     bool throw_error = (failure_mode == NCDFError);
 347     return SystemDictionary::resolve_or_fail(name, class_loader, protection_domain, throw_error, THREAD);
 348   }
 349 }
 350 
 351 oop SignatureStream::as_java_mirror(Handle class_loader, Handle protection_domain,
 352                                     FailureMode failure_mode, TRAPS) {
 353   if (!is_object())
 354     return Universe::java_mirror(type());
 355   Klass* klass = as_klass(class_loader, protection_domain, failure_mode, CHECK_NULL);
 356   if (klass == NULL)  return NULL;
 357   return klass->java_mirror();
 358 }
 359 
 360 Symbol* SignatureStream::as_symbol_or_null() {
 361   // Create a symbol from for string _begin _end
 362   ResourceMark rm;
 363 
 364   int begin = _begin;
 365   int end   = _end;
 366 
 367   if (   _signature->byte_at(_begin) == 'L'
 368       && _signature->byte_at(_end-1) == ';') {
 369     begin++;
 370     end--;
 371   }
 372 
 373   char* buffer = NEW_RESOURCE_ARRAY(char, end - begin);
 374   for (int index = begin; index < end; index++) {
 375     buffer[index - begin] = _signature->byte_at(index);
 376   }
 377   Symbol* result = SymbolTable::probe(buffer, end - begin);
 378   return result;
 379 }
 380 
 381 int SignatureStream::reference_parameter_count() {
 382   int args_count = 0;
 383   for ( ; !at_return_type(); next()) {
 384     if (is_object()) {
 385       args_count++;
 386     }
 387   }
 388   return args_count;
 389 }
 390 
 391 bool SignatureVerifier::is_valid_signature(Symbol* sig) {
 392   const char* signature = (const char*)sig->bytes();
 393   ssize_t len = sig->utf8_length();
 394   if (signature == NULL || signature[0] == '\0' || len < 1) {
 395     return false;
 396   } else if (signature[0] == '(') {
 397     return is_valid_method_signature(sig);
 398   } else {
 399     return is_valid_type_signature(sig);
 400   }
 401 }
 402 
 403 bool SignatureVerifier::is_valid_method_signature(Symbol* sig) {
 404   const char* method_sig = (const char*)sig->bytes();
 405   ssize_t len = sig->utf8_length();
 406   ssize_t index = 0;
 407   if (method_sig != NULL && len > 1 && method_sig[index] == '(') {
 408     ++index;
 409     while (index < len && method_sig[index] != ')') {
 410       ssize_t res = is_valid_type(&method_sig[index], len - index);
 411       if (res == -1) {
 412         return false;
 413       } else {
 414         index += res;
 415       }
 416     }
 417     if (index < len && method_sig[index] == ')') {
 418       // check the return type
 419       ++index;
 420       return (is_valid_type(&method_sig[index], len - index) == (len - index));
 421     }
 422   }
 423   return false;
 424 }
 425 
 426 bool SignatureVerifier::is_valid_type_signature(Symbol* sig) {
 427   const char* type_sig = (const char*)sig->bytes();
 428   ssize_t len = sig->utf8_length();
 429   return (type_sig != NULL && len >= 1 &&
 430           (is_valid_type(type_sig, len) == len));
 431 }
 432 
 433 // Checks to see if the type (not to go beyond 'limit') refers to a valid type.
 434 // Returns -1 if it is not, or the index of the next character that is not part
 435 // of the type.  The type encoding may end before 'limit' and that's ok.
 436 ssize_t SignatureVerifier::is_valid_type(const char* type, ssize_t limit) {
 437   ssize_t index = 0;
 438 
 439   // Iterate over any number of array dimensions
 440   while (index < limit && type[index] == '[') ++index;
 441   if (index >= limit) {
 442     return -1;
 443   }
 444   switch (type[index]) {
 445     case 'B': case 'C': case 'D': case 'F': case 'I':
 446     case 'J': case 'S': case 'Z': case 'V':
 447       return index + 1;
 448     case 'L':
 449       for (index = index + 1; index < limit; ++index) {
 450         char c = type[index];
 451         if (c == ';') {
 452           return index + 1;
 453         }
 454         if (invalid_name_char(c)) {
 455           return -1;
 456         }
 457       }
 458       // fall through
 459     default: ; // fall through
 460   }
 461   return -1;
 462 }
 463 
 464 bool SignatureVerifier::invalid_name_char(char c) {
 465   switch (c) {
 466     case '\0': case '.': case ';': case '[':
 467       return true;
 468     default:
 469       return false;
 470   }
 471 }