--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/share/vm/runtime/signature.hpp	Sat Dec 01 00:00:00 2007 +0000
@@ -0,0 +1,416 @@
+/*
+ * 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 seperate 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);
+};