1 /*
  2  * Copyright (c) 1997, 2023, Oracle and/or its affiliates. All rights reserved.
  3  * Copyright (c) 2021, Azul Systems, Inc. All rights reserved.
  4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  5  *
  6  * This code is free software; you can redistribute it and/or modify it
  7  * under the terms of the GNU General Public License version 2 only, as
  8  * published by the Free Software Foundation.
  9  *
 10  * This code is distributed in the hope that it will be useful, but WITHOUT
 11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 13  * version 2 for more details (a copy is included in the LICENSE file that
 14  * accompanied this code).
 15  *
 16  * You should have received a copy of the GNU General Public License version
 17  * 2 along with this work; if not, write to the Free Software Foundation,
 18  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 19  *
 20  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 21  * or visit www.oracle.com if you need additional information or have any
 22  * questions.
 23  *
 24  */
 25 
 26 #ifndef SHARE_RUNTIME_SIGNATURE_HPP
 27 #define SHARE_RUNTIME_SIGNATURE_HPP
 28 
 29 #include "classfile/symbolTable.hpp"
 30 #include "memory/allocation.hpp"
 31 #include "oops/method.hpp"
 32 
 33 
 34 // Static routines and parsing loops for processing field and method
 35 // descriptors.  In the HotSpot sources we call them "signatures".
 36 //
 37 // A SignatureStream iterates over a Java descriptor (or parts of it).
 38 // The syntax is documented in the Java Virtual Machine Specification,
 39 // section 4.3.
 40 //
 41 // The syntax may be summarized as follows:
 42 //
 43 //     MethodType: '(' {FieldType}* ')' (FieldType | 'V')
 44 //     FieldType: PrimitiveType | ObjectType | ArrayType
 45 //     PrimitiveType: 'B' | 'C' | 'D' | 'F' | 'I' | 'J' | 'S' | 'Z'
 46 //     ObjectType: 'L' ClassName ';' | ArrayType
 47 //     ArrayType: '[' FieldType
 48 //     ClassName: {UnqualifiedName '/'}* UnqualifiedName
 49 //     UnqualifiedName: NameChar {NameChar}*
 50 //     NameChar: ANY_CHAR_EXCEPT('/' | '.' | ';' | '[')
 51 //
 52 // All of the concrete characters in the above grammar are given
 53 // standard manifest constant names of the form JVM_SIGNATURE_x.
 54 // Executable code uses these constant names in preference to raw
 55 // character constants.  Comments and assertion code sometimes use
 56 // the raw character constants for brevity.
 57 //
 58 // The primitive field types (like 'I') correspond 1-1 with type codes
 59 // (like T_INT) which form part of the specification of the 'newarray'
 60 // instruction (JVMS 6.5, section on newarray).  These type codes are
 61 // widely used in the HotSpot code.  They are joined by ad hoc codes
 62 // like T_OBJECT and T_ARRAY (defined in HotSpot but not in the JVMS)
 63 // so that each "basic type" of field descriptor (or void return type)
 64 // has a corresponding T_x code.  Thus, while T_x codes play a very
 65 // minor role in the JVMS, they play a major role in the HotSpot
 66 // sources.  There are fewer than 16 such "basic types", so they fit
 67 // nicely into bitfields.
 68 //
 69 // The syntax of ClassName overlaps slightly with the descriptor
 70 // syntaxes.  The strings "I" and "(I)V" are both class names
 71 // *and* descriptors.  If a class name contains any character other
 72 // than "BCDFIJSZ()V" it cannot be confused with a descriptor.
 73 // Class names inside of descriptors are always contained in an
 74 // "envelope" syntax which starts with 'L' and ends with ';'.
 75 //
 76 // As a confounding factor, array types report their type name strings
 77 // in descriptor format.  These name strings are easy to recognize,
 78 // since they begin with '['.  For this reason some API points on
 79 // HotSpot look for array descriptors as well as proper class names.
 80 //
 81 // For historical reasons some API points that accept class names and
 82 // array names also look for class names wrapped inside an envelope
 83 // (like "LFoo;") and unwrap them on the fly (to a name like "Foo").
 84 
 85 class Signature : AllStatic {
 86  private:
 87   static bool is_valid_array_signature(const Symbol* sig);
 88 
 89  public:
 90 
 91   // Returns the basic type of a field signature (or T_VOID for "V").
 92   // Assumes the signature is a valid field descriptor.
 93   // Do not apply this function to class names or method signatures.
 94   static BasicType basic_type(const Symbol* signature) {
 95     return basic_type(signature->char_at(0));
 96   }
 97 
 98   // Returns T_ILLEGAL for an illegal signature char.
 99   static BasicType basic_type(int ch);
100 
101   // Assuming it is either a class name or signature,
102   // determine if it in fact is an array descriptor.
103   static bool is_array(const Symbol* signature) {
104     return (signature->utf8_length() > 1 &&
105             signature->char_at(0) == JVM_SIGNATURE_ARRAY &&
106             is_valid_array_signature(signature));
107   }
108 
109   // Assuming it is either a class name or signature,
110   // determine if it contains a class name plus ';'.
111   static bool has_envelope(const Symbol* signature) {
112     return ((signature->utf8_length() > 0) &&
113             signature->ends_with(JVM_SIGNATURE_ENDCLASS) &&
114             has_envelope(signature->char_at(0)));
115   }
116 
117   // Determine if this signature char introduces an
118   // envelope, which is a class name plus ';'.
119   static bool has_envelope(char signature_char) {
120     return (signature_char == JVM_SIGNATURE_CLASS) || (signature_char == JVM_SIGNATURE_PRIMITIVE_OBJECT);
121   }
122 
123   // Assuming has_envelope is true, return the symbol
124   // inside the envelope, by stripping 'L' and ';'.
125   // Caller is responsible for decrementing the newly created
126   // Symbol's refcount, use TempNewSymbol.
127   static Symbol* strip_envelope(const Symbol* signature);
128 
129   // Assuming it's either a field or method descriptor, determine
130   // whether it is in fact a method descriptor:
131   static bool is_method(const Symbol* signature) {
132     return signature->starts_with(JVM_SIGNATURE_FUNC);
133   }
134 
135   // Assuming it's a method signature, determine if it must
136   // return void.
137   static bool is_void_method(const Symbol* signature) {
138     assert(is_method(signature), "signature is not for a method");
139     return signature->ends_with(JVM_SIGNATURE_VOID);
140   }
141 };
142 
143 // A SignatureIterator uses a SignatureStream to produce BasicType
144 // results, discarding class names.  This means it can be accelerated
145 // using a fingerprint mechanism, in many cases, without loss of type
146 // information.  The FingerPrinter class computes and caches this
147 // reduced information for faster iteration.
148 
149 class SignatureIterator: public ResourceObj {
150  public:
151   typedef uint64_t fingerprint_t;
152 
153  protected:
154   Symbol*      _signature;             // the signature to iterate over
155   BasicType    _return_type;
156   fingerprint_t _fingerprint;
157 
158  public:
159   // Definitions used in generating and iterating the
160   // bit field form of the signature generated by the
161   // Fingerprinter.
162   enum {
163     fp_static_feature_size    = 1,
164     fp_is_static_bit          = 1,
165 
166     fp_result_feature_size    = 4,
167     fp_result_feature_mask    = right_n_bits(fp_result_feature_size),
168     fp_parameter_feature_size = 4,
169     fp_parameter_feature_mask = right_n_bits(fp_parameter_feature_size),
170 
171     fp_parameters_done        = 0,  // marker for end of parameters (must be zero)
172 
173     // Parameters take up full wordsize, minus the result and static bit fields.
174     // Since fp_parameters_done is zero, termination field arises from shifting
175     // in zero bits, and therefore occupies no extra space.
176     // The sentinel value is all-zero-bits, which is impossible for a true
177     // fingerprint, since at least the result field will be non-zero.
178     fp_max_size_of_parameters = ((BitsPerLong
179                                   - (fp_result_feature_size + fp_static_feature_size))
180                                  / fp_parameter_feature_size)
181   };
182 
183   static bool fp_is_valid_type(BasicType type, bool for_return_type = false);
184 
185   // Sentinel values are zero and not-zero (-1).
186   // No need to protect the sign bit, since every valid return type is non-zero
187   // (even T_VOID), and there are no valid parameter fields which are 0xF (T_VOID).
188   static fingerprint_t zero_fingerprint() { return (fingerprint_t)0; }
189   static fingerprint_t overflow_fingerprint() { return ~(fingerprint_t)0; }
190   static bool fp_is_valid(fingerprint_t fingerprint) {
191     return (fingerprint != zero_fingerprint()) && (fingerprint != overflow_fingerprint());
192   }
193 
194   // Constructors
195   SignatureIterator(Symbol* signature, fingerprint_t fingerprint = zero_fingerprint()) {
196     _signature   = signature;
197     _return_type = T_ILLEGAL;  // sentinel value for uninitialized
198     _fingerprint = zero_fingerprint();
199     if (fingerprint != _fingerprint) {
200       set_fingerprint(fingerprint);
201     }
202   }
203 
204   // If the fingerprint is present, we can use an accelerated loop.
205   void set_fingerprint(fingerprint_t fingerprint);
206 
207   // Returns the set fingerprint, or zero_fingerprint()
208   // if none has been set already.
209   fingerprint_t fingerprint() const { return _fingerprint; }
210 
211   // Iteration
212   // Hey look:  There are no virtual methods in this class.
213   // So how is it customized?  By calling do_parameters_on
214   // an object which answers to "do_type(BasicType)".
215   // By convention, this object is in the subclass
216   // itself, so the call is "do_parameters_on(this)".
217   // The effect of this is to inline the parsing loop
218   // everywhere "do_parameters_on" is called.
219   // If there is a valid fingerprint in the object,
220   // an improved loop is called which just unpacks the
221   // bitfields from the fingerprint.  Otherwise, the
222   // symbol is parsed.
223   template<typename T> inline void do_parameters_on(T* callback); // iterates over parameters only
224   BasicType return_type();  // computes the value on the fly if necessary
225 
226   static BasicType fp_return_type(fingerprint_t fingerprint) {
227     assert(fp_is_valid(fingerprint), "invalid fingerprint");
228     return (BasicType) ((fingerprint >> fp_static_feature_size) & fp_result_feature_mask);
229   }
230   static fingerprint_t fp_start_parameters(fingerprint_t fingerprint) {
231     assert(fp_is_valid(fingerprint), "invalid fingerprint");
232     return fingerprint >> (fp_static_feature_size + fp_result_feature_size);
233   }
234   static BasicType fp_next_parameter(fingerprint_t& mask) {
235     int result = (mask & fp_parameter_feature_mask);
236     mask >>= fp_parameter_feature_size;
237     return (BasicType) result;
238   }
239 };
240 
241 
242 // Specialized SignatureIterators: Used to compute signature specific values.
243 
244 class SignatureTypeNames : public SignatureIterator {
245  protected:
246   virtual void type_name(const char* name)   = 0;
247 
248   friend class SignatureIterator;  // so do_parameters_on can call do_type
249   void do_type(BasicType type) {
250     switch (type) {
251     case T_BOOLEAN: type_name("jboolean"); break;
252     case T_CHAR:    type_name("jchar"   ); break;
253     case T_FLOAT:   type_name("jfloat"  ); break;
254     case T_DOUBLE:  type_name("jdouble" ); break;
255     case T_BYTE:    type_name("jbyte"   ); break;
256     case T_SHORT:   type_name("jshort"  ); break;
257     case T_INT:     type_name("jint"    ); break;
258     case T_LONG:    type_name("jlong"   ); break;
259     case T_VOID:    type_name("void"    ); break;
260     case T_ARRAY:
261     case T_OBJECT:
262     case T_PRIMITIVE_OBJECT:  type_name("jobject" ); break;
263     default: ShouldNotReachHere();
264     }
265   }
266 
267  public:
268   SignatureTypeNames(Symbol* signature) : SignatureIterator(signature) {}
269 };
270 
271 
272 // Specialized SignatureIterator: Used to compute the argument size.
273 
274 class ArgumentSizeComputer: public SignatureIterator {
275  private:
276   int _size;
277   friend class SignatureIterator;  // so do_parameters_on can call do_type
278   void do_type(BasicType type) { _size += parameter_type_word_count(type); }
279  public:
280   ArgumentSizeComputer(Symbol* signature);
281   int size() { return _size; }
282 };
283 
284 
285 class ArgumentCount: public SignatureIterator {
286  private:
287   int _size;
288   friend class SignatureIterator;  // so do_parameters_on can call do_type
289   void do_type(BasicType type) { _size++; }
290  public:
291   ArgumentCount(Symbol* signature);
292   int size() { return _size; }
293 };
294 
295 
296 class ReferenceArgumentCount: public SignatureIterator {
297  private:
298   int _refs;
299   friend class SignatureIterator;  // so do_parameters_on can call do_type
300   void do_type(BasicType type) { if (is_reference_type(type)) _refs++; }
301  public:
302   ReferenceArgumentCount(Symbol* signature);
303   int count() { return _refs; }
304 };
305 
306 
307 // Specialized SignatureIterator: Used to compute the result type.
308 
309 class ResultTypeFinder: public SignatureIterator {
310  public:
311   BasicType type() { return return_type(); }
312   ResultTypeFinder(Symbol* signature) : SignatureIterator(signature) { }
313 };
314 
315 
316 // Fingerprinter computes a unique ID for a given method. The ID
317 // is a bitvector characterizing the methods signature (incl. the receiver).
318 class Fingerprinter: public SignatureIterator {
319  private:
320   fingerprint_t _accumulator;
321   int _param_size;
322   int _stack_arg_slots;
323   int _shift_count;
324   const Method* _method;
325 
326   uint _int_args;
327   uint _fp_args;
328 
329   void initialize_accumulator() {
330     _accumulator = 0;
331     _shift_count = fp_result_feature_size + fp_static_feature_size;
332     _param_size = 0;
333     _stack_arg_slots = 0;
334   }
335 
336   // Out-of-line method does it all in constructor:
337   void compute_fingerprint_and_return_type(bool static_flag = false);
338 
339   void initialize_calling_convention(bool static_flag);
340   void do_type_calling_convention(BasicType type);
341 
342   friend class SignatureIterator;  // so do_parameters_on can call do_type
343   void do_type(BasicType type) {
344     assert(fp_is_valid_type(type), "bad parameter type");
345     _accumulator |= ((fingerprint_t)type << _shift_count);
346     _shift_count += fp_parameter_feature_size;
347     _param_size += (is_double_word_type(type) ? 2 : 1);
348     do_type_calling_convention(type);
349   }
350 
351  public:
352   int size_of_parameters() const { return _param_size; }
353   int num_stack_arg_slots() const { return _stack_arg_slots; }
354 
355   // fingerprint() and return_type() are in super class
356 
357   Fingerprinter(const methodHandle& method)
358     : SignatureIterator(method->signature()),
359       _method(method()) {
360     compute_fingerprint_and_return_type();
361   }
362   Fingerprinter(Symbol* signature, bool is_static)
363     : SignatureIterator(signature),
364       _method(nullptr) {
365     compute_fingerprint_and_return_type(is_static);
366   }
367 };
368 
369 
370 // Specialized SignatureIterator: Used for native call purposes
371 
372 class NativeSignatureIterator: public SignatureIterator {
373  private:
374   methodHandle _method;
375 // We need separate JNI and Java offset values because in 64 bit mode,
376 // the argument offsets are not in sync with the Java stack.
377 // For example a long takes up 1 "C" stack entry but 2 Java stack entries.
378   int          _offset;                // The java stack offset
379   int          _prepended;             // number of prepended JNI parameters (1 JNIEnv, plus 1 mirror if static)
380   int          _jni_offset;            // the current parameter offset, starting with 0
381 
382   friend class SignatureIterator;  // so do_parameters_on can call do_type
383   void do_type(BasicType type) {
384     switch (type) {
385     case T_BYTE:
386     case T_BOOLEAN:
387       pass_byte();  _jni_offset++; _offset++;
388       break;
389     case T_CHAR:
390     case T_SHORT:
391       pass_short();  _jni_offset++; _offset++;
392       break;
393     case T_INT:
394       pass_int();    _jni_offset++; _offset++;
395       break;
396     case T_FLOAT:
397       pass_float();  _jni_offset++; _offset++;
398       break;
399     case T_DOUBLE: {
400       int jni_offset = LP64_ONLY(1) NOT_LP64(2);
401       pass_double(); _jni_offset += jni_offset; _offset += 2;
402       break;
403     }
404     case T_LONG: {
405       int jni_offset = LP64_ONLY(1) NOT_LP64(2);
406       pass_long();   _jni_offset += jni_offset; _offset += 2;
407       break;
408     }
409     case T_ARRAY:
410     case T_OBJECT:
411     case T_PRIMITIVE_OBJECT:
412       pass_object(); _jni_offset++; _offset++;
413       break;
414     default:
415       ShouldNotReachHere();
416     }
417   }
418 
419  public:
420   methodHandle method() const          { return _method; }
421   int          offset() const          { return _offset; }
422   int      jni_offset() const          { return _jni_offset + _prepended; }
423   bool      is_static() const          { return method()->is_static(); }
424   virtual void pass_int()              = 0;
425   virtual void pass_long()             = 0;
426   virtual void pass_object()           = 0;  // objects, arrays, inlines
427   virtual void pass_float()            = 0;
428   virtual void pass_byte()             { pass_int(); };
429   virtual void pass_short()            { pass_int(); };
430 #ifdef _LP64
431   virtual void pass_double()           = 0;
432 #else
433   virtual void pass_double()           { pass_long(); }  // may be same as long
434 #endif
435 
436   NativeSignatureIterator(const methodHandle& method) : SignatureIterator(method->signature()) {
437     _method = method;
438     _offset = 0;
439     _jni_offset = 0;
440 
441     const int JNIEnv_words = 1;
442     const int mirror_words = 1;
443     _prepended = !is_static() ? JNIEnv_words : JNIEnv_words + mirror_words;
444   }
445 
446   void iterate() { iterate(Fingerprinter(method()).fingerprint()); }
447 
448   // iterate() calls the 3 virtual methods according to the following invocation syntax:
449   //
450   // {pass_int | pass_long | pass_object}
451   //
452   // Arguments are handled from left to right (receiver first, if any).
453   // The offset() values refer to the Java stack offsets but are 0 based and increasing.
454   // The java_offset() values count down to 0, and refer to the Java TOS.
455   // The jni_offset() values increase from 1 or 2, and refer to C arguments.
456   // The method's return type is ignored.
457 
458   void iterate(fingerprint_t fingerprint) {
459     set_fingerprint(fingerprint);
460     if (!is_static()) {
461       // handle receiver (not handled by iterate because not in signature)
462       pass_object(); _jni_offset++; _offset++;
463     }
464     do_parameters_on(this);
465   }
466 };
467 
468 
469 // This is the core parsing logic for iterating over signatures.
470 // All of the previous classes use this for doing their work.
471 
472 class SignatureStream : public StackObj {
473  private:
474   const Symbol* _signature;
475   int          _begin;
476   int          _end;
477   int          _limit;
478   int          _array_prefix;  // count of '[' before the array element descr
479   BasicType    _type;
480   int          _state;
481   Symbol*      _previous_name;    // cache the previously looked up symbol to avoid lookups
482   GrowableArray<Symbol*>* _names; // symbols created while parsing that need to be dereferenced
483 
484   Symbol* find_symbol();
485 
486   enum { _s_field = 0, _s_method = 1, _s_method_return = 3 };
487   void set_done() {
488     _state |= -2;   // preserve s_method bit
489     assert(is_done(), "Unable to set state to done");
490   }
491   int scan_type(BasicType bt);
492 
493  public:
494   bool at_return_type() const                    { return _state == (int)_s_method_return; }
495   bool is_done() const                           { return _state < 0; }
496   void next();
497 
498   SignatureStream(const Symbol* signature, bool is_method = true);
499   ~SignatureStream();
500 
501   bool is_reference() const { return is_reference_type(_type); }
502   bool is_array() const     { return _type == T_ARRAY; }
503   BasicType type() const    { return _type; }
504 
505   const u1* raw_bytes() const  { return _signature->bytes() + _begin; }
506   int       raw_length() const { return _end - _begin; }
507   int raw_symbol_begin() const { return _begin + (has_envelope() ? 1 : 0); }
508   int raw_symbol_end() const   { return _end  -  (has_envelope() ? 1 : 0); }
509   char raw_char_at(int i) const {
510     assert(i < _limit, "index for raw_char_at is over the limit");
511     return _signature->char_at(i);
512   }
513 
514   // True if there is an embedded class name in this type,
515   // followed by ';'.
516   bool has_envelope() const {
517     if (!Signature::has_envelope(_signature->char_at(_begin)))
518       return false;
519     // this should always be true, but let's test it:
520     assert(_signature->char_at(_end-1) == JVM_SIGNATURE_ENDCLASS, "signature envelope has no semi-colon at end");
521     return true;
522   }
523 
524   bool has_Q_descriptor() const {
525     return has_envelope() && (_signature->char_at(_begin) == JVM_SIGNATURE_PRIMITIVE_OBJECT);
526   }
527 
528   // return the symbol for chars in symbol_begin()..symbol_end()
529   Symbol* as_symbol() {
530     return find_symbol();
531   }
532 
533   // in case you want only the return type:
534   void skip_to_return_type();
535 
536   // number of '[' in array prefix
537   int array_prefix_length() {
538     return _type == T_ARRAY ? _array_prefix : 0;
539   }
540 
541   // In case you want only the array base type,
542   // reset the stream after skipping some brackets '['.
543   // (The argument is clipped to array_prefix_length(),
544   // and if it ends up as zero this call is a nop.
545   // The default is value skips all brackets '['.)
546  private:
547   int skip_whole_array_prefix();
548  public:
549   int skip_array_prefix(int max_skip_length) {
550     if (_type != T_ARRAY) {
551       return 0;
552     }
553      if (_array_prefix > max_skip_length) {
554       // strip some but not all levels of T_ARRAY
555       _array_prefix -= max_skip_length;
556       _begin += max_skip_length;
557       return max_skip_length;
558     }
559     return skip_whole_array_prefix();
560   }
561   int skip_array_prefix() {
562     if (_type != T_ARRAY) {
563       return 0;
564     }
565     return skip_whole_array_prefix();
566   }
567 
568   // free-standing lookups (bring your own CL/PD pair)
569   enum FailureMode { ReturnNull, NCDFError, CachedOrNull };
570 
571   Klass* as_klass(Handle class_loader, Handle protection_domain, FailureMode failure_mode, TRAPS);
572   InlineKlass* as_inline_klass(InstanceKlass* holder);
573   oop as_java_mirror(Handle class_loader, Handle protection_domain, FailureMode failure_mode, TRAPS);
574 };
575 
576 class SigEntryFilter;
577 typedef GrowableArrayFilterIterator<SigEntry, SigEntryFilter> ExtendedSignature;
578 
579 // Used for adapter generation. One SigEntry is used per element of
580 // the signature of the method. Inline type arguments are treated
581 // specially. See comment for InlineKlass::collect_fields().
582 class SigEntry {
583  public:
584   BasicType _bt;
585   int _offset;
586   Symbol* _symbol;
587 
588   SigEntry()
589     : _bt(T_ILLEGAL), _offset(-1), _symbol(NULL) {}
590 
591   SigEntry(BasicType bt, int offset, Symbol* symbol)
592     : _bt(bt), _offset(offset), _symbol(symbol) {}
593 
594   static int compare(SigEntry* e1, SigEntry* e2) {
595     if (e1->_offset != e2->_offset) {
596       return e1->_offset - e2->_offset;
597     }
598     assert((e1->_bt == T_LONG && (e2->_bt == T_LONG || e2->_bt == T_VOID)) ||
599            (e1->_bt == T_DOUBLE && (e2->_bt == T_DOUBLE || e2->_bt == T_VOID)) ||
600            e1->_bt == T_METADATA || e2->_bt == T_METADATA || e1->_bt == T_VOID || e2->_bt == T_VOID, "bad bt");
601     if (e1->_bt == e2->_bt) {
602       assert(e1->_bt == T_METADATA || e1->_bt == T_VOID, "only ones with duplicate offsets");
603       return 0;
604     }
605     if (e1->_bt == T_VOID ||
606         e2->_bt == T_METADATA) {
607       return 1;
608     }
609     if (e1->_bt == T_METADATA ||
610         e2->_bt == T_VOID) {
611       return -1;
612     }
613     ShouldNotReachHere();
614     return 0;
615   }
616   static void add_entry(GrowableArray<SigEntry>* sig, BasicType bt, Symbol* symbol, int offset = -1);
617   static bool skip_value_delimiters(const GrowableArray<SigEntry>* sig, int i);
618   static int fill_sig_bt(const GrowableArray<SigEntry>* sig, BasicType* sig_bt);
619   static TempNewSymbol create_symbol(const GrowableArray<SigEntry>* sig);
620 };
621 
622 class SigEntryFilter {
623 public:
624   bool operator()(const SigEntry& entry) { return entry._bt != T_METADATA && entry._bt != T_VOID; }
625 };
626 
627 // Specialized SignatureStream: used for invoking SystemDictionary to either find
628 //                              or resolve the underlying type when iterating over a
629 //                              Java descriptor (or parts of it).
630 class ResolvingSignatureStream : public SignatureStream {
631   Klass*       _load_origin;
632   bool         _handles_cached;
633   Handle       _class_loader;       // cached when needed
634   Handle       _protection_domain;  // cached when needed
635 
636   void initialize_load_origin(Klass* load_origin) {
637     _load_origin = load_origin;
638     _handles_cached = (load_origin == nullptr);
639   }
640   void need_handles() {
641     if (!_handles_cached) {
642       cache_handles();
643       _handles_cached = true;
644     }
645   }
646   void cache_handles();
647 
648  public:
649   ResolvingSignatureStream(Symbol* signature, Klass* load_origin, bool is_method = true);
650   ResolvingSignatureStream(Symbol* signature, Handle class_loader, Handle protection_domain, bool is_method = true);
651   ResolvingSignatureStream(const Method* method);
652 
653   Klass* as_klass(FailureMode failure_mode, TRAPS) {
654     need_handles();
655     return SignatureStream::as_klass(_class_loader, _protection_domain,
656                                      failure_mode, THREAD);
657   }
658   oop as_java_mirror(FailureMode failure_mode, TRAPS) {
659     if (is_reference()) {
660       need_handles();
661     }
662     return SignatureStream::as_java_mirror(_class_loader, _protection_domain,
663                                            failure_mode, THREAD);
664   }
665 };
666 
667 // Here is how all the SignatureIterator classes invoke the
668 // SignatureStream engine to do their parsing.
669 template<typename T> inline
670 void SignatureIterator::do_parameters_on(T* callback) {
671   fingerprint_t unaccumulator = _fingerprint;
672 
673   // Check for too many arguments, or missing fingerprint:
674   if (!fp_is_valid(unaccumulator)) {
675     SignatureStream ss(_signature);
676     for (; !ss.at_return_type(); ss.next()) {
677       callback->do_type(ss.type());
678     }
679     // while we are here, capture the return type
680     _return_type = ss.type();
681   } else {
682     // Optimized version of do_parameters when fingerprint is known
683     assert(_return_type != T_ILLEGAL, "return type already captured from fp");
684     unaccumulator = fp_start_parameters(unaccumulator);
685     for (BasicType type; (type = fp_next_parameter(unaccumulator)) != (BasicType)fp_parameters_done; ) {
686       assert(fp_is_valid_type(type), "garbled fingerprint");
687       callback->do_type(type);
688     }
689   }
690 }
691 
692 #ifdef ASSERT
693  class SignatureVerifier : public StackObj {
694   public:
695     static bool is_valid_method_signature(const Symbol* sig);
696     static bool is_valid_type_signature(const Symbol* sig);
697   private:
698     static ssize_t is_valid_type(const char*, ssize_t);
699 };
700 #endif
701 #endif // SHARE_RUNTIME_SIGNATURE_HPP