X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=src%2Fvm%2Fjit%2Falpha%2Fasmpart.S;h=25ceb1da460d34c07988017cc1f80f030117149d;hb=4bca02837622e8ab576a2d177ff5eda0d3987dfc;hp=08a592358b8a7cd114f3df7b4b09b5daf95710e1;hpb=1eac4fcb595d0d4742dda5b859339c7e2447996a;p=cacao.git diff --git a/src/vm/jit/alpha/asmpart.S b/src/vm/jit/alpha/asmpart.S index 08a592358..25ceb1da4 100644 --- a/src/vm/jit/alpha/asmpart.S +++ b/src/vm/jit/alpha/asmpart.S @@ -1,9 +1,9 @@ /* src/vm/jit/alpha/asmpart.S - Java-C interface functions for alpha - Copyright (C) 1996-2005 R. Grafl, A. Krall, C. Kruegel, C. Oates, - R. Obermaisser, M. Platter, M. Probst, S. Ring, E. Steiner, - C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich, J. Wenninger, - Institut f. Computersprachen - TU Wien + Copyright (C) 1996-2005, 2006, 2007 R. Grafl, A. Krall, C. Kruegel, + C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring, + E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich, + J. Wenninger, Institut f. Computersprachen - TU Wien This file is part of CACAO. @@ -19,210 +19,22 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA - 02111-1307, USA. + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + 02110-1301, USA. - Contact: cacao@complang.tuwien.ac.at - - Authors: Andreas Krall - Reinhard Grafl - - Changes: Joseph Wenninger - Christian Thalinger - - $Id: asmpart.S 2399 2005-04-27 12:53:03Z twisti $ + $Id: asmpart.S 7661 2007-04-03 22:29:59Z twisti $ */ -#include "config.h" +#include "config.h" + +#include "vm/jit/alpha/md-abi.h" +#include "vm/jit/alpha/md-asm.h" #include "vm/jit/alpha/offsets.h" -#include "vm/jit/alpha/asmoffsets.h" - - -#define v0 $0 - -#define t0 $1 -#define t1 $2 -#define t2 $3 -#define t3 $4 -#define t4 $5 -#define t5 $6 -#define t6 $7 -#define t7 $8 - -#define s0 $9 -#define s1 $10 -#define s2 $11 -#define s3 $12 -#define s4 $13 -#define s5 $14 -#define s6 $15 - -#define a0 $16 -#define a1 $17 -#define a2 $18 -#define a3 $19 -#define a4 $20 -#define a5 $21 - -#define t8 $22 -#define t9 $23 -#define t10 $24 -#define t11 $25 -#define ra $26 -#define t12 $27 - -#define pv t12 -#define AT $at -#define gp $29 -#define sp $30 -#define zero $31 - -#define itmp1 t11 -#define itmp2 $28 -#define itmp3 gp - -#define xptr itmp1 -#define xpc itmp2 - - -#define ft0 $f1 - -#define fs0 $f2 -#define fs1 $f3 -#define fs2 $f4 -#define fs3 $f5 -#define fs4 $f6 -#define fs5 $f7 -#define fs6 $f8 -#define fs7 $f9 - -#define ft1 $f10 -#define ft2 $f11 -#define ft3 $f12 -#define ft4 $f13 -#define ft5 $f14 -#define ft6 $f15 - -#define fa0 $f16 -#define fa1 $f17 -#define fa2 $f18 -#define fa3 $f19 -#define fa4 $f20 -#define fa5 $f21 - -#define ft7 $f22 -#define ft8 $f23 -#define ft9 $f24 -#define ft10 $f25 -#define ft11 $f26 -#define ft12 $f27 -#define ft13 $f28 -#define ft14 $f29 -#define ft15 $f20 - -#define fzero $f31 - -#define ftmp1 ft13 -#define ftmp2 ft14 -#define ftmp3 ft15 - -#define PAL_imb 0x86 - - -/* save and restore macros ****************************************************/ - -#define SAVE_ARGUMENT_REGISTERS(off) \ - stq a0,(0+(off))*8(sp) ; \ - stq a1,(1+(off))*8(sp) ; \ - stq a2,(2+(off))*8(sp) ; \ - stq a3,(3+(off))*8(sp) ; \ - stq a4,(4+(off))*8(sp) ; \ - stq a5,(5+(off))*8(sp) ; \ - \ - stt fa0,(6+(off))*8(sp) ; \ - stt fa1,(7+(off))*8(sp) ; \ - stt fa2,(8+(off))*8(sp) ; \ - stt fa3,(9+(off))*8(sp) ; \ - stt fa4,(10+(off))*8(sp) ; \ - stt fa5,(11+(off))*8(sp) ; - -#define RESTORE_ARGUMENT_REGISTERS(off) \ - ldq a0,(0+(off))*8(sp) ; \ - ldq a1,(1+(off))*8(sp) ; \ - ldq a2,(2+(off))*8(sp) ; \ - ldq a3,(3+(off))*8(sp) ; \ - ldq a4,(4+(off))*8(sp) ; \ - ldq a5,(5+(off))*8(sp) ; \ - \ - ldt fa0,(6+(off))*8(sp) ; \ - ldt fa1,(7+(off))*8(sp) ; \ - ldt fa2,(8+(off))*8(sp) ; \ - ldt fa3,(9+(off))*8(sp) ; \ - ldt fa4,(10+(off))*8(sp) ; \ - ldt fa5,(11+(off))*8(sp) ; - -#define SAVE_TEMPORARY_REGISTERS(off) \ - stq t0,(0+(off))*8(sp) ; \ - stq t1,(1+(off))*8(sp) ; \ - stq t2,(2+(off))*8(sp) ; \ - stq t3,(3+(off))*8(sp) ; \ - stq t4,(4+(off))*8(sp) ; \ - stq t5,(5+(off))*8(sp) ; \ - stq t6,(6+(off))*8(sp) ; \ - stq t7,(7+(off))*8(sp) ; \ - stq t8,(8+(off))*8(sp) ; \ - stq t9,(9+(off))*8(sp) ; \ - stq t10,(10+(off))*8(sp) ; \ - \ - stt ft0,(11+(off))*8(sp) ; \ - stt ft1,(12+(off))*8(sp) ; \ - stt ft2,(13+(off))*8(sp) ; \ - stt ft3,(14+(off))*8(sp) ; \ - stt ft4,(15+(off))*8(sp) ; \ - stt ft5,(16+(off))*8(sp) ; \ - stt ft6,(17+(off))*8(sp) ; \ - stt ft7,(18+(off))*8(sp) ; \ - stt ft8,(19+(off))*8(sp) ; \ - stt ft9,(20+(off))*8(sp) ; \ - stt ft10,(21+(off))*8(sp) ; \ - stt ft11,(22+(off))*8(sp) ; \ - stt ft12,(23+(off))*8(sp) ; \ - stt ft13,(24+(off))*8(sp) ; \ - stt ft14,(25+(off))*8(sp) ; \ - stt ft15,(26+(off))*8(sp) ; - - -#define RESTORE_TEMPORARY_REGISTERS(off) \ - ldq t0,(0+(off))*8(sp) ; \ - ldq t1,(1+(off))*8(sp) ; \ - ldq t2,(2+(off))*8(sp) ; \ - ldq t3,(3+(off))*8(sp) ; \ - ldq t4,(4+(off))*8(sp) ; \ - ldq t5,(5+(off))*8(sp) ; \ - ldq t6,(6+(off))*8(sp) ; \ - ldq t7,(7+(off))*8(sp) ; \ - ldq t8,(8+(off))*8(sp) ; \ - ldq t9,(9+(off))*8(sp) ; \ - ldq t10,(10+(off))*8(sp) ; \ - \ - ldt ft0,(11+(off))*8(sp) ; \ - ldt ft1,(12+(off))*8(sp) ; \ - ldt ft2,(13+(off))*8(sp) ; \ - ldt ft3,(14+(off))*8(sp) ; \ - ldt ft4,(15+(off))*8(sp) ; \ - ldt ft5,(16+(off))*8(sp) ; \ - ldt ft6,(17+(off))*8(sp) ; \ - ldt ft7,(18+(off))*8(sp) ; \ - ldt ft8,(19+(off))*8(sp) ; \ - ldt ft9,(20+(off))*8(sp) ; \ - ldt ft10,(21+(off))*8(sp) ; \ - ldt ft11,(22+(off))*8(sp) ; \ - ldt ft12,(23+(off))*8(sp) ; \ - ldt ft13,(24+(off))*8(sp) ; \ - ldt ft14,(25+(off))*8(sp) ; \ - ldt ft15,(26+(off))*8(sp) ; + +#include "vm/jit/abi-asm.h" +#include "vm/jit/methodheader.h" .text @@ -230,79 +42,41 @@ .set noreorder -/********************* exported functions and variables ***********************/ +/* export functions ***********************************************************/ - .globl asm_sync_instruction_cache - .globl has_no_x_instr_set - - .globl asm_calljavafunction - .globl asm_calljavafunction_int - - .globl asm_calljavafunction2 - .globl asm_calljavafunction2int - .globl asm_calljavafunction2long - .globl asm_calljavafunction2float - .globl asm_calljavafunction2double + .globl asm_vm_call_method + .globl asm_vm_call_method_int + .globl asm_vm_call_method_long + .globl asm_vm_call_method_float + .globl asm_vm_call_method_double + .globl asm_vm_call_method_exception_handler + .globl asm_vm_call_method_end .globl asm_call_jit_compiler - .globl asm_throw_and_handle_exception - .globl asm_throw_and_handle_nat_exception - .globl asm_throw_and_handle_arithmetic_exception - .globl asm_throw_and_handle_arrayindexoutofbounds_exception + .globl asm_handle_exception .globl asm_handle_nat_exception - .globl asm_wrapper_patcher + .globl asm_abstractmethoderror - .globl asm_builtin_checkarraycast - .globl asm_builtin_aastore + .globl asm_patcher_wrapper - .globl asm_builtin_idiv - .globl asm_builtin_irem - .globl asm_builtin_ldiv - .globl asm_builtin_lrem +#if defined(ENABLE_REPLACEMENT) + .globl asm_replacement_out + .globl asm_replacement_in +#endif + + .globl asm_compare_and_swap + .globl asm_memory_barrier - .globl asm_perform_threadswitch - .globl asm_initialize_thread_stack - .globl asm_switchstackandcall .globl asm_criticalsections .globl asm_getclassvalues_atomic - .globl asm_prepare_native_stackinfo - .globl asm_remove_native_stackinfo - .globl asm_refillin_and_handle_exception - - -/* asm_sync_instruction_cache ************************************************** - - XXX - -*******************************************************************************/ - - .ent asm_sync_instruction_cache - -asm_sync_instruction_cache: - call_pal PAL_imb /* synchronize instruction cache */ - jmp zero,(ra) - - .end asm_sync_instruction_cache - -/*********************** function has_no_x_instr_set *************************** -* * -* determines if the byte support instruction set (21164a and higher) * -* is available. * -* * -*******************************************************************************/ - - .ent has_no_x_instr_set -has_no_x_instr_set: - .long 0x47e03c20 /* amask 1,v0 */ - jmp zero,(ra) /* return */ + .globl asm_md_init + .globl asm_cacheflush - .end has_no_x_instr_set - -/********************* function asm_calljavafunction *************************** +/* asm_vm_call_method ********************************************************** * * * This function calls a Java-method (which possibly needs compilation) * * with up to 4 address parameters. * @@ -316,133 +90,71 @@ has_no_x_instr_set: * * *******************************************************************************/ - .ent asm_calljavafunction - -call_name: - .ascii "calljavafunction\0\0" - - .align 2 /*3*/ - .quad 0 /* catch type all */ - .quad calljava_xhandler /* handler pc */ - .quad calljava_xhandler /* end pc */ - .quad asm_calljavafunction /* start pc */ - .long 1 /* extable size */ - .long 0 /* PADDING */ - .quad 0 /* line number table start */ - .quad 0 /* line number table size */ - .long 0 /* PADDING */ - .long 0 /* fltsave */ - .long 0 /* intsave */ - .long 0 /* isleaf */ - .long 0 /* IsSync */ - .long 32 /* frame size */ - .quad 0 /* method pointer (pointer to name) */ - -asm_calljavafunction: -asm_calljavafunction_int: - ldgp gp,0(pv) - lda sp,-32(sp) /* allocate stack space */ - stq gp,24(sp) /* save global pointer */ - stq ra,0(sp) /* save return address */ - - stq a0,16(sp) /* save method pointer for compiler */ - lda v0,16(sp) /* pass pointer to method pointer via v0*/ - - mov a1,a0 /* pass the remaining parameters */ - mov a2,a1 - mov a3,a2 - mov a4,a3 - - lda $28,asm_call_jit_compiler /* fake virtual function call (2 instr) */ - stq $28,8(sp) /* store function address */ - mov sp,$28 /* set method pointer */ - - ldq pv,8($28) /* method call as in Java */ - jmp ra,(pv) /* call JIT compiler */ -calljava_jit: - lda pv,-64(ra) /* asm_calljavafunction-calljava_jit !!!!!*/ - -calljava_return: - ldq ra,0(sp) /* restore return address */ - ldq gp,24(sp) /* restore global pointer */ - lda sp,32(sp) /* free stack space */ - -calljava_ret: - jmp zero,(ra) - -calljava_xhandler: - ldq gp,24(sp) /* restore global pointer */ - mov xptr,a0 - jsr ra,builtin_throw_exception - ldq ra,0(sp) /* restore return address */ - lda sp,32(sp) /* free stack space */ - mov zero,v0 /* return NULL */ - jmp zero,(ra) - .end asm_calljavafunction - - + .ent asm_vm_call_method - - .ent asm_calljavafunction2 - -call_name2: .align 3 - .quad 0 /* catch type all */ - .quad calljava_xhandler2 /* handler pc */ - .quad calljava_xhandler2 /* end pc */ - .quad asm_calljavafunction2 /* start pc */ - .long 1 /* extable size */ - .long 0 /* PADDING */ - .quad 0 /* line number table start */ - .quad 0 /* line number table size */ - .long 0 /* PADDING */ - .long 0 /* fltsave */ - .long 1 /* intsave */ - .long 0 /* isleaf */ - .long 0 /* IsSync */ - .long 40 /* frame size */ - .quad 0 /* method pointer (pointer to name) */ - -asm_calljavafunction2: -asm_calljavafunction2int: -asm_calljavafunction2long: -asm_calljavafunction2float: -asm_calljavafunction2double: + .quad 0 /* catch type all */ + .quad 0 /* handler pc */ + .quad 0 /* end pc */ + .quad 0 /* start pc */ + .long 1 /* extable size */ + .long 0 /* ALIGNMENT PADDING */ + .quad 0 /* line number table start */ + .quad 0 /* line number table size */ + .long 0 /* ALIGNMENT PADDING */ + .long 0 /* fltsave */ + .long 1 /* intsave */ + .long 0 /* isleaf */ + .long 0 /* IsSync */ + .long 0 /* frame size */ + .quad 0 /* codeinfo pointer */ + +asm_vm_call_method: +asm_vm_call_method_int: +asm_vm_call_method_long: +asm_vm_call_method_float: +asm_vm_call_method_double: ldgp gp,0(pv) - lda sp,-40(sp) /* allocate stack space */ - stq ra,0(sp) /* save return address */ - stq s6,24(sp) - stq gp,8(sp) /* save global pointer */ + lda sp,-5*8(sp) /* allocate stack space */ + stq ra,0*8(sp) /* save return address */ + stq gp,1*8(sp) /* save global pointer */ + stq s6,3*8(sp) + + stq a0,4*8(sp) /* save method pointer for compiler */ - stq a0,32(sp) /* save method pointer for compiler */ - mov a3,t0 /* pointer to arg block */ + mov a2,t0 /* pointer to arg block */ mov a1,s6 /* arg count */ ble s6,calljava_argsloaded lda s6,-1(s6) - ldq a0,offjniitem(t0) - ldt $f16,offjniitem(t0) + ldq a0,offvmargdata(t0) + ldt $f16,offvmargdata(t0) ble s6,calljava_argsloaded + lda s6,-1(s6) - ldq a1,offjniitem+sizejniblock*1(t0) - ldt $f17,offjniitem+sizejniblock*1(t0) + ldq a1,offvmargdata+sizevmarg*1(t0) + ldt $f17,offvmargdata+sizevmarg*1(t0) ble s6,calljava_argsloaded + lda s6,-1(s6) - ldq a2,offjniitem+sizejniblock*2(t0) - ldt $f18,offjniitem+sizejniblock*2(t0) + ldq a2,offvmargdata+sizevmarg*2(t0) + ldt $f18,offvmargdata+sizevmarg*2(t0) ble s6,calljava_argsloaded + lda s6,-1(s6) - ldq a3,offjniitem+sizejniblock*3(t0) - ldt $f19,offjniitem+sizejniblock*3(t0) + ldq a3,offvmargdata+sizevmarg*3(t0) + ldt $f19,offvmargdata+sizevmarg*3(t0) ble s6,calljava_argsloaded + lda s6,-1(s6) - ldq a4,offjniitem+sizejniblock*4(t0) - ldt $f20,offjniitem+sizejniblock*4(t0) + ldq a4,offvmargdata+sizevmarg*4(t0) + ldt $f20,offvmargdata+sizevmarg*4(t0) ble s6,calljava_argsloaded + lda s6,-1(s6) - ldq a5,offjniitem+sizejniblock*5(t0) - ldt $f21,offjniitem+sizejniblock*5(t0) + ldq a5,offvmargdata+sizevmarg*5(t0) + ldt $f21,offvmargdata+sizevmarg*5(t0) calljava_argsloaded: mov sp,t4 ble s6,calljava_nocopy @@ -451,1131 +163,700 @@ calljava_argsloaded: s8addq t1,t4,t2 calljava_copyloop: - ldq t3,offjniitem+sizejniblock*6(t0) + ldq t3,offvmargdata+sizevmarg*6(t0) stq t3,0(t2) lda t1,1(t1) - lda t0,sizejniblock(t0) + lda t0,sizevmarg(t0) lda t2,8(t2) bne t1,calljava_copyloop calljava_nocopy: - lda v0,32(t4) /* pass pointer to method pointer via v0*/ + ldq itmp1,4*8(t4) /* pass method pointer via itmp1 */ - lda $28,asm_call_jit_compiler /* fake virtual function call (2 instr) */ - stq $28,16(t4) /* store function address */ - lda $28,8(t4) /* set method pointer */ + lda mptr,asm_call_jit_compiler/* fake virtual function call (2 instr) */ + stq mptr,2*8(t4) /* store function address */ + lda mptr,1*8(t4) /* set method pointer */ - ldq pv,8($28) /* method call as in Java */ + ldq pv,1*8(mptr) /* method call as in Java */ jmp ra,(pv) /* call JIT compiler */ calljava_jit2: - lda pv,-200(ra) /* asm_calljavafunction-calljava_jit !!!*/ + lda pv,(asm_vm_call_method - calljava_jit2)(ra) s8addq s6,sp,sp calljava_return2: - ldq ra,0(sp) /* restore return address */ - ldq gp,8(sp) /* restore global pointer */ - ldq s6,24(sp) - lda sp,40(sp) /* free stack space */ + ldq ra,0*8(sp) /* restore return address */ + ldq gp,1*8(sp) /* restore global pointer */ + ldq s6,3*8(sp) + lda sp,5*8(sp) /* free stack space */ calljava_ret2: jmp zero,(ra) -calljava_xhandler2: +asm_vm_call_method_exception_handler: s8addq s6,sp,sp - ldq gp,8(sp) /* restore global pointer */ + ldq gp,1*8(sp) /* restore global pointer */ mov itmp1,a0 jsr ra,builtin_throw_exception - ldq ra,0(sp) /* restore return address */ - ldq s6,24(sp) - lda sp,40(sp) /* free stack space */ - mov zero,v0 /* return NULL */ + ldq ra,0*8(sp) /* restore return address */ + ldq s6,3*8(sp) + lda sp,5*8(sp) /* free stack space */ +asm_vm_call_method_end: jmp zero,(ra) - .end asm_calljavafunction2 + .end asm_vm_call_method + + +/* asm_call_jit_compiler ******************************************************* + + Invokes the compiler for untranslated Java methods. -/****************** function asm_call_jit_compiler ***************************** -* * -* invokes the compiler for untranslated JavaVM methods. * -* * -* Register R0 contains a pointer to the method info structure (prepared * -* by createcompilerstub). Using the return address in R26 and the * -* offset in the LDA instruction or using the value in methodptr R28 the * -* patching address for storing the method address can be computed: * -* * -* method address was either loaded using * -* M_LDQ (REG_PV, REG_PV, a) ; invokestatic/special ($27) * -* M_LDA (REG_PV, REG_RA, low) * -* M_LDAH(REG_PV, REG_RA, high) ; optional * -* or * -* M_LDQ (REG_PV, REG_METHODPTR, m) ; invokevirtual/interface ($28) * -* in the static case the method pointer can be computed using the * -* return address and the lda function following the jmp instruction * -* * *******************************************************************************/ .ent asm_call_jit_compiler asm_call_jit_compiler: ldgp gp,0(pv) - ldl t8,-8(ra) /* load instruction LDQ PV,xxx($yy) */ - srl t8,16,t8 /* shift right register number $yy */ - and t8,31,t8 /* isolate register number */ - subl t8,28,t8 /* test for REG_METHODPTR */ - beq t8,noregchange - ldl t8,0(ra) /* load instruction LDA PV,xxx(RA) */ - sll t8,48,t8 - sra t8,48,t8 /* isolate offset */ - addq t8,ra,$28 /* compute update address */ - ldl t8,4(ra) /* load instruction LDAH PV,xxx(PV) */ - srl t8,16,t8 /* isolate instruction code */ - lda t8,-0x177b(t8) /* test for LDAH */ - bne t8,noregchange - ldl t8,4(ra) /* load instruction LDAH PV,xxx(PV) */ - sll t8,16,t8 /* compute high offset */ - addl t8,0,t8 /* sign extend high offset */ - addq t8,$28,$28 /* compute update address */ -noregchange: - lda sp,-14*8(sp) /* reserve stack space */ - - SAVE_ARGUMENT_REGISTERS(0) /* save 6 int/6 float argument registers */ - - stq $28,12*8(sp) /* save method pointer */ - stq ra,13*8(sp) /* save return address */ - - ldq a0,0(v0) /* pass 'methodinfo' pointer to */ - jsr ra,jit_compile /* jit compiler */ - ldgp gp,0(ra) + lda sp,-(ARG_CNT+2)*8(sp) /* +2: keep stack 16-byte aligned */ + + stq ra,0*8(sp) /* save return address */ - RESTORE_ARGUMENT_REGISTERS(0) /* restore 6 int/6 float argument registers */ + SAVE_ARGUMENT_REGISTERS(1) /* save 6 int/6 float argument registers */ - ldq $28,12*8(sp) /* load method pointer */ - ldq ra,13*8(sp) /* load return address */ - lda sp,14*8(sp) /* deallocate stack area */ + mov itmp1,a0 /* pass methodinfo pointer */ + mov mptr,a1 /* pass method pointer */ + lda a2,(ARG_CNT+2)*8(sp) /* pass java sp */ + mov ra,a3 + jsr ra,jit_asm_compile /* call jit compiler */ + mov v0,pv - beq v0,asm_call_jit_compiler_exception + ldq ra,0*8(sp) /* load return address */ - ldl t8,-8(ra) /* load instruction LDQ PV,xxx($yy) */ - sll t8,48,t8 - sra t8,48,t8 /* isolate offset */ + RESTORE_ARGUMENT_REGISTERS(1) /* restore 6 int/6 float argument registers */ - addq t8,$28,t8 /* compute update address via method pointer*/ - stq v0,0(t8) /* save new method address there */ + lda sp,(ARG_CNT+2)*8(sp) /* remove stack frame */ - call_pal PAL_imb /* synchronise instruction cache */ + beq pv,L_asm_call_jit_compiler_exception - mov v0,pv /* load method address into pv */ - jmp zero,(pv) /* and call method. The method returns */ + jmp zero,(pv) /* and call method, the method returns */ /* directly to the caller (ra). */ -asm_call_jit_compiler_exception: -#if defined(USE_THREADS) && defined(NATIVE_THREADS) - subq sp,1*8,sp - stq ra,0*8(sp) - jsr ra,builtin_asm_get_exceptionptrptr - ldq ra,0*8(sp) - addq sp,1*8,sp -#else - lda v0,_exceptionptr -#endif - ldq xptr,0(v0) /* get the exception pointer */ - stq zero,0(v0) /* clear the exception pointer */ +L_asm_call_jit_compiler_exception: + subq sp,2*8,sp + stq ra,0*8(sp) /* save return address (xpc) */ + jsr ra,exceptions_get_and_clear_exception + ldq ra,0*8(sp) /* restore return address (xpc) */ + addq sp,2*8,sp - subq ra,4,xpc - br asm_handle_nat_exception + mov v0,xptr /* get exception */ + subq ra,4,xpc /* exception address is ra - 4 */ + br L_asm_handle_nat_exception .end asm_call_jit_compiler -/**************** function asm_refillin_and_handle_exception ******************* -* * -* This function handles an exception. It does not use the usual calling * -* conventions. The exception is passed in REG_ITMP1 and the * -* pc from the exception raising position is passed in REG_ITMP2. * -* a0 contains the PV of the function causing the problem * -* * -* void asm_handle_arithmetic_exception (exceptionclass, exceptionpc); * -* * -*******************************************************************************/ - .ent asm_refillin_and_handle_exception -asm_refillin_and_handle_exception: - ldgp gp,0(pv) - ldl t0,0(ra) /* load instruction LDA PV,xxx(RA) */ - sll t0,48,t0 - sra t0,48,t0 /* isolate offset */ - addq t0,ra,pv /* compute update address */ - ldl t0,4(ra) /* load instruction LDAH PV,xxx(PV) */ - srl t0,16,t0 /* isolate instruction code */ - lda t0,-0x177b(t0) /* test for LDAH */ - bne t0, asm_refillin_and_handle_exception_cont - ldl t0,4(ra) /* load instruction LDAH PV,xxx(PV) */ - sll t0,16,t0 /* compute high offset */ - addl t0,0,t0 /* sign extend high offset */ - addq t0,pv,pv /* compute update address */ - -asm_refillin_and_handle_exception_cont: - - mov sp,t0 - lda sp,-6*8(sp) /* prepare stackframe*/ - stq pv,5*8(sp) /* store pv of caller */ - stq xptr,4*8(sp) /*exception ptr*/ - stq xpc,3*8(sp) /*address of failure*/ - stq t0,2*8(sp) /*begin of java stack frame*/ - stq pv,1*8(sp) /* store pv of caller */ - stq zero,0*8(sp) /*builtin (invisible) function */ - jsr ra,asm_prepare_native_stackinfo /* puts 2 additional quadwords on stack */ - ldgp gp,0(ra) - - ldq a2,utf_void__java_lang_Throwable - ldq a1,utf_fillInStackTrace - ldq t0,6*8(sp) - ldq t1,offobjvftbl(t0) - ldq a0,offclass(t1) - jsr ra,class_resolvemethod - ldgp gp,0(ra) - /* now we have the method */ - - /*refillin */ - mov v0,a0 - ldq a1,6*8(sp) - jsr ra,asm_calljavafunction - ldgp gp,0(ra) - - /*remove frame*/ - jsr ra,asm_remove_native_stackinfo - ldgp gp,0(ra) - - - /*finish*/ - ldq xpc,0(sp) - ldq xptr,1*8(sp) - ldq pv,2*8(sp) - lda sp,3*8(sp) - br asm_handle_exception - - .end asm_refillin_and_handle_exception - -/****** function asm_throw_and_handle_arrayindexoutofbounds_exception ********** -* * -* This function handles an exception. It does not use the usual calling * -* conventions. The integer parameter is passed in REG_ITMP1 and the * -* pc from the exception raising position is passed in REG_ITMP2. * -* * -* void asm_handle_arithmetic_exception (exceptionclass, exceptionpc); * -* * +/* asm_handle_exception ******************************************************** + + This function handles an exception. It does not use the usual calling + conventions. The exception pointer is passed in REG_ITMP1 and the + pc from the exception raising position is passed in REG_ITMP2. It searches + the local exception table for a handler. If no one is found, it unwinds + stacks and continues searching the callers. + + ATTENTION: itmp3 == gp! + *******************************************************************************/ - .ent asm_throw_and_handle_arrayindexoutofbounds_exception - -asm_throw_and_handle_arrayindexoutofbounds_exception: - ldgp gp,0(pv) - - ldl t0,0(ra) /* load instruction LDA PV,xxx(RA) */ - sll t0,48,t0 - sra t0,48,t0 /* isolate offset */ - addq t0,ra,pv /* compute update address */ - ldl t0,4(ra) /* load instruction LDAH PV,xxx(PV) */ - srl t0,16,t0 /* isolate instruction code */ - lda t0,-0x177b(t0) /* test for LDAH */ - bne t0,asm_throw_and_handle_arrayindexoutofbounds_exception_cont - ldl t0,4(ra) /* load instruction LDAH PV,xxx(PV) */ - sll t0,16,t0 /* compute high offset */ - addl t0,0,t0 /* sign extend high offset */ - addq t0,pv,pv /* compute update address */ - -asm_throw_and_handle_arrayindexoutofbounds_exception_cont: - mov sp,t0 - lda sp,-6*8(sp) /*prepare stackframe*/ - stq pv,5*8(sp) /*pv of failure*/ - stq itmp1,4*8(sp) /*int parameter of the exception*/ - stq xpc,3*8(sp) /*address of failure */ - stq t0,2*8(sp) /*store begin of java stack frame*/ - stq pv,1*8(sp) /*store pv of caller in structure*/ - stq zero,0*8(sp) /*builtin (invisible function)*/ - - jsr ra,asm_prepare_native_stackinfo /* puts 2 additional quadwords on stack */ - ldgp gp,0(ra) + .ent asm_handle_nat_exception - ldq a0,6*8(sp) /*int of exception*/ - jsr ra,new_arrayindexoutofboundsexception - ldgp gp,0(ra) +asm_handle_nat_exception: +L_asm_handle_nat_exception: /* required for PIC code */ +L_asm_handle_exception_stack_loop: + lda sp,-6*8(sp) /* keep stack 16-byte aligned */ + stq xptr,0*8(sp) /* save xptr */ + stq xpc,1*8(sp) /* save xpc */ + stq ra,3*8(sp) /* save RA */ + stq zero,4*8(sp) /* save maybe-leaf flag (cleared) */ - mov v0,itmp1 /*itmp1 is not touched in asm_remove_native_stackinfo*/ + mov ra,a0 /* pass RA */ - jsr ra,asm_remove_native_stackinfo - ldgp gp,0(ra) + br ra,L_asm_handle_exception_load_gp +L_asm_handle_exception_load_gp: + ldgp gp,0(ra) /* load gp */ - ldq itmp2,0(sp) - ldq pv,2*8(sp) - lda sp,3*8(sp) - br asm_handle_exception + jsr ra,md_codegen_get_pv_from_pc/* get PV from RA */ + stq v0,2*8(sp) /* save PV */ - .end asm_throw_and_handle_arrayindexoutofbounds_exception + ldq a0,0*8(sp) /* pass xptr */ + ldq a1,1*8(sp) /* pass xpc */ + mov v0,a2 /* pass PV */ + addq sp,6*8,a3 /* pass Java SP */ + br L_asm_handle_exception_continue -/* asm_throw_and_handle_arithmetic_exception *********************************** + .aent asm_handle_exception - DOCUMENT ME! +asm_handle_exception: +L_asm_handle_exception: /* required for PIC code */ + lda sp,-(ARG_CNT+TMP_CNT)*8(sp) /* create maybe-leaf stackframe */ -*******************************************************************************/ + SAVE_ARGUMENT_REGISTERS(0) /* we save arg and temp registers in */ + SAVE_TEMPORARY_REGISTERS(ARG_CNT) /* case this is a leaf method */ - .ent asm_throw_and_handle_arithmetic_exception - -asm_throw_and_handle_arithmetic_exception: - ldl t0,0(ra) /* load instruction LDA PV,xxx(RA) */ - sll t0,48,t0 - sra t0,48,t0 /* isolate offset */ - addq t0,ra,pv /* compute update address */ - ldl t0,4(ra) /* load instruction LDAH PV,xxx(PV) */ - srl t0,16,t0 /* isolate instruction code */ - lda t0,-0x177b(t0) /* test for LDAH */ - bne t0,asm_throw_and_handle_arithmetic_exception_cont - ldl t0,4(ra) /* load instruction LDAH PV,xxx(PV) */ - sll t0,16,t0 /* compute high offset */ - addl t0,0,t0 /* sign extend high offset */ - addq t0,pv,pv /* compute update address */ - -asm_throw_and_handle_arithmetic_exception_cont: - mov sp,t0 - lda sp,-6*8(sp) /*prepare stackframe*/ - stq pv,5*8(sp) /*pv of failure*/ - stq itmp1,4*8(sp) /*exception string of the exception*/ - stq xpc,3*8(sp) /*address of failure */ - stq t0,2*8(sp) /*store begin of java stack frame*/ - stq pv,1*8(sp) /*store pv of caller in structure*/ - stq zero,0*8(sp) /*builtin (invisible function)*/ - jsr ra,asm_prepare_native_stackinfo /* puts 2 additional quadwords on stack */ - ldgp gp,0(ra) - - jsr ra,new_arithmeticexception - ldgp gp,0(ra) - mov v0,itmp1 /*itmp1 is not touched in asm_remove_native_stackinfo*/ - - jsr ra,asm_remove_native_stackinfo - ldgp gp,0(ra) - - ldq itmp2,0(sp) - ldq pv,2*8(sp) - lda sp,3*8(sp) - br asm_handle_exception - - .end asm_throw_and_handle_arithmetic_exception - - -/* asm_throw_and_handle_exception ********************************************** - - DOCUMENT ME!!! + lda sp,-6*8(sp) /* keep stack 16-byte aligned */ + stq xptr,0*8(sp) /* save xptr */ + stq pv,2*8(sp) /* save PV */ + stq ra,3*8(sp) /* save RA */ + lda t0,1(zero) /* set maybe-leaf flag */ + stq t0,4*8(sp) /* save maybe-leaf flag */ -*******************************************************************************/ + br ra,L_asm_handle_exception_load_gp_2 +L_asm_handle_exception_load_gp_2: + ldgp gp,0(ra) /* load gp */ - .ent asm_throw_and_handle_nat_exception - -asm_throw_and_handle_nat_exception: - ldgp gp,0(pv) - ldl t0,0(ra) /* load instruction LDA PV,xxx(RA) */ - sll t0,48,t0 - sra t0,48,t0 /* isolate offset */ - addq t0,ra,pv /* compute update address */ - ldl t0,4(ra) /* load instruction LDAH PV,xxx(PV) */ - srl t0,16,t0 /* isolate instruction code */ - lda t0,-0x177b(t0) /* test for LDAH */ - bne t0,asm_throw_and_handle_exception - ldl t0,4(ra) /* load instruction LDAH PV,xxx(PV) */ - sll t0,16,t0 /* compute high offset */ - addl t0,0,t0 /* sign extend high offset */ - addq t0,pv,pv /* compute update address */ - - .aent asm_throw_and_handle_exception - -asm_throw_and_handle_exception: - mov sp,t0 - lda sp,-6*8(sp) /* prepare stackframe */ - stq pv,5*8(sp) /* pv of failure */ - stq xptr,4*8(sp) /* classname of the exception */ - stq xpc,3*8(sp) /* address of failure */ - stq t0,2*8(sp) /* store begin of java stack frame */ - stq pv,1*8(sp) /* store pv of caller in structure */ - stq zero,0*8(sp) /* builtin (invisible function) */ - /* puts 2 additional quadwords on stack */ - - br ra,L_asm_throw_and_handle_exception_load_gp -L_asm_throw_and_handle_exception_load_gp: - ldgp gp,0(ra) /* load gp (it's not set correctly in jit) */ + mov xptr,a0 /* pass xptr */ + mov xpc,a1 /* pass xpc */ + mov pv,a2 /* pass PV */ + lda a3,(ARG_CNT+TMP_CNT+6)*8(sp)/* pass Java SP */ - jsr ra,asm_prepare_native_stackinfo - ldgp gp,0(ra) +L_asm_handle_exception_continue: + jsr ra,exceptions_handle_exception - ldq a0,6*8(sp) /* classname of exception */ - jsr ra,new_exception - ldgp gp,0(ra) + beq v0,L_asm_handle_exception_not_catched - mov v0,xptr /* xptr (itmp1) is not touched in */ - /* asm_remove_native_stackinfo */ + mov v0,xpc /* move handlerpc into xpc */ + ldq xptr,0*8(sp) /* restore xptr */ + ldq pv,2*8(sp) /* restore PV */ + ldq ra,3*8(sp) /* restore RA */ + ldq t0,4*8(sp) /* get maybe-leaf flag */ + lda sp,6*8(sp) /* free stack frame */ - jsr ra,asm_remove_native_stackinfo - ldgp gp,0(ra) + beq t0,L_asm_handle_exception_no_leaf - ldq itmp2,0(sp) - ldq pv,2*8(sp) - lda sp,3*8(sp) - br asm_handle_exception + RESTORE_ARGUMENT_REGISTERS(0) /* if this is a leaf method, we have */ + RESTORE_TEMPORARY_REGISTERS(ARG_CNT)/* to restore arg and temp registers */ + + lda sp,(ARG_CNT+TMP_CNT)*8(sp) /* remove maybe-leaf stackframe */ - .end asm_throw_and_handle_nat_exception +L_asm_handle_exception_no_leaf: + jmp zero,(xpc) /* jump to the handler */ +L_asm_handle_exception_not_catched: + ldq xptr,0*8(sp) /* restore xptr */ + ldq pv,2*8(sp) /* restore PV */ + ldq ra,3*8(sp) /* restore RA */ + ldq t0,4*8(sp) /* get maybe-leaf flag */ + lda sp,6*8(sp) -/********************* function asm_handle_exception *************************** -* * -* This function handles an exception. It does not use the usual calling * -* conventions. The exception pointer is passed in REG_ITMP1 and the * -* pc from the exception raising position is passed in REG_ITMP2. It searches * -* the local exception table for a handler. If no one is found, it unwinds * -* stacks and continues searching the callers. * -* * -* void asm_handle_exception (exceptionptr, exceptionpc); * -* * -*******************************************************************************/ + beq t0,L_asm_handle_exception_no_leaf_stack - .ent asm_handle_nat_exception + lda sp,(ARG_CNT+TMP_CNT)*8(sp) /* remove maybe-leaf stackframe */ + mov zero,t0 /* clear the maybe-leaf flag */ -asm_handle_nat_exception: - ldl t0,0(ra) /* load instruction LDA PV,xxx(RA) */ - sll t0,48,t0 - sra t0,48,t0 /* isolate offset */ - addq t0,ra,pv /* compute update address */ - ldl t0,4(ra) /* load instruction LDAH PV,xxx(PV) */ - srl t0,16,t0 /* isolate instruction code */ - lda t0,-0x177b(t0) /* test for LDAH */ - bne t0,asm_handle_exception - ldl t0,4(ra) /* load instruction LDAH PV,xxx(PV) */ - sll t0,16,t0 /* compute high offset */ - addl t0,0,t0 /* sign extend high offset */ - addq t0,pv,pv /* compute update address */ +L_asm_handle_exception_no_leaf_stack: + ldl t1,FrameSize(pv) /* get frame size */ + addq t1,sp,t1 /* pointer to save area */ - .aent asm_handle_exception + ldl t2,IsLeaf(pv) /* is leaf procedure */ + bne t2,L_asm_handle_exception_no_ra_restore -asm_handle_exception: - lda sp,-18*8(sp) /* allocate stack */ - stq t0,0*8(sp) /* save possible used registers */ - stq t1,1*8(sp) /* also registers used by trace_exception */ - stq t2,2*8(sp) - stq t3,3*8(sp) - stq t4,4*8(sp) - stq t5,5*8(sp) - stq t6,6*8(sp) - stq t7,7*8(sp) - stq t8,8*8(sp) - stq t9,9*8(sp) - stq t10,10*8(sp) - stq v0,11*8(sp) - stq a0,12*8(sp) - stq a1,13*8(sp) - stq a2,14*8(sp) - stq a3,15*8(sp) - stq a4,16*8(sp) - stq a5,17*8(sp) - - lda t3,1(zero) /* set no unwind flag */ -ex_stack_loop: - lda sp,-5*8(sp) /* allocate stack */ - stq xptr,0*8(sp) /* save used register */ - stq xpc,1*8(sp) - stq pv,2*8(sp) - stq ra,3*8(sp) - stq t3,4*8(sp) - - mov xptr,a0 - ldq a1,MethodPointer(pv) - mov xpc,a2 -/* mov t3,a3 */ - lda a3,0(zero) - lda a4,1(zero) - br ra,ex_trace /* set ra for gp loading */ -ex_trace: - ldgp gp,0(ra) /* load gp */ - jsr ra,builtin_trace_exception /* trace_exception(xptr,methodptr) */ - - ldq xptr,0*8(sp) /* restore used register */ - ldq xpc,1*8(sp) - ldq pv,2*8(sp) - ldq ra,3*8(sp) - ldq t3,4*8(sp) - lda sp,5*8(sp) /* deallocate stack */ - - ldl t0,ExTableSize(pv) /* t0 = exception table size */ - beq t0,empty_table /* if empty table skip */ - - lda t1,ExTableStart(pv) /* t1 = start of exception table */ - -ex_table_loop: - ldq t2,ExStartPC(t1) /* t2 = exception start pc */ - cmple t2,xpc,t2 /* t2 = (startpc <= xpc) */ - beq t2,ex_table_cont /* if (false) continue */ - ldq t2,ExEndPC(t1) /* t2 = exception end pc */ - cmplt xpc,t2,t2 /* t2 = (xpc < endpc) */ - beq t2,ex_table_cont /* if (false) continue */ - ldq a1,ExCatchType(t1) /* arg1 = exception catch type */ - beq a1,ex_handle_it /* NULL catches everything */ - - ldl itmp3,offclassloaded(a1) - bne itmp3,L_class_loaded - - subq sp,8*8,sp /* allocate stack */ - stq t0,0*8(sp) /* save used register */ - stq t1,1*8(sp) - stq t3,2*8(sp) - stq xptr,3*8(sp) - stq xpc,4*8(sp) - stq pv,5*8(sp) - stq ra,6*8(sp) - stq a1,7*8(sp) - - mov a1,a0 - - br ra,L_class_load_ra /* set ra for gp loading */ -L_class_load_ra: - ldgp gp,0(ra) /* load gp */ - jsr ra,load_class_bootstrap - - ldq t0,0*8(sp) /* restore used register */ - ldq t1,1*8(sp) - ldq t3,2*8(sp) - ldq xptr,3*8(sp) - ldq xpc,4*8(sp) - ldq pv,5*8(sp) - ldq ra,6*8(sp) - ldq a1,7*8(sp) - addq sp,8*8,sp /* deallocate stack */ - -L_class_loaded: - ldl itmp3,offclasslinked(a1) - subq sp,8*8,sp /* allocate stack */ - stq a1,7*8(sp) - bne itmp3,L_class_linked - - stq t0,0*8(sp) /* save used register */ - stq t1,1*8(sp) - stq t3,2*8(sp) - stq xptr,3*8(sp) - stq xpc,4*8(sp) - stq pv,5*8(sp) - stq ra,6*8(sp) - - mov a1,a0 - - br ra,L_class_link_ra /* set ra for gp loading */ -L_class_link_ra: - ldgp gp,0(ra) /* load gp */ - jsr ra,link_class - - ldq t0,0*8(sp) /* restore used register */ - ldq t1,1*8(sp) - ldq t3,2*8(sp) - ldq xptr,3*8(sp) - ldq xpc,4*8(sp) - ldq pv,5*8(sp) - ldq ra,6*8(sp) - -L_class_linked: -_crit_restart1: - ldq a1,7*8(sp) -_crit_begin1: - ldq a0,offobjvftbl(xptr) /* a0 = vftblptr(xptr) */ - ldq a1,offclassvftbl(a1) /* a1 = vftblptr(catchtype) class (not obj) */ - ldl a0,offbaseval(a0) /* a0 = baseval(xptr) */ - ldl v0,offbaseval(a1) /* a2 = baseval(catchtype) */ - ldl a1,offdiffval(a1) /* a1 = diffval(catchtype) */ -_crit_end1: - subl a0,v0,a0 /* a0 = baseval(xptr) - baseval(catchtype) */ - cmpule a0,a1,v0 /* v0 = xptr is instanceof catchtype */ - addq sp,8*8,sp /* deallocate stack */ - beq v0,ex_table_cont /* if (false) continue */ - -ex_handle_it: - ldq xpc,ExHandlerPC(t1) /* xpc = exception handler pc */ - - beq t3,ex_jump /* if (!(no stack unwinding) skip */ - - ldq t0,0*8(sp) /* restore possible used registers */ - ldq t1,1*8(sp) /* also registers used by trace_exception */ - ldq t2,2*8(sp) - ldq t3,3*8(sp) - ldq t4,4*8(sp) - ldq t5,5*8(sp) - ldq t6,6*8(sp) - ldq t7,7*8(sp) - ldq t8,8*8(sp) - ldq t9,9*8(sp) - ldq t10,10*8(sp) - ldq v0,11*8(sp) - ldq a0,12*8(sp) - ldq a1,13*8(sp) - ldq a2,14*8(sp) - ldq a3,15*8(sp) - ldq a4,16*8(sp) - ldq a5,17*8(sp) - lda sp,18*8(sp) /* deallocate stack */ - -ex_jump: - jmp zero,(xpc) /* jump to the handler */ - -ex_table_cont: - lda t1,ExEntrySize(t1) /* next exception table entry */ - subl t0,1,t0 /* decrement entry counter */ - bgt t0,ex_table_loop /* if (t0 > 0) next entry */ - -empty_table: - beq t3,ex_already_cleared /* if here the first time, then */ - lda sp,18*8(sp) /* deallocate stack and */ - clr t3 /* clear the no unwind flag */ -ex_already_cleared: - ldl t0,IsSync(pv) /* t0 = SyncOffset */ - beq t0,no_monitor_exit /* if zero no monitorexit */ - -#if defined(USE_THREADS) - addq sp,t0,t0 /* add stackptr to Offset */ - ldq a0,-8(t0) /* load monitorexit pointer */ - - lda sp,-7*8(sp) /* allocate stack */ - stq t0,0*8(sp) /* save used register */ - stq t1,1*8(sp) - stq t3,2*8(sp) - stq xptr,3*8(sp) - stq xpc,4*8(sp) - stq pv,5*8(sp) - stq ra,6*8(sp) - - br ra,ex_mon_load /* set ra for gp loading */ -ex_mon_load: - ldgp gp,0(ra) /* load gp */ - jsr ra,builtin_monitorexit/* builtin_monitorexit(objectptr) */ - - ldq t0,0*8(sp) /* restore used register */ - ldq t1,1*8(sp) - ldq t3,2*8(sp) - ldq xptr,3*8(sp) - ldq xpc,4*8(sp) - ldq pv,5*8(sp) - ldq ra,6*8(sp) - lda sp,7*8(sp) /* deallocate stack */ -#endif + ldq ra,-1*8(t1) /* restore ra */ + subq t1,8,t1 /* t1-- */ -no_monitor_exit: - ldl t0,FrameSize(pv) /* t0 = frame size */ - addq sp,t0,sp /* unwind stack */ - mov sp,t0 /* t0 = pointer to save area */ - ldl t1,IsLeaf(pv) /* t1 = is leaf procedure */ - bne t1,ex_no_restore /* if (leaf) skip */ - ldq ra,-8(t0) /* restore ra */ - lda t0,-8(t0) /* t0-- */ -ex_no_restore: - mov ra,xpc /* the new xpc is ra */ - ldl t1,IntSave(pv) /* t1 = saved int register count */ - br t2,ex_int1 /* t2 = current pc */ +L_asm_handle_exception_no_ra_restore: + mov ra,xpc /* the new xpc is ra */ + ldl t2,IntSave(pv) /* t2 = saved int register count */ + br t3,ex_int1 /* t3 = current pc */ ex_int1: - lda t2,44(t2) /* lda t2,ex_int2-ex_int1(t2) !!!!!!!!!!!!! */ - negl t1,t1 /* negate register count */ - s4addq t1,t2,t2 /* t2 = ex_int_sav - 4 * register count */ - jmp zero,(t2) /* jump to save position */ - ldq s0,-56(t0) - ldq s1,-48(t0) - ldq s2,-40(t0) - ldq s3,-32(t0) - ldq s4,-24(t0) - ldq s5,-16(t0) - ldq s6,-8(t0) + lda t3,(ex_int2 - ex_int1)(t3) + negl t2,t2 /* negate register count */ + s4addq t2,t3,t3 /* t2 = IntSave - register count * 4 */ + jmp zero,(t3) /* jump to save position */ + + ldq s0,-7*8(t1) + ldq s1,-6*8(t1) + ldq s2,-5*8(t1) + ldq s3,-4*8(t1) + ldq s4,-3*8(t1) + ldq s5,-2*8(t1) + ldq s6,-1*8(t1) + ex_int2: - s8addq t1,t0,t0 /* t0 = t0 - 8 * register count */ + s8addq t2,t1,t1 /* t1 = t1 - 8 * register count */ - ldl t1,FltSave(pv) /* t1 = saved flt register count */ - br t2,ex_flt1 /* t2 = current pc */ + ldl t2,FltSave(pv) /* t2 = saved flt register count */ + br t3,ex_flt1 /* t3 = current pc */ ex_flt1: - lda t2,48(t2) /* lda t2,ex_flt2-ex_flt1(t2) !!!!!!!!!!!!! */ - negl t1,t1 /* negate register count */ - s4addq t1,t2,t2 /* t2 = ex_flt_sav - 4 * register count */ - jmp zero,(t2) /* jump to save position */ - ldt fs0,-64(t0) - ldt fs1,-56(t0) - ldt fs2,-48(t0) - ldt fs3,-40(t0) - ldt fs4,-32(t0) - ldt fs5,-24(t0) - ldt fs6,-16(t0) - ldt fs7,-8(t0) + lda t3,(ex_flt2 - ex_flt1)(t3) + negl t2,t2 /* negate register count */ + s4addq t2,t3,t3 /* t2 = FltSave - 4 * register count */ + jmp zero,(t3) /* jump to save position */ + + ldt fs0,-8*8(t1) + ldt fs1,-7*8(t1) + ldt fs2,-6*8(t1) + ldt fs3,-5*8(t1) + ldt fs4,-4*8(t1) + ldt fs5,-3*8(t1) + ldt fs6,-2*8(t1) + ldt fs7,-1*8(t1) + ex_flt2: - ldl t0,0(ra) /* load instruction LDA PV,xxx(RA) */ - sll t0,48,t0 - sra t0,48,t0 /* isolate offset */ - addq t0,ra,pv /* compute update address */ - ldl t0,4(ra) /* load instruction LDAH PV,xxx(PV) */ - srl t0,16,t0 /* isolate instruction code */ - lda t0,-0x177b(t0) /* test for LDAH */ - bne t0,ex_stack_loop - ldl t0,4(ra) /* load instruction LDAH PV,xxx(RA) */ - sll t0,16,t0 /* compute high offset */ - addl t0,0,t0 /* sign extend high offset */ - addq t0,pv,pv /* compute update address */ - br ex_stack_loop + ldl t1,FrameSize(pv) /* get frame size */ + addq sp,t1,sp /* unwind stack */ + br L_asm_handle_exception_stack_loop .end asm_handle_nat_exception -/* asm_wrapper_patcher ********************************************************* +/* asm_abstractmethoderror ***************************************************** + + Creates and throws an AbstractMethodError. + +*******************************************************************************/ + + .ent asm_abstractmethoderror + +asm_abstractmethoderror: + subq sp,2*8,sp /* create stackframe */ + stq ra,0*8(sp) /* save return address */ + addq sp,2*8,a0 /* pass java sp */ + mov ra,a1 /* pass exception address */ + jsr ra,exceptions_asm_new_abstractmethoderror + ldq ra,0*8(sp) /* restore return address */ + addq sp,2*8,sp /* remove stackframe */ + + mov v0,xptr /* get exception pointer */ + subq ra,4,xpc /* exception address is ra - 4 */ + br L_asm_handle_nat_exception + + .end asm_abstractmethoderror + + +/* asm_patcher_wrapper ********************************************************* XXX Stack layout: - 24 return address into JIT code (patch position) - 16 machine code (which is patched back later) - 8 unresolved class/method/field reference - 0 patcher function pointer to call + 40 return address into JIT code (patch position) + 32 pointer to virtual java_objectheader + 24 machine code (which is patched back later) + 16 unresolved class/method/field reference + 8 data segment displacement from load instructions + 0 patcher function pointer to call (pv afterwards) ATTENTION: itmp3 == gp! But we don't need gp do call the patcher function. *******************************************************************************/ - .ent asm_wrapper_patcher + .ent asm_patcher_wrapper -asm_wrapper_patcher: - lda sp,-(12+27+4)*8(sp) /* create stack frame */ +asm_patcher_wrapper: + lda sp,-((2+12+27+4)*8)(sp) /* create stack frame */ - SAVE_ARGUMENT_REGISTERS(0) /* save 6 int/6 float argument registers */ - SAVE_TEMPORARY_REGISTERS(12) /* save 11 int/16 float temporary registers */ + SAVE_RETURN_REGISTERS(0) /* save 1 int/1 float return registers */ + SAVE_ARGUMENT_REGISTERS(2) /* save 6 int/6 float argument registers */ + SAVE_TEMPORARY_REGISTERS(14) /* save 11 int/16 float temporary registers */ - stq itmp1,(12+27+0)*8(sp) /* save itmp1 */ - stq itmp2,(12+27+1)*8(sp) /* save itmp2 */ - stq ra,(12+27+2)*8(sp) /* save method return address (for leafs) */ - stq pv,(12+27+3)*8(sp) /* save pv of calling java function */ + stq itmp1,(2+12+27+0)*8(sp) /* save itmp1 */ + stq itmp2,(2+12+27+1)*8(sp) /* save itmp2 */ + stq ra,(2+12+27+2)*8(sp) /* save method return address (for leafs) */ + stq pv,(2+12+27+3)*8(sp) /* save pv of calling java function */ - lda a0,(1+12+27+4)*8(sp) /* pass sp, skip patcher function pointer */ - ldq pv,(0+12+27+4)*8(sp) /* get function pointer */ - jmp ra,(pv) /* call the patcher function */ + br ra,L_asm_patcher_wrapper_load_gp +L_asm_patcher_wrapper_load_gp: + ldgp gp,0(ra) /* load gp (it's not set correctly in jit) */ + + lda a0,(2+12+27+4)*8(sp) /* pass SP of patcher stub */ + mov pv,a1 /* pass PV */ + ldq a2,(2+12+27+2)*8(sp) /* pass RA (correct for leafs) */ + jsr ra,patcher_wrapper ldgp gp,0(ra) - - RESTORE_ARGUMENT_REGISTERS(0) /* restore 6 int/6 float argument registers */ - RESTORE_TEMPORARY_REGISTERS(12)/* restore 11 integer temporary registers */ + stq v0,(0+2+12+27+4)*8(sp) /* save return value */ - ldq itmp1,(12+27+0)*8(sp) /* restore itmp1 */ - ldq itmp2,(12+27+1)*8(sp) /* restore itmp2 */ - ldq ra,(12+27+2)*8(sp) /* restore method return address (for leafs)*/ - ldq pv,(12+27+3)*8(sp) /* restore pv of calling java function */ + RESTORE_RETURN_REGISTERS(0) /* restore 1 int/1 float return registers */ + RESTORE_ARGUMENT_REGISTERS(2) /* restore 6 int/6 float argument registers */ + RESTORE_TEMPORARY_REGISTERS(14) /* restore 11 integer temporary registers */ - ldq itmp3,(3+12+27+4)*8(sp)/* get return address (into JIT code) */ - lda sp,(4+12+27+4)*8(sp) /* remove stack frame */ + ldq itmp1,(2+12+27+0)*8(sp) /* restore itmp1 */ + ldq itmp2,(2+12+27+1)*8(sp) /* restore itmp2 */ + ldq ra,(2+12+27+2)*8(sp) /* restore method return address (for leafs)*/ + ldq pv,(2+12+27+3)*8(sp) /* restore pv of calling java function */ - beq v0,L_asm_wrapper_patcher_exception + ldq itmp3,(0+2+12+27+4)*8(sp) /* get return value */ + bne itmp3,L_asm_patcher_wrapper_exception + + ldq itmp3,(5+2+12+27+4)*8(sp) /* get RA to JIT */ + lda sp,(6+2+12+27+4)*8(sp) /* remove stack frame */ jmp zero,(itmp3) /* jump to new patched code */ -L_asm_wrapper_patcher_exception: - mov itmp3,xpc /* return address into JIT code is xpc */ - - br itmp1,L_asm_wrapper_patcher_exception_load_gp -L_asm_wrapper_patcher_exception_load_gp: - ldgp gp,0(itmp1) /* itmp3 == gp, load the current gp */ - -#if defined(USE_THREADS) && defined(NATIVE_THREADS) - subq sp,3*8,sp - stq xpc,0*8(sp) /* save return address (xpc) */ - stq ra,1*8(sp) - stq pv,2*8(sp) - jsr ra,builtin_asm_get_exceptionptrptr - ldq xpc,0*8(sp) /* restore return address (xpc) */ - ldq ra,1*8(sp) - ldq pv,2*8(sp) - addq sp,3*8,sp -#else - lda v0,_exceptionptr -#endif - ldq xptr,0(v0) /* get the exception pointer */ - stq zero,0(v0) /* clear the exception pointer */ - br asm_handle_exception /* we have the pv of the calling java func. */ +L_asm_patcher_wrapper_exception: + mov itmp3,xptr /* get exception */ + ldq xpc,(5+2+12+27+4)*8(sp) /* RA is xpc */ + lda sp,(6+2+12+27+4)*8(sp) /* remove stack frame */ + br L_asm_handle_exception - .end asm_wrapper_patcher + .end asm_patcher_wrapper -/************************ function asm_builtin_idiv **************************** -* * -* Does null check and calls idiv or throws an exception * -* * -*******************************************************************************/ +#if defined(ENABLE_REPLACEMENT) - .ent asm_builtin_idiv +/* asm_replacement_out ********************************************************* -asm_builtin_idiv: - ldgp gp,0(pv) - lda pv,builtin_idiv - beq a1,nb_idiv /* if (null) throw exception */ - jmp zero,(pv) /* else call builtin_idiv */ + This code is jumped to from the replacement-out stubs that are executed + when a thread reaches an activated replacement point. -nb_idiv: - ldq xptr,string_java_lang_ArithmeticException_message - lda xpc,-4(ra) /* faulting address is return adress - 4*/ - br asm_throw_and_handle_arithmetic_exception + The purpose of asm_replacement_out is to read out the parts of the + execution state that cannot be accessed from C code, store this state, + and then call the C function replace_me. - .end asm_builtin_idiv + Stack layout: + 16 start of stack inside method to replace + 0 rplpoint * info on the replacement point that was reached + NOTE: itmp3 has been clobbered by the replacement-out stub! -/************************ function asm_builtin_ldiv **************************** -* * -* Does null check and calls ldiv or throws an exception * -* * *******************************************************************************/ - .ent asm_builtin_ldiv +/* some room to accomodate changes of the stack frame size during replacement */ + /* XXX we should find a cleaner solution here */ +#define REPLACEMENT_ROOM 512 + +#define REPLACEMENT_STACK_OFFSET ((sizeexecutionstate + REPLACEMENT_ROOM + 0xf) & ~0xf) + + .ent asm_replacement_out + +asm_replacement_out: + /* create stack frame */ + lda sp,-(REPLACEMENT_STACK_OFFSET)(sp) + + /* save registers in execution state */ + stq $0 ,( 0*8+offes_intregs)(sp) + stq $1 ,( 1*8+offes_intregs)(sp) + stq $2 ,( 2*8+offes_intregs)(sp) + stq $3 ,( 3*8+offes_intregs)(sp) + stq $4 ,( 4*8+offes_intregs)(sp) + stq $5 ,( 5*8+offes_intregs)(sp) + stq $6 ,( 6*8+offes_intregs)(sp) + stq $7 ,( 7*8+offes_intregs)(sp) + stq $8 ,( 8*8+offes_intregs)(sp) + stq $9 ,( 9*8+offes_intregs)(sp) + stq $10,(10*8+offes_intregs)(sp) + stq $11,(11*8+offes_intregs)(sp) + stq $12,(12*8+offes_intregs)(sp) + stq $13,(13*8+offes_intregs)(sp) + stq $14,(14*8+offes_intregs)(sp) + stq $15,(15*8+offes_intregs)(sp) + stq $16,(16*8+offes_intregs)(sp) + stq $17,(17*8+offes_intregs)(sp) + stq $18,(18*8+offes_intregs)(sp) + stq $19,(19*8+offes_intregs)(sp) + stq $20,(20*8+offes_intregs)(sp) + stq $21,(21*8+offes_intregs)(sp) + stq $22,(22*8+offes_intregs)(sp) + stq $23,(23*8+offes_intregs)(sp) + stq $24,(24*8+offes_intregs)(sp) + stq $25,(25*8+offes_intregs)(sp) + stq $26,(26*8+offes_intregs)(sp) + stq $27,(27*8+offes_intregs)(sp) + stq $28,(28*8+offes_intregs)(sp) + stq $29,(29*8+offes_intregs)(sp) + stq $30,(30*8+offes_intregs)(sp) + stq $31,(31*8+offes_intregs)(sp) + + stt $f0 ,( 0*8+offes_fltregs)(sp) + stt $f1 ,( 1*8+offes_fltregs)(sp) + stt $f2 ,( 2*8+offes_fltregs)(sp) + stt $f3 ,( 3*8+offes_fltregs)(sp) + stt $f4 ,( 4*8+offes_fltregs)(sp) + stt $f5 ,( 5*8+offes_fltregs)(sp) + stt $f6 ,( 6*8+offes_fltregs)(sp) + stt $f7 ,( 7*8+offes_fltregs)(sp) + stt $f8 ,( 8*8+offes_fltregs)(sp) + stt $f9 ,( 9*8+offes_fltregs)(sp) + stt $f10,(10*8+offes_fltregs)(sp) + stt $f11,(11*8+offes_fltregs)(sp) + stt $f12,(12*8+offes_fltregs)(sp) + stt $f13,(13*8+offes_fltregs)(sp) + stt $f14,(14*8+offes_fltregs)(sp) + stt $f15,(15*8+offes_fltregs)(sp) + stt $f16,(16*8+offes_fltregs)(sp) + stt $f17,(17*8+offes_fltregs)(sp) + stt $f18,(18*8+offes_fltregs)(sp) + stt $f19,(19*8+offes_fltregs)(sp) + stt $f20,(20*8+offes_fltregs)(sp) + stt $f21,(21*8+offes_fltregs)(sp) + stt $f22,(22*8+offes_fltregs)(sp) + stt $f23,(23*8+offes_fltregs)(sp) + stt $f24,(24*8+offes_fltregs)(sp) + stt $f25,(25*8+offes_fltregs)(sp) + stt $f26,(26*8+offes_fltregs)(sp) + stt $f27,(27*8+offes_fltregs)(sp) + stt $f28,(28*8+offes_fltregs)(sp) + stt $f29,(29*8+offes_fltregs)(sp) + stt $f30,(30*8+offes_fltregs)(sp) + stt $f31,(31*8+offes_fltregs)(sp) + + /* calculate sp of method */ + lda itmp1,(REPLACEMENT_STACK_OFFSET + 2*8)(sp) + stq itmp1,(offes_sp)(sp) -asm_builtin_ldiv: - ldgp gp,0(pv) - lda pv,builtin_ldiv - beq a1,nb_ldiv /* if (null) throw exception */ - jmp zero,(pv) /* else call builtin_ldiv */ + br ra,L_asm_replacement_out_load_gp +L_asm_replacement_out_load_gp: + ldgp gp,0(ra) /* load gp */ -nb_ldiv: - ldq xptr,string_java_lang_ArithmeticException_message - lda xpc,-4(ra) /* faulting address is return adress - 4*/ - br asm_throw_and_handle_arithmetic_exception + /* store pv */ + stq pv,(offes_pv)(sp) - .end asm_builtin_ldiv + /* call replace_me */ + ldq a0,-(2*8)(itmp1) /* arg0: rplpoint * */ + mov sp,a1 /* arg1: execution state */ + jmp zero,replace_me /* call C function replace_me */ + jmp zero,abort /* NEVER REACHED */ + .end asm_replacement_out + +/* asm_replacement_in ********************************************************** + + This code writes the given execution state and jumps to the replacement + code. + + This function never returns! + + NOTE: itmp3 is not restored! + + C prototype: + void asm_replacement_in(executionstate *es, replace_safestack_t *st); -/************************ function asm_builtin_irem **************************** -* * -* Does null check and calls irem or throws an exception * -* * *******************************************************************************/ - .ent asm_builtin_irem + .ent asm_replacement_in + +asm_replacement_in: + /* a0 == executionstate *es */ -asm_builtin_irem: - ldgp gp,0(pv) - lda pv,builtin_irem - beq a1,nb_irem /* if (null) throw exception */ - jmp zero,(pv) /* else call builtin_irem */ + /* get arguments */ + mov a1,s1 /* replace_safestack_t *st */ + mov a0,s2 /* executionstate *es == safe stack */ -nb_irem: - ldq xptr,string_java_lang_ArithmeticException_message - lda xpc,-4(ra) /* faulting address is return adress - 4*/ - br asm_throw_and_handle_arithmetic_exception + /* switch to the safe stack */ + mov s2,sp - .end asm_builtin_irem + /* call replace_build_execution_state(st) */ + mov s1,a0 + jsr ra,replace_build_execution_state + /* set new sp */ + ldq sp,(offes_sp)(s2) -/************************ function asm_builtin_lrem **************************** -* * -* Does null check and calls lrem or throws an exception * -* * -*******************************************************************************/ + /* build stack frame */ + lda sp,(-sizeexecutionstate)(sp) - .ent asm_builtin_lrem + /* call replace_free_safestack(st,& of allocated executionstate_t) */ + mov sp,a1 /* tmpes */ + mov s1,a0 /* st */ + jsr ra,replace_free_safestack -asm_builtin_lrem: - ldgp gp,0(pv) - lda pv,builtin_lrem - beq a1,nb_lrem /* if (null) throw exception */ - jmp zero,(pv) /* else call builtin_lrem */ + /* set new pv */ + ldq pv,(offes_pv)(sp) + + /* copy registers from execution state */ + ldq $0 ,( 0*8+offes_intregs)(sp) + ldq $1 ,( 1*8+offes_intregs)(sp) + ldq $2 ,( 2*8+offes_intregs)(sp) + ldq $3 ,( 3*8+offes_intregs)(sp) + ldq $4 ,( 4*8+offes_intregs)(sp) + ldq $5 ,( 5*8+offes_intregs)(sp) + ldq $6 ,( 6*8+offes_intregs)(sp) + ldq $7 ,( 7*8+offes_intregs)(sp) + ldq $8 ,( 8*8+offes_intregs)(sp) + ldq $9 ,( 9*8+offes_intregs)(sp) + ldq $10,(10*8+offes_intregs)(sp) + ldq $11,(11*8+offes_intregs)(sp) + ldq $12,(12*8+offes_intregs)(sp) + ldq $13,(13*8+offes_intregs)(sp) + ldq $14,(14*8+offes_intregs)(sp) + ldq $15,(15*8+offes_intregs)(sp) + ldq a0, (16*8+offes_intregs)(sp) + ldq $17,(17*8+offes_intregs)(sp) + ldq $18,(18*8+offes_intregs)(sp) + ldq $19,(19*8+offes_intregs)(sp) + ldq $20,(20*8+offes_intregs)(sp) + ldq $21,(21*8+offes_intregs)(sp) + ldq $22,(22*8+offes_intregs)(sp) + ldq $23,(23*8+offes_intregs)(sp) + ldq $24,(24*8+offes_intregs)(sp) + ldq $25,(25*8+offes_intregs)(sp) + ldq $26,(26*8+offes_intregs)(sp) + /* $27 is pv */ + ldq $28,(28*8+offes_intregs)(sp) + ldq $29,(29*8+offes_intregs)(sp) + /* $30 is sp */ + /* $31 is zero */ + + ldt $f0 ,( 0*8+offes_fltregs)(sp) + ldt $f1 ,( 1*8+offes_fltregs)(sp) + ldt $f2 ,( 2*8+offes_fltregs)(sp) + ldt $f3 ,( 3*8+offes_fltregs)(sp) + ldt $f4 ,( 4*8+offes_fltregs)(sp) + ldt $f5 ,( 5*8+offes_fltregs)(sp) + ldt $f6 ,( 6*8+offes_fltregs)(sp) + ldt $f7 ,( 7*8+offes_fltregs)(sp) + ldt $f8 ,( 8*8+offes_fltregs)(sp) + ldt $f9 ,( 9*8+offes_fltregs)(sp) + ldt $f10,(10*8+offes_fltregs)(sp) + ldt $f11,(11*8+offes_fltregs)(sp) + ldt $f12,(12*8+offes_fltregs)(sp) + ldt $f13,(13*8+offes_fltregs)(sp) + ldt $f14,(14*8+offes_fltregs)(sp) + ldt $f15,(15*8+offes_fltregs)(sp) + ldt $f16,(16*8+offes_fltregs)(sp) + ldt $f17,(17*8+offes_fltregs)(sp) + ldt $f18,(18*8+offes_fltregs)(sp) + ldt $f19,(19*8+offes_fltregs)(sp) + ldt $f20,(20*8+offes_fltregs)(sp) + ldt $f21,(21*8+offes_fltregs)(sp) + ldt $f22,(22*8+offes_fltregs)(sp) + ldt $f23,(23*8+offes_fltregs)(sp) + ldt $f24,(24*8+offes_fltregs)(sp) + ldt $f25,(25*8+offes_fltregs)(sp) + ldt $f26,(26*8+offes_fltregs)(sp) + ldt $f27,(27*8+offes_fltregs)(sp) + ldt $f28,(28*8+offes_fltregs)(sp) + ldt $f29,(29*8+offes_fltregs)(sp) + ldt $f30,(30*8+offes_fltregs)(sp) + ldt $f31,(31*8+offes_fltregs)(sp) -nb_lrem: - ldq xptr,string_java_lang_ArithmeticException_message - lda xpc,-4(ra) /* faulting address is return adress - 4*/ - br asm_throw_and_handle_arithmetic_exception + /* load new pc */ - .end asm_builtin_lrem + ldq itmp3,offes_pc(sp) + /* remove stack frame */ -/******************* function asm_builtin_checkarraycast *********************** -* * -* Does the cast check and eventually throws an exception * -* * -*******************************************************************************/ + lda sp,(sizeexecutionstate)(sp) - .ent asm_builtin_checkarraycast + /* jump to new code */ -asm_builtin_checkarraycast: - ldgp gp,0(pv) - lda sp,-16(sp) /* allocate stack space */ - stq ra,0(sp) /* save return address */ - stq a0,8(sp) /* save object pointer */ - jsr ra,builtin_checkarraycast /* builtin_checkarraycast */ - ldgp gp,0(ra) - beq v0,nb_carray_throw /* if (false) throw exception */ - ldq ra,0(sp) /* restore return address */ - ldq v0,8(sp) /* return object pointer */ - lda sp,16(sp) /* free stack space */ - jmp zero,(ra) + jmp zero,(itmp3) -nb_carray_throw: - ldq ra,0(sp) - lda sp,16(sp) - lda xpc,-4(ra) - ldq xptr,string_java_lang_ClassCastException - jmp zero,asm_throw_and_handle_nat_exception -#if 0 - ldq a0,string_java_lang_ClassCastException - jsr ra,new_exception - ldgp gp,0(ra) - mov v0,xptr - - ldq ra,0(sp) /* restore return address */ - lda sp,16(sp) /* free stack space */ - lda xpc,-4(ra) /* faulting address is return adress - 4*/ - br asm_handle_nat_exception -#endif + .end asm_replacement_in - .end asm_builtin_checkarraycast +#endif /* defined(ENABLE_REPLACEMENT) */ -/******************* function asm_builtin_aastore ****************************** -* * -* Does the cast check and eventually throws an exception * -* * -*******************************************************************************/ +/* asm_compare_and_swap ******************************************************** - .ent asm_builtin_aastore + Does an atomic compare and swap. Required for the lock + implementation. -asm_builtin_aastore: - ldgp gp,0(pv) - beq a0,nb_aastore_null /* if null pointer throw exception */ - ldl t0,offarraysize(a0) /* load size */ - lda sp,-24(sp) /* allocate stack space */ - stq ra,0(sp) /* save return address */ - s8addq a1,a0,t1 /* add index*8 to arrayref */ - cmpult a1,t0,t0 /* do bound check */ - beq t0,nb_aastore_bound /* if out of bounds throw exception */ - mov a2,a1 /* object is second argument */ - stq t1,8(sp) /* save store position */ - stq a1,16(sp) /* save object */ - jsr ra,builtin_canstore /* builtin_canstore(arrayref,object) */ - ldgp gp,0(ra) - ldq ra,0(sp) /* restore return address */ - ldq a0,8(sp) /* restore store position */ - ldq a1,16(sp) /* restore object */ - lda sp,24(sp) /* free stack space */ - beq v0,nb_aastore_throw /* if (false) throw exception */ - stq a1,offobjarrdata(a0) /* store objectptr in array */ - jmp zero,(ra) + Atomically do the following: Check if the location still contains + `oldval`. If so, replace it by `newval` and return `oldval`. -nb_aastore_null: - ldq xptr,string_java_lang_NullPointerException - mov ra,xpc - jmp zero,asm_throw_and_handle_nat_exception -#if 0 - subq sp,8,sp /* allocate stack space */ - stq ra,0(sp) /* save return address */ - jsr ra,new_nullpointerexception - ldgp gp,0(ra) - mov v0,xptr - ldq ra,0(sp) - addq sp,8,sp - - mov ra,xpc /* faulting address is return adress */ - br asm_handle_nat_exception -#endif -nb_aastore_bound: - ldq ra,0(sp) - lda sp,24(sp) - mov ra,xpc - mov a1,xptr - jmp zero,asm_throw_and_handle_arrayindexoutofbounds_exception -#if 0 - ldq a0,string_java_lang_ArrayIndexOutOfBoundsException - jsr ra,new_exception_int /* a1 already contains the index */ - ldgp gp,0(ra) - mov v0,xptr - - ldq ra,0(sp) /* restore return address */ - lda sp,24(sp) /* free stack space */ - mov ra,xpc /* faulting address is return adress */ - br asm_handle_nat_exception -#endif -nb_aastore_throw: - mov ra,xpc - ldq xptr,string_java_lang_ArrayStoreException - jmp zero,asm_throw_and_handle_nat_exception -#if 0 - subq sp,8,sp /* allocate stack space */ - stq ra,0(sp) /* save return address */ - jsr ra,new_arraystoreexception - ldgp gp,0(ra) - mov v0,xptr - ldq ra,0(sp) - addq sp,8,sp - - mov ra,xpc /* faulting address is return adress */ - br asm_handle_nat_exception -#endif - .end asm_builtin_aastore + RETURN VALUE: + the old value at *p + long compare_and_swap(volatile long *p, long oldval, long newval); -/******************* function asm_initialize_thread_stack ********************** -* * -* initialized a thread stack * -* * *******************************************************************************/ - .ent asm_initialize_thread_stack - -asm_initialize_thread_stack: - lda a1,-128(a1) - stq zero, 0(a1) - stq zero, 8(a1) - stq zero, 16(a1) - stq zero, 24(a1) - stq zero, 32(a1) - stq zero, 40(a1) - stq zero, 48(a1) - stt fzero, 56(a1) - stt fzero, 64(a1) - stt fzero, 72(a1) - stt fzero, 80(a1) - stt fzero, 88(a1) - stt fzero, 96(a1) - stt fzero, 104(a1) - stt fzero, 112(a1) - stq a0, 120(a1) - mov a1, v0 + .ent asm_compare_and_swap + +asm_compare_and_swap: +1: + ldq_l v0,0(a0) + cmpeq v0,a1,t0 + beq t0,2f + mov a2,t0 + stq_c t0,0(a0) + beq t0,1b +2: jmp zero,(ra) - .end asm_initialize_thread_stack - + .end asm_compare_and_swap -/******************* function asm_perform_threadswitch ************************* -* * -* void asm_perform_threadswitch (u1 **from, u1 **to, u1 **stackTop); * -* * -* performs a threadswitch * -* * -*******************************************************************************/ - .ent asm_perform_threadswitch - -asm_perform_threadswitch: - subq sp,128,sp - stq s0, 0(sp) - stq s1, 8(sp) - stq s2, 16(sp) - stq s3, 24(sp) - stq s4, 32(sp) - stq s5, 40(sp) - stq s6, 48(sp) - stt fs0, 56(sp) - stt fs1, 64(sp) - stt fs2, 72(sp) - stt fs3, 80(sp) - stt fs4, 88(sp) - stt fs5, 96(sp) - stt fs6, 104(sp) - stt fs7, 112(sp) - stq ra, 120(sp) - stq sp, 0(a0) - stq sp, 0(a2) - ldq sp, 0(a1) - ldq s0, 0(sp) - ldq s1, 8(sp) - ldq s2, 16(sp) - ldq s3, 24(sp) - ldq s4, 32(sp) - ldq s5, 40(sp) - ldq s6, 48(sp) - ldt fs0, 56(sp) - ldt fs1, 64(sp) - ldt fs2, 72(sp) - ldt fs3, 80(sp) - ldt fs4, 88(sp) - ldt fs5, 96(sp) - ldt fs6, 104(sp) - ldt fs7, 112(sp) - ldq ra, 120(sp) - mov ra, pv - addq sp, 128, sp - jmp zero,(ra) - - .end asm_perform_threadswitch - - -/********************* function asm_switchstackandcall ************************* -* * -* void *asm_switchstackandcall (void *stack, void *func, void **stacktopsave, * -* void *p); * -* * -* Switches to a new stack, calls a function and switches back. * -* a0 new stack pointer * -* a1 function pointer * -* a2 pointer to variable where stack top should be stored * -* a3 pointer to user data, is passed to the function * -* * -*******************************************************************************/ +/* asm_memory_barrier ********************************************************** + A memory barrier for the Java Memory Model. - .ent asm_switchstackandcall +*******************************************************************************/ -asm_switchstackandcall: - lda a0,-2*8(a0) /* allocate new stack */ - stq ra,0(a0) /* save return address on new stack */ - stq sp,1*8(a0) /* save old stack pointer on new stack */ - stq sp,0(a2) /* save old stack pointer to variable */ - mov a0,sp /* switch to new stack */ - - mov a1,pv /* load function pointer */ - mov a3,a0 /* pass pointer */ - jmp ra,(pv) /* and call function */ + .ent asm_memory_barrier - ldq ra,0(sp) /* load return address */ - ldq sp,1*8(sp) /* switch to old stack */ +asm_memory_barrier: + mb + jmp zero,(ra) - jmp zero,(ra) /* return */ + .end asm_memory_barrier - .end asm_switchstackandcall .ent asm_getclassvalues_atomic asm_getclassvalues_atomic: -_crit_restart2: -_crit_begin2: +_crit_restart: +_crit_begin: ldl t0,offbaseval(a0) ldl t1,offdiffval(a0) ldl t2,offbaseval(a1) -_crit_end2: +_crit_end: stl t0,offcast_super_baseval(a2) stl t1,offcast_super_diffval(a2) stl t2,offcast_sub_baseval(a2) - jmp zero,(ra) + jmp zero,(ra) .end asm_getclassvalues_atomic + .data asm_criticalsections: -#if defined(USE_THREADS) && defined(NATIVE_THREADS) - .quad _crit_begin1 - .quad _crit_end1 - .quad _crit_restart1 - .quad _crit_begin2 - .quad _crit_end2 - .quad _crit_restart2 +#if defined(ENABLE_THREADS) + .quad _crit_begin + .quad _crit_end + .quad _crit_restart #endif .quad 0 - .ent asm_prepare_native_stackinfo -asm_prepare_native_stackinfo: - lda sp,-24(sp) - stq ra,0(sp) - jsr ra,builtin_asm_get_stackframeinfo - stq v0,16(sp) - ldq t0,0(v0) - stq t0,8(sp) - ldq ra,0(sp) - lda sp,8(sp) - stq sp,0(v0) - ret - .end asm_prepare_native_stackinfo - - .ent asm_remove_native_stackinfo -asm_remove_native_stackinfo: - ldq t0,0(sp) - ldq t1,8(sp) - stq t0,0(t1) - lda sp,40(sp) - ret - .end asm_remove_native_stackinfo +/* asm_md_init ***************************************************************** + + Initialize machine dependent stuff. + + Determines if the byte support instruction set (21164a and higher) + is available. + +*******************************************************************************/ + + .ent asm_md_init + +asm_md_init: + .long 0x47e03c20 /* amask 1,v0 */ + jmp zero,(ra) /* return */ + + .end asm_md_init + + +/* asm_cacheflush ************************************************************** + + XXX + +*******************************************************************************/ + + .ent asm_cacheflush + +asm_cacheflush: + call_pal PAL_imb /* synchronize instruction cache */ + jmp zero,(ra) + + .end asm_cacheflush + + +/* disable exec-stacks ********************************************************/ + +#if defined(__linux__) && defined(__ELF__) + .section .note.GNU-stack,"",@progbits +#endif + /* * These are local overrides for various environment variables in Emacs. @@ -1588,4 +869,5 @@ asm_remove_native_stackinfo: * c-basic-offset: 4 * tab-width: 4 * End: + * vim:noexpandtab:sw=4:ts=4: */