434 lines
17 KiB
C++
434 lines
17 KiB
C++
/*
|
|
* Copyright (c) 1997, 2015, Oracle and/or its affiliates. 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*
|
|
*/
|
|
|
|
#ifndef SHARE_VM_RUNTIME_SIGNATURE_HPP
|
|
#define SHARE_VM_RUNTIME_SIGNATURE_HPP
|
|
|
|
#include "memory/allocation.hpp"
|
|
#include "oops/method.hpp"
|
|
#include "utilities/top.hpp"
|
|
|
|
// 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:
|
|
Symbol* _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,
|
|
is_static_bit = 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(Symbol* 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;
|
|
|
|
static bool is_static(uint64_t fingerprint) {
|
|
assert(fingerprint != (uint64_t)CONST64(-1), "invalid fingerprint");
|
|
return fingerprint & is_static_bit;
|
|
}
|
|
static BasicType return_type(uint64_t fingerprint) {
|
|
assert(fingerprint != (uint64_t)CONST64(-1), "invalid fingerprint");
|
|
return (BasicType) ((fingerprint >> static_feature_size) & result_feature_mask);
|
|
}
|
|
};
|
|
|
|
|
|
// 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(Symbol* 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(Symbol* 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(Symbol* signature) : SignatureInfo(signature) {}
|
|
|
|
int size() { lazy_iterate_parameters(); return _size; }
|
|
};
|
|
|
|
|
|
class ArgumentCount: public SignatureInfo {
|
|
private:
|
|
void set(int size, BasicType type) { _size ++; }
|
|
public:
|
|
ArgumentCount(Symbol* 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(Symbol* 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(const methodHandle& method) : SignatureIterator(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 = (uint64_t)CONST64(-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++; }
|
|
void do_float () { pass_float(); _jni_offset++; _offset++; }
|
|
#ifdef _LP64
|
|
void do_double() { pass_double(); _jni_offset++; _offset += 2; }
|
|
#else
|
|
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;
|
|
virtual void pass_float() = 0;
|
|
#ifdef _LP64
|
|
virtual void pass_double() = 0;
|
|
#else
|
|
virtual void pass_double() { pass_long(); } // may be same as long
|
|
#endif
|
|
|
|
NativeSignatureIterator(const 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:
|
|
Symbol* _signature;
|
|
int _begin;
|
|
int _end;
|
|
BasicType _type;
|
|
bool _at_return_type;
|
|
GrowableArray<Symbol*>* _names; // symbols created while parsing signature
|
|
|
|
public:
|
|
bool at_return_type() const { return _at_return_type; }
|
|
bool is_done() const;
|
|
void next_non_primitive(int t);
|
|
void next() {
|
|
Symbol* 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(Symbol* signature, bool is_method = true);
|
|
~SignatureStream();
|
|
|
|
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; }
|
|
Symbol* as_symbol(TRAPS);
|
|
enum FailureMode { ReturnNull, CNFException, NCDFError };
|
|
Klass* as_klass(Handle class_loader, Handle protection_domain, FailureMode failure_mode, TRAPS);
|
|
oop as_java_mirror(Handle class_loader, Handle protection_domain, FailureMode failure_mode, TRAPS);
|
|
const jbyte* raw_bytes() { return _signature->bytes() + _begin; }
|
|
int raw_length() { return _end - _begin; }
|
|
|
|
// return same as_symbol except allocation of new symbols is avoided.
|
|
Symbol* as_symbol_or_null();
|
|
|
|
// count the number of references in the signature
|
|
int reference_parameter_count();
|
|
};
|
|
|
|
class SignatureVerifier : public StackObj {
|
|
public:
|
|
// Returns true if the symbol is valid method or type signature
|
|
static bool is_valid_signature(Symbol* sig);
|
|
|
|
static bool is_valid_method_signature(Symbol* sig);
|
|
static bool is_valid_type_signature(Symbol* sig);
|
|
private:
|
|
|
|
static ssize_t is_valid_type(const char*, ssize_t);
|
|
static bool invalid_name_char(char);
|
|
};
|
|
|
|
#endif // SHARE_VM_RUNTIME_SIGNATURE_HPP
|