| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| /** |
| * @author Pavel Pervov |
| */ |
| |
| // |
| // exceptions that can be thrown during class resolution: |
| // |
| // (0) LinkageError exceptions during loading and linking |
| // (1) ExceptionInInitializerError: class initializer completes |
| // abruptly by throwing an exception |
| // (2) IllegalAccessError: current class or interface does not have |
| // permission to access the class or interface being resolved. |
| // |
| // class resolution can occur indirectly via resolution of other |
| // constant pool entries (Fieldref, Methodref, InterfaceMethodref), |
| // or directly by the following byte codes: |
| // |
| // (0) anewarray (pg 162) |
| // (1) checkcast (pg 174) |
| // (2) instanceof (pg 256) |
| // (3) multianewarray (pg 316) |
| // - also throws the linking exception, IllegalAccessError, if |
| // the current class does have permission to access the *base* |
| // class of the resolved array class. |
| // (4) new (pg 318) |
| // - also throws the linking exception, InstantiationError, if |
| // the resolved class is an abstract class or an interface. |
| // |
| // resolution of constants occurs directly by the following byte codes: |
| // (0) ldc (pg 291) |
| // (1) ldc_w (pg 292) |
| // (2) ldc2_w (pg 294) |
| // |
| // of these ldc byte codes, only the ldc and ldc_w can cause exceptions |
| // and only when they refer to CONSTANT_String entries. The only exception |
| // possible seems to be the VirtualMachineError exception that happens |
| // when the VM runs out of internal resources. |
| // |
| // exceptions that can be thrown during field and method resolution: |
| // |
| // (0) any of the exceptions for resolving classes |
| // (1) NoSuchFieldError: referenced field does not exist in specified |
| // class or interface. |
| // (2) IllegalAccessError: the current class does not have permission |
| // to access the referenced field. |
| // |
| // During resolution of methods that are declared as native, if the code |
| // for the native method cannot be found, then the VM throws an |
| // UnsatisfiedLinkError. Note, that this causes a problem because the |
| // code for native methods are usually loaded in by the static initializer |
| // code of a class. Therefore, this condition can only be checked at |
| // run-time, when the native method is first called. |
| // |
| // In addition, the byte codes that refer to the constant pool entries |
| // can throw the following exceptions: |
| // |
| // (0) IncompatibleClassChangeError: thrown by getfield and putfield |
| // if the field reference is resolved to a static field. |
| // (1) IncompatibleClassChangeError: thrown by getstatic and putstatic |
| // if the field reference is resolved to a non-static field. |
| // (2) IncompatibleClassChangeError: thrown by invokespecial, |
| // invokeinterface and invokevirtual if the method reference is |
| // resolved to a static method. |
| // (3) AbstractMethodError: thrown by invokespecial, invokeinterface |
| // and invokevirtual if the method reference is resolved to an |
| // abstract method. |
| // (4) IncompatibleClassChangeError: thrown by invokestatic if the |
| // method reference is resolved to a non-static method. |
| // |
| // Invokeinterface throws an IncompatibleClassChangeError if no method |
| // matching the resolved name and description can be found in the class |
| // of the object that is being invoked, or if the method being invoked is |
| // a class (static) method. |
| // |
| |
| #define LOG_DOMAIN LOG_CLASS_INFO |
| #include "cxxlog.h" |
| |
| #include "Class.h" |
| #include "classloader.h" |
| #include "environment.h" |
| #include "compile.h" |
| #include "exceptions.h" |
| #include "interpreter.h" |
| |
| #include "open/bytecodes.h" |
| #include "open/vm_class_manipulation.h" |
| #include "open/vm_ee.h" |
| |
| |
| static void class_report_failure(Class* target, uint16 cp_index, jthrowable exn) |
| { |
| ConstantPool& cp = target->get_constant_pool(); |
| assert(cp.is_valid_index(cp_index)); |
| assert(hythread_is_suspend_enabled()); |
| assert(exn); |
| |
| tmn_suspend_disable(); |
| target->lock(); |
| if (!cp.is_entry_in_error(cp_index)) { |
| // vvv - This should be atomic change |
| cp.resolve_as_error(cp_index, exn); |
| // ^^^ |
| } |
| target->unlock(); |
| tmn_suspend_enable(); |
| } |
| |
| |
| static void class_report_failure(Class* target, uint16 cp_index, |
| const char* exnname, std::stringstream& exnmsg) |
| { |
| TRACE2("resolve.testing", "class_report_failure: " << exnmsg.str().c_str()); |
| jthrowable exn = exn_create(exnname, exnmsg.str().c_str()); |
| // ppervov: FIXME: should throw OOME |
| class_report_failure(target, cp_index, exn); |
| } |
| |
| |
| #define CLASS_REPORT_FAILURE(target, cp_index, exnclass, exnmsg) \ |
| { \ |
| std::stringstream ss; \ |
| ss << exnmsg; \ |
| class_report_failure(target, cp_index, exnclass, ss); \ |
| } |
| |
| |
| Class* Class::_resolve_class(Global_Env* env, |
| unsigned cp_index) |
| { |
| assert(hythread_is_suspend_enabled()); |
| ConstantPool& cp = m_const_pool; |
| |
| lock(); |
| if(cp.is_entry_in_error(cp_index)) { |
| TRACE2("resolve.testing", "Constant pool entry " << cp_index << " already contains error."); |
| unlock(); |
| return NULL; |
| } |
| |
| if(cp.is_entry_resolved(cp_index)) { |
| unlock(); |
| return cp.get_class_class(cp_index); |
| } |
| |
| const String* classname = cp.get_utf8_string(cp.get_class_name_index(cp_index)); |
| unlock(); |
| |
| // load the class in |
| Class* other_clss = m_class_loader->LoadVerifyAndPrepareClass(env, classname); |
| if(other_clss == NULL) |
| { |
| // FIXMECL should find out if this is VirtualMachineError |
| assert(exn_raised()); |
| class_report_failure(this, cp_index, exn_get()); |
| exn_clear(); |
| return NULL; |
| } |
| |
| // Check access control: |
| // referenced class should be public, |
| // or referenced class & declaring class are the same, |
| // or referenced class & declaring class are in the same runtime package, |
| // or declaring class not checked |
| // (the last case is needed for certain magic classes, |
| // eg, reflection implementation) |
| if(m_can_access_all |
| || other_clss->is_public() |
| || other_clss == this |
| || m_package == other_clss->m_package) |
| { |
| lock(); |
| cp.resolve_entry(cp_index, other_clss); |
| unlock(); |
| return other_clss; |
| } |
| |
| // Check access control for inner classes: |
| // access control checks is the same as for members |
| if(strrchr(other_clss->get_name()->bytes, '$') != NULL |
| && can_access_inner_class(env, other_clss)) |
| { |
| lock(); |
| cp.resolve_entry(cp_index, other_clss); |
| unlock(); |
| return other_clss; |
| } |
| |
| CLASS_REPORT_FAILURE(this, cp_index, "java/lang/IllegalAccessError", |
| "from " << get_name()->bytes << " to " << other_clss->get_name()->bytes); |
| // IllegalAccessError |
| return NULL; |
| } // Class::_resolve_class |
| |
| |
| static bool class_can_instantiate(Class* clss, bool _throw) |
| { |
| ASSERT_RAISE_AREA; |
| bool fail = clss->is_abstract(); |
| if(fail && _throw) { |
| exn_raise_by_name("java/lang/InstantiationError", clss->get_name()->bytes); |
| } |
| return !fail; |
| } |
| |
| |
| Class* resolve_class_new_env(Global_Env* env, Class* clss, |
| unsigned cp_index, bool raise_exn) |
| { |
| ASSERT_RAISE_AREA; |
| |
| Class* new_clss = clss->_resolve_class(env, cp_index); |
| if (!new_clss) return NULL; |
| bool can_instantiate = class_can_instantiate(new_clss, false); |
| |
| if(new_clss && !can_instantiate) { |
| return NULL; |
| } |
| return new_clss; |
| } // _resolve_class_new |
| |
| // Can "other_clss" access the field or method "member"? |
| bool Class::can_access_member(Class_Member *member) |
| { |
| Class* member_clss = member->get_class(); |
| // check access permissions |
| if(member->is_public() || (this == member_clss)) { |
| // no problemo |
| return true; |
| } else if(member->is_private()) { |
| // IllegalAccessError |
| return false; |
| } else if(member->is_protected()) { |
| // When a member is protected, it can be accessed by classes |
| // in the same runtime package |
| if(m_package == member_clss->m_package) |
| return true; |
| // Otherwise, when this class is not in the same package, |
| // the class containing the member (member_clss) must be |
| // a superclass of this class |
| // ppervov: FIXME: this can be made a method of struct Class |
| // smth. like: |
| //if(!is_extending_class(member_clss)) { |
| // // IllegalAccessError |
| // return false; |
| //} |
| //return true; |
| Class* c; |
| for(c = get_super_class(); c != NULL; c = c->get_super_class()) { |
| if(c == member_clss) |
| break; |
| } |
| if(c == NULL) { |
| // IllegalAccessError |
| return false; |
| } |
| return true; |
| } else { |
| // When a member has default (or package private) access, |
| // it can only be accessed by classes in the same package |
| if(m_package == member_clss->m_package) |
| return true; |
| return false; |
| } |
| } // Class::can_access_member |
| |
| inline static bool |
| is_class_extended_class( Class *super_clss, |
| Class *check_clss) |
| { |
| for(; super_clss != NULL; super_clss = super_clss->get_super_class()) |
| { |
| if( super_clss->get_class_loader() == check_clss->get_class_loader() |
| && super_clss->get_name() == check_clss->get_name() ) |
| { |
| return true; |
| } |
| } |
| return false; |
| } // is_class_extended_class |
| |
| inline static Class* |
| get_enclosing_class( Global_Env *env, |
| Class *klass ) |
| { |
| Class *encl_clss = NULL; |
| |
| if( strrchr( klass->get_name()->bytes, '$') != NULL ) |
| { // it is anonymous class |
| // search "this$..." in fields and look for enclosing class |
| unsigned index; |
| Field *field; |
| for( index = 0, field = klass->get_field(index); |
| index < klass->get_number_of_fields(); |
| index++, field = klass->get_field(index) ) |
| { |
| if( strncmp( field->get_name()->bytes, "this$", 5 ) |
| || !(field->get_access_flags() & ACC_FINAL) |
| || !field->is_synthetic() ) |
| { |
| continue; |
| } |
| // found self, get signature of enclosing class |
| const String* desc = field->get_descriptor(); |
| // get name of enclosing class |
| String* name = env->string_pool.lookup(&desc->bytes[1], desc->len - 2); |
| // loading enclosing class |
| encl_clss = klass->get_class_loader()->LoadVerifyAndPrepareClass(env, name); |
| break; |
| } |
| } |
| return encl_clss; |
| } // get_enclosing_class |
| |
| bool Class::can_access_inner_class(Global_Env* env, Class* inner_clss) |
| { |
| // check access permissions |
| if (inner_clss->is_public() || (this == inner_clss)) { |
| // no problemo |
| return true; |
| } else if (inner_clss->is_private()) { |
| // IllegalAccessError |
| return false; |
| } else if (inner_clss->is_protected()) { |
| // When inner class is protected, it can be accessed by classes |
| // in the same runtime package. |
| if(m_package == inner_clss->m_package) |
| return true; |
| |
| // array type has the same access as base type |
| if (inner_clss->is_array()) { |
| inner_clss = inner_clss->get_array_base_class(); |
| } |
| |
| // Otherwise, when other_clss is not in the same package, |
| // inner_clss must be a superclass of other_clss. |
| for(Class *decl_other_clss = this; decl_other_clss != NULL;) |
| { |
| for(Class *decl_inner_clss = inner_clss; decl_inner_clss != NULL;) |
| { |
| if(is_class_extended_class( decl_other_clss, decl_inner_clss ) ) { |
| return true; |
| } |
| if( !decl_inner_clss->is_inner_class() ) { |
| // class "decl_inner_clss" isn't inner class |
| break; |
| } else { |
| // loading declaring class |
| if(Class* decl_inner_clss_res = decl_inner_clss->resolve_declaring_class(env)) { |
| decl_inner_clss = decl_inner_clss_res; |
| } else { |
| break; |
| } |
| } |
| } |
| if( !decl_other_clss->is_inner_class() ) |
| { |
| // class "decl_other_clss" isn't inner class |
| decl_other_clss = get_enclosing_class(env, decl_other_clss); |
| continue; |
| } else { |
| // loading declaring class |
| if(Class* decl_other_clss_res = |
| decl_other_clss->resolve_declaring_class(env)) |
| { |
| decl_other_clss = decl_other_clss_res; |
| continue; |
| } |
| } |
| break; |
| } |
| // IllegalAccessError |
| return false; |
| } else { |
| // When a member has default (or package private) access, |
| // it can only be accessed by classes in the same runtime package. |
| if(m_package == inner_clss->m_package) |
| return true; |
| return false; |
| } |
| } // Class::can_access_inner_class |
| |
| |
| Field* Class::_resolve_field(Global_Env *env, unsigned cp_index) |
| { |
| lock(); |
| if(m_const_pool.is_entry_in_error(cp_index)) { |
| TRACE2("resolve.testing", "Constant pool entry " << cp_index << " already contains error."); |
| unlock(); |
| return NULL; |
| } |
| |
| if(m_const_pool.is_entry_resolved(cp_index)) { |
| unlock(); |
| return m_const_pool.get_ref_field(cp_index); |
| } |
| |
| // |
| // constant pool entry hasn't been resolved yet |
| // |
| unsigned other_index = m_const_pool.get_ref_class_index(cp_index); |
| unlock(); |
| |
| // |
| // check error condition from resolve class |
| // |
| Class* other_clss = _resolve_class(env, other_index); |
| if(!other_clss) { |
| if(m_const_pool.is_entry_in_error(other_index)) { |
| class_report_failure(this, cp_index, |
| m_const_pool.get_error_cause(other_index)); |
| } else { |
| assert(exn_raised()); |
| } |
| return NULL; |
| } |
| |
| uint16 name_and_type_index = m_const_pool.get_ref_name_and_type_index(cp_index); |
| String* name = m_const_pool.get_name_and_type_name(name_and_type_index); |
| String* desc = m_const_pool.get_name_and_type_descriptor(name_and_type_index); |
| Field* field = other_clss->lookup_field_recursive(name, desc); |
| if(field == NULL) |
| { |
| // |
| // NoSuchFieldError |
| // |
| CLASS_REPORT_FAILURE(this, cp_index, "java/lang/NoSuchFieldError", |
| other_clss->get_name()->bytes << "." << name->bytes |
| << " of type " << desc->bytes |
| << " while resolving constant pool entry at index " |
| << cp_index << " in class " << get_name()->bytes); |
| return NULL; |
| } |
| |
| // |
| // check access permissions |
| // |
| if(!can_access_member(field)) |
| { |
| // |
| // IllegalAccessError |
| // |
| CLASS_REPORT_FAILURE(this, cp_index, "java/lang/IllegalAccessError", |
| other_clss->get_name()->bytes << "." << name->bytes |
| << " of type " << desc->bytes |
| << " while resolving constant pool entry at index " |
| << cp_index << " in class " << get_name()->bytes); |
| return NULL; |
| } |
| lock(); |
| m_const_pool.resolve_entry(cp_index, field); |
| unlock(); |
| |
| return field; |
| } // Class::_resolve_field |
| |
| |
| bool field_can_link(Class* clss, Field* field, bool _static, bool putfield, bool _throw) |
| { |
| ASSERT_RAISE_AREA; |
| if(_static?(!field->is_static()):(field->is_static())) { |
| if(_throw) { |
| exn_raise_by_name("java/lang/IncompatibleClassChangeError", |
| field->get_class()->get_name()->bytes); |
| } |
| return false; |
| } |
| if(putfield && field->is_final()) { |
| for(int fn = 0; fn < clss->get_number_of_fields(); fn++) { |
| if(clss->get_field(fn) == field) { |
| return true; |
| } |
| } |
| if(_throw) { |
| unsigned buf_size = clss->get_name()->len + |
| field->get_class()->get_name()->len + |
| field->get_name()->len + 15; |
| char* buf = (char*)STD_ALLOCA(buf_size); |
| memset(buf, 0, buf_size); |
| sprintf(buf, " from %s to %s.%s", clss->get_name()->bytes, |
| field->get_class()->get_name()->bytes, |
| field->get_name()->bytes); |
| jthrowable exc_object = exn_create("java/lang/IllegalAccessError", buf); |
| exn_raise_object(exc_object); |
| } |
| return false; |
| } |
| return true; |
| } |
| |
| static bool CAN_LINK_FROM_STATIC = true; // can link from putstatic/getstatic |
| static bool CAN_LINK_FROM_FIELD = false; // can link from putfield/getfield |
| static bool LINK_WRITE_ACCESS = true; // link from putfield/putstatic |
| static bool LINK_READ_ACCESS = false; // link from getfield/getstatic |
| static bool LINK_THROW_ERRORS = true; // should throw linking exception on error |
| |
| Field* resolve_static_field_env(Global_Env *env, |
| Class *clss, |
| unsigned cp_index, |
| bool putfield, |
| bool is_runtume) |
| { |
| ASSERT_RAISE_AREA; |
| |
| Field *field = clss->_resolve_field(env, cp_index); |
| if(!field) { |
| assert(clss->get_constant_pool().is_entry_in_error(cp_index)); |
| if (is_runtume) { |
| exn_raise_object(clss->get_constant_pool().get_error_cause(cp_index)); |
| } |
| return NULL; |
| } |
| if(!field_can_link(clss, field, CAN_LINK_FROM_STATIC, putfield, is_runtume)) { |
| return NULL; |
| } |
| return field; |
| } |
| |
| |
| Field* resolve_nonstatic_field_env(Global_Env* env, |
| Class* clss, |
| unsigned cp_index, |
| unsigned putfield, |
| bool raise_exn) |
| { |
| ASSERT_RAISE_AREA; |
| |
| Field *field = clss->_resolve_field(env, cp_index); |
| if(!field) { |
| assert(clss->get_constant_pool().is_entry_in_error(cp_index)); |
| if (raise_exn) { |
| exn_raise_object(clss->get_constant_pool().get_error_cause(cp_index)); |
| } |
| return NULL; |
| } |
| if(!field_can_link(clss, field, CAN_LINK_FROM_FIELD, putfield, raise_exn)) { |
| return NULL; |
| } |
| return field; |
| } |
| |
| |
| |
| Method* Class::_resolve_method(Global_Env* env, unsigned cp_index) |
| { |
| lock(); |
| if(m_const_pool.is_entry_in_error(cp_index)) { |
| TRACE2("resolve.testing", "Constant pool entry " << cp_index << " already contains error."); |
| unlock(); |
| return NULL; |
| } |
| |
| if(m_const_pool.is_entry_resolved(cp_index)) { |
| unlock(); |
| return m_const_pool.get_ref_method(cp_index); |
| } |
| |
| // |
| // constant pool entry hasn't been resolved yet |
| // |
| unsigned other_index; |
| other_index = m_const_pool.get_ref_class_index(cp_index); |
| unlock(); |
| |
| // |
| // check error condition from resolve class |
| // |
| Class* other_clss = _resolve_class(env, other_index); |
| if(!other_clss) { |
| if(m_const_pool.is_entry_in_error(other_index)) { |
| class_report_failure(this, cp_index, |
| m_const_pool.get_error_cause(other_index)); |
| } else { |
| assert(exn_raised()); |
| } |
| return NULL; |
| } |
| |
| uint16 name_and_type_index = m_const_pool.get_ref_name_and_type_index(cp_index); |
| String* name = m_const_pool.get_name_and_type_name(name_and_type_index); |
| String* desc = m_const_pool.get_name_and_type_descriptor(name_and_type_index); |
| |
| // CONSTANT_Methodref must refer to a class, not an interface, and |
| // CONSTANT_InterfaceMethodref must refer to an interface (vm spec 4.4.2) |
| if(m_const_pool.is_methodref(cp_index) && other_clss->is_interface()) { |
| CLASS_REPORT_FAILURE(this, cp_index, "java/lang/IncompatibleClassChangeError", |
| other_clss->get_name()->bytes |
| << " while resolving constant pool entry " << cp_index |
| << " in class " << m_name->bytes); |
| return NULL; |
| } |
| |
| if(m_const_pool.is_interfacemethodref(cp_index) && !other_clss->is_interface()) { |
| CLASS_REPORT_FAILURE(this, cp_index, "java/lang/IncompatibleClassChangeError", |
| other_clss->get_name()->bytes |
| << " while resolving constant pool entry " << cp_index |
| << " in class " << m_name->bytes); |
| return NULL; |
| } |
| |
| Method* method = class_lookup_method_recursive(other_clss, name, desc); |
| if(method == NULL) { |
| // NoSuchMethodError |
| CLASS_REPORT_FAILURE(this, cp_index, "java/lang/NoSuchMethodError", |
| other_clss->get_name()->bytes << "." << name->bytes << desc->bytes |
| << " while resolving constant pool entry at index " << cp_index |
| << " in class " << m_name->bytes); |
| return NULL; |
| } |
| |
| if(method->is_abstract() && !other_clss->is_abstract()) { |
| // AbstractMethodError |
| CLASS_REPORT_FAILURE(this, cp_index, "java/lang/AbstractMethodError", |
| other_clss->get_name()->bytes << "." << name->bytes << desc->bytes |
| << " while resolving constant pool entry at index " << cp_index |
| << " in class " << m_name->bytes); |
| return NULL; |
| } |
| |
| // |
| // check access permissions |
| // |
| if(!can_access_member(method)) { |
| // IllegalAccessError |
| CLASS_REPORT_FAILURE(this, cp_index, "java/lang/IllegalAccessError", |
| other_clss->get_name()->bytes << "." << name->bytes << desc->bytes |
| << " while resolving constant pool entry at index " << cp_index |
| << " in class " << m_name->bytes); |
| return NULL; |
| } |
| |
| lock(); |
| m_const_pool.resolve_entry(cp_index, method); |
| unlock(); |
| |
| return method; |
| } //_resolve_method |
| |
| |
| static bool method_can_link_static(Class* clss, unsigned index, Method* method, bool _throw) { |
| ASSERT_RAISE_AREA; |
| |
| if (!method->is_static()) { |
| if(_throw) { |
| exn_raise_by_name("java/lang/IncompatibleClassChangeError", |
| method->get_class()->get_name()->bytes); |
| } |
| return false; |
| } |
| return true; |
| } |
| |
| Method* resolve_static_method_env(Global_Env *env, |
| Class *clss, |
| unsigned cp_index, |
| bool raise_exn) |
| { |
| ASSERT_RAISE_AREA; |
| |
| Method* method = clss->_resolve_method(env, cp_index); |
| if(!method) { |
| assert(clss->get_constant_pool().is_entry_in_error(cp_index)); |
| if (raise_exn) { |
| exn_raise_object(clss->get_constant_pool().get_error_cause(cp_index)); |
| } |
| return NULL; |
| } |
| |
| if (!method_can_link_static(clss, cp_index, method, raise_exn)) { |
| return NULL; |
| } |
| return method; |
| } |
| |
| |
| static bool method_can_link_virtual(Class* clss, unsigned cp_index, Method* method, bool _throw) |
| { |
| ASSERT_RAISE_AREA; |
| |
| if(method->is_static()) { |
| if(_throw) { |
| exn_raise_by_name("java/lang/IncompatibleClassChangeError", |
| method->get_class()->get_name()->bytes); |
| } |
| return false; |
| } |
| if(method->get_class()->is_interface()) { |
| if(_throw) { |
| char* buf = (char*)STD_ALLOCA(clss->get_name()->len |
| + method->get_name()->len + method->get_descriptor()->len + 2); |
| sprintf(buf, "%s.%s%s", clss->get_name()->bytes, |
| method->get_name()->bytes, method->get_descriptor()->bytes); |
| jthrowable exc_object = exn_create("java/lang/AbstractMethodError", buf); |
| exn_raise_object(exc_object); |
| } |
| return false; |
| } |
| return true; |
| } |
| |
| |
| Method* resolve_virtual_method_env(Global_Env *env, |
| Class *clss, |
| unsigned cp_index, |
| bool raise_exn) |
| { |
| Method* method = clss->_resolve_method(env, cp_index); |
| if(!method) { |
| assert(clss->get_constant_pool().is_entry_in_error(cp_index)); |
| if (raise_exn) { |
| exn_raise_object(clss->get_constant_pool().get_error_cause(cp_index)); |
| } |
| return NULL; |
| } |
| |
| if (!method_can_link_virtual(clss, cp_index, method, raise_exn)) { |
| return NULL; |
| } |
| return method; |
| } |
| |
| |
| static bool method_can_link_interface(Class* clss, unsigned cp_index, Method* method, bool _throw) { |
| return true; |
| } |
| |
| |
| Method* resolve_interface_method_env(Global_Env *env, |
| Class *clss, |
| unsigned cp_index, |
| bool raise_exn) |
| { |
| Method* method = clss->_resolve_method(env, cp_index); |
| if (!method) { |
| assert(clss->get_constant_pool().is_entry_in_error(cp_index)); |
| if (raise_exn) { |
| exn_raise_object(clss->get_constant_pool().get_error_cause(cp_index)); |
| } |
| return NULL; |
| } |
| if (!method_can_link_interface(clss, cp_index, method, raise_exn)) { |
| return NULL; |
| } |
| return method; |
| } |
| |
| |
| // |
| // resolve constant pool reference to a non-static field |
| // used for getfield and putfield |
| // |
| Field_Handle resolve_nonstatic_field(Compile_Handle h, |
| Class_Handle c, |
| unsigned index, |
| unsigned putfield) |
| { |
| return resolve_nonstatic_field_env(compile_handle_to_environment(h), c, index, putfield, false); |
| } //resolve_nonstatic_field |
| |
| |
| // |
| // resolve constant pool reference to a static field |
| // used for getstatic and putstatic |
| // |
| Field_Handle resolve_static_field(Compile_Handle h, |
| Class_Handle c, |
| unsigned index, |
| unsigned putfield) |
| { |
| return resolve_static_field_env(compile_handle_to_environment(h), c, index, putfield, false); |
| } //resolve_static_field |
| |
| |
| Method_Handle resolve_method(Compile_Handle h, Class_Handle ch, unsigned idx) |
| { |
| return ch->_resolve_method(compile_handle_to_environment(h), idx); |
| } |
| |
| |
| // |
| // resolve constant pool reference to a virtual method |
| // used for invokevirtual |
| // |
| Method_Handle resolve_virtual_method(Compile_Handle h, |
| Class_Handle c, |
| unsigned index) |
| { |
| return resolve_virtual_method_env(compile_handle_to_environment(h), c, index, false); |
| } //resolve_virtual_method |
| |
| |
| static bool method_can_link_special(Class* clss, unsigned index, Method* method, bool _throw) |
| { |
| ASSERT_RAISE_AREA; |
| |
| ConstantPool& cp = clss->get_constant_pool(); |
| unsigned class_idx = cp.get_ref_class_index(index); |
| unsigned class_name_idx = cp.get_class_name_index(class_idx); |
| String* ref_class_name = cp.get_utf8_string(class_name_idx); |
| |
| if(method->get_name() == VM_Global_State::loader_env->Init_String |
| && method->get_class()->get_name() != ref_class_name) |
| { |
| if(_throw) { |
| exn_raise_by_name("java/lang/NoSuchMethodError", |
| method->get_name()->bytes); |
| } |
| return false; |
| } |
| if(method->is_static()) |
| { |
| if(_throw) { |
| exn_raise_by_name("java/lang/IncompatibleClassChangeError", |
| method->get_class()->get_name()->bytes); |
| } |
| return false; |
| } |
| if(method->is_abstract()) |
| { |
| if(_throw) { |
| tmn_suspend_enable(); |
| unsigned buf_size = clss->get_name()->len + |
| method->get_name()->len + method->get_descriptor()->len + 5; |
| char* buf = (char*)STD_ALLOCA(buf_size); |
| memset(buf, 0, buf_size); |
| sprintf(buf, "%s.%s%s", clss->get_name()->bytes, |
| method->get_name()->bytes, method->get_descriptor()->bytes); |
| jthrowable exc_object = exn_create("java/lang/AbstractMethodError", buf); |
| exn_raise_object(exc_object); |
| tmn_suspend_disable(); |
| } |
| return false; |
| } |
| return true; |
| } |
| |
| // |
| // resolve constant pool reference to a method |
| // used for invokespecial |
| // |
| Method* resolve_special_method_env(Global_Env *env, |
| Class_Handle curr_clss, |
| unsigned index, |
| bool raise_exn) |
| { |
| ASSERT_RAISE_AREA; |
| |
| Method* method = curr_clss->_resolve_method(env, index); |
| if(!method) { |
| assert(curr_clss->get_constant_pool().is_entry_in_error(index)); |
| if (raise_exn) { |
| exn_raise_object(curr_clss->get_constant_pool().get_error_cause(index)); |
| } |
| return NULL; |
| } |
| if(curr_clss->is_super() |
| && is_class_extended_class(curr_clss->get_super_class(), method->get_class()) |
| && method->get_name() != env->Init_String) |
| { |
| Method* result_meth; |
| for(Class* clss = curr_clss->get_super_class(); clss; clss = clss->get_super_class()) |
| { |
| result_meth = clss->lookup_method(method->get_name(), method->get_descriptor()); |
| if(result_meth) { |
| method = result_meth; |
| break; |
| } |
| } |
| } |
| if(method && !method_can_link_special(curr_clss, index, method, raise_exn)) |
| return NULL; |
| return method; |
| } //resolve_special_method_env |
| |
| |
| // |
| // resolve constant pool reference to a method |
| // used for invokespecial |
| // |
| Method_Handle resolve_special_method(Compile_Handle h, |
| Class_Handle c, |
| unsigned index) |
| { |
| return resolve_special_method_env(compile_handle_to_environment(h), c, index, false); |
| } //resolve_special_method |
| |
| |
| |
| // |
| // resolve constant pool reference to a static method |
| // used for invokestatic |
| // |
| Method_Handle resolve_static_method(Compile_Handle h, |
| Class_Handle c, |
| unsigned index) |
| { |
| return resolve_static_method_env(compile_handle_to_environment(h), c, index, false); |
| } //resolve_static_method |
| |
| |
| |
| // |
| // resolve constant pool reference to a method |
| // used for invokeinterface |
| // |
| Method_Handle resolve_interface_method(Compile_Handle h, |
| Class_Handle c, |
| unsigned index) |
| { |
| return resolve_interface_method_env(compile_handle_to_environment(h), c, index, false); |
| } //resolve_interface_method |
| |
| |
| // |
| // resolve constant pool reference to a class |
| // used for |
| // (1) new |
| // - InstantiationError exception if resolved class is abstract |
| // (2) anewarray |
| // (3) checkcast |
| // (4) instanceof |
| // (5) multianewarray |
| // |
| // resolve_class_new is used for resolving references to class entries by the |
| // the new byte code. |
| // |
| Class_Handle resolve_class_new(Compile_Handle h, |
| Class_Handle c, |
| unsigned index) |
| { |
| return resolve_class_new_env(compile_handle_to_environment(h), c, index, false); |
| } //resolve_class_new |
| |
| |
| |
| // |
| // resolve_class is used by all the other byte codes that reference classes. |
| // |
| Class_Handle resolve_class(Compile_Handle h, |
| Class_Handle c, |
| unsigned index) |
| { |
| return c->_resolve_class(compile_handle_to_environment(h), index); |
| } //resolve_class |
| |
| BOOLEAN class_cp_is_entry_resolved(Class_Handle clazz, U_16 cp_index) { |
| ConstantPool& cp = clazz->get_constant_pool(); |
| bool res = cp.is_entry_resolved(cp_index); |
| if (!res) { |
| unsigned char tag = cp.get_tag(cp_index); |
| //during the loading of a class not all items in it's constant pool are updated |
| if (tag == CONSTANT_Fieldref || tag == CONSTANT_Methodref |
| || tag == CONSTANT_InterfaceMethodref || tag == CONSTANT_Class) |
| { |
| uint16 typeIndex = tag == CONSTANT_Class ? cp_index : cp.get_ref_class_index(cp_index); |
| res = cp.is_entry_resolved(typeIndex); |
| if (!res) { |
| // the type is not marked as loaded in local constant pool |
| // ask classloader directly |
| uint16 nameIdx = cp.get_class_name_index(typeIndex); |
| String* typeName = cp.get_utf8_string(nameIdx); |
| assert(typeName!=NULL); |
| Class* type = clazz->get_class_loader()->LookupClass(typeName); |
| if (type) { |
| /*TODO: uncommenting this code lead to a crash in StressLoader test |
| clazz->lock(); |
| cp.resolve_entry(typeIndex, type); |
| clazz->unlock();*/ |
| res = true; |
| } |
| |
| //if array of primitives -> return true; |
| if (*typeName->bytes=='[' && !strchr(typeName->bytes, 'L')) { |
| return true; |
| } |
| } |
| |
| } |
| } |
| return res; |
| } |
| |
| |
| void class_throw_linking_error(Class_Handle ch, unsigned index, unsigned opcode) |
| { |
| ASSERT_RAISE_AREA; |
| tmn_suspend_enable(); |
| |
| ConstantPool& cp = ch->get_constant_pool(); |
| if(cp.is_entry_in_error(index)) { |
| exn_raise_object(cp.get_error_cause(index)); |
| tmn_suspend_disable(); |
| return; // will return in interpreter mode |
| } |
| |
| switch(opcode) { |
| case OPCODE_NEW: |
| class_can_instantiate(cp.get_class_class(index), LINK_THROW_ERRORS); |
| break; |
| case OPCODE_PUTFIELD: |
| field_can_link(ch, cp.get_ref_field(index), |
| CAN_LINK_FROM_FIELD, LINK_WRITE_ACCESS, LINK_THROW_ERRORS); |
| break; |
| case OPCODE_GETFIELD: |
| field_can_link(ch, cp.get_ref_field(index), |
| CAN_LINK_FROM_FIELD, LINK_READ_ACCESS, LINK_THROW_ERRORS); |
| break; |
| case OPCODE_PUTSTATIC: |
| field_can_link(ch, cp.get_ref_field(index), |
| CAN_LINK_FROM_STATIC, LINK_WRITE_ACCESS, LINK_THROW_ERRORS); |
| break; |
| case OPCODE_GETSTATIC: |
| field_can_link(ch, cp.get_ref_field(index), |
| CAN_LINK_FROM_STATIC, LINK_READ_ACCESS, LINK_THROW_ERRORS); |
| break; |
| case OPCODE_INVOKEINTERFACE: |
| method_can_link_interface(ch, index, cp.get_ref_method(index), |
| LINK_THROW_ERRORS); |
| break; |
| case OPCODE_INVOKESPECIAL: |
| method_can_link_special(ch, index, cp.get_ref_method(index), |
| LINK_THROW_ERRORS); |
| break; |
| case OPCODE_INVOKESTATIC: |
| method_can_link_static(ch, index, cp.get_ref_method(index), |
| LINK_THROW_ERRORS); |
| break; |
| case OPCODE_INVOKEVIRTUAL: |
| method_can_link_virtual(ch, index, cp.get_ref_method(index), |
| LINK_THROW_ERRORS); |
| break; |
| default: |
| // FIXME Potentially this can be any RuntimeException or Error |
| // The most probable case is OutOfMemoryError. |
| LWARN(5, "**Java exception occured during resolution under compilation"); |
| exn_raise_object(VM_Global_State::loader_env->java_lang_OutOfMemoryError); |
| //ASSERT(0, "Unexpected opcode: " << opcode); |
| break; |
| } |
| tmn_suspend_disable(); |
| } |
| |
| Class* resolve_class_array_of_class(Global_Env* env, Class* cc) |
| { |
| // If the element type is primitive, return one of the preloaded |
| // classes of arrays of primitive types. |
| if (cc->is_primitive()) { |
| if (cc == env->Boolean_Class) { |
| return env->ArrayOfBoolean_Class; |
| } else if (cc == env->Byte_Class) { |
| return env->ArrayOfByte_Class; |
| } else if (cc == env->Char_Class) { |
| return env->ArrayOfChar_Class; |
| } else if (cc == env->Short_Class) { |
| return env->ArrayOfShort_Class; |
| } else if (cc == env->Int_Class) { |
| return env->ArrayOfInt_Class; |
| } else if (cc == env->Long_Class) { |
| return env->ArrayOfLong_Class; |
| } else if (cc == env->Float_Class) { |
| return env->ArrayOfFloat_Class; |
| } else if (cc == env->Double_Class) { |
| return env->ArrayOfDouble_Class; |
| } |
| } |
| |
| char *array_name = (char *)STD_MALLOC(cc->get_name()->len + 5); |
| if(cc->get_name()->bytes[0] == '[') { |
| sprintf(array_name, "[%s", cc->get_name()->bytes); |
| } else { |
| sprintf(array_name, "[L%s;", cc->get_name()->bytes); |
| } |
| String *arr_str = env->string_pool.lookup(array_name); |
| STD_FREE(array_name); |
| |
| Class* arr_clss = cc->get_class_loader()->LoadVerifyAndPrepareClass(env, arr_str); |
| |
| return arr_clss; |
| } // resolve_class_array_of_class |
| |
| // |
| // Given a class handle cl construct a class handle of the type |
| // representing array of cl. |
| // |
| Class_Handle class_get_array_of_class(Class_Handle cl) |
| { |
| Global_Env *env = VM_Global_State::loader_env; |
| Class *arr_clss = resolve_class_array_of_class(env, cl); |
| assert(arr_clss || exn_raised()); |
| |
| return arr_clss; |
| } // class_get_array_of_class |
| |
| |
| static bool resolve_const_pool_item(Global_Env* env, Class* clss, unsigned cp_index) |
| { |
| ConstantPool& cp = clss->get_constant_pool(); |
| |
| if(cp.is_entry_resolved(cp_index)) |
| return true; |
| |
| switch(cp.get_tag(cp_index)) { |
| case CONSTANT_Class: |
| return clss->_resolve_class(env, cp_index); |
| case CONSTANT_Fieldref: |
| return clss->_resolve_field(env, cp_index); |
| case CONSTANT_Methodref: |
| return clss->_resolve_method(env, cp_index); |
| case CONSTANT_InterfaceMethodref: |
| return clss->_resolve_method(env, cp_index); |
| case CONSTANT_NameAndType: // fall through |
| case CONSTANT_Utf8: |
| return true; |
| case CONSTANT_String: // fall through |
| case CONSTANT_Float: // fall through |
| case CONSTANT_Integer: |
| return true; |
| case CONSTANT_Double: // fall through |
| case CONSTANT_Long: |
| case CONSTANT_UnusedEntry: |
| return true; |
| } |
| return false; |
| } |
| |
| |
| /** |
| * Resolve whole constant pool |
| */ |
| int resolve_const_pool(Global_Env& env, Class *clss) { |
| ConstantPool& cp = clss->get_constant_pool(); |
| |
| // It's possible that cp is null when defining class on the fly |
| if(!cp.available()) return 0; |
| |
| unsigned cp_size = cp.get_size(); |
| for (unsigned i = 1; i < cp_size; i++) { |
| if(!resolve_const_pool_item(&env, clss, i)) { |
| return i; |
| } |
| } |
| return 0; |
| } //resolve_const_pool |
