-/* jit/alpha/asmpart.S - Java-C interface functions for alpha
+/* vm/jit/alpha/asmpart.S - Java-C interface functions for alpha
- Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
- Institut f. Computersprachen, TU Wien
- R. Grafl, A. Krall, C. Kruegel, C. Oates, R. Obermaisser, M. Probst,
- S. Ring, E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich,
- J. Wenninger
+ 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
This file is part of CACAO.
Authors: Andreas Krall
Reinhard Grafl
- $Id: asmpart.S 1077 2004-05-20 18:06:55Z twisti $
+ Changes: Joseph Wenninger
+
+ $Id: asmpart.S 1735 2004-12-07 14:33:27Z twisti $
*/
#include "config.h"
-#include "offsets.h"
-
-
-#define MethodPointer -8
-#define FrameSize -12
-#define IsSync -16
-#define IsLeaf -20
-#define IntSave -24
-#define FltSave -28
-/* DEFINE LINE NUMBER STUFF HERE */
-#define ExTableSize -56
-#define ExTableStart -56
-
-#define ExEntrySize -32
-#define ExStartPC -8
-#define ExEndPC -16
-#define ExHandlerPC -24
-#define ExCatchType -32
+#include "vm/jit/alpha/offsets.h"
+#include "vm/jit/alpha/asmoffsets.h"
#define v0 $0
#define fzero $f31
-#define PAL_imb 134
+#define PAL_imb 0x86
.text
.set noat
/********************* exported functions and variables ***********************/
.globl has_no_x_instr_set
- .globl synchronize_caches
.globl asm_calljavafunction
.globl asm_calljavafunction2
.globl asm_calljavafunction2double
.globl asm_calljavafunction2long
.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_check_clinit
.globl asm_perform_threadswitch
.globl asm_initialize_thread_stack
.globl asm_switchstackandcall
- .globl asm_getcallingmethod
.globl asm_builtin_trace
.globl asm_builtin_exittrace
.globl asm_criticalsections
.globl asm_getclassvalues_atomic
+ .globl asm_prepare_native_stackinfo
+ .globl asm_remove_native_stackinfo
+ .globl asm_refillin_and_handle_exception
/*************************** imported functions *******************************/
.globl jit_compile
- .globl _exceptionptr
.globl builtin_monitorexit
.globl builtin_throw_exception
.globl builtin_trace_exception
jsr ra,jit_compile /* jit compiler */
ldgp gp,0(ra)
- call_pal PAL_imb /* synchronise instruction cache */
-
ldq a0,0*8(sp) /* load argument registers */
ldq a1,1*8(sp)
ldq a2,2*8(sp)
addq t8,$28,t8 /* compute update address via method pointer*/
stq v0,0(t8) /* save new method address there */
+ call_pal PAL_imb /* synchronise instruction cache */
+
mov v0,pv /* load method address into pv */
jmp zero,(pv) /* and call method. The method returns */
.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_fillInStackTrace_desc
+ ldq a1,utf_fillInStackTrace_name
+ 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); *
+* *
+*******************************************************************************/
+
+ .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)
+
+ ldq a0,6*8(sp) /*int of exception*/
+ jsr ra,new_arrayindexoutofboundsexception
+ 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_arrayindexoutofbounds_exception
+
+
+/* asm_throw_and_handle_arithmetic_exception ***********************************
+
+ DOCUMENT ME!
+
+*******************************************************************************/
+
+ .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
+
+
+/**************** function asm_throw_and_handle_exception **********************
+* *
+* This function handles an exception. It does not use the usual calling *
+* conventions. The exception class name is passed in REG_ITMP1 and the *
+* pc from the exception raising position is passed in REG_ITMP2. *
+* *
+* void asm_handle_exception (exceptionclass, exceptionpc); *
+* *
+*******************************************************************************/
+ .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 itmp1,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)*/
+ jsr ra,asm_prepare_native_stackinfo /* puts 2 additional quadwords on stack */
+ ldgp gp,0(ra)
+
+ ldq a0,6*8(sp) /*classname of exception*/
+ jsr ra,new_exception
+ 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_nat_exception
+
+
/********************* function asm_handle_exception ***************************
* *
* This function handles an exception. It does not use the usual calling *
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
+ 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 */
.end asm_handle_nat_exception
-/********************* asm_check_clinit ****************************************
-* *
-* Does null check and calls monitorenter or throws an exception *
-* *
+/* asm_check_clinit ************************************************************
+
+ DOCUMENT ME!!!
+
+ Arguments:
+
+ itmp1: pointer to class
+
+ Stack layout:
+
+ 0 mcode ; machine code to patch back in
+
*******************************************************************************/
.ent asm_check_clinit
asm_check_clinit:
- ldgp gp,0(pv)
-
+ ldgp gp,0(itmp2) /* function is called via `jsr ra,itmp1' */
+
+ subq sp,8*8,sp
+
+ stq ra,0*8(sp) /* save return address */
+ stq pv,1*8(sp) /* save pv of calling java function */
+ stq a0,2*8(sp) /* save argument registers for leaf */
+ stq a1,3*8(sp) /* functions and native stub */
+ stq a2,4*8(sp)
+ stq a3,5*8(sp)
+ stq a4,6*8(sp)
+ stq a5,7*8(sp)
+
ldl itmp2,offclassinit(itmp1)
bne itmp2,L_is_initialized
- subq sp,7*8,sp
- stq ra,0*8(sp)
- stq a0,1*8(sp) /* save argument registers for leaf */
- stq a1,2*8(sp) /* functions and native stub */
- stq a2,3*8(sp)
- stq a3,4*8(sp)
- stq a4,5*8(sp)
- stq a5,6*8(sp)
-
- mov itmp1,a0
+ mov itmp1,a0 /* move class pointer to a0 */
jsr ra,class_init
+ ldgp gp,0(ra)
- ldgp gp,0(ra)
- ldq ra,0*8(sp)
- ldq a0,1*8(sp) /* restore argument registers */
- ldq a1,2*8(sp)
- ldq a2,3*8(sp)
- ldq a3,4*8(sp)
- ldq a4,5*8(sp)
- ldq a5,6*8(sp)
- addq sp,7*8,sp
-
beq v0,L_initializererror
L_is_initialized:
- mov ra,itmp1 /* now patch the calling code */
- subq itmp1,(3*4),itmp1 /* go back 3 instructions */
- ldah itmp2,-15392(zero) /* br -- 0xc3e0 == -15392 */
- lda itmp2,4(itmp2) /* jump over 4 instructions */
- stl itmp2,0(itmp1) /* store the new branch: br +4 */
+ ldq ra,0*8(sp) /* get return address */
+ subq ra,1*4,ra /* go back 1 instruction */
+ ldl itmp1,8*8(sp) /* load machine code from stack */
+ stl itmp1,0(ra) /* store the machine code */
+
+ call_pal PAL_imb /* synchronise instruction cache */
+
+ ldq ra,0*8(sp) /* restore return address */
+ ldq pv,1*8(sp) /* restore pv of calling java function */
+ ldq a0,2*8(sp) /* restore argument registers */
+ ldq a1,3*8(sp)
+ ldq a2,4*8(sp)
+ ldq a3,5*8(sp)
+ ldq a4,6*8(sp)
+ ldq a5,7*8(sp)
+
+ addq sp,(8+1)*8,sp /* remove stack frame (+1 for machine code) */
- jmp zero,(ra)
+ subq ra,1*4,ra /* go back 1 instruction */
+ jmp zero,(ra) /* jump to the new code */
L_initializererror:
#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
- ldq xptr,0(v0) /* get the exception pointer */
- stq zero,0(v0) /* clear the exception pointer */
#else
- lda itmp3,_exceptionptr
- ldq xptr,0(itmp3)
- stq zero,0(itmp3)
+ lda v0,_exceptionptr
#endif
+ ldq xptr,0(v0) /* get the exception pointer */
+ stq zero,0(v0) /* clear the exception pointer */
+
+ ldq ra,0*8(sp) /* restore return address */
+ ldq pv,1*8(sp) /* restore pv of calling java function */
+ ldq a0,2*8(sp) /* restore argument registers */
+ ldq a1,3*8(sp)
+ ldq a2,4*8(sp)
+ ldq a3,5*8(sp)
+ ldq a4,6*8(sp)
+ ldq a5,7*8(sp)
+
+ addq sp,(8+1)*8,sp /* remove stack frame (+1 for machine code) */
subq ra,4,xpc
- br asm_handle_nat_exception
+ br asm_handle_exception /* we have the pv of the calling java func. */
.end asm_check_clinit
jmp zero,(pv) /* else call builtin_monitorenter */
nb_monitorenter:
+ lda xpc,-4(ra)
+ ldq xptr,string_java_lang_NullPointerException
+ jmp zero,asm_throw_and_handle_nat_exception
+#if 0
subq sp,8,sp
stq ra,0(sp)
- ldq a0,string_java_lang_NullPointerException
- jsr ra,new_exception
+ jsr ra,new_nullpointerexception
ldgp gp,0(ra)
mov v0,xptr
ldq ra,0(sp)
lda xpc,-4(ra) /* faulting address is return adress - 4*/
br asm_handle_nat_exception
-
+#endif
.end asm_builtin_monitorenter
jmp zero,(pv) /* else call builtin_monitorexit */
nb_monitorexit:
+ lda xpc,-4(ra)
+ ldq xptr,string_java_lang_NullPointerException
+ jmp zero,asm_throw_and_handle_nat_exception
+#if 0
subq sp,8,sp
stq ra,0(sp)
- ldq a0,string_java_lang_NullPointerException
- jsr ra,new_exception
+ jsr ra,new_nullpointerexception
ldgp gp,0(ra)
mov v0,xptr
ldq ra,0(sp)
lda xpc,-4(ra) /* faulting address is return adress - 4*/
br asm_handle_nat_exception
-
+#endif
.end asm_builtin_monitorexit
jmp zero,(pv) /* else call builtin_idiv */
nb_idiv:
- subq sp,8,sp
- stq ra,0(sp)
- ldq a0,string_java_lang_ArithmeticException
- ldq a1,string_java_lang_ArithmeticException_message
- jsr ra,new_exception_message
- ldgp gp,0(ra)
- mov v0,xptr
- ldq ra,0(sp)
- addq sp,8,sp
-
+ ldq xptr,string_java_lang_ArithmeticException_message
lda xpc,-4(ra) /* faulting address is return adress - 4*/
- br asm_handle_nat_exception
+ br asm_throw_and_handle_arithmetic_exception
.end asm_builtin_idiv
jmp zero,(pv) /* else call builtin_ldiv */
nb_ldiv:
- subq sp,8,sp
- stq ra,0(sp)
- ldq a0,string_java_lang_ArithmeticException
- ldq a1,string_java_lang_ArithmeticException_message
- jsr ra,new_exception_message
- ldgp gp,0(ra)
- mov v0,xptr
- ldq ra,0(sp)
- addq sp,8,sp
-
+ ldq xptr,string_java_lang_ArithmeticException_message
lda xpc,-4(ra) /* faulting address is return adress - 4*/
- br asm_handle_nat_exception
+ br asm_throw_and_handle_arithmetic_exception
.end asm_builtin_ldiv
jmp zero,(pv) /* else call builtin_irem */
nb_irem:
- subq sp,8,sp
- stq ra,0(sp)
- ldq a0,string_java_lang_ArithmeticException
- ldq a1,string_java_lang_ArithmeticException_message
- jsr ra,new_exception_message
- ldgp gp,0(ra)
- mov v0,xptr
- ldq ra,0(sp)
- addq sp,8,sp
-
+ ldq xptr,string_java_lang_ArithmeticException_message
lda xpc,-4(ra) /* faulting address is return adress - 4*/
- br asm_handle_nat_exception
+ br asm_throw_and_handle_arithmetic_exception
.end asm_builtin_irem
jmp zero,(pv) /* else call builtin_lrem */
nb_lrem:
- subq sp,8,sp
- stq ra,0(sp)
- ldq a0,string_java_lang_ArithmeticException
- ldq a1,string_java_lang_ArithmeticException_message
- jsr ra,new_exception_message
- ldgp gp,0(ra)
- mov v0,xptr
- ldq ra,0(sp)
- addq sp,8,sp
-
+ ldq xptr,string_java_lang_ArithmeticException_message
lda xpc,-4(ra) /* faulting address is return adress - 4*/
- br asm_handle_nat_exception
+ br asm_throw_and_handle_arithmetic_exception
.end asm_builtin_lrem
jmp zero,(ra)
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)
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_builtin_checkarraycast
stq a1,offobjarrdata(a0) /* store objectptr in array */
jmp zero,(ra)
-nb_aastore_null:
+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 */
- ldq a0,string_java_lang_NullPointerException
- jsr ra,new_exception
+ jsr ra,new_nullpointerexception
ldgp gp,0(ra)
mov v0,xptr
ldq ra,0(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)
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 */
- ldq a0,string_java_lang_ArrayStoreException
- jsr ra,new_exception
+ jsr ra,new_arraystoreexception
ldgp gp,0(ra)
mov v0,xptr
ldq ra,0(sp)
mov ra,xpc /* faulting address is return adress */
br asm_handle_nat_exception
-
+#endif
.end asm_builtin_aastore
asm_getclassvalues_atomic:
_crit_restart2:
_crit_begin2:
- ldq t0,offbaseval(a0)
- ldq t1,offdiffval(a0)
- ldq t2,offbaseval(a1)
+ ldl t0,offbaseval(a0)
+ ldl t1,offdiffval(a0)
+ ldl t2,offbaseval(a1)
_crit_end2:
- stq t0,offcast_super_baseval(a2)
- stq t1,offcast_super_diffval(a2)
- stq t2,offcast_sub_baseval(a2)
- jmp zero,(ra)
+ stl t0,offcast_super_baseval(a2)
+ stl t1,offcast_super_diffval(a2)
+ stl t2,offcast_sub_baseval(a2)
+ jmp zero,(ra)
.end asm_getclassvalues_atomic
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
+ .quad _crit_begin1
+ .quad _crit_end1
+ .quad _crit_restart1
+ .quad _crit_begin2
+ .quad _crit_end2
+ .quad _crit_restart2
#endif
- .quad 0
+ .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
/*
* These are local overrides for various environment variables in Emacs.
projects / cacao.git / blobdiff