| /* |
| * 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" |
| |
| // 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 |