Mercurial > jdk8-mips64-public > hotspot / file revision

 /*

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

  *

  */

 #include "precompiled.hpp"

 #include "classfile/genericSignatures.hpp"

 #include "classfile/symbolTable.hpp"

 #include "classfile/systemDictionary.hpp"

 #include "memory/resourceArea.hpp"

 namespace generic {

 // Helper class for parsing the generic signature Symbol in klass and methods

 class DescriptorStream : public ResourceObj {

  private:

   Symbol* _symbol;

   int _offset;

   int _mark;

   const char* _parse_error;

   void set_parse_error(const char* error) {

     assert(error != NULL, "Can't set NULL error string");

     _parse_error = error;

   }

  public:

   DescriptorStream(Symbol* sym)

       : _symbol(sym), _offset(0), _mark(-1), _parse_error(NULL) {}

   const char* parse_error() const {

     return _parse_error;

   }

   bool at_end() { return _offset >= _symbol->utf8_length(); }

   char peek() {

     if (at_end()) {

       set_parse_error("Peeking past end of signature");

       return '\0';

     } else {

       return _symbol->byte_at(_offset);

     }

   }

   char read() {

     if (at_end()) {

       set_parse_error("Reading past end of signature");

       return '\0';

     } else {

       return _symbol->byte_at(_offset++);

     }

   }

   void read(char expected) {

     char c = read();

     assert_char(c, expected, 0);

   }

   void assert_char(char c, char expected, int pos = -1) {

     if (c != expected) {

       const char* fmt = "Parse error at %d: expected %c but got %c";

       size_t len = strlen(fmt) + 5;

       char* buffer = NEW_RESOURCE_ARRAY(char, len);

       jio_snprintf(buffer, len, fmt, _offset + pos, expected, c);

       set_parse_error(buffer);

     }

   }

   void push(char c) {

     assert(c == _symbol->byte_at(_offset - 1), "Pushing back wrong value");

     --_offset;

   }

   void expect_end() {

     if (!at_end()) {

       set_parse_error("Unexpected data trailing signature");

     }

   }

   bool has_mark() { return _mark != -1; }

   void set_mark() {

     _mark = _offset;

   }

   Identifier* identifier_from_mark() {

     assert(has_mark(), "Mark should be set");

     if (!has_mark()) {

       set_parse_error("Expected mark to be set");

       return NULL;

     } else {

       Identifier* id = new Identifier(_symbol, _mark, _offset - 1);

       _mark = -1;

       return id;

     }

   }

 };

 #define CHECK_FOR_PARSE_ERROR()         \

   if (STREAM->parse_error() != NULL) {   \

     if (VerifyGenericSignatures) {      \

       fatal(STREAM->parse_error());      \

     }                                   \

     return NULL;                        \

   } 0

 #define READ() STREAM->read(); CHECK_FOR_PARSE_ERROR()

 #define PEEK() STREAM->peek(); CHECK_FOR_PARSE_ERROR()

 #define PUSH(c) STREAM->push(c)

 #define EXPECT(c) STREAM->read(c); CHECK_FOR_PARSE_ERROR()

 #define EXPECTED(c, ch) STREAM->assert_char(c, ch); CHECK_FOR_PARSE_ERROR()

 #define EXPECT_END() STREAM->expect_end(); CHECK_FOR_PARSE_ERROR()

 #define CHECK_STREAM STREAM); CHECK_FOR_PARSE_ERROR(); (0

 #ifndef PRODUCT

 void Identifier::print_on(outputStream* str) const {

   for (int i = _begin; i < _end; ++i) {

     str->print("%c", (char)_sym->byte_at(i));

   }

 }

 #endif // ndef PRODUCT

 bool Identifier::equals(Identifier* other) {

   if (_sym == other->_sym && _begin == other->_begin && _end == other->_end) {

     return true;

   } else if (_end - _begin != other->_end - other->_begin) {

     return false;

   } else {

     size_t len = _end - _begin;

     char* addr = ((char*)_sym->bytes()) + _begin;

     char* oaddr = ((char*)other->_sym->bytes()) + other->_begin;

     return strncmp(addr, oaddr, len) == 0;

   }

 }

 bool Identifier::equals(Symbol* sym) {

   Identifier id(sym, 0, sym->utf8_length());

   return equals(&id);

 }

 /**

  * A formal type parameter may be found in the the enclosing class, but it could

  * also come from an enclosing method or outer class, in the case of inner-outer

  * classes or anonymous classes.  For example:

  *

  * class Outer<T,V> {

  *   class Inner<W> {

  *     void m(T t, V v, W w);

  *   }

  * }

  *

  * In this case, the type variables in m()'s signature are not all found in the

  * immediate enclosing class (Inner).  class Inner has only type parameter W,

  * but it's outer_class field will reference Outer's descriptor which contains

  * T & V (no outer_method in this case).

  *

  * If you have an anonymous class, it has both an enclosing method *and* an

  * enclosing class where type parameters can be declared:

  *

  * class MOuter<T> {

  *   <V> void bar(V v) {

  *     Runnable r = new Runnable() {

  *       public void run() {}

  *       public void foo(T t, V v) { ... }

  *     };

  *   }

  * }

  *

  * In this case, foo will be a member of some class, Runnable$1, which has no

  * formal parameters itself, but has an outer_method (bar()) which provides

  * type parameter V, and an outer class MOuter with type parameter T.

  *

  * It is also possible that the outer class is itself an inner class to some

  * other class (or an anonymous class with an enclosing method), so we need to

  * follow the outer_class/outer_method chain to it's end when looking for a

  * type parameter.

  */

 TypeParameter* Descriptor::find_type_parameter(Identifier* id, int* depth) {

   int current_depth = 0;

   MethodDescriptor* outer_method = as_method_signature();

   ClassDescriptor* outer_class = as_class_signature();

   if (outer_class == NULL) { // 'this' is a method signature; use the holder

     outer_class = outer_method->outer_class();

   }

   while (outer_method != NULL || outer_class != NULL) {

     if (outer_method != NULL) {

       for (int i = 0; i < outer_method->type_parameters().length(); ++i) {

         TypeParameter* p = outer_method->type_parameters().at(i);

         if (p->identifier()->equals(id)) {

           *depth = -1; // indicates this this is a method parameter

           return p;

         }

       }

     }

     if (outer_class != NULL) {

       for (int i = 0; i < outer_class->type_parameters().length(); ++i) {

         TypeParameter* p = outer_class->type_parameters().at(i);

         if (p->identifier()->equals(id)) {

           *depth = current_depth;

           return p;

         }

       }

       outer_method = outer_class->outer_method();

       outer_class = outer_class->outer_class();

       ++current_depth;

     }

   }

   if (VerifyGenericSignatures) {

     fatal("Could not resolve identifier");

   }

   return NULL;

 }

 ClassDescriptor* ClassDescriptor::parse_generic_signature(Klass* klass, TRAPS) {

   return parse_generic_signature(klass, NULL, CHECK_NULL);

 }

 ClassDescriptor* ClassDescriptor::parse_generic_signature(

       Klass* klass, Symbol* original_name, TRAPS) {

   InstanceKlass* ik = InstanceKlass::cast(klass);

   Symbol* sym = ik->generic_signature();

   ClassDescriptor* spec;

   if (sym == NULL || (spec = ClassDescriptor::parse_generic_signature(sym)) == NULL) {

     spec = ClassDescriptor::placeholder(ik);

   }

   u2 outer_index = get_outer_class_index(ik, CHECK_NULL);

   if (outer_index != 0) {

     if (original_name == NULL) {

       original_name = ik->name();

     }

     Handle class_loader = Handle(THREAD, ik->class_loader());

     Handle protection_domain = Handle(THREAD, ik->protection_domain());

     Symbol* outer_name = ik->constants()->klass_name_at(outer_index);

     Klass* outer = SystemDictionary::find(

         outer_name, class_loader, protection_domain, CHECK_NULL);

     if (outer == NULL && !THREAD->is_Compiler_thread()) {

       outer = SystemDictionary::resolve_super_or_fail(original_name,

           outer_name, class_loader, protection_domain, false, CHECK_NULL);

     }

     InstanceKlass* outer_ik;

     ClassDescriptor* outer_spec = NULL;

     if (outer == NULL) {

       outer_spec = ClassDescriptor::placeholder(ik);

       assert(false, "Outer class not loaded and not loadable from here");

     } else {

       outer_ik = InstanceKlass::cast(outer);

       outer_spec = parse_generic_signature(outer, original_name, CHECK_NULL);

     }

     spec->set_outer_class(outer_spec);

     u2 encl_method_idx = ik->enclosing_method_method_index();

     if (encl_method_idx != 0 && outer_ik != NULL) {

       ConstantPool* cp = ik->constants();

       u2 name_index = cp->name_ref_index_at(encl_method_idx);

       u2 sig_index = cp->signature_ref_index_at(encl_method_idx);

       Symbol* name = cp->symbol_at(name_index);

       Symbol* sig = cp->symbol_at(sig_index);

       Method* m = outer_ik->find_method(name, sig);

       if (m != NULL) {

         Symbol* gsig = m->generic_signature();

         if (gsig != NULL) {

           MethodDescriptor* gms = MethodDescriptor::parse_generic_signature(gsig, outer_spec);

           spec->set_outer_method(gms);

         }

       } else if (VerifyGenericSignatures) {

         ResourceMark rm;

         stringStream ss;

         ss.print("Could not find method %s %s in class %s",

           name->as_C_string(), sig->as_C_string(), outer_name->as_C_string());

         fatal(ss.as_string());

       }

     }

   }

   spec->bind_variables_to_parameters();

   return spec;

 }

 ClassDescriptor* ClassDescriptor::placeholder(InstanceKlass* klass) {

   GrowableArray<TypeParameter*> formals;

   GrowableArray<ClassType*> interfaces;

   ClassType* super_type = NULL;

   Klass* super_klass = klass->super();

   if (super_klass != NULL) {

     InstanceKlass* super = InstanceKlass::cast(super_klass);

     super_type = ClassType::from_symbol(super->name());

   }

   for (int i = 0; i < klass->local_interfaces()->length(); ++i) {

     InstanceKlass* iface = InstanceKlass::cast(klass->local_interfaces()->at(i));

     interfaces.append(ClassType::from_symbol(iface->name()));

   }

   return new ClassDescriptor(formals, super_type, interfaces);

 }

 ClassDescriptor* ClassDescriptor::parse_generic_signature(Symbol* sym) {

   DescriptorStream ds(sym);

   DescriptorStream* STREAM = &ds;

   GrowableArray<TypeParameter*> parameters(8);

   char c = READ();

   if (c == '<') {

     c = READ();

     while (c != '>') {

       PUSH(c);

       TypeParameter* ftp = TypeParameter::parse_generic_signature(CHECK_STREAM);

       parameters.append(ftp);

       c = READ();

     }

   } else {

     PUSH(c);

   }

   EXPECT('L');

   ClassType* super = ClassType::parse_generic_signature(CHECK_STREAM);

   GrowableArray<ClassType*> signatures(2);

   while (!STREAM->at_end()) {

     EXPECT('L');

     ClassType* iface = ClassType::parse_generic_signature(CHECK_STREAM);

     signatures.append(iface);

   }

   EXPECT_END();

   return new ClassDescriptor(parameters, super, signatures);

 }

 #ifndef PRODUCT

 void ClassDescriptor::print_on(outputStream* str) const {

   str->indent().print_cr("ClassDescriptor {");

   {

     streamIndentor si(str);

     if (_type_parameters.length() > 0) {

       str->indent().print_cr("Formals {");

       {

         streamIndentor si(str);

         for (int i = 0; i < _type_parameters.length(); ++i) {

           _type_parameters.at(i)->print_on(str);

         }

       }

       str->indent().print_cr("}");

     }

     if (_super != NULL) {

       str->indent().print_cr("Superclass: ");

       {

         streamIndentor si(str);

         _super->print_on(str);

       }

     }

     if (_interfaces.length() > 0) {

       str->indent().print_cr("SuperInterfaces: {");

       {

         streamIndentor si(str);

         for (int i = 0; i < _interfaces.length(); ++i) {

           _interfaces.at(i)->print_on(str);

         }

       }

       str->indent().print_cr("}");

     }

     if (_outer_method != NULL) {

       str->indent().print_cr("Outer Method: {");

       {

         streamIndentor si(str);

         _outer_method->print_on(str);

       }

       str->indent().print_cr("}");

     }

     if (_outer_class != NULL) {

       str->indent().print_cr("Outer Class: {");

       {

         streamIndentor si(str);

         _outer_class->print_on(str);

       }

       str->indent().print_cr("}");

     }

   }

   str->indent().print_cr("}");

 }

 #endif // ndef PRODUCT

 ClassType* ClassDescriptor::interface_desc(Symbol* sym) {

   for (int i = 0; i < _interfaces.length(); ++i) {

     if (_interfaces.at(i)->identifier()->equals(sym)) {

       return _interfaces.at(i);

     }

   }

   if (VerifyGenericSignatures) {

     fatal("Did not find expected interface");

   }

   return NULL;

 }

 void ClassDescriptor::bind_variables_to_parameters() {

   if (_outer_class != NULL) {

     _outer_class->bind_variables_to_parameters();

   }

   if (_outer_method != NULL) {

     _outer_method->bind_variables_to_parameters();

   }

   for (int i = 0; i < _type_parameters.length(); ++i) {

     _type_parameters.at(i)->bind_variables_to_parameters(this, i);

   }

   if (_super != NULL) {

     _super->bind_variables_to_parameters(this);

   }

   for (int i = 0; i < _interfaces.length(); ++i) {

     _interfaces.at(i)->bind_variables_to_parameters(this);

   }

 }

 ClassDescriptor* ClassDescriptor::canonicalize(Context* ctx) {

   GrowableArray<TypeParameter*> type_params(_type_parameters.length());

   for (int i = 0; i < _type_parameters.length(); ++i) {

     type_params.append(_type_parameters.at(i)->canonicalize(ctx, 0));

   }

   ClassDescriptor* outer = _outer_class == NULL ? NULL :

       _outer_class->canonicalize(ctx);

   ClassType* super = _super == NULL ? NULL : _super->canonicalize(ctx, 0);

   GrowableArray<ClassType*> interfaces(_interfaces.length());

   for (int i = 0; i < _interfaces.length(); ++i) {

     interfaces.append(_interfaces.at(i)->canonicalize(ctx, 0));

   }

   MethodDescriptor* md = _outer_method == NULL ? NULL :

       _outer_method->canonicalize(ctx);

   return new ClassDescriptor(type_params, super, interfaces, outer, md);

 }

 u2 ClassDescriptor::get_outer_class_index(InstanceKlass* klass, TRAPS) {

   int inner_index = InstanceKlass::inner_class_inner_class_info_offset;

   int outer_index = InstanceKlass::inner_class_outer_class_info_offset;

   int name_offset = InstanceKlass::inner_class_inner_name_offset;

   int next_offset = InstanceKlass::inner_class_next_offset;

   if (klass->inner_classes() == NULL || klass->inner_classes()->length() == 0) {

     // No inner class info => no declaring class

     return 0;

   }

   Array<u2>* i_icls = klass->inner_classes();

   ConstantPool* i_cp = klass->constants();

   int i_length = i_icls->length();

   // Find inner_klass attribute

   for (int i = 0; i + next_offset < i_length; i += next_offset) {

     u2 ioff = i_icls->at(i + inner_index);

     u2 ooff = i_icls->at(i + outer_index);

     u2 noff = i_icls->at(i + name_offset);

     if (ioff != 0) {

       // Check to see if the name matches the class we're looking for

       // before attempting to find the class.

       if (i_cp->klass_name_at_matches(klass, ioff) && ooff != 0) {

         return ooff;

       }

     }

   }

   // It may be anonymous; try for that.

   u2 encl_method_class_idx = klass->enclosing_method_class_index();

   if (encl_method_class_idx != 0) {

     return encl_method_class_idx;

   }

   return 0;

 }

 MethodDescriptor* MethodDescriptor::parse_generic_signature(Method* m, ClassDescriptor* outer) {

   Symbol* generic_sig = m->generic_signature();

   MethodDescriptor* md = NULL;

   if (generic_sig == NULL || (md = parse_generic_signature(generic_sig, outer)) == NULL) {

     md = parse_generic_signature(m->signature(), outer);

   }

   assert(md != NULL, "Could not parse method signature");

   md->bind_variables_to_parameters();

   return md;

 }

 MethodDescriptor* MethodDescriptor::parse_generic_signature(Symbol* sym, ClassDescriptor* outer) {

   DescriptorStream ds(sym);

   DescriptorStream* STREAM = &ds;

   GrowableArray<TypeParameter*> params(8);

   char c = READ();

   if (c == '<') {

     c = READ();

     while (c != '>') {

       PUSH(c);

       TypeParameter* ftp = TypeParameter::parse_generic_signature(CHECK_STREAM);

       params.append(ftp);

       c = READ();

     }

   } else {

     PUSH(c);

   }

   EXPECT('(');

   GrowableArray<Type*> parameters(8);

   c = READ();

   while (c != ')') {

     PUSH(c);

     Type* arg = Type::parse_generic_signature(CHECK_STREAM);

     parameters.append(arg);

     c = READ();

   }

   Type* rt = Type::parse_generic_signature(CHECK_STREAM);

   GrowableArray<Type*> throws;

   while (!STREAM->at_end()) {

     EXPECT('^');

     Type* spec = Type::parse_generic_signature(CHECK_STREAM);

     throws.append(spec);

   }

   return new MethodDescriptor(params, outer, parameters, rt, throws);

 }

 void MethodDescriptor::bind_variables_to_parameters() {

   for (int i = 0; i < _type_parameters.length(); ++i) {

     _type_parameters.at(i)->bind_variables_to_parameters(this, i);

   }

   for (int i = 0; i < _parameters.length(); ++i) {

     _parameters.at(i)->bind_variables_to_parameters(this);

   }

   _return_type->bind_variables_to_parameters(this);

   for (int i = 0; i < _throws.length(); ++i) {

     _throws.at(i)->bind_variables_to_parameters(this);

   }

 }

 bool MethodDescriptor::covariant_match(MethodDescriptor* other, Context* ctx) {

   if (_parameters.length() == other->_parameters.length()) {

     for (int i = 0; i < _parameters.length(); ++i) {

       if (!_parameters.at(i)->covariant_match(other->_parameters.at(i), ctx)) {

         return false;

       }

     }

     if (_return_type->as_primitive() != NULL) {

       return _return_type->covariant_match(other->_return_type, ctx);

     } else {

       // return type is a reference

       return other->_return_type->as_class() != NULL ||

              other->_return_type->as_variable() != NULL ||

              other->_return_type->as_array() != NULL;

     }

   } else {

     return false;

   }

 }

 MethodDescriptor* MethodDescriptor::canonicalize(Context* ctx) {

   GrowableArray<TypeParameter*> type_params(_type_parameters.length());

   for (int i = 0; i < _type_parameters.length(); ++i) {

     type_params.append(_type_parameters.at(i)->canonicalize(ctx, 0));

   }

   ClassDescriptor* outer = _outer_class == NULL ? NULL :

       _outer_class->canonicalize(ctx);

   GrowableArray<Type*> params(_parameters.length());

   for (int i = 0; i < _parameters.length(); ++i) {

     params.append(_parameters.at(i)->canonicalize(ctx, 0));

   }

   Type* rt = _return_type->canonicalize(ctx, 0);

   GrowableArray<Type*> throws(_throws.length());

   for (int i = 0; i < _throws.length(); ++i) {

     throws.append(_throws.at(i)->canonicalize(ctx, 0));

   }

   return new MethodDescriptor(type_params, outer, params, rt, throws);

 }

 #ifndef PRODUCT

 TempNewSymbol MethodDescriptor::reify_signature(Context* ctx, TRAPS) {

   stringStream ss(256);

   ss.print("(");

   for (int i = 0; i < _parameters.length(); ++i) {

     _parameters.at(i)->reify_signature(&ss, ctx);

   }

   ss.print(")");

   _return_type->reify_signature(&ss, ctx);

   return SymbolTable::new_symbol(ss.base(), (int)ss.size(), THREAD);

 }

 void MethodDescriptor::print_on(outputStream* str) const {

   str->indent().print_cr("MethodDescriptor {");

   {

     streamIndentor si(str);

     if (_type_parameters.length() > 0) {

       str->indent().print_cr("Formals: {");

       {

         streamIndentor si(str);

         for (int i = 0; i < _type_parameters.length(); ++i) {

           _type_parameters.at(i)->print_on(str);

         }

       }

       str->indent().print_cr("}");

     }

     str->indent().print_cr("Parameters: {");

     {

       streamIndentor si(str);

       for (int i = 0; i < _parameters.length(); ++i) {

         _parameters.at(i)->print_on(str);

       }

     }

     str->indent().print_cr("}");

     str->indent().print_cr("Return Type: ");

     {

       streamIndentor si(str);

       _return_type->print_on(str);

     }

     if (_throws.length() > 0) {

       str->indent().print_cr("Throws: {");

       {

         streamIndentor si(str);

         for (int i = 0; i < _throws.length(); ++i) {

           _throws.at(i)->print_on(str);

         }

       }

       str->indent().print_cr("}");

     }

   }

   str->indent().print_cr("}");

 }

 #endif // ndef PRODUCT

 TypeParameter* TypeParameter::parse_generic_signature(DescriptorStream* STREAM) {

   STREAM->set_mark();

   char c = READ();

   while (c != ':') {

     c = READ();

   }

   Identifier* id = STREAM->identifier_from_mark();

   ClassType* class_bound = NULL;

   GrowableArray<ClassType*> interface_bounds(8);

   c = READ();

   if (c != '>') {

     if (c != ':') {

       EXPECTED(c, 'L');

       class_bound = ClassType::parse_generic_signature(CHECK_STREAM);

       c = READ();

     }

     while (c == ':') {

       EXPECT('L');

       ClassType* fts = ClassType::parse_generic_signature(CHECK_STREAM);

       interface_bounds.append(fts);

       c = READ();

     }

   }

   PUSH(c);

   return new TypeParameter(id, class_bound, interface_bounds);

 }

 void TypeParameter::bind_variables_to_parameters(Descriptor* sig, int position) {

   if (_class_bound != NULL) {

     _class_bound->bind_variables_to_parameters(sig);

   }

   for (int i = 0; i < _interface_bounds.length(); ++i) {

     _interface_bounds.at(i)->bind_variables_to_parameters(sig);

   }

   _position = position;

 }

 Type* TypeParameter::resolve(

     Context* ctx, int inner_depth, int ctx_depth) {

   if (inner_depth == -1) {

     // This indicates that the parameter is a method type parameter, which

     // isn't resolveable using the class hierarchy context

     return bound();

   }

   ClassType* provider = ctx->at_depth(ctx_depth);

   if (provider != NULL) {

     for (int i = 0; i < inner_depth && provider != NULL; ++i) {

       provider = provider->outer_class();

     }

     if (provider != NULL) {

       TypeArgument* arg = provider->type_argument_at(_position);

       if (arg != NULL) {

         Type* value = arg->lower_bound();

         return value->canonicalize(ctx, ctx_depth + 1);

       }

     }

   }

   return bound();

 }

 TypeParameter* TypeParameter::canonicalize(Context* ctx, int ctx_depth) {

   ClassType* bound = _class_bound == NULL ? NULL :

      _class_bound->canonicalize(ctx, ctx_depth);

   GrowableArray<ClassType*> ifaces(_interface_bounds.length());

   for (int i = 0; i < _interface_bounds.length(); ++i) {

     ifaces.append(_interface_bounds.at(i)->canonicalize(ctx, ctx_depth));

   }

   TypeParameter* ret = new TypeParameter(_identifier, bound, ifaces);

   ret->_position = _position;

   return ret;

 }

 ClassType* TypeParameter::bound() {

   if (_class_bound != NULL) {

     return _class_bound;

   }

   if (_interface_bounds.length() == 1) {

     return _interface_bounds.at(0);

   }

   return ClassType::java_lang_Object(); // TODO: investigate this case

 }

 #ifndef PRODUCT

 void TypeParameter::print_on(outputStream* str) const {

   str->indent().print_cr("Formal: {");

   {

     streamIndentor si(str);

     str->indent().print("Identifier: ");

     _identifier->print_on(str);

     str->print_cr("");

     if (_class_bound != NULL) {

       str->indent().print_cr("Class Bound: ");

       streamIndentor si(str);

       _class_bound->print_on(str);

     }

     if (_interface_bounds.length() > 0) {

       str->indent().print_cr("Interface Bounds: {");

       {

         streamIndentor si(str);

         for (int i = 0; i < _interface_bounds.length(); ++i) {

           _interface_bounds.at(i)->print_on(str);

         }

       }

       str->indent().print_cr("}");

     }

     str->indent().print_cr("Ordinal Position: %d", _position);

   }

   str->indent().print_cr("}");

 }

 #endif // ndef PRODUCT

 Type* Type::parse_generic_signature(DescriptorStream* STREAM) {

   char c = READ();

   switch (c) {

     case 'L':

       return ClassType::parse_generic_signature(CHECK_STREAM);

     case 'T':

       return TypeVariable::parse_generic_signature(CHECK_STREAM);

     case '[':

       return ArrayType::parse_generic_signature(CHECK_STREAM);

     default:

       return new PrimitiveType(c);

   }

 }

 Identifier* ClassType::parse_generic_signature_simple(GrowableArray<TypeArgument*>* args,

     bool* has_inner, DescriptorStream* STREAM) {

   STREAM->set_mark();

   char c = READ();

   while (c != ';' && c != '.' && c != '<') { c = READ(); }

   Identifier* id = STREAM->identifier_from_mark();

   if (c == '<') {

     c = READ();

     while (c != '>') {

       PUSH(c);

       TypeArgument* arg = TypeArgument::parse_generic_signature(CHECK_STREAM);

       args->append(arg);

       c = READ();

     }

     c = READ();

   }

   *has_inner = (c == '.');

   if (!(*has_inner)) {

     EXPECTED(c, ';');

   }

   return id;

 }

 ClassType* ClassType::parse_generic_signature(DescriptorStream* STREAM) {

   return parse_generic_signature(NULL, CHECK_STREAM);

 }

 ClassType* ClassType::parse_generic_signature(ClassType* outer, DescriptorStream* STREAM) {

   GrowableArray<TypeArgument*> args;

   ClassType* gct = NULL;

   bool has_inner = false;

   Identifier* id = parse_generic_signature_simple(&args, &has_inner, STREAM);

   if (id != NULL) {

     gct = new ClassType(id, args, outer);

     if (has_inner) {

       gct = parse_generic_signature(gct, CHECK_STREAM);

     }

   }

   return gct;

 }

 ClassType* ClassType::from_symbol(Symbol* sym) {

   assert(sym != NULL, "Must not be null");

   GrowableArray<TypeArgument*> args;

   Identifier* id = new Identifier(sym, 0, sym->utf8_length());

   return new ClassType(id, args, NULL);

 }

 ClassType* ClassType::java_lang_Object() {

   return from_symbol(vmSymbols::java_lang_Object());

 }

 void ClassType::bind_variables_to_parameters(Descriptor* sig) {

   for (int i = 0; i < _type_arguments.length(); ++i) {

     _type_arguments.at(i)->bind_variables_to_parameters(sig);

   }

   if (_outer_class != NULL) {

     _outer_class->bind_variables_to_parameters(sig);

   }

 }

 TypeArgument* ClassType::type_argument_at(int i) {

   if (i >= 0 && i < _type_arguments.length()) {

     return _type_arguments.at(i);

   } else {

     return NULL;

   }

 }

 #ifndef PRODUCT

 void ClassType::reify_signature(stringStream* ss, Context* ctx) {

   ss->print("L");

   _identifier->print_on(ss);

   ss->print(";");

 }

 void ClassType::print_on(outputStream* str) const {

   str->indent().print_cr("Class {");

   {

     streamIndentor si(str);

     str->indent().print("Name: ");

     _identifier->print_on(str);

     str->print_cr("");

     if (_type_arguments.length() != 0) {

       str->indent().print_cr("Type Arguments: {");

       {

         streamIndentor si(str);

         for (int j = 0; j < _type_arguments.length(); ++j) {

           _type_arguments.at(j)->print_on(str);

         }

       }

       str->indent().print_cr("}");

     }

     if (_outer_class != NULL) {

       str->indent().print_cr("Outer Class: ");

       streamIndentor sir(str);

       _outer_class->print_on(str);

     }

   }

   str->indent().print_cr("}");

 }

 #endif // ndef PRODUCT

 bool ClassType::covariant_match(Type* other, Context* ctx) {

   if (other == this) {

     return true;

   }

   TypeVariable* variable = other->as_variable();

   if (variable != NULL) {

     other = variable->resolve(ctx, 0);

   }

   ClassType* outer = outer_class();

   ClassType* other_class = other->as_class();

   if (other_class == NULL ||

       (outer == NULL) != (other_class->outer_class() == NULL)) {

     return false;

   }

   if (!_identifier->equals(other_class->_identifier)) {

     return false;

   }

   if (outer != NULL && !outer->covariant_match(other_class->outer_class(), ctx)) {

     return false;

   }

   return true;

 }

 ClassType* ClassType::canonicalize(Context* ctx, int ctx_depth) {

   GrowableArray<TypeArgument*> args(_type_arguments.length());

   for (int i = 0; i < _type_arguments.length(); ++i) {

     args.append(_type_arguments.at(i)->canonicalize(ctx, ctx_depth));

   }

   ClassType* outer = _outer_class == NULL ? NULL :

       _outer_class->canonicalize(ctx, ctx_depth);

   return new ClassType(_identifier, args, outer);

 }

 TypeVariable* TypeVariable::parse_generic_signature(DescriptorStream* STREAM) {

   STREAM->set_mark();

   char c = READ();

   while (c != ';') {

     c = READ();

   }

   Identifier* id = STREAM->identifier_from_mark();

   return new TypeVariable(id);

 }

 void TypeVariable::bind_variables_to_parameters(Descriptor* sig) {

   _parameter = sig->find_type_parameter(_id, &_inner_depth);

   if (VerifyGenericSignatures && _parameter == NULL) {

     fatal("Could not find formal parameter");

   }

 }

 Type* TypeVariable::resolve(Context* ctx, int ctx_depth) {

   if (parameter() != NULL) {

     return parameter()->resolve(ctx, inner_depth(), ctx_depth);

   } else {

     if (VerifyGenericSignatures) {

       fatal("Type variable matches no parameter");

     }

     return NULL;

   }

 }

 bool TypeVariable::covariant_match(Type* other, Context* ctx) {

   if (other == this) {

     return true;

   }

   Context my_context(NULL); // empty, results in erasure

   Type* my_type = resolve(&my_context, 0);

   if (my_type == NULL) {

     return false;

   }

   return my_type->covariant_match(other, ctx);

 }

 Type* TypeVariable::canonicalize(Context* ctx, int ctx_depth) {

   return resolve(ctx, ctx_depth);

 }

 #ifndef PRODUCT

 void TypeVariable::reify_signature(stringStream* ss, Context* ctx) {

   Type* type = resolve(ctx, 0);

   if (type != NULL) {

     type->reify_signature(ss, ctx);

   }

 }

 void TypeVariable::print_on(outputStream* str) const {

   str->indent().print_cr("Type Variable {");

   {

     streamIndentor si(str);

     str->indent().print("Name: ");

     _id->print_on(str);

     str->print_cr("");

     str->indent().print_cr("Inner depth: %d", _inner_depth);

   }

   str->indent().print_cr("}");

 }

 #endif // ndef PRODUCT

 ArrayType* ArrayType::parse_generic_signature(DescriptorStream* STREAM) {

   Type* base = Type::parse_generic_signature(CHECK_STREAM);

   return new ArrayType(base);

 }

 void ArrayType::bind_variables_to_parameters(Descriptor* sig) {

   assert(_base != NULL, "Invalid base");

   _base->bind_variables_to_parameters(sig);

 }

 bool ArrayType::covariant_match(Type* other, Context* ctx) {

   assert(_base != NULL, "Invalid base");

   if (other == this) {

     return true;

   }

   ArrayType* other_array = other->as_array();

   return (other_array != NULL && _base->covariant_match(other_array->_base, ctx));

 }

 ArrayType* ArrayType::canonicalize(Context* ctx, int ctx_depth) {

   assert(_base != NULL, "Invalid base");

   return new ArrayType(_base->canonicalize(ctx, ctx_depth));

 }

 #ifndef PRODUCT

 void ArrayType::reify_signature(stringStream* ss, Context* ctx) {

   assert(_base != NULL, "Invalid base");

   ss->print("[");

   _base->reify_signature(ss, ctx);

 }

 void ArrayType::print_on(outputStream* str) const {

   str->indent().print_cr("Array {");

   {

     streamIndentor si(str);

     _base->print_on(str);

   }

   str->indent().print_cr("}");

 }

 #endif // ndef PRODUCT

 bool PrimitiveType::covariant_match(Type* other, Context* ctx) {

   PrimitiveType* other_prim = other->as_primitive();

   return (other_prim != NULL && _type == other_prim->_type);

 }

 PrimitiveType* PrimitiveType::canonicalize(Context* ctx, int ctxd) {

   return this;

 }

 #ifndef PRODUCT

 void PrimitiveType::reify_signature(stringStream* ss, Context* ctx) {

   ss->print("%c", _type);

 }

 void PrimitiveType::print_on(outputStream* str) const {

   str->indent().print_cr("Primitive: '%c'", _type);

 }

 #endif // ndef PRODUCT

 void PrimitiveType::bind_variables_to_parameters(Descriptor* sig) {

 }

 TypeArgument* TypeArgument::parse_generic_signature(DescriptorStream* STREAM) {

   char c = READ();

   Type* type = NULL;

   switch (c) {

     case '*':

       return new TypeArgument(ClassType::java_lang_Object(), NULL);

       break;

     default:

       PUSH(c);

       // fall-through

     case '+':

     case '-':

       type = Type::parse_generic_signature(CHECK_STREAM);

       if (c == '+') {

         return new TypeArgument(type, NULL);

       } else if (c == '-') {

         return new TypeArgument(ClassType::java_lang_Object(), type);

       } else {

         return new TypeArgument(type, type);

       }

   }

 }

 void TypeArgument::bind_variables_to_parameters(Descriptor* sig) {

   assert(_lower_bound != NULL, "Invalid lower bound");

   _lower_bound->bind_variables_to_parameters(sig);

   if (_upper_bound != NULL && _upper_bound != _lower_bound) {

     _upper_bound->bind_variables_to_parameters(sig);

   }

 }

 bool TypeArgument::covariant_match(TypeArgument* other, Context* ctx) {

   assert(_lower_bound != NULL, "Invalid lower bound");

   if (other == this) {

     return true;

   }

   if (!_lower_bound->covariant_match(other->lower_bound(), ctx)) {

     return false;

   }

   return true;

 }

 TypeArgument* TypeArgument::canonicalize(Context* ctx, int ctx_depth) {

   assert(_lower_bound != NULL, "Invalid lower bound");

   Type* lower = _lower_bound->canonicalize(ctx, ctx_depth);

   Type* upper = NULL;

   if (_upper_bound == _lower_bound) {

     upper = lower;

   } else if (_upper_bound != NULL) {

     upper = _upper_bound->canonicalize(ctx, ctx_depth);

   }

   return new TypeArgument(lower, upper);

 }

 #ifndef PRODUCT

 void TypeArgument::print_on(outputStream* str) const {

   str->indent().print_cr("TypeArgument {");

   {

     streamIndentor si(str);

     if (_lower_bound != NULL) {

       str->indent().print("Lower bound: ");

       _lower_bound->print_on(str);

     }

     if (_upper_bound != NULL) {

       str->indent().print("Upper bound: ");

       _upper_bound->print_on(str);

     }

   }

   str->indent().print_cr("}");

 }

 #endif // ndef PRODUCT

 void Context::Mark::destroy() {

   if (is_active()) {

     _context->reset_to_mark(_marked_size);

   }

   deactivate();

 }

 void Context::apply_type_arguments(

     InstanceKlass* current, InstanceKlass* super, TRAPS) {

   assert(_cache != NULL, "Cannot use an empty context");

   ClassType* spec = NULL;

   if (current != NULL) {

     ClassDescriptor* descriptor = _cache->descriptor_for(current, CHECK);

     if (super == current->super()) {

       spec = descriptor->super();

     } else {

       spec = descriptor->interface_desc(super->name());

     }

     if (spec != NULL) {

       _type_arguments.push(spec);

     }

   }

 }

 void Context::reset_to_mark(int size) {

   _type_arguments.trunc_to(size);

 }

 ClassType* Context::at_depth(int i) const {

   if (i < _type_arguments.length()) {

     return _type_arguments.at(_type_arguments.length() - 1 - i);

   }

   return NULL;

 }

 #ifndef PRODUCT

 void Context::print_on(outputStream* str) const {

   str->indent().print_cr("Context {");

   for (int i = 0; i < _type_arguments.length(); ++i) {

     streamIndentor si(str);

     str->indent().print("leval %d: ", i);

     ClassType* ct = at_depth(i);

     if (ct == NULL) {

       str->print_cr("<empty>");

       continue;

     } else {

       str->print_cr("{");

     }

     for (int j = 0; j < ct->type_arguments_length(); ++j) {

       streamIndentor si(str);

       TypeArgument* ta = ct->type_argument_at(j);

       Type* bound = ta->lower_bound();

       bound->print_on(str);

     }

     str->indent().print_cr("}");

   }

   str->indent().print_cr("}");

 }

 #endif // ndef PRODUCT

 ClassDescriptor* DescriptorCache::descriptor_for(InstanceKlass* ik, TRAPS) {

   ClassDescriptor** existing = _class_descriptors.get(ik);

   if (existing == NULL) {

     ClassDescriptor* cd = ClassDescriptor::parse_generic_signature(ik, CHECK_NULL);

     _class_descriptors.put(ik, cd);

     return cd;

   } else {

     return *existing;

   }

 }

 MethodDescriptor* DescriptorCache::descriptor_for(

     Method* mh, ClassDescriptor* cd, TRAPS) {

   assert(mh != NULL && cd != NULL, "Should not be NULL");

   MethodDescriptor** existing = _method_descriptors.get(mh);

   if (existing == NULL) {

     MethodDescriptor* md = MethodDescriptor::parse_generic_signature(mh, cd);

     _method_descriptors.put(mh, md);

     return md;

   } else {

     return *existing;

   }

 }

 MethodDescriptor* DescriptorCache::descriptor_for(Method* mh, TRAPS) {

   ClassDescriptor* cd = descriptor_for(

       InstanceKlass::cast(mh->method_holder()), CHECK_NULL);

   return descriptor_for(mh, cd, THREAD);

 }

 } // namespace generic