src/hotspot/share/runtime/signature.hpp

@@ -23,10 +23,11 @@
  */
 
 #ifndef SHARE_RUNTIME_SIGNATURE_HPP
 #define SHARE_RUNTIME_SIGNATURE_HPP
 
+#include "classfile/symbolTable.hpp"
 #include "memory/allocation.hpp"
 #include "oops/method.hpp"
 
 // SignatureIterators iterate over a Java signature (or parts of it).
 // (Syntax according to: "The Java Virtual Machine Specification" by

@@ -111,10 +112,11 @@
   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_valuetype(int begin, int end) = 0;
   virtual void do_array (int begin, int end) = 0;
 
   static bool is_static(uint64_t fingerprint) {
     assert(fingerprint != (uint64_t)CONST64(-1), "invalid fingerprint");
     return fingerprint & is_static_bit;

@@ -140,10 +142,11 @@
   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_valuetype(int begin, int end) { type_name("jobject"); }
   void do_array (int begin, int end)   { type_name("jobject" ); }
 
  public:
   SignatureTypeNames(Symbol* signature) : SignatureIterator(signature) {}
 };

@@ -168,10 +171,11 @@
   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_valuetype(int begin, int end) { set(T_VALUETYPE_size, T_VALUETYPE ); }
   void do_array (int begin, int end)   { set(T_ARRAY_size  , T_ARRAY  ); }
 
  public:
   SignatureInfo(Symbol* signature) : SignatureIterator(signature) {
     _has_iterated = _has_iterated_return = false;

@@ -234,10 +238,11 @@
   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_valuetype(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(const methodHandle& method) : SignatureIterator(method->signature()) {

@@ -299,20 +304,22 @@
   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++;        }
+  void do_valuetype(int begin, int end){ pass_valuetype();  _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;
+  virtual void pass_valuetype()        = 0;
   virtual void pass_float()            = 0;
 #ifdef _LP64
   virtual void pass_double()           = 0;
 #else
   virtual void pass_double()           { pass_long(); }  // may be same as long

@@ -426,6 +433,65 @@
 
     static ssize_t is_valid_type(const char*, ssize_t);
     static bool invalid_name_char(char);
 };
 
+class SigEntryFilter;
+typedef GrowableArrayFilterIterator<SigEntry, SigEntryFilter> ExtendedSignature;
+
+// Used for adapter generation. One SigEntry is used per element of
+// the signature of the method. Value type arguments are treated
+// specially. See comment for ValueKlass::collect_fields().
+class SigEntry {
+ public:
+  BasicType _bt;
+  int _offset;
+
+  enum { ReservedOffset = -2 }; // Special offset to mark the reserved entry
+
+  SigEntry()
+    : _bt(T_ILLEGAL), _offset(-1) {
+  }
+  SigEntry(BasicType bt, int offset)
+    : _bt(bt), _offset(offset) {}
+
+  SigEntry(BasicType bt)
+    : _bt(bt), _offset(-1) {}
+
+  static int compare(SigEntry* e1, SigEntry* e2) {
+    if (e1->_offset != e2->_offset) {
+      return e1->_offset - e2->_offset;
+    }
+    assert((e1->_bt == T_LONG && (e2->_bt == T_LONG || e2->_bt == T_VOID)) ||
+           (e1->_bt == T_DOUBLE && (e2->_bt == T_DOUBLE || e2->_bt == T_VOID)) ||
+           e1->_bt == T_VALUETYPE || e2->_bt == T_VALUETYPE || e1->_bt == T_VOID || e2->_bt == T_VOID, "bad bt");
+    if (e1->_bt == e2->_bt) {
+      assert(e1->_bt == T_VALUETYPE || e1->_bt == T_VOID, "only ones with duplicate offsets");
+      return 0;
+    }
+    if (e1->_bt == T_VOID ||
+        e2->_bt == T_VALUETYPE) {
+      return 1;
+    }
+    if (e1->_bt == T_VALUETYPE ||
+        e2->_bt == T_VOID) {
+      return -1;
+    }
+    ShouldNotReachHere();
+    return 0;
+  }
+  static void add_entry(GrowableArray<SigEntry>* sig, BasicType bt, int offset = -1);
+  static void insert_reserved_entry(GrowableArray<SigEntry>* sig, int i, BasicType bt);
+  static bool is_reserved_entry(const GrowableArray<SigEntry>* sig, int i);
+  static bool skip_value_delimiters(const GrowableArray<SigEntry>* sig, int i);
+  static int fill_sig_bt(const GrowableArray<SigEntry>* sig, BasicType* sig_bt);
+  static TempNewSymbol create_symbol(const GrowableArray<SigEntry>* sig);
+
+  static bool next_is_reserved(ExtendedSignature& sig, BasicType& bt, bool can_be_void = false);
+};
+
+class SigEntryFilter {
+public:
+  bool operator()(const SigEntry& entry) { return entry._bt != T_VALUETYPE && entry._bt != T_VOID; }
+};
+
 #endif // SHARE_RUNTIME_SIGNATURE_HPP