1 /* Copyright (C) 2001-2023 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3
4 The GNU C Library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Lesser General Public
6 License as published by the Free Software Foundation; either
7 version 2.1 of the License, or (at your option) any later version.
8
9 The GNU C Library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 Lesser General Public License for more details.
13
14 You should have received a copy of the GNU Lesser General Public
15 License along with the GNU C Library; if not, see
16 <https://www.gnu.org/licenses/>. */
17
18 #include <errno.h>
19 #include <stdio.h>
20 #include <stdlib.h>
21 #include <string.h>
22 #include <ucontext.h>
23 #include <unistd.h>
24 #include <link.h>
25 #include <elf.h>
26 #include <fpu_control.h>
27 #include <sys/auxv.h>
28 #include <support/support.h>
29
30 #include <support/xstdio.h>
31
32 static ucontext_t ctx[3];
33
34
35 volatile int global;
36
37
38 static int back_in_main;
39
40
41 volatile static ElfW(auxv_t) *auxv = NULL;
42
43 ElfW(Addr) query_auxv(int type)
44 {
45 FILE *auxv_f;
46 ElfW(auxv_t) auxv_struct;
47 ElfW(auxv_t) *auxv_temp;
48 int i = 0;
49
50 /* if the /proc/self/auxv file has not been manually copied into the heap
51 yet, then do it */
52
53 if(auxv == NULL)
54 {
55 auxv_f = fopen("/proc/self/auxv", "r");
56
57 if(auxv_f == 0)
58 {
59 perror("Error opening file for reading");
60 return 0;
61 }
62 auxv = xmalloc (getpagesize ());
63
64 do
65 {
66 xfread (&auxv_struct, sizeof (ElfW(auxv_t)), 1, auxv_f);
67 auxv[i] = auxv_struct;
68 i++;
69 } while(auxv_struct.a_type != AT_NULL);
70 }
71
72 auxv_temp = (ElfW(auxv_t) *)auxv;
73 i = 0;
74 do
75 {
76 if(auxv_temp[i].a_type == type)
77 {
78 return auxv_temp[i].a_un.a_val;
79 }
80 i++;
81 } while (auxv_temp[i].a_type != AT_NULL);
82
83 return 0;
84 }
85
86 typedef unsigned int di_fpscr_t __attribute__ ((__mode__ (__DI__)));
87 typedef unsigned int si_fpscr_t __attribute__ ((__mode__ (__SI__)));
88
89 #define _FPSCR_RESERVED 0xfffffff8ffffff04ULL
90
91 #define _FPSCR_TEST0_DRN 0x0000000400000000ULL
92 #define _FPSCR_TEST0_RN 0x0000000000000003ULL
93
94 #define _FPSCR_TEST1_DRN 0x0000000300000000ULL
95 #define _FPSCR_TEST1_RN 0x0000000000000002ULL
96
97 /* Macros for accessing the hardware control word on Power6[x]. */
98 #define _GET_DI_FPSCR(__fpscr) \
99 ({union { double d; di_fpscr_t fpscr; } u; \
100 u.d = __builtin_mffs (); \
101 (__fpscr) = u.fpscr; \
102 u.fpscr; \
103 })
104
105 /* We make sure to zero fp after we use it in order to prevent stale data
106 in an fp register from making a test-case pass erroneously. */
107 # define _SET_DI_FPSCR(__fpscr) \
108 { union { double d; di_fpscr_t fpscr; } u; \
109 register double fr; \
110 u.fpscr = __fpscr; \
111 fr = u.d; \
112 /* Set the entire 64-bit FPSCR. */ \
113 __asm__ (".machine push; " \
114 ".machine \"power6\"; " \
115 "mtfsf 255,%0,1,0; " \
116 ".machine pop" : : "f" (fr)); \
117 fr = 0.0; \
118 }
119
120 # define _GET_SI_FPSCR(__fpscr) \
121 ({union { double d; di_fpscr_t fpscr; } u; \
122 u.d = __builtin_mffs (); \
123 (__fpscr) = (si_fpscr_t) u.fpscr; \
124 (si_fpscr_t) u.fpscr; \
125 })
126
127 /* We make sure to zero fp after we use it in order to prevent stale data
128 in an fp register from making a test-case pass erroneously. */
129 # define _SET_SI_FPSCR(__fpscr) \
130 { union { double d; di_fpscr_t fpscr; } u; \
131 register double fr; \
132 /* More-or-less arbitrary; this is a QNaN. */ \
133 u.fpscr = 0xfff80000ULL << 32; \
134 u.fpscr |= __fpscr & 0xffffffffULL; \
135 fr = u.d; \
136 __builtin_mtfsf (255, fr); \
137 fr = 0.0; \
138 }
139
140 void prime_special_regs(int which)
141 {
142 ElfW(Addr) a_val;
143
144 di_fpscr_t di_fpscr __attribute__ ((__aligned__(8)));
145
146 a_val = query_auxv(AT_HWCAP);
147 if(a_val == -1)
148 {
149 puts ("querying the auxv for the hwcap failed");
150 _exit (1);
151 }
152
153 /* Indicates a 64-bit FPSCR. */
154 if (a_val & PPC_FEATURE_HAS_DFP)
155 {
156 _GET_DI_FPSCR(di_fpscr);
157
158 /* Overwrite the existing DRN and RN if there is one. */
159 if (which == 0)
160 di_fpscr = ((di_fpscr & _FPSCR_RESERVED) | (_FPSCR_TEST0_DRN | _FPSCR_TEST0_RN));
161 else
162 di_fpscr = ((di_fpscr & _FPSCR_RESERVED) | (_FPSCR_TEST1_DRN | _FPSCR_TEST1_RN));
163 puts ("Priming 64-bit FPSCR with:");
164 printf("0x%.16llx\n",(unsigned long long int)di_fpscr);
165
166 _SET_DI_FPSCR(di_fpscr);
167 }
168 else
169 {
170 puts ("32-bit FPSCR found and will be tested.");
171 _GET_SI_FPSCR(di_fpscr);
172
173 /* Overwrite the existing RN if there is one. */
174 if (which == 0)
175 di_fpscr = ((di_fpscr & _FPSCR_RESERVED) | (_FPSCR_TEST0_RN));
176 else
177 di_fpscr = ((di_fpscr & _FPSCR_RESERVED) | (_FPSCR_TEST1_RN));
178 puts ("Priming 32-bit FPSCR with:");
179 printf("0x%.8lx\n",(unsigned long int) di_fpscr);
180
181 _SET_SI_FPSCR(di_fpscr);
182 }
183 }
184
185 void clear_special_regs(void)
186 {
187 ElfW(Addr) a_val;
188
189 di_fpscr_t di_fpscr __attribute__ ((__aligned__(8)));
190
191 union {
192 double d;
193 unsigned long long int lli;
194 unsigned int li[2];
195 } dlli;
196
197 a_val = query_auxv(AT_HWCAP);
198 if(a_val == -1)
199 {
200 puts ("querying the auxv for the hwcap failed");
201 _exit (1);
202 }
203
204 #if __WORDSIZE == 32
205 dlli.d = ctx[0].uc_mcontext.uc_regs->fpregs.fpscr;
206 #else
207 dlli.d = ctx[0].uc_mcontext.fp_regs[32];
208 #endif
209
210 puts("The FPSCR value saved in the ucontext_t is:");
211
212 /* Indicates a 64-bit FPSCR. */
213 if (a_val & PPC_FEATURE_HAS_DFP)
214 {
215 printf("0x%.16llx\n",dlli.lli);
216 di_fpscr = 0x0;
217 puts ("Clearing the 64-bit FPSCR to:");
218 printf("0x%.16llx\n",(unsigned long long int) di_fpscr);
219
220 _SET_DI_FPSCR(di_fpscr);
221 }
222 else
223 {
224 printf("0x%.8x\n",(unsigned int) dlli.li[1]);
225 di_fpscr = 0x0;
226 puts ("Clearing the 32-bit FPSCR to:");
227 printf("0x%.8lx\n",(unsigned long int) di_fpscr);
228
229 _SET_SI_FPSCR(di_fpscr);
230 }
231 }
232
233 void test_special_regs(int which)
234 {
235 ElfW(Addr) a_val;
236 unsigned long long int test;
237
238 di_fpscr_t di_fpscr __attribute__ ((__aligned__(8)));
239
240 a_val = query_auxv(AT_HWCAP);
241 if(a_val == -1)
242 {
243 puts ("querying the auxv for the hwcap failed");
244 _exit (2);
245 }
246
247 /* Indicates a 64-bit FPSCR. */
248 if (a_val & PPC_FEATURE_HAS_DFP)
249 {
250 _GET_DI_FPSCR(di_fpscr);
251
252 if (which == 0)
253 puts ("After setcontext the 64-bit FPSCR contains:");
254 else
255 puts ("After swapcontext the 64-bit FPSCR contains:");
256
257 printf("0x%.16llx\n",(unsigned long long int) di_fpscr);
258 test = (_FPSCR_TEST0_DRN | _FPSCR_TEST0_RN);
259 if((di_fpscr & (test)) != (test))
260 {
261 printf ("%s: DRN and RN bits set before getcontext were not preserved across [set|swap]context call: %m",__FUNCTION__);
262 _exit (3);
263 }
264 }
265 else
266 {
267 _GET_SI_FPSCR(di_fpscr);
268 if (which == 0)
269 puts ("After setcontext the 32-bit FPSCR contains:");
270 else
271 puts ("After swapcontext the 32-bit FPSCR contains:");
272
273 printf("0x%.8lx\n",(unsigned long int) di_fpscr);
274 test = _FPSCR_TEST0_RN;
275 if((di_fpscr & test) != test)
276 {
277 printf ("%s: RN bit set before getcontext was not preserved across [set|swap]context call: %m",__FUNCTION__);
278 _exit (4);
279 }
280 }
281 }
282
283
284 static void
285 check_called (void)
286 {
287 if (back_in_main == 0)
288 {
289 puts ("program did not reach main again");
290 _exit (5);
291 }
292 }
293
294
295 int
296 main (void)
297 {
298 atexit (check_called);
299
300 puts ("priming the FPSCR with a marker");
301 prime_special_regs (0);
302
303 puts ("making contexts");
304 if (getcontext (&ctx[0]) != 0)
305 {
306 if (errno == ENOSYS)
307 {
308 back_in_main = 1;
309 exit (0);
310 }
311
312 printf ("%s: getcontext: %m\n", __FUNCTION__);
313 exit (6);
314 }
315
316 /* Play some tricks with this context. */
317 if (++global == 1)
318 {
319 clear_special_regs ( );
320 if (setcontext (&ctx[0]) != 0)
321 {
322 printf ("%s: setcontext: %m\n", __FUNCTION__);
323 exit (7);
324 }
325 }
326 if (global != 2)
327 {
328 printf ("%s: 'global' not incremented twice\n", __FUNCTION__);
329 exit (8);
330 }
331
332 test_special_regs (0);
333
334 global = 0;
335 if (getcontext (&ctx[0]) != 0)
336 {
337 printf ("%s: getcontext: %m\n", __FUNCTION__);
338 exit (9);
339 }
340
341 if (++global == 1)
342 {
343 puts ("priming the FPSCR with a marker");
344 prime_special_regs (1);
345
346 puts ("swapping contexts");
347 if (swapcontext (&ctx[1], &ctx[0]) != 0)
348 {
349 printf ("%s: swapcontext: %m\n", __FUNCTION__);
350 exit (9);
351 }
352 }
353 if (global != 2)
354 {
355 printf ("%s: 'global' not incremented twice\n", __FUNCTION__);
356 exit (10);
357 }
358
359 test_special_regs (1);
360
361 puts ("back at main program");
362 back_in_main = 1;
363
364 puts ("test succeeded");
365 return 0;
366 }