jdk8-mips64-public/hotspot: src/share/vm/classfile/genericSignatures.hpp@95c00927be11 (annotated)

src/share/vm/classfile/genericSignatures.hpp@95c00927be11 (annotated)

src/share/vm/classfile/genericSignatures.hpp

Mon, 27 May 2013 12:56:34 +0200

author: stefank
date: Mon, 27 May 2013 12:56:34 +0200
changeset 5195: 95c00927be11
parent 4245: 4735d2c84362
permissions: -rw-r--r--

8015428: Remove unused CDS support from StringTable
Summary: The string in StringTable is not used by CDS anymore. Remove the unnecessary code in preparation for 8015422: Large performance hit when the StringTable is walked twice in Parallel Scavenge
Reviewed-by: pliden, tschatzl, coleenp

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

Mercurial > jdk8-mips64-public > hotspot / annotate

src/share/vm/classfile/genericSignatures.hpp@95c00927be11 (annotated)

src/share/vm/classfile/genericSignatures.hpp