add a thp-based huge page alloc fallback
[pcsx_rearmed.git] / deps / lightning / check / carg.c
1 #include <lightning.h>
2 #include <stdio.h>
3
4 /*   Simple test for arguments handling, that also shows how to use
5  * arguments to store values.
6  *   Register arguments, if available, are very fast, but are also
7  * very volatile on some ports, because some ports will do C calls
8  * to implement division, remainder, sometimes multiplication, or
9  * some float operations.
10  *   Arguments in registers should be fetched in the prolog of the
11  * function, and if they must be saved, they should be saved in
12  * the prolog.
13  *   The predicate macro "jit_arg_register_p(arg)" allows knowing if
14  * an argument lives in a register, where it is known for being a very
15  * fast to read/write temporary storage.
16  */
17
18 #define W               jit_word_t
19 #define F               jit_float32_t
20 #define D               jit_float64_t
21
22 jit_state_t              *_jit;
23
24 void
25 cw(W a1, W  a2, W  a3, W  a4, W  a5, W  a6, W  a7, W  a8,
26    W a9, W a10, W a11, W a12, W a13, W a14, W a15, W a16)
27 {
28     if ( a1 !=  1 ||  a2 !=  2 ||  a3 !=  3 ||  a4 !=  4 ||
29          a5 !=  5 ||  a6 !=  6 ||  a7 !=  7 ||  a8 !=  8 ||
30          a9 !=  9 || a10 != 10 || a11 != 11 || a12 != 12 ||
31         a13 != 13 || a14 != 14 || a15 != 15 || a16 != 16)
32         abort();
33 }
34
35 void
36 cf(F a1, F  a2, F  a3, F  a4, F  a5, F  a6, F  a7, F  a8,
37    F a9, F a10, F a11, F a12, F a13, F a14, F a15, F a16)
38 {
39     if ( a1 !=  1 ||  a2 !=  2 ||  a3 !=  3 ||  a4 !=  4 ||
40          a5 !=  5 ||  a6 !=  6 ||  a7 !=  7 ||  a8 !=  8 ||
41          a9 !=  9 || a10 != 10 || a11 != 11 || a12 != 12 ||
42         a13 != 13 || a14 != 14 || a15 != 15 || a16 != 16)
43         abort();
44 }
45
46 void
47 cd(D a1, D  a2, D  a3, D  a4, D  a5, D  a6, D  a7, D  a8,
48    D a9, D a10, D a11, D a12, D a13, D a14, D a15, D a16)
49 {
50     if ( a1 !=  1 ||  a2 !=  2 ||  a3 !=  3 ||  a4 !=  4 ||
51          a5 !=  5 ||  a6 !=  6 ||  a7 !=  7 ||  a8 !=  8 ||
52          a9 !=  9 || a10 != 10 || a11 != 11 || a12 != 12 ||
53         a13 != 13 || a14 != 14 || a15 != 15 || a16 != 16)
54         abort();
55 }
56
57 int
58 main(int argc, char *argv[])
59 {
60     void                (*code)(void);
61     jit_node_t          *jmp, *pass, *fail;
62     jit_node_t           *jw, *jf, *jd;
63     jit_int32_t           s1,   s2,   s3,   s4,   s5,   s6,   s7,   s8,
64                           s9,  s10,  s11,  s12,  s13,  s14,  s15,  s16;
65     jit_node_t           *a1,  *a2,  *a3,  *a4,  *a5,  *a6,  *a7,  *a8,
66                          *a9, *a10, *a11, *a12, *a13, *a14, *a15, *a16;
67
68     init_jit(argv[0]);
69     _jit = jit_new_state();
70
71     /* jump to "main" label */
72     jmp = jit_jmpi();
73
74     /* Create jit function that
75      * o Receives 16 word arguments
76      * o Save in the stack any register argument. Also force register
77      *   arguments to be clobbered to properly make the test
78      * o Calls a C function that receives 16 word arguments, with
79      *   values different from the ones received by this function
80      * o Reload from stack any register argument
81      * o Validated all arguments were not modified in the known
82      *   cases it could have been clobbered
83      */
84     jw = jit_label();
85     jit_name("jw");
86     jit_note(__FILE__, __LINE__);
87     jit_prolog();
88     a1  = jit_arg();
89     a2  = jit_arg();
90     a3  = jit_arg();
91     a4  = jit_arg();
92     a5  = jit_arg();
93     a6  = jit_arg();
94     a7  = jit_arg();
95     a8  = jit_arg();
96     a9  = jit_arg();
97     a10 = jit_arg();
98     a11 = jit_arg();
99     a12 = jit_arg();
100     a13 = jit_arg();
101     a14 = jit_arg();
102     a15 = jit_arg();
103     a16 = jit_arg();
104 #define SAVE_ARG(N)                                                     \
105     do {                                                                \
106         if (jit_arg_register_p(a##N)) {                                 \
107             s##N = jit_allocai(sizeof(W));                              \
108             jit_getarg(JIT_R0, a##N);                                   \
109             jit_stxi(s##N, JIT_FP, JIT_R0);                             \
110             jit_putargi(-1, a##N);                                      \
111         }                                                               \
112     } while (0)
113     SAVE_ARG(1);
114     SAVE_ARG(2);
115     SAVE_ARG(3);
116     SAVE_ARG(4);
117     SAVE_ARG(5);
118     SAVE_ARG(6);
119     SAVE_ARG(7);
120     SAVE_ARG(8);
121     SAVE_ARG(9);
122     SAVE_ARG(10);
123     SAVE_ARG(11);
124     SAVE_ARG(12);
125     SAVE_ARG(13);
126     SAVE_ARG(14);
127     SAVE_ARG(15);
128     SAVE_ARG(16);
129 #undef SAVE_ARG
130     jit_prepare();
131     {
132         jit_pushargi(1);
133         jit_pushargi(2);
134         jit_pushargi(3);
135         jit_pushargi(4);
136         jit_pushargi(5);
137         jit_pushargi(6);
138         jit_pushargi(7);
139         jit_pushargi(8);
140         jit_pushargi(9);
141         jit_pushargi(10);
142         jit_pushargi(11);
143         jit_pushargi(12);
144         jit_pushargi(13);
145         jit_pushargi(14);
146         jit_pushargi(15);
147         jit_pushargi(16);
148     }
149     jit_finishi(cw);
150 #define LOAD_ARG(N)                                                     \
151     do {                                                                \
152         if (jit_arg_register_p(a##N)) {                                 \
153             jit_ldxi(JIT_R0, JIT_FP, s##N);                             \
154             jit_putargr(JIT_R0, a##N);                                  \
155         }                                                               \
156     } while (0)
157     LOAD_ARG(1);
158     LOAD_ARG(2);
159     LOAD_ARG(3);
160     LOAD_ARG(4);
161     LOAD_ARG(5);
162     LOAD_ARG(6);
163     LOAD_ARG(7);
164     LOAD_ARG(8);
165     LOAD_ARG(9);
166     LOAD_ARG(10);
167     LOAD_ARG(11);
168     LOAD_ARG(12);
169     LOAD_ARG(13);
170     LOAD_ARG(14);
171     LOAD_ARG(15);
172     LOAD_ARG(16);
173 #undef LOAD_ARG
174     pass = jit_forward();
175     fail = jit_forward();
176 #define CHECK_ARG(N)                                                    \
177     do {                                                                \
178         jit_getarg(JIT_R0, a##N);                                       \
179         jit_patch_at(jit_bnei(JIT_R0, 17 - N), fail);                   \
180     } while (0)
181     CHECK_ARG(1);
182     CHECK_ARG(2);
183     CHECK_ARG(3);
184     CHECK_ARG(4);
185     CHECK_ARG(5);
186     CHECK_ARG(6);
187     CHECK_ARG(7);
188     CHECK_ARG(8);
189     CHECK_ARG(9);
190     CHECK_ARG(10);
191     CHECK_ARG(11);
192     CHECK_ARG(12);
193     CHECK_ARG(13);
194     CHECK_ARG(14);
195     CHECK_ARG(15);
196     CHECK_ARG(16);
197 #undef CHECK_ARG
198     jit_patch_at(jit_jmpi(), pass);
199     jit_link(fail);
200     jit_calli(abort);
201     jit_link(pass);
202     jit_ret();
203     jit_epilog();
204
205     /* Create jit function that
206      * o Receives 16 float arguments
207      * o Save in the stack any register argument. Also force register
208      *   arguments to be clobbered to properly make the test
209      * o Calls a C function that receives 16 float arguments, with
210      *   values different from the ones received by this function
211      * o Reload from stack any register argument
212      * o Validated all arguments were not modified in the known
213      *   cases it could have been clobbered
214      */
215     jf = jit_label();
216     jit_name("jf");
217     jit_note(__FILE__, __LINE__);
218     jit_prolog();
219     a1  = jit_arg_f();
220     a2  = jit_arg_f();
221     a3  = jit_arg_f();
222     a4  = jit_arg_f();
223     a5  = jit_arg_f();
224     a6  = jit_arg_f();
225     a7  = jit_arg_f();
226     a8  = jit_arg_f();
227     a9  = jit_arg_f();
228     a10 = jit_arg_f();
229     a11 = jit_arg_f();
230     a12 = jit_arg_f();
231     a13 = jit_arg_f();
232     a14 = jit_arg_f();
233     a15 = jit_arg_f();
234     a16 = jit_arg_f();
235 #define SAVE_ARG(N)                                                     \
236     do {                                                                \
237         if (jit_arg_register_p(a##N)) {                                 \
238             s##N = jit_allocai(sizeof(F));                              \
239             jit_getarg_f(JIT_F0, a##N);                                 \
240             jit_stxi_f(s##N, JIT_FP, JIT_F0);                           \
241             jit_putargi_f(-1, a##N);                                    \
242         }                                                               \
243     } while (0)
244     SAVE_ARG(1);
245     SAVE_ARG(2);
246     SAVE_ARG(3);
247     SAVE_ARG(4);
248     SAVE_ARG(5);
249     SAVE_ARG(6);
250     SAVE_ARG(7);
251     SAVE_ARG(8);
252     SAVE_ARG(9);
253     SAVE_ARG(10);
254     SAVE_ARG(11);
255     SAVE_ARG(12);
256     SAVE_ARG(13);
257     SAVE_ARG(14);
258     SAVE_ARG(15);
259     SAVE_ARG(16);
260 #undef SAVE_ARG
261     jit_prepare();
262     {
263         jit_pushargi_f(1);
264         jit_pushargi_f(2);
265         jit_pushargi_f(3);
266         jit_pushargi_f(4);
267         jit_pushargi_f(5);
268         jit_pushargi_f(6);
269         jit_pushargi_f(7);
270         jit_pushargi_f(8);
271         jit_pushargi_f(9);
272         jit_pushargi_f(10);
273         jit_pushargi_f(11);
274         jit_pushargi_f(12);
275         jit_pushargi_f(13);
276         jit_pushargi_f(14);
277         jit_pushargi_f(15);
278         jit_pushargi_f(16);
279     }
280     jit_finishi(cf);
281 #define LOAD_ARG(N)                                                     \
282     do {                                                                \
283         if (jit_arg_register_p(a##N)) {                                 \
284             jit_ldxi_f(JIT_F0, JIT_FP, s##N);                           \
285             jit_putargr_f(JIT_F0, a##N);                                \
286         }                                                               \
287     } while (0)
288     LOAD_ARG(1);
289     LOAD_ARG(2);
290     LOAD_ARG(3);
291     LOAD_ARG(4);
292     LOAD_ARG(5);
293     LOAD_ARG(6);
294     LOAD_ARG(7);
295     LOAD_ARG(8);
296     LOAD_ARG(9);
297     LOAD_ARG(10);
298     LOAD_ARG(11);
299     LOAD_ARG(12);
300     LOAD_ARG(13);
301     LOAD_ARG(14);
302     LOAD_ARG(15);
303     LOAD_ARG(16);
304 #undef LOAD_ARG
305     pass = jit_forward();
306     fail = jit_forward();
307 #define CHECK_ARG(N)                                                    \
308     do {                                                                \
309         jit_getarg_f(JIT_F0, a##N);                                     \
310         jit_patch_at(jit_bnei_f(JIT_F0, 17 - N), fail);                 \
311     } while (0)
312     CHECK_ARG(1);
313     CHECK_ARG(2);
314     CHECK_ARG(3);
315     CHECK_ARG(4);
316     CHECK_ARG(5);
317     CHECK_ARG(6);
318     CHECK_ARG(7);
319     CHECK_ARG(8);
320     CHECK_ARG(9);
321     CHECK_ARG(10);
322     CHECK_ARG(11);
323     CHECK_ARG(12);
324     CHECK_ARG(13);
325     CHECK_ARG(14);
326     CHECK_ARG(15);
327     CHECK_ARG(16);
328 #undef CHECK_ARG
329     jit_patch_at(jit_jmpi(), pass);
330     jit_link(fail);
331     jit_calli(abort);
332     jit_link(pass);
333     jit_ret();
334     jit_epilog();
335
336     /* Create jit function that
337      * o Receives 16 double arguments
338      * o Save in the stack any register argument. Also force register
339      *   arguments to be clobbered to properly make the test
340      * o Calls a C function that receives 16 double arguments, with
341      *   values different from the ones received by this function
342      * o Reload from stack any register argument
343      * o Validated all arguments were not modified in the known
344      *   cases it could have been clobbered
345      */
346     jd = jit_label();
347     jit_name("jd");
348     jit_note(__FILE__, __LINE__);
349     jit_prolog();
350     a1  = jit_arg_d();
351     a2  = jit_arg_d();
352     a3  = jit_arg_d();
353     a4  = jit_arg_d();
354     a5  = jit_arg_d();
355     a6  = jit_arg_d();
356     a7  = jit_arg_d();
357     a8  = jit_arg_d();
358     a9  = jit_arg_d();
359     a10 = jit_arg_d();
360     a11 = jit_arg_d();
361     a12 = jit_arg_d();
362     a13 = jit_arg_d();
363     a14 = jit_arg_d();
364     a15 = jit_arg_d();
365     a16 = jit_arg_d();
366 #define SAVE_ARG(N)                                                     \
367     do {                                                                \
368         if (jit_arg_register_p(a##N)) {                                 \
369             s##N = jit_allocai(sizeof(D));                              \
370             jit_getarg_d(JIT_F0, a##N);                                 \
371             jit_stxi_d(s##N, JIT_FP, JIT_F0);                           \
372             jit_putargi_d(-1, a##N);                                    \
373         }                                                               \
374     } while (0)
375     SAVE_ARG(1);
376     SAVE_ARG(2);
377     SAVE_ARG(3);
378     SAVE_ARG(4);
379     SAVE_ARG(5);
380     SAVE_ARG(6);
381     SAVE_ARG(7);
382     SAVE_ARG(8);
383     SAVE_ARG(9);
384     SAVE_ARG(10);
385     SAVE_ARG(11);
386     SAVE_ARG(12);
387     SAVE_ARG(13);
388     SAVE_ARG(14);
389     SAVE_ARG(15);
390     SAVE_ARG(16);
391 #undef SAVE_ARG
392     jit_prepare();
393     {
394         jit_pushargi_d(1);
395         jit_pushargi_d(2);
396         jit_pushargi_d(3);
397         jit_pushargi_d(4);
398         jit_pushargi_d(5);
399         jit_pushargi_d(6);
400         jit_pushargi_d(7);
401         jit_pushargi_d(8);
402         jit_pushargi_d(9);
403         jit_pushargi_d(10);
404         jit_pushargi_d(11);
405         jit_pushargi_d(12);
406         jit_pushargi_d(13);
407         jit_pushargi_d(14);
408         jit_pushargi_d(15);
409         jit_pushargi_d(16);
410     }
411     jit_finishi(cd);
412 #define LOAD_ARG(N)                                                     \
413     do {                                                                \
414         if (jit_arg_register_p(a##N)) {                                 \
415             jit_ldxi_d(JIT_F0, JIT_FP, s##N);                           \
416             jit_putargr_d(JIT_F0, a##N);                                \
417         }                                                               \
418     } while (0)
419     LOAD_ARG(1);
420     LOAD_ARG(2);
421     LOAD_ARG(3);
422     LOAD_ARG(4);
423     LOAD_ARG(5);
424     LOAD_ARG(6);
425     LOAD_ARG(7);
426     LOAD_ARG(8);
427     LOAD_ARG(9);
428     LOAD_ARG(10);
429     LOAD_ARG(11);
430     LOAD_ARG(12);
431     LOAD_ARG(13);
432     LOAD_ARG(14);
433     LOAD_ARG(15);
434     LOAD_ARG(16);
435 #undef LOAD_ARG
436     pass = jit_forward();
437     fail = jit_forward();
438 #define CHECK_ARG(N)                                                    \
439     do {                                                                \
440         jit_getarg_d(JIT_F0, a##N);                                     \
441         jit_patch_at(jit_bnei_d(JIT_F0, 17 - N), fail);                 \
442     } while (0)
443     CHECK_ARG(1);
444     CHECK_ARG(2);
445     CHECK_ARG(3);
446     CHECK_ARG(4);
447     CHECK_ARG(5);
448     CHECK_ARG(6);
449     CHECK_ARG(7);
450     CHECK_ARG(8);
451     CHECK_ARG(9);
452     CHECK_ARG(10);
453     CHECK_ARG(11);
454     CHECK_ARG(12);
455     CHECK_ARG(13);
456     CHECK_ARG(14);
457     CHECK_ARG(15);
458     CHECK_ARG(16);
459 #undef CHECK_ARG
460     jit_patch_at(jit_jmpi(), pass);
461     jit_link(fail);
462     jit_calli(abort);
463     jit_link(pass);
464     jit_ret();
465     jit_epilog();
466
467     /* Create a jit function that calls the 3 previous ones.
468      * o First call the function that receives 16 word arguments
469      * o Then call the function that receives 16 float arguments
470      * o Finally call the function that receives 16 double arguments
471      */
472     jit_patch(jmp);
473     jit_name("main");
474     jit_note(__FILE__, __LINE__);
475     jit_prolog();
476     jit_prepare();
477     {
478         jit_pushargi(16);
479         jit_pushargi(15);
480         jit_pushargi(14);
481         jit_pushargi(13);
482         jit_pushargi(12);
483         jit_pushargi(11);
484         jit_pushargi(10);
485         jit_pushargi(9);
486         jit_pushargi(8);
487         jit_pushargi(7);
488         jit_pushargi(6);
489         jit_pushargi(5);
490         jit_pushargi(4);
491         jit_pushargi(3);
492         jit_pushargi(2);
493         jit_pushargi(1);
494     }
495     jit_patch_at(jit_finishi(NULL), jw);
496
497     jit_prepare();
498     {
499         jit_pushargi_f(16);
500         jit_pushargi_f(15);
501         jit_pushargi_f(14);
502         jit_pushargi_f(13);
503         jit_pushargi_f(12);
504         jit_pushargi_f(11);
505         jit_pushargi_f(10);
506         jit_pushargi_f(9);
507         jit_pushargi_f(8);
508         jit_pushargi_f(7);
509         jit_pushargi_f(6);
510         jit_pushargi_f(5);
511         jit_pushargi_f(4);
512         jit_pushargi_f(3);
513         jit_pushargi_f(2);
514         jit_pushargi_f(1);
515     }
516     jit_patch_at(jit_finishi(NULL), jf);
517
518     jit_prepare();
519     {
520         jit_pushargi_d(16);
521         jit_pushargi_d(15);
522         jit_pushargi_d(14);
523         jit_pushargi_d(13);
524         jit_pushargi_d(12);
525         jit_pushargi_d(11);
526         jit_pushargi_d(10);
527         jit_pushargi_d(9);
528         jit_pushargi_d(8);
529         jit_pushargi_d(7);
530         jit_pushargi_d(6);
531         jit_pushargi_d(5);
532         jit_pushargi_d(4);
533         jit_pushargi_d(3);
534         jit_pushargi_d(2);
535         jit_pushargi_d(1);
536     }
537     jit_patch_at(jit_finishi(NULL), jd);
538     jit_ret();
539     jit_epilog();
540
541     code = jit_emit();
542     jit_clear_state();
543
544     (*code)();
545
546     jit_destroy_state();
547     finish_jit();
548     return (0);
549 }