Mercurial > jdk8-mips64-public > hotspot / file revision

 /*

  * 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);

 }