Mercurial > jdk8-mips64-public > hotspot / file revision

 /*

  * Copyright 1997-2006 Sun Microsystems, Inc.  All Rights Reserved.

  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

  *

  * This code is free software; you can redistribute it and/or modify it

  * under the terms of the GNU General Public License version 2 only, as

  * published by the Free Software Foundation.

  *

  * This code is distributed in the hope that it will be useful, but WITHOUT

  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

  * version 2 for more details (a copy is included in the LICENSE file that

  * accompanied this code).

  *

  * You should have received a copy of the GNU General Public License version

  * 2 along with this work; if not, write to the Free Software Foundation,

  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

  *

  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

  * CA 95054 USA or visit www.sun.com if you need additional information or

  * have any questions.

  *

  */

 // SignatureIterators iterate over a Java signature (or parts of it).

 // (Syntax according to: "The Java Virtual Machine Specification" by

 // Tim Lindholm & Frank Yellin; section 4.3 Descriptors; p. 89ff.)

 //

 // Example: Iterating over ([Lfoo;D)I using

 //                         0123456789

 //

 // iterate_parameters() calls: do_array(2, 7); do_double();

 // iterate_returntype() calls:                              do_int();

 // iterate()            calls: do_array(2, 7); do_double(); do_int();

 //

 // is_return_type()        is: false         ; false      ; true

 //

 // NOTE: The new optimizer has an alternate, for-loop based signature

 // iterator implemented in opto/type.cpp, TypeTuple::make().

 class SignatureIterator: public ResourceObj {

  protected:

   symbolHandle _signature;             // the signature to iterate over

   int          _index;                 // the current character index (only valid during iteration)

   int          _parameter_index;       // the current parameter index (0 outside iteration phase)

   BasicType    _return_type;

   void expect(char c);

   void skip_optional_size();

   int  parse_type();                   // returns the parameter size in words (0 for void)

   void check_signature_end();

  public:

   // Definitions used in generating and iterating the

   // bit field form of the signature generated by the

   // Fingerprinter.

   enum {

     static_feature_size    = 1,

     result_feature_size    = 4,

     result_feature_mask    = 0xF,

     parameter_feature_size = 4,

     parameter_feature_mask = 0xF,

       bool_parm            = 1,

       byte_parm            = 2,

       char_parm            = 3,

       short_parm           = 4,

       int_parm             = 5,

       long_parm            = 6,

       float_parm           = 7,

       double_parm          = 8,

       obj_parm             = 9,

       done_parm            = 10,  // marker for end of parameters

     // max parameters is wordsize minus

     //    The sign bit, termination field, the result and static bit fields

     max_size_of_parameters = (BitsPerLong-1 -

                               result_feature_size - parameter_feature_size -

                               static_feature_size) / parameter_feature_size

   };

   // Constructors

   SignatureIterator(symbolOop signature);

   SignatureIterator(Thread *thread, symbolOop signature);

   SignatureIterator(symbolHandle signature);

   // Iteration

   void dispatch_field();               // dispatches once for field signatures

   void iterate_parameters();           // iterates over parameters only

   void iterate_parameters( uint64_t fingerprint );

   void iterate_returntype();           // iterates over returntype only

   void iterate();                      // iterates over whole signature

   // Returns the word index of the current parameter;

   int  parameter_index() const         { return _parameter_index; }

   bool is_return_type() const          { return parameter_index() < 0; }

   BasicType get_ret_type() const       { return _return_type; }

   // Basic types

   virtual void do_bool  ()             = 0;

   virtual void do_char  ()             = 0;

   virtual void do_float ()             = 0;

   virtual void do_double()             = 0;

   virtual void do_byte  ()             = 0;

   virtual void do_short ()             = 0;

   virtual void do_int   ()             = 0;

   virtual void do_long  ()             = 0;

   virtual void do_void  ()             = 0;

   // Object types (begin indexes the first character of the entry, end indexes the first character after the entry)

   virtual void do_object(int begin, int end) = 0;

   virtual void do_array (int begin, int end) = 0;

 };

 // Specialized SignatureIterators: Used to compute signature specific values.

 class SignatureTypeNames : public SignatureIterator {

  protected:

   virtual void type_name(const char* name)   = 0;

   void do_bool()                       { type_name("jboolean"); }

   void do_char()                       { type_name("jchar"   ); }

   void do_float()                      { type_name("jfloat"  ); }

   void do_double()                     { type_name("jdouble" ); }

   void do_byte()                       { type_name("jbyte"   ); }

   void do_short()                      { type_name("jshort"  ); }

   void do_int()                        { type_name("jint"    ); }

   void do_long()                       { type_name("jlong"   ); }

   void do_void()                       { type_name("void"    ); }

   void do_object(int begin, int end)   { type_name("jobject" ); }

   void do_array (int begin, int end)   { type_name("jobject" ); }

  public:

   SignatureTypeNames(symbolHandle signature) : SignatureIterator(signature) {}

 };

 class SignatureInfo: public SignatureIterator {

  protected:

   bool      _has_iterated;             // need this because iterate cannot be called in constructor (set is virtual!)

   bool      _has_iterated_return;

   int       _size;

   void lazy_iterate_parameters()       { if (!_has_iterated) { iterate_parameters(); _has_iterated = true; } }

   void lazy_iterate_return()           { if (!_has_iterated_return) { iterate_returntype(); _has_iterated_return = true; } }

   virtual void set(int size, BasicType type) = 0;

   void do_bool  ()                     { set(T_BOOLEAN_size, T_BOOLEAN); }

   void do_char  ()                     { set(T_CHAR_size   , T_CHAR   ); }

   void do_float ()                     { set(T_FLOAT_size  , T_FLOAT  ); }

   void do_double()                     { set(T_DOUBLE_size , T_DOUBLE ); }

   void do_byte  ()                     { set(T_BYTE_size   , T_BYTE   ); }

   void do_short ()                     { set(T_SHORT_size  , T_SHORT  ); }

   void do_int   ()                     { set(T_INT_size    , T_INT    ); }

   void do_long  ()                     { set(T_LONG_size   , T_LONG   ); }

   void do_void  ()                     { set(T_VOID_size   , T_VOID   ); }

   void do_object(int begin, int end)   { set(T_OBJECT_size , T_OBJECT ); }

   void do_array (int begin, int end)   { set(T_ARRAY_size  , T_ARRAY  ); }

  public:

   SignatureInfo(symbolHandle signature) : SignatureIterator(signature) {

     _has_iterated = _has_iterated_return = false;

     _size         = 0;

     _return_type  = T_ILLEGAL;

   }

 };

 // Specialized SignatureIterator: Used to compute the argument size.

 class ArgumentSizeComputer: public SignatureInfo {

  private:

   void set(int size, BasicType type)   { _size += size; }

  public:

   ArgumentSizeComputer(symbolHandle signature) : SignatureInfo(signature) {}

   int       size()                     { lazy_iterate_parameters(); return _size; }

 };

 class ArgumentCount: public SignatureInfo {

  private:

   void set(int size, BasicType type)   { _size ++; }

  public:

   ArgumentCount(symbolHandle signature) : SignatureInfo(signature) {}

   int       size()                     { lazy_iterate_parameters(); return _size; }

 };

 // Specialized SignatureIterator: Used to compute the result type.

 class ResultTypeFinder: public SignatureInfo {

  private:

   void set(int size, BasicType type)   { _return_type = type; }

  public:

   BasicType type()                     { lazy_iterate_return(); return _return_type; }

   ResultTypeFinder(symbolHandle signature) : SignatureInfo(signature) {}

 };

 // Fingerprinter computes a unique ID for a given method. The ID

 // is a bitvector characterizing the methods signature (incl. the receiver).

 class Fingerprinter: public SignatureIterator {

  private:

   uint64_t _fingerprint;

   int _shift_count;

   methodHandle mh;

  public:

   void do_bool()    { _fingerprint |= (((uint64_t)bool_parm) << _shift_count); _shift_count += parameter_feature_size; }

   void do_char()    { _fingerprint |= (((uint64_t)char_parm) << _shift_count); _shift_count += parameter_feature_size; }

   void do_byte()    { _fingerprint |= (((uint64_t)byte_parm) << _shift_count); _shift_count += parameter_feature_size; }

   void do_short()   { _fingerprint |= (((uint64_t)short_parm) << _shift_count); _shift_count += parameter_feature_size; }

   void do_int()     { _fingerprint |= (((uint64_t)int_parm) << _shift_count); _shift_count += parameter_feature_size; }

   void do_long()    { _fingerprint |= (((uint64_t)long_parm) << _shift_count); _shift_count += parameter_feature_size; }

   void do_float()   { _fingerprint |= (((uint64_t)float_parm) << _shift_count); _shift_count += parameter_feature_size; }

   void do_double()  { _fingerprint |= (((uint64_t)double_parm) << _shift_count); _shift_count += parameter_feature_size; }

   void do_object(int begin, int end)  { _fingerprint |= (((uint64_t)obj_parm) << _shift_count); _shift_count += parameter_feature_size; }

   void do_array (int begin, int end)  { _fingerprint |= (((uint64_t)obj_parm) << _shift_count); _shift_count += parameter_feature_size; }

   void do_void()    { ShouldNotReachHere(); }

   Fingerprinter(methodHandle method) : SignatureIterator(method->signature()) {

     mh = method;

     _fingerprint = 0;

   }

   Fingerprinter(Thread *thread, methodHandle method) : SignatureIterator(thread, method->signature()) {

     mh = method;

     _fingerprint = 0;

   }

   uint64_t fingerprint() {

     // See if we fingerprinted this method already

     if (mh->constMethod()->fingerprint() != CONST64(0)) {

       return mh->constMethod()->fingerprint();

     }

     if (mh->size_of_parameters() > max_size_of_parameters ) {

       _fingerprint = UCONST64(-1);

       mh->constMethod()->set_fingerprint(_fingerprint);

       return _fingerprint;

     }

     assert( (int)mh->result_type() <= (int)result_feature_mask, "bad result type");

     _fingerprint = mh->result_type();

     _fingerprint <<= static_feature_size;

     if (mh->is_static())  _fingerprint |= 1;

     _shift_count = result_feature_size + static_feature_size;

     iterate_parameters();

     _fingerprint |= ((uint64_t)done_parm) << _shift_count;// mark end of sig

     mh->constMethod()->set_fingerprint(_fingerprint);

     return _fingerprint;

   }

 };

 // Specialized SignatureIterator: Used for native call purposes

 class NativeSignatureIterator: public SignatureIterator {

  private:

   methodHandle _method;

 // We need separate JNI and Java offset values because in 64 bit mode,

 // the argument offsets are not in sync with the Java stack.

 // For example a long takes up 1 "C" stack entry but 2 Java stack entries.

   int          _offset;                // The java stack offset

   int          _prepended;             // number of prepended JNI parameters (1 JNIEnv, plus 1 mirror if static)

   int          _jni_offset;            // the current parameter offset, starting with 0

   void do_bool  ()                     { pass_int();    _jni_offset++; _offset++;       }

   void do_char  ()                     { pass_int();    _jni_offset++; _offset++;       }

 #ifdef _LP64

   void do_float ()                     { pass_float();  _jni_offset++; _offset++;       }

   void do_double()                     { pass_double(); _jni_offset++; _offset += 2;    }

 #else

   void do_float ()                     { pass_int();    _jni_offset++; _offset++;       }

   void do_double()                     { pass_double(); _jni_offset += 2; _offset += 2; }

 #endif

   void do_byte  ()                     { pass_int();    _jni_offset++; _offset++;       }

   void do_short ()                     { pass_int();    _jni_offset++; _offset++;       }

   void do_int   ()                     { pass_int();    _jni_offset++; _offset++;       }

 #ifdef _LP64

   void do_long  ()                     { pass_long();   _jni_offset++; _offset += 2;    }

 #else

   void do_long  ()                     { pass_long();   _jni_offset += 2; _offset += 2; }

 #endif

   void do_void  ()                     { ShouldNotReachHere();                               }

   void do_object(int begin, int end)   { pass_object(); _jni_offset++; _offset++;        }

   void do_array (int begin, int end)   { pass_object(); _jni_offset++; _offset++;        }

  public:

   methodHandle method() const          { return _method; }

   int          offset() const          { return _offset; }

   int      jni_offset() const          { return _jni_offset + _prepended; }

 //  int     java_offset() const          { return method()->size_of_parameters() - _offset - 1; }

   bool      is_static() const          { return method()->is_static(); }

   virtual void pass_int()              = 0;

   virtual void pass_long()             = 0;

   virtual void pass_object()           = 0;

 #ifdef _LP64

   virtual void pass_float()            = 0;

   virtual void pass_double()           = 0;

 #else

   virtual void pass_double()           { pass_long(); }  // may be same as long

 #endif

   NativeSignatureIterator(methodHandle method) : SignatureIterator(method->signature()) {

     _method = method;

     _offset = 0;

     _jni_offset = 0;

     const int JNIEnv_words = 1;

     const int mirror_words = 1;

     _prepended = !is_static() ? JNIEnv_words : JNIEnv_words + mirror_words;

   }

   // iterate() calles the 2 virtual methods according to the following invocation syntax:

   //

   // {pass_int | pass_long | pass_object}

   //

   // Arguments are handled from left to right (receiver first, if any).

   // The offset() values refer to the Java stack offsets but are 0 based and increasing.

   // The java_offset() values count down to 0, and refer to the Java TOS.

   // The jni_offset() values increase from 1 or 2, and refer to C arguments.

   void iterate() { iterate(Fingerprinter(method()).fingerprint());

   }

   // Optimized path if we have the bitvector form of signature

   void iterate( uint64_t fingerprint ) {

     if (!is_static()) {

       // handle receiver (not handled by iterate because not in signature)

       pass_object(); _jni_offset++; _offset++;

     }

     SignatureIterator::iterate_parameters( fingerprint );

   }

 };

 // Handy stream for iterating over signature

 class SignatureStream : public StackObj {

  private:

   symbolHandle _signature;

   int          _begin;

   int          _end;

   BasicType    _type;

   bool         _at_return_type;

  public:

   bool at_return_type() const                    { return _at_return_type; }

   bool is_done() const;

   void next_non_primitive(int t);

   void next() {

     symbolOop sig = _signature();

     int len = sig->utf8_length();

     if (_end >= len) {

       _end = len + 1;

       return;

     }

     _begin = _end;

     int t = sig->byte_at(_begin);

     switch (t) {

       case 'B': _type = T_BYTE;    break;

       case 'C': _type = T_CHAR;    break;

       case 'D': _type = T_DOUBLE;  break;

       case 'F': _type = T_FLOAT;   break;

       case 'I': _type = T_INT;     break;

       case 'J': _type = T_LONG;    break;

       case 'S': _type = T_SHORT;   break;

       case 'Z': _type = T_BOOLEAN; break;

       case 'V': _type = T_VOID;    break;

       default : next_non_primitive(t);

                 return;

     }

     _end++;

   }

   SignatureStream(symbolHandle signature,

                   bool is_method = true) :

                    _signature(signature), _at_return_type(false) {

     _begin = _end = (is_method ? 1 : 0);  // skip first '(' in method signatures

     next();

   }

   bool is_object() const;                        // True if this argument is an object

   bool is_array() const;                         // True if this argument is an array

   BasicType type() const                         { return _type; }

   symbolOop as_symbol(TRAPS);

   // return same as_symbol except allocation of new symbols is avoided.

   symbolOop as_symbol_or_null();

 };

 class SignatureVerifier : public StackObj {

   public:

     // Returns true if the symbol is valid method or type signature

     static bool is_valid_signature(symbolHandle sig);

     static bool is_valid_method_signature(symbolHandle sig);

     static bool is_valid_type_signature(symbolHandle sig);

   private:

     static ssize_t is_valid_type(const char*, ssize_t);

     static bool invalid_name_char(char);

 };