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