1 /*
   2  * Copyright (c) 2003, 2018, Oracle and/or its affiliates. All rights reserved.
   3  * Copyright (c) 2014, Red Hat Inc. All rights reserved.
   4  * Copyright (c) 2015, Linaro Ltd. All rights reserved.
   5  * Copyright (c) 2015-2018, Azul Systems, Inc. All rights reserved.
   6  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   7  *
   8  * This code is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU General Public License version 2 only, as
  10  * published by the Free Software Foundation.
  11  *
  12  * This code is distributed in the hope that it will be useful, but WITHOUT
  13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15  * version 2 for more details (a copy is included in the LICENSE file that
  16  * accompanied this code).
  17  *
  18  * You should have received a copy of the GNU General Public License version
  19  * 2 along with this work; if not, write to the Free Software Foundation,
  20  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  21  *
  22  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  23  * or visit www.oracle.com if you need additional information or have any
  24  * questions.
  25  *
  26  */
  27 
  28 #include "precompiled.hpp"
  29 #include "asm/macroAssembler.inline.hpp"
  30 #include "gc/shared/barrierSetAssembler.hpp"
  31 #include "interp_masm_aarch32.hpp"
  32 #include "interpreter/interpreter.hpp"
  33 #include "interpreter/interpreterRuntime.hpp"
  34 #include "interpreter/templateTable.hpp"
  35 #include "memory/universe.hpp"
  36 #include "oops/method.hpp"
  37 #include "oops/methodData.hpp"
  38 #include "oops/objArrayKlass.hpp"
  39 #include "oops/oop.inline.hpp"
  40 #include "prims/methodHandles.hpp"
  41 #include "runtime/frame.inline.hpp"
  42 #include "runtime/sharedRuntime.hpp"
  43 #include "runtime/stubRoutines.hpp"
  44 #include "runtime/synchronizer.hpp"
  45 #include "vm_version_aarch32.hpp"
  46 
  47 #define __ _masm->
  48 
  49 // Platform-dependent initialization
  50 
  51 extern void aarch32TestHook();
  52 
  53 void TemplateTable::pd_initialize() {
  54   aarch32TestHook();
  55 }
  56 
  57 // Address computation: local variables
  58 
  59 static inline Address iaddress(int n) {
  60   return Address(rlocals, Interpreter::local_offset_in_bytes(n));
  61 }
  62 
  63 static inline Address laddress(int n) {
  64   return iaddress(n + 1);
  65 }
  66 
  67 static inline Address faddress(int n) {
  68   return iaddress(n);
  69 }
  70 
  71 static inline Address daddress(int n) {
  72   return laddress(n);
  73 }
  74 
  75 static inline Address aaddress(int n) {
  76   return iaddress(n);
  77 }
  78 
  79 static inline Address iaddress(Register r) {
  80   return Address(rlocals, r, lsl(2));
  81 }
  82 
  83 // Note these two are different as VLDR/VSTR don't
  84 // support base + (offset{ << x })
  85 static inline Address faddress(Register r, Register scratch,
  86                                InterpreterMacroAssembler* _masm) {
  87   __ lea(scratch, Address(rlocals, r, lsl(2)));
  88   return Address(scratch);
  89 }
  90 
  91 static inline Address daddress(Register r, Register scratch,
  92                                InterpreterMacroAssembler* _masm) {
  93   __ lea(scratch, Address(rlocals, r, lsl(2)));
  94   return Address(scratch, Interpreter::local_offset_in_bytes(1));
  95 }
  96 
  97 static inline Address laddress(Register r, Register scratch,
  98                                InterpreterMacroAssembler * _masm) {
  99   return daddress(r, scratch, _masm);
 100 }
 101 
 102 static inline Address aaddress(Register r) {
 103   return iaddress(r);
 104 }
 105 
 106 static inline Address at_rsp() {
 107   return Address(sp, 0);
 108 }
 109 
 110 // At top of Java expression stack which may be different than sp().  It
 111 // isn't for category 1 objects.
 112 static inline Address at_tos   () {
 113   return Address(sp,  Interpreter::expr_offset_in_bytes(0));
 114 }
 115 
 116 static inline Address at_tos_p1() {
 117   return Address(sp,  Interpreter::expr_offset_in_bytes(1));
 118 }
 119 
 120 static inline Address at_tos_p2() {
 121   return Address(sp,  Interpreter::expr_offset_in_bytes(2));
 122 }
 123 
 124 static inline Address at_tos_p3() {
 125   return Address(sp,  Interpreter::expr_offset_in_bytes(3));
 126 }
 127 
 128 static inline Address at_tos_p4() {
 129   return Address(sp,  Interpreter::expr_offset_in_bytes(4));
 130 }
 131 
 132 static inline Address at_tos_p5() {
 133   return Address(sp,  Interpreter::expr_offset_in_bytes(5));
 134 }
 135 
 136 // Condition conversion
 137 static Assembler::Condition j_not(TemplateTable::Condition cc) {
 138   switch (cc) {
 139   case TemplateTable::equal        : return Assembler::NE;
 140   case TemplateTable::not_equal    : return Assembler::EQ;
 141   case TemplateTable::less         : return Assembler::GE;
 142   case TemplateTable::less_equal   : return Assembler::GT;
 143   case TemplateTable::greater      : return Assembler::LE;
 144   case TemplateTable::greater_equal: return Assembler::LT;
 145   }
 146   ShouldNotReachHere();
 147   return Assembler::EQ;
 148 }
 149 
 150 
 151 // Miscelaneous helper routines
 152 // Store an oop (or NULL) at the Address described by obj.
 153 // If val == noreg this means store a NULL
 154 static void do_oop_store(InterpreterMacroAssembler* _masm,
 155                          Address dst,
 156                          Register val,
 157                          DecoratorSet decorators) {
 158   assert(val == noreg || val == r0, "parameter is just for looks");
 159   assert(!dst.uses(r1) && !dst.uses(r14), "destroyed register");
 160   __ store_heap_oop(dst, val, r14, r1, decorators);
 161 }
 162 
 163 static void do_oop_load(InterpreterMacroAssembler* _masm,
 164                         Address src,
 165                         Register dst,
 166                         DecoratorSet decorators) {
 167   __ load_heap_oop(dst, src, r14, r1, decorators);
 168 }
 169 
 170 Address TemplateTable::at_bcp(int offset) {
 171   assert(_desc->uses_bcp(), "inconsistent uses_bcp information");
 172   return Address(rbcp, offset);
 173 }
 174 
 175 void TemplateTable::patch_bytecode(Bytecodes::Code bc, Register bc_reg,
 176                                    Register temp_reg, bool load_bc_into_bc_reg/*=true*/,
 177                                    int byte_no)
 178 {
 179   if (!RewriteBytecodes)  return;
 180   Label L_patch_done;
 181 
 182   switch (bc) {
 183   case Bytecodes::_fast_aputfield:
 184   case Bytecodes::_fast_bputfield:
 185   case Bytecodes::_fast_zputfield:
 186   case Bytecodes::_fast_cputfield:
 187   case Bytecodes::_fast_dputfield:
 188   case Bytecodes::_fast_fputfield:
 189   case Bytecodes::_fast_iputfield:
 190   case Bytecodes::_fast_lputfield:
 191   case Bytecodes::_fast_sputfield:
 192     {
 193       // We skip bytecode quickening for putfield instructions when
 194       // the put_code written to the constant pool cache is zero.
 195       // This is required so that every execution of this instruction
 196       // calls out to InterpreterRuntime::resolve_get_put to do
 197       // additional, required work.
 198       assert(byte_no == f1_byte || byte_no == f2_byte, "byte_no out of range");
 199       assert(load_bc_into_bc_reg, "we use bc_reg as temp");
 200       __ get_cache_and_index_and_bytecode_at_bcp(temp_reg, bc_reg, temp_reg, byte_no, 1);
 201       __ mov(bc_reg, bc);
 202       __ cmp(temp_reg, (unsigned) 0);
 203       __ b(L_patch_done, Assembler::EQ);  // don't patch
 204     }
 205     break;
 206   default:
 207     assert(byte_no == -1, "sanity");
 208     // the pair bytecodes have already done the load.
 209     if (load_bc_into_bc_reg) {
 210       __ mov(bc_reg, bc);
 211     }
 212   }
 213 
 214   if (JvmtiExport::can_post_breakpoint()) {
 215     Label L_fast_patch;
 216     // if a breakpoint is present we can't rewrite the stream directly
 217     __ load_unsigned_byte(temp_reg, at_bcp(0));
 218     __ cmp(temp_reg, Bytecodes::_breakpoint);
 219     __ b(L_fast_patch, Assembler::NE);
 220     // Let breakpoint table handling rewrite to quicker bytecode
 221     __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::set_original_bytecode_at), rmethod, rbcp, bc_reg);
 222     __ b(L_patch_done);
 223     __ bind(L_fast_patch);
 224   }
 225 
 226 #ifdef ASSERT
 227   Label L_okay;
 228   __ load_unsigned_byte(temp_reg, at_bcp(0));
 229   __ cmp(temp_reg, (int) Bytecodes::java_code(bc));
 230   __ b(L_okay, Assembler::EQ);
 231   __ cmp(temp_reg, bc_reg);
 232   __ b(L_okay, Assembler::EQ);
 233   __ stop("patching the wrong bytecode");
 234   __ bind(L_okay);
 235 #endif
 236 
 237   // patch bytecode
 238   __ strb(bc_reg, at_bcp(0));
 239   __ bind(L_patch_done);
 240 }
 241 
 242 
 243 // Individual instructions
 244 
 245 void TemplateTable::nop() {
 246   transition(vtos, vtos);
 247   // nothing to do
 248 }
 249 
 250 void TemplateTable::shouldnotreachhere() {
 251   transition(vtos, vtos);
 252   __ stop("shouldnotreachhere bytecode");
 253 }
 254 
 255 void TemplateTable::aconst_null()
 256 {
 257   transition(vtos, atos);
 258   __ mov(r0, 0);
 259 }
 260 
 261 void TemplateTable::iconst(int value)
 262 {
 263   transition(vtos, itos);
 264   __ mov(r0, value);
 265 }
 266 
 267 void TemplateTable::lconst(int value)
 268 {
 269   // int is 32 bit and only ever used for loading small values
 270   __ mov(r0, value & 0xffffffff);
 271   __ mov(r1, 0);
 272 }
 273 
 274 void TemplateTable::fconst(int value)
 275 {
 276   transition(vtos, ftos);
 277   float fval = value;
 278   assert(value == 0 || value == 1 || value == 2, "invalid float const");
 279   if (hasFPU()) {
 280     if(__ operand_valid_for_float_immediate(fval)) {
 281       __ vmov_f32(d0, fval);
 282     } else {
 283       __ mov(r0, *((uint32_t*)&fval));
 284       __ vmov_f32(d0, r0);
 285     }
 286   } else {
 287     __ mov(r0, *((uint32_t*)&fval));
 288   }
 289 }
 290 
 291 void TemplateTable::dconst(int value)
 292 {
 293   transition(vtos, dtos);
 294   double dval = value;
 295   assert(value == 0 || value == 1 || value == 2, "invalid double const");
 296   if (hasFPU()) {
 297     if(__ operand_valid_for_double_immediate(dval)) {
 298       __ vmov_f64(d0, dval);
 299     } else {
 300       uint32_t* ptr = (uint32_t*)&dval;
 301       __ mov(r0, *ptr);
 302       __ mov(r1, *(ptr + 1));
 303       __ vmov_f64(d0, r0, r1);
 304     }
 305   } else {
 306     uint32_t* ptr = (uint32_t*)&dval;
 307     __ mov(r0, *ptr);
 308     __ mov(r1, *(ptr + 1));
 309   }
 310 }
 311 
 312 void TemplateTable::bipush()
 313 {
 314   transition(vtos, itos);
 315   __ load_signed_byte(r0, at_bcp(1));
 316 }
 317 
 318 void TemplateTable::sipush()
 319 {
 320   transition(vtos, itos);
 321   __ load_unsigned_short(r0, at_bcp(1));
 322   __ rev(r0, r0);
 323   __ asr(r0, r0, 16);
 324 }
 325 
 326 void TemplateTable::ldc(bool wide)
 327 {
 328   transition(vtos, vtos);
 329   Label call_ldc, notFloat, notClass, notInt, Done;
 330 
 331   if (wide) {
 332     __ get_unsigned_2_byte_index_at_bcp(r1, 1);
 333   } else {
 334     __ load_unsigned_byte(r1, at_bcp(1));
 335   }
 336   __ get_cpool_and_tags(r2, r0);
 337 
 338   const int base_offset = ConstantPool::header_size() * wordSize;
 339   const int tags_offset = Array<u1>::base_offset_in_bytes();
 340 
 341   // get type
 342   __ add(r3, r1, tags_offset);
 343   __ ldrb(r3, Address(r0, r3));
 344 
 345   // unresolved class - get the resolved class
 346   __ cmp(r3, JVM_CONSTANT_UnresolvedClass);
 347   __ b(call_ldc, Assembler::EQ);
 348 
 349   // unresolved class in error state - call into runtime to throw the error
 350   // from the first resolution attempt
 351   __ cmp(r3, JVM_CONSTANT_UnresolvedClassInError);
 352   __ b(call_ldc, Assembler::EQ);
 353 
 354   // resolved class - need to call vm to get java mirror of the class
 355   __ cmp(r3, JVM_CONSTANT_Class);
 356   __ b(notClass, Assembler::NE);
 357 
 358   __ bind(call_ldc);
 359   __ mov(c_rarg1, wide);
 360   call_VM(r0, CAST_FROM_FN_PTR(address, InterpreterRuntime::ldc), c_rarg1);
 361   __ push_ptr(r0);
 362   __ verify_oop(r0);
 363   __ b(Done);
 364 
 365   __ bind(notClass);
 366   if (hasFPU()) {
 367     __ cmp(r3, JVM_CONSTANT_Float);
 368     __ b(notFloat, Assembler::NE);
 369     // ftos
 370     __ adds(r1, r2, r1, lsl(2));
 371     __ vldr_f32(d0, Address(r1, base_offset));
 372 
 373     __ push_f();
 374 
 375     __ b(Done);
 376 
 377     __ bind(notFloat);
 378   } else {
 379         // Soft FP pass through T_INT case.
 380 #ifdef ASSERT
 381         __ cmp(r3, JVM_CONSTANT_Float);
 382         __ mov(r3, JVM_CONSTANT_Integer,  Assembler::EQ);
 383 #endif // ASSER
 384   }
 385 
 386   __ cmp(r3, JVM_CONSTANT_Integer);
 387   __ b(notInt, Assembler::NE);
 388 
 389   // itos
 390   __ adds(r1, r2, r1, lsl(2));
 391   __ ldr(r0, Address(r1, base_offset));
 392   __ push_i(r0);
 393   __ b(Done);
 394 
 395   __ bind(notInt);
 396   condy_helper(Done);
 397 
 398   __ bind(Done);
 399 }
 400 
 401 // Fast path for caching oop constants.
 402 void TemplateTable::fast_aldc(bool wide)
 403 {
 404   transition(vtos, atos);
 405 
 406   Register result = r0;
 407   Register tmp = r1;
 408   Register rarg = r2;
 409 
 410   int index_size = wide ? sizeof(u2) : sizeof(u1);
 411 
 412   Label resolved;
 413 
 414   // We are resolved if the resolved reference cache entry contains a
 415   // non-null object (String, MethodType, etc.)
 416   assert_different_registers(result, tmp);
 417   __ get_cache_index_at_bcp(tmp, 1, index_size);
 418   __ load_resolved_reference_at_index(result, tmp);
 419   __ cbnz(result, resolved);
 420 
 421   address entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_ldc);
 422 
 423   // first time invocation - must resolve first
 424   __ mov(rarg, (int)bytecode());
 425   __ call_VM(result, entry, rarg);
 426 
 427   __ bind(resolved);
 428 
 429   { // Check for the null sentinel.
 430     // If we just called the VM, it already did the mapping for us,
 431     // but it's harmless to retry.
 432 
 433     // Stash null_sentinel address to get its value later
 434     __ movptr(rarg, (uintptr_t)Universe::the_null_sentinel_addr());
 435     __ ldr(tmp, Address(rarg));
 436     __ cmp(result, tmp);
 437     __ mov(result, 0, Assembler::EQ);  // NULL object reference
 438   }
 439 
 440   if (VerifyOops) {
 441     // Safe to call with 0 result
 442     __ verify_oop(result);
 443   }
 444 }
 445 
 446 void TemplateTable::ldc2_w()
 447 {
 448   transition(vtos, vtos);
 449   Label notLong, Done;
 450   __ get_unsigned_2_byte_index_at_bcp(r0, 1);
 451 
 452   __ get_cpool_and_tags(r1, r2);
 453   const int base_offset = ConstantPool::header_size() * wordSize;
 454   const int tags_offset = Array<u1>::base_offset_in_bytes();
 455 
 456   // get type
 457   __ lea(r2, Address(r2, r0, lsl(0)));
 458   __ load_unsigned_byte(r2, Address(r2, tags_offset));
 459   if (hasFPU()) {
 460     Label notDouble;
 461     __ cmp(r2, (int)JVM_CONSTANT_Double);
 462     __ b(notDouble, Assembler::NE);
 463     // dtos
 464     __ lea (r2, Address(r1, r0, lsl(2)));
 465     __ vldr_f64(d0, Address(r2, base_offset));
 466     __ push_d();
 467     __ b(Done);
 468 
 469     __ bind(notDouble);
 470   }
 471   __ cmp(r2, (int)JVM_CONSTANT_Long);
 472   __ b(notLong, Assembler::NE);
 473   // ltos
 474   __ lea(r1, Address(r1, r0, lsl(2)));
 475   __ ldr(r0, Address(r1, base_offset));
 476   __ ldr(r1, Address(r1, base_offset + wordSize));
 477   __ push_l();
 478   __ b(Done);
 479 
 480   __ bind(notLong);
 481   condy_helper(Done);
 482   __ bind(Done);
 483 }
 484 
 485 void TemplateTable::condy_helper(Label& Done)
 486 {
 487   Register obj = r0;
 488   Register rarg = r1;
 489   Register flags = r2;
 490   Register off = r3;
 491 
 492   address entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_ldc);
 493 
 494   __ mov(rarg, (int) bytecode());
 495   __ call_VM(obj, entry, rarg);
 496 
 497   __ get_vm_result_2(flags, rthread);
 498 
 499   // VMr = obj = base address to find primitive value to push
 500   // VMr2 = flags = (tos, off) using format of CPCE::_flags
 501   assert(ConstantPoolCacheEntry::field_index_mask == right_n_bits(ConstantPoolCacheEntry::field_index_bits),
 502           "fix the next line");
 503   __ ubfx(off, flags, 0, ConstantPoolCacheEntry::field_index_bits);
 504 
 505   const Address field(obj, off);
 506 
 507   // What sort of thing are we loading?
 508   __ ubfx(flags, flags, ConstantPoolCacheEntry::tos_state_shift,
 509            ConstantPoolCacheEntry::tos_state_bits);
 510 
 511   switch (bytecode()) {
 512     case Bytecodes::_ldc:
 513     case Bytecodes::_ldc_w:
 514       {
 515         // tos in (itos, ftos, stos, btos, ctos, ztos)
 516         Label notInt, notFloat, notShort, notByte, notChar, notBool;
 517         __ cmp(flags, itos);
 518         __ b(notInt, Assembler::NE);
 519         // itos
 520         __ ldr(r0, field);
 521         __ push(itos);
 522         __ b(Done);
 523 
 524         __ bind(notInt);
 525         __ cmp(flags, ftos);
 526         __ b(notFloat, Assembler::NE);
 527         // ftos
 528         __ lea(rarg, field); // vldr does not accept [r+r] address format
 529         __ load_float(Address(rarg));
 530         __ push(ftos);
 531         __ b(Done);
 532 
 533         __ bind(notFloat);
 534         __ cmp(flags, stos);
 535         __ b(notShort, Assembler::NE);
 536         // stos
 537         __ load_signed_short(r0, field);
 538         __ push(stos);
 539         __ b(Done);
 540 
 541         __ bind(notShort);
 542         __ cmp(flags, btos);
 543         __ b(notByte, Assembler::NE);
 544         // btos
 545         __ load_signed_byte(r0, field);
 546         __ push(btos);
 547         __ b(Done);
 548 
 549         __ bind(notByte);
 550         __ cmp(flags, ctos);
 551         __ b(notChar, Assembler::NE);
 552         // ctos
 553         __ load_unsigned_short(r0, field);
 554         __ push(ctos);
 555         __ b(Done);
 556 
 557         __ bind(notChar);
 558         __ cmp(flags, ztos);
 559         __ b(notBool, Assembler::NE);
 560         // ztos
 561         __ load_signed_byte(r0, field);
 562         __ push(ztos);
 563         __ b(Done);
 564 
 565         __ bind(notBool);
 566         break;
 567       }
 568 
 569     case Bytecodes::_ldc2_w:
 570       {
 571         Label notLong, notDouble;
 572         __ cmp(flags, ltos);
 573         __ b(notLong, Assembler::NE);
 574         // ltos
 575         __ ldrd(r0, r1, field);
 576         __ push(ltos);
 577         __ b(Done);
 578 
 579         __ bind(notLong);
 580         __ cmp(flags, dtos);
 581         __ b(notDouble, Assembler::NE);
 582         // dtos
 583         __ lea(rarg, field); // vdlr does not accept [r+r] address format
 584         __ load_double(Address(rarg));
 585         __ push(dtos);
 586         __ b(Done);
 587 
 588        __ bind(notDouble);
 589         break;
 590       }
 591 
 592     default:
 593       ShouldNotReachHere();
 594     }
 595 
 596     __ stop("bad ldc/condy");
 597 }
 598 
 599 void TemplateTable::locals_index(Register reg, int offset)
 600 {
 601   __ ldrb(reg, at_bcp(offset));
 602   __ neg(reg, reg);
 603 }
 604 
 605 void TemplateTable::iload() {
 606   iload_internal();
 607 }
 608 
 609 void TemplateTable::nofast_iload() {
 610   iload_internal(may_not_rewrite);
 611 }
 612 
 613 void TemplateTable::iload_internal(RewriteControl rc) {
 614   transition(vtos, itos);
 615   if (RewriteFrequentPairs && rc == may_rewrite) {
 616     Label rewrite, done;
 617     Register bc = r2;
 618 
 619     // get next bytecode
 620     __ load_unsigned_byte(r1, at_bcp(Bytecodes::length_for(Bytecodes::_iload)));
 621 
 622     // if _iload, wait to rewrite to iload2.  We only want to rewrite the
 623     // last two iloads in a pair.  Comparing against fast_iload means that
 624     // the next bytecode is neither an iload or a caload, and therefore
 625     // an iload pair.
 626     __ cmp(r1, Bytecodes::_iload);
 627     __ b(done, Assembler::EQ);
 628 
 629     // if _fast_iload rewrite to _fast_iload2
 630     __ cmp(r1, Bytecodes::_fast_iload);
 631     __ mov(bc, Bytecodes::_fast_iload2);
 632     __ b(rewrite, Assembler::EQ);
 633 
 634     // if _caload rewrite to _fast_icaload
 635     __ cmp(r1, Bytecodes::_caload);
 636     __ mov(bc, Bytecodes::_fast_icaload);
 637     __ b(rewrite, Assembler::EQ);
 638 
 639     // else rewrite to _fast_iload
 640     __ mov(bc, Bytecodes::_fast_iload);
 641 
 642     // rewrite
 643     // bc: new bytecode
 644     __ bind(rewrite);
 645     patch_bytecode(Bytecodes::_iload, bc, r1, false);
 646     __ bind(done);
 647 
 648   }
 649 
 650   // do iload, get the local value into tos
 651   locals_index(r1);
 652   __ ldr(r0, iaddress(r1));
 653   __ reg_printf("iloaded value %d\n", r0);
 654 }
 655 
 656 void TemplateTable::fast_iload2()
 657 {
 658   transition(vtos, itos);
 659   locals_index(r1);
 660   __ ldr(r0, iaddress(r1));
 661   __ push(itos);
 662   locals_index(r1, 3);
 663   __ ldr(r0, iaddress(r1));
 664 }
 665 
 666 void TemplateTable::fast_iload()
 667 {
 668   transition(vtos, itos);
 669   locals_index(r1);
 670   __ ldr(r0, iaddress(r1));
 671 }
 672 
 673 void TemplateTable::lload()
 674 {
 675   transition(vtos, ltos);
 676   locals_index(r2);
 677   __ ldrd(r0, r1, laddress(r2, r3, _masm));
 678 }
 679 
 680 void TemplateTable::fload()
 681 {
 682   transition(vtos, ftos);
 683   locals_index(r1);
 684   __ load_float(faddress(r1, r2, _masm));
 685 }
 686 
 687 void TemplateTable::dload()
 688 {
 689   transition(vtos, dtos);
 690   if (hasFPU()) {
 691     __ ldrb(r1, at_bcp(1));
 692     __ sub(r1, rlocals, r1, lsl(LogBytesPerWord));
 693     __ load_double(Address(r1, Interpreter::local_offset_in_bytes(1)));
 694   } else {
 695     locals_index(r2);
 696     __ load_double(daddress(r2, r3, _masm));
 697   }
 698 }
 699 
 700 void TemplateTable::aload()
 701 {
 702   transition(vtos, atos);
 703   locals_index(r1);
 704   __ ldr(r0, iaddress(r1));
 705 }
 706 
 707 void TemplateTable::locals_index_wide(Register reg) {
 708   __ ldrh(reg, at_bcp(2));
 709   __ rev16(reg, reg);
 710   __ neg(reg, reg);
 711 }
 712 
 713 void TemplateTable::wide_iload() {
 714   transition(vtos, itos);
 715   locals_index_wide(r1);
 716   __ ldr(r0, iaddress(r1));
 717 }
 718 
 719 void TemplateTable::wide_lload()
 720 {
 721   transition(vtos, ltos);
 722   locals_index_wide(r2);
 723   __ ldrd(r0, r1, laddress(r2, r3, _masm));
 724 }
 725 
 726 void TemplateTable::wide_fload()
 727 {
 728   transition(vtos, ftos);
 729   locals_index_wide(r1);
 730   if (hasFPU()) {
 731       __ vldr_f32(d0, faddress(r1, rscratch1, _masm));
 732   } else {
 733   __ ldr (r0, faddress(r1, rscratch1, _masm));
 734   }
 735 }
 736 
 737 void TemplateTable::wide_dload()
 738 {
 739   transition(vtos, dtos);
 740   if (hasFPU()) {
 741     __ ldrh(r1, at_bcp(2));
 742     __ rev16(r1, r1);
 743     __ sub(r1, rlocals, r1, lsl(LogBytesPerWord));
 744     __ vldr_f64(d0, Address(r1, Interpreter::local_offset_in_bytes(1)));
 745   } else {
 746     locals_index_wide(r2);
 747     __ ldrd(r0, r1, daddress(r2, r3, _masm));
 748   }
 749 }
 750 
 751 void TemplateTable::wide_aload()
 752 {
 753   transition(vtos, atos);
 754   locals_index_wide(r1);
 755   __ ldr(r0, aaddress(r1));
 756 }
 757 
 758 void TemplateTable::index_check(Register array, Register index)
 759 {
 760   // destroys rscratch1
 761   // check array
 762   __ null_check(array, arrayOopDesc::length_offset_in_bytes());
 763   // sign extend index for use by indexed load
 764   // __ movl2ptr(index, index);
 765   // check index
 766   Register length = rscratch1;
 767   __ ldr(length, Address(array, arrayOopDesc::length_offset_in_bytes()));
 768   __ reg_printf("Checking index in array, array = %p, alen = %d, index = %d\n", array, length, index);
 769   __ cmp(index, length);
 770   if (index != r2) {
 771     // ??? convention: move aberrant index into r2 for exception message
 772     assert(r2 != array, "different registers");
 773     __ mov(r2, index);
 774   }
 775   Label ok;
 776   __ b(ok, Assembler::LO);
 777   // ??? convention: move array into r3 for exception message
 778   __ mov(r3, array);
 779   __ mov(rscratch1, Interpreter::_throw_ArrayIndexOutOfBoundsException_entry);
 780   __ b(rscratch1);
 781   __ bind(ok);
 782 }
 783 
 784 void TemplateTable::iaload()
 785 {
 786   transition(itos, itos);
 787   __ mov(r2, r0);
 788   __ pop_ptr(r0);
 789   // r0: array
 790   // r2: index
 791   index_check(r0, r2); // leaves index in r2, kills rscratch1
 792   __ lea(r2, Address(r0, r2, lsl(2)));
 793   __ access_load_tos_at(T_INT, IN_HEAP | IS_ARRAY, Address(r2, arrayOopDesc::base_offset_in_bytes(T_INT)), noreg, noreg);
 794 }
 795 
 796 void TemplateTable::laload()
 797 {
 798   transition(itos, ltos);
 799   __ mov(r2, r0);
 800   __ pop_ptr(r0);
 801   // r0: array
 802   // r2: index
 803   index_check(r0, r2); // leaves index in r2, kills rscratch1
 804   __ lea(r2, Address(r0, r2, lsl(3)));
 805   __ lea(r2, Address(r2,  arrayOopDesc::base_offset_in_bytes(T_LONG)));
 806   __ atomic_ldrd(r0, r1, r2);
 807   __ access_load_tos_at(T_LONG, IN_HEAP | IS_ARRAY, Address(r2), noreg, noreg);
 808 }
 809 
 810 void TemplateTable::faload()
 811 {
 812   transition(itos, ftos);
 813   __ mov(r2, r0);
 814   __ pop_ptr(r0);
 815   // r0: array
 816   // r2: index
 817   index_check(r0, r2); // leaves index in r2, kills rscratch1
 818   __ lea(r2,  Address(r0, r2, lsl(2)));
 819   __ access_load_tos_at(T_FLOAT, IN_HEAP | IS_ARRAY,
 820           Address(r2, arrayOopDesc::base_offset_in_bytes(T_FLOAT)), noreg, noreg);
 821 }
 822 
 823 void TemplateTable::daload()
 824 {
 825   transition(itos, dtos);
 826   __ mov(r2, r0);
 827   __ pop_ptr(r0);
 828   // r0: array
 829   // r2: index
 830   index_check(r0, r2); // leaves index in r2, kills rscratch1
 831   __ lea(r2,  Address(r0, r2, lsl(3)));
 832   __ access_load_tos_at(T_DOUBLE, IN_HEAP | IS_ARRAY,
 833           Address(r2, arrayOopDesc::base_offset_in_bytes(T_DOUBLE)), noreg, noreg);
 834 }
 835 
 836 void TemplateTable::aaload()
 837 {
 838   transition(itos, atos);
 839   __ mov(r2, r0);
 840   __ pop_ptr(r0);
 841   // r0: array
 842   // r2: index
 843   index_check(r0, r2); // leaves index in r2, kills rscratch1
 844   __ lea(r2, Address(r0, r2, lsl(2)));
 845   do_oop_load(_masm,
 846               Address(r2, arrayOopDesc::base_offset_in_bytes(T_OBJECT)),
 847               r0,
 848               IS_ARRAY);
 849 }
 850 
 851 void TemplateTable::baload()
 852 {
 853   transition(itos, itos);
 854   __ mov(r2, r0);
 855   __ pop_ptr(r0);
 856   // r0: array
 857   // r2: index
 858   index_check(r0, r2); // leaves index in r2, kills rscratch1
 859   __ lea(r2,  Address(r0, r2, lsl(0)));
 860   __ access_load_tos_at(T_BYTE, IN_HEAP | IS_ARRAY, Address(r2, arrayOopDesc::base_offset_in_bytes(T_BYTE)), noreg, noreg);
 861 }
 862 
 863 void TemplateTable::caload()
 864 {
 865   transition(itos, itos);
 866   __ mov(r2, r0);
 867   __ pop_ptr(r0);
 868   // r0: array
 869   // r2: index
 870   index_check(r0, r2); // leaves index in r2, kills rscratch1
 871   __ lea(r2,  Address(r0, r2, lsl(1)));
 872   __ access_load_tos_at(T_CHAR, IN_HEAP | IS_ARRAY, Address(r2, arrayOopDesc::base_offset_in_bytes(T_CHAR)), noreg, noreg);
 873 }
 874 
 875 // iload followed by caload frequent pair
 876 void TemplateTable::fast_icaload()
 877 {
 878   transition(vtos, itos);
 879   // load index out of locals
 880   locals_index(r2);
 881   __ ldr(r2, iaddress(r2));
 882 
 883   __ pop_ptr(r0);
 884 
 885   // r0: array
 886   // r2: index
 887   index_check(r0, r2); // leaves index in r1, kills rscratch1
 888   __ lea(r2,  Address(r0, r2, lsl(1)));
 889   __ access_load_tos_at(T_CHAR, IN_HEAP | IS_ARRAY, Address(r2, arrayOopDesc::base_offset_in_bytes(T_CHAR)), noreg, noreg);
 890 }
 891 
 892 void TemplateTable::saload()
 893 {
 894   transition(itos, itos);
 895   __ mov(r2, r0);
 896   __ pop_ptr(r0);
 897   // r0: array
 898   // r2: index
 899   index_check(r0, r2); // leaves index in r2, kills rscratch1
 900   __ lea(r2,  Address(r0, r2, lsl(1)));
 901   __ access_load_tos_at(T_SHORT, IN_HEAP | IS_ARRAY, Address(r2, arrayOopDesc::base_offset_in_bytes(T_SHORT)), noreg, noreg);
 902 }
 903 
 904 void TemplateTable::iload(int n)
 905 {
 906   transition(vtos, itos);
 907   __ ldr(r0, iaddress(n));
 908 }
 909 
 910 void TemplateTable::lload(int n)
 911 {
 912   transition(vtos, ltos);
 913   __ ldrd(r0, r1, laddress(n));
 914 }
 915 
 916 void TemplateTable::fload(int n)
 917 {
 918   transition(vtos, ftos);
 919   if (hasFPU()) {
 920       __ vldr_f32(d0, faddress(n));
 921   } else {
 922     __ ldr(r0, faddress(n));
 923   }
 924 }
 925 
 926 void TemplateTable::dload(int n)
 927 {
 928   transition(vtos, dtos);
 929   if (hasFPU()) {
 930     __ vldr_f64(d0, daddress(n));
 931   } else {
 932     __ ldrd(r0, r1, daddress(n));
 933   }
 934 }
 935 
 936 void TemplateTable::aload(int n)
 937 {
 938   transition(vtos, atos);
 939   __ ldr(r0, iaddress(n));
 940   __ reg_printf("aload, loaded %p\n", r0);
 941 }
 942 
 943 void TemplateTable::aload_0() {
 944   aload_0_internal();
 945 }
 946 
 947 void TemplateTable::nofast_aload_0() {
 948   aload_0_internal(may_not_rewrite);
 949 }
 950 
 951 void TemplateTable::aload_0_internal(RewriteControl rc) {
 952   // According to bytecode histograms, the pairs:
 953   //
 954   // _aload_0, _fast_igetfield
 955   // _aload_0, _fast_agetfield
 956   // _aload_0, _fast_fgetfield
 957   //
 958   // occur frequently. If RewriteFrequentPairs is set, the (slow)
 959   // _aload_0 bytecode checks if the next bytecode is either
 960   // _fast_igetfield, _fast_agetfield or _fast_fgetfield and then
 961   // rewrites the current bytecode into a pair bytecode; otherwise it
 962   // rewrites the current bytecode into _fast_aload_0 that doesn't do
 963   // the pair check anymore.
 964   //
 965   // Note: If the next bytecode is _getfield, the rewrite must be
 966   //       delayed, otherwise we may miss an opportunity for a pair.
 967   //
 968   // Also rewrite frequent pairs
 969   //   aload_0, aload_1
 970   //   aload_0, iload_1
 971   // These bytecodes with a small amount of code are most profitable
 972   // to rewrite
 973   if (RewriteFrequentPairs && rc == may_rewrite) {
 974     Label rewrite, done;
 975     const Register bc = r14;
 976 
 977     // get next bytecode
 978     __ load_unsigned_byte(r1, at_bcp(Bytecodes::length_for(Bytecodes::_aload_0)));
 979 
 980     // if _getfield then wait with rewrite
 981     __ cmp(r1, Bytecodes::Bytecodes::_getfield);
 982     __ b(done, Assembler::EQ);
 983 
 984     // if _igetfield then rewrite to _fast_iaccess_0
 985     assert(Bytecodes::java_code(Bytecodes::_fast_iaccess_0) == Bytecodes::_aload_0, "fix bytecode definition");
 986     __ cmp(r1, Bytecodes::_fast_igetfield);
 987     __ mov(bc, Bytecodes::_fast_iaccess_0);
 988     __ b(rewrite, Assembler::EQ);
 989 
 990     // if _agetfield then rewrite to _fast_aaccess_0
 991     assert(Bytecodes::java_code(Bytecodes::_fast_aaccess_0) == Bytecodes::_aload_0, "fix bytecode definition");
 992     __ cmp(r1, Bytecodes::_fast_agetfield);
 993     __ mov(bc, Bytecodes::_fast_aaccess_0);
 994     __ b(rewrite, Assembler::EQ);
 995 
 996     // if _fgetfield then rewrite to _fast_faccess_0
 997     assert(Bytecodes::java_code(Bytecodes::_fast_faccess_0) == Bytecodes::_aload_0, "fix bytecode definition");
 998     __ cmp(r1, Bytecodes::_fast_fgetfield);
 999     __ mov(bc, Bytecodes::_fast_faccess_0);
1000     __ b(rewrite, Assembler::EQ);
1001 
1002     // else rewrite to _fast_aload0
1003     assert(Bytecodes::java_code(Bytecodes::_fast_aload_0) == Bytecodes::_aload_0, "fix bytecode definition");
1004     __ mov(bc, Bytecodes::Bytecodes::_fast_aload_0);
1005 
1006     // rewrite
1007     // bc: new bytecode
1008     __ bind(rewrite);
1009     patch_bytecode(Bytecodes::_aload_0, bc, r1, false);
1010 
1011     __ bind(done);
1012   }
1013 
1014   // Do actual aload_0 (must do this after patch_bytecode which might call VM and GC might change oop).
1015   aload(0);
1016 }
1017 
1018 void TemplateTable::istore()
1019 {
1020   transition(itos, vtos);
1021   locals_index(r1);
1022   __ lea(rscratch1, iaddress(r1));
1023   __ str(r0, Address(rscratch1));
1024 }
1025 
1026 void TemplateTable::lstore()
1027 {
1028   transition(ltos, vtos);
1029   locals_index(r2);
1030   __ strd(r0, r1, laddress(r2, r3, _masm));
1031 }
1032 
1033 void TemplateTable::fstore() {
1034   transition(ftos, vtos);
1035   locals_index(r1);
1036   __ lea(rscratch1, iaddress(r1));
1037   if (hasFPU()) {
1038       __ vstr_f32(d0, Address(rscratch1));
1039   } else {
1040     __ str(r0, Address(rscratch1));
1041   }
1042 }
1043 
1044 void TemplateTable::dstore() {
1045   transition(dtos, vtos);
1046   if (hasFPU()) {
1047     locals_index(r1);
1048     __ vstr_f64(d0, daddress(r1, rscratch1, _masm));
1049   } else {
1050     locals_index(r2);
1051     __ strd(r0, r1, daddress(r2, rscratch1, _masm));
1052   }
1053 }
1054 
1055 void TemplateTable::astore()
1056 {
1057   transition(vtos, vtos);
1058   __ pop_ptr(r0);
1059   __ reg_printf("Astore, storing value %p\n", r0);
1060   locals_index(r1);
1061   __ str(r0, aaddress(r1));
1062 }
1063 
1064 void TemplateTable::wide_istore() {
1065   transition(vtos, vtos);
1066   __ pop_i();
1067   locals_index_wide(r1);
1068   __ lea(rscratch1, iaddress(r1));
1069   __ str(r0, Address(rscratch1));
1070 }
1071 
1072 void TemplateTable::wide_lstore() {
1073   transition(vtos, vtos);
1074   __ pop_l();
1075   locals_index_wide(r2);
1076   __ strd(r0, r1, laddress(r2, r3, _masm));
1077 }
1078 
1079 void TemplateTable::wide_fstore() {
1080   transition(vtos, vtos);
1081   locals_index_wide(r1);
1082   __ lea(rscratch1, faddress(r1, rscratch1, _masm));
1083   if (hasFPU()) {
1084       __ pop_f();
1085     __ vstr_f32(d0, rscratch1);
1086   } else {
1087     __ pop_i();
1088     __ str(r0, Address(rscratch1));
1089   }
1090 }
1091 
1092 void TemplateTable::wide_dstore() {
1093   transition(vtos, vtos);
1094   if (hasFPU()) {
1095     __ pop_d();
1096     locals_index_wide(r1);
1097     __ vstr_f64(d0, daddress(r1, rscratch1, _masm));
1098   } else {
1099     __ pop_l();
1100     locals_index_wide(r2);
1101     __ strd(r0, r1, daddress(r2, rscratch1, _masm));
1102   }
1103 }
1104 
1105 void TemplateTable::wide_astore() {
1106   transition(vtos, vtos);
1107   __ pop_ptr(r0);
1108   locals_index_wide(r1);
1109   __ str(r0, aaddress(r1));
1110 }
1111 
1112 void TemplateTable::iastore() {
1113   transition(itos, vtos);
1114   __ pop_i(r2);
1115   __ pop_ptr(r3);
1116   // r0: value
1117   // r2: index
1118   // r3: array
1119   index_check(r3, r2); // prefer index in r2
1120   __ lea(rscratch1, Address(r3, r2, lsl(2)));
1121   __ access_store_tos_at(T_INT, IN_HEAP | IS_ARRAY,
1122                          Address(rscratch1, arrayOopDesc::base_offset_in_bytes(T_INT)), noreg, noreg);
1123 }
1124 
1125 void TemplateTable::lastore() {
1126   transition(ltos, vtos);
1127   __ pop_i(r2);
1128   __ pop_ptr(r3);
1129   // <r0:r1>: value
1130   // r2: index
1131   // r3: array
1132   index_check(r3, r2); // prefer index in r2
1133   __ lea(rscratch1, Address(r3, r2, lsl(3)));
1134   __ lea(rscratch1, Address(rscratch1,
1135                             arrayOopDesc::base_offset_in_bytes(T_LONG)));
1136   __ access_store_tos_at(T_LONG, IN_HEAP | IS_ARRAY, Address(rscratch1), noreg, noreg);
1137 }
1138 
1139 void TemplateTable::fastore() {
1140   transition(ftos, vtos);
1141   __ pop_i(r2);
1142   __ pop_ptr(r3);
1143   // d0/r0: value
1144   // r2:  index
1145   // r3:  array
1146   index_check(r3, r2); // prefer index in r2
1147   __ lea(rscratch1, Address(r3, r2, lsl(2)));
1148   __ access_store_tos_at(T_FLOAT, IN_HEAP | IS_ARRAY,
1149                          Address(rscratch1, arrayOopDesc::base_offset_in_bytes(T_FLOAT)), noreg, noreg);
1150 }
1151 
1152 void TemplateTable::dastore() {
1153   transition(dtos, vtos);
1154   __ pop_i(r2);
1155   __ pop_ptr(r3);
1156   // d0/r0:r1: value
1157   // r2:  index
1158   // r3:  array
1159   index_check(r3, r2); // prefer index in r2
1160   __ lea(rscratch1, Address(r3, r2, lsl(3)));
1161   __ access_store_tos_at(T_DOUBLE, IN_HEAP | IS_ARRAY,
1162           Address(rscratch1, arrayOopDesc::base_offset_in_bytes(T_DOUBLE)), noreg, noreg);
1163 }
1164 
1165 void TemplateTable::aastore() {
1166   Label is_null, ok_is_subtype, done;
1167   transition(vtos, vtos);
1168   // stack: ..., array, index, value
1169   __ ldr(r0, at_tos());    // value
1170   __ ldr(r2, at_tos_p1()); // index
1171   __ ldr(r3, at_tos_p2()); // array
1172 
1173   Address element_address(r2, arrayOopDesc::base_offset_in_bytes(T_OBJECT));
1174 
1175   index_check(r3, r2);
1176 
1177   // do array store check - check for NULL value first
1178   __ cmp(r0, 0);
1179   __ b(is_null, Assembler::EQ);
1180 
1181   // Move subklass into r1
1182   __ load_klass(r1, r0);
1183   // Move superklass into r0
1184   __ load_klass(r0, r3);
1185   __ ldr(r0, Address(r0,
1186                      ObjArrayKlass::element_klass_offset()));
1187   // Compress array + index*oopSize + 12 into a single register.  Frees r2.
1188 
1189   // Generate subtype check.  Blows r2, r14?
1190   // Superklass in r0.  Subklass in r1.
1191   __ gen_subtype_check(r1, ok_is_subtype);
1192 
1193   // Come here on failure
1194   // object is at TOS
1195   __ b(Interpreter::_throw_ArrayStoreException_entry);
1196 
1197   // Come here on success
1198   __ bind(ok_is_subtype);
1199 
1200   // Get the value we will store
1201   __ ldr(r0, at_tos());
1202   // And the clobbered index
1203   __ ldr(r2, at_tos_p1()); // index
1204   __ lea(r2, Address(r3, r2, lsl(2)));
1205   // Now store using the appropriate barrier
1206 
1207   do_oop_store(_masm, element_address, r0, IS_ARRAY);
1208   __ b(done);
1209 
1210   // Have a NULL in r0, r3=array, r2=index.  Store NULL at ary[idx]
1211   __ bind(is_null);
1212   __ profile_null_seen(r1);
1213 
1214   __ lea(r2, Address(r3, r2, lsl(2)));
1215   // Store a NULL
1216   do_oop_store(_masm, element_address, noreg, IS_ARRAY);
1217 
1218   // Pop stack arguments
1219   __ bind(done);
1220   __ add(sp, sp, 3 * Interpreter::stackElementSize);
1221 }
1222 
1223 void TemplateTable::bastore()
1224 {
1225   transition(itos, vtos);
1226   __ pop_i(r2);
1227   __ pop_ptr(r3);
1228   // r0: value
1229   // r2: index
1230   // r3: array
1231   index_check(r3, r2); // prefer index in r2
1232 
1233   // Need to check whether array is boolean or byte
1234   // since both types share the bastore bytecode.
1235   __ load_klass(r1, r3);
1236   __ ldr(r1, Address(r1, Klass::layout_helper_offset()));
1237   int diffbit = Klass::layout_helper_boolean_diffbit();
1238   __ tst(r1, diffbit);
1239   __ andr(r0, r0, 1, Assembler::NE);  // if it is a T_BOOLEAN array, mask the stored value to 0/1
1240 
1241   __ lea(rscratch1, Address(r3, r2));
1242   __ access_store_tos_at(T_BYTE, IN_HEAP | IS_ARRAY,
1243                          Address(rscratch1, arrayOopDesc::base_offset_in_bytes(T_BYTE)), noreg, noreg);
1244 }
1245 
1246 void TemplateTable::castore()
1247 {
1248   transition(itos, vtos);
1249   __ pop_i(r2);
1250   __ pop_ptr(r3);
1251   // r0: value
1252   // r2: index
1253   // r3: array
1254   index_check(r3, r2); // prefer index in r2
1255   __ lea(rscratch1, Address(r3, r2, lsl(1)));
1256   __ access_store_tos_at(T_CHAR, IN_HEAP | IS_ARRAY,
1257                          Address(rscratch1, arrayOopDesc::base_offset_in_bytes(T_CHAR)), noreg, noreg);
1258 }
1259 
1260 void TemplateTable::sastore()
1261 {
1262   castore();
1263 }
1264 
1265 void TemplateTable::istore(int n)
1266 {
1267   transition(itos, vtos);
1268   __ str(r0, iaddress(n));
1269 }
1270 
1271 void TemplateTable::lstore(int n)
1272 {
1273   transition(ltos, vtos);
1274   __ strd(r0, r1, laddress(n));
1275 }
1276 
1277 void TemplateTable::fstore(int n)
1278 {
1279   transition(ftos, vtos);
1280   if (hasFPU()) {
1281       __ vstr_f32(d0, faddress(n));
1282   } else {
1283     __ str(r0, faddress(n));
1284   }
1285 }
1286 
1287 void TemplateTable::dstore(int n)
1288 {
1289   transition(dtos, vtos);
1290   if (hasFPU()) {
1291       __ vstr_f64(d0, daddress(n));
1292   } else {
1293     __ strd(r0, r1, daddress(n));
1294   }
1295 }
1296 
1297 void TemplateTable::astore(int n)
1298 {
1299   transition(vtos, vtos);
1300   __ pop_ptr(r0);
1301   __ str(r0, iaddress(n));
1302 }
1303 
1304 void TemplateTable::pop()
1305 {
1306   transition(vtos, vtos);
1307   __ add(sp, sp, Interpreter::stackElementSize);
1308 }
1309 
1310 void TemplateTable::pop2()
1311 {
1312   transition(vtos, vtos);
1313   __ add(sp, sp, 2 * Interpreter::stackElementSize);
1314 }
1315 
1316 void TemplateTable::dup()
1317 {
1318   transition(vtos, vtos);
1319   __ ldr(r0, Address(sp, 0));
1320   __ reg_printf("Value duplicated is %p\n", r0);
1321   __ push(r0);
1322   // stack: ..., a, a
1323 }
1324 
1325 void TemplateTable::dup_x1()
1326 {
1327   transition(vtos, vtos);
1328   // stack: ..., a, b
1329   __ ldr(r0, at_tos());  // load b
1330   __ ldr(r2, at_tos_p1());  // load a
1331   __ str(r0, at_tos_p1());  // store b
1332   __ str(r2, at_tos());  // store a
1333   __ push(r0);                  // push b
1334   // stack: ..., b, a, b
1335 }
1336 
1337 void TemplateTable::dup_x2()
1338 {
1339   transition(vtos, vtos);
1340   // stack: ..., a, b, c
1341   __ ldr(r0, at_tos());  // load c
1342   __ ldr(r2, at_tos_p2());  // load a
1343   __ str(r0, at_tos_p2());  // store c in a
1344   __ push(r0);      // push c
1345   // stack: ..., c, b, c, c
1346   __ ldr(r0, at_tos_p2());  // load b
1347   __ str(r2, at_tos_p2());  // store a in b
1348   // stack: ..., c, a, c, c
1349   __ str(r0, at_tos_p1());  // store b in c
1350   // stack: ..., c, a, b, c
1351 }
1352 
1353 void TemplateTable::dup2()
1354 {
1355   transition(vtos, vtos);
1356   // stack: ..., a, b
1357   __ ldr(r0, at_tos_p1());  // load a
1358   __ push(r0);                  // push a
1359   __ ldr(r0, at_tos_p1());  // load b
1360   __ push(r0);                  // push b
1361   // stack: ..., a, b, a, b
1362 }
1363 
1364 void TemplateTable::dup2_x1()
1365 {
1366   transition(vtos, vtos);
1367   // stack: ..., a, b, c
1368   __ ldr(r2, at_tos());  // load c
1369   __ ldr(r0, at_tos_p1());  // load b
1370   __ push(r0);                  // push b
1371   __ push(r2);                  // push c
1372   // stack: ..., a, b, c, b, c
1373   __ str(r2, at_tos_p3());  // store c in b
1374   // stack: ..., a, c, c, b, c
1375   __ ldr(r2, at_tos_p4());  // load a
1376   __ str(r2, at_tos_p2());  // store a in 2nd c
1377   // stack: ..., a, c, a, b, c
1378   __ str(r0, at_tos_p4());  // store b in a
1379   // stack: ..., b, c, a, b, c
1380 }
1381 
1382 void TemplateTable::dup2_x2()
1383 {
1384   transition(vtos, vtos);
1385   // stack: ..., a, b, c, d
1386   __ ldr(r2, at_tos());  // load d
1387   __ ldr(r0, at_tos_p1());  // load c
1388   __ push(r0)            ;      // push c
1389   __ push(r2);                  // push d
1390   // stack: ..., a, b, c, d, c, d
1391   __ ldr(r0, at_tos_p4());  // load b
1392   __ str(r0, at_tos_p2());  // store b in d
1393   __ str(r2, at_tos_p4());  // store d in b
1394   // stack: ..., a, d, c, b, c, d
1395   __ ldr(r2, at_tos_p5());  // load a
1396   __ ldr(r0, at_tos_p3());  // load c
1397   __ str(r2, at_tos_p3());  // store a in c
1398   __ str(r0, at_tos_p5());  // store c in a
1399   // stack: ..., c, d, a, b, c, d
1400 }
1401 
1402 void TemplateTable::swap()
1403 {
1404   transition(vtos, vtos);
1405   // stack: ..., a, b
1406   __ ldr(r2, at_tos_p1());  // load a
1407   __ ldr(r0, at_tos());  // load b
1408   __ str(r2, at_tos());  // store a in b
1409   __ str(r0, at_tos_p1());  // store b in a
1410   // stack: ..., b, a
1411 }
1412 
1413 void TemplateTable::iop2(Operation op)
1414 {
1415   transition(itos, itos);
1416   // r0 <== r1 op r0
1417   __ pop_i(r1);
1418   switch (op) {
1419   case add  : __ add(r0, r1, r0);  break;
1420   case sub  : __ sub(r0, r1, r0);  break;
1421   case mul  : __ mul(r0, r1, r0);  break;
1422   case _and : __ andr(r0, r1, r0); break;
1423   case _or  : __ orr(r0, r1, r0);  break;
1424   case _xor : __ eor(r0, r1, r0);  break;
1425   case shl  :
1426       __ andr(r0, r0, 0x1f);
1427       __ lsl(r0, r1, r0);
1428       break;
1429   case shr  :
1430       __ andr(r0, r0, 0x1f);
1431       __ asr(r0, r1, r0);
1432       break;
1433   case ushr :
1434       __ andr(r0, r0, 0x1f);
1435       __ lsr(r0, r1, r0);
1436       break;
1437   default   : ShouldNotReachHere();
1438   }
1439 }
1440 
1441 void TemplateTable::lop2(Operation op)
1442 {
1443   transition(ltos, ltos);
1444   // <r1:r0> <== <r3:r2> op <r1:r0>
1445   __ pop_l(r2, r3);
1446   switch (op) {
1447   case add  : __ adds(r0, r2, r0); __ adc(r1, r3, r1);  break;
1448   case sub  : __ subs(r0, r2, r0); __ sbc(r1, r3, r1);  break;
1449   case mul  : __ mult_long(r0, r2, r0);                 break;
1450   case _and : __ andr(r0, r2, r0); __ andr(r1, r3, r1); break;
1451   case _or  : __ orr(r0, r2, r0);  __ orr(r1, r3, r1);  break;
1452   case _xor : __ eor(r0, r2, r0);  __ eor(r1, r3, r1);  break;
1453   default   : ShouldNotReachHere();
1454   }
1455 }
1456 
1457 void TemplateTable::idiv()
1458 {
1459   transition(itos, itos);
1460   // explicitly check for div0
1461   Label no_div0;
1462   __ cmp(r0, 0);
1463   __ b(no_div0, Assembler::NE);
1464   __ mov(rscratch1, Interpreter::_throw_ArithmeticException_entry);
1465   __ b(rscratch1);
1466   __ bind(no_div0);
1467   __ pop_i(r1);
1468   // r0 <== r1 idiv r0
1469   __ divide(r0, r1, r0, 32, false);
1470 }
1471 
1472 void TemplateTable::irem()
1473 {
1474   transition(itos, itos);
1475   // explicitly check for div0
1476   Label no_div0;
1477   __ cmp(r0, 0);
1478   __ b(no_div0, Assembler::NE);
1479   __ mov(rscratch1, Interpreter::_throw_ArithmeticException_entry);
1480   __ b(rscratch1);
1481   __ bind(no_div0);
1482   __ pop_i(r1);
1483   // r0 <== r1 irem r0
1484   __ divide(r0, r1, r0, 32, true);
1485 }
1486 
1487 void TemplateTable::lmul()
1488 {
1489   transition(ltos, ltos);
1490   __ pop_l(r2, r3);
1491   __ mult_long(r0, r0, r2);
1492 }
1493 
1494 void TemplateTable::ldiv()
1495 {
1496   transition(ltos, ltos);
1497   // explicitly check for div0
1498   __ cmp(r0, 0);
1499   __ cmp(r1, 0, Assembler::EQ);
1500   __ mov(rscratch1, Interpreter::_throw_ArithmeticException_entry, Assembler::EQ);
1501   __ b(rscratch1, Assembler::EQ);
1502 
1503   __ pop_l(r2, r3);
1504   // r0 <== r1 ldiv r0
1505   __ divide(r0, r2, r0, 64, false);
1506 }
1507 
1508 void TemplateTable::lrem()
1509 {
1510   transition(ltos, ltos);
1511   // explicitly check for div0
1512   __ cmp(r0, 0);
1513   __ cmp(r1, 0, Assembler::EQ);
1514   __ mov(rscratch1, Interpreter::_throw_ArithmeticException_entry, Assembler::EQ);
1515   __ b(rscratch1, Assembler::EQ);
1516 
1517   __ pop_l(r2, r3);
1518   // r0 <== r1 lrem r0
1519   __ divide(r0, r2, r0, 64, true);
1520 }
1521 
1522 void TemplateTable::lshl() {
1523     transition(itos, ltos);
1524     // shift count is in r0 - take shift from bottom six bits only
1525     __ andr(r0, r0, 0x3f);
1526     __ pop_l(r2, r3);
1527     const int word_bits = 8 * wordSize;
1528 
1529     __ sub(r1, r0, word_bits);
1530     __ lsl(r3, r3, r0);
1531     __ orr(r3, r3, r2, lsl(r1));
1532     __ rsb(r1, r0, word_bits);
1533     __ orr(r1, r3, r2, lsr(r1));
1534     __ lsl(r0, r2, r0);
1535 }
1536 
1537 void TemplateTable::lshr() {
1538     transition(itos, ltos);
1539     // shift count is in r0 - take shift from bottom six bits only
1540     __ andr(rscratch1, r0, 0x3f);
1541     __ pop_l(r2, r3);
1542     const int word_bits = 8 * wordSize;
1543 
1544     __ lsr(r2, r2, rscratch1);
1545     __ rsb(r1, rscratch1, word_bits);
1546     __ orr(r0, r2, r3, lsl(r1));
1547     __ asr(r1, r3, rscratch1);
1548     __ subs(rscratch1, rscratch1, word_bits);
1549     __ orr(r0, r2, r3, asr(rscratch1), Assembler::GT);
1550 }
1551 
1552 void TemplateTable::lushr() {
1553     transition(itos, ltos);
1554     // shift count is in r0 - take shift from bottom six bits only
1555     __ andr(r0, r0, 0x3f);
1556     __ pop_l(r2, r3);
1557     const int word_bits = 8 * wordSize;
1558 
1559     __ lsr(r2, r2, r0);
1560     __ rsb(r1, r0, word_bits);
1561     __ orr(r2, r2, r3, lsl(r1));
1562     __ lsr(r1, r3, r0);
1563     __ sub(r0, r0, word_bits);
1564     __ orr(r0, r2, r3, lsr(r0));
1565 }
1566 
1567 void TemplateTable::fop2(Operation op)
1568 {
1569   transition(ftos, ftos);
1570   if(hasFPU()) {
1571     switch (op) {
1572     case add:
1573       __ pop_f(d1);
1574       __ vadd_f32(d0, d1, d0);
1575       break;
1576     case sub:
1577       __ pop_f(d1);
1578       __ vsub_f32(d0, d1, d0);
1579       break;
1580     case mul:
1581       __ pop_f(d1);
1582       __ vmul_f32(d0, d1, d0);
1583       break;
1584     case div:
1585       __ pop_f(d1);
1586       __ vdiv_f32(d0, d1, d0);
1587       break;
1588     case rem:
1589       __ vmov_f32(f1, f0);
1590       __ pop_f(f0);
1591       #ifndef HARD_FLOAT_CC
1592       __ vmov_f32(r0, f0);
1593       __ vmov_f32(r1, f1);
1594       #endif
1595       __ mov(rscratch1, (address)fmodf);
1596       __ bl(rscratch1);
1597       #ifndef HARD_FLOAT_CC
1598       __ vmov_f32(f0, r0);
1599       #endif
1600       break;
1601     default:
1602       ShouldNotReachHere();
1603       break;
1604     }
1605   } else {
1606 #ifdef __SOFTFP__
1607     __ mov(r1, r0);
1608     __ pop_i(r0);
1609     switch (op) {
1610     case add:
1611       __ call_VM_leaf_base(CAST_FROM_FN_PTR(address, SharedRuntime::fadd), 0);
1612       break;
1613     case sub:
1614       __ call_VM_leaf_base(CAST_FROM_FN_PTR(address, SharedRuntime::fsub), 0);
1615       break;
1616     case mul:
1617       __ call_VM_leaf_base(CAST_FROM_FN_PTR(address, SharedRuntime::fmul), 0);
1618       break;
1619     case div:
1620       __ call_VM_leaf_base(CAST_FROM_FN_PTR(address, SharedRuntime::fdiv), 0);
1621       break;
1622     case rem:
1623       __ call_VM_leaf_base(CAST_FROM_FN_PTR(address, SharedRuntime::frem), 0);
1624       break;
1625     default:
1626       ShouldNotReachHere();
1627       break;
1628     }
1629   #else
1630       // expected -mfloat-abi=soft
1631       ShouldNotReachHere();
1632 #endif
1633 }
1634 }
1635 
1636 void TemplateTable::dop2(Operation op)
1637 {
1638   transition(dtos, dtos);
1639   if (hasFPU()) {
1640     switch (op) {
1641     case add:
1642       __ pop_d(d1);
1643       __ vadd_f64(d0, d1, d0);
1644       break;
1645     case sub:
1646       __ pop_d(d1);
1647       __ vsub_f64(d0, d1, d0);
1648       break;
1649     case mul:
1650       __ pop_d(d1);
1651       __ vmul_f64(d0, d1, d0);
1652       break;
1653     case div:
1654       __ pop_d(d1);
1655       __ vdiv_f64(d0, d1, d0);
1656       break;
1657     case rem:
1658       __ vmov_f64(d1, d0);
1659       __ pop_d(d0);
1660       #ifndef HARD_FLOAT_CC
1661       __ vmov_f64(r0, r1, d0);
1662       __ vmov_f64(r2, r3, d1);
1663       #endif
1664       __ mov(rscratch1, (address)(double (*)(double, double))fmod);
1665       __ bl(rscratch1);
1666       #ifndef HARD_FLOAT_CC
1667       __ vmov_f64(d0, r0, r1);
1668       #endif
1669       break;
1670     default:
1671       ShouldNotReachHere();
1672       break;
1673     }
1674   } else {
1675 #ifdef __SOFTFP__
1676     __ push_l(r0, r1);
1677     __ pop_l(r2,r3);
1678     __ pop_l(r0,r1);
1679     switch (op) {
1680     case add:
1681       __ call_VM_leaf_base(CAST_FROM_FN_PTR(address, SharedRuntime::dadd), 0);
1682       break;
1683     case sub:
1684       __ call_VM_leaf_base(CAST_FROM_FN_PTR(address, SharedRuntime::dsub), 0);
1685       break;
1686     case mul:
1687       __ call_VM_leaf_base(CAST_FROM_FN_PTR(address, SharedRuntime::dmul), 0);
1688       break;
1689     case div:
1690       __ call_VM_leaf_base(CAST_FROM_FN_PTR(address, SharedRuntime::ddiv), 0);
1691       break;
1692     case rem:
1693       __ call_VM_leaf_base(CAST_FROM_FN_PTR(address, SharedRuntime::drem), 0);
1694       break;
1695     default:
1696       ShouldNotReachHere();
1697       break;
1698     }
1699 #else
1700       // expected -mfloat-abi=soft
1701       ShouldNotReachHere();
1702 #endif
1703   }
1704 }
1705 
1706 void TemplateTable::ineg()
1707 {
1708   transition(itos, itos);
1709   __ neg(r0, r0);
1710 
1711 }
1712 
1713 void TemplateTable::lneg()
1714 {
1715   transition(ltos, ltos);
1716   __ rsbs(r0, r0, 0);
1717   __  rsc(r1, r1, 0);
1718 }
1719 
1720 void TemplateTable::fneg()
1721 {
1722   transition(ftos, ftos);
1723   if(hasFPU()) {
1724       __ vneg_f32(d0, d0);
1725   } else {
1726 #ifdef __SOFTFP__
1727     __ call_VM_leaf_base(CAST_FROM_FN_PTR(address, SharedRuntime::fneg), 0);
1728 #else
1729       // expected -mfloat-abi=soft
1730       ShouldNotReachHere();
1731 #endif
1732   }
1733 }
1734 
1735 void TemplateTable::dneg()
1736 {
1737   transition(dtos, dtos);
1738   if(hasFPU()) {
1739       __ vneg_f64(d0, d0);
1740   } else {
1741 #ifdef __SOFTFP__
1742       __ call_VM_leaf_base(CAST_FROM_FN_PTR(address, SharedRuntime::dneg), 0);
1743 #else
1744       // expected -mfloat-abi=soft
1745       ShouldNotReachHere();
1746 #endif
1747   }
1748 }
1749 
1750 void TemplateTable::iinc()
1751 {
1752   transition(vtos, vtos);
1753   __ load_signed_byte(r1, at_bcp(2)); // get constant
1754   locals_index(r2);
1755   __ ldr(r0, iaddress(r2));
1756   __ add(r0, r0, r1);
1757   __ str(r0, iaddress(r2));
1758 }
1759 
1760 void TemplateTable::wide_iinc()
1761 {
1762   transition(vtos, vtos);
1763   __ ldr(r1, at_bcp(2)); // get constant and index
1764   __ rev16(r1, r1);
1765   __ uxth(r2, r1);
1766   __ neg(r2, r2);
1767   __ sxth(r1, r1, ror(16));
1768   __ ldr(r0, iaddress(r2));
1769   __ add(r0, r0, r1);
1770   __ str(r0, iaddress(r2));
1771 }
1772 
1773 void TemplateTable::convert()
1774 {
1775   // Checking
1776 #ifdef ASSERT
1777   {
1778     TosState tos_in  = ilgl;
1779     TosState tos_out = ilgl;
1780     switch (bytecode()) {
1781     case Bytecodes::_i2l: // fall through
1782     case Bytecodes::_i2f: // fall through
1783     case Bytecodes::_i2d: // fall through
1784     case Bytecodes::_i2b: // fall through
1785     case Bytecodes::_i2c: // fall through
1786     case Bytecodes::_i2s: tos_in = itos; break;
1787     case Bytecodes::_l2i: // fall through
1788     case Bytecodes::_l2f: // fall through
1789     case Bytecodes::_l2d: tos_in = ltos; break;
1790     case Bytecodes::_f2i: // fall through
1791     case Bytecodes::_f2l: // fall through
1792     case Bytecodes::_f2d: tos_in = ftos; break;
1793     case Bytecodes::_d2i: // fall through
1794     case Bytecodes::_d2l: // fall through
1795     case Bytecodes::_d2f: tos_in = dtos; break;
1796     default             : ShouldNotReachHere();
1797     }
1798     switch (bytecode()) {
1799     case Bytecodes::_l2i: // fall through
1800     case Bytecodes::_f2i: // fall through
1801     case Bytecodes::_d2i: // fall through
1802     case Bytecodes::_i2b: // fall through
1803     case Bytecodes::_i2c: // fall through
1804     case Bytecodes::_i2s: tos_out = itos; break;
1805     case Bytecodes::_i2l: // fall through
1806     case Bytecodes::_f2l: // fall through
1807     case Bytecodes::_d2l: tos_out = ltos; break;
1808     case Bytecodes::_i2f: // fall through
1809     case Bytecodes::_l2f: // fall through
1810     case Bytecodes::_d2f: tos_out = ftos; break;
1811     case Bytecodes::_i2d: // fall through
1812     case Bytecodes::_l2d: // fall through
1813     case Bytecodes::_f2d: tos_out = dtos; break;
1814     default             : ShouldNotReachHere();
1815     }
1816     transition(tos_in, tos_out);
1817   }
1818 #endif // ASSERT
1819   // static const int64_t is_nan = 0x8000000000000000L;
1820   //TODO fix this and remove _ sxtw and _ uxtw as don't exist in arm32
1821   // need to figure out about handling doubles and longs as they won't
1822   // fit into a single register in arm32
1823   // Conversion
1824   switch (bytecode()) {
1825   case Bytecodes::_i2l:
1826     // __ sxtw(r0, r0);
1827     __ reg_printf("Convert i2l (before) 0x00000000%08x\n", r0);
1828     __ asr(r1, r0, 31);
1829     __ reg_printf("Convert i2l (after) 0x%08x%08x\n", r1, r0);
1830     break;
1831   case Bytecodes::_i2f:
1832     if(hasFPU()) {
1833       __ vmov_f32(d0, r0);
1834       __ vcvt_f32_s32(d0, d0);
1835     } else {
1836 #ifdef __SOFTFP__
1837       __ call_VM_leaf_base(CAST_FROM_FN_PTR(address, SharedRuntime::i2f), 0);
1838 #else
1839       // expected -mfloat-abi=soft
1840       ShouldNotReachHere();
1841 #endif
1842     }
1843     break;
1844   case Bytecodes::_i2d:
1845     if(hasFPU()) {
1846       //__ scvtfwd(d0, r0);
1847       __ vmov_f32(d0, r0);
1848       __ vcvt_f64_s32(d0, d0);
1849     } else {
1850 #ifdef __SOFTFP__
1851         // ro -> <r1:r0>
1852       __ call_VM_leaf_base(CAST_FROM_FN_PTR(address, SharedRuntime::i2d), 0);
1853 #else
1854       // expected -mfloat-abi=soft
1855       ShouldNotReachHere();
1856 #endif
1857     }
1858     break;
1859   case Bytecodes::_i2b:
1860     __ sxtb(r0, r0);
1861     break;
1862   case Bytecodes::_i2c:
1863     __ uxth(r0, r0);
1864     break;
1865   case Bytecodes::_i2s:
1866     __ sxth(r0, r0);
1867     break;
1868   case Bytecodes::_l2i:
1869     //__ uxtw(r0, r0);
1870     break;
1871   case Bytecodes::_l2f:
1872     // <r1:r0> -> d0
1873     // or <r1:r0> -> r0 for softfp
1874     __ call_VM_leaf_base(CAST_FROM_FN_PTR(address, SharedRuntime::l2f), 0);
1875 #ifndef HARD_FLOAT_CC
1876     if(hasFPU()) {
1877         __ vmov_f32(d0, r0);
1878     }
1879 #endif
1880     break;
1881   case Bytecodes::_l2d:
1882     // <r1:r0> -> d0
1883     // or <r1:r0> -> <r1:r0> for softfp
1884     __ call_VM_leaf_base(CAST_FROM_FN_PTR(address, SharedRuntime::l2d), 0);
1885 #ifndef HARD_FLOAT_CC
1886     if(hasFPU()) {
1887         __ vmov_f64(d0, r0, r1);
1888     }
1889 #endif
1890     break;
1891   case Bytecodes::_f2i:
1892   {
1893       if(hasFPU()) {
1894         __ vcvt_s32_f32(d0, d0);
1895         __ vmov_f32(r0, d0);
1896       } else {
1897         __ call_VM_leaf_base(CAST_FROM_FN_PTR(address, SharedRuntime::f2i), 0);
1898       }
1899   }
1900     break;
1901   case Bytecodes::_f2l:
1902   {
1903 #if !defined(HARD_FLOAT_CC)
1904     //float already in d0 long goes to <r1:r0>
1905     if(hasFPU()) {
1906         //Need to move float in d0 to r0
1907         __ vmov_f32(r0, d0);
1908     }
1909 #endif //!defined(HARD_FLOAT_CC)
1910     __ call_VM_leaf_base(CAST_FROM_FN_PTR(address, SharedRuntime::f2l), 0);
1911   }
1912     break;
1913   case Bytecodes::_f2d:
1914     if(hasFPU()) {
1915         __ vcvt_f64_f32(d0, d0);
1916     } else {
1917 #ifdef __SOFTFP__
1918         __ call_VM_leaf_base(CAST_FROM_FN_PTR(address, SharedRuntime::f2d), 0);
1919 #else
1920       // expected -mfloat-abi=soft
1921       ShouldNotReachHere();
1922 #endif
1923     }
1924     break;
1925   case Bytecodes::_d2i:
1926   {
1927     if(hasFPU()) {
1928         __ vcvt_s32_f64(d0, d0);
1929         __ vmov_f32(r0, d0);
1930     } else {
1931 #ifdef __SOFTFP__
1932         __ call_VM_leaf_base(CAST_FROM_FN_PTR(address, SharedRuntime::d2i), 0);
1933 #else
1934         // expected -mfloat-abi=soft
1935         ShouldNotReachHere();
1936 #endif
1937     }
1938   }
1939     break;
1940   case Bytecodes::_d2l:
1941   {
1942     // d0 -> <r1:r0>
1943 #if !defined(HARD_FLOAT_CC)
1944     if(hasFPU()) {
1945         //Need to move float in d0 to r0
1946         __ vmov_f64(r0, r1, d0);
1947     }
1948 #endif //!defined(HARD_FLOAT_CC)
1949     __ call_VM_leaf_base(CAST_FROM_FN_PTR(address, SharedRuntime::d2l), 0);
1950   }
1951     break;
1952   case Bytecodes::_d2f:
1953     if(hasFPU()) {
1954         __ vcvt_f32_f64(d0, d0);
1955     } else {
1956 #ifdef __SOFTFP__
1957         __ call_VM_leaf_base(CAST_FROM_FN_PTR(address, SharedRuntime::d2f), 0);
1958 #else
1959       // expected -mfloat-abi=soft
1960       ShouldNotReachHere();
1961 #endif
1962     }
1963     break;
1964   default:
1965     ShouldNotReachHere();
1966   }
1967 }
1968 
1969 void TemplateTable::lcmp()
1970 {
1971   transition(ltos, itos);
1972   __ pop_l(r2, r3);
1973   // <r1:r0> == <r3:r2> : 0
1974   // <r1:r0> < <r3:r2> : 1
1975   // <r1:r0> > <r3:r2> : -1
1976   __ reg_printf("Long comparing 0x%08x%08x\n", r1, r0);
1977   __ reg_printf("           and 0x%08x%08x\n", r3, r2);
1978   //cmp high
1979   Label lower, end;
1980   __ cmp(r3, r1);
1981   __ b(lower, Assembler::EQ);
1982   __ mov(r0, 1);
1983   __ sub(r0, r0, 2, Assembler::LT);
1984   __ b(end);
1985 
1986   __ bind(lower);
1987   __ subs(r0, r2, r0);
1988   __ mov(r0, 1, Assembler::NE);
1989   __ sub(r0, r0, 2, Assembler::LO); // Place -1
1990   __ bind(end);
1991 
1992   __ reg_printf("Result of comparison is %d\n", r0);
1993 }
1994 
1995 void TemplateTable::float_cmp(bool is_float, int unordered_result)
1996 {
1997     if(hasFPU()) {
1998         if (is_float) {
1999          __ pop_f(d1);
2000          __ vcmp_f32(d1, d0);
2001        } else {
2002          __ pop_d(d1);
2003          /*__ vmov_f64(r0, r1, d0);
2004          __ vmov_f64(r2, r3, d1);
2005          __ reg_printf("Doing comparison cmp( 0x%08x%08x,\n", r3, r2);
2006          __ reg_printf("                      0x%08x%08x)\n", r1, r0);*/
2007          __ vcmp_f64(d1, d0);
2008        }
2009        __ vmrs(rscratch1);
2010        __ andr(rscratch1, rscratch1, Assembler::FP_MASK);
2011        __ reg_printf("Masked comparison result is %08x\n", rscratch1);
2012 
2013        if (unordered_result < 0) {
2014          // we want -1 for unordered or less than, 0 for equal and 1 for
2015          // greater than.
2016          __ mov(r0, -1);
2017          __ cmp(rscratch1, Assembler::FP_EQ);
2018          __ mov(r0, 0, Assembler::EQ);
2019          __ cmp(rscratch1, Assembler::FP_GT);
2020          __ mov(r0, 1, Assembler::EQ);
2021          __ reg_printf("un_res < 0, comparison result is %d\n", r0);
2022        } else {
2023          // we want -1 for less than, 0 for equal and 1 for unordered or
2024          // greater than.
2025          __ mov(r0, 1);
2026          __ cmp(rscratch1, Assembler::FP_LT);
2027          __ sub(r0, r0, 2, Assembler::EQ); //Load -1 - but one less instruction
2028          __ cmp(rscratch1, Assembler::FP_EQ);
2029          __ mov(r0, 0, Assembler::EQ);
2030          __ reg_printf("un_res >= 0, comparison result is %d\n", r0);
2031        }
2032     } else { // hasFPU
2033 #ifdef __SOFTFP__
2034         if (is_float) {
2035             __ mov(r1, r0);
2036             __ pop_i(r0);
2037             if (unordered_result < 0) {
2038                 __ call_VM_leaf_base(CAST_FROM_FN_PTR(address, SharedRuntime::fcmpl), 0);
2039             } else {
2040                 __ call_VM_leaf_base(CAST_FROM_FN_PTR(address, SharedRuntime::fcmpg), 0);
2041             }
2042         } else {
2043             __ mov(r2, r0);
2044             __ mov(r3, r1);
2045             __ pop_l(r0);
2046             if (unordered_result < 0) {
2047                 __ call_VM_leaf_base(CAST_FROM_FN_PTR(address, SharedRuntime::dcmpl), 0);
2048             } else {
2049                 __ call_VM_leaf_base(CAST_FROM_FN_PTR(address, SharedRuntime::dcmpg), 0);
2050             }
2051         }
2052 #else
2053         // expected -mfloat-abi=soft
2054         ShouldNotReachHere();
2055 #endif
2056   }
2057 }
2058 
2059 void TemplateTable::branch(bool is_jsr, bool is_wide)
2060 {
2061   // We might be moving to a safepoint.  The thread which calls
2062   // Interpreter::notice_safepoints() will effectively flush its cache
2063   // when it makes a system call, but we need to do something to
2064   // ensure that we see the changed dispatch table.
2065   __ membar(MacroAssembler::LoadLoad);
2066 
2067   __ profile_taken_branch(r0, r1);
2068   const ByteSize be_offset = MethodCounters::backedge_counter_offset() +
2069                              InvocationCounter::counter_offset();
2070   const ByteSize inv_offset = MethodCounters::invocation_counter_offset() +
2071                               InvocationCounter::counter_offset();
2072 
2073   // load branch displacement
2074   if (!is_wide) {
2075     __ ldrh(r2, at_bcp(1));
2076     __ rev16(r2, r2);
2077     // sign extend the 16 bit value in r2
2078     __ sxth(r2, r2);
2079   } else {
2080     __ ldr(r2, at_bcp(1));
2081     __ rev(r2, r2);
2082   }
2083 
2084   // Handle all the JSR stuff here, then exit.
2085   // It's much shorter and cleaner than intermingling with the non-JSR
2086   // normal-branch stuff occurring below.
2087 
2088   if (is_jsr) {
2089     // Pre-load the next target bytecode into rscratch1
2090     __ load_unsigned_byte(rscratch1, Address(rbcp, r2));
2091     // compute return address as bci
2092     __ ldr(rscratch2, Address(rmethod, Method::const_offset()));
2093     __ add(rscratch2, rscratch2,
2094            in_bytes(ConstMethod::codes_offset()) - (is_wide ? 5 : 3));
2095     __ sub(r1, rbcp, rscratch2);
2096     __ push_i(r1);
2097     // Adjust the bcp by the 16-bit displacement in r2
2098     __ add(rbcp, rbcp, r2);
2099     __ dispatch_only(vtos, /*generate_poll*/true);
2100     return;
2101   }
2102 
2103   // Normal (non-jsr) branch handling
2104 
2105   // Adjust the bcp by the displacement in r2
2106   __ add(rbcp, rbcp, r2);
2107 
2108   assert(UseLoopCounter || !UseOnStackReplacement,
2109          "on-stack-replacement requires loop counters");
2110   Label backedge_counter_overflow;
2111   Label profile_method;
2112   Label dispatch;
2113   if (UseLoopCounter) {
2114     // increment backedge counter for backward branches
2115     // r0: MDO
2116     // w1: MDO bumped taken-count
2117     // r2: target offset
2118     __ cmp(r2, 0);
2119     __ b(dispatch, Assembler::GT); // count only if backward branch
2120 
2121     // ECN: FIXME: This code smells
2122     // check if MethodCounters exists
2123     Label has_counters;
2124     __ ldr(rscratch1, Address(rmethod, Method::method_counters_offset()));
2125     __ cbnz(rscratch1, has_counters);
2126     __ push(r0);
2127     __ push(r1);
2128     __ push(r2);
2129     __ call_VM(noreg, CAST_FROM_FN_PTR(address,
2130             InterpreterRuntime::build_method_counters), rmethod);
2131     __ pop(r2);
2132     __ pop(r1);
2133     __ pop(r0);
2134     __ ldr(rscratch1, Address(rmethod, Method::method_counters_offset()));
2135     __ cbz(rscratch1, dispatch); // No MethodCounters allocated, OutOfMemory
2136     __ bind(has_counters);
2137 
2138     if (TieredCompilation) {
2139       Label no_mdo;
2140       int increment = InvocationCounter::count_increment;
2141       if (ProfileInterpreter) {
2142         // Are we profiling?
2143         __ ldr(r1, Address(rmethod, in_bytes(Method::method_data_offset())));
2144         __ cbz(r1, no_mdo);
2145         // Increment the MDO backedge counter
2146         const Address mdo_backedge_counter(r1, in_bytes(MethodData::backedge_counter_offset()) +
2147                                            in_bytes(InvocationCounter::counter_offset()));
2148         const Address mask(r1, in_bytes(MethodData::backedge_mask_offset()));
2149         __ increment_mask_and_jump(mdo_backedge_counter, increment, mask,
2150                                    r0, rscratch2, false, Assembler::EQ,
2151                 UseOnStackReplacement ? &backedge_counter_overflow : NULL);
2152         __ b(dispatch);
2153       }
2154       __ bind(no_mdo);
2155       // Increment backedge counter in MethodCounters*
2156       __ ldr(rscratch1, Address(rmethod, Method::method_counters_offset()));
2157       const Address mask(rscratch1, in_bytes(MethodCounters::backedge_mask_offset()));
2158       __ increment_mask_and_jump(Address(rscratch1, be_offset), increment, mask,
2159                                  r0, rscratch2, false, Assembler::EQ,
2160               UseOnStackReplacement ? &backedge_counter_overflow : NULL);
2161     } else { // not TieredCompilation
2162       // increment counter
2163       __ ldr(rscratch2, Address(rmethod, Method::method_counters_offset()));
2164       __ ldr(r0, Address(rscratch2, be_offset));        // load backedge counter
2165       __ add(rscratch1, r0, InvocationCounter::count_increment); // increment counter
2166       __ str(rscratch1, Address(rscratch2, be_offset));        // store counter
2167 
2168       __ ldr(r0, Address(rscratch2, inv_offset));    // load invocation counter
2169       __ mov(rscratch1, (unsigned)InvocationCounter::count_mask_value);
2170       __ andr(r0, r0, rscratch1); // and the status bits
2171       __ ldr(rscratch1, Address(rscratch2, be_offset));        // load backedge counter
2172       __ add(r0, r0, rscratch1);        // add both counters
2173 
2174       if (ProfileInterpreter) {
2175         // Test to see if we should create a method data oop
2176         __ ldr(rscratch1, Address(rscratch2, in_bytes(MethodCounters::interpreter_profile_limit_offset())));
2177         __ cmp(r0, rscratch1);
2178         __ b(dispatch, Assembler::LT);
2179 
2180         // if no method data exists, go to profile method
2181         __ test_method_data_pointer(r0, profile_method);
2182 
2183         if (UseOnStackReplacement) {
2184           // check for overflow against w1 which is the MDO taken count
2185           __ ldr(rscratch1, Address(rscratch2, in_bytes(MethodCounters::interpreter_backward_branch_limit_offset())));
2186           __ cmp(r1, rscratch1);
2187           __ b(dispatch, Assembler::LO); // Intel == Assembler::below
2188 
2189           // When ProfileInterpreter is on, the backedge_count comes
2190           // from the MethodData*, which value does not get reset on
2191           // the call to frequency_counter_overflow().  To avoid
2192           // excessive calls to the overflow routine while the method is
2193           // being compiled, add a second test to make sure the overflow
2194           // function is called only once every overflow_frequency.
2195           const int overflow_frequency = 1024;
2196           const int of_mask_lsb = exact_log2(overflow_frequency);
2197           __ bfc(r1, of_mask_lsb, 32 - of_mask_lsb);
2198           __ cmp(r1, 0);
2199           __ b(backedge_counter_overflow, Assembler::EQ);
2200 
2201         }
2202       } else {
2203         if (UseOnStackReplacement) {
2204           // check for overflow against w0, which is the sum of the
2205           // counters
2206           __ ldr(rscratch1, Address(rscratch2, in_bytes(MethodCounters::interpreter_backward_branch_limit_offset())));
2207           __ cmp(r0, rscratch1);
2208           __ b(backedge_counter_overflow, Assembler::HS); // Intel == Assembler::aboveEqual
2209         }
2210       }
2211     }
2212   }
2213   __ bind(dispatch);
2214 
2215   // Pre-load the next target bytecode into rscratch1
2216   __ load_unsigned_byte(rscratch1, Address(rbcp, 0));
2217 
2218   // continue with the bytecode @ target
2219   // rscratch1: target bytecode
2220   // rbcp: target bcp
2221   __ dispatch_only(vtos, /*generate_poll*/true);
2222 
2223   if (UseLoopCounter) {
2224     if (ProfileInterpreter) {
2225       // Out-of-line code to allocate method data oop.
2226       __ bind(profile_method);
2227       __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::profile_method));
2228       __ load_unsigned_byte(r1, Address(rbcp, 0));  // restore target bytecode
2229       __ set_method_data_pointer_for_bcp();
2230       __ b(dispatch);
2231     }
2232 
2233     if (UseOnStackReplacement) {
2234       // invocation counter overflow
2235       __ bind(backedge_counter_overflow);
2236       __ neg(r2, r2);
2237       __ add(r2, r2, rbcp);     // branch bcp
2238       // IcoResult frequency_counter_overflow([JavaThread*], address branch_bcp)
2239       __ call_VM(noreg,
2240                  CAST_FROM_FN_PTR(address,
2241                                   InterpreterRuntime::frequency_counter_overflow),
2242                  r2);
2243 
2244       __ load_unsigned_byte(r1, Address(rbcp, 0));  // restore target bytecode
2245 
2246       // r0: osr nmethod (osr ok) or NULL (osr not possible)
2247       // r1: target bytecode
2248       // r2: scratch
2249       __ cbz(r0, dispatch);     // test result -- no osr if null
2250       // nmethod may have been invalidated (VM may block upon call_VM return)
2251       __ ldr(r2, Address(r0, nmethod::state_offset()));
2252       __ subs(r2, r2, nmethod::in_use);
2253       __ b(dispatch, Assembler::NE);
2254 
2255       // We have the address of an on stack replacement routine in r0
2256       // We need to prepare to execute the OSR method. First we must
2257       // migrate the locals and monitors off of the stack.
2258 
2259       __ mov(r4, r0);               // save the nmethod
2260 
2261       call_VM(noreg, CAST_FROM_FN_PTR(address, SharedRuntime::OSR_migration_begin));
2262 
2263       // r0 is OSR buffer, ensure it's in the expected parameter location
2264       assert(j_rarg0 == r0, "assumed");
2265 
2266       // remove activation
2267       // get sender sp
2268       __ ldr(rscratch1,
2269           Address(rfp, frame::get_interpreter_frame_sender_sp_offset() * wordSize));
2270       // remove frame anchor
2271       __ leave();
2272       __ mov(sp, rscratch1);
2273       // Ensure compiled code always sees stack at proper alignment
2274       __ align_stack();
2275 
2276       // and begin the OSR nmethod
2277       __ ldr(rscratch1, Address(r4, nmethod::osr_entry_point_offset()));
2278       __ b(rscratch1);
2279     }
2280   }
2281 }
2282 
2283 
2284 void TemplateTable::if_0cmp(Condition cc)
2285 {
2286   transition(itos, vtos);
2287   // assume branch is more often taken than not (loops use backward branches)
2288   Label not_taken;
2289   /*if (cc == equal) {
2290     __ cmp(r0, 0);
2291     __ b(not_taken, Assembler::NE);
2292   } else if (cc == not_equal) {
2293     __ cmp(r0, 0);
2294     __ b(not_taken, Assembler::EQ);
2295   } else {
2296     __ ands(rscratch1, r0, r0);
2297     __ b(not_taken, j_not(cc));
2298   }*/
2299   __ cmp(r0, 0);
2300   __ b(not_taken, j_not(cc));
2301 
2302   branch(false, false);
2303   __ bind(not_taken);
2304   __ profile_not_taken_branch(r0);
2305 }
2306 
2307 void TemplateTable::if_icmp(Condition cc)
2308 {
2309   transition(itos, vtos);
2310   // assume branch is more often taken than not (loops use backward branches)
2311   Label not_taken;
2312   __ pop_i(r1);
2313   __ reg_printf("Comparing TOS = %p, and SOS = %p\n", r0, r1);
2314   __ cmp(r1, r0);
2315   __ b(not_taken, j_not(cc));
2316   branch(false, false);
2317   __ bind(not_taken);
2318   __ profile_not_taken_branch(r0);
2319 }
2320 
2321 void TemplateTable::if_nullcmp(Condition cc)
2322 {
2323   transition(atos, vtos);
2324   // assume branch is more often taken than not (loops use backward branches)
2325   Label not_taken;
2326   if (cc == equal)
2327     __ cbnz(r0, not_taken);
2328   else
2329     __ cbz(r0, not_taken);
2330   branch(false, false);
2331   __ bind(not_taken);
2332   __ profile_not_taken_branch(r0);
2333 }
2334 
2335 void TemplateTable::if_acmp(Condition cc)
2336 {
2337   transition(atos, vtos);
2338   // assume branch is more often taken than not (loops use backward branches)
2339   Label not_taken;
2340   __ pop_ptr(r1);
2341   __ cmpoop(r1, r0);
2342   __ b(not_taken, j_not(cc));
2343   branch(false, false);
2344   __ bind(not_taken);
2345   __ profile_not_taken_branch(r0);
2346 }
2347 
2348 void TemplateTable::ret() {
2349   transition(vtos, vtos);
2350   // We might be moving to a safepoint.  The thread which calls
2351   // Interpreter::notice_safepoints() will effectively flush its cache
2352   // when it makes a system call, but we need to do something to
2353   // ensure that we see the changed dispatch table.
2354   __ membar(MacroAssembler::LoadLoad);
2355 
2356   locals_index(r1);
2357   __ ldr(r1, aaddress(r1)); // get return bci, compute return bcp
2358   __ profile_ret(r1, r2);
2359   __ ldr(rbcp, Address(rmethod, Method::const_offset()));
2360   __ lea(rbcp, Address(rbcp, r1));
2361   __ add(rbcp, rbcp, in_bytes(ConstMethod::codes_offset()));
2362   __ dispatch_next(vtos, 0, /*generate_poll*/true);
2363 }
2364 
2365 void TemplateTable::wide_ret() {
2366   transition(vtos, vtos);
2367   locals_index_wide(r1);
2368   __ ldr(r1, aaddress(r1)); // get return bci, compute return bcp
2369   __ profile_ret(r1, r2);
2370   __ ldr(rbcp, Address(rmethod, Method::const_offset()));
2371   __ lea(rbcp, Address(rbcp, r1));
2372   __ add(rbcp, rbcp, in_bytes(ConstMethod::codes_offset()));
2373   __ dispatch_next(vtos, 0, /*generate_poll*/true);
2374 }
2375 
2376 
2377 void TemplateTable::tableswitch() {
2378   Label default_case, continue_execution;
2379   transition(itos, vtos);
2380   // align rbcp
2381   __ lea(r1, at_bcp(BytesPerInt));
2382   __ bic(r1, r1, BytesPerInt - 1);
2383   // load lo & hi
2384   __ ldr(r2, Address(r1, BytesPerInt));
2385   __ ldr(r3, Address(r1, 2 * BytesPerInt));
2386   __ rev(r2, r2);
2387   __ rev(r3, r3);
2388   // check against lo & hi
2389   __ cmp(r0, r2);
2390   __ b(default_case, Assembler::LT);
2391   __ cmp(r0, r3);
2392   __ b(default_case, Assembler::GT);
2393   // lookup dispatch offset
2394   __ sub(r0, r0, r2);
2395   __ lea(r3, Address(r1, r0, lsl(2)));
2396   __ ldr(r3, Address(r3, 3 * BytesPerInt));
2397   __ profile_switch_case(r0, r1, r2);
2398   // continue execution
2399   __ bind(continue_execution);
2400   __ rev(r3, r3);
2401   __ load_unsigned_byte(rscratch1, Address(rbcp, r3));
2402   __ add(rbcp, rbcp, r3);
2403   __ dispatch_only(vtos, /*generate_poll*/true);
2404   // handle default
2405   __ bind(default_case);
2406   __ profile_switch_default(r0);
2407   __ ldr(r3, Address(r1, 0));
2408   __ b(continue_execution);
2409 }
2410 
2411 void TemplateTable::lookupswitch() {
2412   transition(itos, itos);
2413   __ stop("lookupswitch bytecode should have been rewritten");
2414 }
2415 
2416 void TemplateTable::fast_linearswitch() {
2417   transition(itos, vtos);
2418   Label loop_entry, loop, found, continue_execution;
2419 
2420   __ reg_printf("Linearswitching to value %d\n", r0);
2421 
2422   // bswap r0 so we can avoid bswapping the table entries
2423   __ rev(r0, r0);
2424   // align rbcp
2425   __ lea(r14, at_bcp(BytesPerInt)); // btw: should be able to get rid of
2426                                     // this instruction (change offsets
2427                                     // below)
2428   __ bic(r14, r14, BytesPerInt - 1);
2429   // set counter
2430   __ ldr(r1, Address(r14, BytesPerInt));
2431   __ rev(r1, r1);
2432   __ b(loop_entry);
2433   // table search
2434   __ bind(loop);
2435   __ lea(rscratch1, Address(r14, r1, lsl(3)));
2436   __ ldr(rscratch1, Address(rscratch1, 2 * BytesPerInt));
2437   __ cmp(r0, rscratch1);
2438   __ b(found, Assembler::EQ);
2439   __ bind(loop_entry);
2440   __ subs(r1, r1, 1);
2441   __ b(loop, Assembler::PL);
2442   // default case
2443   __ profile_switch_default(r0);
2444   __ ldr(r3, Address(r14, 0));
2445   __ b(continue_execution);
2446   // entry found -> get offset
2447   __ bind(found);
2448   __ lea(rscratch1, Address(r14, r1, lsl(3)));
2449   __ ldr(r3, Address(rscratch1, 3 * BytesPerInt));
2450   __ profile_switch_case(r1, r0, r14);
2451   // continue execution
2452   __ bind(continue_execution);
2453   __ rev(r3, r3);
2454   __ add(rbcp, rbcp, r3);
2455   __ ldrb(rscratch1, Address(rbcp, 0));
2456   __ dispatch_only(vtos, /*generate_poll*/true);
2457 }
2458 
2459 void TemplateTable::fast_binaryswitch() {
2460   transition(itos, vtos);
2461   // Implementation using the following core algorithm:
2462   //
2463   // int binary_search(int key, LookupswitchPair* array, int n) {
2464   //   // Binary search according to "Methodik des Programmierens" by
2465   //   // Edsger W. Dijkstra and W.H.J. Feijen, Addison Wesley Germany 1985.
2466   //   int i = 0;
2467   //   int j = n;
2468   //   while (i+1 < j) {
2469   //     // invariant P: 0 <= i < j <= n and (a[i] <= key < a[j] or Q)
2470   //     // with      Q: for all i: 0 <= i < n: key < a[i]
2471   //     // where a stands for the array and assuming that the (inexisting)
2472   //     // element a[n] is infinitely big.
2473   //     int h = (i + j) >> 1;
2474   //     // i < h < j
2475   //     if (key < array[h].fast_match()) {
2476   //       j = h;
2477   //     } else {
2478   //       i = h;
2479   //     }
2480   //   }
2481   //   // R: a[i] <= key < a[i+1] or Q
2482   //   // (i.e., if key is within array, i is the correct index)
2483   //   return i;
2484   // }
2485 
2486   // Register allocation
2487   const Register key   = r0; // already set (tosca)
2488   const Register array = r1;
2489   const Register i     = r2;
2490   const Register j     = r3;
2491   const Register h     = rscratch1;
2492   const Register temp  = rscratch2;
2493 
2494   // Find array start
2495   __ lea(array, at_bcp(3 * BytesPerInt)); // btw: should be able to
2496                                           // get rid of this
2497                                           // instruction (change
2498                                           // offsets below)
2499   __ bic(array, array, BytesPerInt - 1);
2500 
2501   // Initialize i & j
2502   __ mov(i, 0);                            // i = 0;
2503   __ ldr(j, Address(array, -BytesPerInt)); // j = length(array);
2504 
2505   // Convert j into native byteordering
2506   __ rev(j, j);
2507 
2508   // And start
2509   Label entry;
2510   __ b(entry);
2511 
2512   // binary search loop
2513   {
2514     Label loop;
2515     __ bind(loop);
2516     // int h = (i + j) >> 1;
2517     __ add(h, i, j);                           // h = i + j;
2518     __ lsr(h, h, 1);                                   // h = (i + j) >> 1;
2519     // if (key < array[h].fast_match()) {
2520     //   j = h;
2521     // } else {
2522     //   i = h;
2523     // }
2524     // Convert array[h].match to native byte-ordering before compare
2525     __ ldr(temp, Address(array, h, lsl(3)));
2526     __ rev(temp, temp);
2527     __ cmp(key, temp);
2528     // j = h if (key <  array[h].fast_match())
2529     __ mov(j, h, Assembler::LT);
2530     // i = h if (key >= array[h].fast_match())
2531     __ mov(i, h, Assembler::GE);
2532     // while (i+1 < j)
2533     __ bind(entry);
2534     __ add(h, i, 1);          // i+1
2535     __ cmp(h, j);             // i+1 < j
2536     __ b(loop, Assembler::LT);
2537   }
2538 
2539   // end of binary search, result index is i (must check again!)
2540   Label default_case;
2541   // Convert array[i].match to native byte-ordering before compare
2542   __ ldr(temp, Address(array, i, lsl(3)));
2543   __ rev(temp, temp);
2544   __ cmp(key, temp);
2545   __ b(default_case, Assembler::NE);
2546 
2547   // entry found -> j = offset
2548   __ add(j, array, i, lsl(3));
2549   __ ldr(j, Address(j, BytesPerInt));
2550   __ profile_switch_case(i, key, array);
2551   __ rev(j, j);
2552   __ load_unsigned_byte(rscratch1, Address(rbcp, j));
2553   __ lea(rbcp, Address(rbcp, j));
2554   __ dispatch_only(vtos, /*generate_poll*/true);
2555 
2556   // default case -> j = default offset
2557   __ bind(default_case);
2558   __ profile_switch_default(i);
2559   __ ldr(j, Address(array, -2 * BytesPerInt));
2560   __ rev(j, j);
2561   __ load_unsigned_byte(rscratch1, Address(rbcp, j));
2562   __ lea(rbcp, Address(rbcp, j));
2563   __ dispatch_only(vtos, /*genrate_poll*/true);
2564 }
2565 
2566 void TemplateTable::_return(TosState state)
2567 {
2568   __ reg_printf("STARTING RETURN\n");
2569   //__ stop("_return");
2570   transition(state, state);
2571   if(ltos == state) {
2572     __ reg_printf("Doing long return, tos value is 0x%08x%08x\n", r1, r0);
2573   } else if ( itos == state || atos == state) {
2574     __ reg_printf("Doing int/ref return, tos value is 0x%08x\n", r0);
2575   }
2576 
2577   assert(_desc->calls_vm(),
2578          "inconsistent calls_vm information"); // call in remove_activation
2579 
2580   if (_desc->bytecode() == Bytecodes::_return_register_finalizer) {
2581     assert(state == vtos, "only valid state");
2582 
2583     __ reg_printf("A\n");
2584     __ ldr(c_rarg1, aaddress(0));
2585     __ reg_printf("object is = %p\nB\n", c_rarg1);
2586     __ load_klass(r3, c_rarg1);
2587     __ reg_printf("C\n");
2588     __ ldr(r3, Address(r3, Klass::access_flags_offset()));
2589     __ reg_printf("D\n");
2590     __ tst(r3, JVM_ACC_HAS_FINALIZER);
2591     __ reg_printf("E\n");
2592     Label skip_register_finalizer;
2593     __ b(skip_register_finalizer, Assembler::EQ);
2594     __ reg_printf("About to call into the VM\n");
2595     __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::register_finalizer), c_rarg1);
2596     __ reg_printf("F\n");
2597     __ bind(skip_register_finalizer);
2598   }
2599 
2600   // Issue a StoreStore barrier after all stores but before return
2601   // from any constructor for any class with a final field.  We don't
2602   // know if this is a finalizer, so we always do so.
2603   if (_desc->bytecode() == Bytecodes::_return)
2604     __ membar(MacroAssembler::StoreStore);
2605 
2606   // Narrow result if state is itos but result type is smaller.
2607   // Need to narrow in the return bytecode rather than in generate_return_entry
2608   // since compiled code callers expect the result to already be narrowed.
2609   if (state == itos) {
2610     __ narrow(r0);
2611   }
2612 
2613   __ reg_printf("About to attmpt to remove activation with rfp = %p\n", rfp);
2614   __ remove_activation(state);
2615   __ reg_printf("Finshed _return, about to jump to lr = %p\n", lr);
2616   __ b(lr);
2617 }
2618 
2619 // ----------------------------------------------------------------------------
2620 // Volatile variables demand their effects be made known to all CPU's
2621 // in order.  Store buffers on most chips allow reads & writes to
2622 // reorder; the JMM's ReadAfterWrite.java test fails in -Xint mode
2623 // without some kind of memory barrier (i.e., it's not sufficient that
2624 // the interpreter does not reorder volatile references, the hardware
2625 // also must not reorder them).
2626 //
2627 // According to the new Java Memory Model (JMM):
2628 // (1) All volatiles are serialized wrt to each other.  ALSO reads &
2629 //     writes act as aquire & release, so:
2630 // (2) A read cannot let unrelated NON-volatile memory refs that
2631 //     happen after the read float up to before the read.  It's OK for
2632 //     non-volatile memory refs that happen before the volatile read to
2633 //     float down below it.
2634 // (3) Similar a volatile write cannot let unrelated NON-volatile
2635 //     memory refs that happen BEFORE the write float down to after the
2636 //     write.  It's OK for non-volatile memory refs that happen after the
2637 //     volatile write to float up before it.
2638 //
2639 // We only put in barriers around volatile refs (they are expensive),
2640 // not _between_ memory refs (that would require us to track the
2641 // flavor of the previous memory refs).  Requirements (2) and (3)
2642 // require some barriers before volatile stores and after volatile
2643 // loads.  These nearly cover requirement (1) but miss the
2644 // volatile-store-volatile-load case.  This final case is placed after
2645 // volatile-stores although it could just as well go before
2646 // volatile-loads.
2647 
2648 //Note none of these calls use rscratch1, well some do but are set again before return
2649 // so index can be rscratch1 ( I think )
2650 void TemplateTable::resolve_cache_and_index(int byte_no,
2651                                             Register Rcache,
2652                                             Register index,
2653                                             size_t index_size) {
2654   // Note none of the functions called here use any rscratch
2655   // call_VM may do but will save the argument first!
2656   const Register temp = rscratch2;
2657   assert_different_registers(Rcache, index, temp);
2658 
2659   Label resolved;
2660 
2661   Bytecodes::Code code = bytecode();
2662   switch (code) {
2663   case Bytecodes::_nofast_getfield: code = Bytecodes::_getfield; break;
2664   case Bytecodes::_nofast_putfield: code = Bytecodes::_putfield; break;
2665   }
2666 
2667   assert(byte_no == f1_byte || byte_no == f2_byte, "byte_no out of range");
2668   __ get_cache_and_index_and_bytecode_at_bcp(Rcache, index, temp, byte_no, 1, index_size);
2669   __ cmp(temp, (int) code);  // have we resolved this bytecode?
2670   __ b(resolved, Assembler::EQ);
2671 
2672   __ reg_printf("Not resolved, resolving, with rthread = %p, rfp = %p\n", rthread, rfp);
2673   // resolve first time through
2674   address entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_from_cache);
2675   __ mov(temp, (int) code);
2676   __ call_VM(noreg, entry, temp);
2677   __ reg_printf("Resolve complete\n");
2678 
2679   // Update registers with resolved info
2680   __ get_cache_and_index_at_bcp(Rcache, index, 1, index_size);
2681   // n.b. unlike x86 Rcache is now rcpool plus the indexed offset
2682   // so all clients ofthis method must be modified accordingly
2683   __ bind(resolved);
2684 }
2685 
2686 // The Rcache and index registers must be set before call
2687 // n.b unlike x86 cache already includes the index offset
2688 void TemplateTable::load_field_cp_cache_entry(Register obj,
2689                                               Register cache,
2690                                               Register index,
2691                                               Register off,
2692                                               Register flags,
2693                                               bool is_static = false) {
2694   assert_different_registers(cache, index, flags, off);
2695 
2696   ByteSize cp_base_offset = ConstantPoolCache::base_offset();
2697   // Field offset
2698   __ ldr(off, Address(cache, in_bytes(cp_base_offset +
2699                                       ConstantPoolCacheEntry::f2_offset())));
2700   // Flags
2701   __ ldr(flags, Address(cache, in_bytes(cp_base_offset +
2702                                         ConstantPoolCacheEntry::flags_offset())));
2703 
2704   // klass overwrite register
2705   if (is_static) {
2706     __ ldr(obj, Address(cache, in_bytes(cp_base_offset +
2707                                         ConstantPoolCacheEntry::f1_offset())));
2708     const int mirror_offset = in_bytes(Klass::java_mirror_offset());
2709     __ ldr(obj, Address(obj, mirror_offset));
2710     __ resolve_oop_handle(obj, r3);
2711   }
2712 }
2713 
2714 void TemplateTable::load_invoke_cp_cache_entry(int byte_no,
2715                                                Register method,
2716                                                Register itable_index,
2717                                                Register flags,
2718                                                bool is_invokevirtual,
2719                                                bool is_invokevfinal, /*unused*/
2720                                                bool is_invokedynamic) {
2721   // setup registers
2722   const Register cache = rscratch1;
2723   const Register index = r14;
2724   assert_different_registers(method, flags);
2725   assert_different_registers(method, cache, index);
2726   assert_different_registers(itable_index, flags);
2727   assert_different_registers(itable_index, cache, index);
2728   // determine constant pool cache field offsets
2729   assert(is_invokevirtual == (byte_no == f2_byte), "is_invokevirtual flag redundant");
2730   const int method_offset = in_bytes(
2731     ConstantPoolCache::base_offset() +
2732       (is_invokevirtual
2733        ? ConstantPoolCacheEntry::f2_offset()
2734        : ConstantPoolCacheEntry::f1_offset()));
2735   const int flags_offset = in_bytes(ConstantPoolCache::base_offset() +
2736                                     ConstantPoolCacheEntry::flags_offset());
2737   // access constant pool cache fields
2738   const int index_offset = in_bytes(ConstantPoolCache::base_offset() +
2739                                     ConstantPoolCacheEntry::f2_offset());
2740 
2741   size_t index_size = (is_invokedynamic ? sizeof(u4) : sizeof(u2));
2742   resolve_cache_and_index(byte_no, cache, index, index_size);
2743   __ ldr(method, Address(cache, method_offset));
2744 
2745   if (itable_index != noreg) {
2746     __ ldr(itable_index, Address(cache, index_offset));
2747   }
2748   __ ldr(flags, Address(cache, flags_offset));
2749 
2750   __ reg_printf("Invocation, index = %d\n", index);
2751 }
2752 
2753 
2754 // The registers cache and index expected to be set before call.
2755 // Correct values of the cache and index registers are preserved.
2756 void TemplateTable::jvmti_post_field_access(Register cache, Register index,
2757                                             bool is_static, bool has_tos) {
2758   // do the JVMTI work here to avoid disturbing the register state below
2759   // We use c_rarg registers here because we want to use the register used in
2760   // the call to the VM
2761   if (JvmtiExport::can_post_field_access()) {
2762     // Check to see if a field access watch has been set before we
2763     // take the time to call into the VM.
2764     Label L1;
2765     assert_different_registers(cache, index, r0);
2766     __ lea(rscratch1, ExternalAddress((address) JvmtiExport::get_field_access_count_addr()));
2767     __ ldr(r0, Address(rscratch1));
2768     __ cmp(r0, 0);
2769     __ b(L1, Assembler::EQ);
2770 
2771     __ get_cache_and_index_at_bcp(c_rarg2, c_rarg3, 1);
2772     __ lea(c_rarg2, Address(c_rarg2, in_bytes(ConstantPoolCache::base_offset())));
2773 
2774     if (is_static) {
2775       __ mov(c_rarg1, 0); // NULL object reference
2776     } else {
2777       __ ldr(c_rarg1, at_tos()); // get object pointer without popping it
2778       __ verify_oop(c_rarg1);
2779     }
2780     // c_rarg1: object pointer or NULL
2781     // c_rarg2: cache entry pointer
2782     // c_rarg3: jvalue object on the stack
2783     __ call_VM(noreg, CAST_FROM_FN_PTR(address,
2784                                        InterpreterRuntime::post_field_access),
2785                c_rarg1, c_rarg2, c_rarg3);
2786     __ get_cache_and_index_at_bcp(cache, index, 1);
2787     __ bind(L1);
2788   }
2789 }
2790 
2791 void TemplateTable::pop_and_check_object(Register r)
2792 {
2793   __ pop_ptr(r);
2794   __ null_check(r);  // for field access must check obj.
2795   __ verify_oop(r);
2796 }
2797 
2798 void TemplateTable::getfield_or_static(int byte_no, bool is_static, RewriteControl rc) {
2799   //__ stop("getfield or static");
2800   //FIXME Find a better way than this!
2801   const Register cache    = r2;
2802   const Register index    = r3;
2803   const Register obj      = r14;
2804   const Register off      = rscratch2; //pop_and_check_object
2805   const Register flags    = r0;
2806   const Register bc       = r14; // uses same reg as obj, so don't mix them
2807   const Register bytecode = r1;
2808 
2809   resolve_cache_and_index(byte_no, cache, index, sizeof(u2));
2810   jvmti_post_field_access(cache, index, is_static, false);
2811   load_field_cp_cache_entry(obj, cache, index, off, flags, is_static);
2812 
2813   if (!is_static) {
2814     // obj is on the stack
2815     // trashes rscratch1
2816     pop_and_check_object(obj);
2817   }
2818 
2819   const Address field(obj, off);
2820 
2821   Label Done, notByte, notBool, notInt, notShort, notChar,
2822     notLong, notFloat, notObj, notDouble,
2823     notVolatileLong, notVolatileDouble, DoneBarrier;
2824 
2825   // Don't rewrite getstatic, only getfield
2826   if (is_static) rc = may_not_rewrite;
2827 
2828   __ extract_bits(bytecode, flags, ConstantPoolCacheEntry::tos_state_shift,  ConstantPoolCacheEntry::tos_state_bits);
2829 
2830   assert(btos == 0, "change code, btos != 0");
2831   __ cbnz(bytecode, notByte);
2832 
2833   // btos
2834   __ access_load_tos_at(T_BYTE, IN_HEAP, field, noreg, noreg);
2835   __ push(btos);
2836   // Rewrite bytecode to be faster
2837   if (rc == may_rewrite) {
2838     patch_bytecode(Bytecodes::_fast_bgetfield, bc, bytecode);
2839   }
2840   __ b(Done);
2841 
2842   __ bind(notByte);
2843   __ cmp(bytecode, ztos);
2844   __ b(notBool, Assembler::NE);
2845 
2846   // ztos (same code as btos)
2847   __ access_load_tos_at(T_BOOLEAN, IN_HEAP, field, noreg, noreg);
2848   __ push(ztos);
2849   // Rewrite bytecode to be faster
2850   if (rc == may_rewrite) {
2851     // use btos rewriting, no truncating to t/f bit is needed for getfield.
2852     patch_bytecode(Bytecodes::_fast_bgetfield, bc, bytecode);
2853   }
2854   __ b(Done);
2855 
2856   __ bind(notBool);
2857   __ cmp(bytecode, atos);
2858   __ b(notObj, Assembler::NE);
2859   // atos
2860   do_oop_load(_masm, field, r0, IN_HEAP);
2861   __ push(atos);
2862   __ reg_printf("Getfield or static, atos = 0x%08x\n", r0);
2863   if (rc == may_rewrite) {
2864     patch_bytecode(Bytecodes::_fast_agetfield, bc, bytecode);
2865   }
2866   __ b(Done);
2867 
2868   __ bind(notObj);
2869   __ cmp(bytecode, itos);
2870   __ b(notInt, Assembler::NE);
2871   // itos
2872   __ access_load_tos_at(T_INT, IN_HEAP, field, noreg, noreg);
2873   __ push(itos);
2874   __ reg_printf("Getfield or static, itos = 0x%08x\n", r0);
2875   // Rewrite bytecode to be faster
2876   if (rc == may_rewrite) {
2877     patch_bytecode(Bytecodes::_fast_igetfield, bc, bytecode);
2878   }
2879   __ b(Done);
2880 
2881   __ bind(notInt);
2882   __ cmp(bytecode, ctos);
2883   __ b(notChar, Assembler::NE);
2884   // ctos
2885   __ access_load_tos_at(T_CHAR, IN_HEAP, field, noreg, noreg);
2886   __ push(ctos);
2887   // Rewrite bytecode to be faster
2888   if (rc == may_rewrite) {
2889     patch_bytecode(Bytecodes::_fast_cgetfield, bc, bytecode);
2890   }
2891   __ b(Done);
2892 
2893   __ bind(notChar);
2894   __ cmp(bytecode, stos);
2895   __ b(notShort, Assembler::NE);
2896   // stos
2897   __ access_load_tos_at(T_SHORT, IN_HEAP, field, noreg, noreg);
2898   __ push(stos);
2899   // Rewrite bytecode to be faster
2900   if (rc == may_rewrite) {
2901     patch_bytecode(Bytecodes::_fast_sgetfield, bc, bytecode);
2902   }
2903   __ b(Done);
2904 
2905   __ bind(notShort);
2906   __ cmp(bytecode, ltos);
2907   __ b(notLong, Assembler::NE);
2908   // ltos
2909   __ tbz(flags, ConstantPoolCacheEntry::is_volatile_shift, notVolatileLong);
2910   __ access_load_tos_at(T_LONG, IN_HEAP | MO_SEQ_CST, field, bytecode, noreg); // don't need bytecode anymore
2911   __ membar(MacroAssembler::LoadLoad | MacroAssembler::LoadStore);
2912   __ push(ltos);
2913   // Rewrite bytecode to be faster
2914   if (rc == may_rewrite) {
2915     patch_bytecode(Bytecodes::_fast_lgetfield, bc, bytecode);
2916   }
2917   __ b(DoneBarrier);
2918 
2919   __ bind(notVolatileLong);
2920   __ access_load_tos_at(T_LONG, IN_HEAP, field, noreg, noreg);
2921   __ push(ltos);
2922   // Rewrite bytecode to be faster
2923   if (rc == may_rewrite) {
2924     patch_bytecode(Bytecodes::_fast_lgetfield, bc, bytecode);
2925   }
2926   __ b(Done);
2927 
2928   __ bind(notLong);
2929   __ cmp(bytecode, ftos);
2930   __ b(notFloat, Assembler::NE);
2931   // ftos
2932   __ access_load_tos_at(T_FLOAT, IN_HEAP, field, bytecode, noreg); // don't need bytecode anymore
2933   __ push(ftos);
2934   // Rewrite bytecode to be faster
2935   if (rc == may_rewrite) {
2936     patch_bytecode(Bytecodes::_fast_fgetfield, bc, bytecode);
2937   }
2938   __ b(Done);
2939 
2940   __ bind(notFloat);
2941 #ifdef ASSERT
2942   __ cmp(bytecode, dtos);
2943   __ b(notDouble, Assembler::NE);
2944 #endif
2945   // dtos
2946   __ tbz(flags, ConstantPoolCacheEntry::is_volatile_shift, notVolatileDouble);
2947   __ access_load_tos_at(T_DOUBLE, IN_HEAP | MO_SEQ_CST, field, bytecode, noreg); // don't need bytecode anymore
2948   __ membar(MacroAssembler::LoadLoad | MacroAssembler::LoadStore);
2949   __ push(dtos);
2950   // Rewrite bytecode to be faster
2951   if (rc == may_rewrite) {
2952     patch_bytecode(Bytecodes::_fast_dgetfield, bc, bytecode);
2953   }
2954   __ b(DoneBarrier);
2955 
2956   __ bind(notVolatileDouble);
2957   __ access_load_tos_at(T_DOUBLE, IN_HEAP, field, bytecode, noreg); // don't need bytecode anymore
2958   __ push(dtos);
2959   // Rewrite bytecode to be faster
2960   if (rc == may_rewrite) {
2961     patch_bytecode(Bytecodes::_fast_dgetfield, bc, bytecode);
2962   }
2963   __ b(DoneBarrier);
2964 #ifdef ASSERT
2965 
2966   __ bind(notDouble);
2967   __ stop("Bad state");
2968 #endif
2969 
2970   __ bind(Done);
2971   __ tbz(flags, ConstantPoolCacheEntry::is_volatile_shift, DoneBarrier);
2972   __ membar(MacroAssembler::LoadLoad | MacroAssembler::LoadStore);
2973   __ bind(DoneBarrier);
2974 }
2975 
2976 void TemplateTable::getfield(int byte_no) {
2977   getfield_or_static(byte_no, false);
2978 }
2979 
2980 void TemplateTable::nofast_getfield(int byte_no) {
2981   getfield_or_static(byte_no, false, may_not_rewrite);
2982 }
2983 
2984 void TemplateTable::getstatic(int byte_no) {
2985   getfield_or_static(byte_no, true);
2986 }
2987 
2988 // The registers cache and index expected to be set before call.
2989 // The function may destroy various registers, just not the cache and index registers.
2990 void TemplateTable::jvmti_post_field_mod(Register cache, Register index, bool is_static) {
2991   transition(vtos, vtos);
2992 
2993   ByteSize cp_base_offset = ConstantPoolCache::base_offset();
2994 
2995   if (JvmtiExport::can_post_field_modification()) {
2996     // Check to see if a field modification watch has been set before
2997     // we take the time to call into the VM.
2998     Label L1;
2999     assert_different_registers(cache, index, r0);
3000     __ lea(rscratch1, ExternalAddress((address)JvmtiExport::get_field_modification_count_addr()));
3001     __ ldr(r0, Address(rscratch1));
3002     __ cbz(r0, L1);
3003 
3004     __ get_cache_and_index_at_bcp(c_rarg2, rscratch1, 1);
3005 
3006     if (is_static) {
3007       // Life is simple.  Null out the object pointer.
3008       __ mov(c_rarg1, 0);
3009     } else {
3010       // Life is harder. The stack holds the value on top, followed by
3011       // the object.  We don't know the size of the value, though; it
3012       // could be one or two words depending on its type. As a result,
3013       // we must find the type to determine where the object is.
3014       __ ldr(c_rarg3, Address(c_rarg2,
3015                               in_bytes(cp_base_offset +
3016                                        ConstantPoolCacheEntry::flags_offset())));
3017       __ lsr(c_rarg3, c_rarg3,
3018              ConstantPoolCacheEntry::tos_state_shift);
3019       ConstantPoolCacheEntry::verify_tos_state_shift();
3020       Label nope2, done, ok;
3021       __ ldr(c_rarg1, at_tos_p1());  // initially assume a one word jvalue
3022       __ cmp(c_rarg3, ltos);
3023       __ b(ok, Assembler::EQ);
3024       __ cmp(c_rarg3, dtos);
3025       __ b(nope2, Assembler::NE);
3026       __ bind(ok);
3027       __ ldr(c_rarg1, at_tos_p2()); // ltos (two word jvalue)
3028       __ bind(nope2);
3029     }
3030     // cache entry pointer
3031     __ add(c_rarg2, c_rarg2, in_bytes(cp_base_offset));
3032     // object (tos)
3033     __ mov(c_rarg3, sp);
3034     // c_rarg1: object pointer set up above (NULL if static)
3035     // c_rarg2: cache entry pointer
3036     // c_rarg3: jvalue object on the stack
3037     __ call_VM(noreg,
3038                CAST_FROM_FN_PTR(address,
3039                                 InterpreterRuntime::post_field_modification),
3040                c_rarg1, c_rarg2, c_rarg3);
3041     __ get_cache_and_index_at_bcp(cache, index, 1);
3042     __ bind(L1);
3043   }
3044 }
3045 
3046 void TemplateTable::putfield_or_static(int byte_no, bool is_static, RewriteControl rc) {
3047   transition(vtos, vtos);
3048   const Register cache = r2;
3049   const Register index = rscratch1;
3050   const Register obj   = r2;
3051   const Register off   = r3;
3052   const Register flags = r14;
3053   const Register bc    = rscratch2;
3054 
3055   resolve_cache_and_index(byte_no, cache, index, sizeof(u2));
3056   __ reg_printf("Putfield or static, index = %d\n", index);
3057   jvmti_post_field_mod(cache, index, is_static);
3058   load_field_cp_cache_entry(obj, cache, index, off, flags, is_static);
3059 
3060   Label Done;
3061   {
3062     Label notVolatile;
3063     __ tbz(flags, ConstantPoolCacheEntry::is_volatile_shift, notVolatile);
3064     __ membar(MacroAssembler::StoreStore);
3065     __ bind(notVolatile);
3066   }
3067   __ reg_printf("Putfield or static B\n");
3068 
3069   // field address
3070   const Address field(obj, off);
3071 
3072   Label notByte, notBool, notInt, notShort, notChar,
3073     notLong, notFloat, notObj, notDouble, DoneBarrier;
3074 
3075   __ extract_bits(rscratch1, flags, ConstantPoolCacheEntry::tos_state_shift, ConstantPoolCacheEntry::tos_state_bits);
3076 
3077   __ cmp(rscratch1, btos);
3078   __ b(notByte, Assembler::NE);
3079 
3080   // Don't rewrite putstatic, only putfield
3081   if (is_static) rc = may_not_rewrite;
3082   // btos
3083   {
3084     __ pop(btos);
3085     if (!is_static) {
3086       pop_and_check_object(obj);
3087     }
3088     __ access_store_tos_at(T_BYTE, IN_HEAP, field, noreg, noreg);
3089     if (rc == may_rewrite) {
3090       patch_bytecode(Bytecodes::_fast_bputfield, bc, r1, true, byte_no);
3091     }
3092     __ b(Done);
3093   }
3094 
3095   __ bind(notByte);
3096   __ cmp(rscratch1, ztos);
3097   __ b(notBool, Assembler::NE);
3098 
3099   // ztos
3100   {
3101     __ pop(ztos);
3102     if (!is_static) pop_and_check_object(obj);
3103     __ access_store_tos_at(T_BOOLEAN, IN_HEAP, field, noreg, noreg);
3104     if (rc == may_rewrite) {
3105       patch_bytecode(Bytecodes::_fast_zputfield, bc, r1, true, byte_no);
3106     }
3107     __ b(Done);
3108   }
3109 
3110   __ bind(notBool);
3111   __ cmp(rscratch1, atos);
3112   __ b(notObj, Assembler::NE);
3113 
3114   // atos
3115   {
3116     __ pop(atos);
3117     if (!is_static) {
3118       pop_and_check_object(obj);
3119     }
3120     // Store into the field
3121     do_oop_store(_masm, field, r0, IN_HEAP);
3122     if (rc == may_rewrite) {
3123       patch_bytecode(Bytecodes::_fast_aputfield, bc, r1, true, byte_no);
3124     }
3125     __ b(Done);
3126   }
3127 
3128   __ bind(notObj);
3129   __ cmp(rscratch1, itos);
3130   __ b(notInt, Assembler::NE);
3131 
3132   // itos
3133   {
3134     __ pop(itos);
3135     if (!is_static) pop_and_check_object(obj);
3136     __ access_store_tos_at(T_INT, IN_HEAP, field, noreg, noreg);
3137     if (rc == may_rewrite) {
3138       patch_bytecode(Bytecodes::_fast_iputfield, bc, r1, true, byte_no);
3139     }
3140     __ b(Done);
3141   }
3142 
3143   __ bind(notInt);
3144   __ cmp(rscratch1, ctos);
3145   __ b(notChar, Assembler::NE);
3146 
3147   // ctos
3148   {
3149     __ pop(ctos);
3150     if (!is_static) {
3151       pop_and_check_object(obj);
3152     }
3153     __ access_store_tos_at(T_CHAR, IN_HEAP, field, noreg, noreg);
3154     if (rc == may_rewrite) {
3155       patch_bytecode(Bytecodes::_fast_cputfield, bc, r1, true, byte_no);
3156     }
3157     __ b(Done);
3158   }
3159 
3160   __ bind(notChar);
3161   __ cmp(rscratch1, stos);
3162   __ b(notShort, Assembler::NE);
3163 
3164   // stos
3165   {
3166     __ pop(stos);
3167     if (!is_static) {
3168       pop_and_check_object(obj);
3169     }
3170     __ access_store_tos_at(T_SHORT, IN_HEAP, field, noreg, noreg);
3171     if (rc == may_rewrite) {
3172       patch_bytecode(Bytecodes::_fast_sputfield, bc, r1, true, byte_no);
3173     }
3174     __ b(Done);
3175   }
3176 
3177   __ bind(notShort);
3178   __ cmp(rscratch1, ltos);
3179   __ b(notLong, Assembler::NE);
3180 
3181   // ltos
3182   {
3183     Label nonVolatileLong;
3184     __ pop(ltos);
3185     if (!is_static) pop_and_check_object(obj);
3186     __ tbz(flags, ConstantPoolCacheEntry::is_volatile_shift, nonVolatileLong);
3187     __ lea(flags, field);
3188     __ access_store_tos_at(T_LONG, IN_HEAP | MO_SEQ_CST, Address(flags), r2, r3); // trashes index===rscratch1
3189     if (rc == may_rewrite) {
3190       patch_bytecode(Bytecodes::_fast_lputfield, bc, r1, true, byte_no);
3191     }
3192     __ membar(MacroAssembler::StoreLoad);
3193     __ b(DoneBarrier);
3194     __ bind(nonVolatileLong);
3195     __ access_store_tos_at(T_LONG, IN_HEAP, field, noreg, noreg);
3196     if (rc == may_rewrite) {
3197       patch_bytecode(Bytecodes::_fast_lputfield, bc, r1, true, byte_no);
3198     }
3199     __ b(DoneBarrier);
3200   }
3201 
3202   __ bind(notLong);
3203   __ cmp(rscratch1, ftos);
3204   __ b(notFloat, Assembler::NE);
3205 
3206   // ftos
3207   {
3208     __ pop(ftos);
3209     if (!is_static) pop_and_check_object(obj);
3210     __ access_store_tos_at(T_FLOAT, IN_HEAP, field, index, noreg);
3211     if (rc == may_rewrite) {
3212       patch_bytecode(Bytecodes::_fast_fputfield, bc, r1, true, byte_no);
3213     }
3214     __ b(Done);
3215   }
3216 
3217   __ bind(notFloat);
3218 #ifdef ASSERT
3219   __ cmp(rscratch1, dtos);
3220   __ b(notDouble, Assembler::NE);
3221 #endif // ASSERT
3222 
3223   // dtos
3224   {
3225     Label nonVolatileDouble;
3226     __ pop(dtos);
3227     if (!is_static) pop_and_check_object(obj);
3228     __ tbz(flags, ConstantPoolCacheEntry::is_volatile_shift, nonVolatileDouble);
3229     __ access_store_tos_at(T_DOUBLE, IN_HEAP | MO_SEQ_CST, field, r2, r3); // trashes index===rscratch1
3230     if (rc == may_rewrite) {
3231       patch_bytecode(Bytecodes::_fast_dputfield, bc, r1, true, byte_no);
3232     }
3233     __ membar(MacroAssembler::StoreLoad);
3234     __ b(DoneBarrier);
3235     __ bind(nonVolatileDouble);
3236     __ access_store_tos_at(T_DOUBLE, IN_HEAP, field, index, noreg);
3237     if (rc == may_rewrite) {
3238       patch_bytecode(Bytecodes::_fast_dputfield, bc, r1, true, byte_no);
3239     }
3240     __ b(DoneBarrier);
3241   }
3242 
3243 #ifdef ASSERT
3244   __ b(Done);
3245 
3246   __ bind(notDouble);
3247   __ stop("Bad state");
3248 #endif // ASSERT
3249 
3250   __ bind(Done);
3251 
3252   {
3253     __ tbz(flags, ConstantPoolCacheEntry::is_volatile_shift, DoneBarrier);
3254     __ membar(MacroAssembler::StoreLoad);
3255   }
3256   __ bind(DoneBarrier);
3257   //FIXME find a more elegant way!
3258   __ get_dispatch();
3259 }
3260 
3261 void TemplateTable::putfield(int byte_no) {
3262   putfield_or_static(byte_no, false);
3263 }
3264 
3265 void TemplateTable::nofast_putfield(int byte_no) {
3266   putfield_or_static(byte_no, false, may_not_rewrite);
3267 }
3268 
3269 void TemplateTable::putstatic(int byte_no) {
3270   putfield_or_static(byte_no, true);
3271 }
3272 
3273 void TemplateTable::jvmti_post_fast_field_mod()
3274 {
3275   if (JvmtiExport::can_post_field_modification()) {
3276     // Check to see if a field modification watch has been set before
3277     // we take the time to call into the VM.
3278     Label L2;
3279     __ lea(rscratch1, ExternalAddress((address)JvmtiExport::get_field_modification_count_addr()));
3280     __ ldr(c_rarg3, Address(rscratch1));
3281     __ cmp(c_rarg3, 0);
3282     __ b(L2, Assembler::EQ);
3283     __ pop_ptr(r14);                  // copy the object pointer from tos
3284     __ verify_oop(r14);
3285     __ push_ptr(r14);                 // put the object pointer back on tos
3286     // Save tos values before call_VM() clobbers them. Since we have
3287     // to do it for every data type, we use the saved values as the
3288     // jvalue object.
3289     switch (bytecode()) {          // load values into the jvalue object
3290     case Bytecodes::_fast_aputfield: __ push_ptr(r0); break;
3291     case Bytecodes::_fast_bputfield: // fall through
3292     case Bytecodes::_fast_zputfield: // fall through
3293     case Bytecodes::_fast_sputfield: // fall through
3294     case Bytecodes::_fast_cputfield: // fall through
3295     case Bytecodes::_fast_iputfield: __ push_i(r0); break;
3296     case Bytecodes::_fast_dputfield:
3297         if(hasFPU()) {
3298             __ push_d();
3299         } else {
3300             __ push_l();
3301         }
3302         break;
3303     case Bytecodes::_fast_fputfield:
3304         if(hasFPU()) {
3305             __ push_f();
3306         } else {
3307             __ push_i();
3308         }
3309         break;
3310     case Bytecodes::_fast_lputfield: __ push_l(r0); break;
3311 
3312     default:
3313       ShouldNotReachHere();
3314     }
3315     __ mov(c_rarg3, sp);             // points to jvalue on the stack
3316     // access constant pool cache entry
3317     __ get_cache_entry_pointer_at_bcp(c_rarg2, r0, 1);
3318     __ verify_oop(r14);
3319     // r14: object pointer copied above
3320     // c_rarg2: cache entry pointer
3321     // c_rarg3: jvalue object on the stack
3322     __ call_VM(noreg,
3323                CAST_FROM_FN_PTR(address,
3324                                 InterpreterRuntime::post_field_modification),
3325                r14, c_rarg2, c_rarg3);
3326 
3327     switch (bytecode()) {             // restore tos values
3328     case Bytecodes::_fast_aputfield: __ pop_ptr(r0); break;
3329     case Bytecodes::_fast_fputfield:
3330         if(hasFPU()) {
3331             __ pop_f(); break;
3332         }
3333     case Bytecodes::_fast_bputfield: // fall through
3334     case Bytecodes::_fast_zputfield: // fall through
3335     case Bytecodes::_fast_sputfield: // fall through
3336     case Bytecodes::_fast_cputfield: // fall through
3337     case Bytecodes::_fast_iputfield: __ pop_i(r0); break;
3338     case Bytecodes::_fast_dputfield:
3339         if(hasFPU()) {
3340             __ pop_d(); break;
3341         }
3342     case Bytecodes::_fast_lputfield: __ pop_l(r0); break;
3343     }
3344     __ bind(L2);
3345   }
3346 }
3347 
3348 void TemplateTable::fast_storefield(TosState state)
3349 {
3350   transition(state, vtos);
3351 
3352   ByteSize base = ConstantPoolCache::base_offset();
3353 
3354   jvmti_post_fast_field_mod();
3355 
3356   // access constant pool cache
3357   __ get_cache_and_index_at_bcp(r2, rscratch1, 1); // index not used
3358 
3359   Register flags = r14;
3360   // test for volatile with r14
3361   __ ldr(flags, Address(r2, in_bytes(base +
3362                                    ConstantPoolCacheEntry::flags_offset())));
3363 
3364   // replace index with field offset from cache entry
3365   __ ldr(r3, Address(r2, in_bytes(base + ConstantPoolCacheEntry::f2_offset())));
3366 
3367   // Get object from stack
3368   pop_and_check_object(r2);
3369 
3370   // field address
3371   const Address field(r2, r3);
3372 
3373   // long and double need special processing, see below
3374   // the rest only need barrier before if field is volatile
3375   if (bytecode() != Bytecodes::_fast_dputfield && bytecode() != Bytecodes::_fast_lputfield) {
3376     Label notVolatile;
3377     __ tbz(r14, ConstantPoolCacheEntry::is_volatile_shift, notVolatile);
3378     __ membar(MacroAssembler::StoreStore);
3379     __ bind(notVolatile);
3380   }
3381 
3382   // access field
3383   switch (bytecode()) {
3384   case Bytecodes::_fast_aputfield:
3385     do_oop_store(_masm, field, r0, IN_HEAP);
3386     break;
3387   case Bytecodes::_fast_dputfield:
3388   {
3389     Label notVolatile, cont;
3390     __ tbz(flags, ConstantPoolCacheEntry::is_volatile_shift, notVolatile);
3391     __ membar(MacroAssembler::StoreStore);
3392     __ access_store_tos_at(T_DOUBLE, IN_HEAP | MO_SEQ_CST, field, r2, r3); // trashes rscratch1, ok to reuse r2, r3
3393     __ b(cont);
3394     __ bind(notVolatile);
3395     __ access_store_tos_at(T_DOUBLE, IN_HEAP, field, rscratch1, noreg);
3396     __ bind(cont);
3397   }
3398     break;
3399   case Bytecodes::_fast_lputfield:
3400   {
3401     Label notVolatile, cont;
3402     __ tbz(flags, ConstantPoolCacheEntry::is_volatile_shift, notVolatile);
3403     __ membar(MacroAssembler::StoreStore);
3404     __ access_store_tos_at(T_LONG, IN_HEAP | MO_SEQ_CST, field, r2, r3); // trashes rscratch1, ok to reuse r2, r3
3405     __ b(cont);
3406     __ bind(notVolatile);
3407     __ access_store_tos_at(T_LONG, IN_HEAP, field, rscratch1, noreg);
3408     __ bind(cont);
3409   }
3410     break;
3411   case Bytecodes::_fast_fputfield:
3412     __ access_store_tos_at(T_FLOAT, IN_HEAP, field, rscratch1, noreg);
3413     break;
3414   case Bytecodes::_fast_iputfield:
3415     __ access_store_tos_at(T_INT, IN_HEAP, field, noreg, noreg);
3416     break;
3417   case Bytecodes::_fast_zputfield:
3418     __ access_store_tos_at(T_BOOLEAN, IN_HEAP, field, noreg, noreg);
3419     break;
3420   case Bytecodes::_fast_bputfield:
3421     __ access_store_tos_at(T_BYTE, IN_HEAP, field, noreg, noreg);
3422     break;
3423   case Bytecodes::_fast_sputfield:
3424     __ access_store_tos_at(T_SHORT, IN_HEAP, field, noreg, noreg);
3425     break;
3426   case Bytecodes::_fast_cputfield:
3427     __ access_store_tos_at(T_CHAR, IN_HEAP, field, noreg, noreg);
3428     break;
3429   default:
3430     ShouldNotReachHere();
3431   }
3432 
3433   {
3434     Label notVolatile;
3435     __ tbz(flags, ConstantPoolCacheEntry::is_volatile_shift, notVolatile);
3436     __ membar(MacroAssembler::StoreLoad);
3437     __ bind(notVolatile);
3438   }
3439 }
3440 
3441 
3442 void TemplateTable::fast_accessfield(TosState state)
3443 {
3444   transition(atos, state);
3445   // Do the JVMTI work here to avoid disturbing the register state below
3446   if (JvmtiExport::can_post_field_access()) {
3447     // Check to see if a field access watch has been set before we
3448     // take the time to call into the VM.
3449     Label L1;
3450     __ lea(rscratch1, ExternalAddress((address) JvmtiExport::get_field_access_count_addr()));
3451     __ ldr(r2, Address(rscratch1));
3452     __ cmp(r2, 0);
3453     __ b(L1, Assembler::EQ);
3454     // access constant pool cache entry
3455     __ get_cache_entry_pointer_at_bcp(c_rarg2, rscratch2, 1);
3456     __ verify_oop(r0);
3457     __ push_ptr(r0);  // save object pointer before call_VM() clobbers it
3458     __ mov(c_rarg1, r0);
3459     // c_rarg1: object pointer copied above
3460     // c_rarg2: cache entry pointer
3461     __ call_VM(noreg,
3462                CAST_FROM_FN_PTR(address,
3463                                 InterpreterRuntime::post_field_access),
3464                c_rarg1, c_rarg2);
3465     __ pop_ptr(r0); // restore object pointer
3466     __ bind(L1);
3467   }
3468 
3469   // access constant pool cache
3470   __ get_cache_and_index_at_bcp(r2, r1, 1);
3471   __ ldr(r1, Address(r2, in_bytes(ConstantPoolCache::base_offset() +
3472                                   ConstantPoolCacheEntry::f2_offset())));
3473   __ ldr(r3, Address(r2, in_bytes(ConstantPoolCache::base_offset() +
3474                                   ConstantPoolCacheEntry::flags_offset())));
3475 
3476   // r0: object
3477   __ verify_oop(r0);
3478   __ null_check(r0);
3479   const Address field(r0, r1);
3480 
3481   // access field
3482   switch (bytecode()) {
3483   case Bytecodes::_fast_agetfield:
3484     do_oop_load(_masm, field, r0, IN_HEAP);
3485     __ verify_oop(r0);
3486     break;
3487   case Bytecodes::_fast_dgetfield:
3488   {
3489     Label notVolatile, cont;
3490     __ tbz(r3, ConstantPoolCacheEntry::is_volatile_shift, notVolatile);
3491     __ access_load_tos_at(T_DOUBLE, IN_HEAP | MO_SEQ_CST, field, r2, r3); // trashes rscratch1
3492     __ membar(MacroAssembler::LoadLoad | MacroAssembler::LoadStore);
3493     __ b(cont);
3494     __ bind(notVolatile);
3495     __ access_load_tos_at(T_DOUBLE, IN_HEAP, field, rscratch1, noreg);
3496     __ bind(cont);
3497   }
3498     break;
3499   case Bytecodes::_fast_lgetfield:
3500   {
3501     Label notVolatile, cont;
3502     __ tbz(r3, ConstantPoolCacheEntry::is_volatile_shift, notVolatile);
3503     __ access_load_tos_at(T_LONG, IN_HEAP | MO_SEQ_CST, field, r2, r3); // trashes rscratch1
3504     __ membar(MacroAssembler::LoadLoad | MacroAssembler::LoadStore);
3505     __ b(cont);
3506     __ bind(notVolatile);
3507     __ access_load_tos_at(T_LONG, IN_HEAP, field, noreg, noreg);
3508     __ bind(cont);
3509   }
3510     break;
3511   case Bytecodes::_fast_fgetfield:
3512     __ access_load_tos_at(T_FLOAT, IN_HEAP, field, rscratch1, noreg);
3513     break;
3514   case Bytecodes::_fast_igetfield:
3515     __ access_load_tos_at(T_INT, IN_HEAP, field, noreg, noreg);
3516     break;
3517   case Bytecodes::_fast_bgetfield:
3518     __ access_load_tos_at(T_BYTE, IN_HEAP, field, noreg, noreg);
3519     break;
3520   case Bytecodes::_fast_sgetfield:
3521     __ access_load_tos_at(T_SHORT, IN_HEAP, field, noreg, noreg);
3522     break;
3523   case Bytecodes::_fast_cgetfield:
3524     __ access_load_tos_at(T_CHAR, IN_HEAP, field, noreg, noreg);
3525     break;
3526   default:
3527     ShouldNotReachHere();
3528   }
3529   // long and double have barrier already placed
3530   if (bytecode() != Bytecodes::_fast_dgetfield && bytecode() != Bytecodes::_fast_lgetfield) {
3531     Label notVolatile;
3532     __ tbz(r3, ConstantPoolCacheEntry::is_volatile_shift, notVolatile);
3533     __ membar(MacroAssembler::LoadLoad | MacroAssembler::LoadStore);
3534     __ bind(notVolatile);
3535   }
3536 }
3537 
3538 void TemplateTable::fast_xaccess(TosState state)
3539 {
3540   transition(vtos, state);
3541 
3542   // get receiver
3543   __ ldr(r0, aaddress(0));
3544   // access constant pool cache
3545   __ get_cache_and_index_at_bcp(r2, r3, 2);
3546   __ ldr(r1, Address(r2, in_bytes(ConstantPoolCache::base_offset() +
3547                                   ConstantPoolCacheEntry::f2_offset())));
3548   // make sure exception is reported in correct bcp range (getfield is
3549   // next instruction)
3550   __ add(rbcp, rbcp, 1);
3551   __ null_check(r0);
3552 
3553   Address field(r0, r1);
3554   switch (state) {
3555   case ftos:
3556     __ access_load_tos_at(T_FLOAT, IN_HEAP, field, r0, noreg);
3557     break;
3558   case itos:
3559     __ access_load_tos_at(T_INT, IN_HEAP, field, noreg, noreg);
3560     break;
3561   case atos:
3562     do_oop_load(_masm, field, r0, IN_HEAP);
3563     __ verify_oop(r0);
3564     break;
3565   default:
3566     ShouldNotReachHere();
3567   }
3568 
3569   {
3570     Label notVolatile;
3571     __ ldr(r3, Address(r2, in_bytes(ConstantPoolCache::base_offset() +
3572                                      ConstantPoolCacheEntry::flags_offset())));
3573     __ tbz(r3, ConstantPoolCacheEntry::is_volatile_shift, notVolatile);
3574     __ membar(MacroAssembler::LoadLoad | MacroAssembler::LoadStore);
3575     __ bind(notVolatile);
3576   }
3577 
3578   __ sub(rbcp, rbcp, 1);
3579 }
3580 
3581 
3582 
3583 //-----------------------------------------------------------------------------
3584 // Calls
3585 
3586 void TemplateTable::count_calls(Register method, Register temp) {
3587   // implemented elsewhere
3588   ShouldNotReachHere();
3589 }
3590 
3591 void TemplateTable::prepare_invoke(int byte_no,
3592                                    Register method, // linked method (or i-klass)
3593                                    Register index,  // itable index, MethodType, etc.
3594                                    Register recv,   // if caller wants to see it
3595                                    Register flags   // if caller wants to test it
3596                                    ) {
3597   // determine flags
3598   Bytecodes::Code code = bytecode();
3599   const bool is_invokeinterface  = code == Bytecodes::_invokeinterface;
3600   const bool is_invokedynamic    = code == Bytecodes::_invokedynamic;
3601   const bool is_invokehandle     = code == Bytecodes::_invokehandle;
3602   const bool is_invokevirtual    = code == Bytecodes::_invokevirtual;
3603   const bool is_invokespecial    = code == Bytecodes::_invokespecial;
3604   const bool load_receiver       = (recv  != noreg);
3605   const bool save_flags          = (flags != noreg);
3606   assert(load_receiver == (code != Bytecodes::_invokestatic && code != Bytecodes::_invokedynamic), "");
3607   assert(save_flags    == (is_invokeinterface || is_invokevirtual), "need flags for vfinal");
3608   assert(flags == noreg || flags == r3, "");
3609   assert(recv  == noreg || recv  == r2, "");
3610 
3611   // setup registers & access constant pool cache
3612   if (recv  == noreg)  recv  = r2;
3613   if (flags == noreg)  flags = r3;
3614   assert_different_registers(method, index, recv, flags);
3615 
3616   // save 'interpreter return address'
3617   __ save_bcp();
3618 
3619   load_invoke_cp_cache_entry(byte_no, method, index, flags, is_invokevirtual, false, is_invokedynamic);
3620 
3621   // maybe push appendix to arguments (just before return address)
3622   if (is_invokedynamic || is_invokehandle) {
3623     Label L_no_push;
3624     __ tbz(flags, ConstantPoolCacheEntry::has_appendix_shift, L_no_push);
3625     // Push the appendix as a trailing parameter.
3626     // This must be done before we get the receiver,
3627     // since the parameter_size includes it.
3628     __ push(r14); //NOT NEEDED?!
3629     __ mov(r14, index);
3630     assert(ConstantPoolCacheEntry::_indy_resolved_references_appendix_offset == 0, "appendix expected at index+0");
3631     __ load_resolved_reference_at_index(index, r14);
3632     __ pop(r14);
3633     __ push(index);  // push appendix (MethodType, CallSite, etc.)
3634     __ bind(L_no_push);
3635   }
3636 
3637   // load receiver if needed (note: no return address pushed yet)
3638   if (load_receiver) {
3639     __ andr(recv, flags, ConstantPoolCacheEntry::parameter_size_mask);
3640     // const int no_return_pc_pushed_yet = -1;  // argument slot correction before we push return address
3641     // const int receiver_is_at_end      = -1;  // back off one slot to get receiver
3642     // Address recv_addr = __ argument_address(recv, no_return_pc_pushed_yet + receiver_is_at_end);
3643     // __ movptr(recv, recv_addr);
3644 
3645     __ add(rscratch1, sp, recv, lsl(2));
3646     __ ldr(recv, Address(rscratch1, -Interpreter::expr_offset_in_bytes(1)));
3647     __ verify_oop(recv);
3648   }
3649 
3650   // compute return type
3651   // x86 uses a shift and mask or wings it with a shift plus assert
3652   // the mask is not needed. aarch32 just uses bitfield extract
3653   __ extract_bits(rscratch2, flags, ConstantPoolCacheEntry::tos_state_shift,  ConstantPoolCacheEntry::tos_state_bits);
3654   // load return address
3655   {
3656     const address table_addr = (address) Interpreter::invoke_return_entry_table_for(code);
3657     __ mov(rscratch1, table_addr);
3658     __ ldr(lr, Address(rscratch1, rscratch2, lsl(2)));
3659   }
3660 }
3661 
3662 
3663 void TemplateTable::invokevirtual_helper(Register index,
3664                                          Register recv,
3665                                          Register flags)
3666 {
3667   // Uses temporary registers r0, r3
3668   assert_different_registers(index, recv, r0, r3);
3669   // Test for an invoke of a final method
3670   Label notFinal;
3671   __ tbz(flags, ConstantPoolCacheEntry::is_vfinal_shift, notFinal);
3672 
3673   __ reg_printf("It's a virtual final call\n");
3674   const Register method = index;  // method must be rmethod
3675   assert(method == rmethod,
3676          "methodOop must be rmethod for interpreter calling convention");
3677 
3678   // do the call - the index is actually the method to call
3679   // that is, f2 is a vtable index if !is_vfinal, else f2 is a Method*
3680 
3681   // It's final, need a null check here!
3682   __ null_check(recv);
3683 
3684   // profile this call
3685   __ profile_final_call(r0);
3686   __ profile_arguments_type(r0, method, rscratch2, true);
3687 
3688   __ jump_from_interpreted(method, r0);
3689 
3690   __ bind(notFinal);
3691   __ reg_printf("It's not a virtual final call\n");
3692   // get receiver klass
3693   __ null_check(recv, oopDesc::klass_offset_in_bytes());
3694   __ load_klass(r0, recv);
3695 
3696   // profile this call
3697   __ profile_virtual_call(r0, rlocals, r3);
3698 
3699   // get target methodOop & entry point
3700   __ lookup_virtual_method(r0, index, method);
3701   __ profile_arguments_type(r3, method, rscratch2, true);
3702 
3703   __ jump_from_interpreted(method, r3);
3704 }
3705 
3706 void TemplateTable::invokevirtual(int byte_no)
3707 {
3708   transition(vtos, vtos);
3709   assert(byte_no == f2_byte, "use this argument");
3710 
3711   __ reg_printf("Invokevirtual, the sp is %p\n", sp);
3712   prepare_invoke(byte_no, rmethod, noreg, r2, r3);
3713 
3714   // rmethod: index (actually a Method*)
3715   // r2: receiver
3716   // r3: flags
3717 
3718   invokevirtual_helper(rmethod, r2, r3);
3719 }
3720 
3721 void TemplateTable::invokespecial(int byte_no)
3722 {
3723   transition(vtos, vtos);
3724   assert(byte_no == f1_byte, "use this argument");
3725   __ ldr(rscratch1, Address(sp));
3726   __ reg_printf("Stack pointer is %p, tos word = %p\n", sp, rscratch1);
3727 
3728   prepare_invoke(byte_no, rmethod, noreg,  // get f1 Method*
3729                  r2);  // get receiver also for null check
3730 
3731   __ verify_oop(r2);
3732   __ null_check(r2);
3733 
3734   // do the call
3735   __ profile_call(r0);
3736   __ profile_arguments_type(r0, rmethod, rbcp, false);
3737   __ jump_from_interpreted(rmethod, r0);
3738 }
3739 
3740 void TemplateTable::invokestatic(int byte_no)
3741 {
3742   transition(vtos, vtos);
3743   assert(byte_no == f1_byte, "use this argument");
3744 
3745   prepare_invoke(byte_no, rmethod);  // get f1 Method*
3746   // do the call
3747   __ profile_call(r0);
3748   __ profile_arguments_type(r0, rmethod, rscratch2, false);
3749   __ jump_from_interpreted(rmethod, r0);
3750 }
3751 
3752 void TemplateTable::fast_invokevfinal(int byte_no) {
3753   transition(vtos, vtos);
3754   assert(byte_no == f2_byte, "use this argument");
3755   __ stop("fast_invokevfinal not used on aarch32");}
3756 
3757 void TemplateTable::invokeinterface(int byte_no) {
3758   transition(vtos, vtos);
3759   assert(byte_no == f1_byte, "use this argument");
3760 
3761   Register temp = rdispatch; //free at this point and reloaded later
3762   prepare_invoke(byte_no, r0, rmethod,  // get f1 Klass*, f2 Method*
3763                  r2, r3); // recv, flags
3764 
3765 
3766   __ create_breakpoint();
3767   // r0: interface klass (from f1)
3768   // rmethod: method (from f2)
3769   // r2: receiver
3770   // r3: flags
3771 
3772   // First check for Object case, then private interface method,
3773   // then regular interface method.
3774 
3775   // Special case of invokeinterface called for virtual method of
3776   // java.lang.Object.  See cpCache.cpp for details.
3777   Label notObjectMethod;
3778   __ tbz(r3, ConstantPoolCacheEntry::is_forced_virtual_shift, notObjectMethod);
3779 
3780   __ reg_printf("ABC: Invoking invokevirtual_helper\n");
3781   invokevirtual_helper(rmethod, r2, r3); //loads lr too
3782   __ bind(notObjectMethod);
3783 
3784   Label no_such_interface;
3785 
3786   // Check for private method invocation - indicated by vfinal
3787   Label notVFinal;
3788   __ tbz(r3, ConstantPoolCacheEntry::is_vfinal_shift, notVFinal);
3789 
3790   // Get receiver klass into r3 - also a null check
3791   __ null_check(r2, oopDesc::klass_offset_in_bytes());
3792   __ load_klass(r3, r2);
3793 
3794   Label subtype;
3795   __ check_klass_subtype(r3, r0, temp, subtype);
3796   // If we get here the typecheck failed
3797   __ b(no_such_interface);
3798   __ bind(subtype);
3799 
3800   __ profile_final_call(r0);
3801   __ profile_arguments_type(r0, rmethod, temp, true);
3802   __ jump_from_interpreted(rmethod, r0);
3803 
3804   __ bind(notVFinal);
3805 
3806   __ reg_printf("ABC: invokeinterface says 'It's not a method'\n");
3807   // Get receiver klass into r3 - also a null check
3808   __ restore_locals();
3809   __ null_check(r2, oopDesc::klass_offset_in_bytes());
3810   __ load_klass(r3, r2);
3811 
3812   Label no_such_method;
3813 
3814   // Preserve method in r1 for throw_AbstractMethodErrorVerbose.
3815   __ mov(r1, rmethod);
3816   // Receiver subtype check against REFC.
3817   // Superklass in r0. Subklass in r3.
3818   __ lookup_interface_method(// inputs: rec. class, interface, itable index
3819                              r3, r0, noreg,
3820                              // outputs: scan temp. reg, scan temp. reg
3821                              rbcp, temp,
3822                              no_such_interface,
3823                              /*return_method=*/false);
3824 
3825 
3826   // profile this call
3827   __ restore_bcp(); // rbcp was destroyed by receiver type check
3828   __ profile_virtual_call(r3, temp, r0);
3829 
3830   // Get declaring interface class from method, and itable index
3831   __ ldr(r0, Address(rmethod, Method::const_offset()));
3832   __ ldr(r0, Address(r0, ConstMethod::constants_offset()));
3833   __ ldr(r0, Address(r0, ConstantPool::pool_holder_offset_in_bytes()));
3834   __ ldr(rmethod, Address(rmethod, Method::itable_index_offset()));
3835   assert(Method::itable_index_max <= 0, "incorrect below");
3836   __ add(temp, rmethod, -Method::itable_index_max);
3837   __ neg(rmethod, temp);
3838 
3839   // Preserve recvKlass for throw_AbstractMethodErrorVerbose.
3840   __ mov(rlocals, r3);
3841   __ lookup_interface_method(// inputs: rec. class, interface, itable index
3842                              rlocals, r0, rmethod,
3843                              // outputs: method, scan temp. reg
3844                              rmethod, temp,
3845                              no_such_interface);
3846 
3847   // rmethod,: methodOop to call
3848   // r2: receiver
3849   // Check for abstract method error
3850   // Note: This should be done more efficiently via a throw_abstract_method_error
3851   //       interpreter entry point and a conditional jump to it in case of a null
3852   //       method.
3853   __ cbz(rmethod, no_such_method);
3854 
3855   __ profile_arguments_type(r3, rmethod, temp, true);
3856 
3857   // do the call
3858   // r2: receiver
3859   // rmethod,: methodOop
3860   __ jump_from_interpreted(rmethod, r3);
3861   __ should_not_reach_here();
3862 
3863   // exception handling code follows...
3864   // note: must restore interpreter registers to canonical
3865   //       state for exception handling to work correctly!
3866 
3867   __ bind(no_such_method);
3868   __ reg_printf("ABC: invokeinterface says 'There's no such method'\n");
3869   // throw exception
3870   __ restore_bcp();      // bcp must be correct for exception handler   (was destroyed)
3871   __ restore_locals();   // make sure locals pointer is correct as well (was destroyed)
3872   // Pass arguments for generating a verbose error message.
3873   __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_AbstractMethodErrorVerbose), r3, r1);
3874   // the call_VM checks for exception, so we should never return here.
3875   __ should_not_reach_here();
3876 
3877   __ bind(no_such_interface);
3878   __ reg_printf("ABC: invokeinterface says 'There's no such interface'\n");
3879   // throw exception
3880   __ restore_bcp();      // bcp must be correct for exception handler   (was destroyed)
3881   __ restore_locals();   // make sure locals pointer is correct as well (was destroyed)
3882   // Pass arguments for generating a verbose error message.
3883   __ call_VM(noreg, CAST_FROM_FN_PTR(address,
3884                    InterpreterRuntime::throw_IncompatibleClassChangeErrorVerbose), r3, r0);
3885   // the call_VM checks for exception, so we should never return here.
3886   __ should_not_reach_here();
3887   return;
3888 }
3889 
3890 void TemplateTable::invokehandle(int byte_no) {
3891   transition(vtos, vtos);
3892   assert(byte_no == f1_byte, "use this argument");
3893 
3894   prepare_invoke(byte_no, rmethod, r0, r2);
3895   __ verify_method_ptr(r2);
3896   __ verify_oop(r2);
3897   __ null_check(r2);
3898 
3899   // FIXME: profile the LambdaForm also
3900 
3901   __ profile_final_call(r3);
3902   __ profile_arguments_type(r3, rmethod, rscratch2, true);
3903 
3904   __ jump_from_interpreted(rmethod, r0);
3905 }
3906 
3907 void TemplateTable::invokedynamic(int byte_no) {
3908   transition(vtos, vtos);
3909   assert(byte_no == f1_byte, "use this argument");
3910 
3911   prepare_invoke(byte_no, rmethod, r0);
3912 
3913   // r0: CallSite object (from cpool->resolved_references[])
3914   // rmethod: MH.linkToCallSite method (from f2)
3915 
3916   // Note:  r0_callsite is already pushed by prepare_invoke
3917 
3918   // %%% should make a type profile for any invokedynamic that takes a ref argument
3919   // profile this call
3920   __ profile_call(rbcp);
3921   __ profile_arguments_type(r3, rmethod, rscratch2, false);
3922 
3923   __ verify_oop(r0);
3924 
3925   __ jump_from_interpreted(rmethod, r0);
3926 }
3927 
3928 
3929 //-----------------------------------------------------------------------------
3930 // Allocation
3931 
3932 void TemplateTable::_new() {
3933   transition(vtos, atos);
3934 
3935   __ get_unsigned_2_byte_index_at_bcp(r3, 1);
3936   Label slow_case;
3937   Label done;
3938   Label initialize_header;
3939   Label initialize_object; // including clearing the fields
3940 
3941   __ get_cpool_and_tags(r2, r0);
3942   // Make sure the class we're about to instantiate has been resolved.
3943   // This is done before loading InstanceKlass to be consistent with the order
3944   // how Constant Pool is updated (see ConstantPool::klass_at_put)
3945   const int tags_offset = Array<u1>::base_offset_in_bytes();
3946   __ lea(rscratch1, Address(r0, r3, lsl(0)));
3947   __ ldrb(rscratch1, Address(rscratch1, tags_offset));
3948   __ cmp(rscratch1, JVM_CONSTANT_Class);
3949   __ b(slow_case, Assembler::NE);
3950 
3951   // get InstanceKlass
3952   __ load_resolved_klass_at_offset(r2, r3, r2, rscratch1);
3953 
3954   // make sure klass is initialized & doesn't have finalizer
3955   // make sure klass is fully initialized
3956   __ ldrb(rscratch1, Address(r2, InstanceKlass::init_state_offset()));
3957   __ cmp(rscratch1, InstanceKlass::fully_initialized);
3958   __ b(slow_case, Assembler::NE);
3959 
3960   // get instance_size in InstanceKlass (scaled to a count of bytes)
3961   __ ldr(r3, Address(r2, Klass::layout_helper_offset()));
3962   // test to see if it has a finalizer or is malformed in some way
3963   __ tbnz(r3, exact_log2(Klass::_lh_instance_slow_path_bit), slow_case);
3964 
3965   // Allocate the instance:
3966   //  If TLAB is enabled:
3967   //    Try to allocate in the TLAB.
3968   //    If fails, go to the slow path.
3969   //  Else If inline contiguous allocations are enabled:
3970   //    Try to allocate in eden.
3971   //    If fails due to heap end, go to slow path.
3972   //
3973   //  If TLAB is enabled OR inline contiguous is enabled:
3974   //    Initialize the allocation.
3975   //    Exit.
3976   //
3977   //  Go to slow path.
3978   const bool allow_shared_alloc =
3979     Universe::heap()->supports_inline_contig_alloc();
3980 
3981   if (UseTLAB) {
3982     __ tlab_allocate(r0, r3, 0, noreg, r1, slow_case);
3983 
3984     if (ZeroTLAB) {
3985       // the fields have been already cleared
3986       __ b(initialize_header);
3987     } else {
3988       // initialize both the header and fields
3989       __ b(initialize_object);
3990     }
3991   } else {
3992     // Allocation in the shared Eden, if allowed.
3993     //
3994     // r3: instance size in bytes
3995     if (allow_shared_alloc) {
3996       __ eden_allocate(r0, r3, 0, r10, slow_case);
3997     }
3998   }
3999 
4000   // If UseTLAB or allow_shared_alloc are true, the object is created above and
4001   // there is an initialize need. Otherwise, skip and go to the slow path.
4002   if (UseTLAB || allow_shared_alloc) {
4003     // The object is initialized before the header.  If the object size is
4004     // zero, go directly to the header initialization.
4005     __ bind(initialize_object);
4006     __ sub(r3, r3, sizeof(oopDesc));
4007     __ cbz(r3, initialize_header);
4008 
4009     // Initialize object fields
4010     {
4011       __ add(rscratch1, r0, sizeof(oopDesc));
4012       __ mov(rscratch2, 0);
4013       Label loop;
4014       __ bind(loop);
4015       __ str(rscratch2, Address(__ post(rscratch1, BytesPerInt)));
4016       __ sub(r3, r3, BytesPerInt);
4017       __ cbnz(r3, loop);
4018     }
4019 
4020     // initialize object header only.
4021     __ bind(initialize_header);
4022     if (UseBiasedLocking) {
4023       __ ldr(rscratch1, Address(r2, Klass::prototype_header_offset()));
4024     } else {
4025       __ mov(rscratch1, (intptr_t)markOopDesc::prototype());
4026     }
4027     __ str(rscratch1, Address(r0, oopDesc::mark_offset_in_bytes()));
4028     __ mov(rscratch2, 0);
4029     __ store_klass_gap(r0, rscratch2);  // zero klass gap for compressed oops - not using
4030     // not using compressed oops
4031     __ store_klass(r0, r2);      // store klass last
4032 
4033 #ifdef DTRACE_ENABLED
4034     {
4035       SkipIfEqual skip(_masm, &DTraceAllocProbes, false);
4036       // Trigger dtrace event for fastpath
4037       __ push(atos); // save the return value
4038       __ call_VM_leaf(
4039            CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_object_alloc), r0);
4040       __ pop(atos); // restore the return value
4041 
4042     }
4043 #endif
4044     __ b(done);
4045   }
4046 
4047   // slow case
4048   __ bind(slow_case);
4049   __ get_constant_pool(c_rarg1);
4050   __ get_unsigned_2_byte_index_at_bcp(c_rarg2, 1);
4051   call_VM(r0, CAST_FROM_FN_PTR(address, InterpreterRuntime::_new), c_rarg1, c_rarg2);
4052   __ verify_oop(r0);
4053 
4054   // continue
4055   __ bind(done);
4056 
4057   __ reg_printf("New object reference is %p\n", r0);
4058   // Must prevent reordering of stores for object initialization with stores that publish the new object.
4059   __ membar(Assembler::StoreStore);
4060 }
4061 
4062 void TemplateTable::newarray() {
4063   transition(itos, atos);
4064   __ load_unsigned_byte(c_rarg1, at_bcp(1));
4065   __ mov(c_rarg2, r0);
4066   call_VM(r0, CAST_FROM_FN_PTR(address, InterpreterRuntime::newarray),
4067           c_rarg1, c_rarg2);
4068   // Must prevent reordering of stores for object initialization with stores that publish the new object.
4069   __ membar(Assembler::StoreStore);
4070 }
4071 
4072 void TemplateTable::anewarray() {
4073   transition(itos, atos);
4074   __ get_unsigned_2_byte_index_at_bcp(c_rarg2, 1);
4075   __ reg_printf("Index = %d\n", c_rarg2);
4076   __ get_constant_pool(c_rarg1);
4077   __ mov(c_rarg3, r0);
4078   __ reg_printf("About to call InterpreterRuntime::anewarray\n");
4079   call_VM(r0, CAST_FROM_FN_PTR(address, InterpreterRuntime::anewarray),
4080           c_rarg1, c_rarg2, c_rarg3);
4081   __ reg_printf("Finshed call to InterpreterRuntime::anewarray\n");
4082   // Must prevent reordering of stores for object initialization with stores that publish the new object.
4083   __ membar(Assembler::StoreStore);
4084   __ reg_printf("Finshed anewarray\n");
4085 }
4086 
4087 void TemplateTable::arraylength() {
4088   transition(atos, itos);
4089   __ null_check(r0, arrayOopDesc::length_offset_in_bytes());
4090   __ ldr(r0, Address(r0, arrayOopDesc::length_offset_in_bytes()));
4091 }
4092 
4093 void TemplateTable::checkcast()
4094 {
4095   transition(atos, atos);
4096   Label done, is_null, ok_is_subtype, quicked, resolved;
4097   __ cbz(r0, is_null);
4098 
4099   // Get cpool & tags index
4100   __ get_cpool_and_tags(r2, r3); // r2=cpool, r3=tags array
4101   __ get_unsigned_2_byte_index_at_bcp(r14, 1); // r14=index
4102   // See if bytecode has already been quicked
4103   __ add(rscratch1, r3, Array<u1>::base_offset_in_bytes());
4104   __ ldrb(r1, Address(rscratch1, r14));
4105   __ cmp(r1, JVM_CONSTANT_Class);
4106   __ b(quicked, Assembler::EQ);
4107 
4108   __ push(atos); // save receiver for result, and for GC
4109   call_VM(r0, CAST_FROM_FN_PTR(address, InterpreterRuntime::quicken_io_cc));
4110   // vm_result_2 has metadata result
4111   __ get_vm_result_2(r0, rthread);
4112   __ pop(r3); // restore receiver
4113   __ b(resolved);
4114 
4115   // Get superklass in r0 and subklass in r3
4116   __ bind(quicked);
4117   __ mov(r3, r0); // Save object in r3; r0 needed for subtype check
4118   __ load_resolved_klass_at_offset(r2, r14, r0, rscratch1); // r0 = klass
4119 
4120   __ bind(resolved);
4121   __ load_klass(r1, r3);
4122 
4123   // Generate subtype check.  Blows r2. Object in r3.
4124   // Superklass in r0. Subklass in r1.
4125   __ gen_subtype_check(r1, ok_is_subtype);
4126 
4127   // Come here on failure
4128   __ push(r3);
4129   // object is at TOS
4130   __ b(Interpreter::_throw_ClassCastException_entry);
4131 
4132   // Come here on success
4133   __ bind(ok_is_subtype);
4134   __ mov(r0, r3); // Restore object in r3
4135 
4136   // Collect counts on whether this test sees NULLs a lot or not.
4137   if (ProfileInterpreter) {
4138     __ b(done);
4139     __ bind(is_null);
4140     __ profile_null_seen(r2);
4141   } else {
4142     __ bind(is_null);   // same as 'done'
4143   }
4144   __ bind(done);
4145 }
4146 
4147 void TemplateTable::instanceof() {
4148   transition(atos, itos);
4149   Label done, is_null, ok_is_subtype, quicked, resolved;
4150   __ cbz(r0, is_null);
4151 
4152   // Get cpool & tags index
4153   __ get_cpool_and_tags(r2, r3); // r2=cpool, r3=tags array
4154   __ get_unsigned_2_byte_index_at_bcp(r14, 1); // r14=index
4155 
4156   // See if bytecode has already been quicked
4157   __ add(rscratch1, r3, Array<u1>::base_offset_in_bytes());
4158   __ ldrb(r1, Address(rscratch1, r14));
4159   __ cmp(r1, JVM_CONSTANT_Class);
4160   __ b(quicked, Assembler::EQ);
4161 
4162   __ push(atos); // save receiver for result, and for GC
4163   __ push_i(r14); // save index (used if profiling)
4164   call_VM(r0, CAST_FROM_FN_PTR(address, InterpreterRuntime::quicken_io_cc));
4165   // vm_result_2 has metadata result
4166   __ get_vm_result_2(r0, rthread);
4167   __ pop_i(r14); // restore index
4168   __ pop(r3); // restore receiver
4169   __ verify_oop(r3);
4170   __ load_klass(r3, r3);
4171   __ b(resolved);
4172 
4173   // Get superklass in r0 and subklass in r3
4174   __ bind(quicked);
4175   __ load_klass(r3, r0);
4176   __ load_resolved_klass_at_offset(r2, r14, r0, rscratch1);
4177 
4178   __ bind(resolved);
4179 
4180   // Generate subtype check.  Blows r2.
4181   // Superklass in r0.  Subklass in r3.
4182   __ gen_subtype_check(r3, ok_is_subtype);
4183 
4184   // Come here on failure
4185   __ mov(r0, 0);
4186   __ b(done);
4187   // Come here on success
4188   __ bind(ok_is_subtype);
4189   __ mov(r0, 1);
4190 
4191   // Collect counts on whether this test sees NULLs a lot or not.
4192   if (ProfileInterpreter) {
4193     __ b(done);
4194     __ bind(is_null);
4195     __ profile_null_seen(r2);
4196   } else {
4197     __ bind(is_null);   // same as 'done'
4198   }
4199   __ bind(done);
4200   // r0 = 0: obj == NULL or  obj is not an instanceof the specified klass
4201   // r0 = 1: obj != NULL and obj is     an instanceof the specified klass
4202 }
4203 
4204 //-----------------------------------------------------------------------------
4205 // Breakpoints
4206 void TemplateTable::_breakpoint() {
4207   // Note: We get here even if we are single stepping..
4208   // jbug inists on setting breakpoints at every bytecode
4209   // even if we are in single step mode.
4210 
4211   transition(vtos, vtos);
4212 
4213   // get the unpatched byte code
4214   __ get_method(c_rarg1);
4215   __ call_VM(noreg,
4216              CAST_FROM_FN_PTR(address,
4217                               InterpreterRuntime::get_original_bytecode_at),
4218              c_rarg1, rbcp);
4219   __ push(r0);
4220 
4221   // post the breakpoint event
4222   __ call_VM(noreg,
4223              CAST_FROM_FN_PTR(address, InterpreterRuntime::_breakpoint),
4224              rmethod, rbcp);
4225 
4226   // complete the execution of original bytecode
4227   __ pop(rscratch1);
4228   __ dispatch_only_normal(vtos);
4229 }
4230 
4231 //-----------------------------------------------------------------------------
4232 // Exceptions
4233 
4234 void TemplateTable::athrow() {
4235   transition(atos, vtos);
4236   __ null_check(r0);
4237   __ b(Interpreter::throw_exception_entry());
4238 }
4239 
4240 //-----------------------------------------------------------------------------
4241 // Synchronization
4242 //
4243 // Note: monitorenter & exit are symmetric routines; which is reflected
4244 //       in the assembly code structure as well
4245 //
4246 // Stack layout:
4247 //
4248 // [expressions  ] <--- sp                = expression stack top
4249 // ..
4250 // [expressions  ]
4251 // [monitor entry] <--- monitor block top = expression stack bot
4252 // ..
4253 // [monitor entry]
4254 // [frame data   ] <--- monitor block bot
4255 // ...
4256 // [saved rbp    ] <--- rbp
4257 void TemplateTable::monitorenter()
4258 {
4259   transition(atos, vtos);
4260 
4261   // check for NULL object
4262   __ null_check(r0);
4263 
4264   const Address monitor_block_top(
4265         rfp, frame::get_interpreter_frame_monitor_block_top_offset() * wordSize);
4266   const Address monitor_block_bot(
4267         rfp, frame::get_interpreter_frame_initial_sp_offset() * wordSize);
4268   const int entry_size = frame::interpreter_frame_monitor_size() * wordSize;
4269 
4270   Label allocated;
4271 
4272   // initialize entry pointer
4273   __ mov(c_rarg1, 0); // points to free slot or NULL
4274 
4275   // find a free slot in the monitor block (result in c_rarg1)
4276   {
4277     Label entry, loop, exit;
4278     __ ldr(c_rarg3, monitor_block_top); // points to current entry,
4279                                         // starting with top-most entry
4280     __ lea(c_rarg2, monitor_block_bot); // points to word before bottom
4281 
4282     __ b(entry);
4283 
4284     __ bind(loop);
4285     // check if current entry is used
4286     // if not used then remember entry in c_rarg1
4287     __ ldr(rscratch1, Address(c_rarg3, BasicObjectLock::obj_offset_in_bytes()));
4288     __ cmp(rscratch1, 0);
4289     __ mov(c_rarg1, c_rarg3, Assembler::EQ);
4290     // check if current entry is for same object
4291     __ cmp(r0, rscratch1);
4292     // if same object then stop searching
4293     __ b(exit, Assembler::EQ);
4294     // otherwise advance to next entry
4295     __ add(c_rarg3, c_rarg3, entry_size);
4296     __ bind(entry);
4297     // check if bottom reached
4298     __ cmp(c_rarg3, c_rarg2);
4299     // if not at bottom then check this entry
4300     __ b(loop, Assembler::NE);
4301     __ bind(exit);
4302   }
4303 
4304   __ cbnz(c_rarg1, allocated); // check if a slot has been found and
4305                             // if found, continue with that on
4306 
4307   // allocate one if there's no free slot
4308   {
4309     Label entry, loop; //, no_adjust;
4310     // 1. compute new pointers            // rsp: old expression stack top
4311     __ ldr(c_rarg1, monitor_block_bot);   // c_rarg1: old expression stack bottom
4312     __ sub(sp, sp, entry_size);           // move expression stack top
4313     __ sub(c_rarg1, c_rarg1, entry_size); // move expression stack bottom
4314     __ mov(c_rarg3, sp);                  // set start value for copy loop
4315     __ str(c_rarg1, monitor_block_bot);   // set new monitor block bottom
4316 
4317     //__ cmp(sp, c_rarg3);                  // Check if we need to move sp
4318     //__ b(no_adjust, Assembler::LO);      // to allow more stack space
4319                                           // for our new sp
4320     //__ sub(sp, sp, 2 * wordSize);
4321     //__ bind(no_adjust);
4322 
4323     __ b(entry);
4324     // 2. move expression stack contents
4325     __ bind(loop);
4326     __ ldr(c_rarg2, Address(c_rarg3, entry_size)); // load expression stack
4327                                                    // word from old location
4328     __ str(c_rarg2, Address(c_rarg3, 0));          // and store it at new location
4329     __ add(c_rarg3, c_rarg3, wordSize);            // advance to next word
4330     __ bind(entry);
4331     __ cmp(c_rarg3, c_rarg1);        // check if bottom reached
4332     __ b(loop, Assembler::NE);      // if not at bottom then
4333                                      // copy next word
4334   }
4335 
4336   // call run-time routine
4337   // c_rarg1: points to monitor entry
4338   __ bind(allocated);
4339 
4340   // Increment bcp to point to the next bytecode, so exception
4341   // handling for async. exceptions work correctly.
4342   // The object has already been poped from the stack, so the
4343   // expression stack looks correct.
4344   __ add(rbcp, rbcp, 1); //inc
4345 
4346   // store object
4347   __ str(r0, Address(c_rarg1, BasicObjectLock::obj_offset_in_bytes()));
4348   __ lock_object(c_rarg1);
4349 
4350   // check to make sure this monitor doesn't cause stack overflow after locking
4351   __ save_bcp();  // in case of exception
4352   __ generate_stack_overflow_check(0);
4353 
4354   // The bcp has already been incremented. Just need to dispatch to
4355   // next instruction.
4356   __ dispatch_next(vtos);
4357 }
4358 
4359 
4360 void TemplateTable::monitorexit()
4361 {
4362   transition(atos, vtos);
4363 
4364   // check for NULL object
4365   __ null_check(r0);
4366 
4367   const Address monitor_block_top(
4368         rfp, frame::get_interpreter_frame_monitor_block_top_offset() * wordSize);
4369   const Address monitor_block_bot(
4370         rfp, frame::get_interpreter_frame_initial_sp_offset() * wordSize);
4371   const int entry_size = frame::interpreter_frame_monitor_size() * wordSize;
4372 
4373   Label found;
4374 
4375   // find matching slot
4376   {
4377     Label entry, loop;
4378     __ ldr(c_rarg1, monitor_block_top); // points to current entry,
4379                                         // starting with top-most entry
4380     __ lea(c_rarg2, monitor_block_bot); // points to word before bottom
4381                                         // of monitor block
4382     __ b(entry);
4383 
4384     __ bind(loop);
4385     // check if current entry is for same object
4386     __ ldr(rscratch1, Address(c_rarg1, BasicObjectLock::obj_offset_in_bytes()));
4387     __ cmp(r0, rscratch1);
4388     // if same object then stop searching
4389     __ b(found, Assembler::EQ);
4390     // otherwise advance to next entry
4391     __ add(c_rarg1, c_rarg1, entry_size);
4392     __ bind(entry);
4393     // check if bottom reached
4394     __ cmp(c_rarg1, c_rarg2);
4395     // if not at bottom then check this entry
4396     __ b(loop, Assembler::NE);
4397   }
4398 
4399   // error handling. Unlocking was not block-structured
4400   __ call_VM(noreg, CAST_FROM_FN_PTR(address,
4401                    InterpreterRuntime::throw_illegal_monitor_state_exception));
4402   __ should_not_reach_here();
4403 
4404   // call run-time routine
4405   __ bind(found);
4406   __ push_ptr(r0); // make sure object is on stack (contract with oopMaps)
4407   __ unlock_object(c_rarg1);
4408   __ pop_ptr(r0); // discard object
4409 }
4410 
4411 
4412 // Wide instructions
4413 //J_UPDATE
4414 void TemplateTable::wide()
4415 {
4416   __ load_unsigned_byte(r14, at_bcp(1));
4417   __ mov(rscratch1, (address)Interpreter::_wentry_point);
4418   __ ldr(rscratch1, Address(rscratch1, r14, lsl(2)));
4419   __ b(rscratch1);
4420 }
4421 
4422 
4423 // Multi arrays
4424 //J_UPDATE
4425 void TemplateTable::multianewarray() {
4426   transition(vtos, atos);
4427   __ load_unsigned_byte(r0, at_bcp(3)); // get number of dimensions
4428   // last dim is on top of stack; we want address of first one:
4429   // first_addr = last_addr + (ndims - 1) * wordSize
4430   __ lea(c_rarg1, Address(sp, r0, lsl(2)));
4431   __ sub(c_rarg1, c_rarg1, wordSize);
4432   call_VM(r0,
4433           CAST_FROM_FN_PTR(address, InterpreterRuntime::multianewarray),
4434           c_rarg1);
4435   __ load_unsigned_byte(r1, at_bcp(3));
4436   __ lea(sp, Address(sp, r1, lsl(2)));
4437 }