Avoid using the warnings pragma in proto.t - use may not work yet.
[perl.git] / mpeix / mpeix_setjmp.c
1 /* Workaround for CR JAGab60546 setjmp/longjmp and
2    JAGad55982 sigsetjmp/siglongjmp from shared libraries. */
3
4 /*
5   * tabstop=4
6   *
7   * _setjmp/setjmp/sigsetjmp and
8   *_longjmp/longjmp/siglongjmp.
9   *
10   * Written by Mark Klein, 10 October, 2000
11   * Updated for gcc 3.x 6 October, 2005
12   *
13   * These routines are GCC specific and MUST BE COMPILED
14   * WITH -O2
15   *
16   * The existing setjmp/longjmp code in both libc.a and XL.PUB.SYS
17   * are not SR4 aware and cause problems when working with shared
18   * libraries (XLs), especially when executing a longjmp between
19   * XLs. This code preserves SR4 and will successfully handle
20   * a cross space longjmp. However, the setjmp code must be
21   * bound into each XL from which it will be called as well as
22   * being bound into the main program.
23   */
24
25 /*
26   * The following macro takes the contents of the jmpbuf and
27   * restores the registers from them. There is other code
28   * elsewhere that ensures that __jmpbuf is %r26 at this
29   * point in time. If it becomes some other register, that
30   * register must be the last restored. At the end will
31   * be a branch external that will cause a cross space
32   * return if needed.
33   */
34 #define RESTORE_REGS_AND_RETURN(__jmpbuf, __retval)                  \
35 ({                                                                   \
36          __asm__ __volatile__ (                                      \
37              "   ldw    0(%%sr0, %0), %%rp\n"                        \
38              "\t   ldw    4(%%sr0, %0), %%sp\n"                      \
39              "\t   ldw   16(%%sr0, %0), %%r3\n"                      \
40              "\t   ldw   20(%%sr0, %0), %%r4\n"                      \
41              "\t   ldw   24(%%sr0, %0), %%r5\n"                      \
42              "\t   ldw   28(%%sr0, %0), %%r6\n"                      \
43              "\t   ldw   32(%%sr0, %0), %%r7\n"                      \
44              "\t   ldw   36(%%sr0, %0), %%r8\n"                      \
45              "\t   ldw   40(%%sr0, %0), %%r9\n"                      \
46              "\t   ldw   44(%%sr0, %0), %%r10\n"                     \
47              "\t   ldw   48(%%sr0, %0), %%r11\n"                     \
48              "\t   ldw   52(%%sr0, %0), %%r12\n"                     \
49              "\t   ldw   56(%%sr0, %0), %%r13\n"                     \
50              "\t   ldw   60(%%sr0, %0), %%r14\n"                     \
51              "\t   ldw   64(%%sr0, %0), %%r15\n"                     \
52              "\t   ldw   68(%%sr0, %0), %%r16\n"                     \
53              "\t   ldw   72(%%sr0, %0), %%r17\n"                     \
54              "\t   ldw   76(%%sr0, %0), %%r18\n"                     \
55              "\t   ldw   80(%%sr0, %0), %%r19\n"                     \
56              "\t   ldw   84(%%sr0, %0), %%r20\n"                     \
57              "\t   ldw   88(%%sr0, %0), %%r21\n"                     \
58              "\t   ldw   92(%%sr0, %0), %%r22\n"                     \
59              "\t   ldw   96(%%sr0, %0), %%r23\n"                     \
60              "\t   ldw  100(%%sr0, %0), %%r24\n"                     \
61              "\t   ldw  104(%%sr0, %0), %%r25\n"                     \
62              "\t   ldw  112(%%sr0, %0), %%r27\n"                     \
63              "\t   ldw  116(%%sr0, %0), %%r1\n"                      \
64              "\t   mtsp %%r1, %%sr3\n"                               \
65              "\t   ldw  120(%%sr0, %0), %%r1\n"                      \
66              "\t   mtsp %%r1, %%sr1\n"                               \
67              "\t   or,<>   %%r0, %1, %%r0\n"                         \
68              "\t     ldi 1, %%r28\n"                                 \
69              "\t   ldw  108(%%sr0, %0), %%r26\n"                     \
70              "\t   be       0(%%sr1, %%rp)\n"                        \
71              "\t   mtsp %%r1, %%sr4\n"                               \
72                  : \
73                  : "r" (__jmpbuf),                                   \
74                    "r" (__retval));                                  \
75 })
76
77 /*
78   * The following macro extracts the signal mask
79   * from  __jmpbuf from the 3rd and 4th words and
80   * if non-zero, calls sigprocmask with that value
81   * to set the signal mask. This macro is usually
82   * invoked before the registers are restored in
83   * the longjmp routines and it can clobber things
84   * without needing to spill them as a result.
85   * A quick frame is built before making the
86   * call and cut back just afterwards.
87   * The ldi 2, %r26 is actually SIG_SETMASK from
88   * /usr/include/signal.h.
89   */
90 #define RESTORE_SIGNAL_MASK(__jmpbuf)                                \
91 ({                                                                   \
92    __asm__ __volatile__ (                                            \
93               "  ldw 8(%0), %%r26\n"                                 \
94               "\t  comibt,=,n 0,%%r26,.+36\n"                        \
95               "\t    ldo 64(%%sp), %%sp\n"                           \
96               "\t    stw %0, -28(%%sp)\n"                            \
97               "\t    ldi 0, %%r24\n"                                 \
98               "\t    ldo 8(%0), %%r25\n"                             \
99               "\t    .import sigprocmask,code\n"                     \
100               "\t    bl sigprocmask,%%rp\n"                          \
101               "\t    ldi 2, %%r26\n"                                 \
102               "\t    ldw -28(%%sr0, %%sp), %0\n"                     \
103               "\t    ldo -64(%%sp), %%sp\n"                          \
104                      :                                               \
105                      : "r" (__jmpbuf));                              \
106 })
107
108 /*
109   * This macro saves the current contents of the
110   * registers to __jmpbuf. Note that __jmpbuf is
111   * guaranteed elsewhere to be in %r26. We do not
112   * want it spilled, nor do we want a new frame
113   * built.
114   */
115 #define SAVE_REGS(__jmpbuf)                                          \
116 ({                                                                   \
117    __asm__ __volatile__ (                                            \
118               "  stw %%rp,     0(%%sr0, %0)\n"                       \
119               "\t  stw %%sp,     4(%%sr0, %0)\n"                     \
120               "\t  stw %%r0,     8(%%sr0, %0)\n"                     \
121               "\t  stw %%r3,    16(%%sr0, %0)\n"                     \
122               "\t  stw %%r4,    20(%%sr0, %0)\n"                     \
123               "\t  stw %%r5,    24(%%sr0, %0)\n"                     \
124               "\t  stw %%r6,    28(%%sr0, %0)\n"                     \
125               "\t  stw %%r7,    32(%%sr0, %0)\n"                     \
126               "\t  stw %%r8,    36(%%sr0, %0)\n"                     \
127               "\t  stw %%r9,    40(%%sr0, %0)\n"                     \
128               "\t  stw %%r10,   44(%%sr0, %0)\n"                     \
129               "\t  stw %%r11,   48(%%sr0, %0)\n"                     \
130               "\t  stw %%r12,   52(%%sr0, %0)\n"                     \
131               "\t  stw %%r13,   56(%%sr0, %0)\n"                     \
132               "\t  stw %%r14,   60(%%sr0, %0)\n"                     \
133               "\t  stw %%r15,   64(%%sr0, %0)\n"                     \
134               "\t  stw %%r16,   68(%%sr0, %0)\n"                     \
135               "\t  stw %%r17,   72(%%sr0, %0)\n"                     \
136               "\t  stw %%r18,   76(%%sr0, %0)\n"                     \
137               "\t  stw %%r19,   80(%%sr0, %0)\n"                     \
138               "\t  stw %%r20,   84(%%sr0, %0)\n"                     \
139               "\t  stw %%r21,   88(%%sr0, %0)\n"                     \
140               "\t  stw %%r22,   92(%%sr0, %0)\n"                     \
141               "\t  stw %%r23,   96(%%sr0, %0)\n"                     \
142               "\t  stw %%r24,  100(%%sr0, %0)\n"                     \
143               "\t  stw %%r25,  104(%%sr0, %0)\n"                     \
144               "\t  stw %%r26,  108(%%sr0, %0)\n"                     \
145               "\t  stw %%r27,  112(%%sr0, %0)\n"                     \
146               "\t  mfsp %%sr3, %%r1\n"                               \
147               "\t  stw %%r1,   116(%%sr0, %0)\n"                     \
148               "\t  mfsp %%sr4, %%r1\n"                               \
149               "\t  stw %%r1,   120(%%sr0, %0)\n"                     \
150                    :                                                 \
151                    : "r" (__jmpbuf));                                \
152 })
153
154 /*
155   * This macro will save the signal mask to the
156   * __jmpbuf if __savemask is non-zero. By this
157   * point in time, the other resisters have been
158   * saved into the __jmpbuf.
159   * The ldi 0, %r26 is actually SIG_BLOCK from
160   * /usr/include/signal.h. Since the block is
161   * an OR of the bits, this does not change the
162   * mask, but returns it into the double word at
163   * the address in %r24.
164   */
165 #define SAVE_SIGNAL_MASK(__jmpbuf,__savemask)                        \
166 ({                                                                   \
167    __asm__ __volatile__ (                                            \
168               "  comibt,=,n 0,%1,.+36\n"                             \
169               "\t    stw %%rp, -20(%%sr0, %%sp)\n"                   \
170               "\t    ldo 64(%%sp), %%sp\n"                           \
171               "\t    ldo 8(%0), %%r24\n"                             \
172               "\t    ldi 0, %%r25\n"                                 \
173               "\t    .import sigprocmask,code\n"                     \
174               "\t    bl sigprocmask,%%rp\n"                          \
175               "\t    ldi 0, %%r26\n"                                 \
176               "\t    ldo -64(%%sp), %%sp\n"                          \
177               "\t    ldw -20(%%sr0, %%sp), %%rp\n"                   \
178                      :                                               \
179                      : "r" (__jmpbuf),                               \
180                        "r" (__savemask));                            \
181 })
182
183 /*
184   * Construct a jump buffer and unconditionally save
185   * the signal mask. Return a 0 unconditinoally.
186   * Care is taken here and in the macros to assume
187   * the __jumpbuf is in %r26 and that the return
188   * value will be in %r28. It is done this way to
189   * prevent a frame from being built and any registers
190   * from being spilled.
191   */
192 int setjmp(register void *jmpbuf)
193 {
194    register int __jmpbuf asm ("%r26");
195
196    SAVE_REGS(__jmpbuf);
197    SAVE_SIGNAL_MASK(__jmpbuf, 1);
198    return 0;
199 }
200
201 /*
202   * Construct a jump buffer but do not save the
203   * signal mask.
204   */
205 int _setjmp(register void *jmpbuf)
206 {
207    register int __jmpbuf asm ("%r26");
208
209    SAVE_REGS(__jmpbuf);
210    return 0;
211 }
212
213 /*
214   * Construct a jump buffer and conditionally save
215   * the signal mask. The mask is saved if the
216   * savemask parameter is non-zero.
217   */
218 int sigsetjmp(register void *jmpbuf, register int savemask)
219 {
220    register int __jmpbuf   asm ("%r26");
221    register int __savemask asm ("%r25");
222
223    SAVE_REGS(__jmpbuf);
224    SAVE_SIGNAL_MASK(__jmpbuf, __savemask);
225    return 0;
226 }
227
228 /*
229   * Return to the location established in the jmpbuf,
230   * and place the value in i2 in %r28. Registers
231   * %r4 and %r5 are co-opted to save the address and
232   * value of jmpbuf and the return value. The signal
233   * mask is re-established if needed, then the
234   * address of jmpbuf and value of retval are placed
235   * into %r26 and %r28 correspondingly. This routine
236   * will never return to its caller and the stack
237   * will be cut back to whatever exists in the jmpbuf.
238   */
239 void longjmp(register void *jmpbuf, register int i2)
240 {
241    register int __jmpbuf        asm ("%r26");
242    register int __retval        asm ("%r28");
243
244    __asm__ __volatile__ (
245               "  copy %0, %%r4\n"
246               "\t  copy %1, %%r5\n"
247                      :
248                      : "r" (jmpbuf),
249                        "r" (i2));
250
251    RESTORE_SIGNAL_MASK (__jmpbuf);
252
253    __asm__ __volatile__ (
254               "  copy %%r4, %0\n"
255               "\t  copy %%r5, %1\n"
256                      : "=r" (__jmpbuf),
257                        "=r" (__retval));
258
259    RESTORE_REGS_AND_RETURN (__jmpbuf, __retval);
260 }
261
262 /*
263   * Return to the location established in the jmpbuf,
264   * but do not restore the signal mask.
265   */
266 void _longjmp(register void *jmpbuf, register int i2)
267 {
268    register int __retval         asm ("%r28");
269    register int __jmpbuf         asm ("%r26");
270
271    __jmpbuf = (int)jmpbuf;
272    __retval = i2;
273
274    RESTORE_REGS_AND_RETURN (__jmpbuf, __retval);
275 }
276
277 /*
278   * Return to the location establsihed in the jmpbuf,
279   * and conditionally re-establish the signal mask.
280   */
281 void siglongjmp(register void *jmpbuf, register int i2)
282 {
283    register int __jmpbuf        asm ("%r26");
284    register int __retval        asm ("%r28");
285
286    __asm__ __volatile__ (
287               "  copy %0, %%r4\n"
288               "\t  copy %1, %%r5\n"
289                      :
290                      : "r" (jmpbuf),
291                        "r" (i2));
292
293    RESTORE_SIGNAL_MASK (__jmpbuf);
294
295    __asm__ __volatile__ (
296               "  copy %%r4, %0\n"
297               "\t  copy %%r5, %1\n"
298                      : "=r" (__jmpbuf),
299                        "=r" (__retval));
300
301    RESTORE_REGS_AND_RETURN (__jmpbuf, __retval);
302 }
303
304 #ifdef TEST
305 int buf1[50];
306 int buf2[50];
307
308 foo() {
309    printf("In routine foo(). Doing Longjmp.\n");
310    longjmp(buf1, 123);
311    printf("This is in foo after the longjmp() call. Should not reach here.\n");
312 }
313
314 bar(int ret) {
315    printf("In routine bar(%d). Doing siglongjmp.\n",ret);
316    siglongjmp(buf2, ret);
317    printf("This is in bar after the siglongjmp() call. Should not reach here.\n");
318 }
319
320 main() {
321    int i;
322    if ((i = setjmp(buf1)))
323      {
324            printf("This is the return from the longjmp. i: %d\n",i);
325          }
326    else
327      {
328            printf("Jump buffer established, i: %d. Calling foo()\n",i);
329            foo();
330            printf("This is in main after the foo() call. Should not reach here.\n ");
331          }
332
333    if ((i = sigsetjmp(buf2,0)))
334      {
335            printf("This is the return from the longjmp. i: %d\n",i);
336          }
337    else
338      {
339            printf("Jump buffer established, i: %d. Calling bar(456)\n",i);
340            bar(456);
341            printf("This is in main after the bar(456) call. Should not reach here.\n");
342          }
343
344    if ((i = sigsetjmp(buf2,1)))
345      {
346            printf("This is the return from the longjmp. i: %d\n",i);
347          }
348    else
349      {
350            printf("Jump buffer established, i: %d. Calling bar(789)\n",i);
351            bar(789);
352            printf("This is in main after the bar(789) call. Should not reach here.\n");
353          }
354 }
355 #endif