jdk8-mips64-public/hotspot: comparison src/share/vm/classfile/verifier.cpp

-:dfe27f03244a
+:e9ff18c4ace7
 /*
-* Copyright (c) 1998, 2009, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1998, 2010, 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.
 objArrayHandle methods(THREAD, _klass->methods());
 int num_methods = methods->length();
 for (int index = 0; index < num_methods; index++) {
+// Check for recursive re-verification before each method.
+if (was_recursively_verified())  return;
 methodOop m = (methodOop)methods->obj_at(index);
 if (m->is_native() || m->is_abstract()) {
 // If m is native or abstract, skip it.  It is checked in class file
 // parser that methods do not override a final method.
 continue;
 }
 verify_method(methodHandle(THREAD, m), CHECK_VERIFY(this));
+}
+if (_verify_verbose || TraceClassInitialization) {
+if (was_recursively_verified())
+tty->print_cr("Recursive verification detected for: %s",
+_klass->external_name());
 }
 }
 void ClassVerifier::verify_method(methodHandle m, TRAPS) {
 ResourceMark rm(THREAD);
 bool no_control_flow = false; // Set to true when there is no direct control
 // flow from current instruction to the next
 // instruction in sequence
 Bytecodes::Code opcode;
 while (!bcs.is_last_bytecode()) {
+// Check for recursive re-verification before each bytecode.
+if (was_recursively_verified())  return;
 opcode = bcs.raw_next();
 u2 bci = bcs.bci();
 // Set current frame's offset to bci
 current_frame.set_offset(bci);
 current_frame.push_stack(
 VerificationType::integer_type(), CHECK_VERIFY(this));
 no_control_flow = false; break;
 case Bytecodes::_ldc :
 verify_ldc(
-opcode, bcs.get_index(), &current_frame,
+opcode, bcs.get_index_u1(), &current_frame,
 cp, bci, CHECK_VERIFY(this));
 no_control_flow = false; break;
 case Bytecodes::_ldc_w :
 case Bytecodes::_ldc2_w :
 verify_ldc(
-opcode, bcs.get_index_big(), &current_frame,
+opcode, bcs.get_index_u2(), &current_frame,
 cp, bci, CHECK_VERIFY(this));
 no_control_flow = false; break;
 case Bytecodes::_iload :
 verify_iload(bcs.get_index(), &current_frame, CHECK_VERIFY(this));
 no_control_flow = false; break;
 &bcs, code_length, &current_frame,
 &this_uninit, return_type, cp, CHECK_VERIFY(this));
 no_control_flow = false; break;
 case Bytecodes::_new :
 {
-index = bcs.get_index_big();
+index = bcs.get_index_u2();
 verify_cp_class_type(index, cp, CHECK_VERIFY(this));
 VerificationType new_class_type =
 cp_index_to_type(index, cp, CHECK_VERIFY(this));
 if (!new_class_type.is_object()) {
 verify_error(bci, "Illegal new instruction");
 VerificationType::integer_type(),  CHECK_VERIFY(this));
 current_frame.push_stack(type, CHECK_VERIFY(this));
 no_control_flow = false; break;
 case Bytecodes::_anewarray :
 verify_anewarray(
-bcs.get_index_big(), cp, &current_frame, CHECK_VERIFY(this));
+bcs.get_index_u2(), cp, &current_frame, CHECK_VERIFY(this));
 no_control_flow = false; break;
 case Bytecodes::_arraylength :
 type = current_frame.pop_stack(
 VerificationType::reference_check(), CHECK_VERIFY(this));
 if (!(type.is_null() || type.is_array())) {
 current_frame.push_stack(
 VerificationType::integer_type(), CHECK_VERIFY(this));
 no_control_flow = false; break;
 case Bytecodes::_checkcast :
 {
-index = bcs.get_index_big();
+index = bcs.get_index_u2();
 verify_cp_class_type(index, cp, CHECK_VERIFY(this));
 current_frame.pop_stack(
 VerificationType::reference_check(), CHECK_VERIFY(this));
 VerificationType klass_type = cp_index_to_type(
 index, cp, CHECK_VERIFY(this));
 current_frame.push_stack(klass_type, CHECK_VERIFY(this));
 no_control_flow = false; break;
 }
 case Bytecodes::_instanceof : {
-index = bcs.get_index_big();
+index = bcs.get_index_u2();
 verify_cp_class_type(index, cp, CHECK_VERIFY(this));
 current_frame.pop_stack(
 VerificationType::reference_check(), CHECK_VERIFY(this));
 current_frame.push_stack(
 VerificationType::integer_type(), CHECK_VERIFY(this));
 current_frame.pop_stack(
 VerificationType::reference_check(), CHECK_VERIFY(this));
 no_control_flow = false; break;
 case Bytecodes::_multianewarray :
 {
-index = bcs.get_index_big();
+index = bcs.get_index_u2();
 u2 dim = *(bcs.bcp()+3);
 verify_cp_class_type(index, cp, CHECK_VERIFY(this));
 VerificationType new_array_type =
 cp_index_to_type(index, cp, CHECK_VERIFY(this));
 if (!new_array_type.is_array()) {
 RawBytecodeStream bcs(m);
 while (!bcs.is_last_bytecode()) {
 if (bcs.raw_next() != Bytecodes::_illegal) {
 int bci = bcs.bci();
-if (bcs.code() == Bytecodes::_new) {
+if (bcs.raw_code() == Bytecodes::_new) {
 code_data[bci] = NEW_OFFSET;
 } else {
 code_data[bci] = BYTECODE_OFFSET;
 }
 } else {
 void ClassVerifier::verify_cp_type(
 int index, constantPoolHandle cp, unsigned int types, TRAPS) {
 // In some situations, bytecode rewriting may occur while we're verifying.
 // In this case, a constant pool cache exists and some indices refer to that
-// instead.  Get the original index for the tag check
+// instead.  Be sure we don't pick up such indices by accident.
-constantPoolCacheOop cache = cp->cache();
+// We must check was_recursively_verified() before we get here.
-if (cache != NULL &&
+guarantee(cp->cache() == NULL, "not rewritten yet");
-((types == (1 <<  JVM_CONSTANT_InterfaceMethodref)) ||
-(types == (1 <<  JVM_CONSTANT_Methodref)) ||
-(types == (1 <<  JVM_CONSTANT_Fieldref)))) {
-int native_index = index;
-if (Bytes::is_Java_byte_ordering_different()) {
-native_index = Bytes::swap_u2(index);
-}
-assert((native_index >= 0) && (native_index < cache->length()),
-"Must be a legal index into the cp cache");
-index = cache->entry_at(native_index)->constant_pool_index();
-}
 verify_cp_index(cp, index, CHECK_VERIFY(this));
 unsigned int tag = cp->tag_at(index).value();
 if ((types & (1 << tag)) == 0) {
 verify_error(
 }
 int default_offset = (int) Bytes::get_Java_u4(aligned_bcp);
 int keys, delta;
 current_frame->pop_stack(
 VerificationType::integer_type(), CHECK_VERIFY(this));
-if (bcs->code() == Bytecodes::_tableswitch) {
+if (bcs->raw_code() == Bytecodes::_tableswitch) {
 jint low = (jint)Bytes::get_Java_u4(aligned_bcp + jintSize);
 jint high = (jint)Bytes::get_Java_u4(aligned_bcp + 2*jintSize);
 if (low > high) {
 verify_error(bci,
 "low must be less than or equal to high in tableswitch");
 void ClassVerifier::verify_field_instructions(RawBytecodeStream* bcs,
 StackMapFrame* current_frame,
 constantPoolHandle cp,
 TRAPS) {
-u2 index = bcs->get_index_big();
+u2 index = bcs->get_index_u2();
 verify_cp_type(index, cp, 1 << JVM_CONSTANT_Fieldref, CHECK_VERIFY(this));
 // Get field name and signature
 symbolHandle field_name = symbolHandle(THREAD, cp->name_ref_at(index));
 symbolHandle field_sig = symbolHandle(THREAD, cp->signature_ref_at(index));
 VerificationType stack_object_type;
 int n = change_sig_to_verificationType(
 &sig_stream, field_type, CHECK_VERIFY(this));
 u2 bci = bcs->bci();
 bool is_assignable;
-switch (bcs->code()) {
+switch (bcs->raw_code()) {
 case Bytecodes::_getstatic: {
 for (int i = 0; i < n; i++) {
 current_frame->push_stack(field_type[i], CHECK_VERIFY(this));
 }
 break;
 if (name_in_supers(ref_class_type.name(), current_class())) {
 klassOop ref_klass = load_class(
 ref_class_type.name(), CHECK_VERIFY(this));
 methodOop m = instanceKlass::cast(ref_klass)->uncached_lookup_method(
 vmSymbols::object_initializer_name(),
-cp->signature_ref_at(bcs->get_index_big()));
+cp->signature_ref_at(bcs->get_index_u2()));
 instanceKlassHandle mh(THREAD, m->method_holder());
 if (m->is_protected() && !mh->is_same_class_package(_klass())) {
 bool assignable = current_type().is_assignable_from(
 objectref_type, current_class(), CHECK_VERIFY(this));
 if (!assignable) {
 void ClassVerifier::verify_invoke_instructions(
 RawBytecodeStream* bcs, u4 code_length, StackMapFrame* current_frame,
 bool *this_uninit, VerificationType return_type,
 constantPoolHandle cp, TRAPS) {
 // Make sure the constant pool item is the right type
-u2 index = bcs->get_index_big();
+u2 index = bcs->get_index_u2();
-Bytecodes::Code opcode = bcs->code();
+Bytecodes::Code opcode = bcs->raw_code();
 unsigned int types = (opcode == Bytecodes::_invokeinterface
 ? 1 << JVM_CONSTANT_InterfaceMethodref
 : opcode == Bytecodes::_invokedynamic
 ? 1 << JVM_CONSTANT_NameAndType
 : 1 << JVM_CONSTANT_Methodref);

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

comparison: src/share/vm/classfile/verifier.cpp

src/share/vm/classfile/verifier.cpp