notaz.gp2x.de / pcsx_rearmed.git / blame
| Commit | Line | Data |
|---|---|---|
| 4a71579b PC |
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; | |
| 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 | #define CHECK_ARG(N) \ | |
| 176 | do { \ | |
| 177 | jit_getarg(JIT_R0, a##N); \ | |
| 178 | jit_patch_at(jit_beqi(JIT_R0, 17 - N), pass); \ | |
| 179 | } while (0) | |
| 180 | CHECK_ARG(1); | |
| 181 | CHECK_ARG(2); | |
| 182 | CHECK_ARG(3); | |
| 183 | CHECK_ARG(4); | |
| 184 | CHECK_ARG(5); | |
| 185 | CHECK_ARG(6); | |
| 186 | CHECK_ARG(7); | |
| 187 | CHECK_ARG(8); | |
| 188 | CHECK_ARG(9); | |
| 189 | CHECK_ARG(10); | |
| 190 | CHECK_ARG(11); | |
| 191 | CHECK_ARG(12); | |
| 192 | CHECK_ARG(13); | |
| 193 | CHECK_ARG(14); | |
| 194 | CHECK_ARG(15); | |
| 195 | CHECK_ARG(16); | |
| 196 | #undef CHECK_ARG | |
| 197 | jit_calli(abort); | |
| 198 | jit_link(pass); | |
| 199 | jit_ret(); | |
| 200 | jit_epilog(); | |
| 201 | ||
| 202 | /* Create jit function that | |
| 203 | * o Receives 16 float arguments | |
| 204 | * o Save in the stack any register argument. Also force register | |
| 205 | * arguments to be clobbered to properly make the test | |
| 206 | * o Calls a C function that receives 16 float arguments, with | |
| 207 | * values different from the ones received by this function | |
| 208 | * o Reload from stack any register argument | |
| 209 | * o Validated all arguments were not modified in the known | |
| 210 | * cases it could have been clobbered | |
| 211 | */ | |
| 212 | jf = jit_label(); | |
| 213 | jit_name("jf"); | |
| 214 | jit_note(__FILE__, __LINE__); | |
| 215 | jit_prolog(); | |
| 216 | a1 = jit_arg_f(); | |
| 217 | a2 = jit_arg_f(); | |
| 218 | a3 = jit_arg_f(); | |
| 219 | a4 = jit_arg_f(); | |
| 220 | a5 = jit_arg_f(); | |
| 221 | a6 = jit_arg_f(); | |
| 222 | a7 = jit_arg_f(); | |
| 223 | a8 = jit_arg_f(); | |
| 224 | a9 = jit_arg_f(); | |
| 225 | a10 = jit_arg_f(); | |
| 226 | a11 = jit_arg_f(); | |
| 227 | a12 = jit_arg_f(); | |
| 228 | a13 = jit_arg_f(); | |
| 229 | a14 = jit_arg_f(); | |
| 230 | a15 = jit_arg_f(); | |
| 231 | a16 = jit_arg_f(); | |
| 232 | #define SAVE_ARG(N) \ | |
| 233 | do { \ | |
| 234 | if (jit_arg_register_p(a##N)) { \ | |
| 235 | s##N = jit_allocai(sizeof(F)); \ | |
| 236 | jit_getarg_f(JIT_F0, a##N); \ | |
| 237 | jit_stxi_f(s##N, JIT_FP, JIT_F0); \ | |
| 238 | jit_putargi_f(-1, a##N); \ | |
| 239 | } \ | |
| 240 | } while (0) | |
| 241 | SAVE_ARG(1); | |
| 242 | SAVE_ARG(2); | |
| 243 | SAVE_ARG(3); | |
| 244 | SAVE_ARG(4); | |
| 245 | SAVE_ARG(5); | |
| 246 | SAVE_ARG(6); | |
| 247 | SAVE_ARG(7); | |
| 248 | SAVE_ARG(8); | |
| 249 | SAVE_ARG(9); | |
| 250 | SAVE_ARG(10); | |
| 251 | SAVE_ARG(11); | |
| 252 | SAVE_ARG(12); | |
| 253 | SAVE_ARG(13); | |
| 254 | SAVE_ARG(14); | |
| 255 | SAVE_ARG(15); | |
| 256 | SAVE_ARG(16); | |
| 257 | #undef SAVE_ARG | |
| 258 | jit_prepare(); | |
| 259 | { | |
| 260 | jit_pushargi_f(1); | |
| 261 | jit_pushargi_f(2); | |
| 262 | jit_pushargi_f(3); | |
| 263 | jit_pushargi_f(4); | |
| 264 | jit_pushargi_f(5); | |
| 265 | jit_pushargi_f(6); | |
| 266 | jit_pushargi_f(7); | |
| 267 | jit_pushargi_f(8); | |
| 268 | jit_pushargi_f(9); | |
| 269 | jit_pushargi_f(10); | |
| 270 | jit_pushargi_f(11); | |
| 271 | jit_pushargi_f(12); | |
| 272 | jit_pushargi_f(13); | |
| 273 | jit_pushargi_f(14); | |
| 274 | jit_pushargi_f(15); | |
| 275 | jit_pushargi_f(16); | |
| 276 | } | |
| 277 | jit_finishi(cf); | |
| 278 | #define LOAD_ARG(N) \ | |
| 279 | do { \ | |
| 280 | if (jit_arg_register_p(a##N)) { \ | |
| 281 | jit_ldxi_f(JIT_F0, JIT_FP, s##N); \ | |
| 282 | jit_putargr_f(JIT_F0, a##N); \ | |
| 283 | } \ | |
| 284 | } while (0) | |
| 285 | LOAD_ARG(1); | |
| 286 | LOAD_ARG(2); | |
| 287 | LOAD_ARG(3); | |
| 288 | LOAD_ARG(4); | |
| 289 | LOAD_ARG(5); | |
| 290 | LOAD_ARG(6); | |
| 291 | LOAD_ARG(7); | |
| 292 | LOAD_ARG(8); | |
| 293 | LOAD_ARG(9); | |
| 294 | LOAD_ARG(10); | |
| 295 | LOAD_ARG(11); | |
| 296 | LOAD_ARG(12); | |
| 297 | LOAD_ARG(13); | |
| 298 | LOAD_ARG(14); | |
| 299 | LOAD_ARG(15); | |
| 300 | LOAD_ARG(16); | |
| 301 | #undef LOAD_ARG | |
| 302 | pass = jit_forward(); | |
| 303 | #define CHECK_ARG(N) \ | |
| 304 | do { \ | |
| 305 | jit_getarg_f(JIT_F0, a##N); \ | |
| 306 | jit_patch_at(jit_beqi_f(JIT_F0, 17 - N), pass); \ | |
| 307 | } while (0) | |
| 308 | CHECK_ARG(1); | |
| 309 | CHECK_ARG(2); | |
| 310 | CHECK_ARG(3); | |
| 311 | CHECK_ARG(4); | |
| 312 | CHECK_ARG(5); | |
| 313 | CHECK_ARG(6); | |
| 314 | CHECK_ARG(7); | |
| 315 | CHECK_ARG(8); | |
| 316 | CHECK_ARG(9); | |
| 317 | CHECK_ARG(10); | |
| 318 | CHECK_ARG(11); | |
| 319 | CHECK_ARG(12); | |
| 320 | CHECK_ARG(13); | |
| 321 | CHECK_ARG(14); | |
| 322 | CHECK_ARG(15); | |
| 323 | CHECK_ARG(16); | |
| 324 | #undef CHECK_ARG | |
| 325 | jit_calli(abort); | |
| 326 | jit_link(pass); | |
| 327 | jit_ret(); | |
| 328 | jit_epilog(); | |
| 329 | ||
| 330 | /* Create jit function that | |
| 331 | * o Receives 16 double arguments | |
| 332 | * o Save in the stack any register argument. Also force register | |
| 333 | * arguments to be clobbered to properly make the test | |
| 334 | * o Calls a C function that receives 16 double arguments, with | |
| 335 | * values different from the ones received by this function | |
| 336 | * o Reload from stack any register argument | |
| 337 | * o Validated all arguments were not modified in the known | |
| 338 | * cases it could have been clobbered | |
| 339 | */ | |
| 340 | jd = jit_label(); | |
| 341 | jit_name("jd"); | |
| 342 | jit_note(__FILE__, __LINE__); | |
| 343 | jit_prolog(); | |
| 344 | a1 = jit_arg_d(); | |
| 345 | a2 = jit_arg_d(); | |
| 346 | a3 = jit_arg_d(); | |
| 347 | a4 = jit_arg_d(); | |
| 348 | a5 = jit_arg_d(); | |
| 349 | a6 = jit_arg_d(); | |
| 350 | a7 = jit_arg_d(); | |
| 351 | a8 = jit_arg_d(); | |
| 352 | a9 = jit_arg_d(); | |
| 353 | a10 = jit_arg_d(); | |
| 354 | a11 = jit_arg_d(); | |
| 355 | a12 = jit_arg_d(); | |
| 356 | a13 = jit_arg_d(); | |
| 357 | a14 = jit_arg_d(); | |
| 358 | a15 = jit_arg_d(); | |
| 359 | a16 = jit_arg_d(); | |
| 360 | #define SAVE_ARG(N) \ | |
| 361 | do { \ | |
| 362 | if (jit_arg_register_p(a##N)) { \ | |
| 363 | s##N = jit_allocai(sizeof(D)); \ | |
| 364 | jit_getarg_d(JIT_F0, a##N); \ | |
| 365 | jit_stxi_d(s##N, JIT_FP, JIT_F0); \ | |
| 366 | jit_putargi_d(-1, a##N); \ | |
| 367 | } \ | |
| 368 | } while (0) | |
| 369 | SAVE_ARG(1); | |
| 370 | SAVE_ARG(2); | |
| 371 | SAVE_ARG(3); | |
| 372 | SAVE_ARG(4); | |
| 373 | SAVE_ARG(5); | |
| 374 | SAVE_ARG(6); | |
| 375 | SAVE_ARG(7); | |
| 376 | SAVE_ARG(8); | |
| 377 | SAVE_ARG(9); | |
| 378 | SAVE_ARG(10); | |
| 379 | SAVE_ARG(11); | |
| 380 | SAVE_ARG(12); | |
| 381 | SAVE_ARG(13); | |
| 382 | SAVE_ARG(14); | |
| 383 | SAVE_ARG(15); | |
| 384 | SAVE_ARG(16); | |
| 385 | #undef SAVE_ARG | |
| 386 | jit_prepare(); | |
| 387 | { | |
| 388 | jit_pushargi_d(1); | |
| 389 | jit_pushargi_d(2); | |
| 390 | jit_pushargi_d(3); | |
| 391 | jit_pushargi_d(4); | |
| 392 | jit_pushargi_d(5); | |
| 393 | jit_pushargi_d(6); | |
| 394 | jit_pushargi_d(7); | |
| 395 | jit_pushargi_d(8); | |
| 396 | jit_pushargi_d(9); | |
| 397 | jit_pushargi_d(10); | |
| 398 | jit_pushargi_d(11); | |
| 399 | jit_pushargi_d(12); | |
| 400 | jit_pushargi_d(13); | |
| 401 | jit_pushargi_d(14); | |
| 402 | jit_pushargi_d(15); | |
| 403 | jit_pushargi_d(16); | |
| 404 | } | |
| 405 | jit_finishi(cd); | |
| 406 | #define LOAD_ARG(N) \ | |
| 407 | do { \ | |
| 408 | if (jit_arg_register_p(a##N)) { \ | |
| 409 | jit_ldxi_d(JIT_F0, JIT_FP, s##N); \ | |
| 410 | jit_putargr_d(JIT_F0, a##N); \ | |
| 411 | } \ | |
| 412 | } while (0) | |
| 413 | LOAD_ARG(1); | |
| 414 | LOAD_ARG(2); | |
| 415 | LOAD_ARG(3); | |
| 416 | LOAD_ARG(4); | |
| 417 | LOAD_ARG(5); | |
| 418 | LOAD_ARG(6); | |
| 419 | LOAD_ARG(7); | |
| 420 | LOAD_ARG(8); | |
| 421 | LOAD_ARG(9); | |
| 422 | LOAD_ARG(10); | |
| 423 | LOAD_ARG(11); | |
| 424 | LOAD_ARG(12); | |
| 425 | LOAD_ARG(13); | |
| 426 | LOAD_ARG(14); | |
| 427 | LOAD_ARG(15); | |
| 428 | LOAD_ARG(16); | |
| 429 | #undef LOAD_ARG | |
| 430 | pass = jit_forward(); | |
| 431 | #define CHECK_ARG(N) \ | |
| 432 | do { \ | |
| 433 | jit_getarg_d(JIT_F0, a##N); \ | |
| 434 | jit_patch_at(jit_beqi_d(JIT_F0, 17 - N), pass); \ | |
| 435 | } while (0) | |
| 436 | CHECK_ARG(1); | |
| 437 | CHECK_ARG(2); | |
| 438 | CHECK_ARG(3); | |
| 439 | CHECK_ARG(4); | |
| 440 | CHECK_ARG(5); | |
| 441 | CHECK_ARG(6); | |
| 442 | CHECK_ARG(7); | |
| 443 | CHECK_ARG(8); | |
| 444 | CHECK_ARG(9); | |
| 445 | CHECK_ARG(10); | |
| 446 | CHECK_ARG(11); | |
| 447 | CHECK_ARG(12); | |
| 448 | CHECK_ARG(13); | |
| 449 | CHECK_ARG(14); | |
| 450 | CHECK_ARG(15); | |
| 451 | CHECK_ARG(16); | |
| 452 | #undef CHECK_ARG | |
| 453 | jit_calli(abort); | |
| 454 | jit_link(pass); | |
| 455 | jit_ret(); | |
| 456 | jit_epilog(); | |
| 457 | ||
| 458 | /* Create a jit function that calls the 3 previous ones. | |
| 459 | * o First call the function that receives 16 word arguments | |
| 460 | * o Then call the function that receives 16 float arguments | |
| 461 | * o Finally call the function that receives 16 double arguments | |
| 462 | */ | |
| 463 | jit_patch(jmp); | |
| 464 | jit_name("main"); | |
| 465 | jit_note(__FILE__, __LINE__); | |
| 466 | jit_prolog(); | |
| 467 | jit_prepare(); | |
| 468 | { | |
| 469 | jit_pushargi(16); | |
| 470 | jit_pushargi(15); | |
| 471 | jit_pushargi(14); | |
| 472 | jit_pushargi(13); | |
| 473 | jit_pushargi(12); | |
| 474 | jit_pushargi(11); | |
| 475 | jit_pushargi(10); | |
| 476 | jit_pushargi(9); | |
| 477 | jit_pushargi(8); | |
| 478 | jit_pushargi(7); | |
| 479 | jit_pushargi(6); | |
| 480 | jit_pushargi(5); | |
| 481 | jit_pushargi(4); | |
| 482 | jit_pushargi(3); | |
| 483 | jit_pushargi(2); | |
| 484 | jit_pushargi(1); | |
| 485 | } | |
| 486 | jit_patch_at(jit_finishi(NULL), jw); | |
| 487 | jit_prepare(); | |
| 488 | { | |
| 489 | jit_pushargi_f(16); | |
| 490 | jit_pushargi_f(15); | |
| 491 | jit_pushargi_f(14); | |
| 492 | jit_pushargi_f(13); | |
| 493 | jit_pushargi_f(12); | |
| 494 | jit_pushargi_f(11); | |
| 495 | jit_pushargi_f(10); | |
| 496 | jit_pushargi_f(9); | |
| 497 | jit_pushargi_f(8); | |
| 498 | jit_pushargi_f(7); | |
| 499 | jit_pushargi_f(6); | |
| 500 | jit_pushargi_f(5); | |
| 501 | jit_pushargi_f(4); | |
| 502 | jit_pushargi_f(3); | |
| 503 | jit_pushargi_f(2); | |
| 504 | jit_pushargi_f(1); | |
| 505 | } | |
| 506 | jit_patch_at(jit_finishi(NULL), jf); | |
| 507 | jit_prepare(); | |
| 508 | { | |
| 509 | jit_pushargi_d(16); | |
| 510 | jit_pushargi_d(15); | |
| 511 | jit_pushargi_d(14); | |
| 512 | jit_pushargi_d(13); | |
| 513 | jit_pushargi_d(12); | |
| 514 | jit_pushargi_d(11); | |
| 515 | jit_pushargi_d(10); | |
| 516 | jit_pushargi_d(9); | |
| 517 | jit_pushargi_d(8); | |
| 518 | jit_pushargi_d(7); | |
| 519 | jit_pushargi_d(6); | |
| 520 | jit_pushargi_d(5); | |
| 521 | jit_pushargi_d(4); | |
| 522 | jit_pushargi_d(3); | |
| 523 | jit_pushargi_d(2); | |
| 524 | jit_pushargi_d(1); | |
| 525 | } | |
| 526 | jit_patch_at(jit_finishi(NULL), jd); | |
| 527 | jit_ret(); | |
| 528 | jit_epilog(); | |
| 529 | ||
| 530 | code = jit_emit(); | |
| 531 | jit_clear_state(); | |
| 532 | ||
| 533 | (*code)(); | |
| 534 | ||
| 535 | jit_destroy_state(); | |
| 536 | finish_jit(); | |
| 537 | return (0); | |
| 538 | } |