|
|
//++//// Module Name://// longjmp.s//// Abstract://// This module implements the IA64 specific routine to perform a long// jump operation.//// N.B. This routine conditionally provides SAFE & UNSAFE handling of longjmp// which is NOT integrated with structured exception handling. The// determination is made based on whether the Type field// has been set to a nonzero value.//// N.B. Currently, this routine assumes the setjmp site is EM.// Support for iA setjmp site is to be finished.//// Author://// William K. Cheung (wcheung) 30-Jan-1996//// Environment://// Any mode.//// Revision History://// Updated to EAS2.1.////--
#include "ksia64.h"
//++//// int// longjmp (// IN jmp_buf JumpBuffer,// IN int ReturnValue// )//// Routine Description://// This function performs a long jump to the context specified by the// jump buffer.//// Arguments://// JumpBuffer (a0) - Supplies the address of a jump buffer that contains// jump information.//// ReturnValue (a1) - Supplies the value that is to be returned to the// caller of set jump.//// Return Value://// None.////--
.global RtlUnwind2 .type RtlUnwind2, @function
NESTED_ENTRY(longjmp)
NESTED_SETUP(2, 2, 6, 0) .fframe ExceptionRecordLength+ContextFrameLength add sp = -ExceptionRecordLength-ContextFrameLength, sp ARGPTR(a0)
PROLOGUE_END
mov t4 = ar.rsc cmp.eq pt1, pt0 = zero, a1 add t6 = JbUnwindData, a0 ;;
ld8 out0 = [t6], 8 // get the UnwindData mov t2 = ar.bsp add t0 = JbIntNats, a0 ;;
//// If address of registration record is not equal to zero,// a safe longjmp is to be performed.//
cmp.ne pt2, pt3 = zero, out0 add t1 = JbBrS0, a0 add t22 = JbIntS0, a0 ;;
(pt1) add a1 = 1, r0 shr.u t22 = t22, 3 ;;
mov v0 = a1
//// before restoring integer registers, restore their NaT bits so that// the load fills will recover them correctly.//
(pt3) ld8 t7 = [t0], JbStIIP - JbIntNats (pt3) and t22 = 0x3f, t22 (pt2) br.spnt Lj30
mov ar.rsc = zero // put RSE in lazy mode ;;
mov t3 = ar.bspstore cmp4.ge pt1, pt0 = 4, t22 ;;
//// at the same time, compute and shift the loaded preserved integer// registers' NaTs to the proper location.//
ld8.nt1 t15 = [t0], JbBrS1 - JbStIIP ld8.nt1 t16 = [t1], JbBrS2 - JbBrS0 (pt0) add t21 = -4, t22 ;;
ld8.nt1 t17 = [t0], JbBrS3 - JbBrS1 ld8.nt1 t18 = [t1], JbBrS4 - JbBrS2 (pt0) add t6 = 68, t22 ;;
ld8.nt1 t19 = [t0], JbRsBSP - JbBrS3 ld8.nt1 t20 = [t1], JbRsPFS - JbBrS4 (pt1) sub t21 = 4, t22 ;;
ld8.nt1 t10 = [t0], JbApUNAT - JbRsBSP ld8.nt1 t11 = [t1], JbApLC - JbRsPFS (pt0) shl t5 = t7, t21 ;;
ld8.nt1 t12 = [t0] ld8.nt1 t13 = [t1], JbPreds - JbApLC (pt0) shr.u t8 = t7, t6 ;;
ld8.nt1 t14 = [t1] (pt1) shr t9 = t7, t21 (pt0) or t9 = t8, t5 ;;
extr.u t5 = t11, 7, 7 // local frame size extr.u t6 = t10, 3, 6 // rnat index ;;
sub t8 = 63, t6 mov t1 = t5 ;;
cmp.le pt2, pt1 = t8, t5 ;;
(pt2) add t1 = 1, t1(pt2) sub t5 = t5, t8(pt1) br.sptk Lj50 ;;
Lj40: cmp.le pt2, pt3 = 63, t5 ;;
(pt2) add t5 = -63, t5(pt2) add t1 = 1, t1(pt2) br.cond.dpnt Lj40 ;;
Lj50: shladd t10 = t1, 3, t10
//// t2 = current bsp// t3 = current bspstore// t4 = saved rsc// t9 = NaTs of sp, s0 - s3// t10 = setjmp's bsp// t11 = setjmp's pfs// t12 = setjmp's unat// t13 = setjmp's loop counter// t14 = setjmp's predicates// t15 = setjmp's brp (StIIP)// t16 = setjmp's bs0// t17 = setjmp's bs1// t18 = setjmp's bs2// t19 = setjmp's bs3// t20 = setjmp's bs4//// Now UNAT contains the NaTs of the preserved integer registers// at bit positions corresponding to the locations from which the// integer registers can be restored (with load fill operations)//// Restore predicates and loop counter.//
mov ar.unat = t9 mov pr = t14, -1 mov ar.lc = t13
add t0 = JbFltS0, a0 add t1 = JbFltS1, a0 mov ar.pfs = t11 ;;
//// scratch registers t5 - t9, t11, t13, t14 are available for use.//// load preserved floating point states from jump buffer// move the loaded branch register states to the corresponding br registers//
ldf.fill.nt1 fs0 = [t0], JbFltS2 - JbFltS0 ldf.fill.nt1 fs1 = [t1], JbFltS3 - JbFltS1 nop.i 0 ;;
ldf.fill.nt1 fs2 = [t0], JbFltS4 - JbFltS2 ldf.fill.nt1 fs3 = [t1], JbFltS5 - JbFltS3 mov brp = t15 ;;
ldf.fill.nt1 fs4 = [t0], JbFltS6 - JbFltS4 ldf.fill.nt1 fs5 = [t1], JbFltS7 - JbFltS5 mov bs0 = t16 ;;
ldf.fill.nt1 fs6 = [t0], JbFltS8 - JbFltS6 ldf.fill.nt1 fs7 = [t1], JbFltS9 - JbFltS7 mov bs1 = t17 ;;
ldf.fill.nt1 fs8 = [t0], JbFltS10 - JbFltS8 ldf.fill.nt1 fs9 = [t1], JbFltS11 - JbFltS9 mov bs2 = t18 ;;
ldf.fill.nt1 fs10 = [t0], JbFltS12 - JbFltS10 ldf.fill.nt1 fs11 = [t1], JbFltS13 - JbFltS11 mov bs3 = t19 ;;
ldf.fill.nt1 fs12 = [t0], JbFltS14 - JbFltS12 ldf.fill.nt1 fs13 = [t1], JbFltS15 - JbFltS13 mov bs4 = t20 ;;
ldf.fill.nt1 fs14 = [t0], JbFltS16 - JbFltS14 ldf.fill.nt1 fs15 = [t1], JbFltS17 - JbFltS15 brp.ret.sptk brp, Lj20 ;;
//// scratch registers t6 - t9, t11, t13 - t20 are available for use//// t2 is current bsp// t3 is current bspstore// t4 is saved rsc// t5 is the setjmp's fpsr// t10 is the setjmp's bsp// t12 is the setjmp's unat//
ldf.fill.nt1 fs16 = [t0], JbFltS18 - JbFltS16 ldf.fill.nt1 fs17 = [t1], JbFltS19 - JbFltS17 cmp.lt p0, pt1 = t3, t10 // current bspstore < setjmp's bsp ;;
ldf.fill.nt1 fs18 = [t0], JbFPSR - JbFltS18 ldf.fill.nt1 fs19 = [t1], JbIntS1 - JbFltS19 dep t9 = 1, t10, 3, 6 // OR 1s to get desired RNAT location ;; // t9 = OR(0x1f8, t10)
mov t11 = ar.rnat // save rnat for later use ld8.nt1 t5 = [t0], JbIntS0 - JbFPSR (pt1) br.cond.spnt Lj10 ;;
flushrs // Flush the RSE and move up nop.m 0 mov t3 = t2 // the current bspstore ;;
Lj10:
// // t3 is top of backing store in memory // t9 is desired RNAT collection location //
ld8.fill.nt1 s0 = [t0], JbIntS2 - JbIntS0 ld8.fill.nt1 s1 = [t1], JbIntS3 - JbIntS1 cmp.lt pt1, pt2 = t3, t9 // current top of backing store ;; // is smaller than desired RNAT
// collection location? // pt1: use RNAT app. register // pt2: load RNAT from bstore
ld8.fill.nt1 s2 = [t0], JbIntSp - JbIntS2 ld8.fill.nt1 s3 = [t1] nop.i 0 ;;
ld8.fill.nt1 t17 = [t0] // load setjmp's sp (pt2) ld8.nt1 t15 = [t9] // load desired RNAT nop.i 0 ;;
loadrs // invalidates dirty registers ;;
mov ar.bspstore = t10 // set bspstore register ;;
invala mov ar.unat = t12 // set unat mov sp = t17 // set stack pointer
(pt2) mov ar.rnat = t15 // set rnat to loaded value (pt1) mov ar.rnat = t11 // reuse rnat content nop.i 0
Lj20: mov ar.rsc = t4 // restore RSC ;;
mov ar.fpsr = t5 // restore FPSR br.ret.sptk.clr brp // return to setjmp site
Lj30:
//// t6 -> UnwindData+8// out0 - target psp// out1 - target bsp// out2 - target ip (setjmp's StIIP)// out3 - exception record address// out4 - return value// out5 - context record address//
add t5 = JbStIIP, a0 add t0 = ErExceptionCode+STACK_SCRATCH_AREA, sp add t1 = ErExceptionFlags+STACK_SCRATCH_AREA, sp ;;
ld8 out1 = [t6] // target bsp movl v0 = STATUS_LONGJUMP // get long jump status code
ld8 out2 = [t5] // target ip st4 [t1] = zero, ErExceptionAddress - ErExceptionFlags add out3 = STACK_SCRATCH_AREA, sp ;;
st4 [t0] = v0, ErExceptionInformation - ErExceptionCode STPTRINC(t1, zero, ErExceptionRecord - ErExceptionAddress) mov out4 = a1 ;;
STPTR(t0, a0) STPTRINC(t1, zero, ErNumberParameters - ErExceptionRecord) mov t4 = 1 // set to 1 argument ;;
st4 [t1] = t4 add out5 = STACK_SCRATCH_AREA+ExceptionRecordLength, sp br.call.sptk.many brp = RtlUnwind2 // call RtlUnwind2
NESTED_EXIT(longjmp)
|
