test_src/sljitTest.c

   1 /*
   2  *    Stack-less Just-In-Time compiler
   3  *
   4  *    Copyright Zoltan Herczeg (hzmester@freemail.hu). All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without modification, are
   7  * permitted provided that the following conditions are met:
   8  *
   9  *   1. Redistributions of source code must retain the above copyright notice, this list of
  10  *      conditions and the following disclaimer.
  11  *
  12  *   2. Redistributions in binary form must reproduce the above copyright notice, this list
  13  *      of conditions and the following disclaimer in the documentation and/or other materials
  14  *      provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND CONTRIBUTORS ``AS IS'' AND ANY
  17  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  18  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
  19  * SHALL THE COPYRIGHT HOLDER(S) OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  20  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
  21  * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  22  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  23  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  24  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 /* Must be the first one. Must not depend on any other include. */
  28 #include "sljitLir.h"
  29
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33
  34 #ifdef _MSC_VER
  35 #pragma warning(push)
  36 #pragma warning(disable: 4127) /* conditional expression is constant */
  37 #endif
  38
  39 #if defined _WIN32 || defined _WIN64
  40 #define COLOR_RED
  41 #define COLOR_GREEN
  42 #define COLOR_ARCH
  43 #define COLOR_DEFAULT
  44 #else
  45 #define COLOR_RED "\33[31m"
  46 #define COLOR_GREEN "\33[32m"
  47 #define COLOR_ARCH "\33[33m"
  48 #define COLOR_DEFAULT "\33[0m"
  49 #endif
  50
  51 union executable_code {
  52         void* code;
  53         sljit_sw (SLJIT_FUNC *func0)(void);
  54         sljit_sw (SLJIT_FUNC *func1)(sljit_sw a);
  55         sljit_sw (SLJIT_FUNC *func2)(sljit_sw a, sljit_sw b);
  56         sljit_sw (SLJIT_FUNC *func3)(sljit_sw a, sljit_sw b, sljit_sw c);
  57
  58         sljit_sw (*test53_f1)(sljit_sw a, sljit_sw b, sljit_sw c);
  59
  60         void (SLJIT_FUNC *test70_f1)(sljit_s32 a, sljit_uw b, sljit_u32 c, sljit_sw d);
  61         void (*test70_f2)(sljit_s32 a, sljit_u32 b, sljit_sw c, sljit_sw d);
  62         void (SLJIT_FUNC *test70_f3)(sljit_s32 a, sljit_f32 b, sljit_uw c, sljit_f64 d);
  63         void (SLJIT_FUNC *test70_f4)(sljit_f32 a, sljit_f64 b, sljit_f32 c, sljit_s32 d);
  64         void (SLJIT_FUNC *test70_f5)(sljit_f64 a, sljit_f32 b, sljit_u32 c, sljit_f32 d);
  65         void (SLJIT_FUNC *test70_f6)(sljit_f64 a, sljit_s32 b, sljit_f32 c, sljit_f64 d);
  66         void (SLJIT_FUNC *test70_f7)(sljit_f32 a, sljit_s32 b, sljit_uw c, sljit_u32 d);
  67         void (SLJIT_FUNC *test70_f8)(sljit_f64 a, sljit_f64 b, sljit_uw c, sljit_sw d);
  68         void (SLJIT_FUNC *test70_f9)(sljit_f64 a, sljit_f64 b, sljit_uw c, sljit_f64 d);
  69         void (SLJIT_FUNC *test70_f10)(sljit_f64 a, sljit_f64 b, sljit_f64 c, sljit_s32 d);
  70
  71         sljit_sw (*test71_f1)(sljit_sw a, sljit_sw b, sljit_sw c, sljit_sw d);
  72         sljit_sw (*test71_f2)(sljit_f64 a, sljit_f64 b);
  73         sljit_sw (SLJIT_FUNC *test71_f3)(sljit_f64 a, sljit_f64 b, sljit_f64 c, sljit_f64 d);
  74         sljit_sw (SLJIT_FUNC *test71_f4)(sljit_f64 a, sljit_f64 b, sljit_f64 c);
  75
  76         void (SLJIT_FUNC *test73_f1)(sljit_s32 a, sljit_sw b, sljit_sw c, sljit_s32 d);
  77         void (*test73_f2)(sljit_sw a, sljit_sw b, sljit_s32 c, sljit_s32 d);
  78         void (SLJIT_FUNC *test73_f3)(sljit_f64 a, sljit_f64 b, sljit_f64 c, sljit_sw d);
  79         void (SLJIT_FUNC *test73_f4)(sljit_f64 a, sljit_f64 b, sljit_sw c, sljit_sw d);
  80 };
  81 typedef union executable_code executable_code;
  82
  83 static sljit_s32 successful_tests = 0;
  84 static sljit_s32 verbose = 0;
  85 static sljit_s32 silent = 0;
  86
  87 #define FAILED(cond, text) \
  88         if (SLJIT_UNLIKELY(cond)) { \
  89                 printf(text); \
  90                 return; \
  91         }
  92
  93 #define CHECK(compiler) \
  94         if (sljit_get_compiler_error(compiler) != SLJIT_ERR_COMPILED) { \
  95                 printf("Compiler error: %d\n", sljit_get_compiler_error(compiler)); \
  96                 sljit_free_compiler(compiler); \
  97                 return; \
  98         }
  99
 100 static void cond_set(struct sljit_compiler *compiler, sljit_s32 dst, sljit_sw dstw, sljit_s32 type)
 101 {
 102         /* Testing both sljit_emit_op_flags and sljit_emit_jump. */
 103         struct sljit_jump* jump;
 104         struct sljit_label* label;
 105
 106         sljit_emit_op_flags(compiler, SLJIT_MOV, dst, dstw, type);
 107         jump = sljit_emit_jump(compiler, type);
 108         sljit_emit_op2(compiler, SLJIT_ADD, dst, dstw, dst, dstw, SLJIT_IMM, 2);
 109         label = sljit_emit_label(compiler);
 110         sljit_set_label(jump, label);
 111 }
 112
 113 #if !(defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED)
 114
 115 /* For interface testing and for test64. */
 116 void *sljit_test_malloc_exec(sljit_uw size, void *exec_allocator_data)
 117 {
 118         if (exec_allocator_data)
 119                 return exec_allocator_data;
 120
 121         return SLJIT_BUILTIN_MALLOC_EXEC(size, exec_allocator_data);
 122 }
 123
 124 /* For interface testing. */
 125 void sljit_test_free_code(void* code, void *exec_allocator_data)
 126 {
 127         SLJIT_UNUSED_ARG(exec_allocator_data);
 128         SLJIT_BUILTIN_FREE_EXEC(code, exec_allocator_data);
 129 }
 130
 131 #define MALLOC_EXEC(result, size) \
 132         result = SLJIT_MALLOC_EXEC(size, NULL); \
 133         if (!result) { \
 134                 printf("Cannot allocate executable memory\n"); \
 135                 return; \
 136         } \
 137         memset(result, 255, size);
 138
 139 #define FREE_EXEC(ptr) \
 140         SLJIT_FREE_EXEC(((sljit_u8*)(ptr)) + SLJIT_EXEC_OFFSET(ptr), NULL);
 141
 142 static void test_exec_allocator(void)
 143 {
 144         /* This is not an sljit test. */
 145         void *ptr1;
 146         void *ptr2;
 147         void *ptr3;
 148
 149         if (verbose)
 150                 printf("Run executable allocator test\n");
 151
 152         MALLOC_EXEC(ptr1, 32);
 153         MALLOC_EXEC(ptr2, 512);
 154         MALLOC_EXEC(ptr3, 512);
 155         FREE_EXEC(ptr2);
 156         FREE_EXEC(ptr3);
 157         FREE_EXEC(ptr1);
 158         MALLOC_EXEC(ptr1, 262104);
 159         MALLOC_EXEC(ptr2, 32000);
 160         FREE_EXEC(ptr1);
 161         MALLOC_EXEC(ptr1, 262104);
 162         FREE_EXEC(ptr1);
 163         FREE_EXEC(ptr2);
 164         MALLOC_EXEC(ptr1, 512);
 165         MALLOC_EXEC(ptr2, 512);
 166         MALLOC_EXEC(ptr3, 512);
 167         FREE_EXEC(ptr2);
 168         MALLOC_EXEC(ptr2, 512);
 169 #if (defined SLJIT_EXECUTABLE_ALLOCATOR && SLJIT_EXECUTABLE_ALLOCATOR)
 170         sljit_free_unused_memory_exec();
 171 #endif
 172         FREE_EXEC(ptr3);
 173         FREE_EXEC(ptr1);
 174         FREE_EXEC(ptr2);
 175
 176 #if (defined SLJIT_EXECUTABLE_ALLOCATOR && SLJIT_EXECUTABLE_ALLOCATOR)
 177         sljit_free_unused_memory_exec();
 178 #endif
 179 }
 180
 181 #undef MALLOC_EXEC
 182
 183 #endif /* !(defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED) */
 184
 185 static void test1(void)
 186 {
 187         /* Enter and return from an sljit function. */
 188         executable_code code;
 189         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
 190
 191         if (verbose)
 192                 printf("Run test1\n");
 193
 194         FAILED(!compiler, "cannot create compiler\n");
 195
 196         /* 3 arguments passed, 3 arguments used. */
 197         sljit_emit_enter(compiler, 0, SLJIT_ARGS3(W, W, W, W), 3, 3, 0, 0, 0);
 198         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_S1, 0);
 199
 200         SLJIT_ASSERT(sljit_get_generated_code_size(compiler) == 0);
 201         code.code = sljit_generate_code(compiler);
 202         CHECK(compiler);
 203         SLJIT_ASSERT(compiler->error == SLJIT_ERR_COMPILED);
 204         SLJIT_ASSERT(sljit_get_generated_code_size(compiler) > 0);
 205         sljit_free_compiler(compiler);
 206
 207         FAILED(code.func3(3, -21, 86) != -21, "test1 case 1 failed\n");
 208         FAILED(code.func3(4789, 47890, 997) != 47890, "test1 case 2 failed\n");
 209
 210         sljit_free_code(code.code, NULL);
 211         successful_tests++;
 212 }
 213
 214 static void test2(void)
 215 {
 216         /* Test mov. */
 217         executable_code code;
 218         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
 219         sljit_sw buf[8];
 220         static sljit_sw data[2] = { 0, -9876 };
 221
 222         if (verbose)
 223                 printf("Run test2\n");
 224
 225         FAILED(!compiler, "cannot create compiler\n");
 226
 227         buf[0] = 5678;
 228         buf[1] = 0;
 229         buf[2] = 0;
 230         buf[3] = 0;
 231         buf[4] = 0;
 232         buf[5] = 0;
 233         buf[6] = 0;
 234         buf[7] = 0;
 235         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(W, P), 3, 2, 0, 0, 0);
 236         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 9999);
 237         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_S0, 0);
 238         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_sw), SLJIT_R0, 0);
 239         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, sizeof(sljit_sw));
 240         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_MEM2(SLJIT_S1, SLJIT_R1), 0);
 241         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, 2);
 242         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM2(SLJIT_S1, SLJIT_S0), SLJIT_WORD_SHIFT, SLJIT_MEM2(SLJIT_S1, SLJIT_R1), 0);
 243         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, 3);
 244         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM2(SLJIT_S1, SLJIT_S0), SLJIT_WORD_SHIFT, SLJIT_MEM0(), (sljit_sw)&buf);
 245         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, sizeof(sljit_sw));
 246         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_R0), (sljit_sw)&data);
 247         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S1), 4 * sizeof(sljit_sw), SLJIT_R0, 0);
 248         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&buf - 0x12345678);
 249         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_R0), 0x12345678);
 250         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S1), 5 * sizeof(sljit_sw), SLJIT_R0, 0);
 251         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 3456);
 252         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, (sljit_sw)&buf - 0xff890 + 6 * (sljit_sw)sizeof(sljit_sw));
 253         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), 0xff890, SLJIT_R0, 0);
 254         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, (sljit_sw)&buf + 0xff890 + 7 * (sljit_sw)sizeof(sljit_sw));
 255         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), -0xff890, SLJIT_R0, 0);
 256         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_R2, 0);
 257
 258         code.code = sljit_generate_code(compiler);
 259         CHECK(compiler);
 260         sljit_free_compiler(compiler);
 261
 262         FAILED(code.func1((sljit_sw)&buf) != 9999, "test2 case 1 failed\n");
 263         FAILED(buf[1] != 9999, "test2 case 2 failed\n");
 264         FAILED(buf[2] != 9999, "test2 case 3 failed\n");
 265         FAILED(buf[3] != 5678, "test2 case 4 failed\n");
 266         FAILED(buf[4] != -9876, "test2 case 5 failed\n");
 267         FAILED(buf[5] != 5678, "test2 case 6 failed\n");
 268         FAILED(buf[6] != 3456, "test2 case 6 failed\n");
 269         FAILED(buf[7] != 3456, "test2 case 6 failed\n");
 270
 271         sljit_free_code(code.code, NULL);
 272         successful_tests++;
 273 }
 274
 275 static void test3(void)
 276 {
 277         /* Test not. */
 278         executable_code code;
 279         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
 280         sljit_sw buf[5];
 281
 282         if (verbose)
 283                 printf("Run test3\n");
 284
 285         FAILED(!compiler, "cannot create compiler\n");
 286         buf[0] = 1234;
 287         buf[1] = 0;
 288         buf[2] = 9876;
 289         buf[3] = 0;
 290         buf[4] = 0x12345678;
 291
 292         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(W, P), 3, 1, 0, 0, 0);
 293         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_MEM1(SLJIT_S0), 0);
 294         sljit_emit_op1(compiler, SLJIT_NOT, SLJIT_MEM0(), (sljit_sw)&buf[1], SLJIT_MEM0(), (sljit_sw)&buf[1]);
 295         sljit_emit_op1(compiler, SLJIT_NOT, SLJIT_RETURN_REG, 0, SLJIT_MEM1(SLJIT_S0), 0);
 296         sljit_emit_op1(compiler, SLJIT_NOT, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 3, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 2);
 297         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, (sljit_sw)&buf[4] - 0xff0000 - 0x20);
 298         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, (sljit_sw)&buf[4] - 0xff0000);
 299         sljit_emit_op1(compiler, SLJIT_NOT, SLJIT_MEM1(SLJIT_R1), 0xff0000 + 0x20, SLJIT_MEM1(SLJIT_R2), 0xff0000);
 300         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);
 301
 302         code.code = sljit_generate_code(compiler);
 303         CHECK(compiler);
 304         sljit_free_compiler(compiler);
 305
 306         FAILED(code.func1((sljit_sw)&buf) != ~1234, "test3 case 1 failed\n");
 307         FAILED(buf[1] != ~1234, "test3 case 2 failed\n");
 308         FAILED(buf[3] != ~9876, "test3 case 3 failed\n");
 309         FAILED(buf[4] != ~0x12345678, "test3 case 4 failed\n");
 310
 311         sljit_free_code(code.code, NULL);
 312         successful_tests++;
 313 }
 314
 315 static void test4(void)
 316 {
 317         /* Test neg. */
 318         executable_code code;
 319         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
 320         sljit_sw buf[4];
 321
 322         if (verbose)
 323                 printf("Run test4\n");
 324
 325         FAILED(!compiler, "cannot create compiler\n");
 326         buf[0] = 0;
 327         buf[1] = 1234;
 328         buf[2] = 0;
 329         buf[3] = 0;
 330
 331         sljit_emit_enter(compiler, 0, SLJIT_ARGS2(W, P, W), 3, 2, 0, 0, 0);
 332         sljit_emit_op1(compiler, SLJIT_NEG, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 2, SLJIT_S1, 0);
 333         sljit_emit_op1(compiler, SLJIT_NEG, SLJIT_MEM0(), (sljit_sw)&buf[0], SLJIT_MEM0(), (sljit_sw)&buf[1]);
 334         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 299);
 335         sljit_emit_op1(compiler, SLJIT_NEG, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 3, SLJIT_R1, 0);
 336         sljit_emit_op1(compiler, SLJIT_NEG, SLJIT_RETURN_REG, 0, SLJIT_S1, 0);
 337         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);
 338
 339         code.code = sljit_generate_code(compiler);
 340         CHECK(compiler);
 341         sljit_free_compiler(compiler);
 342
 343         FAILED(code.func2((sljit_sw)&buf, 4567) != -4567, "test4 case 1 failed\n");
 344         FAILED(buf[0] != -1234, "test4 case 2 failed\n");
 345         FAILED(buf[2] != -4567, "test4 case 3 failed\n");
 346         FAILED(buf[3] != -299, "test4 case 4 failed\n");
 347
 348         sljit_free_code(code.code, NULL);
 349         successful_tests++;
 350 }
 351
 352 static void test5(void)
 353 {
 354         /* Test add. */
 355         executable_code code;
 356         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
 357         sljit_sw buf[9];
 358
 359         if (verbose)
 360                 printf("Run test5\n");
 361
 362         FAILED(!compiler, "cannot create compiler\n");
 363         buf[0] = 100;
 364         buf[1] = 200;
 365         buf[2] = 300;
 366         buf[3] = 0;
 367         buf[4] = 0;
 368         buf[5] = 0;
 369         buf[6] = 0;
 370         buf[7] = 0;
 371         buf[8] = 313;
 372
 373         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(W, P), 3, 2, 0, 0, 0);
 374         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, sizeof(sljit_sw));
 375         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 50);
 376         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM2(SLJIT_S0, SLJIT_R0), 1, SLJIT_MEM2(SLJIT_S0, SLJIT_R0), 1, SLJIT_MEM2(SLJIT_S0, SLJIT_R0), 0);
 377         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, sizeof(sljit_sw) + 2);
 378         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, 50);
 379         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), 0);
 380         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0);
 381         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_IMM, 4, SLJIT_R0, 0);
 382         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_IMM, 50, SLJIT_R1, 0);
 383         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_IMM, 50, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw));
 384         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_R1, 0);
 385         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_R1, 0, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw));
 386         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw));
 387         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_R1, 0);
 388         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0x1e7d39f2);
 389         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_sw), SLJIT_R1, 0, SLJIT_IMM, 0x23de7c06);
 390         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_sw), SLJIT_IMM, 0x3d72e452, SLJIT_R1, 0);
 391         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_sw), SLJIT_IMM, -43, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_sw));
 392         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_IMM, 1000, SLJIT_R0, 0);
 393         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 1430);
 394         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_IMM, -99, SLJIT_R0, 0);
 395
 396         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_R0, 0);
 397
 398         code.code = sljit_generate_code(compiler);
 399         CHECK(compiler);
 400         sljit_free_compiler(compiler);
 401
 402         FAILED(code.func1((sljit_sw)&buf) != 2437 + 2 * sizeof(sljit_sw), "test5 case 1 failed\n");
 403         FAILED(buf[0] != 202 + 2 * sizeof(sljit_sw), "test5 case 2 failed\n");
 404         FAILED(buf[2] != 500, "test5 case 3 failed\n");
 405         FAILED(buf[3] != 400, "test5 case 4 failed\n");
 406         FAILED(buf[4] != 200, "test5 case 5 failed\n");
 407         FAILED(buf[5] != 250, "test5 case 6 failed\n");
 408         FAILED(buf[6] != 0x425bb5f8, "test5 case 7 failed\n");
 409         FAILED(buf[7] != 0x5bf01e44, "test5 case 8 failed\n");
 410         FAILED(buf[8] != 270, "test5 case 9 failed\n");
 411
 412         sljit_free_code(code.code, NULL);
 413         successful_tests++;
 414 }
 415
 416 static void test6(void)
 417 {
 418         /* Test addc, sub, subc. */
 419         executable_code code;
 420         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
 421         sljit_sw buf[11];
 422
 423         if (verbose)
 424                 printf("Run test6\n");
 425
 426         FAILED(!compiler, "cannot create compiler\n");
 427         buf[0] = 0;
 428         buf[1] = 0;
 429         buf[2] = 0;
 430         buf[3] = 0;
 431         buf[4] = 0;
 432         buf[5] = 0;
 433         buf[6] = 0;
 434         buf[7] = 0;
 435         buf[8] = 0;
 436         buf[9] = 0;
 437         buf[10] = 4000;
 438
 439         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(W, P), 3, 1, 0, 0, 0);
 440         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -1);
 441         sljit_emit_op2(compiler, SLJIT_ADD | SLJIT_SET_CARRY, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, -1);
 442         sljit_emit_op2(compiler, SLJIT_ADDC, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_IMM, 0, SLJIT_IMM, 0);
 443         sljit_emit_op2(compiler, SLJIT_ADD | SLJIT_SET_CARRY, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_R0, 0);
 444         sljit_emit_op2(compiler, SLJIT_ADDC, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_IMM, 4);
 445         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 100);
 446         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 2, SLJIT_R0, 0, SLJIT_IMM, 50);
 447         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_CARRY, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 6000);
 448         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 3, SLJIT_IMM, 10);
 449         sljit_emit_op2(compiler, SLJIT_SUBC, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 3, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 3, SLJIT_IMM, 5);
 450         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 100);
 451         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 2);
 452         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 4, SLJIT_R0, 0);
 453         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 5000);
 454         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 4, SLJIT_R0, 0);
 455         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_R1, 0);
 456         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 5, SLJIT_R1, 0);
 457         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 5000);
 458         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R0, 0, SLJIT_IMM, 6000, SLJIT_R0, 0);
 459         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 6, SLJIT_R0, 0);
 460         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 100);
 461         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, 32768);
 462         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 7, SLJIT_R1, 0);
 463         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, -32767);
 464         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 8, SLJIT_R1, 0);
 465         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0x52cd3bf4);
 466         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 9, SLJIT_R0, 0, SLJIT_IMM, 0x3da297c6);
 467         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 6000);
 468         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 10, SLJIT_R1, 0);
 469         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 10, SLJIT_R1, 0);
 470         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, 10);
 471         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_CARRY, SLJIT_RETURN_REG, 0, SLJIT_RETURN_REG, 0, SLJIT_IMM, 5);
 472         sljit_emit_op2(compiler, SLJIT_SUBC, SLJIT_RETURN_REG, 0, SLJIT_RETURN_REG, 0, SLJIT_IMM, 2);
 473         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_RETURN_REG, 0, SLJIT_RETURN_REG, 0, SLJIT_IMM, -2220);
 474         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);
 475
 476         code.code = sljit_generate_code(compiler);
 477         CHECK(compiler);
 478         sljit_free_compiler(compiler);
 479
 480         FAILED(code.func1((sljit_sw)&buf) != 2223, "test6 case 1 failed\n");
 481         FAILED(buf[0] != 1, "test6 case 2 failed\n");
 482         FAILED(buf[1] != 5, "test6 case 3 failed\n");
 483         FAILED(buf[2] != 50, "test6 case 4 failed\n");
 484         FAILED(buf[3] != 4, "test6 case 5 failed\n");
 485         FAILED(buf[4] != 50, "test6 case 6 failed\n");
 486         FAILED(buf[5] != 50, "test6 case 7 failed\n");
 487         FAILED(buf[6] != 1000, "test6 case 8 failed\n");
 488         FAILED(buf[7] != 100 - 32768, "test6 case 9 failed\n");
 489         FAILED(buf[8] != 100 + 32767, "test6 case 10 failed\n");
 490         FAILED(buf[9] != 0x152aa42e, "test6 case 11 failed\n");
 491         FAILED(buf[10] != -2000, "test6 case 12 failed\n");
 492
 493         sljit_free_code(code.code, NULL);
 494         successful_tests++;
 495 }
 496
 497 static void test7(void)
 498 {
 499         /* Test logical operators. */
 500         executable_code code;
 501         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
 502         sljit_sw buf[8];
 503
 504         if (verbose)
 505                 printf("Run test7\n");
 506
 507         FAILED(!compiler, "cannot create compiler\n");
 508         buf[0] = 0xff80;
 509         buf[1] = 0x0f808080;
 510         buf[2] = 0;
 511         buf[3] = 0xaaaaaa;
 512         buf[4] = 0;
 513         buf[5] = 0x4040;
 514         buf[6] = 0;
 515         buf[7] = (sljit_sw)0xc43a7f95;
 516
 517         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(W, P), 3, 1, 0, 0, 0);
 518         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0xf0C000);
 519         sljit_emit_op2(compiler, SLJIT_OR, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 2, SLJIT_R0, 0, SLJIT_IMM, 0x308f);
 520         sljit_emit_op2(compiler, SLJIT_XOR, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw));
 521         sljit_emit_op2(compiler, SLJIT_AND, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 3, SLJIT_IMM, 0xf0f0f0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 3);
 522         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0xC0F0);
 523         sljit_emit_op2(compiler, SLJIT_XOR, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 5);
 524         sljit_emit_op2(compiler, SLJIT_OR, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 0xff0000);
 525         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 4, SLJIT_R0, 0);
 526         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 0xC0F0);
 527         sljit_emit_op2(compiler, SLJIT_AND, SLJIT_R2, 0, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 5);
 528         sljit_emit_op2(compiler, SLJIT_OR, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 5, SLJIT_R2, 0, SLJIT_IMM, 0xff0000);
 529         sljit_emit_op2(compiler, SLJIT_XOR, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_IMM, 0xFFFFFF, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw));
 530         sljit_emit_op2(compiler, SLJIT_OR, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 6, SLJIT_IMM, (sljit_sw)0xa56c82c0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 6);
 531         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 7);
 532         sljit_emit_op2(compiler, SLJIT_XOR, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 7, SLJIT_IMM, (sljit_sw)0xff00ff00, SLJIT_R0, 0);
 533         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)0xff00ff00);
 534         sljit_emit_op2(compiler, SLJIT_OR, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, 0x0f);
 535         sljit_emit_op2(compiler, SLJIT_AND, SLJIT_RETURN_REG, 0, SLJIT_IMM, 0x888888, SLJIT_R1, 0);
 536         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);
 537
 538         code.code = sljit_generate_code(compiler);
 539         CHECK(compiler);
 540         sljit_free_compiler(compiler);
 541
 542         FAILED(code.func1((sljit_sw)&buf) != 0x8808, "test7 case 1 failed\n");
 543         FAILED(buf[0] != 0x0F807F00, "test7 case 2 failed\n");
 544         FAILED(buf[1] != 0x0F7F7F7F, "test7 case 3 failed\n");
 545         FAILED(buf[2] != 0x00F0F08F, "test7 case 4 failed\n");
 546         FAILED(buf[3] != 0x00A0A0A0, "test7 case 5 failed\n");
 547         FAILED(buf[4] != 0x00FF80B0, "test7 case 6 failed\n");
 548         FAILED(buf[5] != 0x00FF4040, "test7 case 7 failed\n");
 549         FAILED(buf[6] != (sljit_sw)0xa56c82c0, "test7 case 8 failed\n");
 550         FAILED(buf[7] != 0x3b3a8095, "test7 case 9 failed\n");
 551
 552         sljit_free_code(code.code, NULL);
 553         successful_tests++;
 554 }
 555
 556 static void test8(void)
 557 {
 558         /* Test flags (neg, cmp, test). */
 559         executable_code code;
 560         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
 561         sljit_sw buf[13];
 562
 563         if (verbose)
 564                 printf("Run test8\n");
 565
 566         FAILED(!compiler, "cannot create compiler\n");
 567         buf[0] = 100;
 568         buf[1] = 3;
 569         buf[2] = 3;
 570         buf[3] = 3;
 571         buf[4] = 3;
 572         buf[5] = 3;
 573         buf[6] = 3;
 574         buf[7] = 3;
 575         buf[8] = 3;
 576         buf[9] = 3;
 577         buf[10] = 3;
 578         buf[11] = 3;
 579         buf[12] = 3;
 580
 581         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, P), 3, 2, 0, 0, 0);
 582         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 20);
 583         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 10);
 584         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_Z, SLJIT_IMM, 6, SLJIT_IMM, 5);
 585         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_NOT_EQUAL);
 586         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 2, SLJIT_EQUAL);
 587         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_GREATER, SLJIT_R0, 0, SLJIT_IMM, 3000);
 588         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_GREATER);
 589         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_LESS, SLJIT_R0, 0, SLJIT_IMM, 3000);
 590         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 3, SLJIT_S1, 0);
 591         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_LESS);
 592         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 4, SLJIT_R2, 0);
 593         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_SIG_GREATER, SLJIT_R0, 0, SLJIT_IMM, -15);
 594         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_SIG_GREATER);
 595         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 5, SLJIT_R2, 0);
 596         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -(sljit_sw)(~(sljit_uw)0 >> 1) - 1);
 597         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_Z | SLJIT_SET_OVERFLOW, SLJIT_R0, 0, SLJIT_R1, 0);
 598         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_Z | SLJIT_SET_OVERFLOW, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0);
 599         sljit_emit_op1(compiler, SLJIT_NEG | SLJIT_SET_Z | SLJIT_SET_OVERFLOW, SLJIT_R1, 0, SLJIT_R0, 0);
 600         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 6, SLJIT_OVERFLOW);
 601         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -1);
 602         sljit_emit_op1(compiler, SLJIT_NOT | SLJIT_SET_Z, SLJIT_R1, 0, SLJIT_R0, 0);
 603         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 7, SLJIT_ZERO);
 604         sljit_emit_op1(compiler, SLJIT_NOT | SLJIT_SET_Z, SLJIT_R0, 0, SLJIT_R1, 0);
 605         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 8, SLJIT_ZERO);
 606         sljit_emit_op2u(compiler, SLJIT_AND | SLJIT_SET_Z, SLJIT_IMM, 0xffff, SLJIT_R0, 0);
 607         sljit_emit_op2u(compiler, SLJIT_AND | SLJIT_SET_Z, SLJIT_R0, 0, SLJIT_IMM, 0xffff);
 608         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 9, SLJIT_NOT_ZERO);
 609         sljit_emit_op2u(compiler, SLJIT_AND | SLJIT_SET_Z, SLJIT_IMM, 0xffff, SLJIT_R1, 0);
 610         sljit_emit_op2u(compiler, SLJIT_AND | SLJIT_SET_Z, SLJIT_R1, 0, SLJIT_IMM, 0xffff);
 611         sljit_emit_op2u(compiler, SLJIT_AND | SLJIT_SET_Z, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R1, 0);
 612         sljit_emit_op2u(compiler, SLJIT_AND | SLJIT_SET_Z, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_S0), 0);
 613         sljit_emit_op2u(compiler, SLJIT_AND | SLJIT_SET_Z, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_MEM1(SLJIT_S0), 0);
 614         sljit_emit_op2u(compiler, SLJIT_AND | SLJIT_SET_Z, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_IMM, 0x1);
 615         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 10, SLJIT_NOT_ZERO);
 616         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -(sljit_sw)(~(sljit_uw)0 >> 1) - 1);
 617         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0);
 618         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_OVERFLOW, SLJIT_R1, 0, SLJIT_R0, 0);
 619         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 11, SLJIT_OVERFLOW);
 620         sljit_emit_op2u(compiler, SLJIT_ADD | SLJIT_SET_OVERFLOW, SLJIT_R1, 0, SLJIT_R0, 0);
 621         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 12, SLJIT_OVERFLOW);
 622         sljit_emit_return_void(compiler);
 623
 624         code.code = sljit_generate_code(compiler);
 625         CHECK(compiler);
 626         sljit_free_compiler(compiler);
 627
 628         code.func1((sljit_sw)&buf);
 629         FAILED(buf[1] != 1, "test8 case 1 failed\n");
 630         FAILED(buf[2] != 0, "test8 case 2 failed\n");
 631         FAILED(buf[3] != 0, "test8 case 3 failed\n");
 632         FAILED(buf[4] != 1, "test8 case 4 failed\n");
 633         FAILED(buf[5] != 1, "test8 case 5 failed\n");
 634         FAILED(buf[6] != 1, "test8 case 6 failed\n");
 635         FAILED(buf[7] != 1, "test8 case 7 failed\n");
 636         FAILED(buf[8] != 0, "test8 case 8 failed\n");
 637         FAILED(buf[9] != 1, "test8 case 9 failed\n");
 638         FAILED(buf[10] != 0, "test8 case 10 failed\n");
 639         FAILED(buf[11] != 1, "test8 case 11 failed\n");
 640         FAILED(buf[12] != 0, "test8 case 12 failed\n");
 641
 642         sljit_free_code(code.code, NULL);
 643         successful_tests++;
 644 }
 645
 646 static void test9(void)
 647 {
 648         /* Test shift. */
 649         executable_code code;
 650         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
 651         sljit_sw buf[13];
 652 #ifdef SLJIT_PREF_SHIFT_REG
 653         sljit_s32 shift_reg = SLJIT_PREF_SHIFT_REG;
 654 #else
 655         sljit_s32 shift_reg = SLJIT_R2;
 656 #endif
 657
 658         SLJIT_ASSERT(shift_reg >= SLJIT_R2 && shift_reg <= SLJIT_R3);
 659
 660         if (verbose)
 661                 printf("Run test9\n");
 662
 663         FAILED(!compiler, "cannot create compiler\n");
 664         buf[0] = 0;
 665         buf[1] = 0;
 666         buf[2] = 0;
 667         buf[3] = 0;
 668         buf[4] = 1 << 10;
 669         buf[5] = 0;
 670         buf[6] = 0;
 671         buf[7] = 0;
 672         buf[8] = 0;
 673         buf[9] = 3;
 674         buf[10] = 0;
 675         buf[11] = 0;
 676         buf[12] = 0;
 677
 678         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, P), 4, 2, 0, 0, 0);
 679         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0xf);
 680         sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 3);
 681         sljit_emit_op2(compiler, SLJIT_LSHR, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 1);
 682         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0);
 683         sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, 1);
 684         sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_R1, 0, SLJIT_IMM, 1);
 685         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -64);
 686         sljit_emit_op1(compiler, SLJIT_MOV, shift_reg, 0, SLJIT_IMM, 2);
 687         sljit_emit_op2(compiler, SLJIT_ASHR, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 2, SLJIT_R0, 0, shift_reg, 0);
 688
 689         sljit_emit_op1(compiler, SLJIT_MOV, shift_reg, 0, SLJIT_IMM, 0xff);
 690         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 4);
 691         sljit_emit_op2(compiler, SLJIT_SHL, shift_reg, 0, shift_reg, 0, SLJIT_R0, 0);
 692         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 3, shift_reg, 0);
 693         sljit_emit_op1(compiler, SLJIT_MOV, shift_reg, 0, SLJIT_IMM, 0xff);
 694         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 8);
 695         sljit_emit_op2(compiler, SLJIT_LSHR, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 4, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 4, SLJIT_R0, 0);
 696         sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 5, shift_reg, 0, SLJIT_R0, 0);
 697
 698         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_IMM, 0xf);
 699         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 2);
 700         sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_S1, 0, SLJIT_S1, 0, SLJIT_R0, 0);
 701         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 6, SLJIT_S1, 0);
 702         sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_R0, 0, SLJIT_S1, 0, SLJIT_R0, 0);
 703         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 7, SLJIT_R0, 0);
 704         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 0xf00);
 705         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 4);
 706         sljit_emit_op2(compiler, SLJIT_LSHR, SLJIT_R1, 0, SLJIT_R2, 0, SLJIT_R0, 0);
 707         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 8, SLJIT_R1, 0);
 708
 709         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)buf);
 710         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 9);
 711         sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_MEM2(SLJIT_R0, SLJIT_R1), SLJIT_WORD_SHIFT, SLJIT_MEM2(SLJIT_R0, SLJIT_R1), SLJIT_WORD_SHIFT, SLJIT_MEM2(SLJIT_R0, SLJIT_R1), SLJIT_WORD_SHIFT);
 712
 713         sljit_emit_op1(compiler, SLJIT_MOV, shift_reg, 0, SLJIT_IMM, 4);
 714         sljit_emit_op2(compiler, SLJIT_SHL, shift_reg, 0, SLJIT_IMM, 2, shift_reg, 0);
 715         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 10, shift_reg, 0);
 716
 717         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0xa9);
 718         sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, 0);
 719         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 0x7d00);
 720         sljit_emit_op2(compiler, SLJIT_LSHR32, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 32);
 721 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
 722         sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_R0, 0, SLJIT_R0, 0);
 723 #endif
 724         sljit_emit_op2(compiler, SLJIT_OR, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_R0, 0);
 725         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0xe30000);
 726 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
 727         sljit_emit_op2(compiler, SLJIT_ASHR, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 0xffc0);
 728 #else
 729         sljit_emit_op2(compiler, SLJIT_ASHR, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 0xffe0);
 730 #endif
 731         sljit_emit_op2(compiler, SLJIT_OR, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_R0, 0);
 732         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 0x25000000);
 733         sljit_emit_op2(compiler, SLJIT_SHL32, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 0xfffe1);
 734 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
 735         sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_R0, 0, SLJIT_R0, 0);
 736 #endif
 737         sljit_emit_op2(compiler, SLJIT_OR, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 11, SLJIT_R1, 0, SLJIT_R0, 0);
 738
 739         sljit_emit_op1(compiler, SLJIT_MOV, shift_reg, 0, SLJIT_IMM, 0);
 740         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0x5c);
 741         sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_R1, 0, SLJIT_R0, 0, shift_reg, 0);
 742         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 0xf600);
 743         sljit_emit_op2(compiler, SLJIT_LSHR32, SLJIT_R0, 0, SLJIT_R0, 0, shift_reg, 0);
 744 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
 745         /* Alternative form of uint32 type cast. */
 746         sljit_emit_op2(compiler, SLJIT_AND, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 0xffffffff);
 747 #endif
 748         sljit_emit_op2(compiler, SLJIT_OR, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_R0, 0);
 749         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0x630000);
 750         sljit_emit_op2(compiler, SLJIT_ASHR, SLJIT_R0, 0, SLJIT_R0, 0, shift_reg, 0);
 751         sljit_emit_op2(compiler, SLJIT_OR, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 12, SLJIT_R1, 0, SLJIT_R0, 0);
 752
 753         sljit_emit_return_void(compiler);
 754
 755         code.code = sljit_generate_code(compiler);
 756         CHECK(compiler);
 757         sljit_free_compiler(compiler);
 758
 759         code.func1((sljit_sw)&buf);
 760         FAILED(buf[0] != 0x3c, "test9 case 1 failed\n");
 761         FAILED(buf[1] != 0xf0, "test9 case 2 failed\n");
 762         FAILED(buf[2] != -16, "test9 case 3 failed\n");
 763         FAILED(buf[3] != 0xff0, "test9 case 4 failed\n");
 764         FAILED(buf[4] != 4, "test9 case 5 failed\n");
 765         FAILED(buf[5] != 0xff00, "test9 case 6 failed\n");
 766         FAILED(buf[6] != 0x3c, "test9 case 7 failed\n");
 767         FAILED(buf[7] != 0xf0, "test9 case 8 failed\n");
 768         FAILED(buf[8] != 0xf0, "test9 case 9 failed\n");
 769         FAILED(buf[9] != 0x18, "test9 case 10 failed\n");
 770         FAILED(buf[10] != 32, "test9 case 11 failed\n");
 771         FAILED(buf[11] != 0x4ae37da9, "test9 case 12 failed\n");
 772         FAILED(buf[12] != 0x63f65c, "test9 case 13 failed\n");
 773
 774         sljit_free_code(code.code, NULL);
 775         successful_tests++;
 776 }
 777
 778 static void test10(void)
 779 {
 780         /* Test multiplications. */
 781         executable_code code;
 782         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
 783         sljit_sw buf[7];
 784
 785         if (verbose)
 786                 printf("Run test10\n");
 787
 788         FAILED(!compiler, "cannot create compiler\n");
 789         buf[0] = 3;
 790         buf[1] = 0;
 791         buf[2] = 0;
 792         buf[3] = 6;
 793         buf[4] = -10;
 794         buf[5] = 0;
 795         buf[6] = 0;
 796
 797         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(W, P), 3, 1, 0, 0, 0);
 798         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 5);
 799         sljit_emit_op2(compiler, SLJIT_MUL, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0);
 800         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0);
 801         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 7);
 802         sljit_emit_op2(compiler, SLJIT_MUL, SLJIT_R0, 0, SLJIT_R2, 0, SLJIT_IMM, 8);
 803         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_R0, 0);
 804         sljit_emit_op2(compiler, SLJIT_MUL, SLJIT_R0, 0, SLJIT_IMM, -3, SLJIT_IMM, -4);
 805         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 2, SLJIT_R0, 0);
 806         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -2);
 807         sljit_emit_op2(compiler, SLJIT_MUL, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 3, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 3, SLJIT_R0, 0);
 808         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, sizeof(sljit_sw) / 2);
 809         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, (sljit_sw)&buf[3]);
 810         sljit_emit_op2(compiler, SLJIT_MUL, SLJIT_MEM2(SLJIT_R1, SLJIT_R0), 1, SLJIT_MEM2(SLJIT_R1, SLJIT_R0), 1, SLJIT_MEM2(SLJIT_R1, SLJIT_R0), 1);
 811         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 9);
 812         sljit_emit_op2(compiler, SLJIT_MUL, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_R0, 0);
 813         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 5, SLJIT_R0, 0);
 814 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
 815         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 3);
 816         sljit_emit_op2(compiler, SLJIT_MUL, SLJIT_R0, 0, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(0x123456789));
 817         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 6, SLJIT_R0, 0);
 818 #endif
 819         sljit_emit_op2(compiler, SLJIT_MUL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 11, SLJIT_IMM, 10);
 820         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);
 821
 822         code.code = sljit_generate_code(compiler);
 823         CHECK(compiler);
 824         sljit_free_compiler(compiler);
 825
 826         FAILED(code.func1((sljit_sw)&buf) != 110, "test10 case 1 failed\n");
 827         FAILED(buf[0] != 15, "test10 case 2 failed\n");
 828         FAILED(buf[1] != 56, "test10 case 3 failed\n");
 829         FAILED(buf[2] != 12, "test10 case 4 failed\n");
 830         FAILED(buf[3] != -12, "test10 case 5 failed\n");
 831         FAILED(buf[4] != 100, "test10 case 6 failed\n");
 832         FAILED(buf[5] != 81, "test10 case 7 failed\n");
 833 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
 834         FAILED(buf[6] != SLJIT_W(0x123456789) * 3, "test10 case 8 failed\n");
 835 #endif
 836
 837         sljit_free_code(code.code, NULL);
 838         successful_tests++;
 839 }
 840
 841 static void test11(void)
 842 {
 843         /* Test rewritable constants. */
 844         executable_code code;
 845         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
 846         struct sljit_const* const1;
 847         struct sljit_const* const2;
 848         struct sljit_const* const3;
 849         struct sljit_const* const4;
 850         void* value;
 851         sljit_sw executable_offset;
 852         sljit_uw const1_addr;
 853         sljit_uw const2_addr;
 854         sljit_uw const3_addr;
 855         sljit_uw const4_addr;
 856 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
 857         sljit_sw word_value1 = (sljit_sw)SLJIT_W(0xaaaaaaaaaaaaaaaa);
 858         sljit_sw word_value2 = (sljit_sw)SLJIT_W(0xfee1deadfbadf00d);
 859 #else
 860         sljit_sw word_value1 = (sljit_sw)0xaaaaaaaal;
 861         sljit_sw word_value2 = (sljit_sw)0xfbadf00dl;
 862 #endif
 863         sljit_sw buf[3];
 864
 865         if (verbose)
 866                 printf("Run test11\n");
 867
 868         FAILED(!compiler, "cannot create compiler\n");
 869         buf[0] = 0;
 870         buf[1] = 0;
 871         buf[2] = 0;
 872
 873         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(W, P), 3, 1, 0, 0, 0);
 874
 875         SLJIT_ASSERT(!sljit_alloc_memory(compiler, 0));
 876         SLJIT_ASSERT(!sljit_alloc_memory(compiler, 16 * sizeof(sljit_sw) + 1));
 877
 878         const1 = sljit_emit_const(compiler, SLJIT_MEM0(), (sljit_sw)&buf[0], -0x81b9);
 879
 880         value = sljit_alloc_memory(compiler, 16 * sizeof(sljit_sw));
 881         if (value != NULL)
 882         {
 883                 SLJIT_ASSERT(!((sljit_sw)value & ((sljit_sw)sizeof(sljit_sw) - 1)));
 884                 memset(value, 255, 16 * sizeof(sljit_sw));
 885         }
 886
 887         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 2);
 888         const2 = sljit_emit_const(compiler, SLJIT_MEM2(SLJIT_S0, SLJIT_R0), SLJIT_WORD_SHIFT - 1, -65535);
 889         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&buf[0] + 2 * (sljit_sw)sizeof(sljit_sw) - 2);
 890         const3 = sljit_emit_const(compiler, SLJIT_MEM1(SLJIT_R0), 0, word_value1);
 891
 892         value = sljit_alloc_memory(compiler, 17);
 893         if (value != NULL)
 894         {
 895                 SLJIT_ASSERT(!((sljit_sw)value & ((sljit_sw)sizeof(sljit_sw) - 1)));
 896                 memset(value, 255, 16);
 897         }
 898
 899         const4 = sljit_emit_const(compiler, SLJIT_RETURN_REG, 0, (sljit_sw)0xf7afcdb7);
 900
 901         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);
 902
 903         code.code = sljit_generate_code(compiler);
 904         CHECK(compiler);
 905         executable_offset = sljit_get_executable_offset(compiler);
 906         const1_addr = sljit_get_const_addr(const1);
 907         const2_addr = sljit_get_const_addr(const2);
 908         const3_addr = sljit_get_const_addr(const3);
 909         const4_addr = sljit_get_const_addr(const4);
 910         sljit_free_compiler(compiler);
 911
 912         FAILED(code.func1((sljit_sw)&buf) != (sljit_sw)0xf7afcdb7, "test11 case 1 failed\n");
 913         FAILED(buf[0] != -0x81b9, "test11 case 2 failed\n");
 914         FAILED(buf[1] != -65535, "test11 case 3 failed\n");
 915         FAILED(buf[2] != word_value1, "test11 case 4 failed\n");
 916
 917         sljit_set_const(const1_addr, -1, executable_offset);
 918         sljit_set_const(const2_addr, word_value2, executable_offset);
 919         sljit_set_const(const3_addr, (sljit_sw)0xbab0fea1, executable_offset);
 920         sljit_set_const(const4_addr, -60089, executable_offset);
 921
 922         FAILED(code.func1((sljit_sw)&buf) != -60089, "test11 case 5 failed\n");
 923         FAILED(buf[0] != -1, "test11 case 6 failed\n");
 924         FAILED(buf[1] != word_value2, "test11 case 7 failed\n");
 925         FAILED(buf[2] != (sljit_sw)0xbab0fea1, "test11 case 8 failed\n");
 926
 927         sljit_free_code(code.code, NULL);
 928         successful_tests++;
 929 }
 930
 931 static void test12(void)
 932 {
 933         /* Test rewriteable jumps. */
 934         executable_code code;
 935         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
 936         struct sljit_label *label1;
 937         struct sljit_label *label2;
 938         struct sljit_label *label3;
 939         struct sljit_jump *jump1;
 940         struct sljit_jump *jump2;
 941         struct sljit_jump *jump3;
 942         sljit_sw executable_offset;
 943         void* value;
 944         sljit_uw jump1_addr;
 945         sljit_uw label1_addr;
 946         sljit_uw label2_addr;
 947         sljit_sw buf[1];
 948
 949         if (verbose)
 950                 printf("Run test12\n");
 951
 952         FAILED(!compiler, "cannot create compiler\n");
 953         buf[0] = 0;
 954
 955         sljit_emit_enter(compiler, 0, SLJIT_ARGS2(VOID, P, W), 3, 2, 0, 0, 0);
 956         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_SIG_GREATER, SLJIT_S1, 0, SLJIT_IMM, 10);
 957         jump1 = sljit_emit_jump(compiler, SLJIT_REWRITABLE_JUMP | SLJIT_SIG_GREATER);
 958         /* Default handler. */
 959         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_IMM, 5);
 960         jump2 = sljit_emit_jump(compiler, SLJIT_JUMP);
 961
 962         value = sljit_alloc_memory(compiler, 15);
 963         if (value != NULL)
 964         {
 965                 SLJIT_ASSERT(!((sljit_sw)value & ((sljit_sw)sizeof(sljit_sw) - 1)));
 966                 memset(value, 255, 15);
 967         }
 968
 969         /* Handler 1. */
 970         label1 = sljit_emit_label(compiler);
 971         sljit_emit_op0(compiler, SLJIT_ENDBR);
 972         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_IMM, 6);
 973         jump3 = sljit_emit_jump(compiler, SLJIT_JUMP);
 974         /* Handler 2. */
 975         label2 = sljit_emit_label(compiler);
 976         sljit_emit_op0(compiler, SLJIT_ENDBR);
 977         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_IMM, 7);
 978         /* Exit. */
 979         label3 = sljit_emit_label(compiler);
 980         sljit_emit_op0(compiler, SLJIT_ENDBR);
 981         sljit_set_label(jump2, label3);
 982         sljit_set_label(jump3, label3);
 983         /* By default, set to handler 1. */
 984         sljit_set_label(jump1, label1);
 985         sljit_emit_return_void(compiler);
 986
 987         value = sljit_alloc_memory(compiler, 8);
 988         if (value != NULL)
 989         {
 990                 SLJIT_ASSERT(!((sljit_sw)value & ((sljit_sw)sizeof(sljit_sw) - 1)));
 991                 memset(value, 255, 8);
 992         }
 993
 994         code.code = sljit_generate_code(compiler);
 995         CHECK(compiler);
 996         executable_offset = sljit_get_executable_offset(compiler);
 997         jump1_addr = sljit_get_jump_addr(jump1);
 998         label1_addr = sljit_get_label_addr(label1);
 999         label2_addr = sljit_get_label_addr(label2);
1000         sljit_free_compiler(compiler);
1001
1002         code.func2((sljit_sw)&buf, 4);
1003         FAILED(buf[0] != 5, "test12 case 1 failed\n");
1004
1005         code.func2((sljit_sw)&buf, 11);
1006         FAILED(buf[0] != 6, "test12 case 2 failed\n");
1007
1008         sljit_set_jump_addr(jump1_addr, label2_addr, executable_offset);
1009         code.func2((sljit_sw)&buf, 12);
1010         FAILED(buf[0] != 7, "test12 case 3 failed\n");
1011
1012         sljit_set_jump_addr(jump1_addr, label1_addr, executable_offset);
1013         code.func2((sljit_sw)&buf, 13);
1014         FAILED(buf[0] != 6, "test12 case 4 failed\n");
1015
1016         sljit_free_code(code.code, NULL);
1017         successful_tests++;
1018 }
1019
1020 static void test13(void)
1021 {
1022         /* Test fpu monadic functions. */
1023         executable_code code;
1024         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
1025         sljit_f64 buf[7];
1026         sljit_sw buf2[6];
1027
1028         if (verbose)
1029                 printf("Run test13\n");
1030
1031         if (!sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
1032                 if (verbose)
1033                         printf("no fpu available, test13 skipped\n");
1034                 successful_tests++;
1035                 if (compiler)
1036                         sljit_free_compiler(compiler);
1037                 return;
1038         }
1039
1040         FAILED(!compiler, "cannot create compiler\n");
1041         buf[0] = 7.75;
1042         buf[1] = -4.5;
1043         buf[2] = 0.0;
1044         buf[3] = 0.0;
1045         buf[4] = 0.0;
1046         buf[5] = 0.0;
1047         buf[6] = 0.0;
1048
1049         buf2[0] = 10;
1050         buf2[1] = 10;
1051         buf2[2] = 10;
1052         buf2[3] = 10;
1053         buf2[4] = 10;
1054         buf2[5] = 10;
1055
1056         sljit_emit_enter(compiler, 0, SLJIT_ARGS2(VOID, P, P), 3, 2, 6, 0, 0);
1057         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM0(), (sljit_sw)&buf[2], SLJIT_MEM0(), (sljit_sw)&buf[1]);
1058         sljit_emit_fop1(compiler, SLJIT_ABS_F64, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_f64), SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64));
1059         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR0, 0, SLJIT_MEM0(), (sljit_sw)&buf[0]);
1060         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 2 * sizeof(sljit_f64));
1061         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR1, 0, SLJIT_MEM2(SLJIT_S0, SLJIT_R0), 0);
1062         sljit_emit_fop1(compiler, SLJIT_NEG_F64, SLJIT_FR2, 0, SLJIT_FR0, 0);
1063         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR3, 0, SLJIT_FR2, 0);
1064         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM0(), (sljit_sw)&buf[4], SLJIT_FR3, 0);
1065         sljit_emit_fop1(compiler, SLJIT_ABS_F64, SLJIT_FR4, 0, SLJIT_FR1, 0);
1066         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_f64), SLJIT_FR4, 0);
1067         sljit_emit_fop1(compiler, SLJIT_NEG_F64, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_f64), SLJIT_FR4, 0);
1068
1069         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR5, 0, SLJIT_MEM1(SLJIT_S0), 0);
1070         sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_GREATER_F, SLJIT_FR5, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64));
1071         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S1), 0, SLJIT_GREATER_F64);
1072         sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_GREATER_F, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64), SLJIT_FR5, 0);
1073         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_sw), SLJIT_GREATER_F64);
1074         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR1, 0, SLJIT_FR5, 0);
1075         sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_EQUAL_F, SLJIT_FR1, 0, SLJIT_FR1, 0);
1076         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S1), 2 * sizeof(sljit_sw), SLJIT_EQUAL_F64);
1077         sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_LESS_F, SLJIT_FR1, 0, SLJIT_FR1, 0);
1078         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S1), 3 * sizeof(sljit_sw), SLJIT_LESS_F64);
1079         sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_EQUAL_F, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64));
1080         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S1), 4 * sizeof(sljit_sw), SLJIT_EQUAL_F64);
1081         sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_NOT_EQUAL_F, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64));
1082         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S1), 5 * sizeof(sljit_sw), SLJIT_NOT_EQUAL_F64);
1083
1084         sljit_emit_return_void(compiler);
1085
1086         code.code = sljit_generate_code(compiler);
1087         CHECK(compiler);
1088         sljit_free_compiler(compiler);
1089
1090         code.func2((sljit_sw)&buf, (sljit_sw)&buf2);
1091         FAILED(buf[2] != -4.5, "test13 case 1 failed\n");
1092         FAILED(buf[3] != 4.5, "test13 case 2 failed\n");
1093         FAILED(buf[4] != -7.75, "test13 case 3 failed\n");
1094         FAILED(buf[5] != 4.5, "test13 case 4 failed\n");
1095         FAILED(buf[6] != -4.5, "test13 case 5 failed\n");
1096
1097         FAILED(buf2[0] != 1, "test13 case 6 failed\n");
1098         FAILED(buf2[1] != 0, "test13 case 7 failed\n");
1099         FAILED(buf2[2] != 1, "test13 case 8 failed\n");
1100         FAILED(buf2[3] != 0, "test13 case 9 failed\n");
1101         FAILED(buf2[4] != 0, "test13 case 10 failed\n");
1102         FAILED(buf2[5] != 1, "test13 case 11 failed\n");
1103
1104         sljit_free_code(code.code, NULL);
1105         successful_tests++;
1106 }
1107
1108 static void test14(void)
1109 {
1110         /* Test fpu diadic functions. */
1111         executable_code code;
1112         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
1113         sljit_f64 buf[15];
1114
1115         if (verbose)
1116                 printf("Run test14\n");
1117
1118         if (!sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
1119                 if (verbose)
1120                         printf("no fpu available, test14 skipped\n");
1121                 successful_tests++;
1122                 if (compiler)
1123                         sljit_free_compiler(compiler);
1124                 return;
1125         }
1126         buf[0] = 7.25;
1127         buf[1] = 3.5;
1128         buf[2] = 1.75;
1129         buf[3] = 0.0;
1130         buf[4] = 0.0;
1131         buf[5] = 0.0;
1132         buf[6] = 0.0;
1133         buf[7] = 0.0;
1134         buf[8] = 0.0;
1135         buf[9] = 0.0;
1136         buf[10] = 0.0;
1137         buf[11] = 0.0;
1138         buf[12] = 8.0;
1139         buf[13] = 4.0;
1140         buf[14] = 0.0;
1141
1142         FAILED(!compiler, "cannot create compiler\n");
1143         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, P), 3, 1, 6, 0, 0);
1144
1145         /* ADD */
1146         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, sizeof(sljit_f64));
1147         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64));
1148         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 2);
1149         sljit_emit_fop2(compiler, SLJIT_ADD_F64, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 3, SLJIT_MEM2(SLJIT_S0, SLJIT_R0), 0, SLJIT_MEM1(SLJIT_S0), 0);
1150         sljit_emit_fop2(compiler, SLJIT_ADD_F64, SLJIT_FR0, 0, SLJIT_FR0, 0, SLJIT_FR1, 0);
1151         sljit_emit_fop2(compiler, SLJIT_ADD_F64, SLJIT_FR1, 0, SLJIT_FR0, 0, SLJIT_FR1, 0);
1152         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 4, SLJIT_FR0, 0);
1153         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 5, SLJIT_FR1, 0);
1154
1155         /* SUB */
1156         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S0), 0);
1157         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR3, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 2);
1158         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 2);
1159         sljit_emit_fop2(compiler, SLJIT_SUB_F64, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 6, SLJIT_FR3, 0, SLJIT_MEM2(SLJIT_S0, SLJIT_R1), SLJIT_F64_SHIFT);
1160         sljit_emit_fop2(compiler, SLJIT_SUB_F64, SLJIT_FR2, 0, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 2);
1161         sljit_emit_fop2(compiler, SLJIT_SUB_F64, SLJIT_FR3, 0, SLJIT_FR2, 0, SLJIT_FR3, 0);
1162         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 7, SLJIT_FR2, 0);
1163         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 8, SLJIT_FR3, 0);
1164
1165         /* MUL */
1166         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 1);
1167         sljit_emit_fop2(compiler, SLJIT_MUL_F64, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 9, SLJIT_MEM2(SLJIT_S0, SLJIT_R1), SLJIT_F64_SHIFT, SLJIT_FR1, 0);
1168         sljit_emit_fop2(compiler, SLJIT_MUL_F64, SLJIT_FR1, 0, SLJIT_FR1, 0, SLJIT_FR2, 0);
1169         sljit_emit_fop2(compiler, SLJIT_MUL_F64, SLJIT_FR5, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 2, SLJIT_FR2, 0);
1170         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 10, SLJIT_FR1, 0);
1171         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 11, SLJIT_FR5, 0);
1172
1173         /* DIV */
1174         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR5, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 12);
1175         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 13);
1176         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR4, 0, SLJIT_FR5, 0);
1177         sljit_emit_fop2(compiler, SLJIT_DIV_F64, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 12, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 12, SLJIT_FR1, 0);
1178         sljit_emit_fop2(compiler, SLJIT_DIV_F64, SLJIT_FR5, 0, SLJIT_FR5, 0, SLJIT_FR1, 0);
1179         sljit_emit_fop2(compiler, SLJIT_DIV_F64, SLJIT_FR4, 0, SLJIT_FR1, 0, SLJIT_FR4, 0);
1180         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 13, SLJIT_FR5, 0);
1181         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 14, SLJIT_FR4, 0);
1182
1183         sljit_emit_return_void(compiler);
1184
1185         code.code = sljit_generate_code(compiler);
1186         CHECK(compiler);
1187         sljit_free_compiler(compiler);
1188
1189         code.func1((sljit_sw)&buf);
1190         FAILED(buf[3] != 10.75, "test14 case 1 failed\n");
1191         FAILED(buf[4] != 5.25, "test14 case 2 failed\n");
1192         FAILED(buf[5] != 7.0, "test14 case 3 failed\n");
1193         FAILED(buf[6] != 0.0, "test14 case 4 failed\n");
1194         FAILED(buf[7] != 5.5, "test14 case 5 failed\n");
1195         FAILED(buf[8] != 3.75, "test14 case 6 failed\n");
1196         FAILED(buf[9] != 24.5, "test14 case 7 failed\n");
1197         FAILED(buf[10] != 38.5, "test14 case 8 failed\n");
1198         FAILED(buf[11] != 9.625, "test14 case 9 failed\n");
1199         FAILED(buf[12] != 2.0, "test14 case 10 failed\n");
1200         FAILED(buf[13] != 2.0, "test14 case 11 failed\n");
1201         FAILED(buf[14] != 0.5, "test14 case 12 failed\n");
1202
1203         sljit_free_code(code.code, NULL);
1204         successful_tests++;
1205 }
1206
1207 static sljit_sw SLJIT_FUNC func(sljit_sw a, sljit_sw b, sljit_sw c)
1208 {
1209         return a + b + c + 5;
1210 }
1211
1212 static void test15(void)
1213 {
1214         /* Test function call. */
1215         executable_code code;
1216         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
1217         struct sljit_jump* jump = NULL;
1218         sljit_sw buf[7];
1219
1220         if (verbose)
1221                 printf("Run test15\n");
1222
1223         FAILED(!compiler, "cannot create compiler\n");
1224         buf[0] = 0;
1225         buf[1] = 0;
1226         buf[2] = 0;
1227         buf[3] = 0;
1228         buf[4] = 0;
1229         buf[5] = 0;
1230         buf[6] = SLJIT_FUNC_ADDR(func);
1231
1232         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(W, P), 4, 1, 0, 0, 0);
1233
1234         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 5);
1235         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 7);
1236         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, -3);
1237         sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_ARGS3(W, W, W, W), SLJIT_IMM, SLJIT_FUNC_ADDR(func));
1238         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_RETURN_REG, 0);
1239
1240         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -5);
1241         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, -10);
1242         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 2);
1243         jump = sljit_emit_call(compiler, SLJIT_CALL | SLJIT_REWRITABLE_JUMP, SLJIT_ARGS3(W, W, W, W));
1244         sljit_set_target(jump, (sljit_uw)-1);
1245         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_RETURN_REG, 0);
1246
1247         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_FUNC_ADDR(func));
1248         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 40);
1249         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, -3);
1250         sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_ARGS3(W, W, W, W), SLJIT_R0, 0);
1251         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_RETURN_REG, 0);
1252
1253         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -60);
1254         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, SLJIT_FUNC_ADDR(func));
1255         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, -30);
1256         sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_ARGS3(W, W, W, W), SLJIT_R1, 0);
1257         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_RETURN_REG, 0);
1258
1259         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 10);
1260         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 16);
1261         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, SLJIT_FUNC_ADDR(func));
1262         sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_ARGS3(W, W, W, W), SLJIT_R2, 0);
1263         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_RETURN_REG, 0);
1264
1265         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 100);
1266         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 110);
1267         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 120);
1268         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, SLJIT_FUNC_ADDR(func));
1269         sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_ARGS3(W, W, W, W), SLJIT_R3, 0);
1270         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_RETURN_REG, 0);
1271
1272         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -10);
1273         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, -16);
1274         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 6);
1275         sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_ARGS3(W, W, W, W), SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_sw));
1276         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_sw), SLJIT_RETURN_REG, 0);
1277
1278         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);
1279
1280         code.code = sljit_generate_code(compiler);
1281         CHECK(compiler);
1282         sljit_set_jump_addr(sljit_get_jump_addr(jump), SLJIT_FUNC_UADDR(func), sljit_get_executable_offset(compiler));
1283         sljit_free_compiler(compiler);
1284
1285         FAILED(code.func1((sljit_sw)&buf) != -15, "test15 case 1 failed\n");
1286         FAILED(buf[0] != 14, "test15 case 2 failed\n");
1287         FAILED(buf[1] != -8, "test15 case 3 failed\n");
1288         FAILED(buf[2] != SLJIT_FUNC_ADDR(func) + 42, "test15 case 4 failed\n");
1289         FAILED(buf[3] != SLJIT_FUNC_ADDR(func) - 85, "test15 case 5 failed\n");
1290         FAILED(buf[4] != SLJIT_FUNC_ADDR(func) + 31, "test15 case 6 failed\n");
1291         FAILED(buf[5] != 335, "test15 case 7 failed\n");
1292         FAILED(buf[6] != -15, "test15 case 8 failed\n");
1293
1294         sljit_free_code(code.code, NULL);
1295         successful_tests++;
1296 }
1297
1298 static void test16(void)
1299 {
1300         /* Ackermann benchmark. */
1301         executable_code code;
1302         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
1303         struct sljit_label *entry;
1304         struct sljit_label *label;
1305         struct sljit_jump *jump;
1306         struct sljit_jump *jump1;
1307         struct sljit_jump *jump2;
1308
1309         if (verbose)
1310                 printf("Run test16\n");
1311
1312         FAILED(!compiler, "cannot create compiler\n");
1313
1314         entry = sljit_emit_label(compiler);
1315         sljit_emit_enter(compiler, 0, SLJIT_ARGS2(W, W, W), 3, 2, 0, 0, 0);
1316         /* If x == 0. */
1317         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_Z, SLJIT_S0, 0, SLJIT_IMM, 0);
1318         jump1 = sljit_emit_jump(compiler, SLJIT_EQUAL);
1319         /* If y == 0. */
1320         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_Z, SLJIT_S1, 0, SLJIT_IMM, 0);
1321         jump2 = sljit_emit_jump(compiler, SLJIT_EQUAL);
1322
1323         /* Ack(x,y-1). */
1324         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_S0, 0);
1325         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R1, 0, SLJIT_S1, 0, SLJIT_IMM, 1);
1326         jump = sljit_emit_call(compiler, SLJIT_CALL, SLJIT_ARGS2(W, W, W));
1327         sljit_set_label(jump, entry);
1328
1329         /* Returns with Ack(x-1, Ack(x,y-1)). */
1330         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_RETURN_REG, 0);
1331         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R0, 0, SLJIT_S0, 0, SLJIT_IMM, 1);
1332         jump = sljit_emit_call(compiler, SLJIT_CALL, SLJIT_ARGS2(W, W, W));
1333         sljit_set_label(jump, entry);
1334         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);
1335
1336         /* Returns with y+1. */
1337         label = sljit_emit_label(compiler);
1338         sljit_set_label(jump1, label);
1339         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_RETURN_REG, 0, SLJIT_IMM, 1, SLJIT_S1, 0);
1340         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);
1341
1342         /* Returns with Ack(x-1,1) */
1343         label = sljit_emit_label(compiler);
1344         sljit_set_label(jump2, label);
1345         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R0, 0, SLJIT_S0, 0, SLJIT_IMM, 1);
1346         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 1);
1347         jump = sljit_emit_call(compiler, SLJIT_CALL, SLJIT_ARGS2(W, W, W));
1348         sljit_set_label(jump, entry);
1349         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);
1350
1351         code.code = sljit_generate_code(compiler);
1352         CHECK(compiler);
1353         sljit_free_compiler(compiler);
1354
1355         FAILED(code.func2(3, 3) != 61, "test16 case 1 failed\n");
1356         /* For benchmarking. */
1357         /* FAILED(code.func2(3, 11) != 16381, "test16 case 1 failed\n"); */
1358
1359         sljit_free_code(code.code, NULL);
1360         successful_tests++;
1361 }
1362
1363 static void test17(void)
1364 {
1365         /* Test arm constant pool. */
1366         executable_code code;
1367         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
1368         sljit_s32 i;
1369         sljit_sw buf[5];
1370
1371         if (verbose)
1372                 printf("Run test17\n");
1373
1374         FAILED(!compiler, "cannot create compiler\n");
1375
1376         for (i = 0; i < 5; i++)
1377                 buf[i] = 0;
1378
1379         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, P), 3, 1, 0, 0, 0);
1380         for (i = 0; i <= 0xfff; i++) {
1381                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)0x81818000 | i);
1382                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)0x81818000 | i);
1383                 if ((i & 0x3ff) == 0)
1384                         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), (i >> 10) * (sljit_sw)sizeof(sljit_sw), SLJIT_R0, 0);
1385         }
1386         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_R0, 0);
1387         sljit_emit_return_void(compiler);
1388
1389         code.code = sljit_generate_code(compiler);
1390         CHECK(compiler);
1391         sljit_free_compiler(compiler);
1392
1393         code.func1((sljit_sw)&buf);
1394         FAILED((sljit_uw)buf[0] != 0x81818000, "test17 case 1 failed\n");
1395         FAILED((sljit_uw)buf[1] != 0x81818400, "test17 case 2 failed\n");
1396         FAILED((sljit_uw)buf[2] != 0x81818800, "test17 case 3 failed\n");
1397         FAILED((sljit_uw)buf[3] != 0x81818c00, "test17 case 4 failed\n");
1398         FAILED((sljit_uw)buf[4] != 0x81818fff, "test17 case 5 failed\n");
1399
1400         sljit_free_code(code.code, NULL);
1401         successful_tests++;
1402 }
1403
1404 static void test18(void)
1405 {
1406         /* Test 64 bit. */
1407         executable_code code;
1408         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
1409         sljit_sw buf[11];
1410
1411         if (verbose)
1412                 printf("Run test18\n");
1413
1414         FAILED(!compiler, "cannot create compiler\n");
1415         buf[0] = 0;
1416         buf[1] = 0;
1417         buf[2] = 0;
1418         buf[3] = 0;
1419         buf[4] = 0;
1420         buf[5] = 100;
1421         buf[6] = 100;
1422         buf[7] = 100;
1423         buf[8] = 100;
1424         buf[9] = 0;
1425 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) && (defined SLJIT_BIG_ENDIAN && SLJIT_BIG_ENDIAN)
1426         buf[10] = SLJIT_W(1) << 32;
1427 #else
1428         buf[10] = 1;
1429 #endif
1430
1431         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, P), 3, 2, 0, 0, 0);
1432
1433 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
1434         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_IMM, SLJIT_W(0x1122334455667788));
1435         sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_IMM, SLJIT_W(0x1122334455667788));
1436
1437         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(1000000000000));
1438         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 2, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(1000000000000));
1439         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 3, SLJIT_IMM, SLJIT_W(5000000000000), SLJIT_R0, 0);
1440
1441         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(0x1108080808));
1442         sljit_emit_op2(compiler, SLJIT_ADD32, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 4, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(0x1120202020));
1443
1444         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0x1108080808));
1445         sljit_emit_op2u(compiler, SLJIT_AND | SLJIT_SET_Z, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0x1120202020));
1446         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_ZERO);
1447         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 5, SLJIT_S1, 0);
1448         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_R0, 0);
1449         sljit_emit_op2u(compiler, SLJIT_AND32 | SLJIT_SET_Z, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0x1120202020));
1450         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 6, SLJIT_ZERO);
1451
1452         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0x1108080808));
1453         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_LESS, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0x2208080808));
1454         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 7, SLJIT_LESS);
1455         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_R0, 0);
1456         sljit_emit_op2u(compiler, SLJIT_AND32 | SLJIT_SET_Z, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0x1104040404));
1457         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 8, SLJIT_NOT_ZERO);
1458
1459         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 4);
1460         sljit_emit_op2(compiler, SLJIT_SHL32, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 9, SLJIT_IMM, SLJIT_W(0xffff0000), SLJIT_R0, 0);
1461
1462         sljit_emit_op2(compiler, SLJIT_MUL32, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 10, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 10, SLJIT_IMM, -1);
1463 #else
1464         /* 32 bit operations. */
1465
1466         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_IMM, 0x11223344);
1467         sljit_emit_op2(compiler, SLJIT_ADD32, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_IMM, 0x44332211);
1468
1469 #endif
1470
1471         sljit_emit_return_void(compiler);
1472
1473         code.code = sljit_generate_code(compiler);
1474         CHECK(compiler);
1475         sljit_free_compiler(compiler);
1476
1477         code.func1((sljit_sw)&buf);
1478 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
1479         FAILED(buf[0] != SLJIT_W(0x1122334455667788), "test18 case 1 failed\n");
1480 #if (defined SLJIT_LITTLE_ENDIAN && SLJIT_LITTLE_ENDIAN)
1481         FAILED(buf[1] != 0x55667788, "test18 case 2 failed\n");
1482 #else
1483         FAILED(buf[1] != SLJIT_W(0x5566778800000000), "test18 case 2 failed\n");
1484 #endif
1485         FAILED(buf[2] != SLJIT_W(2000000000000), "test18 case 3 failed\n");
1486         FAILED(buf[3] != SLJIT_W(4000000000000), "test18 case 4 failed\n");
1487 #if (defined SLJIT_LITTLE_ENDIAN && SLJIT_LITTLE_ENDIAN)
1488         FAILED(buf[4] != 0x28282828, "test18 case 5 failed\n");
1489 #else
1490         FAILED(buf[4] != SLJIT_W(0x2828282800000000), "test18 case 5 failed\n");
1491 #endif
1492         FAILED(buf[5] != 0, "test18 case 6 failed\n");
1493         FAILED(buf[6] != 1, "test18 case 7 failed\n");
1494         FAILED(buf[7] != 1, "test18 case 8 failed\n");
1495         FAILED(buf[8] != 0, "test18 case 9 failed\n");
1496 #if (defined SLJIT_LITTLE_ENDIAN && SLJIT_LITTLE_ENDIAN)
1497         FAILED(buf[9] != (sljit_sw)0xfff00000, "test18 case 10 failed\n");
1498         FAILED(buf[10] != (sljit_sw)0xffffffff, "test18 case 11 failed\n");
1499 #else
1500         FAILED(buf[9] != (sljit_sw)SLJIT_W(0xfff0000000000000), "test18 case 10 failed\n");
1501         FAILED(buf[10] != (sljit_sw)SLJIT_W(0xffffffff00000000), "test18 case 11 failed\n");
1502 #endif
1503 #else
1504         FAILED(buf[0] != 0x11223344, "test18 case 1 failed\n");
1505         FAILED(buf[1] != 0x44332211, "test18 case 2 failed\n");
1506 #endif
1507
1508         sljit_free_code(code.code, NULL);
1509         successful_tests++;
1510 }
1511
1512 static void test19(void)
1513 {
1514         /* Test arm partial instruction caching. */
1515         executable_code code;
1516         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
1517         sljit_sw buf[10];
1518
1519         if (verbose)
1520                 printf("Run test19\n");
1521
1522         FAILED(!compiler, "cannot create compiler\n");
1523         buf[0] = 6;
1524         buf[1] = 4;
1525         buf[2] = 0;
1526         buf[3] = 0;
1527         buf[4] = 0;
1528         buf[5] = 0;
1529         buf[6] = 2;
1530         buf[7] = 0;
1531
1532         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, P), 3, 1, 0, 0, 0);
1533         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw));
1534         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM0(), (sljit_sw)&buf[2], SLJIT_MEM0(), (sljit_sw)&buf[1], SLJIT_MEM0(), (sljit_sw)&buf[0]);
1535         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0);
1536         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, sizeof(sljit_sw));
1537         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 3, SLJIT_MEM1(SLJIT_R0), (sljit_sw)&buf[0], SLJIT_MEM1(SLJIT_R1), (sljit_sw)&buf[0]);
1538         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 4, SLJIT_MEM0(), (sljit_sw)&buf[0], SLJIT_IMM, 2);
1539         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 5, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_MEM1(SLJIT_R0), (sljit_sw)&buf[0] + 4 * (sljit_sw)sizeof(sljit_sw));
1540         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 7, SLJIT_IMM, 10);
1541         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 7);
1542         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM1(SLJIT_R1), (sljit_sw)&buf[5], SLJIT_MEM2(SLJIT_S0, SLJIT_R0), SLJIT_WORD_SHIFT, SLJIT_MEM1(SLJIT_R1), (sljit_sw)&buf[5]);
1543
1544         sljit_emit_return_void(compiler);
1545
1546         code.code = sljit_generate_code(compiler);
1547         CHECK(compiler);
1548         sljit_free_compiler(compiler);
1549
1550         code.func1((sljit_sw)&buf);
1551         FAILED(buf[0] != 10, "test19 case 1 failed\n");
1552         FAILED(buf[1] != 4, "test19 case 2 failed\n");
1553         FAILED(buf[2] != 14, "test19 case 3 failed\n");
1554         FAILED(buf[3] != 14, "test19 case 4 failed\n");
1555         FAILED(buf[4] != 8, "test19 case 5 failed\n");
1556         FAILED(buf[5] != 6, "test19 case 6 failed\n");
1557         FAILED(buf[6] != 12, "test19 case 7 failed\n");
1558         FAILED(buf[7] != 10, "test19 case 8 failed\n");
1559
1560         sljit_free_code(code.code, NULL);
1561         successful_tests++;
1562 }
1563
1564 static void test20(void)
1565 {
1566         /* Test stack. */
1567         executable_code code;
1568         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
1569         struct sljit_jump* jump;
1570         struct sljit_label* label;
1571         sljit_sw buf[6];
1572 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
1573         sljit_sw offset_value = SLJIT_W(0x1234567812345678);
1574 #else
1575         sljit_sw offset_value = SLJIT_W(0x12345678);
1576 #endif
1577
1578         if (verbose)
1579                 printf("Run test20\n");
1580
1581         FAILED(!compiler, "cannot create compiler\n");
1582         buf[0] = 5;
1583         buf[1] = 12;
1584         buf[2] = 0;
1585         buf[3] = 0;
1586         buf[4] = 111;
1587         buf[5] = -12345;
1588
1589         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(W, P), 5, 5, 0, 0, 4 * sizeof(sljit_sw));
1590         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), sizeof(sljit_uw), SLJIT_MEM1(SLJIT_S0), 0);
1591         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_uw));
1592         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, -1);
1593         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R4, 0, SLJIT_IMM, -1);
1594         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S3, 0, SLJIT_IMM, -1);
1595         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S4, 0, SLJIT_IMM, -1);
1596         sljit_emit_op2(compiler, SLJIT_MUL, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_uw), SLJIT_MEM1(SLJIT_SP), 0, SLJIT_MEM1(SLJIT_SP), sizeof(sljit_uw));
1597         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_uw), SLJIT_MEM1(SLJIT_SP), sizeof(sljit_uw), SLJIT_MEM1(SLJIT_SP), 0);
1598         sljit_get_local_base(compiler, SLJIT_R0, 0, -offset_value);
1599         sljit_get_local_base(compiler, SLJIT_MEM1(SLJIT_S0), 0, -0x1234);
1600         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_S0), 0);
1601         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_uw), SLJIT_MEM1(SLJIT_R0), offset_value, SLJIT_MEM1(SLJIT_R1), 0x1234 + sizeof(sljit_sw));
1602         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_uw));
1603         /* Dummy last instructions. */
1604         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, 23);
1605         sljit_emit_label(compiler);
1606
1607         code.code = sljit_generate_code(compiler);
1608         CHECK(compiler);
1609         sljit_free_compiler(compiler);
1610
1611         FAILED(code.func1((sljit_sw)&buf) != -12345, "test20 case 1 failed\n")
1612
1613         FAILED(buf[2] != 60, "test20 case 2 failed\n");
1614         FAILED(buf[3] != 17, "test20 case 3 failed\n");
1615         FAILED(buf[4] != 7, "test20 case 4 failed\n");
1616
1617         sljit_free_code(code.code, NULL);
1618
1619         compiler = sljit_create_compiler(NULL, NULL);
1620         sljit_emit_enter(compiler, 0, SLJIT_ARGS3(W, W, W, W), 3, 3, 0, 0, SLJIT_MAX_LOCAL_SIZE);
1621
1622         sljit_get_local_base(compiler, SLJIT_R0, 0, SLJIT_MAX_LOCAL_SIZE - sizeof(sljit_sw));
1623         sljit_get_local_base(compiler, SLJIT_R1, 0, -(sljit_sw)sizeof(sljit_sw));
1624         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, -1);
1625         label = sljit_emit_label(compiler);
1626         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, sizeof(sljit_sw));
1627         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), 0, SLJIT_R2, 0);
1628         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_Z, SLJIT_R1, 0, SLJIT_R0, 0);
1629         jump = sljit_emit_jump(compiler, SLJIT_NOT_EQUAL);
1630         sljit_set_label(jump, label);
1631
1632         /* Saved registers should keep their value. */
1633         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_S0, 0, SLJIT_S0, 0, SLJIT_S1, 0);
1634         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_S0, 0, SLJIT_S2, 0);
1635         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_R0, 0);
1636
1637         code.code = sljit_generate_code(compiler);
1638         CHECK(compiler);
1639         sljit_free_compiler(compiler);
1640
1641         FAILED(code.func3(1234, 5678, 9012) != 15924, "test20 case 5 failed\n");
1642
1643         sljit_free_code(code.code, NULL);
1644         successful_tests++;
1645 }
1646
1647 static void test21(void)
1648 {
1649         /* Test set context. The parts of the jit code can be separated in the memory. */
1650         executable_code code1;
1651         executable_code code2;
1652         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
1653         struct sljit_jump* jump = NULL;
1654         sljit_uw addr;
1655         sljit_sw executable_offset;
1656         sljit_sw buf[4];
1657
1658         if (verbose)
1659                 printf("Run test21\n");
1660
1661         FAILED(!compiler, "cannot create compiler\n");
1662         buf[0] = 9;
1663         buf[1] = -6;
1664         buf[2] = 0;
1665         buf[3] = 0;
1666
1667         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(W, P), 3, 2, 0, 0, 2 * sizeof(sljit_sw));
1668
1669         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), 0, SLJIT_IMM, 10);
1670         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM1(SLJIT_SP), sizeof(sljit_sw), SLJIT_MEM1(SLJIT_S0), 0, SLJIT_MEM1(SLJIT_SP), 0);
1671
1672         jump = sljit_emit_jump(compiler, SLJIT_JUMP | SLJIT_REWRITABLE_JUMP);
1673         sljit_set_target(jump, 0);
1674
1675         code1.code = sljit_generate_code(compiler);
1676         CHECK(compiler);
1677
1678         executable_offset = sljit_get_executable_offset(compiler);
1679         addr = sljit_get_jump_addr(jump);
1680
1681         sljit_free_compiler(compiler);
1682
1683         compiler = sljit_create_compiler(NULL, NULL);
1684         FAILED(!compiler, "cannot create compiler\n");
1685
1686         /* Other part of the jit code. */
1687         sljit_set_context(compiler, 0, 1, 3, 2, 0, 0, 2 * sizeof(sljit_sw));
1688
1689         sljit_emit_op0(compiler, SLJIT_ENDBR);
1690         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 2, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_MEM1(SLJIT_SP), 0);
1691         sljit_emit_op2(compiler, SLJIT_MUL, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 3, SLJIT_MEM1(SLJIT_SP), 0, SLJIT_MEM1(SLJIT_SP), 0);
1692         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_MEM1(SLJIT_SP), sizeof(sljit_sw));
1693
1694         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);
1695
1696         code2.code = sljit_generate_code(compiler);
1697         CHECK(compiler);
1698         sljit_free_compiler(compiler);
1699
1700         sljit_set_jump_addr(addr, SLJIT_FUNC_UADDR(code2.code), executable_offset);
1701
1702         FAILED(code1.func1((sljit_sw)&buf) != 19, "test21 case 1 failed\n");
1703         FAILED(buf[2] != -16, "test21 case 2 failed\n");
1704         FAILED(buf[3] != 100, "test21 case 3 failed\n");
1705
1706         sljit_free_code(code1.code, NULL);
1707         sljit_free_code(code2.code, NULL);
1708         successful_tests++;
1709 }
1710
1711 static void test22(void)
1712 {
1713         /* Test simple byte and half-int data transfers. */
1714         executable_code code;
1715         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
1716         sljit_sw buf[4];
1717         sljit_s16 sbuf[9];
1718         sljit_s8 bbuf[5];
1719
1720         if (verbose)
1721                 printf("Run test22\n");
1722
1723         FAILED(!compiler, "cannot create compiler\n");
1724         buf[0] = 0;
1725         buf[1] = 0;
1726         buf[2] = -1;
1727         buf[3] = -1;
1728
1729         sbuf[0] = 0;
1730         sbuf[1] = 0;
1731         sbuf[2] = -9;
1732         sbuf[3] = 0;
1733         sbuf[4] = 0;
1734         sbuf[5] = 0;
1735         sbuf[6] = 0;
1736
1737         bbuf[0] = 0;
1738         bbuf[1] = 0;
1739         bbuf[2] = -56;
1740         bbuf[3] = 0;
1741         bbuf[4] = 0;
1742
1743         sljit_emit_enter(compiler, 0, SLJIT_ARGS3(VOID, P, P, P), 3, 3, 0, 0, 0);
1744
1745         sljit_emit_op1(compiler, SLJIT_MOV_S16, SLJIT_MEM1(SLJIT_S1), 0, SLJIT_IMM, -13);
1746         sljit_emit_op1(compiler, SLJIT_MOV_U16, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_s16), SLJIT_IMM, 0x1234);
1747         sljit_emit_op1(compiler, SLJIT_MOV_S16, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S1), 2 * sizeof(sljit_s16));
1748         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0);
1749         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_S1, 0, SLJIT_S1, 0, SLJIT_IMM, 2 * sizeof(sljit_s16));
1750         sljit_emit_op1(compiler, SLJIT_MOV_U16, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_s16), SLJIT_MEM1(SLJIT_S1), -(sljit_sw)sizeof(sljit_s16));
1751         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0xff0000 + 8000);
1752         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 2);
1753         sljit_emit_op1(compiler, SLJIT_MOV_S16, SLJIT_MEM2(SLJIT_S1, SLJIT_R1), 1, SLJIT_R0, 0);
1754         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R2, 0, SLJIT_S1, 0, SLJIT_IMM, 0x1234 - 3 * sizeof(sljit_s16));
1755         sljit_emit_op1(compiler, SLJIT_MOV_S16, SLJIT_MEM1(SLJIT_R2), 0x1234, SLJIT_IMM, -9317);
1756         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R2, 0, SLJIT_S1, 0, SLJIT_IMM, 0x1234 + 4 * sizeof(sljit_s16));
1757         sljit_emit_op1(compiler, SLJIT_MOV_S16, SLJIT_MEM1(SLJIT_R2), -0x1234, SLJIT_IMM, -9317);
1758         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R2, 0, SLJIT_S1, 0, SLJIT_IMM, 0x12348 - 5 * sizeof(sljit_s16));
1759         sljit_emit_op1(compiler, SLJIT_MOV_S16, SLJIT_MEM1(SLJIT_R2), 0x12348, SLJIT_IMM, -8888);
1760         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R2, 0, SLJIT_S1, 0, SLJIT_IMM, 0x12348 + 6 * sizeof(sljit_s16));
1761         sljit_emit_op1(compiler, SLJIT_MOV_S16, SLJIT_MEM1(SLJIT_R2), -0x12348, SLJIT_IMM, -8888);
1762
1763         sljit_emit_op1(compiler, SLJIT_MOV_S8, SLJIT_MEM1(SLJIT_S2), 0, SLJIT_IMM, -45);
1764         sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_MEM1(SLJIT_S2), sizeof(sljit_s8), SLJIT_IMM, 0x12);
1765         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 4 * sizeof(sljit_s8));
1766         sljit_emit_op1(compiler, SLJIT_MOV_S8, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_S2), 2 * sizeof(sljit_s8));
1767         sljit_emit_op1(compiler, SLJIT_MOV_S8, SLJIT_S1, 0, SLJIT_R1, 0);
1768         sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_S1, 0, SLJIT_S1, 0);
1769         sljit_emit_op1(compiler, SLJIT_MOV_S8, SLJIT_R2, 0, SLJIT_S1, 0);
1770         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_R2, 0);
1771         sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_MEM1(SLJIT_S2), 3 * sizeof(sljit_s8), SLJIT_S1, 0);
1772         sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_MEM2(SLJIT_S2, SLJIT_R0), 0, SLJIT_R0, 0);
1773         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 1);
1774         sljit_emit_op1(compiler, SLJIT_MOV_U16, SLJIT_R0, 0, SLJIT_IMM, 0);
1775         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_R0, 0);
1776         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 1);
1777         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0);
1778         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_R0, 0);
1779
1780         sljit_emit_return_void(compiler);
1781
1782         code.code = sljit_generate_code(compiler);
1783         CHECK(compiler);
1784         sljit_free_compiler(compiler);
1785
1786         code.func3((sljit_sw)&buf, (sljit_sw)&sbuf, (sljit_sw)&bbuf);
1787         FAILED(buf[0] != -9, "test22 case 1 failed\n");
1788         FAILED(buf[1] != -56, "test22 case 2 failed\n");
1789         FAILED(buf[2] != 0, "test22 case 3 failed\n");
1790         FAILED(buf[3] != 0, "test22 case 4 failed\n");
1791
1792         FAILED(sbuf[0] != -13, "test22 case 5 failed\n");
1793         FAILED(sbuf[1] != 0x1234, "test22 case 6 failed\n");
1794         FAILED(sbuf[3] != 0x1234, "test22 case 7 failed\n");
1795         FAILED(sbuf[4] != 8000, "test22 case 8 failed\n");
1796         FAILED(sbuf[5] != -9317, "test22 case 9 failed\n");
1797         FAILED(sbuf[6] != -9317, "test22 case 10 failed\n");
1798         FAILED(sbuf[7] != -8888, "test22 case 11 failed\n");
1799         FAILED(sbuf[8] != -8888, "test22 case 12 failed\n");
1800
1801         FAILED(bbuf[0] != -45, "test22 case 13 failed\n");
1802         FAILED(bbuf[1] != 0x12, "test22 case 14 failed\n");
1803         FAILED(bbuf[3] != -56, "test22 case 15 failed\n");
1804         FAILED(bbuf[4] != 4, "test22 case 16 failed\n");
1805
1806         sljit_free_code(code.code, NULL);
1807         successful_tests++;
1808 }
1809
1810 static void test23(void)
1811 {
1812         /* Test 32 bit / 64 bit signed / unsigned int transfer and conversion.
1813            This test has do real things on 64 bit systems, but works on 32 bit systems as well. */
1814         executable_code code;
1815         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
1816         sljit_sw buf[9];
1817         sljit_s32 ibuf[5];
1818         union {
1819                 sljit_s32 asint;
1820                 sljit_u8 asbytes[4];
1821         } u;
1822 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
1823         sljit_sw garbage = SLJIT_W(0x1234567812345678);
1824 #else
1825         sljit_sw garbage = 0x12345678;
1826 #endif
1827
1828         if (verbose)
1829                 printf("Run test23\n");
1830
1831         FAILED(!compiler, "cannot create compiler\n");
1832         buf[0] = 0;
1833         buf[1] = 0;
1834         buf[2] = 0;
1835         buf[3] = 0;
1836         buf[4] = 0;
1837         buf[5] = 0;
1838         buf[6] = 0;
1839         buf[7] = 0;
1840         buf[8] = 0;
1841
1842         ibuf[0] = 0;
1843         ibuf[1] = 0;
1844         ibuf[2] = -5791;
1845         ibuf[3] = 43579;
1846         ibuf[4] = 658923;
1847
1848         sljit_emit_enter(compiler, 0, SLJIT_ARGS2(W, P, P), 3, 3, 0, 0, 0);
1849         sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_MEM1(SLJIT_S1), 0, SLJIT_IMM, 34567);
1850         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 4);
1851         sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_MEM2(SLJIT_S1, SLJIT_R0), 0, SLJIT_IMM, -7654);
1852         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, garbage);
1853         sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S1), 2 * sizeof(sljit_s32));
1854         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0);
1855         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, garbage);
1856         sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S1), 3 * sizeof(sljit_s32));
1857         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_R0, 0);
1858         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, garbage);
1859         sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S1), 4 * sizeof(sljit_s32));
1860         sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_R0, 0, SLJIT_R0, 0);
1861         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_R0, 0);
1862         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0x0f00f00);
1863         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R1, 0, SLJIT_S0, 0, SLJIT_IMM, 0x7777);
1864         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), 0x7777 + 3 * sizeof(sljit_sw), SLJIT_R0, 0);
1865         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_S0, 0, SLJIT_IMM, 0x7777);
1866         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), -0x7777 + 4 * (sljit_sw)sizeof(sljit_sw), SLJIT_R0, 0);
1867         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_S0, 0, SLJIT_IMM, 5 * sizeof(sljit_sw));
1868         sljit_emit_op2(compiler, SLJIT_LSHR, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, 1);
1869         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM2(SLJIT_R1, SLJIT_R1), 0, SLJIT_IMM, 16);
1870         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0);
1871         sljit_emit_op2(compiler, SLJIT_OR, SLJIT_MEM2(SLJIT_R0, SLJIT_R1), 1, SLJIT_IMM, 64, SLJIT_MEM2(SLJIT_R0, SLJIT_R1), 1);
1872         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM0(), (sljit_sw)&buf[7], SLJIT_IMM, 0x123456);
1873         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), (sljit_sw)&buf[6], SLJIT_MEM0(), (sljit_sw)&buf[7]);
1874         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_S0, 0, SLJIT_IMM, 5 * sizeof(sljit_sw));
1875         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), 2 * sizeof(sljit_sw), SLJIT_R1, 0);
1876         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R2, 0, SLJIT_S0, 0, SLJIT_IMM, 7 * sizeof(sljit_sw));
1877         sljit_emit_op2(compiler, SLJIT_LSHR, SLJIT_R2, 0, SLJIT_R2, 0, SLJIT_IMM, 1);
1878         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_MEM2(SLJIT_R2, SLJIT_R2), 0);
1879         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&buf[8] - 0x12340);
1880         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 0x12340, SLJIT_R2, 0);
1881         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM1(SLJIT_R0), 0x12340, SLJIT_MEM1(SLJIT_R2), 3 * sizeof(sljit_sw), SLJIT_IMM, 6);
1882         sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_MEM1(SLJIT_S1), 4 * sizeof(sljit_s32), SLJIT_IMM, 0x12345678);
1883         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0x2bd700 | 243);
1884         sljit_emit_return(compiler, SLJIT_MOV_S8, SLJIT_R1, 0);
1885
1886         code.code = sljit_generate_code(compiler);
1887         CHECK(compiler);
1888         sljit_free_compiler(compiler);
1889
1890         FAILED(code.func2((sljit_sw)&buf, (sljit_sw)&ibuf) != -13, "test23 case 1 failed\n");
1891         FAILED(buf[0] != -5791, "test23 case 2 failed\n");
1892         FAILED(buf[1] != 43579, "test23 case 3 failed\n");
1893         FAILED(buf[2] != 658923, "test23 case 4 failed\n");
1894         FAILED(buf[3] != 0x0f00f00, "test23 case 5 failed\n");
1895         FAILED(buf[4] != 0x0f00f00, "test23 case 6 failed\n");
1896         FAILED(buf[5] != 80, "test23 case 7 failed\n");
1897         FAILED(buf[6] != 0x123456, "test23 case 8 failed\n");
1898         FAILED(buf[7] != (sljit_sw)&buf[5], "test23 case 9 failed\n");
1899         FAILED(buf[8] != (sljit_sw)&buf[5] + 6, "test23 case 10 failed\n");
1900
1901         FAILED(ibuf[0] != 34567, "test23 case 11 failed\n");
1902         FAILED(ibuf[1] != -7654, "test23 case 12 failed\n");
1903         u.asint = ibuf[4];
1904 #if (defined SLJIT_LITTLE_ENDIAN && SLJIT_LITTLE_ENDIAN)
1905         FAILED(u.asbytes[0] != 0x78, "test23 case 13 failed\n");
1906         FAILED(u.asbytes[1] != 0x56, "test23 case 14 failed\n");
1907         FAILED(u.asbytes[2] != 0x34, "test23 case 15 failed\n");
1908         FAILED(u.asbytes[3] != 0x12, "test23 case 16 failed\n");
1909 #else
1910         FAILED(u.asbytes[0] != 0x12, "test23 case 13 failed\n");
1911         FAILED(u.asbytes[1] != 0x34, "test23 case 14 failed\n");
1912         FAILED(u.asbytes[2] != 0x56, "test23 case 15 failed\n");
1913         FAILED(u.asbytes[3] != 0x78, "test23 case 16 failed\n");
1914 #endif
1915
1916         sljit_free_code(code.code, NULL);
1917         successful_tests++;
1918 }
1919
1920 static void test24(void)
1921 {
1922         /* Some complicated addressing modes. */
1923         executable_code code;
1924         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
1925         sljit_sw buf[9];
1926         sljit_s16 sbuf[5];
1927         sljit_s8 bbuf[7];
1928
1929         if (verbose)
1930                 printf("Run test24\n");
1931
1932         FAILED(!compiler, "cannot create compiler\n");
1933
1934         buf[0] = 100567;
1935         buf[1] = 75799;
1936         buf[2] = 0;
1937         buf[3] = -8;
1938         buf[4] = -50;
1939         buf[5] = 0;
1940         buf[6] = 0;
1941         buf[7] = 0;
1942         buf[8] = 0;
1943
1944         sbuf[0] = 30000;
1945         sbuf[1] = 0;
1946         sbuf[2] = 0;
1947         sbuf[3] = -12345;
1948         sbuf[4] = 0;
1949
1950         bbuf[0] = -128;
1951         bbuf[1] = 0;
1952         bbuf[2] = 0;
1953         bbuf[3] = 99;
1954         bbuf[4] = 0;
1955         bbuf[5] = 0;
1956         bbuf[6] = 0;
1957
1958         sljit_emit_enter(compiler, 0, SLJIT_ARGS3(VOID, P, P, P), 3, 3, 0, 0, 0);
1959
1960         /* Nothing should be updated. */
1961         sljit_emit_op1(compiler, SLJIT_MOV_S16, SLJIT_MEM0(), (sljit_sw)&sbuf[1], SLJIT_MEM0(), (sljit_sw)&sbuf[0]);
1962         sljit_emit_op1(compiler, SLJIT_MOV_S8, SLJIT_MEM0(), (sljit_sw)&bbuf[1], SLJIT_MEM0(), (sljit_sw)&bbuf[0]);
1963         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 2);
1964         sljit_emit_op1(compiler, SLJIT_MOV_U16, SLJIT_MEM2(SLJIT_S1, SLJIT_R0), 1, SLJIT_MEM0(), (sljit_sw)&sbuf[3]);
1965         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&buf[0]);
1966         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, sizeof(sljit_sw));
1967         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 2);
1968         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM2(SLJIT_R0, SLJIT_R2), SLJIT_WORD_SHIFT, SLJIT_MEM0(), (sljit_sw)&buf[0], SLJIT_MEM2(SLJIT_R1, SLJIT_R0), 0);
1969         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, sizeof(sljit_s8));
1970         sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_MEM1(SLJIT_R0), (sljit_sw)&bbuf[1], SLJIT_MEM1(SLJIT_R0), (sljit_sw)&bbuf[2]);
1971
1972         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, sizeof(sljit_s16));
1973         sljit_emit_op1(compiler, SLJIT_MOV_S16, SLJIT_MEM1(SLJIT_R1), (sljit_sw)&sbuf[3], SLJIT_R1, 0);
1974
1975         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 3);
1976         sljit_emit_op2(compiler, SLJIT_MUL, SLJIT_MEM2(SLJIT_S0, SLJIT_R0), SLJIT_WORD_SHIFT, SLJIT_MEM2(SLJIT_S0, SLJIT_R0), SLJIT_WORD_SHIFT, SLJIT_MEM2(SLJIT_S0, SLJIT_R0), SLJIT_WORD_SHIFT);
1977         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 4);
1978         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_S0, 0);
1979         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM2(SLJIT_S0, SLJIT_R0), SLJIT_WORD_SHIFT, SLJIT_MEM2(SLJIT_R1, SLJIT_R0), SLJIT_WORD_SHIFT, SLJIT_MEM2(SLJIT_S0, SLJIT_R0), SLJIT_WORD_SHIFT);
1980
1981         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_S0, 0, SLJIT_IMM, 9 * sizeof(sljit_sw));
1982         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_S0, 0, SLJIT_IMM, 4 * sizeof(sljit_sw));
1983         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, -(4 << SLJIT_WORD_SHIFT));
1984         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM2(SLJIT_R0, SLJIT_R2), 0, SLJIT_MEM2(SLJIT_R1, SLJIT_R2), 0);
1985
1986         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&buf - 0x7fff8000 + 6 * (sljit_sw)sizeof(sljit_sw));
1987         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 952467);
1988         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 0x7fff8000, SLJIT_R1, 0);
1989         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 0x7fff8000 + sizeof(sljit_sw), SLJIT_MEM1(SLJIT_R0), 0x7fff8000);
1990
1991         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&buf + 0x7fff7fff + 6 * (sljit_sw)sizeof(sljit_sw));
1992         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM1(SLJIT_R0), -0x7fff7fff + 2 * (sljit_sw)sizeof(sljit_sw), SLJIT_MEM1(SLJIT_R0), -0x7fff7fff + (sljit_sw)sizeof(sljit_sw), SLJIT_MEM1(SLJIT_R0), -0x7fff7fff);
1993         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&bbuf - 0x7fff7ffe + 3 * (sljit_sw)sizeof(sljit_s8));
1994         sljit_emit_op1(compiler, SLJIT_MOV_S8, SLJIT_MEM1(SLJIT_R0), 0x7fff7fff, SLJIT_MEM1(SLJIT_R0), 0x7fff7ffe);
1995         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&bbuf + 0x7fff7fff + 5 * (sljit_sw)sizeof(sljit_s8));
1996         sljit_emit_op1(compiler, SLJIT_MOV_S8, SLJIT_MEM1(SLJIT_R0), -0x7fff7fff, SLJIT_MEM1(SLJIT_R0), -0x7fff8000);
1997 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
1998         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&bbuf - SLJIT_W(0x123456123456));
1999         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, (sljit_sw)&bbuf - SLJIT_W(0x123456123456));
2000         sljit_emit_op1(compiler, SLJIT_MOV_S8, SLJIT_MEM1(SLJIT_R0), SLJIT_W(0x123456123456) + 6 * sizeof(sljit_s8), SLJIT_MEM1(SLJIT_R1), SLJIT_W(0x123456123456));
2001 #endif
2002
2003         sljit_emit_return_void(compiler);
2004
2005         code.code = sljit_generate_code(compiler);
2006         CHECK(compiler);
2007         sljit_free_compiler(compiler);
2008
2009         code.func3((sljit_sw)&buf, (sljit_sw)&sbuf, (sljit_sw)&bbuf);
2010         FAILED(buf[2] != 176366, "test24 case 1 failed\n");
2011         FAILED(buf[3] != 64, "test24 case 2 failed\n");
2012         FAILED(buf[4] != -100, "test24 case 3 failed\n");
2013         FAILED(buf[5] != 100567, "test24 case 4 failed\n");
2014         FAILED(buf[6] != 952467, "test24 case 5 failed\n");
2015         FAILED(buf[7] != 952467, "test24 case 6 failed\n");
2016         FAILED(buf[8] != 952467 * 2, "test24 case 7 failed\n");
2017
2018         FAILED(sbuf[1] != 30000, "test24 case 8 failed\n");
2019         FAILED(sbuf[2] != -12345, "test24 case 9 failed\n");
2020         FAILED(sbuf[4] != sizeof(sljit_s16), "test24 case 10 failed\n");
2021
2022         FAILED(bbuf[1] != -128, "test24 case 11 failed\n");
2023         FAILED(bbuf[2] != 99, "test24 case 12 failed\n");
2024         FAILED(bbuf[4] != 99, "test24 case 13 failed\n");
2025         FAILED(bbuf[5] != 99, "test24 case 14 failed\n");
2026 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
2027         FAILED(bbuf[6] != -128, "test24 case 15 failed\n");
2028 #endif
2029
2030         sljit_free_code(code.code, NULL);
2031         successful_tests++;
2032 }
2033
2034 static void test25(void)
2035 {
2036 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
2037         /* 64 bit loads. */
2038         executable_code code;
2039         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
2040         sljit_sw buf[14];
2041
2042         if (verbose)
2043                 printf("Run test25\n");
2044
2045         FAILED(!compiler, "cannot create compiler\n");
2046         buf[0] = 7;
2047         buf[1] = 0;
2048         buf[2] = 0;
2049         buf[3] = 0;
2050         buf[4] = 0;
2051         buf[5] = 0;
2052         buf[6] = 0;
2053         buf[7] = 0;
2054         buf[8] = 0;
2055         buf[9] = 0;
2056         buf[10] = 0;
2057         buf[11] = 0;
2058         buf[12] = 0;
2059         buf[13] = 0;
2060
2061         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, P), 3, 1, 0, 0, 0);
2062
2063         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_IMM, 0);
2064         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 1 * sizeof(sljit_sw), SLJIT_IMM, 0x7fff);
2065         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_IMM, -0x8000);
2066         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_IMM, 0x7fffffff);
2067         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_IMM, SLJIT_W(-0x80000000));
2068         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_IMM, SLJIT_W(0x1234567887654321));
2069         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_sw), SLJIT_IMM, SLJIT_W(0xff80000000));
2070         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_sw), SLJIT_IMM, SLJIT_W(0x3ff0000000));
2071         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_sw), SLJIT_IMM, (sljit_sw)SLJIT_W(0xfffffff800100000));
2072         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 9 * sizeof(sljit_sw), SLJIT_IMM, (sljit_sw)SLJIT_W(0xfffffff80010f000));
2073         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 10 * sizeof(sljit_sw), SLJIT_IMM, SLJIT_W(0x07fff00000008001));
2074         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 11 * sizeof(sljit_sw), SLJIT_IMM, SLJIT_W(0x07fff00080010000));
2075         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 12 * sizeof(sljit_sw), SLJIT_IMM, SLJIT_W(0x07fff00080018001));
2076         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 13 * sizeof(sljit_sw), SLJIT_IMM, SLJIT_W(0x07fff00ffff00000));
2077
2078         sljit_emit_return_void(compiler);
2079
2080         code.code = sljit_generate_code(compiler);
2081         CHECK(compiler);
2082         sljit_free_compiler(compiler);
2083
2084         code.func1((sljit_sw)&buf);
2085         FAILED(buf[0] != 0, "test25 case 1 failed\n");
2086         FAILED(buf[1] != 0x7fff, "test25 case 2 failed\n");
2087         FAILED(buf[2] != -0x8000, "test25 case 3 failed\n");
2088         FAILED(buf[3] != 0x7fffffff, "test25 case 4 failed\n");
2089         FAILED(buf[4] != SLJIT_W(-0x80000000), "test25 case 5 failed\n");
2090         FAILED(buf[5] != SLJIT_W(0x1234567887654321), "test25 case 6 failed\n");
2091         FAILED(buf[6] != SLJIT_W(0xff80000000), "test25 case 7 failed\n");
2092         FAILED(buf[7] != SLJIT_W(0x3ff0000000), "test25 case 8 failed\n");
2093         FAILED((sljit_uw)buf[8] != SLJIT_W(0xfffffff800100000), "test25 case 9 failed\n");
2094         FAILED((sljit_uw)buf[9] != SLJIT_W(0xfffffff80010f000), "test25 case 10 failed\n");
2095         FAILED(buf[10] != SLJIT_W(0x07fff00000008001), "test25 case 11 failed\n");
2096         FAILED(buf[11] != SLJIT_W(0x07fff00080010000), "test25 case 12 failed\n");
2097         FAILED(buf[12] != SLJIT_W(0x07fff00080018001), "test25 case 13 failed\n");
2098         FAILED(buf[13] != SLJIT_W(0x07fff00ffff00000), "test25 case 14 failed\n");
2099
2100         sljit_free_code(code.code, NULL);
2101 #endif
2102         successful_tests++;
2103 }
2104
2105 static void test26(void)
2106 {
2107         /* Aligned access without aligned offsets. */
2108         executable_code code;
2109         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
2110         sljit_sw buf[4];
2111         sljit_s32 ibuf[4];
2112         sljit_f64 dbuf[4];
2113
2114         if (verbose)
2115                 printf("Run test26\n");
2116
2117         FAILED(!compiler, "cannot create compiler\n");
2118
2119         buf[0] = -2789;
2120         buf[1] = 0;
2121         buf[2] = 4;
2122         buf[3] = -4;
2123
2124         ibuf[0] = -689;
2125         ibuf[1] = 0;
2126         ibuf[2] = -6;
2127         ibuf[3] = 3;
2128
2129         dbuf[0] = 5.75;
2130         dbuf[1] = 0.0;
2131         dbuf[2] = 0.0;
2132         dbuf[3] = -4.0;
2133
2134         sljit_emit_enter(compiler, 0, SLJIT_ARGS3(VOID, P, P, P), 3, 3, 0, 0, 0);
2135
2136         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_S0, 0, SLJIT_S0, 0, SLJIT_IMM, 3);
2137         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_S1, 0, SLJIT_S1, 0, SLJIT_IMM, 1);
2138         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), -3);
2139         sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_s32) - 1, SLJIT_R0, 0);
2140         sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S1), -1);
2141         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) - 3, SLJIT_R0, 0);
2142
2143         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_S0, 0, SLJIT_IMM, 100);
2144         sljit_emit_op2(compiler, SLJIT_MUL, SLJIT_MEM1(SLJIT_R0), (sljit_sw)sizeof(sljit_sw) * 2 - 103, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 2 - 3, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 3 - 3);
2145         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_S1, 0, SLJIT_IMM, 100);
2146         sljit_emit_op2(compiler, SLJIT_MUL32, SLJIT_MEM1(SLJIT_R0), (sljit_sw)sizeof(sljit_s32) * 2 - 101, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_s32) * 2 - 1, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_s32) * 3 - 1);
2147
2148         if (sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
2149                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_S2, 0, SLJIT_S2, 0, SLJIT_IMM, 3);
2150                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S2), sizeof(sljit_f64) - 3, SLJIT_MEM1(SLJIT_S2), -3);
2151                 sljit_emit_fop2(compiler, SLJIT_ADD_F64, SLJIT_MEM1(SLJIT_S2), sizeof(sljit_f64) * 2 - 3, SLJIT_MEM1(SLJIT_S2), -3, SLJIT_MEM1(SLJIT_S2), sizeof(sljit_f64) - 3);
2152                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_S2, 0, SLJIT_IMM, 2);
2153                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, (sizeof(sljit_f64) * 3 - 4) >> 1);
2154                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R2, 0, SLJIT_S2, 0, SLJIT_IMM, 1);
2155                 sljit_emit_fop2(compiler, SLJIT_DIV_F64, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_f64) * 3 - 5, SLJIT_MEM1(SLJIT_S2), sizeof(sljit_f64) * 2 - 3, SLJIT_MEM2(SLJIT_R2, SLJIT_R1), 1);
2156         }
2157
2158         sljit_emit_return_void(compiler);
2159
2160         code.code = sljit_generate_code(compiler);
2161         CHECK(compiler);
2162         sljit_free_compiler(compiler);
2163
2164         code.func3((sljit_sw)&buf, (sljit_sw)&ibuf, (sljit_sw)&dbuf);
2165
2166         FAILED(buf[1] != -689, "test26 case 1 failed\n");
2167         FAILED(buf[2] != -16, "test26 case 2 failed\n");
2168         FAILED(ibuf[1] != -2789, "test26 case 3 failed\n");
2169         FAILED(ibuf[2] != -18, "test26 case 4 failed\n");
2170
2171         if (sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
2172                 FAILED(dbuf[1] != 5.75, "test26 case 5 failed\n");
2173                 FAILED(dbuf[2] != 11.5, "test26 case 6 failed\n");
2174                 FAILED(dbuf[3] != -2.875, "test26 case 7 failed\n");
2175         }
2176
2177         sljit_free_code(code.code, NULL);
2178         successful_tests++;
2179 }
2180
2181 static void test27(void)
2182 {
2183 #define SET_NEXT_BYTE(type) \
2184                 cond_set(compiler, SLJIT_R2, 0, type); \
2185                 sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_MEM1(SLJIT_S0), 1, SLJIT_R2, 0); \
2186                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_S0, 0, SLJIT_S0, 0, SLJIT_IMM, 1);
2187 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
2188 #define RESULT(i) i
2189 #else
2190 #define RESULT(i) (3 - i)
2191 #endif
2192
2193         /* Playing with conditional flags. */
2194         executable_code code;
2195         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
2196         sljit_u8 buf[41];
2197         sljit_u32 i;
2198 #ifdef SLJIT_PREF_SHIFT_REG
2199         sljit_s32 shift_reg = SLJIT_PREF_SHIFT_REG;
2200 #else
2201         sljit_s32 shift_reg = SLJIT_R2;
2202 #endif
2203
2204         SLJIT_ASSERT(shift_reg >= SLJIT_R2 && shift_reg <= SLJIT_R3);
2205
2206         if (verbose)
2207                 printf("Run test27\n");
2208
2209         for (i = 0; i < sizeof(buf); ++i)
2210                 buf[i] = 10;
2211
2212         FAILED(!compiler, "cannot create compiler\n");
2213
2214         /* 3 arguments passed, 3 arguments used. */
2215         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, P), 4, 3, 0, 0, 0);
2216
2217         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_S0, 0, SLJIT_S0, 0, SLJIT_IMM, 1);
2218
2219         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0x1001);
2220         sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 20);
2221         /* 0x100100000 on 64 bit machines, 0x100000 on 32 bit machines. */
2222         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0x800000);
2223         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_GREATER, SLJIT_R0, 0, SLJIT_R1, 0);
2224         sljit_emit_op0(compiler, SLJIT_ENDBR); /* ENDBR should keep the flags. */
2225         sljit_emit_op0(compiler, SLJIT_NOP); /* Nop should keep the flags. */
2226         SET_NEXT_BYTE(SLJIT_GREATER);
2227         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_LESS, SLJIT_R0, 0, SLJIT_R1, 0);
2228         SET_NEXT_BYTE(SLJIT_LESS);
2229         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_R0, 0);
2230         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_R1, 0);
2231         sljit_emit_op2u(compiler, SLJIT_SUB32 | SLJIT_SET_GREATER, SLJIT_R0, 0, SLJIT_R1, 0);
2232         sljit_emit_op0(compiler, SLJIT_ENDBR); /* ENDBR should keep the flags. */
2233         sljit_emit_op0(compiler, SLJIT_NOP); /* Nop should keep the flags. */
2234         SET_NEXT_BYTE(SLJIT_GREATER);
2235         sljit_emit_op2u(compiler, SLJIT_SUB32 | SLJIT_SET_LESS, SLJIT_R0, 0, SLJIT_R1, 0);
2236         SET_NEXT_BYTE(SLJIT_LESS);
2237
2238         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0x1000);
2239         sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 20);
2240         sljit_emit_op2(compiler, SLJIT_OR, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 0x10);
2241         /* 0x100000010 on 64 bit machines, 0x10 on 32 bit machines. */
2242         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_GREATER, SLJIT_R0, 0, SLJIT_IMM, 0x80);
2243         SET_NEXT_BYTE(SLJIT_GREATER);
2244         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_LESS, SLJIT_R0, 0, SLJIT_IMM, 0x80);
2245         SET_NEXT_BYTE(SLJIT_LESS);
2246         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_R0, 0);
2247         sljit_emit_op2u(compiler, SLJIT_SUB32 | SLJIT_SET_GREATER, SLJIT_R0, 0, SLJIT_IMM, 0x80);
2248         SET_NEXT_BYTE(SLJIT_GREATER);
2249         sljit_emit_op2u(compiler, SLJIT_SUB32 | SLJIT_SET_LESS, SLJIT_R0, 0, SLJIT_IMM, 0x80);
2250         SET_NEXT_BYTE(SLJIT_LESS);
2251
2252         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0);
2253         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 1);
2254         /* 0xff..ff on all machines. */
2255         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, 1);
2256         SET_NEXT_BYTE(SLJIT_LESS_EQUAL);
2257         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_GREATER_EQUAL, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, 1);
2258         SET_NEXT_BYTE(SLJIT_GREATER_EQUAL);
2259         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_SIG_GREATER, SLJIT_R2, 0, SLJIT_R1, 0, SLJIT_IMM, -1);
2260         SET_NEXT_BYTE(SLJIT_SIG_GREATER);
2261         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_SIG_LESS, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, -1);
2262         SET_NEXT_BYTE(SLJIT_SIG_LESS);
2263         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_Z, SLJIT_R2, 0, SLJIT_R1, 0, SLJIT_R0, 0);
2264         SET_NEXT_BYTE(SLJIT_EQUAL);
2265         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_Z, SLJIT_R0, 0, SLJIT_R1, 0, SLJIT_R0, 0);
2266         SET_NEXT_BYTE(SLJIT_NOT_EQUAL);
2267         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_OVERFLOW, SLJIT_R0, 0, SLJIT_R1, 0, SLJIT_IMM, -2);
2268         SET_NEXT_BYTE(SLJIT_OVERFLOW);
2269         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_OVERFLOW, SLJIT_R0, 0, SLJIT_R1, 0, SLJIT_IMM, -2);
2270         SET_NEXT_BYTE(SLJIT_NOT_OVERFLOW);
2271         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_GREATER_EQUAL, SLJIT_R0, 0, SLJIT_R1, 0, SLJIT_IMM, -2);
2272         SET_NEXT_BYTE(SLJIT_GREATER_EQUAL);
2273         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_R0, 0, SLJIT_R1, 0, SLJIT_IMM, -2);
2274         SET_NEXT_BYTE(SLJIT_LESS_EQUAL);
2275         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, (sljit_sw)((sljit_uw)1 << ((8 * sizeof(sljit_uw)) - 1)));
2276         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_SIG_LESS, SLJIT_R0, 0, SLJIT_R1, 0, SLJIT_IMM, 1);
2277         SET_NEXT_BYTE(SLJIT_SIG_LESS);
2278         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_SIG_GREATER, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, -1);
2279         SET_NEXT_BYTE(SLJIT_SIG_GREATER);
2280         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R0, 0, SLJIT_R1, 0, SLJIT_IMM, 1);
2281         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_SIG_GREATER_EQUAL, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, -2);
2282         SET_NEXT_BYTE(SLJIT_SIG_GREATER_EQUAL);
2283         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_SIG_GREATER, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 2);
2284         SET_NEXT_BYTE(SLJIT_SIG_GREATER);
2285
2286         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)0x80000000);
2287         sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 16);
2288         sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 16);
2289         /* 0x80..0 on 64 bit machines, 0 on 32 bit machines. */
2290         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, (sljit_sw)0xffffffff);
2291         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_OVERFLOW, SLJIT_R0, 0, SLJIT_R1, 0);
2292         SET_NEXT_BYTE(SLJIT_OVERFLOW);
2293         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_OVERFLOW, SLJIT_R0, 0, SLJIT_R1, 0);
2294         SET_NEXT_BYTE(SLJIT_NOT_OVERFLOW);
2295         sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_R0, 0, SLJIT_R0, 0);
2296         sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_R1, 0, SLJIT_R1, 0);
2297         sljit_emit_op2u(compiler, SLJIT_SUB32 | SLJIT_SET_OVERFLOW, SLJIT_R0, 0, SLJIT_R1, 0);
2298         SET_NEXT_BYTE(SLJIT_OVERFLOW);
2299         sljit_emit_op2u(compiler, SLJIT_SUB32 | SLJIT_SET_OVERFLOW, SLJIT_R0, 0, SLJIT_R1, 0);
2300         SET_NEXT_BYTE(SLJIT_NOT_OVERFLOW);
2301
2302         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0);
2303         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_CARRY, SLJIT_R0, 0, SLJIT_IMM, 1);
2304         sljit_emit_op2u(compiler, SLJIT_SUBC | SLJIT_SET_CARRY, SLJIT_R0, 0, SLJIT_IMM, 0);
2305         sljit_emit_op2(compiler, SLJIT_SUBC, SLJIT_R0, 0, SLJIT_IMM, 6, SLJIT_R0, 0);
2306         sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_MEM1(SLJIT_S0), 1, SLJIT_R0, 0);
2307         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_S0, 0, SLJIT_S0, 0, SLJIT_IMM, 1);
2308
2309         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -1);
2310         sljit_emit_op2u(compiler, SLJIT_ADD | SLJIT_SET_CARRY, SLJIT_R0, 0, SLJIT_IMM, 1);
2311         sljit_emit_op2u(compiler, SLJIT_ADDC | SLJIT_SET_CARRY, SLJIT_R0, 0, SLJIT_IMM, 1);
2312         sljit_emit_op2(compiler, SLJIT_ADDC, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 9);
2313         sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_MEM1(SLJIT_S0), 1, SLJIT_R0, 0);
2314         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_S0, 0, SLJIT_S0, 0, SLJIT_IMM, 1);
2315
2316         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 1);
2317         sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, (8 * sizeof(sljit_sw)) - 1);
2318         sljit_emit_op2u(compiler, SLJIT_ADD | SLJIT_SET_Z, SLJIT_R0, 0, SLJIT_IMM, 0);
2319         SET_NEXT_BYTE(SLJIT_EQUAL);
2320         sljit_emit_op2u(compiler, SLJIT_ADD | SLJIT_SET_Z, SLJIT_R0, 0, SLJIT_R0, 0);
2321         SET_NEXT_BYTE(SLJIT_EQUAL);
2322
2323         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0);
2324         sljit_emit_op2(compiler, SLJIT_ASHR | SLJIT_SET_Z, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 0);
2325         SET_NEXT_BYTE(SLJIT_EQUAL);
2326         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 1);
2327         sljit_emit_op2(compiler, SLJIT_LSHR | SLJIT_SET_Z, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 0xffffc0);
2328         SET_NEXT_BYTE(SLJIT_NOT_EQUAL);
2329         sljit_emit_op1(compiler, SLJIT_MOV, shift_reg, 0, SLJIT_IMM, 0);
2330         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0);
2331         sljit_emit_op2(compiler, SLJIT_ASHR | SLJIT_SET_Z, SLJIT_R0, 0, SLJIT_R0, 0, shift_reg, 0);
2332         SET_NEXT_BYTE(SLJIT_EQUAL);
2333         sljit_emit_op1(compiler, SLJIT_MOV, shift_reg, 0, SLJIT_IMM, 0);
2334         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 1);
2335         sljit_emit_op2(compiler, SLJIT_LSHR | SLJIT_SET_Z, SLJIT_R0, 0, SLJIT_R0, 0, shift_reg, 0);
2336         SET_NEXT_BYTE(SLJIT_NOT_EQUAL);
2337
2338         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0);
2339         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 1);
2340         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_CARRY, SLJIT_R0, 0, SLJIT_R0, 0);
2341         sljit_emit_op2(compiler, SLJIT_SUBC | SLJIT_SET_CARRY, SLJIT_R2, 0, SLJIT_IMM, 1, SLJIT_R0, 0);
2342         sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_MEM1(SLJIT_S0), 1, SLJIT_R2, 0);
2343         sljit_emit_op2u(compiler, SLJIT_SUBC | SLJIT_SET_CARRY, SLJIT_R0, 0, SLJIT_R1, 0);
2344         sljit_emit_op2(compiler, SLJIT_SUBC, SLJIT_R2, 0, SLJIT_IMM, 1, SLJIT_R0, 0);
2345         sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_MEM1(SLJIT_S0), 2, SLJIT_R2, 0);
2346         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_S0, 0, SLJIT_S0, 0, SLJIT_IMM, 2);
2347
2348         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -34);
2349         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_LESS, SLJIT_R0, 0, SLJIT_IMM, 0x1234);
2350         SET_NEXT_BYTE(SLJIT_LESS);
2351         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_SIG_LESS, SLJIT_R0, 0, SLJIT_IMM, 0x1234);
2352         SET_NEXT_BYTE(SLJIT_SIG_LESS);
2353 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
2354         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0x12300000000) - 43);
2355 #else
2356         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, -43);
2357 #endif
2358         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, -96);
2359         sljit_emit_op2u(compiler, SLJIT_SUB32 | SLJIT_SET_LESS, SLJIT_R0, 0, SLJIT_R1, 0);
2360         SET_NEXT_BYTE(SLJIT_LESS);
2361         sljit_emit_op2u(compiler, SLJIT_SUB32 | SLJIT_SET_SIG_GREATER, SLJIT_R0, 0, SLJIT_R1, 0);
2362         SET_NEXT_BYTE(SLJIT_SIG_GREATER);
2363
2364         sljit_emit_return_void(compiler);
2365
2366         code.code = sljit_generate_code(compiler);
2367         CHECK(compiler);
2368         sljit_free_compiler(compiler);
2369
2370         code.func1((sljit_sw)&buf);
2371
2372         FAILED(buf[0] != RESULT(1), "test27 case 1 failed\n");
2373         FAILED(buf[1] != RESULT(2), "test27 case 2 failed\n");
2374         FAILED(buf[2] != 2, "test27 case 3 failed\n");
2375         FAILED(buf[3] != 1, "test27 case 4 failed\n");
2376         FAILED(buf[4] != RESULT(1), "test27 case 5 failed\n");
2377         FAILED(buf[5] != RESULT(2), "test27 case 6 failed\n");
2378         FAILED(buf[6] != 2, "test27 case 7 failed\n");
2379         FAILED(buf[7] != 1, "test27 case 8 failed\n");
2380
2381         FAILED(buf[8] != 2, "test27 case 9 failed\n");
2382         FAILED(buf[9] != 1, "test27 case 10 failed\n");
2383         FAILED(buf[10] != 2, "test27 case 11 failed\n");
2384         FAILED(buf[11] != 1, "test27 case 12 failed\n");
2385         FAILED(buf[12] != 1, "test27 case 13 failed\n");
2386         FAILED(buf[13] != 2, "test27 case 14 failed\n");
2387         FAILED(buf[14] != 2, "test27 case 15 failed\n");
2388         FAILED(buf[15] != 1, "test27 case 16 failed\n");
2389         FAILED(buf[16] != 1, "test27 case 17 failed\n");
2390         FAILED(buf[17] != 2, "test27 case 18 failed\n");
2391         FAILED(buf[18] != 1, "test27 case 19 failed\n");
2392         FAILED(buf[19] != 1, "test27 case 20 failed\n");
2393         FAILED(buf[20] != 1, "test27 case 21 failed\n");
2394         FAILED(buf[21] != 2, "test27 case 22 failed\n");
2395
2396         FAILED(buf[22] != RESULT(1), "test27 case 23 failed\n");
2397         FAILED(buf[23] != RESULT(2), "test27 case 24 failed\n");
2398         FAILED(buf[24] != 2, "test27 case 25 failed\n");
2399         FAILED(buf[25] != 1, "test27 case 26 failed\n");
2400
2401         FAILED(buf[26] != 5, "test27 case 27 failed\n");
2402         FAILED(buf[27] != 9, "test27 case 28 failed\n");
2403
2404         FAILED(buf[28] != 2, "test27 case 29 failed\n");
2405         FAILED(buf[29] != 1, "test27 case 30 failed\n");
2406
2407         FAILED(buf[30] != 1, "test27 case 31 failed\n");
2408         FAILED(buf[31] != 1, "test27 case 32 failed\n");
2409         FAILED(buf[32] != 1, "test27 case 33 failed\n");
2410         FAILED(buf[33] != 1, "test27 case 34 failed\n");
2411
2412         FAILED(buf[34] != 1, "test27 case 35 failed\n");
2413         FAILED(buf[35] != 0, "test27 case 36 failed\n");
2414
2415         FAILED(buf[36] != 2, "test27 case 37 failed\n");
2416         FAILED(buf[37] != 1, "test27 case 38 failed\n");
2417         FAILED(buf[38] != 2, "test27 case 39 failed\n");
2418         FAILED(buf[39] != 1, "test27 case 40 failed\n");
2419         FAILED(buf[40] != 10, "test27 case 41 failed\n");
2420
2421         sljit_free_code(code.code, NULL);
2422         successful_tests++;
2423 #undef SET_NEXT_BYTE
2424 #undef RESULT
2425 }
2426
2427 static void test28(void)
2428 {
2429         /* Test mov. */
2430         executable_code code;
2431         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
2432         struct sljit_const* const1 = NULL;
2433         struct sljit_label* label = NULL;
2434         sljit_uw label_addr = 0;
2435         sljit_sw buf[5];
2436
2437         if (verbose)
2438                 printf("Run test28\n");
2439
2440         FAILED(!compiler, "cannot create compiler\n");
2441
2442         buf[0] = -36;
2443         buf[1] = 8;
2444         buf[2] = 0;
2445         buf[3] = 10;
2446         buf[4] = 0;
2447
2448         FAILED(!compiler, "cannot create compiler\n");
2449         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(W, P), 5, 5, 0, 0, 0);
2450         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, -234);
2451         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R4, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw));
2452         sljit_emit_op2(compiler, SLJIT_MUL, SLJIT_S3, 0, SLJIT_R3, 0, SLJIT_R4, 0);
2453         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_S3, 0);
2454         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_Z, SLJIT_S3, 0, SLJIT_IMM, 0);
2455         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_S3, 0, SLJIT_NOT_ZERO);
2456         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_S3, 0);
2457         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S4, 0, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw));
2458         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_S4, 0, SLJIT_S4, 0, SLJIT_R4, 0);
2459         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_S4, 0);
2460
2461         const1 = sljit_emit_const(compiler, SLJIT_S3, 0, 0);
2462         sljit_emit_ijump(compiler, SLJIT_JUMP, SLJIT_S3, 0);
2463         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_S3, 0, SLJIT_S3, 0, SLJIT_IMM, 100);
2464         label = sljit_emit_label(compiler);
2465         sljit_emit_op0(compiler, SLJIT_ENDBR);
2466         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_S3, 0);
2467
2468         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_R4, 0);
2469
2470         code.code = sljit_generate_code(compiler);
2471         CHECK(compiler);
2472
2473         label_addr = sljit_get_label_addr(label);
2474         sljit_set_const(sljit_get_const_addr(const1), (sljit_sw)label_addr, sljit_get_executable_offset(compiler));
2475
2476         sljit_free_compiler(compiler);
2477
2478         FAILED(code.func1((sljit_sw)&buf) != 8, "test28 case 1 failed\n");
2479         FAILED(buf[1] != -1872, "test28 case 2 failed\n");
2480         FAILED(buf[2] != 1, "test28 case 3 failed\n");
2481         FAILED(buf[3] != 2, "test28 case 4 failed\n");
2482         FAILED(buf[4] != (sljit_sw)label_addr, "test28 case 5 failed\n");
2483
2484         sljit_free_code(code.code, NULL);
2485         successful_tests++;
2486 }
2487
2488 static void test29(void)
2489 {
2490         /* Test signed/unsigned bytes and halfs. */
2491         executable_code code;
2492         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
2493         sljit_sw buf[25];
2494         sljit_s32 i;
2495
2496         if (verbose)
2497                 printf("Run test29\n");
2498
2499         for (i = 0; i < 25; i++)
2500                 buf[i] = 0;
2501
2502         FAILED(!compiler, "cannot create compiler\n");
2503         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, P), 5, 5, 0, 0, 0);
2504
2505         sljit_emit_op1(compiler, SLJIT_MOV_S8, SLJIT_R0, 0, SLJIT_IMM, -187);
2506         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0);
2507         sljit_emit_op1(compiler, SLJIT_MOV_S8, SLJIT_R0, 0, SLJIT_IMM, -605);
2508         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_uw), SLJIT_R0, 0);
2509         sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_R0, 0, SLJIT_IMM, -56);
2510         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_uw), SLJIT_R0, 0);
2511         sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_R4, 0, SLJIT_IMM, 0xcde5);
2512         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_uw), SLJIT_R4, 0);
2513
2514         sljit_emit_op1(compiler, SLJIT_MOV_S16, SLJIT_R0, 0, SLJIT_IMM, -45896);
2515         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_uw), SLJIT_R0, 0);
2516         sljit_emit_op1(compiler, SLJIT_MOV_S16, SLJIT_R0, 0, SLJIT_IMM, -1472797);
2517         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_uw), SLJIT_R0, 0);
2518         sljit_emit_op1(compiler, SLJIT_MOV_U16, SLJIT_R0, 0, SLJIT_IMM, -12890);
2519         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_uw), SLJIT_R0, 0);
2520         sljit_emit_op1(compiler, SLJIT_MOV_U16, SLJIT_R4, 0, SLJIT_IMM, 0x9cb0a6);
2521         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_uw), SLJIT_R4, 0);
2522
2523 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
2524         sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(-3580429715));
2525         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_uw), SLJIT_R0, 0);
2526         sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(-100722768662));
2527         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 9 * sizeof(sljit_uw), SLJIT_R0, 0);
2528         sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(-1457052677972));
2529         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 10 * sizeof(sljit_uw), SLJIT_R0, 0);
2530         sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_R4, 0, SLJIT_IMM, SLJIT_W(0xcef97a70b5));
2531         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 11 * sizeof(sljit_uw), SLJIT_R4, 0);
2532 #endif
2533
2534         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, -187);
2535         sljit_emit_op1(compiler, SLJIT_MOV_S8, SLJIT_R0, 0, SLJIT_R1, 0);
2536         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 12 * sizeof(sljit_uw), SLJIT_R0, 0);
2537         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, -605);
2538         sljit_emit_op1(compiler, SLJIT_MOV_S8, SLJIT_R0, 0, SLJIT_S2, 0);
2539         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 13 * sizeof(sljit_uw), SLJIT_R0, 0);
2540         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, -56);
2541         sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_R0, 0, SLJIT_R2, 0);
2542         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 14 * sizeof(sljit_uw), SLJIT_R0, 0);
2543         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, 0xcde5);
2544         sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_R4, 0, SLJIT_R3, 0);
2545         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 15 * sizeof(sljit_uw), SLJIT_R4, 0);
2546
2547         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, -45896);
2548         sljit_emit_op1(compiler, SLJIT_MOV_S16, SLJIT_R0, 0, SLJIT_R1, 0);
2549         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 16 * sizeof(sljit_uw), SLJIT_R0, 0);
2550         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, -1472797);
2551         sljit_emit_op1(compiler, SLJIT_MOV_S16, SLJIT_R0, 0, SLJIT_S2, 0);
2552         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 17 * sizeof(sljit_uw), SLJIT_R0, 0);
2553         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, -12890);
2554         sljit_emit_op1(compiler, SLJIT_MOV_U16, SLJIT_R0, 0, SLJIT_R2, 0);
2555         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 18 * sizeof(sljit_uw), SLJIT_R0, 0);
2556         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, 0x9cb0a6);
2557         sljit_emit_op1(compiler, SLJIT_MOV_U16, SLJIT_R4, 0, SLJIT_R3, 0);
2558         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 19 * sizeof(sljit_uw), SLJIT_R4, 0);
2559
2560 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
2561         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(-3580429715));
2562         sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_R0, 0, SLJIT_R1, 0);
2563         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 20 * sizeof(sljit_uw), SLJIT_R0, 0);
2564         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, SLJIT_W(-100722768662));
2565         sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_R0, 0, SLJIT_S2, 0);
2566         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 21 * sizeof(sljit_uw), SLJIT_R0, 0);
2567         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, SLJIT_W(-1457052677972));
2568         sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_R0, 0, SLJIT_R2, 0);
2569         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 22 * sizeof(sljit_uw), SLJIT_R0, 0);
2570         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, SLJIT_W(0xcef97a70b5));
2571         sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_R4, 0, SLJIT_R3, 0);
2572         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 23 * sizeof(sljit_uw), SLJIT_R4, 0);
2573 #endif
2574
2575         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, 0x9faa5);
2576         sljit_emit_op1(compiler, SLJIT_MOV_S8, SLJIT_S2, 0, SLJIT_S2, 0);
2577         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 24 * sizeof(sljit_uw), SLJIT_S2, 0);
2578
2579         sljit_emit_return_void(compiler);
2580
2581         code.code = sljit_generate_code(compiler);
2582         CHECK(compiler);
2583         sljit_free_compiler(compiler);
2584
2585         code.func1((sljit_sw)&buf);
2586         FAILED(buf[0] != 69, "test29 case 1 failed\n");
2587         FAILED(buf[1] != -93, "test29 case 2 failed\n");
2588         FAILED(buf[2] != 200, "test29 case 3 failed\n");
2589         FAILED(buf[3] != 0xe5, "test29 case 4 failed\n");
2590         FAILED(buf[4] != 19640, "test29 case 5 failed\n");
2591         FAILED(buf[5] != -31005, "test29 case 6 failed\n");
2592         FAILED(buf[6] != 52646, "test29 case 7 failed\n");
2593         FAILED(buf[7] != 0xb0a6, "test29 case 8 failed\n");
2594
2595 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
2596         FAILED(buf[8] != SLJIT_W(714537581), "test29 case 9 failed\n");
2597         FAILED(buf[9] != SLJIT_W(-1938520854), "test29 case 10 failed\n");
2598         FAILED(buf[10] != SLJIT_W(3236202668), "test29 case 11 failed\n");
2599         FAILED(buf[11] != SLJIT_W(0xf97a70b5), "test29 case 12 failed\n");
2600 #endif
2601
2602         FAILED(buf[12] != 69, "test29 case 13 failed\n");
2603         FAILED(buf[13] != -93, "test29 case 14 failed\n");
2604         FAILED(buf[14] != 200, "test29 case 15 failed\n");
2605         FAILED(buf[15] != 0xe5, "test29 case 16 failed\n");
2606         FAILED(buf[16] != 19640, "test29 case 17 failed\n");
2607         FAILED(buf[17] != -31005, "test29 case 18 failed\n");
2608         FAILED(buf[18] != 52646, "test29 case 19 failed\n");
2609         FAILED(buf[19] != 0xb0a6, "test29 case 20 failed\n");
2610
2611 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
2612         FAILED(buf[20] != SLJIT_W(714537581), "test29 case 21 failed\n");
2613         FAILED(buf[21] != SLJIT_W(-1938520854), "test29 case 22 failed\n");
2614         FAILED(buf[22] != SLJIT_W(3236202668), "test29 case 23 failed\n");
2615         FAILED(buf[23] != SLJIT_W(0xf97a70b5), "test29 case 24 failed\n");
2616 #endif
2617
2618         FAILED(buf[24] != -91, "test29 case 25 failed\n");
2619
2620         sljit_free_code(code.code, NULL);
2621         successful_tests++;
2622 }
2623
2624 static void test30(void)
2625 {
2626         /* Test unused results. */
2627         executable_code code;
2628         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
2629         sljit_sw buf[1];
2630
2631         if (verbose)
2632                 printf("Run test30\n");
2633
2634         FAILED(!compiler, "cannot create compiler\n");
2635         buf[0] = 0;
2636         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, P), 5, 5, 0, 0, 0);
2637
2638         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 1);
2639         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 1);
2640         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 1);
2641         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, 1);
2642         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R4, 0, SLJIT_IMM, 1);
2643 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
2644         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_S1, 0, SLJIT_IMM, SLJIT_W(-0x123ffffffff));
2645 #else
2646         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_S1, 0, SLJIT_IMM, 1);
2647 #endif
2648         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, 1);
2649         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S3, 0, SLJIT_IMM, 1);
2650         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S4, 0, SLJIT_IMM, 1);
2651
2652         /* Some calculations with unused results. */
2653         sljit_emit_op2u(compiler, SLJIT_ADD | SLJIT_SET_Z, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_MEM1(SLJIT_S0), 0);
2654         sljit_emit_op2u(compiler, SLJIT_SUB32 | SLJIT_SET_GREATER_EQUAL, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_MEM1(SLJIT_S0), 0);
2655         sljit_emit_op2u(compiler, SLJIT_MUL | SLJIT_SET_OVERFLOW, SLJIT_S0, 0, SLJIT_MEM1(SLJIT_S0), 0);
2656         sljit_emit_op2u(compiler, SLJIT_SHL | SLJIT_SET_Z, SLJIT_S3, 0, SLJIT_R2, 0);
2657         sljit_emit_op2u(compiler, SLJIT_LSHR | SLJIT_SET_Z, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_IMM, 5);
2658         sljit_emit_op2u(compiler, SLJIT_AND | SLJIT_SET_Z, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_IMM, 0xff);
2659
2660         /* Testing that any change happens. */
2661         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_R1, 0);
2662         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_R2, 0);
2663         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_R3, 0);
2664         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_R4, 0);
2665         sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_S1, 0, SLJIT_S1, 0);
2666         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_S1, 0);
2667         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_S2, 0);
2668         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_S3, 0);
2669         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0, SLJIT_S4, 0);
2670
2671         sljit_emit_return_void(compiler);
2672
2673         code.code = sljit_generate_code(compiler);
2674         CHECK(compiler);
2675         sljit_free_compiler(compiler);
2676
2677         code.func1((sljit_sw)&buf);
2678         FAILED(buf[0] != 9, "test30 case 1 failed\n");
2679
2680         sljit_free_code(code.code, NULL);
2681         successful_tests++;
2682 }
2683
2684 static void test31(void)
2685 {
2686         /* Integer mul and set flags. */
2687         executable_code code;
2688         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
2689         sljit_sw buf[12];
2690         sljit_s32 i;
2691 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
2692         sljit_sw big_word = SLJIT_W(0x7fffffff00000000);
2693         sljit_sw big_word2 = SLJIT_W(0x7fffffff00000012);
2694 #else
2695         sljit_sw big_word = 0x7fffffff;
2696         sljit_sw big_word2 = 0x00000012;
2697 #endif
2698
2699         if (verbose)
2700                 printf("Run test31\n");
2701
2702         for (i = 0; i < 12; i++)
2703                 buf[i] = 3;
2704
2705         FAILED(!compiler, "cannot create compiler\n");
2706
2707         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, P), 3, 5, 0, 0, 0);
2708         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0);
2709         sljit_emit_op2u(compiler, SLJIT_MUL | SLJIT_SET_OVERFLOW, SLJIT_R1, 0, SLJIT_IMM, -45);
2710         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_NOT_OVERFLOW);
2711         sljit_emit_op2u(compiler, SLJIT_MUL | SLJIT_SET_OVERFLOW, SLJIT_R1, 0, SLJIT_IMM, -45);
2712         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_OVERFLOW);
2713
2714         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, big_word);
2715         sljit_emit_op2(compiler, SLJIT_MUL | SLJIT_SET_OVERFLOW, SLJIT_R2, 0, SLJIT_S2, 0, SLJIT_IMM, -2);
2716         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 33); /* Should not change flags. */
2717         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0); /* Should not change flags. */
2718         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_OVERFLOW);
2719         sljit_emit_op2(compiler, SLJIT_MUL | SLJIT_SET_OVERFLOW, SLJIT_R2, 0, SLJIT_S2, 0, SLJIT_IMM, -2);
2720         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_NOT_OVERFLOW);
2721
2722         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_S3, 0, SLJIT_IMM, 0x3f6b0);
2723         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_S4, 0, SLJIT_IMM, 0x2a783);
2724         sljit_emit_op2(compiler, SLJIT_MUL32 | SLJIT_SET_OVERFLOW, SLJIT_R1, 0, SLJIT_S3, 0, SLJIT_S4, 0);
2725         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_OVERFLOW);
2726         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_R1, 0);
2727
2728         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, big_word2);
2729         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R2, 0, SLJIT_R1, 0);
2730         sljit_emit_op2(compiler, SLJIT_MUL32 | SLJIT_SET_OVERFLOW, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, 23);
2731         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_sw), SLJIT_OVERFLOW);
2732
2733         sljit_emit_op2u(compiler, SLJIT_MUL32 | SLJIT_SET_OVERFLOW, SLJIT_R2, 0, SLJIT_IMM, -23);
2734         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_sw), SLJIT_NOT_OVERFLOW);
2735         sljit_emit_op2u(compiler, SLJIT_MUL | SLJIT_SET_OVERFLOW, SLJIT_R2, 0, SLJIT_IMM, -23);
2736         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_sw), SLJIT_NOT_OVERFLOW);
2737
2738         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 67);
2739         sljit_emit_op2(compiler, SLJIT_MUL | SLJIT_SET_OVERFLOW, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, -23);
2740         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 9 * sizeof(sljit_sw), SLJIT_R1, 0);
2741
2742         sljit_emit_return_void(compiler);
2743
2744         code.code = sljit_generate_code(compiler);
2745         CHECK(compiler);
2746         sljit_free_compiler(compiler);
2747
2748         code.func1((sljit_sw)&buf);
2749
2750         FAILED(buf[0] != 1, "test31 case 1 failed\n");
2751         FAILED(buf[1] != 2, "test31 case 2 failed\n");
2752 /* Qemu issues for 64 bit muls. */
2753 #if !(defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
2754         FAILED(buf[2] != 1, "test31 case 3 failed\n");
2755         FAILED(buf[3] != 2, "test31 case 4 failed\n");
2756 #endif
2757         FAILED(buf[4] != 1, "test31 case 5 failed\n");
2758         FAILED((buf[5] & (sljit_sw)0xffffffff) != (sljit_sw)0x85540c10, "test31 case 6 failed\n");
2759         FAILED(buf[6] != 2, "test31 case 7 failed\n");
2760         FAILED(buf[7] != 1, "test31 case 8 failed\n");
2761 #if !(defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
2762         FAILED(buf[8] != 1, "test31 case 9 failed\n");
2763 #endif
2764         FAILED(buf[9] != -1541, "test31 case 10 failed\n");
2765
2766         sljit_free_code(code.code, NULL);
2767         successful_tests++;
2768 }
2769
2770 static void test32(void)
2771 {
2772         /* Floating point set flags. */
2773         executable_code code;
2774         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
2775         sljit_s32 i;
2776
2777         sljit_sw buf[16];
2778         union {
2779                 sljit_f64 value;
2780                 struct {
2781                         sljit_s32 value1;
2782                         sljit_s32 value2;
2783                 } u;
2784         } dbuf[4];
2785
2786         if (verbose)
2787                 printf("Run test32\n");
2788
2789         for (i = 0; i < 16; i++)
2790                 buf[i] = 5;
2791
2792         /* Two NaNs */
2793         dbuf[0].u.value1 = 0x7fffffff;
2794         dbuf[0].u.value2 = 0x7fffffff;
2795         dbuf[1].u.value1 = 0x7fffffff;
2796         dbuf[1].u.value2 = 0x7fffffff;
2797         dbuf[2].value = -13.0;
2798         dbuf[3].value = 27.0;
2799
2800         if (!sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
2801                 if (verbose)
2802                         printf("no fpu available, test32 skipped\n");
2803                 successful_tests++;
2804                 if (compiler)
2805                         sljit_free_compiler(compiler);
2806                 return;
2807         }
2808
2809         FAILED(!compiler, "cannot create compiler\n");
2810         SLJIT_ASSERT(sizeof(sljit_f64) == 8 && sizeof(sljit_s32) == 4 && sizeof(dbuf[0]) == 8);
2811
2812         sljit_emit_enter(compiler, 0, SLJIT_ARGS2(VOID, P, P), 1, 2, 4, 0, 0);
2813
2814         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S1), 0);
2815         sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_UNORDERED_F, SLJIT_MEM1(SLJIT_S1), 3 * sizeof(sljit_f64), SLJIT_FR0, 0);
2816         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S1), 2 * sizeof(sljit_f64));
2817         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_UNORDERED_F64);
2818         sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_ORDERED_F, SLJIT_MEM1(SLJIT_S1), 3 * sizeof(sljit_f64), SLJIT_FR0, 0);
2819         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_ORDERED_F64);
2820
2821         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S1), 3 * sizeof(sljit_f64));
2822         sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_UNORDERED_F, SLJIT_FR1, 0, SLJIT_FR2, 0);
2823         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_UNORDERED_F64);
2824         sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_ORDERED_F, SLJIT_FR1, 0, SLJIT_FR2, 0);
2825         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_ORDERED_F64);
2826         sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_LESS_F, SLJIT_FR1, 0, SLJIT_FR2, 0);
2827         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_LESS_F64);
2828         sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_GREATER_EQUAL_F, SLJIT_FR1, 0, SLJIT_FR2, 0);
2829         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_GREATER_EQUAL_F64);
2830         sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_GREATER_F, SLJIT_FR1, 0, SLJIT_FR2, 0);
2831         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_sw), SLJIT_GREATER_F64);
2832         sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_LESS_EQUAL_F, SLJIT_FR1, 0, SLJIT_FR2, 0);
2833         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_sw), SLJIT_LESS_EQUAL_F64);
2834         sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_EQUAL_F, SLJIT_FR1, 0, SLJIT_FR2, 0);
2835         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_sw), SLJIT_EQUAL_F64);
2836         sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_NOT_EQUAL_F, SLJIT_FR1, 0, SLJIT_FR2, 0);
2837         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 9 * sizeof(sljit_sw), SLJIT_NOT_EQUAL_F64);
2838
2839         sljit_emit_fop2(compiler, SLJIT_ADD_F64, SLJIT_FR3, 0, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_f64));
2840         sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_UNORDERED_F, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S1), 3 * sizeof(sljit_f64));
2841         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 10 * sizeof(sljit_sw), SLJIT_UNORDERED_F64);
2842         sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_EQUAL_F, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S1), 3 * sizeof(sljit_f64));
2843         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 11 * sizeof(sljit_sw), SLJIT_EQUAL_F64);
2844
2845         sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_ORDERED_F, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_f64), SLJIT_FR0, 0);
2846         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 12 * sizeof(sljit_sw), SLJIT_ORDERED_F64);
2847
2848         sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_UNORDERED_F, SLJIT_FR3, 0, SLJIT_FR2, 0);
2849         sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S1), 0);
2850         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 13 * sizeof(sljit_sw), SLJIT_UNORDERED_F64);
2851
2852         sljit_emit_return_void(compiler);
2853
2854         code.code = sljit_generate_code(compiler);
2855         CHECK(compiler);
2856         sljit_free_compiler(compiler);
2857
2858         code.func2((sljit_sw)&buf, (sljit_sw)&dbuf);
2859
2860         FAILED(buf[0] != 1, "test32 case 1 failed\n");
2861         FAILED(buf[1] != 2, "test32 case 2 failed\n");
2862         FAILED(buf[2] != 2, "test32 case 3 failed\n");
2863         FAILED(buf[3] != 1, "test32 case 4 failed\n");
2864         FAILED(buf[4] != 1, "test32 case 5 failed\n");
2865         FAILED(buf[5] != 2, "test32 case 6 failed\n");
2866         FAILED(buf[6] != 2, "test32 case 7 failed\n");
2867         FAILED(buf[7] != 1, "test32 case 8 failed\n");
2868         FAILED(buf[8] != 2, "test32 case 9 failed\n");
2869         FAILED(buf[9] != 1, "test32 case 10 failed\n");
2870         FAILED(buf[10] != 2, "test32 case 11 failed\n");
2871         FAILED(buf[11] != 1, "test32 case 12 failed\n");
2872         FAILED(buf[12] != 2, "test32 case 13 failed\n");
2873         FAILED(buf[13] != 1, "test32 case 14 failed\n");
2874
2875         sljit_free_code(code.code, NULL);
2876         successful_tests++;
2877 }
2878
2879 static void test33(void)
2880 {
2881         /* Test setting multiple flags. */
2882         executable_code code;
2883         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
2884         struct sljit_jump* jump;
2885         sljit_sw buf[10];
2886
2887         if (verbose)
2888                 printf("Run test33\n");
2889
2890         buf[0] = 3;
2891         buf[1] = 3;
2892         buf[2] = 3;
2893         buf[3] = 3;
2894         buf[4] = 3;
2895         buf[5] = 3;
2896         buf[6] = 3;
2897         buf[7] = 3;
2898         buf[8] = 3;
2899         buf[9] = 3;
2900
2901         FAILED(!compiler, "cannot create compiler\n");
2902
2903         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, P), 3, 3, 0, 0, 0);
2904
2905         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 20);
2906         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 10);
2907         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_Z | SLJIT_SET_LESS, SLJIT_R2, 0, SLJIT_R0, 0, SLJIT_R1, 0);
2908         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_ZERO);
2909         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, -10);
2910         jump = sljit_emit_jump(compiler, SLJIT_LESS);
2911         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_IMM, 11);
2912         sljit_set_label(jump, sljit_emit_label(compiler));
2913
2914         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_Z | SLJIT_SET_SIG_GREATER, SLJIT_R2, 0, SLJIT_R0, 0, SLJIT_R1, 0);
2915         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_SIG_GREATER);
2916         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_IMM, 45);
2917         jump = sljit_emit_jump(compiler, SLJIT_NOT_EQUAL);
2918         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_IMM, 55);
2919         sljit_set_label(jump, sljit_emit_label(compiler));
2920
2921 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
2922         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)SLJIT_W(0x8000000000000000));
2923 #else
2924         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)SLJIT_W(0x80000000));
2925 #endif
2926         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 1);
2927         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_Z | SLJIT_SET_OVERFLOW, SLJIT_R2, 0, SLJIT_R0, 0, SLJIT_R1, 0);
2928         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_IMM, 33);
2929         jump = sljit_emit_jump(compiler, SLJIT_NOT_OVERFLOW);
2930         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_ZERO);
2931         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_IMM, 13);
2932         sljit_set_label(jump, sljit_emit_label(compiler));
2933
2934         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)0x80000000);
2935         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_R0, 0);
2936         sljit_emit_op2(compiler, SLJIT_SUB32 | SLJIT_SET_Z | SLJIT_SET_OVERFLOW, SLJIT_R2, 0, SLJIT_R0, 0, SLJIT_R1, 0);
2937         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, 0);
2938         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_sw), SLJIT_NOT_ZERO);
2939         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_sw), SLJIT_IMM, 78);
2940         jump = sljit_emit_jump(compiler, SLJIT_OVERFLOW);
2941         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_sw), SLJIT_IMM, 48);
2942         sljit_set_label(jump, sljit_emit_label(compiler));
2943
2944 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
2945         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)SLJIT_W(0x8000000000000000));
2946 #else
2947         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)SLJIT_W(0x80000000));
2948 #endif
2949         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_R0, 0);
2950         sljit_emit_op2(compiler, SLJIT_ADD | SLJIT_SET_Z | SLJIT_SET_OVERFLOW, SLJIT_R2, 0, SLJIT_R0, 0, SLJIT_R1, 0);
2951         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_sw), SLJIT_IMM, 30);
2952         jump = sljit_emit_jump(compiler, SLJIT_NOT_OVERFLOW);
2953         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_sw), SLJIT_IMM, 50);
2954         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 9 * sizeof(sljit_sw), SLJIT_ZERO);
2955         sljit_set_label(jump, sljit_emit_label(compiler));
2956
2957         sljit_emit_return_void(compiler);
2958
2959         code.code = sljit_generate_code(compiler);
2960         CHECK(compiler);
2961         sljit_free_compiler(compiler);
2962
2963         code.func1((sljit_sw)&buf);
2964
2965         FAILED(buf[0] != 0, "test33 case 1 failed\n");
2966         FAILED(buf[1] != 11, "test33 case 2 failed\n");
2967         FAILED(buf[2] != 1, "test33 case 3 failed\n");
2968         FAILED(buf[3] != 45, "test33 case 4 failed\n");
2969         FAILED(buf[4] != 13, "test33 case 5 failed\n");
2970         FAILED(buf[5] != 0, "test33 case 6 failed\n");
2971         FAILED(buf[6] != 0, "test33 case 7 failed\n");
2972         FAILED(buf[7] != 48, "test33 case 8 failed\n");
2973         FAILED(buf[8] != 50, "test33 case 9 failed\n");
2974         FAILED(buf[9] != 1, "test33 case 10 failed\n");
2975
2976         sljit_free_code(code.code, NULL);
2977         successful_tests++;
2978 }
2979
2980 static void test34(void)
2981 {
2982         /* Test fast calls. */
2983         executable_code codeA;
2984         executable_code codeB;
2985         executable_code codeC;
2986         executable_code codeD;
2987         executable_code codeE;
2988         executable_code codeF;
2989         struct sljit_compiler* compiler;
2990         struct sljit_jump *jump;
2991         struct sljit_label* label;
2992         sljit_uw addr;
2993         sljit_p buf[2];
2994
2995         if (verbose)
2996                 printf("Run test34\n");
2997
2998         buf[0] = 0;
2999         buf[1] = 0;
3000
3001         /* A */
3002         compiler = sljit_create_compiler(NULL, NULL);
3003         FAILED(!compiler, "cannot create compiler\n");
3004         sljit_set_context(compiler, 0, 1, 5, 5, 0, 0, 2 * sizeof(sljit_p));
3005
3006         sljit_emit_op0(compiler, SLJIT_ENDBR);
3007         sljit_emit_fast_enter(compiler, SLJIT_R1, 0);
3008         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 4);
3009         sljit_emit_op_src(compiler, SLJIT_FAST_RETURN, SLJIT_R1, 0);
3010
3011         codeA.code = sljit_generate_code(compiler);
3012         CHECK(compiler);
3013         sljit_free_compiler(compiler);
3014
3015         /* B */
3016         compiler = sljit_create_compiler(NULL, NULL);
3017         FAILED(!compiler, "cannot create compiler\n");
3018         sljit_set_context(compiler, 0, 1, 5, 5, 0, 0, 2 * sizeof(sljit_p));
3019
3020         sljit_emit_op0(compiler, SLJIT_ENDBR);
3021         sljit_emit_fast_enter(compiler, SLJIT_R4, 0);
3022         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 6);
3023         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, SLJIT_FUNC_ADDR(codeA.code));
3024         sljit_emit_ijump(compiler, SLJIT_FAST_CALL, SLJIT_R1, 0);
3025         sljit_emit_op_src(compiler, SLJIT_FAST_RETURN, SLJIT_R4, 0);
3026
3027         codeB.code = sljit_generate_code(compiler);
3028         CHECK(compiler);
3029         sljit_free_compiler(compiler);
3030
3031         /* C */
3032         compiler = sljit_create_compiler(NULL, NULL);
3033         FAILED(!compiler, "cannot create compiler\n");
3034         sljit_set_context(compiler, 0, 1, 5, 5, 0, 0, 2 * sizeof(sljit_p));
3035
3036         sljit_emit_op0(compiler, SLJIT_ENDBR);
3037         sljit_emit_fast_enter(compiler, SLJIT_MEM1(SLJIT_SP), sizeof(sljit_p));
3038         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 8);
3039         jump = sljit_emit_jump(compiler, SLJIT_FAST_CALL | SLJIT_REWRITABLE_JUMP);
3040         sljit_set_target(jump, SLJIT_FUNC_UADDR(codeB.code));
3041         sljit_emit_op_src(compiler, SLJIT_FAST_RETURN, SLJIT_MEM1(SLJIT_SP), sizeof(sljit_p));
3042
3043         codeC.code = sljit_generate_code(compiler);
3044         CHECK(compiler);
3045         sljit_free_compiler(compiler);
3046
3047         /* D */
3048         compiler = sljit_create_compiler(NULL, NULL);
3049         FAILED(!compiler, "cannot create compiler\n");
3050         sljit_set_context(compiler, 0, 1, 5, 5, 0, 0, 2 * sizeof(sljit_p));
3051
3052         sljit_emit_op0(compiler, SLJIT_ENDBR);
3053         sljit_emit_fast_enter(compiler, SLJIT_MEM1(SLJIT_SP), 0);
3054         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 10);
3055         sljit_emit_ijump(compiler, SLJIT_FAST_CALL, SLJIT_IMM, SLJIT_FUNC_ADDR(codeC.code));
3056         sljit_emit_op_src(compiler, SLJIT_FAST_RETURN, SLJIT_MEM1(SLJIT_SP), 0);
3057
3058         codeD.code = sljit_generate_code(compiler);
3059         CHECK(compiler);
3060         sljit_free_compiler(compiler);
3061
3062         /* E */
3063         compiler = sljit_create_compiler(NULL, NULL);
3064         FAILED(!compiler, "cannot create compiler\n");
3065         sljit_set_context(compiler, 0, 1, 5, 5, 0, 0, 2 * sizeof(sljit_p));
3066
3067         sljit_emit_fast_enter(compiler, SLJIT_MEM1(SLJIT_S0), 0);
3068         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 12);
3069         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_p), SLJIT_IMM, SLJIT_FUNC_ADDR(codeD.code));
3070         sljit_emit_ijump(compiler, SLJIT_FAST_CALL, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_p));
3071         sljit_emit_op_src(compiler, SLJIT_FAST_RETURN, SLJIT_MEM1(SLJIT_S0), 0);
3072
3073         codeE.code = sljit_generate_code(compiler);
3074         CHECK(compiler);
3075         sljit_free_compiler(compiler);
3076
3077         /* F */
3078         compiler = sljit_create_compiler(NULL, NULL);
3079         FAILED(!compiler, "cannot create compiler\n");
3080
3081         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(W, P), 5, 5, 0, 0, 2 * sizeof(sljit_p));
3082         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0);
3083         sljit_emit_ijump(compiler, SLJIT_FAST_CALL, SLJIT_IMM, SLJIT_FUNC_ADDR(codeE.code));
3084         label = sljit_emit_label(compiler);
3085         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_R0, 0);
3086
3087         codeF.code = sljit_generate_code(compiler);
3088         CHECK(compiler);
3089         addr = sljit_get_label_addr(label);
3090         sljit_free_compiler(compiler);
3091
3092         FAILED(codeF.func1((sljit_sw)&buf) != 40, "test34 case 1 failed\n");
3093         FAILED(buf[0] != addr - SLJIT_RETURN_ADDRESS_OFFSET, "test34 case 2 failed\n");
3094
3095         sljit_free_code(codeA.code, NULL);
3096         sljit_free_code(codeB.code, NULL);
3097         sljit_free_code(codeC.code, NULL);
3098         sljit_free_code(codeD.code, NULL);
3099         sljit_free_code(codeE.code, NULL);
3100         sljit_free_code(codeF.code, NULL);
3101         successful_tests++;
3102 }
3103
3104 static void test35(void)
3105 {
3106         /* More complicated tests for fast calls. */
3107         executable_code codeA;
3108         executable_code codeB;
3109         executable_code codeC;
3110         struct sljit_compiler* compiler;
3111         struct sljit_jump *jump = NULL;
3112         struct sljit_label* label;
3113         sljit_sw executable_offset;
3114         sljit_uw return_addr;
3115         sljit_uw jump_addr = 0;
3116         sljit_p buf[1];
3117
3118         if (verbose)
3119                 printf("Run test35\n");
3120
3121         buf[0] = 0;
3122
3123         /* A */
3124         compiler = sljit_create_compiler(NULL, NULL);
3125         FAILED(!compiler, "cannot create compiler\n");
3126         sljit_set_context(compiler, 0, 0, 2, 2, 0, 0, 0);
3127
3128         sljit_emit_fast_enter(compiler, SLJIT_MEM0(), (sljit_sw)&buf[0]);
3129         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 5);
3130
3131         jump = sljit_emit_jump(compiler, SLJIT_FAST_CALL | SLJIT_REWRITABLE_JUMP);
3132         sljit_set_target(jump, 0);
3133
3134         label = sljit_emit_label(compiler);
3135         sljit_emit_op_src(compiler, SLJIT_FAST_RETURN, SLJIT_MEM0(), (sljit_sw)&buf[0]);
3136
3137         codeA.code = sljit_generate_code(compiler);
3138         CHECK(compiler);
3139         executable_offset = sljit_get_executable_offset(compiler);
3140         jump_addr = sljit_get_jump_addr(jump);
3141         sljit_free_compiler(compiler);
3142
3143         /* B */
3144         compiler = sljit_create_compiler(NULL, NULL);
3145         FAILED(!compiler, "cannot create compiler\n");
3146         sljit_set_context(compiler, 0, 0, 2, 2, 0, 0, 0);
3147
3148         sljit_emit_op0(compiler, SLJIT_ENDBR);
3149         sljit_emit_fast_enter(compiler, SLJIT_R1, 0);
3150         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 7);
3151         sljit_emit_op_src(compiler, SLJIT_FAST_RETURN, SLJIT_R1, 0);
3152
3153         codeB.code = sljit_generate_code(compiler);
3154         CHECK(compiler);
3155         sljit_free_compiler(compiler);
3156
3157         sljit_set_jump_addr(jump_addr, SLJIT_FUNC_UADDR(codeB.code), executable_offset);
3158
3159         /* C */
3160         compiler = sljit_create_compiler(NULL, NULL);
3161         FAILED(!compiler, "cannot create compiler\n");
3162
3163         sljit_emit_enter(compiler, 0, SLJIT_ARGS0(W), 2, 2, 0, 0, 0);
3164         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0);
3165         sljit_emit_ijump(compiler, SLJIT_FAST_CALL, SLJIT_IMM, SLJIT_FUNC_ADDR(codeA.code));
3166         label = sljit_emit_label(compiler);
3167         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_R0, 0);
3168
3169         codeC.code = sljit_generate_code(compiler);
3170         CHECK(compiler);
3171         return_addr = sljit_get_label_addr(label);
3172         sljit_free_compiler(compiler);
3173
3174         FAILED(codeC.func0() != 12, "test35 case 1 failed\n");
3175         FAILED(buf[0] != return_addr - SLJIT_RETURN_ADDRESS_OFFSET, "test35 case 2 failed\n");
3176
3177         sljit_free_code(codeA.code, NULL);
3178         sljit_free_code(codeB.code, NULL);
3179         sljit_free_code(codeC.code, NULL);
3180         successful_tests++;
3181 }
3182
3183 static void cmp_test(struct sljit_compiler *compiler, sljit_s32 type, sljit_s32 src1, sljit_sw src1w, sljit_s32 src2, sljit_sw src2w)
3184 {
3185         /* 2 = true, 1 = false */
3186         struct sljit_jump* jump;
3187         struct sljit_label* label;
3188
3189         sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_MEM1(SLJIT_S0), 1, SLJIT_IMM, 2);
3190         jump = sljit_emit_cmp(compiler, type, src1, src1w, src2, src2w);
3191         sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_MEM1(SLJIT_S0), 1, SLJIT_IMM, 1);
3192         label = sljit_emit_label(compiler);
3193         sljit_emit_op0(compiler, SLJIT_ENDBR);
3194         sljit_set_label(jump, label);
3195         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_S0, 0, SLJIT_S0, 0, SLJIT_IMM, 1);
3196 }
3197
3198 #define TEST_CASES      (7 + 10 + 12 + 11 + 4)
3199 static void test36(void)
3200 {
3201         /* Compare instruction. */
3202         executable_code code;
3203         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
3204
3205         sljit_s8 buf[TEST_CASES];
3206         sljit_s8 compare_buf[TEST_CASES] = {
3207                 1, 1, 2, 2, 1, 2, 2,
3208                 1, 1, 2, 2, 2, 1, 2, 2, 1, 1,
3209                 2, 2, 2, 1, 2, 2, 2, 2, 1, 1, 2, 2,
3210                 2, 1, 2, 1, 1, 1, 2, 1, 2, 1, 2,
3211                 2, 1, 1, 2
3212         };
3213         sljit_sw data[4];
3214         sljit_s32 i;
3215
3216         if (verbose)
3217                 printf("Run test36\n");
3218
3219         FAILED(!compiler, "cannot create compiler\n");
3220         for (i = 0; i < TEST_CASES; ++i)
3221                 buf[i] = 100;
3222         data[0] = 32;
3223         data[1] = -9;
3224         data[2] = 43;
3225         data[3] = -13;
3226
3227         sljit_emit_enter(compiler, 0, SLJIT_ARGS2(VOID, P, P), 3, 2, 0, 0, 0);
3228         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_S0, 0, SLJIT_S0, 0, SLJIT_IMM, 1);
3229
3230         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 13);
3231         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 15);
3232         cmp_test(compiler, SLJIT_EQUAL, SLJIT_IMM, 9, SLJIT_R0, 0);
3233         cmp_test(compiler, SLJIT_EQUAL, SLJIT_R0, 0, SLJIT_R1, 0);
3234         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 3);
3235         cmp_test(compiler, SLJIT_EQUAL, SLJIT_MEM2(SLJIT_S1, SLJIT_R0), SLJIT_WORD_SHIFT, SLJIT_IMM, -13);
3236         cmp_test(compiler, SLJIT_NOT_EQUAL, SLJIT_IMM, 0, SLJIT_R0, 0);
3237         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0);
3238         cmp_test(compiler, SLJIT_NOT_EQUAL | SLJIT_REWRITABLE_JUMP, SLJIT_IMM, 0, SLJIT_R0, 0);
3239         cmp_test(compiler, SLJIT_EQUAL, SLJIT_MEM2(SLJIT_S1, SLJIT_R0), SLJIT_WORD_SHIFT, SLJIT_MEM2(SLJIT_S1, SLJIT_R0), SLJIT_WORD_SHIFT);
3240         cmp_test(compiler, SLJIT_EQUAL | SLJIT_REWRITABLE_JUMP, SLJIT_R0, 0, SLJIT_IMM, 0);
3241
3242         cmp_test(compiler, SLJIT_SIG_LESS, SLJIT_MEM1(SLJIT_S1), 0, SLJIT_IMM, 0);
3243         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -8);
3244         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0);
3245         cmp_test(compiler, SLJIT_SIG_GREATER, SLJIT_R0, 0, SLJIT_IMM, 0);
3246         cmp_test(compiler, SLJIT_SIG_LESS_EQUAL, SLJIT_R0, 0, SLJIT_IMM, 0);
3247         cmp_test(compiler, SLJIT_SIG_LESS | SLJIT_REWRITABLE_JUMP, SLJIT_R0, 0, SLJIT_IMM, 0);
3248         cmp_test(compiler, SLJIT_SIG_GREATER_EQUAL, SLJIT_R1, 0, SLJIT_IMM, 0);
3249         cmp_test(compiler, SLJIT_SIG_GREATER, SLJIT_IMM, 0, SLJIT_MEM1(SLJIT_S1), 2 * sizeof(sljit_sw));
3250         cmp_test(compiler, SLJIT_SIG_LESS_EQUAL, SLJIT_IMM, 0, SLJIT_R1, 0);
3251         cmp_test(compiler, SLJIT_SIG_LESS, SLJIT_IMM, 0, SLJIT_MEM1(SLJIT_S1), 2 * sizeof(sljit_sw));
3252         cmp_test(compiler, SLJIT_SIG_LESS, SLJIT_IMM, 0, SLJIT_MEM1(SLJIT_S1), 3 * sizeof(sljit_sw));
3253         cmp_test(compiler, SLJIT_SIG_LESS | SLJIT_REWRITABLE_JUMP, SLJIT_IMM, 0, SLJIT_MEM1(SLJIT_S1), 3 * sizeof(sljit_sw));
3254
3255         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 8);
3256         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0);
3257         cmp_test(compiler, SLJIT_LESS, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_sw));
3258         cmp_test(compiler, SLJIT_GREATER_EQUAL, SLJIT_R0, 0, SLJIT_IMM, 8);
3259         cmp_test(compiler, SLJIT_LESS, SLJIT_R0, 0, SLJIT_IMM, -10);
3260         cmp_test(compiler, SLJIT_LESS, SLJIT_R0, 0, SLJIT_IMM, 8);
3261         cmp_test(compiler, SLJIT_GREATER_EQUAL, SLJIT_IMM, 8, SLJIT_R1, 0);
3262         cmp_test(compiler, SLJIT_GREATER_EQUAL | SLJIT_REWRITABLE_JUMP, SLJIT_IMM, 8, SLJIT_R1, 0);
3263         cmp_test(compiler, SLJIT_GREATER, SLJIT_IMM, 8, SLJIT_R1, 0);
3264         cmp_test(compiler, SLJIT_LESS_EQUAL, SLJIT_IMM, 7, SLJIT_R0, 0);
3265         cmp_test(compiler, SLJIT_GREATER, SLJIT_IMM, 1, SLJIT_MEM1(SLJIT_S1), 3 * sizeof(sljit_sw));
3266         cmp_test(compiler, SLJIT_LESS_EQUAL, SLJIT_R0, 0, SLJIT_R1, 0);
3267         cmp_test(compiler, SLJIT_GREATER, SLJIT_R0, 0, SLJIT_R1, 0);
3268         cmp_test(compiler, SLJIT_GREATER | SLJIT_REWRITABLE_JUMP, SLJIT_R0, 0, SLJIT_R1, 0);
3269
3270         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -3);
3271         cmp_test(compiler, SLJIT_SIG_LESS, SLJIT_R0, 0, SLJIT_R1, 0);
3272         cmp_test(compiler, SLJIT_SIG_GREATER_EQUAL, SLJIT_R0, 0, SLJIT_R1, 0);
3273         cmp_test(compiler, SLJIT_SIG_LESS, SLJIT_R0, 0, SLJIT_IMM, -1);
3274         cmp_test(compiler, SLJIT_SIG_GREATER_EQUAL, SLJIT_R0, 0, SLJIT_IMM, 1);
3275         cmp_test(compiler, SLJIT_SIG_LESS, SLJIT_MEM1(SLJIT_S1), 0, SLJIT_IMM, -1);
3276         cmp_test(compiler, SLJIT_SIG_LESS | SLJIT_REWRITABLE_JUMP, SLJIT_MEM1(SLJIT_S1), 0, SLJIT_IMM, -1);
3277         cmp_test(compiler, SLJIT_SIG_LESS_EQUAL, SLJIT_R0, 0, SLJIT_R1, 0);
3278         cmp_test(compiler, SLJIT_SIG_GREATER, SLJIT_R0, 0, SLJIT_R1, 0);
3279         cmp_test(compiler, SLJIT_SIG_LESS_EQUAL, SLJIT_IMM, -4, SLJIT_R0, 0);
3280         cmp_test(compiler, SLJIT_SIG_GREATER, SLJIT_IMM, -1, SLJIT_R1, 0);
3281         cmp_test(compiler, SLJIT_SIG_GREATER | SLJIT_REWRITABLE_JUMP, SLJIT_R1, 0, SLJIT_IMM, -1);
3282
3283 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
3284         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0xf00000004));
3285         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_R0, 0);
3286         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_R1, 0);
3287         cmp_test(compiler, SLJIT_LESS | SLJIT_32, SLJIT_R1, 0, SLJIT_IMM, 5);
3288         cmp_test(compiler, SLJIT_LESS, SLJIT_R0, 0, SLJIT_IMM, 5);
3289         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0xff0000004));
3290         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_R0, 0);
3291         cmp_test(compiler, SLJIT_SIG_GREATER | SLJIT_32, SLJIT_R1, 0, SLJIT_IMM, 5);
3292         cmp_test(compiler, SLJIT_SIG_GREATER, SLJIT_R0, 0, SLJIT_IMM, 5);
3293 #else
3294         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 4);
3295         cmp_test(compiler, SLJIT_LESS | SLJIT_32, SLJIT_R0, 0, SLJIT_IMM, 5);
3296         cmp_test(compiler, SLJIT_GREATER | SLJIT_32, SLJIT_R0, 0, SLJIT_IMM, 5);
3297         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)0xf0000004);
3298         cmp_test(compiler, SLJIT_SIG_GREATER | SLJIT_32, SLJIT_R0, 0, SLJIT_IMM, 5);
3299         cmp_test(compiler, SLJIT_SIG_LESS | SLJIT_32, SLJIT_R0, 0, SLJIT_IMM, 5);
3300 #endif
3301
3302         sljit_emit_return_void(compiler);
3303
3304         code.code = sljit_generate_code(compiler);
3305         CHECK(compiler);
3306         sljit_free_compiler(compiler);
3307
3308         code.func2((sljit_sw)&buf, (sljit_sw)&data);
3309
3310         for (i = 0; i < TEST_CASES; ++i)
3311                 if (SLJIT_UNLIKELY(buf[i] != compare_buf[i])) {
3312                         printf("test36 case %d failed\n", i + 1);
3313                         return;
3314                 }
3315
3316         sljit_free_code(code.code, NULL);
3317         successful_tests++;
3318 }
3319 #undef TEST_CASES
3320
3321 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
3322 #define BITN(n) (SLJIT_W(1) << (63 - (n)))
3323 #define RESN(n) (n)
3324 #else
3325 #define BITN(n) (1 << (31 - ((n) & 0x1f)))
3326 #define RESN(n) ((n) & 0x1f)
3327 #endif
3328
3329 static void test37(void)
3330 {
3331         /* Test count leading zeroes. */
3332         executable_code code;
3333         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
3334         sljit_sw buf[9];
3335         sljit_s32 ibuf[2];
3336         sljit_s32 i;
3337
3338         if (verbose)
3339                 printf("Run test37\n");
3340
3341         FAILED(!compiler, "cannot create compiler\n");
3342
3343         for (i = 0; i < 9; i++)
3344                 buf[i] = -1;
3345         buf[2] = 0;
3346         buf[4] = BITN(13);
3347         ibuf[0] = -1;
3348         ibuf[1] = -1;
3349         sljit_emit_enter(compiler, 0, SLJIT_ARGS2(VOID, P, P), 1, 3, 0, 0, 0);
3350         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, BITN(27));
3351         sljit_emit_op1(compiler, SLJIT_CLZ, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0);
3352         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, BITN(47));
3353         sljit_emit_op1(compiler, SLJIT_CLZ, SLJIT_R0, 0, SLJIT_S2, 0);
3354         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_R0, 0);
3355         sljit_emit_op1(compiler, SLJIT_CLZ, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw));
3356         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -1);
3357         sljit_emit_op1(compiler, SLJIT_CLZ, SLJIT_R0, 0, SLJIT_R0, 0);
3358         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_R0, 0);
3359         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 0);
3360         sljit_emit_op1(compiler, SLJIT_CLZ32, SLJIT_MEM1(SLJIT_S1), 0, SLJIT_R0, 0);
3361         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -1);
3362         sljit_emit_op1(compiler, SLJIT_CLZ, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw));
3363         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_R0, 0);
3364         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, BITN(58));
3365         sljit_emit_op1(compiler, SLJIT_CLZ, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_R0, 0);
3366         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0);
3367         sljit_emit_op1(compiler, SLJIT_CLZ, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_sw), SLJIT_R0, 0);
3368 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
3369         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0xff08a00000));
3370 #else
3371         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 0x08a00000);
3372 #endif
3373         sljit_emit_op1(compiler, SLJIT_CLZ32, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_s32), SLJIT_R0, 0);
3374         sljit_emit_op1(compiler, SLJIT_CLZ32, SLJIT_R0, 0, SLJIT_R0, 0);
3375         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_sw), SLJIT_R0, 0);
3376 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
3377         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0xffc8a00000));
3378 #else
3379         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)0xc8a00000);
3380 #endif
3381         sljit_emit_op1(compiler, SLJIT_CLZ32, SLJIT_R0, 0, SLJIT_R0, 0);
3382         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_sw), SLJIT_R0, 0);
3383
3384         sljit_emit_return_void(compiler);
3385
3386         code.code = sljit_generate_code(compiler);
3387         CHECK(compiler);
3388         sljit_free_compiler(compiler);
3389
3390         code.func2((sljit_sw)&buf, (sljit_sw)&ibuf);
3391         FAILED(buf[0] != RESN(27), "test37 case 1 failed\n");
3392         FAILED(buf[1] != RESN(47), "test37 case 2 failed\n");
3393 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
3394         FAILED(buf[2] != 64, "test37 case 3 failed\n");
3395 #else
3396         FAILED(buf[2] != 32, "test37 case 3 failed\n");
3397 #endif
3398         FAILED(buf[3] != 0, "test37 case 4 failed\n");
3399         FAILED(ibuf[0] != 32, "test37 case 5 failed\n");
3400         FAILED(buf[4] != RESN(13), "test37 case 6 failed\n");
3401         FAILED(buf[5] != RESN(58), "test37 case 7 failed\n");
3402 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
3403         FAILED(buf[6] != 64, "test37 case 8 failed\n");
3404 #else
3405         FAILED(buf[6] != 32, "test37 case 8 failed\n");
3406 #endif
3407         FAILED(ibuf[1] != 4, "test37 case 9 failed\n");
3408
3409         FAILED((buf[7] & (sljit_sw)0xffffffff) != 4, "test37 case 10 failed\n");
3410         FAILED((buf[8] & (sljit_sw)0xffffffff) != 0, "test37 case 11 failed\n");
3411
3412         sljit_free_code(code.code, NULL);
3413         successful_tests++;
3414 }
3415 #undef BITN
3416 #undef RESN
3417
3418 static void test38(void)
3419 {
3420 #if (defined SLJIT_UTIL_STACK && SLJIT_UTIL_STACK)
3421         /* Test stack utility. */
3422         executable_code code;
3423         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
3424         struct sljit_jump* alloc1_fail;
3425         struct sljit_jump* alloc2_fail;
3426         struct sljit_jump* alloc3_fail;
3427         struct sljit_jump* sanity1_fail;
3428         struct sljit_jump* sanity2_fail;
3429         struct sljit_jump* sanity3_fail;
3430         struct sljit_jump* sanity4_fail;
3431         struct sljit_jump* jump;
3432         struct sljit_label* label;
3433
3434         if (verbose)
3435                 printf("Run test38\n");
3436
3437         FAILED(!compiler, "cannot create compiler\n");
3438
3439         sljit_emit_enter(compiler, 0, SLJIT_ARGS0(W), 3, 1, 0, 0, 0);
3440
3441         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 8192);
3442         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 65536);
3443         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 0);
3444         sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_ARGS3(P, W, W, P), SLJIT_IMM, SLJIT_FUNC_ADDR(sljit_allocate_stack));
3445         alloc1_fail = sljit_emit_cmp(compiler, SLJIT_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 0);
3446         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_RETURN_REG, 0);
3447
3448         /* Write 8k data. */
3449         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), SLJIT_OFFSETOF(struct sljit_stack, start));
3450         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, 8192);
3451         label = sljit_emit_label(compiler);
3452         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_IMM, -1);
3453         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, sizeof(sljit_sw));
3454         jump = sljit_emit_cmp(compiler, SLJIT_LESS, SLJIT_R0, 0, SLJIT_R1, 0);
3455         sljit_set_label(jump, label);
3456
3457         /* Grow stack. */
3458         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_S0, 0);
3459         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_S0), SLJIT_OFFSETOF(struct sljit_stack, end), SLJIT_IMM, 65536);
3460         sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_ARGS2(P, P, P), SLJIT_IMM, SLJIT_FUNC_ADDR(sljit_stack_resize));
3461         alloc2_fail = sljit_emit_cmp(compiler, SLJIT_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 0);
3462         sanity1_fail = sljit_emit_cmp(compiler, SLJIT_NOT_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_MEM1(SLJIT_S0), SLJIT_OFFSETOF(struct sljit_stack, start));
3463
3464         /* Write 64k data. */
3465         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), SLJIT_OFFSETOF(struct sljit_stack, start));
3466         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, 65536);
3467         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_S0), SLJIT_OFFSETOF(struct sljit_stack, min_start));
3468         sanity2_fail = sljit_emit_cmp(compiler, SLJIT_NOT_EQUAL, SLJIT_R0, 0, SLJIT_R2, 0);
3469         label = sljit_emit_label(compiler);
3470         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_IMM, -1);
3471         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, sizeof(sljit_sw));
3472         jump = sljit_emit_cmp(compiler, SLJIT_LESS, SLJIT_R0, 0, SLJIT_R1, 0);
3473         sljit_set_label(jump, label);
3474
3475         /* Shrink stack. */
3476         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_S0, 0);
3477         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_S0), SLJIT_OFFSETOF(struct sljit_stack, end), SLJIT_IMM, 32768);
3478         sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_ARGS2(P, P, P), SLJIT_IMM, SLJIT_FUNC_ADDR(sljit_stack_resize));
3479         alloc3_fail = sljit_emit_cmp(compiler, SLJIT_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 0);
3480         sanity3_fail = sljit_emit_cmp(compiler, SLJIT_NOT_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_MEM1(SLJIT_S0), SLJIT_OFFSETOF(struct sljit_stack, start));
3481
3482         /* Write 32k data. */
3483         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), SLJIT_OFFSETOF(struct sljit_stack, start));
3484         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_S0), SLJIT_OFFSETOF(struct sljit_stack, end));
3485         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R2, 0, SLJIT_R1, 0, SLJIT_IMM, 32768);
3486         sanity4_fail = sljit_emit_cmp(compiler, SLJIT_NOT_EQUAL, SLJIT_R0, 0, SLJIT_R2, 0);
3487         label = sljit_emit_label(compiler);
3488         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_IMM, -1);
3489         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, sizeof(sljit_sw));
3490         jump = sljit_emit_cmp(compiler, SLJIT_LESS, SLJIT_R0, 0, SLJIT_R1, 0);
3491         sljit_set_label(jump, label);
3492
3493         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_S0, 0);
3494         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0);
3495         sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_ARGS2(VOID, P, P), SLJIT_IMM, SLJIT_FUNC_ADDR(sljit_free_stack));
3496
3497         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_IMM, 4567);
3498
3499         label = sljit_emit_label(compiler);
3500         sljit_set_label(alloc1_fail, label);
3501         sljit_set_label(alloc2_fail, label);
3502         sljit_set_label(alloc3_fail, label);
3503         sljit_set_label(sanity1_fail, label);
3504         sljit_set_label(sanity2_fail, label);
3505         sljit_set_label(sanity3_fail, label);
3506         sljit_set_label(sanity4_fail, label);
3507         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_IMM, 0);
3508
3509         code.code = sljit_generate_code(compiler);
3510         CHECK(compiler);
3511         sljit_free_compiler(compiler);
3512
3513         /* Just survive this. */
3514         FAILED(code.func0() != 4567, "test38 case 1 failed\n");
3515
3516         sljit_free_code(code.code, NULL);
3517 #endif
3518         successful_tests++;
3519 }
3520
3521 static void test39(void)
3522 {
3523         /* Test error handling. */
3524         executable_code code;
3525         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
3526         struct sljit_jump* jump;
3527
3528         if (verbose)
3529                 printf("Run test39\n");
3530
3531         FAILED(!compiler, "cannot create compiler\n");
3532
3533         /* Such assignment should never happen in a regular program. */
3534         compiler->error = -3967;
3535
3536         SLJIT_ASSERT(sljit_emit_enter(compiler, 0, SLJIT_ARGS2(VOID, W, W), 5, 5, 6, 0, 32) == -3967);
3537         SLJIT_ASSERT(sljit_emit_return(compiler, SLJIT_MOV, SLJIT_R1, 0) == -3967);
3538         SLJIT_ASSERT(sljit_emit_op0(compiler, SLJIT_NOP) == -3967);
3539         SLJIT_ASSERT(sljit_emit_op0(compiler, SLJIT_ENDBR) == -3967);
3540         SLJIT_ASSERT(sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM2(SLJIT_R0, SLJIT_R1), 1) == -3967);
3541         SLJIT_ASSERT(sljit_emit_op2(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_R0), 64, SLJIT_MEM1(SLJIT_S0), -64) == -3967);
3542         SLJIT_ASSERT(sljit_emit_fop1(compiler, SLJIT_ABS_F64, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_R1), 0) == -3967);
3543         SLJIT_ASSERT(sljit_emit_fop2(compiler, SLJIT_DIV_F64, SLJIT_FR2, 0, SLJIT_MEM2(SLJIT_R0, SLJIT_S0), 0, SLJIT_FR2, 0) == -3967);
3544         SLJIT_ASSERT(!sljit_emit_label(compiler));
3545         jump = sljit_emit_call(compiler, SLJIT_CALL, SLJIT_ARGS4(W, 32, P, F32, F64));
3546         SLJIT_ASSERT(!jump);
3547         sljit_set_label(jump, (struct sljit_label*)0x123450);
3548         sljit_set_target(jump, 0x123450);
3549         jump = sljit_emit_cmp(compiler, SLJIT_SIG_LESS_EQUAL, SLJIT_R0, 0, SLJIT_R1, 0);
3550         SLJIT_ASSERT(!jump);
3551         SLJIT_ASSERT(sljit_emit_ijump(compiler, SLJIT_JUMP, SLJIT_MEM1(SLJIT_R0), 8) == -3967);
3552         SLJIT_ASSERT(sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_OVERFLOW) == -3967);
3553         SLJIT_ASSERT(!sljit_emit_const(compiler, SLJIT_R0, 0, 99));
3554
3555         SLJIT_ASSERT(!compiler->labels && !compiler->jumps && !compiler->consts);
3556         SLJIT_ASSERT(!compiler->last_label && !compiler->last_jump && !compiler->last_const);
3557         SLJIT_ASSERT(!compiler->buf->next && !compiler->buf->used_size);
3558         SLJIT_ASSERT(!compiler->abuf->next && !compiler->abuf->used_size);
3559
3560         sljit_set_compiler_memory_error(compiler);
3561         FAILED(sljit_get_compiler_error(compiler) != -3967, "test39 case 1 failed\n");
3562
3563         code.code = sljit_generate_code(compiler);
3564         FAILED(sljit_get_compiler_error(compiler) != -3967, "test39 case 2 failed\n");
3565         FAILED(!!code.code, "test39 case 3 failed\n");
3566         sljit_free_compiler(compiler);
3567
3568         compiler = sljit_create_compiler(NULL, NULL);
3569         FAILED(!compiler, "cannot create compiler\n");
3570
3571         FAILED(sljit_get_compiler_error(compiler) != SLJIT_SUCCESS, "test39 case 4 failed\n");
3572         sljit_set_compiler_memory_error(compiler);
3573         FAILED(sljit_get_compiler_error(compiler) != SLJIT_ERR_ALLOC_FAILED, "test39 case 5 failed\n");
3574         sljit_free_compiler(compiler);
3575
3576         successful_tests++;
3577 }
3578
3579 static void test40(void)
3580 {
3581         /* Test emit_op_flags. */
3582         executable_code code;
3583         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
3584         sljit_sw buf[10];
3585
3586         if (verbose)
3587                 printf("Run test40\n");
3588
3589         FAILED(!compiler, "cannot create compiler\n");
3590         buf[0] = -100;
3591         buf[1] = -100;
3592         buf[2] = -100;
3593         buf[3] = -8;
3594         buf[4] = -100;
3595         buf[5] = -100;
3596         buf[6] = 0;
3597         buf[7] = 0;
3598         buf[8] = -100;
3599         buf[9] = -100;
3600
3601         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(W, P), 3, 4, 0, 0, sizeof(sljit_sw));
3602
3603         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -5);
3604         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_SIG_LESS, SLJIT_IMM, -6, SLJIT_R0, 0);
3605         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0x123456);
3606         sljit_emit_op_flags(compiler, SLJIT_OR, SLJIT_R1, 0, SLJIT_SIG_LESS);
3607         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R1, 0);
3608
3609         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -13);
3610         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_Z, SLJIT_IMM, -13, SLJIT_R0, 0);
3611         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), 0, SLJIT_IMM, 0);
3612         sljit_emit_op_flags(compiler, SLJIT_OR | SLJIT_SET_Z, SLJIT_MEM1(SLJIT_SP), 0, SLJIT_EQUAL);
3613         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_NOT_EQUAL);
3614         sljit_emit_op2(compiler, SLJIT_OR, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_MEM1(SLJIT_SP), 0);
3615         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_Z, SLJIT_IMM, -13, SLJIT_R0, 0);
3616         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0);
3617         sljit_emit_op_flags(compiler, SLJIT_OR | SLJIT_SET_Z, SLJIT_R1, 0, SLJIT_EQUAL);
3618         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 2, SLJIT_EQUAL);
3619
3620         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -13);
3621         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 3);
3622         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_SIG_LESS, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_R1, 0);
3623         sljit_emit_op_flags(compiler, SLJIT_OR, SLJIT_MEM2(SLJIT_S0, SLJIT_R1), SLJIT_WORD_SHIFT, SLJIT_SIG_LESS);
3624
3625         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -8);
3626         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 33);
3627         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_GREATER, SLJIT_R0, 0, SLJIT_R1, 0);
3628         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_IMM, 0);
3629         sljit_emit_op_flags(compiler, SLJIT_OR | SLJIT_SET_Z, SLJIT_R2, 0, SLJIT_GREATER);
3630         sljit_emit_op_flags(compiler, SLJIT_OR, SLJIT_S1, 0, SLJIT_EQUAL);
3631         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_Z, SLJIT_R0, 0, SLJIT_R1, 0);
3632         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S3, 0, SLJIT_IMM, 0x88);
3633         sljit_emit_op_flags(compiler, SLJIT_OR, SLJIT_S3, 0, SLJIT_NOT_EQUAL);
3634         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 4, SLJIT_S1, 0);
3635         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 5, SLJIT_S3, 0);
3636
3637         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0x84);
3638         sljit_emit_op2u(compiler, SLJIT_AND | SLJIT_SET_Z, SLJIT_IMM, 0x180, SLJIT_R0, 0);
3639         sljit_emit_op_flags(compiler, SLJIT_OR | SLJIT_SET_Z, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 6, SLJIT_EQUAL);
3640         sljit_emit_op_flags(compiler, SLJIT_OR, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 7, SLJIT_EQUAL);
3641
3642         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 1);
3643         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_Z, SLJIT_R0, 0, SLJIT_IMM, 1);
3644         sljit_emit_op_flags(compiler, SLJIT_OR | SLJIT_SET_Z, SLJIT_R0, 0, SLJIT_NOT_EQUAL);
3645         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 8, SLJIT_NOT_EQUAL);
3646
3647         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0x123456);
3648         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_GREATER, SLJIT_R0, 0, SLJIT_IMM, 1);
3649         sljit_emit_op_flags(compiler, SLJIT_OR, SLJIT_R0, 0, SLJIT_GREATER);
3650         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 9, SLJIT_R0, 0);
3651
3652         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), 0, SLJIT_IMM, 0xbaddead);
3653         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), 0);
3654
3655         code.code = sljit_generate_code(compiler);
3656         CHECK(compiler);
3657         sljit_free_compiler(compiler);
3658
3659         FAILED(code.func1((sljit_sw)&buf) != 0xbaddead, "test40 case 1 failed\n");
3660         FAILED(buf[0] != 0x123457, "test40 case 2 failed\n");
3661         FAILED(buf[1] != 1, "test40 case 3 failed\n");
3662         FAILED(buf[2] != 0, "test40 case 4 failed\n");
3663         FAILED(buf[3] != -7, "test40 case 5 failed\n");
3664         FAILED(buf[4] != 0, "test40 case 6 failed\n");
3665         FAILED(buf[5] != 0x89, "test40 case 7 failed\n");
3666         FAILED(buf[6] != 0, "test40 case 8 failed\n");
3667         FAILED(buf[7] != 1, "test40 case 9 failed\n");
3668         FAILED(buf[8] != 1, "test40 case 10 failed\n");
3669         FAILED(buf[9] != 0x123457, "test40 case 11 failed\n");
3670
3671         sljit_free_code(code.code, NULL);
3672         successful_tests++;
3673 }
3674
3675 static void test41(void)
3676 {
3677         /* Test inline assembly. */
3678         executable_code code;
3679         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
3680         sljit_s32 i;
3681         sljit_f64 buf[3];
3682 #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
3683         sljit_u8 inst[16];
3684 #elif (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
3685         sljit_u8 inst[16];
3686         sljit_s32 reg;
3687 #else
3688         sljit_u32 inst;
3689 #endif
3690
3691         if (verbose)
3692                 printf("Run test41\n");
3693
3694 #if !(defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
3695         SLJIT_ASSERT(sljit_has_cpu_feature(SLJIT_HAS_VIRTUAL_REGISTERS) == 0);
3696 #endif
3697
3698         for (i = 0; i < SLJIT_NUMBER_OF_REGISTERS; i++) {
3699 #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
3700                 if (SLJIT_R(i) >= SLJIT_R3 && SLJIT_R(i) <= SLJIT_R8) {
3701                         SLJIT_ASSERT(sljit_get_register_index(SLJIT_R(i)) == -1);
3702                         continue;
3703                 }
3704 #endif
3705                 SLJIT_ASSERT(sljit_get_register_index(SLJIT_R(i)) >= 0 && sljit_get_register_index(SLJIT_R(i)) < 64);
3706         }
3707
3708         FAILED(!compiler, "cannot create compiler\n");
3709         sljit_emit_enter(compiler, 0, SLJIT_ARGS2(W, W, W), 3, 3, 0, 0, 0);
3710
3711         /* Returns with the sum of SLJIT_S0 and SLJIT_S1. */
3712 #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
3713         /* lea SLJIT_RETURN_REG, [SLJIT_S0, SLJIT_S1] */
3714         inst[0] = 0x48;
3715         inst[1] = 0x8d;
3716         inst[2] = (sljit_u8)(0x04 | ((sljit_get_register_index(SLJIT_RETURN_REG) & 0x7) << 3));
3717         inst[3] = (sljit_u8)((sljit_get_register_index(SLJIT_S0) & 0x7)
3718                 | ((sljit_get_register_index(SLJIT_S1) & 0x7) << 3));
3719         sljit_emit_op_custom(compiler, inst, 4);
3720 #elif (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
3721         /* lea SLJIT_RETURN_REG, [SLJIT_S0, SLJIT_S1] */
3722         inst[0] = 0x48; /* REX_W */
3723         inst[1] = 0x8d;
3724         reg = sljit_get_register_index(SLJIT_RETURN_REG);
3725         inst[2] = (sljit_u8)(0x04 | ((reg & 0x7) << 3));
3726         if (reg > 7)
3727                 inst[0] |= 0x04; /* REX_R */
3728         reg = sljit_get_register_index(SLJIT_S0);
3729         inst[3] = (sljit_u8)(reg & 0x7);
3730         if (reg > 7)
3731                 inst[0] |= 0x01; /* REX_B */
3732         reg = sljit_get_register_index(SLJIT_S1);
3733         inst[3] = (sljit_u8)(inst[3] | ((reg & 0x7) << 3));
3734         if (reg > 7)
3735                 inst[0] |= 0x02; /* REX_X */
3736         sljit_emit_op_custom(compiler, inst, 4);
3737 #elif (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5) || (defined SLJIT_CONFIG_ARM_V7 && SLJIT_CONFIG_ARM_V7)
3738         /* add rd, rn, rm */
3739         inst = 0xe0800000 | ((sljit_u32)sljit_get_register_index(SLJIT_RETURN_REG) << 12)
3740                 | ((sljit_u32)sljit_get_register_index(SLJIT_S0) << 16)
3741                 | (sljit_u32)sljit_get_register_index(SLJIT_S1);
3742         sljit_emit_op_custom(compiler, &inst, sizeof(sljit_u32));
3743 #elif (defined SLJIT_CONFIG_ARM_THUMB2 && SLJIT_CONFIG_ARM_THUMB2)
3744         /* add rd, rn, rm */
3745         inst = 0xeb000000 | ((sljit_u32)sljit_get_register_index(SLJIT_RETURN_REG) << 8)
3746                 | ((sljit_u32)sljit_get_register_index(SLJIT_S0) << 16)
3747                 | (sljit_u32)sljit_get_register_index(SLJIT_S1);
3748         sljit_emit_op_custom(compiler, &inst, sizeof(sljit_u32));
3749 #elif (defined SLJIT_CONFIG_ARM_64 && SLJIT_CONFIG_ARM_64)
3750         /* add rd, rn, rm */
3751         inst = 0x8b000000 | (sljit_u32)sljit_get_register_index(SLJIT_RETURN_REG)
3752                 | ((sljit_u32)sljit_get_register_index(SLJIT_S0) << 5)
3753                 | ((sljit_u32)sljit_get_register_index(SLJIT_S1) << 16);
3754         sljit_emit_op_custom(compiler, &inst, sizeof(sljit_u32));
3755 #elif (defined SLJIT_CONFIG_PPC && SLJIT_CONFIG_PPC)
3756         /* add rD, rA, rB */
3757         inst = (31 << 26) | (266 << 1) | ((sljit_u32)sljit_get_register_index(SLJIT_RETURN_REG) << 21)
3758                 | ((sljit_u32)sljit_get_register_index(SLJIT_S0) << 16)
3759                 | ((sljit_u32)sljit_get_register_index(SLJIT_S1) << 11);
3760         sljit_emit_op_custom(compiler, &inst, sizeof(sljit_u32));
3761 #elif (defined SLJIT_CONFIG_MIPS_32 && SLJIT_CONFIG_MIPS_32)
3762         /* addu rd, rs, rt */
3763         inst = 33 | ((sljit_u32)sljit_get_register_index(SLJIT_RETURN_REG) << 11)
3764                 | ((sljit_u32)sljit_get_register_index(SLJIT_S0) << 21)
3765                 | ((sljit_u32)sljit_get_register_index(SLJIT_S1) << 16);
3766         sljit_emit_op_custom(compiler, &inst, sizeof(sljit_u32));
3767 #elif (defined SLJIT_CONFIG_MIPS_64 && SLJIT_CONFIG_MIPS_64)
3768         /* daddu rd, rs, rt */
3769         inst = 45 | ((sljit_u32)sljit_get_register_index(SLJIT_RETURN_REG) << 11)
3770                 | ((sljit_u32)sljit_get_register_index(SLJIT_S0) << 21)
3771                 | ((sljit_u32)sljit_get_register_index(SLJIT_S1) << 16);
3772         sljit_emit_op_custom(compiler, &inst, sizeof(sljit_u32));
3773 #elif (defined SLJIT_CONFIG_SPARC_32 && SLJIT_CONFIG_SPARC_32)
3774         /* add rd, rs1, rs2 */
3775         inst = (0x2u << 30) | ((sljit_u32)sljit_get_register_index(SLJIT_RETURN_REG) << 25)
3776                 | ((sljit_u32)sljit_get_register_index(SLJIT_S0) << 14)
3777                 | (sljit_u32)sljit_get_register_index(SLJIT_S1);
3778         sljit_emit_op_custom(compiler, &inst, sizeof(sljit_u32));
3779 #elif (defined SLJIT_CONFIG_S390X && SLJIT_CONFIG_S390X)
3780         /* agrk rd, rs1, rs2 */
3781         inst = (0xb9e8u << 16)
3782                 | ((sljit_u32)sljit_get_register_index(SLJIT_RETURN_REG) << 4)
3783                 | ((sljit_u32)sljit_get_register_index(SLJIT_S0) << 12)
3784                 | (sljit_u32)sljit_get_register_index(SLJIT_S1);
3785         sljit_emit_op_custom(compiler, &inst, sizeof(inst));
3786 #else
3787         inst = 0;
3788         sljit_emit_op_custom(compiler, &inst, 0);
3789 #endif
3790
3791         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);
3792
3793         code.code = sljit_generate_code(compiler);
3794         CHECK(compiler);
3795         sljit_free_compiler(compiler);
3796
3797         FAILED(code.func2(32, -11) != 21, "test41 case 1 failed\n");
3798         FAILED(code.func2(1000, 234) != 1234, "test41 case 2 failed\n");
3799 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
3800         FAILED(code.func2(SLJIT_W(0x20f0a04090c06070), SLJIT_W(0x020f0a04090c0607)) != SLJIT_W(0x22ffaa4499cc6677), "test41 case 3 failed\n");
3801 #endif
3802
3803         sljit_free_code(code.code, NULL);
3804
3805         if (sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
3806                 buf[0] = 13.5;
3807                 buf[1] = -2.25;
3808                 buf[2] = 0.0;
3809
3810                 compiler = sljit_create_compiler(NULL, NULL);
3811                 sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, P), 0, 1, 2, 0, 0);
3812                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S0), 0);
3813                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64));
3814 #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
3815                 /* addsd x, xm */
3816                 inst[0] = 0xf2;
3817                 inst[1] = 0x0f;
3818                 inst[2] = 0x58;
3819                 inst[3] = (sljit_u8)(0xc0 | (sljit_get_float_register_index(SLJIT_FR0) << 3)
3820                         | sljit_get_float_register_index(SLJIT_FR1));
3821                 sljit_emit_op_custom(compiler, inst, 4);
3822 #elif (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
3823                 /* addsd x, xm */
3824                 if (sljit_get_float_register_index(SLJIT_FR0) > 7 || sljit_get_float_register_index(SLJIT_FR1) > 7) {
3825                         inst[0] = 0;
3826                         if (sljit_get_float_register_index(SLJIT_FR0) > 7)
3827                                 inst[0] |= 0x04; /* REX_R */
3828                         if (sljit_get_float_register_index(SLJIT_FR1) > 7)
3829                                 inst[0] |= 0x01; /* REX_B */
3830                         inst[1] = 0xf2;
3831                         inst[2] = 0x0f;
3832                         inst[3] = 0x58;
3833                         inst[4] = (sljit_u8)(0xc0 | ((sljit_get_float_register_index(SLJIT_FR0) & 0x7) << 3)
3834                                 | (sljit_get_float_register_index(SLJIT_FR1) & 0x7));
3835                         sljit_emit_op_custom(compiler, inst, 5);
3836                 }
3837                 else {
3838                         inst[0] = 0xf2;
3839                         inst[1] = 0x0f;
3840                         inst[2] = 0x58;
3841                         inst[3] = (sljit_u8)(0xc0 | (sljit_get_float_register_index(SLJIT_FR0) << 3)
3842                                 | sljit_get_float_register_index(SLJIT_FR1));
3843                         sljit_emit_op_custom(compiler, inst, 4);
3844                 }
3845 #elif (defined SLJIT_CONFIG_ARM_32 && SLJIT_CONFIG_ARM_32)
3846                 /* vadd.f64 dd, dn, dm */
3847                 inst = 0xee300b00 | (((sljit_u32)sljit_get_float_register_index(SLJIT_FR0) >> 1) << 12)
3848                         | (((sljit_u32)sljit_get_float_register_index(SLJIT_FR0) >> 1) << 16)
3849                         | ((sljit_u32)sljit_get_float_register_index(SLJIT_FR1) >> 1);
3850                 sljit_emit_op_custom(compiler, &inst, sizeof(sljit_u32));
3851 #elif (defined SLJIT_CONFIG_ARM_64 && SLJIT_CONFIG_ARM_64)
3852                 /* fadd rd, rn, rm */
3853                 inst = 0x1e602800 | (sljit_u32)sljit_get_float_register_index(SLJIT_FR0)
3854                         | ((sljit_u32)sljit_get_float_register_index(SLJIT_FR0) << 5)
3855                         | ((sljit_u32)sljit_get_float_register_index(SLJIT_FR1) << 16);
3856                 sljit_emit_op_custom(compiler, &inst, sizeof(sljit_u32));
3857 #elif (defined SLJIT_CONFIG_PPC && SLJIT_CONFIG_PPC)
3858                 /* fadd frD, frA, frB */
3859                 inst = (63u << 26) | (21u << 1) | ((sljit_u32)sljit_get_float_register_index(SLJIT_FR0) << 21)
3860                         | ((sljit_u32)sljit_get_float_register_index(SLJIT_FR0) << 16)
3861                         | ((sljit_u32)sljit_get_float_register_index(SLJIT_FR1) << 11);
3862                 sljit_emit_op_custom(compiler, &inst, sizeof(sljit_u32));
3863 #elif (defined SLJIT_CONFIG_MIPS && SLJIT_CONFIG_MIPS)
3864                 /* add.d fd, fs, ft */
3865                 inst = (17 << 26) | (17 << 21) | ((sljit_u32)sljit_get_float_register_index(SLJIT_FR0) << 6)
3866                         | ((sljit_u32)sljit_get_float_register_index(SLJIT_FR0) << 11)
3867                         | ((sljit_u32)sljit_get_float_register_index(SLJIT_FR1) << 16);
3868                 sljit_emit_op_custom(compiler, &inst, sizeof(sljit_u32));
3869 #elif (defined SLJIT_CONFIG_SPARC_32 && SLJIT_CONFIG_SPARC_32)
3870                 /* faddd rd, rs1, rs2 */
3871                 inst = (0x2u << 30) | (0x34u << 19) | (0x42u << 5)
3872                         | ((sljit_u32)sljit_get_float_register_index(SLJIT_FR0) << 25)
3873                         | ((sljit_u32)sljit_get_float_register_index(SLJIT_FR0) << 14)
3874                         | (sljit_u32)sljit_get_float_register_index(SLJIT_FR1);
3875                 sljit_emit_op_custom(compiler, &inst, sizeof(sljit_u32));
3876 #elif (defined SLJIT_CONFIG_S390X && SLJIT_CONFIG_S390X)
3877                 /* adbr r1, r2 */
3878                 inst = 0xb31a0000
3879                         | ((sljit_u32)sljit_get_float_register_index(SLJIT_FR0) << 4)
3880                         | (sljit_u32)sljit_get_float_register_index(SLJIT_FR1);
3881                 sljit_emit_op_custom(compiler, &inst, sizeof(sljit_u32));
3882 #endif
3883                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_f64), SLJIT_FR0, 0);
3884                 sljit_emit_return_void(compiler);
3885
3886                 code.code = sljit_generate_code(compiler);
3887                 CHECK(compiler);
3888                 sljit_free_compiler(compiler);
3889
3890                 code.func1((sljit_sw)&buf);
3891                 FAILED(buf[2] != 11.25, "test41 case 3 failed\n");
3892
3893                 sljit_free_code(code.code, NULL);
3894         }
3895
3896         successful_tests++;
3897 }
3898
3899 static void test42(void)
3900 {
3901         /* Test long multiply and division. */
3902         executable_code code;
3903         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
3904         sljit_s32 i;
3905         sljit_sw buf[7 + 4 + 8 + 8];
3906
3907         if (verbose)
3908                 printf("Run test42\n");
3909
3910         FAILED(!compiler, "cannot create compiler\n");
3911         for (i = 0; i < 7 + 4 + 8 + 8; i++)
3912                 buf[i] = -1;
3913
3914         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, P), 5, 5, 0, 0, 0);
3915
3916         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, -0x1fb308a);
3917         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, 0xf50c873);
3918         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R4, 0, SLJIT_IMM, 0x8a0475b);
3919         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_IMM, 0x9dc849b);
3920         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, -0x7c69a35);
3921         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S3, 0, SLJIT_IMM, 0x5a4d0c4);
3922         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S4, 0, SLJIT_IMM, 0x9a3b06d);
3923
3924 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
3925         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(-0x5dc4f897b8cd67f5));
3926         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(0x3f8b5c026cb088df));
3927         sljit_emit_op0(compiler, SLJIT_LMUL_UW);
3928         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_sw), SLJIT_R0, 0);
3929         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_sw), SLJIT_R1, 0);
3930
3931         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(-0x5dc4f897b8cd67f5));
3932         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(0x3f8b5c026cb088df));
3933         sljit_emit_op0(compiler, SLJIT_LMUL_SW);
3934         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 9 * sizeof(sljit_sw), SLJIT_R0, 0);
3935         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 10 * sizeof(sljit_sw), SLJIT_R1, 0);
3936
3937         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(-0x5dc4f897b8cd67f5));
3938         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(0x3f8b5c026cb088df));
3939         sljit_emit_op0(compiler, SLJIT_DIVMOD_UW);
3940         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 11 * sizeof(sljit_sw), SLJIT_R0, 0);
3941         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 12 * sizeof(sljit_sw), SLJIT_R1, 0);
3942
3943         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(-0x5dc4f897b8cd67f5));
3944         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(0x3f8b5c026cb088df));
3945         sljit_emit_op0(compiler, SLJIT_DIVMOD_SW);
3946         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 13 * sizeof(sljit_sw), SLJIT_R0, 0);
3947         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 14 * sizeof(sljit_sw), SLJIT_R1, 0);
3948
3949         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0x5cf783d3cf0a74b0));
3950         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(0x3d5df42d03a28fc7));
3951         sljit_emit_op0(compiler, SLJIT_DIVMOD_U32);
3952         sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_R0, 0, SLJIT_R0, 0);
3953         sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_R1, 0, SLJIT_R1, 0);
3954         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 15 * sizeof(sljit_sw), SLJIT_R0, 0);
3955         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 16 * sizeof(sljit_sw), SLJIT_R1, 0);
3956
3957         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0x371df5197ba26a28));
3958         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(0x46c78a5cfd6a420c));
3959         sljit_emit_op0(compiler, SLJIT_DIVMOD_S32);
3960         sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_R0, 0, SLJIT_R0, 0);
3961         sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_R1, 0, SLJIT_R1, 0);
3962         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 17 * sizeof(sljit_sw), SLJIT_R0, 0);
3963         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 18 * sizeof(sljit_sw), SLJIT_R1, 0);
3964
3965         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)SLJIT_W(0xc456f048c28a611b));
3966         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(0x3d4af2c543));
3967         sljit_emit_op0(compiler, SLJIT_DIV_UW);
3968         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 19 * sizeof(sljit_sw), SLJIT_R0, 0);
3969         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 20 * sizeof(sljit_sw), SLJIT_R1, 0);
3970
3971         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(-0x720fa4b74c329b14));
3972         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(0xa64ae42b7d6));
3973         sljit_emit_op0(compiler, SLJIT_DIV_SW);
3974         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 21 * sizeof(sljit_sw), SLJIT_R0, 0);
3975         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 22 * sizeof(sljit_sw), SLJIT_R1, 0);
3976
3977         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0x4af51c027b34));
3978         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(0x9ba4ff2906b14));
3979         sljit_emit_op0(compiler, SLJIT_DIV_U32);
3980         sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_R0, 0, SLJIT_R0, 0);
3981         sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_R1, 0, SLJIT_R1, 0);
3982         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 23 * sizeof(sljit_sw), SLJIT_R0, 0);
3983         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 24 * sizeof(sljit_sw), SLJIT_R1, 0);
3984
3985         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0xc40b58a3f20d));
3986         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(-0xa63c923));
3987         sljit_emit_op0(compiler, SLJIT_DIV_S32);
3988         sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_R0, 0, SLJIT_R0, 0);
3989         sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_R1, 0, SLJIT_R1, 0);
3990         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 25 * sizeof(sljit_sw), SLJIT_R0, 0);
3991         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 26 * sizeof(sljit_sw), SLJIT_R1, 0);
3992
3993 #else
3994         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -0x58cd67f5);
3995         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0x3cb088df);
3996         sljit_emit_op0(compiler, SLJIT_LMUL_UW);
3997         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_sw), SLJIT_R0, 0);
3998         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_sw), SLJIT_R1, 0);
3999
4000         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -0x58cd67f5);
4001         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0x3cb088df);
4002         sljit_emit_op0(compiler, SLJIT_LMUL_SW);
4003         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 9 * sizeof(sljit_sw), SLJIT_R0, 0);
4004         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 10 * sizeof(sljit_sw), SLJIT_R1, 0);
4005
4006         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -0x58cd67f5);
4007         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0x3cb088df);
4008         sljit_emit_op0(compiler, SLJIT_DIVMOD_UW);
4009         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 11 * sizeof(sljit_sw), SLJIT_R0, 0);
4010         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 12 * sizeof(sljit_sw), SLJIT_R1, 0);
4011
4012         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -0x58cd67f5);
4013         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0x3cb088df);
4014         sljit_emit_op0(compiler, SLJIT_DIVMOD_SW);
4015         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 13 * sizeof(sljit_sw), SLJIT_R0, 0);
4016         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 14 * sizeof(sljit_sw), SLJIT_R1, 0);
4017
4018         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)0xcf0a74b0);
4019         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, 0x03a28fc7);
4020         sljit_emit_op0(compiler, SLJIT_DIVMOD_U32);
4021         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 15 * sizeof(sljit_sw), SLJIT_R0, 0);
4022         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 16 * sizeof(sljit_sw), SLJIT_R1, 0);
4023
4024         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 0x7ba26a28);
4025         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, (sljit_sw)0xfd6a420c);
4026         sljit_emit_op0(compiler, SLJIT_DIVMOD_S32);
4027         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 17 * sizeof(sljit_sw), SLJIT_R0, 0);
4028         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 18 * sizeof(sljit_sw), SLJIT_R1, 0);
4029
4030         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)0x9d4b7036);
4031         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0xb86d0);
4032         sljit_emit_op0(compiler, SLJIT_DIV_UW);
4033         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 19 * sizeof(sljit_sw), SLJIT_R0, 0);
4034         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 20 * sizeof(sljit_sw), SLJIT_R1, 0);
4035
4036         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -0x58b0692c);
4037         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0xd357);
4038         sljit_emit_op0(compiler, SLJIT_DIV_SW);
4039         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 21 * sizeof(sljit_sw), SLJIT_R0, 0);
4040         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 22 * sizeof(sljit_sw), SLJIT_R1, 0);
4041
4042         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 0x1c027b34);
4043         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, (sljit_sw)0xf2906b14);
4044         sljit_emit_op0(compiler, SLJIT_DIV_U32);
4045         sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_R0, 0, SLJIT_R0, 0);
4046         sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_R1, 0, SLJIT_R1, 0);
4047         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 23 * sizeof(sljit_sw), SLJIT_R0, 0);
4048         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 24 * sizeof(sljit_sw), SLJIT_R1, 0);
4049
4050         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 0x58a3f20d);
4051         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, -0xa63c923);
4052         sljit_emit_op0(compiler, SLJIT_DIV_S32);
4053         sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_R0, 0, SLJIT_R0, 0);
4054         sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_R1, 0, SLJIT_R1, 0);
4055         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 25 * sizeof(sljit_sw), SLJIT_R0, 0);
4056         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 26 * sizeof(sljit_sw), SLJIT_R1, 0);
4057 #endif
4058
4059         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R2, 0);
4060         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_R3, 0);
4061         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_R4, 0);
4062         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_S1, 0);
4063         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_S2, 0);
4064         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_S3, 0);
4065         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_sw), SLJIT_S4, 0);
4066
4067         sljit_emit_return_void(compiler);
4068
4069         code.code = sljit_generate_code(compiler);
4070         CHECK(compiler);
4071         sljit_free_compiler(compiler);
4072
4073         code.func1((sljit_sw)&buf);
4074
4075         FAILED(buf[0] != -0x1fb308a, "test42 case 1 failed\n");
4076         FAILED(buf[1] != 0xf50c873, "test42 case 2 failed\n");
4077         FAILED(buf[2] != 0x8a0475b, "test42 case 3 failed\n");
4078         FAILED(buf[3] != 0x9dc849b, "test42 case 4 failed\n");
4079         FAILED(buf[4] != -0x7c69a35, "test42 case 5 failed\n");
4080         FAILED(buf[5] != 0x5a4d0c4, "test42 case 6 failed\n");
4081         FAILED(buf[6] != 0x9a3b06d, "test42 case 7 failed\n");
4082
4083 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
4084         FAILED(buf[7] != SLJIT_W(-4388959407985636971), "test42 case 8 failed\n");
4085         FAILED(buf[8] != SLJIT_W(2901680654366567099), "test42 case 9 failed\n");
4086         FAILED(buf[9] != SLJIT_W(-4388959407985636971), "test42 case 10 failed\n");
4087         FAILED(buf[10] != SLJIT_W(-1677173957268872740), "test42 case 11 failed\n");
4088         FAILED(buf[11] != SLJIT_W(2), "test42 case 12 failed\n");
4089         FAILED(buf[12] != SLJIT_W(2532236178951865933), "test42 case 13 failed\n");
4090         FAILED(buf[13] != SLJIT_W(-1), "test42 case 14 failed\n");
4091         FAILED(buf[14] != SLJIT_W(-2177944059851366166), "test42 case 15 failed\n");
4092 #else
4093         FAILED(buf[7] != -1587000939, "test42 case 8 failed\n");
4094         FAILED(buf[8] != 665003983, "test42 case 9 failed\n");
4095         FAILED(buf[9] != -1587000939, "test42 case 10 failed\n");
4096         FAILED(buf[10] != -353198352, "test42 case 11 failed\n");
4097         FAILED(buf[11] != 2, "test42 case 12 failed\n");
4098         FAILED(buf[12] != 768706125, "test42 case 13 failed\n");
4099         FAILED(buf[13] != -1, "test42 case 14 failed\n");
4100         FAILED(buf[14] != -471654166, "test42 case 15 failed\n");
4101 #endif
4102
4103         FAILED(buf[15] != 56, "test42 case 16 failed\n");
4104         FAILED(buf[16] != 58392872, "test42 case 17 failed\n");
4105         FAILED(buf[17] != -47, "test42 case 18 failed\n");
4106         FAILED(buf[18] != 35949148, "test42 case 19 failed\n");
4107
4108 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
4109         FAILED(buf[19] != SLJIT_W(0x3340bfc), "test42 case 20 failed\n");
4110         FAILED(buf[20] != SLJIT_W(0x3d4af2c543), "test42 case 21 failed\n");
4111         FAILED(buf[21] != SLJIT_W(-0xaf978), "test42 case 22 failed\n");
4112         FAILED(buf[22] != SLJIT_W(0xa64ae42b7d6), "test42 case 23 failed\n");
4113 #else
4114         FAILED(buf[19] != SLJIT_W(0xda5), "test42 case 20 failed\n");
4115         FAILED(buf[20] != SLJIT_W(0xb86d0), "test42 case 21 failed\n");
4116         FAILED(buf[21] != SLJIT_W(-0x6b6e), "test42 case 22 failed\n");
4117         FAILED(buf[22] != SLJIT_W(0xd357), "test42 case 23 failed\n");
4118 #endif
4119
4120         FAILED(buf[23] != 0x0, "test42 case 24 failed\n");
4121         FAILED(buf[24] != (sljit_sw)0xf2906b14, "test42 case 25 failed\n");
4122         FAILED(buf[25] != -0x8, "test42 case 26 failed\n");
4123         FAILED(buf[26] != -0xa63c923, "test42 case 27 failed\n");
4124
4125         sljit_free_code(code.code, NULL);
4126         successful_tests++;
4127 }
4128
4129 static void test43(void)
4130 {
4131         /* Test floating point compare. */
4132         executable_code code;
4133         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
4134         struct sljit_jump* jump;
4135
4136         union {
4137                 sljit_f64 value;
4138                 struct {
4139                         sljit_u32 value1;
4140                         sljit_u32 value2;
4141                 } u;
4142         } dbuf[4];
4143
4144         if (verbose)
4145                 printf("Run test43\n");
4146
4147         if (!sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
4148                 if (verbose)
4149                         printf("no fpu available, test43 skipped\n");
4150                 successful_tests++;
4151                 if (compiler)
4152                         sljit_free_compiler(compiler);
4153                 return;
4154         }
4155
4156         FAILED(!compiler, "cannot create compiler\n");
4157
4158         dbuf[0].value = 12.125;
4159         /* a NaN */
4160         dbuf[1].u.value1 = 0x7fffffff;
4161         dbuf[1].u.value2 = 0x7fffffff;
4162         dbuf[2].value = -13.5;
4163         dbuf[3].value = 12.125;
4164
4165         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(W, P), 1, 1, 3, 0, 0);
4166         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 2);
4167         /* dbuf[0] < dbuf[2] -> -2 */
4168         jump = sljit_emit_fcmp(compiler, SLJIT_GREATER_EQUAL_F64, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_MEM2(SLJIT_S0, SLJIT_R0), SLJIT_F64_SHIFT);
4169         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_IMM, -2);
4170
4171         sljit_set_label(jump, sljit_emit_label(compiler));
4172         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S0), 0);
4173         /* dbuf[0] and dbuf[1] is not NaN -> 5 */
4174         jump = sljit_emit_fcmp(compiler, SLJIT_UNORDERED_F64, SLJIT_MEM0(), (sljit_sw)&dbuf[1], SLJIT_FR1, 0);
4175         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_IMM, 5);
4176
4177         sljit_set_label(jump, sljit_emit_label(compiler));
4178         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_f64));
4179         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, 11);
4180         /* dbuf[0] == dbuf[3] -> 11 */
4181         jump = sljit_emit_fcmp(compiler, SLJIT_EQUAL_F64, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_FR2, 0);
4182
4183         /* else -> -17 */
4184         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, -17);
4185         sljit_set_label(jump, sljit_emit_label(compiler));
4186         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);
4187
4188         code.code = sljit_generate_code(compiler);
4189         CHECK(compiler);
4190         sljit_free_compiler(compiler);
4191
4192         FAILED(code.func1((sljit_sw)&dbuf) != 11, "test43 case 1 failed\n");
4193         dbuf[3].value = 12;
4194         FAILED(code.func1((sljit_sw)&dbuf) != -17, "test43 case 2 failed\n");
4195         dbuf[1].value = 0;
4196         FAILED(code.func1((sljit_sw)&dbuf) != 5, "test43 case 3 failed\n");
4197         dbuf[2].value = 20;
4198         FAILED(code.func1((sljit_sw)&dbuf) != -2, "test43 case 4 failed\n");
4199
4200         sljit_free_code(code.code, NULL);
4201         successful_tests++;
4202 }
4203
4204 static void test44(void)
4205 {
4206         /* Test mov. */
4207         executable_code code;
4208         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
4209         void *buf[5];
4210
4211         if (verbose)
4212                 printf("Run test44\n");
4213
4214         FAILED(!compiler, "cannot create compiler\n");
4215
4216         buf[0] = buf + 2;
4217         buf[1] = NULL;
4218         buf[2] = NULL;
4219         buf[3] = NULL;
4220         buf[4] = NULL;
4221         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(P, P), 3, 2, 0, 0, 0);
4222
4223         sljit_emit_op1(compiler, SLJIT_MOV_P, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), 0);
4224         sljit_emit_op1(compiler, SLJIT_MOV_P, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_p), SLJIT_R0, 0);
4225         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, sizeof(sljit_p));
4226         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 2);
4227         sljit_emit_op1(compiler, SLJIT_MOV_P, SLJIT_MEM2(SLJIT_S0, SLJIT_R1), SLJIT_POINTER_SHIFT, SLJIT_R0, 0);
4228         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, sizeof(sljit_p));
4229         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 3 << SLJIT_POINTER_SHIFT);
4230         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_S0, 0);
4231         sljit_emit_op1(compiler, SLJIT_MOV_P, SLJIT_MEM2(SLJIT_R2, SLJIT_R1), 0, SLJIT_R0, 0);
4232         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 2 * sizeof(sljit_p));
4233         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 1 << SLJIT_POINTER_SHIFT);
4234         sljit_emit_op1(compiler, SLJIT_MOV_P, SLJIT_MEM2(SLJIT_R2, SLJIT_R1), 2, SLJIT_R0, 0);
4235
4236         sljit_emit_return(compiler, SLJIT_MOV_P, SLJIT_R0, 0);
4237
4238         code.code = sljit_generate_code(compiler);
4239         CHECK(compiler);
4240         sljit_free_compiler(compiler);
4241
4242         FAILED(code.func1((sljit_sw)&buf) != (sljit_sw)(buf + 2), "test44 case 1 failed\n");
4243         FAILED(buf[1] != buf + 2, "test44 case 2 failed\n");
4244         FAILED(buf[2] != buf + 3, "test44 case 3 failed\n");
4245         FAILED(buf[3] != buf + 4, "test44 case 4 failed\n");
4246         FAILED(buf[4] != buf + 2, "test44 case 5 failed\n");
4247
4248         sljit_free_code(code.code, NULL);
4249         successful_tests++;
4250 }
4251
4252 static void test45(void)
4253 {
4254         /* Test single precision floating point. */
4255
4256         executable_code code;
4257         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
4258         sljit_f32 buf[12];
4259         sljit_sw buf2[6];
4260         struct sljit_jump* jump;
4261
4262         if (verbose)
4263                 printf("Run test45\n");
4264
4265         if (!sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
4266                 if (verbose)
4267                         printf("no fpu available, test45 skipped\n");
4268                 successful_tests++;
4269                 if (compiler)
4270                         sljit_free_compiler(compiler);
4271                 return;
4272         }
4273
4274         FAILED(!compiler, "cannot create compiler\n");
4275
4276         buf[0] = 5.5;
4277         buf[1] = -7.25;
4278         buf[2] = 0;
4279         buf[3] = 0;
4280         buf[4] = 0;
4281         buf[5] = 0;
4282         buf[6] = 0;
4283         buf[7] = 8.75;
4284         buf[8] = 0;
4285         buf[9] = 16.5;
4286         buf[10] = 0;
4287         buf[11] = 0;
4288
4289         buf2[0] = -1;
4290         buf2[1] = -1;
4291         buf2[2] = -1;
4292         buf2[3] = -1;
4293         buf2[4] = -1;
4294         buf2[5] = -1;
4295
4296         sljit_emit_enter(compiler, 0, SLJIT_ARGS2(VOID, P, P), 3, 2, 6, 0, 0);
4297
4298         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S0), 0);
4299         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR5, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f32));
4300         sljit_emit_fop1(compiler, SLJIT_NEG_F32, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_f32), SLJIT_FR0, 0);
4301         sljit_emit_fop1(compiler, SLJIT_ABS_F32, SLJIT_FR1, 0, SLJIT_FR5, 0);
4302         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_f32), SLJIT_FR1, 0);
4303         sljit_emit_fop1(compiler, SLJIT_ABS_F32, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_f32), SLJIT_FR5, 0);
4304         sljit_emit_fop1(compiler, SLJIT_NEG_F32, SLJIT_FR4, 0, SLJIT_MEM1(SLJIT_S0), 0);
4305         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_f32), SLJIT_FR4, 0);
4306
4307         sljit_emit_fop2(compiler, SLJIT_ADD_F32, SLJIT_FR0, 0, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f32));
4308         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_f32), SLJIT_FR0, 0);
4309         sljit_emit_fop2(compiler, SLJIT_SUB_F32, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_f32), SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_f32), SLJIT_FR5, 0);
4310         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S0), 0);
4311         sljit_emit_fop2(compiler, SLJIT_MUL_F32, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_f32), SLJIT_FR0, 0, SLJIT_FR0, 0);
4312         sljit_emit_fop2(compiler, SLJIT_DIV_F32, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S0), 9 * sizeof(sljit_f32), SLJIT_FR0, 0);
4313         sljit_emit_fop1(compiler, SLJIT_ABS_F32, SLJIT_MEM1(SLJIT_S0), 9 * sizeof(sljit_f32), SLJIT_FR2, 0);
4314         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R0, 0, SLJIT_S0, 0, SLJIT_IMM, 0x3d0ac);
4315         sljit_emit_fop1(compiler, SLJIT_NEG_F32, SLJIT_MEM1(SLJIT_S0), 10 * sizeof(sljit_f32), SLJIT_MEM1(SLJIT_R0), 0x3d0ac);
4316         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_S0, 0, SLJIT_IMM, 0x3d0ac + sizeof(sljit_f32));
4317         sljit_emit_fop1(compiler, SLJIT_ABS_F32, SLJIT_MEM1(SLJIT_S0), 11 * sizeof(sljit_f32), SLJIT_MEM1(SLJIT_R0), -0x3d0ac);
4318
4319         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S0), 0);
4320         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f32));
4321         sljit_emit_fop1(compiler, SLJIT_CMP_F32 | SLJIT_SET_EQUAL_F, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S0), 0);
4322         cond_set(compiler, SLJIT_MEM1(SLJIT_S1), 0, SLJIT_EQUAL_F32);
4323         sljit_emit_fop1(compiler, SLJIT_CMP_F32 | SLJIT_SET_LESS_F, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S0), 0);
4324         cond_set(compiler, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_sw), SLJIT_LESS_F32);
4325         sljit_emit_fop1(compiler, SLJIT_CMP_F32 | SLJIT_SET_EQUAL_F, SLJIT_FR1, 0, SLJIT_FR2, 0);
4326         cond_set(compiler, SLJIT_MEM1(SLJIT_S1), 2 * sizeof(sljit_sw), SLJIT_EQUAL_F32);
4327         sljit_emit_fop1(compiler, SLJIT_CMP_F32 | SLJIT_SET_GREATER_EQUAL_F, SLJIT_FR1, 0, SLJIT_FR2, 0);
4328         cond_set(compiler, SLJIT_MEM1(SLJIT_S1), 3 * sizeof(sljit_sw), SLJIT_GREATER_EQUAL_F32);
4329
4330         jump = sljit_emit_fcmp(compiler, SLJIT_LESS_EQUAL_F32, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f32));
4331         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S1), 4 * sizeof(sljit_sw), SLJIT_IMM, 7);
4332         sljit_set_label(jump, sljit_emit_label(compiler));
4333
4334         jump = sljit_emit_fcmp(compiler, SLJIT_GREATER_F32, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_FR2, 0);
4335         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S1), 5 * sizeof(sljit_sw), SLJIT_IMM, 6);
4336         sljit_set_label(jump, sljit_emit_label(compiler));
4337
4338         sljit_emit_return_void(compiler);
4339
4340         code.code = sljit_generate_code(compiler);
4341         CHECK(compiler);
4342         sljit_free_compiler(compiler);
4343
4344         code.func2((sljit_sw)&buf, (sljit_sw)&buf2);
4345         FAILED(buf[2] != -5.5, "test45 case 1 failed\n");
4346         FAILED(buf[3] != 7.25, "test45 case 2 failed\n");
4347         FAILED(buf[4] != 7.25, "test45 case 3 failed\n");
4348         FAILED(buf[5] != -5.5, "test45 case 4 failed\n");
4349         FAILED(buf[6] != -1.75, "test45 case 5 failed\n");
4350         FAILED(buf[7] != 16.0, "test45 case 6 failed\n");
4351         FAILED(buf[8] != 30.25, "test45 case 7 failed\n");
4352         FAILED(buf[9] != 3, "test45 case 8 failed\n");
4353         FAILED(buf[10] != -5.5, "test45 case 9 failed\n");
4354         FAILED(buf[11] != 7.25, "test45 case 10 failed\n");
4355         FAILED(buf2[0] != 1, "test45 case 11 failed\n");
4356         FAILED(buf2[1] != 2, "test45 case 12 failed\n");
4357         FAILED(buf2[2] != 2, "test45 case 13 failed\n");
4358         FAILED(buf2[3] != 1, "test45 case 14 failed\n");
4359         FAILED(buf2[4] != 7, "test45 case 15 failed\n");
4360         FAILED(buf2[5] != -1, "test45 case 16 failed\n");
4361
4362         sljit_free_code(code.code, NULL);
4363         successful_tests++;
4364 }
4365
4366 static void test46(void)
4367 {
4368         /* Test sljit_emit_op_flags with 32 bit operations. */
4369
4370         executable_code code;
4371         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
4372         sljit_s32 buf[24];
4373         sljit_sw buf2[6];
4374         sljit_s32 i;
4375
4376         if (verbose)
4377                 printf("Run test46\n");
4378
4379         for (i = 0; i < 24; ++i)
4380                 buf[i] = -17;
4381         buf[16] = 0;
4382         for (i = 0; i < 6; ++i)
4383                 buf2[i] = -13;
4384         buf2[4] = -124;
4385
4386         sljit_emit_enter(compiler, 0, SLJIT_ARGS2(VOID, P, P), 3, 3, 0, 0, 0);
4387
4388         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, -7);
4389         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_Z | SLJIT_SET_LESS, SLJIT_R2, 0, SLJIT_IMM, 13);
4390         sljit_emit_op_flags(compiler, SLJIT_MOV32, SLJIT_MEM0(), (sljit_sw)&buf, SLJIT_LESS);
4391         sljit_emit_op_flags(compiler, SLJIT_AND32, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_s32), SLJIT_NOT_ZERO);
4392
4393         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_Z, SLJIT_R2, 0, SLJIT_IMM, -7);
4394         sljit_emit_op_flags(compiler, SLJIT_AND32 | SLJIT_SET_Z, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_s32), SLJIT_EQUAL);
4395         sljit_emit_op_flags(compiler, SLJIT_AND32, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_s32), SLJIT_NOT_EQUAL);
4396         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0x1235);
4397         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_Z, SLJIT_R0, 0, SLJIT_IMM, 0x1235);
4398         sljit_emit_op_flags(compiler, SLJIT_AND32 | SLJIT_SET_Z, SLJIT_R0, 0, SLJIT_ZERO);
4399         sljit_emit_op_flags(compiler, SLJIT_AND32, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_s32), SLJIT_ZERO);
4400         sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_MEM1(SLJIT_S0), 10 * sizeof(sljit_s32), SLJIT_R0, 0);
4401
4402         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_Z, SLJIT_R2, 0, SLJIT_IMM, -7);
4403         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 12);
4404         sljit_emit_op_flags(compiler, SLJIT_MOV32, SLJIT_MEM2(SLJIT_S0, SLJIT_R0), 2, SLJIT_EQUAL);
4405         sljit_emit_op_flags(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_EQUAL);
4406         sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_MEM1(SLJIT_S0), 14 * sizeof(sljit_s32), SLJIT_R0, 0);
4407         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 16);
4408         sljit_emit_op_flags(compiler, SLJIT_AND32 | SLJIT_SET_Z, SLJIT_MEM2(SLJIT_S0, SLJIT_R0), 2, SLJIT_EQUAL);
4409         sljit_emit_op_flags(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_S0), 18 * sizeof(sljit_s32), SLJIT_NOT_EQUAL);
4410
4411         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_Z, SLJIT_R2, 0, SLJIT_IMM, -7);
4412         sljit_emit_op_flags(compiler, SLJIT_XOR32 | SLJIT_SET_Z, SLJIT_MEM1(SLJIT_S0), 20 * sizeof(sljit_s32), SLJIT_ZERO);
4413         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 39);
4414         sljit_emit_op_flags(compiler, SLJIT_XOR32, SLJIT_R0, 0, SLJIT_NOT_ZERO);
4415         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_S0), 22 * sizeof(sljit_s32), SLJIT_R0, 0);
4416
4417         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_GREATER, SLJIT_R2, 0, SLJIT_IMM, -7);
4418         sljit_emit_op_flags(compiler, SLJIT_AND, SLJIT_MEM0(), (sljit_sw)&buf2, SLJIT_GREATER);
4419         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_SIG_LESS, SLJIT_R2, 0, SLJIT_IMM, 5);
4420         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 1);
4421         sljit_emit_op_flags(compiler, SLJIT_AND | SLJIT_SET_Z, SLJIT_MEM2(SLJIT_S1, SLJIT_R0), SLJIT_WORD_SHIFT, SLJIT_SIG_LESS);
4422         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 2);
4423         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_Z | SLJIT_SET_LESS, SLJIT_R2, 0, SLJIT_IMM, 5);
4424         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM2(SLJIT_S1, SLJIT_R0), SLJIT_WORD_SHIFT, SLJIT_LESS);
4425         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_NOT_EQUAL);
4426         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_SIG_LESS, SLJIT_R2, 0, SLJIT_IMM, 5);
4427         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S1), 3 * sizeof(sljit_sw), SLJIT_S2, 0);
4428         sljit_emit_op_flags(compiler, SLJIT_AND | SLJIT_SET_Z, SLJIT_MEM2(SLJIT_S1, SLJIT_R0), SLJIT_WORD_SHIFT, SLJIT_SIG_LESS);
4429         sljit_emit_op_flags(compiler, SLJIT_OR, SLJIT_MEM1(SLJIT_S1), 4 * sizeof(sljit_sw), SLJIT_ZERO);
4430         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_GREATER, SLJIT_R2, 0, SLJIT_IMM, 0);
4431         sljit_emit_op_flags(compiler, SLJIT_XOR, SLJIT_MEM1(SLJIT_S1), 5 * sizeof(sljit_sw), SLJIT_GREATER);
4432
4433         sljit_emit_return_void(compiler);
4434
4435         code.code = sljit_generate_code(compiler);
4436         CHECK(compiler);
4437         sljit_free_compiler(compiler);
4438
4439         code.func2((sljit_sw)&buf, (sljit_sw)&buf2);
4440         FAILED(buf[0] != 0, "test46 case 1 failed\n");
4441         FAILED(buf[1] != -17, "test46 case 2 failed\n");
4442         FAILED(buf[2] != 1, "test46 case 3 failed\n");
4443         FAILED(buf[3] != -17, "test46 case 4 failed\n");
4444         FAILED(buf[4] != 1, "test46 case 5 failed\n");
4445         FAILED(buf[5] != -17, "test46 case 6 failed\n");
4446         FAILED(buf[6] != 1, "test46 case 7 failed\n");
4447         FAILED(buf[7] != -17, "test46 case 8 failed\n");
4448         FAILED(buf[8] != 0, "test46 case 9 failed\n");
4449         FAILED(buf[9] != -17, "test46 case 10 failed\n");
4450         FAILED(buf[10] != 1, "test46 case 11 failed\n");
4451         FAILED(buf[11] != -17, "test46 case 12 failed\n");
4452         FAILED(buf[12] != 1, "test46 case 13 failed\n");
4453         FAILED(buf[13] != -17, "test46 case 14 failed\n");
4454         FAILED(buf[14] != 1, "test46 case 15 failed\n");
4455         FAILED(buf[15] != -17, "test46 case 16 failed\n");
4456         FAILED(buf[16] != 0, "test46 case 17 failed\n");
4457         FAILED(buf[17] != -17, "test46 case 18 failed\n");
4458         FAILED(buf[18] != 0, "test46 case 19 failed\n");
4459         FAILED(buf[19] != -17, "test46 case 20 failed\n");
4460         FAILED(buf[20] != -18, "test46 case 21 failed\n");
4461         FAILED(buf[21] != -17, "test46 case 22 failed\n");
4462         FAILED(buf[22] != 38, "test46 case 23 failed\n");
4463         FAILED(buf[23] != -17, "test46 case 24 failed\n");
4464
4465         FAILED(buf2[0] != 0, "test46 case 25 failed\n");
4466         FAILED(buf2[1] != 1, "test46 case 26 failed\n");
4467         FAILED(buf2[2] != 0, "test46 case 27 failed\n");
4468         FAILED(buf2[3] != 1, "test46 case 28 failed\n");
4469         FAILED(buf2[4] != -123, "test46 case 29 failed\n");
4470         FAILED(buf2[5] != -14, "test46 case 30 failed\n");
4471
4472         sljit_free_code(code.code, NULL);
4473         successful_tests++;
4474 }
4475
4476 static void test47(void)
4477 {
4478         /* Test jump optimizations. */
4479         executable_code code;
4480         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
4481         sljit_sw buf[3];
4482
4483         if (verbose)
4484                 printf("Run test47\n");
4485
4486         FAILED(!compiler, "cannot create compiler\n");
4487         buf[0] = 0;
4488         buf[1] = 0;
4489         buf[2] = 0;
4490
4491         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(W, P), 3, 1, 0, 0, 0);
4492         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0x3a5c6f);
4493         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_LESS, SLJIT_R0, 0, SLJIT_IMM, 3);
4494         sljit_set_target(sljit_emit_jump(compiler, SLJIT_LESS), 0x11223344);
4495         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0);
4496         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0xd37c10);
4497 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
4498         sljit_set_target(sljit_emit_jump(compiler, SLJIT_LESS), SLJIT_W(0x112233445566));
4499 #endif
4500         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_R0, 0);
4501         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0x59b48e);
4502 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
4503         sljit_set_target(sljit_emit_jump(compiler, SLJIT_LESS), SLJIT_W(0x1122334455667788));
4504 #endif
4505         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_R0, 0);
4506         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);
4507
4508         code.code = sljit_generate_code(compiler);
4509         CHECK(compiler);
4510         sljit_free_compiler(compiler);
4511
4512         FAILED(code.func1((sljit_sw)&buf) != 0x59b48e, "test47 case 1 failed\n");
4513         FAILED(buf[0] != 0x3a5c6f, "test47 case 2 failed\n");
4514         FAILED(buf[1] != 0xd37c10, "test47 case 3 failed\n");
4515         FAILED(buf[2] != 0x59b48e, "test47 case 4 failed\n");
4516
4517         sljit_free_code(code.code, NULL);
4518         successful_tests++;
4519 }
4520
4521 static void test48(void)
4522 {
4523         /* Test floating point conversions. */
4524         executable_code code;
4525         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
4526         int i;
4527         sljit_f64 dbuf[10];
4528         sljit_f32 sbuf[10];
4529         sljit_sw wbuf[10];
4530         sljit_s32 ibuf[10];
4531
4532         if (verbose)
4533                 printf("Run test48\n");
4534
4535         if (!sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
4536                 if (verbose)
4537                         printf("no fpu available, test48 skipped\n");
4538                 successful_tests++;
4539                 if (compiler)
4540                         sljit_free_compiler(compiler);
4541                 return;
4542         }
4543
4544         FAILED(!compiler, "cannot create compiler\n");
4545         for (i = 0; i < 10; i++) {
4546                 dbuf[i] = 0.0;
4547                 sbuf[i] = 0.0;
4548                 wbuf[i] = 0;
4549                 ibuf[i] = 0;
4550         }
4551
4552         dbuf[0] = 123.5;
4553         dbuf[1] = -367;
4554         dbuf[2] = 917.75;
4555
4556         sbuf[0] = 476.25;
4557         sbuf[1] = -1689.75;
4558
4559         wbuf[0] = 2345;
4560
4561         ibuf[0] = 312;
4562         ibuf[1] = -9324;
4563
4564         sljit_emit_enter(compiler, 0, SLJIT_ARGS0(VOID), 3, 3, 6, 0, 0);
4565         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, (sljit_sw)&dbuf);
4566         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_IMM, (sljit_sw)&sbuf);
4567         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, (sljit_sw)&wbuf);
4568         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, (sljit_sw)&ibuf);
4569
4570         /* sbuf[2] */
4571         sljit_emit_fop1(compiler, SLJIT_CONV_F32_FROM_F64, SLJIT_MEM1(SLJIT_S1), 2 * sizeof(sljit_f32), SLJIT_MEM1(SLJIT_S0), 0);
4572         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR5, 0, SLJIT_MEM1(SLJIT_S0), 0);
4573         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 3);
4574         /* sbuf[3] */
4575         sljit_emit_fop1(compiler, SLJIT_CONV_F32_FROM_F64, SLJIT_MEM2(SLJIT_S1, SLJIT_R0), SLJIT_F32_SHIFT, SLJIT_FR5, 0);
4576         sljit_emit_fop1(compiler, SLJIT_CONV_F64_FROM_F32, SLJIT_FR4, 0, SLJIT_MEM1(SLJIT_S1), 0);
4577         /* dbuf[3] */
4578         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_f64), SLJIT_FR4, 0);
4579         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR3, 0, SLJIT_MEM1(SLJIT_S1), 0);
4580         sljit_emit_fop1(compiler, SLJIT_CONV_F64_FROM_F32, SLJIT_FR2, 0, SLJIT_FR3, 0);
4581         /* dbuf[4] */
4582         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_f64), SLJIT_FR2, 0);
4583         /* sbuf[4] */
4584         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_S1), 4 * sizeof(sljit_f32), SLJIT_FR3, 0);
4585
4586         /* wbuf[1] */
4587         sljit_emit_fop1(compiler, SLJIT_CONV_SW_FROM_F64, SLJIT_MEM1(SLJIT_S2), sizeof(sljit_sw), SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64));
4588         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 2);
4589         sljit_emit_fop1(compiler, SLJIT_CONV_SW_FROM_F64, SLJIT_R0, 0, SLJIT_MEM2(SLJIT_S0, SLJIT_R0), SLJIT_F64_SHIFT);
4590         /* wbuf[2] */
4591         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S2), 2 * sizeof(sljit_sw), SLJIT_R0, 0);
4592         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR5, 0, SLJIT_MEM1(SLJIT_S1), 0);
4593         /* wbuf[3] */
4594         sljit_emit_fop1(compiler, SLJIT_CONV_SW_FROM_F32, SLJIT_MEM1(SLJIT_S2), 3 * sizeof(sljit_sw), SLJIT_FR5, 0);
4595         sljit_emit_fop1(compiler, SLJIT_NEG_F32, SLJIT_FR0, 0, SLJIT_FR5, 0);
4596         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 4);
4597         /* wbuf[4] */
4598         sljit_emit_fop1(compiler, SLJIT_CONV_SW_FROM_F32, SLJIT_MEM2(SLJIT_S2, SLJIT_R1), SLJIT_WORD_SHIFT, SLJIT_FR0, 0);
4599         sljit_emit_fop1(compiler, SLJIT_NEG_F64, SLJIT_FR4, 0, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_f64));
4600         /* ibuf[2] */
4601         sljit_emit_fop1(compiler, SLJIT_CONV_S32_FROM_F64, SLJIT_MEM1(SLJIT_R2), 2 * sizeof(sljit_s32), SLJIT_FR4, 0);
4602         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_f32));
4603         sljit_emit_fop1(compiler, SLJIT_CONV_S32_FROM_F32, SLJIT_R0, 0, SLJIT_FR1, 0);
4604         /* ibuf[3] */
4605         sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_MEM1(SLJIT_R2), 3 * sizeof(sljit_s32), SLJIT_R0, 0);
4606
4607         /* dbuf[5] */
4608         sljit_emit_fop1(compiler, SLJIT_CONV_F64_FROM_SW, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_f64), SLJIT_MEM1(SLJIT_S2), 0);
4609         sljit_emit_fop1(compiler, SLJIT_CONV_F64_FROM_SW, SLJIT_FR2, 0, SLJIT_IMM, -6213);
4610         /* dbuf[6] */
4611         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_f64), SLJIT_FR2, 0);
4612         /* dbuf[7] */
4613         sljit_emit_fop1(compiler, SLJIT_CONV_F64_FROM_S32, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_f64), SLJIT_MEM0(), (sljit_sw)&ibuf[0]);
4614         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_R2), sizeof(sljit_s32));
4615         sljit_emit_fop1(compiler, SLJIT_CONV_F64_FROM_S32, SLJIT_FR1, 0, SLJIT_R0, 0);
4616         /* dbuf[8] */
4617         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_f64), SLJIT_FR1, 0);
4618         /* dbuf[9] */
4619         sljit_emit_fop1(compiler, SLJIT_CONV_F64_FROM_SW, SLJIT_MEM0(), (sljit_sw)(dbuf + 9), SLJIT_IMM, -77);
4620         /* sbuf[5] */
4621         sljit_emit_fop1(compiler, SLJIT_CONV_F32_FROM_SW, SLJIT_MEM1(SLJIT_S1), 5 * sizeof(sljit_f32), SLJIT_IMM, -123);
4622         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 7190);
4623         sljit_emit_fop1(compiler, SLJIT_CONV_F32_FROM_SW, SLJIT_FR3, 0, SLJIT_R0, 0);
4624         /* sbuf[6] */
4625         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_S1), 6 * sizeof(sljit_f32), SLJIT_FR3, 0);
4626         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 123);
4627         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R1, 0, SLJIT_R2, 0, SLJIT_IMM, 123 * sizeof(sljit_s32));
4628         sljit_emit_fop1(compiler, SLJIT_CONV_F32_FROM_S32, SLJIT_FR1, 0, SLJIT_MEM2(SLJIT_R1, SLJIT_R0), 2);
4629         /* sbuf[7] */
4630         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_S1), 7 * sizeof(sljit_f32), SLJIT_FR1, 0);
4631         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 8);
4632         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, 3812);
4633         /* sbuf[8] */
4634         sljit_emit_fop1(compiler, SLJIT_CONV_F32_FROM_S32, SLJIT_MEM2(SLJIT_S1, SLJIT_R0), SLJIT_F32_SHIFT, SLJIT_R1, 0);
4635         /* sbuf[9] */
4636         sljit_emit_fop1(compiler, SLJIT_CONV_F32_FROM_SW, SLJIT_MEM0(), (sljit_sw)(sbuf + 9), SLJIT_IMM, -79);
4637
4638         sljit_emit_return_void(compiler);
4639
4640         code.code = sljit_generate_code(compiler);
4641         CHECK(compiler);
4642         sljit_free_compiler(compiler);
4643
4644         code.func0();
4645         FAILED(dbuf[3] != 476.25, "test48 case 1 failed\n");
4646         FAILED(dbuf[4] != 476.25, "test48 case 2 failed\n");
4647         FAILED(dbuf[5] != 2345.0, "test48 case 3 failed\n");
4648         FAILED(dbuf[6] != -6213.0, "test48 case 4 failed\n");
4649         FAILED(dbuf[7] != 312.0, "test48 case 5 failed\n");
4650         FAILED(dbuf[8] != -9324.0, "test48 case 6 failed\n");
4651         FAILED(dbuf[9] != -77.0, "test48 case 7 failed\n");
4652
4653         FAILED(sbuf[2] != 123.5, "test48 case 8 failed\n");
4654         FAILED(sbuf[3] != 123.5, "test48 case 9 failed\n");
4655         FAILED(sbuf[4] != 476.25, "test48 case 10 failed\n");
4656         FAILED(sbuf[5] != -123, "test48 case 11 failed\n");
4657         FAILED(sbuf[6] != 7190, "test48 case 12 failed\n");
4658         FAILED(sbuf[7] != 312, "test48 case 13 failed\n");
4659         FAILED(sbuf[8] != 3812, "test48 case 14 failed\n");
4660         FAILED(sbuf[9] != -79.0, "test48 case 15 failed\n");
4661
4662         FAILED(wbuf[1] != -367, "test48 case 16 failed\n");
4663         FAILED(wbuf[2] != 917, "test48 case 17 failed\n");
4664         FAILED(wbuf[3] != 476, "test48 case 18 failed\n");
4665         FAILED(wbuf[4] != -476, "test48 case 19 failed\n");
4666
4667         FAILED(ibuf[2] != -917, "test48 case 20 failed\n");
4668         FAILED(ibuf[3] != -1689, "test48 case 21 failed\n");
4669
4670         sljit_free_code(code.code, NULL);
4671         successful_tests++;
4672 }
4673
4674 static void test49(void)
4675 {
4676         /* Test floating point conversions. */
4677         executable_code code;
4678         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
4679         int i;
4680         sljit_f64 dbuf[10];
4681         sljit_f32 sbuf[9];
4682         sljit_sw wbuf[9];
4683         sljit_s32 ibuf[9];
4684         sljit_s32* dbuf_ptr = (sljit_s32*)dbuf;
4685         sljit_s32* sbuf_ptr = (sljit_s32*)sbuf;
4686
4687         if (verbose)
4688                 printf("Run test49\n");
4689
4690         if (!sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
4691                 if (verbose)
4692                         printf("no fpu available, test49 skipped\n");
4693                 successful_tests++;
4694                 if (compiler)
4695                         sljit_free_compiler(compiler);
4696                 return;
4697         }
4698
4699         FAILED(!compiler, "cannot create compiler\n");
4700
4701         for (i = 0; i < 9; i++) {
4702                 dbuf_ptr[i << 1] = -1;
4703                 dbuf_ptr[(i << 1) + 1] = -1;
4704                 sbuf_ptr[i] = -1;
4705                 wbuf[i] = -1;
4706                 ibuf[i] = -1;
4707         }
4708
4709 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
4710         dbuf[9] = (sljit_f64)SLJIT_W(0x1122334455);
4711 #endif
4712         dbuf[0] = 673.75;
4713         sbuf[0] = -879.75;
4714         wbuf[0] = 345;
4715         ibuf[0] = -249;
4716
4717         sljit_emit_enter(compiler, 0, SLJIT_ARGS0(VOID), 3, 3, 3, 0, 0);
4718         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, (sljit_sw)&dbuf);
4719         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_IMM, (sljit_sw)&sbuf);
4720         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, (sljit_sw)&wbuf);
4721         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, (sljit_sw)&ibuf);
4722
4723         /* dbuf[2] */
4724         sljit_emit_fop1(compiler, SLJIT_CONV_F64_FROM_F32, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_f64), SLJIT_MEM1(SLJIT_S1), 0);
4725         /* sbuf[2] */
4726         sljit_emit_fop1(compiler, SLJIT_CONV_F32_FROM_F64, SLJIT_MEM1(SLJIT_S1), 2 * sizeof(sljit_f32), SLJIT_MEM1(SLJIT_S0), 0);
4727         /* wbuf[2] */
4728         sljit_emit_fop1(compiler, SLJIT_CONV_SW_FROM_F64, SLJIT_MEM1(SLJIT_S2), 2 * sizeof(sljit_sw), SLJIT_MEM1(SLJIT_S0), 0);
4729         /* wbuf[4] */
4730         sljit_emit_fop1(compiler, SLJIT_CONV_SW_FROM_F32, SLJIT_MEM1(SLJIT_S2), 4 * sizeof(sljit_sw), SLJIT_MEM1(SLJIT_S1), 0);
4731         /* ibuf[2] */
4732         sljit_emit_fop1(compiler, SLJIT_CONV_S32_FROM_F64, SLJIT_MEM1(SLJIT_R2), 2 * sizeof(sljit_s32), SLJIT_MEM1(SLJIT_S0), 0);
4733         /* ibuf[4] */
4734         sljit_emit_fop1(compiler, SLJIT_CONV_S32_FROM_F32, SLJIT_MEM1(SLJIT_R2), 4 * sizeof(sljit_s32), SLJIT_MEM1(SLJIT_S1), 0);
4735         /* dbuf[4] */
4736         sljit_emit_fop1(compiler, SLJIT_CONV_F64_FROM_SW, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_f64), SLJIT_MEM1(SLJIT_S2), 0);
4737         /* sbuf[4] */
4738         sljit_emit_fop1(compiler, SLJIT_CONV_F32_FROM_SW, SLJIT_MEM1(SLJIT_S1), 4 * sizeof(sljit_f32), SLJIT_MEM1(SLJIT_S2), 0);
4739         /* dbuf[6] */
4740         sljit_emit_fop1(compiler, SLJIT_CONV_F64_FROM_S32, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_f64), SLJIT_MEM1(SLJIT_R2), 0);
4741         /* sbuf[6] */
4742         sljit_emit_fop1(compiler, SLJIT_CONV_F32_FROM_S32, SLJIT_MEM1(SLJIT_S1), 6 * sizeof(sljit_f32), SLJIT_MEM1(SLJIT_R2), 0);
4743
4744 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
4745         sljit_emit_fop1(compiler, SLJIT_CONV_SW_FROM_F64, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), 9 * sizeof(sljit_f64));
4746         /* wbuf[8] */
4747         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S2), 8 * sizeof(sljit_sw), SLJIT_R0, 0);
4748         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S0), 9 * sizeof(sljit_f64));
4749         sljit_emit_fop1(compiler, SLJIT_CONV_S32_FROM_F64, SLJIT_R0, 0, SLJIT_FR2, 0);
4750         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_R0, 0);
4751         sljit_emit_op2(compiler, SLJIT_AND32, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 0xffff);
4752         /* ibuf[8] */
4753         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_R2), 8 * sizeof(sljit_s32), SLJIT_R0, 0);
4754         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0x4455667788));
4755         /* dbuf[8] */
4756         sljit_emit_fop1(compiler, SLJIT_CONV_F64_FROM_SW, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_f64), SLJIT_R0, 0);
4757         /* dbuf[9] */
4758         sljit_emit_fop1(compiler, SLJIT_CONV_F64_FROM_S32, SLJIT_MEM1(SLJIT_S0), 9 * sizeof(sljit_f64), SLJIT_IMM, SLJIT_W(0x7766554433));
4759 #endif
4760
4761         sljit_emit_return_void(compiler);
4762
4763         code.code = sljit_generate_code(compiler);
4764         CHECK(compiler);
4765         sljit_free_compiler(compiler);
4766
4767         code.func0();
4768
4769         FAILED(dbuf_ptr[(1 * 2) + 0] != -1, "test49 case 1 failed\n");
4770         FAILED(dbuf_ptr[(1 * 2) + 1] != -1, "test49 case 2 failed\n");
4771         FAILED(dbuf[2] != -879.75, "test49 case 3 failed\n");
4772         FAILED(dbuf_ptr[(3 * 2) + 0] != -1, "test49 case 4 failed\n");
4773         FAILED(dbuf_ptr[(3 * 2) + 1] != -1, "test49 case 5 failed\n");
4774         FAILED(dbuf[4] != 345, "test49 case 6 failed\n");
4775         FAILED(dbuf_ptr[(5 * 2) + 0] != -1, "test49 case 7 failed\n");
4776         FAILED(dbuf_ptr[(5 * 2) + 1] != -1, "test49 case 8 failed\n");
4777         FAILED(dbuf[6] != -249, "test49 case 9 failed\n");
4778         FAILED(dbuf_ptr[(7 * 2) + 0] != -1, "test49 case 10 failed\n");
4779         FAILED(dbuf_ptr[(7 * 2) + 1] != -1, "test49 case 11 failed\n");
4780
4781         FAILED(sbuf_ptr[1] != -1, "test49 case 12 failed\n");
4782         FAILED(sbuf[2] != 673.75, "test49 case 13 failed\n");
4783         FAILED(sbuf_ptr[3] != -1, "test49 case 14 failed\n");
4784         FAILED(sbuf[4] != 345, "test49 case 15 failed\n");
4785         FAILED(sbuf_ptr[5] != -1, "test49 case 16 failed\n");
4786         FAILED(sbuf[6] != -249, "test49 case 17 failed\n");
4787         FAILED(sbuf_ptr[7] != -1, "test49 case 18 failed\n");
4788
4789         FAILED(wbuf[1] != -1, "test49 case 19 failed\n");
4790         FAILED(wbuf[2] != 673, "test49 case 20 failed\n");
4791         FAILED(wbuf[3] != -1, "test49 case 21 failed\n");
4792         FAILED(wbuf[4] != -879, "test49 case 22 failed\n");
4793         FAILED(wbuf[5] != -1, "test49 case 23 failed\n");
4794
4795         FAILED(ibuf[1] != -1, "test49 case 24 failed\n");
4796         FAILED(ibuf[2] != 673, "test49 case 25 failed\n");
4797         FAILED(ibuf[3] != -1, "test49 case 26 failed\n");
4798         FAILED(ibuf[4] != -879, "test49 case 27 failed\n");
4799         FAILED(ibuf[5] != -1, "test49 case 28 failed\n");
4800
4801 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
4802         FAILED(dbuf[8] != (sljit_f64)SLJIT_W(0x4455667788), "test49 case 29 failed\n");
4803         FAILED(dbuf[9] != (sljit_f64)SLJIT_W(0x66554433), "test49 case 30 failed\n");
4804         FAILED(wbuf[8] != SLJIT_W(0x1122334455), "test48 case 31 failed\n");
4805         FAILED(ibuf[8] == 0x4455, "test48 case 32 failed\n");
4806 #endif
4807
4808         sljit_free_code(code.code, NULL);
4809         successful_tests++;
4810 }
4811
4812 static void test50(void)
4813 {
4814         /* Test stack and floating point operations. */
4815         executable_code code;
4816         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
4817 #if !(defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86)
4818         sljit_uw size1, size2, size3;
4819         int result;
4820 #endif
4821         sljit_f32 sbuf[7];
4822
4823         if (verbose)
4824                 printf("Run test50\n");
4825
4826         if (!sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
4827                 if (verbose)
4828                         printf("no fpu available, test50 skipped\n");
4829                 successful_tests++;
4830                 if (compiler)
4831                         sljit_free_compiler(compiler);
4832                 return;
4833         }
4834
4835         FAILED(!compiler, "cannot create compiler\n");
4836
4837         sbuf[0] = 245.5;
4838         sbuf[1] = -100.25;
4839         sbuf[2] = 713.75;
4840
4841         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, P), 3, 3, 6, 0, 8 * sizeof(sljit_f32));
4842
4843         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), 0, SLJIT_MEM1(SLJIT_S0), 0);
4844         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_SP), sizeof(sljit_f32), SLJIT_MEM1(SLJIT_SP), 0);
4845         /* sbuf[3] */
4846         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_f32), SLJIT_MEM1(SLJIT_SP), sizeof(sljit_f32));
4847         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), sizeof(sljit_f32), SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f32));
4848         sljit_emit_fop2(compiler, SLJIT_ADD_F32, SLJIT_MEM1(SLJIT_SP), 2 * sizeof(sljit_f32), SLJIT_MEM1(SLJIT_SP), 0, SLJIT_MEM1(SLJIT_SP), sizeof(sljit_f32));
4849         /* sbuf[4] */
4850         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_f32), SLJIT_MEM1(SLJIT_SP), 2 * sizeof(sljit_f32));
4851         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), 2 * sizeof(sljit_f32), SLJIT_IMM, 5934);
4852         sljit_emit_fop1(compiler, SLJIT_CONV_F32_FROM_SW, SLJIT_MEM1(SLJIT_SP), 3 * sizeof(sljit_f32), SLJIT_MEM1(SLJIT_SP), 2 * sizeof(sljit_f32));
4853         /* sbuf[5] */
4854         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_f32), SLJIT_MEM1(SLJIT_SP), 3 * sizeof(sljit_f32));
4855
4856 #if !(defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86)
4857         size1 = compiler->size;
4858 #endif
4859         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_f32));
4860 #if !(defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86)
4861         size2 = compiler->size;
4862 #endif
4863         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR5, 0, SLJIT_FR2, 0);
4864 #if !(defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86)
4865         size3 = compiler->size;
4866 #endif
4867         /* sbuf[6] */
4868         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_f32), SLJIT_FR5, 0);
4869 #if !(defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86)
4870         result = (compiler->size - size3) == (size3 - size2) && (size3 - size2) == (size2 - size1);
4871 #endif
4872
4873         sljit_emit_return_void(compiler);
4874
4875         code.code = sljit_generate_code(compiler);
4876         CHECK(compiler);
4877         sljit_free_compiler(compiler);
4878
4879         code.func1((sljit_sw)&sbuf);
4880
4881         FAILED(sbuf[3] != 245.5, "test50 case 1 failed\n");
4882         FAILED(sbuf[4] != 145.25, "test50 case 2 failed\n");
4883         FAILED(sbuf[5] != 5934, "test50 case 3 failed\n");
4884         FAILED(sbuf[6] != 713.75, "test50 case 4 failed\n");
4885 #if !(defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86)
4886         FAILED(!result, "test50 case 5 failed\n");
4887 #endif
4888
4889         sljit_free_code(code.code, NULL);
4890         successful_tests++;
4891 }
4892
4893 static void test51(void)
4894 {
4895         /* Test all registers provided by the CPU. */
4896         executable_code code;
4897         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
4898         struct sljit_jump* jump;
4899         sljit_sw buf[2];
4900         sljit_s32 i;
4901
4902         if (verbose)
4903                 printf("Run test51\n");
4904
4905         FAILED(!compiler, "cannot create compiler\n");
4906
4907         buf[0] = 39;
4908
4909         sljit_emit_enter(compiler, 0, SLJIT_ARGS0(VOID), SLJIT_NUMBER_OF_REGISTERS, 0, 0, 0, 0);
4910
4911         for (i = 0; i < SLJIT_NUMBER_OF_REGISTERS; i++)
4912                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R(i), 0, SLJIT_IMM, 32);
4913
4914         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)buf);
4915         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0);
4916
4917         for (i = 2; i < SLJIT_NUMBER_OF_REGISTERS; i++) {
4918                 if (sljit_get_register_index(SLJIT_R(i)) >= 0) {
4919                         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R(i), 0, SLJIT_R0, 0);
4920                         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_R(i)), 0);
4921                 } else
4922                         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, buf[0]);
4923         }
4924
4925         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 32);
4926         for (i = 2; i < SLJIT_NUMBER_OF_REGISTERS; i++) {
4927                 if (sljit_get_register_index(SLJIT_R(i)) >= 0) {
4928                         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R(i), 0, SLJIT_R0, 0);
4929                         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_R(i)), 32);
4930                 } else
4931                         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, buf[0]);
4932         }
4933
4934         for (i = 2; i < SLJIT_NUMBER_OF_REGISTERS; i++) {
4935                 if (sljit_get_register_index(SLJIT_R(i)) >= 0) {
4936                         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R(i), 0, SLJIT_IMM, 32);
4937                         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_MEM2(SLJIT_R(i), SLJIT_R0), 0);
4938                         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_MEM2(SLJIT_R0, SLJIT_R(i)), 0);
4939                         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R(i), 0, SLJIT_IMM, 8);
4940                         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_MEM2(SLJIT_R0, SLJIT_R(i)), 2);
4941                 } else
4942                         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, 3 * buf[0]);
4943         }
4944
4945         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 32 + sizeof(sljit_sw), SLJIT_R1, 0);
4946
4947         sljit_emit_return_void(compiler);
4948
4949         code.code = sljit_generate_code(compiler);
4950         CHECK(compiler);
4951         sljit_free_compiler(compiler);
4952
4953         code.func0();
4954
4955         FAILED(buf[1] != (39 * 5 * (SLJIT_NUMBER_OF_REGISTERS - 2)), "test51 case 1 failed\n");
4956
4957         sljit_free_code(code.code, NULL);
4958
4959         /* Next test. */
4960
4961         compiler = sljit_create_compiler(NULL, NULL);
4962
4963         FAILED(!compiler, "cannot create compiler\n");
4964
4965         sljit_emit_enter(compiler, 0, SLJIT_ARGS0(W), SLJIT_NUMBER_OF_SCRATCH_REGISTERS, SLJIT_NUMBER_OF_SAVED_REGISTERS, 0, 0, 0);
4966
4967         for (i = 0; i < SLJIT_NUMBER_OF_REGISTERS; i++)
4968                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R(i), 0, SLJIT_IMM, 17);
4969
4970         jump = sljit_emit_call(compiler, SLJIT_CALL, SLJIT_ARGS0(W));
4971         /* SLJIT_R0 contains the first value. */
4972         for (i = 1; i < SLJIT_NUMBER_OF_REGISTERS; i++)
4973                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_R(i), 0);
4974
4975         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_R0, 0);
4976
4977         sljit_set_label(jump, sljit_emit_label(compiler));
4978         sljit_emit_enter(compiler, 0, SLJIT_ARGS0(VOID), SLJIT_NUMBER_OF_REGISTERS, 0, 0, 0, 0);
4979         for (i = 0; i < SLJIT_NUMBER_OF_REGISTERS; i++)
4980                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R(i), 0, SLJIT_IMM, 35);
4981         sljit_emit_return_void(compiler);
4982
4983         code.code = sljit_generate_code(compiler);
4984         CHECK(compiler);
4985         sljit_free_compiler(compiler);
4986
4987         FAILED(code.func0() != (SLJIT_NUMBER_OF_SCRATCH_REGISTERS * 35 + SLJIT_NUMBER_OF_SAVED_REGISTERS * 17), "test51 case 2 failed\n");
4988
4989         sljit_free_code(code.code, NULL);
4990
4991         /* Next test. */
4992
4993         compiler = sljit_create_compiler(NULL, NULL);
4994
4995         FAILED(!compiler, "cannot create compiler\n");
4996
4997         sljit_emit_enter(compiler, 0, SLJIT_ARGS0(W), SLJIT_NUMBER_OF_SCRATCH_REGISTERS, SLJIT_NUMBER_OF_SAVED_REGISTERS, 0, 0, 0);
4998
4999         for (i = 0; i < SLJIT_NUMBER_OF_SCRATCH_REGISTERS; i++)
5000                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R(i), 0, SLJIT_IMM, 68);
5001         for (i = 0; i < SLJIT_NUMBER_OF_SAVED_REGISTERS; i++)
5002                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S(i), 0, SLJIT_IMM, 68);
5003
5004         jump = sljit_emit_call(compiler, SLJIT_CALL, SLJIT_ARGS0(W));
5005         /* SLJIT_R0 contains the first value. */
5006         for (i = 1; i < SLJIT_NUMBER_OF_REGISTERS; i++)
5007                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_R(i), 0);
5008
5009         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_R0, 0);
5010
5011         sljit_set_label(jump, sljit_emit_label(compiler));
5012         sljit_emit_enter(compiler, 0, SLJIT_ARGS0(VOID), SLJIT_NUMBER_OF_REGISTERS, 0, 0, 0, 0);
5013         for (i = 0; i < SLJIT_NUMBER_OF_REGISTERS; i++)
5014                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R(i), 0, SLJIT_IMM, 43);
5015         sljit_emit_return_void(compiler);
5016
5017         code.code = sljit_generate_code(compiler);
5018         CHECK(compiler);
5019         sljit_free_compiler(compiler);
5020
5021         FAILED(code.func0() != (SLJIT_NUMBER_OF_SCRATCH_REGISTERS * 43 + SLJIT_NUMBER_OF_SAVED_REGISTERS * 68), "test51 case 3 failed\n");
5022
5023         sljit_free_code(code.code, NULL);
5024         successful_tests++;
5025 }
5026
5027 static void test52(void)
5028 {
5029         /* Test all registers provided by the CPU. */
5030         executable_code code;
5031         struct sljit_compiler* compiler;
5032         struct sljit_jump* jump;
5033         sljit_f64 buf[3];
5034         sljit_s32 i;
5035
5036         if (verbose)
5037                 printf("Run test52\n");
5038
5039         if (!sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
5040                 if (verbose)
5041                         printf("no fpu available, test52 skipped\n");
5042                 successful_tests++;
5043                 return;
5044         }
5045
5046         /* Next test. */
5047
5048         compiler = sljit_create_compiler(NULL, NULL);
5049         FAILED(!compiler, "cannot create compiler\n");
5050         buf[0] = 6.25;
5051         buf[1] = 17.75;
5052
5053         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, P), 0, 1, SLJIT_NUMBER_OF_SCRATCH_FLOAT_REGISTERS, SLJIT_NUMBER_OF_SAVED_FLOAT_REGISTERS, 0);
5054
5055         for (i = 0; i < SLJIT_NUMBER_OF_FLOAT_REGISTERS; i++)
5056                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR(i), 0, SLJIT_MEM1(SLJIT_S0), 0);
5057
5058         jump = sljit_emit_call(compiler, SLJIT_CALL, SLJIT_ARGS0(VOID));
5059         /* SLJIT_FR0 contains the first value. */
5060         for (i = 1; i < SLJIT_NUMBER_OF_FLOAT_REGISTERS; i++)
5061                 sljit_emit_fop2(compiler, SLJIT_ADD_F64, SLJIT_FR0, 0, SLJIT_FR0, 0, SLJIT_FR(i), 0);
5062         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_f64), SLJIT_FR0, 0);
5063
5064         sljit_emit_return_void(compiler);
5065
5066         sljit_set_label(jump, sljit_emit_label(compiler));
5067         sljit_emit_enter(compiler, 0, SLJIT_ARGS0(VOID), 1, 0, SLJIT_NUMBER_OF_FLOAT_REGISTERS, 0, 0);
5068         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&buf[1]);
5069         for (i = 0; i < SLJIT_NUMBER_OF_FLOAT_REGISTERS; i++)
5070                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR(i), 0, SLJIT_MEM1(SLJIT_R0), 0);
5071         sljit_emit_return_void(compiler);
5072
5073         code.code = sljit_generate_code(compiler);
5074         CHECK(compiler);
5075         sljit_free_compiler(compiler);
5076
5077         code.func1((sljit_sw)&buf);
5078         FAILED(buf[2] != (SLJIT_NUMBER_OF_SCRATCH_FLOAT_REGISTERS * 17.75 + SLJIT_NUMBER_OF_SAVED_FLOAT_REGISTERS * 6.25), "test52 case 1 failed\n");
5079
5080         sljit_free_code(code.code, NULL);
5081
5082         /* Next test. */
5083
5084         compiler = sljit_create_compiler(NULL, NULL);
5085         FAILED(!compiler, "cannot create compiler\n");
5086         buf[0] = -32.5;
5087         buf[1] = -11.25;
5088
5089         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, P), 0, 1, SLJIT_NUMBER_OF_SCRATCH_FLOAT_REGISTERS, SLJIT_NUMBER_OF_SAVED_FLOAT_REGISTERS, 0);
5090
5091         for (i = 0; i < SLJIT_NUMBER_OF_SCRATCH_FLOAT_REGISTERS; i++)
5092                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR(i), 0, SLJIT_MEM1(SLJIT_S0), 0);
5093         for (i = 0; i < SLJIT_NUMBER_OF_SAVED_FLOAT_REGISTERS; i++)
5094                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FS(i), 0, SLJIT_MEM1(SLJIT_S0), 0);
5095
5096         jump = sljit_emit_call(compiler, SLJIT_CALL, SLJIT_ARGS0(VOID));
5097         /* SLJIT_FR0 contains the first value. */
5098         for (i = 1; i < SLJIT_NUMBER_OF_FLOAT_REGISTERS; i++)
5099                 sljit_emit_fop2(compiler, SLJIT_ADD_F64, SLJIT_FR0, 0, SLJIT_FR0, 0, SLJIT_FR(i), 0);
5100         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_f64), SLJIT_FR0, 0);
5101
5102         sljit_emit_return_void(compiler);
5103
5104         sljit_set_label(jump, sljit_emit_label(compiler));
5105         sljit_emit_enter(compiler, 0, SLJIT_ARGS0(VOID), 1, 0, SLJIT_NUMBER_OF_FLOAT_REGISTERS, 0, 0);
5106         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&buf[1]);
5107         for (i = 0; i < SLJIT_NUMBER_OF_FLOAT_REGISTERS; i++)
5108                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR(i), 0, SLJIT_MEM1(SLJIT_R0), 0);
5109         sljit_emit_return_void(compiler);
5110
5111         code.code = sljit_generate_code(compiler);
5112         CHECK(compiler);
5113         sljit_free_compiler(compiler);
5114
5115         code.func1((sljit_sw)&buf);
5116         FAILED(buf[2] != (SLJIT_NUMBER_OF_SCRATCH_FLOAT_REGISTERS * -11.25 + SLJIT_NUMBER_OF_SAVED_FLOAT_REGISTERS * -32.5), "test52 case 2 failed\n");
5117
5118         sljit_free_code(code.code, NULL);
5119         successful_tests++;
5120 }
5121
5122 static void test53(void)
5123 {
5124         /* Check cdecl calls. */
5125         executable_code code;
5126         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
5127         sljit_sw buf[3];
5128
5129         if (verbose)
5130                 printf("Run test53\n");
5131
5132         FAILED(!compiler, "cannot create compiler\n");
5133         buf[0] = -1;
5134
5135         sljit_emit_enter(compiler, SLJIT_ENTER_CDECL, SLJIT_ARGS3(VOID, W, W, W), 1, 3, 0, 0, 2 * sizeof(sljit_sw));
5136
5137         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)buf);
5138         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_S0, 0);
5139         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_sw), SLJIT_S1, 0);
5140         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 2 * sizeof(sljit_sw), SLJIT_S2, 0);
5141
5142         sljit_emit_return_void(compiler);
5143
5144         code.code = sljit_generate_code(compiler);
5145         CHECK(compiler);
5146         sljit_free_compiler(compiler);
5147
5148         code.test53_f1(7895, -3812, 4087);
5149
5150         FAILED(buf[0] != 7895, "test53 case 1 failed\n");
5151         FAILED(buf[1] != -3812, "test53 case 2 failed\n");
5152         FAILED(buf[2] != 4087, "test53 case 3 failed\n");
5153
5154         sljit_free_code(code.code, NULL);
5155
5156         successful_tests++;
5157 }
5158
5159 static void test54(void)
5160 {
5161         /* Check cmov. */
5162         executable_code code;
5163         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
5164 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
5165         sljit_sw large_num = SLJIT_W(0x1234567812345678);
5166 #else
5167         sljit_sw large_num = SLJIT_W(0x12345678);
5168 #endif
5169         int i;
5170         sljit_sw buf[19];
5171         sljit_s32 ibuf[4];
5172
5173         union {
5174                 sljit_f32 value;
5175                 sljit_s32 s32_value;
5176         } sbuf[3];
5177
5178         sbuf[0].s32_value = 0x7fffffff;
5179         sbuf[1].value = 7.5;
5180         sbuf[2].value = -14.75;
5181
5182         if (verbose)
5183                 printf("Run test54\n");
5184
5185         FAILED(!compiler, "cannot create compiler\n");
5186
5187         for (i = 0; i < 19; i++)
5188                 buf[i] = 0;
5189         for (i = 0; i < 4; i++)
5190                 ibuf[i] = 0;
5191
5192         sljit_emit_enter(compiler, 0, SLJIT_ARGS3(VOID, P, P, P), 5, 3, 3, 0, 0);
5193
5194         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 17);
5195         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 34);
5196         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_SIG_LESS, SLJIT_R0, 0, SLJIT_IMM, -10);
5197         sljit_emit_cmov(compiler, SLJIT_SIG_LESS, SLJIT_R0, SLJIT_R1, 0);
5198         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0);
5199         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_SIG_GREATER, SLJIT_R0, 0, SLJIT_IMM, -10);
5200         sljit_emit_cmov(compiler, SLJIT_SIG_GREATER, SLJIT_R0, SLJIT_R1, 0);
5201         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_R0, 0);
5202
5203         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 24);
5204         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_Z, SLJIT_R0, 0, SLJIT_IMM, 24);
5205         sljit_emit_cmov(compiler, SLJIT_NOT_EQUAL, SLJIT_R0, SLJIT_IMM, 66);
5206         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_R0, 0);
5207         sljit_emit_cmov(compiler, SLJIT_EQUAL, SLJIT_R0, SLJIT_IMM, 78);
5208         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_R0, 0);
5209         sljit_emit_cmov(compiler, SLJIT_EQUAL, SLJIT_R0, SLJIT_IMM, large_num);
5210         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_R0, 0);
5211
5212 #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
5213         SLJIT_ASSERT(sljit_get_register_index(SLJIT_R3) == -1 && sljit_get_register_index(SLJIT_R4) == -1);
5214 #endif
5215         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 7);
5216         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, -45);
5217         sljit_emit_op2(compiler, SLJIT_MUL | SLJIT_SET_OVERFLOW, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, 8);
5218         sljit_emit_cmov(compiler, SLJIT_OVERFLOW, SLJIT_R3, SLJIT_IMM, 35);
5219         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_R3, 0);
5220         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, large_num);
5221         sljit_emit_op2u(compiler, SLJIT_MUL | SLJIT_SET_OVERFLOW, SLJIT_R0, 0, SLJIT_IMM, large_num);
5222         sljit_emit_cmov(compiler, SLJIT_OVERFLOW, SLJIT_R3, SLJIT_IMM, 35);
5223         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_sw), SLJIT_R3, 0);
5224
5225         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 71);
5226         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, 13);
5227         sljit_emit_op2(compiler, SLJIT_LSHR | SLJIT_SET_Z, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, 8);
5228         sljit_emit_cmov(compiler, SLJIT_EQUAL, SLJIT_R3, SLJIT_R0, 0);
5229         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_sw), SLJIT_R3, 0);
5230
5231         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 12);
5232         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, -29);
5233         sljit_emit_op2(compiler, SLJIT_MUL | SLJIT_SET_OVERFLOW, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 8);
5234         sljit_emit_cmov(compiler, SLJIT_NOT_OVERFLOW, SLJIT_R0, SLJIT_R3, 0);
5235         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_sw), SLJIT_R3, 0);
5236
5237         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 16);
5238         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, -12);
5239         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R4, 0, SLJIT_IMM, 21);
5240         sljit_emit_op2u(compiler, SLJIT_AND | SLJIT_SET_Z, SLJIT_R0, 0, SLJIT_IMM, 8);
5241         sljit_emit_cmov(compiler, SLJIT_NOT_EQUAL, SLJIT_R3, SLJIT_R4, 0);
5242         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 9 * sizeof(sljit_sw), SLJIT_R3, 0);
5243         sljit_emit_cmov(compiler, SLJIT_EQUAL, SLJIT_R3, SLJIT_R4, 0);
5244         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 10 * sizeof(sljit_sw), SLJIT_R3, 0);
5245
5246         if (sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
5247                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S2), 0);
5248                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S2), sizeof(sljit_f32));
5249                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S2), 2 * sizeof(sljit_f32));
5250
5251                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 16);
5252                 sljit_emit_fop1(compiler, SLJIT_CMP_F32 | SLJIT_SET_EQUAL_F, SLJIT_FR1, 0, SLJIT_FR2, 0);
5253                 sljit_emit_cmov(compiler, SLJIT_EQUAL_F32, SLJIT_R0, SLJIT_IMM, -45);
5254                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 11 * sizeof(sljit_sw), SLJIT_R0, 0);
5255                 sljit_emit_fop1(compiler, SLJIT_CMP_F32 | SLJIT_SET_GREATER_F, SLJIT_FR1, 0, SLJIT_FR2, 0);
5256                 sljit_emit_cmov(compiler, SLJIT_GREATER_F32, SLJIT_R0, SLJIT_IMM, -45);
5257                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 12 * sizeof(sljit_sw), SLJIT_R0, 0);
5258                 sljit_emit_fop1(compiler, SLJIT_CMP_F32 | SLJIT_SET_GREATER_EQUAL_F, SLJIT_FR1, 0, SLJIT_FR2, 0);
5259                 sljit_emit_cmov(compiler, SLJIT_GREATER_EQUAL_F32, SLJIT_R0, SLJIT_IMM, 33);
5260                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 13 * sizeof(sljit_sw), SLJIT_R0, 0);
5261
5262                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 8);
5263                 sljit_emit_fop1(compiler, SLJIT_CMP_F32 | SLJIT_SET_LESS_F, SLJIT_FR1, 0, SLJIT_FR2, 0);
5264                 sljit_emit_cmov(compiler, SLJIT_LESS_F32, SLJIT_R0, SLJIT_IMM, -70);
5265                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 14 * sizeof(sljit_sw), SLJIT_R0, 0);
5266                 sljit_emit_fop1(compiler, SLJIT_CMP_F32 | SLJIT_SET_LESS_EQUAL_F, SLJIT_FR2, 0, SLJIT_FR1, 0);
5267                 sljit_emit_cmov(compiler, SLJIT_LESS_EQUAL_F32, SLJIT_R0, SLJIT_IMM, -60);
5268                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 15 * sizeof(sljit_sw), SLJIT_R0, 0);
5269                 sljit_emit_fop1(compiler, SLJIT_CMP_F32 | SLJIT_SET_NOT_EQUAL_F, SLJIT_FR1, 0, SLJIT_FR2, 0);
5270                 sljit_emit_cmov(compiler, SLJIT_NOT_EQUAL_F32, SLJIT_R0, SLJIT_IMM, 31);
5271                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 16 * sizeof(sljit_sw), SLJIT_R0, 0);
5272
5273                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 53);
5274                 sljit_emit_fop1(compiler, SLJIT_CMP_F32 | SLJIT_SET_ORDERED_F, SLJIT_FR1, 0, SLJIT_FR0, 0);
5275                 sljit_emit_cmov(compiler, SLJIT_ORDERED_F32, SLJIT_R0, SLJIT_IMM, 17);
5276                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 17 * sizeof(sljit_sw), SLJIT_R0, 0);
5277                 sljit_emit_fop1(compiler, SLJIT_CMP_F32 | SLJIT_SET_UNORDERED_F, SLJIT_FR1, 0, SLJIT_FR0, 0);
5278                 sljit_emit_cmov(compiler, SLJIT_UNORDERED_F32, SLJIT_R0, SLJIT_IMM, 59);
5279                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 18 * sizeof(sljit_sw), SLJIT_R0, 0);
5280         }
5281
5282         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 177);
5283         sljit_emit_op2u(compiler, SLJIT_SUB32 | SLJIT_SET_LESS, SLJIT_R0, 0, SLJIT_IMM, 178);
5284         sljit_emit_cmov(compiler, SLJIT_LESS, SLJIT_R0 | SLJIT_32, SLJIT_IMM, 200);
5285         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_S1), 0, SLJIT_R0, 0);
5286
5287         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 95);
5288         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R3, 0, SLJIT_IMM, 177);
5289         sljit_emit_op2u(compiler, SLJIT_SUB32 | SLJIT_SET_LESS_EQUAL, SLJIT_R0, 0, SLJIT_IMM, 95);
5290         sljit_emit_cmov(compiler, SLJIT_LESS_EQUAL, SLJIT_R3 | SLJIT_32, SLJIT_R0, 0);
5291         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 0);
5292         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_s32), SLJIT_R3, 0);
5293
5294         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R3, 0, SLJIT_IMM, 56);
5295         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R4, 0, SLJIT_IMM, -63);
5296         sljit_emit_op2u(compiler, SLJIT_SUB32 | SLJIT_SET_SIG_LESS, SLJIT_R3, 0, SLJIT_R4, 0);
5297         sljit_emit_cmov(compiler, SLJIT_SIG_LESS, SLJIT_R3 | SLJIT_32, SLJIT_R4, 0);
5298         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_S1), 2 * sizeof(sljit_s32), SLJIT_R3, 0);
5299         sljit_emit_op2u(compiler, SLJIT_SUB32 | SLJIT_SET_SIG_GREATER, SLJIT_R3, 0, SLJIT_R4, 0);
5300         sljit_emit_cmov(compiler, SLJIT_SIG_GREATER, SLJIT_R3 | SLJIT_32, SLJIT_R4, 0);
5301         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_S1), 3 * sizeof(sljit_s32), SLJIT_R3, 0);
5302
5303         sljit_emit_return_void(compiler);
5304
5305         code.code = sljit_generate_code(compiler);
5306         CHECK(compiler);
5307         sljit_free_compiler(compiler);
5308
5309         code.func3((sljit_sw)&buf, (sljit_sw)&ibuf, (sljit_sw)&sbuf);
5310
5311         FAILED(buf[0] != 17, "test54 case 1 failed\n");
5312         FAILED(buf[1] != 34, "test54 case 2 failed\n");
5313         FAILED(buf[2] != 24, "test54 case 3 failed\n");
5314         FAILED(buf[3] != 78, "test54 case 4 failed\n");
5315         FAILED(buf[4] != large_num, "test54 case 5 failed\n");
5316         FAILED(buf[5] != -45, "test54 case 6 failed\n");
5317         FAILED(buf[6] != 35, "test54 case 7 failed\n");
5318         FAILED(buf[7] != 71, "test54 case 8 failed\n");
5319         FAILED(buf[8] != -29, "test54 case 9 failed\n");
5320         FAILED(buf[9] != -12, "test54 case 10 failed\n");
5321         FAILED(buf[10] != 21, "test54 case 11 failed\n");
5322
5323         if (sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
5324                 FAILED(buf[11] != 16, "test54 case 12 failed\n");
5325                 FAILED(buf[12] != -45, "test54 case 13 failed\n");
5326                 FAILED(buf[13] != 33, "test54 case 14 failed\n");
5327                 FAILED(buf[14] != 8, "test54 case 15 failed\n");
5328                 FAILED(buf[15] != -60, "test54 case 16 failed\n");
5329                 FAILED(buf[16] != 31, "test54 case 17 failed\n");
5330                 FAILED(buf[17] != 53, "test54 case 18 failed\n");
5331                 FAILED(buf[18] != 59, "test54 case 19 failed\n");
5332         }
5333
5334         FAILED(ibuf[0] != 200, "test54 case 12 failed\n");
5335         FAILED(ibuf[1] != 95, "test54 case 13 failed\n");
5336         FAILED(ibuf[2] != 56, "test54 case 14 failed\n");
5337         FAILED(ibuf[3] != -63, "test54 case 15 failed\n");
5338
5339         sljit_free_code(code.code, NULL);
5340         successful_tests++;
5341 }
5342
5343 static void test55(void)
5344 {
5345         /* Check value preservation. */
5346         executable_code code;
5347         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
5348         sljit_sw buf[2];
5349         sljit_s32 i;
5350
5351         if (verbose)
5352                 printf("Run test55\n");
5353
5354         FAILED(!compiler, "cannot create compiler\n");
5355         buf[0] = 0;
5356         buf[1] = 0;
5357
5358         sljit_emit_enter(compiler, 0, SLJIT_ARGS0(VOID), SLJIT_NUMBER_OF_REGISTERS, 0, 0, 0, sizeof (sljit_sw));
5359
5360         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), 0, SLJIT_IMM, 217);
5361
5362         /* Check 1 */
5363         for (i = 0; i < SLJIT_NUMBER_OF_REGISTERS; i++)
5364                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R(i), 0, SLJIT_IMM, 118);
5365
5366         sljit_emit_op0(compiler, SLJIT_DIVMOD_SW);
5367
5368         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0);
5369
5370         for (i = 2; i < SLJIT_NUMBER_OF_REGISTERS; i++)
5371                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_R(i), 0);
5372         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_SP), 0);
5373
5374         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM0(), (sljit_sw)(buf + 0), SLJIT_R0, 0);
5375
5376         /* Check 2 */
5377         for (i = 0; i < SLJIT_NUMBER_OF_REGISTERS; i++)
5378                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R(i), 0, SLJIT_IMM, 146);
5379
5380         sljit_emit_op0(compiler, SLJIT_DIV_SW);
5381
5382         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0);
5383
5384         for (i = 1; i < SLJIT_NUMBER_OF_REGISTERS; i++)
5385                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_R(i), 0);
5386         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_SP), 0);
5387
5388         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM0(), (sljit_sw)(buf + 1), SLJIT_R0, 0);
5389
5390         sljit_emit_return_void(compiler);
5391
5392         code.code = sljit_generate_code(compiler);
5393         CHECK(compiler);
5394         sljit_free_compiler(compiler);
5395
5396         code.func0();
5397
5398         FAILED(buf[0] != (SLJIT_NUMBER_OF_REGISTERS - 2) * 118 + 217, "test55 case 1 failed\n");
5399         FAILED(buf[1] != (SLJIT_NUMBER_OF_REGISTERS - 1) * 146 + 217, "test55 case 2 failed\n");
5400
5401         sljit_free_code(code.code, NULL);
5402         successful_tests++;
5403 }
5404
5405 static void test56(void)
5406 {
5407         /* Check integer substraction with negative immediate. */
5408         executable_code code;
5409         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
5410         sljit_sw buf[13];
5411         sljit_s32 i;
5412
5413         if (verbose)
5414                 printf("Run test56\n");
5415
5416         for (i = 0; i < 13; i++)
5417                 buf[i] = 77;
5418
5419         FAILED(!compiler, "cannot create compiler\n");
5420
5421         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, P), 3, 1, 0, 0, 0);
5422
5423         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 90 << 12);
5424         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_SIG_GREATER, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, -(91 << 12));
5425         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R1, 0);
5426         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_SIG_GREATER);
5427         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_LESS, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, -(91 << 12));
5428         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_R1, 0);
5429         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_LESS);
5430         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_SIG_GREATER_EQUAL, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, -(91 << 12));
5431         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_SIG_GREATER_EQUAL);
5432         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, -(91 << 12));
5433         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_LESS_EQUAL);
5434         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_GREATER, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, -(91 << 12));
5435         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_sw), SLJIT_GREATER);
5436         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_SIG_LESS, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, -(91 << 12));
5437         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_sw), SLJIT_SIG_LESS);
5438
5439         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 90);
5440         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_SIG_GREATER, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, -91);
5441         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_sw), SLJIT_R0, 0);
5442         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 9 * sizeof(sljit_sw), SLJIT_SIG_GREATER);
5443         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 90);
5444         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, -91);
5445         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 10 * sizeof(sljit_sw), SLJIT_LESS_EQUAL);
5446
5447         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, -0x7fffffff);
5448         sljit_emit_op2(compiler, SLJIT_ADD32 | SLJIT_SET_OVERFLOW, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, -(91 << 12));
5449         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 11 * sizeof(sljit_sw), SLJIT_OVERFLOW);
5450
5451         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, -0x7fffffff-1);
5452         sljit_emit_op1(compiler, SLJIT_NEG32 | SLJIT_SET_OVERFLOW, SLJIT_R0, 0, SLJIT_R0, 0);
5453         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 12 * sizeof(sljit_sw), SLJIT_OVERFLOW);
5454
5455         sljit_emit_return_void(compiler);
5456
5457         code.code = sljit_generate_code(compiler);
5458         CHECK(compiler);
5459         sljit_free_compiler(compiler);
5460
5461         code.func1((sljit_sw)&buf);
5462
5463         FAILED(buf[0] != (181 << 12), "test56 case 1 failed\n");
5464         FAILED(buf[1] != 1, "test56 case 2 failed\n");
5465         FAILED(buf[2] != (181 << 12), "test56 case 3 failed\n");
5466         FAILED(buf[3] != 1, "test56 case 4 failed\n");
5467         FAILED(buf[4] != 1, "test56 case 5 failed\n");
5468         FAILED(buf[5] != 1, "test56 case 6 failed\n");
5469         FAILED(buf[6] != 0, "test56 case 7 failed\n");
5470         FAILED(buf[7] != 0, "test56 case 8 failed\n");
5471         FAILED(buf[8] != 181, "test56 case 9 failed\n");
5472         FAILED(buf[9] != 1, "test56 case 10 failed\n");
5473         FAILED(buf[10] != 1, "test56 case 11 failed\n");
5474         FAILED(buf[11] != 1, "test56 case 12 failed\n");
5475         FAILED(buf[12] != 1, "test56 case 13 failed\n");
5476
5477         sljit_free_code(code.code, NULL);
5478         successful_tests++;
5479 }
5480
5481 static void test57(void)
5482 {
5483         /* Check prefetch instructions. */
5484         executable_code code;
5485         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
5486         struct sljit_label* labels[5];
5487         sljit_p addr[5];
5488         int i;
5489
5490         if (verbose)
5491                 printf("Run test57\n");
5492
5493         FAILED(!compiler, "cannot create compiler\n");
5494
5495         sljit_emit_enter(compiler, 0, SLJIT_ARGS0(VOID), 3, 1, 0, 0, 0);
5496
5497         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0);
5498         labels[0] = sljit_emit_label(compiler);
5499         /* Should never crash. */
5500         sljit_emit_op_src(compiler, SLJIT_PREFETCH_L1, SLJIT_MEM2(SLJIT_R0, SLJIT_R0), 2);
5501         labels[1] = sljit_emit_label(compiler);
5502         sljit_emit_op_src(compiler, SLJIT_PREFETCH_L2, SLJIT_MEM0(), 0);
5503         labels[2] = sljit_emit_label(compiler);
5504 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
5505         sljit_emit_op_src(compiler, SLJIT_PREFETCH_L3, SLJIT_MEM1(SLJIT_R0), SLJIT_W(0x1122334455667788));
5506 #else
5507         sljit_emit_op_src(compiler, SLJIT_PREFETCH_L3, SLJIT_MEM1(SLJIT_R0), 0x11223344);
5508 #endif
5509         labels[3] = sljit_emit_label(compiler);
5510         sljit_emit_op_src(compiler, SLJIT_PREFETCH_ONCE, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_sw));
5511         labels[4] = sljit_emit_label(compiler);
5512
5513         sljit_emit_return_void(compiler);
5514
5515         code.code = sljit_generate_code(compiler);
5516         CHECK(compiler);
5517
5518         for (i = 0; i < 5; i++)
5519                 addr[i] = sljit_get_label_addr(labels[i]);
5520
5521         sljit_free_compiler(compiler);
5522
5523         code.func0();
5524
5525         if (sljit_has_cpu_feature(SLJIT_HAS_PREFETCH)) {
5526                 FAILED(addr[0] == addr[1], "test57 case 1 failed\n");
5527                 FAILED(addr[1] == addr[2], "test57 case 2 failed\n");
5528                 FAILED(addr[2] == addr[3], "test57 case 3 failed\n");
5529                 FAILED(addr[3] == addr[4], "test57 case 4 failed\n");
5530         }
5531         else {
5532                 FAILED(addr[0] != addr[1], "test57 case 1 failed\n");
5533                 FAILED(addr[1] != addr[2], "test57 case 2 failed\n");
5534                 FAILED(addr[2] != addr[3], "test57 case 3 failed\n");
5535                 FAILED(addr[3] != addr[4], "test57 case 4 failed\n");
5536         }
5537
5538         sljit_free_code(code.code, NULL);
5539         successful_tests++;
5540 }
5541
5542 static sljit_f64 SLJIT_FUNC test58_f1(sljit_f32 a, sljit_f32 b, sljit_f64 c)
5543 {
5544         return (sljit_f64)a + (sljit_f64)b + c;
5545 }
5546
5547 static sljit_f32 SLJIT_FUNC test58_f2(sljit_sw a, sljit_f64 b, sljit_f32 c)
5548 {
5549         return (sljit_f32)((sljit_f64)a + b + (sljit_f64)c);
5550 }
5551
5552 static sljit_f64 SLJIT_FUNC test58_f3(sljit_sw a, sljit_f32 b, sljit_sw c)
5553 {
5554         return (sljit_f64)a + (sljit_f64)b + (sljit_f64)c;
5555 }
5556
5557 static sljit_f64 test58_f4(sljit_f32 a, sljit_sw b)
5558 {
5559         return (sljit_f64)a + (sljit_f64)b;
5560 }
5561
5562 static sljit_f32 test58_f5(sljit_f32 a, sljit_f64 b, sljit_s32 c)
5563 {
5564         return (sljit_f32)((sljit_f64)a + b + (sljit_f64)c);
5565 }
5566
5567 static sljit_sw SLJIT_FUNC test58_f6(sljit_f64 a, sljit_sw b)
5568 {
5569         return (sljit_sw)(a + (sljit_f64)b);
5570 }
5571
5572 static void test58(void)
5573 {
5574         /* Check function calls with floating point arguments. */
5575         executable_code code;
5576         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
5577         struct sljit_jump* jump = NULL;
5578         sljit_f64 dbuf[7];
5579         sljit_f32 sbuf[7];
5580         sljit_sw wbuf[2];
5581
5582         if (verbose)
5583                 printf("Run test58\n");
5584
5585         if (!sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
5586                 if (verbose)
5587                         printf("no fpu available, test58 skipped\n");
5588                 successful_tests++;
5589                 if (compiler)
5590                         sljit_free_compiler(compiler);
5591                 return;
5592         }
5593
5594         dbuf[0] = 5.25;
5595         dbuf[1] = 0.0;
5596         dbuf[2] = 2.5;
5597         dbuf[3] = 0.0;
5598         dbuf[4] = 0.0;
5599         dbuf[5] = 0.0;
5600         dbuf[6] = -18.0;
5601
5602         sbuf[0] = 6.75;
5603         sbuf[1] = -3.5;
5604         sbuf[2] = 1.5;
5605         sbuf[3] = 0.0;
5606         sbuf[4] = 0.0;
5607
5608         wbuf[0] = 0;
5609         wbuf[1] = 0;
5610
5611         FAILED(!compiler, "cannot create compiler\n");
5612
5613         sljit_emit_enter(compiler, 0, SLJIT_ARGS3(VOID, P, P, P), 3, 3, 4, 0, sizeof(sljit_sw));
5614
5615         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S1), 0);
5616         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_f32));
5617         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S0), 0);
5618         sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_ARGS3(F64, F32, F32, F64), SLJIT_IMM, SLJIT_FUNC_ADDR(test58_f1));
5619         /* dbuf[1] */
5620         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64), SLJIT_FR0, 0);
5621
5622         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_f32));
5623         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S1), 2 * sizeof(sljit_f32));
5624         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_f64));
5625         jump = sljit_emit_call(compiler, SLJIT_CALL, SLJIT_ARGS3(F64, F32, F32, F64));
5626         sljit_set_target(jump, SLJIT_FUNC_UADDR(test58_f1));
5627         /* dbuf[3] */
5628         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_f64), SLJIT_FR0, 0);
5629
5630         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), 0, SLJIT_IMM, SLJIT_FUNC_ADDR(test58_f2));
5631         sljit_get_local_base(compiler, SLJIT_R1, 0, -16);
5632         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 16);
5633         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S0), 0);
5634         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_f32));
5635         sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_ARGS3(F32, W, F64, F32), SLJIT_MEM2(SLJIT_R1, SLJIT_R0), 0);
5636         /* sbuf[3] */
5637         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_S1), 3 * sizeof(sljit_f32), SLJIT_FR0, 0);
5638
5639         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -4);
5640         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 9);
5641         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 0);
5642         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S1), 0);
5643         jump = sljit_emit_call(compiler, SLJIT_CALL, SLJIT_ARGS3(F64, W, F32, W));
5644         sljit_set_target(jump, SLJIT_FUNC_UADDR(test58_f3));
5645         /* dbuf[4] */
5646         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_f64), SLJIT_FR0, 0);
5647
5648         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_f32));
5649         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -6);
5650         jump = sljit_emit_call(compiler, SLJIT_CALL_CDECL, SLJIT_ARGS2(F64, F32, W));
5651         sljit_set_target(jump, SLJIT_FUNC_UADDR(test58_f4));
5652         /* dbuf[5] */
5653         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_f64), SLJIT_FR0, 0);
5654
5655         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), 0, SLJIT_IMM, SLJIT_FUNC_ADDR(test58_f5));
5656         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S1), 2 * sizeof(sljit_f32));
5657         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_f64));
5658         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 8);
5659         sljit_emit_icall(compiler, SLJIT_CALL_CDECL, SLJIT_ARGS3(F32, F32, F64, 32), SLJIT_MEM1(SLJIT_SP), 0);
5660         /* sbuf[4] */
5661         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_S1), 4 * sizeof(sljit_f32), SLJIT_FR0, 0);
5662
5663         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_f64));
5664         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_FUNC_ADDR(test58_f6));
5665         sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_ARGS2(W, F64, W), SLJIT_R0, 0);
5666         /* wbuf[0] */
5667         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S2), 0, SLJIT_R0, 0);
5668
5669         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_f64));
5670         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 319);
5671         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, SLJIT_FUNC_ADDR(test58_f6));
5672         sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_ARGS2(W, F64, W), SLJIT_R1, 0);
5673         /* wbuf[1] */
5674         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S2), sizeof(sljit_sw), SLJIT_R0, 0);
5675
5676         sljit_emit_return_void(compiler);
5677
5678         code.code = sljit_generate_code(compiler);
5679         CHECK(compiler);
5680         sljit_free_compiler(compiler);
5681
5682         code.func3((sljit_sw)&dbuf, (sljit_sw)&sbuf, (sljit_sw)&wbuf);
5683
5684         FAILED(dbuf[1] != 8.5, "test58 case 1 failed\n");
5685         FAILED(dbuf[3] != 0.5, "test58 case 2 failed\n");
5686         FAILED(sbuf[3] != 17.75, "test58 case 3 failed\n");
5687         FAILED(dbuf[4] != 11.75, "test58 case 4 failed\n");
5688         FAILED(dbuf[5] != -9.5, "test58 case 5 failed\n");
5689         FAILED(sbuf[4] != 12, "test58 case 6 failed\n");
5690         FAILED(wbuf[0] != SLJIT_FUNC_ADDR(test58_f6) - 18, "test58 case 7 failed\n");
5691         FAILED(wbuf[1] != 301, "test58 case 8 failed\n");
5692
5693         sljit_free_code(code.code, NULL);
5694         successful_tests++;
5695 }
5696
5697 static sljit_sw SLJIT_FUNC test59_f1(sljit_sw a, sljit_s32 b, sljit_sw c, sljit_sw d)
5698 {
5699         return (sljit_sw)(a + b + c + d - SLJIT_FUNC_ADDR(test59_f1));
5700 }
5701
5702 static sljit_sw test59_f2(sljit_sw a, sljit_s32 b, sljit_sw c, sljit_sw d)
5703 {
5704         return (sljit_sw)(a + b + c + d - SLJIT_FUNC_ADDR(test59_f2));
5705 }
5706
5707 static sljit_s32 SLJIT_FUNC test59_f3(sljit_f64 a, sljit_f32 b, sljit_f64 c, sljit_sw d)
5708 {
5709         return (sljit_s32)(a + b + c + (sljit_f64)d);
5710 }
5711
5712 static sljit_f32 SLJIT_FUNC test59_f4(sljit_f32 a, sljit_s32 b, sljit_f64 c, sljit_sw d)
5713 {
5714         return (sljit_f32)(a + (sljit_f64)b + c + (sljit_f64)d);
5715 }
5716
5717 static sljit_f32 SLJIT_FUNC test59_f5(sljit_f32 a, sljit_f64 b, sljit_f32 c, sljit_f64 d)
5718 {
5719         return (sljit_f32)(a + b + c + (sljit_f64)d);
5720 }
5721
5722 static void test59(void)
5723 {
5724         /* Check function calls with four arguments. */
5725         executable_code code;
5726         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
5727         struct sljit_jump* jump = NULL;
5728         sljit_sw wbuf[6];
5729         sljit_f64 dbuf[3];
5730         sljit_f32 sbuf[4];
5731
5732         if (verbose)
5733                 printf("Run test59\n");
5734
5735         wbuf[0] = 0;
5736         wbuf[1] = 0;
5737         wbuf[2] = 0;
5738         wbuf[3] = SLJIT_FUNC_ADDR(test59_f1);
5739         wbuf[4] = 0;
5740         wbuf[5] = 0;
5741
5742         if (sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
5743                 dbuf[0] = 5.125;
5744                 dbuf[1] = 6.125;
5745                 dbuf[2] = 4.25;
5746
5747                 sbuf[0] = 0.75;
5748                 sbuf[1] = -1.5;
5749                 sbuf[2] = 0.0;
5750                 sbuf[3] = 0.0;
5751         }
5752
5753         FAILED(!compiler, "cannot create compiler\n");
5754
5755         sljit_emit_enter(compiler, 0, SLJIT_ARGS3(VOID, P, P, P), 4, 3, 4, 0, sizeof(sljit_sw));
5756
5757         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 33);
5758         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, -20);
5759         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, SLJIT_FUNC_ADDR(test59_f1));
5760         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, -40);
5761         sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_ARGS4(W, W, 32, W, W), SLJIT_R2, 0);
5762         /* wbuf[0] */
5763         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0);
5764
5765         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 16);
5766         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, -30);
5767         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 50);
5768         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, SLJIT_FUNC_ADDR(test59_f2));
5769         sljit_emit_icall(compiler, SLJIT_CALL_CDECL, SLJIT_ARGS4(W, W, 32, W, W), SLJIT_R3, 0);
5770         /* wbuf[1] */
5771         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_R0, 0);
5772
5773         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_FUNC_ADDR(test59_f1));
5774         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, -25);
5775         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 100);
5776         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, -10);
5777         sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_ARGS4(W, W, 32, W, W), SLJIT_R0, 0);
5778         /* wbuf[2] */
5779         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_R0, 0);
5780
5781         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_S0, 0);
5782         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, 231);
5783         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 3);
5784         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, SLJIT_FUNC_ADDR(test59_f1) - 100);
5785         sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_ARGS4(W, W, 32, W, W), SLJIT_MEM2(SLJIT_R0, SLJIT_R2), SLJIT_WORD_SHIFT);
5786         /* wbuf[4] */
5787         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_R0, 0);
5788
5789         if (sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
5790                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S1), 0);
5791                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S2), 0);
5792                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_f64));
5793                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -100);
5794                 sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_ARGS4(32, F64, F32, F64, W), SLJIT_IMM, SLJIT_FUNC_ADDR(test59_f3));
5795                 sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_R0, 0, SLJIT_R0, 0);
5796                 /* wbuf[5] */
5797                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_R0, 0);
5798
5799                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S2), sizeof(sljit_f32));
5800                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S1), 2 * sizeof(sljit_f64));
5801                 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 36);
5802                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 41);
5803                 jump = sljit_emit_call(compiler, SLJIT_CALL, SLJIT_ARGS4(F32, F32, 32, F64, W));
5804                 sljit_set_target(jump, SLJIT_FUNC_UADDR(test59_f4));
5805                 /* sbuf[2] */
5806                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_S2), 2 * sizeof(sljit_f32), SLJIT_FR0, 0);
5807
5808                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_FUNC_ADDR(test59_f5));
5809                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S2), 0);
5810                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S1), 0);
5811                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S2), sizeof(sljit_f32));
5812                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR3, 0, SLJIT_MEM1(SLJIT_S1), 2 * sizeof(sljit_f64));
5813                 sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_ARGS4(F32, F32, F64, F32, F64), SLJIT_R0, 0);
5814                 /* sbuf[2] */
5815                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_S2), 3 * sizeof(sljit_f32), SLJIT_FR0, 0);
5816         }
5817
5818         sljit_emit_return_void(compiler);
5819
5820         code.code = sljit_generate_code(compiler);
5821         CHECK(compiler);
5822         sljit_free_compiler(compiler);
5823
5824         code.func3((sljit_sw)&wbuf, (sljit_sw)&dbuf, (sljit_sw)&sbuf);
5825
5826         FAILED(wbuf[0] != -27, "test59 case 1 failed\n");
5827         FAILED(wbuf[1] != 36, "test59 case 2 failed\n");
5828         FAILED(wbuf[2] != 65, "test59 case 3 failed\n");
5829         FAILED(wbuf[4] != (sljit_sw)wbuf + 134, "test59 case 4 failed\n");
5830
5831         if (sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
5832                 FAILED(wbuf[5] != -88, "test59 case 5 failed\n");
5833                 FAILED(sbuf[2] != 79.75, "test59 case 6 failed\n");
5834                 FAILED(sbuf[3] != 8.625, "test59 case 7 failed\n");
5835         }
5836
5837         sljit_free_code(code.code, NULL);
5838         successful_tests++;
5839 }
5840
5841 static void test60(void)
5842 {
5843         /* Test memory accesses with pre/post updates. */
5844         executable_code code;
5845         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
5846         sljit_u32 i;
5847         sljit_s32 supported[10];
5848         sljit_sw wbuf[18];
5849         sljit_s8 bbuf[4];
5850         sljit_s32 ibuf[4];
5851
5852 #if (defined SLJIT_CONFIG_ARM_64 && SLJIT_CONFIG_ARM_64) || (defined SLJIT_CONFIG_ARM_THUMB2 && SLJIT_CONFIG_ARM_THUMB2)
5853         static sljit_u8 expected[10] = { 1, 1, 1, 1, 1, 1, 0, 0, 0, 0 };
5854 #elif (defined SLJIT_CONFIG_ARM_32 && SLJIT_CONFIG_ARM_32)
5855         static sljit_u8 expected[10] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
5856 #elif (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32)
5857         static sljit_u8 expected[10] = { 1, 0, 1, 1, 0, 1, 1, 1, 0, 0 };
5858 #elif (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
5859         static sljit_u8 expected[10] = { 1, 0, 0, 1, 0, 0, 1, 1, 0, 0 };
5860 #else
5861         static sljit_u8 expected[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
5862 #endif
5863
5864         if (verbose)
5865                 printf("Run test60\n");
5866
5867         for (i = 0; i < 18; i++)
5868                 wbuf[i] = 0;
5869         wbuf[2] = -887766;
5870
5871         bbuf[0] = 0;
5872         bbuf[1] = 0;
5873         bbuf[2] = -13;
5874
5875         ibuf[0] = -5678;
5876         ibuf[1] = 0;
5877         ibuf[2] = 0;
5878
5879         FAILED(!compiler, "cannot create compiler\n");
5880
5881         sljit_emit_enter(compiler, 0, SLJIT_ARGS3(VOID, P, P, P), 4, 3, 4, 0, sizeof(sljit_sw));
5882
5883         supported[0] = sljit_emit_mem(compiler, SLJIT_MOV | SLJIT_MEM_SUPP | SLJIT_MEM_PRE, SLJIT_R1, SLJIT_MEM1(SLJIT_R0), 2 * sizeof(sljit_sw));
5884         if (supported[0] == SLJIT_SUCCESS) {
5885                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_S0, 0);
5886                 sljit_emit_mem(compiler, SLJIT_MOV | SLJIT_MEM_PRE, SLJIT_R1, SLJIT_MEM1(SLJIT_R0), 2 * sizeof(sljit_sw));
5887                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R1, 0);
5888                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_R0, 0);
5889         }
5890
5891         supported[1] = sljit_emit_mem(compiler, SLJIT_MOV_S8 | SLJIT_MEM_SUPP | SLJIT_MEM_POST, SLJIT_R0, SLJIT_MEM1(SLJIT_R2), -2 * (sljit_sw)sizeof(sljit_s8));
5892         if (supported[1] == SLJIT_SUCCESS) {
5893                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R2, 0, SLJIT_S1, 0, SLJIT_IMM, 2 * sizeof(sljit_s8));
5894                 sljit_emit_mem(compiler, SLJIT_MOV_S8 | SLJIT_MEM_POST, SLJIT_R0, SLJIT_MEM1(SLJIT_R2), -2 * (sljit_sw)sizeof(sljit_s8));
5895                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_R0, 0);
5896                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_R2, 0);
5897         }
5898
5899         supported[2] = sljit_emit_mem(compiler, SLJIT_MOV_S32 | SLJIT_MEM_SUPP | SLJIT_MEM_PRE, SLJIT_R2, SLJIT_MEM1(SLJIT_R1), -2 * (sljit_sw)sizeof(sljit_s32));
5900         if (supported[2] == SLJIT_SUCCESS) {
5901                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_S2, 0, SLJIT_IMM, 2 * sizeof(sljit_s32));
5902                 sljit_emit_mem(compiler, SLJIT_MOV_S32 | SLJIT_MEM_PRE, SLJIT_R2, SLJIT_MEM1(SLJIT_R1), -2 * (sljit_sw)sizeof(sljit_s32));
5903                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_R2, 0);
5904                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_sw), SLJIT_R1, 0);
5905         }
5906
5907         supported[3] = sljit_emit_mem(compiler, SLJIT_MOV32 | SLJIT_MEM_SUPP | SLJIT_MEM_STORE | SLJIT_MEM_PRE, SLJIT_R1, SLJIT_MEM1(SLJIT_R2), 2 * sizeof(sljit_s32));
5908         if (supported[3] == SLJIT_SUCCESS) {
5909                 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, -8765);
5910                 sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R2, 0, SLJIT_S2, 0, SLJIT_IMM, sizeof(sljit_s32));
5911                 sljit_emit_mem(compiler, SLJIT_MOV32 | SLJIT_MEM_STORE | SLJIT_MEM_PRE, SLJIT_R1, SLJIT_MEM1(SLJIT_R2), 2 * sizeof(sljit_s32));
5912                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_sw), SLJIT_R2, 0);
5913         }
5914
5915         supported[4] = sljit_emit_mem(compiler, SLJIT_MOV_S8 | SLJIT_MEM_SUPP | SLJIT_MEM_STORE | SLJIT_MEM_POST, SLJIT_R1, SLJIT_MEM1(SLJIT_R2), -128 * (sljit_sw)sizeof(sljit_s8));
5916         if (supported[4] == SLJIT_SUCCESS) {
5917                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, -121);
5918                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_S1, 0);
5919                 sljit_emit_mem(compiler, SLJIT_MOV_S8 | SLJIT_MEM_STORE | SLJIT_MEM_POST, SLJIT_R1, SLJIT_MEM1(SLJIT_R2), -128 * (sljit_sw)sizeof(sljit_s8));
5920                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_sw), SLJIT_R2, 0);
5921         }
5922
5923         supported[5] = sljit_emit_mem(compiler, SLJIT_MOV | SLJIT_MEM_SUPP | SLJIT_MEM_STORE | SLJIT_MEM_PRE, SLJIT_R1, SLJIT_MEM1(SLJIT_R0), 1);
5924         if (supported[5] == SLJIT_SUCCESS) {
5925                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_S0, 0, SLJIT_IMM, 9 * sizeof(sljit_sw) - 1);
5926                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, -881199);
5927                 sljit_emit_mem(compiler, SLJIT_MOV | SLJIT_MEM_STORE | SLJIT_MEM_PRE, SLJIT_R1, SLJIT_MEM1(SLJIT_R0), 1);
5928                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 10 * sizeof(sljit_sw), SLJIT_R0, 0);
5929         }
5930
5931         supported[6] = sljit_emit_mem(compiler, SLJIT_MOV_S32 | SLJIT_MEM_SUPP | SLJIT_MEM_PRE, SLJIT_R0, SLJIT_MEM2(SLJIT_R1, SLJIT_R2), 0);
5932         if (supported[6] == SLJIT_SUCCESS) {
5933                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_S2, 0, SLJIT_IMM, 213);
5934                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, -213);
5935                 sljit_emit_mem(compiler, SLJIT_MOV_S32 | SLJIT_MEM_PRE, SLJIT_R0, SLJIT_MEM2(SLJIT_R1, SLJIT_R2), 0);
5936                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 11 * sizeof(sljit_sw), SLJIT_R0, 0);
5937                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 12 * sizeof(sljit_sw), SLJIT_R1, 0);
5938         }
5939
5940         supported[7] = sljit_emit_mem(compiler, SLJIT_MOV_S32 | SLJIT_MEM_SUPP | SLJIT_MEM_STORE | SLJIT_MEM_PRE, SLJIT_R0, SLJIT_MEM2(SLJIT_R1, SLJIT_R2), 0);
5941         if (supported[7] == SLJIT_SUCCESS) {
5942                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_S2, 0);
5943                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 2 * sizeof(sljit_s32));
5944                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -7890);
5945                 sljit_emit_mem(compiler, SLJIT_MOV_S32 | SLJIT_MEM_STORE | SLJIT_MEM_PRE, SLJIT_R0, SLJIT_MEM2(SLJIT_R1, SLJIT_R2), 0);
5946                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 13 * sizeof(sljit_sw), SLJIT_R1, 0);
5947         }
5948
5949         supported[8] = sljit_emit_mem(compiler, SLJIT_MOV | SLJIT_MEM_SUPP | SLJIT_MEM_POST, SLJIT_R0, SLJIT_MEM2(SLJIT_R1, SLJIT_R2), 2);
5950         if (supported[8] == SLJIT_SUCCESS) {
5951                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_S0, 0, SLJIT_IMM, 2 * sizeof(sljit_sw));
5952                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 2 * sizeof(sljit_sw));
5953                 sljit_emit_mem(compiler, SLJIT_MOV | SLJIT_MEM_POST, SLJIT_R0, SLJIT_MEM2(SLJIT_R1, SLJIT_R2), 2);
5954                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 14 * sizeof(sljit_sw), SLJIT_R0, 0);
5955                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 15 * sizeof(sljit_sw), SLJIT_R1, 0);
5956         }
5957
5958         supported[9] = sljit_emit_mem(compiler, SLJIT_MOV_S8 | SLJIT_MEM_SUPP | SLJIT_MEM_POST, SLJIT_R0, SLJIT_MEM2(SLJIT_R1, SLJIT_R2), 0);
5959         if (supported[9] == SLJIT_SUCCESS) {
5960                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_S1, 0, SLJIT_IMM, 2 * sizeof(sljit_s8));
5961                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, -2 * (sljit_sw)sizeof(sljit_s8));
5962                 sljit_emit_mem(compiler, SLJIT_MOV_S8 | SLJIT_MEM_POST, SLJIT_R0, SLJIT_MEM2(SLJIT_R1, SLJIT_R2), 0);
5963                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 16 * sizeof(sljit_sw), SLJIT_R0, 0);
5964                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 17 * sizeof(sljit_sw), SLJIT_R1, 0);
5965         }
5966
5967         SLJIT_ASSERT(sljit_emit_mem(compiler, SLJIT_MOV_S8 | SLJIT_MEM_SUPP | SLJIT_MEM_PRE, SLJIT_R0, SLJIT_MEM2(SLJIT_R1, SLJIT_R2), 1) == SLJIT_ERR_UNSUPPORTED);
5968         SLJIT_ASSERT(sljit_emit_mem(compiler, SLJIT_MOV_S8 | SLJIT_MEM_SUPP | SLJIT_MEM_POST, SLJIT_R0, SLJIT_MEM2(SLJIT_R1, SLJIT_R2), 1) == SLJIT_ERR_UNSUPPORTED);
5969
5970 #if (defined SLJIT_CONFIG_ARM_THUMB2 && SLJIT_CONFIG_ARM_THUMB2) || (defined SLJIT_CONFIG_ARM_64 && SLJIT_CONFIG_ARM_64)
5971         /* TODO: at least for ARM (both V5 and V7) the range below needs further fixing */
5972         SLJIT_ASSERT(sljit_emit_mem(compiler, SLJIT_MOV | SLJIT_MEM_SUPP | SLJIT_MEM_PRE, SLJIT_R1, SLJIT_MEM1(SLJIT_R0), 256) == SLJIT_ERR_UNSUPPORTED);
5973         SLJIT_ASSERT(sljit_emit_mem(compiler, SLJIT_MOV | SLJIT_MEM_SUPP | SLJIT_MEM_POST, SLJIT_R1, SLJIT_MEM1(SLJIT_R0), -257) == SLJIT_ERR_UNSUPPORTED);
5974 #endif
5975
5976         sljit_emit_return_void(compiler);
5977
5978         code.code = sljit_generate_code(compiler);
5979         CHECK(compiler);
5980         sljit_free_compiler(compiler);
5981
5982         code.func3((sljit_sw)&wbuf, (sljit_sw)&bbuf, (sljit_sw)&ibuf);
5983
5984         FAILED(sizeof(expected) != sizeof(supported) / sizeof(sljit_s32), "test60 case 1 failed\n");
5985
5986         for (i = 0; i < sizeof(expected); i++) {
5987                 if (expected[i]) {
5988                         if (supported[i] != SLJIT_SUCCESS) {
5989                                 printf("tast60 case %d should be supported\n", i + 1);
5990                                 return;
5991                         }
5992                 } else {
5993                         if (supported[i] == SLJIT_SUCCESS) {
5994                                 printf("test60 case %d should not be supported\n", i + 1);
5995                                 return;
5996                         }
5997                 }
5998         }
5999
6000         FAILED(supported[0] == SLJIT_SUCCESS && wbuf[0] != -887766, "test60 case 2 failed\n");
6001         FAILED(supported[0] == SLJIT_SUCCESS && wbuf[1] != (sljit_sw)(wbuf + 2), "test60 case 3 failed\n");
6002         FAILED(supported[1] == SLJIT_SUCCESS && wbuf[3] != -13, "test60 case 4 failed\n");
6003         FAILED(supported[1] == SLJIT_SUCCESS && wbuf[4] != (sljit_sw)(bbuf), "test60 case 5 failed\n");
6004         FAILED(supported[2] == SLJIT_SUCCESS && wbuf[5] != -5678, "test60 case 6 failed\n");
6005         FAILED(supported[2] == SLJIT_SUCCESS && wbuf[6] != (sljit_sw)(ibuf), "test60 case 7 failed\n");
6006         FAILED(supported[3] == SLJIT_SUCCESS && ibuf[1] != -8765, "test60 case 8 failed\n");
6007         FAILED(supported[3] == SLJIT_SUCCESS && wbuf[7] != (sljit_sw)(ibuf + 1), "test60 case 9 failed\n");
6008         FAILED(supported[4] == SLJIT_SUCCESS && bbuf[0] != -121, "test60 case 10 failed\n");
6009         FAILED(supported[4] == SLJIT_SUCCESS && wbuf[8] != (sljit_sw)(bbuf) - 128 * (sljit_sw)sizeof(sljit_s8), "test60 case 11 failed\n");
6010         FAILED(supported[5] == SLJIT_SUCCESS && wbuf[9] != -881199, "test60 case 12 failed\n");
6011         FAILED(supported[5] == SLJIT_SUCCESS && wbuf[10] != (sljit_sw)(wbuf + 9), "test60 case 13 failed\n");
6012         FAILED(supported[6] == SLJIT_SUCCESS && wbuf[11] != -5678, "test60 case 14 failed\n");
6013         FAILED(supported[6] == SLJIT_SUCCESS && wbuf[12] != (sljit_sw)(ibuf), "test60 case 15 failed\n");
6014         FAILED(supported[7] == SLJIT_SUCCESS && ibuf[2] != -7890, "test60 case 16 failed\n");
6015         FAILED(supported[7] == SLJIT_SUCCESS && wbuf[13] != (sljit_sw)(ibuf + 2), "test60 case 17 failed\n");
6016         FAILED(supported[8] == SLJIT_SUCCESS && wbuf[14] != -887766, "test60 case 18 failed\n");
6017         FAILED(supported[8] == SLJIT_SUCCESS && wbuf[15] != (sljit_sw)(wbuf + 10), "test60 case 19 failed\n");
6018         FAILED(supported[9] == SLJIT_SUCCESS && wbuf[16] != -13, "test60 case 20 failed\n");
6019         FAILED(supported[9] == SLJIT_SUCCESS && wbuf[17] != (sljit_sw)(bbuf), "test60 case 21 failed\n");
6020
6021         sljit_free_code(code.code, NULL);
6022         successful_tests++;
6023 }
6024
6025 static void test61(void)
6026 {
6027         /* Test float memory accesses with pre/post updates. */
6028         executable_code code;
6029         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
6030         sljit_u32 i;
6031         sljit_s32 supported[6];
6032         sljit_sw wbuf[6];
6033         sljit_f64 dbuf[4];
6034         sljit_f32 sbuf[4];
6035 #if (defined SLJIT_CONFIG_ARM_64 && SLJIT_CONFIG_ARM_64)
6036         static sljit_u8 expected[6] = { 1, 1, 1, 1, 0, 0 };
6037 #elif (defined SLJIT_CONFIG_PPC && SLJIT_CONFIG_PPC)
6038         static sljit_u8 expected[6] = { 1, 0, 1, 0, 1, 1 };
6039 #else
6040         static sljit_u8 expected[6] = { 0, 0, 0, 0, 0, 0 };
6041 #endif
6042
6043         if (!sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
6044                 if (verbose)
6045                         printf("no fpu available, test61 skipped\n");
6046                 successful_tests++;
6047                 if (compiler)
6048                         sljit_free_compiler(compiler);
6049                 return;
6050         }
6051
6052         if (verbose)
6053                 printf("Run test61\n");
6054
6055         for (i = 0; i < 6; i++)
6056                 wbuf[i] = 0;
6057
6058         dbuf[0] = 66.725;
6059         dbuf[1] = 0.0;
6060         dbuf[2] = 0.0;
6061         dbuf[3] = 0.0;
6062
6063         sbuf[0] = 0.0;
6064         sbuf[1] = -22.125;
6065         sbuf[2] = 0.0;
6066         sbuf[3] = 0.0;
6067
6068         FAILED(!compiler, "cannot create compiler\n");
6069
6070         sljit_emit_enter(compiler, 0, SLJIT_ARGS3(VOID, P, P, P), 4, 3, 4, 0, sizeof(sljit_sw));
6071
6072         supported[0] = sljit_emit_fmem(compiler, SLJIT_MOV_F64 | SLJIT_MEM_SUPP | SLJIT_MEM_PRE, SLJIT_FR0, SLJIT_MEM1(SLJIT_R0), 4 * sizeof(sljit_f64));
6073         if (supported[0] == SLJIT_SUCCESS) {
6074                 sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R0, 0, SLJIT_S1, 0, SLJIT_IMM, 4 * sizeof(sljit_f64));
6075                 sljit_emit_fmem(compiler, SLJIT_MOV_F64 | SLJIT_MEM_PRE, SLJIT_FR0, SLJIT_MEM1(SLJIT_R0), 4 * sizeof(sljit_f64));
6076                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_f64), SLJIT_FR0, 0);
6077                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0);
6078         }
6079
6080         supported[1] = sljit_emit_fmem(compiler, SLJIT_MOV_F64 | SLJIT_MEM_SUPP | SLJIT_MEM_STORE | SLJIT_MEM_POST, SLJIT_FR2, SLJIT_MEM1(SLJIT_R0), -(sljit_sw)sizeof(sljit_f64));
6081         if (supported[1] == SLJIT_SUCCESS) {
6082                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_S1, 0, SLJIT_IMM, 2 * sizeof(sljit_f64));
6083                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S1), 0);
6084                 sljit_emit_fmem(compiler, SLJIT_MOV_F64 | SLJIT_MEM_STORE | SLJIT_MEM_POST, SLJIT_FR2, SLJIT_MEM1(SLJIT_R0), -(sljit_sw)sizeof(sljit_f64));
6085                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_R0, 0);
6086         }
6087
6088         supported[2] = sljit_emit_fmem(compiler, SLJIT_MOV_F32 | SLJIT_MEM_SUPP | SLJIT_MEM_STORE | SLJIT_MEM_PRE, SLJIT_FR1, SLJIT_MEM1(SLJIT_R2), -4 * (sljit_sw)sizeof(sljit_f32));
6089         if (supported[2] == SLJIT_SUCCESS) {
6090                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R2, 0, SLJIT_S2, 0, SLJIT_IMM, 4 * sizeof(sljit_f32));
6091                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S2), sizeof(sljit_f32));
6092                 sljit_emit_fmem(compiler, SLJIT_MOV_F32 | SLJIT_MEM_STORE | SLJIT_MEM_PRE, SLJIT_FR1, SLJIT_MEM1(SLJIT_R2), -4 * (sljit_sw)sizeof(sljit_f32));
6093                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_R2, 0);
6094         }
6095
6096         supported[3] = sljit_emit_fmem(compiler, SLJIT_MOV_F32 | SLJIT_MEM_SUPP | SLJIT_MEM_POST, SLJIT_FR1, SLJIT_MEM1(SLJIT_R1), sizeof(sljit_f32));
6097         if (supported[3] == SLJIT_SUCCESS) {
6098                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_S2, 0, SLJIT_IMM, sizeof(sljit_f32));
6099                 sljit_emit_fmem(compiler, SLJIT_MOV_F32 | SLJIT_MEM_POST, SLJIT_FR1, SLJIT_MEM1(SLJIT_R1), sizeof(sljit_f32));
6100                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_S2), 2 * sizeof(sljit_f32), SLJIT_FR1, 0);
6101                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_R1, 0);
6102         }
6103
6104         supported[4] = sljit_emit_fmem(compiler, SLJIT_MOV_F64 | SLJIT_MEM_SUPP | SLJIT_MEM_PRE, SLJIT_FR0, SLJIT_MEM2(SLJIT_R1, SLJIT_R0), 0);
6105         if (supported[4] == SLJIT_SUCCESS) {
6106                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_S1, 0, SLJIT_IMM, 8 * sizeof(sljit_f64));
6107                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -8 * (sljit_sw)sizeof(sljit_f64));
6108                 sljit_emit_fmem(compiler, SLJIT_MOV_F64 | SLJIT_MEM_PRE, SLJIT_FR0, SLJIT_MEM2(SLJIT_R1, SLJIT_R0), 0);
6109                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S1), 3 * sizeof(sljit_f64), SLJIT_FR0, 0);
6110                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_R1, 0);
6111         }
6112
6113         supported[5] = sljit_emit_fmem(compiler, SLJIT_MOV_F32 | SLJIT_MEM_SUPP | SLJIT_MEM_STORE | SLJIT_MEM_PRE, SLJIT_FR2, SLJIT_MEM2(SLJIT_R2, SLJIT_R1), 0);
6114         if (supported[5] == SLJIT_SUCCESS) {
6115                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_S2, 0);
6116                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 3 * sizeof(sljit_f32));
6117                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S2), sizeof(sljit_f32));
6118                 sljit_emit_fmem(compiler, SLJIT_MOV_F32 | SLJIT_MEM_STORE | SLJIT_MEM_PRE, SLJIT_FR2, SLJIT_MEM2(SLJIT_R2, SLJIT_R1), 0);
6119                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_R2, 0);
6120         }
6121
6122         SLJIT_ASSERT(sljit_emit_fmem(compiler, SLJIT_MOV_F64 | SLJIT_MEM_SUPP | SLJIT_MEM_POST, SLJIT_FR0, SLJIT_MEM2(SLJIT_R1, SLJIT_R2), 0) == SLJIT_ERR_UNSUPPORTED);
6123         SLJIT_ASSERT(sljit_emit_fmem(compiler, SLJIT_MOV_F32 | SLJIT_MEM_SUPP | SLJIT_MEM_STORE | SLJIT_MEM_POST, SLJIT_FR0, SLJIT_MEM2(SLJIT_R1, SLJIT_R2), 0) == SLJIT_ERR_UNSUPPORTED);
6124
6125 #if (defined SLJIT_CONFIG_ARM_64 && SLJIT_CONFIG_ARM_64)
6126         /* TODO: at least for ARM (both V5 and V7) the range below needs further fixing */
6127         SLJIT_ASSERT(sljit_emit_fmem(compiler, SLJIT_MOV_F64 | SLJIT_MEM_SUPP | SLJIT_MEM_PRE, SLJIT_FR0, SLJIT_MEM1(SLJIT_R0), 256) == SLJIT_ERR_UNSUPPORTED);
6128         SLJIT_ASSERT(sljit_emit_fmem(compiler, SLJIT_MOV_F64 | SLJIT_MEM_SUPP | SLJIT_MEM_POST, SLJIT_FR0, SLJIT_MEM1(SLJIT_R0), -257) == SLJIT_ERR_UNSUPPORTED);
6129 #endif
6130
6131         sljit_emit_return_void(compiler);
6132
6133         code.code = sljit_generate_code(compiler);
6134         CHECK(compiler);
6135         sljit_free_compiler(compiler);
6136
6137         code.func3((sljit_sw)&wbuf, (sljit_sw)&dbuf, (sljit_sw)&sbuf);
6138
6139         FAILED(sizeof(expected) != sizeof(supported) / sizeof(sljit_s32), "test61 case 1 failed\n");
6140
6141         for (i = 0; i < sizeof(expected); i++) {
6142                 if (expected[i]) {
6143                         if (supported[i] != SLJIT_SUCCESS) {
6144                                 printf("tast61 case %d should be supported\n", i + 1);
6145                                 return;
6146                         }
6147                 } else {
6148                         if (supported[i] == SLJIT_SUCCESS) {
6149                                 printf("test61 case %d should not be supported\n", i + 1);
6150                                 return;
6151                         }
6152                 }
6153         }
6154
6155         FAILED(supported[0] == SLJIT_SUCCESS && dbuf[1] != 66.725, "test61 case 2 failed\n");
6156         FAILED(supported[0] == SLJIT_SUCCESS && wbuf[0] != (sljit_sw)(dbuf), "test61 case 3 failed\n");
6157         FAILED(supported[1] == SLJIT_SUCCESS && dbuf[2] != 66.725, "test61 case 4 failed\n");
6158         FAILED(supported[1] == SLJIT_SUCCESS && wbuf[1] != (sljit_sw)(dbuf + 1), "test61 case 5 failed\n");
6159         FAILED(supported[2] == SLJIT_SUCCESS && sbuf[0] != -22.125, "test61 case 6 failed\n");
6160         FAILED(supported[2] == SLJIT_SUCCESS && wbuf[2] != (sljit_sw)(sbuf), "test61 case 7 failed\n");
6161         FAILED(supported[3] == SLJIT_SUCCESS && sbuf[2] != -22.125, "test61 case 8 failed\n");
6162         FAILED(supported[3] == SLJIT_SUCCESS && wbuf[3] != (sljit_sw)(sbuf + 2), "test61 case 9 failed\n");
6163         FAILED(supported[4] == SLJIT_SUCCESS && dbuf[3] != 66.725, "test61 case 10 failed\n");
6164         FAILED(supported[4] == SLJIT_SUCCESS && wbuf[4] != (sljit_sw)(dbuf), "test61 case 11 failed\n");
6165         FAILED(supported[5] == SLJIT_SUCCESS && sbuf[3] != -22.125, "test61 case 12 failed\n");
6166         FAILED(supported[5] == SLJIT_SUCCESS && wbuf[5] != (sljit_sw)(sbuf + 3), "test61 case 13 failed\n");
6167
6168         sljit_free_code(code.code, NULL);
6169         successful_tests++;
6170 }
6171
6172 static void test62(void)
6173 {
6174         /* Test fast calls flag preservation. */
6175         executable_code code1;
6176         executable_code code2;
6177         struct sljit_compiler* compiler;
6178
6179         if (verbose)
6180                 printf("Run test62\n");
6181
6182         /* A */
6183         compiler = sljit_create_compiler(NULL, NULL);
6184         FAILED(!compiler, "cannot create compiler\n");
6185         sljit_set_context(compiler, 0, SLJIT_ARGS1(W, W), 1, 1, 0, 0, 0);
6186
6187         sljit_emit_fast_enter(compiler, SLJIT_R0, 0);
6188         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_Z | SLJIT_SET_LESS, SLJIT_S0, 0, SLJIT_IMM, 42);
6189         sljit_emit_op_src(compiler, SLJIT_FAST_RETURN, SLJIT_R0, 0);
6190
6191         code1.code = sljit_generate_code(compiler);
6192         CHECK(compiler);
6193         sljit_free_compiler(compiler);
6194
6195         /* B */
6196         compiler = sljit_create_compiler(NULL, NULL);
6197         FAILED(!compiler, "cannot create compiler\n");
6198
6199         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(W, W), 1, 1, 0, 0, 0);
6200         sljit_emit_ijump(compiler, SLJIT_FAST_CALL, SLJIT_IMM, SLJIT_FUNC_ADDR(code1.code));
6201         sljit_set_current_flags(compiler, SLJIT_CURRENT_FLAGS_ADD_SUB | SLJIT_CURRENT_FLAGS_COMPARE | SLJIT_SET_Z | SLJIT_SET_LESS);
6202         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_ZERO);
6203         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_LESS);
6204         sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_S0, 0, SLJIT_S0, 0, SLJIT_IMM, 1);
6205         sljit_emit_op2(compiler, SLJIT_OR, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_S0, 0);
6206         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_R0, 0);
6207
6208         code2.code = sljit_generate_code(compiler);
6209         CHECK(compiler);
6210         sljit_free_compiler(compiler);
6211
6212         FAILED(code2.func1(88) != 0, "test62 case 1 failed\n");
6213         FAILED(code2.func1(42) != 1, "test62 case 2 failed\n");
6214         FAILED(code2.func1(0) != 2, "test62 case 3 failed\n");
6215
6216         sljit_free_code(code1.code, NULL);
6217         sljit_free_code(code2.code, NULL);
6218         successful_tests++;
6219 }
6220
6221 static void test63(void)
6222 {
6223         /* Test put label. */
6224         executable_code code;
6225         struct sljit_label *label[2];
6226         struct sljit_put_label *put_label[5];
6227         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
6228         sljit_uw addr[2];
6229         sljit_uw buf[4];
6230 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
6231         sljit_sw offs = SLJIT_W(0x123456789012);
6232 #else
6233         sljit_sw offs = 0x12345678;
6234 #endif
6235
6236         if (verbose)
6237                 printf("Run test63\n");
6238
6239         FAILED(!compiler, "cannot create compiler\n");
6240         buf[0] = 0;
6241         buf[1] = 0;
6242         buf[2] = 0;
6243         buf[3] = 0;
6244
6245         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(W, P), 3, 1, 0, 0, 2 * sizeof(sljit_sw));
6246
6247         put_label[0] = sljit_emit_put_label(compiler, SLJIT_R0, 0);
6248         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0);
6249
6250         put_label[1] = sljit_emit_put_label(compiler, SLJIT_MEM1(SLJIT_SP), sizeof(sljit_uw));
6251         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_uw), SLJIT_MEM1(SLJIT_SP), sizeof(sljit_uw));
6252
6253         label[0] = sljit_emit_label(compiler);
6254         sljit_set_put_label(put_label[0], label[0]);
6255         sljit_set_put_label(put_label[1], label[0]);
6256
6257         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)(buf + 2) - offs);
6258         put_label[2] = sljit_emit_put_label(compiler, SLJIT_MEM1(SLJIT_R0), offs);
6259
6260         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, (offs + (sljit_sw)sizeof(sljit_uw)) >> 1);
6261         put_label[3] = sljit_emit_put_label(compiler, SLJIT_MEM2(SLJIT_R0, SLJIT_R1), 1);
6262
6263         label[1] = sljit_emit_label(compiler);
6264         sljit_set_put_label(put_label[2], label[1]);
6265         sljit_set_put_label(put_label[3], label[1]);
6266
6267         put_label[4] = sljit_emit_put_label(compiler, SLJIT_RETURN_REG, 0);
6268         sljit_set_put_label(put_label[4], label[0]);
6269         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);
6270
6271         code.code = sljit_generate_code(compiler);
6272         CHECK(compiler);
6273
6274         addr[0] = sljit_get_label_addr(label[0]);
6275         addr[1] = sljit_get_label_addr(label[1]);
6276
6277         sljit_free_compiler(compiler);
6278
6279         FAILED(code.func1((sljit_sw)&buf) != (sljit_sw)addr[0], "test63 case 1 failed\n");
6280         FAILED(buf[0] != addr[0], "test63 case 2 failed\n");
6281         FAILED(buf[1] != addr[0], "test63 case 3 failed\n");
6282         FAILED(buf[2] != addr[1], "test63 case 4 failed\n");
6283         FAILED(buf[3] != addr[1], "test63 case 5 failed\n");
6284
6285         sljit_free_code(code.code, NULL);
6286         successful_tests++;
6287 }
6288
6289 static void test64(void)
6290 {
6291         /* Test put label with absolute label addresses */
6292         executable_code code;
6293         sljit_uw malloc_addr;
6294         struct sljit_label label[4];
6295         struct sljit_put_label *put_label[2];
6296         struct sljit_compiler* compiler;
6297         sljit_uw buf[5];
6298 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
6299         sljit_sw offs1 = SLJIT_W(0x123456781122);
6300         sljit_sw offs2 = SLJIT_W(0x1234567811223344);
6301 #else /* !SLJIT_64BIT_ARCHITECTURE */
6302         sljit_sw offs1 = 0x12345678;
6303         sljit_sw offs2 = (sljit_sw)0x80000000;
6304 #endif /* SLJIT_64BIT_ARCHITECTURE */
6305
6306         if (verbose)
6307                 printf("Run test64\n");
6308
6309         /* lock next allocation; see sljit_test_malloc_exec() */
6310 #if !(defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED)
6311         malloc_addr = (sljit_uw)SLJIT_MALLOC_EXEC(1024, NULL);
6312
6313         if (!malloc_addr) {
6314                 printf("Cannot allocate executable memory\n");
6315                 return;
6316         }
6317
6318         compiler = sljit_create_compiler(NULL, (void*)malloc_addr);
6319         malloc_addr += (sljit_uw)SLJIT_EXEC_OFFSET((void*)malloc_addr);
6320 #else /* SLJIT_CONFIG_UNSUPPORTED */
6321         malloc_addr = 0;
6322         compiler = sljit_create_compiler(NULL, (void*)malloc_addr);
6323 #endif /* !SLJIT_CONFIG_UNSUPPORTED */
6324
6325         label[0].addr = 0x1234;
6326         label[0].size = (sljit_uw)0x1234 - malloc_addr;
6327
6328         label[1].addr = 0x12345678;
6329         label[1].size = (sljit_uw)0x12345678 - malloc_addr;
6330
6331         label[2].addr = (sljit_uw)offs1;
6332         label[2].size = (sljit_uw)offs1 - malloc_addr;
6333
6334         label[3].addr = (sljit_uw)offs2;
6335         label[3].size = (sljit_uw)offs2 - malloc_addr;
6336
6337         FAILED(!compiler, "cannot create compiler\n");
6338         buf[0] = 0;
6339         buf[1] = 0;
6340         buf[2] = 0;
6341         buf[3] = 0;
6342         buf[4] = 0;
6343
6344         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(W, P), 3, 1, 0, 0, 2 * sizeof(sljit_sw));
6345
6346         put_label[0] = sljit_emit_put_label(compiler, SLJIT_R0, 0);
6347         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0);
6348
6349         put_label[1] = sljit_emit_put_label(compiler, SLJIT_MEM1(SLJIT_SP), sizeof(sljit_uw));
6350         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_uw), SLJIT_MEM1(SLJIT_SP), sizeof(sljit_uw));
6351
6352         sljit_set_put_label(put_label[0], &label[0]);
6353         sljit_set_put_label(put_label[1], &label[0]);
6354
6355         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)(buf + 2) - offs1);
6356         put_label[0] = sljit_emit_put_label(compiler, SLJIT_MEM1(SLJIT_R0), offs1);
6357
6358         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, (offs1 + (sljit_sw)sizeof(sljit_uw)) >> 1);
6359         put_label[1] = sljit_emit_put_label(compiler, SLJIT_MEM2(SLJIT_R0, SLJIT_R1), 1);
6360
6361         sljit_set_put_label(put_label[0], &label[1]);
6362         sljit_set_put_label(put_label[1], &label[1]);
6363
6364         put_label[0] = sljit_emit_put_label(compiler, SLJIT_R2, 0);
6365         sljit_set_put_label(put_label[0], &label[2]);
6366         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_uw), SLJIT_R2, 0);
6367
6368         put_label[0] = sljit_emit_put_label(compiler, SLJIT_RETURN_REG, 0);
6369         sljit_set_put_label(put_label[0], &label[3]);
6370         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);
6371
6372         code.code = sljit_generate_code(compiler);
6373         CHECK(compiler);
6374         sljit_free_compiler(compiler);
6375         SLJIT_ASSERT(SLJIT_FUNC_UADDR(code.code) >= malloc_addr && SLJIT_FUNC_UADDR(code.code) <= malloc_addr + 8);
6376
6377         FAILED(code.func1((sljit_sw)&buf) != (sljit_sw)label[3].addr, "test64 case 1 failed\n");
6378         FAILED(buf[0] != label[0].addr, "test64 case 2 failed\n");
6379         FAILED(buf[1] != label[0].addr, "test64 case 3 failed\n");
6380         FAILED(buf[2] != label[1].addr, "test64 case 4 failed\n");
6381         FAILED(buf[3] != label[1].addr, "test64 case 5 failed\n");
6382         FAILED(buf[4] != label[2].addr, "test64 case 6 failed\n");
6383
6384         sljit_free_code(code.code, NULL);
6385
6386         successful_tests++;
6387 }
6388
6389 static void test65(void)
6390 {
6391         /* Test jump tables. */
6392         executable_code code;
6393         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
6394         sljit_s32 i;
6395         /* Normally this table is allocated on the heap. */
6396         sljit_uw addr[64];
6397         struct sljit_label *labels[64];
6398         struct sljit_jump *jump;
6399
6400         if (verbose)
6401                 printf("Run test65\n");
6402
6403         FAILED(!compiler, "cannot create compiler\n");
6404
6405         sljit_emit_enter(compiler, 0, SLJIT_ARGS2(W, W, W), 1, 2, 0, 0, 0);
6406
6407         jump = sljit_emit_cmp(compiler, SLJIT_GREATER_EQUAL, SLJIT_S0, 0, SLJIT_IMM, 64);
6408         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)addr);
6409         sljit_emit_ijump(compiler, SLJIT_JUMP, SLJIT_MEM2(SLJIT_R0, SLJIT_S0), SLJIT_WORD_SHIFT);
6410
6411         for (i = 0; i < 64; i++) {
6412                 labels[i] = sljit_emit_label(compiler);
6413                 sljit_emit_op0(compiler, SLJIT_ENDBR);
6414                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_S1, 0, SLJIT_IMM, i * 2);
6415                 sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);
6416         }
6417
6418         sljit_set_label(jump, sljit_emit_label(compiler));
6419         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_IMM, -1);
6420
6421         code.code = sljit_generate_code(compiler);
6422         CHECK(compiler);
6423
6424         for (i = 0; i < 64; i++) {
6425                 addr[i] = sljit_get_label_addr(labels[i]);
6426         }
6427
6428         sljit_free_compiler(compiler);
6429
6430         FAILED(code.func2(64, 0) != -1, "test65 case 1 failed\n");
6431
6432         for (i = 0; i < 64; i++) {
6433                 FAILED(code.func2(i, i * 2) != i * 4, "test65 case 2 failed\n");
6434         }
6435
6436         sljit_free_code(code.code, NULL);
6437         successful_tests++;
6438 }
6439
6440 static void test66(void)
6441 {
6442         /* Test direct jumps (computed goto). */
6443         executable_code code;
6444         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
6445         sljit_s32 i;
6446         sljit_uw addr[64];
6447         struct sljit_label *labels[64];
6448
6449         if (verbose)
6450                 printf("Run test66\n");
6451
6452         FAILED(!compiler, "cannot create compiler\n");
6453
6454         sljit_emit_enter(compiler, 0, SLJIT_ARGS2(W, W, W), 1, 2, 0, 0, 0);
6455         sljit_emit_ijump(compiler, SLJIT_JUMP, SLJIT_S0, 0);
6456
6457         for (i = 0; i < 64; i++) {
6458                 labels[i] = sljit_emit_label(compiler);
6459                 sljit_emit_op0(compiler, SLJIT_ENDBR);
6460                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_S1, 0, SLJIT_IMM, i * 2);
6461                 sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);
6462         }
6463
6464         code.code = sljit_generate_code(compiler);
6465         CHECK(compiler);
6466
6467         for (i = 0; i < 64; i++) {
6468                 addr[i] = sljit_get_label_addr(labels[i]);
6469         }
6470
6471         sljit_free_compiler(compiler);
6472
6473         for (i = 0; i < 64; i++) {
6474                 FAILED(code.func2((sljit_sw)addr[i], i) != i * 3, "test66 case 1 failed\n");
6475         }
6476
6477         sljit_free_code(code.code, NULL);
6478         successful_tests++;
6479 }
6480
6481 static void test67(void)
6482 {
6483         /* Test skipping returns from fast calls (return type is fast). */
6484         executable_code code;
6485         struct sljit_compiler *compiler = sljit_create_compiler(NULL, NULL);
6486         struct sljit_jump *call, *jump;
6487         struct sljit_label *label;
6488
6489         if (verbose)
6490                 printf("Run test67\n");
6491
6492         FAILED(!compiler, "cannot create compiler\n");
6493
6494         sljit_emit_enter(compiler, 0, SLJIT_ARGS0(W), 3, 1, 0, 0, 0);
6495
6496         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0);
6497         call = sljit_emit_jump(compiler, SLJIT_FAST_CALL);
6498
6499         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_R0, 0);
6500
6501         /* First function, never returns. */
6502         label = sljit_emit_label(compiler);
6503         sljit_set_label(call, label);
6504         sljit_emit_fast_enter(compiler, SLJIT_R1, 0);
6505
6506         call = sljit_emit_jump(compiler, SLJIT_FAST_CALL);
6507
6508         /* Should never return here, marked by a segmentation fault if it does. */
6509         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM0(), 0);
6510
6511         /* Second function, skips the first function. */
6512         sljit_set_label(call, sljit_emit_label(compiler));
6513         sljit_emit_fast_enter(compiler, SLJIT_R2, 0);
6514
6515         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 1);
6516
6517         jump = sljit_emit_cmp(compiler, SLJIT_NOT_EQUAL, SLJIT_R0, 0, SLJIT_IMM, 1);
6518
6519         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_R1, 0);
6520         sljit_set_label(sljit_emit_jump(compiler, SLJIT_FAST_CALL), label);
6521         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 1);
6522         sljit_emit_op_src(compiler, SLJIT_SKIP_FRAMES_BEFORE_FAST_RETURN, SLJIT_S0, 0);
6523         sljit_emit_op_src(compiler, SLJIT_FAST_RETURN, SLJIT_S0, 0);
6524
6525         sljit_set_label(jump, sljit_emit_label(compiler));
6526         sljit_emit_op_src(compiler, SLJIT_SKIP_FRAMES_BEFORE_FAST_RETURN, SLJIT_R1, 0);
6527         sljit_emit_op_src(compiler, SLJIT_FAST_RETURN, SLJIT_R1, 0);
6528
6529         code.code = sljit_generate_code(compiler);
6530         CHECK(compiler);
6531
6532         sljit_free_compiler(compiler);
6533
6534         FAILED(code.func0() != 3, "test67 case 1 failed\n");
6535
6536         sljit_free_code(code.code, NULL);
6537         successful_tests++;
6538 }
6539
6540 static void test68(void)
6541 {
6542         /* Test skipping returns from fast calls (return type is normal). */
6543         executable_code code;
6544         struct sljit_compiler *compiler;
6545         struct sljit_jump *call, *jump;
6546         struct sljit_label *label;
6547         int i;
6548
6549         if (verbose)
6550                 printf("Run test68\n");
6551
6552         for (i = 0; i < 6; i++) {
6553                 compiler = sljit_create_compiler(NULL, NULL);
6554                 FAILED(!compiler, "cannot create compiler\n");
6555
6556                 sljit_emit_enter(compiler, 0, SLJIT_ARGS0(W), 2 + (i % 6), (i % 6), 0, 0, 0);
6557
6558                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0);
6559                 call = sljit_emit_jump(compiler, SLJIT_FAST_CALL);
6560
6561                 /* Should never return here, marked by a segmentation fault if it does. */
6562                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM0(), 0);
6563
6564                 /* Recursive fast call. */
6565                 label = sljit_emit_label(compiler);
6566                 sljit_set_label(call, label);
6567                 sljit_emit_fast_enter(compiler, SLJIT_R1, 0);
6568
6569                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 1);
6570
6571                 jump = sljit_emit_cmp(compiler, SLJIT_GREATER_EQUAL, SLJIT_R0, 0, SLJIT_IMM, 4);
6572
6573                 sljit_set_label(sljit_emit_jump(compiler, SLJIT_FAST_CALL), label);
6574
6575                 sljit_set_label(jump, sljit_emit_label(compiler));
6576                 sljit_emit_op0(compiler, SLJIT_SKIP_FRAMES_BEFORE_RETURN);
6577                 sljit_emit_return(compiler, SLJIT_MOV, SLJIT_R0, 0);
6578
6579                 code.code = sljit_generate_code(compiler);
6580                 CHECK(compiler);
6581
6582                 sljit_free_compiler(compiler);
6583
6584                 if (SLJIT_UNLIKELY(code.func0() != 4)) {
6585                         printf("test68 case %d failed\n", i + 1);
6586                         return;
6587                 }
6588                 sljit_free_code(code.code, NULL);
6589         }
6590
6591         successful_tests++;
6592 }
6593
6594 static void test69(void)
6595 {
6596         /* Test sljit_set_current_flags. */
6597         executable_code code;
6598         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
6599         sljit_sw buf[8];
6600         sljit_s32 i;
6601
6602         if (verbose)
6603                 printf("Run test69\n");
6604
6605         for (i = 0; i < 8; i++)
6606                 buf[i] = 4;
6607
6608         FAILED(!compiler, "cannot create compiler\n");
6609
6610         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, P), 3, 1, 0, 0, 0);
6611
6612         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)1 << ((sizeof (sljit_sw) * 8) - 2));
6613         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_R0, 0);
6614         sljit_emit_op2(compiler, SLJIT_ADD | SLJIT_SET_OVERFLOW, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_R1, 0);
6615         sljit_emit_label(compiler);
6616         sljit_set_current_flags(compiler, SLJIT_SET_OVERFLOW | SLJIT_CURRENT_FLAGS_ADD_SUB);
6617         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_OVERFLOW);
6618
6619         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 5);
6620         sljit_emit_op2(compiler, SLJIT_ADD | SLJIT_SET_OVERFLOW, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_R1, 0);
6621         sljit_emit_label(compiler);
6622         sljit_set_current_flags(compiler, SLJIT_SET_OVERFLOW | SLJIT_CURRENT_FLAGS_ADD_SUB);
6623         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_OVERFLOW);
6624
6625         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_R0, 0);
6626         sljit_emit_op2(compiler, SLJIT_MUL | SLJIT_SET_OVERFLOW, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_R1, 0);
6627         sljit_emit_label(compiler);
6628         sljit_set_current_flags(compiler, SLJIT_SET_OVERFLOW);
6629         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_OVERFLOW);
6630
6631         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 5);
6632         sljit_emit_op2(compiler, SLJIT_MUL | SLJIT_SET_OVERFLOW, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_R1, 0);
6633         sljit_emit_label(compiler);
6634         sljit_set_current_flags(compiler, SLJIT_SET_OVERFLOW);
6635         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_OVERFLOW);
6636
6637         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 6);
6638         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 5);
6639         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_GREATER, SLJIT_R1, 0, SLJIT_R2, 0);
6640         sljit_emit_label(compiler);
6641         sljit_set_current_flags(compiler, SLJIT_SET_GREATER | SLJIT_CURRENT_FLAGS_ADD_SUB | SLJIT_CURRENT_FLAGS_COMPARE);
6642         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_GREATER);
6643
6644         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_Z, SLJIT_R1, 0, SLJIT_R2, 0);
6645         sljit_emit_label(compiler);
6646         sljit_set_current_flags(compiler, SLJIT_SET_Z | SLJIT_CURRENT_FLAGS_ADD_SUB | SLJIT_CURRENT_FLAGS_COMPARE);
6647         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_ZERO);
6648
6649         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, 1 << 31);
6650         sljit_emit_op2u(compiler, SLJIT_ADD32 | SLJIT_SET_Z, SLJIT_R1, 0, SLJIT_R1, 0);
6651         sljit_emit_label(compiler);
6652         sljit_set_current_flags(compiler, SLJIT_SET_Z | SLJIT_CURRENT_FLAGS_32 | SLJIT_CURRENT_FLAGS_ADD_SUB);
6653         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_sw), SLJIT_ZERO);
6654
6655         sljit_emit_op2u(compiler, SLJIT_SHL32 | SLJIT_SET_Z, SLJIT_R1, 0, SLJIT_IMM, 1);
6656         sljit_emit_label(compiler);
6657         sljit_set_current_flags(compiler, SLJIT_SET_Z | SLJIT_CURRENT_FLAGS_32);
6658         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_sw), SLJIT_NOT_ZERO);
6659
6660         sljit_emit_return_void(compiler);
6661
6662         code.code = sljit_generate_code(compiler);
6663         CHECK(compiler);
6664         sljit_free_compiler(compiler);
6665
6666         code.func1((sljit_sw)&buf);
6667
6668         FAILED(buf[0] != 1, "test69 case 1 failed\n");
6669         FAILED(buf[1] != 2, "test69 case 2 failed\n");
6670         FAILED(buf[2] != 1, "test69 case 3 failed\n");
6671         FAILED(buf[3] != 2, "test69 case 4 failed\n");
6672         FAILED(buf[4] != 1, "test69 case 5 failed\n");
6673         FAILED(buf[5] != 2, "test69 case 6 failed\n");
6674         FAILED(buf[6] != 1, "test69 case 7 failed\n");
6675         FAILED(buf[7] != 2, "test69 case 8 failed\n");
6676
6677         sljit_free_code(code.code, NULL);
6678         successful_tests++;
6679 }
6680
6681 static void test70(void)
6682 {
6683         /* Test argument passing to sljit_emit_enter. */
6684         executable_code code;
6685         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
6686         sljit_sw wbuf[2];
6687         sljit_s32 ibuf[2];
6688         sljit_f64 dbuf[3];
6689         sljit_f32 fbuf[2];
6690
6691         if (verbose)
6692                 printf("Run test70\n");
6693
6694         wbuf[0] = 0;
6695         wbuf[1] = 0;
6696         ibuf[0] = 0;
6697         ibuf[1] = 0;
6698
6699         FAILED(!compiler, "cannot create compiler\n");
6700
6701         sljit_emit_enter(compiler, 0, SLJIT_ARGS4(VOID, 32, W, 32, W), 1, 4, 0, 0, 0);
6702         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&wbuf);
6703         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_S1, 0);
6704         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_sw), SLJIT_S3, 0);
6705         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&ibuf);
6706         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_S0, 0);
6707         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_s32), SLJIT_S2, 0);
6708         sljit_emit_return_void(compiler);
6709
6710         code.code = sljit_generate_code(compiler);
6711         CHECK(compiler);
6712         sljit_free_compiler(compiler);
6713
6714         code.test70_f1(-1478, 9476, 4928, -6832);
6715
6716         FAILED(wbuf[0] != 9476, "test70 case 1 failed\n");
6717         FAILED(wbuf[1] != -6832, "test70 case 2 failed\n");
6718         FAILED(ibuf[0] != -1478, "test70 case 3 failed\n");
6719         FAILED(ibuf[1] != 4928, "test70 case 4 failed\n");
6720
6721         sljit_free_code(code.code, NULL);
6722
6723         compiler = sljit_create_compiler(NULL, NULL);
6724         FAILED(!compiler, "cannot create compiler\n");
6725
6726         sljit_emit_enter(compiler, SLJIT_ENTER_CDECL, SLJIT_ARGS4(VOID, 32, 32, W, W), 1, 4, 0, 0, 0);
6727         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&wbuf);
6728         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_S0, 0);
6729         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_sw), SLJIT_S1, 0);
6730         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&ibuf);
6731         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_S2, 0);
6732         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_s32), SLJIT_S3, 0);
6733         sljit_emit_return_void(compiler);
6734
6735         code.code = sljit_generate_code(compiler);
6736         CHECK(compiler);
6737         sljit_free_compiler(compiler);
6738
6739         code.test70_f2(4721, 7892, -3579, -4830);
6740
6741         FAILED(wbuf[0] != 4721, "test70 case 5 failed\n");
6742         FAILED(wbuf[1] != 7892, "test70 case 6 failed\n");
6743         FAILED(ibuf[0] != -3579, "test70 case 7 failed\n");
6744         FAILED(ibuf[1] != -4830, "test70 case 8 failed\n");
6745
6746         sljit_free_code(code.code, NULL);
6747
6748         if (sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
6749                 wbuf[0] = 0;
6750                 ibuf[0] = 0;
6751                 dbuf[0] = 0;
6752                 fbuf[0] = 0;
6753
6754                 compiler = sljit_create_compiler(NULL, NULL);
6755                 FAILED(!compiler, "cannot create compiler\n");
6756
6757                 sljit_emit_enter(compiler, 0, SLJIT_ARGS4(VOID, 32, F32, W, F64), 2, 2, 2, 0, 0);
6758                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM0(), (sljit_sw)&wbuf, SLJIT_S1, 0);
6759                 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM0(), (sljit_sw)&ibuf, SLJIT_S0, 0);
6760                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM0(), (sljit_sw)&dbuf, SLJIT_FR1, 0);
6761                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM0(), (sljit_sw)&fbuf, SLJIT_FR0, 0);
6762                 sljit_emit_return_void(compiler);
6763
6764                 code.code = sljit_generate_code(compiler);
6765                 CHECK(compiler);
6766                 sljit_free_compiler(compiler);
6767
6768                 code.test70_f3(-6834, 674.5, 2789, -895.25);
6769
6770                 FAILED(wbuf[0] != 2789, "test70 case 9 failed\n");
6771                 FAILED(ibuf[0] != -6834, "test70 case 10 failed\n");
6772                 FAILED(dbuf[0] != -895.25, "test70 case 11 failed\n");
6773                 FAILED(fbuf[0] != 674.5, "test70 case 12 failed\n");
6774
6775                 ibuf[0] = 0;
6776                 dbuf[0] = 0;
6777                 fbuf[0] = 0;
6778                 fbuf[1] = 0;
6779
6780                 compiler = sljit_create_compiler(NULL, NULL);
6781                 FAILED(!compiler, "cannot create compiler\n");
6782
6783                 sljit_emit_enter(compiler, 0, SLJIT_ARGS4(VOID, F32, F64, F32, 32), 1, 1, 3, 0, 0);
6784                 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM0(), (sljit_sw)&ibuf, SLJIT_S0, 0);
6785                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM0(), (sljit_sw)&dbuf, SLJIT_FR1, 0);
6786                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&fbuf);
6787                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_FR0, 0);
6788                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_f32), SLJIT_FR2, 0);
6789                 sljit_emit_return_void(compiler);
6790
6791                 code.code = sljit_generate_code(compiler);
6792                 CHECK(compiler);
6793                 sljit_free_compiler(compiler);
6794
6795                 code.test70_f4(-4712.5, 5342.25, 2904.25, -4607);
6796
6797                 FAILED(ibuf[0] != -4607, "test70 case 13 failed\n");
6798                 FAILED(dbuf[0] != 5342.25, "test70 case 14 failed\n");
6799                 FAILED(fbuf[0] != -4712.5, "test70 case 15 failed\n");
6800                 FAILED(fbuf[1] != 2904.25, "test70 case 16 failed\n");
6801
6802                 ibuf[0] = 0;
6803                 dbuf[0] = 0;
6804                 fbuf[0] = 0;
6805                 fbuf[1] = 0;
6806
6807                 compiler = sljit_create_compiler(NULL, NULL);
6808                 FAILED(!compiler, "cannot create compiler\n");
6809
6810                 sljit_emit_enter(compiler, 0, SLJIT_ARGS4(VOID, F64, F32, 32, F32), 1, 1, 3, 0, 0);
6811                 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM0(), (sljit_sw)&ibuf, SLJIT_S0, 0);
6812                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM0(), (sljit_sw)&dbuf, SLJIT_FR0, 0);
6813                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&fbuf);
6814                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_FR1, 0);
6815                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_f32), SLJIT_FR2, 0);
6816
6817                 sljit_emit_return_void(compiler);
6818
6819                 code.code = sljit_generate_code(compiler);
6820                 CHECK(compiler);
6821                 sljit_free_compiler(compiler);
6822
6823                 code.test70_f5(3578.5, 4619.25, 6859, -1807.75);
6824
6825                 FAILED(ibuf[0] != 6859, "test70 case 17 failed\n");
6826                 FAILED(dbuf[0] != 3578.5, "test70 case 18 failed\n");
6827                 FAILED(fbuf[0] != 4619.25, "test70 case 19 failed\n");
6828                 FAILED(fbuf[1] != -1807.75, "test70 case 20 failed\n");
6829
6830                 ibuf[0] = 0;
6831                 dbuf[0] = 0;
6832                 dbuf[1] = 0;
6833                 fbuf[0] = 0;
6834
6835                 compiler = sljit_create_compiler(NULL, NULL);
6836                 FAILED(!compiler, "cannot create compiler\n");
6837
6838                 sljit_emit_enter(compiler, 0, SLJIT_ARGS4(VOID, F64, 32, F32, F64), SLJIT_NUMBER_OF_SCRATCH_REGISTERS + 2, 1, 3, 0, 33);
6839                 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM0(), (sljit_sw)&ibuf, SLJIT_S0, 0);
6840                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&dbuf);
6841                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_FR0, 0);
6842                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_f64), SLJIT_FR2, 0);
6843                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM0(), (sljit_sw)&fbuf, SLJIT_FR1, 0);
6844                 sljit_emit_return_void(compiler);
6845
6846                 code.code = sljit_generate_code(compiler);
6847                 CHECK(compiler);
6848                 sljit_free_compiler(compiler);
6849
6850                 code.test70_f6(2740.75, -2651, -7909.25, 3671.5);
6851
6852                 FAILED(ibuf[0] != -2651, "test70 case 21 failed\n");
6853                 FAILED(dbuf[0] != 2740.75, "test70 case 22 failed\n");
6854                 FAILED(dbuf[1] != 3671.5, "test70 case 23 failed\n");
6855                 FAILED(fbuf[0] != -7909.25, "test70 case 24 failed\n");
6856
6857                 wbuf[0] = 0;
6858                 ibuf[0] = 0;
6859                 ibuf[1] = 0;
6860                 fbuf[0] = 0;
6861
6862                 compiler = sljit_create_compiler(NULL, NULL);
6863                 FAILED(!compiler, "cannot create compiler\n");
6864
6865                 sljit_emit_enter(compiler, 0, SLJIT_ARGS4(VOID, F32, 32, W, 32), 1, 3, 1, 0, 1);
6866                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM0(), (sljit_sw)&wbuf, SLJIT_S1, 0);
6867                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&ibuf);
6868                 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_S0, 0);
6869                 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_s32), SLJIT_S2, 0);
6870                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM0(), (sljit_sw)&fbuf, SLJIT_FR0, 0);
6871                 sljit_emit_return_void(compiler);
6872
6873                 code.code = sljit_generate_code(compiler);
6874                 CHECK(compiler);
6875                 sljit_free_compiler(compiler);
6876
6877                 code.test70_f7(-5219.25, -4530, 7214, 6741);
6878
6879                 FAILED(wbuf[0] != 7214, "test70 case 25 failed\n");
6880                 FAILED(ibuf[0] != -4530, "test70 case 26 failed\n");
6881                 FAILED(ibuf[1] != 6741, "test70 case 27 failed\n");
6882                 FAILED(fbuf[0] != -5219.25, "test70 case 28 failed\n");
6883
6884                 wbuf[0] = 0;
6885                 wbuf[1] = 0;
6886                 dbuf[0] = 0;
6887                 dbuf[1] = 0;
6888
6889                 compiler = sljit_create_compiler(NULL, NULL);
6890                 FAILED(!compiler, "cannot create compiler\n");
6891
6892                 sljit_emit_enter(compiler, 0, SLJIT_ARGS4(VOID, F64, F64, W, W), 1, 5, 2, 0, SLJIT_MAX_LOCAL_SIZE - 1);
6893                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), 0, SLJIT_S0, 0);
6894                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_SP), SLJIT_MAX_LOCAL_SIZE - 2 * sizeof(sljit_f64), SLJIT_FR0, 0);
6895                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&wbuf);
6896                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_S0, 0);
6897                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_sw), SLJIT_S1, 0);
6898                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&dbuf);
6899                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_FR0, 0);
6900                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_f64), SLJIT_FR1, 0);
6901                 sljit_emit_return_void(compiler);
6902
6903                 code.code = sljit_generate_code(compiler);
6904                 CHECK(compiler);
6905                 sljit_free_compiler(compiler);
6906
6907                 code.test70_f8(-3749.75, 5280.5, 9134, -6506);
6908
6909                 FAILED(wbuf[0] != 9134, "test70 case 29 failed\n");
6910                 FAILED(wbuf[1] != -6506, "test70 case 30 failed\n");
6911                 FAILED(dbuf[0] != -3749.75, "test70 case 31 failed\n");
6912                 FAILED(dbuf[1] != 5280.5, "test70 case 32 failed\n");
6913
6914                 wbuf[0] = 0;
6915                 dbuf[0] = 0;
6916                 dbuf[1] = 0;
6917                 dbuf[2] = 0;
6918
6919                 compiler = sljit_create_compiler(NULL, NULL);
6920                 FAILED(!compiler, "cannot create compiler\n");
6921
6922                 sljit_emit_enter(compiler, 0, SLJIT_ARGS4(VOID, F64, F64, W, F64), 1, 1, 3, 0, SLJIT_MAX_LOCAL_SIZE);
6923                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM0(), (sljit_sw)&wbuf, SLJIT_S0, 0);
6924                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&dbuf);
6925                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_FR0, 0);
6926                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_f64), SLJIT_FR1, 0);
6927                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_R0), 2 * sizeof(sljit_f64), SLJIT_FR2, 0);
6928
6929                 sljit_emit_return_void(compiler);
6930
6931                 code.code = sljit_generate_code(compiler);
6932                 CHECK(compiler);
6933                 sljit_free_compiler(compiler);
6934
6935                 code.test70_f9(-6049.25, 7301.5, 4610, -4312.75);
6936
6937                 FAILED(wbuf[0] != 4610, "test70 case 33 failed\n");
6938                 FAILED(dbuf[0] != -6049.25, "test70 case 34 failed\n");
6939                 FAILED(dbuf[1] != 7301.5, "test70 case 35 failed\n");
6940                 FAILED(dbuf[2] != -4312.75, "test70 case 36 failed\n");
6941
6942                 ibuf[0] = 0;
6943                 dbuf[0] = 0;
6944                 dbuf[1] = 0;
6945                 dbuf[2] = 0;
6946
6947                 compiler = sljit_create_compiler(NULL, NULL);
6948                 FAILED(!compiler, "cannot create compiler\n");
6949
6950                 sljit_emit_enter(compiler, 0, SLJIT_ARGS4(VOID, F64, F64, F64, 32), 1, 1, 3, 0, 0);
6951                 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM0(), (sljit_sw)&ibuf, SLJIT_S0, 0);
6952                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&dbuf);
6953                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_FR0, 0);
6954                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_f64), SLJIT_FR1, 0);
6955                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_R0), 2 * sizeof(sljit_f64), SLJIT_FR2, 0);
6956
6957                 sljit_emit_return_void(compiler);
6958
6959                 code.code = sljit_generate_code(compiler);
6960                 CHECK(compiler);
6961                 sljit_free_compiler(compiler);
6962
6963                 code.test70_f10(4810.5, -9148.75, 8601.25, 6703);
6964
6965                 FAILED(ibuf[0] != 6703, "test70 case 37 failed\n");
6966                 FAILED(dbuf[0] != 4810.5, "test70 case 38 failed\n");
6967                 FAILED(dbuf[1] != -9148.75, "test70 case 39 failed\n");
6968                 FAILED(dbuf[2] != 8601.25, "test70 case 40 failed\n");
6969         }
6970
6971         successful_tests++;
6972 }
6973
6974 #if !(defined SLJIT_CONFIG_SPARC && SLJIT_CONFIG_SPARC)
6975
6976 static sljit_sw SLJIT_FUNC test71_f1(sljit_sw a)
6977 {
6978         return a + 10000;
6979 }
6980
6981 static sljit_sw SLJIT_FUNC test71_f2(sljit_sw a, sljit_s32 b, sljit_s32 c, sljit_sw d)
6982 {
6983         return a | b | c | d;
6984 }
6985
6986 static sljit_sw test71_f3(sljit_sw a, sljit_s32 b, sljit_s32 c, sljit_sw d)
6987 {
6988         return a | b | c | d;
6989 }
6990
6991 static sljit_sw test71_f4(sljit_sw a, sljit_s32 b, sljit_s32 c, sljit_sw d)
6992 {
6993         SLJIT_UNUSED_ARG(a);
6994         return b | c | d;
6995 }
6996
6997 static sljit_sw test71_f5(void)
6998 {
6999         return 7461932;
7000 }
7001
7002 static sljit_sw SLJIT_FUNC test71_f6(sljit_f64 a, sljit_f64 b, sljit_f64 c, sljit_f64 d)
7003 {
7004         if (a == 1345.5 && b == -8724.25 && c == 9034.75 && d == 6307.5)
7005                 return 8920567;
7006         return 0;
7007 }
7008
7009 static sljit_sw SLJIT_FUNC test71_f7(sljit_f64 a, sljit_f64 b, sljit_f64 c, sljit_sw d)
7010 {
7011         if (a == 4061.25 && b == -3291.75 && c == 8703.5 && d == 1706)
7012                 return 5074526;
7013         return 0;
7014 }
7015
7016 #endif /* !SLJIT_CONFIG_SPARC */
7017
7018 static void test71(void)
7019 {
7020 #if !(defined SLJIT_CONFIG_SPARC && SLJIT_CONFIG_SPARC)
7021         /* Test tail calls. */
7022         executable_code code;
7023         struct sljit_compiler* compiler;
7024         struct sljit_jump *jump;
7025         sljit_uw jump_addr;
7026         sljit_sw executable_offset;
7027         sljit_sw wbuf[1];
7028         sljit_f64 dbuf[4];
7029
7030         if (verbose)
7031                 printf("Run test71\n");
7032
7033         /* Next test. */
7034
7035         compiler = sljit_create_compiler(NULL, NULL);
7036         FAILED(!compiler, "cannot create compiler\n");
7037
7038         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(W, W), 4, 4, 0, 0, 0);
7039         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_S0, 0);
7040         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0);
7041         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 0);
7042         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, 0);
7043         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, -1);
7044         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_IMM, -1);
7045         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, -1);
7046         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S3, 0, SLJIT_IMM, -1);
7047         sljit_emit_icall(compiler, SLJIT_CALL | SLJIT_CALL_RETURN, SLJIT_ARGS1(W, W), SLJIT_IMM, SLJIT_FUNC_ADDR(test71_f1));
7048         /* Should crash. */
7049         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM0(), 0);
7050
7051         code.code = sljit_generate_code(compiler);
7052         CHECK(compiler);
7053         sljit_free_compiler(compiler);
7054
7055         FAILED(code.func1(7987) != 17987, "test71 case 1 failed\n");
7056
7057         /* Next test. */
7058
7059         compiler = sljit_create_compiler(NULL, NULL);
7060         FAILED(!compiler, "cannot create compiler\n");
7061
7062         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(W, W), 1, 4, 0, 0, 0);
7063         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_S0, 0);
7064         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, -1);
7065         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_IMM, -1);
7066         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, -1);
7067         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S3, 0, SLJIT_IMM, -1);
7068         jump = sljit_emit_call(compiler, SLJIT_CALL | SLJIT_REWRITABLE_JUMP | SLJIT_CALL_RETURN, SLJIT_ARGS1(W, W));
7069         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM0(), 0);
7070
7071         sljit_set_target(jump, 0);
7072
7073         code.code = sljit_generate_code(compiler);
7074         CHECK(compiler);
7075
7076         executable_offset = sljit_get_executable_offset(compiler);
7077         jump_addr = sljit_get_jump_addr(jump);
7078         sljit_free_compiler(compiler);
7079
7080         sljit_set_jump_addr(jump_addr, SLJIT_FUNC_UADDR(test71_f1), executable_offset);
7081
7082         FAILED(code.func1(3903) != 13903, "test71 case 2 failed\n");
7083
7084         /* Next test. */
7085
7086         compiler = sljit_create_compiler(NULL, NULL);
7087         FAILED(!compiler, "cannot create compiler\n");
7088
7089         sljit_emit_enter(compiler, 0, SLJIT_ARGS0(W), 4, 2, 0, 0, SLJIT_MAX_LOCAL_SIZE);
7090         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), 0, SLJIT_IMM, SLJIT_FUNC_ADDR(test71_f2));
7091         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0x28000000);
7092         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, 0x00140000);
7093         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R2, 0, SLJIT_IMM, 0x00002800);
7094         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, 0x00000041);
7095         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, -1);
7096         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_IMM, -1);
7097         sljit_emit_icall(compiler, SLJIT_CALL | SLJIT_CALL_RETURN, SLJIT_ARGS4(W, W, 32, 32, W), SLJIT_MEM1(SLJIT_SP), 0);
7098         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM0(), 0);
7099
7100         code.code = sljit_generate_code(compiler);
7101         CHECK(compiler);
7102         sljit_free_compiler(compiler);
7103
7104         FAILED(code.func0() != 0x28142841, "test71 case 3 failed\n");
7105
7106         /* Next test. */
7107
7108         compiler = sljit_create_compiler(NULL, NULL);
7109         FAILED(!compiler, "cannot create compiler\n");
7110
7111         sljit_emit_enter(compiler, SLJIT_ENTER_CDECL, SLJIT_ARGS4(W, W, 32, 32, W), 4, 4, 0, 0, 9);
7112         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_S0, 0);
7113         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_S1, 0);
7114         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R2, 0, SLJIT_S2, 0);
7115         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_S3, 0);
7116         sljit_emit_icall(compiler, SLJIT_CALL | SLJIT_CALL_RETURN, SLJIT_ARGS4(W, W, 32, 32, W), SLJIT_IMM, SLJIT_FUNC_ADDR(test71_f2));
7117         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM0(), 0);
7118
7119         code.code = sljit_generate_code(compiler);
7120         CHECK(compiler);
7121         sljit_free_compiler(compiler);
7122
7123         FAILED(code.test71_f1(0x650000, 0x13, 0x8400, 0x29000000) != 0x29658413, "test71 case 4 failed\n");
7124
7125         sljit_free_code(code.code, NULL);
7126
7127         /* Next test. */
7128
7129         compiler = sljit_create_compiler(NULL, NULL);
7130         FAILED(!compiler, "cannot create compiler\n");
7131
7132         sljit_emit_enter(compiler, 0, SLJIT_ARGS0(W), 4, 4, 0, 0, SLJIT_MAX_LOCAL_SIZE);
7133         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S3, 0, SLJIT_IMM, SLJIT_FUNC_ADDR(test71_f2));
7134         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)0x81000000);
7135         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, 0x00480000);
7136         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R2, 0, SLJIT_IMM, 0x00002100);
7137         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, 0x00000014);
7138         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, -1);
7139         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_IMM, -1);
7140         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, -1);
7141         sljit_emit_icall(compiler, SLJIT_CALL | SLJIT_CALL_RETURN, SLJIT_ARGS4(W, W, 32, 32, W), SLJIT_S3, 0);
7142         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM0(), 0);
7143
7144         code.code = sljit_generate_code(compiler);
7145         CHECK(compiler);
7146         sljit_free_compiler(compiler);
7147
7148         FAILED(code.func0() != (sljit_sw)0x81482114, "test71 case 5 failed\n");
7149
7150         sljit_free_code(code.code, NULL);
7151
7152         /* Next test. */
7153
7154         compiler = sljit_create_compiler(NULL, NULL);
7155         FAILED(!compiler, "cannot create compiler\n");
7156
7157         sljit_emit_enter(compiler, 0, SLJIT_ARGS3(W, W, W, W), 4, 4, 0, 0, 0);
7158         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_S0, 0);
7159         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_S1, 0);
7160         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R2, 0, SLJIT_S2, 0);
7161         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, 0x48000000);
7162         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, -1);
7163         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_IMM, -1);
7164         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, -1);
7165         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S3, 0, SLJIT_IMM, -1);
7166         sljit_emit_icall(compiler, SLJIT_CALL_CDECL | SLJIT_CALL_RETURN, SLJIT_ARGS4(W, W, 32, 32, W), SLJIT_IMM, SLJIT_FUNC_ADDR(test71_f3));
7167         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM0(), 0);
7168
7169         code.code = sljit_generate_code(compiler);
7170         CHECK(compiler);
7171         sljit_free_compiler(compiler);
7172
7173         FAILED(code.func3(0x12, 0x8800, 0x240000) != 0x48248812, "test71 case 6 failed\n");
7174
7175         sljit_free_code(code.code, NULL);
7176
7177         /* Next test. */
7178
7179         compiler = sljit_create_compiler(NULL, NULL);
7180         FAILED(!compiler, "cannot create compiler\n");
7181
7182         sljit_emit_enter(compiler, SLJIT_ENTER_CDECL, SLJIT_ARGS0(W), 4, 0, 0, 0, 0);
7183         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_FUNC_ADDR(test71_f4));
7184         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, 0x342);
7185         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R2, 0, SLJIT_IMM, 0x451000);
7186         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, 0x21000000);
7187         sljit_emit_icall(compiler, SLJIT_CALL_CDECL | SLJIT_CALL_RETURN, SLJIT_ARGS4(W, W, 32, 32, W), SLJIT_R0, 0);
7188         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM0(), 0);
7189
7190         code.code = sljit_generate_code(compiler);
7191         CHECK(compiler);
7192         sljit_free_compiler(compiler);
7193
7194         FAILED(code.func0() != 0x21451342, "test71 case 7 failed\n");
7195
7196         sljit_free_code(code.code, NULL);
7197
7198         /* Next test. */
7199
7200         compiler = sljit_create_compiler(NULL, NULL);
7201         FAILED(!compiler, "cannot create compiler\n");
7202
7203         sljit_emit_enter(compiler, SLJIT_ENTER_CDECL, SLJIT_ARGS0(W), 1, 0, 0, 0, 9);
7204         sljit_emit_icall(compiler, SLJIT_CALL_CDECL | SLJIT_CALL_RETURN, SLJIT_ARGS0(W), SLJIT_IMM, SLJIT_FUNC_ADDR(test71_f5));
7205         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM0(), 0);
7206
7207         code.code = sljit_generate_code(compiler);
7208         CHECK(compiler);
7209         sljit_free_compiler(compiler);
7210
7211         FAILED(code.func0() != 7461932, "test71 case 8 failed\n");
7212
7213         sljit_free_code(code.code, NULL);
7214
7215         if (sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
7216                 /* Next test. */
7217
7218                 dbuf[0] = 9034.75;
7219                 dbuf[1] = 6307.5;
7220
7221                 compiler = sljit_create_compiler(NULL, NULL);
7222                 FAILED(!compiler, "cannot create compiler\n");
7223
7224                 sljit_emit_enter(compiler, SLJIT_ENTER_CDECL, SLJIT_ARGS2(W, F64, F64), 1, 1, 4, 0, 0);
7225                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&dbuf);
7226                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_R0), 0);
7227                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR3, 0, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_f64));
7228                 sljit_emit_icall(compiler, SLJIT_CALL | SLJIT_CALL_RETURN, SLJIT_ARGS4(W, F64, F64, F64, F64), SLJIT_IMM, SLJIT_FUNC_ADDR(test71_f6));
7229                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM0(), 0);
7230
7231                 code.code = sljit_generate_code(compiler);
7232                 CHECK(compiler);
7233                 sljit_free_compiler(compiler);
7234
7235                 FAILED(code.test71_f2(1345.5, -8724.25) != 8920567, "test71 case 9 failed\n");
7236
7237                 sljit_free_code(code.code, NULL);
7238
7239                 /* Next test. */
7240
7241                 wbuf[0] = SLJIT_FUNC_ADDR(test71_f6);
7242
7243                 compiler = sljit_create_compiler(NULL, NULL);
7244                 FAILED(!compiler, "cannot create compiler\n");
7245
7246                 sljit_emit_enter(compiler, 0, SLJIT_ARGS4(W, F64, F64, F64, F64), 1, 0, 4, 0, 0);
7247                 sljit_emit_icall(compiler, SLJIT_CALL | SLJIT_CALL_RETURN, SLJIT_ARGS4(W, F64, F64, F64, F64), SLJIT_MEM0(), (sljit_sw)wbuf);
7248                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM0(), 0);
7249
7250                 code.code = sljit_generate_code(compiler);
7251                 CHECK(compiler);
7252                 sljit_free_compiler(compiler);
7253
7254                 FAILED(code.test71_f3(1345.5, -8724.25, 9034.75, 6307.5) != 8920567, "test71 case 10 failed\n");
7255
7256                 sljit_free_code(code.code, NULL);
7257
7258                 /* Next test. */
7259
7260                 compiler = sljit_create_compiler(NULL, NULL);
7261                 FAILED(!compiler, "cannot create compiler\n");
7262
7263                 sljit_emit_enter(compiler, 0, SLJIT_ARGS3(W, F64, F64, F64), 1, 0, 4, 0, 0);
7264                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 1706);
7265                 jump = sljit_emit_call(compiler, SLJIT_CALL | SLJIT_CALL_RETURN, SLJIT_ARGS4(W, F64, F64, F64, W));
7266                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM0(), 0);
7267
7268                 sljit_set_target(jump, SLJIT_FUNC_UADDR(test71_f7));
7269
7270                 code.code = sljit_generate_code(compiler);
7271                 CHECK(compiler);
7272                 sljit_free_compiler(compiler);
7273
7274                 FAILED(code.test71_f4(4061.25, -3291.75, 8703.5) != 5074526, "test71 case 11 failed\n");
7275
7276                 sljit_free_code(code.code, NULL);
7277
7278                 /* Next test. */
7279
7280                 compiler = sljit_create_compiler(NULL, NULL);
7281                 FAILED(!compiler, "cannot create compiler\n");
7282
7283                 sljit_emit_enter(compiler, 0, SLJIT_ARGS3(W, F64, F64, F64), SLJIT_NUMBER_OF_SCRATCH_REGISTERS + 1, 0, 4, 0, 0);
7284                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 1706);
7285                 jump = sljit_emit_call(compiler, SLJIT_CALL | SLJIT_CALL_RETURN, SLJIT_ARGS4(W, F64, F64, F64, W));
7286                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM0(), 0);
7287
7288                 sljit_set_target(jump, SLJIT_FUNC_UADDR(test71_f7));
7289
7290                 code.code = sljit_generate_code(compiler);
7291                 CHECK(compiler);
7292                 sljit_free_compiler(compiler);
7293
7294                 FAILED(code.test71_f4(4061.25, -3291.75, 8703.5) != 5074526, "test71 case 12 failed\n");
7295
7296                 sljit_free_code(code.code, NULL);
7297
7298                 /* Next test. */
7299
7300                 compiler = sljit_create_compiler(NULL, NULL);
7301                 FAILED(!compiler, "cannot create compiler\n");
7302
7303                 sljit_emit_enter(compiler, 0, SLJIT_ARGS3(W, F64, F64, F64), SLJIT_NUMBER_OF_SCRATCH_REGISTERS + 1, 1, 3, 0, SLJIT_MAX_LOCAL_SIZE);
7304                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 1706);
7305                 jump = sljit_emit_call(compiler, SLJIT_CALL | SLJIT_CALL_RETURN, SLJIT_ARGS4(W, F64, F64, F64, W));
7306                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM0(), 0);
7307
7308                 sljit_set_target(jump, SLJIT_FUNC_UADDR(test71_f7));
7309
7310                 code.code = sljit_generate_code(compiler);
7311                 CHECK(compiler);
7312                 sljit_free_compiler(compiler);
7313
7314                 FAILED(code.test71_f4(4061.25, -3291.75, 8703.5) != 5074526, "test71 case 13 failed\n");
7315
7316                 sljit_free_code(code.code, NULL);
7317         }
7318 #endif /* !SLJIT_CONFIG_SPARC */
7319
7320         successful_tests++;
7321 }
7322
7323 static void test72(void)
7324 {
7325         /* Test using all fpu registers. */
7326         executable_code code;
7327         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
7328         sljit_f64 buf[SLJIT_NUMBER_OF_FLOAT_REGISTERS];
7329         sljit_f64 buf2[2];
7330         struct sljit_jump *jump;
7331         sljit_s32 i;
7332
7333         if (verbose)
7334                 printf("Run test72\n");
7335
7336         if (!sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
7337                 if (verbose)
7338                         printf("no fpu available, test72 skipped\n");
7339                 successful_tests++;
7340                 if (compiler)
7341                         sljit_free_compiler(compiler);
7342                 return;
7343         }
7344
7345         /* Next test. */
7346         FAILED(!compiler, "cannot create compiler\n");
7347
7348         buf2[0] = 7.75;
7349         buf2[1] = -8.25;
7350
7351         for (i = 0; i < SLJIT_NUMBER_OF_FLOAT_REGISTERS; i++)
7352                 buf[i] = 0.0;
7353
7354         sljit_emit_enter(compiler, 0, SLJIT_ARGS2(VOID, P, P), 1, 2, SLJIT_NUMBER_OF_FLOAT_REGISTERS, 0, 0);
7355         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S1), 0);
7356         for (i = 1; i < SLJIT_NUMBER_OF_FLOAT_REGISTERS; i++)
7357                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR(i), 0, SLJIT_FR0, 0);
7358
7359         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_S1, 0);
7360         jump = sljit_emit_call(compiler, SLJIT_CALL, SLJIT_ARGS1(VOID, W));
7361
7362         for (i = 0; i < SLJIT_NUMBER_OF_FLOAT_REGISTERS; i++)
7363                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), i * (sljit_sw)sizeof(sljit_f64), SLJIT_FR(i), 0);
7364         sljit_emit_return_void(compiler);
7365
7366         /* Called function. */
7367         sljit_set_label(jump, sljit_emit_label(compiler));
7368         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, P), 0, 1, SLJIT_NUMBER_OF_FLOAT_REGISTERS, 0, 0);
7369
7370         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64));
7371         for (i = 1; i < SLJIT_NUMBER_OF_FLOAT_REGISTERS; i++)
7372                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR(i), 0, SLJIT_FR0, 0);
7373
7374         sljit_set_context(compiler, 0, SLJIT_ARGS1(VOID, P), 0, 1, SLJIT_NUMBER_OF_FLOAT_REGISTERS, 0, 0);
7375         sljit_emit_return_void(compiler);
7376
7377         code.code = sljit_generate_code(compiler);
7378         CHECK(compiler);
7379         sljit_free_compiler(compiler);
7380
7381         code.func2((sljit_sw)buf, (sljit_sw)buf2);
7382
7383         for (i = 0; i < SLJIT_NUMBER_OF_SCRATCH_FLOAT_REGISTERS; i++) {
7384                 FAILED(buf[i] != -8.25, "test72 case 1 failed\n");
7385         }
7386
7387         for (i = SLJIT_NUMBER_OF_SCRATCH_FLOAT_REGISTERS; i < SLJIT_NUMBER_OF_FLOAT_REGISTERS; i++) {
7388                 FAILED(buf[i] != 7.75, "test72 case 2 failed\n");
7389         }
7390
7391         sljit_free_code(code.code, NULL);
7392
7393         /* Next test. */
7394         if (SLJIT_NUMBER_OF_SAVED_FLOAT_REGISTERS >= 3) {
7395                 compiler = sljit_create_compiler(NULL, NULL);
7396                 FAILED(!compiler, "cannot create compiler\n");
7397
7398                 buf2[0] = -6.25;
7399                 buf2[1] = 3.75;
7400
7401                 for (i = 0; i < SLJIT_NUMBER_OF_FLOAT_REGISTERS; i++)
7402                         buf[i] = 0.0;
7403
7404                 sljit_emit_enter(compiler, 0, SLJIT_ARGS2(VOID, P, P), 1, 2, SLJIT_NUMBER_OF_FLOAT_REGISTERS - 2, 1, SLJIT_MAX_LOCAL_SIZE);
7405                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FS0, 0, SLJIT_MEM1(SLJIT_S1), 0);
7406                 for (i = 0; i < SLJIT_NUMBER_OF_FLOAT_REGISTERS - 2; i++)
7407                         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR(i), 0, SLJIT_FS0, 0);
7408
7409                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_S1, 0);
7410                 jump = sljit_emit_call(compiler, SLJIT_CALL, SLJIT_ARGS1(VOID, W));
7411
7412                 for (i = 0; i < SLJIT_NUMBER_OF_FLOAT_REGISTERS - 2; i++)
7413                         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), i * (sljit_sw)sizeof(sljit_f64), SLJIT_FR(i), 0);
7414                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), (SLJIT_NUMBER_OF_FLOAT_REGISTERS - 1) * (sljit_sw)sizeof(sljit_f64), SLJIT_FS0, 0);
7415                 sljit_emit_return_void(compiler);
7416
7417                 /* Called function. */
7418                 sljit_set_label(jump, sljit_emit_label(compiler));
7419                 sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, P), 0, 1, SLJIT_NUMBER_OF_FLOAT_REGISTERS, 0, SLJIT_MAX_LOCAL_SIZE);
7420
7421                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64));
7422                 for (i = 1; i < SLJIT_NUMBER_OF_FLOAT_REGISTERS; i++)
7423                         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR(i), 0, SLJIT_FR0, 0);
7424
7425                 sljit_set_context(compiler, 0, SLJIT_ARGS1(VOID, P), 0, 1, SLJIT_NUMBER_OF_FLOAT_REGISTERS, 0, SLJIT_MAX_LOCAL_SIZE);
7426                 sljit_emit_return_void(compiler);
7427
7428                 code.code = sljit_generate_code(compiler);
7429                 CHECK(compiler);
7430                 sljit_free_compiler(compiler);
7431
7432                 code.func2((sljit_sw)buf, (sljit_sw)buf2);
7433
7434                 for (i = 0; i < SLJIT_NUMBER_OF_SCRATCH_FLOAT_REGISTERS; i++) {
7435                         FAILED(buf[i] != 3.75, "test72 case 3 failed\n");
7436                 }
7437
7438                 for (i = SLJIT_NUMBER_OF_SCRATCH_FLOAT_REGISTERS; i < SLJIT_NUMBER_OF_FLOAT_REGISTERS - 2; i++) {
7439                         FAILED(buf[i] != -6.25, "test72 case 4 failed\n");
7440                 }
7441
7442                 FAILED(buf[SLJIT_NUMBER_OF_FLOAT_REGISTERS - 2] != 0, "test72 case 5 failed\n");
7443                 FAILED(buf[SLJIT_NUMBER_OF_FLOAT_REGISTERS - 1] != -6.25, "test72 case 6 failed\n");
7444
7445                 sljit_free_code(code.code, NULL);
7446         }
7447         successful_tests++;
7448 }
7449
7450 static void test73(void)
7451 {
7452         /* Test tail calls. */
7453         executable_code code;
7454         struct sljit_compiler* compiler;
7455         sljit_sw wbuf[2];
7456         sljit_s32 ibuf[2];
7457         sljit_f64 dbuf[3];
7458
7459         if (verbose)
7460                 printf("Run test73\n");
7461
7462         /* Next test. */
7463
7464         compiler = sljit_create_compiler(NULL, NULL);
7465         FAILED(!compiler, "cannot create compiler\n");
7466
7467         sljit_emit_enter(compiler, 0, SLJIT_ARGS4(VOID, 32_R, W, W_R, 32), 3, 2, 0, 0, 0);
7468         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, (sljit_sw)&wbuf);
7469         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), 0, SLJIT_S0, 0);
7470         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), sizeof(sljit_sw), SLJIT_R2, 0);
7471         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, (sljit_sw)&ibuf);
7472         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_R1), 0, SLJIT_R0, 0);
7473         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_R1), sizeof(sljit_s32), SLJIT_S1, 0);
7474         sljit_emit_return_void(compiler);
7475
7476         code.code = sljit_generate_code(compiler);
7477         CHECK(compiler);
7478         sljit_free_compiler(compiler);
7479
7480         code.test73_f1(3467, -6781, 5038, 6310);
7481
7482         FAILED(wbuf[0] != -6781, "test73 case 1 failed\n");
7483         FAILED(wbuf[1] != 5038, "test73 case 2 failed\n");
7484         FAILED(ibuf[0] != 3467, "test73 case 3 failed\n");
7485         FAILED(ibuf[1] != 6310, "test73 case 4 failed\n");
7486         sljit_free_code(code.code, NULL);
7487
7488         /* Next test. */
7489
7490         compiler = sljit_create_compiler(NULL, NULL);
7491         FAILED(!compiler, "cannot create compiler\n");
7492
7493         sljit_emit_enter(compiler, 0, SLJIT_ARGS4(VOID, 32, W_R, W, 32_R), 4, 2, 0, 0, 8192);
7494         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&wbuf);
7495         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_R1, 0);
7496         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_sw), SLJIT_S1, 0);
7497         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&ibuf);
7498         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_S0, 0);
7499         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_s32), SLJIT_R3, 0);
7500         sljit_emit_return_void(compiler);
7501
7502         code.code = sljit_generate_code(compiler);
7503         CHECK(compiler);
7504         sljit_free_compiler(compiler);
7505
7506         code.test73_f1(-9723, 5208, 4761, 5084);
7507
7508         FAILED(wbuf[0] != 5208, "test73 case 5 failed\n");
7509         FAILED(wbuf[1] != 4761, "test73 case 6 failed\n");
7510         FAILED(ibuf[0] != -9723, "test73 case 7 failed\n");
7511         FAILED(ibuf[1] != 5084, "test73 case 8 failed\n");
7512         sljit_free_code(code.code, NULL);
7513
7514         /* Next test. */
7515
7516         compiler = sljit_create_compiler(NULL, NULL);
7517         FAILED(!compiler, "cannot create compiler\n");
7518
7519         sljit_emit_enter(compiler, 0, SLJIT_ARGS4(VOID, 32_R, W_R, W_R, 32_R), 4, 1, 0, 0, SLJIT_MAX_LOCAL_SIZE);
7520         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, (sljit_sw)&wbuf);
7521         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R1, 0);
7522         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_R2, 0);
7523         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, (sljit_sw)&ibuf);
7524         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0);
7525         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_s32), SLJIT_R3, 0);
7526         sljit_emit_return_void(compiler);
7527
7528         code.code = sljit_generate_code(compiler);
7529         CHECK(compiler);
7530         sljit_free_compiler(compiler);
7531
7532         code.test73_f1(5934, 6043, -8572, -3861);
7533
7534         FAILED(wbuf[0] != 6043, "test73 case 9 failed\n");
7535         FAILED(wbuf[1] != -8572, "test73 case 10 failed\n");
7536         FAILED(ibuf[0] != 5934, "test73 case 11 failed\n");
7537         FAILED(ibuf[1] != -3861, "test73 case 12 failed\n");
7538         sljit_free_code(code.code, NULL);
7539
7540         /* Next test. */
7541
7542         compiler = sljit_create_compiler(NULL, NULL);
7543         FAILED(!compiler, "cannot create compiler\n");
7544
7545         sljit_emit_enter(compiler, SLJIT_ENTER_CDECL, SLJIT_ARGS4(VOID, W_R, W_R, 32_R, 32_R), 4, 1, 0, 0, SLJIT_MAX_LOCAL_SIZE);
7546         sljit_set_context(compiler, SLJIT_ENTER_CDECL, SLJIT_ARGS4(VOID, W_R, W_R, 32_R, 32_R), 4, 1, 0, 0, SLJIT_MAX_LOCAL_SIZE);
7547         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, (sljit_sw)&wbuf);
7548         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0);
7549         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_R1, 0);
7550         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, (sljit_sw)&ibuf);
7551         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R2, 0);
7552         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_s32), SLJIT_R3, 0);
7553         sljit_emit_return_void(compiler);
7554
7555         code.code = sljit_generate_code(compiler);
7556         CHECK(compiler);
7557         sljit_free_compiler(compiler);
7558
7559         code.test73_f2(6732, -5916, 2740, -3621);
7560
7561         FAILED(wbuf[0] != 6732, "test73 case 13 failed\n");
7562         FAILED(wbuf[1] != -5916, "test73 case 14 failed\n");
7563         FAILED(ibuf[0] != 2740, "test73 case 15 failed\n");
7564         FAILED(ibuf[1] != -3621, "test73 case 16 failed\n");
7565         sljit_free_code(code.code, NULL);
7566
7567         if (sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
7568                 /* Next test. */
7569
7570                 compiler = sljit_create_compiler(NULL, NULL);
7571                 FAILED(!compiler, "cannot create compiler\n");
7572
7573                 sljit_emit_enter(compiler, 0, SLJIT_ARGS4(VOID, F64, F64, F64, W_R), 1, 0, 3, 0, SLJIT_MAX_LOCAL_SIZE);
7574                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM0(), (sljit_sw)&wbuf, SLJIT_R0, 0);
7575                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&dbuf);
7576                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_FR0, 0);
7577                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_f64), SLJIT_FR1, 0);
7578                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_R0), 2 * sizeof(sljit_f64), SLJIT_FR2, 0);
7579
7580                 sljit_emit_return_void(compiler);
7581
7582                 code.code = sljit_generate_code(compiler);
7583                 CHECK(compiler);
7584                 sljit_free_compiler(compiler);
7585
7586                 code.test73_f3(7390.25, -8045.5, 1390.75, 8201);
7587
7588                 FAILED(wbuf[0] != 8201, "test73 case 17 failed\n");
7589                 FAILED(dbuf[0] != 7390.25, "test73 case 18 failed\n");
7590                 FAILED(dbuf[1] != -8045.5, "test73 case 19 failed\n");
7591                 FAILED(dbuf[2] != 1390.75, "test73 case 20 failed\n");
7592
7593                 /* Next test. */
7594
7595                 compiler = sljit_create_compiler(NULL, NULL);
7596                 FAILED(!compiler, "cannot create compiler\n");
7597
7598                 sljit_emit_enter(compiler, 0, SLJIT_ARGS4(VOID, F64, F64, W, W_R), 2, 1, 2, 0, SLJIT_MAX_LOCAL_SIZE);
7599                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&wbuf);
7600                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_S0, 0);
7601                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_sw), SLJIT_R1, 0);
7602                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&dbuf);
7603                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_FR0, 0);
7604                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_f64), SLJIT_FR1, 0);
7605
7606                 sljit_emit_return_void(compiler);
7607
7608                 code.code = sljit_generate_code(compiler);
7609                 CHECK(compiler);
7610                 sljit_free_compiler(compiler);
7611
7612                 code.test73_f4(4892.75, -3702.5, 4731, 8530);
7613
7614                 FAILED(wbuf[0] != 4731, "test73 case 21 failed\n");
7615                 FAILED(wbuf[1] != 8530, "test73 case 22 failed\n");
7616                 FAILED(dbuf[0] != 4892.75, "test73 case 23 failed\n");
7617                 FAILED(dbuf[1] != -3702.5, "test73 case 24 failed\n");
7618         }
7619
7620         successful_tests++;
7621 }
7622
7623 int sljit_test(int argc, char* argv[])
7624 {
7625         sljit_s32 has_arg = (argc >= 2 && argv[1][0] == '-' && argv[1][2] == '\0');
7626         verbose = has_arg && argv[1][1] == 'v';
7627         silent = has_arg && argv[1][1] == 's';
7628
7629         if (!verbose && !silent)
7630                 printf("Pass -v to enable verbose, -s to disable this hint.\n\n");
7631
7632 #if !(defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED)
7633         test_exec_allocator();
7634 #endif
7635         test1();
7636         test2();
7637         test3();
7638         test4();
7639         test5();
7640         test6();
7641         test7();
7642         test8();
7643         test9();
7644         test10();
7645         test11();
7646         test12();
7647         test13();
7648         test14();
7649         test15();
7650         test16();
7651         test17();
7652         test18();
7653         test19();
7654         test20();
7655         test21();
7656         test22();
7657         test23();
7658         test24();
7659         test25();
7660         test26();
7661         test27();
7662         test28();
7663         test29();
7664         test30();
7665         test31();
7666         test32();
7667         test33();
7668         test34();
7669         test35();
7670         test36();
7671         test37();
7672         test38();
7673         test39();
7674         test40();
7675         test41();
7676         test42();
7677         test43();
7678         test44();
7679         test45();
7680         test46();
7681         test47();
7682         test48();
7683         test49();
7684         test50();
7685         test51();
7686         test52();
7687         test53();
7688         test54();
7689         test55();
7690         test56();
7691         test57();
7692         test58();
7693         test59();
7694         test60();
7695         test61();
7696         test62();
7697         test63();
7698         test64();
7699         test65();
7700         test66();
7701         test67();
7702         test68();
7703         test69();
7704         test70();
7705         test71();
7706         test72();
7707         test73();
7708
7709 #if (defined SLJIT_EXECUTABLE_ALLOCATOR && SLJIT_EXECUTABLE_ALLOCATOR)
7710         sljit_free_unused_memory_exec();
7711 #endif
7712
7713 #       define TEST_COUNT 73
7714
7715         printf("SLJIT tests: ");
7716         if (successful_tests == TEST_COUNT)
7717                 printf("all tests are " COLOR_GREEN "PASSED" COLOR_DEFAULT " ");
7718         else
7719                 printf(COLOR_RED "%d" COLOR_DEFAULT " (" COLOR_RED "%d%%" COLOR_DEFAULT ") tests are " COLOR_RED "FAILED" COLOR_DEFAULT " ", TEST_COUNT - successful_tests, (TEST_COUNT - successful_tests) * 100 / TEST_COUNT);
7720         printf("on " COLOR_ARCH "%s" COLOR_DEFAULT "%s\n", sljit_get_platform_name(), sljit_has_cpu_feature(SLJIT_HAS_FPU) ? " (with fpu)" : " (without fpu)");
7721
7722         return TEST_COUNT - successful_tests;
7723
7724 #       undef TEST_COUNT
7725 }
7726
7727 #ifdef _MSC_VER
7728 #pragma warning(pop)
7729 #endif