[perl5.git] / mpeix / mpeix_setjmp.c

/* Workaround for CR JAGab60546 setjmp/longjmp and
   JAGad55982 sigsetjmp/siglongjmp from shared libraries. */

/*
  * tabstop=4
  *
  * _setjmp/setjmp/sigsetjmp and
  *_longjmp/longjmp/siglongjmp.
  *
  * Written by Mark Klein, 10 October, 2000
  * Updated for gcc 3.x 6 October, 2005
  *
  * These routines are GCC specific and MUST BE COMPILED
  * WITH -O2
  *
  * The existing setjmp/longjmp code in both libc.a and XL.PUB.SYS
  * are not SR4 aware and cause problems when working with shared
  * libraries (XLs), especially when executing a longjmp between
  * XLs. This code preserves SR4 and will successfully handle
  * a cross space longjmp. However, the setjmp code must be
  * bound into each XL from which it will be called as well as
  * being bound into the main program.
  */

/*
  * The following macro takes the contents of the jmpbuf and
  * restores the registers from them. There is other code
  * elsewhere that ensures that __jmpbuf is %r26 at this
  * point in time. If it becomes some other register, that
  * register must be the last restored. At the end will
  * be a branch external that will cause a cross space
  * return if needed.
  */
#define RESTORE_REGS_AND_RETURN(__jmpbuf, __retval)                  \
({                                                                   \
         __asm__ __volatile__ (                                      \
             "   ldw    0(%%sr0, %0), %%rp\n"                        \
             "\t   ldw    4(%%sr0, %0), %%sp\n"                      \
             "\t   ldw   16(%%sr0, %0), %%r3\n"                      \
             "\t   ldw   20(%%sr0, %0), %%r4\n"                      \
             "\t   ldw   24(%%sr0, %0), %%r5\n"                      \
             "\t   ldw   28(%%sr0, %0), %%r6\n"                      \
             "\t   ldw   32(%%sr0, %0), %%r7\n"                      \
             "\t   ldw   36(%%sr0, %0), %%r8\n"                      \
             "\t   ldw   40(%%sr0, %0), %%r9\n"                      \
             "\t   ldw   44(%%sr0, %0), %%r10\n"                     \
             "\t   ldw   48(%%sr0, %0), %%r11\n"                     \
             "\t   ldw   52(%%sr0, %0), %%r12\n"                     \
             "\t   ldw   56(%%sr0, %0), %%r13\n"                     \
             "\t   ldw   60(%%sr0, %0), %%r14\n"                     \
             "\t   ldw   64(%%sr0, %0), %%r15\n"                     \
             "\t   ldw   68(%%sr0, %0), %%r16\n"                     \
             "\t   ldw   72(%%sr0, %0), %%r17\n"                     \
             "\t   ldw   76(%%sr0, %0), %%r18\n"                     \
             "\t   ldw   80(%%sr0, %0), %%r19\n"                     \
             "\t   ldw   84(%%sr0, %0), %%r20\n"                     \
             "\t   ldw   88(%%sr0, %0), %%r21\n"                     \
             "\t   ldw   92(%%sr0, %0), %%r22\n"                     \
             "\t   ldw   96(%%sr0, %0), %%r23\n"                     \
             "\t   ldw  100(%%sr0, %0), %%r24\n"                     \
             "\t   ldw  104(%%sr0, %0), %%r25\n"                     \
             "\t   ldw  112(%%sr0, %0), %%r27\n"                     \
             "\t   ldw  116(%%sr0, %0), %%r1\n"                      \
             "\t   mtsp %%r1, %%sr3\n"                               \
             "\t   ldw  120(%%sr0, %0), %%r1\n"                      \
             "\t   mtsp %%r1, %%sr1\n"                               \
             "\t   or,<>   %%r0, %1, %%r0\n"                         \
             "\t     ldi 1, %%r28\n"                                 \
             "\t   ldw  108(%%sr0, %0), %%r26\n"                     \
             "\t   be       0(%%sr1, %%rp)\n"                        \
             "\t   mtsp %%r1, %%sr4\n"                               \
                 : \
                 : "r" (__jmpbuf),                                   \
                   "r" (__retval));                                  \
})

/*
  * The following macro extracts the signal mask
  * from  __jmpbuf from the 3rd and 4th words and
  * if non-zero, calls sigprocmask with that value
  * to set the signal mask. This macro is usually
  * invoked before the registers are restored in
  * the longjmp routines and it can clobber things
  * without needing to spill them as a result.
  * A quick frame is built before making the
  * call and cut back just afterwards.
  * The ldi 2, %r26 is actually SIG_SETMASK from
  * /usr/include/signal.h.
  */
#define RESTORE_SIGNAL_MASK(__jmpbuf)                                \
({                                                                   \
   __asm__ __volatile__ (                                            \
              "  ldw 8(%0), %%r26\n"                                 \
              "\t  comibt,=,n 0,%%r26,.+36\n"                        \
              "\t    ldo 64(%%sp), %%sp\n"                           \
              "\t    stw %0, -28(%%sp)\n"                            \
              "\t    ldi 0, %%r24\n"                                 \
              "\t    ldo 8(%0), %%r25\n"                             \
              "\t    .import sigprocmask,code\n"                     \
              "\t    bl sigprocmask,%%rp\n"                          \
              "\t    ldi 2, %%r26\n"                                 \
              "\t    ldw -28(%%sr0, %%sp), %0\n"                     \
              "\t    ldo -64(%%sp), %%sp\n"                          \
                     :                                               \
                     : "r" (__jmpbuf));                              \
})

/*
  * This macro saves the current contents of the
  * registers to __jmpbuf. Note that __jmpbuf is
  * guaranteed elsewhere to be in %r26. We do not
  * want it spilled, nor do we want a new frame
  * built.
  */
#define SAVE_REGS(__jmpbuf)                                          \
({                                                                   \
   __asm__ __volatile__ (                                            \
              "  stw %%rp,     0(%%sr0, %0)\n"                       \
              "\t  stw %%sp,     4(%%sr0, %0)\n"                     \
              "\t  stw %%r0,     8(%%sr0, %0)\n"                     \
              "\t  stw %%r3,    16(%%sr0, %0)\n"                     \
              "\t  stw %%r4,    20(%%sr0, %0)\n"                     \
              "\t  stw %%r5,    24(%%sr0, %0)\n"                     \
              "\t  stw %%r6,    28(%%sr0, %0)\n"                     \
              "\t  stw %%r7,    32(%%sr0, %0)\n"                     \
              "\t  stw %%r8,    36(%%sr0, %0)\n"                     \
              "\t  stw %%r9,    40(%%sr0, %0)\n"                     \
              "\t  stw %%r10,   44(%%sr0, %0)\n"                     \
              "\t  stw %%r11,   48(%%sr0, %0)\n"                     \
              "\t  stw %%r12,   52(%%sr0, %0)\n"                     \
              "\t  stw %%r13,   56(%%sr0, %0)\n"                     \
              "\t  stw %%r14,   60(%%sr0, %0)\n"                     \
              "\t  stw %%r15,   64(%%sr0, %0)\n"                     \
              "\t  stw %%r16,   68(%%sr0, %0)\n"                     \
              "\t  stw %%r17,   72(%%sr0, %0)\n"                     \
              "\t  stw %%r18,   76(%%sr0, %0)\n"                     \
              "\t  stw %%r19,   80(%%sr0, %0)\n"                     \
              "\t  stw %%r20,   84(%%sr0, %0)\n"                     \
              "\t  stw %%r21,   88(%%sr0, %0)\n"                     \
              "\t  stw %%r22,   92(%%sr0, %0)\n"                     \
              "\t  stw %%r23,   96(%%sr0, %0)\n"                     \
              "\t  stw %%r24,  100(%%sr0, %0)\n"                     \
              "\t  stw %%r25,  104(%%sr0, %0)\n"                     \
              "\t  stw %%r26,  108(%%sr0, %0)\n"                     \
              "\t  stw %%r27,  112(%%sr0, %0)\n"                     \
              "\t  mfsp %%sr3, %%r1\n"                               \
              "\t  stw %%r1,   116(%%sr0, %0)\n"                     \
              "\t  mfsp %%sr4, %%r1\n"                               \
              "\t  stw %%r1,   120(%%sr0, %0)\n"                     \
                   :                                                 \
                   : "r" (__jmpbuf));                                \
})

/*
  * This macro will save the signal mask to the
  * __jmpbuf if __savemask is non-zero. By this
  * point in time, the other resisters have been
  * saved into the __jmpbuf.
  * The ldi 0, %r26 is actually SIG_BLOCK from
  * /usr/include/signal.h. Since the block is
  * an OR of the bits, this does not change the
  * mask, but returns it into the double word at
  * the address in %r24.
  */
#define SAVE_SIGNAL_MASK(__jmpbuf,__savemask)                        \
({                                                                   \
   __asm__ __volatile__ (                                            \
              "  comibt,=,n 0,%1,.+36\n"                             \
              "\t    stw %%rp, -20(%%sr0, %%sp)\n"                   \
              "\t    ldo 64(%%sp), %%sp\n"                           \
              "\t    ldo 8(%0), %%r24\n"                             \
              "\t    ldi 0, %%r25\n"                                 \
              "\t    .import sigprocmask,code\n"                     \
              "\t    bl sigprocmask,%%rp\n"                          \
              "\t    ldi 0, %%r26\n"                                 \
              "\t    ldo -64(%%sp), %%sp\n"                          \
              "\t    ldw -20(%%sr0, %%sp), %%rp\n"                   \
                     :                                               \
                     : "r" (__jmpbuf),                               \
                       "r" (__savemask));                            \
})

/*
  * Construct a jump buffer and unconditionally save
  * the signal mask. Return a 0 unconditinoally.
  * Care is taken here and in the macros to assume
  * the __jumpbuf is in %r26 and that the return
  * value will be in %r28. It is done this way to
  * prevent a frame from being built and any registers
  * from being spilled.
  */
int setjmp(register void *jmpbuf)
{
   register int __jmpbuf asm ("%r26");

   SAVE_REGS(__jmpbuf);
   SAVE_SIGNAL_MASK(__jmpbuf, 1);
   return 0;
}

/*
  * Construct a jump buffer but do not save the
  * signal mask.
  */
int _setjmp(register void *jmpbuf)
{
   register int __jmpbuf asm ("%r26");

   SAVE_REGS(__jmpbuf);
   return 0;
}

/*
  * Construct a jump buffer and conditionally save
  * the signal mask. The mask is saved if the
  * savemask parameter is non-zero.
  */
int sigsetjmp(register void *jmpbuf, register int savemask)
{
   register int __jmpbuf   asm ("%r26");
   register int __savemask asm ("%r25");

   SAVE_REGS(__jmpbuf);
   SAVE_SIGNAL_MASK(__jmpbuf, __savemask);
   return 0;
}

/*
  * Return to the location established in the jmpbuf,
  * and place the value in i2 in %r28. Registers
  * %r4 and %r5 are co-opted to save the address and
  * value of jmpbuf and the return value. The signal
  * mask is re-established if needed, then the
  * address of jmpbuf and value of retval are placed
  * into %r26 and %r28 correspondingly. This routine
  * will never return to its caller and the stack
  * will be cut back to whatever exists in the jmpbuf.
  */
void longjmp(register void *jmpbuf, register int i2)
{
   register int __jmpbuf        asm ("%r26");
   register int __retval        asm ("%r28");

   __asm__ __volatile__ (
              "  copy %0, %%r4\n"
              "\t  copy %1, %%r5\n"
                     :
                     : "r" (jmpbuf),
                       "r" (i2));

   RESTORE_SIGNAL_MASK (__jmpbuf);

   __asm__ __volatile__ (
              "  copy %%r4, %0\n"
              "\t  copy %%r5, %1\n"
                     : "=r" (__jmpbuf),
                       "=r" (__retval));

   RESTORE_REGS_AND_RETURN (__jmpbuf, __retval);
}

/*
  * Return to the location established in the jmpbuf,
  * but do not restore the signal mask.
  */
void _longjmp(register void *jmpbuf, register int i2)
{
   register int __retval         asm ("%r28");
   register int __jmpbuf         asm ("%r26");

   __jmpbuf = (int)jmpbuf;
   __retval = i2;

   RESTORE_REGS_AND_RETURN (__jmpbuf, __retval);
}

/*
  * Return to the location establsihed in the jmpbuf,
  * and conditionally re-establish the signal mask.
  */
void siglongjmp(register void *jmpbuf, register int i2)
{
   register int __jmpbuf        asm ("%r26");
   register int __retval        asm ("%r28");

   __asm__ __volatile__ (
              "  copy %0, %%r4\n"
              "\t  copy %1, %%r5\n"
                     :
                     : "r" (jmpbuf),
                       "r" (i2));

   RESTORE_SIGNAL_MASK (__jmpbuf);

   __asm__ __volatile__ (
              "  copy %%r4, %0\n"
              "\t  copy %%r5, %1\n"
                     : "=r" (__jmpbuf),
                       "=r" (__retval));

   RESTORE_REGS_AND_RETURN (__jmpbuf, __retval);
}

#ifdef TEST
int buf1[50];
int buf2[50];

foo() {
   printf("In routine foo(). Doing Longjmp.\n");
   longjmp(buf1, 123);
   printf("This is in foo after the longjmp() call. Should not reach here.\n");
}

bar(int ret) {
   printf("In routine bar(%d). Doing siglongjmp.\n",ret);
   siglongjmp(buf2, ret);
   printf("This is in bar after the siglongjmp() call. Should not reach here.\n");
}

main() {
   int i;
   if ((i = setjmp(buf1)))
     {
           printf("This is the return from the longjmp. i: %d\n",i);
         }
   else
     {
           printf("Jump buffer established, i: %d. Calling foo()\n",i);
           foo();
           printf("This is in main after the foo() call. Should not reach here.\n ");
         }

   if ((i = sigsetjmp(buf2,0)))
     {
           printf("This is the return from the longjmp. i: %d\n",i);
         }
   else
     {
           printf("Jump buffer established, i: %d. Calling bar(456)\n",i);
           bar(456);
           printf("This is in main after the bar(456) call. Should not reach here.\n");
         }

   if ((i = sigsetjmp(buf2,1)))
     {
           printf("This is the return from the longjmp. i: %d\n",i);
         }
   else
     {
           printf("Jump buffer established, i: %d. Calling bar(789)\n",i);
           bar(789);
           printf("This is in main after the bar(789) call. Should not reach here.\n");
         }
}
#endif
Commit	Line	Data
f382e41b KH	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