1 /*
   2  * Copyright (c) 1998, 2013, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "classfile/classFileStream.hpp"
  27 #include "classfile/javaClasses.hpp"
  28 #include "classfile/stackMapTable.hpp"
  29 #include "classfile/stackMapFrame.hpp"
  30 #include "classfile/stackMapTableFormat.hpp"
  31 #include "classfile/systemDictionary.hpp"
  32 #include "classfile/verifier.hpp"
  33 #include "classfile/vmSymbols.hpp"
  34 #include "interpreter/bytecodes.hpp"
  35 #include "interpreter/bytecodeStream.hpp"
  36 #include "memory/oopFactory.hpp"
  37 #include "memory/resourceArea.hpp"
  38 #include "oops/instanceKlass.hpp"
  39 #include "oops/oop.inline.hpp"
  40 #include "oops/typeArrayOop.hpp"
  41 #include "prims/jvm.h"
  42 #include "runtime/fieldDescriptor.hpp"
  43 #include "runtime/handles.inline.hpp"
  44 #include "runtime/interfaceSupport.hpp"
  45 #include "runtime/javaCalls.hpp"
  46 #include "runtime/orderAccess.hpp"
  47 #include "runtime/os.hpp"
  48 #ifdef TARGET_ARCH_x86
  49 # include "bytes_x86.hpp"
  50 #endif
  51 #ifdef TARGET_ARCH_sparc
  52 # include "bytes_sparc.hpp"
  53 #endif
  54 #ifdef TARGET_ARCH_zero
  55 # include "bytes_zero.hpp"
  56 #endif
  57 #ifdef TARGET_ARCH_arm
  58 # include "bytes_arm.hpp"
  59 #endif
  60 #ifdef TARGET_ARCH_ppc
  61 # include "bytes_ppc.hpp"
  62 #endif
  63 
  64 #define NOFAILOVER_MAJOR_VERSION                       51
  65 #define NONZERO_PADDING_BYTES_IN_SWITCH_MAJOR_VERSION  51
  66 #define STATIC_METHOD_IN_INTERFACE_MAJOR_VERSION       52
  67 
  68 // Access to external entry for VerifyClassCodes - old byte code verifier
  69 
  70 extern "C" {
  71   typedef jboolean (*verify_byte_codes_fn_t)(JNIEnv *, jclass, char *, jint);
  72   typedef jboolean (*verify_byte_codes_fn_new_t)(JNIEnv *, jclass, char *, jint, jint);
  73 }
  74 
  75 static void* volatile _verify_byte_codes_fn = NULL;
  76 
  77 static volatile jint _is_new_verify_byte_codes_fn = (jint) true;
  78 
  79 static void* verify_byte_codes_fn() {
  80   if (_verify_byte_codes_fn == NULL) {
  81     void *lib_handle = os::native_java_library();
  82     void *func = os::dll_lookup(lib_handle, "VerifyClassCodesForMajorVersion");
  83     OrderAccess::release_store_ptr(&_verify_byte_codes_fn, func);
  84     if (func == NULL) {
  85       OrderAccess::release_store(&_is_new_verify_byte_codes_fn, false);
  86       func = os::dll_lookup(lib_handle, "VerifyClassCodes");
  87       OrderAccess::release_store_ptr(&_verify_byte_codes_fn, func);
  88     }
  89   }
  90   return (void*)_verify_byte_codes_fn;
  91 }
  92 
  93 
  94 // Methods in Verifier
  95 
  96 bool Verifier::should_verify_for(oop class_loader, bool should_verify_class) {
  97   return (class_loader == NULL || !should_verify_class) ?
  98     BytecodeVerificationLocal : BytecodeVerificationRemote;
  99 }
 100 
 101 bool Verifier::relax_verify_for(oop loader) {
 102   bool trusted = java_lang_ClassLoader::is_trusted_loader(loader);
 103   bool need_verify =
 104     // verifyAll
 105     (BytecodeVerificationLocal && BytecodeVerificationRemote) ||
 106     // verifyRemote
 107     (!BytecodeVerificationLocal && BytecodeVerificationRemote && !trusted);
 108   return !need_verify;
 109 }
 110 
 111 bool Verifier::verify(instanceKlassHandle klass, Verifier::Mode mode, bool should_verify_class, TRAPS) {
 112   HandleMark hm;
 113   ResourceMark rm(THREAD);
 114 
 115   Symbol* exception_name = NULL;
 116   const size_t message_buffer_len = klass->name()->utf8_length() + 1024;
 117   char* message_buffer = NEW_RESOURCE_ARRAY(char, message_buffer_len);
 118   char* exception_message = message_buffer;
 119 
 120   const char* klassName = klass->external_name();
 121   bool can_failover = FailOverToOldVerifier &&
 122       klass->major_version() < NOFAILOVER_MAJOR_VERSION;
 123 
 124   // If the class should be verified, first see if we can use the split
 125   // verifier.  If not, or if verification fails and FailOverToOldVerifier
 126   // is set, then call the inference verifier.
 127   if (is_eligible_for_verification(klass, should_verify_class)) {
 128     if (TraceClassInitialization) {
 129       tty->print_cr("Start class verification for: %s", klassName);
 130     }
 131     if (klass->major_version() >= STACKMAP_ATTRIBUTE_MAJOR_VERSION) {
 132       ClassVerifier split_verifier(klass, THREAD);
 133       split_verifier.verify_class(THREAD);
 134       exception_name = split_verifier.result();
 135       if (can_failover && !HAS_PENDING_EXCEPTION &&
 136           (exception_name == vmSymbols::java_lang_VerifyError() ||
 137            exception_name == vmSymbols::java_lang_ClassFormatError())) {
 138         if (TraceClassInitialization || VerboseVerification) {
 139           tty->print_cr(
 140             "Fail over class verification to old verifier for: %s", klassName);
 141         }
 142         exception_name = inference_verify(
 143           klass, message_buffer, message_buffer_len, THREAD);
 144       }
 145       if (exception_name != NULL) {
 146         exception_message = split_verifier.exception_message();
 147       }
 148     } else {
 149       exception_name = inference_verify(
 150           klass, message_buffer, message_buffer_len, THREAD);
 151     }
 152 
 153     if (TraceClassInitialization || VerboseVerification) {
 154       if (HAS_PENDING_EXCEPTION) {
 155         tty->print("Verification for %s has", klassName);
 156         tty->print_cr(" exception pending %s ",
 157           InstanceKlass::cast(PENDING_EXCEPTION->klass())->external_name());
 158       } else if (exception_name != NULL) {
 159         tty->print_cr("Verification for %s failed", klassName);
 160       }
 161       tty->print_cr("End class verification for: %s", klassName);
 162     }
 163   }
 164 
 165   if (HAS_PENDING_EXCEPTION) {
 166     return false; // use the existing exception
 167   } else if (exception_name == NULL) {
 168     return true; // verifcation succeeded
 169   } else { // VerifyError or ClassFormatError to be created and thrown
 170     ResourceMark rm(THREAD);
 171     instanceKlassHandle kls =
 172       SystemDictionary::resolve_or_fail(exception_name, true, CHECK_false);
 173     while (!kls.is_null()) {
 174       if (kls == klass) {
 175         // If the class being verified is the exception we're creating
 176         // or one of it's superclasses, we're in trouble and are going
 177         // to infinitely recurse when we try to initialize the exception.
 178         // So bail out here by throwing the preallocated VM error.
 179         THROW_OOP_(Universe::virtual_machine_error_instance(), false);
 180       }
 181       kls = kls->super();
 182     }
 183     message_buffer[message_buffer_len - 1] = '\0'; // just to be sure
 184     THROW_MSG_(exception_name, exception_message, false);
 185   }
 186 }
 187 
 188 bool Verifier::is_eligible_for_verification(instanceKlassHandle klass, bool should_verify_class) {
 189   Symbol* name = klass->name();
 190   Klass* refl_magic_klass = SystemDictionary::reflect_MagicAccessorImpl_klass();
 191   Klass* lambda_magic_klass = SystemDictionary::lambda_MagicLambdaImpl_klass();
 192 
 193   bool is_reflect = refl_magic_klass != NULL && klass->is_subtype_of(refl_magic_klass);
 194   bool is_lambda = lambda_magic_klass != NULL && klass->is_subtype_of(lambda_magic_klass);
 195 
 196   return (should_verify_for(klass->class_loader(), should_verify_class) &&
 197     // return if the class is a bootstrapping class
 198     // or defineClass specified not to verify by default (flags override passed arg)
 199     // We need to skip the following four for bootstraping
 200     name != vmSymbols::java_lang_Object() &&
 201     name != vmSymbols::java_lang_Class() &&
 202     name != vmSymbols::java_lang_String() &&
 203     name != vmSymbols::java_lang_Throwable() &&
 204 
 205     // Can not verify the bytecodes for shared classes because they have
 206     // already been rewritten to contain constant pool cache indices,
 207     // which the verifier can't understand.
 208     // Shared classes shouldn't have stackmaps either.
 209     !klass()->is_shared() &&
 210 
 211     // As of the fix for 4486457 we disable verification for all of the
 212     // dynamically-generated bytecodes associated with the 1.4
 213     // reflection implementation, not just those associated with
 214     // sun/reflect/SerializationConstructorAccessor.
 215     // NOTE: this is called too early in the bootstrapping process to be
 216     // guarded by Universe::is_gte_jdk14x_version()/UseNewReflection.
 217     // Also for lambda generated code, gte jdk8
 218     (!is_reflect || VerifyReflectionBytecodes) &&
 219     (!is_lambda || VerifyLambdaBytecodes)
 220   );
 221 }
 222 
 223 Symbol* Verifier::inference_verify(
 224     instanceKlassHandle klass, char* message, size_t message_len, TRAPS) {
 225   JavaThread* thread = (JavaThread*)THREAD;
 226   JNIEnv *env = thread->jni_environment();
 227 
 228   void* verify_func = verify_byte_codes_fn();
 229 
 230   if (verify_func == NULL) {
 231     jio_snprintf(message, message_len, "Could not link verifier");
 232     return vmSymbols::java_lang_VerifyError();
 233   }
 234 
 235   ResourceMark rm(THREAD);
 236   if (VerboseVerification) {
 237     tty->print_cr("Verifying class %s with old format", klass->external_name());
 238   }
 239 
 240   jclass cls = (jclass) JNIHandles::make_local(env, klass->java_mirror());
 241   jint result;
 242 
 243   {
 244     HandleMark hm(thread);
 245     ThreadToNativeFromVM ttn(thread);
 246     // ThreadToNativeFromVM takes care of changing thread_state, so safepoint
 247     // code knows that we have left the VM
 248 
 249     if (_is_new_verify_byte_codes_fn) {
 250       verify_byte_codes_fn_new_t func =
 251         CAST_TO_FN_PTR(verify_byte_codes_fn_new_t, verify_func);
 252       result = (*func)(env, cls, message, (int)message_len,
 253           klass->major_version());
 254     } else {
 255       verify_byte_codes_fn_t func =
 256         CAST_TO_FN_PTR(verify_byte_codes_fn_t, verify_func);
 257       result = (*func)(env, cls, message, (int)message_len);
 258     }
 259   }
 260 
 261   JNIHandles::destroy_local(cls);
 262 
 263   // These numbers are chosen so that VerifyClassCodes interface doesn't need
 264   // to be changed (still return jboolean (unsigned char)), and result is
 265   // 1 when verification is passed.
 266   if (result == 0) {
 267     return vmSymbols::java_lang_VerifyError();
 268   } else if (result == 1) {
 269     return NULL; // verified.
 270   } else if (result == 2) {
 271     THROW_MSG_(vmSymbols::java_lang_OutOfMemoryError(), message, NULL);
 272   } else if (result == 3) {
 273     return vmSymbols::java_lang_ClassFormatError();
 274   } else {
 275     ShouldNotReachHere();
 276     return NULL;
 277   }
 278 }
 279 
 280 TypeOrigin TypeOrigin::null() {
 281   return TypeOrigin();
 282 }
 283 TypeOrigin TypeOrigin::local(u2 index, StackMapFrame* frame) {
 284   assert(frame != NULL, "Must have a frame");
 285   return TypeOrigin(CF_LOCALS, index, StackMapFrame::copy(frame),
 286      frame->local_at(index));
 287 }
 288 TypeOrigin TypeOrigin::stack(u2 index, StackMapFrame* frame) {
 289   assert(frame != NULL, "Must have a frame");
 290   return TypeOrigin(CF_STACK, index, StackMapFrame::copy(frame),
 291       frame->stack_at(index));
 292 }
 293 TypeOrigin TypeOrigin::sm_local(u2 index, StackMapFrame* frame) {
 294   assert(frame != NULL, "Must have a frame");
 295   return TypeOrigin(SM_LOCALS, index, StackMapFrame::copy(frame),
 296       frame->local_at(index));
 297 }
 298 TypeOrigin TypeOrigin::sm_stack(u2 index, StackMapFrame* frame) {
 299   assert(frame != NULL, "Must have a frame");
 300   return TypeOrigin(SM_STACK, index, StackMapFrame::copy(frame),
 301       frame->stack_at(index));
 302 }
 303 TypeOrigin TypeOrigin::bad_index(u2 index) {
 304   return TypeOrigin(BAD_INDEX, index, NULL, VerificationType::bogus_type());
 305 }
 306 TypeOrigin TypeOrigin::cp(u2 index, VerificationType vt) {
 307   return TypeOrigin(CONST_POOL, index, NULL, vt);
 308 }
 309 TypeOrigin TypeOrigin::signature(VerificationType vt) {
 310   return TypeOrigin(SIG, 0, NULL, vt);
 311 }
 312 TypeOrigin TypeOrigin::implicit(VerificationType t) {
 313   return TypeOrigin(IMPLICIT, 0, NULL, t);
 314 }
 315 TypeOrigin TypeOrigin::frame(StackMapFrame* frame) {
 316   return TypeOrigin(FRAME_ONLY, 0, StackMapFrame::copy(frame),
 317                     VerificationType::bogus_type());
 318 }
 319 
 320 void TypeOrigin::reset_frame() {
 321   if (_frame != NULL) {
 322     _frame->restore();
 323   }
 324 }
 325 
 326 void TypeOrigin::details(outputStream* ss) const {
 327   _type.print_on(ss);
 328   switch (_origin) {
 329     case CF_LOCALS:
 330       ss->print(" (current frame, locals[%d])", _index);
 331       break;
 332     case CF_STACK:
 333       ss->print(" (current frame, stack[%d])", _index);
 334       break;
 335     case SM_LOCALS:
 336       ss->print(" (stack map, locals[%d])", _index);
 337       break;
 338     case SM_STACK:
 339       ss->print(" (stack map, stack[%d])", _index);
 340       break;
 341     case CONST_POOL:
 342       ss->print(" (constant pool %d)", _index);
 343       break;
 344     case SIG:
 345       ss->print(" (from method signature)");
 346       break;
 347     case IMPLICIT:
 348     case FRAME_ONLY:
 349     case NONE:
 350     default:
 351       ;
 352   }
 353 }
 354 
 355 #ifdef ASSERT
 356 void TypeOrigin::print_on(outputStream* str) const {
 357   str->print("{%d,%d,%p:", _origin, _index, _frame);
 358   if (_frame != NULL) {
 359     _frame->print_on(str);
 360   } else {
 361     str->print("null");
 362   }
 363   str->print(",");
 364   _type.print_on(str);
 365   str->print("}");
 366 }
 367 #endif
 368 
 369 void ErrorContext::details(outputStream* ss, const Method* method) const {
 370   if (is_valid()) {
 371     ss->print_cr("");
 372     ss->print_cr("Exception Details:");
 373     location_details(ss, method);
 374     reason_details(ss);
 375     frame_details(ss);
 376     bytecode_details(ss, method);
 377     handler_details(ss, method);
 378     stackmap_details(ss, method);
 379   }
 380 }
 381 
 382 void ErrorContext::reason_details(outputStream* ss) const {
 383   streamIndentor si(ss);
 384   ss->indent().print_cr("Reason:");
 385   streamIndentor si2(ss);
 386   ss->indent().print("");
 387   switch (_fault) {
 388     case INVALID_BYTECODE:
 389       ss->print("Error exists in the bytecode");
 390       break;
 391     case WRONG_TYPE:
 392       if (_expected.is_valid()) {
 393         ss->print("Type ");
 394         _type.details(ss);
 395         ss->print(" is not assignable to ");
 396         _expected.details(ss);
 397       } else {
 398         ss->print("Invalid type: ");
 399         _type.details(ss);
 400       }
 401       break;
 402     case FLAGS_MISMATCH:
 403       if (_expected.is_valid()) {
 404         ss->print("Current frame's flags are not assignable "
 405                   "to stack map frame's.");
 406       } else {
 407         ss->print("Current frame's flags are invalid in this context.");
 408       }
 409       break;
 410     case BAD_CP_INDEX:
 411       ss->print("Constant pool index %d is invalid", _type.index());
 412       break;
 413     case BAD_LOCAL_INDEX:
 414       ss->print("Local index %d is invalid", _type.index());
 415       break;
 416     case LOCALS_SIZE_MISMATCH:
 417       ss->print("Current frame's local size doesn't match stackmap.");
 418       break;
 419     case STACK_SIZE_MISMATCH:
 420       ss->print("Current frame's stack size doesn't match stackmap.");
 421       break;
 422     case STACK_OVERFLOW:
 423       ss->print("Exceeded max stack size.");
 424       break;
 425     case STACK_UNDERFLOW:
 426       ss->print("Attempt to pop empty stack.");
 427       break;
 428     case MISSING_STACKMAP:
 429       ss->print("Expected stackmap frame at this location.");
 430       break;
 431     case BAD_STACKMAP:
 432       ss->print("Invalid stackmap specification.");
 433       break;
 434     case UNKNOWN:
 435     default:
 436       ShouldNotReachHere();
 437       ss->print_cr("Unknown");
 438   }
 439   ss->print_cr("");
 440 }
 441 
 442 void ErrorContext::location_details(outputStream* ss, const Method* method) const {
 443   if (_bci != -1 && method != NULL) {
 444     streamIndentor si(ss);
 445     const char* bytecode_name = "<invalid>";
 446     if (method->validate_bci_from_bcx(_bci) != -1) {
 447       Bytecodes::Code code = Bytecodes::code_or_bp_at(method->bcp_from(_bci));
 448       if (Bytecodes::is_defined(code)) {
 449           bytecode_name = Bytecodes::name(code);
 450       } else {
 451           bytecode_name = "<illegal>";
 452       }
 453     }
 454     InstanceKlass* ik = method->method_holder();
 455     ss->indent().print_cr("Location:");
 456     streamIndentor si2(ss);
 457     ss->indent().print_cr("%s.%s%s @%d: %s",
 458         ik->name()->as_C_string(), method->name()->as_C_string(),
 459         method->signature()->as_C_string(), _bci, bytecode_name);
 460   }
 461 }
 462 
 463 void ErrorContext::frame_details(outputStream* ss) const {
 464   streamIndentor si(ss);
 465   if (_type.is_valid() && _type.frame() != NULL) {
 466     ss->indent().print_cr("Current Frame:");
 467     streamIndentor si2(ss);
 468     _type.frame()->print_on(ss);
 469   }
 470   if (_expected.is_valid() && _expected.frame() != NULL) {
 471     ss->indent().print_cr("Stackmap Frame:");
 472     streamIndentor si2(ss);
 473     _expected.frame()->print_on(ss);
 474   }
 475 }
 476 
 477 void ErrorContext::bytecode_details(outputStream* ss, const Method* method) const {
 478   if (method != NULL) {
 479     streamIndentor si(ss);
 480     ss->indent().print_cr("Bytecode:");
 481     streamIndentor si2(ss);
 482     ss->print_data(method->code_base(), method->code_size(), false);
 483   }
 484 }
 485 
 486 void ErrorContext::handler_details(outputStream* ss, const Method* method) const {
 487   if (method != NULL) {
 488     streamIndentor si(ss);
 489     ExceptionTable table(method);
 490     if (table.length() > 0) {
 491       ss->indent().print_cr("Exception Handler Table:");
 492       streamIndentor si2(ss);
 493       for (int i = 0; i < table.length(); ++i) {
 494         ss->indent().print_cr("bci [%d, %d] => handler: %d", table.start_pc(i),
 495             table.end_pc(i), table.handler_pc(i));
 496       }
 497     }
 498   }
 499 }
 500 
 501 void ErrorContext::stackmap_details(outputStream* ss, const Method* method) const {
 502   if (method != NULL && method->has_stackmap_table()) {
 503     streamIndentor si(ss);
 504     ss->indent().print_cr("Stackmap Table:");
 505     Array<u1>* data = method->stackmap_data();
 506     stack_map_table* sm_table =
 507         stack_map_table::at((address)data->adr_at(0));
 508     stack_map_frame* sm_frame = sm_table->entries();
 509     streamIndentor si2(ss);
 510     int current_offset = -1;
 511     for (u2 i = 0; i < sm_table->number_of_entries(); ++i) {
 512       ss->indent();
 513       sm_frame->print_on(ss, current_offset);
 514       ss->print_cr("");
 515       current_offset += sm_frame->offset_delta();
 516       sm_frame = sm_frame->next();
 517     }
 518   }
 519 }
 520 
 521 // Methods in ClassVerifier
 522 
 523 ClassVerifier::ClassVerifier(
 524     instanceKlassHandle klass, TRAPS)
 525     : _thread(THREAD), _exception_type(NULL), _message(NULL), _klass(klass) {
 526   _this_type = VerificationType::reference_type(klass->name());
 527   // Create list to hold symbols in reference area.
 528   _symbols = new GrowableArray<Symbol*>(100, 0, NULL);
 529 }
 530 
 531 ClassVerifier::~ClassVerifier() {
 532   // Decrement the reference count for any symbols created.
 533   for (int i = 0; i < _symbols->length(); i++) {
 534     Symbol* s = _symbols->at(i);
 535     s->decrement_refcount();
 536   }
 537 }
 538 
 539 VerificationType ClassVerifier::object_type() const {
 540   return VerificationType::reference_type(vmSymbols::java_lang_Object());
 541 }
 542 
 543 TypeOrigin ClassVerifier::ref_ctx(const char* sig, TRAPS) {
 544   VerificationType vt = VerificationType::reference_type(
 545       create_temporary_symbol(sig, (int)strlen(sig), THREAD));
 546   return TypeOrigin::implicit(vt);
 547 }
 548 
 549 void ClassVerifier::verify_class(TRAPS) {
 550   if (VerboseVerification) {
 551     tty->print_cr("Verifying class %s with new format",
 552       _klass->external_name());
 553   }
 554 
 555   Array<Method*>* methods = _klass->methods();
 556   int num_methods = methods->length();
 557 
 558   for (int index = 0; index < num_methods; index++) {
 559     // Check for recursive re-verification before each method.
 560     if (was_recursively_verified())  return;
 561 
 562     Method* m = methods->at(index);
 563     if (m->is_native() || m->is_abstract() || m->is_overpass()) {
 564       // If m is native or abstract, skip it.  It is checked in class file
 565       // parser that methods do not override a final method.  Overpass methods
 566       // are trusted since the VM generates them.
 567       continue;
 568     }
 569     verify_method(methodHandle(THREAD, m), CHECK_VERIFY(this));
 570   }
 571 
 572   if (VerboseVerification || TraceClassInitialization) {
 573     if (was_recursively_verified())
 574       tty->print_cr("Recursive verification detected for: %s",
 575           _klass->external_name());
 576   }
 577 }
 578 
 579 void ClassVerifier::verify_method(methodHandle m, TRAPS) {
 580   HandleMark hm(THREAD);
 581   _method = m;   // initialize _method
 582   if (VerboseVerification) {
 583     tty->print_cr("Verifying method %s", m->name_and_sig_as_C_string());
 584   }
 585 
 586   const char* bad_type_msg = "Bad type on operand stack in %s";
 587 
 588   int32_t max_stack = m->verifier_max_stack();
 589   int32_t max_locals = m->max_locals();
 590   constantPoolHandle cp(THREAD, m->constants());
 591 
 592   if (!SignatureVerifier::is_valid_method_signature(m->signature())) {
 593     class_format_error("Invalid method signature");
 594     return;
 595   }
 596 
 597   // Initial stack map frame: offset is 0, stack is initially empty.
 598   StackMapFrame current_frame(max_locals, max_stack, this);
 599   // Set initial locals
 600   VerificationType return_type = current_frame.set_locals_from_arg(
 601     m, current_type(), CHECK_VERIFY(this));
 602 
 603   int32_t stackmap_index = 0; // index to the stackmap array
 604 
 605   u4 code_length = m->code_size();
 606 
 607   // Scan the bytecode and map each instruction's start offset to a number.
 608   char* code_data = generate_code_data(m, code_length, CHECK_VERIFY(this));
 609 
 610   int ex_min = code_length;
 611   int ex_max = -1;
 612   // Look through each item on the exception table. Each of the fields must refer
 613   // to a legal instruction.
 614   verify_exception_handler_table(
 615     code_length, code_data, ex_min, ex_max, CHECK_VERIFY(this));
 616 
 617   // Look through each entry on the local variable table and make sure
 618   // its range of code array offsets is valid. (4169817)
 619   if (m->has_localvariable_table()) {
 620     verify_local_variable_table(code_length, code_data, CHECK_VERIFY(this));
 621   }
 622 
 623   Array<u1>* stackmap_data = m->stackmap_data();
 624   StackMapStream stream(stackmap_data);
 625   StackMapReader reader(this, &stream, code_data, code_length, THREAD);
 626   StackMapTable stackmap_table(&reader, &current_frame, max_locals, max_stack,
 627                                code_data, code_length, CHECK_VERIFY(this));
 628 
 629   if (VerboseVerification) {
 630     stackmap_table.print_on(tty);
 631   }
 632 
 633   RawBytecodeStream bcs(m);
 634 
 635   // Scan the byte code linearly from the start to the end
 636   bool no_control_flow = false; // Set to true when there is no direct control
 637                                 // flow from current instruction to the next
 638                                 // instruction in sequence
 639   Bytecodes::Code opcode;
 640   while (!bcs.is_last_bytecode()) {
 641     // Check for recursive re-verification before each bytecode.
 642     if (was_recursively_verified())  return;
 643 
 644     opcode = bcs.raw_next();
 645     u2 bci = bcs.bci();
 646 
 647     // Set current frame's offset to bci
 648     current_frame.set_offset(bci);
 649     current_frame.set_mark();
 650 
 651     // Make sure every offset in stackmap table point to the beginning to
 652     // an instruction. Match current_frame to stackmap_table entry with
 653     // the same offset if exists.
 654     stackmap_index = verify_stackmap_table(
 655       stackmap_index, bci, &current_frame, &stackmap_table,
 656       no_control_flow, CHECK_VERIFY(this));
 657 
 658 
 659     bool this_uninit = false;  // Set to true when invokespecial <init> initialized 'this'
 660 
 661     // Merge with the next instruction
 662     {
 663       u2 index;
 664       int target;
 665       VerificationType type, type2;
 666       VerificationType atype;
 667 
 668 #ifndef PRODUCT
 669       if (VerboseVerification) {
 670         current_frame.print_on(tty);
 671         tty->print_cr("offset = %d,  opcode = %s", bci, Bytecodes::name(opcode));
 672       }
 673 #endif
 674 
 675       // Make sure wide instruction is in correct format
 676       if (bcs.is_wide()) {
 677         if (opcode != Bytecodes::_iinc   && opcode != Bytecodes::_iload  &&
 678             opcode != Bytecodes::_aload  && opcode != Bytecodes::_lload  &&
 679             opcode != Bytecodes::_istore && opcode != Bytecodes::_astore &&
 680             opcode != Bytecodes::_lstore && opcode != Bytecodes::_fload  &&
 681             opcode != Bytecodes::_dload  && opcode != Bytecodes::_fstore &&
 682             opcode != Bytecodes::_dstore) {
 683           /* Unreachable?  RawBytecodeStream's raw_next() returns 'illegal'
 684            * if we encounter a wide instruction that modifies an invalid
 685            * opcode (not one of the ones listed above) */
 686           verify_error(ErrorContext::bad_code(bci), "Bad wide instruction");
 687           return;
 688         }
 689       }
 690 
 691       switch (opcode) {
 692         case Bytecodes::_nop :
 693           no_control_flow = false; break;
 694         case Bytecodes::_aconst_null :
 695           current_frame.push_stack(
 696             VerificationType::null_type(), CHECK_VERIFY(this));
 697           no_control_flow = false; break;
 698         case Bytecodes::_iconst_m1 :
 699         case Bytecodes::_iconst_0 :
 700         case Bytecodes::_iconst_1 :
 701         case Bytecodes::_iconst_2 :
 702         case Bytecodes::_iconst_3 :
 703         case Bytecodes::_iconst_4 :
 704         case Bytecodes::_iconst_5 :
 705           current_frame.push_stack(
 706             VerificationType::integer_type(), CHECK_VERIFY(this));
 707           no_control_flow = false; break;
 708         case Bytecodes::_lconst_0 :
 709         case Bytecodes::_lconst_1 :
 710           current_frame.push_stack_2(
 711             VerificationType::long_type(),
 712             VerificationType::long2_type(), CHECK_VERIFY(this));
 713           no_control_flow = false; break;
 714         case Bytecodes::_fconst_0 :
 715         case Bytecodes::_fconst_1 :
 716         case Bytecodes::_fconst_2 :
 717           current_frame.push_stack(
 718             VerificationType::float_type(), CHECK_VERIFY(this));
 719           no_control_flow = false; break;
 720         case Bytecodes::_dconst_0 :
 721         case Bytecodes::_dconst_1 :
 722           current_frame.push_stack_2(
 723             VerificationType::double_type(),
 724             VerificationType::double2_type(), CHECK_VERIFY(this));
 725           no_control_flow = false; break;
 726         case Bytecodes::_sipush :
 727         case Bytecodes::_bipush :
 728           current_frame.push_stack(
 729             VerificationType::integer_type(), CHECK_VERIFY(this));
 730           no_control_flow = false; break;
 731         case Bytecodes::_ldc :
 732           verify_ldc(
 733             opcode, bcs.get_index_u1(), &current_frame,
 734             cp, bci, CHECK_VERIFY(this));
 735           no_control_flow = false; break;
 736         case Bytecodes::_ldc_w :
 737         case Bytecodes::_ldc2_w :
 738           verify_ldc(
 739             opcode, bcs.get_index_u2(), &current_frame,
 740             cp, bci, CHECK_VERIFY(this));
 741           no_control_flow = false; break;
 742         case Bytecodes::_iload :
 743           verify_iload(bcs.get_index(), &current_frame, CHECK_VERIFY(this));
 744           no_control_flow = false; break;
 745         case Bytecodes::_iload_0 :
 746         case Bytecodes::_iload_1 :
 747         case Bytecodes::_iload_2 :
 748         case Bytecodes::_iload_3 :
 749           index = opcode - Bytecodes::_iload_0;
 750           verify_iload(index, &current_frame, CHECK_VERIFY(this));
 751           no_control_flow = false; break;
 752         case Bytecodes::_lload :
 753           verify_lload(bcs.get_index(), &current_frame, CHECK_VERIFY(this));
 754           no_control_flow = false; break;
 755         case Bytecodes::_lload_0 :
 756         case Bytecodes::_lload_1 :
 757         case Bytecodes::_lload_2 :
 758         case Bytecodes::_lload_3 :
 759           index = opcode - Bytecodes::_lload_0;
 760           verify_lload(index, &current_frame, CHECK_VERIFY(this));
 761           no_control_flow = false; break;
 762         case Bytecodes::_fload :
 763           verify_fload(bcs.get_index(), &current_frame, CHECK_VERIFY(this));
 764           no_control_flow = false; break;
 765         case Bytecodes::_fload_0 :
 766         case Bytecodes::_fload_1 :
 767         case Bytecodes::_fload_2 :
 768         case Bytecodes::_fload_3 :
 769           index = opcode - Bytecodes::_fload_0;
 770           verify_fload(index, &current_frame, CHECK_VERIFY(this));
 771           no_control_flow = false; break;
 772         case Bytecodes::_dload :
 773           verify_dload(bcs.get_index(), &current_frame, CHECK_VERIFY(this));
 774           no_control_flow = false; break;
 775         case Bytecodes::_dload_0 :
 776         case Bytecodes::_dload_1 :
 777         case Bytecodes::_dload_2 :
 778         case Bytecodes::_dload_3 :
 779           index = opcode - Bytecodes::_dload_0;
 780           verify_dload(index, &current_frame, CHECK_VERIFY(this));
 781           no_control_flow = false; break;
 782         case Bytecodes::_aload :
 783           verify_aload(bcs.get_index(), &current_frame, CHECK_VERIFY(this));
 784           no_control_flow = false; break;
 785         case Bytecodes::_aload_0 :
 786         case Bytecodes::_aload_1 :
 787         case Bytecodes::_aload_2 :
 788         case Bytecodes::_aload_3 :
 789           index = opcode - Bytecodes::_aload_0;
 790           verify_aload(index, &current_frame, CHECK_VERIFY(this));
 791           no_control_flow = false; break;
 792         case Bytecodes::_iaload :
 793           type = current_frame.pop_stack(
 794             VerificationType::integer_type(), CHECK_VERIFY(this));
 795           atype = current_frame.pop_stack(
 796             VerificationType::reference_check(), CHECK_VERIFY(this));
 797           if (!atype.is_int_array()) {
 798             verify_error(ErrorContext::bad_type(bci,
 799                 current_frame.stack_top_ctx(), ref_ctx("[I", THREAD)),
 800                 bad_type_msg, "iaload");
 801             return;
 802           }
 803           current_frame.push_stack(
 804             VerificationType::integer_type(), CHECK_VERIFY(this));
 805           no_control_flow = false; break;
 806         case Bytecodes::_baload :
 807           type = current_frame.pop_stack(
 808             VerificationType::integer_type(), CHECK_VERIFY(this));
 809           atype = current_frame.pop_stack(
 810             VerificationType::reference_check(), CHECK_VERIFY(this));
 811           if (!atype.is_bool_array() && !atype.is_byte_array()) {
 812             verify_error(
 813                 ErrorContext::bad_type(bci, current_frame.stack_top_ctx()),
 814                 bad_type_msg, "baload");
 815             return;
 816           }
 817           current_frame.push_stack(
 818             VerificationType::integer_type(), CHECK_VERIFY(this));
 819           no_control_flow = false; break;
 820         case Bytecodes::_caload :
 821           type = current_frame.pop_stack(
 822             VerificationType::integer_type(), CHECK_VERIFY(this));
 823           atype = current_frame.pop_stack(
 824             VerificationType::reference_check(), CHECK_VERIFY(this));
 825           if (!atype.is_char_array()) {
 826             verify_error(ErrorContext::bad_type(bci,
 827                 current_frame.stack_top_ctx(), ref_ctx("[C", THREAD)),
 828                 bad_type_msg, "caload");
 829             return;
 830           }
 831           current_frame.push_stack(
 832             VerificationType::integer_type(), CHECK_VERIFY(this));
 833           no_control_flow = false; break;
 834         case Bytecodes::_saload :
 835           type = current_frame.pop_stack(
 836             VerificationType::integer_type(), CHECK_VERIFY(this));
 837           atype = current_frame.pop_stack(
 838             VerificationType::reference_check(), CHECK_VERIFY(this));
 839           if (!atype.is_short_array()) {
 840             verify_error(ErrorContext::bad_type(bci,
 841                 current_frame.stack_top_ctx(), ref_ctx("[S", THREAD)),
 842                 bad_type_msg, "saload");
 843             return;
 844           }
 845           current_frame.push_stack(
 846             VerificationType::integer_type(), CHECK_VERIFY(this));
 847           no_control_flow = false; break;
 848         case Bytecodes::_laload :
 849           type = current_frame.pop_stack(
 850             VerificationType::integer_type(), CHECK_VERIFY(this));
 851           atype = current_frame.pop_stack(
 852             VerificationType::reference_check(), CHECK_VERIFY(this));
 853           if (!atype.is_long_array()) {
 854             verify_error(ErrorContext::bad_type(bci,
 855                 current_frame.stack_top_ctx(), ref_ctx("[J", THREAD)),
 856                 bad_type_msg, "laload");
 857             return;
 858           }
 859           current_frame.push_stack_2(
 860             VerificationType::long_type(),
 861             VerificationType::long2_type(), CHECK_VERIFY(this));
 862           no_control_flow = false; break;
 863         case Bytecodes::_faload :
 864           type = current_frame.pop_stack(
 865             VerificationType::integer_type(), CHECK_VERIFY(this));
 866           atype = current_frame.pop_stack(
 867             VerificationType::reference_check(), CHECK_VERIFY(this));
 868           if (!atype.is_float_array()) {
 869             verify_error(ErrorContext::bad_type(bci,
 870                 current_frame.stack_top_ctx(), ref_ctx("[F", THREAD)),
 871                 bad_type_msg, "faload");
 872             return;
 873           }
 874           current_frame.push_stack(
 875             VerificationType::float_type(), CHECK_VERIFY(this));
 876           no_control_flow = false; break;
 877         case Bytecodes::_daload :
 878           type = current_frame.pop_stack(
 879             VerificationType::integer_type(), CHECK_VERIFY(this));
 880           atype = current_frame.pop_stack(
 881             VerificationType::reference_check(), CHECK_VERIFY(this));
 882           if (!atype.is_double_array()) {
 883             verify_error(ErrorContext::bad_type(bci,
 884                 current_frame.stack_top_ctx(), ref_ctx("[D", THREAD)),
 885                 bad_type_msg, "daload");
 886             return;
 887           }
 888           current_frame.push_stack_2(
 889             VerificationType::double_type(),
 890             VerificationType::double2_type(), CHECK_VERIFY(this));
 891           no_control_flow = false; break;
 892         case Bytecodes::_aaload : {
 893           type = current_frame.pop_stack(
 894             VerificationType::integer_type(), CHECK_VERIFY(this));
 895           atype = current_frame.pop_stack(
 896             VerificationType::reference_check(), CHECK_VERIFY(this));
 897           if (!atype.is_reference_array()) {
 898             verify_error(ErrorContext::bad_type(bci,
 899                 current_frame.stack_top_ctx(),
 900                 TypeOrigin::implicit(VerificationType::reference_check())),
 901                 bad_type_msg, "aaload");
 902             return;
 903           }
 904           if (atype.is_null()) {
 905             current_frame.push_stack(
 906               VerificationType::null_type(), CHECK_VERIFY(this));
 907           } else {
 908             VerificationType component =
 909               atype.get_component(this, CHECK_VERIFY(this));
 910             current_frame.push_stack(component, CHECK_VERIFY(this));
 911           }
 912           no_control_flow = false; break;
 913         }
 914         case Bytecodes::_istore :
 915           verify_istore(bcs.get_index(), &current_frame, CHECK_VERIFY(this));
 916           no_control_flow = false; break;
 917         case Bytecodes::_istore_0 :
 918         case Bytecodes::_istore_1 :
 919         case Bytecodes::_istore_2 :
 920         case Bytecodes::_istore_3 :
 921           index = opcode - Bytecodes::_istore_0;
 922           verify_istore(index, &current_frame, CHECK_VERIFY(this));
 923           no_control_flow = false; break;
 924         case Bytecodes::_lstore :
 925           verify_lstore(bcs.get_index(), &current_frame, CHECK_VERIFY(this));
 926           no_control_flow = false; break;
 927         case Bytecodes::_lstore_0 :
 928         case Bytecodes::_lstore_1 :
 929         case Bytecodes::_lstore_2 :
 930         case Bytecodes::_lstore_3 :
 931           index = opcode - Bytecodes::_lstore_0;
 932           verify_lstore(index, &current_frame, CHECK_VERIFY(this));
 933           no_control_flow = false; break;
 934         case Bytecodes::_fstore :
 935           verify_fstore(bcs.get_index(), &current_frame, CHECK_VERIFY(this));
 936           no_control_flow = false; break;
 937         case Bytecodes::_fstore_0 :
 938         case Bytecodes::_fstore_1 :
 939         case Bytecodes::_fstore_2 :
 940         case Bytecodes::_fstore_3 :
 941           index = opcode - Bytecodes::_fstore_0;
 942           verify_fstore(index, &current_frame, CHECK_VERIFY(this));
 943           no_control_flow = false; break;
 944         case Bytecodes::_dstore :
 945           verify_dstore(bcs.get_index(), &current_frame, CHECK_VERIFY(this));
 946           no_control_flow = false; break;
 947         case Bytecodes::_dstore_0 :
 948         case Bytecodes::_dstore_1 :
 949         case Bytecodes::_dstore_2 :
 950         case Bytecodes::_dstore_3 :
 951           index = opcode - Bytecodes::_dstore_0;
 952           verify_dstore(index, &current_frame, CHECK_VERIFY(this));
 953           no_control_flow = false; break;
 954         case Bytecodes::_astore :
 955           verify_astore(bcs.get_index(), &current_frame, CHECK_VERIFY(this));
 956           no_control_flow = false; break;
 957         case Bytecodes::_astore_0 :
 958         case Bytecodes::_astore_1 :
 959         case Bytecodes::_astore_2 :
 960         case Bytecodes::_astore_3 :
 961           index = opcode - Bytecodes::_astore_0;
 962           verify_astore(index, &current_frame, CHECK_VERIFY(this));
 963           no_control_flow = false; break;
 964         case Bytecodes::_iastore :
 965           type = current_frame.pop_stack(
 966             VerificationType::integer_type(), CHECK_VERIFY(this));
 967           type2 = current_frame.pop_stack(
 968             VerificationType::integer_type(), CHECK_VERIFY(this));
 969           atype = current_frame.pop_stack(
 970             VerificationType::reference_check(), CHECK_VERIFY(this));
 971           if (!atype.is_int_array()) {
 972             verify_error(ErrorContext::bad_type(bci,
 973                 current_frame.stack_top_ctx(), ref_ctx("[I", THREAD)),
 974                 bad_type_msg, "iastore");
 975             return;
 976           }
 977           no_control_flow = false; break;
 978         case Bytecodes::_bastore :
 979           type = current_frame.pop_stack(
 980             VerificationType::integer_type(), CHECK_VERIFY(this));
 981           type2 = current_frame.pop_stack(
 982             VerificationType::integer_type(), CHECK_VERIFY(this));
 983           atype = current_frame.pop_stack(
 984             VerificationType::reference_check(), CHECK_VERIFY(this));
 985           if (!atype.is_bool_array() && !atype.is_byte_array()) {
 986             verify_error(
 987                 ErrorContext::bad_type(bci, current_frame.stack_top_ctx()),
 988                 bad_type_msg, "bastore");
 989             return;
 990           }
 991           no_control_flow = false; break;
 992         case Bytecodes::_castore :
 993           current_frame.pop_stack(
 994             VerificationType::integer_type(), CHECK_VERIFY(this));
 995           current_frame.pop_stack(
 996             VerificationType::integer_type(), CHECK_VERIFY(this));
 997           atype = current_frame.pop_stack(
 998             VerificationType::reference_check(), CHECK_VERIFY(this));
 999           if (!atype.is_char_array()) {
1000             verify_error(ErrorContext::bad_type(bci,
1001                 current_frame.stack_top_ctx(), ref_ctx("[C", THREAD)),
1002                 bad_type_msg, "castore");
1003             return;
1004           }
1005           no_control_flow = false; break;
1006         case Bytecodes::_sastore :
1007           current_frame.pop_stack(
1008             VerificationType::integer_type(), CHECK_VERIFY(this));
1009           current_frame.pop_stack(
1010             VerificationType::integer_type(), CHECK_VERIFY(this));
1011           atype = current_frame.pop_stack(
1012             VerificationType::reference_check(), CHECK_VERIFY(this));
1013           if (!atype.is_short_array()) {
1014             verify_error(ErrorContext::bad_type(bci,
1015                 current_frame.stack_top_ctx(), ref_ctx("[S", THREAD)),
1016                 bad_type_msg, "sastore");
1017             return;
1018           }
1019           no_control_flow = false; break;
1020         case Bytecodes::_lastore :
1021           current_frame.pop_stack_2(
1022             VerificationType::long2_type(),
1023             VerificationType::long_type(), CHECK_VERIFY(this));
1024           current_frame.pop_stack(
1025             VerificationType::integer_type(), CHECK_VERIFY(this));
1026           atype = current_frame.pop_stack(
1027             VerificationType::reference_check(), CHECK_VERIFY(this));
1028           if (!atype.is_long_array()) {
1029             verify_error(ErrorContext::bad_type(bci,
1030                 current_frame.stack_top_ctx(), ref_ctx("[J", THREAD)),
1031                 bad_type_msg, "lastore");
1032             return;
1033           }
1034           no_control_flow = false; break;
1035         case Bytecodes::_fastore :
1036           current_frame.pop_stack(
1037             VerificationType::float_type(), CHECK_VERIFY(this));
1038           current_frame.pop_stack
1039             (VerificationType::integer_type(), CHECK_VERIFY(this));
1040           atype = current_frame.pop_stack(
1041             VerificationType::reference_check(), CHECK_VERIFY(this));
1042           if (!atype.is_float_array()) {
1043             verify_error(ErrorContext::bad_type(bci,
1044                 current_frame.stack_top_ctx(), ref_ctx("[F", THREAD)),
1045                 bad_type_msg, "fastore");
1046             return;
1047           }
1048           no_control_flow = false; break;
1049         case Bytecodes::_dastore :
1050           current_frame.pop_stack_2(
1051             VerificationType::double2_type(),
1052             VerificationType::double_type(), CHECK_VERIFY(this));
1053           current_frame.pop_stack(
1054             VerificationType::integer_type(), CHECK_VERIFY(this));
1055           atype = current_frame.pop_stack(
1056             VerificationType::reference_check(), CHECK_VERIFY(this));
1057           if (!atype.is_double_array()) {
1058             verify_error(ErrorContext::bad_type(bci,
1059                 current_frame.stack_top_ctx(), ref_ctx("[D", THREAD)),
1060                 bad_type_msg, "dastore");
1061             return;
1062           }
1063           no_control_flow = false; break;
1064         case Bytecodes::_aastore :
1065           type = current_frame.pop_stack(object_type(), CHECK_VERIFY(this));
1066           type2 = current_frame.pop_stack(
1067             VerificationType::integer_type(), CHECK_VERIFY(this));
1068           atype = current_frame.pop_stack(
1069             VerificationType::reference_check(), CHECK_VERIFY(this));
1070           // more type-checking is done at runtime
1071           if (!atype.is_reference_array()) {
1072             verify_error(ErrorContext::bad_type(bci,
1073                 current_frame.stack_top_ctx(),
1074                 TypeOrigin::implicit(VerificationType::reference_check())),
1075                 bad_type_msg, "aastore");
1076             return;
1077           }
1078           // 4938384: relaxed constraint in JVMS 3nd edition.
1079           no_control_flow = false; break;
1080         case Bytecodes::_pop :
1081           current_frame.pop_stack(
1082             VerificationType::category1_check(), CHECK_VERIFY(this));
1083           no_control_flow = false; break;
1084         case Bytecodes::_pop2 :
1085           type = current_frame.pop_stack(CHECK_VERIFY(this));
1086           if (type.is_category1()) {
1087             current_frame.pop_stack(
1088               VerificationType::category1_check(), CHECK_VERIFY(this));
1089           } else if (type.is_category2_2nd()) {
1090             current_frame.pop_stack(
1091               VerificationType::category2_check(), CHECK_VERIFY(this));
1092           } else {
1093             /* Unreachable? Would need a category2_1st on TOS
1094              * which does not appear possible. */
1095             verify_error(
1096                 ErrorContext::bad_type(bci, current_frame.stack_top_ctx()),
1097                 bad_type_msg, "pop2");
1098             return;
1099           }
1100           no_control_flow = false; break;
1101         case Bytecodes::_dup :
1102           type = current_frame.pop_stack(
1103             VerificationType::category1_check(), CHECK_VERIFY(this));
1104           current_frame.push_stack(type, CHECK_VERIFY(this));
1105           current_frame.push_stack(type, CHECK_VERIFY(this));
1106           no_control_flow = false; break;
1107         case Bytecodes::_dup_x1 :
1108           type = current_frame.pop_stack(
1109             VerificationType::category1_check(), CHECK_VERIFY(this));
1110           type2 = current_frame.pop_stack(
1111             VerificationType::category1_check(), CHECK_VERIFY(this));
1112           current_frame.push_stack(type, CHECK_VERIFY(this));
1113           current_frame.push_stack(type2, CHECK_VERIFY(this));
1114           current_frame.push_stack(type, CHECK_VERIFY(this));
1115           no_control_flow = false; break;
1116         case Bytecodes::_dup_x2 :
1117         {
1118           VerificationType type3;
1119           type = current_frame.pop_stack(
1120             VerificationType::category1_check(), CHECK_VERIFY(this));
1121           type2 = current_frame.pop_stack(CHECK_VERIFY(this));
1122           if (type2.is_category1()) {
1123             type3 = current_frame.pop_stack(
1124               VerificationType::category1_check(), CHECK_VERIFY(this));
1125           } else if (type2.is_category2_2nd()) {
1126             type3 = current_frame.pop_stack(
1127               VerificationType::category2_check(), CHECK_VERIFY(this));
1128           } else {
1129             /* Unreachable? Would need a category2_1st at stack depth 2 with
1130              * a category1 on TOS which does not appear possible. */
1131             verify_error(ErrorContext::bad_type(
1132                 bci, current_frame.stack_top_ctx()), bad_type_msg, "dup_x2");
1133             return;
1134           }
1135           current_frame.push_stack(type, CHECK_VERIFY(this));
1136           current_frame.push_stack(type3, CHECK_VERIFY(this));
1137           current_frame.push_stack(type2, CHECK_VERIFY(this));
1138           current_frame.push_stack(type, CHECK_VERIFY(this));
1139           no_control_flow = false; break;
1140         }
1141         case Bytecodes::_dup2 :
1142           type = current_frame.pop_stack(CHECK_VERIFY(this));
1143           if (type.is_category1()) {
1144             type2 = current_frame.pop_stack(
1145               VerificationType::category1_check(), CHECK_VERIFY(this));
1146           } else if (type.is_category2_2nd()) {
1147             type2 = current_frame.pop_stack(
1148               VerificationType::category2_check(), CHECK_VERIFY(this));
1149           } else {
1150             /* Unreachable?  Would need a category2_1st on TOS which does not
1151              * appear possible. */
1152             verify_error(
1153                 ErrorContext::bad_type(bci, current_frame.stack_top_ctx()),
1154                 bad_type_msg, "dup2");
1155             return;
1156           }
1157           current_frame.push_stack(type2, CHECK_VERIFY(this));
1158           current_frame.push_stack(type, CHECK_VERIFY(this));
1159           current_frame.push_stack(type2, CHECK_VERIFY(this));
1160           current_frame.push_stack(type, CHECK_VERIFY(this));
1161           no_control_flow = false; break;
1162         case Bytecodes::_dup2_x1 :
1163         {
1164           VerificationType type3;
1165           type = current_frame.pop_stack(CHECK_VERIFY(this));
1166           if (type.is_category1()) {
1167             type2 = current_frame.pop_stack(
1168               VerificationType::category1_check(), CHECK_VERIFY(this));
1169           } else if (type.is_category2_2nd()) {
1170             type2 = current_frame.pop_stack(
1171               VerificationType::category2_check(), CHECK_VERIFY(this));
1172           } else {
1173             /* Unreachable?  Would need a category2_1st on TOS which does
1174              * not appear possible. */
1175             verify_error(
1176                 ErrorContext::bad_type(bci, current_frame.stack_top_ctx()),
1177                 bad_type_msg, "dup2_x1");
1178             return;
1179           }
1180           type3 = current_frame.pop_stack(
1181             VerificationType::category1_check(), CHECK_VERIFY(this));
1182           current_frame.push_stack(type2, CHECK_VERIFY(this));
1183           current_frame.push_stack(type, CHECK_VERIFY(this));
1184           current_frame.push_stack(type3, CHECK_VERIFY(this));
1185           current_frame.push_stack(type2, CHECK_VERIFY(this));
1186           current_frame.push_stack(type, CHECK_VERIFY(this));
1187           no_control_flow = false; break;
1188         }
1189         case Bytecodes::_dup2_x2 :
1190         {
1191           VerificationType type3, type4;
1192           type = current_frame.pop_stack(CHECK_VERIFY(this));
1193           if (type.is_category1()) {
1194             type2 = current_frame.pop_stack(
1195               VerificationType::category1_check(), CHECK_VERIFY(this));
1196           } else if (type.is_category2_2nd()) {
1197             type2 = current_frame.pop_stack(
1198               VerificationType::category2_check(), CHECK_VERIFY(this));
1199           } else {
1200             /* Unreachable?  Would need a category2_1st on TOS which does
1201              * not appear possible. */
1202             verify_error(
1203                 ErrorContext::bad_type(bci, current_frame.stack_top_ctx()),
1204                 bad_type_msg, "dup2_x2");
1205             return;
1206           }
1207           type3 = current_frame.pop_stack(CHECK_VERIFY(this));
1208           if (type3.is_category1()) {
1209             type4 = current_frame.pop_stack(
1210               VerificationType::category1_check(), CHECK_VERIFY(this));
1211           } else if (type3.is_category2_2nd()) {
1212             type4 = current_frame.pop_stack(
1213               VerificationType::category2_check(), CHECK_VERIFY(this));
1214           } else {
1215             /* Unreachable?  Would need a category2_1st on TOS after popping
1216              * a long/double or two category 1's, which does not
1217              * appear possible. */
1218             verify_error(
1219                 ErrorContext::bad_type(bci, current_frame.stack_top_ctx()),
1220                 bad_type_msg, "dup2_x2");
1221             return;
1222           }
1223           current_frame.push_stack(type2, CHECK_VERIFY(this));
1224           current_frame.push_stack(type, CHECK_VERIFY(this));
1225           current_frame.push_stack(type4, CHECK_VERIFY(this));
1226           current_frame.push_stack(type3, CHECK_VERIFY(this));
1227           current_frame.push_stack(type2, CHECK_VERIFY(this));
1228           current_frame.push_stack(type, CHECK_VERIFY(this));
1229           no_control_flow = false; break;
1230         }
1231         case Bytecodes::_swap :
1232           type = current_frame.pop_stack(
1233             VerificationType::category1_check(), CHECK_VERIFY(this));
1234           type2 = current_frame.pop_stack(
1235             VerificationType::category1_check(), CHECK_VERIFY(this));
1236           current_frame.push_stack(type, CHECK_VERIFY(this));
1237           current_frame.push_stack(type2, CHECK_VERIFY(this));
1238           no_control_flow = false; break;
1239         case Bytecodes::_iadd :
1240         case Bytecodes::_isub :
1241         case Bytecodes::_imul :
1242         case Bytecodes::_idiv :
1243         case Bytecodes::_irem :
1244         case Bytecodes::_ishl :
1245         case Bytecodes::_ishr :
1246         case Bytecodes::_iushr :
1247         case Bytecodes::_ior :
1248         case Bytecodes::_ixor :
1249         case Bytecodes::_iand :
1250           current_frame.pop_stack(
1251             VerificationType::integer_type(), CHECK_VERIFY(this));
1252           // fall through
1253         case Bytecodes::_ineg :
1254           current_frame.pop_stack(
1255             VerificationType::integer_type(), CHECK_VERIFY(this));
1256           current_frame.push_stack(
1257             VerificationType::integer_type(), CHECK_VERIFY(this));
1258           no_control_flow = false; break;
1259         case Bytecodes::_ladd :
1260         case Bytecodes::_lsub :
1261         case Bytecodes::_lmul :
1262         case Bytecodes::_ldiv :
1263         case Bytecodes::_lrem :
1264         case Bytecodes::_land :
1265         case Bytecodes::_lor :
1266         case Bytecodes::_lxor :
1267           current_frame.pop_stack_2(
1268             VerificationType::long2_type(),
1269             VerificationType::long_type(), CHECK_VERIFY(this));
1270           // fall through
1271         case Bytecodes::_lneg :
1272           current_frame.pop_stack_2(
1273             VerificationType::long2_type(),
1274             VerificationType::long_type(), CHECK_VERIFY(this));
1275           current_frame.push_stack_2(
1276             VerificationType::long_type(),
1277             VerificationType::long2_type(), CHECK_VERIFY(this));
1278           no_control_flow = false; break;
1279         case Bytecodes::_lshl :
1280         case Bytecodes::_lshr :
1281         case Bytecodes::_lushr :
1282           current_frame.pop_stack(
1283             VerificationType::integer_type(), CHECK_VERIFY(this));
1284           current_frame.pop_stack_2(
1285             VerificationType::long2_type(),
1286             VerificationType::long_type(), CHECK_VERIFY(this));
1287           current_frame.push_stack_2(
1288             VerificationType::long_type(),
1289             VerificationType::long2_type(), CHECK_VERIFY(this));
1290           no_control_flow = false; break;
1291         case Bytecodes::_fadd :
1292         case Bytecodes::_fsub :
1293         case Bytecodes::_fmul :
1294         case Bytecodes::_fdiv :
1295         case Bytecodes::_frem :
1296           current_frame.pop_stack(
1297             VerificationType::float_type(), CHECK_VERIFY(this));
1298           // fall through
1299         case Bytecodes::_fneg :
1300           current_frame.pop_stack(
1301             VerificationType::float_type(), CHECK_VERIFY(this));
1302           current_frame.push_stack(
1303             VerificationType::float_type(), CHECK_VERIFY(this));
1304           no_control_flow = false; break;
1305         case Bytecodes::_dadd :
1306         case Bytecodes::_dsub :
1307         case Bytecodes::_dmul :
1308         case Bytecodes::_ddiv :
1309         case Bytecodes::_drem :
1310           current_frame.pop_stack_2(
1311             VerificationType::double2_type(),
1312             VerificationType::double_type(), CHECK_VERIFY(this));
1313           // fall through
1314         case Bytecodes::_dneg :
1315           current_frame.pop_stack_2(
1316             VerificationType::double2_type(),
1317             VerificationType::double_type(), CHECK_VERIFY(this));
1318           current_frame.push_stack_2(
1319             VerificationType::double_type(),
1320             VerificationType::double2_type(), CHECK_VERIFY(this));
1321           no_control_flow = false; break;
1322         case Bytecodes::_iinc :
1323           verify_iinc(bcs.get_index(), &current_frame, CHECK_VERIFY(this));
1324           no_control_flow = false; break;
1325         case Bytecodes::_i2l :
1326           type = current_frame.pop_stack(
1327             VerificationType::integer_type(), CHECK_VERIFY(this));
1328           current_frame.push_stack_2(
1329             VerificationType::long_type(),
1330             VerificationType::long2_type(), CHECK_VERIFY(this));
1331           no_control_flow = false; break;
1332        case Bytecodes::_l2i :
1333           current_frame.pop_stack_2(
1334             VerificationType::long2_type(),
1335             VerificationType::long_type(), CHECK_VERIFY(this));
1336           current_frame.push_stack(
1337             VerificationType::integer_type(), CHECK_VERIFY(this));
1338           no_control_flow = false; break;
1339         case Bytecodes::_i2f :
1340           current_frame.pop_stack(
1341             VerificationType::integer_type(), CHECK_VERIFY(this));
1342           current_frame.push_stack(
1343             VerificationType::float_type(), CHECK_VERIFY(this));
1344           no_control_flow = false; break;
1345         case Bytecodes::_i2d :
1346           current_frame.pop_stack(
1347             VerificationType::integer_type(), CHECK_VERIFY(this));
1348           current_frame.push_stack_2(
1349             VerificationType::double_type(),
1350             VerificationType::double2_type(), CHECK_VERIFY(this));
1351           no_control_flow = false; break;
1352         case Bytecodes::_l2f :
1353           current_frame.pop_stack_2(
1354             VerificationType::long2_type(),
1355             VerificationType::long_type(), CHECK_VERIFY(this));
1356           current_frame.push_stack(
1357             VerificationType::float_type(), CHECK_VERIFY(this));
1358           no_control_flow = false; break;
1359         case Bytecodes::_l2d :
1360           current_frame.pop_stack_2(
1361             VerificationType::long2_type(),
1362             VerificationType::long_type(), CHECK_VERIFY(this));
1363           current_frame.push_stack_2(
1364             VerificationType::double_type(),
1365             VerificationType::double2_type(), CHECK_VERIFY(this));
1366           no_control_flow = false; break;
1367         case Bytecodes::_f2i :
1368           current_frame.pop_stack(
1369             VerificationType::float_type(), CHECK_VERIFY(this));
1370           current_frame.push_stack(
1371             VerificationType::integer_type(), CHECK_VERIFY(this));
1372           no_control_flow = false; break;
1373         case Bytecodes::_f2l :
1374           current_frame.pop_stack(
1375             VerificationType::float_type(), CHECK_VERIFY(this));
1376           current_frame.push_stack_2(
1377             VerificationType::long_type(),
1378             VerificationType::long2_type(), CHECK_VERIFY(this));
1379           no_control_flow = false; break;
1380         case Bytecodes::_f2d :
1381           current_frame.pop_stack(
1382             VerificationType::float_type(), CHECK_VERIFY(this));
1383           current_frame.push_stack_2(
1384             VerificationType::double_type(),
1385             VerificationType::double2_type(), CHECK_VERIFY(this));
1386           no_control_flow = false; break;
1387         case Bytecodes::_d2i :
1388           current_frame.pop_stack_2(
1389             VerificationType::double2_type(),
1390             VerificationType::double_type(), CHECK_VERIFY(this));
1391           current_frame.push_stack(
1392             VerificationType::integer_type(), CHECK_VERIFY(this));
1393           no_control_flow = false; break;
1394         case Bytecodes::_d2l :
1395           current_frame.pop_stack_2(
1396             VerificationType::double2_type(),
1397             VerificationType::double_type(), CHECK_VERIFY(this));
1398           current_frame.push_stack_2(
1399             VerificationType::long_type(),
1400             VerificationType::long2_type(), CHECK_VERIFY(this));
1401           no_control_flow = false; break;
1402         case Bytecodes::_d2f :
1403           current_frame.pop_stack_2(
1404             VerificationType::double2_type(),
1405             VerificationType::double_type(), CHECK_VERIFY(this));
1406           current_frame.push_stack(
1407             VerificationType::float_type(), CHECK_VERIFY(this));
1408           no_control_flow = false; break;
1409         case Bytecodes::_i2b :
1410         case Bytecodes::_i2c :
1411         case Bytecodes::_i2s :
1412           current_frame.pop_stack(
1413             VerificationType::integer_type(), CHECK_VERIFY(this));
1414           current_frame.push_stack(
1415             VerificationType::integer_type(), CHECK_VERIFY(this));
1416           no_control_flow = false; break;
1417         case Bytecodes::_lcmp :
1418           current_frame.pop_stack_2(
1419             VerificationType::long2_type(),
1420             VerificationType::long_type(), CHECK_VERIFY(this));
1421           current_frame.pop_stack_2(
1422             VerificationType::long2_type(),
1423             VerificationType::long_type(), CHECK_VERIFY(this));
1424           current_frame.push_stack(
1425             VerificationType::integer_type(), CHECK_VERIFY(this));
1426           no_control_flow = false; break;
1427         case Bytecodes::_fcmpl :
1428         case Bytecodes::_fcmpg :
1429           current_frame.pop_stack(
1430             VerificationType::float_type(), CHECK_VERIFY(this));
1431           current_frame.pop_stack(
1432             VerificationType::float_type(), CHECK_VERIFY(this));
1433           current_frame.push_stack(
1434             VerificationType::integer_type(), CHECK_VERIFY(this));
1435           no_control_flow = false; break;
1436         case Bytecodes::_dcmpl :
1437         case Bytecodes::_dcmpg :
1438           current_frame.pop_stack_2(
1439             VerificationType::double2_type(),
1440             VerificationType::double_type(), CHECK_VERIFY(this));
1441           current_frame.pop_stack_2(
1442             VerificationType::double2_type(),
1443             VerificationType::double_type(), CHECK_VERIFY(this));
1444           current_frame.push_stack(
1445             VerificationType::integer_type(), CHECK_VERIFY(this));
1446           no_control_flow = false; break;
1447         case Bytecodes::_if_icmpeq:
1448         case Bytecodes::_if_icmpne:
1449         case Bytecodes::_if_icmplt:
1450         case Bytecodes::_if_icmpge:
1451         case Bytecodes::_if_icmpgt:
1452         case Bytecodes::_if_icmple:
1453           current_frame.pop_stack(
1454             VerificationType::integer_type(), CHECK_VERIFY(this));
1455           // fall through
1456         case Bytecodes::_ifeq:
1457         case Bytecodes::_ifne:
1458         case Bytecodes::_iflt:
1459         case Bytecodes::_ifge:
1460         case Bytecodes::_ifgt:
1461         case Bytecodes::_ifle:
1462           current_frame.pop_stack(
1463             VerificationType::integer_type(), CHECK_VERIFY(this));
1464           target = bcs.dest();
1465           stackmap_table.check_jump_target(
1466             &current_frame, target, CHECK_VERIFY(this));
1467           no_control_flow = false; break;
1468         case Bytecodes::_if_acmpeq :
1469         case Bytecodes::_if_acmpne :
1470           current_frame.pop_stack(
1471             VerificationType::reference_check(), CHECK_VERIFY(this));
1472           // fall through
1473         case Bytecodes::_ifnull :
1474         case Bytecodes::_ifnonnull :
1475           current_frame.pop_stack(
1476             VerificationType::reference_check(), CHECK_VERIFY(this));
1477           target = bcs.dest();
1478           stackmap_table.check_jump_target
1479             (&current_frame, target, CHECK_VERIFY(this));
1480           no_control_flow = false; break;
1481         case Bytecodes::_goto :
1482           target = bcs.dest();
1483           stackmap_table.check_jump_target(
1484             &current_frame, target, CHECK_VERIFY(this));
1485           no_control_flow = true; break;
1486         case Bytecodes::_goto_w :
1487           target = bcs.dest_w();
1488           stackmap_table.check_jump_target(
1489             &current_frame, target, CHECK_VERIFY(this));
1490           no_control_flow = true; break;
1491         case Bytecodes::_tableswitch :
1492         case Bytecodes::_lookupswitch :
1493           verify_switch(
1494             &bcs, code_length, code_data, &current_frame,
1495             &stackmap_table, CHECK_VERIFY(this));
1496           no_control_flow = true; break;
1497         case Bytecodes::_ireturn :
1498           type = current_frame.pop_stack(
1499             VerificationType::integer_type(), CHECK_VERIFY(this));
1500           verify_return_value(return_type, type, bci,
1501                               &current_frame, CHECK_VERIFY(this));
1502           no_control_flow = true; break;
1503         case Bytecodes::_lreturn :
1504           type2 = current_frame.pop_stack(
1505             VerificationType::long2_type(), CHECK_VERIFY(this));
1506           type = current_frame.pop_stack(
1507             VerificationType::long_type(), CHECK_VERIFY(this));
1508           verify_return_value(return_type, type, bci,
1509                               &current_frame, CHECK_VERIFY(this));
1510           no_control_flow = true; break;
1511         case Bytecodes::_freturn :
1512           type = current_frame.pop_stack(
1513             VerificationType::float_type(), CHECK_VERIFY(this));
1514           verify_return_value(return_type, type, bci,
1515                               &current_frame, CHECK_VERIFY(this));
1516           no_control_flow = true; break;
1517         case Bytecodes::_dreturn :
1518           type2 = current_frame.pop_stack(
1519             VerificationType::double2_type(),  CHECK_VERIFY(this));
1520           type = current_frame.pop_stack(
1521             VerificationType::double_type(), CHECK_VERIFY(this));
1522           verify_return_value(return_type, type, bci,
1523                               &current_frame, CHECK_VERIFY(this));
1524           no_control_flow = true; break;
1525         case Bytecodes::_areturn :
1526           type = current_frame.pop_stack(
1527             VerificationType::reference_check(), CHECK_VERIFY(this));
1528           verify_return_value(return_type, type, bci,
1529                               &current_frame, CHECK_VERIFY(this));
1530           no_control_flow = true; break;
1531         case Bytecodes::_return :
1532           if (return_type != VerificationType::bogus_type()) {
1533             verify_error(ErrorContext::bad_code(bci),
1534                          "Method expects a return value");
1535             return;
1536           }
1537           // Make sure "this" has been initialized if current method is an
1538           // <init>
1539           if (_method->name() == vmSymbols::object_initializer_name() &&
1540               current_frame.flag_this_uninit()) {
1541             verify_error(ErrorContext::bad_code(bci),
1542                          "Constructor must call super() or this() "
1543                          "before return");
1544             return;
1545           }
1546           no_control_flow = true; break;
1547         case Bytecodes::_getstatic :
1548         case Bytecodes::_putstatic :
1549         case Bytecodes::_getfield :
1550         case Bytecodes::_putfield :
1551           verify_field_instructions(
1552             &bcs, &current_frame, cp, CHECK_VERIFY(this));
1553           no_control_flow = false; break;
1554         case Bytecodes::_invokevirtual :
1555         case Bytecodes::_invokespecial :
1556         case Bytecodes::_invokestatic :
1557           verify_invoke_instructions(
1558             &bcs, code_length, &current_frame,
1559             &this_uninit, return_type, cp, CHECK_VERIFY(this));
1560           no_control_flow = false; break;
1561         case Bytecodes::_invokeinterface :
1562         case Bytecodes::_invokedynamic :
1563           verify_invoke_instructions(
1564             &bcs, code_length, &current_frame,
1565             &this_uninit, return_type, cp, CHECK_VERIFY(this));
1566           no_control_flow = false; break;
1567         case Bytecodes::_new :
1568         {
1569           index = bcs.get_index_u2();
1570           verify_cp_class_type(bci, index, cp, CHECK_VERIFY(this));
1571           VerificationType new_class_type =
1572             cp_index_to_type(index, cp, CHECK_VERIFY(this));
1573           if (!new_class_type.is_object()) {
1574             verify_error(ErrorContext::bad_type(bci,
1575                 TypeOrigin::cp(index, new_class_type)),
1576                 "Illegal new instruction");
1577             return;
1578           }
1579           type = VerificationType::uninitialized_type(bci);
1580           current_frame.push_stack(type, CHECK_VERIFY(this));
1581           no_control_flow = false; break;
1582         }
1583         case Bytecodes::_newarray :
1584           type = get_newarray_type(bcs.get_index(), bci, CHECK_VERIFY(this));
1585           current_frame.pop_stack(
1586             VerificationType::integer_type(),  CHECK_VERIFY(this));
1587           current_frame.push_stack(type, CHECK_VERIFY(this));
1588           no_control_flow = false; break;
1589         case Bytecodes::_anewarray :
1590           verify_anewarray(
1591             bci, bcs.get_index_u2(), cp, &current_frame, CHECK_VERIFY(this));
1592           no_control_flow = false; break;
1593         case Bytecodes::_arraylength :
1594           type = current_frame.pop_stack(
1595             VerificationType::reference_check(), CHECK_VERIFY(this));
1596           if (!(type.is_null() || type.is_array())) {
1597             verify_error(ErrorContext::bad_type(
1598                 bci, current_frame.stack_top_ctx()),
1599                 bad_type_msg, "arraylength");
1600           }
1601           current_frame.push_stack(
1602             VerificationType::integer_type(), CHECK_VERIFY(this));
1603           no_control_flow = false; break;
1604         case Bytecodes::_checkcast :
1605         {
1606           index = bcs.get_index_u2();
1607           verify_cp_class_type(bci, index, cp, CHECK_VERIFY(this));
1608           current_frame.pop_stack(object_type(), CHECK_VERIFY(this));
1609           VerificationType klass_type = cp_index_to_type(
1610             index, cp, CHECK_VERIFY(this));
1611           current_frame.push_stack(klass_type, CHECK_VERIFY(this));
1612           no_control_flow = false; break;
1613         }
1614         case Bytecodes::_instanceof : {
1615           index = bcs.get_index_u2();
1616           verify_cp_class_type(bci, index, cp, CHECK_VERIFY(this));
1617           current_frame.pop_stack(object_type(), CHECK_VERIFY(this));
1618           current_frame.push_stack(
1619             VerificationType::integer_type(), CHECK_VERIFY(this));
1620           no_control_flow = false; break;
1621         }
1622         case Bytecodes::_monitorenter :
1623         case Bytecodes::_monitorexit :
1624           current_frame.pop_stack(
1625             VerificationType::reference_check(), CHECK_VERIFY(this));
1626           no_control_flow = false; break;
1627         case Bytecodes::_multianewarray :
1628         {
1629           index = bcs.get_index_u2();
1630           u2 dim = *(bcs.bcp()+3);
1631           verify_cp_class_type(bci, index, cp, CHECK_VERIFY(this));
1632           VerificationType new_array_type =
1633             cp_index_to_type(index, cp, CHECK_VERIFY(this));
1634           if (!new_array_type.is_array()) {
1635             verify_error(ErrorContext::bad_type(bci,
1636                 TypeOrigin::cp(index, new_array_type)),
1637                 "Illegal constant pool index in multianewarray instruction");
1638             return;
1639           }
1640           if (dim < 1 || new_array_type.dimensions() < dim) {
1641             verify_error(ErrorContext::bad_code(bci),
1642                 "Illegal dimension in multianewarray instruction: %d", dim);
1643             return;
1644           }
1645           for (int i = 0; i < dim; i++) {
1646             current_frame.pop_stack(
1647               VerificationType::integer_type(), CHECK_VERIFY(this));
1648           }
1649           current_frame.push_stack(new_array_type, CHECK_VERIFY(this));
1650           no_control_flow = false; break;
1651         }
1652         case Bytecodes::_athrow :
1653           type = VerificationType::reference_type(
1654             vmSymbols::java_lang_Throwable());
1655           current_frame.pop_stack(type, CHECK_VERIFY(this));
1656           no_control_flow = true; break;
1657         default:
1658           // We only need to check the valid bytecodes in class file.
1659           // And jsr and ret are not in the new class file format in JDK1.5.
1660           verify_error(ErrorContext::bad_code(bci),
1661               "Bad instruction: %02x", opcode);
1662           no_control_flow = false;
1663           return;
1664       }  // end switch
1665     }  // end Merge with the next instruction
1666 
1667     // Look for possible jump target in exception handlers and see if it
1668     // matches current_frame
1669     if (bci >= ex_min && bci < ex_max) {
1670       verify_exception_handler_targets(
1671         bci, this_uninit, &current_frame, &stackmap_table, CHECK_VERIFY(this));
1672     }
1673   } // end while
1674 
1675   // Make sure that control flow does not fall through end of the method
1676   if (!no_control_flow) {
1677     verify_error(ErrorContext::bad_code(code_length),
1678         "Control flow falls through code end");
1679     return;
1680   }
1681 }
1682 
1683 char* ClassVerifier::generate_code_data(methodHandle m, u4 code_length, TRAPS) {
1684   char* code_data = NEW_RESOURCE_ARRAY(char, code_length);
1685   memset(code_data, 0, sizeof(char) * code_length);
1686   RawBytecodeStream bcs(m);
1687 
1688   while (!bcs.is_last_bytecode()) {
1689     if (bcs.raw_next() != Bytecodes::_illegal) {
1690       int bci = bcs.bci();
1691       if (bcs.raw_code() == Bytecodes::_new) {
1692         code_data[bci] = NEW_OFFSET;
1693       } else {
1694         code_data[bci] = BYTECODE_OFFSET;
1695       }
1696     } else {
1697       verify_error(ErrorContext::bad_code(bcs.bci()), "Bad instruction");
1698       return NULL;
1699     }
1700   }
1701 
1702   return code_data;
1703 }
1704 
1705 void ClassVerifier::verify_exception_handler_table(u4 code_length, char* code_data, int& min, int& max, TRAPS) {
1706   ExceptionTable exhandlers(_method());
1707   int exlength = exhandlers.length();
1708   constantPoolHandle cp (THREAD, _method->constants());
1709 
1710   for(int i = 0; i < exlength; i++) {
1711     //reacquire the table in case a GC happened
1712     ExceptionTable exhandlers(_method());
1713     u2 start_pc = exhandlers.start_pc(i);
1714     u2 end_pc = exhandlers.end_pc(i);
1715     u2 handler_pc = exhandlers.handler_pc(i);
1716     if (start_pc >= code_length || code_data[start_pc] == 0) {
1717       class_format_error("Illegal exception table start_pc %d", start_pc);
1718       return;
1719     }
1720     if (end_pc != code_length) {   // special case: end_pc == code_length
1721       if (end_pc > code_length || code_data[end_pc] == 0) {
1722         class_format_error("Illegal exception table end_pc %d", end_pc);
1723         return;
1724       }
1725     }
1726     if (handler_pc >= code_length || code_data[handler_pc] == 0) {
1727       class_format_error("Illegal exception table handler_pc %d", handler_pc);
1728       return;
1729     }
1730     int catch_type_index = exhandlers.catch_type_index(i);
1731     if (catch_type_index != 0) {
1732       VerificationType catch_type = cp_index_to_type(
1733         catch_type_index, cp, CHECK_VERIFY(this));
1734       VerificationType throwable =
1735         VerificationType::reference_type(vmSymbols::java_lang_Throwable());
1736       bool is_subclass = throwable.is_assignable_from(
1737         catch_type, this, CHECK_VERIFY(this));
1738       if (!is_subclass) {
1739         // 4286534: should throw VerifyError according to recent spec change
1740         verify_error(ErrorContext::bad_type(handler_pc,
1741             TypeOrigin::cp(catch_type_index, catch_type),
1742             TypeOrigin::implicit(throwable)),
1743             "Catch type is not a subclass "
1744             "of Throwable in exception handler %d", handler_pc);
1745         return;
1746       }
1747     }
1748     if (start_pc < min) min = start_pc;
1749     if (end_pc > max) max = end_pc;
1750   }
1751 }
1752 
1753 void ClassVerifier::verify_local_variable_table(u4 code_length, char* code_data, TRAPS) {
1754   int localvariable_table_length = _method()->localvariable_table_length();
1755   if (localvariable_table_length > 0) {
1756     LocalVariableTableElement* table = _method()->localvariable_table_start();
1757     for (int i = 0; i < localvariable_table_length; i++) {
1758       u2 start_bci = table[i].start_bci;
1759       u2 length = table[i].length;
1760 
1761       if (start_bci >= code_length || code_data[start_bci] == 0) {
1762         class_format_error(
1763           "Illegal local variable table start_pc %d", start_bci);
1764         return;
1765       }
1766       u4 end_bci = (u4)(start_bci + length);
1767       if (end_bci != code_length) {
1768         if (end_bci >= code_length || code_data[end_bci] == 0) {
1769           class_format_error( "Illegal local variable table length %d", length);
1770           return;
1771         }
1772       }
1773     }
1774   }
1775 }
1776 
1777 u2 ClassVerifier::verify_stackmap_table(u2 stackmap_index, u2 bci,
1778                                         StackMapFrame* current_frame,
1779                                         StackMapTable* stackmap_table,
1780                                         bool no_control_flow, TRAPS) {
1781   if (stackmap_index < stackmap_table->get_frame_count()) {
1782     u2 this_offset = stackmap_table->get_offset(stackmap_index);
1783     if (no_control_flow && this_offset > bci) {
1784       verify_error(ErrorContext::missing_stackmap(bci),
1785                    "Expecting a stack map frame");
1786       return 0;
1787     }
1788     if (this_offset == bci) {
1789       ErrorContext ctx;
1790       // See if current stack map can be assigned to the frame in table.
1791       // current_frame is the stackmap frame got from the last instruction.
1792       // If matched, current_frame will be updated by this method.
1793       bool matches = stackmap_table->match_stackmap(
1794         current_frame, this_offset, stackmap_index,
1795         !no_control_flow, true, &ctx, CHECK_VERIFY_(this, 0));
1796       if (!matches) {
1797         // report type error
1798         verify_error(ctx, "Instruction type does not match stack map");
1799         return 0;
1800       }
1801       stackmap_index++;
1802     } else if (this_offset < bci) {
1803       // current_offset should have met this_offset.
1804       class_format_error("Bad stack map offset %d", this_offset);
1805       return 0;
1806     }
1807   } else if (no_control_flow) {
1808     verify_error(ErrorContext::bad_code(bci), "Expecting a stack map frame");
1809     return 0;
1810   }
1811   return stackmap_index;
1812 }
1813 
1814 void ClassVerifier::verify_exception_handler_targets(u2 bci, bool this_uninit, StackMapFrame* current_frame,
1815                                                      StackMapTable* stackmap_table, TRAPS) {
1816   constantPoolHandle cp (THREAD, _method->constants());
1817   ExceptionTable exhandlers(_method());
1818   int exlength = exhandlers.length();
1819   for(int i = 0; i < exlength; i++) {
1820     //reacquire the table in case a GC happened
1821     ExceptionTable exhandlers(_method());
1822     u2 start_pc = exhandlers.start_pc(i);
1823     u2 end_pc = exhandlers.end_pc(i);
1824     u2 handler_pc = exhandlers.handler_pc(i);
1825     int catch_type_index = exhandlers.catch_type_index(i);
1826     if(bci >= start_pc && bci < end_pc) {
1827       u1 flags = current_frame->flags();
1828       if (this_uninit) {  flags |= FLAG_THIS_UNINIT; }
1829       StackMapFrame* new_frame = current_frame->frame_in_exception_handler(flags);
1830       if (catch_type_index != 0) {
1831         // We know that this index refers to a subclass of Throwable
1832         VerificationType catch_type = cp_index_to_type(
1833           catch_type_index, cp, CHECK_VERIFY(this));
1834         new_frame->push_stack(catch_type, CHECK_VERIFY(this));
1835       } else {
1836         VerificationType throwable =
1837           VerificationType::reference_type(vmSymbols::java_lang_Throwable());
1838         new_frame->push_stack(throwable, CHECK_VERIFY(this));
1839       }
1840       ErrorContext ctx;
1841       bool matches = stackmap_table->match_stackmap(
1842         new_frame, handler_pc, true, false, &ctx, CHECK_VERIFY(this));
1843       if (!matches) {
1844         verify_error(ctx, "Stack map does not match the one at "
1845             "exception handler %d", handler_pc);
1846         return;
1847       }
1848     }
1849   }
1850 }
1851 
1852 void ClassVerifier::verify_cp_index(
1853     u2 bci, constantPoolHandle cp, int index, TRAPS) {
1854   int nconstants = cp->length();
1855   if ((index <= 0) || (index >= nconstants)) {
1856     verify_error(ErrorContext::bad_cp_index(bci, index),
1857         "Illegal constant pool index %d in class %s",
1858         index, cp->pool_holder()->external_name());
1859     return;
1860   }
1861 }
1862 
1863 void ClassVerifier::verify_cp_type(
1864     u2 bci, int index, constantPoolHandle cp, unsigned int types, TRAPS) {
1865 
1866   // In some situations, bytecode rewriting may occur while we're verifying.
1867   // In this case, a constant pool cache exists and some indices refer to that
1868   // instead.  Be sure we don't pick up such indices by accident.
1869   // We must check was_recursively_verified() before we get here.
1870   guarantee(cp->cache() == NULL, "not rewritten yet");
1871 
1872   verify_cp_index(bci, cp, index, CHECK_VERIFY(this));
1873   unsigned int tag = cp->tag_at(index).value();
1874   if ((types & (1 << tag)) == 0) {
1875     verify_error(ErrorContext::bad_cp_index(bci, index),
1876       "Illegal type at constant pool entry %d in class %s",
1877       index, cp->pool_holder()->external_name());
1878     return;
1879   }
1880 }
1881 
1882 void ClassVerifier::verify_cp_class_type(
1883     u2 bci, int index, constantPoolHandle cp, TRAPS) {
1884   verify_cp_index(bci, cp, index, CHECK_VERIFY(this));
1885   constantTag tag = cp->tag_at(index);
1886   if (!tag.is_klass() && !tag.is_unresolved_klass()) {
1887     verify_error(ErrorContext::bad_cp_index(bci, index),
1888         "Illegal type at constant pool entry %d in class %s",
1889         index, cp->pool_holder()->external_name());
1890     return;
1891   }
1892 }
1893 
1894 void ClassVerifier::verify_error(ErrorContext ctx, const char* msg, ...) {
1895   stringStream ss;
1896 
1897   ctx.reset_frames();
1898   _exception_type = vmSymbols::java_lang_VerifyError();
1899   _error_context = ctx;
1900   va_list va;
1901   va_start(va, msg);
1902   ss.vprint(msg, va);
1903   va_end(va);
1904   _message = ss.as_string();
1905 #ifdef ASSERT
1906   ResourceMark rm;
1907   const char* exception_name = _exception_type->as_C_string();
1908   Exceptions::debug_check_abort(exception_name, NULL);
1909 #endif // ndef ASSERT
1910 }
1911 
1912 void ClassVerifier::class_format_error(const char* msg, ...) {
1913   stringStream ss;
1914   _exception_type = vmSymbols::java_lang_ClassFormatError();
1915   va_list va;
1916   va_start(va, msg);
1917   ss.vprint(msg, va);
1918   va_end(va);
1919   if (!_method.is_null()) {
1920     ss.print(" in method %s", _method->name_and_sig_as_C_string());
1921   }
1922   _message = ss.as_string();
1923 }
1924 
1925 Klass* ClassVerifier::load_class(Symbol* name, TRAPS) {
1926   // Get current loader and protection domain first.
1927   oop loader = current_class()->class_loader();
1928   oop protection_domain = current_class()->protection_domain();
1929 
1930   return SystemDictionary::resolve_or_fail(
1931     name, Handle(THREAD, loader), Handle(THREAD, protection_domain),
1932     true, CHECK_NULL);
1933 }
1934 
1935 bool ClassVerifier::is_protected_access(instanceKlassHandle this_class,
1936                                         Klass* target_class,
1937                                         Symbol* field_name,
1938                                         Symbol* field_sig,
1939                                         bool is_method) {
1940   No_Safepoint_Verifier nosafepoint;
1941 
1942   // If target class isn't a super class of this class, we don't worry about this case
1943   if (!this_class->is_subclass_of(target_class)) {
1944     return false;
1945   }
1946   // Check if the specified method or field is protected
1947   InstanceKlass* target_instance = InstanceKlass::cast(target_class);
1948   fieldDescriptor fd;
1949   if (is_method) {
1950     Method* m = target_instance->uncached_lookup_method(field_name, field_sig);
1951     if (m != NULL && m->is_protected()) {
1952       if (!this_class->is_same_class_package(m->method_holder())) {
1953         return true;
1954       }
1955     }
1956   } else {
1957     Klass* member_klass = target_instance->find_field(field_name, field_sig, &fd);
1958     if (member_klass != NULL && fd.is_protected()) {
1959       if (!this_class->is_same_class_package(member_klass)) {
1960         return true;
1961       }
1962     }
1963   }
1964   return false;
1965 }
1966 
1967 void ClassVerifier::verify_ldc(
1968     int opcode, u2 index, StackMapFrame* current_frame,
1969     constantPoolHandle cp, u2 bci, TRAPS) {
1970   verify_cp_index(bci, cp, index, CHECK_VERIFY(this));
1971   constantTag tag = cp->tag_at(index);
1972   unsigned int types;
1973   if (opcode == Bytecodes::_ldc || opcode == Bytecodes::_ldc_w) {
1974     if (!tag.is_unresolved_klass()) {
1975       types = (1 << JVM_CONSTANT_Integer) | (1 << JVM_CONSTANT_Float)
1976             | (1 << JVM_CONSTANT_String)  | (1 << JVM_CONSTANT_Class)
1977             | (1 << JVM_CONSTANT_MethodHandle) | (1 << JVM_CONSTANT_MethodType);
1978       // Note:  The class file parser already verified the legality of
1979       // MethodHandle and MethodType constants.
1980       verify_cp_type(bci, index, cp, types, CHECK_VERIFY(this));
1981     }
1982   } else {
1983     assert(opcode == Bytecodes::_ldc2_w, "must be ldc2_w");
1984     types = (1 << JVM_CONSTANT_Double) | (1 << JVM_CONSTANT_Long);
1985     verify_cp_type(bci, index, cp, types, CHECK_VERIFY(this));
1986   }
1987   if (tag.is_string() && cp->is_pseudo_string_at(index)) {
1988     current_frame->push_stack(object_type(), CHECK_VERIFY(this));
1989   } else if (tag.is_string()) {
1990     current_frame->push_stack(
1991       VerificationType::reference_type(
1992         vmSymbols::java_lang_String()), CHECK_VERIFY(this));
1993   } else if (tag.is_klass() || tag.is_unresolved_klass()) {
1994     current_frame->push_stack(
1995       VerificationType::reference_type(
1996         vmSymbols::java_lang_Class()), CHECK_VERIFY(this));
1997   } else if (tag.is_int()) {
1998     current_frame->push_stack(
1999       VerificationType::integer_type(), CHECK_VERIFY(this));
2000   } else if (tag.is_float()) {
2001     current_frame->push_stack(
2002       VerificationType::float_type(), CHECK_VERIFY(this));
2003   } else if (tag.is_double()) {
2004     current_frame->push_stack_2(
2005       VerificationType::double_type(),
2006       VerificationType::double2_type(), CHECK_VERIFY(this));
2007   } else if (tag.is_long()) {
2008     current_frame->push_stack_2(
2009       VerificationType::long_type(),
2010       VerificationType::long2_type(), CHECK_VERIFY(this));
2011   } else if (tag.is_method_handle()) {
2012     current_frame->push_stack(
2013       VerificationType::reference_type(
2014         vmSymbols::java_lang_invoke_MethodHandle()), CHECK_VERIFY(this));
2015   } else if (tag.is_method_type()) {
2016     current_frame->push_stack(
2017       VerificationType::reference_type(
2018         vmSymbols::java_lang_invoke_MethodType()), CHECK_VERIFY(this));
2019   } else {
2020     /* Unreachable? verify_cp_type has already validated the cp type. */
2021     verify_error(
2022         ErrorContext::bad_cp_index(bci, index), "Invalid index in ldc");
2023     return;
2024   }
2025 }
2026 
2027 void ClassVerifier::verify_switch(
2028     RawBytecodeStream* bcs, u4 code_length, char* code_data,
2029     StackMapFrame* current_frame, StackMapTable* stackmap_table, TRAPS) {
2030   int bci = bcs->bci();
2031   address bcp = bcs->bcp();
2032   address aligned_bcp = (address) round_to((intptr_t)(bcp + 1), jintSize);
2033 
2034   if (_klass->major_version() < NONZERO_PADDING_BYTES_IN_SWITCH_MAJOR_VERSION) {
2035     // 4639449 & 4647081: padding bytes must be 0
2036     u2 padding_offset = 1;
2037     while ((bcp + padding_offset) < aligned_bcp) {
2038       if(*(bcp + padding_offset) != 0) {
2039         verify_error(ErrorContext::bad_code(bci),
2040                      "Nonzero padding byte in lookswitch or tableswitch");
2041         return;
2042       }
2043       padding_offset++;
2044     }
2045   }
2046 
2047   int default_offset = (int) Bytes::get_Java_u4(aligned_bcp);
2048   int keys, delta;
2049   current_frame->pop_stack(
2050     VerificationType::integer_type(), CHECK_VERIFY(this));
2051   if (bcs->raw_code() == Bytecodes::_tableswitch) {
2052     jint low = (jint)Bytes::get_Java_u4(aligned_bcp + jintSize);
2053     jint high = (jint)Bytes::get_Java_u4(aligned_bcp + 2*jintSize);
2054     if (low > high) {
2055       verify_error(ErrorContext::bad_code(bci),
2056           "low must be less than or equal to high in tableswitch");
2057       return;
2058     }
2059     keys = high - low + 1;
2060     if (keys < 0) {
2061       verify_error(ErrorContext::bad_code(bci), "too many keys in tableswitch");
2062       return;
2063     }
2064     delta = 1;
2065   } else {
2066     keys = (int)Bytes::get_Java_u4(aligned_bcp + jintSize);
2067     if (keys < 0) {
2068       verify_error(ErrorContext::bad_code(bci),
2069                    "number of keys in lookupswitch less than 0");
2070       return;
2071     }
2072     delta = 2;
2073     // Make sure that the lookupswitch items are sorted
2074     for (int i = 0; i < (keys - 1); i++) {
2075       jint this_key = Bytes::get_Java_u4(aligned_bcp + (2+2*i)*jintSize);
2076       jint next_key = Bytes::get_Java_u4(aligned_bcp + (2+2*i+2)*jintSize);
2077       if (this_key >= next_key) {
2078         verify_error(ErrorContext::bad_code(bci),
2079                      "Bad lookupswitch instruction");
2080         return;
2081       }
2082     }
2083   }
2084   int target = bci + default_offset;
2085   stackmap_table->check_jump_target(current_frame, target, CHECK_VERIFY(this));
2086   for (int i = 0; i < keys; i++) {
2087     // Because check_jump_target() may safepoint, the bytecode could have
2088     // moved, which means 'aligned_bcp' is no good and needs to be recalculated.
2089     aligned_bcp = (address)round_to((intptr_t)(bcs->bcp() + 1), jintSize);
2090     target = bci + (jint)Bytes::get_Java_u4(aligned_bcp+(3+i*delta)*jintSize);
2091     stackmap_table->check_jump_target(
2092       current_frame, target, CHECK_VERIFY(this));
2093   }
2094   NOT_PRODUCT(aligned_bcp = NULL);  // no longer valid at this point
2095 }
2096 
2097 bool ClassVerifier::name_in_supers(
2098     Symbol* ref_name, instanceKlassHandle current) {
2099   Klass* super = current->super();
2100   while (super != NULL) {
2101     if (super->name() == ref_name) {
2102       return true;
2103     }
2104     super = super->super();
2105   }
2106   return false;
2107 }
2108 
2109 void ClassVerifier::verify_field_instructions(RawBytecodeStream* bcs,
2110                                               StackMapFrame* current_frame,
2111                                               constantPoolHandle cp,
2112                                               TRAPS) {
2113   u2 index = bcs->get_index_u2();
2114   verify_cp_type(bcs->bci(), index, cp,
2115       1 << JVM_CONSTANT_Fieldref, CHECK_VERIFY(this));
2116 
2117   // Get field name and signature
2118   Symbol* field_name = cp->name_ref_at(index);
2119   Symbol* field_sig = cp->signature_ref_at(index);
2120 
2121   if (!SignatureVerifier::is_valid_type_signature(field_sig)) {
2122     class_format_error(
2123       "Invalid signature for field in class %s referenced "
2124       "from constant pool index %d", _klass->external_name(), index);
2125     return;
2126   }
2127 
2128   // Get referenced class type
2129   VerificationType ref_class_type = cp_ref_index_to_type(
2130     index, cp, CHECK_VERIFY(this));
2131   if (!ref_class_type.is_object()) {
2132     /* Unreachable?  Class file parser verifies Fieldref contents */
2133     verify_error(ErrorContext::bad_type(bcs->bci(),
2134         TypeOrigin::cp(index, ref_class_type)),
2135         "Expecting reference to class in class %s at constant pool index %d",
2136         _klass->external_name(), index);
2137     return;
2138   }
2139   VerificationType target_class_type = ref_class_type;
2140 
2141   assert(sizeof(VerificationType) == sizeof(uintptr_t),
2142         "buffer type must match VerificationType size");
2143   uintptr_t field_type_buffer[2];
2144   VerificationType* field_type = (VerificationType*)field_type_buffer;
2145   // If we make a VerificationType[2] array directly, the compiler calls
2146   // to the c-runtime library to do the allocation instead of just
2147   // stack allocating it.  Plus it would run constructors.  This shows up
2148   // in performance profiles.
2149 
2150   SignatureStream sig_stream(field_sig, false);
2151   VerificationType stack_object_type;
2152   int n = change_sig_to_verificationType(
2153     &sig_stream, field_type, CHECK_VERIFY(this));
2154   u2 bci = bcs->bci();
2155   bool is_assignable;
2156   switch (bcs->raw_code()) {
2157     case Bytecodes::_getstatic: {
2158       for (int i = 0; i < n; i++) {
2159         current_frame->push_stack(field_type[i], CHECK_VERIFY(this));
2160       }
2161       break;
2162     }
2163     case Bytecodes::_putstatic: {
2164       for (int i = n - 1; i >= 0; i--) {
2165         current_frame->pop_stack(field_type[i], CHECK_VERIFY(this));
2166       }
2167       break;
2168     }
2169     case Bytecodes::_getfield: {
2170       stack_object_type = current_frame->pop_stack(
2171         target_class_type, CHECK_VERIFY(this));
2172       for (int i = 0; i < n; i++) {
2173         current_frame->push_stack(field_type[i], CHECK_VERIFY(this));
2174       }
2175       goto check_protected;
2176     }
2177     case Bytecodes::_putfield: {
2178       for (int i = n - 1; i >= 0; i--) {
2179         current_frame->pop_stack(field_type[i], CHECK_VERIFY(this));
2180       }
2181       stack_object_type = current_frame->pop_stack(CHECK_VERIFY(this));
2182 
2183       // The JVMS 2nd edition allows field initialization before the superclass
2184       // initializer, if the field is defined within the current class.
2185       fieldDescriptor fd;
2186       if (stack_object_type == VerificationType::uninitialized_this_type() &&
2187           target_class_type.equals(current_type()) &&
2188           _klass->find_local_field(field_name, field_sig, &fd)) {
2189         stack_object_type = current_type();
2190       }
2191       is_assignable = target_class_type.is_assignable_from(
2192         stack_object_type, this, CHECK_VERIFY(this));
2193       if (!is_assignable) {
2194         verify_error(ErrorContext::bad_type(bci,
2195             current_frame->stack_top_ctx(),
2196             TypeOrigin::cp(index, target_class_type)),
2197             "Bad type on operand stack in putfield");
2198         return;
2199       }
2200     }
2201     check_protected: {
2202       if (_this_type == stack_object_type)
2203         break; // stack_object_type must be assignable to _current_class_type
2204       Symbol* ref_class_name =
2205         cp->klass_name_at(cp->klass_ref_index_at(index));
2206       if (!name_in_supers(ref_class_name, current_class()))
2207         // stack_object_type must be assignable to _current_class_type since:
2208         // 1. stack_object_type must be assignable to ref_class.
2209         // 2. ref_class must be _current_class or a subclass of it. It can't
2210         //    be a superclass of it. See revised JVMS 5.4.4.
2211         break;
2212 
2213       Klass* ref_class_oop = load_class(ref_class_name, CHECK);
2214       if (is_protected_access(current_class(), ref_class_oop, field_name,
2215                               field_sig, false)) {
2216         // It's protected access, check if stack object is assignable to
2217         // current class.
2218         is_assignable = current_type().is_assignable_from(
2219           stack_object_type, this, CHECK_VERIFY(this));
2220         if (!is_assignable) {
2221           verify_error(ErrorContext::bad_type(bci,
2222               current_frame->stack_top_ctx(),
2223               TypeOrigin::implicit(current_type())),
2224               "Bad access to protected data in getfield");
2225           return;
2226         }
2227       }
2228       break;
2229     }
2230     default: ShouldNotReachHere();
2231   }
2232 }
2233 
2234 void ClassVerifier::verify_invoke_init(
2235     RawBytecodeStream* bcs, u2 ref_class_index, VerificationType ref_class_type,
2236     StackMapFrame* current_frame, u4 code_length, bool *this_uninit,
2237     constantPoolHandle cp, TRAPS) {
2238   u2 bci = bcs->bci();
2239   VerificationType type = current_frame->pop_stack(
2240     VerificationType::reference_check(), CHECK_VERIFY(this));
2241   if (type == VerificationType::uninitialized_this_type()) {
2242     // The method must be an <init> method of this class or its superclass
2243     Klass* superk = current_class()->super();
2244     if (ref_class_type.name() != current_class()->name() &&
2245         ref_class_type.name() != superk->name()) {
2246       verify_error(ErrorContext::bad_type(bci,
2247           TypeOrigin::implicit(ref_class_type),
2248           TypeOrigin::implicit(current_type())),
2249           "Bad <init> method call");
2250       return;
2251     }
2252     current_frame->initialize_object(type, current_type());
2253     *this_uninit = true;
2254   } else if (type.is_uninitialized()) {
2255     u2 new_offset = type.bci();
2256     address new_bcp = bcs->bcp() - bci + new_offset;
2257     if (new_offset > (code_length - 3) || (*new_bcp) != Bytecodes::_new) {
2258       /* Unreachable?  Stack map parsing ensures valid type and new
2259        * instructions have a valid BCI. */
2260       verify_error(ErrorContext::bad_code(new_offset),
2261                    "Expecting new instruction");
2262       return;
2263     }
2264     u2 new_class_index = Bytes::get_Java_u2(new_bcp + 1);
2265     verify_cp_class_type(bci, new_class_index, cp, CHECK_VERIFY(this));
2266 
2267     // The method must be an <init> method of the indicated class
2268     VerificationType new_class_type = cp_index_to_type(
2269       new_class_index, cp, CHECK_VERIFY(this));
2270     if (!new_class_type.equals(ref_class_type)) {
2271       verify_error(ErrorContext::bad_type(bci,
2272           TypeOrigin::cp(new_class_index, new_class_type),
2273           TypeOrigin::cp(ref_class_index, ref_class_type)),
2274           "Call to wrong <init> method");
2275       return;
2276     }
2277     // According to the VM spec, if the referent class is a superclass of the
2278     // current class, and is in a different runtime package, and the method is
2279     // protected, then the objectref must be the current class or a subclass
2280     // of the current class.
2281     VerificationType objectref_type = new_class_type;
2282     if (name_in_supers(ref_class_type.name(), current_class())) {
2283       Klass* ref_klass = load_class(
2284         ref_class_type.name(), CHECK_VERIFY(this));
2285       Method* m = InstanceKlass::cast(ref_klass)->uncached_lookup_method(
2286         vmSymbols::object_initializer_name(),
2287         cp->signature_ref_at(bcs->get_index_u2()));
2288       instanceKlassHandle mh(THREAD, m->method_holder());
2289       if (m->is_protected() && !mh->is_same_class_package(_klass())) {
2290         bool assignable = current_type().is_assignable_from(
2291           objectref_type, this, CHECK_VERIFY(this));
2292         if (!assignable) {
2293           verify_error(ErrorContext::bad_type(bci,
2294               TypeOrigin::cp(new_class_index, objectref_type),
2295               TypeOrigin::implicit(current_type())),
2296               "Bad access to protected <init> method");
2297           return;
2298         }
2299       }
2300     }
2301     current_frame->initialize_object(type, new_class_type);
2302   } else {
2303     verify_error(ErrorContext::bad_type(bci, current_frame->stack_top_ctx()),
2304         "Bad operand type when invoking <init>");
2305     return;
2306   }
2307 }
2308 
2309 void ClassVerifier::verify_invoke_instructions(
2310     RawBytecodeStream* bcs, u4 code_length, StackMapFrame* current_frame,
2311     bool *this_uninit, VerificationType return_type,
2312     constantPoolHandle cp, TRAPS) {
2313   // Make sure the constant pool item is the right type
2314   u2 index = bcs->get_index_u2();
2315   Bytecodes::Code opcode = bcs->raw_code();
2316   unsigned int types;
2317   switch (opcode) {
2318     case Bytecodes::_invokeinterface:
2319       types = 1 << JVM_CONSTANT_InterfaceMethodref;
2320       break;
2321     case Bytecodes::_invokedynamic:
2322       types = 1 << JVM_CONSTANT_InvokeDynamic;
2323       break;
2324     case Bytecodes::_invokespecial:
2325     case Bytecodes::_invokestatic:
2326       types = (_klass->major_version() < STATIC_METHOD_IN_INTERFACE_MAJOR_VERSION) ?
2327         (1 << JVM_CONSTANT_Methodref) :
2328         ((1 << JVM_CONSTANT_InterfaceMethodref) | (1 << JVM_CONSTANT_Methodref));
2329       break;
2330     default:
2331       types = 1 << JVM_CONSTANT_Methodref;
2332   }
2333   verify_cp_type(bcs->bci(), index, cp, types, CHECK_VERIFY(this));
2334 
2335   // Get method name and signature
2336   Symbol* method_name = cp->name_ref_at(index);
2337   Symbol* method_sig = cp->signature_ref_at(index);
2338 
2339   if (!SignatureVerifier::is_valid_method_signature(method_sig)) {
2340     class_format_error(
2341       "Invalid method signature in class %s referenced "
2342       "from constant pool index %d", _klass->external_name(), index);
2343     return;
2344   }
2345 
2346   // Get referenced class type
2347   VerificationType ref_class_type;
2348   if (opcode == Bytecodes::_invokedynamic) {
2349     if (!EnableInvokeDynamic ||
2350         _klass->major_version() < Verifier::INVOKEDYNAMIC_MAJOR_VERSION) {
2351       class_format_error(
2352         (!EnableInvokeDynamic ?
2353          "invokedynamic instructions not enabled in this JVM" :
2354          "invokedynamic instructions not supported by this class file version"),
2355         _klass->external_name());
2356       return;
2357     }
2358   } else {
2359     ref_class_type = cp_ref_index_to_type(index, cp, CHECK_VERIFY(this));
2360   }
2361 
2362   // For a small signature length, we just allocate 128 bytes instead
2363   // of parsing the signature once to find its size.
2364   // -3 is for '(', ')' and return descriptor; multiply by 2 is for
2365   // longs/doubles to be consertive.
2366   assert(sizeof(VerificationType) == sizeof(uintptr_t),
2367         "buffer type must match VerificationType size");
2368   uintptr_t on_stack_sig_types_buffer[128];
2369   // If we make a VerificationType[128] array directly, the compiler calls
2370   // to the c-runtime library to do the allocation instead of just
2371   // stack allocating it.  Plus it would run constructors.  This shows up
2372   // in performance profiles.
2373 
2374   VerificationType* sig_types;
2375   int size = (method_sig->utf8_length() - 3) * 2;
2376   if (size > 128) {
2377     // Long and double occupies two slots here.
2378     ArgumentSizeComputer size_it(method_sig);
2379     size = size_it.size();
2380     sig_types = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, VerificationType, size);
2381   } else{
2382     sig_types = (VerificationType*)on_stack_sig_types_buffer;
2383   }
2384   SignatureStream sig_stream(method_sig);
2385   int sig_i = 0;
2386   while (!sig_stream.at_return_type()) {
2387     sig_i += change_sig_to_verificationType(
2388       &sig_stream, &sig_types[sig_i], CHECK_VERIFY(this));
2389     sig_stream.next();
2390   }
2391   int nargs = sig_i;
2392 
2393 #ifdef ASSERT
2394   {
2395     ArgumentSizeComputer size_it(method_sig);
2396     assert(nargs == size_it.size(), "Argument sizes do not match");
2397     assert(nargs <= (method_sig->utf8_length() - 3) * 2, "estimate of max size isn't conservative enough");
2398   }
2399 #endif
2400 
2401   // Check instruction operands
2402   u2 bci = bcs->bci();
2403   if (opcode == Bytecodes::_invokeinterface) {
2404     address bcp = bcs->bcp();
2405     // 4905268: count operand in invokeinterface should be nargs+1, not nargs.
2406     // JSR202 spec: The count operand of an invokeinterface instruction is valid if it is
2407     // the difference between the size of the operand stack before and after the instruction
2408     // executes.
2409     if (*(bcp+3) != (nargs+1)) {
2410       verify_error(ErrorContext::bad_code(bci),
2411           "Inconsistent args count operand in invokeinterface");
2412       return;
2413     }
2414     if (*(bcp+4) != 0) {
2415       verify_error(ErrorContext::bad_code(bci),
2416           "Fourth operand byte of invokeinterface must be zero");
2417       return;
2418     }
2419   }
2420 
2421   if (opcode == Bytecodes::_invokedynamic) {
2422     address bcp = bcs->bcp();
2423     if (*(bcp+3) != 0 || *(bcp+4) != 0) {
2424       verify_error(ErrorContext::bad_code(bci),
2425           "Third and fourth operand bytes of invokedynamic must be zero");
2426       return;
2427     }
2428   }
2429 
2430   if (method_name->byte_at(0) == '<') {
2431     // Make sure <init> can only be invoked by invokespecial
2432     if (opcode != Bytecodes::_invokespecial ||
2433         method_name != vmSymbols::object_initializer_name()) {
2434       verify_error(ErrorContext::bad_code(bci),
2435           "Illegal call to internal method");
2436       return;
2437     }
2438   } else if (opcode == Bytecodes::_invokespecial
2439              && !ref_class_type.equals(current_type())
2440              && !ref_class_type.equals(VerificationType::reference_type(
2441                   current_class()->super()->name()))) {
2442     bool subtype = false;
2443     if (!current_class()->is_anonymous()) {
2444       subtype = ref_class_type.is_assignable_from(
2445                  current_type(), this, CHECK_VERIFY(this));
2446     } else {
2447       subtype = ref_class_type.is_assignable_from(VerificationType::reference_type(
2448                  current_class()->host_klass()->name()), this, CHECK_VERIFY(this));
2449     }
2450     if (!subtype) {
2451       verify_error(ErrorContext::bad_code(bci),
2452           "Bad invokespecial instruction: "
2453           "current class isn't assignable to reference class.");
2454        return;
2455     }
2456   }
2457   // Match method descriptor with operand stack
2458   for (int i = nargs - 1; i >= 0; i--) {  // Run backwards
2459     current_frame->pop_stack(sig_types[i], CHECK_VERIFY(this));
2460   }
2461   // Check objectref on operand stack
2462   if (opcode != Bytecodes::_invokestatic &&
2463       opcode != Bytecodes::_invokedynamic) {
2464     if (method_name == vmSymbols::object_initializer_name()) {  // <init> method
2465       verify_invoke_init(bcs, index, ref_class_type, current_frame,
2466         code_length, this_uninit, cp, CHECK_VERIFY(this));
2467     } else {   // other methods
2468       // Ensures that target class is assignable to method class.
2469       if (opcode == Bytecodes::_invokespecial) {
2470         if (!current_class()->is_anonymous()) {
2471           current_frame->pop_stack(current_type(), CHECK_VERIFY(this));
2472         } else {
2473           // anonymous class invokespecial calls: check if the
2474           // objectref is a subtype of the host_klass of the current class
2475           // to allow an anonymous class to reference methods in the host_klass
2476           VerificationType top = current_frame->pop_stack(CHECK_VERIFY(this));
2477           VerificationType hosttype =
2478             VerificationType::reference_type(current_class()->host_klass()->name());
2479           bool subtype = hosttype.is_assignable_from(top, this, CHECK_VERIFY(this));
2480           if (!subtype) {
2481             verify_error( ErrorContext::bad_type(current_frame->offset(),
2482               current_frame->stack_top_ctx(),
2483               TypeOrigin::implicit(top)),
2484               "Bad type on operand stack");
2485             return;
2486           }
2487         }
2488       } else if (opcode == Bytecodes::_invokevirtual) {
2489         VerificationType stack_object_type =
2490           current_frame->pop_stack(ref_class_type, CHECK_VERIFY(this));
2491         if (current_type() != stack_object_type) {
2492           assert(cp->cache() == NULL, "not rewritten yet");
2493           Symbol* ref_class_name =
2494             cp->klass_name_at(cp->klass_ref_index_at(index));
2495           // See the comments in verify_field_instructions() for
2496           // the rationale behind this.
2497           if (name_in_supers(ref_class_name, current_class())) {
2498             Klass* ref_class = load_class(ref_class_name, CHECK);
2499             if (is_protected_access(
2500                   _klass, ref_class, method_name, method_sig, true)) {
2501               // It's protected access, check if stack object is
2502               // assignable to current class.
2503               bool is_assignable = current_type().is_assignable_from(
2504                 stack_object_type, this, CHECK_VERIFY(this));
2505               if (!is_assignable) {
2506                 if (ref_class_type.name() == vmSymbols::java_lang_Object()
2507                     && stack_object_type.is_array()
2508                     && method_name == vmSymbols::clone_name()) {
2509                   // Special case: arrays pretend to implement public Object
2510                   // clone().
2511                 } else {
2512                   verify_error(ErrorContext::bad_type(bci,
2513                       current_frame->stack_top_ctx(),
2514                       TypeOrigin::implicit(current_type())),
2515                       "Bad access to protected data in invokevirtual");
2516                   return;
2517                 }
2518               }
2519             }
2520           }
2521         }
2522       } else {
2523         assert(opcode == Bytecodes::_invokeinterface, "Unexpected opcode encountered");
2524         current_frame->pop_stack(ref_class_type, CHECK_VERIFY(this));
2525       }
2526     }
2527   }
2528   // Push the result type.
2529   if (sig_stream.type() != T_VOID) {
2530     if (method_name == vmSymbols::object_initializer_name()) {
2531       // <init> method must have a void return type
2532       /* Unreachable?  Class file parser verifies that methods with '<' have
2533        * void return */
2534       verify_error(ErrorContext::bad_code(bci),
2535           "Return type must be void in <init> method");
2536       return;
2537     }
2538     VerificationType return_type[2];
2539     int n = change_sig_to_verificationType(
2540       &sig_stream, return_type, CHECK_VERIFY(this));
2541     for (int i = 0; i < n; i++) {
2542       current_frame->push_stack(return_type[i], CHECK_VERIFY(this)); // push types backwards
2543     }
2544   }
2545 }
2546 
2547 VerificationType ClassVerifier::get_newarray_type(
2548     u2 index, u2 bci, TRAPS) {
2549   const char* from_bt[] = {
2550     NULL, NULL, NULL, NULL, "[Z", "[C", "[F", "[D", "[B", "[S", "[I", "[J",
2551   };
2552   if (index < T_BOOLEAN || index > T_LONG) {
2553     verify_error(ErrorContext::bad_code(bci), "Illegal newarray instruction");
2554     return VerificationType::bogus_type();
2555   }
2556 
2557   // from_bt[index] contains the array signature which has a length of 2
2558   Symbol* sig = create_temporary_symbol(
2559     from_bt[index], 2, CHECK_(VerificationType::bogus_type()));
2560   return VerificationType::reference_type(sig);
2561 }
2562 
2563 void ClassVerifier::verify_anewarray(
2564     u2 bci, u2 index, constantPoolHandle cp,
2565     StackMapFrame* current_frame, TRAPS) {
2566   verify_cp_class_type(bci, index, cp, CHECK_VERIFY(this));
2567   current_frame->pop_stack(
2568     VerificationType::integer_type(), CHECK_VERIFY(this));
2569 
2570   VerificationType component_type =
2571     cp_index_to_type(index, cp, CHECK_VERIFY(this));
2572   int length;
2573   char* arr_sig_str;
2574   if (component_type.is_array()) {     // it's an array
2575     const char* component_name = component_type.name()->as_utf8();
2576     // add one dimension to component
2577     length = (int)strlen(component_name) + 1;
2578     arr_sig_str = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, length);
2579     arr_sig_str[0] = '[';
2580     strncpy(&arr_sig_str[1], component_name, length - 1);
2581   } else {         // it's an object or interface
2582     const char* component_name = component_type.name()->as_utf8();
2583     // add one dimension to component with 'L' prepended and ';' postpended.
2584     length = (int)strlen(component_name) + 3;
2585     arr_sig_str = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, length);
2586     arr_sig_str[0] = '[';
2587     arr_sig_str[1] = 'L';
2588     strncpy(&arr_sig_str[2], component_name, length - 2);
2589     arr_sig_str[length - 1] = ';';
2590   }
2591   Symbol* arr_sig = create_temporary_symbol(
2592     arr_sig_str, length, CHECK_VERIFY(this));
2593   VerificationType new_array_type = VerificationType::reference_type(arr_sig);
2594   current_frame->push_stack(new_array_type, CHECK_VERIFY(this));
2595 }
2596 
2597 void ClassVerifier::verify_iload(u2 index, StackMapFrame* current_frame, TRAPS) {
2598   current_frame->get_local(
2599     index, VerificationType::integer_type(), CHECK_VERIFY(this));
2600   current_frame->push_stack(
2601     VerificationType::integer_type(), CHECK_VERIFY(this));
2602 }
2603 
2604 void ClassVerifier::verify_lload(u2 index, StackMapFrame* current_frame, TRAPS) {
2605   current_frame->get_local_2(
2606     index, VerificationType::long_type(),
2607     VerificationType::long2_type(), CHECK_VERIFY(this));
2608   current_frame->push_stack_2(
2609     VerificationType::long_type(),
2610     VerificationType::long2_type(), CHECK_VERIFY(this));
2611 }
2612 
2613 void ClassVerifier::verify_fload(u2 index, StackMapFrame* current_frame, TRAPS) {
2614   current_frame->get_local(
2615     index, VerificationType::float_type(), CHECK_VERIFY(this));
2616   current_frame->push_stack(
2617     VerificationType::float_type(), CHECK_VERIFY(this));
2618 }
2619 
2620 void ClassVerifier::verify_dload(u2 index, StackMapFrame* current_frame, TRAPS) {
2621   current_frame->get_local_2(
2622     index, VerificationType::double_type(),
2623     VerificationType::double2_type(), CHECK_VERIFY(this));
2624   current_frame->push_stack_2(
2625     VerificationType::double_type(),
2626     VerificationType::double2_type(), CHECK_VERIFY(this));
2627 }
2628 
2629 void ClassVerifier::verify_aload(u2 index, StackMapFrame* current_frame, TRAPS) {
2630   VerificationType type = current_frame->get_local(
2631     index, VerificationType::reference_check(), CHECK_VERIFY(this));
2632   current_frame->push_stack(type, CHECK_VERIFY(this));
2633 }
2634 
2635 void ClassVerifier::verify_istore(u2 index, StackMapFrame* current_frame, TRAPS) {
2636   current_frame->pop_stack(
2637     VerificationType::integer_type(), CHECK_VERIFY(this));
2638   current_frame->set_local(
2639     index, VerificationType::integer_type(), CHECK_VERIFY(this));
2640 }
2641 
2642 void ClassVerifier::verify_lstore(u2 index, StackMapFrame* current_frame, TRAPS) {
2643   current_frame->pop_stack_2(
2644     VerificationType::long2_type(),
2645     VerificationType::long_type(), CHECK_VERIFY(this));
2646   current_frame->set_local_2(
2647     index, VerificationType::long_type(),
2648     VerificationType::long2_type(), CHECK_VERIFY(this));
2649 }
2650 
2651 void ClassVerifier::verify_fstore(u2 index, StackMapFrame* current_frame, TRAPS) {
2652   current_frame->pop_stack(VerificationType::float_type(), CHECK_VERIFY(this));
2653   current_frame->set_local(
2654     index, VerificationType::float_type(), CHECK_VERIFY(this));
2655 }
2656 
2657 void ClassVerifier::verify_dstore(u2 index, StackMapFrame* current_frame, TRAPS) {
2658   current_frame->pop_stack_2(
2659     VerificationType::double2_type(),
2660     VerificationType::double_type(), CHECK_VERIFY(this));
2661   current_frame->set_local_2(
2662     index, VerificationType::double_type(),
2663     VerificationType::double2_type(), CHECK_VERIFY(this));
2664 }
2665 
2666 void ClassVerifier::verify_astore(u2 index, StackMapFrame* current_frame, TRAPS) {
2667   VerificationType type = current_frame->pop_stack(
2668     VerificationType::reference_check(), CHECK_VERIFY(this));
2669   current_frame->set_local(index, type, CHECK_VERIFY(this));
2670 }
2671 
2672 void ClassVerifier::verify_iinc(u2 index, StackMapFrame* current_frame, TRAPS) {
2673   VerificationType type = current_frame->get_local(
2674     index, VerificationType::integer_type(), CHECK_VERIFY(this));
2675   current_frame->set_local(index, type, CHECK_VERIFY(this));
2676 }
2677 
2678 void ClassVerifier::verify_return_value(
2679     VerificationType return_type, VerificationType type, u2 bci,
2680     StackMapFrame* current_frame, TRAPS) {
2681   if (return_type == VerificationType::bogus_type()) {
2682     verify_error(ErrorContext::bad_type(bci,
2683         current_frame->stack_top_ctx(), TypeOrigin::signature(return_type)),
2684         "Method expects a return value");
2685     return;
2686   }
2687   bool match = return_type.is_assignable_from(type, this, CHECK_VERIFY(this));
2688   if (!match) {
2689     verify_error(ErrorContext::bad_type(bci,
2690         current_frame->stack_top_ctx(), TypeOrigin::signature(return_type)),
2691         "Bad return type");
2692     return;
2693   }
2694 }
2695 
2696 // The verifier creates symbols which are substrings of Symbols.
2697 // These are stored in the verifier until the end of verification so that
2698 // they can be reference counted.
2699 Symbol* ClassVerifier::create_temporary_symbol(const Symbol *s, int begin,
2700                                                int end, TRAPS) {
2701   Symbol* sym = SymbolTable::new_symbol(s, begin, end, CHECK_NULL);
2702   _symbols->push(sym);
2703   return sym;
2704 }
2705 
2706 Symbol* ClassVerifier::create_temporary_symbol(const char *s, int length, TRAPS) {
2707   Symbol* sym = SymbolTable::new_symbol(s, length, CHECK_NULL);
2708   _symbols->push(sym);
2709   return sym;
2710 }