324       push(long2_type());
 325     }
 326     void      pop_long() {
 327       assert(type_at_tos() == long2_type(), "must be 2nd half");
 328       pop();
 329       assert(is_long(type_at_tos()), "must be long");
 330       pop();
 331     }
 332     void      push_object(ciKlass* klass) {
 333       push(klass);
 334     }
 335     void      pop_object() {
 336       assert(is_reference(type_at_tos()), "must be reference type");
 337       pop();
 338     }
 339     void      pop_array() {
 340       assert(type_at_tos() == null_type() ||
 341              type_at_tos()->is_array_klass(), "must be array type");
 342       pop();
 343     }
 344     // pop_objArray and pop_typeArray narrow the tos to ciObjArrayKlass
 345     // or ciTypeArrayKlass (resp.).  In the rare case that an explicit
 346     // null is popped from the stack, we return NULL.  Caller beware.
 347     ciObjArrayKlass* pop_objArray() {
 348       ciType* array = pop_value();
 349       if (array == null_type())  return NULL;
 350       assert(array->is_obj_array_klass(), "must be object array type");
 351       return array->as_obj_array_klass();


 352     }
 353     ciTypeArrayKlass* pop_typeArray() {
 354       ciType* array = pop_value();
 355       if (array == null_type())  return NULL;
 356       assert(array->is_type_array_klass(), "must be prim array type");
 357       return array->as_type_array_klass();
 358     }
 359     void      push_null() {
 360       push(null_type());
 361     }
 362     void      do_null_assert(ciKlass* unloaded_klass);
 363 
 364     // Helper convenience routines.
 365     void do_aaload(ciBytecodeStream* str);
 366     void do_checkcast(ciBytecodeStream* str);
 367     void do_getfield(ciBytecodeStream* str);
 368     void do_getstatic(ciBytecodeStream* str);
 369     void do_invoke(ciBytecodeStream* str, bool has_receiver);
 370     void do_jsr(ciBytecodeStream* str);
 371     void do_ldc(ciBytecodeStream* str);
 372     void do_multianewarray(ciBytecodeStream* str);
 373     void do_new(ciBytecodeStream* str);
 374     void do_vnew(ciBytecodeStream* str);
 375     void do_newarray(ciBytecodeStream* str);
 376     void do_putfield(ciBytecodeStream* str);
 377     void do_putstatic(ciBytecodeStream* str);
 378     void do_ret(ciBytecodeStream* str);
 379     void do_vunbox(ciBytecodeStream* str);
 380     void do_vbox(ciBytecodeStream* str);
 381 
 382     void overwrite_local_double_long(int index) {
 383       // Invalidate the previous local if it contains first half of
 384       // a double or long value since it's seconf half is being overwritten.
 385       int prev_index = index - 1;

 324       push(long2_type());
 325     }
 326     void      pop_long() {
 327       assert(type_at_tos() == long2_type(), "must be 2nd half");
 328       pop();
 329       assert(is_long(type_at_tos()), "must be long");
 330       pop();
 331     }
 332     void      push_object(ciKlass* klass) {
 333       push(klass);
 334     }
 335     void      pop_object() {
 336       assert(is_reference(type_at_tos()), "must be reference type");
 337       pop();
 338     }
 339     void      pop_array() {
 340       assert(type_at_tos() == null_type() ||
 341              type_at_tos()->is_array_klass(), "must be array type");
 342       pop();
 343     }
 344     // pop_valueOrobjArray and pop_typeArray narrow the tos to ciObjArrayKlass,
 345     // ciValueArrayKlass or ciTypeArrayKlass (resp.). In the rare case that an explicit
 346     // null is popped from the stack, we return NULL.  Caller beware.
 347     ciArrayKlass* pop_objOrValueArray() {
 348       ciType* array = pop_value();
 349       if (array == null_type())  return NULL;
 350       // Value type arrays may contain oop or flattened representation
 351       assert(array->is_obj_array_klass() || (ValueArrayFlatten && array->is_value_array_klass()),
 352              "must be value or object array type");
 353       return array->as_array_klass();
 354     }
 355     ciTypeArrayKlass* pop_typeArray() {
 356       ciType* array = pop_value();
 357       if (array == null_type())  return NULL;
 358       assert(array->is_type_array_klass(), "must be prim array type");
 359       return array->as_type_array_klass();
 360     }
 361     void      push_null() {
 362       push(null_type());
 363     }
 364     void      do_null_assert(ciKlass* unloaded_klass);
 365 
 366     // Helper convenience routines.
 367     void do_aload(ciBytecodeStream* str);
 368     void do_checkcast(ciBytecodeStream* str);
 369     void do_getfield(ciBytecodeStream* str);
 370     void do_getstatic(ciBytecodeStream* str);
 371     void do_invoke(ciBytecodeStream* str, bool has_receiver);
 372     void do_jsr(ciBytecodeStream* str);
 373     void do_ldc(ciBytecodeStream* str);
 374     void do_multianewarray(ciBytecodeStream* str);
 375     void do_new(ciBytecodeStream* str);
 376     void do_vnew(ciBytecodeStream* str);
 377     void do_newarray(ciBytecodeStream* str);
 378     void do_putfield(ciBytecodeStream* str);
 379     void do_putstatic(ciBytecodeStream* str);
 380     void do_ret(ciBytecodeStream* str);
 381     void do_vunbox(ciBytecodeStream* str);
 382     void do_vbox(ciBytecodeStream* str);
 383 
 384     void overwrite_local_double_long(int index) {
 385       // Invalidate the previous local if it contains first half of
 386       // a double or long value since it's seconf half is being overwritten.
 387       int prev_index = index - 1;