Mercurial > hg > truffle
view src/share/vm/classfile/genericSignatures.hpp @ 7535:f057113c7a87
provide TargetDescription in LoweringTool
author | Lukas Stadler <lukas.stadler@jku.at> |
---|---|
date | Wed, 23 Jan 2013 16:46:20 +0100 |
parents | 4735d2c84362 |
children |
line wrap: on
line source
/* * Copyright (c) 2012, 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_CLASSFILE_GENERICSIGNATURES_HPP #define SHARE_VM_CLASSFILE_GENERICSIGNATURES_HPP #include "classfile/symbolTable.hpp" #include "memory/allocation.hpp" #include "runtime/signature.hpp" #include "utilities/growableArray.hpp" #include "utilities/resourceHash.hpp" class stringStream; namespace generic { class Identifier; class ClassDescriptor; class MethodDescriptor; class TypeParameter; // a formal type parameter declared in generic signatures class TypeArgument; // The "type value" passed to fill parameters in supertypes class TypeVariable; // A usage of a type parameter as a value /** * Example: * * <T, V> class Foo extends Bar<String> { int m(V v) {} } * ^^^^^^ ^^^^^^ ^^ * type parameters type argument type variable * * Note that a type variable could be passed as an argument too: * <T, V> class Foo extends Bar<T> { int m(V v) {} } * ^^^ * type argument's value is a type variable */ class Type; class ClassType; class ArrayType; class PrimitiveType; class Context; class DescriptorCache; class DescriptorStream; class Identifier : public ResourceObj { private: Symbol* _sym; int _begin; int _end; public: Identifier(Symbol* sym, int begin, int end) : _sym(sym), _begin(begin), _end(end) {} bool equals(Identifier* other); bool equals(Symbol* sym); #ifndef PRODUCT void print_on(outputStream* str) const; #endif // ndef PRODUCT }; class Descriptor : public ResourceObj { protected: GrowableArray<TypeParameter*> _type_parameters; ClassDescriptor* _outer_class; Descriptor(GrowableArray<TypeParameter*>& params, ClassDescriptor* outer) : _type_parameters(params), _outer_class(outer) {} public: ClassDescriptor* outer_class() { return _outer_class; } void set_outer_class(ClassDescriptor* sig) { _outer_class = sig; } virtual ClassDescriptor* as_class_signature() { return NULL; } virtual MethodDescriptor* as_method_signature() { return NULL; } bool is_class_signature() { return as_class_signature() != NULL; } bool is_method_signature() { return as_method_signature() != NULL; } GrowableArray<TypeParameter*>& type_parameters() { return _type_parameters; } TypeParameter* find_type_parameter(Identifier* id, int* param_depth); virtual void bind_variables_to_parameters() = 0; #ifndef PRODUCT virtual void print_on(outputStream* str) const = 0; #endif }; class ClassDescriptor : public Descriptor { private: ClassType* _super; GrowableArray<ClassType*> _interfaces; MethodDescriptor* _outer_method; ClassDescriptor(GrowableArray<TypeParameter*>& ftp, ClassType* scs, GrowableArray<ClassType*>& sis, ClassDescriptor* outer_class = NULL, MethodDescriptor* outer_method = NULL) : Descriptor(ftp, outer_class), _super(scs), _interfaces(sis), _outer_method(outer_method) {} static u2 get_outer_class_index(InstanceKlass* k, TRAPS); static ClassDescriptor* parse_generic_signature(Klass* k, Symbol* original_name, TRAPS); public: virtual ClassDescriptor* as_class_signature() { return this; } MethodDescriptor* outer_method() { return _outer_method; } void set_outer_method(MethodDescriptor* m) { _outer_method = m; } ClassType* super() { return _super; } ClassType* interface_desc(Symbol* sym); static ClassDescriptor* parse_generic_signature(Klass* k, TRAPS); static ClassDescriptor* parse_generic_signature(Symbol* sym); // For use in superclass chains in positions where this is no generic info static ClassDescriptor* placeholder(InstanceKlass* klass); #ifndef PRODUCT void print_on(outputStream* str) const; #endif ClassDescriptor* canonicalize(Context* ctx); // Linking sets the position index in any contained TypeVariable type // to correspond to the location of that identifier in the formal type // parameters. void bind_variables_to_parameters(); }; class MethodDescriptor : public Descriptor { private: GrowableArray<Type*> _parameters; Type* _return_type; GrowableArray<Type*> _throws; MethodDescriptor(GrowableArray<TypeParameter*>& ftp, ClassDescriptor* outer, GrowableArray<Type*>& sigs, Type* rt, GrowableArray<Type*>& throws) : Descriptor(ftp, outer), _parameters(sigs), _return_type(rt), _throws(throws) {} public: static MethodDescriptor* parse_generic_signature(Method* m, ClassDescriptor* outer); static MethodDescriptor* parse_generic_signature(Symbol* sym, ClassDescriptor* outer); MethodDescriptor* as_method_signature() { return this; } // Performs generic analysis on the method parameters to determine // if both methods refer to the same argument types. bool covariant_match(MethodDescriptor* other, Context* ctx); // Returns a new method descriptor with all generic variables // removed and replaced with whatever is indicated using the Context. MethodDescriptor* canonicalize(Context* ctx); void bind_variables_to_parameters(); #ifndef PRODUCT TempNewSymbol reify_signature(Context* ctx, TRAPS); void print_on(outputStream* str) const; #endif }; class TypeParameter : public ResourceObj { private: Identifier* _identifier; ClassType* _class_bound; GrowableArray<ClassType*> _interface_bounds; // The position is the ordinal location of the parameter within the // formal parameter list (excluding outer classes). It is only set for // formal type parameters that are associated with a class -- method // type parameters are left as -1. When resolving a generic variable to // find the actual type, this index is used to access the generic type // argument in the provided context object. int _position; // Assigned during variable linking TypeParameter(Identifier* id, ClassType* class_bound, GrowableArray<ClassType*>& interface_bounds) : _identifier(id), _class_bound(class_bound), _interface_bounds(interface_bounds), _position(-1) {} public: static TypeParameter* parse_generic_signature(DescriptorStream* str); ClassType* bound(); int position() { return _position; } void bind_variables_to_parameters(Descriptor* sig, int position); Identifier* identifier() { return _identifier; } Type* resolve(Context* ctx, int inner_depth, int ctx_depth); TypeParameter* canonicalize(Context* ctx, int ctx_depth); #ifndef PRODUCT void print_on(outputStream* str) const; #endif }; class Type : public ResourceObj { public: static Type* parse_generic_signature(DescriptorStream* str); virtual ClassType* as_class() { return NULL; } virtual TypeVariable* as_variable() { return NULL; } virtual ArrayType* as_array() { return NULL; } virtual PrimitiveType* as_primitive() { return NULL; } virtual bool covariant_match(Type* gt, Context* ctx) = 0; virtual Type* canonicalize(Context* ctx, int ctx_depth) = 0; virtual void bind_variables_to_parameters(Descriptor* sig) = 0; #ifndef PRODUCT virtual void reify_signature(stringStream* ss, Context* ctx) = 0; virtual void print_on(outputStream* str) const = 0; #endif }; class ClassType : public Type { friend class ClassDescriptor; protected: Identifier* _identifier; GrowableArray<TypeArgument*> _type_arguments; ClassType* _outer_class; ClassType(Identifier* identifier, GrowableArray<TypeArgument*>& args, ClassType* outer) : _identifier(identifier), _type_arguments(args), _outer_class(outer) {} // Returns true if there are inner classes to read static Identifier* parse_generic_signature_simple( GrowableArray<TypeArgument*>* args, bool* has_inner, DescriptorStream* str); static ClassType* parse_generic_signature(ClassType* outer, DescriptorStream* str); static ClassType* from_symbol(Symbol* sym); public: ClassType* as_class() { return this; } static ClassType* parse_generic_signature(DescriptorStream* str); static ClassType* java_lang_Object(); Identifier* identifier() { return _identifier; } int type_arguments_length() { return _type_arguments.length(); } TypeArgument* type_argument_at(int i); virtual ClassType* outer_class() { return _outer_class; } bool covariant_match(Type* gt, Context* ctx); ClassType* canonicalize(Context* ctx, int context_depth); void bind_variables_to_parameters(Descriptor* sig); #ifndef PRODUCT void reify_signature(stringStream* ss, Context* ctx); void print_on(outputStream* str) const; #endif }; class TypeVariable : public Type { private: Identifier* _id; TypeParameter* _parameter; // assigned during linking // how many steps "out" from inner classes, -1 if method int _inner_depth; TypeVariable(Identifier* id) : _id(id), _parameter(NULL), _inner_depth(0) {} public: TypeVariable* as_variable() { return this; } static TypeVariable* parse_generic_signature(DescriptorStream* str); Identifier* identifier() { return _id; } TypeParameter* parameter() { return _parameter; } int inner_depth() { return _inner_depth; } void bind_variables_to_parameters(Descriptor* sig); Type* resolve(Context* ctx, int ctx_depth); bool covariant_match(Type* gt, Context* ctx); Type* canonicalize(Context* ctx, int ctx_depth); #ifndef PRODUCT void reify_signature(stringStream* ss, Context* ctx); void print_on(outputStream* str) const; #endif }; class ArrayType : public Type { private: Type* _base; ArrayType(Type* base) : _base(base) {} public: ArrayType* as_array() { return this; } static ArrayType* parse_generic_signature(DescriptorStream* str); bool covariant_match(Type* gt, Context* ctx); ArrayType* canonicalize(Context* ctx, int ctx_depth); void bind_variables_to_parameters(Descriptor* sig); #ifndef PRODUCT void reify_signature(stringStream* ss, Context* ctx); void print_on(outputStream* str) const; #endif }; class PrimitiveType : public Type { friend class Type; private: char _type; // includes V for void PrimitiveType(char& type) : _type(type) {} public: PrimitiveType* as_primitive() { return this; } bool covariant_match(Type* gt, Context* ctx); PrimitiveType* canonicalize(Context* ctx, int ctx_depth); void bind_variables_to_parameters(Descriptor* sig); #ifndef PRODUCT void reify_signature(stringStream* ss, Context* ctx); void print_on(outputStream* str) const; #endif }; class TypeArgument : public ResourceObj { private: Type* _lower_bound; Type* _upper_bound; // may be null or == _lower_bound TypeArgument(Type* lower_bound, Type* upper_bound) : _lower_bound(lower_bound), _upper_bound(upper_bound) {} public: static TypeArgument* parse_generic_signature(DescriptorStream* str); Type* lower_bound() { return _lower_bound; } Type* upper_bound() { return _upper_bound; } void bind_variables_to_parameters(Descriptor* sig); TypeArgument* canonicalize(Context* ctx, int ctx_depth); bool covariant_match(TypeArgument* a, Context* ctx); #ifndef PRODUCT void print_on(outputStream* str) const; #endif }; class Context : public ResourceObj { private: DescriptorCache* _cache; GrowableArray<ClassType*> _type_arguments; void reset_to_mark(int size); public: // When this object goes out of scope or 'destroy' is // called, then the application of the type to the // context is wound-back (unless it's been deactivated). class Mark : public StackObj { private: mutable Context* _context; int _marked_size; bool is_active() const { return _context != NULL; } void deactivate() const { _context = NULL; } public: Mark() : _context(NULL), _marked_size(0) {} Mark(Context* ctx, int sz) : _context(ctx), _marked_size(sz) {} Mark(const Mark& m) : _context(m._context), _marked_size(m._marked_size) { m.deactivate(); // Ownership is transferred } Mark& operator=(const Mark& cm) { destroy(); _context = cm._context; _marked_size = cm._marked_size; cm.deactivate(); return *this; } void destroy(); ~Mark() { destroy(); } }; Context(DescriptorCache* cache) : _cache(cache) {} Mark mark() { return Mark(this, _type_arguments.length()); } void apply_type_arguments(InstanceKlass* current, InstanceKlass* super,TRAPS); ClassType* at_depth(int i) const; #ifndef PRODUCT void print_on(outputStream* str) const; #endif }; /** * Contains a cache of descriptors for classes and methods so they can be * looked-up instead of reparsing each time they are needed. */ class DescriptorCache : public ResourceObj { private: ResourceHashtable<InstanceKlass*, ClassDescriptor*> _class_descriptors; ResourceHashtable<Method*, MethodDescriptor*> _method_descriptors; public: ClassDescriptor* descriptor_for(InstanceKlass* ikh, TRAPS); MethodDescriptor* descriptor_for(Method* mh, ClassDescriptor* cd, TRAPS); // Class descriptor derived from method holder MethodDescriptor* descriptor_for(Method* mh, TRAPS); }; } // namespace generic #endif // SHARE_VM_CLASSFILE_GENERICSIGNATURES_HPP