1/* libunwind - a platform-independent unwind library 2 Copyright (C) 2003 Hewlett-Packard Co 3 Contributed by David Mosberger-Tang <davidm@hpl.hp.com> 4 5This file is part of libunwind. 6 7Permission is hereby granted, free of charge, to any person obtaining 8a copy of this software and associated documentation files (the 9"Software"), to deal in the Software without restriction, including 10without limitation the rights to use, copy, modify, merge, publish, 11distribute, sublicense, and/or sell copies of the Software, and to 12permit persons to whom the Software is furnished to do so, subject to 13the following conditions: 14 15The above copyright notice and this permission notice shall be 16included in all copies or substantial portions of the Software. 17 18THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 19EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 20MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 21NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE 22LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 23OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 24WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ 25 26#include "ia64-test-rbs.h" 27 28 .common stackmem, NSTACKS*STACK_SIZE, 16 29 30 .text 31 32#define SAVED_SP_OFF 0 33#define SAVED_RP_OFF 8 34#define SAVED_PFS_OFF 16 35#define SAVED_RNAT_OFF 24 36#define SAVED_BSP_OFF 32 37#define SAVED_BSPSTORE_OFF 40 38#define FRAME_SIZE 48 39 40#define SPILL(n) \ 41 /* int rbs_spill_#n(long iteration, int (*next_func[])()) */ \ 42 .globl rbs_spill_##n; \ 43 .proc rbs_spill_##n; \ 44rbs_spill_##n: \ 45 .prologue; \ 46 alloc r18 = ar.pfs, 2, (n)-2, 2, 0;/* read ar.pfs */ \ 47 /* first, calculate address of new stack: */ \ 48 addl r2 = @ltoff(stackmem), gp; \ 49 add r8 = 1, in0; \ 50 ;; \ 51 ld8 r2 = [r2]; /* r2 = &stackmem */ \ 52 shl r3 = in0, STACK_SIZE_SHIFT; \ 53 shladd r8 = r8, 3, in1; /* r8 = &next_func[iteration+1] */ \ 54 ;; \ 55 ld8 r8 = [r8]; /* r8 = next_func[iteration+1] */ \ 56 add r2 = r2, r3; /* r2 = stackmem[iteration] */ \ 57 ;; \ 58 ld8 r9 = [r8], 8;; /* r9 = target's entry-point */ \ 59 ld8 gp = [r8]; /* r22 = target's gp */ \ 60 addl r3 = STACK_SIZE-FRAME_SIZE, r2; /* r3 = &stackframe */ \ 61 ;; \ 62 mov b6 = r9; \ 63 st8 [r3] = sp; \ 64 .vframesp SAVED_SP_OFF+16; \ 65 adds sp = -16, r3; /* switch the memory stack */ \ 66 ;; \ 67 adds r3 = (SAVED_RP_OFF - SAVED_SP_OFF), r3; \ 68 mov r16 = rp; \ 69 ;; \ 70 .savesp rp, SAVED_RP_OFF+16; \ 71 st8 [r3] = r16, (SAVED_PFS_OFF - SAVED_RP_OFF); \ 72 ;; \ 73 .savesp ar.pfs, SAVED_PFS_OFF+16; \ 74 st8 [r3] = r18, (SAVED_BSP_OFF - SAVED_PFS_OFF); \ 75 mov r16 = ar.bsp; \ 76 mov r17 = ar.bspstore; \ 77 mov r18 = ar.rnat; \ 78 ;; \ 79 .savesp ar.bsp, SAVED_BSP_OFF+16; \ 80 st8 [r3] = r16, (SAVED_BSPSTORE_OFF - SAVED_BSP_OFF); \ 81 ;; \ 82 .savesp ar.bspstore, SAVED_BSPSTORE_OFF+16; \ 83 st8 [r3] = r17, (SAVED_RNAT_OFF - SAVED_BSPSTORE_OFF); \ 84 mov out1 = in1; \ 85 ;; \ 86 .savesp ar.rnat, SAVED_RNAT_OFF+16; \ 87 st8 [r3] = r18; \ 88 .body; \ 89 mov ar.bspstore = r2; /* switch the backing store */ \ 90 adds out0 = 1, in0; \ 91 ;; \ 92 br.call.sptk.many rp = b6; \ 931: /* switch back to stack: */ \ 94 adds r3 = SAVED_SP_OFF+16, sp; \ 95 cmp.ge p8, p0 = r8, r0; \ 96 ;; \ 97(p8) add r8 = 1, r8; \ 98 ld8 r16 = [r3], (SAVED_RP_OFF-SAVED_SP_OFF);; /* saved sp */ \ 99 ld8 r17 = [r3], (SAVED_PFS_OFF-SAVED_RP_OFF);; /* saved rp */ \ 100 ld8 r18 = [r3], (SAVED_RNAT_OFF-SAVED_PFS_OFF);;/* saved pfs */ \ 101 ld8 r19 = [r3], (SAVED_BSP_OFF-SAVED_RNAT_OFF);;/* saved rnat */ \ 102 ld8 r20 = [r3], (SAVED_BSPSTORE_OFF-SAVED_BSP_OFF);;/* saved bsp */ \ 103 ld8 r21 = [r3];; /* saved bspstore */ \ 104 mov rp = r17; \ 105 mov ar.pfs = r18; \ 106 shl r3 = in0, STACK_SIZE_SHIFT; \ 107 addl r2 = @ltoff(stackmem), gp;; \ 108 ld8 r2 = [r2];; /* r2 = &stackmem */ \ 109 add r2 = r2, r3; /* r2 = stackmem[iteration] */ \ 110 mov r3 = ar.bsp;; \ 111 sub r2 = r3, r2;; /* r2 = dirty_size */ \ 112 shl r2 = r2, 16;; \ 113 mov ar.rsc = r2;; \ 114 alloc r3 = ar.pfs, 0, 0, 0, 0;; \ 115 loadrs;; \ 116 mov ar.bspstore = r21;; /* this also restores ar.bsp */ \ 117 mov ar.rnat = r19; \ 118 .restore sp; \ 119 mov sp = r16; \ 120 br.ret.sptk.many rp; \ 121 .endp rbs_spill_##n 122 123 SPILL(2); SPILL(3) 124 SPILL(4); SPILL(5); SPILL(6); SPILL(7) 125 SPILL(8); SPILL(9); SPILL(10); SPILL(11) 126 SPILL(12); SPILL(13); SPILL(14); SPILL(15) 127 SPILL(16); SPILL(17); SPILL(18); SPILL(19) 128 SPILL(20); SPILL(21); SPILL(22); SPILL(23) 129 SPILL(24); SPILL(25); SPILL(26); SPILL(27) 130 SPILL(28); SPILL(29); SPILL(30); SPILL(31) 131 SPILL(32); SPILL(33); SPILL(34); SPILL(35) 132 SPILL(36); SPILL(37); SPILL(38); SPILL(39) 133 SPILL(40); SPILL(41); SPILL(42); SPILL(43) 134 SPILL(44); SPILL(45); SPILL(46); SPILL(47) 135 SPILL(48); SPILL(49); SPILL(50); SPILL(51) 136 SPILL(52); SPILL(53); SPILL(54); SPILL(55) 137 SPILL(56); SPILL(57); SPILL(58); SPILL(59) 138 SPILL(60); SPILL(61); SPILL(62); SPILL(63) 139 SPILL(64); SPILL(65); SPILL(66); SPILL(67) 140 SPILL(68); SPILL(69); SPILL(70); SPILL(71) 141 SPILL(72); SPILL(73); SPILL(74); SPILL(75) 142 SPILL(76); SPILL(77); SPILL(78); SPILL(79) 143 SPILL(80); SPILL(81); SPILL(82); SPILL(83) 144 SPILL(84); SPILL(85); SPILL(86); SPILL(87) 145 SPILL(88); SPILL(89); SPILL(90); SPILL(91) 146 SPILL(92); SPILL(93); SPILL(94) 147 148#define LD_LOC(n) \ 149 ld4 loc##n = [in1], 4;; \ 150 cmp.eq p8, p9 = r0, loc##n;; \ 151(p9) or loc##n = loc##n, r8; \ 152(p8) ld4.s loc##n = [r0] 153 154#define CK_LOC(n) \ 155 ld4 r16 = [in1], 4;; \ 156 cmp.eq p8, p9 = r0, r16; \ 157 or r16 = r16, r9;; \ 158(p8) tnat.z p10, p0 = loc##n; \ 159(p9) cmp.ne p10, p0 = r16, loc##n; \ 160 ;; \ 161(p10) mov r8 = -n; \ 162(p10) br.cond.spnt.many .fail 163 164 /* int loadup(long iteration, int *values, next_func[]) */ 165 166 .global loadup 167 .proc loadup 168loadup: 169 .prologue 170 .save ar.pfs, r36 171 alloc loc1 = ar.pfs, 3, 90, 3, 0 172 .save rp, loc0 173 mov loc0 = rp 174 .body 175 cmp.eq p6, p7 = 1, in0 176 ;; 177 mov ar.rsc = 0 // put RSE into enforced lazy mode 178(p6) mov out1 = in2 179(p7) mov out2 = in2 180 181(p6) ld8 r17 = [in2] // get address of function descriptor 182(p7) add out0 = -1, in0 183(p7) mov out1 = in1 184 185 ;; 186(p6) ld8 r16 = [r17], 8 // load entry point 187 shl r8 = in0, 32 // store iteration # in top 32 bits 188 mov r18 = in1 189 ;; 190(p6) ld8 r1 = [r17] // load gp 191(p6) mov b6 = r16 192 193(p6) mov out0 = 0 194 ;; 195 LD_LOC( 2); LD_LOC( 3) 196 LD_LOC( 4); LD_LOC( 5); LD_LOC( 6); LD_LOC( 7) 197 LD_LOC( 8); LD_LOC( 9); LD_LOC(10); LD_LOC(11) 198 LD_LOC(12); LD_LOC(13); LD_LOC(14); LD_LOC(15) 199 LD_LOC(16); LD_LOC(17); LD_LOC(18); LD_LOC(19) 200 LD_LOC(20); LD_LOC(21); LD_LOC(22); LD_LOC(23) 201 LD_LOC(24); LD_LOC(25); LD_LOC(26); LD_LOC(27) 202 LD_LOC(28); LD_LOC(29); LD_LOC(30); LD_LOC(31) 203 LD_LOC(32); LD_LOC(33); LD_LOC(34); LD_LOC(35) 204 LD_LOC(36); LD_LOC(37); LD_LOC(38); LD_LOC(39) 205 LD_LOC(40); LD_LOC(41); LD_LOC(42); LD_LOC(43) 206 LD_LOC(44); LD_LOC(45); LD_LOC(46); LD_LOC(47) 207 LD_LOC(48); LD_LOC(49); LD_LOC(50); LD_LOC(51) 208 LD_LOC(52); LD_LOC(53); LD_LOC(54); LD_LOC(55) 209 LD_LOC(56); LD_LOC(57); LD_LOC(58); LD_LOC(59) 210 LD_LOC(60); LD_LOC(61); LD_LOC(62); LD_LOC(63) 211 LD_LOC(64); LD_LOC(65); LD_LOC(66); LD_LOC(67) 212 LD_LOC(68); LD_LOC(69); LD_LOC(70); LD_LOC(71) 213 LD_LOC(72); LD_LOC(73); LD_LOC(74); LD_LOC(75) 214 LD_LOC(76); LD_LOC(77); LD_LOC(78); LD_LOC(79) 215 LD_LOC(80); LD_LOC(81); LD_LOC(82); LD_LOC(83) 216 LD_LOC(84); LD_LOC(85); LD_LOC(86); LD_LOC(87) 217 LD_LOC(88); LD_LOC(89) 218 ;; 219{ .mbb 220 mov in1 = r18 221(p6) br.call.sptk.many rp = b6 222(p7) br.call.sptk.many rp = loadup 223} 224 cmp.lt p8, p9 = r8, r0 225 shl r9 = in0, 32 // store iteration # in top 32 bits 226(p8) br.cond.spnt.few .fail 227 ;; 228 add r8 = 1, r8 229 CK_LOC( 2); CK_LOC( 3) 230 CK_LOC( 4); CK_LOC( 5); CK_LOC( 6); CK_LOC( 7) 231 CK_LOC( 8); CK_LOC( 9); CK_LOC(10); CK_LOC(11) 232 CK_LOC(12); CK_LOC(13); CK_LOC(14); CK_LOC(15) 233 CK_LOC(16); CK_LOC(17); CK_LOC(18); CK_LOC(19) 234 CK_LOC(20); CK_LOC(21); CK_LOC(22); CK_LOC(23) 235 CK_LOC(24); CK_LOC(25); CK_LOC(26); CK_LOC(27) 236 CK_LOC(28); CK_LOC(29); CK_LOC(30); CK_LOC(31) 237 CK_LOC(32); CK_LOC(33); CK_LOC(34); CK_LOC(35) 238 CK_LOC(36); CK_LOC(37); CK_LOC(38); CK_LOC(39) 239 CK_LOC(40); CK_LOC(41); CK_LOC(42); CK_LOC(43) 240 CK_LOC(44); CK_LOC(45); CK_LOC(46); CK_LOC(47) 241 CK_LOC(48); CK_LOC(49); CK_LOC(50); CK_LOC(51) 242 CK_LOC(52); CK_LOC(53); CK_LOC(54); CK_LOC(55) 243 CK_LOC(56); CK_LOC(57); CK_LOC(58); CK_LOC(59) 244 CK_LOC(60); CK_LOC(61); CK_LOC(62); CK_LOC(63) 245 CK_LOC(64); CK_LOC(65); CK_LOC(66); CK_LOC(67) 246 CK_LOC(68); CK_LOC(69); CK_LOC(70); CK_LOC(71) 247 CK_LOC(72); CK_LOC(73); CK_LOC(74); CK_LOC(75) 248 CK_LOC(76); CK_LOC(77); CK_LOC(78); CK_LOC(79) 249 CK_LOC(80); CK_LOC(81); CK_LOC(82); CK_LOC(83) 250 CK_LOC(84); CK_LOC(85); CK_LOC(86); CK_LOC(87) 251 CK_LOC(88); CK_LOC(89) 252.fail: 253 mov rp = loc0 254 mov ar.pfs = loc1 255 br.ret.sptk.many rp 256 .endp loadup 257 258 .global resumption_point_label 259 .proc resumption_point 260resumption_point: 261resumption_point_label: 262 .prologue 263 .save rp, r16 264 .save ar.pfs, r0 265 .body 266 mov r8 = r15 267 mov b6 = r16 268 ;; 269 br.cond.sptk.many b6 270 .endp resumption_point 271 272#ifdef __linux__ 273 /* We do not need executable stack. */ 274 .section .note.GNU-stack,"",@progbits 275#endif 276