1 /*
   2  * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "interpreter/interpreter.hpp"
  27 #include "interpreter/interpreterRuntime.hpp"
  28 #include "interpreter/interp_masm.hpp"
  29 #include "interpreter/templateTable.hpp"
  30 #include "memory/universe.inline.hpp"
  31 #include "oops/methodData.hpp"
  32 #include "oops/objArrayKlass.hpp"
  33 #include "oops/oop.inline.hpp"
  34 #include "prims/methodHandles.hpp"
  35 #include "runtime/sharedRuntime.hpp"
  36 #include "runtime/stubRoutines.hpp"
  37 #include "runtime/synchronizer.hpp"
  38 #include "utilities/macros.hpp"
  39 
  40 #ifndef CC_INTERP
  41 #define __ _masm->
  42 
  43 // Misc helpers
  44 
  45 // Do an oop store like *(base + index + offset) = val
  46 // index can be noreg,
  47 static void do_oop_store(InterpreterMacroAssembler* _masm,
  48                          Register base,
  49                          Register index,
  50                          int offset,
  51                          Register val,
  52                          Register tmp,
  53                          BarrierSet::Name barrier,
  54                          bool precise) {
  55   assert(tmp != val && tmp != base && tmp != index, "register collision");
  56   assert(index == noreg || offset == 0, "only one offset");
  57   switch (barrier) {
  58 #if INCLUDE_ALL_GCS
  59     case BarrierSet::G1SATBCTLogging:
  60       {
  61         // Load and record the previous value.
  62         __ g1_write_barrier_pre(base, index, offset,
  63                                 noreg /* pre_val */,
  64                                 tmp, true /*preserve_o_regs*/);
  65 
  66         // G1 barrier needs uncompressed oop for region cross check.
  67         Register new_val = val;
  68         if (UseCompressedOops && val != G0) {
  69           new_val = tmp;
  70           __ mov(val, new_val);
  71         }
  72 
  73         if (index == noreg ) {
  74           assert(Assembler::is_simm13(offset), "fix this code");
  75           __ store_heap_oop(val, base, offset);
  76         } else {
  77           __ store_heap_oop(val, base, index);
  78         }
  79 
  80         // No need for post barrier if storing NULL
  81         if (val != G0) {
  82           if (precise) {
  83             if (index == noreg) {
  84               __ add(base, offset, base);
  85             } else {
  86               __ add(base, index, base);
  87             }
  88           }
  89           __ g1_write_barrier_post(base, new_val, tmp);
  90         }
  91       }
  92       break;
  93 #endif // INCLUDE_ALL_GCS
  94     case BarrierSet::CardTableForRS:
  95     case BarrierSet::CardTableExtension:
  96       {
  97         if (index == noreg ) {
  98           assert(Assembler::is_simm13(offset), "fix this code");
  99           __ store_heap_oop(val, base, offset);
 100         } else {
 101           __ store_heap_oop(val, base, index);
 102         }
 103         // No need for post barrier if storing NULL
 104         if (val != G0) {
 105           if (precise) {
 106             if (index == noreg) {
 107               __ add(base, offset, base);
 108             } else {
 109               __ add(base, index, base);
 110             }
 111           }
 112           __ card_write_barrier_post(base, val, tmp);
 113         }
 114       }
 115       break;
 116     case BarrierSet::ModRef:
 117       ShouldNotReachHere();
 118       break;
 119     default      :
 120       ShouldNotReachHere();
 121 
 122   }
 123 }
 124 
 125 
 126 //----------------------------------------------------------------------------------------------------
 127 // Platform-dependent initialization
 128 
 129 void TemplateTable::pd_initialize() {
 130   // (none)
 131 }
 132 
 133 
 134 //----------------------------------------------------------------------------------------------------
 135 // Condition conversion
 136 Assembler::Condition ccNot(TemplateTable::Condition cc) {
 137   switch (cc) {
 138     case TemplateTable::equal        : return Assembler::notEqual;
 139     case TemplateTable::not_equal    : return Assembler::equal;
 140     case TemplateTable::less         : return Assembler::greaterEqual;
 141     case TemplateTable::less_equal   : return Assembler::greater;
 142     case TemplateTable::greater      : return Assembler::lessEqual;
 143     case TemplateTable::greater_equal: return Assembler::less;
 144   }
 145   ShouldNotReachHere();
 146   return Assembler::zero;
 147 }
 148 
 149 //----------------------------------------------------------------------------------------------------
 150 // Miscelaneous helper routines
 151 
 152 
 153 Address TemplateTable::at_bcp(int offset) {
 154   assert(_desc->uses_bcp(), "inconsistent uses_bcp information");
 155   return Address(Lbcp, offset);
 156 }
 157 
 158 
 159 void TemplateTable::patch_bytecode(Bytecodes::Code bc, Register bc_reg,
 160                                    Register temp_reg, bool load_bc_into_bc_reg/*=true*/,
 161                                    int byte_no) {
 162   // With sharing on, may need to test Method* flag.
 163   if (!RewriteBytecodes)  return;
 164   Label L_patch_done;
 165 
 166   switch (bc) {
 167   case Bytecodes::_fast_aputfield:
 168   case Bytecodes::_fast_bputfield:
 169   case Bytecodes::_fast_cputfield:
 170   case Bytecodes::_fast_dputfield:
 171   case Bytecodes::_fast_fputfield:
 172   case Bytecodes::_fast_iputfield:
 173   case Bytecodes::_fast_lputfield:
 174   case Bytecodes::_fast_sputfield:
 175     {
 176       // We skip bytecode quickening for putfield instructions when
 177       // the put_code written to the constant pool cache is zero.
 178       // This is required so that every execution of this instruction
 179       // calls out to InterpreterRuntime::resolve_get_put to do
 180       // additional, required work.
 181       assert(byte_no == f1_byte || byte_no == f2_byte, "byte_no out of range");
 182       assert(load_bc_into_bc_reg, "we use bc_reg as temp");
 183       __ get_cache_and_index_and_bytecode_at_bcp(bc_reg, temp_reg, temp_reg, byte_no, 1);
 184       __ set(bc, bc_reg);
 185       __ cmp_and_br_short(temp_reg, 0, Assembler::equal, Assembler::pn, L_patch_done);  // don't patch
 186     }
 187     break;
 188   default:
 189     assert(byte_no == -1, "sanity");
 190     if (load_bc_into_bc_reg) {
 191       __ set(bc, bc_reg);
 192     }
 193   }
 194 
 195   if (JvmtiExport::can_post_breakpoint()) {
 196     Label L_fast_patch;
 197     __ ldub(at_bcp(0), temp_reg);
 198     __ cmp_and_br_short(temp_reg, Bytecodes::_breakpoint, Assembler::notEqual, Assembler::pt, L_fast_patch);
 199     // perform the quickening, slowly, in the bowels of the breakpoint table
 200     __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::set_original_bytecode_at), Lmethod, Lbcp, bc_reg);
 201     __ ba_short(L_patch_done);
 202     __ bind(L_fast_patch);
 203   }
 204 
 205 #ifdef ASSERT
 206   Bytecodes::Code orig_bytecode =  Bytecodes::java_code(bc);
 207   Label L_okay;
 208   __ ldub(at_bcp(0), temp_reg);
 209   __ cmp(temp_reg, orig_bytecode);
 210   __ br(Assembler::equal, false, Assembler::pt, L_okay);
 211   __ delayed()->cmp(temp_reg, bc_reg);
 212   __ br(Assembler::equal, false, Assembler::pt, L_okay);
 213   __ delayed()->nop();
 214   __ stop("patching the wrong bytecode");
 215   __ bind(L_okay);
 216 #endif
 217 
 218   // patch bytecode
 219   __ stb(bc_reg, at_bcp(0));
 220   __ bind(L_patch_done);
 221 }
 222 
 223 //----------------------------------------------------------------------------------------------------
 224 // Individual instructions
 225 
 226 void TemplateTable::nop() {
 227   transition(vtos, vtos);
 228   // nothing to do
 229 }
 230 
 231 void TemplateTable::shouldnotreachhere() {
 232   transition(vtos, vtos);
 233   __ stop("shouldnotreachhere bytecode");
 234 }
 235 
 236 void TemplateTable::aconst_null() {
 237   transition(vtos, atos);
 238   __ clr(Otos_i);
 239 }
 240 
 241 
 242 void TemplateTable::iconst(int value) {
 243   transition(vtos, itos);
 244   __ set(value, Otos_i);
 245 }
 246 
 247 
 248 void TemplateTable::lconst(int value) {
 249   transition(vtos, ltos);
 250   assert(value >= 0, "check this code");
 251 #ifdef _LP64
 252   __ set(value, Otos_l);
 253 #else
 254   __ set(value, Otos_l2);
 255   __ clr( Otos_l1);
 256 #endif
 257 }
 258 
 259 
 260 void TemplateTable::fconst(int value) {
 261   transition(vtos, ftos);
 262   static float zero = 0.0, one = 1.0, two = 2.0;
 263   float* p;
 264   switch( value ) {
 265    default: ShouldNotReachHere();
 266    case 0:  p = &zero;  break;
 267    case 1:  p = &one;   break;
 268    case 2:  p = &two;   break;
 269   }
 270   AddressLiteral a(p);
 271   __ sethi(a, G3_scratch);
 272   __ ldf(FloatRegisterImpl::S, G3_scratch, a.low10(), Ftos_f);
 273 }
 274 
 275 
 276 void TemplateTable::dconst(int value) {
 277   transition(vtos, dtos);
 278   static double zero = 0.0, one = 1.0;
 279   double* p;
 280   switch( value ) {
 281    default: ShouldNotReachHere();
 282    case 0:  p = &zero;  break;
 283    case 1:  p = &one;   break;
 284   }
 285   AddressLiteral a(p);
 286   __ sethi(a, G3_scratch);
 287   __ ldf(FloatRegisterImpl::D, G3_scratch, a.low10(), Ftos_d);
 288 }
 289 
 290 
 291 // %%%%% Should factore most snippet templates across platforms
 292 
 293 void TemplateTable::bipush() {
 294   transition(vtos, itos);
 295   __ ldsb( at_bcp(1), Otos_i );
 296 }
 297 
 298 void TemplateTable::sipush() {
 299   transition(vtos, itos);
 300   __ get_2_byte_integer_at_bcp(1, G3_scratch, Otos_i, InterpreterMacroAssembler::Signed);
 301 }
 302 
 303 void TemplateTable::ldc(bool wide) {
 304   transition(vtos, vtos);
 305   Label call_ldc, notInt, isString, notString, notClass, exit;
 306 
 307   if (wide) {
 308     __ get_2_byte_integer_at_bcp(1, G3_scratch, O1, InterpreterMacroAssembler::Unsigned);
 309   } else {
 310     __ ldub(Lbcp, 1, O1);
 311   }
 312   __ get_cpool_and_tags(O0, O2);
 313 
 314   const int base_offset = ConstantPool::header_size() * wordSize;
 315   const int tags_offset = Array<u1>::base_offset_in_bytes();
 316 
 317   // get type from tags
 318   __ add(O2, tags_offset, O2);
 319   __ ldub(O2, O1, O2);
 320 
 321   // unresolved class? If so, must resolve
 322   __ cmp_and_brx_short(O2, JVM_CONSTANT_UnresolvedClass, Assembler::equal, Assembler::pt, call_ldc);
 323 
 324   // unresolved class in error state
 325   __ cmp_and_brx_short(O2, JVM_CONSTANT_UnresolvedClassInError, Assembler::equal, Assembler::pn, call_ldc);
 326 
 327   __ cmp(O2, JVM_CONSTANT_Class);      // need to call vm to get java mirror of the class
 328   __ brx(Assembler::notEqual, true, Assembler::pt, notClass);
 329   __ delayed()->add(O0, base_offset, O0);
 330 
 331   __ bind(call_ldc);
 332   __ set(wide, O1);
 333   call_VM(Otos_i, CAST_FROM_FN_PTR(address, InterpreterRuntime::ldc), O1);
 334   __ push(atos);
 335   __ ba_short(exit);
 336 
 337   __ bind(notClass);
 338  // __ add(O0, base_offset, O0);
 339   __ sll(O1, LogBytesPerWord, O1);
 340   __ cmp(O2, JVM_CONSTANT_Integer);
 341   __ brx(Assembler::notEqual, true, Assembler::pt, notInt);
 342   __ delayed()->cmp(O2, JVM_CONSTANT_String);
 343   __ ld(O0, O1, Otos_i);
 344   __ push(itos);
 345   __ ba_short(exit);
 346 
 347   __ bind(notInt);
 348  // __ cmp(O2, JVM_CONSTANT_String);
 349   __ brx(Assembler::notEqual, true, Assembler::pt, notString);
 350   __ delayed()->ldf(FloatRegisterImpl::S, O0, O1, Ftos_f);
 351   __ bind(isString);
 352   __ stop("string should be rewritten to fast_aldc");
 353   __ ba_short(exit);
 354 
 355   __ bind(notString);
 356  // __ ldf(FloatRegisterImpl::S, O0, O1, Ftos_f);
 357   __ push(ftos);
 358 
 359   __ bind(exit);
 360 }
 361 
 362 // Fast path for caching oop constants.
 363 // %%% We should use this to handle Class and String constants also.
 364 // %%% It will simplify the ldc/primitive path considerably.
 365 void TemplateTable::fast_aldc(bool wide) {
 366   transition(vtos, atos);
 367 
 368   int index_size = wide ? sizeof(u2) : sizeof(u1);
 369   Label resolved;
 370 
 371   // We are resolved if the resolved reference cache entry contains a
 372   // non-null object (CallSite, etc.)
 373   assert_different_registers(Otos_i, G3_scratch);
 374   __ get_cache_index_at_bcp(Otos_i, G3_scratch, 1, index_size);  // load index => G3_scratch
 375   __ load_resolved_reference_at_index(Otos_i, G3_scratch);
 376   __ tst(Otos_i);
 377   __ br(Assembler::notEqual, false, Assembler::pt, resolved);
 378   __ delayed()->set((int)bytecode(), O1);
 379 
 380   address entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_ldc);
 381 
 382   // first time invocation - must resolve first
 383   __ call_VM(Otos_i, entry, O1);
 384   __ bind(resolved);
 385   __ verify_oop(Otos_i);
 386 }
 387 
 388 void TemplateTable::ldc2_w() {
 389   transition(vtos, vtos);
 390   Label Long, exit;
 391 
 392   __ get_2_byte_integer_at_bcp(1, G3_scratch, O1, InterpreterMacroAssembler::Unsigned);
 393   __ get_cpool_and_tags(O0, O2);
 394 
 395   const int base_offset = ConstantPool::header_size() * wordSize;
 396   const int tags_offset = Array<u1>::base_offset_in_bytes();
 397   // get type from tags
 398   __ add(O2, tags_offset, O2);
 399   __ ldub(O2, O1, O2);
 400 
 401   __ sll(O1, LogBytesPerWord, O1);
 402   __ add(O0, O1, G3_scratch);
 403 
 404   __ cmp_and_brx_short(O2, JVM_CONSTANT_Double, Assembler::notEqual, Assembler::pt, Long);
 405   // A double can be placed at word-aligned locations in the constant pool.
 406   // Check out Conversions.java for an example.
 407   // Also ConstantPool::header_size() is 20, which makes it very difficult
 408   // to double-align double on the constant pool.  SG, 11/7/97
 409 #ifdef _LP64
 410   __ ldf(FloatRegisterImpl::D, G3_scratch, base_offset, Ftos_d);
 411 #else
 412   FloatRegister f = Ftos_d;
 413   __ ldf(FloatRegisterImpl::S, G3_scratch, base_offset, f);
 414   __ ldf(FloatRegisterImpl::S, G3_scratch, base_offset + sizeof(jdouble)/2,
 415          f->successor());
 416 #endif
 417   __ push(dtos);
 418   __ ba_short(exit);
 419 
 420   __ bind(Long);
 421 #ifdef _LP64
 422   __ ldx(G3_scratch, base_offset, Otos_l);
 423 #else
 424   __ ld(G3_scratch, base_offset, Otos_l);
 425   __ ld(G3_scratch, base_offset + sizeof(jlong)/2, Otos_l->successor());
 426 #endif
 427   __ push(ltos);
 428 
 429   __ bind(exit);
 430 }
 431 
 432 void TemplateTable::locals_index(Register reg, int offset) {
 433   __ ldub( at_bcp(offset), reg );
 434 }
 435 
 436 void TemplateTable::locals_index_wide(Register reg) {
 437   // offset is 2, not 1, because Lbcp points to wide prefix code
 438   __ get_2_byte_integer_at_bcp(2, G4_scratch, reg, InterpreterMacroAssembler::Unsigned);
 439 }
 440 
 441 void TemplateTable::iload() {
 442   iload_internal();
 443 }
 444 
 445 void TemplateTable::nofast_iload() {
 446   iload_internal(may_not_rewrite);
 447 }
 448 
 449 void TemplateTable::iload_internal(RewriteControl rc) {
 450   transition(vtos, itos);
 451   // Rewrite iload,iload  pair into fast_iload2
 452   //         iload,caload pair into fast_icaload
 453   if (RewriteFrequentPairs && rc == may_rewrite) {
 454     Label rewrite, done;
 455 
 456     // get next byte
 457     __ ldub(at_bcp(Bytecodes::length_for(Bytecodes::_iload)), G3_scratch);
 458 
 459     // if _iload, wait to rewrite to iload2.  We only want to rewrite the
 460     // last two iloads in a pair.  Comparing against fast_iload means that
 461     // the next bytecode is neither an iload or a caload, and therefore
 462     // an iload pair.
 463     __ cmp_and_br_short(G3_scratch, (int)Bytecodes::_iload, Assembler::equal, Assembler::pn, done);
 464 
 465     __ cmp(G3_scratch, (int)Bytecodes::_fast_iload);
 466     __ br(Assembler::equal, false, Assembler::pn, rewrite);
 467     __ delayed()->set(Bytecodes::_fast_iload2, G4_scratch);
 468 
 469     __ cmp(G3_scratch, (int)Bytecodes::_caload);
 470     __ br(Assembler::equal, false, Assembler::pn, rewrite);
 471     __ delayed()->set(Bytecodes::_fast_icaload, G4_scratch);
 472 
 473     __ set(Bytecodes::_fast_iload, G4_scratch);  // don't check again
 474     // rewrite
 475     // G4_scratch: fast bytecode
 476     __ bind(rewrite);
 477     patch_bytecode(Bytecodes::_iload, G4_scratch, G3_scratch, false);
 478     __ bind(done);
 479   }
 480 
 481   // Get the local value into tos
 482   locals_index(G3_scratch);
 483   __ access_local_int( G3_scratch, Otos_i );
 484 }
 485 
 486 void TemplateTable::fast_iload2() {
 487   transition(vtos, itos);
 488   locals_index(G3_scratch);
 489   __ access_local_int( G3_scratch, Otos_i );
 490   __ push_i();
 491   locals_index(G3_scratch, 3);  // get next bytecode's local index.
 492   __ access_local_int( G3_scratch, Otos_i );
 493 }
 494 
 495 void TemplateTable::fast_iload() {
 496   transition(vtos, itos);
 497   locals_index(G3_scratch);
 498   __ access_local_int( G3_scratch, Otos_i );
 499 }
 500 
 501 void TemplateTable::lload() {
 502   transition(vtos, ltos);
 503   locals_index(G3_scratch);
 504   __ access_local_long( G3_scratch, Otos_l );
 505 }
 506 
 507 
 508 void TemplateTable::fload() {
 509   transition(vtos, ftos);
 510   locals_index(G3_scratch);
 511   __ access_local_float( G3_scratch, Ftos_f );
 512 }
 513 
 514 
 515 void TemplateTable::dload() {
 516   transition(vtos, dtos);
 517   locals_index(G3_scratch);
 518   __ access_local_double( G3_scratch, Ftos_d );
 519 }
 520 
 521 
 522 void TemplateTable::aload() {
 523   transition(vtos, atos);
 524   locals_index(G3_scratch);
 525   __ access_local_ptr( G3_scratch, Otos_i);
 526 }
 527 
 528 
 529 void TemplateTable::wide_iload() {
 530   transition(vtos, itos);
 531   locals_index_wide(G3_scratch);
 532   __ access_local_int( G3_scratch, Otos_i );
 533 }
 534 
 535 
 536 void TemplateTable::wide_lload() {
 537   transition(vtos, ltos);
 538   locals_index_wide(G3_scratch);
 539   __ access_local_long( G3_scratch, Otos_l );
 540 }
 541 
 542 
 543 void TemplateTable::wide_fload() {
 544   transition(vtos, ftos);
 545   locals_index_wide(G3_scratch);
 546   __ access_local_float( G3_scratch, Ftos_f );
 547 }
 548 
 549 
 550 void TemplateTable::wide_dload() {
 551   transition(vtos, dtos);
 552   locals_index_wide(G3_scratch);
 553   __ access_local_double( G3_scratch, Ftos_d );
 554 }
 555 
 556 
 557 void TemplateTable::wide_aload() {
 558   transition(vtos, atos);
 559   locals_index_wide(G3_scratch);
 560   __ access_local_ptr( G3_scratch, Otos_i );
 561   __ verify_oop(Otos_i);
 562 }
 563 
 564 
 565 void TemplateTable::iaload() {
 566   transition(itos, itos);
 567   // Otos_i: index
 568   // tos: array
 569   __ index_check(O2, Otos_i, LogBytesPerInt, G3_scratch, O3);
 570   __ ld(O3, arrayOopDesc::base_offset_in_bytes(T_INT), Otos_i);
 571 }
 572 
 573 
 574 void TemplateTable::laload() {
 575   transition(itos, ltos);
 576   // Otos_i: index
 577   // O2: array
 578   __ index_check(O2, Otos_i, LogBytesPerLong, G3_scratch, O3);
 579   __ ld_long(O3, arrayOopDesc::base_offset_in_bytes(T_LONG), Otos_l);
 580 }
 581 
 582 
 583 void TemplateTable::faload() {
 584   transition(itos, ftos);
 585   // Otos_i: index
 586   // O2: array
 587   __ index_check(O2, Otos_i, LogBytesPerInt, G3_scratch, O3);
 588   __ ldf(FloatRegisterImpl::S, O3, arrayOopDesc::base_offset_in_bytes(T_FLOAT), Ftos_f);
 589 }
 590 
 591 
 592 void TemplateTable::daload() {
 593   transition(itos, dtos);
 594   // Otos_i: index
 595   // O2: array
 596   __ index_check(O2, Otos_i, LogBytesPerLong, G3_scratch, O3);
 597   __ ldf(FloatRegisterImpl::D, O3, arrayOopDesc::base_offset_in_bytes(T_DOUBLE), Ftos_d);
 598 }
 599 
 600 
 601 void TemplateTable::aaload() {
 602   transition(itos, atos);
 603   // Otos_i: index
 604   // tos: array
 605   __ index_check(O2, Otos_i, UseCompressedOops ? 2 : LogBytesPerWord, G3_scratch, O3);
 606   __ load_heap_oop(O3, arrayOopDesc::base_offset_in_bytes(T_OBJECT), Otos_i);
 607   __ verify_oop(Otos_i);
 608 }
 609 
 610 
 611 void TemplateTable::baload() {
 612   transition(itos, itos);
 613   // Otos_i: index
 614   // tos: array
 615   __ index_check(O2, Otos_i, 0, G3_scratch, O3);
 616   __ ldsb(O3, arrayOopDesc::base_offset_in_bytes(T_BYTE), Otos_i);
 617 }
 618 
 619 
 620 void TemplateTable::caload() {
 621   transition(itos, itos);
 622   // Otos_i: index
 623   // tos: array
 624   __ index_check(O2, Otos_i, LogBytesPerShort, G3_scratch, O3);
 625   __ lduh(O3, arrayOopDesc::base_offset_in_bytes(T_CHAR), Otos_i);
 626 }
 627 
 628 void TemplateTable::fast_icaload() {
 629   transition(vtos, itos);
 630   // Otos_i: index
 631   // tos: array
 632   locals_index(G3_scratch);
 633   __ access_local_int( G3_scratch, Otos_i );
 634   __ index_check(O2, Otos_i, LogBytesPerShort, G3_scratch, O3);
 635   __ lduh(O3, arrayOopDesc::base_offset_in_bytes(T_CHAR), Otos_i);
 636 }
 637 
 638 
 639 void TemplateTable::saload() {
 640   transition(itos, itos);
 641   // Otos_i: index
 642   // tos: array
 643   __ index_check(O2, Otos_i, LogBytesPerShort, G3_scratch, O3);
 644   __ ldsh(O3, arrayOopDesc::base_offset_in_bytes(T_SHORT), Otos_i);
 645 }
 646 
 647 
 648 void TemplateTable::iload(int n) {
 649   transition(vtos, itos);
 650   __ ld( Llocals, Interpreter::local_offset_in_bytes(n), Otos_i );
 651 }
 652 
 653 
 654 void TemplateTable::lload(int n) {
 655   transition(vtos, ltos);
 656   assert(n+1 < Argument::n_register_parameters, "would need more code");
 657   __ load_unaligned_long(Llocals, Interpreter::local_offset_in_bytes(n+1), Otos_l);
 658 }
 659 
 660 
 661 void TemplateTable::fload(int n) {
 662   transition(vtos, ftos);
 663   assert(n < Argument::n_register_parameters, "would need more code");
 664   __ ldf( FloatRegisterImpl::S, Llocals, Interpreter::local_offset_in_bytes(n),     Ftos_f );
 665 }
 666 
 667 
 668 void TemplateTable::dload(int n) {
 669   transition(vtos, dtos);
 670   FloatRegister dst = Ftos_d;
 671   __ load_unaligned_double(Llocals, Interpreter::local_offset_in_bytes(n+1), dst);
 672 }
 673 
 674 
 675 void TemplateTable::aload(int n) {
 676   transition(vtos, atos);
 677   __ ld_ptr( Llocals, Interpreter::local_offset_in_bytes(n), Otos_i );
 678 }
 679 
 680 void TemplateTable::aload_0() {
 681   aload_0_internal();
 682 }
 683 
 684 void TemplateTable::nofast_aload_0() {
 685   aload_0_internal(may_not_rewrite);
 686 }
 687 
 688 void TemplateTable::aload_0_internal(RewriteControl rc) {
 689   transition(vtos, atos);
 690 
 691   // According to bytecode histograms, the pairs:
 692   //
 693   // _aload_0, _fast_igetfield (itos)
 694   // _aload_0, _fast_agetfield (atos)
 695   // _aload_0, _fast_fgetfield (ftos)
 696   //
 697   // occur frequently. If RewriteFrequentPairs is set, the (slow) _aload_0
 698   // bytecode checks the next bytecode and then rewrites the current
 699   // bytecode into a pair bytecode; otherwise it rewrites the current
 700   // bytecode into _fast_aload_0 that doesn't do the pair check anymore.
 701   //
 702   if (RewriteFrequentPairs && rc == may_rewrite) {
 703     Label rewrite, done;
 704 
 705     // get next byte
 706     __ ldub(at_bcp(Bytecodes::length_for(Bytecodes::_aload_0)), G3_scratch);
 707 
 708     // do actual aload_0
 709     aload(0);
 710 
 711     // if _getfield then wait with rewrite
 712     __ cmp_and_br_short(G3_scratch, (int)Bytecodes::_getfield, Assembler::equal, Assembler::pn, done);
 713 
 714     // if _igetfield then rewrite to _fast_iaccess_0
 715     assert(Bytecodes::java_code(Bytecodes::_fast_iaccess_0) == Bytecodes::_aload_0, "adjust fast bytecode def");
 716     __ cmp(G3_scratch, (int)Bytecodes::_fast_igetfield);
 717     __ br(Assembler::equal, false, Assembler::pn, rewrite);
 718     __ delayed()->set(Bytecodes::_fast_iaccess_0, G4_scratch);
 719 
 720     // if _agetfield then rewrite to _fast_aaccess_0
 721     assert(Bytecodes::java_code(Bytecodes::_fast_aaccess_0) == Bytecodes::_aload_0, "adjust fast bytecode def");
 722     __ cmp(G3_scratch, (int)Bytecodes::_fast_agetfield);
 723     __ br(Assembler::equal, false, Assembler::pn, rewrite);
 724     __ delayed()->set(Bytecodes::_fast_aaccess_0, G4_scratch);
 725 
 726     // if _fgetfield then rewrite to _fast_faccess_0
 727     assert(Bytecodes::java_code(Bytecodes::_fast_faccess_0) == Bytecodes::_aload_0, "adjust fast bytecode def");
 728     __ cmp(G3_scratch, (int)Bytecodes::_fast_fgetfield);
 729     __ br(Assembler::equal, false, Assembler::pn, rewrite);
 730     __ delayed()->set(Bytecodes::_fast_faccess_0, G4_scratch);
 731 
 732     // else rewrite to _fast_aload0
 733     assert(Bytecodes::java_code(Bytecodes::_fast_aload_0) == Bytecodes::_aload_0, "adjust fast bytecode def");
 734     __ set(Bytecodes::_fast_aload_0, G4_scratch);
 735 
 736     // rewrite
 737     // G4_scratch: fast bytecode
 738     __ bind(rewrite);
 739     patch_bytecode(Bytecodes::_aload_0, G4_scratch, G3_scratch, false);
 740     __ bind(done);
 741   } else {
 742     aload(0);
 743   }
 744 }
 745 
 746 void TemplateTable::istore() {
 747   transition(itos, vtos);
 748   locals_index(G3_scratch);
 749   __ store_local_int( G3_scratch, Otos_i );
 750 }
 751 
 752 
 753 void TemplateTable::lstore() {
 754   transition(ltos, vtos);
 755   locals_index(G3_scratch);
 756   __ store_local_long( G3_scratch, Otos_l );
 757 }
 758 
 759 
 760 void TemplateTable::fstore() {
 761   transition(ftos, vtos);
 762   locals_index(G3_scratch);
 763   __ store_local_float( G3_scratch, Ftos_f );
 764 }
 765 
 766 
 767 void TemplateTable::dstore() {
 768   transition(dtos, vtos);
 769   locals_index(G3_scratch);
 770   __ store_local_double( G3_scratch, Ftos_d );
 771 }
 772 
 773 
 774 void TemplateTable::astore() {
 775   transition(vtos, vtos);
 776   __ load_ptr(0, Otos_i);
 777   __ inc(Lesp, Interpreter::stackElementSize);
 778   __ verify_oop_or_return_address(Otos_i, G3_scratch);
 779   locals_index(G3_scratch);
 780   __ store_local_ptr(G3_scratch, Otos_i);
 781 }
 782 
 783 
 784 void TemplateTable::wide_istore() {
 785   transition(vtos, vtos);
 786   __ pop_i();
 787   locals_index_wide(G3_scratch);
 788   __ store_local_int( G3_scratch, Otos_i );
 789 }
 790 
 791 
 792 void TemplateTable::wide_lstore() {
 793   transition(vtos, vtos);
 794   __ pop_l();
 795   locals_index_wide(G3_scratch);
 796   __ store_local_long( G3_scratch, Otos_l );
 797 }
 798 
 799 
 800 void TemplateTable::wide_fstore() {
 801   transition(vtos, vtos);
 802   __ pop_f();
 803   locals_index_wide(G3_scratch);
 804   __ store_local_float( G3_scratch, Ftos_f );
 805 }
 806 
 807 
 808 void TemplateTable::wide_dstore() {
 809   transition(vtos, vtos);
 810   __ pop_d();
 811   locals_index_wide(G3_scratch);
 812   __ store_local_double( G3_scratch, Ftos_d );
 813 }
 814 
 815 
 816 void TemplateTable::wide_astore() {
 817   transition(vtos, vtos);
 818   __ load_ptr(0, Otos_i);
 819   __ inc(Lesp, Interpreter::stackElementSize);
 820   __ verify_oop_or_return_address(Otos_i, G3_scratch);
 821   locals_index_wide(G3_scratch);
 822   __ store_local_ptr(G3_scratch, Otos_i);
 823 }
 824 
 825 
 826 void TemplateTable::iastore() {
 827   transition(itos, vtos);
 828   __ pop_i(O2); // index
 829   // Otos_i: val
 830   // O3: array
 831   __ index_check(O3, O2, LogBytesPerInt, G3_scratch, O2);
 832   __ st(Otos_i, O2, arrayOopDesc::base_offset_in_bytes(T_INT));
 833 }
 834 
 835 
 836 void TemplateTable::lastore() {
 837   transition(ltos, vtos);
 838   __ pop_i(O2); // index
 839   // Otos_l: val
 840   // O3: array
 841   __ index_check(O3, O2, LogBytesPerLong, G3_scratch, O2);
 842   __ st_long(Otos_l, O2, arrayOopDesc::base_offset_in_bytes(T_LONG));
 843 }
 844 
 845 
 846 void TemplateTable::fastore() {
 847   transition(ftos, vtos);
 848   __ pop_i(O2); // index
 849   // Ftos_f: val
 850   // O3: array
 851   __ index_check(O3, O2, LogBytesPerInt, G3_scratch, O2);
 852   __ stf(FloatRegisterImpl::S, Ftos_f, O2, arrayOopDesc::base_offset_in_bytes(T_FLOAT));
 853 }
 854 
 855 
 856 void TemplateTable::dastore() {
 857   transition(dtos, vtos);
 858   __ pop_i(O2); // index
 859   // Fos_d: val
 860   // O3: array
 861   __ index_check(O3, O2, LogBytesPerLong, G3_scratch, O2);
 862   __ stf(FloatRegisterImpl::D, Ftos_d, O2, arrayOopDesc::base_offset_in_bytes(T_DOUBLE));
 863 }
 864 
 865 
 866 void TemplateTable::aastore() {
 867   Label store_ok, is_null, done;
 868   transition(vtos, vtos);
 869   __ ld_ptr(Lesp, Interpreter::expr_offset_in_bytes(0), Otos_i);
 870   __ ld(Lesp, Interpreter::expr_offset_in_bytes(1), O2);         // get index
 871   __ ld_ptr(Lesp, Interpreter::expr_offset_in_bytes(2), O3);     // get array
 872   // Otos_i: val
 873   // O2: index
 874   // O3: array
 875   __ verify_oop(Otos_i);
 876   __ index_check_without_pop(O3, O2, UseCompressedOops ? 2 : LogBytesPerWord, G3_scratch, O1);
 877 
 878   // do array store check - check for NULL value first
 879   __ br_null_short( Otos_i, Assembler::pn, is_null );
 880 
 881   __ load_klass(O3, O4); // get array klass
 882   __ load_klass(Otos_i, O5); // get value klass
 883 
 884   // do fast instanceof cache test
 885 
 886   __ ld_ptr(O4,     in_bytes(ObjArrayKlass::element_klass_offset()),  O4);
 887 
 888   assert(Otos_i == O0, "just checking");
 889 
 890   // Otos_i:    value
 891   // O1:        addr - offset
 892   // O2:        index
 893   // O3:        array
 894   // O4:        array element klass
 895   // O5:        value klass
 896 
 897   // Address element(O1, 0, arrayOopDesc::base_offset_in_bytes(T_OBJECT));
 898 
 899   // Generate a fast subtype check.  Branch to store_ok if no
 900   // failure.  Throw if failure.
 901   __ gen_subtype_check( O5, O4, G3_scratch, G4_scratch, G1_scratch, store_ok );
 902 
 903   // Not a subtype; so must throw exception
 904   __ throw_if_not_x( Assembler::never, Interpreter::_throw_ArrayStoreException_entry, G3_scratch );
 905 
 906   // Store is OK.
 907   __ bind(store_ok);
 908   do_oop_store(_masm, O1, noreg, arrayOopDesc::base_offset_in_bytes(T_OBJECT), Otos_i, G3_scratch, _bs->kind(), true);
 909 
 910   __ ba(done);
 911   __ delayed()->inc(Lesp, 3* Interpreter::stackElementSize); // adj sp (pops array, index and value)
 912 
 913   __ bind(is_null);
 914   do_oop_store(_masm, O1, noreg, arrayOopDesc::base_offset_in_bytes(T_OBJECT), G0, G4_scratch, _bs->kind(), true);
 915 
 916   __ profile_null_seen(G3_scratch);
 917   __ inc(Lesp, 3* Interpreter::stackElementSize);     // adj sp (pops array, index and value)
 918   __ bind(done);
 919 }
 920 
 921 
 922 void TemplateTable::bastore() {
 923   transition(itos, vtos);
 924   __ pop_i(O2); // index
 925   // Otos_i: val
 926   // O3: array
 927   __ index_check(O3, O2, 0, G3_scratch, O2);
 928   __ stb(Otos_i, O2, arrayOopDesc::base_offset_in_bytes(T_BYTE));
 929 }
 930 
 931 
 932 void TemplateTable::castore() {
 933   transition(itos, vtos);
 934   __ pop_i(O2); // index
 935   // Otos_i: val
 936   // O3: array
 937   __ index_check(O3, O2, LogBytesPerShort, G3_scratch, O2);
 938   __ sth(Otos_i, O2, arrayOopDesc::base_offset_in_bytes(T_CHAR));
 939 }
 940 
 941 
 942 void TemplateTable::sastore() {
 943   // %%%%% Factor across platform
 944   castore();
 945 }
 946 
 947 
 948 void TemplateTable::istore(int n) {
 949   transition(itos, vtos);
 950   __ st(Otos_i, Llocals, Interpreter::local_offset_in_bytes(n));
 951 }
 952 
 953 
 954 void TemplateTable::lstore(int n) {
 955   transition(ltos, vtos);
 956   assert(n+1 < Argument::n_register_parameters, "only handle register cases");
 957   __ store_unaligned_long(Otos_l, Llocals, Interpreter::local_offset_in_bytes(n+1));
 958 
 959 }
 960 
 961 
 962 void TemplateTable::fstore(int n) {
 963   transition(ftos, vtos);
 964   assert(n < Argument::n_register_parameters, "only handle register cases");
 965   __ stf(FloatRegisterImpl::S, Ftos_f, Llocals, Interpreter::local_offset_in_bytes(n));
 966 }
 967 
 968 
 969 void TemplateTable::dstore(int n) {
 970   transition(dtos, vtos);
 971   FloatRegister src = Ftos_d;
 972   __ store_unaligned_double(src, Llocals, Interpreter::local_offset_in_bytes(n+1));
 973 }
 974 
 975 
 976 void TemplateTable::astore(int n) {
 977   transition(vtos, vtos);
 978   __ load_ptr(0, Otos_i);
 979   __ inc(Lesp, Interpreter::stackElementSize);
 980   __ verify_oop_or_return_address(Otos_i, G3_scratch);
 981   __ store_local_ptr(n, Otos_i);
 982 }
 983 
 984 
 985 void TemplateTable::pop() {
 986   transition(vtos, vtos);
 987   __ inc(Lesp, Interpreter::stackElementSize);
 988 }
 989 
 990 
 991 void TemplateTable::pop2() {
 992   transition(vtos, vtos);
 993   __ inc(Lesp, 2 * Interpreter::stackElementSize);
 994 }
 995 
 996 
 997 void TemplateTable::dup() {
 998   transition(vtos, vtos);
 999   // stack: ..., a
1000   // load a and tag
1001   __ load_ptr(0, Otos_i);
1002   __ push_ptr(Otos_i);
1003   // stack: ..., a, a
1004 }
1005 
1006 
1007 void TemplateTable::dup_x1() {
1008   transition(vtos, vtos);
1009   // stack: ..., a, b
1010   __ load_ptr( 1, G3_scratch);  // get a
1011   __ load_ptr( 0, Otos_l1);     // get b
1012   __ store_ptr(1, Otos_l1);     // put b
1013   __ store_ptr(0, G3_scratch);  // put a - like swap
1014   __ push_ptr(Otos_l1);         // push b
1015   // stack: ..., b, a, b
1016 }
1017 
1018 
1019 void TemplateTable::dup_x2() {
1020   transition(vtos, vtos);
1021   // stack: ..., a, b, c
1022   // get c and push on stack, reuse registers
1023   __ load_ptr( 0, G3_scratch);  // get c
1024   __ push_ptr(G3_scratch);      // push c with tag
1025   // stack: ..., a, b, c, c  (c in reg)  (Lesp - 4)
1026   // (stack offsets n+1 now)
1027   __ load_ptr( 3, Otos_l1);     // get a
1028   __ store_ptr(3, G3_scratch);  // put c at 3
1029   // stack: ..., c, b, c, c  (a in reg)
1030   __ load_ptr( 2, G3_scratch);  // get b
1031   __ store_ptr(2, Otos_l1);     // put a at 2
1032   // stack: ..., c, a, c, c  (b in reg)
1033   __ store_ptr(1, G3_scratch);  // put b at 1
1034   // stack: ..., c, a, b, c
1035 }
1036 
1037 
1038 void TemplateTable::dup2() {
1039   transition(vtos, vtos);
1040   __ load_ptr(1, G3_scratch);  // get a
1041   __ load_ptr(0, Otos_l1);     // get b
1042   __ push_ptr(G3_scratch);     // push a
1043   __ push_ptr(Otos_l1);        // push b
1044   // stack: ..., a, b, a, b
1045 }
1046 
1047 
1048 void TemplateTable::dup2_x1() {
1049   transition(vtos, vtos);
1050   // stack: ..., a, b, c
1051   __ load_ptr( 1, Lscratch);    // get b
1052   __ load_ptr( 2, Otos_l1);     // get a
1053   __ store_ptr(2, Lscratch);    // put b at a
1054   // stack: ..., b, b, c
1055   __ load_ptr( 0, G3_scratch);  // get c
1056   __ store_ptr(1, G3_scratch);  // put c at b
1057   // stack: ..., b, c, c
1058   __ store_ptr(0, Otos_l1);     // put a at c
1059   // stack: ..., b, c, a
1060   __ push_ptr(Lscratch);        // push b
1061   __ push_ptr(G3_scratch);      // push c
1062   // stack: ..., b, c, a, b, c
1063 }
1064 
1065 
1066 // The spec says that these types can be a mixture of category 1 (1 word)
1067 // types and/or category 2 types (long and doubles)
1068 void TemplateTable::dup2_x2() {
1069   transition(vtos, vtos);
1070   // stack: ..., a, b, c, d
1071   __ load_ptr( 1, Lscratch);    // get c
1072   __ load_ptr( 3, Otos_l1);     // get a
1073   __ store_ptr(3, Lscratch);    // put c at 3
1074   __ store_ptr(1, Otos_l1);     // put a at 1
1075   // stack: ..., c, b, a, d
1076   __ load_ptr( 2, G3_scratch);  // get b
1077   __ load_ptr( 0, Otos_l1);     // get d
1078   __ store_ptr(0, G3_scratch);  // put b at 0
1079   __ store_ptr(2, Otos_l1);     // put d at 2
1080   // stack: ..., c, d, a, b
1081   __ push_ptr(Lscratch);        // push c
1082   __ push_ptr(Otos_l1);         // push d
1083   // stack: ..., c, d, a, b, c, d
1084 }
1085 
1086 
1087 void TemplateTable::swap() {
1088   transition(vtos, vtos);
1089   // stack: ..., a, b
1090   __ load_ptr( 1, G3_scratch);  // get a
1091   __ load_ptr( 0, Otos_l1);     // get b
1092   __ store_ptr(0, G3_scratch);  // put b
1093   __ store_ptr(1, Otos_l1);     // put a
1094   // stack: ..., b, a
1095 }
1096 
1097 
1098 void TemplateTable::iop2(Operation op) {
1099   transition(itos, itos);
1100   __ pop_i(O1);
1101   switch (op) {
1102    case  add:  __  add(O1, Otos_i, Otos_i);  break;
1103    case  sub:  __  sub(O1, Otos_i, Otos_i);  break;
1104      // %%%%% Mul may not exist: better to call .mul?
1105    case  mul:  __ smul(O1, Otos_i, Otos_i);  break;
1106    case _and:  __ and3(O1, Otos_i, Otos_i);  break;
1107    case  _or:  __  or3(O1, Otos_i, Otos_i);  break;
1108    case _xor:  __ xor3(O1, Otos_i, Otos_i);  break;
1109    case  shl:  __  sll(O1, Otos_i, Otos_i);  break;
1110    case  shr:  __  sra(O1, Otos_i, Otos_i);  break;
1111    case ushr:  __  srl(O1, Otos_i, Otos_i);  break;
1112    default: ShouldNotReachHere();
1113   }
1114 }
1115 
1116 
1117 void TemplateTable::lop2(Operation op) {
1118   transition(ltos, ltos);
1119   __ pop_l(O2);
1120   switch (op) {
1121 #ifdef _LP64
1122    case  add:  __  add(O2, Otos_l, Otos_l);  break;
1123    case  sub:  __  sub(O2, Otos_l, Otos_l);  break;
1124    case _and:  __ and3(O2, Otos_l, Otos_l);  break;
1125    case  _or:  __  or3(O2, Otos_l, Otos_l);  break;
1126    case _xor:  __ xor3(O2, Otos_l, Otos_l);  break;
1127 #else
1128    case  add:  __ addcc(O3, Otos_l2, Otos_l2);  __ addc(O2, Otos_l1, Otos_l1);  break;
1129    case  sub:  __ subcc(O3, Otos_l2, Otos_l2);  __ subc(O2, Otos_l1, Otos_l1);  break;
1130    case _and:  __  and3(O3, Otos_l2, Otos_l2);  __ and3(O2, Otos_l1, Otos_l1);  break;
1131    case  _or:  __   or3(O3, Otos_l2, Otos_l2);  __  or3(O2, Otos_l1, Otos_l1);  break;
1132    case _xor:  __  xor3(O3, Otos_l2, Otos_l2);  __ xor3(O2, Otos_l1, Otos_l1);  break;
1133 #endif
1134    default: ShouldNotReachHere();
1135   }
1136 }
1137 
1138 
1139 void TemplateTable::idiv() {
1140   // %%%%% Later: ForSPARC/V7 call .sdiv library routine,
1141   // %%%%% Use ldsw...sdivx on pure V9 ABI. 64 bit safe.
1142 
1143   transition(itos, itos);
1144   __ pop_i(O1); // get 1st op
1145 
1146   // Y contains upper 32 bits of result, set it to 0 or all ones
1147   __ wry(G0);
1148   __ mov(~0, G3_scratch);
1149 
1150   __ tst(O1);
1151      Label neg;
1152   __ br(Assembler::negative, true, Assembler::pn, neg);
1153   __ delayed()->wry(G3_scratch);
1154   __ bind(neg);
1155 
1156      Label ok;
1157   __ tst(Otos_i);
1158   __ throw_if_not_icc( Assembler::notZero, Interpreter::_throw_ArithmeticException_entry, G3_scratch );
1159 
1160   const int min_int = 0x80000000;
1161   Label regular;
1162   __ cmp(Otos_i, -1);
1163   __ br(Assembler::notEqual, false, Assembler::pt, regular);
1164 #ifdef _LP64
1165   // Don't put set in delay slot
1166   // Set will turn into multiple instructions in 64 bit mode
1167   __ delayed()->nop();
1168   __ set(min_int, G4_scratch);
1169 #else
1170   __ delayed()->set(min_int, G4_scratch);
1171 #endif
1172   Label done;
1173   __ cmp(O1, G4_scratch);
1174   __ br(Assembler::equal, true, Assembler::pt, done);
1175   __ delayed()->mov(O1, Otos_i);   // (mov only executed if branch taken)
1176 
1177   __ bind(regular);
1178   __ sdiv(O1, Otos_i, Otos_i); // note: irem uses O1 after this instruction!
1179   __ bind(done);
1180 }
1181 
1182 
1183 void TemplateTable::irem() {
1184   transition(itos, itos);
1185   __ mov(Otos_i, O2); // save divisor
1186   idiv();                               // %%%% Hack: exploits fact that idiv leaves dividend in O1
1187   __ smul(Otos_i, O2, Otos_i);
1188   __ sub(O1, Otos_i, Otos_i);
1189 }
1190 
1191 
1192 void TemplateTable::lmul() {
1193   transition(ltos, ltos);
1194   __ pop_l(O2);
1195 #ifdef _LP64
1196   __ mulx(Otos_l, O2, Otos_l);
1197 #else
1198   __ call_VM_leaf(Lscratch, CAST_FROM_FN_PTR(address, SharedRuntime::lmul));
1199 #endif
1200 
1201 }
1202 
1203 
1204 void TemplateTable::ldiv() {
1205   transition(ltos, ltos);
1206 
1207   // check for zero
1208   __ pop_l(O2);
1209 #ifdef _LP64
1210   __ tst(Otos_l);
1211   __ throw_if_not_xcc( Assembler::notZero, Interpreter::_throw_ArithmeticException_entry, G3_scratch);
1212   __ sdivx(O2, Otos_l, Otos_l);
1213 #else
1214   __ orcc(Otos_l1, Otos_l2, G0);
1215   __ throw_if_not_icc( Assembler::notZero, Interpreter::_throw_ArithmeticException_entry, G3_scratch);
1216   __ call_VM_leaf(Lscratch, CAST_FROM_FN_PTR(address, SharedRuntime::ldiv));
1217 #endif
1218 }
1219 
1220 
1221 void TemplateTable::lrem() {
1222   transition(ltos, ltos);
1223 
1224   // check for zero
1225   __ pop_l(O2);
1226 #ifdef _LP64
1227   __ tst(Otos_l);
1228   __ throw_if_not_xcc( Assembler::notZero, Interpreter::_throw_ArithmeticException_entry, G3_scratch);
1229   __ sdivx(O2, Otos_l, Otos_l2);
1230   __ mulx (Otos_l2, Otos_l, Otos_l2);
1231   __ sub  (O2, Otos_l2, Otos_l);
1232 #else
1233   __ orcc(Otos_l1, Otos_l2, G0);
1234   __ throw_if_not_icc(Assembler::notZero, Interpreter::_throw_ArithmeticException_entry, G3_scratch);
1235   __ call_VM_leaf(Lscratch, CAST_FROM_FN_PTR(address, SharedRuntime::lrem));
1236 #endif
1237 }
1238 
1239 
1240 void TemplateTable::lshl() {
1241   transition(itos, ltos); // %%%% could optimize, fill delay slot or opt for ultra
1242 
1243   __ pop_l(O2);                          // shift value in O2, O3
1244 #ifdef _LP64
1245   __ sllx(O2, Otos_i, Otos_l);
1246 #else
1247   __ lshl(O2, O3, Otos_i, Otos_l1, Otos_l2, O4);
1248 #endif
1249 }
1250 
1251 
1252 void TemplateTable::lshr() {
1253   transition(itos, ltos); // %%%% see lshl comment
1254 
1255   __ pop_l(O2);                          // shift value in O2, O3
1256 #ifdef _LP64
1257   __ srax(O2, Otos_i, Otos_l);
1258 #else
1259   __ lshr(O2, O3, Otos_i, Otos_l1, Otos_l2, O4);
1260 #endif
1261 }
1262 
1263 
1264 
1265 void TemplateTable::lushr() {
1266   transition(itos, ltos); // %%%% see lshl comment
1267 
1268   __ pop_l(O2);                          // shift value in O2, O3
1269 #ifdef _LP64
1270   __ srlx(O2, Otos_i, Otos_l);
1271 #else
1272   __ lushr(O2, O3, Otos_i, Otos_l1, Otos_l2, O4);
1273 #endif
1274 }
1275 
1276 
1277 void TemplateTable::fop2(Operation op) {
1278   transition(ftos, ftos);
1279   switch (op) {
1280    case  add:  __  pop_f(F4); __ fadd(FloatRegisterImpl::S, F4, Ftos_f, Ftos_f);  break;
1281    case  sub:  __  pop_f(F4); __ fsub(FloatRegisterImpl::S, F4, Ftos_f, Ftos_f);  break;
1282    case  mul:  __  pop_f(F4); __ fmul(FloatRegisterImpl::S, F4, Ftos_f, Ftos_f);  break;
1283    case  div:  __  pop_f(F4); __ fdiv(FloatRegisterImpl::S, F4, Ftos_f, Ftos_f);  break;
1284    case  rem:
1285      assert(Ftos_f == F0, "just checking");
1286 #ifdef _LP64
1287      // LP64 calling conventions use F1, F3 for passing 2 floats
1288      __ pop_f(F1);
1289      __ fmov(FloatRegisterImpl::S, Ftos_f, F3);
1290 #else
1291      __ pop_i(O0);
1292      __ stf(FloatRegisterImpl::S, Ftos_f, __ d_tmp);
1293      __ ld( __ d_tmp, O1 );
1294 #endif
1295      __ call_VM_leaf(Lscratch, CAST_FROM_FN_PTR(address, SharedRuntime::frem));
1296      assert( Ftos_f == F0, "fix this code" );
1297      break;
1298 
1299    default: ShouldNotReachHere();
1300   }
1301 }
1302 
1303 
1304 void TemplateTable::dop2(Operation op) {
1305   transition(dtos, dtos);
1306   switch (op) {
1307    case  add:  __  pop_d(F4); __ fadd(FloatRegisterImpl::D, F4, Ftos_d, Ftos_d);  break;
1308    case  sub:  __  pop_d(F4); __ fsub(FloatRegisterImpl::D, F4, Ftos_d, Ftos_d);  break;
1309    case  mul:  __  pop_d(F4); __ fmul(FloatRegisterImpl::D, F4, Ftos_d, Ftos_d);  break;
1310    case  div:  __  pop_d(F4); __ fdiv(FloatRegisterImpl::D, F4, Ftos_d, Ftos_d);  break;
1311    case  rem:
1312 #ifdef _LP64
1313      // Pass arguments in D0, D2
1314      __ fmov(FloatRegisterImpl::D, Ftos_f, F2 );
1315      __ pop_d( F0 );
1316 #else
1317      // Pass arguments in O0O1, O2O3
1318      __ stf(FloatRegisterImpl::D, Ftos_f, __ d_tmp);
1319      __ ldd( __ d_tmp, O2 );
1320      __ pop_d(Ftos_f);
1321      __ stf(FloatRegisterImpl::D, Ftos_f, __ d_tmp);
1322      __ ldd( __ d_tmp, O0 );
1323 #endif
1324      __ call_VM_leaf(Lscratch, CAST_FROM_FN_PTR(address, SharedRuntime::drem));
1325      assert( Ftos_d == F0, "fix this code" );
1326      break;
1327 
1328    default: ShouldNotReachHere();
1329   }
1330 }
1331 
1332 
1333 void TemplateTable::ineg() {
1334   transition(itos, itos);
1335   __ neg(Otos_i);
1336 }
1337 
1338 
1339 void TemplateTable::lneg() {
1340   transition(ltos, ltos);
1341 #ifdef _LP64
1342   __ sub(G0, Otos_l, Otos_l);
1343 #else
1344   __ lneg(Otos_l1, Otos_l2);
1345 #endif
1346 }
1347 
1348 
1349 void TemplateTable::fneg() {
1350   transition(ftos, ftos);
1351   __ fneg(FloatRegisterImpl::S, Ftos_f, Ftos_f);
1352 }
1353 
1354 
1355 void TemplateTable::dneg() {
1356   transition(dtos, dtos);
1357   __ fneg(FloatRegisterImpl::D, Ftos_f, Ftos_f);
1358 }
1359 
1360 
1361 void TemplateTable::iinc() {
1362   transition(vtos, vtos);
1363   locals_index(G3_scratch);
1364   __ ldsb(Lbcp, 2, O2);  // load constant
1365   __ access_local_int(G3_scratch, Otos_i);
1366   __ add(Otos_i, O2, Otos_i);
1367   __ st(Otos_i, G3_scratch, 0);    // access_local_int puts E.A. in G3_scratch
1368 }
1369 
1370 
1371 void TemplateTable::wide_iinc() {
1372   transition(vtos, vtos);
1373   locals_index_wide(G3_scratch);
1374   __ get_2_byte_integer_at_bcp( 4,  O2, O3, InterpreterMacroAssembler::Signed);
1375   __ access_local_int(G3_scratch, Otos_i);
1376   __ add(Otos_i, O3, Otos_i);
1377   __ st(Otos_i, G3_scratch, 0);    // access_local_int puts E.A. in G3_scratch
1378 }
1379 
1380 
1381 void TemplateTable::convert() {
1382 // %%%%% Factor this first part accross platforms
1383   #ifdef ASSERT
1384     TosState tos_in  = ilgl;
1385     TosState tos_out = ilgl;
1386     switch (bytecode()) {
1387       case Bytecodes::_i2l: // fall through
1388       case Bytecodes::_i2f: // fall through
1389       case Bytecodes::_i2d: // fall through
1390       case Bytecodes::_i2b: // fall through
1391       case Bytecodes::_i2c: // fall through
1392       case Bytecodes::_i2s: tos_in = itos; break;
1393       case Bytecodes::_l2i: // fall through
1394       case Bytecodes::_l2f: // fall through
1395       case Bytecodes::_l2d: tos_in = ltos; break;
1396       case Bytecodes::_f2i: // fall through
1397       case Bytecodes::_f2l: // fall through
1398       case Bytecodes::_f2d: tos_in = ftos; break;
1399       case Bytecodes::_d2i: // fall through
1400       case Bytecodes::_d2l: // fall through
1401       case Bytecodes::_d2f: tos_in = dtos; break;
1402       default             : ShouldNotReachHere();
1403     }
1404     switch (bytecode()) {
1405       case Bytecodes::_l2i: // fall through
1406       case Bytecodes::_f2i: // fall through
1407       case Bytecodes::_d2i: // fall through
1408       case Bytecodes::_i2b: // fall through
1409       case Bytecodes::_i2c: // fall through
1410       case Bytecodes::_i2s: tos_out = itos; break;
1411       case Bytecodes::_i2l: // fall through
1412       case Bytecodes::_f2l: // fall through
1413       case Bytecodes::_d2l: tos_out = ltos; break;
1414       case Bytecodes::_i2f: // fall through
1415       case Bytecodes::_l2f: // fall through
1416       case Bytecodes::_d2f: tos_out = ftos; break;
1417       case Bytecodes::_i2d: // fall through
1418       case Bytecodes::_l2d: // fall through
1419       case Bytecodes::_f2d: tos_out = dtos; break;
1420       default             : ShouldNotReachHere();
1421     }
1422     transition(tos_in, tos_out);
1423   #endif
1424 
1425 
1426   // Conversion
1427   Label done;
1428   switch (bytecode()) {
1429    case Bytecodes::_i2l:
1430 #ifdef _LP64
1431     // Sign extend the 32 bits
1432     __ sra ( Otos_i, 0, Otos_l );
1433 #else
1434     __ addcc(Otos_i, 0, Otos_l2);
1435     __ br(Assembler::greaterEqual, true, Assembler::pt, done);
1436     __ delayed()->clr(Otos_l1);
1437     __ set(~0, Otos_l1);
1438 #endif
1439     break;
1440 
1441    case Bytecodes::_i2f:
1442     __ st(Otos_i, __ d_tmp );
1443     __ ldf(FloatRegisterImpl::S,  __ d_tmp, F0);
1444     __ fitof(FloatRegisterImpl::S, F0, Ftos_f);
1445     break;
1446 
1447    case Bytecodes::_i2d:
1448     __ st(Otos_i, __ d_tmp);
1449     __ ldf(FloatRegisterImpl::S,  __ d_tmp, F0);
1450     __ fitof(FloatRegisterImpl::D, F0, Ftos_f);
1451     break;
1452 
1453    case Bytecodes::_i2b:
1454     __ sll(Otos_i, 24, Otos_i);
1455     __ sra(Otos_i, 24, Otos_i);
1456     break;
1457 
1458    case Bytecodes::_i2c:
1459     __ sll(Otos_i, 16, Otos_i);
1460     __ srl(Otos_i, 16, Otos_i);
1461     break;
1462 
1463    case Bytecodes::_i2s:
1464     __ sll(Otos_i, 16, Otos_i);
1465     __ sra(Otos_i, 16, Otos_i);
1466     break;
1467 
1468    case Bytecodes::_l2i:
1469 #ifndef _LP64
1470     __ mov(Otos_l2, Otos_i);
1471 #else
1472     // Sign-extend into the high 32 bits
1473     __ sra(Otos_l, 0, Otos_i);
1474 #endif
1475     break;
1476 
1477    case Bytecodes::_l2f:
1478    case Bytecodes::_l2d:
1479     __ st_long(Otos_l, __ d_tmp);
1480     __ ldf(FloatRegisterImpl::D, __ d_tmp, Ftos_d);
1481 
1482     if (bytecode() == Bytecodes::_l2f) {
1483       __ fxtof(FloatRegisterImpl::S, Ftos_d, Ftos_f);
1484     } else {
1485       __ fxtof(FloatRegisterImpl::D, Ftos_d, Ftos_d);
1486     }
1487     break;
1488 
1489   case Bytecodes::_f2i:  {
1490       Label isNaN;
1491       // result must be 0 if value is NaN; test by comparing value to itself
1492       __ fcmp(FloatRegisterImpl::S, Assembler::fcc0, Ftos_f, Ftos_f);
1493       __ fb(Assembler::f_unordered, true, Assembler::pn, isNaN);
1494       __ delayed()->clr(Otos_i);                                     // NaN
1495       __ ftoi(FloatRegisterImpl::S, Ftos_f, F30);
1496       __ stf(FloatRegisterImpl::S, F30, __ d_tmp);
1497       __ ld(__ d_tmp, Otos_i);
1498       __ bind(isNaN);
1499     }
1500     break;
1501 
1502    case Bytecodes::_f2l:
1503     // must uncache tos
1504     __ push_f();
1505 #ifdef _LP64
1506     __ pop_f(F1);
1507 #else
1508     __ pop_i(O0);
1509 #endif
1510     __ call_VM_leaf(Lscratch, CAST_FROM_FN_PTR(address, SharedRuntime::f2l));
1511     break;
1512 
1513    case Bytecodes::_f2d:
1514     __ ftof( FloatRegisterImpl::S, FloatRegisterImpl::D, Ftos_f, Ftos_f);
1515     break;
1516 
1517    case Bytecodes::_d2i:
1518    case Bytecodes::_d2l:
1519     // must uncache tos
1520     __ push_d();
1521 #ifdef _LP64
1522     // LP64 calling conventions pass first double arg in D0
1523     __ pop_d( Ftos_d );
1524 #else
1525     __ pop_i( O0 );
1526     __ pop_i( O1 );
1527 #endif
1528     __ call_VM_leaf(Lscratch,
1529         bytecode() == Bytecodes::_d2i
1530           ? CAST_FROM_FN_PTR(address, SharedRuntime::d2i)
1531           : CAST_FROM_FN_PTR(address, SharedRuntime::d2l));
1532     break;
1533 
1534     case Bytecodes::_d2f:
1535       __ ftof( FloatRegisterImpl::D, FloatRegisterImpl::S, Ftos_d, Ftos_f);
1536     break;
1537 
1538     default: ShouldNotReachHere();
1539   }
1540   __ bind(done);
1541 }
1542 
1543 
1544 void TemplateTable::lcmp() {
1545   transition(ltos, itos);
1546 
1547 #ifdef _LP64
1548   __ pop_l(O1); // pop off value 1, value 2 is in O0
1549   __ lcmp( O1, Otos_l, Otos_i );
1550 #else
1551   __ pop_l(O2); // cmp O2,3 to O0,1
1552   __ lcmp( O2, O3, Otos_l1, Otos_l2, Otos_i );
1553 #endif
1554 }
1555 
1556 
1557 void TemplateTable::float_cmp(bool is_float, int unordered_result) {
1558 
1559   if (is_float) __ pop_f(F2);
1560   else          __ pop_d(F2);
1561 
1562   assert(Ftos_f == F0  &&  Ftos_d == F0,  "alias checking:");
1563 
1564   __ float_cmp( is_float, unordered_result, F2, F0, Otos_i );
1565 }
1566 
1567 void TemplateTable::branch(bool is_jsr, bool is_wide) {
1568   // Note: on SPARC, we use InterpreterMacroAssembler::if_cmp also.
1569   __ verify_thread();
1570 
1571   const Register O2_bumped_count = O2;
1572   __ profile_taken_branch(G3_scratch, O2_bumped_count);
1573 
1574   // get (wide) offset to O1_disp
1575   const Register O1_disp = O1;
1576   if (is_wide)  __ get_4_byte_integer_at_bcp( 1,  G4_scratch, O1_disp,                                    InterpreterMacroAssembler::set_CC);
1577   else          __ get_2_byte_integer_at_bcp( 1,  G4_scratch, O1_disp, InterpreterMacroAssembler::Signed, InterpreterMacroAssembler::set_CC);
1578 
1579   // Handle all the JSR stuff here, then exit.
1580   // It's much shorter and cleaner than intermingling with the
1581   // non-JSR normal-branch stuff occurring below.
1582   if( is_jsr ) {
1583     // compute return address as bci in Otos_i
1584     __ ld_ptr(Lmethod, Method::const_offset(), G3_scratch);
1585     __ sub(Lbcp, G3_scratch, G3_scratch);
1586     __ sub(G3_scratch, in_bytes(ConstMethod::codes_offset()) - (is_wide ? 5 : 3), Otos_i);
1587 
1588     // Bump Lbcp to target of JSR
1589     __ add(Lbcp, O1_disp, Lbcp);
1590     // Push returnAddress for "ret" on stack
1591     __ push_ptr(Otos_i);
1592     // And away we go!
1593     __ dispatch_next(vtos);
1594     return;
1595   }
1596 
1597   // Normal (non-jsr) branch handling
1598 
1599   // Save the current Lbcp
1600   const Register l_cur_bcp = Lscratch;
1601   __ mov( Lbcp, l_cur_bcp );
1602 
1603   bool increment_invocation_counter_for_backward_branches = UseCompiler && UseLoopCounter;
1604   if ( increment_invocation_counter_for_backward_branches ) {
1605     Label Lforward;
1606     // check branch direction
1607     __ br( Assembler::positive, false,  Assembler::pn, Lforward );
1608     // Bump bytecode pointer by displacement (take the branch)
1609     __ delayed()->add( O1_disp, Lbcp, Lbcp );     // add to bc addr
1610 
1611     const Register G3_method_counters = G3_scratch;
1612     __ get_method_counters(Lmethod, G3_method_counters, Lforward);
1613 
1614     if (TieredCompilation) {
1615       Label Lno_mdo, Loverflow;
1616       int increment = InvocationCounter::count_increment;
1617       if (ProfileInterpreter) {
1618         // If no method data exists, go to profile_continue.
1619         __ ld_ptr(Lmethod, Method::method_data_offset(), G4_scratch);
1620         __ br_null_short(G4_scratch, Assembler::pn, Lno_mdo);
1621 
1622         // Increment backedge counter in the MDO
1623         Address mdo_backedge_counter(G4_scratch, in_bytes(MethodData::backedge_counter_offset()) +
1624                                                  in_bytes(InvocationCounter::counter_offset()));
1625         Address mask(G4_scratch, in_bytes(MethodData::backedge_mask_offset()));
1626         __ increment_mask_and_jump(mdo_backedge_counter, increment, mask, G3_scratch, O0,
1627                                    Assembler::notZero, &Lforward);
1628         __ ba_short(Loverflow);
1629       }
1630 
1631       // If there's no MDO, increment counter in MethodCounters*
1632       __ bind(Lno_mdo);
1633       Address backedge_counter(G3_method_counters,
1634               in_bytes(MethodCounters::backedge_counter_offset()) +
1635               in_bytes(InvocationCounter::counter_offset()));
1636       Address mask(G3_method_counters, in_bytes(MethodCounters::backedge_mask_offset()));
1637       __ increment_mask_and_jump(backedge_counter, increment, mask, G4_scratch, O0,
1638                                  Assembler::notZero, &Lforward);
1639       __ bind(Loverflow);
1640 
1641       // notify point for loop, pass branch bytecode
1642       __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::frequency_counter_overflow), l_cur_bcp);
1643 
1644       // Was an OSR adapter generated?
1645       // O0 = osr nmethod
1646       __ br_null_short(O0, Assembler::pn, Lforward);
1647 
1648       // Has the nmethod been invalidated already?
1649       __ ldub(O0, nmethod::state_offset(), O2);
1650       __ cmp_and_br_short(O2, nmethod::in_use, Assembler::notEqual, Assembler::pn, Lforward);
1651 
1652       // migrate the interpreter frame off of the stack
1653 
1654       __ mov(G2_thread, L7);
1655       // save nmethod
1656       __ mov(O0, L6);
1657       __ set_last_Java_frame(SP, noreg);
1658       __ call_VM_leaf(noreg, CAST_FROM_FN_PTR(address, SharedRuntime::OSR_migration_begin), L7);
1659       __ reset_last_Java_frame();
1660       __ mov(L7, G2_thread);
1661 
1662       // move OSR nmethod to I1
1663       __ mov(L6, I1);
1664 
1665       // OSR buffer to I0
1666       __ mov(O0, I0);
1667 
1668       // remove the interpreter frame
1669       __ restore(I5_savedSP, 0, SP);
1670 
1671       // Jump to the osr code.
1672       __ ld_ptr(O1, nmethod::osr_entry_point_offset(), O2);
1673       __ jmp(O2, G0);
1674       __ delayed()->nop();
1675 
1676     } else { // not TieredCompilation
1677       // Update Backedge branch separately from invocations
1678       const Register G4_invoke_ctr = G4;
1679       __ increment_backedge_counter(G3_method_counters, G4_invoke_ctr, G1_scratch);
1680       if (ProfileInterpreter) {
1681         __ test_invocation_counter_for_mdp(G4_invoke_ctr, G3_method_counters, G1_scratch, Lforward);
1682         if (UseOnStackReplacement) {
1683 
1684           __ test_backedge_count_for_osr(O2_bumped_count, G3_method_counters, l_cur_bcp, G1_scratch);
1685         }
1686       } else {
1687         if (UseOnStackReplacement) {
1688           __ test_backedge_count_for_osr(G4_invoke_ctr, G3_method_counters, l_cur_bcp, G1_scratch);
1689         }
1690       }
1691     }
1692 
1693     __ bind(Lforward);
1694   } else
1695     // Bump bytecode pointer by displacement (take the branch)
1696     __ add( O1_disp, Lbcp, Lbcp );// add to bc addr
1697 
1698   // continue with bytecode @ target
1699   // %%%%% Like Intel, could speed things up by moving bytecode fetch to code above,
1700   // %%%%% and changing dispatch_next to dispatch_only
1701   __ dispatch_next(vtos);
1702 }
1703 
1704 
1705 // Note Condition in argument is TemplateTable::Condition
1706 // arg scope is within class scope
1707 
1708 void TemplateTable::if_0cmp(Condition cc) {
1709   // no pointers, integer only!
1710   transition(itos, vtos);
1711   // assume branch is more often taken than not (loops use backward branches)
1712   __ cmp( Otos_i, 0);
1713   __ if_cmp(ccNot(cc), false);
1714 }
1715 
1716 
1717 void TemplateTable::if_icmp(Condition cc) {
1718   transition(itos, vtos);
1719   __ pop_i(O1);
1720   __ cmp(O1, Otos_i);
1721   __ if_cmp(ccNot(cc), false);
1722 }
1723 
1724 
1725 void TemplateTable::if_nullcmp(Condition cc) {
1726   transition(atos, vtos);
1727   __ tst(Otos_i);
1728   __ if_cmp(ccNot(cc), true);
1729 }
1730 
1731 
1732 void TemplateTable::if_acmp(Condition cc) {
1733   transition(atos, vtos);
1734   __ pop_ptr(O1);
1735   __ verify_oop(O1);
1736   __ verify_oop(Otos_i);
1737   __ cmp(O1, Otos_i);
1738   __ if_cmp(ccNot(cc), true);
1739 }
1740 
1741 
1742 
1743 void TemplateTable::ret() {
1744   transition(vtos, vtos);
1745   locals_index(G3_scratch);
1746   __ access_local_returnAddress(G3_scratch, Otos_i);
1747   // Otos_i contains the bci, compute the bcp from that
1748 
1749 #ifdef _LP64
1750 #ifdef ASSERT
1751   // jsr result was labeled as an 'itos' not an 'atos' because we cannot GC
1752   // the result.  The return address (really a BCI) was stored with an
1753   // 'astore' because JVM specs claim it's a pointer-sized thing.  Hence in
1754   // the 64-bit build the 32-bit BCI is actually in the low bits of a 64-bit
1755   // loaded value.
1756   { Label zzz ;
1757      __ set (65536, G3_scratch) ;
1758      __ cmp (Otos_i, G3_scratch) ;
1759      __ bp( Assembler::lessEqualUnsigned, false, Assembler::xcc, Assembler::pn, zzz);
1760      __ delayed()->nop();
1761      __ stop("BCI is in the wrong register half?");
1762      __ bind (zzz) ;
1763   }
1764 #endif
1765 #endif
1766 
1767   __ profile_ret(vtos, Otos_i, G4_scratch);
1768 
1769   __ ld_ptr(Lmethod, Method::const_offset(), G3_scratch);
1770   __ add(G3_scratch, Otos_i, G3_scratch);
1771   __ add(G3_scratch, in_bytes(ConstMethod::codes_offset()), Lbcp);
1772   __ dispatch_next(vtos);
1773 }
1774 
1775 
1776 void TemplateTable::wide_ret() {
1777   transition(vtos, vtos);
1778   locals_index_wide(G3_scratch);
1779   __ access_local_returnAddress(G3_scratch, Otos_i);
1780   // Otos_i contains the bci, compute the bcp from that
1781 
1782   __ profile_ret(vtos, Otos_i, G4_scratch);
1783 
1784   __ ld_ptr(Lmethod, Method::const_offset(), G3_scratch);
1785   __ add(G3_scratch, Otos_i, G3_scratch);
1786   __ add(G3_scratch, in_bytes(ConstMethod::codes_offset()), Lbcp);
1787   __ dispatch_next(vtos);
1788 }
1789 
1790 
1791 void TemplateTable::tableswitch() {
1792   transition(itos, vtos);
1793   Label default_case, continue_execution;
1794 
1795   // align bcp
1796   __ add(Lbcp, BytesPerInt, O1);
1797   __ and3(O1, -BytesPerInt, O1);
1798   // load lo, hi
1799   __ ld(O1, 1 * BytesPerInt, O2);       // Low Byte
1800   __ ld(O1, 2 * BytesPerInt, O3);       // High Byte
1801 #ifdef _LP64
1802   // Sign extend the 32 bits
1803   __ sra ( Otos_i, 0, Otos_i );
1804 #endif /* _LP64 */
1805 
1806   // check against lo & hi
1807   __ cmp( Otos_i, O2);
1808   __ br( Assembler::less, false, Assembler::pn, default_case);
1809   __ delayed()->cmp( Otos_i, O3 );
1810   __ br( Assembler::greater, false, Assembler::pn, default_case);
1811   // lookup dispatch offset
1812   __ delayed()->sub(Otos_i, O2, O2);
1813   __ profile_switch_case(O2, O3, G3_scratch, G4_scratch);
1814   __ sll(O2, LogBytesPerInt, O2);
1815   __ add(O2, 3 * BytesPerInt, O2);
1816   __ ba(continue_execution);
1817   __ delayed()->ld(O1, O2, O2);
1818   // handle default
1819   __ bind(default_case);
1820   __ profile_switch_default(O3);
1821   __ ld(O1, 0, O2); // get default offset
1822   // continue execution
1823   __ bind(continue_execution);
1824   __ add(Lbcp, O2, Lbcp);
1825   __ dispatch_next(vtos);
1826 }
1827 
1828 
1829 void TemplateTable::lookupswitch() {
1830   transition(itos, itos);
1831   __ stop("lookupswitch bytecode should have been rewritten");
1832 }
1833 
1834 void TemplateTable::fast_linearswitch() {
1835   transition(itos, vtos);
1836     Label loop_entry, loop, found, continue_execution;
1837   // align bcp
1838   __ add(Lbcp, BytesPerInt, O1);
1839   __ and3(O1, -BytesPerInt, O1);
1840  // set counter
1841   __ ld(O1, BytesPerInt, O2);
1842   __ sll(O2, LogBytesPerInt + 1, O2); // in word-pairs
1843   __ add(O1, 2 * BytesPerInt, O3); // set first pair addr
1844   __ ba(loop_entry);
1845   __ delayed()->add(O3, O2, O2); // counter now points past last pair
1846 
1847   // table search
1848   __ bind(loop);
1849   __ cmp(O4, Otos_i);
1850   __ br(Assembler::equal, true, Assembler::pn, found);
1851   __ delayed()->ld(O3, BytesPerInt, O4); // offset -> O4
1852   __ inc(O3, 2 * BytesPerInt);
1853 
1854   __ bind(loop_entry);
1855   __ cmp(O2, O3);
1856   __ brx(Assembler::greaterUnsigned, true, Assembler::pt, loop);
1857   __ delayed()->ld(O3, 0, O4);
1858 
1859   // default case
1860   __ ld(O1, 0, O4); // get default offset
1861   if (ProfileInterpreter) {
1862     __ profile_switch_default(O3);
1863     __ ba_short(continue_execution);
1864   }
1865 
1866   // entry found -> get offset
1867   __ bind(found);
1868   if (ProfileInterpreter) {
1869     __ sub(O3, O1, O3);
1870     __ sub(O3, 2*BytesPerInt, O3);
1871     __ srl(O3, LogBytesPerInt + 1, O3); // in word-pairs
1872     __ profile_switch_case(O3, O1, O2, G3_scratch);
1873 
1874     __ bind(continue_execution);
1875   }
1876   __ add(Lbcp, O4, Lbcp);
1877   __ dispatch_next(vtos);
1878 }
1879 
1880 
1881 void TemplateTable::fast_binaryswitch() {
1882   transition(itos, vtos);
1883   // Implementation using the following core algorithm: (copied from Intel)
1884   //
1885   // int binary_search(int key, LookupswitchPair* array, int n) {
1886   //   // Binary search according to "Methodik des Programmierens" by
1887   //   // Edsger W. Dijkstra and W.H.J. Feijen, Addison Wesley Germany 1985.
1888   //   int i = 0;
1889   //   int j = n;
1890   //   while (i+1 < j) {
1891   //     // invariant P: 0 <= i < j <= n and (a[i] <= key < a[j] or Q)
1892   //     // with      Q: for all i: 0 <= i < n: key < a[i]
1893   //     // where a stands for the array and assuming that the (inexisting)
1894   //     // element a[n] is infinitely big.
1895   //     int h = (i + j) >> 1;
1896   //     // i < h < j
1897   //     if (key < array[h].fast_match()) {
1898   //       j = h;
1899   //     } else {
1900   //       i = h;
1901   //     }
1902   //   }
1903   //   // R: a[i] <= key < a[i+1] or Q
1904   //   // (i.e., if key is within array, i is the correct index)
1905   //   return i;
1906   // }
1907 
1908   // register allocation
1909   assert(Otos_i == O0, "alias checking");
1910   const Register Rkey     = Otos_i;                    // already set (tosca)
1911   const Register Rarray   = O1;
1912   const Register Ri       = O2;
1913   const Register Rj       = O3;
1914   const Register Rh       = O4;
1915   const Register Rscratch = O5;
1916 
1917   const int log_entry_size = 3;
1918   const int entry_size = 1 << log_entry_size;
1919 
1920   Label found;
1921   // Find Array start
1922   __ add(Lbcp, 3 * BytesPerInt, Rarray);
1923   __ and3(Rarray, -BytesPerInt, Rarray);
1924   // initialize i & j (in delay slot)
1925   __ clr( Ri );
1926 
1927   // and start
1928   Label entry;
1929   __ ba(entry);
1930   __ delayed()->ld( Rarray, -BytesPerInt, Rj);
1931   // (Rj is already in the native byte-ordering.)
1932 
1933   // binary search loop
1934   { Label loop;
1935     __ bind( loop );
1936     // int h = (i + j) >> 1;
1937     __ sra( Rh, 1, Rh );
1938     // if (key < array[h].fast_match()) {
1939     //   j = h;
1940     // } else {
1941     //   i = h;
1942     // }
1943     __ sll( Rh, log_entry_size, Rscratch );
1944     __ ld( Rarray, Rscratch, Rscratch );
1945     // (Rscratch is already in the native byte-ordering.)
1946     __ cmp( Rkey, Rscratch );
1947     __ movcc( Assembler::less,         false, Assembler::icc, Rh, Rj );  // j = h if (key <  array[h].fast_match())
1948     __ movcc( Assembler::greaterEqual, false, Assembler::icc, Rh, Ri );  // i = h if (key >= array[h].fast_match())
1949 
1950     // while (i+1 < j)
1951     __ bind( entry );
1952     __ add( Ri, 1, Rscratch );
1953     __ cmp(Rscratch, Rj);
1954     __ br( Assembler::less, true, Assembler::pt, loop );
1955     __ delayed()->add( Ri, Rj, Rh ); // start h = i + j  >> 1;
1956   }
1957 
1958   // end of binary search, result index is i (must check again!)
1959   Label default_case;
1960   Label continue_execution;
1961   if (ProfileInterpreter) {
1962     __ mov( Ri, Rh );              // Save index in i for profiling
1963   }
1964   __ sll( Ri, log_entry_size, Ri );
1965   __ ld( Rarray, Ri, Rscratch );
1966   // (Rscratch is already in the native byte-ordering.)
1967   __ cmp( Rkey, Rscratch );
1968   __ br( Assembler::notEqual, true, Assembler::pn, default_case );
1969   __ delayed()->ld( Rarray, -2 * BytesPerInt, Rj ); // load default offset -> j
1970 
1971   // entry found -> j = offset
1972   __ inc( Ri, BytesPerInt );
1973   __ profile_switch_case(Rh, Rj, Rscratch, Rkey);
1974   __ ld( Rarray, Ri, Rj );
1975   // (Rj is already in the native byte-ordering.)
1976 
1977   if (ProfileInterpreter) {
1978     __ ba_short(continue_execution);
1979   }
1980 
1981   __ bind(default_case); // fall through (if not profiling)
1982   __ profile_switch_default(Ri);
1983 
1984   __ bind(continue_execution);
1985   __ add( Lbcp, Rj, Lbcp );
1986   __ dispatch_next( vtos );
1987 }
1988 
1989 
1990 void TemplateTable::_return(TosState state) {
1991   transition(state, state);
1992   assert(_desc->calls_vm(), "inconsistent calls_vm information");
1993 
1994   if (_desc->bytecode() == Bytecodes::_return_register_finalizer) {
1995     assert(state == vtos, "only valid state");
1996     __ mov(G0, G3_scratch);
1997     __ access_local_ptr(G3_scratch, Otos_i);
1998     __ load_klass(Otos_i, O2);
1999     __ set(JVM_ACC_HAS_FINALIZER, G3);
2000     __ ld(O2, in_bytes(Klass::access_flags_offset()), O2);
2001     __ andcc(G3, O2, G0);
2002     Label skip_register_finalizer;
2003     __ br(Assembler::zero, false, Assembler::pn, skip_register_finalizer);
2004     __ delayed()->nop();
2005 
2006     // Call out to do finalizer registration
2007     __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::register_finalizer), Otos_i);
2008 
2009     __ bind(skip_register_finalizer);
2010   }
2011 
2012   __ remove_activation(state, /* throw_monitor_exception */ true);
2013 
2014   // The caller's SP was adjusted upon method entry to accomodate
2015   // the callee's non-argument locals. Undo that adjustment.
2016   __ ret();                             // return to caller
2017   __ delayed()->restore(I5_savedSP, G0, SP);
2018 }
2019 
2020 
2021 // ----------------------------------------------------------------------------
2022 // Volatile variables demand their effects be made known to all CPU's in
2023 // order.  Store buffers on most chips allow reads & writes to reorder; the
2024 // JMM's ReadAfterWrite.java test fails in -Xint mode without some kind of
2025 // memory barrier (i.e., it's not sufficient that the interpreter does not
2026 // reorder volatile references, the hardware also must not reorder them).
2027 //
2028 // According to the new Java Memory Model (JMM):
2029 // (1) All volatiles are serialized wrt to each other.
2030 // ALSO reads & writes act as aquire & release, so:
2031 // (2) A read cannot let unrelated NON-volatile memory refs that happen after
2032 // the read float up to before the read.  It's OK for non-volatile memory refs
2033 // that happen before the volatile read to float down below it.
2034 // (3) Similar a volatile write cannot let unrelated NON-volatile memory refs
2035 // that happen BEFORE the write float down to after the write.  It's OK for
2036 // non-volatile memory refs that happen after the volatile write to float up
2037 // before it.
2038 //
2039 // We only put in barriers around volatile refs (they are expensive), not
2040 // _between_ memory refs (that would require us to track the flavor of the
2041 // previous memory refs).  Requirements (2) and (3) require some barriers
2042 // before volatile stores and after volatile loads.  These nearly cover
2043 // requirement (1) but miss the volatile-store-volatile-load case.  This final
2044 // case is placed after volatile-stores although it could just as well go
2045 // before volatile-loads.
2046 void TemplateTable::volatile_barrier(Assembler::Membar_mask_bits order_constraint) {
2047   // Helper function to insert a is-volatile test and memory barrier
2048   // All current sparc implementations run in TSO, needing only StoreLoad
2049   if ((order_constraint & Assembler::StoreLoad) == 0) return;
2050   __ membar( order_constraint );
2051 }
2052 
2053 // ----------------------------------------------------------------------------
2054 void TemplateTable::resolve_cache_and_index(int byte_no,
2055                                             Register Rcache,
2056                                             Register index,
2057                                             size_t index_size) {
2058   // Depends on cpCacheOop layout!
2059 
2060   Label resolved;
2061   Bytecodes::Code code = bytecode();
2062   switch (code) {
2063   case Bytecodes::_nofast_getfield: code = Bytecodes::_getfield; break;
2064   case Bytecodes::_nofast_putfield: code = Bytecodes::_putfield; break;
2065   }
2066 
2067   assert(byte_no == f1_byte || byte_no == f2_byte, "byte_no out of range");
2068   __ get_cache_and_index_and_bytecode_at_bcp(Rcache, index, Lbyte_code, byte_no, 1, index_size);
2069   __ cmp(Lbyte_code, code);  // have we resolved this bytecode?
2070   __ br(Assembler::equal, false, Assembler::pt, resolved);
2071   __ delayed()->set(code, O1);
2072 
2073   address entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_from_cache);
2074   // first time invocation - must resolve first
2075   __ call_VM(noreg, entry, O1);
2076   // Update registers with resolved info
2077   __ get_cache_and_index_at_bcp(Rcache, index, 1, index_size);
2078   __ bind(resolved);
2079 }
2080 
2081 void TemplateTable::load_invoke_cp_cache_entry(int byte_no,
2082                                                Register method,
2083                                                Register itable_index,
2084                                                Register flags,
2085                                                bool is_invokevirtual,
2086                                                bool is_invokevfinal,
2087                                                bool is_invokedynamic) {
2088   // Uses both G3_scratch and G4_scratch
2089   Register cache = G3_scratch;
2090   Register index = G4_scratch;
2091   assert_different_registers(cache, method, itable_index);
2092 
2093   // determine constant pool cache field offsets
2094   assert(is_invokevirtual == (byte_no == f2_byte), "is_invokevirtual flag redundant");
2095   const int method_offset = in_bytes(
2096       ConstantPoolCache::base_offset() +
2097       ((byte_no == f2_byte)
2098        ? ConstantPoolCacheEntry::f2_offset()
2099        : ConstantPoolCacheEntry::f1_offset()
2100       )
2101     );
2102   const int flags_offset = in_bytes(ConstantPoolCache::base_offset() +
2103                                     ConstantPoolCacheEntry::flags_offset());
2104   // access constant pool cache fields
2105   const int index_offset = in_bytes(ConstantPoolCache::base_offset() +
2106                                     ConstantPoolCacheEntry::f2_offset());
2107 
2108   if (is_invokevfinal) {
2109     __ get_cache_and_index_at_bcp(cache, index, 1);
2110     __ ld_ptr(Address(cache, method_offset), method);
2111   } else {
2112     size_t index_size = (is_invokedynamic ? sizeof(u4) : sizeof(u2));
2113     resolve_cache_and_index(byte_no, cache, index, index_size);
2114     __ ld_ptr(Address(cache, method_offset), method);
2115   }
2116 
2117   if (itable_index != noreg) {
2118     // pick up itable or appendix index from f2 also:
2119     __ ld_ptr(Address(cache, index_offset), itable_index);
2120   }
2121   __ ld_ptr(Address(cache, flags_offset), flags);
2122 }
2123 
2124 // The Rcache register must be set before call
2125 void TemplateTable::load_field_cp_cache_entry(Register Robj,
2126                                               Register Rcache,
2127                                               Register index,
2128                                               Register Roffset,
2129                                               Register Rflags,
2130                                               bool is_static) {
2131   assert_different_registers(Rcache, Rflags, Roffset);
2132 
2133   ByteSize cp_base_offset = ConstantPoolCache::base_offset();
2134 
2135   __ ld_ptr(Rcache, cp_base_offset + ConstantPoolCacheEntry::flags_offset(), Rflags);
2136   __ ld_ptr(Rcache, cp_base_offset + ConstantPoolCacheEntry::f2_offset(), Roffset);
2137   if (is_static) {
2138     __ ld_ptr(Rcache, cp_base_offset + ConstantPoolCacheEntry::f1_offset(), Robj);
2139     const int mirror_offset = in_bytes(Klass::java_mirror_offset());
2140     __ ld_ptr( Robj, mirror_offset, Robj);
2141   }
2142 }
2143 
2144 // The registers Rcache and index expected to be set before call.
2145 // Correct values of the Rcache and index registers are preserved.
2146 void TemplateTable::jvmti_post_field_access(Register Rcache,
2147                                             Register index,
2148                                             bool is_static,
2149                                             bool has_tos) {
2150   ByteSize cp_base_offset = ConstantPoolCache::base_offset();
2151 
2152   if (JvmtiExport::can_post_field_access()) {
2153     // Check to see if a field access watch has been set before we take
2154     // the time to call into the VM.
2155     Label Label1;
2156     assert_different_registers(Rcache, index, G1_scratch);
2157     AddressLiteral get_field_access_count_addr(JvmtiExport::get_field_access_count_addr());
2158     __ load_contents(get_field_access_count_addr, G1_scratch);
2159     __ cmp_and_br_short(G1_scratch, 0, Assembler::equal, Assembler::pt, Label1);
2160 
2161     __ add(Rcache, in_bytes(cp_base_offset), Rcache);
2162 
2163     if (is_static) {
2164       __ clr(Otos_i);
2165     } else {
2166       if (has_tos) {
2167       // save object pointer before call_VM() clobbers it
2168         __ push_ptr(Otos_i);  // put object on tos where GC wants it.
2169       } else {
2170         // Load top of stack (do not pop the value off the stack);
2171         __ ld_ptr(Lesp, Interpreter::expr_offset_in_bytes(0), Otos_i);
2172       }
2173       __ verify_oop(Otos_i);
2174     }
2175     // Otos_i: object pointer or NULL if static
2176     // Rcache: cache entry pointer
2177     __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::post_field_access),
2178                Otos_i, Rcache);
2179     if (!is_static && has_tos) {
2180       __ pop_ptr(Otos_i);  // restore object pointer
2181       __ verify_oop(Otos_i);
2182     }
2183     __ get_cache_and_index_at_bcp(Rcache, index, 1);
2184     __ bind(Label1);
2185   }
2186 }
2187 
2188 void TemplateTable::getfield_or_static(int byte_no, bool is_static, RewriteControl rc) {
2189   transition(vtos, vtos);
2190 
2191   Register Rcache = G3_scratch;
2192   Register index  = G4_scratch;
2193   Register Rclass = Rcache;
2194   Register Roffset= G4_scratch;
2195   Register Rflags = G1_scratch;
2196   ByteSize cp_base_offset = ConstantPoolCache::base_offset();
2197 
2198   resolve_cache_and_index(byte_no, Rcache, index, sizeof(u2));
2199   jvmti_post_field_access(Rcache, index, is_static, false);
2200   load_field_cp_cache_entry(Rclass, Rcache, index, Roffset, Rflags, is_static);
2201 
2202   if (!is_static) {
2203     pop_and_check_object(Rclass);
2204   } else {
2205     __ verify_oop(Rclass);
2206   }
2207 
2208   Label exit;
2209 
2210   Assembler::Membar_mask_bits membar_bits =
2211     Assembler::Membar_mask_bits(Assembler::LoadLoad | Assembler::LoadStore);
2212 
2213   if (__ membar_has_effect(membar_bits)) {
2214     // Get volatile flag
2215     __ set((1 << ConstantPoolCacheEntry::is_volatile_shift), Lscratch);
2216     __ and3(Rflags, Lscratch, Lscratch);
2217   }
2218 
2219   Label checkVolatile;
2220 
2221   // compute field type
2222   Label notByte, notInt, notShort, notChar, notLong, notFloat, notObj;
2223   __ srl(Rflags, ConstantPoolCacheEntry::tos_state_shift, Rflags);
2224   // Make sure we don't need to mask Rflags after the above shift
2225   ConstantPoolCacheEntry::verify_tos_state_shift();
2226 
2227   // Check atos before itos for getstatic, more likely (in Queens at least)
2228   __ cmp(Rflags, atos);
2229   __ br(Assembler::notEqual, false, Assembler::pt, notObj);
2230   __ delayed() ->cmp(Rflags, itos);
2231 
2232   // atos
2233   __ load_heap_oop(Rclass, Roffset, Otos_i);
2234   __ verify_oop(Otos_i);
2235   __ push(atos);
2236   if (!is_static && rc == may_rewrite) {
2237     patch_bytecode(Bytecodes::_fast_agetfield, G3_scratch, G4_scratch);
2238   }
2239   __ ba(checkVolatile);
2240   __ delayed()->tst(Lscratch);
2241 
2242   __ bind(notObj);
2243 
2244   // cmp(Rflags, itos);
2245   __ br(Assembler::notEqual, false, Assembler::pt, notInt);
2246   __ delayed() ->cmp(Rflags, ltos);
2247 
2248   // itos
2249   __ ld(Rclass, Roffset, Otos_i);
2250   __ push(itos);
2251   if (!is_static && rc == may_rewrite) {
2252     patch_bytecode(Bytecodes::_fast_igetfield, G3_scratch, G4_scratch);
2253   }
2254   __ ba(checkVolatile);
2255   __ delayed()->tst(Lscratch);
2256 
2257   __ bind(notInt);
2258 
2259   // cmp(Rflags, ltos);
2260   __ br(Assembler::notEqual, false, Assembler::pt, notLong);
2261   __ delayed() ->cmp(Rflags, btos);
2262 
2263   // ltos
2264   // load must be atomic
2265   __ ld_long(Rclass, Roffset, Otos_l);
2266   __ push(ltos);
2267   if (!is_static && rc == may_rewrite) {
2268     patch_bytecode(Bytecodes::_fast_lgetfield, G3_scratch, G4_scratch);
2269   }
2270   __ ba(checkVolatile);
2271   __ delayed()->tst(Lscratch);
2272 
2273   __ bind(notLong);
2274 
2275   // cmp(Rflags, btos);
2276   __ br(Assembler::notEqual, false, Assembler::pt, notByte);
2277   __ delayed() ->cmp(Rflags, ctos);
2278 
2279   // btos
2280   __ ldsb(Rclass, Roffset, Otos_i);
2281   __ push(itos);
2282   if (!is_static && rc == may_rewrite) {
2283     patch_bytecode(Bytecodes::_fast_bgetfield, G3_scratch, G4_scratch);
2284   }
2285   __ ba(checkVolatile);
2286   __ delayed()->tst(Lscratch);
2287 
2288   __ bind(notByte);
2289 
2290   // cmp(Rflags, ctos);
2291   __ br(Assembler::notEqual, false, Assembler::pt, notChar);
2292   __ delayed() ->cmp(Rflags, stos);
2293 
2294   // ctos
2295   __ lduh(Rclass, Roffset, Otos_i);
2296   __ push(itos);
2297   if (!is_static && rc == may_rewrite) {
2298     patch_bytecode(Bytecodes::_fast_cgetfield, G3_scratch, G4_scratch);
2299   }
2300   __ ba(checkVolatile);
2301   __ delayed()->tst(Lscratch);
2302 
2303   __ bind(notChar);
2304 
2305   // cmp(Rflags, stos);
2306   __ br(Assembler::notEqual, false, Assembler::pt, notShort);
2307   __ delayed() ->cmp(Rflags, ftos);
2308 
2309   // stos
2310   __ ldsh(Rclass, Roffset, Otos_i);
2311   __ push(itos);
2312   if (!is_static && rc == may_rewrite) {
2313     patch_bytecode(Bytecodes::_fast_sgetfield, G3_scratch, G4_scratch);
2314   }
2315   __ ba(checkVolatile);
2316   __ delayed()->tst(Lscratch);
2317 
2318   __ bind(notShort);
2319 
2320 
2321   // cmp(Rflags, ftos);
2322   __ br(Assembler::notEqual, false, Assembler::pt, notFloat);
2323   __ delayed() ->tst(Lscratch);
2324 
2325   // ftos
2326   __ ldf(FloatRegisterImpl::S, Rclass, Roffset, Ftos_f);
2327   __ push(ftos);
2328   if (!is_static && rc == may_rewrite) {
2329     patch_bytecode(Bytecodes::_fast_fgetfield, G3_scratch, G4_scratch);
2330   }
2331   __ ba(checkVolatile);
2332   __ delayed()->tst(Lscratch);
2333 
2334   __ bind(notFloat);
2335 
2336 
2337   // dtos
2338   __ ldf(FloatRegisterImpl::D, Rclass, Roffset, Ftos_d);
2339   __ push(dtos);
2340   if (!is_static && rc == may_rewrite) {
2341     patch_bytecode(Bytecodes::_fast_dgetfield, G3_scratch, G4_scratch);
2342   }
2343 
2344   __ bind(checkVolatile);
2345   if (__ membar_has_effect(membar_bits)) {
2346     // __ tst(Lscratch); executed in delay slot
2347     __ br(Assembler::zero, false, Assembler::pt, exit);
2348     __ delayed()->nop();
2349     volatile_barrier(membar_bits);
2350   }
2351 
2352   __ bind(exit);
2353 }
2354 
2355 void TemplateTable::getfield(int byte_no) {
2356   getfield_or_static(byte_no, false);
2357 }
2358 
2359 void TemplateTable::nofast_getfield(int byte_no) {
2360   getfield_or_static(byte_no, false, may_not_rewrite);
2361 }
2362 
2363 void TemplateTable::getstatic(int byte_no) {
2364   getfield_or_static(byte_no, true);
2365 }
2366 
2367 void TemplateTable::fast_accessfield(TosState state) {
2368   transition(atos, state);
2369   Register Rcache  = G3_scratch;
2370   Register index   = G4_scratch;
2371   Register Roffset = G4_scratch;
2372   Register Rflags  = Rcache;
2373   ByteSize cp_base_offset = ConstantPoolCache::base_offset();
2374 
2375   __ get_cache_and_index_at_bcp(Rcache, index, 1);
2376   jvmti_post_field_access(Rcache, index, /*is_static*/false, /*has_tos*/true);
2377 
2378   __ ld_ptr(Rcache, cp_base_offset + ConstantPoolCacheEntry::f2_offset(), Roffset);
2379 
2380   __ null_check(Otos_i);
2381   __ verify_oop(Otos_i);
2382 
2383   Label exit;
2384 
2385   Assembler::Membar_mask_bits membar_bits =
2386     Assembler::Membar_mask_bits(Assembler::LoadLoad | Assembler::LoadStore);
2387   if (__ membar_has_effect(membar_bits)) {
2388     // Get volatile flag
2389     __ ld_ptr(Rcache, cp_base_offset + ConstantPoolCacheEntry::f2_offset(), Rflags);
2390     __ set((1 << ConstantPoolCacheEntry::is_volatile_shift), Lscratch);
2391   }
2392 
2393   switch (bytecode()) {
2394     case Bytecodes::_fast_bgetfield:
2395       __ ldsb(Otos_i, Roffset, Otos_i);
2396       break;
2397     case Bytecodes::_fast_cgetfield:
2398       __ lduh(Otos_i, Roffset, Otos_i);
2399       break;
2400     case Bytecodes::_fast_sgetfield:
2401       __ ldsh(Otos_i, Roffset, Otos_i);
2402       break;
2403     case Bytecodes::_fast_igetfield:
2404       __ ld(Otos_i, Roffset, Otos_i);
2405       break;
2406     case Bytecodes::_fast_lgetfield:
2407       __ ld_long(Otos_i, Roffset, Otos_l);
2408       break;
2409     case Bytecodes::_fast_fgetfield:
2410       __ ldf(FloatRegisterImpl::S, Otos_i, Roffset, Ftos_f);
2411       break;
2412     case Bytecodes::_fast_dgetfield:
2413       __ ldf(FloatRegisterImpl::D, Otos_i, Roffset, Ftos_d);
2414       break;
2415     case Bytecodes::_fast_agetfield:
2416       __ load_heap_oop(Otos_i, Roffset, Otos_i);
2417       break;
2418     default:
2419       ShouldNotReachHere();
2420   }
2421 
2422   if (__ membar_has_effect(membar_bits)) {
2423     __ btst(Lscratch, Rflags);
2424     __ br(Assembler::zero, false, Assembler::pt, exit);
2425     __ delayed()->nop();
2426     volatile_barrier(membar_bits);
2427     __ bind(exit);
2428   }
2429 
2430   if (state == atos) {
2431     __ verify_oop(Otos_i);    // does not blow flags!
2432   }
2433 }
2434 
2435 void TemplateTable::jvmti_post_fast_field_mod() {
2436   if (JvmtiExport::can_post_field_modification()) {
2437     // Check to see if a field modification watch has been set before we take
2438     // the time to call into the VM.
2439     Label done;
2440     AddressLiteral get_field_modification_count_addr(JvmtiExport::get_field_modification_count_addr());
2441     __ load_contents(get_field_modification_count_addr, G4_scratch);
2442     __ cmp_and_br_short(G4_scratch, 0, Assembler::equal, Assembler::pt, done);
2443     __ pop_ptr(G4_scratch);     // copy the object pointer from tos
2444     __ verify_oop(G4_scratch);
2445     __ push_ptr(G4_scratch);    // put the object pointer back on tos
2446     __ get_cache_entry_pointer_at_bcp(G1_scratch, G3_scratch, 1);
2447     // Save tos values before call_VM() clobbers them. Since we have
2448     // to do it for every data type, we use the saved values as the
2449     // jvalue object.
2450     switch (bytecode()) {  // save tos values before call_VM() clobbers them
2451     case Bytecodes::_fast_aputfield: __ push_ptr(Otos_i); break;
2452     case Bytecodes::_fast_bputfield: // fall through
2453     case Bytecodes::_fast_sputfield: // fall through
2454     case Bytecodes::_fast_cputfield: // fall through
2455     case Bytecodes::_fast_iputfield: __ push_i(Otos_i); break;
2456     case Bytecodes::_fast_dputfield: __ push_d(Ftos_d); break;
2457     case Bytecodes::_fast_fputfield: __ push_f(Ftos_f); break;
2458     // get words in right order for use as jvalue object
2459     case Bytecodes::_fast_lputfield: __ push_l(Otos_l); break;
2460     }
2461     // setup pointer to jvalue object
2462     __ mov(Lesp, G3_scratch);  __ inc(G3_scratch, wordSize);
2463     // G4_scratch:  object pointer
2464     // G1_scratch: cache entry pointer
2465     // G3_scratch: jvalue object on the stack
2466     __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::post_field_modification), G4_scratch, G1_scratch, G3_scratch);
2467     switch (bytecode()) {             // restore tos values
2468     case Bytecodes::_fast_aputfield: __ pop_ptr(Otos_i); break;
2469     case Bytecodes::_fast_bputfield: // fall through
2470     case Bytecodes::_fast_sputfield: // fall through
2471     case Bytecodes::_fast_cputfield: // fall through
2472     case Bytecodes::_fast_iputfield: __ pop_i(Otos_i); break;
2473     case Bytecodes::_fast_dputfield: __ pop_d(Ftos_d); break;
2474     case Bytecodes::_fast_fputfield: __ pop_f(Ftos_f); break;
2475     case Bytecodes::_fast_lputfield: __ pop_l(Otos_l); break;
2476     }
2477     __ bind(done);
2478   }
2479 }
2480 
2481 // The registers Rcache and index expected to be set before call.
2482 // The function may destroy various registers, just not the Rcache and index registers.
2483 void TemplateTable::jvmti_post_field_mod(Register Rcache, Register index, bool is_static) {
2484   ByteSize cp_base_offset = ConstantPoolCache::base_offset();
2485 
2486   if (JvmtiExport::can_post_field_modification()) {
2487     // Check to see if a field modification watch has been set before we take
2488     // the time to call into the VM.
2489     Label Label1;
2490     assert_different_registers(Rcache, index, G1_scratch);
2491     AddressLiteral get_field_modification_count_addr(JvmtiExport::get_field_modification_count_addr());
2492     __ load_contents(get_field_modification_count_addr, G1_scratch);
2493     __ cmp_and_br_short(G1_scratch, 0, Assembler::zero, Assembler::pt, Label1);
2494 
2495     // The Rcache and index registers have been already set.
2496     // This allows to eliminate this call but the Rcache and index
2497     // registers must be correspondingly used after this line.
2498     __ get_cache_and_index_at_bcp(G1_scratch, G4_scratch, 1);
2499 
2500     __ add(G1_scratch, in_bytes(cp_base_offset), G3_scratch);
2501     if (is_static) {
2502       // Life is simple.  Null out the object pointer.
2503       __ clr(G4_scratch);
2504     } else {
2505       Register Rflags = G1_scratch;
2506       // Life is harder. The stack holds the value on top, followed by the
2507       // object.  We don't know the size of the value, though; it could be
2508       // one or two words depending on its type. As a result, we must find
2509       // the type to determine where the object is.
2510 
2511       Label two_word, valsizeknown;
2512       __ ld_ptr(G1_scratch, cp_base_offset + ConstantPoolCacheEntry::flags_offset(), Rflags);
2513       __ mov(Lesp, G4_scratch);
2514       __ srl(Rflags, ConstantPoolCacheEntry::tos_state_shift, Rflags);
2515       // Make sure we don't need to mask Rflags after the above shift
2516       ConstantPoolCacheEntry::verify_tos_state_shift();
2517       __ cmp(Rflags, ltos);
2518       __ br(Assembler::equal, false, Assembler::pt, two_word);
2519       __ delayed()->cmp(Rflags, dtos);
2520       __ br(Assembler::equal, false, Assembler::pt, two_word);
2521       __ delayed()->nop();
2522       __ inc(G4_scratch, Interpreter::expr_offset_in_bytes(1));
2523       __ ba_short(valsizeknown);
2524       __ bind(two_word);
2525 
2526       __ inc(G4_scratch, Interpreter::expr_offset_in_bytes(2));
2527 
2528       __ bind(valsizeknown);
2529       // setup object pointer
2530       __ ld_ptr(G4_scratch, 0, G4_scratch);
2531       __ verify_oop(G4_scratch);
2532     }
2533     // setup pointer to jvalue object
2534     __ mov(Lesp, G1_scratch);  __ inc(G1_scratch, wordSize);
2535     // G4_scratch:  object pointer or NULL if static
2536     // G3_scratch: cache entry pointer
2537     // G1_scratch: jvalue object on the stack
2538     __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::post_field_modification),
2539                G4_scratch, G3_scratch, G1_scratch);
2540     __ get_cache_and_index_at_bcp(Rcache, index, 1);
2541     __ bind(Label1);
2542   }
2543 }
2544 
2545 void TemplateTable::pop_and_check_object(Register r) {
2546   __ pop_ptr(r);
2547   __ null_check(r);  // for field access must check obj.
2548   __ verify_oop(r);
2549 }
2550 
2551 void TemplateTable::putfield_or_static(int byte_no, bool is_static, RewriteControl rc) {
2552   transition(vtos, vtos);
2553   Register Rcache = G3_scratch;
2554   Register index  = G4_scratch;
2555   Register Rclass = Rcache;
2556   Register Roffset= G4_scratch;
2557   Register Rflags = G1_scratch;
2558   ByteSize cp_base_offset = ConstantPoolCache::base_offset();
2559 
2560   resolve_cache_and_index(byte_no, Rcache, index, sizeof(u2));
2561   jvmti_post_field_mod(Rcache, index, is_static);
2562   load_field_cp_cache_entry(Rclass, Rcache, index, Roffset, Rflags, is_static);
2563 
2564   Assembler::Membar_mask_bits read_bits =
2565     Assembler::Membar_mask_bits(Assembler::LoadStore | Assembler::StoreStore);
2566   Assembler::Membar_mask_bits write_bits = Assembler::StoreLoad;
2567 
2568   Label notVolatile, checkVolatile, exit;
2569   if (__ membar_has_effect(read_bits) || __ membar_has_effect(write_bits)) {
2570     __ set((1 << ConstantPoolCacheEntry::is_volatile_shift), Lscratch);
2571     __ and3(Rflags, Lscratch, Lscratch);
2572 
2573     if (__ membar_has_effect(read_bits)) {
2574       __ cmp_and_br_short(Lscratch, 0, Assembler::equal, Assembler::pt, notVolatile);
2575       volatile_barrier(read_bits);
2576       __ bind(notVolatile);
2577     }
2578   }
2579 
2580   __ srl(Rflags, ConstantPoolCacheEntry::tos_state_shift, Rflags);
2581   // Make sure we don't need to mask Rflags after the above shift
2582   ConstantPoolCacheEntry::verify_tos_state_shift();
2583 
2584   // compute field type
2585   Label notInt, notShort, notChar, notObj, notByte, notLong, notFloat;
2586 
2587   if (is_static) {
2588     // putstatic with object type most likely, check that first
2589     __ cmp(Rflags, atos);
2590     __ br(Assembler::notEqual, false, Assembler::pt, notObj);
2591     __ delayed()->cmp(Rflags, itos);
2592 
2593     // atos
2594     {
2595       __ pop_ptr();
2596       __ verify_oop(Otos_i);
2597       do_oop_store(_masm, Rclass, Roffset, 0, Otos_i, G1_scratch, _bs->kind(), false);
2598       __ ba(checkVolatile);
2599       __ delayed()->tst(Lscratch);
2600     }
2601 
2602     __ bind(notObj);
2603     // cmp(Rflags, itos);
2604     __ br(Assembler::notEqual, false, Assembler::pt, notInt);
2605     __ delayed()->cmp(Rflags, btos);
2606 
2607     // itos
2608     {
2609       __ pop_i();
2610       __ st(Otos_i, Rclass, Roffset);
2611       __ ba(checkVolatile);
2612       __ delayed()->tst(Lscratch);
2613     }
2614 
2615     __ bind(notInt);
2616   } else {
2617     // putfield with int type most likely, check that first
2618     __ cmp(Rflags, itos);
2619     __ br(Assembler::notEqual, false, Assembler::pt, notInt);
2620     __ delayed()->cmp(Rflags, atos);
2621 
2622     // itos
2623     {
2624       __ pop_i();
2625       pop_and_check_object(Rclass);
2626       __ st(Otos_i, Rclass, Roffset);
2627       if (rc == may_rewrite) patch_bytecode(Bytecodes::_fast_iputfield, G3_scratch, G4_scratch, true, byte_no);
2628       __ ba(checkVolatile);
2629       __ delayed()->tst(Lscratch);
2630     }
2631 
2632     __ bind(notInt);
2633     // cmp(Rflags, atos);
2634     __ br(Assembler::notEqual, false, Assembler::pt, notObj);
2635     __ delayed()->cmp(Rflags, btos);
2636 
2637     // atos
2638     {
2639       __ pop_ptr();
2640       pop_and_check_object(Rclass);
2641       __ verify_oop(Otos_i);
2642       do_oop_store(_masm, Rclass, Roffset, 0, Otos_i, G1_scratch, _bs->kind(), false);
2643       if (rc == may_rewrite) patch_bytecode(Bytecodes::_fast_aputfield, G3_scratch, G4_scratch, true, byte_no);
2644       __ ba(checkVolatile);
2645       __ delayed()->tst(Lscratch);
2646     }
2647 
2648     __ bind(notObj);
2649   }
2650 
2651   // cmp(Rflags, btos);
2652   __ br(Assembler::notEqual, false, Assembler::pt, notByte);
2653   __ delayed()->cmp(Rflags, ltos);
2654 
2655   // btos
2656   {
2657     __ pop_i();
2658     if (!is_static) pop_and_check_object(Rclass);
2659     __ stb(Otos_i, Rclass, Roffset);
2660     if (!is_static && rc == may_rewrite) {
2661       patch_bytecode(Bytecodes::_fast_bputfield, G3_scratch, G4_scratch, true, byte_no);
2662     }
2663     __ ba(checkVolatile);
2664     __ delayed()->tst(Lscratch);
2665   }
2666 
2667   __ bind(notByte);
2668   // cmp(Rflags, ltos);
2669   __ br(Assembler::notEqual, false, Assembler::pt, notLong);
2670   __ delayed()->cmp(Rflags, ctos);
2671 
2672   // ltos
2673   {
2674     __ pop_l();
2675     if (!is_static) pop_and_check_object(Rclass);
2676     __ st_long(Otos_l, Rclass, Roffset);
2677     if (!is_static && rc == may_rewrite) {
2678       patch_bytecode(Bytecodes::_fast_lputfield, G3_scratch, G4_scratch, true, byte_no);
2679     }
2680     __ ba(checkVolatile);
2681     __ delayed()->tst(Lscratch);
2682   }
2683 
2684   __ bind(notLong);
2685   // cmp(Rflags, ctos);
2686   __ br(Assembler::notEqual, false, Assembler::pt, notChar);
2687   __ delayed()->cmp(Rflags, stos);
2688 
2689   // ctos (char)
2690   {
2691     __ pop_i();
2692     if (!is_static) pop_and_check_object(Rclass);
2693     __ sth(Otos_i, Rclass, Roffset);
2694     if (!is_static && rc == may_rewrite) {
2695       patch_bytecode(Bytecodes::_fast_cputfield, G3_scratch, G4_scratch, true, byte_no);
2696     }
2697     __ ba(checkVolatile);
2698     __ delayed()->tst(Lscratch);
2699   }
2700 
2701   __ bind(notChar);
2702   // cmp(Rflags, stos);
2703   __ br(Assembler::notEqual, false, Assembler::pt, notShort);
2704   __ delayed()->cmp(Rflags, ftos);
2705 
2706   // stos (short)
2707   {
2708     __ pop_i();
2709     if (!is_static) pop_and_check_object(Rclass);
2710     __ sth(Otos_i, Rclass, Roffset);
2711     if (!is_static && rc == may_rewrite) {
2712       patch_bytecode(Bytecodes::_fast_sputfield, G3_scratch, G4_scratch, true, byte_no);
2713     }
2714     __ ba(checkVolatile);
2715     __ delayed()->tst(Lscratch);
2716   }
2717 
2718   __ bind(notShort);
2719   // cmp(Rflags, ftos);
2720   __ br(Assembler::notZero, false, Assembler::pt, notFloat);
2721   __ delayed()->nop();
2722 
2723   // ftos
2724   {
2725     __ pop_f();
2726     if (!is_static) pop_and_check_object(Rclass);
2727     __ stf(FloatRegisterImpl::S, Ftos_f, Rclass, Roffset);
2728     if (!is_static && rc == may_rewrite) {
2729       patch_bytecode(Bytecodes::_fast_fputfield, G3_scratch, G4_scratch, true, byte_no);
2730     }
2731     __ ba(checkVolatile);
2732     __ delayed()->tst(Lscratch);
2733   }
2734 
2735   __ bind(notFloat);
2736 
2737   // dtos
2738   {
2739     __ pop_d();
2740     if (!is_static) pop_and_check_object(Rclass);
2741     __ stf(FloatRegisterImpl::D, Ftos_d, Rclass, Roffset);
2742     if (!is_static && rc == may_rewrite) {
2743       patch_bytecode(Bytecodes::_fast_dputfield, G3_scratch, G4_scratch, true, byte_no);
2744     }
2745   }
2746 
2747   __ bind(checkVolatile);
2748   __ tst(Lscratch);
2749 
2750   if (__ membar_has_effect(write_bits)) {
2751     // __ tst(Lscratch); in delay slot
2752     __ br(Assembler::zero, false, Assembler::pt, exit);
2753     __ delayed()->nop();
2754     volatile_barrier(Assembler::StoreLoad);
2755     __ bind(exit);
2756   }
2757 }
2758 
2759 void TemplateTable::fast_storefield(TosState state) {
2760   transition(state, vtos);
2761   Register Rcache = G3_scratch;
2762   Register Rclass = Rcache;
2763   Register Roffset= G4_scratch;
2764   Register Rflags = G1_scratch;
2765   ByteSize cp_base_offset = ConstantPoolCache::base_offset();
2766 
2767   jvmti_post_fast_field_mod();
2768 
2769   __ get_cache_and_index_at_bcp(Rcache, G4_scratch, 1);
2770 
2771   Assembler::Membar_mask_bits read_bits =
2772     Assembler::Membar_mask_bits(Assembler::LoadStore | Assembler::StoreStore);
2773   Assembler::Membar_mask_bits write_bits = Assembler::StoreLoad;
2774 
2775   Label notVolatile, checkVolatile, exit;
2776   if (__ membar_has_effect(read_bits) || __ membar_has_effect(write_bits)) {
2777     __ ld_ptr(Rcache, cp_base_offset + ConstantPoolCacheEntry::flags_offset(), Rflags);
2778     __ set((1 << ConstantPoolCacheEntry::is_volatile_shift), Lscratch);
2779     __ and3(Rflags, Lscratch, Lscratch);
2780     if (__ membar_has_effect(read_bits)) {
2781       __ cmp_and_br_short(Lscratch, 0, Assembler::equal, Assembler::pt, notVolatile);
2782       volatile_barrier(read_bits);
2783       __ bind(notVolatile);
2784     }
2785   }
2786 
2787   __ ld_ptr(Rcache, cp_base_offset + ConstantPoolCacheEntry::f2_offset(), Roffset);
2788   pop_and_check_object(Rclass);
2789 
2790   switch (bytecode()) {
2791     case Bytecodes::_fast_bputfield: __ stb(Otos_i, Rclass, Roffset); break;
2792     case Bytecodes::_fast_cputfield: /* fall through */
2793     case Bytecodes::_fast_sputfield: __ sth(Otos_i, Rclass, Roffset); break;
2794     case Bytecodes::_fast_iputfield: __ st(Otos_i, Rclass, Roffset);  break;
2795     case Bytecodes::_fast_lputfield: __ st_long(Otos_l, Rclass, Roffset); break;
2796     case Bytecodes::_fast_fputfield:
2797       __ stf(FloatRegisterImpl::S, Ftos_f, Rclass, Roffset);
2798       break;
2799     case Bytecodes::_fast_dputfield:
2800       __ stf(FloatRegisterImpl::D, Ftos_d, Rclass, Roffset);
2801       break;
2802     case Bytecodes::_fast_aputfield:
2803       do_oop_store(_masm, Rclass, Roffset, 0, Otos_i, G1_scratch, _bs->kind(), false);
2804       break;
2805     default:
2806       ShouldNotReachHere();
2807   }
2808 
2809   if (__ membar_has_effect(write_bits)) {
2810     __ cmp_and_br_short(Lscratch, 0, Assembler::equal, Assembler::pt, exit);
2811     volatile_barrier(Assembler::StoreLoad);
2812     __ bind(exit);
2813   }
2814 }
2815 
2816 void TemplateTable::putfield(int byte_no) {
2817   putfield_or_static(byte_no, false);
2818 }
2819 
2820 void TemplateTable::nofast_putfield(int byte_no) {
2821   putfield_or_static(byte_no, false, may_not_rewrite);
2822 }
2823 
2824 void TemplateTable::putstatic(int byte_no) {
2825   putfield_or_static(byte_no, true);
2826 }
2827 
2828 void TemplateTable::fast_xaccess(TosState state) {
2829   transition(vtos, state);
2830   Register Rcache = G3_scratch;
2831   Register Roffset = G4_scratch;
2832   Register Rflags  = G4_scratch;
2833   Register Rreceiver = Lscratch;
2834 
2835   __ ld_ptr(Llocals, 0, Rreceiver);
2836 
2837   // access constant pool cache  (is resolved)
2838   __ get_cache_and_index_at_bcp(Rcache, G4_scratch, 2);
2839   __ ld_ptr(Rcache, ConstantPoolCache::base_offset() + ConstantPoolCacheEntry::f2_offset(), Roffset);
2840   __ add(Lbcp, 1, Lbcp);       // needed to report exception at the correct bcp
2841 
2842   __ verify_oop(Rreceiver);
2843   __ null_check(Rreceiver);
2844   if (state == atos) {
2845     __ load_heap_oop(Rreceiver, Roffset, Otos_i);
2846   } else if (state == itos) {
2847     __ ld (Rreceiver, Roffset, Otos_i) ;
2848   } else if (state == ftos) {
2849     __ ldf(FloatRegisterImpl::S, Rreceiver, Roffset, Ftos_f);
2850   } else {
2851     ShouldNotReachHere();
2852   }
2853 
2854   Assembler::Membar_mask_bits membar_bits =
2855     Assembler::Membar_mask_bits(Assembler::LoadLoad | Assembler::LoadStore);
2856   if (__ membar_has_effect(membar_bits)) {
2857 
2858     // Get is_volatile value in Rflags and check if membar is needed
2859     __ ld_ptr(Rcache, ConstantPoolCache::base_offset() + ConstantPoolCacheEntry::flags_offset(), Rflags);
2860 
2861     // Test volatile
2862     Label notVolatile;
2863     __ set((1 << ConstantPoolCacheEntry::is_volatile_shift), Lscratch);
2864     __ btst(Rflags, Lscratch);
2865     __ br(Assembler::zero, false, Assembler::pt, notVolatile);
2866     __ delayed()->nop();
2867     volatile_barrier(membar_bits);
2868     __ bind(notVolatile);
2869   }
2870 
2871   __ interp_verify_oop(Otos_i, state, __FILE__, __LINE__);
2872   __ sub(Lbcp, 1, Lbcp);
2873 }
2874 
2875 //----------------------------------------------------------------------------------------------------
2876 // Calls
2877 
2878 void TemplateTable::count_calls(Register method, Register temp) {
2879   // implemented elsewhere
2880   ShouldNotReachHere();
2881 }
2882 
2883 void TemplateTable::prepare_invoke(int byte_no,
2884                                    Register method,  // linked method (or i-klass)
2885                                    Register ra,      // return address
2886                                    Register index,   // itable index, MethodType, etc.
2887                                    Register recv,    // if caller wants to see it
2888                                    Register flags    // if caller wants to test it
2889                                    ) {
2890   // determine flags
2891   const Bytecodes::Code code = bytecode();
2892   const bool is_invokeinterface  = code == Bytecodes::_invokeinterface;
2893   const bool is_invokedynamic    = code == Bytecodes::_invokedynamic;
2894   const bool is_invokehandle     = code == Bytecodes::_invokehandle;
2895   const bool is_invokevirtual    = code == Bytecodes::_invokevirtual;
2896   const bool is_invokespecial    = code == Bytecodes::_invokespecial;
2897   const bool load_receiver       = (recv != noreg);
2898   assert(load_receiver == (code != Bytecodes::_invokestatic && code != Bytecodes::_invokedynamic), "");
2899   assert(recv  == noreg || recv  == O0, "");
2900   assert(flags == noreg || flags == O1, "");
2901 
2902   // setup registers & access constant pool cache
2903   if (recv  == noreg)  recv  = O0;
2904   if (flags == noreg)  flags = O1;
2905   const Register temp = O2;
2906   assert_different_registers(method, ra, index, recv, flags, temp);
2907 
2908   load_invoke_cp_cache_entry(byte_no, method, index, flags, is_invokevirtual, false, is_invokedynamic);
2909 
2910   __ mov(SP, O5_savedSP);  // record SP that we wanted the callee to restore
2911 
2912   // maybe push appendix to arguments
2913   if (is_invokedynamic || is_invokehandle) {
2914     Label L_no_push;
2915     __ set((1 << ConstantPoolCacheEntry::has_appendix_shift), temp);
2916     __ btst(flags, temp);
2917     __ br(Assembler::zero, false, Assembler::pt, L_no_push);
2918     __ delayed()->nop();
2919     // Push the appendix as a trailing parameter.
2920     // This must be done before we get the receiver,
2921     // since the parameter_size includes it.
2922     assert(ConstantPoolCacheEntry::_indy_resolved_references_appendix_offset == 0, "appendix expected at index+0");
2923     __ load_resolved_reference_at_index(temp, index);
2924     __ verify_oop(temp);
2925     __ push_ptr(temp);  // push appendix (MethodType, CallSite, etc.)
2926     __ bind(L_no_push);
2927   }
2928 
2929   // load receiver if needed (after appendix is pushed so parameter size is correct)
2930   if (load_receiver) {
2931     __ and3(flags, ConstantPoolCacheEntry::parameter_size_mask, temp);  // get parameter size
2932     __ load_receiver(temp, recv);  //  __ argument_address uses Gargs but we need Lesp
2933     __ verify_oop(recv);
2934   }
2935 
2936   // compute return type
2937   __ srl(flags, ConstantPoolCacheEntry::tos_state_shift, ra);
2938   // Make sure we don't need to mask flags after the above shift
2939   ConstantPoolCacheEntry::verify_tos_state_shift();
2940   // load return address
2941   {
2942     const address table_addr = (address) Interpreter::invoke_return_entry_table_for(code);
2943     AddressLiteral table(table_addr);
2944     __ set(table, temp);
2945     __ sll(ra, LogBytesPerWord, ra);
2946     __ ld_ptr(Address(temp, ra), ra);
2947   }
2948 }
2949 
2950 
2951 void TemplateTable::generate_vtable_call(Register Rrecv, Register Rindex, Register Rret) {
2952   Register Rtemp = G4_scratch;
2953   Register Rcall = Rindex;
2954   assert_different_registers(Rcall, G5_method, Gargs, Rret);
2955 
2956   // get target Method* & entry point
2957   __ lookup_virtual_method(Rrecv, Rindex, G5_method);
2958   __ profile_arguments_type(G5_method, Rcall, Gargs, true);
2959   __ profile_called_method(G5_method, Rtemp);
2960   __ call_from_interpreter(Rcall, Gargs, Rret);
2961 }
2962 
2963 void TemplateTable::invokevirtual(int byte_no) {
2964   transition(vtos, vtos);
2965   assert(byte_no == f2_byte, "use this argument");
2966 
2967   Register Rscratch = G3_scratch;
2968   Register Rtemp    = G4_scratch;
2969   Register Rret     = Lscratch;
2970   Register O0_recv  = O0;
2971   Label notFinal;
2972 
2973   load_invoke_cp_cache_entry(byte_no, G5_method, noreg, Rret, true, false, false);
2974   __ mov(SP, O5_savedSP); // record SP that we wanted the callee to restore
2975 
2976   // Check for vfinal
2977   __ set((1 << ConstantPoolCacheEntry::is_vfinal_shift), G4_scratch);
2978   __ btst(Rret, G4_scratch);
2979   __ br(Assembler::zero, false, Assembler::pt, notFinal);
2980   __ delayed()->and3(Rret, 0xFF, G4_scratch);      // gets number of parameters
2981 
2982   if (RewriteBytecodes && !UseSharedSpaces) {
2983     patch_bytecode(Bytecodes::_fast_invokevfinal, Rscratch, Rtemp);
2984   }
2985 
2986   invokevfinal_helper(Rscratch, Rret);
2987 
2988   __ bind(notFinal);
2989 
2990   __ mov(G5_method, Rscratch);  // better scratch register
2991   __ load_receiver(G4_scratch, O0_recv);  // gets receiverOop
2992   // receiver is in O0_recv
2993   __ verify_oop(O0_recv);
2994 
2995   // get return address
2996   AddressLiteral table(Interpreter::invoke_return_entry_table());
2997   __ set(table, Rtemp);
2998   __ srl(Rret, ConstantPoolCacheEntry::tos_state_shift, Rret);          // get return type
2999   // Make sure we don't need to mask Rret after the above shift
3000   ConstantPoolCacheEntry::verify_tos_state_shift();
3001   __ sll(Rret,  LogBytesPerWord, Rret);
3002   __ ld_ptr(Rtemp, Rret, Rret);         // get return address
3003 
3004   // get receiver klass
3005   __ null_check(O0_recv, oopDesc::klass_offset_in_bytes());
3006   __ load_klass(O0_recv, O0_recv);
3007   __ verify_klass_ptr(O0_recv);
3008 
3009   __ profile_virtual_call(O0_recv, O4);
3010 
3011   generate_vtable_call(O0_recv, Rscratch, Rret);
3012 }
3013 
3014 void TemplateTable::fast_invokevfinal(int byte_no) {
3015   transition(vtos, vtos);
3016   assert(byte_no == f2_byte, "use this argument");
3017 
3018   load_invoke_cp_cache_entry(byte_no, G5_method, noreg, Lscratch, true,
3019                              /*is_invokevfinal*/true, false);
3020   __ mov(SP, O5_savedSP); // record SP that we wanted the callee to restore
3021   invokevfinal_helper(G3_scratch, Lscratch);
3022 }
3023 
3024 void TemplateTable::invokevfinal_helper(Register Rscratch, Register Rret) {
3025   Register Rtemp = G4_scratch;
3026 
3027   // Load receiver from stack slot
3028   __ ld_ptr(G5_method, in_bytes(Method::const_offset()), G4_scratch);
3029   __ lduh(G4_scratch, in_bytes(ConstMethod::size_of_parameters_offset()), G4_scratch);
3030   __ load_receiver(G4_scratch, O0);
3031 
3032   // receiver NULL check
3033   __ null_check(O0);
3034 
3035   __ profile_final_call(O4);
3036   __ profile_arguments_type(G5_method, Rscratch, Gargs, true);
3037 
3038   // get return address
3039   AddressLiteral table(Interpreter::invoke_return_entry_table());
3040   __ set(table, Rtemp);
3041   __ srl(Rret, ConstantPoolCacheEntry::tos_state_shift, Rret);          // get return type
3042   // Make sure we don't need to mask Rret after the above shift
3043   ConstantPoolCacheEntry::verify_tos_state_shift();
3044   __ sll(Rret,  LogBytesPerWord, Rret);
3045   __ ld_ptr(Rtemp, Rret, Rret);         // get return address
3046 
3047 
3048   // do the call
3049   __ call_from_interpreter(Rscratch, Gargs, Rret);
3050 }
3051 
3052 
3053 void TemplateTable::invokespecial(int byte_no) {
3054   transition(vtos, vtos);
3055   assert(byte_no == f1_byte, "use this argument");
3056 
3057   const Register Rret     = Lscratch;
3058   const Register O0_recv  = O0;
3059   const Register Rscratch = G3_scratch;
3060 
3061   prepare_invoke(byte_no, G5_method, Rret, noreg, O0_recv);  // get receiver also for null check
3062   __ null_check(O0_recv);
3063 
3064   // do the call
3065   __ profile_call(O4);
3066   __ profile_arguments_type(G5_method, Rscratch, Gargs, false);
3067   __ call_from_interpreter(Rscratch, Gargs, Rret);
3068 }
3069 
3070 
3071 void TemplateTable::invokestatic(int byte_no) {
3072   transition(vtos, vtos);
3073   assert(byte_no == f1_byte, "use this argument");
3074 
3075   const Register Rret     = Lscratch;
3076   const Register Rscratch = G3_scratch;
3077 
3078   prepare_invoke(byte_no, G5_method, Rret);  // get f1 Method*
3079 
3080   // do the call
3081   __ profile_call(O4);
3082   __ profile_arguments_type(G5_method, Rscratch, Gargs, false);
3083   __ call_from_interpreter(Rscratch, Gargs, Rret);
3084 }
3085 
3086 void TemplateTable::invokeinterface_object_method(Register RKlass,
3087                                                   Register Rcall,
3088                                                   Register Rret,
3089                                                   Register Rflags) {
3090   Register Rscratch = G4_scratch;
3091   Register Rindex = Lscratch;
3092 
3093   assert_different_registers(Rscratch, Rindex, Rret);
3094 
3095   Label notFinal;
3096 
3097   // Check for vfinal
3098   __ set((1 << ConstantPoolCacheEntry::is_vfinal_shift), Rscratch);
3099   __ btst(Rflags, Rscratch);
3100   __ br(Assembler::zero, false, Assembler::pt, notFinal);
3101   __ delayed()->nop();
3102 
3103   __ profile_final_call(O4);
3104 
3105   // do the call - the index (f2) contains the Method*
3106   assert_different_registers(G5_method, Gargs, Rcall);
3107   __ mov(Rindex, G5_method);
3108   __ profile_arguments_type(G5_method, Rcall, Gargs, true);
3109   __ call_from_interpreter(Rcall, Gargs, Rret);
3110   __ bind(notFinal);
3111 
3112   __ profile_virtual_call(RKlass, O4);
3113   generate_vtable_call(RKlass, Rindex, Rret);
3114 }
3115 
3116 
3117 void TemplateTable::invokeinterface(int byte_no) {
3118   transition(vtos, vtos);
3119   assert(byte_no == f1_byte, "use this argument");
3120 
3121   const Register Rinterface  = G1_scratch;
3122   const Register Rret        = G3_scratch;
3123   const Register Rindex      = Lscratch;
3124   const Register O0_recv     = O0;
3125   const Register O1_flags    = O1;
3126   const Register O2_Klass    = O2;
3127   const Register Rscratch    = G4_scratch;
3128   assert_different_registers(Rscratch, G5_method);
3129 
3130   prepare_invoke(byte_no, Rinterface, Rret, Rindex, O0_recv, O1_flags);
3131 
3132   // get receiver klass
3133   __ null_check(O0_recv, oopDesc::klass_offset_in_bytes());
3134   __ load_klass(O0_recv, O2_Klass);
3135 
3136   // Special case of invokeinterface called for virtual method of
3137   // java.lang.Object.  See cpCacheOop.cpp for details.
3138   // This code isn't produced by javac, but could be produced by
3139   // another compliant java compiler.
3140   Label notMethod;
3141   __ set((1 << ConstantPoolCacheEntry::is_forced_virtual_shift), Rscratch);
3142   __ btst(O1_flags, Rscratch);
3143   __ br(Assembler::zero, false, Assembler::pt, notMethod);
3144   __ delayed()->nop();
3145 
3146   invokeinterface_object_method(O2_Klass, Rinterface, Rret, O1_flags);
3147 
3148   __ bind(notMethod);
3149 
3150   __ profile_virtual_call(O2_Klass, O4);
3151 
3152   //
3153   // find entry point to call
3154   //
3155 
3156   // compute start of first itableOffsetEntry (which is at end of vtable)
3157   const int base = InstanceKlass::vtable_start_offset() * wordSize;
3158   Label search;
3159   Register Rtemp = O1_flags;
3160 
3161   __ ld(O2_Klass, InstanceKlass::vtable_length_offset() * wordSize, Rtemp);
3162   if (align_object_offset(1) > 1) {
3163     __ round_to(Rtemp, align_object_offset(1));
3164   }
3165   __ sll(Rtemp, LogBytesPerWord, Rtemp);   // Rscratch *= 4;
3166   if (Assembler::is_simm13(base)) {
3167     __ add(Rtemp, base, Rtemp);
3168   } else {
3169     __ set(base, Rscratch);
3170     __ add(Rscratch, Rtemp, Rtemp);
3171   }
3172   __ add(O2_Klass, Rtemp, Rscratch);
3173 
3174   __ bind(search);
3175 
3176   __ ld_ptr(Rscratch, itableOffsetEntry::interface_offset_in_bytes(), Rtemp);
3177   {
3178     Label ok;
3179 
3180     // Check that entry is non-null.  Null entries are probably a bytecode
3181     // problem.  If the interface isn't implemented by the receiver class,
3182     // the VM should throw IncompatibleClassChangeError.  linkResolver checks
3183     // this too but that's only if the entry isn't already resolved, so we
3184     // need to check again.
3185     __ br_notnull_short( Rtemp, Assembler::pt, ok);
3186     call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_IncompatibleClassChangeError));
3187     __ should_not_reach_here();
3188     __ bind(ok);
3189   }
3190 
3191   __ cmp(Rinterface, Rtemp);
3192   __ brx(Assembler::notEqual, true, Assembler::pn, search);
3193   __ delayed()->add(Rscratch, itableOffsetEntry::size() * wordSize, Rscratch);
3194 
3195   // entry found and Rscratch points to it
3196   __ ld(Rscratch, itableOffsetEntry::offset_offset_in_bytes(), Rscratch);
3197 
3198   assert(itableMethodEntry::method_offset_in_bytes() == 0, "adjust instruction below");
3199   __ sll(Rindex, exact_log2(itableMethodEntry::size() * wordSize), Rindex);       // Rindex *= 8;
3200   __ add(Rscratch, Rindex, Rscratch);
3201   __ ld_ptr(O2_Klass, Rscratch, G5_method);
3202 
3203   // Check for abstract method error.
3204   {
3205     Label ok;
3206     __ br_notnull_short(G5_method, Assembler::pt, ok);
3207     call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_AbstractMethodError));
3208     __ should_not_reach_here();
3209     __ bind(ok);
3210   }
3211 
3212   Register Rcall = Rinterface;
3213   assert_different_registers(Rcall, G5_method, Gargs, Rret);
3214 
3215   __ profile_arguments_type(G5_method, Rcall, Gargs, true);
3216   __ profile_called_method(G5_method, Rscratch);
3217   __ call_from_interpreter(Rcall, Gargs, Rret);
3218 }
3219 
3220 void TemplateTable::invokehandle(int byte_no) {
3221   transition(vtos, vtos);
3222   assert(byte_no == f1_byte, "use this argument");
3223 
3224   const Register Rret       = Lscratch;
3225   const Register G4_mtype   = G4_scratch;
3226   const Register O0_recv    = O0;
3227   const Register Rscratch   = G3_scratch;
3228 
3229   prepare_invoke(byte_no, G5_method, Rret, G4_mtype, O0_recv);
3230   __ null_check(O0_recv);
3231 
3232   // G4: MethodType object (from cpool->resolved_references[f1], if necessary)
3233   // G5: MH.invokeExact_MT method (from f2)
3234 
3235   // Note:  G4_mtype is already pushed (if necessary) by prepare_invoke
3236 
3237   // do the call
3238   __ verify_oop(G4_mtype);
3239   __ profile_final_call(O4);  // FIXME: profile the LambdaForm also
3240   __ profile_arguments_type(G5_method, Rscratch, Gargs, true);
3241   __ call_from_interpreter(Rscratch, Gargs, Rret);
3242 }
3243 
3244 
3245 void TemplateTable::invokedynamic(int byte_no) {
3246   transition(vtos, vtos);
3247   assert(byte_no == f1_byte, "use this argument");
3248 
3249   const Register Rret        = Lscratch;
3250   const Register G4_callsite = G4_scratch;
3251   const Register Rscratch    = G3_scratch;
3252 
3253   prepare_invoke(byte_no, G5_method, Rret, G4_callsite);
3254 
3255   // G4: CallSite object (from cpool->resolved_references[f1])
3256   // G5: MH.linkToCallSite method (from f2)
3257 
3258   // Note:  G4_callsite is already pushed by prepare_invoke
3259 
3260   // %%% should make a type profile for any invokedynamic that takes a ref argument
3261   // profile this call
3262   __ profile_call(O4);
3263 
3264   // do the call
3265   __ verify_oop(G4_callsite);
3266   __ profile_arguments_type(G5_method, Rscratch, Gargs, false);
3267   __ call_from_interpreter(Rscratch, Gargs, Rret);
3268 }
3269 
3270 
3271 //----------------------------------------------------------------------------------------------------
3272 // Allocation
3273 
3274 void TemplateTable::_new() {
3275   transition(vtos, atos);
3276 
3277   Label slow_case;
3278   Label done;
3279   Label initialize_header;
3280   Label initialize_object;  // including clearing the fields
3281 
3282   Register RallocatedObject = Otos_i;
3283   Register RinstanceKlass = O1;
3284   Register Roffset = O3;
3285   Register Rscratch = O4;
3286 
3287   __ get_2_byte_integer_at_bcp(1, Rscratch, Roffset, InterpreterMacroAssembler::Unsigned);
3288   __ get_cpool_and_tags(Rscratch, G3_scratch);
3289   // make sure the class we're about to instantiate has been resolved
3290   // This is done before loading InstanceKlass to be consistent with the order
3291   // how Constant Pool is updated (see ConstantPool::klass_at_put)
3292   __ add(G3_scratch, Array<u1>::base_offset_in_bytes(), G3_scratch);
3293   __ ldub(G3_scratch, Roffset, G3_scratch);
3294   __ cmp(G3_scratch, JVM_CONSTANT_Class);
3295   __ br(Assembler::notEqual, false, Assembler::pn, slow_case);
3296   __ delayed()->sll(Roffset, LogBytesPerWord, Roffset);
3297   // get InstanceKlass
3298   //__ sll(Roffset, LogBytesPerWord, Roffset);        // executed in delay slot
3299   __ add(Roffset, sizeof(ConstantPool), Roffset);
3300   __ ld_ptr(Rscratch, Roffset, RinstanceKlass);
3301 
3302   // make sure klass is fully initialized:
3303   __ ldub(RinstanceKlass, in_bytes(InstanceKlass::init_state_offset()), G3_scratch);
3304   __ cmp(G3_scratch, InstanceKlass::fully_initialized);
3305   __ br(Assembler::notEqual, false, Assembler::pn, slow_case);
3306   __ delayed()->ld(RinstanceKlass, in_bytes(Klass::layout_helper_offset()), Roffset);
3307 
3308   // get instance_size in InstanceKlass (already aligned)
3309   //__ ld(RinstanceKlass, in_bytes(Klass::layout_helper_offset()), Roffset);
3310 
3311   // make sure klass does not have has_finalizer, or is abstract, or interface or java/lang/Class
3312   __ btst(Klass::_lh_instance_slow_path_bit, Roffset);
3313   __ br(Assembler::notZero, false, Assembler::pn, slow_case);
3314   __ delayed()->nop();
3315 
3316   // allocate the instance
3317   // 1) Try to allocate in the TLAB
3318   // 2) if fail, and the TLAB is not full enough to discard, allocate in the shared Eden
3319   // 3) if the above fails (or is not applicable), go to a slow case
3320   // (creates a new TLAB, etc.)
3321 
3322   const bool allow_shared_alloc =
3323     Universe::heap()->supports_inline_contig_alloc();
3324 
3325   if(UseTLAB) {
3326     Register RoldTopValue = RallocatedObject;
3327     Register RtlabWasteLimitValue = G3_scratch;
3328     Register RnewTopValue = G1_scratch;
3329     Register RendValue = Rscratch;
3330     Register RfreeValue = RnewTopValue;
3331 
3332     // check if we can allocate in the TLAB
3333     __ ld_ptr(G2_thread, in_bytes(JavaThread::tlab_top_offset()), RoldTopValue); // sets up RalocatedObject
3334     __ ld_ptr(G2_thread, in_bytes(JavaThread::tlab_end_offset()), RendValue);
3335     __ add(RoldTopValue, Roffset, RnewTopValue);
3336 
3337     // if there is enough space, we do not CAS and do not clear
3338     __ cmp(RnewTopValue, RendValue);
3339     if(ZeroTLAB) {
3340       // the fields have already been cleared
3341       __ brx(Assembler::lessEqualUnsigned, true, Assembler::pt, initialize_header);
3342     } else {
3343       // initialize both the header and fields
3344       __ brx(Assembler::lessEqualUnsigned, true, Assembler::pt, initialize_object);
3345     }
3346     __ delayed()->st_ptr(RnewTopValue, G2_thread, in_bytes(JavaThread::tlab_top_offset()));
3347 
3348     if (allow_shared_alloc) {
3349       // Check if tlab should be discarded (refill_waste_limit >= free)
3350       __ ld_ptr(G2_thread, in_bytes(JavaThread::tlab_refill_waste_limit_offset()), RtlabWasteLimitValue);
3351       __ sub(RendValue, RoldTopValue, RfreeValue);
3352 #ifdef _LP64
3353       __ srlx(RfreeValue, LogHeapWordSize, RfreeValue);
3354 #else
3355       __ srl(RfreeValue, LogHeapWordSize, RfreeValue);
3356 #endif
3357       __ cmp_and_brx_short(RtlabWasteLimitValue, RfreeValue, Assembler::greaterEqualUnsigned, Assembler::pt, slow_case); // tlab waste is small
3358 
3359       // increment waste limit to prevent getting stuck on this slow path
3360       __ add(RtlabWasteLimitValue, ThreadLocalAllocBuffer::refill_waste_limit_increment(), RtlabWasteLimitValue);
3361       __ st_ptr(RtlabWasteLimitValue, G2_thread, in_bytes(JavaThread::tlab_refill_waste_limit_offset()));
3362     } else {
3363       // No allocation in the shared eden.
3364       __ ba_short(slow_case);
3365     }
3366   }
3367 
3368   // Allocation in the shared Eden
3369   if (allow_shared_alloc) {
3370     Register RoldTopValue = G1_scratch;
3371     Register RtopAddr = G3_scratch;
3372     Register RnewTopValue = RallocatedObject;
3373     Register RendValue = Rscratch;
3374 
3375     __ set((intptr_t)Universe::heap()->top_addr(), RtopAddr);
3376 
3377     Label retry;
3378     __ bind(retry);
3379     __ set((intptr_t)Universe::heap()->end_addr(), RendValue);
3380     __ ld_ptr(RendValue, 0, RendValue);
3381     __ ld_ptr(RtopAddr, 0, RoldTopValue);
3382     __ add(RoldTopValue, Roffset, RnewTopValue);
3383 
3384     // RnewTopValue contains the top address after the new object
3385     // has been allocated.
3386     __ cmp_and_brx_short(RnewTopValue, RendValue, Assembler::greaterUnsigned, Assembler::pn, slow_case);
3387 
3388     __ cas_ptr(RtopAddr, RoldTopValue, RnewTopValue);
3389 
3390     // if someone beat us on the allocation, try again, otherwise continue
3391     __ cmp_and_brx_short(RoldTopValue, RnewTopValue, Assembler::notEqual, Assembler::pn, retry);
3392 
3393     // bump total bytes allocated by this thread
3394     // RoldTopValue and RtopAddr are dead, so can use G1 and G3
3395     __ incr_allocated_bytes(Roffset, G1_scratch, G3_scratch);
3396   }
3397 
3398   if (UseTLAB || Universe::heap()->supports_inline_contig_alloc()) {
3399     // clear object fields
3400     __ bind(initialize_object);
3401     __ deccc(Roffset, sizeof(oopDesc));
3402     __ br(Assembler::zero, false, Assembler::pt, initialize_header);
3403     __ delayed()->add(RallocatedObject, sizeof(oopDesc), G3_scratch);
3404 
3405     // initialize remaining object fields
3406     if (UseBlockZeroing) {
3407       // Use BIS for zeroing
3408       __ bis_zeroing(G3_scratch, Roffset, G1_scratch, initialize_header);
3409     } else {
3410       Label loop;
3411       __ subcc(Roffset, wordSize, Roffset);
3412       __ bind(loop);
3413       //__ subcc(Roffset, wordSize, Roffset);      // executed above loop or in delay slot
3414       __ st_ptr(G0, G3_scratch, Roffset);
3415       __ br(Assembler::notEqual, false, Assembler::pt, loop);
3416       __ delayed()->subcc(Roffset, wordSize, Roffset);
3417     }
3418     __ ba_short(initialize_header);
3419   }
3420 
3421   // slow case
3422   __ bind(slow_case);
3423   __ get_2_byte_integer_at_bcp(1, G3_scratch, O2, InterpreterMacroAssembler::Unsigned);
3424   __ get_constant_pool(O1);
3425 
3426   call_VM(Otos_i, CAST_FROM_FN_PTR(address, InterpreterRuntime::_new), O1, O2);
3427 
3428   __ ba_short(done);
3429 
3430   // Initialize the header: mark, klass
3431   __ bind(initialize_header);
3432 
3433   if (UseBiasedLocking) {
3434     __ ld_ptr(RinstanceKlass, in_bytes(Klass::prototype_header_offset()), G4_scratch);
3435   } else {
3436     __ set((intptr_t)markOopDesc::prototype(), G4_scratch);
3437   }
3438   __ st_ptr(G4_scratch, RallocatedObject, oopDesc::mark_offset_in_bytes());       // mark
3439   __ store_klass_gap(G0, RallocatedObject);         // klass gap if compressed
3440   __ store_klass(RinstanceKlass, RallocatedObject); // klass (last for cms)
3441 
3442   {
3443     SkipIfEqual skip_if(
3444       _masm, G4_scratch, &DTraceAllocProbes, Assembler::zero);
3445     // Trigger dtrace event
3446     __ push(atos);
3447     __ call_VM_leaf(noreg,
3448        CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_object_alloc), O0);
3449     __ pop(atos);
3450   }
3451 
3452   // continue
3453   __ bind(done);
3454 }
3455 
3456 
3457 
3458 void TemplateTable::newarray() {
3459   transition(itos, atos);
3460   __ ldub(Lbcp, 1, O1);
3461      call_VM(Otos_i, CAST_FROM_FN_PTR(address, InterpreterRuntime::newarray), O1, Otos_i);
3462 }
3463 
3464 
3465 void TemplateTable::anewarray() {
3466   transition(itos, atos);
3467   __ get_constant_pool(O1);
3468   __ get_2_byte_integer_at_bcp(1, G4_scratch, O2, InterpreterMacroAssembler::Unsigned);
3469      call_VM(Otos_i, CAST_FROM_FN_PTR(address, InterpreterRuntime::anewarray), O1, O2, Otos_i);
3470 }
3471 
3472 
3473 void TemplateTable::arraylength() {
3474   transition(atos, itos);
3475   Label ok;
3476   __ verify_oop(Otos_i);
3477   __ tst(Otos_i);
3478   __ throw_if_not_1_x( Assembler::notZero, ok );
3479   __ delayed()->ld(Otos_i, arrayOopDesc::length_offset_in_bytes(), Otos_i);
3480   __ throw_if_not_2( Interpreter::_throw_NullPointerException_entry, G3_scratch, ok);
3481 }
3482 
3483 
3484 void TemplateTable::checkcast() {
3485   transition(atos, atos);
3486   Label done, is_null, quicked, cast_ok, resolved;
3487   Register Roffset = G1_scratch;
3488   Register RobjKlass = O5;
3489   Register RspecifiedKlass = O4;
3490 
3491   // Check for casting a NULL
3492   __ br_null(Otos_i, false, Assembler::pn, is_null);
3493   __ delayed()->nop();
3494 
3495   // Get value klass in RobjKlass
3496   __ load_klass(Otos_i, RobjKlass); // get value klass
3497 
3498   // Get constant pool tag
3499   __ get_2_byte_integer_at_bcp(1, Lscratch, Roffset, InterpreterMacroAssembler::Unsigned);
3500 
3501   // See if the checkcast has been quickened
3502   __ get_cpool_and_tags(Lscratch, G3_scratch);
3503   __ add(G3_scratch, Array<u1>::base_offset_in_bytes(), G3_scratch);
3504   __ ldub(G3_scratch, Roffset, G3_scratch);
3505   __ cmp(G3_scratch, JVM_CONSTANT_Class);
3506   __ br(Assembler::equal, true, Assembler::pt, quicked);
3507   __ delayed()->sll(Roffset, LogBytesPerWord, Roffset);
3508 
3509   __ push_ptr(); // save receiver for result, and for GC
3510   call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::quicken_io_cc) );
3511   __ get_vm_result_2(RspecifiedKlass);
3512   __ pop_ptr(Otos_i, G3_scratch); // restore receiver
3513 
3514   __ ba_short(resolved);
3515 
3516   // Extract target class from constant pool
3517   __ bind(quicked);
3518   __ add(Roffset, sizeof(ConstantPool), Roffset);
3519   __ ld_ptr(Lscratch, Roffset, RspecifiedKlass);
3520   __ bind(resolved);
3521   __ load_klass(Otos_i, RobjKlass); // get value klass
3522 
3523   // Generate a fast subtype check.  Branch to cast_ok if no
3524   // failure.  Throw exception if failure.
3525   __ gen_subtype_check( RobjKlass, RspecifiedKlass, G3_scratch, G4_scratch, G1_scratch, cast_ok );
3526 
3527   // Not a subtype; so must throw exception
3528   __ throw_if_not_x( Assembler::never, Interpreter::_throw_ClassCastException_entry, G3_scratch );
3529 
3530   __ bind(cast_ok);
3531 
3532   if (ProfileInterpreter) {
3533     __ ba_short(done);
3534   }
3535   __ bind(is_null);
3536   __ profile_null_seen(G3_scratch);
3537   __ bind(done);
3538 }
3539 
3540 
3541 void TemplateTable::instanceof() {
3542   Label done, is_null, quicked, resolved;
3543   transition(atos, itos);
3544   Register Roffset = G1_scratch;
3545   Register RobjKlass = O5;
3546   Register RspecifiedKlass = O4;
3547 
3548   // Check for casting a NULL
3549   __ br_null(Otos_i, false, Assembler::pt, is_null);
3550   __ delayed()->nop();
3551 
3552   // Get value klass in RobjKlass
3553   __ load_klass(Otos_i, RobjKlass); // get value klass
3554 
3555   // Get constant pool tag
3556   __ get_2_byte_integer_at_bcp(1, Lscratch, Roffset, InterpreterMacroAssembler::Unsigned);
3557 
3558   // See if the checkcast has been quickened
3559   __ get_cpool_and_tags(Lscratch, G3_scratch);
3560   __ add(G3_scratch, Array<u1>::base_offset_in_bytes(), G3_scratch);
3561   __ ldub(G3_scratch, Roffset, G3_scratch);
3562   __ cmp(G3_scratch, JVM_CONSTANT_Class);
3563   __ br(Assembler::equal, true, Assembler::pt, quicked);
3564   __ delayed()->sll(Roffset, LogBytesPerWord, Roffset);
3565 
3566   __ push_ptr(); // save receiver for result, and for GC
3567   call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::quicken_io_cc) );
3568   __ get_vm_result_2(RspecifiedKlass);
3569   __ pop_ptr(Otos_i, G3_scratch); // restore receiver
3570 
3571   __ ba_short(resolved);
3572 
3573   // Extract target class from constant pool
3574   __ bind(quicked);
3575   __ add(Roffset, sizeof(ConstantPool), Roffset);
3576   __ get_constant_pool(Lscratch);
3577   __ ld_ptr(Lscratch, Roffset, RspecifiedKlass);
3578   __ bind(resolved);
3579   __ load_klass(Otos_i, RobjKlass); // get value klass
3580 
3581   // Generate a fast subtype check.  Branch to cast_ok if no
3582   // failure.  Return 0 if failure.
3583   __ or3(G0, 1, Otos_i);      // set result assuming quick tests succeed
3584   __ gen_subtype_check( RobjKlass, RspecifiedKlass, G3_scratch, G4_scratch, G1_scratch, done );
3585   // Not a subtype; return 0;
3586   __ clr( Otos_i );
3587 
3588   if (ProfileInterpreter) {
3589     __ ba_short(done);
3590   }
3591   __ bind(is_null);
3592   __ profile_null_seen(G3_scratch);
3593   __ bind(done);
3594 }
3595 
3596 void TemplateTable::_breakpoint() {
3597 
3598    // Note: We get here even if we are single stepping..
3599    // jbug inists on setting breakpoints at every bytecode
3600    // even if we are in single step mode.
3601 
3602    transition(vtos, vtos);
3603    // get the unpatched byte code
3604    __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::get_original_bytecode_at), Lmethod, Lbcp);
3605    __ mov(O0, Lbyte_code);
3606 
3607    // post the breakpoint event
3608    __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::_breakpoint), Lmethod, Lbcp);
3609 
3610    // complete the execution of original bytecode
3611    __ dispatch_normal(vtos);
3612 }
3613 
3614 
3615 //----------------------------------------------------------------------------------------------------
3616 // Exceptions
3617 
3618 void TemplateTable::athrow() {
3619   transition(atos, vtos);
3620 
3621   // This works because exception is cached in Otos_i which is same as O0,
3622   // which is same as what throw_exception_entry_expects
3623   assert(Otos_i == Oexception, "see explanation above");
3624 
3625   __ verify_oop(Otos_i);
3626   __ null_check(Otos_i);
3627   __ throw_if_not_x(Assembler::never, Interpreter::throw_exception_entry(), G3_scratch);
3628 }
3629 
3630 
3631 //----------------------------------------------------------------------------------------------------
3632 // Synchronization
3633 
3634 
3635 // See frame_sparc.hpp for monitor block layout.
3636 // Monitor elements are dynamically allocated by growing stack as needed.
3637 
3638 void TemplateTable::monitorenter() {
3639   transition(atos, vtos);
3640   __ verify_oop(Otos_i);
3641   // Try to acquire a lock on the object
3642   // Repeat until succeeded (i.e., until
3643   // monitorenter returns true).
3644 
3645   {   Label ok;
3646     __ tst(Otos_i);
3647     __ throw_if_not_1_x( Assembler::notZero,  ok);
3648     __ delayed()->mov(Otos_i, Lscratch); // save obj
3649     __ throw_if_not_2( Interpreter::_throw_NullPointerException_entry, G3_scratch, ok);
3650   }
3651 
3652   assert(O0 == Otos_i, "Be sure where the object to lock is");
3653 
3654   // find a free slot in the monitor block
3655 
3656 
3657   // initialize entry pointer
3658   __ clr(O1); // points to free slot or NULL
3659 
3660   {
3661     Label entry, loop, exit;
3662     __ add( __ top_most_monitor(), O2 ); // last one to check
3663     __ ba( entry );
3664     __ delayed()->mov( Lmonitors, O3 ); // first one to check
3665 
3666 
3667     __ bind( loop );
3668 
3669     __ verify_oop(O4);          // verify each monitor's oop
3670     __ tst(O4); // is this entry unused?
3671     __ movcc( Assembler::zero, false, Assembler::ptr_cc, O3, O1);
3672 
3673     __ cmp(O4, O0); // check if current entry is for same object
3674     __ brx( Assembler::equal, false, Assembler::pn, exit );
3675     __ delayed()->inc( O3, frame::interpreter_frame_monitor_size() * wordSize ); // check next one
3676 
3677     __ bind( entry );
3678 
3679     __ cmp( O3, O2 );
3680     __ brx( Assembler::lessEqualUnsigned, true, Assembler::pt, loop );
3681     __ delayed()->ld_ptr(O3, BasicObjectLock::obj_offset_in_bytes(), O4);
3682 
3683     __ bind( exit );
3684   }
3685 
3686   { Label allocated;
3687 
3688     // found free slot?
3689     __ br_notnull_short(O1, Assembler::pn, allocated);
3690 
3691     __ add_monitor_to_stack( false, O2, O3 );
3692     __ mov(Lmonitors, O1);
3693 
3694     __ bind(allocated);
3695   }
3696 
3697   // Increment bcp to point to the next bytecode, so exception handling for async. exceptions work correctly.
3698   // The object has already been poped from the stack, so the expression stack looks correct.
3699   __ inc(Lbcp);
3700 
3701   __ st_ptr(O0, O1, BasicObjectLock::obj_offset_in_bytes()); // store object
3702   __ lock_object(O1, O0);
3703 
3704   // check if there's enough space on the stack for the monitors after locking
3705   __ generate_stack_overflow_check(0);
3706 
3707   // The bcp has already been incremented. Just need to dispatch to next instruction.
3708   __ dispatch_next(vtos);
3709 }
3710 
3711 
3712 void TemplateTable::monitorexit() {
3713   transition(atos, vtos);
3714   __ verify_oop(Otos_i);
3715   __ tst(Otos_i);
3716   __ throw_if_not_x( Assembler::notZero, Interpreter::_throw_NullPointerException_entry, G3_scratch );
3717 
3718   assert(O0 == Otos_i, "just checking");
3719 
3720   { Label entry, loop, found;
3721     __ add( __ top_most_monitor(), O2 ); // last one to check
3722     __ ba(entry);
3723     // use Lscratch to hold monitor elem to check, start with most recent monitor,
3724     // By using a local it survives the call to the C routine.
3725     __ delayed()->mov( Lmonitors, Lscratch );
3726 
3727     __ bind( loop );
3728 
3729     __ verify_oop(O4);          // verify each monitor's oop
3730     __ cmp(O4, O0); // check if current entry is for desired object
3731     __ brx( Assembler::equal, true, Assembler::pt, found );
3732     __ delayed()->mov(Lscratch, O1); // pass found entry as argument to monitorexit
3733 
3734     __ inc( Lscratch, frame::interpreter_frame_monitor_size() * wordSize ); // advance to next
3735 
3736     __ bind( entry );
3737 
3738     __ cmp( Lscratch, O2 );
3739     __ brx( Assembler::lessEqualUnsigned, true, Assembler::pt, loop );
3740     __ delayed()->ld_ptr(Lscratch, BasicObjectLock::obj_offset_in_bytes(), O4);
3741 
3742     call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_illegal_monitor_state_exception));
3743     __ should_not_reach_here();
3744 
3745     __ bind(found);
3746   }
3747   __ unlock_object(O1);
3748 }
3749 
3750 
3751 //----------------------------------------------------------------------------------------------------
3752 // Wide instructions
3753 
3754 void TemplateTable::wide() {
3755   transition(vtos, vtos);
3756   __ ldub(Lbcp, 1, G3_scratch);// get next bc
3757   __ sll(G3_scratch, LogBytesPerWord, G3_scratch);
3758   AddressLiteral ep(Interpreter::_wentry_point);
3759   __ set(ep, G4_scratch);
3760   __ ld_ptr(G4_scratch, G3_scratch, G3_scratch);
3761   __ jmp(G3_scratch, G0);
3762   __ delayed()->nop();
3763   // Note: the Lbcp increment step is part of the individual wide bytecode implementations
3764 }
3765 
3766 
3767 //----------------------------------------------------------------------------------------------------
3768 // Multi arrays
3769 
3770 void TemplateTable::multianewarray() {
3771   transition(vtos, atos);
3772      // put ndims * wordSize into Lscratch
3773   __ ldub( Lbcp,     3,               Lscratch);
3774   __ sll(  Lscratch, Interpreter::logStackElementSize, Lscratch);
3775      // Lesp points past last_dim, so set to O1 to first_dim address
3776   __ add(  Lesp,     Lscratch,        O1);
3777      call_VM(Otos_i, CAST_FROM_FN_PTR(address, InterpreterRuntime::multianewarray), O1);
3778   __ add(  Lesp,     Lscratch,        Lesp); // pop all dimensions off the stack
3779 }
3780 #endif /* !CC_INTERP */
--- EOF ---