< prev index next >
src/hotspot/share/runtime/signature.hpp
Print this page
*** 23,32 ****
--- 23,33 ----
*/
#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,120 ****
--- 112,122 ----
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,149 ****
--- 142,152 ----
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,177 ****
--- 171,181 ----
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,243 ****
--- 238,248 ----
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,318 ****
--- 304,325 ----
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,431 ****
--- 433,497 ----
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
< prev index next >