jdk8-mips64-public/hotspot: src/cpu/mips/vm/stubGenerator_mips

src/cpu/mips/vm/stubGenerator_mips_64.cpp@4bfb40d1e17a (annotated)

src/cpu/mips/vm/stubGenerator_mips_64.cpp

Wed, 29 Mar 2017 09:41:51 +0800

author: aoqi
date: Wed, 29 Mar 2017 09:41:51 +0800
changeset 392: 4bfb40d1e17a
parent 373: 3a34fc828b4a
child 401: 721a83ed5111
permissions: -rw-r--r--

#4662 TieredCompilation is turned off.
TieredCompilation is not supported yet.

 /*
  * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2015, 2016, Loongson Technology. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  *
  */
 #include "precompiled.hpp"
 #include "asm/macroAssembler.hpp"
 #include "asm/macroAssembler.inline.hpp"
 #include "interpreter/interpreter.hpp"
 #include "nativeInst_mips.hpp"
 #include "oops/instanceOop.hpp"
 #include "oops/method.hpp"
 #include "oops/objArrayKlass.hpp"
 #include "oops/oop.inline.hpp"
 #include "prims/methodHandles.hpp"
 #include "runtime/frame.inline.hpp"
 #include "runtime/handles.inline.hpp"
 #include "runtime/sharedRuntime.hpp"
 #include "runtime/stubCodeGenerator.hpp"
 #include "runtime/stubRoutines.hpp"
 #include "runtime/thread.inline.hpp"
 #include "utilities/top.hpp"
 #ifdef COMPILER2
 #include "opto/runtime.hpp"
 #endif
 // Declaration and definition of StubGenerator (no .hpp file).
 // For a more detailed description of the stub routine structure
 // see the comment in stubRoutines.hpp
 #define __ _masm->
 //#define TIMES_OOP (UseCompressedOops ? Address::times_4 : Address::times_8)
 //#define a__ ((Assembler*)_masm)->
 //#ifdef PRODUCT
 //#define BLOCK_COMMENT(str) /* nothing */
 //#else
 //#define BLOCK_COMMENT(str) __ block_comment(str)
 //#endif
 //#define BIND(label) bind(label); BLOCK_COMMENT(#label ":")
 const int MXCSR_MASK = 0xFFC0;  // Mask out any pending exceptions
 // Stub Code definitions
 static address handle_unsafe_access() {
   JavaThread* thread = JavaThread::current();
   address pc = thread->saved_exception_pc();
   // pc is the instruction which we must emulate
   // doing a no-op is fine:  return garbage from the load
   // therefore, compute npc
   //address npc = Assembler::locate_next_instruction(pc);
 	address npc = (address)((unsigned long)pc + sizeof(unsigned long));
   // request an async exception
   thread->set_pending_unsafe_access_error();
   // return address of next instruction to execute
   return npc;
 }
 class StubGenerator: public StubCodeGenerator {
  private:
   // ABI mips n64
   // This fig is not MIPS ABI. It is call Java from C ABI.
   // Call stubs are used to call Java from C
   //
   //    [ return_from_Java     ]
   //    [ argument word n-1    ] <--- sp
   //      ...
   //    [ argument word 0      ]
   //      ...
   //-10 [ S6     	       ]
   // -9 [ S5		       ]
   // -8 [ S4		       ]
   // -7 [ S3                   ]
   // -6 [ S0  		       ]
   // -5 [ TSR(S2)	       ]
   // -4 [ LVP(S7)              ]
   // -3 [ BCP(S1)              ]
   // -2 [ saved fp             ] <--- fp_after_call
   // -1 [ return address       ]
   //  0 [ ptr. to call wrapper ] <--- a0 (old sp -->)fp
   //  1 [ result               ] <--- a1
   //  2 [ result_type          ] <--- a2
   //  3 [ method               ] <--- a3
   //  4 [ entry_point          ] <--- a4
   //  5 [ parameters           ] <--- a5
   //  6 [ parameter_size       ] <--- a6
   //  7 [ thread               ] <--- a7
   //
   // _LP64: n64 does not save paras in sp.
   //
   //    [ return_from_Java     ]
   //    [ argument word n-1    ] <--- sp
   //      ...
   //    [ argument word 0      ]
   //      ...
   //-14 [ thread               ]
   //-13 [ result_type          ] <--- a2
   //-12 [ result               ] <--- a1
   //-11 [ ptr. to call wrapper ] <--- a0
   //-10 [ S6     	       ]
   // -9 [ S5		       ]
   // -8 [ S4		       ]
   // -7 [ S3                   ]
   // -6 [ S0  		       ]
   // -5 [ TSR(S2)	       ]
   // -4 [ LVP(S7)              ]
   // -3 [ BCP(S1)              ]
   // -2 [ saved fp             ] <--- fp_after_call
   // -1 [ return address       ]
   //  0 [        	       ] <--- old sp
   /*
    * 2014/01/16 Fu: Find a right place in the call_stub for GP.
    * GP will point to the starting point of Interpreter::dispatch_table(itos).
    * It should be saved/restored before/after Java calls.
    *
    */
    enum call_stub_layout {
      RA_off		  = -1,
      FP_off		  = -2,
      BCP_off		  = -3,
      LVP_off		  = -4,
      TSR_off		  = -5,
      S1_off		  = -6,
      S3_off		  = -7,
      S4_off		  = -8,
      S5_off		  = -9,
      S6_off		  = -10,
      result_off		  = -11,
      result_type_off	  = -12,
      thread_off		  = -13,
      total_off		  = thread_off - 3,
      GP_off               = -16,
    };
   address generate_call_stub(address& return_address) {
     StubCodeMark mark(this, "StubRoutines", "call_stub");
     address start = __ pc();
     // same as in generate_catch_exception()!
     // stub code
     // save ra and fp
     __ sd(RA, SP, RA_off * wordSize);
     __ sd(FP, SP, FP_off * wordSize);
     __ sd(BCP, SP, BCP_off * wordSize);
     __ sd(LVP, SP, LVP_off * wordSize);
     __ sd(GP, SP, GP_off * wordSize);
     __ sd(TSR, SP, TSR_off * wordSize);
     __ sd(S1, SP, S1_off * wordSize);
     __ sd(S3, SP, S3_off * wordSize);
     __ sd(S4, SP, S4_off * wordSize);
     __ sd(S5, SP, S5_off * wordSize);
     __ sd(S6, SP, S6_off * wordSize);
     __ set64(GP, (long)Interpreter::dispatch_table(itos));
     // I think 14 is the max gap between argument and callee saved register
     __ daddi(FP, SP, (-2) * wordSize);
     __ daddi(SP, SP, total_off * wordSize);
 //FIXME, aoqi. find a suitable place to save A1 & A2.
     /*
     __ sd(A0, FP, frame::entry_frame_call_wrapper_offset * wordSize);
     __ sd(A1, FP, 3 * wordSize);
     __ sd(A2, FP, 4 * wordSize);
     __ sd(A3, FP, 5 * wordSize);
     __ sd(A4, FP, 6 * wordSize);
     __ sd(A5, FP, 7 * wordSize);
     __ sd(A6, FP, 8 * wordSize);
     __ sd(A7, FP, 9 * wordSize);
     */
     __ sd(A0, FP, frame::entry_frame_call_wrapper_offset * wordSize);
     __ sd(A1, FP, result_off * wordSize);
     __ sd(A2, FP, result_type_off * wordSize);
     __ sd(A7, FP, thread_off * wordSize);
 #ifdef OPT_THREAD
     //__ get_thread(TREG);
     __ move(TREG, A7);
     //__ ld(TREG, FP, thread_off * wordSize);
 #endif
     //add for compressedoops
     __ reinit_heapbase();
 #ifdef ASSERT
     // make sure we have no pending exceptions
     {
       Label L;
     	__ ld(AT, A7, in_bytes(Thread::pending_exception_offset()));
     	__ beq(AT, R0, L);
     	__ delayed()->nop();
     	/* FIXME: I do not know how to realize stop in mips arch, do it in the future */
     	__ stop("StubRoutines::call_stub: entered with pending exception");
     	__ bind(L);
     }
 #endif
     // pass parameters if any
     // A5: parameter
     // A6: parameter_size
     // T0: parameter_size_tmp(--)
     // T2: offset(++)
     // T3: tmp
     Label parameters_done;
     // judge if the parameter_size equals 0
     __ beq(A6, R0, parameters_done);
     __ delayed()->nop();
     __ dsll(AT, A6, Interpreter::logStackElementSize);
     __ dsub(SP, SP, AT);
     __ move(AT, -StackAlignmentInBytes);
     __ andr(SP, SP , AT);
     // Copy Java parameters in reverse order (receiver last)
     // Note that the argument order is inverted in the process
     // source is edx[ecx: N-1..0]
     // dest   is esp[ebx: 0..N-1]
     Label loop;
     __ move(T0, A6);
     __ move(T2, R0);
     __ bind(loop);
     // get parameter
     __ dsll(T3, T0, LogBytesPerWord);
     __ dadd(T3, T3, A5);
     __ ld(AT, T3,  -wordSize);
     __ dsll(T3, T2, LogBytesPerWord);
     __ dadd(T3, T3, SP);
     __ sd(AT, T3, Interpreter::expr_offset_in_bytes(0));
     __ daddi(T2, T2, 1);
     __ daddi(T0, T0, -1);
     __ bne(T0, R0, loop);
     __ delayed()->nop();
     // advance to next parameter
     // call Java function
     __ bind(parameters_done);
     // receiver in V0, methodOop in Rmethod
     __ move(Rmethod, A3);
     __ move(Rsender, SP);             //set sender sp
     __ jalr(A4);
     __ delayed()->nop();
     return_address = __ pc();
     Label common_return;
     __ bind(common_return);
     // store result depending on type
     // (everything that is not T_LONG, T_FLOAT or T_DOUBLE is treated as T_INT)
     __ ld(T0, FP, result_off * wordSize); 	// result --> T0
     Label is_long, is_float, is_double, exit;
     __ ld(T2, FP, result_type_off * wordSize);	// result_type --> T2
     __ daddi(T3, T2, (-1) * T_LONG);
     __ beq(T3, R0, is_long);
     __ delayed()->daddi(T3, T2, (-1) * T_FLOAT);
     __ beq(T3, R0, is_float);
     __ delayed()->daddi(T3, T2, (-1) * T_DOUBLE);
     __ beq(T3, R0, is_double);
     __ delayed()->nop();
     // handle T_INT case
     __ sd(V0, T0, 0 * wordSize);
     __ bind(exit);
     // restore
     __ daddi(SP, FP, 2 * wordSize );
     __ ld(RA, SP, RA_off * wordSize);
     __ ld(FP, SP, FP_off * wordSize);
     __ ld(BCP, SP, BCP_off * wordSize);
     __ ld(LVP, SP, LVP_off * wordSize);
     __ ld(GP, SP, GP_off * wordSize);
     __ ld(TSR, SP, TSR_off * wordSize);
     __ ld(S1, SP, S1_off * wordSize);
     __ ld(S3, SP, S3_off * wordSize);
     __ ld(S4, SP, S4_off * wordSize);
     __ ld(S5, SP, S5_off * wordSize);
     __ ld(S6, SP, S6_off * wordSize);
     // return
     __ jr(RA);
     __ delayed()->nop();
     // handle return types different from T_INT
     __ bind(is_long);
     __ sd(V0, T0, 0 * wordSize);
     //__ sd(V1, T0, 1 * wordSize);
     //__ sd(R0, T0, 1 * wordSize);
     __ b(exit);
     __ delayed()->nop();
     __ bind(is_float);
     __ swc1(F0, T0, 0 * wordSize);
     __ b(exit);
     __ delayed()->nop();
     __ bind(is_double);
     __ sdc1(F0, T0, 0 * wordSize);
     //__ sdc1(F1, T0, 1 * wordSize);
     //__ sd(R0, T0, 1 * wordSize);
     __ b(exit);
     __ delayed()->nop();
     //FIXME, 1.6 mips version add operation of fpu here
     StubRoutines::gs2::set_call_stub_compiled_return(__ pc());
     __ b(common_return);
     __ delayed()->nop();
     return start;
   }
   // Return point for a Java call if there's an exception thrown in
   // Java code.  The exception is caught and transformed into a
   // pending exception stored in JavaThread that can be tested from
   // within the VM.
   //
   // Note: Usually the parameters are removed by the callee. In case
   // of an exception crossing an activation frame boundary, that is
   // not the case if the callee is compiled code => need to setup the
   // rsp.
   //
   // rax: exception oop
   address generate_catch_exception() {
     StubCodeMark mark(this, "StubRoutines", "catch_exception");
     address start = __ pc();
     Register thread = TREG;
     // get thread directly
 #ifndef OPT_THREAD
     __ ld(thread, FP, thread_off * wordSize);
 #endif
 #ifdef ASSERT
     // verify that threads correspond
     { Label L;
       __ get_thread(T8);
       __ beq(T8, thread, L);
       __ delayed()->nop();
       __ stop("StubRoutines::catch_exception: threads must correspond");
       __ bind(L);
     }
 #endif
     // set pending exception
     __ verify_oop(V0);
     __ sd(V0, thread, in_bytes(Thread::pending_exception_offset()));
     __ li(AT, (long)__FILE__);
     __ sd(AT, thread, in_bytes(Thread::exception_file_offset   ()));
     __ li(AT, (long)__LINE__);
     __ sd(AT, thread, in_bytes(Thread::exception_line_offset   ()));
     // complete return to VM
     assert(StubRoutines::_call_stub_return_address != NULL, "_call_stub_return_address must have been generated before");
     __ jmp(StubRoutines::_call_stub_return_address, relocInfo::none);
     __ delayed()->nop();
     return start;
   }
   // Continuation point for runtime calls returning with a pending
   // exception.  The pending exception check happened in the runtime
   // or native call stub.  The pending exception in Thread is
   // converted into a Java-level exception.
   //
   // Contract with Java-level exception handlers:
   // rax: exception
   // rdx: throwing pc
   //
   // NOTE: At entry of this stub, exception-pc must be on stack !!
   address generate_forward_exception() {
     StubCodeMark mark(this, "StubRoutines", "forward exception");
     //Register thread = TREG;
     Register thread = TREG;
     address start = __ pc();
     // Upon entry, the sp points to the return address returning into Java
     // (interpreted or compiled) code; i.e., the return address becomes the
     // throwing pc.
     //
     // Arguments pushed before the runtime call are still on the stack but
     // the exception handler will reset the stack pointer -> ignore them.
     // A potential result in registers can be ignored as well.
 #ifdef ASSERT
     // make sure this code is only executed if there is a pending exception
 #ifndef OPT_THREAD
     __ get_thread(thread);
 #endif
     { Label L;
       __ ld(AT, thread, in_bytes(Thread::pending_exception_offset()));
       __ bne(AT, R0, L);
       __ delayed()->nop();
       __ stop("StubRoutines::forward exception: no pending exception (1)");
       __ bind(L);
     }
 #endif
     // compute exception handler into T9
     __ ld(A1, SP, 0);
     __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::exception_handler_for_return_address), thread, A1);
     __ move(T9, V0);
     __ pop(V1);
 #ifndef OPT_THREAD
     __ get_thread(thread);
 #endif
     __ ld(V0, thread, in_bytes(Thread::pending_exception_offset()));
     __ sd(R0, thread, in_bytes(Thread::pending_exception_offset()));
 #ifdef ASSERT
     // make sure exception is set
     { Label L;
       __ bne(V0, R0, L);
       __ delayed()->nop();
       __ stop("StubRoutines::forward exception: no pending exception (2)");
       __ bind(L);
     }
 #endif
     // continue at exception handler (return address removed)
     // V0: exception
     // T9: exception handler
     // V1: throwing pc
     __ verify_oop(V0);
     __ jr(T9);
     __ delayed()->nop();
     return start;
   }
   // Support for intptr_t get_previous_fp()
   //
   // This routine is used to find the previous frame pointer for the
   // caller (current_frame_guess). This is used as part of debugging
   // ps() is seemingly lost trying to find frames.
   // This code assumes that caller current_frame_guess) has a frame.
   address generate_get_previous_fp() {
     StubCodeMark mark(this, "StubRoutines", "get_previous_fp");
     const Address old_fp       (FP,  0);
     const Address older_fp       (V0,  0);
     address start = __ pc();
     __ enter();
     __ lw(V0, old_fp); // callers fp
     __ lw(V0, older_fp); // the frame for ps()
     __ leave();
     __ jr(RA);
     __ delayed()->nop();
     return start;
   }
   // The following routine generates a subroutine to throw an
   // asynchronous UnknownError when an unsafe access gets a fault that
   // could not be reasonably prevented by the programmer.  (Example:
   // SIGBUS/OBJERR.)
   address generate_handler_for_unsafe_access() {
 		StubCodeMark mark(this, "StubRoutines", "handler_for_unsafe_access");
 		address start = __ pc();
 		__ pushad();                      // push registers
 		//  Address next_pc(esp, RegisterImpl::number_of_registers * BytesPerWord);
 		__ call(CAST_FROM_FN_PTR(address, handle_unsafe_access), relocInfo::runtime_call_type);
 		__ delayed()->nop();
 		__ sw(V0, SP, RegisterImpl::number_of_registers * BytesPerWord);
 		__ popad();
 		__ jr(RA);
 		__ delayed()->nop();
 		return start;
   }
   // Non-destructive plausibility checks for oops
   //
   // Arguments:
   //    all args on stack!
   //
   // Stack after saving c_rarg3:
   //    [tos + 0]: saved c_rarg3
   //    [tos + 1]: saved c_rarg2
   //    [tos + 2]: saved r12 (several TemplateTable methods use it)
   //    [tos + 3]: saved flags
   //    [tos + 4]: return address
   //  * [tos + 5]: error message (char*)
   //  * [tos + 6]: object to verify (oop)
   //  * [tos + 7]: saved rax - saved by caller and bashed
   //  * = popped on exit
   address generate_verify_oop() {
 	  StubCodeMark mark(this, "StubRoutines", "verify_oop");
 	  address start = __ pc();
 	  __ reinit_heapbase();
 	  __ verify_oop_subroutine();
     address end = __ pc();
 	  return start;
   }
   //
   //  Generate overlap test for array copy stubs
   //
   //  Input:
   //     A0    -  array1
   //     A1    -  array2
   //     A2    -  element count
   //
   //  Note: this code can only use %eax, %ecx, and %edx
   //
  // use T9 as temp
   void array_overlap_test(address no_overlap_target, int log2_elem_size) {
     int elem_size = 1 << log2_elem_size;
     Address::ScaleFactor sf = Address::times_1;
     switch (log2_elem_size) {
       case 0: sf = Address::times_1; break;
       case 1: sf = Address::times_2; break;
       case 2: sf = Address::times_4; break;
       case 3: sf = Address::times_8; break;
     }
     __ dsll(AT, A2, sf);
     __ dadd(AT, AT, A0);
     __ lea(T9, Address(AT, -elem_size));
     __ dsub(AT, A1, A0);
     __ blez(AT, no_overlap_target);
     __ delayed()->nop();
     __ dsub(AT, A1, T9);
     __ bgtz(AT, no_overlap_target);
     __ delayed()->nop();
     // 2016/05/10 aoqi: If A0 = 0xf... and A1 = 0x0..., than goto no_overlap_target
     Label L;
     __ bgez(A0, L);
     __ delayed()->nop();
     __ bgtz(A1, no_overlap_target);
     __ delayed()->nop();
     __ bind(L);
   }
   //
   //  Generate store check for array
   //
   //  Input:
   //     T0    -  starting address(edi)
   //     T1    -  element count  (ecx)
   //
   //  The 2 input registers are overwritten
   //
 #define TIMES_OOP (UseCompressedOops ? Address::times_4 : Address::times_8)
 	void array_store_check() {
 		BarrierSet* bs = Universe::heap()->barrier_set();
 		assert(bs->kind() == BarrierSet::CardTableModRef, "Wrong barrier set kind");
 		CardTableModRefBS* ct = (CardTableModRefBS*)bs;
 		assert(sizeof(*ct->byte_map_base) == sizeof(jbyte), "adjust this code");
 		Label l_0;
 		__ dsll(AT, T1, TIMES_OOP);
 		__ dadd(AT, T0, AT);
 		__ daddiu(T1, AT, - BytesPerHeapOop);
 		__ shr(T0, CardTableModRefBS::card_shift);
 		__ shr(T1, CardTableModRefBS::card_shift);
 		__ dsub(T1, T1, T0);   // end --> cards count
 		__ bind(l_0);
 		__ set64(AT, (long)ct->byte_map_base);
 		__ dadd(AT, AT, T0);
 		__ dadd(AT, AT, T1);
 		__ sb(R0, AT, 0);
                 __ sync();
 		__ bgez(T1, l_0);
 		__ delayed()->daddi(T1, T1, - 1);
 	}
   // Arguments:
   //   aligned - true => Input and output aligned on a HeapWord == 8-byte boundary
   //             ignored
   //   name    - stub name string
   //
   // Inputs:
   //   c_rarg0   - source array address
   //   c_rarg1   - destination array address
   //   c_rarg2   - element count, treated as ssize_t, can be zero
   //
   // If 'from' and/or 'to' are aligned on 4-, 2-, or 1-byte boundaries,
   // we let the hardware handle it.  The one to eight bytes within words,
   // dwords or qwords that span cache line boundaries will still be loaded
   // and stored atomically.
   //
   // Side Effects:
   //   disjoint_byte_copy_entry is set to the no-overlap entry point
   //   used by generate_conjoint_byte_copy().
   //
   address generate_disjoint_byte_copy(bool aligned, const char * name) {
     StubCodeMark mark(this, "StubRoutines", name);
     __ align(CodeEntryAlignment);
     Register tmp1 = T0;
     Register tmp2 = T1;
     Register tmp3 = T3;
     address start = __ pc();
     __ push(tmp1);
     __ push(tmp2);
     __ push(tmp3);
     __ move(tmp1, A0);
     __ move(tmp2, A1);
     __ move(tmp3, A2);
     Label l_1, l_2, l_3, l_4, l_5, l_6, l_7, l_8, l_9, l_10, l_11;
     Label l_debug;
     __ daddi(AT, tmp3, -9); //why the number is 9 ?
     __ blez(AT, l_9);
     __ delayed()->nop();
     if (!aligned) {
       __ xorr(AT, tmp1, tmp2);
       __ andi(AT, AT, 1);
       __ bne(AT, R0, l_9); // if arrays don't have the same alignment mod 2, do 1 element copy
       __ delayed()->nop();
       __ andi(AT, tmp1, 1);
       __ beq(AT, R0, l_10); //copy 1 enlement if necessary to aligh to 2 bytes
       __ delayed()->nop();
       __ lb(AT, tmp1, 0);
       __ daddi(tmp1, tmp1, 1);
       __ sb(AT, tmp2, 0);
       __ daddi(tmp2, tmp2, 1);
       __ daddi(tmp3, tmp3, -1);
       __ bind(l_10);
       __ xorr(AT, tmp1, tmp2);
       __ andi(AT, AT, 3);
       __ bne(AT, R0, l_1); // if arrays don't have the same alignment mod 4, do 2 elements copy
       __ delayed()->nop();
       // At this point it is guaranteed that both, from and to have the same alignment mod 4.
       // Copy 2 elements if necessary to align to 4 bytes.
       __ andi(AT, tmp1, 3);
       __ beq(AT, R0, l_2);
       __ delayed()->nop();
       __ lhu(AT, tmp1, 0);
       __ daddi(tmp1, tmp1, 2);
       __ sh(AT, tmp2, 0);
       __ daddi(tmp2, tmp2, 2);
       __ daddi(tmp3, tmp3, -2);
       __ bind(l_2);
       // At this point the positions of both, from and to, are at least 4 byte aligned.
       // Copy 4 elements at a time.
       // Align to 8 bytes, but only if both, from and to, have same alignment mod 8.
       __ xorr(AT, tmp1, tmp2);
       __ andi(AT, AT, 7);
       __ bne(AT, R0, l_6); // not same alignment mod 8 -> copy 2, either from or to will be unaligned
       __ delayed()->nop();
       // Copy a 4 elements if necessary to align to 8 bytes.
       __ andi(AT, tmp1, 7);
       __ beq(AT, R0, l_7);
       __ delayed()->nop();
       __ lw(AT, tmp1, 0);
       __ daddi(tmp3, tmp3, -4);
       __ sw(AT, tmp2, 0);
       { // FasterArrayCopy
         __ daddi(tmp1, tmp1, 4);
         __ daddi(tmp2, tmp2, 4);
       }
     }
     __ bind(l_7);
     // Copy 4 elements at a time; either the loads or the stores can
     // be unaligned if aligned == false.
     { // FasterArrayCopy
       __ daddi(AT, tmp3, -7);
       __ blez(AT, l_6); // copy 4 at a time if less than 4 elements remain
       __ delayed()->nop();
       __ bind(l_8);
       // For Loongson, there is 128-bit memory access. TODO
       __ ld(AT, tmp1, 0);
       __ sd(AT, tmp2, 0);
       __ daddi(tmp1, tmp1, 8);
       __ daddi(tmp2, tmp2, 8);
       __ daddi(tmp3, tmp3, -8);
       __ daddi(AT, tmp3, -8);
       __ bgez(AT, l_8);
       __ delayed()->nop();
     }
     __ bind(l_6);
     // copy 4 bytes at a time
     { // FasterArrayCopy
       __ daddi(AT, tmp3, -3);
       __ blez(AT, l_1);
       __ delayed()->nop();
       __ bind(l_3);
       __ lw(AT, tmp1, 0);
       __ sw(AT, tmp2, 0);
       __ daddi(tmp1, tmp1, 4);
       __ daddi(tmp2, tmp2, 4);
       __ daddi(tmp3, tmp3, -4);
       __ daddi(AT, tmp3, -4);
       __ bgez(AT, l_3);
       __ delayed()->nop();
     }
     // do 2 bytes copy
     __ bind(l_1);
     {
       __ daddi(AT, tmp3, -1);
       __ blez(AT, l_9);
       __ delayed()->nop();
       __ bind(l_5);
       __ lhu(AT, tmp1, 0);
       __ daddi(tmp3, tmp3, -2);
       __ sh(AT, tmp2, 0);
       __ daddi(tmp1, tmp1, 2);
       __ daddi(tmp2, tmp2, 2);
       __ daddi(AT, tmp3, -2);
       __ bgez(AT, l_5);
       __ delayed()->nop();
     }
     //do 1 element copy--byte
     __ bind(l_9);
     __ beq(R0, tmp3, l_4);
     __ delayed()->nop();
     {
       __ bind(l_11);
       __ lb(AT, tmp1, 0);
       __ daddi(tmp3, tmp3, -1);
       __ sb(AT, tmp2, 0);
       __ daddi(tmp1, tmp1, 1);
       __ daddi(tmp2, tmp2, 1);
       __ daddi(AT, tmp3, -1);
       __ bgez(AT, l_11);
       __ delayed()->nop();
     }
     __ bind(l_4);
     __ pop(tmp3);
     __ pop(tmp2);
     __ pop(tmp1);
     __ jr(RA);
     __ delayed()->nop();
     return start;
   }
   // Arguments:
   //   aligned - true => Input and output aligned on a HeapWord == 8-byte boundary
   //             ignored
   //   name    - stub name string
   //
   // Inputs:
   //   A0   - source array address
   //   A1   - destination array address
   //   A2   - element count, treated as ssize_t, can be zero
   //
   // If 'from' and/or 'to' are aligned on 4-, 2-, or 1-byte boundaries,
   // we let the hardware handle it.  The one to eight bytes within words,
   // dwords or qwords that span cache line boundaries will still be loaded
   // and stored atomically.
   //
   address generate_conjoint_byte_copy(bool aligned, const char *name) {
     __ align(CodeEntryAlignment);
     StubCodeMark mark(this, "StubRoutines", name);
     address start = __ pc();
     Label l_copy_4_bytes_loop, l_copy_suffix, l_copy_suffix_loop, l_exit;
     Label l_copy_byte, l_from_unaligned, l_unaligned, l_4_bytes_aligned;
     address nooverlap_target = aligned ?
 	    StubRoutines::arrayof_jbyte_disjoint_arraycopy() :
 	    StubRoutines::jbyte_disjoint_arraycopy();
     array_overlap_test(nooverlap_target, 0);
     const Register from      = A0;   // source array address
     const Register to        = A1;   // destination array address
     const Register count     = A2;   // elements count
     const Register end_from  = T3;   // source array end address
     const Register end_to    = T0;   // destination array end address
     const Register end_count = T1;   // destination array end address
     __ push(end_from);
     __ push(end_to);
     __ push(end_count);
     __ push(T8);
     // copy from high to low
     __ move(end_count, count);
     __ dadd(end_from, from, end_count);
     __ dadd(end_to, to, end_count);
     // 2016/05/08 aoqi: If end_from and end_to has differante alignment, unaligned copy is performed.
     __ andi(AT, end_from, 3);
     __ andi(T8, end_to, 3);
     __ bne(AT, T8, l_copy_byte);
     __ delayed()->nop();
     // First deal with the unaligned data at the top.
     __ bind(l_unaligned);
     __ beq(end_count, R0, l_exit);
     __ delayed()->nop();
     __ andi(AT, end_from, 3);
     __ bne(AT, R0, l_from_unaligned);
     __ delayed()->nop();
     __ andi(AT, end_to, 3);
     __ beq(AT, R0, l_4_bytes_aligned);
     __ delayed()->nop();
     __ bind(l_from_unaligned);
     __ lb(AT, end_from, -1);
     __ sb(AT, end_to, -1);
     __ daddi(end_from, end_from, -1);
     __ daddi(end_to, end_to, -1);
     __ daddi(end_count, end_count, -1);
     __ b(l_unaligned);
     __ delayed()->nop();
     // now end_to, end_from point to 4-byte aligned high-ends
     //     end_count contains byte count that is not copied.
     // copy 4 bytes at a time
     __ bind(l_4_bytes_aligned);
     __ move(T8, end_count);
     __ daddi(AT, end_count, -3);
     __ blez(AT, l_copy_suffix);
     __ delayed()->nop();
     //__ andi(T8, T8, 3);
     __ lea(end_from, Address(end_from, -4));
     __ lea(end_to, Address(end_to, -4));
     __ dsrl(end_count, end_count, 2);
     __ align(16);
     __ bind(l_copy_4_bytes_loop); //l_copy_4_bytes
     __ lw(AT, end_from, 0);
     __ sw(AT, end_to, 0);
     __ addi(end_from, end_from, -4);
     __ addi(end_to, end_to, -4);
     __ addi(end_count, end_count, -1);
     __ bne(end_count, R0, l_copy_4_bytes_loop);
     __ delayed()->nop();
     __ b(l_copy_suffix);
     __ delayed()->nop();
     // copy dwords aligned or not with repeat move
     // l_copy_suffix
     // copy suffix (0-3 bytes)
     __ bind(l_copy_suffix);
     __ andi(T8, T8, 3);
     __ beq(T8, R0, l_exit);
     __ delayed()->nop();
     __ addi(end_from, end_from, 3);
     __ addi(end_to, end_to, 3);
     __ bind(l_copy_suffix_loop);
     __ lb(AT, end_from, 0);
     __ sb(AT, end_to, 0);
     __ addi(end_from, end_from, -1);
     __ addi(end_to, end_to, -1);
     __ addi(T8, T8, -1);
     __ bne(T8, R0, l_copy_suffix_loop);
     __ delayed()->nop();
     __ bind(l_copy_byte);
     __ beq(end_count, R0, l_exit);
     __ delayed()->nop();
     __ lb(AT, end_from, -1);
     __ sb(AT, end_to, -1);
     __ daddi(end_from, end_from, -1);
     __ daddi(end_to, end_to, -1);
     __ daddi(end_count, end_count, -1);
     __ b(l_copy_byte);
     __ delayed()->nop();
     __ bind(l_exit);
     __ pop(T8);
     __ pop(end_count);
     __ pop(end_to);
     __ pop(end_from);
     __ jr(RA);
     __ delayed()->nop();
     return start;
   }
   // Generate stub for disjoint short copy.  If "aligned" is true, the
   // "from" and "to" addresses are assumed to be heapword aligned.
   //
   // Arguments for generated stub:
   //      from:  A0
   //      to:    A1
   //  elm.count: A2 treated as signed
   //  one element: 2 bytes
   //
   // Strategy for aligned==true:
   //
   //  If length <= 9:
   //     1. copy 1 elements at a time (l_5)
   //
   //  If length > 9:
   //     1. copy 4 elements at a time until less than 4 elements are left (l_7)
   //     2. copy 2 elements at a time until less than 2 elements are left (l_6)
   //     3. copy last element if one was left in step 2. (l_1)
   //
   //
   // Strategy for aligned==false:
   //
   //  If length <= 9: same as aligned==true case
   //
   //  If length > 9:
   //     1. continue with step 7. if the alignment of from and to mod 4
   //        is different.
   //     2. align from and to to 4 bytes by copying 1 element if necessary
   //     3. at l_2 from and to are 4 byte aligned; continue with
   //        6. if they cannot be aligned to 8 bytes because they have
   //        got different alignment mod 8.
   //     4. at this point we know that both, from and to, have the same
   //        alignment mod 8, now copy one element if necessary to get
   //        8 byte alignment of from and to.
   //     5. copy 4 elements at a time until less than 4 elements are
   //        left; depending on step 3. all load/stores are aligned.
   //     6. copy 2 elements at a time until less than 2 elements are
   //        left. (l_6)
   //     7. copy 1 element at a time. (l_5)
   //     8. copy last element if one was left in step 6. (l_1)
   address generate_disjoint_short_copy(bool aligned, const char * name) {
     StubCodeMark mark(this, "StubRoutines", name);
     __ align(CodeEntryAlignment);
     Register tmp1 = T0;
     Register tmp2 = T1;
     Register tmp3 = T3;
     Register tmp4 = T8;
     Register tmp5 = T9;
     Register tmp6 = T2;
     address start = __ pc();
     __ push(tmp1);
     __ push(tmp2);
     __ push(tmp3);
     __ move(tmp1, A0);
     __ move(tmp2, A1);
     __ move(tmp3, A2);
     Label l_1, l_2, l_3, l_4, l_5, l_6, l_7, l_8, l_9, l_10, l_11, l_12, l_13, l_14;
     Label l_debug;
     // don't try anything fancy if arrays don't have many elements
     __ daddi(AT, tmp3, -23);
     __ blez(AT, l_14);
     __ delayed()->nop();
     // move push here
     __ push(tmp4);
     __ push(tmp5);
     __ push(tmp6);
     if (!aligned) {
       __ xorr(AT, A0, A1);
       __ andi(AT, AT, 1);
       __ bne(AT, R0, l_debug); // if arrays don't have the same alignment mod 2, can this happen?
       __ delayed()->nop();
       __ xorr(AT, A0, A1);
       __ andi(AT, AT, 3);
       __ bne(AT, R0, l_1); // if arrays don't have the same alignment mod 4, do 1 element copy
       __ delayed()->nop();
       // At this point it is guaranteed that both, from and to have the same alignment mod 4.
       // Copy 1 element if necessary to align to 4 bytes.
       __ andi(AT, A0, 3);
       __ beq(AT, R0, l_2);
       __ delayed()->nop();
       __ lhu(AT, tmp1, 0);
       __ daddi(tmp1, tmp1, 2);
       __ sh(AT, tmp2, 0);
       __ daddi(tmp2, tmp2, 2);
       __ daddi(tmp3, tmp3, -1);
       __ bind(l_2);
       // At this point the positions of both, from and to, are at least 4 byte aligned.
       // Copy 4 elements at a time.
       // Align to 8 bytes, but only if both, from and to, have same alignment mod 8.
       __ xorr(AT, tmp1, tmp2);
       __ andi(AT, AT, 7);
       __ bne(AT, R0, l_6); // not same alignment mod 8 -> copy 2, either from or to will be unaligned
       __ delayed()->nop();
       // Copy a 2-element word if necessary to align to 8 bytes.
       __ andi(AT, tmp1, 7);
       __ beq(AT, R0, l_7);
       __ delayed()->nop();
       __ lw(AT, tmp1, 0);
       __ daddi(tmp3, tmp3, -2);
       __ sw(AT, tmp2, 0);
       __ daddi(tmp1, tmp1, 4);
       __ daddi(tmp2, tmp2, 4);
     }// end of if (!aligned)
     __ bind(l_7);
     // At this time the position of both, from and to, are at least 8 byte aligned.
     // Copy 8 elemnets at a time.
     // Align to 16 bytes, but only if both from and to have same alignment mod 8.
     __ xorr(AT, tmp1, tmp2);
     __ andi(AT, AT, 15);
     __ bne(AT, R0, l_9);
     __ delayed()->nop();
     // Copy 4-element word if necessary to align to 16 bytes,
     __ andi(AT, tmp1, 15);
     __ beq(AT, R0, l_10);
     __ delayed()->nop();
     __ ld(AT, tmp1, 0);
     __ daddi(tmp3, tmp3, -4);
     __ sd(AT, tmp2, 0);
     __ daddi(tmp1, tmp1, 8);
     __ daddi(tmp2, tmp2, 8);
     __ bind(l_10);
     // Copy 8 elements at a time; either the loads or the stores can
     // be unalligned if aligned == false
     { // FasterArrayCopy
       __ bind(l_11);
       // For loongson the 128-bit memory access instruction is gslq/gssq
       if (UseLoongsonISA) {
         __ gslq(AT, tmp4, tmp1, 0);
         __ gslq(tmp5, tmp6, tmp1, 16);
         __ daddi(tmp1, tmp1, 32);
         __ daddi(tmp2, tmp2, 32);
         __ gssq(AT, tmp4, tmp2, -32);
         __ gssq(tmp5, tmp6, tmp2, -16);
       } else {
         __ ld(AT, tmp1, 0);
         __ ld(tmp4, tmp1, 8);
         __ ld(tmp5, tmp1, 16);
         __ ld(tmp6, tmp1, 24);
         __ daddi(tmp1, tmp1, 32);
         __ sd(AT, tmp2, 0);
         __ sd(tmp4, tmp2, 8);
         __ sd(tmp5, tmp2, 16);
         __ sd(tmp6, tmp2, 24);
         __ daddi(tmp2, tmp2, 32);
       }
       __ daddi(tmp3, tmp3, -16);
       __ daddi(AT, tmp3, -16);
       __ bgez(AT, l_11);
       __ delayed()->nop();
     }
     __ bind(l_9);
     // Copy 4 elements at a time; either the loads or the stores can
     // be unaligned if aligned == false.
     { // FasterArrayCopy
       __ daddi(AT, tmp3, -15);// loop unrolling 4 times, so if the elements should not be less than 16
       __ blez(AT, l_4); // copy 2 at a time if less than 16 elements remain
       __ delayed()->nop();
       __ bind(l_8);
       __ ld(AT, tmp1, 0);
       __ ld(tmp4, tmp1, 8);
       __ ld(tmp5, tmp1, 16);
       __ ld(tmp6, tmp1, 24);
       __ sd(AT, tmp2, 0);
       __ sd(tmp4, tmp2, 8);
       __ sd(tmp5, tmp2,16);
       __ daddi(tmp1, tmp1, 32);
       __ daddi(tmp2, tmp2, 32);
       __ daddi(tmp3, tmp3, -16);
       __ daddi(AT, tmp3, -16);
       __ bgez(AT, l_8);
       __ sd(tmp6, tmp2, -8);
     }
     __ bind(l_6);
     // copy 2 element at a time
     { // FasterArrayCopy
       __ daddi(AT, tmp3, -7);
       __ blez(AT, l_4);
       __ delayed()->nop();
       __ bind(l_3);
       __ lw(AT, tmp1, 0);
       __ lw(tmp4, tmp1, 4);
       __ lw(tmp5, tmp1, 8);
       __ lw(tmp6, tmp1, 12);
       __ sw(AT, tmp2, 0);
       __ sw(tmp4, tmp2, 4);
       __ sw(tmp5, tmp2, 8);
       __ daddi(tmp1, tmp1, 16);
       __ daddi(tmp2, tmp2, 16);
       __ daddi(tmp3, tmp3, -8);
       __ daddi(AT, tmp3, -8);
       __ bgez(AT, l_3);
       __ sw(tmp6, tmp2, -4);
     }
     __ bind(l_1);
     // do single element copy (8 bit), can this happen?
     { // FasterArrayCopy
       __ daddi(AT, tmp3, -3);
       __ blez(AT, l_4);
       __ delayed()->nop();
       __ bind(l_5);
       __ lhu(AT, tmp1, 0);
       __ lhu(tmp4, tmp1, 2);
       __ lhu(tmp5, tmp1, 4);
       __ lhu(tmp6, tmp1, 6);
       __ sh(AT, tmp2, 0);
       __ sh(tmp4, tmp2, 2);
       __ sh(tmp5, tmp2, 4);
       __ daddi(tmp1, tmp1, 8);
       __ daddi(tmp2, tmp2, 8);
       __ daddi(tmp3, tmp3, -4);
       __ daddi(AT, tmp3, -4);
       __ bgez(AT, l_5);
       __ sh(tmp6, tmp2, -2);
     }
     // single element
     __ bind(l_4);
     __ pop(tmp6);
     __ pop(tmp5);
     __ pop(tmp4);
     __ bind(l_14);
     { // FasterArrayCopy
       __ beq(R0, tmp3, l_13);
       __ delayed()->nop();
       __ bind(l_12);
       __ lhu(AT, tmp1, 0);
       __ sh(AT, tmp2, 0);
       __ daddi(tmp1, tmp1, 2);
       __ daddi(tmp2, tmp2, 2);
       __ daddi(tmp3, tmp3, -1);
       __ daddi(AT, tmp3, -1);
       __ bgez(AT, l_12);
       __ delayed()->nop();
     }
     __ bind(l_13);
     __ pop(tmp3);
     __ pop(tmp2);
     __ pop(tmp1);
     __ jr(RA);
     __ delayed()->nop();
     __ bind(l_debug);
     __ stop("generate_disjoint_short_copy should not reach here");
     return start;
   }
   // Arguments:
   //   aligned - true => Input and output aligned on a HeapWord == 8-byte boundary
   //             ignored
   //   name    - stub name string
   //
   // Inputs:
   //   c_rarg0   - source array address
   //   c_rarg1   - destination array address
   //   c_rarg2   - element count, treated as ssize_t, can be zero
   //
   // If 'from' and/or 'to' are aligned on 4- or 2-byte boundaries, we
   // let the hardware handle it.  The two or four words within dwords
   // or qwords that span cache line boundaries will still be loaded
   // and stored atomically.
   //
   address generate_conjoint_short_copy(bool aligned, const char *name) {
 		Label l_1, l_2, l_3, l_4, l_5;
 		StubCodeMark mark(this, "StubRoutines", name);
 		__ align(CodeEntryAlignment);
 		address start = __ pc();
 		address nooverlap_target = aligned ?
 						StubRoutines::arrayof_jshort_disjoint_arraycopy() :
 						StubRoutines::jshort_disjoint_arraycopy();
 		array_overlap_test(nooverlap_target, 1);
 		__ push(T3);
 		__ push(T0);
 		__ push(T1);
 		__ push(T8);
 		/*
 			 __ pushl(esi);
 			 __ movl(ecx, Address(esp, 4+12));      // count
 			 __ pushl(edi);
 			 __ movl(esi, Address(esp, 8+ 4));      // from
 			 __ movl(edi, Address(esp, 8+ 8));      // to
 		 */
 		__ move(T1, A2);
 		__ move(T3, A0);
 		__ move(T0, A1);
 		// copy dwords from high to low
 		// __ leal(esi, Address(esi, ecx, Address::times_2, -4)); // from + count*2 - 4
 		__ sll(AT, T1, Address::times_2);
 		__ add(AT, T3, AT);
 		__ lea(T3, Address( AT, -4));
 		//__ std();
 		//__ leal(edi, Address(edi, ecx, Address::times_2, -4)); // to + count*2 - 4
 		__ sll(AT,T1 , Address::times_2);
 		__ add(AT, T0, AT);
 		__ lea(T0, Address( AT, -4));
 		//  __ movl(eax, ecx);
 		__ move(T8, T1);
 		__ bind(l_1);
 		//   __ sarl(ecx, 1);              // dword count
 		__ sra(T1,T1, 1);
 		//__ jcc(Assembler::equal, l_4);                   // no dwords to move
 		__ beq(T1, R0, l_4);
 		__ delayed()->nop();
 		/*    __ cmpl(ecx, 32);
 					__ jcc(Assembler::above, l_3);                   // > 32 dwords
 		// copy dwords with loop
 		__ subl(edi, esi);
 		 */     __ align(16);
 		__ bind(l_2);
 		//__ movl(edx, Address(esi));
 		__ lw(AT, T3, 0);
 		//__ movl(Address(edi, esi, Address::times_1), edx);
 		__ sw(AT, T0, 0);
 		//__ subl(esi, 4);
 		__ addi(T3, T3, -4);
 		__ addi(T0, T0, -4);
 		//__ decl(ecx);
 		__ addi(T1, T1, -1);
 		//  __ jcc(Assembler::notEqual, l_2);
 		__ bne(T1, R0, l_2);
 		__ delayed()->nop();
 		//  __ addl(edi, esi);
 		// __ jmp(l_4);
 		__ b(l_4);
 		__ delayed()->nop();
 		// copy dwords with repeat move
 		__ bind(l_3);
 		//   __ rep_movl();
 		__ bind(l_4);
 		//  __ andl(eax, 1);              // suffix count
 		__ andi(T8, T8, 1);              // suffix count
 		//__ jcc(Assembler::equal, l_5);                   // no suffix
 		__ beq(T8, R0, l_5 );
 		__ delayed()->nop();
 		// copy suffix
 		//   __ movw(edx, Address(esi, 2));
 		__ lh(AT, T3, 2);
 		//  __ movw(Address(edi, 2), edx);
 		__ sh(AT, T0, 2);
 		__ bind(l_5);
 		//    __ cld();
 		//    __ popl(edi);
 		//    __ popl(esi);
 		//   __ ret(0);
 		__ pop(T8);
 		__ pop(T1);
 		__ pop(T0);
 		__ pop(T3);
 		__ jr(RA);
 		__ delayed()->nop();
 		return start;
   }
   // Arguments:
   //   aligned - true => Input and output aligned on a HeapWord == 8-byte boundary
   //             ignored
   //   is_oop  - true => oop array, so generate store check code
   //   name    - stub name string
   //
   // Inputs:
   //   c_rarg0   - source array address
   //   c_rarg1   - destination array address
   //   c_rarg2   - element count, treated as ssize_t, can be zero
   //
   // If 'from' and/or 'to' are aligned on 4-byte boundaries, we let
   // the hardware handle it.  The two dwords within qwords that span
   // cache line boundaries will still be loaded and stored atomicly.
   //
   // Side Effects:
   //   disjoint_int_copy_entry is set to the no-overlap entry point
   //   used by generate_conjoint_int_oop_copy().
   //
   address generate_disjoint_int_oop_copy(bool aligned, bool is_oop, const char *name) {
     Label l_3, l_4, l_5, l_6, l_7;
     StubCodeMark mark(this, "StubRoutines", name);
     __ align(CodeEntryAlignment);
     address start = __ pc();
     __ push(T3);
     __ push(T0);
     __ push(T1);
     __ push(T8);
     __ move(T1, A2);
     __ move(T3, A0);
     __ move(T0, A1);
     if (is_oop) {
       if (Use3A2000) __ sync();
     }
     if(!aligned) {
       __ xorr(AT, T3, T0);
       __ andi(AT, AT, 7);
       __ bne(AT, R0, l_5); // not same alignment mod 8 -> copy 1 element each time
       __ delayed()->nop();
       __ andi(AT, T3, 7);
       __ beq(AT, R0, l_6); //copy 2 elements each time
       __ delayed()->nop();
       __ lw(AT, T3, 0);
       __ daddi(T1, T1, -1);
       __ sw(AT, T0, 0);
       __ daddi(T3, T3, 4);
       __ daddi(T0, T0, 4);
     }
     {
       __ bind(l_6);
       __ daddi(AT, T1, -1);
       __ blez(AT, l_5);
       __ delayed()->nop();
       __ bind(l_7);
       __ ld(AT, T3, 0);
       __ sd(AT, T0, 0);
       __ daddi(T3, T3, 8);
       __ daddi(T0, T0, 8);
       __ daddi(T1, T1, -2);
       __ daddi(AT, T1, -2);
       __ bgez(AT, l_7);
       __ delayed()->nop();
     }
     __ bind(l_5);
     __ beq(T1, R0, l_4);
     __ delayed()->nop();
     __ align(16);
     __ bind(l_3);
     __ lw(AT, T3, 0);
     __ sw(AT, T0, 0);
     __ addi(T3, T3, 4);
     __ addi(T0, T0, 4);
     __ addi(T1, T1, -1);
     __ bne(T1, R0, l_3);
     __ delayed()->nop();
     if (is_oop) {
       __ move(T0, A1);
       __ move(T1, A2);
       array_store_check();
     }
     // exit
     __ bind(l_4);
     __ pop(T8);
     __ pop(T1);
     __ pop(T0);
     __ pop(T3);
     __ jr(RA);
     __ delayed()->nop();
     return start;
   }
   // Arguments:
   //   aligned - true => Input and output aligned on a HeapWord == 8-byte boundary
   //             ignored
   //   is_oop  - true => oop array, so generate store check code
   //   name    - stub name string
   //
   // Inputs:
   //   c_rarg0   - source array address
   //   c_rarg1   - destination array address
   //   c_rarg2   - element count, treated as ssize_t, can be zero
   //
   // If 'from' and/or 'to' are aligned on 4-byte boundaries, we let
   // the hardware handle it.  The two dwords within qwords that span
   // cache line boundaries will still be loaded and stored atomicly.
   //
   address generate_conjoint_int_oop_copy(bool aligned, bool is_oop, const char *name) {
 		Label l_2, l_4;
 		StubCodeMark mark(this, "StubRoutines", name);
 		__ align(CodeEntryAlignment);
 		address start = __ pc();
 		address nooverlap_target;
 		if (is_oop) {
 			nooverlap_target = aligned ?
 							StubRoutines::arrayof_oop_disjoint_arraycopy() :
 							StubRoutines::oop_disjoint_arraycopy();
 		}else {
 			nooverlap_target = aligned ?
 							StubRoutines::arrayof_jint_disjoint_arraycopy() :
 							StubRoutines::jint_disjoint_arraycopy();
 		}
 		array_overlap_test(nooverlap_target, 2);
 		__ push(T3);
 		__ push(T0);
 		__ push(T1);
 		__ push(T8);
 		__ move(T1, A2);
 		__ move(T3, A0);
 		__ move(T0, A1);
                 // T3: source array address
                 // T0: destination array address
                 // T1: element count
 		if (is_oop) {
                    if (Use3A2000) __ sync();
 		}
 		__ sll(AT, T1, Address::times_4);
 		__ add(AT, T3, AT);
 		__ lea(T3 , Address(AT, -4));
 		__ sll(AT, T1, Address::times_4);
 		__ add(AT, T0, AT);
 		__ lea(T0 , Address(AT, -4));
 		__ beq(T1, R0, l_4);
 		__ delayed()->nop();
 		__ align(16);
 		__ bind(l_2);
 		__ lw(AT, T3, 0);
 		__ sw(AT, T0, 0);
 		__ addi(T3, T3, -4);
 		__ addi(T0, T0, -4);
 		__ addi(T1, T1, -1);
 		__ bne(T1, R0, l_2);
 		__ delayed()->nop();
 		if (is_oop) {
 			__ move(T0, A1);
 			__ move(T1, A2);
 			array_store_check();
 		}
 		__ bind(l_4);
 		__ pop(T8);
 		__ pop(T1);
 		__ pop(T0);
 		__ pop(T3);
 		__ jr(RA);
 		__ delayed()->nop();
 		return start;
   }
   // Arguments:
   //   aligned - true => Input and output aligned on a HeapWord == 8-byte boundary
   //             ignored
   //   is_oop  - true => oop array, so generate store check code
   //   name    - stub name string
   //
   // Inputs:
   //   c_rarg0   - source array address
   //   c_rarg1   - destination array address
   //   c_rarg2   - element count, treated as ssize_t, can be zero
   //
   // If 'from' and/or 'to' are aligned on 4-byte boundaries, we let
   // the hardware handle it.  The two dwords within qwords that span
   // cache line boundaries will still be loaded and stored atomicly.
   //
   // Side Effects:
   //   disjoint_int_copy_entry is set to the no-overlap entry point
   //   used by generate_conjoint_int_oop_copy().
   //
   address generate_disjoint_long_oop_copy(bool aligned, bool is_oop, const char *name) {
 		Label l_3, l_4;
 		StubCodeMark mark(this, "StubRoutines", name);
 		__ align(CodeEntryAlignment);
 		address start = __ pc();
 		__ push(T3);
 		__ push(T0);
 		__ push(T1);
 		__ push(T8);
 		__ move(T1, A2);
 		__ move(T3, A0);
 		__ move(T0, A1);
                 // T3: source array address
                 // T0: destination array address
                 // T1: element count
 		if (is_oop) {
                   if (Use3A2000) __ sync();
 		}
 		__ beq(T1, R0, l_4);
 		__ delayed()->nop();
 		__ align(16);
 		__ bind(l_3);
 		__ ld(AT, T3, 0);
 		__ sd(AT, T0, 0);
 		__ addi(T3, T3, 8);
 		__ addi(T0, T0, 8);
 		__ addi(T1, T1, -1);
 		__ bne(T1, R0, l_3);
 		__ delayed()->nop();
 		if (is_oop) {
 			__ move(T0, A1);
 			__ move(T1, A2);
 			array_store_check();
 		}
                 // exit
 		__ bind(l_4);
 		__ pop(T8);
 		__ pop(T1);
 		__ pop(T0);
 		__ pop(T3);
 		__ jr(RA);
 		__ delayed()->nop();
 		return start;
 	}
   // Arguments:
   //   aligned - true => Input and output aligned on a HeapWord == 8-byte boundary
   //             ignored
   //   is_oop  - true => oop array, so generate store check code
   //   name    - stub name string
   //
   // Inputs:
   //   c_rarg0   - source array address
   //   c_rarg1   - destination array address
   //   c_rarg2   - element count, treated as ssize_t, can be zero
   //
   // If 'from' and/or 'to' are aligned on 4-byte boundaries, we let
   // the hardware handle it.  The two dwords within qwords that span
   // cache line boundaries will still be loaded and stored atomicly.
   //
   address generate_conjoint_long_oop_copy(bool aligned, bool is_oop, const char *name) {
 		Label l_2, l_4;
 		StubCodeMark mark(this, "StubRoutines", name);
 		__ align(CodeEntryAlignment);
 		address start = __ pc();
 		address nooverlap_target;
 		if (is_oop) {
 			nooverlap_target = aligned ?
 							StubRoutines::arrayof_oop_disjoint_arraycopy() :
 							StubRoutines::oop_disjoint_arraycopy();
 		}else {
 			nooverlap_target = aligned ?
 							StubRoutines::arrayof_jlong_disjoint_arraycopy() :
 							StubRoutines::jlong_disjoint_arraycopy();
 		}
 		array_overlap_test(nooverlap_target, 3);
 		__ push(T3);
 		__ push(T0);
 		__ push(T1);
 		__ push(T8);
 		__ move(T1, A2);
 		__ move(T3, A0);
 		__ move(T0, A1);
 		if (is_oop) {
                    if (Use3A2000) __ sync();
 		}
 		__ sll(AT, T1, Address::times_8);
 		__ add(AT, T3, AT);
 		__ lea(T3 , Address(AT, -8));
 		__ sll(AT, T1, Address::times_8);
 		__ add(AT, T0, AT);
 		__ lea(T0 , Address(AT, -8));
 		__ beq(T1, R0, l_4);
 		__ delayed()->nop();
 		__ align(16);
 		__ bind(l_2);
 		__ ld(AT, T3, 0);
 		__ sd(AT, T0, 0);
 		__ addi(T3, T3, -8);
 		__ addi(T0, T0, -8);
 		__ addi(T1, T1, -1);
 		__ bne(T1, R0, l_2);
 		__ delayed()->nop();
 		if (is_oop) {
 			__ move(T0, A1);
 			__ move(T1, A2);
 			array_store_check();
 		}
 		__ bind(l_4);
 		__ pop(T8);
 		__ pop(T1);
 		__ pop(T0);
 		__ pop(T3);
 		__ jr(RA);
 		__ delayed()->nop();
 		return start;
   }
 //FIXME
   address generate_disjoint_long_copy(bool aligned, const char *name) {
 	  Label l_1, l_2;
 	  StubCodeMark mark(this, "StubRoutines", name);
 	  __ align(CodeEntryAlignment);
 	  address start = __ pc();
 	  //      __ movl(ecx, Address(esp, 4+8));       // count
 	  //     __ movl(eax, Address(esp, 4+0));       // from
 	  //    __ movl(edx, Address(esp, 4+4));       // to
 	  __ move(T1, A2);
 	  __ move(T3, A0);
 	  __ move(T0, A1);
 	  __ push(T3);
 	  __ push(T0);
 	  __ push(T1);
 	  //__ subl(edx, eax);
 	  //__ jmp(l_2);
 	  __ b(l_2);
 	  __ delayed()->nop();
 	  __ align(16);
 	  __ bind(l_1);
 	  //   if (VM_Version::supports_mmx()) {
 	  //     __ movq(mmx0, Address(eax));
 	  //     __ movq(Address(eax, edx, Address::times_1), mmx0);
 	  //   } else {
 	  //   __ fild_d(Address(eax));
 	  __ ld(AT, T3, 0);
 	  // __ fistp_d(Address(eax, edx, Address::times_1));
 	  __ sd (AT, T0, 0);
 	  //   }
 	  //   __ addl(eax, 8);
 	  __ addi(T3, T3, 8);
 	  __ addi(T0, T0, 8);
 	  __ bind(l_2);
 	  //    __ decl(ecx);
 	  __ addi(T1, T1, -1);
 	  //    __ jcc(Assembler::greaterEqual, l_1);
 	  __ bgez(T1, l_1);
 	  __ delayed()->nop();
 	  //  if (VM_Version::supports_mmx()) {
 	  //    __ emms();
 	  //  }
 	  //  __ ret(0);
 	  __ pop(T1);
 	  __ pop(T0);
 	  __ pop(T3);
 	  __ jr(RA);
 	  __ delayed()->nop();
 	  return start;
   }
   address generate_conjoint_long_copy(bool aligned, const char *name) {
 	  Label l_1, l_2;
 	  StubCodeMark mark(this, "StubRoutines", name);
 	  __ align(CodeEntryAlignment);
 	  address start = __ pc();
 	  address nooverlap_target = aligned ?
 		  StubRoutines::arrayof_jlong_disjoint_arraycopy() :
 		  StubRoutines::jlong_disjoint_arraycopy();
 	  array_overlap_test(nooverlap_target, 3);
 	  __ push(T3);
 	  __ push(T0);
 	  __ push(T1);
 		/*      __ movl(ecx, Address(esp, 4+8));       // count
 						__ movl(eax, Address(esp, 4+0));       // from
 						__ movl(edx, Address(esp, 4+4));       // to
 						__ jmp(l_2);
 		 */
 	  __ move(T1, A2);
 	  __ move(T3, A0);
 	  __ move(T0, A1);
 	  __ sll(AT, T1, Address::times_8);
 	  __ add(AT, T3, AT);
 	  __ lea(T3 , Address(AT, -8));
 	  __ sll(AT, T1, Address::times_8);
 	  __ add(AT, T0, AT);
 	  __ lea(T0 , Address(AT, -8));
 	  __ b(l_2);
 	  __ delayed()->nop();
 	  __ align(16);
 		__ bind(l_1);
 		/*      if (VM_Version::supports_mmx()) {
 						__ movq(mmx0, Address(eax, ecx, Address::times_8));
 						__ movq(Address(edx, ecx,Address::times_8), mmx0);
 						} else {
 						__ fild_d(Address(eax, ecx, Address::times_8));
 						__ fistp_d(Address(edx, ecx,Address::times_8));
 						}
 		 */
 		__ ld(AT, T3, 0);
 		__ sd (AT, T0, 0);
 	  __ addi(T3, T3, -8);
 	  __ addi(T0, T0,-8);
 	  __ bind(l_2);
 	  //	    __ decl(ecx);
 	  __ addi(T1, T1, -1);
 	  //__ jcc(Assembler::greaterEqual, l_1);
 	  __ bgez(T1, l_1);
 	  __ delayed()->nop();
 	  //      if (VM_Version::supports_mmx()) {
 	  //      __ emms();
 	  //   }
 	  //  __ ret(0);
 	  __ pop(T1);
 	  __ pop(T0);
 	  __ pop(T3);
 	  __ jr(RA);
 	  __ delayed()->nop();
 	  return start;
   }
   void generate_arraycopy_stubs() {
     if (UseCompressedOops) {
       StubRoutines::_oop_disjoint_arraycopy          = generate_disjoint_int_oop_copy(false, true,
                                                                                       "oop_disjoint_arraycopy");
       StubRoutines::_oop_arraycopy                   = generate_conjoint_int_oop_copy(false, true,
                                                                                       "oop_arraycopy");
       StubRoutines::_oop_disjoint_arraycopy_uninit   = generate_disjoint_int_oop_copy(false, true,
                                                                                       "oop_disjoint_arraycopy_uninit");
       StubRoutines::_oop_arraycopy_uninit            = generate_conjoint_int_oop_copy(false, true,
                                                                                       "oop_arraycopy_uninit");
     } else {
       StubRoutines::_oop_disjoint_arraycopy          = generate_disjoint_long_oop_copy(false, true,
                                                                                        "oop_disjoint_arraycopy");
       StubRoutines::_oop_arraycopy                   = generate_conjoint_long_oop_copy(false, true,
                                                                                        "oop_arraycopy");
       StubRoutines::_oop_disjoint_arraycopy_uninit   = generate_disjoint_long_oop_copy(false, true,
                                                                                        "oop_disjoint_arraycopy_uninit");
       StubRoutines::_oop_arraycopy_uninit            = generate_conjoint_long_oop_copy(false, true,
                                                                                        "oop_arraycopy_uninit");
     }
     StubRoutines::_jbyte_disjoint_arraycopy          = generate_disjoint_byte_copy(false, "jbyte_disjoint_arraycopy");
     StubRoutines::_jshort_disjoint_arraycopy         = generate_disjoint_short_copy(false, "jshort_disjoint_arraycopy");
     StubRoutines::_jint_disjoint_arraycopy           = generate_disjoint_int_oop_copy(false, false, "jint_disjoint_arraycopy");
     StubRoutines::_jlong_disjoint_arraycopy          = generate_disjoint_long_copy(false, "jlong_disjoint_arraycopy");
     StubRoutines::_jbyte_arraycopy  = generate_conjoint_byte_copy(false, "jbyte_arraycopy");
     StubRoutines::_jshort_arraycopy = generate_conjoint_short_copy(false, "jshort_arraycopy");
     StubRoutines::_jint_arraycopy   = generate_conjoint_int_oop_copy(false, false, "jint_arraycopy");
     StubRoutines::_jlong_arraycopy  = generate_conjoint_long_copy(false, "jlong_arraycopy");
     // We don't generate specialized code for HeapWord-aligned source
     // arrays, so just use the code we've already generated
     StubRoutines::_arrayof_jbyte_disjoint_arraycopy  = StubRoutines::_jbyte_disjoint_arraycopy;
     StubRoutines::_arrayof_jbyte_arraycopy           = StubRoutines::_jbyte_arraycopy;
     StubRoutines::_arrayof_jshort_disjoint_arraycopy = StubRoutines::_jshort_disjoint_arraycopy;
     StubRoutines::_arrayof_jshort_arraycopy          = StubRoutines::_jshort_arraycopy;
     StubRoutines::_arrayof_jint_disjoint_arraycopy   = StubRoutines::_jint_disjoint_arraycopy;
     StubRoutines::_arrayof_jint_arraycopy            = StubRoutines::_jint_arraycopy;
     StubRoutines::_arrayof_jlong_disjoint_arraycopy  = StubRoutines::_jlong_disjoint_arraycopy;
     StubRoutines::_arrayof_jlong_arraycopy           = StubRoutines::_jlong_arraycopy;
     StubRoutines::_arrayof_oop_disjoint_arraycopy    = StubRoutines::_oop_disjoint_arraycopy;
     StubRoutines::_arrayof_oop_arraycopy             = StubRoutines::_oop_arraycopy;
     StubRoutines::_arrayof_oop_disjoint_arraycopy_uninit    = StubRoutines::_oop_disjoint_arraycopy_uninit;
     StubRoutines::_arrayof_oop_arraycopy_uninit             = StubRoutines::_oop_arraycopy_uninit;
   }
 //Wang: add a function to implement SafeFetch32 and SafeFetchN
   void generate_safefetch(const char* name, int size, address* entry,
                           address* fault_pc, address* continuation_pc) {
     // safefetch signatures:
     //   int      SafeFetch32(int*      adr, int      errValue);
     //   intptr_t SafeFetchN (intptr_t* adr, intptr_t errValue);
     //
     // arguments:
     //   A0 = adr
     //   A1 = errValue
     //
     // result:
     //   PPC_RET  = *adr or errValue
     StubCodeMark mark(this, "StubRoutines", name);
     // Entry point, pc or function descriptor.
     *entry = __ pc();
     // Load *adr into A1, may fault.
     *fault_pc = __ pc();
     switch (size) {
       case 4:
         // int32_t
         __ lw(A1, A0, 0);
         break;
       case 8:
         // int64_t
         __ ld(A1, A0, 0);
         break;
       default:
         ShouldNotReachHere();
     }
     // return errValue or *adr
     *continuation_pc = __ pc();
     __ addu(V0,A1,R0);
     __ jr(RA);
     __ delayed()->nop();
   }
 #undef __
 #define __ masm->
   // Continuation point for throwing of implicit exceptions that are
   // not handled in the current activation. Fabricates an exception
   // oop and initiates normal exception dispatching in this
   // frame. Since we need to preserve callee-saved values (currently
   // only for C2, but done for C1 as well) we need a callee-saved oop
   // map and therefore have to make these stubs into RuntimeStubs
   // rather than BufferBlobs.  If the compiler needs all registers to
   // be preserved between the fault point and the exception handler
   // then it must assume responsibility for that in
   // AbstractCompiler::continuation_for_implicit_null_exception or
   // continuation_for_implicit_division_by_zero_exception. All other
   // implicit exceptions (e.g., NullPointerException or
   // AbstractMethodError on entry) are either at call sites or
   // otherwise assume that stack unwinding will be initiated, so
   // caller saved registers were assumed volatile in the compiler.
   address generate_throw_exception(const char* name,
                                    address runtime_entry,
                                    bool restore_saved_exception_pc) {
     // Information about frame layout at time of blocking runtime call.
     // Note that we only have to preserve callee-saved registers since
     // the compilers are responsible for supplying a continuation point
 		// if they expect all registers to be preserved.
 //#define aoqi_test
 #ifdef aoqi_test
 tty->print_cr("%s:%d name:%s", __func__, __LINE__, name);
 #endif
 		enum layout {
 			thread_off,    // last_java_sp
 			S7_off,        // callee saved register      sp + 1
 			S6_off,        // callee saved register      sp + 2
 			S5_off,        // callee saved register      sp + 3
 			S4_off,        // callee saved register      sp + 4
 			S3_off,        // callee saved register      sp + 5
 			S2_off,        // callee saved register      sp + 6
 			S1_off,        // callee saved register      sp + 7
 			S0_off,        // callee saved register      sp + 8
 			FP_off,
 			ret_address,
 			framesize
 		};
 		int insts_size = 2048;
 		int locs_size  = 32;
 		//  CodeBuffer* code     = new CodeBuffer(insts_size, locs_size, 0, 0, 0, false,
 		//  NULL, NULL, NULL, false, NULL, name, false);
 		CodeBuffer code (name , insts_size, locs_size);
 #ifdef aoqi_test
 tty->print_cr("%s:%d name:%s", __func__, __LINE__, name);
 #endif
 		OopMapSet* oop_maps  = new OopMapSet();
 #ifdef aoqi_test
 tty->print_cr("%s:%d name:%s", __func__, __LINE__, name);
 #endif
 		MacroAssembler* masm = new MacroAssembler(&code);
 #ifdef aoqi_test
 tty->print_cr("%s:%d name:%s", __func__, __LINE__, name);
 #endif
 		address start = __ pc();
     	//__ stop("generate_throw_exception");
 		/*
 			 __ move(AT, (int)&jerome1 );
 			 __ sw(SP, AT, 0);
 			 __ move(AT, (int)&jerome2 );
 			 __ sw(FP, AT, 0);
 			 __ move(AT, (int)&jerome3 );
 			 __ sw(RA, AT, 0);
 			 __ move(AT, (int)&jerome4 );
 			 __ sw(R0, AT, 0);
 			 __ move(AT, (int)&jerome5 );
 			 __ sw(R0, AT, 0);
 			 __ move(AT, (int)&jerome6 );
 			 __ sw(R0, AT, 0);
 			 __ move(AT, (int)&jerome7 );
 			 __ sw(R0, AT, 0);
 			 __ move(AT, (int)&jerome10 );
 			 __ sw(R0, AT, 0);
 			 __ pushad();
 		//__ enter();
 		__ call(CAST_FROM_FN_PTR(address, SharedRuntime::print_call_statistics),
 		relocInfo::runtime_call_type);
 		__ delayed()->nop();
 		//__ leave();
 		__ popad();
 		 */
 		// This is an inlined and slightly modified version of call_VM
 		// which has the ability to fetch the return PC out of
 		// thread-local storage and also sets up last_Java_sp slightly
 		// differently than the real call_VM
 #ifndef OPT_THREAD
 		Register java_thread = TREG;
 		__ get_thread(java_thread);
 #else
 		Register java_thread = TREG;
 #endif
 #ifdef aoqi_test
 tty->print_cr("%s:%d name:%s", __func__, __LINE__, name);
 #endif
 		if (restore_saved_exception_pc) {
 			__ ld(RA, java_thread, in_bytes(JavaThread::saved_exception_pc_offset())); // eax
 		}
 		__ enter(); // required for proper stackwalking of RuntimeStub frame
 		__ addi(SP, SP, (-1) * (framesize-2) * wordSize); // prolog
 		__ sd(S0, SP, S0_off * wordSize);
 		__ sd(S1, SP, S1_off * wordSize);
 		__ sd(S2, SP, S2_off * wordSize);
 		__ sd(S3, SP, S3_off * wordSize);
 		__ sd(S4, SP, S4_off * wordSize);
 		__ sd(S5, SP, S5_off * wordSize);
 		__ sd(S6, SP, S6_off * wordSize);
 		__ sd(S7, SP, S7_off * wordSize);
 		int frame_complete = __ pc() - start;
 		// push java thread (becomes first argument of C function)
 		__ sd(java_thread, SP, thread_off * wordSize);
 		if (java_thread!=A0)
 			__ move(A0, java_thread);
 		// Set up last_Java_sp and last_Java_fp
 		__ set_last_Java_frame(java_thread, SP, FP, NULL);
 		__ relocate(relocInfo::internal_pc_type);
 		{
 			intptr_t save_pc = (intptr_t)__ pc() +  NativeMovConstReg::instruction_size + 28;
 			__ patchable_set48(AT, save_pc);
 		}
 		__ sd(AT, java_thread, in_bytes(JavaThread::last_Java_pc_offset()));
 		// Call runtime
 		__ call(runtime_entry);
 		__ delayed()->nop();
 		// Generate oop map
 		OopMap* map =  new OopMap(framesize, 0);
 		oop_maps->add_gc_map(__ offset(),  map);
 		// restore the thread (cannot use the pushed argument since arguments
 		// may be overwritten by C code generated by an optimizing compiler);
 		// however can use the register value directly if it is callee saved.
 #ifndef OPT_THREAD
 		__ get_thread(java_thread);
 #endif
 		__ ld(SP, java_thread, in_bytes(JavaThread::last_Java_sp_offset()));
 		//  __ reset_last_Java_frame(java_thread, true);
 		__ reset_last_Java_frame(java_thread, true, true);
 		// Restore callee save registers.  This must be done after resetting the Java frame
 		__ ld(S0, SP, S0_off * wordSize);
 		__ ld(S1, SP, S1_off * wordSize);
 		__ ld(S2, SP, S2_off * wordSize);
 		__ ld(S3, SP, S3_off * wordSize);
 		__ ld(S4, SP, S4_off * wordSize);
 		__ ld(S5, SP, S5_off * wordSize);
 		__ ld(S6, SP, S6_off * wordSize);
 		__ ld(S7, SP, S7_off * wordSize);
 		// discard arguments
 		__ addi(SP, SP, (framesize-2) * wordSize); // epilog
 		//	__ leave(); // required for proper stackwalking of RuntimeStub frame
 		__ addi(SP, FP, wordSize);
 		__ ld(FP, SP, -1*wordSize);
 		// check for pending exceptions
 #ifdef ASSERT
 		Label L;
 		__ lw(AT, java_thread, in_bytes(Thread::pending_exception_offset()));
 		__ bne(AT, R0, L);
 		__ delayed()->nop();
 		__ should_not_reach_here();
 		__ bind(L);
 #endif //ASSERT
 		__ jmp(StubRoutines::forward_exception_entry(), relocInfo::runtime_call_type);
 		__ delayed()->nop();
 #ifdef aoqi_test
 tty->print_cr("%s:%d name:%s", __func__, __LINE__, name);
 #endif
 		RuntimeStub* stub = RuntimeStub::new_runtime_stub(name, &code,frame_complete,
 										framesize, oop_maps, false);
 #ifdef aoqi_test
 tty->print_cr("%s:%d name:%s", __func__, __LINE__, name);
 #endif
 		return stub->entry_point();
   }
   // Initialization
   void generate_initial() {
 /*
 		// Generates all stubs and initializes the entry points
     // This platform-specific stub is needed by generate_call_stub()
     StubRoutines::mips::_mxcsr_std        = generate_fp_mask("mxcsr_std",        0x0000000000001F80);
     // entry points that exist in all platforms Note: This is code
     // that could be shared among different platforms - however the
     // benefit seems to be smaller than the disadvantage of having a
     // much more complicated generator structure. See also comment in
     // stubRoutines.hpp.
     StubRoutines::_forward_exception_entry = generate_forward_exception();
     StubRoutines::_call_stub_entry =
       generate_call_stub(StubRoutines::_call_stub_return_address);
     // is referenced by megamorphic call
     StubRoutines::_catch_exception_entry = generate_catch_exception();
     // atomic calls
     StubRoutines::_atomic_xchg_entry         = generate_atomic_xchg();
     StubRoutines::_atomic_xchg_ptr_entry     = generate_atomic_xchg_ptr();
     StubRoutines::_atomic_cmpxchg_entry      = generate_atomic_cmpxchg();
     StubRoutines::_atomic_cmpxchg_long_entry = generate_atomic_cmpxchg_long();
     StubRoutines::_atomic_add_entry          = generate_atomic_add();
     StubRoutines::_atomic_add_ptr_entry      = generate_atomic_add_ptr();
     StubRoutines::_fence_entry               = generate_orderaccess_fence();
     StubRoutines::_handler_for_unsafe_access_entry =
       generate_handler_for_unsafe_access();
     // platform dependent
     StubRoutines::mips::_get_previous_fp_entry = generate_get_previous_fp();
     StubRoutines::mips::_verify_mxcsr_entry    = generate_verify_mxcsr();
 */
 		// Generates all stubs and initializes the entry points
 		//-------------------------------------------------------------
 		//-----------------------------------------------------------
 		// entry points that exist in all platforms
 		// Note: This is code that could be shared among different platforms - however the benefit seems to be smaller
 		// than the disadvantage of having a much more complicated generator structure.
 		// See also comment in stubRoutines.hpp.
 		StubRoutines::_forward_exception_entry = generate_forward_exception();
 		StubRoutines::_call_stub_entry = generate_call_stub(StubRoutines::_call_stub_return_address);
 		// is referenced by megamorphic call
 		StubRoutines::_catch_exception_entry = generate_catch_exception();
 		StubRoutines::_handler_for_unsafe_access_entry = generate_handler_for_unsafe_access();
 		// platform dependent
 		StubRoutines::gs2::_get_previous_fp_entry = generate_get_previous_fp();
 	}
 void generate_all() {
 #ifdef aoqi_test
 tty->print_cr("%s:%d", __func__, __LINE__);
 #endif
     // Generates all stubs and initializes the entry points
     // These entry points require SharedInfo::stack0 to be set up in
     // non-core builds and need to be relocatable, so they each
     // fabricate a RuntimeStub internally.
 	/*
     StubRoutines::_throw_AbstractMethodError_entry =
       generate_throw_exception("AbstractMethodError throw_exception",
                                CAST_FROM_FN_PTR(address,
                                                 SharedRuntime::
                                                 throw_AbstractMethodError),
                                false);
     StubRoutines::_throw_IncompatibleClassChangeError_entry =
       generate_throw_exception("IncompatibleClassChangeError throw_exception",
                                CAST_FROM_FN_PTR(address,
                                                 SharedRuntime::
                                                 throw_IncompatibleClassChangeError),
                                false);
     StubRoutines::_throw_ArithmeticException_entry =
       generate_throw_exception("ArithmeticException throw_exception",
                                CAST_FROM_FN_PTR(address,
                                                 SharedRuntime::
                                                 throw_ArithmeticException),
                                true);
     StubRoutines::_throw_NullPointerException_entry =
       generate_throw_exception("NullPointerException throw_exception",
                                CAST_FROM_FN_PTR(address,
                                                 SharedRuntime::
                                                 throw_NullPointerException),
                                true);
     StubRoutines::_throw_NullPointerException_at_call_entry =
       generate_throw_exception("NullPointerException at call throw_exception",
                                CAST_FROM_FN_PTR(address,
                                                 SharedRuntime::
                                                 throw_NullPointerException_at_call),
                                false);
     StubRoutines::_throw_StackOverflowError_entry =
       generate_throw_exception("StackOverflowError throw_exception",
                                CAST_FROM_FN_PTR(address,
                                                 SharedRuntime::
                                                 throw_StackOverflowError),
                                false);
     // entry points that are platform specific
     StubRoutines::mips::_f2i_fixup = generate_f2i_fixup();
     StubRoutines::mips::_f2l_fixup = generate_f2l_fixup();
     StubRoutines::mips::_d2i_fixup = generate_d2i_fixup();
     StubRoutines::mips::_d2l_fixup = generate_d2l_fixup();
     StubRoutines::mips::_float_sign_mask  = generate_fp_mask("float_sign_mask",  0x7FFFFFFF7FFFFFFF);
     StubRoutines::mips::_float_sign_flip  = generate_fp_mask("float_sign_flip",  0x8000000080000000);
     StubRoutines::mips::_double_sign_mask = generate_fp_mask("double_sign_mask", 0x7FFFFFFFFFFFFFFF);
     StubRoutines::mips::_double_sign_flip = generate_fp_mask("double_sign_flip", 0x8000000000000000);
     // support for verify_oop (must happen after universe_init)
     StubRoutines::_verify_oop_subroutine_entry = generate_verify_oop();
     // arraycopy stubs used by compilers
     generate_arraycopy_stubs();
 	*/
 #ifdef aoqi_test
 tty->print_cr("%s:%d", __func__, __LINE__);
 #endif
 		StubRoutines::_throw_AbstractMethodError_entry         = generate_throw_exception("AbstractMethodError throw_exception",          CAST_FROM_FN_PTR(address, SharedRuntime::throw_AbstractMethodError),  false);
 #ifdef aoqi_test
 tty->print_cr("%s:%d", __func__, __LINE__);
 #endif
 //		StubRoutines::_throw_ArithmeticException_entry         = generate_throw_exception("ArithmeticException throw_exception",          CAST_FROM_FN_PTR(address, SharedRuntime::throw_ArithmeticException),  true);
 #ifdef aoqi_test
 tty->print_cr("%s:%d", __func__, __LINE__);
 #endif
 //		StubRoutines::_throw_NullPointerException_entry        = generate_throw_exception("NullPointerException throw_exception",         CAST_FROM_FN_PTR(address, SharedRuntime::throw_NullPointerException), true);
 #ifdef aoqi_test
 tty->print_cr("%s:%d", __func__, __LINE__);
 #endif
 		StubRoutines::_throw_NullPointerException_at_call_entry= generate_throw_exception("NullPointerException at call throw_exception", CAST_FROM_FN_PTR(address, SharedRuntime::throw_NullPointerException_at_call), false);
 #ifdef aoqi_test
 tty->print_cr("%s:%d", __func__, __LINE__);
 #endif
 		StubRoutines::_throw_StackOverflowError_entry          = generate_throw_exception("StackOverflowError throw_exception",           CAST_FROM_FN_PTR(address, SharedRuntime::throw_StackOverflowError),   false);
 #ifdef aoqi_test
 tty->print_cr("%s:%d", __func__, __LINE__);
 #endif
 		//------------------------------------------------------
 		//------------------------------------------------------------------
 		// entry points that are platform specific
 		// support for verify_oop (must happen after universe_init)
 #ifdef aoqi_test
 tty->print_cr("%s:%d", __func__, __LINE__);
 #endif
 		StubRoutines::_verify_oop_subroutine_entry	   = generate_verify_oop();
 #ifdef aoqi_test
 tty->print_cr("%s:%d", __func__, __LINE__);
 #endif
 #ifndef CORE
 		// arraycopy stubs used by compilers
 		generate_arraycopy_stubs();
 #ifdef aoqi_test
 tty->print_cr("%s:%d", __func__, __LINE__);
 #endif
 #endif
     // Safefetch stubs.
     generate_safefetch("SafeFetch32", sizeof(int),     &StubRoutines::_safefetch32_entry,
                                                        &StubRoutines::_safefetch32_fault_pc,
                                                        &StubRoutines::_safefetch32_continuation_pc);
     generate_safefetch("SafeFetchN", sizeof(intptr_t), &StubRoutines::_safefetchN_entry,
                                                        &StubRoutines::_safefetchN_fault_pc,
                                                        &StubRoutines::_safefetchN_continuation_pc);
 	}
  public:
   StubGenerator(CodeBuffer* code, bool all) : StubCodeGenerator(code) {
     if (all) {
       generate_all();
     } else {
       generate_initial();
     }
   }
 }; // end class declaration
 /*
 address StubGenerator::disjoint_byte_copy_entry  = NULL;
 address StubGenerator::disjoint_short_copy_entry = NULL;
 address StubGenerator::disjoint_int_copy_entry   = NULL;
 address StubGenerator::disjoint_long_copy_entry  = NULL;
 address StubGenerator::disjoint_oop_copy_entry   = NULL;
 address StubGenerator::byte_copy_entry  = NULL;
 address StubGenerator::short_copy_entry = NULL;
 address StubGenerator::int_copy_entry   = NULL;
 address StubGenerator::long_copy_entry  = NULL;
 address StubGenerator::oop_copy_entry   = NULL;
 address StubGenerator::checkcast_copy_entry = NULL;
 */
 void StubGenerator_generate(CodeBuffer* code, bool all) {
   StubGenerator g(code, all);
 }

Mercurial > jdk8-mips64-public > hotspot / annotate

src/cpu/mips/vm/stubGenerator_mips_64.cpp@4bfb40d1e17a (annotated)

src/cpu/mips/vm/stubGenerator_mips_64.cpp