test_src/sljitTest.c

   1 /*
   2  *    Stack-less Just-In-Time compiler
   3  *
   4  *    Copyright Zoltan Herczeg (hzmester@freemail.hu). All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without modification, are
   7  * permitted provided that the following conditions are met:
   8  *
   9  *   1. Redistributions of source code must retain the above copyright notice, this list of
  10  *      conditions and the following disclaimer.
  11  *
  12  *   2. Redistributions in binary form must reproduce the above copyright notice, this list
  13  *      of conditions and the following disclaimer in the documentation and/or other materials
  14  *      provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND CONTRIBUTORS ``AS IS'' AND ANY
  17  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  18  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
  19  * SHALL THE COPYRIGHT HOLDER(S) OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  20  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
  21  * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  22  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  23  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  24  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 /* Must be the first one. Must not depend on any other include. */
  28 #include "sljitLir.h"
  29
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33
  34 #ifdef _MSC_VER
  35 #pragma warning(push)
  36 #pragma warning(disable: 4127) /* conditional expression is constant */
  37 #endif
  38
  39 #if defined _WIN32 || defined _WIN64
  40 #define COLOR_RED
  41 #define COLOR_GREEN
  42 #define COLOR_ARCH
  43 #define COLOR_DEFAULT
  44 #else
  45 #define COLOR_RED "\33[31m"
  46 #define COLOR_GREEN "\33[32m"
  47 #define COLOR_ARCH "\33[33m"
  48 #define COLOR_DEFAULT "\33[0m"
  49 #endif
  50
  51 union executable_code {
  52         void* code;
  53         sljit_sw (SLJIT_FUNC *func0)(void);
  54         sljit_sw (SLJIT_FUNC *func1)(sljit_sw a);
  55         sljit_sw (SLJIT_FUNC *func2)(sljit_sw a, sljit_sw b);
  56         sljit_sw (SLJIT_FUNC *func3)(sljit_sw a, sljit_sw b, sljit_sw c);
  57
  58         sljit_sw (*test53_f1)(sljit_sw a, sljit_sw b, sljit_sw c);
  59
  60         void (SLJIT_FUNC *test70_f1)(sljit_s32 a, sljit_uw b, sljit_u32 c, sljit_sw d);
  61         void (*test70_f2)(sljit_s32 a, sljit_u32 b, sljit_sw c, sljit_sw d);
  62         void (SLJIT_FUNC *test70_f3)(sljit_s32 a, sljit_f32 b, sljit_uw c, sljit_f64 d);
  63         void (SLJIT_FUNC *test70_f4)(sljit_f32 a, sljit_f64 b, sljit_f32 c, sljit_s32 d);
  64         void (SLJIT_FUNC *test70_f5)(sljit_f64 a, sljit_f32 b, sljit_u32 c, sljit_f32 d);
  65         void (SLJIT_FUNC *test70_f6)(sljit_f64 a, sljit_s32 b, sljit_f32 c, sljit_f64 d);
  66         void (SLJIT_FUNC *test70_f7)(sljit_f32 a, sljit_s32 b, sljit_uw c, sljit_u32 d);
  67         void (SLJIT_FUNC *test70_f8)(sljit_f64 a, sljit_f64 b, sljit_uw c, sljit_sw d);
  68         void (SLJIT_FUNC *test70_f9)(sljit_f64 a, sljit_f64 b, sljit_uw c, sljit_f64 d);
  69         void (SLJIT_FUNC *test70_f10)(sljit_f64 a, sljit_f64 b, sljit_f64 c, sljit_s32 d);
  70
  71         sljit_sw (*test71_f1)(sljit_sw a, sljit_sw b, sljit_sw c, sljit_sw d);
  72         sljit_sw (*test71_f2)(sljit_f64 a, sljit_f64 b);
  73         sljit_sw (SLJIT_FUNC *test71_f3)(sljit_f64 a, sljit_f64 b, sljit_f64 c, sljit_f64 d);
  74         sljit_sw (SLJIT_FUNC *test71_f4)(sljit_f64 a, sljit_f64 b, sljit_f64 c);
  75
  76         void (SLJIT_FUNC *test73_f1)(sljit_s32 a, sljit_sw b, sljit_sw c, sljit_s32 d);
  77         void (*test73_f2)(sljit_sw a, sljit_sw b, sljit_s32 c, sljit_s32 d);
  78         void (SLJIT_FUNC *test73_f3)(sljit_f64 a, sljit_f64 b, sljit_f64 c, sljit_sw d);
  79         void (SLJIT_FUNC *test73_f4)(sljit_f64 a, sljit_f64 b, sljit_sw c, sljit_sw d);
  80 };
  81 typedef union executable_code executable_code;
  82
  83 static sljit_s32 successful_tests = 0;
  84 static sljit_s32 verbose = 0;
  85 static sljit_s32 silent = 0;
  86
  87 #define FAILED(cond, text) \
  88         if (SLJIT_UNLIKELY(cond)) { \
  89                 printf(text); \
  90                 return; \
  91         }
  92
  93 #define CHECK(compiler) \
  94         if (sljit_get_compiler_error(compiler) != SLJIT_ERR_COMPILED) { \
  95                 printf("Compiler error: %d\n", sljit_get_compiler_error(compiler)); \
  96                 sljit_free_compiler(compiler); \
  97                 return; \
  98         }
  99
 100 static void cond_set(struct sljit_compiler *compiler, sljit_s32 dst, sljit_sw dstw, sljit_s32 type)
 101 {
 102         /* Testing both sljit_emit_op_flags and sljit_emit_jump. */
 103         struct sljit_jump* jump;
 104         struct sljit_label* label;
 105
 106         sljit_emit_op_flags(compiler, SLJIT_MOV, dst, dstw, type);
 107         jump = sljit_emit_jump(compiler, type);
 108         sljit_emit_op2(compiler, SLJIT_ADD, dst, dstw, dst, dstw, SLJIT_IMM, 2);
 109         label = sljit_emit_label(compiler);
 110         sljit_set_label(jump, label);
 111 }
 112
 113 #if !(defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED)
 114
 115 /* For interface testing and for test64. */
 116 void *sljit_test_malloc_exec(sljit_uw size, void *exec_allocator_data)
 117 {
 118         if (exec_allocator_data)
 119                 return exec_allocator_data;
 120
 121         return SLJIT_BUILTIN_MALLOC_EXEC(size, exec_allocator_data);
 122 }
 123
 124 /* For interface testing. */
 125 void sljit_test_free_code(void* code, void *exec_allocator_data)
 126 {
 127         SLJIT_UNUSED_ARG(exec_allocator_data);
 128         SLJIT_BUILTIN_FREE_EXEC(code, exec_allocator_data);
 129 }
 130
 131 #define MALLOC_EXEC(result, size) \
 132         result = SLJIT_MALLOC_EXEC(size, NULL); \
 133         if (!result) { \
 134                 printf("Cannot allocate executable memory\n"); \
 135                 return; \
 136         } \
 137         memset(result, 255, size);
 138
 139 #define FREE_EXEC(ptr) \
 140         SLJIT_FREE_EXEC(((sljit_u8*)(ptr)) + SLJIT_EXEC_OFFSET(ptr), NULL);
 141
 142 static void test_exec_allocator(void)
 143 {
 144         /* This is not an sljit test. */
 145         void *ptr1;
 146         void *ptr2;
 147         void *ptr3;
 148
 149         if (verbose)
 150                 printf("Run executable allocator test\n");
 151
 152         MALLOC_EXEC(ptr1, 32);
 153         MALLOC_EXEC(ptr2, 512);
 154         MALLOC_EXEC(ptr3, 512);
 155         FREE_EXEC(ptr2);
 156         FREE_EXEC(ptr3);
 157         FREE_EXEC(ptr1);
 158         MALLOC_EXEC(ptr1, 262104);
 159         MALLOC_EXEC(ptr2, 32000);
 160         FREE_EXEC(ptr1);
 161         MALLOC_EXEC(ptr1, 262104);
 162         FREE_EXEC(ptr1);
 163         FREE_EXEC(ptr2);
 164         MALLOC_EXEC(ptr1, 512);
 165         MALLOC_EXEC(ptr2, 512);
 166         MALLOC_EXEC(ptr3, 512);
 167         FREE_EXEC(ptr2);
 168         MALLOC_EXEC(ptr2, 512);
 169 #if (defined SLJIT_EXECUTABLE_ALLOCATOR && SLJIT_EXECUTABLE_ALLOCATOR)
 170         sljit_free_unused_memory_exec();
 171 #endif
 172         FREE_EXEC(ptr3);
 173         FREE_EXEC(ptr1);
 174         FREE_EXEC(ptr2);
 175
 176 #if (defined SLJIT_EXECUTABLE_ALLOCATOR && SLJIT_EXECUTABLE_ALLOCATOR)
 177         sljit_free_unused_memory_exec();
 178 #endif
 179 }
 180
 181 #undef MALLOC_EXEC
 182
 183 #endif /* !(defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED) */
 184
 185 static void test1(void)
 186 {
 187         /* Enter and return from an sljit function. */
 188         executable_code code;
 189         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
 190
 191         if (verbose)
 192                 printf("Run test1\n");
 193
 194         FAILED(!compiler, "cannot create compiler\n");
 195
 196         /* 3 arguments passed, 3 arguments used. */
 197         sljit_emit_enter(compiler, 0, SLJIT_ARGS3(W, W, W, W), 3, 3, 0, 0, 0);
 198         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_S1, 0);
 199
 200         SLJIT_ASSERT(sljit_get_generated_code_size(compiler) == 0);
 201         code.code = sljit_generate_code(compiler);
 202         CHECK(compiler);
 203         SLJIT_ASSERT(compiler->error == SLJIT_ERR_COMPILED);
 204         SLJIT_ASSERT(sljit_get_generated_code_size(compiler) > 0);
 205         sljit_free_compiler(compiler);
 206
 207         FAILED(code.func3(3, -21, 86) != -21, "test1 case 1 failed\n");
 208         FAILED(code.func3(4789, 47890, 997) != 47890, "test1 case 2 failed\n");
 209
 210         sljit_free_code(code.code, NULL);
 211         successful_tests++;
 212 }
 213
 214 static void test2(void)
 215 {
 216         /* Test mov. */
 217         executable_code code;
 218         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
 219         sljit_sw buf[8];
 220         static sljit_sw data[2] = { 0, -9876 };
 221
 222         if (verbose)
 223                 printf("Run test2\n");
 224
 225         FAILED(!compiler, "cannot create compiler\n");
 226
 227         buf[0] = 5678;
 228         buf[1] = 0;
 229         buf[2] = 0;
 230         buf[3] = 0;
 231         buf[4] = 0;
 232         buf[5] = 0;
 233         buf[6] = 0;
 234         buf[7] = 0;
 235         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(W, P), 3, 2, 0, 0, 0);
 236         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 9999);
 237         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_S0, 0);
 238         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_sw), SLJIT_R0, 0);
 239         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, sizeof(sljit_sw));
 240         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_MEM2(SLJIT_S1, SLJIT_R1), 0);
 241         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, 2);
 242         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM2(SLJIT_S1, SLJIT_S0), SLJIT_WORD_SHIFT, SLJIT_MEM2(SLJIT_S1, SLJIT_R1), 0);
 243         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, 3);
 244         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM2(SLJIT_S1, SLJIT_S0), SLJIT_WORD_SHIFT, SLJIT_MEM0(), (sljit_sw)&buf);
 245         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, sizeof(sljit_sw));
 246         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_R0), (sljit_sw)&data);
 247         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S1), 4 * sizeof(sljit_sw), SLJIT_R0, 0);
 248         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&buf - 0x12345678);
 249         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_R0), 0x12345678);
 250         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S1), 5 * sizeof(sljit_sw), SLJIT_R0, 0);
 251         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 3456);
 252         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, (sljit_sw)&buf - 0xff890 + 6 * (sljit_sw)sizeof(sljit_sw));
 253         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), 0xff890, SLJIT_R0, 0);
 254         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, (sljit_sw)&buf + 0xff890 + 7 * (sljit_sw)sizeof(sljit_sw));
 255         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), -0xff890, SLJIT_R0, 0);
 256         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_R2, 0);
 257
 258         code.code = sljit_generate_code(compiler);
 259         CHECK(compiler);
 260         sljit_free_compiler(compiler);
 261
 262         FAILED(code.func1((sljit_sw)&buf) != 9999, "test2 case 1 failed\n");
 263         FAILED(buf[1] != 9999, "test2 case 2 failed\n");
 264         FAILED(buf[2] != 9999, "test2 case 3 failed\n");
 265         FAILED(buf[3] != 5678, "test2 case 4 failed\n");
 266         FAILED(buf[4] != -9876, "test2 case 5 failed\n");
 267         FAILED(buf[5] != 5678, "test2 case 6 failed\n");
 268         FAILED(buf[6] != 3456, "test2 case 6 failed\n");
 269         FAILED(buf[7] != 3456, "test2 case 6 failed\n");
 270
 271         sljit_free_code(code.code, NULL);
 272         successful_tests++;
 273 }
 274
 275 static void test3(void)
 276 {
 277         /* Test not. */
 278         executable_code code;
 279         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
 280         sljit_sw buf[5];
 281
 282         if (verbose)
 283                 printf("Run test3\n");
 284
 285         FAILED(!compiler, "cannot create compiler\n");
 286         buf[0] = 1234;
 287         buf[1] = 0;
 288         buf[2] = 9876;
 289         buf[3] = 0;
 290         buf[4] = 0x12345678;
 291
 292         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(W, P), 3, 1, 0, 0, 0);
 293         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_MEM1(SLJIT_S0), 0);
 294         sljit_emit_op1(compiler, SLJIT_NOT, SLJIT_MEM0(), (sljit_sw)&buf[1], SLJIT_MEM0(), (sljit_sw)&buf[1]);
 295         sljit_emit_op1(compiler, SLJIT_NOT, SLJIT_RETURN_REG, 0, SLJIT_MEM1(SLJIT_S0), 0);
 296         sljit_emit_op1(compiler, SLJIT_NOT, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 3, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 2);
 297         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, (sljit_sw)&buf[4] - 0xff0000 - 0x20);
 298         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, (sljit_sw)&buf[4] - 0xff0000);
 299         sljit_emit_op1(compiler, SLJIT_NOT, SLJIT_MEM1(SLJIT_R1), 0xff0000 + 0x20, SLJIT_MEM1(SLJIT_R2), 0xff0000);
 300         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);
 301
 302         code.code = sljit_generate_code(compiler);
 303         CHECK(compiler);
 304         sljit_free_compiler(compiler);
 305
 306         FAILED(code.func1((sljit_sw)&buf) != ~1234, "test3 case 1 failed\n");
 307         FAILED(buf[1] != ~1234, "test3 case 2 failed\n");
 308         FAILED(buf[3] != ~9876, "test3 case 3 failed\n");
 309         FAILED(buf[4] != ~0x12345678, "test3 case 4 failed\n");
 310
 311         sljit_free_code(code.code, NULL);
 312         successful_tests++;
 313 }
 314
 315 static void test4(void)
 316 {
 317         /* Test negate. */
 318         executable_code code;
 319         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
 320         sljit_sw buf[4];
 321
 322         if (verbose)
 323                 printf("Run test4\n");
 324
 325         FAILED(!compiler, "cannot create compiler\n");
 326         buf[0] = 0;
 327         buf[1] = 1234;
 328         buf[2] = 0;
 329         buf[3] = 0;
 330
 331         sljit_emit_enter(compiler, 0, SLJIT_ARGS2(W, P, W), 3, 2, 0, 0, 0);
 332         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 2, SLJIT_IMM, 0, SLJIT_S1, 0);
 333         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_MEM0(), (sljit_sw)&buf[0], SLJIT_IMM, 0, SLJIT_MEM0(), (sljit_sw)&buf[1]);
 334         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 299);
 335         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 3, SLJIT_IMM, 0, SLJIT_R1, 0);
 336         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_RETURN_REG, 0, SLJIT_IMM, 0, SLJIT_S1, 0);
 337         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);
 338
 339         code.code = sljit_generate_code(compiler);
 340         CHECK(compiler);
 341         sljit_free_compiler(compiler);
 342
 343         FAILED(code.func2((sljit_sw)&buf, 4567) != -4567, "test4 case 1 failed\n");
 344         FAILED(buf[0] != -1234, "test4 case 2 failed\n");
 345         FAILED(buf[2] != -4567, "test4 case 3 failed\n");
 346         FAILED(buf[3] != -299, "test4 case 4 failed\n");
 347
 348         sljit_free_code(code.code, NULL);
 349         successful_tests++;
 350 }
 351
 352 static void test5(void)
 353 {
 354         /* Test add. */
 355         executable_code code;
 356         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
 357         sljit_sw buf[9];
 358
 359         if (verbose)
 360                 printf("Run test5\n");
 361
 362         FAILED(!compiler, "cannot create compiler\n");
 363         buf[0] = 100;
 364         buf[1] = 200;
 365         buf[2] = 300;
 366         buf[3] = 0;
 367         buf[4] = 0;
 368         buf[5] = 0;
 369         buf[6] = 0;
 370         buf[7] = 0;
 371         buf[8] = 313;
 372
 373         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(W, P), 3, 2, 0, 0, 0);
 374         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, sizeof(sljit_sw));
 375         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 50);
 376         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM2(SLJIT_S0, SLJIT_R0), 1, SLJIT_MEM2(SLJIT_S0, SLJIT_R0), 1, SLJIT_MEM2(SLJIT_S0, SLJIT_R0), 0);
 377         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, sizeof(sljit_sw) + 2);
 378         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, 50);
 379         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), 0);
 380         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0);
 381         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_IMM, 4, SLJIT_R0, 0);
 382         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_IMM, 50, SLJIT_R1, 0);
 383         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_IMM, 50, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw));
 384         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_R1, 0);
 385         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_R1, 0, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw));
 386         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw));
 387         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_R1, 0);
 388         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0x1e7d39f2);
 389         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_sw), SLJIT_R1, 0, SLJIT_IMM, 0x23de7c06);
 390         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_sw), SLJIT_IMM, 0x3d72e452, SLJIT_R1, 0);
 391         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_sw), SLJIT_IMM, -43, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_sw));
 392         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_IMM, 1000, SLJIT_R0, 0);
 393         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 1430);
 394         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_IMM, -99, SLJIT_R0, 0);
 395
 396         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_R0, 0);
 397
 398         code.code = sljit_generate_code(compiler);
 399         CHECK(compiler);
 400         sljit_free_compiler(compiler);
 401
 402         FAILED(code.func1((sljit_sw)&buf) != 2437 + 2 * sizeof(sljit_sw), "test5 case 1 failed\n");
 403         FAILED(buf[0] != 202 + 2 * sizeof(sljit_sw), "test5 case 2 failed\n");
 404         FAILED(buf[2] != 500, "test5 case 3 failed\n");
 405         FAILED(buf[3] != 400, "test5 case 4 failed\n");
 406         FAILED(buf[4] != 200, "test5 case 5 failed\n");
 407         FAILED(buf[5] != 250, "test5 case 6 failed\n");
 408         FAILED(buf[6] != 0x425bb5f8, "test5 case 7 failed\n");
 409         FAILED(buf[7] != 0x5bf01e44, "test5 case 8 failed\n");
 410         FAILED(buf[8] != 270, "test5 case 9 failed\n");
 411
 412         sljit_free_code(code.code, NULL);
 413         successful_tests++;
 414 }
 415
 416 static void test6(void)
 417 {
 418         /* Test addc, sub, subc. */
 419         executable_code code;
 420         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
 421         sljit_sw buf[11];
 422
 423         if (verbose)
 424                 printf("Run test6\n");
 425
 426         FAILED(!compiler, "cannot create compiler\n");
 427         buf[0] = 0;
 428         buf[1] = 0;
 429         buf[2] = 0;
 430         buf[3] = 0;
 431         buf[4] = 0;
 432         buf[5] = 0;
 433         buf[6] = 0;
 434         buf[7] = 0;
 435         buf[8] = 0;
 436         buf[9] = 0;
 437         buf[10] = 4000;
 438
 439         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(W, P), 3, 1, 0, 0, 0);
 440         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -1);
 441         sljit_emit_op2(compiler, SLJIT_ADD | SLJIT_SET_CARRY, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, -1);
 442         sljit_emit_op2(compiler, SLJIT_ADDC, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_IMM, 0, SLJIT_IMM, 0);
 443         sljit_emit_op2(compiler, SLJIT_ADD | SLJIT_SET_CARRY, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_R0, 0);
 444         sljit_emit_op2(compiler, SLJIT_ADDC, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_IMM, 4);
 445         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 100);
 446         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 2, SLJIT_R0, 0, SLJIT_IMM, 50);
 447         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_CARRY, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 6000);
 448         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 3, SLJIT_IMM, 10);
 449         sljit_emit_op2(compiler, SLJIT_SUBC, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 3, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 3, SLJIT_IMM, 5);
 450         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 100);
 451         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 2);
 452         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 4, SLJIT_R0, 0);
 453         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 5000);
 454         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 4, SLJIT_R0, 0);
 455         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_R1, 0);
 456         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 5, SLJIT_R1, 0);
 457         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 5000);
 458         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R0, 0, SLJIT_IMM, 6000, SLJIT_R0, 0);
 459         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 6, SLJIT_R0, 0);
 460         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 100);
 461         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, 32768);
 462         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 7, SLJIT_R1, 0);
 463         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, -32767);
 464         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 8, SLJIT_R1, 0);
 465         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0x52cd3bf4);
 466         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 9, SLJIT_R0, 0, SLJIT_IMM, 0x3da297c6);
 467         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 6000);
 468         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 10, SLJIT_R1, 0);
 469         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 10, SLJIT_R1, 0);
 470         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, 10);
 471         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_CARRY, SLJIT_RETURN_REG, 0, SLJIT_RETURN_REG, 0, SLJIT_IMM, 5);
 472         sljit_emit_op2(compiler, SLJIT_SUBC, SLJIT_RETURN_REG, 0, SLJIT_RETURN_REG, 0, SLJIT_IMM, 2);
 473         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_RETURN_REG, 0, SLJIT_RETURN_REG, 0, SLJIT_IMM, -2220);
 474         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);
 475
 476         code.code = sljit_generate_code(compiler);
 477         CHECK(compiler);
 478         sljit_free_compiler(compiler);
 479
 480         FAILED(code.func1((sljit_sw)&buf) != 2223, "test6 case 1 failed\n");
 481         FAILED(buf[0] != 1, "test6 case 2 failed\n");
 482         FAILED(buf[1] != 5, "test6 case 3 failed\n");
 483         FAILED(buf[2] != 50, "test6 case 4 failed\n");
 484         FAILED(buf[3] != 4, "test6 case 5 failed\n");
 485         FAILED(buf[4] != 50, "test6 case 6 failed\n");
 486         FAILED(buf[5] != 50, "test6 case 7 failed\n");
 487         FAILED(buf[6] != 1000, "test6 case 8 failed\n");
 488         FAILED(buf[7] != 100 - 32768, "test6 case 9 failed\n");
 489         FAILED(buf[8] != 100 + 32767, "test6 case 10 failed\n");
 490         FAILED(buf[9] != 0x152aa42e, "test6 case 11 failed\n");
 491         FAILED(buf[10] != -2000, "test6 case 12 failed\n");
 492
 493         sljit_free_code(code.code, NULL);
 494         successful_tests++;
 495 }
 496
 497 static void test7(void)
 498 {
 499         /* Test logical operators. */
 500         executable_code code;
 501         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
 502         sljit_sw buf[8];
 503
 504         if (verbose)
 505                 printf("Run test7\n");
 506
 507         FAILED(!compiler, "cannot create compiler\n");
 508         buf[0] = 0xff80;
 509         buf[1] = 0x0f808080;
 510         buf[2] = 0;
 511         buf[3] = 0xaaaaaa;
 512         buf[4] = 0;
 513         buf[5] = 0x4040;
 514         buf[6] = 0;
 515         buf[7] = (sljit_sw)0xc43a7f95;
 516
 517         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(W, P), 3, 1, 0, 0, 0);
 518         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0xf0C000);
 519         sljit_emit_op2(compiler, SLJIT_OR, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 2, SLJIT_R0, 0, SLJIT_IMM, 0x308f);
 520         sljit_emit_op2(compiler, SLJIT_XOR, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw));
 521         sljit_emit_op2(compiler, SLJIT_AND, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 3, SLJIT_IMM, 0xf0f0f0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 3);
 522         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0xC0F0);
 523         sljit_emit_op2(compiler, SLJIT_XOR, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 5);
 524         sljit_emit_op2(compiler, SLJIT_OR, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 0xff0000);
 525         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 4, SLJIT_R0, 0);
 526         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 0xC0F0);
 527         sljit_emit_op2(compiler, SLJIT_AND, SLJIT_R2, 0, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 5);
 528         sljit_emit_op2(compiler, SLJIT_OR, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 5, SLJIT_R2, 0, SLJIT_IMM, 0xff0000);
 529         sljit_emit_op2(compiler, SLJIT_XOR, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_IMM, 0xFFFFFF, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw));
 530         sljit_emit_op2(compiler, SLJIT_OR, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 6, SLJIT_IMM, (sljit_sw)0xa56c82c0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 6);
 531         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 7);
 532         sljit_emit_op2(compiler, SLJIT_XOR, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 7, SLJIT_IMM, (sljit_sw)0xff00ff00, SLJIT_R0, 0);
 533         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)0xff00ff00);
 534         sljit_emit_op2(compiler, SLJIT_OR, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, 0x0f);
 535         sljit_emit_op2(compiler, SLJIT_AND, SLJIT_RETURN_REG, 0, SLJIT_IMM, 0x888888, SLJIT_R1, 0);
 536         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);
 537
 538         code.code = sljit_generate_code(compiler);
 539         CHECK(compiler);
 540         sljit_free_compiler(compiler);
 541
 542         FAILED(code.func1((sljit_sw)&buf) != 0x8808, "test7 case 1 failed\n");
 543         FAILED(buf[0] != 0x0F807F00, "test7 case 2 failed\n");
 544         FAILED(buf[1] != 0x0F7F7F7F, "test7 case 3 failed\n");
 545         FAILED(buf[2] != 0x00F0F08F, "test7 case 4 failed\n");
 546         FAILED(buf[3] != 0x00A0A0A0, "test7 case 5 failed\n");
 547         FAILED(buf[4] != 0x00FF80B0, "test7 case 6 failed\n");
 548         FAILED(buf[5] != 0x00FF4040, "test7 case 7 failed\n");
 549         FAILED(buf[6] != (sljit_sw)0xa56c82c0, "test7 case 8 failed\n");
 550         FAILED(buf[7] != 0x3b3a8095, "test7 case 9 failed\n");
 551
 552         sljit_free_code(code.code, NULL);
 553         successful_tests++;
 554 }
 555
 556 static void test8(void)
 557 {
 558         /* Test flags (neg, cmp, test). */
 559         executable_code code;
 560         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
 561         sljit_sw buf[19];
 562         sljit_s32 i;
 563
 564         if (verbose)
 565                 printf("Run test8\n");
 566
 567         FAILED(!compiler, "cannot create compiler\n");
 568         buf[0] = 100;
 569         for (i = 1; i < 19; i++)
 570                 buf[i] = 3;
 571
 572         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, P), 3, 2, 0, 0, 0);
 573         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 20);
 574         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 10);
 575         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_Z, SLJIT_IMM, 6, SLJIT_IMM, 5);
 576         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_NOT_EQUAL);
 577         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 2, SLJIT_EQUAL);
 578         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_GREATER, SLJIT_R0, 0, SLJIT_IMM, 3000);
 579         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_GREATER);
 580         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_LESS, SLJIT_R0, 0, SLJIT_IMM, 3000);
 581         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 3, SLJIT_S1, 0);
 582         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_LESS);
 583         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 4, SLJIT_R2, 0);
 584         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_SIG_GREATER, SLJIT_R0, 0, SLJIT_IMM, -15);
 585         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_SIG_GREATER);
 586         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 5, SLJIT_R2, 0);
 587         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -(sljit_sw)(~(sljit_uw)0 >> 1) - 1);
 588         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_Z | SLJIT_SET_OVERFLOW, SLJIT_R0, 0, SLJIT_R1, 0);
 589         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_Z | SLJIT_SET_OVERFLOW, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0);
 590         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_Z | SLJIT_SET_OVERFLOW, SLJIT_R1, 0, SLJIT_IMM, 0, SLJIT_R0, 0);
 591         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 6, SLJIT_OVERFLOW);
 592         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -1);
 593         sljit_emit_op1(compiler, SLJIT_NOT | SLJIT_SET_Z, SLJIT_R1, 0, SLJIT_R0, 0);
 594         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 7, SLJIT_ZERO);
 595         sljit_emit_op1(compiler, SLJIT_NOT | SLJIT_SET_Z, SLJIT_R0, 0, SLJIT_R1, 0);
 596         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 8, SLJIT_ZERO);
 597         sljit_emit_op2u(compiler, SLJIT_AND | SLJIT_SET_Z, SLJIT_IMM, 0xffff, SLJIT_R0, 0);
 598         sljit_emit_op2u(compiler, SLJIT_AND | SLJIT_SET_Z, SLJIT_R0, 0, SLJIT_IMM, 0xffff);
 599         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 9, SLJIT_NOT_ZERO);
 600         sljit_emit_op2u(compiler, SLJIT_AND | SLJIT_SET_Z, SLJIT_IMM, 0xffff, SLJIT_R1, 0);
 601         sljit_emit_op2u(compiler, SLJIT_AND | SLJIT_SET_Z, SLJIT_R1, 0, SLJIT_IMM, 0xffff);
 602         sljit_emit_op2u(compiler, SLJIT_AND | SLJIT_SET_Z, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R1, 0);
 603         sljit_emit_op2u(compiler, SLJIT_AND | SLJIT_SET_Z, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_S0), 0);
 604         sljit_emit_op2u(compiler, SLJIT_AND | SLJIT_SET_Z, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_MEM1(SLJIT_S0), 0);
 605         sljit_emit_op2u(compiler, SLJIT_AND | SLJIT_SET_Z, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_IMM, 0x1);
 606         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 10, SLJIT_NOT_ZERO);
 607         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -(sljit_sw)(~(sljit_uw)0 >> 1) - 1);
 608         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0);
 609         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_OVERFLOW, SLJIT_R1, 0, SLJIT_R0, 0);
 610         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 11, SLJIT_OVERFLOW);
 611         sljit_emit_op2u(compiler, SLJIT_ADD | SLJIT_SET_OVERFLOW, SLJIT_R1, 0, SLJIT_R0, 0);
 612         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 12, SLJIT_OVERFLOW);
 613         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 9);
 614         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_Z | SLJIT_SET_LESS, SLJIT_R0, 0, SLJIT_IMM, 0, SLJIT_R0, 0);
 615         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 13, SLJIT_LESS);
 616         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 14, SLJIT_ZERO);
 617         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0);
 618         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_Z | SLJIT_SET_LESS, SLJIT_R0, 0, SLJIT_IMM, 0, SLJIT_R0, 0);
 619         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 15, SLJIT_LESS);
 620         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 16, SLJIT_ZERO);
 621         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -9);
 622         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_SIG_LESS, SLJIT_R0, 0, SLJIT_IMM, 0, SLJIT_R0, 0);
 623         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 17, SLJIT_SIG_LESS);
 624         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -9);
 625         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_SIG_GREATER, SLJIT_R0, 0, SLJIT_IMM, 0, SLJIT_R0, 0);
 626         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 18, SLJIT_SIG_GREATER);
 627
 628         sljit_emit_return_void(compiler);
 629
 630         code.code = sljit_generate_code(compiler);
 631         CHECK(compiler);
 632         sljit_free_compiler(compiler);
 633
 634         code.func1((sljit_sw)&buf);
 635         FAILED(buf[1] != 1, "test8 case 1 failed\n");
 636         FAILED(buf[2] != 0, "test8 case 2 failed\n");
 637         FAILED(buf[3] != 0, "test8 case 3 failed\n");
 638         FAILED(buf[4] != 1, "test8 case 4 failed\n");
 639         FAILED(buf[5] != 1, "test8 case 5 failed\n");
 640         FAILED(buf[6] != 1, "test8 case 6 failed\n");
 641         FAILED(buf[7] != 1, "test8 case 7 failed\n");
 642         FAILED(buf[8] != 0, "test8 case 8 failed\n");
 643         FAILED(buf[9] != 1, "test8 case 9 failed\n");
 644         FAILED(buf[10] != 0, "test8 case 10 failed\n");
 645         FAILED(buf[11] != 1, "test8 case 11 failed\n");
 646         FAILED(buf[12] != 0, "test8 case 12 failed\n");
 647         FAILED(buf[13] != 1, "test8 case 13 failed\n");
 648         FAILED(buf[14] != 0, "test8 case 14 failed\n");
 649         FAILED(buf[15] != 0, "test8 case 15 failed\n");
 650         FAILED(buf[16] != 1, "test8 case 16 failed\n");
 651         FAILED(buf[17] != 0, "test8 case 17 failed\n");
 652         FAILED(buf[18] != 1, "test8 case 18 failed\n");
 653
 654         sljit_free_code(code.code, NULL);
 655         successful_tests++;
 656 }
 657
 658 static void test9(void)
 659 {
 660         /* Test shift. */
 661         executable_code code;
 662         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
 663         sljit_sw buf[13];
 664 #ifdef SLJIT_PREF_SHIFT_REG
 665         sljit_s32 shift_reg = SLJIT_PREF_SHIFT_REG;
 666 #else
 667         sljit_s32 shift_reg = SLJIT_R2;
 668 #endif
 669
 670         SLJIT_ASSERT(shift_reg >= SLJIT_R2 && shift_reg <= SLJIT_R3);
 671
 672         if (verbose)
 673                 printf("Run test9\n");
 674
 675         FAILED(!compiler, "cannot create compiler\n");
 676         buf[0] = 0;
 677         buf[1] = 0;
 678         buf[2] = 0;
 679         buf[3] = 0;
 680         buf[4] = 1 << 10;
 681         buf[5] = 0;
 682         buf[6] = 0;
 683         buf[7] = 0;
 684         buf[8] = 0;
 685         buf[9] = 3;
 686         buf[10] = 0;
 687         buf[11] = 0;
 688         buf[12] = 0;
 689
 690         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, P), 4, 2, 0, 0, 0);
 691         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0xf);
 692         sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 3);
 693         sljit_emit_op2(compiler, SLJIT_LSHR, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 1);
 694         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0);
 695         sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, 1);
 696         sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_R1, 0, SLJIT_IMM, 1);
 697         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -64);
 698         sljit_emit_op1(compiler, SLJIT_MOV, shift_reg, 0, SLJIT_IMM, 2);
 699         sljit_emit_op2(compiler, SLJIT_ASHR, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 2, SLJIT_R0, 0, shift_reg, 0);
 700
 701         sljit_emit_op1(compiler, SLJIT_MOV, shift_reg, 0, SLJIT_IMM, 0xff);
 702         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 4);
 703         sljit_emit_op2(compiler, SLJIT_SHL, shift_reg, 0, shift_reg, 0, SLJIT_R0, 0);
 704         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 3, shift_reg, 0);
 705         sljit_emit_op1(compiler, SLJIT_MOV, shift_reg, 0, SLJIT_IMM, 0xff);
 706         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 8);
 707         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);
 708         sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 5, shift_reg, 0, SLJIT_R0, 0);
 709
 710         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_IMM, 0xf);
 711         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 2);
 712         sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_S1, 0, SLJIT_S1, 0, SLJIT_R0, 0);
 713         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 6, SLJIT_S1, 0);
 714         sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_R0, 0, SLJIT_S1, 0, SLJIT_R0, 0);
 715         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 7, SLJIT_R0, 0);
 716         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 0xf00);
 717         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 4);
 718         sljit_emit_op2(compiler, SLJIT_LSHR, SLJIT_R1, 0, SLJIT_R2, 0, SLJIT_R0, 0);
 719         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 8, SLJIT_R1, 0);
 720
 721         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)buf);
 722         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 9);
 723         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);
 724
 725         sljit_emit_op1(compiler, SLJIT_MOV, shift_reg, 0, SLJIT_IMM, 4);
 726         sljit_emit_op2(compiler, SLJIT_SHL, shift_reg, 0, SLJIT_IMM, 2, shift_reg, 0);
 727         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 10, shift_reg, 0);
 728
 729         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0xa9);
 730         sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, 0);
 731         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 0x7d00);
 732         sljit_emit_op2(compiler, SLJIT_LSHR32, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 32);
 733 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
 734         sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_R0, 0, SLJIT_R0, 0);
 735 #endif
 736         sljit_emit_op2(compiler, SLJIT_OR, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_R0, 0);
 737         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0xe30000);
 738 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
 739         sljit_emit_op2(compiler, SLJIT_ASHR, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 0xffc0);
 740 #else
 741         sljit_emit_op2(compiler, SLJIT_ASHR, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 0xffe0);
 742 #endif
 743         sljit_emit_op2(compiler, SLJIT_OR, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_R0, 0);
 744         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 0x25000000);
 745         sljit_emit_op2(compiler, SLJIT_SHL32, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 0xfffe1);
 746 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
 747         sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_R0, 0, SLJIT_R0, 0);
 748 #endif
 749         sljit_emit_op2(compiler, SLJIT_OR, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 11, SLJIT_R1, 0, SLJIT_R0, 0);
 750
 751         sljit_emit_op1(compiler, SLJIT_MOV, shift_reg, 0, SLJIT_IMM, 0);
 752         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0x5c);
 753         sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_R1, 0, SLJIT_R0, 0, shift_reg, 0);
 754         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 0xf600);
 755         sljit_emit_op2(compiler, SLJIT_LSHR32, SLJIT_R0, 0, SLJIT_R0, 0, shift_reg, 0);
 756 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
 757         /* Alternative form of uint32 type cast. */
 758         sljit_emit_op2(compiler, SLJIT_AND, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 0xffffffff);
 759 #endif
 760         sljit_emit_op2(compiler, SLJIT_OR, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_R0, 0);
 761         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0x630000);
 762         sljit_emit_op2(compiler, SLJIT_ASHR, SLJIT_R0, 0, SLJIT_R0, 0, shift_reg, 0);
 763         sljit_emit_op2(compiler, SLJIT_OR, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 12, SLJIT_R1, 0, SLJIT_R0, 0);
 764
 765         sljit_emit_return_void(compiler);
 766
 767         code.code = sljit_generate_code(compiler);
 768         CHECK(compiler);
 769         sljit_free_compiler(compiler);
 770
 771         code.func1((sljit_sw)&buf);
 772         FAILED(buf[0] != 0x3c, "test9 case 1 failed\n");
 773         FAILED(buf[1] != 0xf0, "test9 case 2 failed\n");
 774         FAILED(buf[2] != -16, "test9 case 3 failed\n");
 775         FAILED(buf[3] != 0xff0, "test9 case 4 failed\n");
 776         FAILED(buf[4] != 4, "test9 case 5 failed\n");
 777         FAILED(buf[5] != 0xff00, "test9 case 6 failed\n");
 778         FAILED(buf[6] != 0x3c, "test9 case 7 failed\n");
 779         FAILED(buf[7] != 0xf0, "test9 case 8 failed\n");
 780         FAILED(buf[8] != 0xf0, "test9 case 9 failed\n");
 781         FAILED(buf[9] != 0x18, "test9 case 10 failed\n");
 782         FAILED(buf[10] != 32, "test9 case 11 failed\n");
 783         FAILED(buf[11] != 0x4ae37da9, "test9 case 12 failed\n");
 784         FAILED(buf[12] != 0x63f65c, "test9 case 13 failed\n");
 785
 786         sljit_free_code(code.code, NULL);
 787         successful_tests++;
 788 }
 789
 790 static void test10(void)
 791 {
 792         /* Test multiplications. */
 793         executable_code code;
 794         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
 795         sljit_sw buf[7];
 796
 797         if (verbose)
 798                 printf("Run test10\n");
 799
 800         FAILED(!compiler, "cannot create compiler\n");
 801         buf[0] = 3;
 802         buf[1] = 0;
 803         buf[2] = 0;
 804         buf[3] = 6;
 805         buf[4] = -10;
 806         buf[5] = 0;
 807         buf[6] = 0;
 808
 809         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(W, P), 3, 1, 0, 0, 0);
 810         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 5);
 811         sljit_emit_op2(compiler, SLJIT_MUL, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0);
 812         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0);
 813         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 7);
 814         sljit_emit_op2(compiler, SLJIT_MUL, SLJIT_R0, 0, SLJIT_R2, 0, SLJIT_IMM, 8);
 815         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_R0, 0);
 816         sljit_emit_op2(compiler, SLJIT_MUL, SLJIT_R0, 0, SLJIT_IMM, -3, SLJIT_IMM, -4);
 817         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 2, SLJIT_R0, 0);
 818         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -2);
 819         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);
 820         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, sizeof(sljit_sw) / 2);
 821         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, (sljit_sw)&buf[3]);
 822         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);
 823         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 9);
 824         sljit_emit_op2(compiler, SLJIT_MUL, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_R0, 0);
 825         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 5, SLJIT_R0, 0);
 826 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
 827         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 3);
 828         sljit_emit_op2(compiler, SLJIT_MUL, SLJIT_R0, 0, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(0x123456789));
 829         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 6, SLJIT_R0, 0);
 830 #endif
 831         sljit_emit_op2(compiler, SLJIT_MUL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 11, SLJIT_IMM, 10);
 832         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);
 833
 834         code.code = sljit_generate_code(compiler);
 835         CHECK(compiler);
 836         sljit_free_compiler(compiler);
 837
 838         FAILED(code.func1((sljit_sw)&buf) != 110, "test10 case 1 failed\n");
 839         FAILED(buf[0] != 15, "test10 case 2 failed\n");
 840         FAILED(buf[1] != 56, "test10 case 3 failed\n");
 841         FAILED(buf[2] != 12, "test10 case 4 failed\n");
 842         FAILED(buf[3] != -12, "test10 case 5 failed\n");
 843         FAILED(buf[4] != 100, "test10 case 6 failed\n");
 844         FAILED(buf[5] != 81, "test10 case 7 failed\n");
 845 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
 846         FAILED(buf[6] != SLJIT_W(0x123456789) * 3, "test10 case 8 failed\n");
 847 #endif
 848
 849         sljit_free_code(code.code, NULL);
 850         successful_tests++;
 851 }
 852
 853 static void test11(void)
 854 {
 855         /* Test rewritable constants. */
 856         executable_code code;
 857         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
 858         struct sljit_const* const1;
 859         struct sljit_const* const2;
 860         struct sljit_const* const3;
 861         struct sljit_const* const4;
 862         void* value;
 863         sljit_sw executable_offset;
 864         sljit_uw const1_addr;
 865         sljit_uw const2_addr;
 866         sljit_uw const3_addr;
 867         sljit_uw const4_addr;
 868 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
 869         sljit_sw word_value1 = (sljit_sw)SLJIT_W(0xaaaaaaaaaaaaaaaa);
 870         sljit_sw word_value2 = (sljit_sw)SLJIT_W(0xfee1deadfbadf00d);
 871 #else
 872         sljit_sw word_value1 = (sljit_sw)0xaaaaaaaal;
 873         sljit_sw word_value2 = (sljit_sw)0xfbadf00dl;
 874 #endif
 875         sljit_sw buf[3];
 876
 877         if (verbose)
 878                 printf("Run test11\n");
 879
 880         FAILED(!compiler, "cannot create compiler\n");
 881         buf[0] = 0;
 882         buf[1] = 0;
 883         buf[2] = 0;
 884
 885         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(W, P), 3, 1, 0, 0, 0);
 886
 887         SLJIT_ASSERT(!sljit_alloc_memory(compiler, 0));
 888         SLJIT_ASSERT(!sljit_alloc_memory(compiler, 16 * sizeof(sljit_sw) + 1));
 889
 890         const1 = sljit_emit_const(compiler, SLJIT_MEM0(), (sljit_sw)&buf[0], -0x81b9);
 891
 892         value = sljit_alloc_memory(compiler, 16 * sizeof(sljit_sw));
 893         if (value != NULL)
 894         {
 895                 SLJIT_ASSERT(!((sljit_sw)value & ((sljit_sw)sizeof(sljit_sw) - 1)));
 896                 memset(value, 255, 16 * sizeof(sljit_sw));
 897         }
 898
 899         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 2);
 900         const2 = sljit_emit_const(compiler, SLJIT_MEM2(SLJIT_S0, SLJIT_R0), SLJIT_WORD_SHIFT - 1, -65535);
 901         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);
 902         const3 = sljit_emit_const(compiler, SLJIT_MEM1(SLJIT_R0), 0, word_value1);
 903
 904         value = sljit_alloc_memory(compiler, 17);
 905         if (value != NULL)
 906         {
 907                 SLJIT_ASSERT(!((sljit_sw)value & ((sljit_sw)sizeof(sljit_sw) - 1)));
 908                 memset(value, 255, 16);
 909         }
 910
 911         const4 = sljit_emit_const(compiler, SLJIT_RETURN_REG, 0, (sljit_sw)0xf7afcdb7);
 912
 913         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);
 914
 915         code.code = sljit_generate_code(compiler);
 916         CHECK(compiler);
 917         executable_offset = sljit_get_executable_offset(compiler);
 918         const1_addr = sljit_get_const_addr(const1);
 919         const2_addr = sljit_get_const_addr(const2);
 920         const3_addr = sljit_get_const_addr(const3);
 921         const4_addr = sljit_get_const_addr(const4);
 922         sljit_free_compiler(compiler);
 923
 924         FAILED(code.func1((sljit_sw)&buf) != (sljit_sw)0xf7afcdb7, "test11 case 1 failed\n");
 925         FAILED(buf[0] != -0x81b9, "test11 case 2 failed\n");
 926         FAILED(buf[1] != -65535, "test11 case 3 failed\n");
 927         FAILED(buf[2] != word_value1, "test11 case 4 failed\n");
 928
 929         sljit_set_const(const1_addr, -1, executable_offset);
 930         sljit_set_const(const2_addr, word_value2, executable_offset);
 931         sljit_set_const(const3_addr, (sljit_sw)0xbab0fea1, executable_offset);
 932         sljit_set_const(const4_addr, -60089, executable_offset);
 933
 934         FAILED(code.func1((sljit_sw)&buf) != -60089, "test11 case 5 failed\n");
 935         FAILED(buf[0] != -1, "test11 case 6 failed\n");
 936         FAILED(buf[1] != word_value2, "test11 case 7 failed\n");
 937         FAILED(buf[2] != (sljit_sw)0xbab0fea1, "test11 case 8 failed\n");
 938
 939         sljit_free_code(code.code, NULL);
 940         successful_tests++;
 941 }
 942
 943 static void test12(void)
 944 {
 945         /* Test rewriteable jumps. */
 946         executable_code code;
 947         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
 948         struct sljit_label *label1;
 949         struct sljit_label *label2;
 950         struct sljit_label *label3;
 951         struct sljit_jump *jump1;
 952         struct sljit_jump *jump2;
 953         struct sljit_jump *jump3;
 954         sljit_sw executable_offset;
 955         void* value;
 956         sljit_uw jump1_addr;
 957         sljit_uw label1_addr;
 958         sljit_uw label2_addr;
 959         sljit_sw buf[1];
 960
 961         if (verbose)
 962                 printf("Run test12\n");
 963
 964         FAILED(!compiler, "cannot create compiler\n");
 965         buf[0] = 0;
 966
 967         sljit_emit_enter(compiler, 0, SLJIT_ARGS2(VOID, P, W), 3, 2, 0, 0, 0);
 968         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_SIG_GREATER, SLJIT_S1, 0, SLJIT_IMM, 10);
 969         jump1 = sljit_emit_jump(compiler, SLJIT_REWRITABLE_JUMP | SLJIT_SIG_GREATER);
 970         /* Default handler. */
 971         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_IMM, 5);
 972         jump2 = sljit_emit_jump(compiler, SLJIT_JUMP);
 973
 974         value = sljit_alloc_memory(compiler, 15);
 975         if (value != NULL)
 976         {
 977                 SLJIT_ASSERT(!((sljit_sw)value & ((sljit_sw)sizeof(sljit_sw) - 1)));
 978                 memset(value, 255, 15);
 979         }
 980
 981         /* Handler 1. */
 982         label1 = sljit_emit_label(compiler);
 983         sljit_emit_op0(compiler, SLJIT_ENDBR);
 984         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_IMM, 6);
 985         jump3 = sljit_emit_jump(compiler, SLJIT_JUMP);
 986         /* Handler 2. */
 987         label2 = sljit_emit_label(compiler);
 988         sljit_emit_op0(compiler, SLJIT_ENDBR);
 989         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_IMM, 7);
 990         /* Exit. */
 991         label3 = sljit_emit_label(compiler);
 992         sljit_emit_op0(compiler, SLJIT_ENDBR);
 993         sljit_set_label(jump2, label3);
 994         sljit_set_label(jump3, label3);
 995         /* By default, set to handler 1. */
 996         sljit_set_label(jump1, label1);
 997         sljit_emit_return_void(compiler);
 998
 999         value = sljit_alloc_memory(compiler, 8);
1000         if (value != NULL)
1001         {
1002                 SLJIT_ASSERT(!((sljit_sw)value & ((sljit_sw)sizeof(sljit_sw) - 1)));
1003                 memset(value, 255, 8);
1004         }
1005
1006         code.code = sljit_generate_code(compiler);
1007         CHECK(compiler);
1008         executable_offset = sljit_get_executable_offset(compiler);
1009         jump1_addr = sljit_get_jump_addr(jump1);
1010         label1_addr = sljit_get_label_addr(label1);
1011         label2_addr = sljit_get_label_addr(label2);
1012         sljit_free_compiler(compiler);
1013
1014         code.func2((sljit_sw)&buf, 4);
1015         FAILED(buf[0] != 5, "test12 case 1 failed\n");
1016
1017         code.func2((sljit_sw)&buf, 11);
1018         FAILED(buf[0] != 6, "test12 case 2 failed\n");
1019
1020         sljit_set_jump_addr(jump1_addr, label2_addr, executable_offset);
1021         code.func2((sljit_sw)&buf, 12);
1022         FAILED(buf[0] != 7, "test12 case 3 failed\n");
1023
1024         sljit_set_jump_addr(jump1_addr, label1_addr, executable_offset);
1025         code.func2((sljit_sw)&buf, 13);
1026         FAILED(buf[0] != 6, "test12 case 4 failed\n");
1027
1028         sljit_free_code(code.code, NULL);
1029         successful_tests++;
1030 }
1031
1032 static void test13(void)
1033 {
1034         /* Test fpu monadic functions. */
1035         executable_code code;
1036         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
1037         sljit_f64 buf[7];
1038         sljit_sw buf2[6];
1039
1040         if (verbose)
1041                 printf("Run test13\n");
1042
1043         if (!sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
1044                 if (verbose)
1045                         printf("no fpu available, test13 skipped\n");
1046                 successful_tests++;
1047                 if (compiler)
1048                         sljit_free_compiler(compiler);
1049                 return;
1050         }
1051
1052         FAILED(!compiler, "cannot create compiler\n");
1053         buf[0] = 7.75;
1054         buf[1] = -4.5;
1055         buf[2] = 0.0;
1056         buf[3] = 0.0;
1057         buf[4] = 0.0;
1058         buf[5] = 0.0;
1059         buf[6] = 0.0;
1060
1061         buf2[0] = 10;
1062         buf2[1] = 10;
1063         buf2[2] = 10;
1064         buf2[3] = 10;
1065         buf2[4] = 10;
1066         buf2[5] = 10;
1067
1068         sljit_emit_enter(compiler, 0, SLJIT_ARGS2(VOID, P, P), 3, 2, 6, 0, 0);
1069         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM0(), (sljit_sw)&buf[2], SLJIT_MEM0(), (sljit_sw)&buf[1]);
1070         sljit_emit_fop1(compiler, SLJIT_ABS_F64, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_f64), SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64));
1071         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR0, 0, SLJIT_MEM0(), (sljit_sw)&buf[0]);
1072         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 2 * sizeof(sljit_f64));
1073         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR1, 0, SLJIT_MEM2(SLJIT_S0, SLJIT_R0), 0);
1074         sljit_emit_fop1(compiler, SLJIT_NEG_F64, SLJIT_FR2, 0, SLJIT_FR0, 0);
1075         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR3, 0, SLJIT_FR2, 0);
1076         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM0(), (sljit_sw)&buf[4], SLJIT_FR3, 0);
1077         sljit_emit_fop1(compiler, SLJIT_ABS_F64, SLJIT_FR4, 0, SLJIT_FR1, 0);
1078         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_f64), SLJIT_FR4, 0);
1079         sljit_emit_fop1(compiler, SLJIT_NEG_F64, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_f64), SLJIT_FR4, 0);
1080
1081         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR5, 0, SLJIT_MEM1(SLJIT_S0), 0);
1082         sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_F_GREATER, SLJIT_FR5, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64));
1083         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S1), 0, SLJIT_F_GREATER);
1084         sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_F_GREATER, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64), SLJIT_FR5, 0);
1085         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_sw), SLJIT_F_GREATER);
1086         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR1, 0, SLJIT_FR5, 0);
1087         sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_F_EQUAL, SLJIT_FR1, 0, SLJIT_FR1, 0);
1088         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S1), 2 * sizeof(sljit_sw), SLJIT_F_EQUAL);
1089         sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_F_LESS, SLJIT_FR1, 0, SLJIT_FR1, 0);
1090         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S1), 3 * sizeof(sljit_sw), SLJIT_F_LESS);
1091         sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_F_EQUAL, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64));
1092         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S1), 4 * sizeof(sljit_sw), SLJIT_F_EQUAL);
1093         sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_F_NOT_EQUAL, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64));
1094         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S1), 5 * sizeof(sljit_sw), SLJIT_F_NOT_EQUAL);
1095
1096         sljit_emit_return_void(compiler);
1097
1098         code.code = sljit_generate_code(compiler);
1099         CHECK(compiler);
1100         sljit_free_compiler(compiler);
1101
1102         code.func2((sljit_sw)&buf, (sljit_sw)&buf2);
1103         FAILED(buf[2] != -4.5, "test13 case 1 failed\n");
1104         FAILED(buf[3] != 4.5, "test13 case 2 failed\n");
1105         FAILED(buf[4] != -7.75, "test13 case 3 failed\n");
1106         FAILED(buf[5] != 4.5, "test13 case 4 failed\n");
1107         FAILED(buf[6] != -4.5, "test13 case 5 failed\n");
1108
1109         FAILED(buf2[0] != 1, "test13 case 6 failed\n");
1110         FAILED(buf2[1] != 0, "test13 case 7 failed\n");
1111         FAILED(buf2[2] != 1, "test13 case 8 failed\n");
1112         FAILED(buf2[3] != 0, "test13 case 9 failed\n");
1113         FAILED(buf2[4] != 0, "test13 case 10 failed\n");
1114         FAILED(buf2[5] != 1, "test13 case 11 failed\n");
1115
1116         sljit_free_code(code.code, NULL);
1117         successful_tests++;
1118 }
1119
1120 static void test14(void)
1121 {
1122         /* Test fpu diadic functions. */
1123         executable_code code;
1124         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
1125         sljit_f64 buf[15];
1126
1127         if (verbose)
1128                 printf("Run test14\n");
1129
1130         if (!sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
1131                 if (verbose)
1132                         printf("no fpu available, test14 skipped\n");
1133                 successful_tests++;
1134                 if (compiler)
1135                         sljit_free_compiler(compiler);
1136                 return;
1137         }
1138         buf[0] = 7.25;
1139         buf[1] = 3.5;
1140         buf[2] = 1.75;
1141         buf[3] = 0.0;
1142         buf[4] = 0.0;
1143         buf[5] = 0.0;
1144         buf[6] = 0.0;
1145         buf[7] = 0.0;
1146         buf[8] = 0.0;
1147         buf[9] = 0.0;
1148         buf[10] = 0.0;
1149         buf[11] = 0.0;
1150         buf[12] = 8.0;
1151         buf[13] = 4.0;
1152         buf[14] = 0.0;
1153
1154         FAILED(!compiler, "cannot create compiler\n");
1155         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, P), 3, 1, 6, 0, 0);
1156
1157         /* ADD */
1158         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, sizeof(sljit_f64));
1159         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64));
1160         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 2);
1161         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);
1162         sljit_emit_fop2(compiler, SLJIT_ADD_F64, SLJIT_FR0, 0, SLJIT_FR0, 0, SLJIT_FR1, 0);
1163         sljit_emit_fop2(compiler, SLJIT_ADD_F64, SLJIT_FR1, 0, SLJIT_FR0, 0, SLJIT_FR1, 0);
1164         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 4, SLJIT_FR0, 0);
1165         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 5, SLJIT_FR1, 0);
1166
1167         /* SUB */
1168         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S0), 0);
1169         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR3, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 2);
1170         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 2);
1171         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);
1172         sljit_emit_fop2(compiler, SLJIT_SUB_F64, SLJIT_FR2, 0, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 2);
1173         sljit_emit_fop2(compiler, SLJIT_SUB_F64, SLJIT_FR3, 0, SLJIT_FR2, 0, SLJIT_FR3, 0);
1174         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 7, SLJIT_FR2, 0);
1175         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 8, SLJIT_FR3, 0);
1176
1177         /* MUL */
1178         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 1);
1179         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);
1180         sljit_emit_fop2(compiler, SLJIT_MUL_F64, SLJIT_FR1, 0, SLJIT_FR1, 0, SLJIT_FR2, 0);
1181         sljit_emit_fop2(compiler, SLJIT_MUL_F64, SLJIT_FR5, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 2, SLJIT_FR2, 0);
1182         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 10, SLJIT_FR1, 0);
1183         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 11, SLJIT_FR5, 0);
1184
1185         /* DIV */
1186         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR5, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 12);
1187         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 13);
1188         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR4, 0, SLJIT_FR5, 0);
1189         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);
1190         sljit_emit_fop2(compiler, SLJIT_DIV_F64, SLJIT_FR5, 0, SLJIT_FR5, 0, SLJIT_FR1, 0);
1191         sljit_emit_fop2(compiler, SLJIT_DIV_F64, SLJIT_FR4, 0, SLJIT_FR1, 0, SLJIT_FR4, 0);
1192         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 13, SLJIT_FR5, 0);
1193         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 14, SLJIT_FR4, 0);
1194
1195         sljit_emit_return_void(compiler);
1196
1197         code.code = sljit_generate_code(compiler);
1198         CHECK(compiler);
1199         sljit_free_compiler(compiler);
1200
1201         code.func1((sljit_sw)&buf);
1202         FAILED(buf[3] != 10.75, "test14 case 1 failed\n");
1203         FAILED(buf[4] != 5.25, "test14 case 2 failed\n");
1204         FAILED(buf[5] != 7.0, "test14 case 3 failed\n");
1205         FAILED(buf[6] != 0.0, "test14 case 4 failed\n");
1206         FAILED(buf[7] != 5.5, "test14 case 5 failed\n");
1207         FAILED(buf[8] != 3.75, "test14 case 6 failed\n");
1208         FAILED(buf[9] != 24.5, "test14 case 7 failed\n");
1209         FAILED(buf[10] != 38.5, "test14 case 8 failed\n");
1210         FAILED(buf[11] != 9.625, "test14 case 9 failed\n");
1211         FAILED(buf[12] != 2.0, "test14 case 10 failed\n");
1212         FAILED(buf[13] != 2.0, "test14 case 11 failed\n");
1213         FAILED(buf[14] != 0.5, "test14 case 12 failed\n");
1214
1215         sljit_free_code(code.code, NULL);
1216         successful_tests++;
1217 }
1218
1219 static sljit_sw SLJIT_FUNC func(sljit_sw a, sljit_sw b, sljit_sw c)
1220 {
1221         return a + b + c + 5;
1222 }
1223
1224 static void test15(void)
1225 {
1226         /* Test function call. */
1227         executable_code code;
1228         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
1229         struct sljit_jump* jump = NULL;
1230         sljit_sw buf[7];
1231
1232         if (verbose)
1233                 printf("Run test15\n");
1234
1235         FAILED(!compiler, "cannot create compiler\n");
1236         buf[0] = 0;
1237         buf[1] = 0;
1238         buf[2] = 0;
1239         buf[3] = 0;
1240         buf[4] = 0;
1241         buf[5] = 0;
1242         buf[6] = SLJIT_FUNC_ADDR(func);
1243
1244         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(W, P), 4, 1, 0, 0, 0);
1245
1246         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 5);
1247         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 7);
1248         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, -3);
1249         sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_ARGS3(W, W, W, W), SLJIT_IMM, SLJIT_FUNC_ADDR(func));
1250         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_RETURN_REG, 0);
1251
1252         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -5);
1253         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, -10);
1254         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 2);
1255         jump = sljit_emit_call(compiler, SLJIT_CALL | SLJIT_REWRITABLE_JUMP, SLJIT_ARGS3(W, W, W, W));
1256         sljit_set_target(jump, (sljit_uw)-1);
1257         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_RETURN_REG, 0);
1258
1259         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_FUNC_ADDR(func));
1260         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 40);
1261         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, -3);
1262         sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_ARGS3(W, W, W, W), SLJIT_R0, 0);
1263         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_RETURN_REG, 0);
1264
1265         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -60);
1266         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, SLJIT_FUNC_ADDR(func));
1267         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, -30);
1268         sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_ARGS3(W, W, W, W), SLJIT_R1, 0);
1269         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_RETURN_REG, 0);
1270
1271         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 10);
1272         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 16);
1273         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, SLJIT_FUNC_ADDR(func));
1274         sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_ARGS3(W, W, W, W), SLJIT_R2, 0);
1275         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_RETURN_REG, 0);
1276
1277         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 100);
1278         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 110);
1279         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 120);
1280         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, SLJIT_FUNC_ADDR(func));
1281         sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_ARGS3(W, W, W, W), SLJIT_R3, 0);
1282         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_RETURN_REG, 0);
1283
1284         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -10);
1285         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, -16);
1286         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 6);
1287         sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_ARGS3(W, W, W, W), SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_sw));
1288         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_sw), SLJIT_RETURN_REG, 0);
1289
1290         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);
1291
1292         code.code = sljit_generate_code(compiler);
1293         CHECK(compiler);
1294         sljit_set_jump_addr(sljit_get_jump_addr(jump), SLJIT_FUNC_UADDR(func), sljit_get_executable_offset(compiler));
1295         sljit_free_compiler(compiler);
1296
1297         FAILED(code.func1((sljit_sw)&buf) != -15, "test15 case 1 failed\n");
1298         FAILED(buf[0] != 14, "test15 case 2 failed\n");
1299         FAILED(buf[1] != -8, "test15 case 3 failed\n");
1300         FAILED(buf[2] != SLJIT_FUNC_ADDR(func) + 42, "test15 case 4 failed\n");
1301         FAILED(buf[3] != SLJIT_FUNC_ADDR(func) - 85, "test15 case 5 failed\n");
1302         FAILED(buf[4] != SLJIT_FUNC_ADDR(func) + 31, "test15 case 6 failed\n");
1303         FAILED(buf[5] != 335, "test15 case 7 failed\n");
1304         FAILED(buf[6] != -15, "test15 case 8 failed\n");
1305
1306         sljit_free_code(code.code, NULL);
1307         successful_tests++;
1308 }
1309
1310 static void test16(void)
1311 {
1312         /* Ackermann benchmark. */
1313         executable_code code;
1314         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
1315         struct sljit_label *entry;
1316         struct sljit_label *label;
1317         struct sljit_jump *jump;
1318         struct sljit_jump *jump1;
1319         struct sljit_jump *jump2;
1320
1321         if (verbose)
1322                 printf("Run test16\n");
1323
1324         FAILED(!compiler, "cannot create compiler\n");
1325
1326         entry = sljit_emit_label(compiler);
1327         sljit_emit_enter(compiler, 0, SLJIT_ARGS2(W, W, W), 3, 2, 0, 0, 0);
1328         /* If x == 0. */
1329         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_Z, SLJIT_S0, 0, SLJIT_IMM, 0);
1330         jump1 = sljit_emit_jump(compiler, SLJIT_EQUAL);
1331         /* If y == 0. */
1332         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_Z, SLJIT_S1, 0, SLJIT_IMM, 0);
1333         jump2 = sljit_emit_jump(compiler, SLJIT_EQUAL);
1334
1335         /* Ack(x,y-1). */
1336         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_S0, 0);
1337         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R1, 0, SLJIT_S1, 0, SLJIT_IMM, 1);
1338         jump = sljit_emit_call(compiler, SLJIT_CALL, SLJIT_ARGS2(W, W, W));
1339         sljit_set_label(jump, entry);
1340
1341         /* Returns with Ack(x-1, Ack(x,y-1)). */
1342         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_RETURN_REG, 0);
1343         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R0, 0, SLJIT_S0, 0, SLJIT_IMM, 1);
1344         jump = sljit_emit_call(compiler, SLJIT_CALL, SLJIT_ARGS2(W, W, W));
1345         sljit_set_label(jump, entry);
1346         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);
1347
1348         /* Returns with y+1. */
1349         label = sljit_emit_label(compiler);
1350         sljit_set_label(jump1, label);
1351         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_RETURN_REG, 0, SLJIT_IMM, 1, SLJIT_S1, 0);
1352         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);
1353
1354         /* Returns with Ack(x-1,1) */
1355         label = sljit_emit_label(compiler);
1356         sljit_set_label(jump2, label);
1357         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R0, 0, SLJIT_S0, 0, SLJIT_IMM, 1);
1358         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 1);
1359         jump = sljit_emit_call(compiler, SLJIT_CALL, SLJIT_ARGS2(W, W, W));
1360         sljit_set_label(jump, entry);
1361         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);
1362
1363         code.code = sljit_generate_code(compiler);
1364         CHECK(compiler);
1365         sljit_free_compiler(compiler);
1366
1367         FAILED(code.func2(3, 3) != 61, "test16 case 1 failed\n");
1368         /* For benchmarking. */
1369         /* FAILED(code.func2(3, 11) != 16381, "test16 case 1 failed\n"); */
1370
1371         sljit_free_code(code.code, NULL);
1372         successful_tests++;
1373 }
1374
1375 static void test17(void)
1376 {
1377         /* Test arm constant pool. */
1378         executable_code code;
1379         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
1380         sljit_s32 i;
1381         sljit_sw buf[5];
1382
1383         if (verbose)
1384                 printf("Run test17\n");
1385
1386         FAILED(!compiler, "cannot create compiler\n");
1387
1388         for (i = 0; i < 5; i++)
1389                 buf[i] = 0;
1390
1391         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, P), 3, 1, 0, 0, 0);
1392         for (i = 0; i <= 0xfff; i++) {
1393                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)0x81818000 | i);
1394                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)0x81818000 | i);
1395                 if ((i & 0x3ff) == 0)
1396                         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), (i >> 10) * (sljit_sw)sizeof(sljit_sw), SLJIT_R0, 0);
1397         }
1398         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_R0, 0);
1399         sljit_emit_return_void(compiler);
1400
1401         code.code = sljit_generate_code(compiler);
1402         CHECK(compiler);
1403         sljit_free_compiler(compiler);
1404
1405         code.func1((sljit_sw)&buf);
1406         FAILED((sljit_uw)buf[0] != 0x81818000, "test17 case 1 failed\n");
1407         FAILED((sljit_uw)buf[1] != 0x81818400, "test17 case 2 failed\n");
1408         FAILED((sljit_uw)buf[2] != 0x81818800, "test17 case 3 failed\n");
1409         FAILED((sljit_uw)buf[3] != 0x81818c00, "test17 case 4 failed\n");
1410         FAILED((sljit_uw)buf[4] != 0x81818fff, "test17 case 5 failed\n");
1411
1412         sljit_free_code(code.code, NULL);
1413         successful_tests++;
1414 }
1415
1416 static void test18(void)
1417 {
1418         /* Test 64 bit. */
1419         executable_code code;
1420         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
1421         sljit_sw buf[11];
1422
1423         if (verbose)
1424                 printf("Run test18\n");
1425
1426         FAILED(!compiler, "cannot create compiler\n");
1427         buf[0] = 0;
1428         buf[1] = 0;
1429         buf[2] = 0;
1430         buf[3] = 0;
1431         buf[4] = 0;
1432         buf[5] = 100;
1433         buf[6] = 100;
1434         buf[7] = 100;
1435         buf[8] = 100;
1436         buf[9] = 0;
1437 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) && (defined SLJIT_BIG_ENDIAN && SLJIT_BIG_ENDIAN)
1438         buf[10] = SLJIT_W(1) << 32;
1439 #else
1440         buf[10] = 1;
1441 #endif
1442
1443         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, P), 3, 2, 0, 0, 0);
1444
1445 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
1446         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_IMM, SLJIT_W(0x1122334455667788));
1447         sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_IMM, SLJIT_W(0x1122334455667788));
1448
1449         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(1000000000000));
1450         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 2, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(1000000000000));
1451         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 3, SLJIT_IMM, SLJIT_W(5000000000000), SLJIT_R0, 0);
1452
1453         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(0x1108080808));
1454         sljit_emit_op2(compiler, SLJIT_ADD32, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 4, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(0x1120202020));
1455
1456         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0x1108080808));
1457         sljit_emit_op2u(compiler, SLJIT_AND | SLJIT_SET_Z, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0x1120202020));
1458         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_ZERO);
1459         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 5, SLJIT_S1, 0);
1460         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_R0, 0);
1461         sljit_emit_op2u(compiler, SLJIT_AND32 | SLJIT_SET_Z, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0x1120202020));
1462         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 6, SLJIT_ZERO);
1463
1464         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0x1108080808));
1465         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_LESS, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0x2208080808));
1466         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 7, SLJIT_LESS);
1467         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_R0, 0);
1468         sljit_emit_op2u(compiler, SLJIT_AND32 | SLJIT_SET_Z, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0x1104040404));
1469         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 8, SLJIT_NOT_ZERO);
1470
1471         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 4);
1472         sljit_emit_op2(compiler, SLJIT_SHL32, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 9, SLJIT_IMM, SLJIT_W(0xffff0000), SLJIT_R0, 0);
1473
1474         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);
1475 #else
1476         /* 32 bit operations. */
1477
1478         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_IMM, 0x11223344);
1479         sljit_emit_op2(compiler, SLJIT_ADD32, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_IMM, 0x44332211);
1480
1481 #endif
1482
1483         sljit_emit_return_void(compiler);
1484
1485         code.code = sljit_generate_code(compiler);
1486         CHECK(compiler);
1487         sljit_free_compiler(compiler);
1488
1489         code.func1((sljit_sw)&buf);
1490 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
1491         FAILED(buf[0] != SLJIT_W(0x1122334455667788), "test18 case 1 failed\n");
1492 #if (defined SLJIT_LITTLE_ENDIAN && SLJIT_LITTLE_ENDIAN)
1493         FAILED(buf[1] != 0x55667788, "test18 case 2 failed\n");
1494 #else
1495         FAILED(buf[1] != SLJIT_W(0x5566778800000000), "test18 case 2 failed\n");
1496 #endif
1497         FAILED(buf[2] != SLJIT_W(2000000000000), "test18 case 3 failed\n");
1498         FAILED(buf[3] != SLJIT_W(4000000000000), "test18 case 4 failed\n");
1499 #if (defined SLJIT_LITTLE_ENDIAN && SLJIT_LITTLE_ENDIAN)
1500         FAILED(buf[4] != 0x28282828, "test18 case 5 failed\n");
1501 #else
1502         FAILED(buf[4] != SLJIT_W(0x2828282800000000), "test18 case 5 failed\n");
1503 #endif
1504         FAILED(buf[5] != 0, "test18 case 6 failed\n");
1505         FAILED(buf[6] != 1, "test18 case 7 failed\n");
1506         FAILED(buf[7] != 1, "test18 case 8 failed\n");
1507         FAILED(buf[8] != 0, "test18 case 9 failed\n");
1508 #if (defined SLJIT_LITTLE_ENDIAN && SLJIT_LITTLE_ENDIAN)
1509         FAILED(buf[9] != (sljit_sw)0xfff00000, "test18 case 10 failed\n");
1510         FAILED(buf[10] != (sljit_sw)0xffffffff, "test18 case 11 failed\n");
1511 #else
1512         FAILED(buf[9] != (sljit_sw)SLJIT_W(0xfff0000000000000), "test18 case 10 failed\n");
1513         FAILED(buf[10] != (sljit_sw)SLJIT_W(0xffffffff00000000), "test18 case 11 failed\n");
1514 #endif
1515 #else
1516         FAILED(buf[0] != 0x11223344, "test18 case 1 failed\n");
1517         FAILED(buf[1] != 0x44332211, "test18 case 2 failed\n");
1518 #endif
1519
1520         sljit_free_code(code.code, NULL);
1521         successful_tests++;
1522 }
1523
1524 static void test19(void)
1525 {
1526         /* Test arm partial instruction caching. */
1527         executable_code code;
1528         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
1529         sljit_sw buf[10];
1530
1531         if (verbose)
1532                 printf("Run test19\n");
1533
1534         FAILED(!compiler, "cannot create compiler\n");
1535         buf[0] = 6;
1536         buf[1] = 4;
1537         buf[2] = 0;
1538         buf[3] = 0;
1539         buf[4] = 0;
1540         buf[5] = 0;
1541         buf[6] = 2;
1542         buf[7] = 0;
1543
1544         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, P), 3, 1, 0, 0, 0);
1545         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw));
1546         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM0(), (sljit_sw)&buf[2], SLJIT_MEM0(), (sljit_sw)&buf[1], SLJIT_MEM0(), (sljit_sw)&buf[0]);
1547         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0);
1548         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, sizeof(sljit_sw));
1549         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]);
1550         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 4, SLJIT_MEM0(), (sljit_sw)&buf[0], SLJIT_IMM, 2);
1551         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));
1552         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 7, SLJIT_IMM, 10);
1553         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 7);
1554         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]);
1555
1556         sljit_emit_return_void(compiler);
1557
1558         code.code = sljit_generate_code(compiler);
1559         CHECK(compiler);
1560         sljit_free_compiler(compiler);
1561
1562         code.func1((sljit_sw)&buf);
1563         FAILED(buf[0] != 10, "test19 case 1 failed\n");
1564         FAILED(buf[1] != 4, "test19 case 2 failed\n");
1565         FAILED(buf[2] != 14, "test19 case 3 failed\n");
1566         FAILED(buf[3] != 14, "test19 case 4 failed\n");
1567         FAILED(buf[4] != 8, "test19 case 5 failed\n");
1568         FAILED(buf[5] != 6, "test19 case 6 failed\n");
1569         FAILED(buf[6] != 12, "test19 case 7 failed\n");
1570         FAILED(buf[7] != 10, "test19 case 8 failed\n");
1571
1572         sljit_free_code(code.code, NULL);
1573         successful_tests++;
1574 }
1575
1576 static void test20(void)
1577 {
1578         /* Test stack. */
1579         executable_code code;
1580         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
1581         struct sljit_jump* jump;
1582         struct sljit_label* label;
1583         sljit_sw buf[6];
1584 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
1585         sljit_sw offset_value = SLJIT_W(0x1234567812345678);
1586 #else
1587         sljit_sw offset_value = SLJIT_W(0x12345678);
1588 #endif
1589
1590         if (verbose)
1591                 printf("Run test20\n");
1592
1593         FAILED(!compiler, "cannot create compiler\n");
1594         buf[0] = 5;
1595         buf[1] = 12;
1596         buf[2] = 0;
1597         buf[3] = 0;
1598         buf[4] = 111;
1599         buf[5] = -12345;
1600
1601         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(W, P), 5, 5, 0, 0, 4 * sizeof(sljit_sw));
1602         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), sizeof(sljit_uw), SLJIT_MEM1(SLJIT_S0), 0);
1603         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_uw));
1604         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, -1);
1605         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R4, 0, SLJIT_IMM, -1);
1606         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S3, 0, SLJIT_IMM, -1);
1607         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S4, 0, SLJIT_IMM, -1);
1608         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));
1609         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);
1610         sljit_get_local_base(compiler, SLJIT_R0, 0, -offset_value);
1611         sljit_get_local_base(compiler, SLJIT_MEM1(SLJIT_S0), 0, -0x1234);
1612         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_S0), 0);
1613         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));
1614         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_uw));
1615         /* Dummy last instructions. */
1616         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, 23);
1617         sljit_emit_label(compiler);
1618
1619         code.code = sljit_generate_code(compiler);
1620         CHECK(compiler);
1621         sljit_free_compiler(compiler);
1622
1623         FAILED(code.func1((sljit_sw)&buf) != -12345, "test20 case 1 failed\n")
1624
1625         FAILED(buf[2] != 60, "test20 case 2 failed\n");
1626         FAILED(buf[3] != 17, "test20 case 3 failed\n");
1627         FAILED(buf[4] != 7, "test20 case 4 failed\n");
1628
1629         sljit_free_code(code.code, NULL);
1630
1631         compiler = sljit_create_compiler(NULL, NULL);
1632         sljit_emit_enter(compiler, 0, SLJIT_ARGS3(W, W, W, W), 3, 3, 0, 0, SLJIT_MAX_LOCAL_SIZE);
1633
1634         sljit_get_local_base(compiler, SLJIT_R0, 0, SLJIT_MAX_LOCAL_SIZE - sizeof(sljit_sw));
1635         sljit_get_local_base(compiler, SLJIT_R1, 0, -(sljit_sw)sizeof(sljit_sw));
1636         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, -1);
1637         label = sljit_emit_label(compiler);
1638         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, sizeof(sljit_sw));
1639         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), 0, SLJIT_R2, 0);
1640         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_Z, SLJIT_R1, 0, SLJIT_R0, 0);
1641         jump = sljit_emit_jump(compiler, SLJIT_NOT_EQUAL);
1642         sljit_set_label(jump, label);
1643
1644         /* Saved registers should keep their value. */
1645         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_S0, 0, SLJIT_S0, 0, SLJIT_S1, 0);
1646         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_S0, 0, SLJIT_S2, 0);
1647         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_R0, 0);
1648
1649         code.code = sljit_generate_code(compiler);
1650         CHECK(compiler);
1651         sljit_free_compiler(compiler);
1652
1653         FAILED(code.func3(1234, 5678, 9012) != 15924, "test20 case 5 failed\n");
1654
1655         sljit_free_code(code.code, NULL);
1656         successful_tests++;
1657 }
1658
1659 static void test21(void)
1660 {
1661         /* Test set context. The parts of the jit code can be separated in the memory. */
1662         executable_code code1;
1663         executable_code code2;
1664         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
1665         struct sljit_jump* jump = NULL;
1666         sljit_uw addr;
1667         sljit_sw executable_offset;
1668         sljit_sw buf[4];
1669
1670         if (verbose)
1671                 printf("Run test21\n");
1672
1673         FAILED(!compiler, "cannot create compiler\n");
1674         buf[0] = 9;
1675         buf[1] = -6;
1676         buf[2] = 0;
1677         buf[3] = 0;
1678
1679         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(W, P), 3, 2, 0, 0, 2 * sizeof(sljit_sw));
1680
1681         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), 0, SLJIT_IMM, 10);
1682         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM1(SLJIT_SP), sizeof(sljit_sw), SLJIT_MEM1(SLJIT_S0), 0, SLJIT_MEM1(SLJIT_SP), 0);
1683
1684         jump = sljit_emit_jump(compiler, SLJIT_JUMP | SLJIT_REWRITABLE_JUMP);
1685         sljit_set_target(jump, 0);
1686
1687         code1.code = sljit_generate_code(compiler);
1688         CHECK(compiler);
1689
1690         executable_offset = sljit_get_executable_offset(compiler);
1691         addr = sljit_get_jump_addr(jump);
1692
1693         sljit_free_compiler(compiler);
1694
1695         compiler = sljit_create_compiler(NULL, NULL);
1696         FAILED(!compiler, "cannot create compiler\n");
1697
1698         /* Other part of the jit code. */
1699         sljit_set_context(compiler, 0, 1, 3, 2, 0, 0, 2 * sizeof(sljit_sw));
1700
1701         sljit_emit_op0(compiler, SLJIT_ENDBR);
1702         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);
1703         sljit_emit_op2(compiler, SLJIT_MUL, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 3, SLJIT_MEM1(SLJIT_SP), 0, SLJIT_MEM1(SLJIT_SP), 0);
1704         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_MEM1(SLJIT_SP), sizeof(sljit_sw));
1705
1706         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);
1707
1708         code2.code = sljit_generate_code(compiler);
1709         CHECK(compiler);
1710         sljit_free_compiler(compiler);
1711
1712         sljit_set_jump_addr(addr, SLJIT_FUNC_UADDR(code2.code), executable_offset);
1713
1714         FAILED(code1.func1((sljit_sw)&buf) != 19, "test21 case 1 failed\n");
1715         FAILED(buf[2] != -16, "test21 case 2 failed\n");
1716         FAILED(buf[3] != 100, "test21 case 3 failed\n");
1717
1718         sljit_free_code(code1.code, NULL);
1719         sljit_free_code(code2.code, NULL);
1720         successful_tests++;
1721 }
1722
1723 static void test22(void)
1724 {
1725         /* Test simple byte and half-int data transfers. */
1726         executable_code code;
1727         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
1728         sljit_sw buf[4];
1729         sljit_s16 sbuf[9];
1730         sljit_s8 bbuf[5];
1731
1732         if (verbose)
1733                 printf("Run test22\n");
1734
1735         FAILED(!compiler, "cannot create compiler\n");
1736         buf[0] = 0;
1737         buf[1] = 0;
1738         buf[2] = -1;
1739         buf[3] = -1;
1740
1741         sbuf[0] = 0;
1742         sbuf[1] = 0;
1743         sbuf[2] = -9;
1744         sbuf[3] = 0;
1745         sbuf[4] = 0;
1746         sbuf[5] = 0;
1747         sbuf[6] = 0;
1748
1749         bbuf[0] = 0;
1750         bbuf[1] = 0;
1751         bbuf[2] = -56;
1752         bbuf[3] = 0;
1753         bbuf[4] = 0;
1754
1755         sljit_emit_enter(compiler, 0, SLJIT_ARGS3(VOID, P, P, P), 3, 3, 0, 0, 0);
1756
1757         sljit_emit_op1(compiler, SLJIT_MOV_S16, SLJIT_MEM1(SLJIT_S1), 0, SLJIT_IMM, -13);
1758         sljit_emit_op1(compiler, SLJIT_MOV_U16, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_s16), SLJIT_IMM, 0x1234);
1759         sljit_emit_op1(compiler, SLJIT_MOV_S16, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S1), 2 * sizeof(sljit_s16));
1760         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0);
1761         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_S1, 0, SLJIT_S1, 0, SLJIT_IMM, 2 * sizeof(sljit_s16));
1762         sljit_emit_op1(compiler, SLJIT_MOV_U16, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_s16), SLJIT_MEM1(SLJIT_S1), -(sljit_sw)sizeof(sljit_s16));
1763         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0xff0000 + 8000);
1764         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 2);
1765         sljit_emit_op1(compiler, SLJIT_MOV_S16, SLJIT_MEM2(SLJIT_S1, SLJIT_R1), 1, SLJIT_R0, 0);
1766         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R2, 0, SLJIT_S1, 0, SLJIT_IMM, 0x1234 - 3 * sizeof(sljit_s16));
1767         sljit_emit_op1(compiler, SLJIT_MOV_S16, SLJIT_MEM1(SLJIT_R2), 0x1234, SLJIT_IMM, -9317);
1768         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R2, 0, SLJIT_S1, 0, SLJIT_IMM, 0x1234 + 4 * sizeof(sljit_s16));
1769         sljit_emit_op1(compiler, SLJIT_MOV_S16, SLJIT_MEM1(SLJIT_R2), -0x1234, SLJIT_IMM, -9317);
1770         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R2, 0, SLJIT_S1, 0, SLJIT_IMM, 0x12348 - 5 * sizeof(sljit_s16));
1771         sljit_emit_op1(compiler, SLJIT_MOV_S16, SLJIT_MEM1(SLJIT_R2), 0x12348, SLJIT_IMM, -8888);
1772         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R2, 0, SLJIT_S1, 0, SLJIT_IMM, 0x12348 + 6 * sizeof(sljit_s16));
1773         sljit_emit_op1(compiler, SLJIT_MOV_S16, SLJIT_MEM1(SLJIT_R2), -0x12348, SLJIT_IMM, -8888);
1774
1775         sljit_emit_op1(compiler, SLJIT_MOV_S8, SLJIT_MEM1(SLJIT_S2), 0, SLJIT_IMM, -45);
1776         sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_MEM1(SLJIT_S2), sizeof(sljit_s8), SLJIT_IMM, 0x12);
1777         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 4 * sizeof(sljit_s8));
1778         sljit_emit_op1(compiler, SLJIT_MOV_S8, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_S2), 2 * sizeof(sljit_s8));
1779         sljit_emit_op1(compiler, SLJIT_MOV_S8, SLJIT_S1, 0, SLJIT_R1, 0);
1780         sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_S1, 0, SLJIT_S1, 0);
1781         sljit_emit_op1(compiler, SLJIT_MOV_S8, SLJIT_R2, 0, SLJIT_S1, 0);
1782         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_R2, 0);
1783         sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_MEM1(SLJIT_S2), 3 * sizeof(sljit_s8), SLJIT_S1, 0);
1784         sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_MEM2(SLJIT_S2, SLJIT_R0), 0, SLJIT_R0, 0);
1785         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 1);
1786         sljit_emit_op1(compiler, SLJIT_MOV_U16, SLJIT_R0, 0, SLJIT_IMM, 0);
1787         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_R0, 0);
1788         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 1);
1789         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0);
1790         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_R0, 0);
1791
1792         sljit_emit_return_void(compiler);
1793
1794         code.code = sljit_generate_code(compiler);
1795         CHECK(compiler);
1796         sljit_free_compiler(compiler);
1797
1798         code.func3((sljit_sw)&buf, (sljit_sw)&sbuf, (sljit_sw)&bbuf);
1799         FAILED(buf[0] != -9, "test22 case 1 failed\n");
1800         FAILED(buf[1] != -56, "test22 case 2 failed\n");
1801         FAILED(buf[2] != 0, "test22 case 3 failed\n");
1802         FAILED(buf[3] != 0, "test22 case 4 failed\n");
1803
1804         FAILED(sbuf[0] != -13, "test22 case 5 failed\n");
1805         FAILED(sbuf[1] != 0x1234, "test22 case 6 failed\n");
1806         FAILED(sbuf[3] != 0x1234, "test22 case 7 failed\n");
1807         FAILED(sbuf[4] != 8000, "test22 case 8 failed\n");
1808         FAILED(sbuf[5] != -9317, "test22 case 9 failed\n");
1809         FAILED(sbuf[6] != -9317, "test22 case 10 failed\n");
1810         FAILED(sbuf[7] != -8888, "test22 case 11 failed\n");
1811         FAILED(sbuf[8] != -8888, "test22 case 12 failed\n");
1812
1813         FAILED(bbuf[0] != -45, "test22 case 13 failed\n");
1814         FAILED(bbuf[1] != 0x12, "test22 case 14 failed\n");
1815         FAILED(bbuf[3] != -56, "test22 case 15 failed\n");
1816         FAILED(bbuf[4] != 4, "test22 case 16 failed\n");
1817
1818         sljit_free_code(code.code, NULL);
1819         successful_tests++;
1820 }
1821
1822 static void test23(void)
1823 {
1824         /* Test 32 bit / 64 bit signed / unsigned int transfer and conversion.
1825            This test has do real things on 64 bit systems, but works on 32 bit systems as well. */
1826         executable_code code;
1827         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
1828         sljit_sw buf[9];
1829         sljit_s32 ibuf[5];
1830         union {
1831                 sljit_s32 asint;
1832                 sljit_u8 asbytes[4];
1833         } u;
1834 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
1835         sljit_sw garbage = SLJIT_W(0x1234567812345678);
1836 #else
1837         sljit_sw garbage = 0x12345678;
1838 #endif
1839
1840         if (verbose)
1841                 printf("Run test23\n");
1842
1843         FAILED(!compiler, "cannot create compiler\n");
1844         buf[0] = 0;
1845         buf[1] = 0;
1846         buf[2] = 0;
1847         buf[3] = 0;
1848         buf[4] = 0;
1849         buf[5] = 0;
1850         buf[6] = 0;
1851         buf[7] = 0;
1852         buf[8] = 0;
1853
1854         ibuf[0] = 0;
1855         ibuf[1] = 0;
1856         ibuf[2] = -5791;
1857         ibuf[3] = 43579;
1858         ibuf[4] = 658923;
1859
1860         sljit_emit_enter(compiler, 0, SLJIT_ARGS2(W, P, P), 3, 3, 0, 0, 0);
1861         sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_MEM1(SLJIT_S1), 0, SLJIT_IMM, 34567);
1862         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 4);
1863         sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_MEM2(SLJIT_S1, SLJIT_R0), 0, SLJIT_IMM, -7654);
1864         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, garbage);
1865         sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S1), 2 * sizeof(sljit_s32));
1866         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0);
1867         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, garbage);
1868         sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S1), 3 * sizeof(sljit_s32));
1869         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_R0, 0);
1870         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, garbage);
1871         sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S1), 4 * sizeof(sljit_s32));
1872         sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_R0, 0, SLJIT_R0, 0);
1873         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_R0, 0);
1874         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0x0f00f00);
1875         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R1, 0, SLJIT_S0, 0, SLJIT_IMM, 0x7777);
1876         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), 0x7777 + 3 * sizeof(sljit_sw), SLJIT_R0, 0);
1877         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_S0, 0, SLJIT_IMM, 0x7777);
1878         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), -0x7777 + 4 * (sljit_sw)sizeof(sljit_sw), SLJIT_R0, 0);
1879         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_S0, 0, SLJIT_IMM, 5 * sizeof(sljit_sw));
1880         sljit_emit_op2(compiler, SLJIT_LSHR, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, 1);
1881         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM2(SLJIT_R1, SLJIT_R1), 0, SLJIT_IMM, 16);
1882         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0);
1883         sljit_emit_op2(compiler, SLJIT_OR, SLJIT_MEM2(SLJIT_R0, SLJIT_R1), 1, SLJIT_IMM, 64, SLJIT_MEM2(SLJIT_R0, SLJIT_R1), 1);
1884         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM0(), (sljit_sw)&buf[7], SLJIT_IMM, 0x123456);
1885         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), (sljit_sw)&buf[6], SLJIT_MEM0(), (sljit_sw)&buf[7]);
1886         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_S0, 0, SLJIT_IMM, 5 * sizeof(sljit_sw));
1887         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), 2 * sizeof(sljit_sw), SLJIT_R1, 0);
1888         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R2, 0, SLJIT_S0, 0, SLJIT_IMM, 7 * sizeof(sljit_sw));
1889         sljit_emit_op2(compiler, SLJIT_LSHR, SLJIT_R2, 0, SLJIT_R2, 0, SLJIT_IMM, 1);
1890         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_MEM2(SLJIT_R2, SLJIT_R2), 0);
1891         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&buf[8] - 0x12340);
1892         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 0x12340, SLJIT_R2, 0);
1893         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM1(SLJIT_R0), 0x12340, SLJIT_MEM1(SLJIT_R2), 3 * sizeof(sljit_sw), SLJIT_IMM, 6);
1894         sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_MEM1(SLJIT_S1), 4 * sizeof(sljit_s32), SLJIT_IMM, 0x12345678);
1895         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0x2bd700 | 243);
1896         sljit_emit_return(compiler, SLJIT_MOV_S8, SLJIT_R1, 0);
1897
1898         code.code = sljit_generate_code(compiler);
1899         CHECK(compiler);
1900         sljit_free_compiler(compiler);
1901
1902         FAILED(code.func2((sljit_sw)&buf, (sljit_sw)&ibuf) != -13, "test23 case 1 failed\n");
1903         FAILED(buf[0] != -5791, "test23 case 2 failed\n");
1904         FAILED(buf[1] != 43579, "test23 case 3 failed\n");
1905         FAILED(buf[2] != 658923, "test23 case 4 failed\n");
1906         FAILED(buf[3] != 0x0f00f00, "test23 case 5 failed\n");
1907         FAILED(buf[4] != 0x0f00f00, "test23 case 6 failed\n");
1908         FAILED(buf[5] != 80, "test23 case 7 failed\n");
1909         FAILED(buf[6] != 0x123456, "test23 case 8 failed\n");
1910         FAILED(buf[7] != (sljit_sw)&buf[5], "test23 case 9 failed\n");
1911         FAILED(buf[8] != (sljit_sw)&buf[5] + 6, "test23 case 10 failed\n");
1912
1913         FAILED(ibuf[0] != 34567, "test23 case 11 failed\n");
1914         FAILED(ibuf[1] != -7654, "test23 case 12 failed\n");
1915         u.asint = ibuf[4];
1916 #if (defined SLJIT_LITTLE_ENDIAN && SLJIT_LITTLE_ENDIAN)
1917         FAILED(u.asbytes[0] != 0x78, "test23 case 13 failed\n");
1918         FAILED(u.asbytes[1] != 0x56, "test23 case 14 failed\n");
1919         FAILED(u.asbytes[2] != 0x34, "test23 case 15 failed\n");
1920         FAILED(u.asbytes[3] != 0x12, "test23 case 16 failed\n");
1921 #else
1922         FAILED(u.asbytes[0] != 0x12, "test23 case 13 failed\n");
1923         FAILED(u.asbytes[1] != 0x34, "test23 case 14 failed\n");
1924         FAILED(u.asbytes[2] != 0x56, "test23 case 15 failed\n");
1925         FAILED(u.asbytes[3] != 0x78, "test23 case 16 failed\n");
1926 #endif
1927
1928         sljit_free_code(code.code, NULL);
1929         successful_tests++;
1930 }
1931
1932 static void test24(void)
1933 {
1934         /* Some complicated addressing modes. */
1935         executable_code code;
1936         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
1937         sljit_sw buf[9];
1938         sljit_s16 sbuf[5];
1939         sljit_s8 bbuf[7];
1940
1941         if (verbose)
1942                 printf("Run test24\n");
1943
1944         FAILED(!compiler, "cannot create compiler\n");
1945
1946         buf[0] = 100567;
1947         buf[1] = 75799;
1948         buf[2] = 0;
1949         buf[3] = -8;
1950         buf[4] = -50;
1951         buf[5] = 0;
1952         buf[6] = 0;
1953         buf[7] = 0;
1954         buf[8] = 0;
1955
1956         sbuf[0] = 30000;
1957         sbuf[1] = 0;
1958         sbuf[2] = 0;
1959         sbuf[3] = -12345;
1960         sbuf[4] = 0;
1961
1962         bbuf[0] = -128;
1963         bbuf[1] = 0;
1964         bbuf[2] = 0;
1965         bbuf[3] = 99;
1966         bbuf[4] = 0;
1967         bbuf[5] = 0;
1968         bbuf[6] = 0;
1969
1970         sljit_emit_enter(compiler, 0, SLJIT_ARGS3(VOID, P, P, P), 3, 3, 0, 0, 0);
1971
1972         /* Nothing should be updated. */
1973         sljit_emit_op1(compiler, SLJIT_MOV_S16, SLJIT_MEM0(), (sljit_sw)&sbuf[1], SLJIT_MEM0(), (sljit_sw)&sbuf[0]);
1974         sljit_emit_op1(compiler, SLJIT_MOV_S8, SLJIT_MEM0(), (sljit_sw)&bbuf[1], SLJIT_MEM0(), (sljit_sw)&bbuf[0]);
1975         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 2);
1976         sljit_emit_op1(compiler, SLJIT_MOV_U16, SLJIT_MEM2(SLJIT_S1, SLJIT_R0), 1, SLJIT_MEM0(), (sljit_sw)&sbuf[3]);
1977         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&buf[0]);
1978         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, sizeof(sljit_sw));
1979         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 2);
1980         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);
1981         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, sizeof(sljit_s8));
1982         sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_MEM1(SLJIT_R0), (sljit_sw)&bbuf[1], SLJIT_MEM1(SLJIT_R0), (sljit_sw)&bbuf[2]);
1983
1984         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, sizeof(sljit_s16));
1985         sljit_emit_op1(compiler, SLJIT_MOV_S16, SLJIT_MEM1(SLJIT_R1), (sljit_sw)&sbuf[3], SLJIT_R1, 0);
1986
1987         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 3);
1988         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);
1989         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 4);
1990         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_S0, 0);
1991         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);
1992
1993         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_S0, 0, SLJIT_IMM, 9 * sizeof(sljit_sw));
1994         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_S0, 0, SLJIT_IMM, 4 * sizeof(sljit_sw));
1995         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, -(4 << SLJIT_WORD_SHIFT));
1996         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM2(SLJIT_R0, SLJIT_R2), 0, SLJIT_MEM2(SLJIT_R1, SLJIT_R2), 0);
1997
1998         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&buf - 0x7fff8000 + 6 * (sljit_sw)sizeof(sljit_sw));
1999         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 952467);
2000         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 0x7fff8000, SLJIT_R1, 0);
2001         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 0x7fff8000 + sizeof(sljit_sw), SLJIT_MEM1(SLJIT_R0), 0x7fff8000);
2002
2003         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&buf + 0x7fff7fff + 6 * (sljit_sw)sizeof(sljit_sw));
2004         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);
2005         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&bbuf - 0x7fff7ffe + 3 * (sljit_sw)sizeof(sljit_s8));
2006         sljit_emit_op1(compiler, SLJIT_MOV_S8, SLJIT_MEM1(SLJIT_R0), 0x7fff7fff, SLJIT_MEM1(SLJIT_R0), 0x7fff7ffe);
2007         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&bbuf + 0x7fff7fff + 5 * (sljit_sw)sizeof(sljit_s8));
2008         sljit_emit_op1(compiler, SLJIT_MOV_S8, SLJIT_MEM1(SLJIT_R0), -0x7fff7fff, SLJIT_MEM1(SLJIT_R0), -0x7fff8000);
2009 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
2010         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&bbuf - SLJIT_W(0x123456123456));
2011         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, (sljit_sw)&bbuf - SLJIT_W(0x123456123456));
2012         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));
2013 #endif
2014
2015         sljit_emit_return_void(compiler);
2016
2017         code.code = sljit_generate_code(compiler);
2018         CHECK(compiler);
2019         sljit_free_compiler(compiler);
2020
2021         code.func3((sljit_sw)&buf, (sljit_sw)&sbuf, (sljit_sw)&bbuf);
2022         FAILED(buf[2] != 176366, "test24 case 1 failed\n");
2023         FAILED(buf[3] != 64, "test24 case 2 failed\n");
2024         FAILED(buf[4] != -100, "test24 case 3 failed\n");
2025         FAILED(buf[5] != 100567, "test24 case 4 failed\n");
2026         FAILED(buf[6] != 952467, "test24 case 5 failed\n");
2027         FAILED(buf[7] != 952467, "test24 case 6 failed\n");
2028         FAILED(buf[8] != 952467 * 2, "test24 case 7 failed\n");
2029
2030         FAILED(sbuf[1] != 30000, "test24 case 8 failed\n");
2031         FAILED(sbuf[2] != -12345, "test24 case 9 failed\n");
2032         FAILED(sbuf[4] != sizeof(sljit_s16), "test24 case 10 failed\n");
2033
2034         FAILED(bbuf[1] != -128, "test24 case 11 failed\n");
2035         FAILED(bbuf[2] != 99, "test24 case 12 failed\n");
2036         FAILED(bbuf[4] != 99, "test24 case 13 failed\n");
2037         FAILED(bbuf[5] != 99, "test24 case 14 failed\n");
2038 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
2039         FAILED(bbuf[6] != -128, "test24 case 15 failed\n");
2040 #endif
2041
2042         sljit_free_code(code.code, NULL);
2043         successful_tests++;
2044 }
2045
2046 static void test25(void)
2047 {
2048 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
2049         /* 64 bit loads. */
2050         executable_code code;
2051         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
2052         sljit_sw buf[14];
2053
2054         if (verbose)
2055                 printf("Run test25\n");
2056
2057         FAILED(!compiler, "cannot create compiler\n");
2058         buf[0] = 7;
2059         buf[1] = 0;
2060         buf[2] = 0;
2061         buf[3] = 0;
2062         buf[4] = 0;
2063         buf[5] = 0;
2064         buf[6] = 0;
2065         buf[7] = 0;
2066         buf[8] = 0;
2067         buf[9] = 0;
2068         buf[10] = 0;
2069         buf[11] = 0;
2070         buf[12] = 0;
2071         buf[13] = 0;
2072
2073         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, P), 3, 1, 0, 0, 0);
2074
2075         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_IMM, 0);
2076         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 1 * sizeof(sljit_sw), SLJIT_IMM, 0x7fff);
2077         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_IMM, -0x8000);
2078         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_IMM, 0x7fffffff);
2079         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_IMM, SLJIT_W(-0x80000000));
2080         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_IMM, SLJIT_W(0x1234567887654321));
2081         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_sw), SLJIT_IMM, SLJIT_W(0xff80000000));
2082         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_sw), SLJIT_IMM, SLJIT_W(0x3ff0000000));
2083         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_sw), SLJIT_IMM, (sljit_sw)SLJIT_W(0xfffffff800100000));
2084         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 9 * sizeof(sljit_sw), SLJIT_IMM, (sljit_sw)SLJIT_W(0xfffffff80010f000));
2085         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 10 * sizeof(sljit_sw), SLJIT_IMM, SLJIT_W(0x07fff00000008001));
2086         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 11 * sizeof(sljit_sw), SLJIT_IMM, SLJIT_W(0x07fff00080010000));
2087         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 12 * sizeof(sljit_sw), SLJIT_IMM, SLJIT_W(0x07fff00080018001));
2088         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 13 * sizeof(sljit_sw), SLJIT_IMM, SLJIT_W(0x07fff00ffff00000));
2089
2090         sljit_emit_return_void(compiler);
2091
2092         code.code = sljit_generate_code(compiler);
2093         CHECK(compiler);
2094         sljit_free_compiler(compiler);
2095
2096         code.func1((sljit_sw)&buf);
2097         FAILED(buf[0] != 0, "test25 case 1 failed\n");
2098         FAILED(buf[1] != 0x7fff, "test25 case 2 failed\n");
2099         FAILED(buf[2] != -0x8000, "test25 case 3 failed\n");
2100         FAILED(buf[3] != 0x7fffffff, "test25 case 4 failed\n");
2101         FAILED(buf[4] != SLJIT_W(-0x80000000), "test25 case 5 failed\n");
2102         FAILED(buf[5] != SLJIT_W(0x1234567887654321), "test25 case 6 failed\n");
2103         FAILED(buf[6] != SLJIT_W(0xff80000000), "test25 case 7 failed\n");
2104         FAILED(buf[7] != SLJIT_W(0x3ff0000000), "test25 case 8 failed\n");
2105         FAILED((sljit_uw)buf[8] != SLJIT_W(0xfffffff800100000), "test25 case 9 failed\n");
2106         FAILED((sljit_uw)buf[9] != SLJIT_W(0xfffffff80010f000), "test25 case 10 failed\n");
2107         FAILED(buf[10] != SLJIT_W(0x07fff00000008001), "test25 case 11 failed\n");
2108         FAILED(buf[11] != SLJIT_W(0x07fff00080010000), "test25 case 12 failed\n");
2109         FAILED(buf[12] != SLJIT_W(0x07fff00080018001), "test25 case 13 failed\n");
2110         FAILED(buf[13] != SLJIT_W(0x07fff00ffff00000), "test25 case 14 failed\n");
2111
2112         sljit_free_code(code.code, NULL);
2113 #endif
2114         successful_tests++;
2115 }
2116
2117 static void test26(void)
2118 {
2119         /* Aligned access without aligned offsets. */
2120         executable_code code;
2121         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
2122         sljit_sw buf[4];
2123         sljit_s32 ibuf[4];
2124         sljit_f64 dbuf[4];
2125
2126         if (verbose)
2127                 printf("Run test26\n");
2128
2129         FAILED(!compiler, "cannot create compiler\n");
2130
2131         buf[0] = -2789;
2132         buf[1] = 0;
2133         buf[2] = 4;
2134         buf[3] = -4;
2135
2136         ibuf[0] = -689;
2137         ibuf[1] = 0;
2138         ibuf[2] = -6;
2139         ibuf[3] = 3;
2140
2141         dbuf[0] = 5.75;
2142         dbuf[1] = 0.0;
2143         dbuf[2] = 0.0;
2144         dbuf[3] = -4.0;
2145
2146         sljit_emit_enter(compiler, 0, SLJIT_ARGS3(VOID, P, P, P), 3, 3, 0, 0, 0);
2147
2148         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_S0, 0, SLJIT_S0, 0, SLJIT_IMM, 3);
2149         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_S1, 0, SLJIT_S1, 0, SLJIT_IMM, 1);
2150         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), -3);
2151         sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_s32) - 1, SLJIT_R0, 0);
2152         sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S1), -1);
2153         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) - 3, SLJIT_R0, 0);
2154
2155         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_S0, 0, SLJIT_IMM, 100);
2156         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);
2157         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_S1, 0, SLJIT_IMM, 100);
2158         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);
2159
2160         if (sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
2161                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_S2, 0, SLJIT_S2, 0, SLJIT_IMM, 3);
2162                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S2), sizeof(sljit_f64) - 3, SLJIT_MEM1(SLJIT_S2), -3);
2163                 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);
2164                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_S2, 0, SLJIT_IMM, 2);
2165                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, (sizeof(sljit_f64) * 3 - 4) >> 1);
2166                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R2, 0, SLJIT_S2, 0, SLJIT_IMM, 1);
2167                 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);
2168         }
2169
2170         sljit_emit_return_void(compiler);
2171
2172         code.code = sljit_generate_code(compiler);
2173         CHECK(compiler);
2174         sljit_free_compiler(compiler);
2175
2176         code.func3((sljit_sw)&buf, (sljit_sw)&ibuf, (sljit_sw)&dbuf);
2177
2178         FAILED(buf[1] != -689, "test26 case 1 failed\n");
2179         FAILED(buf[2] != -16, "test26 case 2 failed\n");
2180         FAILED(ibuf[1] != -2789, "test26 case 3 failed\n");
2181         FAILED(ibuf[2] != -18, "test26 case 4 failed\n");
2182
2183         if (sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
2184                 FAILED(dbuf[1] != 5.75, "test26 case 5 failed\n");
2185                 FAILED(dbuf[2] != 11.5, "test26 case 6 failed\n");
2186                 FAILED(dbuf[3] != -2.875, "test26 case 7 failed\n");
2187         }
2188
2189         sljit_free_code(code.code, NULL);
2190         successful_tests++;
2191 }
2192
2193 static void test27(void)
2194 {
2195 #define SET_NEXT_BYTE(type) \
2196                 cond_set(compiler, SLJIT_R2, 0, type); \
2197                 sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_MEM1(SLJIT_S0), 1, SLJIT_R2, 0); \
2198                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_S0, 0, SLJIT_S0, 0, SLJIT_IMM, 1);
2199 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
2200 #define RESULT(i) i
2201 #else
2202 #define RESULT(i) (3 - i)
2203 #endif
2204
2205         /* Playing with conditional flags. */
2206         executable_code code;
2207         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
2208         sljit_u8 buf[41];
2209         sljit_u32 i;
2210 #ifdef SLJIT_PREF_SHIFT_REG
2211         sljit_s32 shift_reg = SLJIT_PREF_SHIFT_REG;
2212 #else
2213         sljit_s32 shift_reg = SLJIT_R2;
2214 #endif
2215
2216         SLJIT_ASSERT(shift_reg >= SLJIT_R2 && shift_reg <= SLJIT_R3);
2217
2218         if (verbose)
2219                 printf("Run test27\n");
2220
2221         for (i = 0; i < sizeof(buf); ++i)
2222                 buf[i] = 10;
2223
2224         FAILED(!compiler, "cannot create compiler\n");
2225
2226         /* 3 arguments passed, 3 arguments used. */
2227         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, P), 4, 3, 0, 0, 0);
2228
2229         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_S0, 0, SLJIT_S0, 0, SLJIT_IMM, 1);
2230
2231         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0x1001);
2232         sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 20);
2233         /* 0x100100000 on 64 bit machines, 0x100000 on 32 bit machines. */
2234         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0x800000);
2235         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_GREATER, SLJIT_R0, 0, SLJIT_R1, 0);
2236         sljit_emit_op0(compiler, SLJIT_ENDBR); /* ENDBR should keep the flags. */
2237         sljit_emit_op0(compiler, SLJIT_NOP); /* Nop should keep the flags. */
2238         SET_NEXT_BYTE(SLJIT_GREATER);
2239         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_LESS, SLJIT_R0, 0, SLJIT_R1, 0);
2240         SET_NEXT_BYTE(SLJIT_LESS);
2241         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_R0, 0);
2242         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_R1, 0);
2243         sljit_emit_op2u(compiler, SLJIT_SUB32 | SLJIT_SET_GREATER, SLJIT_R0, 0, SLJIT_R1, 0);
2244         sljit_emit_op0(compiler, SLJIT_ENDBR); /* ENDBR should keep the flags. */
2245         sljit_emit_op0(compiler, SLJIT_NOP); /* Nop should keep the flags. */
2246         SET_NEXT_BYTE(SLJIT_GREATER);
2247         sljit_emit_op2u(compiler, SLJIT_SUB32 | SLJIT_SET_LESS, SLJIT_R0, 0, SLJIT_R1, 0);
2248         SET_NEXT_BYTE(SLJIT_LESS);
2249
2250         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0x1000);
2251         sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 20);
2252         sljit_emit_op2(compiler, SLJIT_OR, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 0x10);
2253         /* 0x100000010 on 64 bit machines, 0x10 on 32 bit machines. */
2254         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_GREATER, SLJIT_R0, 0, SLJIT_IMM, 0x80);
2255         SET_NEXT_BYTE(SLJIT_GREATER);
2256         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_LESS, SLJIT_R0, 0, SLJIT_IMM, 0x80);
2257         SET_NEXT_BYTE(SLJIT_LESS);
2258         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_R0, 0);
2259         sljit_emit_op2u(compiler, SLJIT_SUB32 | SLJIT_SET_GREATER, SLJIT_R0, 0, SLJIT_IMM, 0x80);
2260         SET_NEXT_BYTE(SLJIT_GREATER);
2261         sljit_emit_op2u(compiler, SLJIT_SUB32 | SLJIT_SET_LESS, SLJIT_R0, 0, SLJIT_IMM, 0x80);
2262         SET_NEXT_BYTE(SLJIT_LESS);
2263
2264         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0);
2265         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 1);
2266         /* 0xff..ff on all machines. */
2267         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, 1);
2268         SET_NEXT_BYTE(SLJIT_LESS_EQUAL);
2269         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_GREATER_EQUAL, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, 1);
2270         SET_NEXT_BYTE(SLJIT_GREATER_EQUAL);
2271         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_SIG_GREATER, SLJIT_R2, 0, SLJIT_R1, 0, SLJIT_IMM, -1);
2272         SET_NEXT_BYTE(SLJIT_SIG_GREATER);
2273         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_SIG_LESS, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, -1);
2274         SET_NEXT_BYTE(SLJIT_SIG_LESS);
2275         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_Z, SLJIT_R2, 0, SLJIT_R1, 0, SLJIT_R0, 0);
2276         SET_NEXT_BYTE(SLJIT_EQUAL);
2277         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_Z, SLJIT_R0, 0, SLJIT_R1, 0, SLJIT_R0, 0);
2278         SET_NEXT_BYTE(SLJIT_NOT_EQUAL);
2279         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_OVERFLOW, SLJIT_R0, 0, SLJIT_R1, 0, SLJIT_IMM, -2);
2280         SET_NEXT_BYTE(SLJIT_OVERFLOW);
2281         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_OVERFLOW, SLJIT_R0, 0, SLJIT_R1, 0, SLJIT_IMM, -2);
2282         SET_NEXT_BYTE(SLJIT_NOT_OVERFLOW);
2283         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_GREATER_EQUAL, SLJIT_R0, 0, SLJIT_R1, 0, SLJIT_IMM, -2);
2284         SET_NEXT_BYTE(SLJIT_GREATER_EQUAL);
2285         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_R0, 0, SLJIT_R1, 0, SLJIT_IMM, -2);
2286         SET_NEXT_BYTE(SLJIT_LESS_EQUAL);
2287         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, (sljit_sw)((sljit_uw)1 << ((8 * sizeof(sljit_uw)) - 1)));
2288         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_SIG_LESS, SLJIT_R0, 0, SLJIT_R1, 0, SLJIT_IMM, 1);
2289         SET_NEXT_BYTE(SLJIT_SIG_LESS);
2290         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_SIG_GREATER, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, -1);
2291         SET_NEXT_BYTE(SLJIT_SIG_GREATER);
2292         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R0, 0, SLJIT_R1, 0, SLJIT_IMM, 1);
2293         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_SIG_GREATER_EQUAL, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, -2);
2294         SET_NEXT_BYTE(SLJIT_SIG_GREATER_EQUAL);
2295         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_SIG_GREATER, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 2);
2296         SET_NEXT_BYTE(SLJIT_SIG_GREATER);
2297
2298         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)0x80000000);
2299         sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 16);
2300         sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 16);
2301         /* 0x80..0 on 64 bit machines, 0 on 32 bit machines. */
2302         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, (sljit_sw)0xffffffff);
2303         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_OVERFLOW, SLJIT_R0, 0, SLJIT_R1, 0);
2304         SET_NEXT_BYTE(SLJIT_OVERFLOW);
2305         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_OVERFLOW, SLJIT_R0, 0, SLJIT_R1, 0);
2306         SET_NEXT_BYTE(SLJIT_NOT_OVERFLOW);
2307         sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_R0, 0, SLJIT_R0, 0);
2308         sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_R1, 0, SLJIT_R1, 0);
2309         sljit_emit_op2u(compiler, SLJIT_SUB32 | SLJIT_SET_OVERFLOW, SLJIT_R0, 0, SLJIT_R1, 0);
2310         SET_NEXT_BYTE(SLJIT_OVERFLOW);
2311         sljit_emit_op2u(compiler, SLJIT_SUB32 | SLJIT_SET_OVERFLOW, SLJIT_R0, 0, SLJIT_R1, 0);
2312         SET_NEXT_BYTE(SLJIT_NOT_OVERFLOW);
2313
2314         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0);
2315         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_CARRY, SLJIT_R0, 0, SLJIT_IMM, 1);
2316         sljit_emit_op2u(compiler, SLJIT_SUBC | SLJIT_SET_CARRY, SLJIT_R0, 0, SLJIT_IMM, 0);
2317         sljit_emit_op2(compiler, SLJIT_SUBC, SLJIT_R0, 0, SLJIT_IMM, 6, SLJIT_R0, 0);
2318         sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_MEM1(SLJIT_S0), 1, SLJIT_R0, 0);
2319         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_S0, 0, SLJIT_S0, 0, SLJIT_IMM, 1);
2320
2321         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -1);
2322         sljit_emit_op2u(compiler, SLJIT_ADD | SLJIT_SET_CARRY, SLJIT_R0, 0, SLJIT_IMM, 1);
2323         sljit_emit_op2u(compiler, SLJIT_ADDC | SLJIT_SET_CARRY, SLJIT_R0, 0, SLJIT_IMM, 1);
2324         sljit_emit_op2(compiler, SLJIT_ADDC, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 9);
2325         sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_MEM1(SLJIT_S0), 1, SLJIT_R0, 0);
2326         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_S0, 0, SLJIT_S0, 0, SLJIT_IMM, 1);
2327
2328         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 1);
2329         sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, (8 * sizeof(sljit_sw)) - 1);
2330         sljit_emit_op2u(compiler, SLJIT_ADD | SLJIT_SET_Z, SLJIT_R0, 0, SLJIT_IMM, 0);
2331         SET_NEXT_BYTE(SLJIT_EQUAL);
2332         sljit_emit_op2u(compiler, SLJIT_ADD | SLJIT_SET_Z, SLJIT_R0, 0, SLJIT_R0, 0);
2333         SET_NEXT_BYTE(SLJIT_EQUAL);
2334
2335         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0);
2336         sljit_emit_op2(compiler, SLJIT_ASHR | SLJIT_SET_Z, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 0);
2337         SET_NEXT_BYTE(SLJIT_EQUAL);
2338         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 1);
2339         sljit_emit_op2(compiler, SLJIT_LSHR | SLJIT_SET_Z, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 0xffffc0);
2340         SET_NEXT_BYTE(SLJIT_NOT_EQUAL);
2341         sljit_emit_op1(compiler, SLJIT_MOV, shift_reg, 0, SLJIT_IMM, 0);
2342         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0);
2343         sljit_emit_op2(compiler, SLJIT_ASHR | SLJIT_SET_Z, SLJIT_R0, 0, SLJIT_R0, 0, shift_reg, 0);
2344         SET_NEXT_BYTE(SLJIT_EQUAL);
2345         sljit_emit_op1(compiler, SLJIT_MOV, shift_reg, 0, SLJIT_IMM, 0);
2346         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 1);
2347         sljit_emit_op2(compiler, SLJIT_LSHR | SLJIT_SET_Z, SLJIT_R0, 0, SLJIT_R0, 0, shift_reg, 0);
2348         SET_NEXT_BYTE(SLJIT_NOT_EQUAL);
2349
2350         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0);
2351         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 1);
2352         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_CARRY, SLJIT_R0, 0, SLJIT_R0, 0);
2353         sljit_emit_op2(compiler, SLJIT_SUBC | SLJIT_SET_CARRY, SLJIT_R2, 0, SLJIT_IMM, 1, SLJIT_R0, 0);
2354         sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_MEM1(SLJIT_S0), 1, SLJIT_R2, 0);
2355         sljit_emit_op2u(compiler, SLJIT_SUBC | SLJIT_SET_CARRY, SLJIT_R0, 0, SLJIT_R1, 0);
2356         sljit_emit_op2(compiler, SLJIT_SUBC, SLJIT_R2, 0, SLJIT_IMM, 1, SLJIT_R0, 0);
2357         sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_MEM1(SLJIT_S0), 2, SLJIT_R2, 0);
2358         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_S0, 0, SLJIT_S0, 0, SLJIT_IMM, 2);
2359
2360         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -34);
2361         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_LESS, SLJIT_R0, 0, SLJIT_IMM, 0x1234);
2362         SET_NEXT_BYTE(SLJIT_LESS);
2363         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_SIG_LESS, SLJIT_R0, 0, SLJIT_IMM, 0x1234);
2364         SET_NEXT_BYTE(SLJIT_SIG_LESS);
2365 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
2366         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0x12300000000) - 43);
2367 #else
2368         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, -43);
2369 #endif
2370         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, -96);
2371         sljit_emit_op2u(compiler, SLJIT_SUB32 | SLJIT_SET_LESS, SLJIT_R0, 0, SLJIT_R1, 0);
2372         SET_NEXT_BYTE(SLJIT_LESS);
2373         sljit_emit_op2u(compiler, SLJIT_SUB32 | SLJIT_SET_SIG_GREATER, SLJIT_R0, 0, SLJIT_R1, 0);
2374         SET_NEXT_BYTE(SLJIT_SIG_GREATER);
2375
2376         sljit_emit_return_void(compiler);
2377
2378         code.code = sljit_generate_code(compiler);
2379         CHECK(compiler);
2380         sljit_free_compiler(compiler);
2381
2382         code.func1((sljit_sw)&buf);
2383
2384         FAILED(buf[0] != RESULT(1), "test27 case 1 failed\n");
2385         FAILED(buf[1] != RESULT(2), "test27 case 2 failed\n");
2386         FAILED(buf[2] != 2, "test27 case 3 failed\n");
2387         FAILED(buf[3] != 1, "test27 case 4 failed\n");
2388         FAILED(buf[4] != RESULT(1), "test27 case 5 failed\n");
2389         FAILED(buf[5] != RESULT(2), "test27 case 6 failed\n");
2390         FAILED(buf[6] != 2, "test27 case 7 failed\n");
2391         FAILED(buf[7] != 1, "test27 case 8 failed\n");
2392
2393         FAILED(buf[8] != 2, "test27 case 9 failed\n");
2394         FAILED(buf[9] != 1, "test27 case 10 failed\n");
2395         FAILED(buf[10] != 2, "test27 case 11 failed\n");
2396         FAILED(buf[11] != 1, "test27 case 12 failed\n");
2397         FAILED(buf[12] != 1, "test27 case 13 failed\n");
2398         FAILED(buf[13] != 2, "test27 case 14 failed\n");
2399         FAILED(buf[14] != 2, "test27 case 15 failed\n");
2400         FAILED(buf[15] != 1, "test27 case 16 failed\n");
2401         FAILED(buf[16] != 1, "test27 case 17 failed\n");
2402         FAILED(buf[17] != 2, "test27 case 18 failed\n");
2403         FAILED(buf[18] != 1, "test27 case 19 failed\n");
2404         FAILED(buf[19] != 1, "test27 case 20 failed\n");
2405         FAILED(buf[20] != 1, "test27 case 21 failed\n");
2406         FAILED(buf[21] != 2, "test27 case 22 failed\n");
2407
2408         FAILED(buf[22] != RESULT(1), "test27 case 23 failed\n");
2409         FAILED(buf[23] != RESULT(2), "test27 case 24 failed\n");
2410         FAILED(buf[24] != 2, "test27 case 25 failed\n");
2411         FAILED(buf[25] != 1, "test27 case 26 failed\n");
2412
2413         FAILED(buf[26] != 5, "test27 case 27 failed\n");
2414         FAILED(buf[27] != 9, "test27 case 28 failed\n");
2415
2416         FAILED(buf[28] != 2, "test27 case 29 failed\n");
2417         FAILED(buf[29] != 1, "test27 case 30 failed\n");
2418
2419         FAILED(buf[30] != 1, "test27 case 31 failed\n");
2420         FAILED(buf[31] != 1, "test27 case 32 failed\n");
2421         FAILED(buf[32] != 1, "test27 case 33 failed\n");
2422         FAILED(buf[33] != 1, "test27 case 34 failed\n");
2423
2424         FAILED(buf[34] != 1, "test27 case 35 failed\n");
2425         FAILED(buf[35] != 0, "test27 case 36 failed\n");
2426
2427         FAILED(buf[36] != 2, "test27 case 37 failed\n");
2428         FAILED(buf[37] != 1, "test27 case 38 failed\n");
2429         FAILED(buf[38] != 2, "test27 case 39 failed\n");
2430         FAILED(buf[39] != 1, "test27 case 40 failed\n");
2431         FAILED(buf[40] != 10, "test27 case 41 failed\n");
2432
2433         sljit_free_code(code.code, NULL);
2434         successful_tests++;
2435 #undef SET_NEXT_BYTE
2436 #undef RESULT
2437 }
2438
2439 static void test28(void)
2440 {
2441         /* Test mov. */
2442         executable_code code;
2443         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
2444         struct sljit_const* const1 = NULL;
2445         struct sljit_label* label = NULL;
2446         sljit_uw label_addr = 0;
2447         sljit_sw buf[5];
2448
2449         if (verbose)
2450                 printf("Run test28\n");
2451
2452         FAILED(!compiler, "cannot create compiler\n");
2453
2454         buf[0] = -36;
2455         buf[1] = 8;
2456         buf[2] = 0;
2457         buf[3] = 10;
2458         buf[4] = 0;
2459
2460         FAILED(!compiler, "cannot create compiler\n");
2461         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(W, P), 5, 5, 0, 0, 0);
2462         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, -234);
2463         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R4, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw));
2464         sljit_emit_op2(compiler, SLJIT_MUL, SLJIT_S3, 0, SLJIT_R3, 0, SLJIT_R4, 0);
2465         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_S3, 0);
2466         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_Z, SLJIT_S3, 0, SLJIT_IMM, 0);
2467         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_S3, 0, SLJIT_NOT_ZERO);
2468         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_S3, 0);
2469         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S4, 0, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw));
2470         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_S4, 0, SLJIT_S4, 0, SLJIT_R4, 0);
2471         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_S4, 0);
2472
2473         const1 = sljit_emit_const(compiler, SLJIT_S3, 0, 0);
2474         sljit_emit_ijump(compiler, SLJIT_JUMP, SLJIT_S3, 0);
2475         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_S3, 0, SLJIT_S3, 0, SLJIT_IMM, 100);
2476         label = sljit_emit_label(compiler);
2477         sljit_emit_op0(compiler, SLJIT_ENDBR);
2478         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_S3, 0);
2479
2480         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_R4, 0);
2481
2482         code.code = sljit_generate_code(compiler);
2483         CHECK(compiler);
2484
2485         label_addr = sljit_get_label_addr(label);
2486         sljit_set_const(sljit_get_const_addr(const1), (sljit_sw)label_addr, sljit_get_executable_offset(compiler));
2487
2488         sljit_free_compiler(compiler);
2489
2490         FAILED(code.func1((sljit_sw)&buf) != 8, "test28 case 1 failed\n");
2491         FAILED(buf[1] != -1872, "test28 case 2 failed\n");
2492         FAILED(buf[2] != 1, "test28 case 3 failed\n");
2493         FAILED(buf[3] != 2, "test28 case 4 failed\n");
2494         FAILED(buf[4] != (sljit_sw)label_addr, "test28 case 5 failed\n");
2495
2496         sljit_free_code(code.code, NULL);
2497         successful_tests++;
2498 }
2499
2500 static void test29(void)
2501 {
2502         /* Test signed/unsigned bytes and halfs. */
2503         executable_code code;
2504         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
2505         sljit_sw buf[25];
2506         sljit_s32 i;
2507
2508         if (verbose)
2509                 printf("Run test29\n");
2510
2511         for (i = 0; i < 25; i++)
2512                 buf[i] = 0;
2513
2514         FAILED(!compiler, "cannot create compiler\n");
2515         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, P), 5, 5, 0, 0, 0);
2516
2517         sljit_emit_op1(compiler, SLJIT_MOV_S8, SLJIT_R0, 0, SLJIT_IMM, -187);
2518         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0);
2519         sljit_emit_op1(compiler, SLJIT_MOV_S8, SLJIT_R0, 0, SLJIT_IMM, -605);
2520         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_uw), SLJIT_R0, 0);
2521         sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_R0, 0, SLJIT_IMM, -56);
2522         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_uw), SLJIT_R0, 0);
2523         sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_R4, 0, SLJIT_IMM, 0xcde5);
2524         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_uw), SLJIT_R4, 0);
2525
2526         sljit_emit_op1(compiler, SLJIT_MOV_S16, SLJIT_R0, 0, SLJIT_IMM, -45896);
2527         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_uw), SLJIT_R0, 0);
2528         sljit_emit_op1(compiler, SLJIT_MOV_S16, SLJIT_R0, 0, SLJIT_IMM, -1472797);
2529         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_uw), SLJIT_R0, 0);
2530         sljit_emit_op1(compiler, SLJIT_MOV_U16, SLJIT_R0, 0, SLJIT_IMM, -12890);
2531         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_uw), SLJIT_R0, 0);
2532         sljit_emit_op1(compiler, SLJIT_MOV_U16, SLJIT_R4, 0, SLJIT_IMM, 0x9cb0a6);
2533         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_uw), SLJIT_R4, 0);
2534
2535 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
2536         sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(-3580429715));
2537         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_uw), SLJIT_R0, 0);
2538         sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(-100722768662));
2539         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 9 * sizeof(sljit_uw), SLJIT_R0, 0);
2540         sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(-1457052677972));
2541         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 10 * sizeof(sljit_uw), SLJIT_R0, 0);
2542         sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_R4, 0, SLJIT_IMM, SLJIT_W(0xcef97a70b5));
2543         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 11 * sizeof(sljit_uw), SLJIT_R4, 0);
2544 #endif
2545
2546         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, -187);
2547         sljit_emit_op1(compiler, SLJIT_MOV_S8, SLJIT_R0, 0, SLJIT_R1, 0);
2548         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 12 * sizeof(sljit_uw), SLJIT_R0, 0);
2549         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, -605);
2550         sljit_emit_op1(compiler, SLJIT_MOV_S8, SLJIT_R0, 0, SLJIT_S2, 0);
2551         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 13 * sizeof(sljit_uw), SLJIT_R0, 0);
2552         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, -56);
2553         sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_R0, 0, SLJIT_R2, 0);
2554         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 14 * sizeof(sljit_uw), SLJIT_R0, 0);
2555         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, 0xcde5);
2556         sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_R4, 0, SLJIT_R3, 0);
2557         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 15 * sizeof(sljit_uw), SLJIT_R4, 0);
2558
2559         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, -45896);
2560         sljit_emit_op1(compiler, SLJIT_MOV_S16, SLJIT_R0, 0, SLJIT_R1, 0);
2561         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 16 * sizeof(sljit_uw), SLJIT_R0, 0);
2562         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, -1472797);
2563         sljit_emit_op1(compiler, SLJIT_MOV_S16, SLJIT_R0, 0, SLJIT_S2, 0);
2564         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 17 * sizeof(sljit_uw), SLJIT_R0, 0);
2565         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, -12890);
2566         sljit_emit_op1(compiler, SLJIT_MOV_U16, SLJIT_R0, 0, SLJIT_R2, 0);
2567         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 18 * sizeof(sljit_uw), SLJIT_R0, 0);
2568         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, 0x9cb0a6);
2569         sljit_emit_op1(compiler, SLJIT_MOV_U16, SLJIT_R4, 0, SLJIT_R3, 0);
2570         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 19 * sizeof(sljit_uw), SLJIT_R4, 0);
2571
2572 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
2573         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(-3580429715));
2574         sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_R0, 0, SLJIT_R1, 0);
2575         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 20 * sizeof(sljit_uw), SLJIT_R0, 0);
2576         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, SLJIT_W(-100722768662));
2577         sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_R0, 0, SLJIT_S2, 0);
2578         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 21 * sizeof(sljit_uw), SLJIT_R0, 0);
2579         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, SLJIT_W(-1457052677972));
2580         sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_R0, 0, SLJIT_R2, 0);
2581         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 22 * sizeof(sljit_uw), SLJIT_R0, 0);
2582         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, SLJIT_W(0xcef97a70b5));
2583         sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_R4, 0, SLJIT_R3, 0);
2584         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 23 * sizeof(sljit_uw), SLJIT_R4, 0);
2585 #endif
2586
2587         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, 0x9faa5);
2588         sljit_emit_op1(compiler, SLJIT_MOV_S8, SLJIT_S2, 0, SLJIT_S2, 0);
2589         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 24 * sizeof(sljit_uw), SLJIT_S2, 0);
2590
2591         sljit_emit_return_void(compiler);
2592
2593         code.code = sljit_generate_code(compiler);
2594         CHECK(compiler);
2595         sljit_free_compiler(compiler);
2596
2597         code.func1((sljit_sw)&buf);
2598         FAILED(buf[0] != 69, "test29 case 1 failed\n");
2599         FAILED(buf[1] != -93, "test29 case 2 failed\n");
2600         FAILED(buf[2] != 200, "test29 case 3 failed\n");
2601         FAILED(buf[3] != 0xe5, "test29 case 4 failed\n");
2602         FAILED(buf[4] != 19640, "test29 case 5 failed\n");
2603         FAILED(buf[5] != -31005, "test29 case 6 failed\n");
2604         FAILED(buf[6] != 52646, "test29 case 7 failed\n");
2605         FAILED(buf[7] != 0xb0a6, "test29 case 8 failed\n");
2606
2607 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
2608         FAILED(buf[8] != SLJIT_W(714537581), "test29 case 9 failed\n");
2609         FAILED(buf[9] != SLJIT_W(-1938520854), "test29 case 10 failed\n");
2610         FAILED(buf[10] != SLJIT_W(3236202668), "test29 case 11 failed\n");
2611         FAILED(buf[11] != SLJIT_W(0xf97a70b5), "test29 case 12 failed\n");
2612 #endif
2613
2614         FAILED(buf[12] != 69, "test29 case 13 failed\n");
2615         FAILED(buf[13] != -93, "test29 case 14 failed\n");
2616         FAILED(buf[14] != 200, "test29 case 15 failed\n");
2617         FAILED(buf[15] != 0xe5, "test29 case 16 failed\n");
2618         FAILED(buf[16] != 19640, "test29 case 17 failed\n");
2619         FAILED(buf[17] != -31005, "test29 case 18 failed\n");
2620         FAILED(buf[18] != 52646, "test29 case 19 failed\n");
2621         FAILED(buf[19] != 0xb0a6, "test29 case 20 failed\n");
2622
2623 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
2624         FAILED(buf[20] != SLJIT_W(714537581), "test29 case 21 failed\n");
2625         FAILED(buf[21] != SLJIT_W(-1938520854), "test29 case 22 failed\n");
2626         FAILED(buf[22] != SLJIT_W(3236202668), "test29 case 23 failed\n");
2627         FAILED(buf[23] != SLJIT_W(0xf97a70b5), "test29 case 24 failed\n");
2628 #endif
2629
2630         FAILED(buf[24] != -91, "test29 case 25 failed\n");
2631
2632         sljit_free_code(code.code, NULL);
2633         successful_tests++;
2634 }
2635
2636 static void test30(void)
2637 {
2638         /* Test unused results. */
2639         executable_code code;
2640         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
2641         sljit_sw buf[1];
2642
2643         if (verbose)
2644                 printf("Run test30\n");
2645
2646         FAILED(!compiler, "cannot create compiler\n");
2647         buf[0] = 0;
2648         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, P), 5, 5, 0, 0, 0);
2649
2650         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 1);
2651         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 1);
2652         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 1);
2653         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, 1);
2654         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R4, 0, SLJIT_IMM, 1);
2655 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
2656         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_S1, 0, SLJIT_IMM, SLJIT_W(-0x123ffffffff));
2657 #else
2658         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_S1, 0, SLJIT_IMM, 1);
2659 #endif
2660         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, 1);
2661         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S3, 0, SLJIT_IMM, 1);
2662         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S4, 0, SLJIT_IMM, 1);
2663
2664         /* Some calculations with unused results. */
2665         sljit_emit_op2u(compiler, SLJIT_ADD | SLJIT_SET_Z, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_MEM1(SLJIT_S0), 0);
2666         sljit_emit_op2u(compiler, SLJIT_SUB32 | SLJIT_SET_GREATER_EQUAL, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_MEM1(SLJIT_S0), 0);
2667         sljit_emit_op2u(compiler, SLJIT_MUL | SLJIT_SET_OVERFLOW, SLJIT_S0, 0, SLJIT_MEM1(SLJIT_S0), 0);
2668         sljit_emit_op2u(compiler, SLJIT_SHL | SLJIT_SET_Z, SLJIT_S3, 0, SLJIT_R2, 0);
2669         sljit_emit_op2u(compiler, SLJIT_LSHR | SLJIT_SET_Z, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_IMM, 5);
2670         sljit_emit_op2u(compiler, SLJIT_AND | SLJIT_SET_Z, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_IMM, 0xff);
2671
2672         /* Testing that any change happens. */
2673         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_R1, 0);
2674         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_R2, 0);
2675         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_R3, 0);
2676         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_R4, 0);
2677         sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_S1, 0, SLJIT_S1, 0);
2678         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_S1, 0);
2679         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_S2, 0);
2680         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_S3, 0);
2681         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0, SLJIT_S4, 0);
2682
2683         sljit_emit_return_void(compiler);
2684
2685         code.code = sljit_generate_code(compiler);
2686         CHECK(compiler);
2687         sljit_free_compiler(compiler);
2688
2689         code.func1((sljit_sw)&buf);
2690         FAILED(buf[0] != 9, "test30 case 1 failed\n");
2691
2692         sljit_free_code(code.code, NULL);
2693         successful_tests++;
2694 }
2695
2696 static void test31(void)
2697 {
2698         /* Integer mul and set flags. */
2699         executable_code code;
2700         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
2701         sljit_sw buf[12];
2702         sljit_s32 i;
2703 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
2704         sljit_sw big_word = SLJIT_W(0x7fffffff00000000);
2705         sljit_sw big_word2 = SLJIT_W(0x7fffffff00000012);
2706 #else
2707         sljit_sw big_word = 0x7fffffff;
2708         sljit_sw big_word2 = 0x00000012;
2709 #endif
2710
2711         if (verbose)
2712                 printf("Run test31\n");
2713
2714         for (i = 0; i < 12; i++)
2715                 buf[i] = 3;
2716
2717         FAILED(!compiler, "cannot create compiler\n");
2718
2719         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, P), 3, 5, 0, 0, 0);
2720         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0);
2721         sljit_emit_op2u(compiler, SLJIT_MUL | SLJIT_SET_OVERFLOW, SLJIT_R1, 0, SLJIT_IMM, -45);
2722         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_NOT_OVERFLOW);
2723         sljit_emit_op2u(compiler, SLJIT_MUL | SLJIT_SET_OVERFLOW, SLJIT_R1, 0, SLJIT_IMM, -45);
2724         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_OVERFLOW);
2725
2726         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, big_word);
2727         sljit_emit_op2(compiler, SLJIT_MUL | SLJIT_SET_OVERFLOW, SLJIT_R2, 0, SLJIT_S2, 0, SLJIT_IMM, -2);
2728         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 33); /* Should not change flags. */
2729         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0); /* Should not change flags. */
2730         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_OVERFLOW);
2731         sljit_emit_op2(compiler, SLJIT_MUL | SLJIT_SET_OVERFLOW, SLJIT_R2, 0, SLJIT_S2, 0, SLJIT_IMM, -2);
2732         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_NOT_OVERFLOW);
2733
2734         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_S3, 0, SLJIT_IMM, 0x3f6b0);
2735         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_S4, 0, SLJIT_IMM, 0x2a783);
2736         sljit_emit_op2(compiler, SLJIT_MUL32 | SLJIT_SET_OVERFLOW, SLJIT_R1, 0, SLJIT_S3, 0, SLJIT_S4, 0);
2737         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_OVERFLOW);
2738         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_R1, 0);
2739
2740         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, big_word2);
2741         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R2, 0, SLJIT_R1, 0);
2742         sljit_emit_op2(compiler, SLJIT_MUL32 | SLJIT_SET_OVERFLOW, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, 23);
2743         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_sw), SLJIT_OVERFLOW);
2744
2745         sljit_emit_op2u(compiler, SLJIT_MUL32 | SLJIT_SET_OVERFLOW, SLJIT_R2, 0, SLJIT_IMM, -23);
2746         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_sw), SLJIT_NOT_OVERFLOW);
2747         sljit_emit_op2u(compiler, SLJIT_MUL | SLJIT_SET_OVERFLOW, SLJIT_R2, 0, SLJIT_IMM, -23);
2748         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_sw), SLJIT_NOT_OVERFLOW);
2749
2750         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 67);
2751         sljit_emit_op2(compiler, SLJIT_MUL | SLJIT_SET_OVERFLOW, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, -23);
2752         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 9 * sizeof(sljit_sw), SLJIT_R1, 0);
2753
2754         sljit_emit_return_void(compiler);
2755
2756         code.code = sljit_generate_code(compiler);
2757         CHECK(compiler);
2758         sljit_free_compiler(compiler);
2759
2760         code.func1((sljit_sw)&buf);
2761
2762         FAILED(buf[0] != 1, "test31 case 1 failed\n");
2763         FAILED(buf[1] != 2, "test31 case 2 failed\n");
2764 /* Qemu issues for 64 bit muls. */
2765 #if !(defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
2766         FAILED(buf[2] != 1, "test31 case 3 failed\n");
2767         FAILED(buf[3] != 2, "test31 case 4 failed\n");
2768 #endif
2769         FAILED(buf[4] != 1, "test31 case 5 failed\n");
2770         FAILED((buf[5] & (sljit_sw)0xffffffff) != (sljit_sw)0x85540c10, "test31 case 6 failed\n");
2771         FAILED(buf[6] != 2, "test31 case 7 failed\n");
2772         FAILED(buf[7] != 1, "test31 case 8 failed\n");
2773 #if !(defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
2774         FAILED(buf[8] != 1, "test31 case 9 failed\n");
2775 #endif
2776         FAILED(buf[9] != -1541, "test31 case 10 failed\n");
2777
2778         sljit_free_code(code.code, NULL);
2779         successful_tests++;
2780 }
2781
2782 static void test32(void)
2783 {
2784         /* Floating point set flags. */
2785         executable_code code;
2786         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
2787         sljit_s32 i;
2788
2789         sljit_sw buf[16];
2790         union {
2791                 sljit_f64 value;
2792                 struct {
2793                         sljit_s32 value1;
2794                         sljit_s32 value2;
2795                 } u;
2796         } dbuf[4];
2797
2798         if (verbose)
2799                 printf("Run test32\n");
2800
2801         for (i = 0; i < 16; i++)
2802                 buf[i] = 5;
2803
2804         /* Two NaNs */
2805         dbuf[0].u.value1 = 0x7fffffff;
2806         dbuf[0].u.value2 = 0x7fffffff;
2807         dbuf[1].u.value1 = 0x7fffffff;
2808         dbuf[1].u.value2 = 0x7fffffff;
2809         dbuf[2].value = -13.0;
2810         dbuf[3].value = 27.0;
2811
2812         if (!sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
2813                 if (verbose)
2814                         printf("no fpu available, test32 skipped\n");
2815                 successful_tests++;
2816                 if (compiler)
2817                         sljit_free_compiler(compiler);
2818                 return;
2819         }
2820
2821         FAILED(!compiler, "cannot create compiler\n");
2822         SLJIT_ASSERT(sizeof(sljit_f64) == 8 && sizeof(sljit_s32) == 4 && sizeof(dbuf[0]) == 8);
2823
2824         sljit_emit_enter(compiler, 0, SLJIT_ARGS2(VOID, P, P), 1, 2, 4, 0, 0);
2825
2826         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S1), 0);
2827         sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_UNORDERED, SLJIT_MEM1(SLJIT_S1), 3 * sizeof(sljit_f64), SLJIT_FR0, 0);
2828         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S1), 2 * sizeof(sljit_f64));
2829         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_UNORDERED);
2830         sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_ORDERED, SLJIT_MEM1(SLJIT_S1), 3 * sizeof(sljit_f64), SLJIT_FR0, 0);
2831         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_ORDERED);
2832
2833         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S1), 3 * sizeof(sljit_f64));
2834         sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_UNORDERED, SLJIT_FR1, 0, SLJIT_FR2, 0);
2835         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_UNORDERED);
2836         sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_ORDERED, SLJIT_FR1, 0, SLJIT_FR2, 0);
2837         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_ORDERED);
2838         sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_F_LESS, SLJIT_FR1, 0, SLJIT_FR2, 0);
2839         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_F_LESS);
2840         sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_F_GREATER_EQUAL, SLJIT_FR1, 0, SLJIT_FR2, 0);
2841         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_F_GREATER_EQUAL);
2842         sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_F_GREATER, SLJIT_FR1, 0, SLJIT_FR2, 0);
2843         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_sw), SLJIT_F_GREATER);
2844         sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_F_LESS_EQUAL, SLJIT_FR1, 0, SLJIT_FR2, 0);
2845         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_sw), SLJIT_F_LESS_EQUAL);
2846         sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_F_EQUAL, SLJIT_FR1, 0, SLJIT_FR2, 0);
2847         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_sw), SLJIT_F_EQUAL);
2848         sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_F_NOT_EQUAL, SLJIT_FR1, 0, SLJIT_FR2, 0);
2849         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 9 * sizeof(sljit_sw), SLJIT_F_NOT_EQUAL);
2850
2851         sljit_emit_fop2(compiler, SLJIT_ADD_F64, SLJIT_FR3, 0, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_f64));
2852         sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_UNORDERED, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S1), 3 * sizeof(sljit_f64));
2853         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 10 * sizeof(sljit_sw), SLJIT_UNORDERED);
2854         sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_F_EQUAL, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S1), 3 * sizeof(sljit_f64));
2855         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 11 * sizeof(sljit_sw), SLJIT_F_EQUAL);
2856
2857         sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_ORDERED, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_f64), SLJIT_FR0, 0);
2858         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 12 * sizeof(sljit_sw), SLJIT_ORDERED);
2859
2860         sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_UNORDERED, SLJIT_FR3, 0, SLJIT_FR2, 0);
2861         sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S1), 0);
2862         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 13 * sizeof(sljit_sw), SLJIT_UNORDERED);
2863
2864         sljit_emit_return_void(compiler);
2865
2866         code.code = sljit_generate_code(compiler);
2867         CHECK(compiler);
2868         sljit_free_compiler(compiler);
2869
2870         code.func2((sljit_sw)&buf, (sljit_sw)&dbuf);
2871
2872         FAILED(buf[0] != 1, "test32 case 1 failed\n");
2873         FAILED(buf[1] != 2, "test32 case 2 failed\n");
2874         FAILED(buf[2] != 2, "test32 case 3 failed\n");
2875         FAILED(buf[3] != 1, "test32 case 4 failed\n");
2876         FAILED(buf[4] != 1, "test32 case 5 failed\n");
2877         FAILED(buf[5] != 2, "test32 case 6 failed\n");
2878         FAILED(buf[6] != 2, "test32 case 7 failed\n");
2879         FAILED(buf[7] != 1, "test32 case 8 failed\n");
2880         FAILED(buf[8] != 2, "test32 case 9 failed\n");
2881         FAILED(buf[9] != 1, "test32 case 10 failed\n");
2882         FAILED(buf[10] != 2, "test32 case 11 failed\n");
2883         FAILED(buf[11] != 1, "test32 case 12 failed\n");
2884         FAILED(buf[12] != 2, "test32 case 13 failed\n");
2885         FAILED(buf[13] != 1, "test32 case 14 failed\n");
2886
2887         sljit_free_code(code.code, NULL);
2888         successful_tests++;
2889 }
2890
2891 static void test33(void)
2892 {
2893         /* Test setting multiple flags. */
2894         executable_code code;
2895         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
2896         struct sljit_jump* jump;
2897         sljit_sw buf[10];
2898
2899         if (verbose)
2900                 printf("Run test33\n");
2901
2902         buf[0] = 3;
2903         buf[1] = 3;
2904         buf[2] = 3;
2905         buf[3] = 3;
2906         buf[4] = 3;
2907         buf[5] = 3;
2908         buf[6] = 3;
2909         buf[7] = 3;
2910         buf[8] = 3;
2911         buf[9] = 3;
2912
2913         FAILED(!compiler, "cannot create compiler\n");
2914
2915         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, P), 3, 3, 0, 0, 0);
2916
2917         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 20);
2918         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 10);
2919         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_Z | SLJIT_SET_LESS, SLJIT_R2, 0, SLJIT_R0, 0, SLJIT_R1, 0);
2920         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_ZERO);
2921         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, -10);
2922         jump = sljit_emit_jump(compiler, SLJIT_LESS);
2923         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_IMM, 11);
2924         sljit_set_label(jump, sljit_emit_label(compiler));
2925
2926         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_Z | SLJIT_SET_SIG_GREATER, SLJIT_R2, 0, SLJIT_R0, 0, SLJIT_R1, 0);
2927         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_SIG_GREATER);
2928         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_IMM, 45);
2929         jump = sljit_emit_jump(compiler, SLJIT_NOT_EQUAL);
2930         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_IMM, 55);
2931         sljit_set_label(jump, sljit_emit_label(compiler));
2932
2933 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
2934         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)SLJIT_W(0x8000000000000000));
2935 #else
2936         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)SLJIT_W(0x80000000));
2937 #endif
2938         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 1);
2939         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_Z | SLJIT_SET_OVERFLOW, SLJIT_R2, 0, SLJIT_R0, 0, SLJIT_R1, 0);
2940         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_IMM, 33);
2941         jump = sljit_emit_jump(compiler, SLJIT_NOT_OVERFLOW);
2942         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_ZERO);
2943         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_IMM, 13);
2944         sljit_set_label(jump, sljit_emit_label(compiler));
2945
2946         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)0x80000000);
2947         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_R0, 0);
2948         sljit_emit_op2(compiler, SLJIT_SUB32 | SLJIT_SET_Z | SLJIT_SET_OVERFLOW, SLJIT_R2, 0, SLJIT_R0, 0, SLJIT_R1, 0);
2949         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, 0);
2950         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_sw), SLJIT_NOT_ZERO);
2951         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_sw), SLJIT_IMM, 78);
2952         jump = sljit_emit_jump(compiler, SLJIT_OVERFLOW);
2953         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_sw), SLJIT_IMM, 48);
2954         sljit_set_label(jump, sljit_emit_label(compiler));
2955
2956 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
2957         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)SLJIT_W(0x8000000000000000));
2958 #else
2959         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)SLJIT_W(0x80000000));
2960 #endif
2961         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_R0, 0);
2962         sljit_emit_op2(compiler, SLJIT_ADD | SLJIT_SET_Z | SLJIT_SET_OVERFLOW, SLJIT_R2, 0, SLJIT_R0, 0, SLJIT_R1, 0);
2963         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_sw), SLJIT_IMM, 30);
2964         jump = sljit_emit_jump(compiler, SLJIT_NOT_OVERFLOW);
2965         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_sw), SLJIT_IMM, 50);
2966         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 9 * sizeof(sljit_sw), SLJIT_ZERO);
2967         sljit_set_label(jump, sljit_emit_label(compiler));
2968
2969         sljit_emit_return_void(compiler);
2970
2971         code.code = sljit_generate_code(compiler);
2972         CHECK(compiler);
2973         sljit_free_compiler(compiler);
2974
2975         code.func1((sljit_sw)&buf);
2976
2977         FAILED(buf[0] != 0, "test33 case 1 failed\n");
2978         FAILED(buf[1] != 11, "test33 case 2 failed\n");
2979         FAILED(buf[2] != 1, "test33 case 3 failed\n");
2980         FAILED(buf[3] != 45, "test33 case 4 failed\n");
2981         FAILED(buf[4] != 13, "test33 case 5 failed\n");
2982         FAILED(buf[5] != 0, "test33 case 6 failed\n");
2983         FAILED(buf[6] != 0, "test33 case 7 failed\n");
2984         FAILED(buf[7] != 48, "test33 case 8 failed\n");
2985         FAILED(buf[8] != 50, "test33 case 9 failed\n");
2986         FAILED(buf[9] != 1, "test33 case 10 failed\n");
2987
2988         sljit_free_code(code.code, NULL);
2989         successful_tests++;
2990 }
2991
2992 static void test34(void)
2993 {
2994         /* Test fast calls. */
2995         executable_code codeA;
2996         executable_code codeB;
2997         executable_code codeC;
2998         executable_code codeD;
2999         executable_code codeE;
3000         executable_code codeF;
3001         struct sljit_compiler* compiler;
3002         struct sljit_jump *jump;
3003         struct sljit_label* label;
3004         sljit_uw addr;
3005         sljit_p buf[2];
3006
3007         if (verbose)
3008                 printf("Run test34\n");
3009
3010         buf[0] = 0;
3011         buf[1] = 0;
3012
3013         /* A */
3014         compiler = sljit_create_compiler(NULL, NULL);
3015         FAILED(!compiler, "cannot create compiler\n");
3016         sljit_set_context(compiler, 0, 1, 5, 5, 0, 0, 2 * sizeof(sljit_p));
3017
3018         sljit_emit_op0(compiler, SLJIT_ENDBR);
3019         sljit_emit_fast_enter(compiler, SLJIT_R1, 0);
3020         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 4);
3021         sljit_emit_op_src(compiler, SLJIT_FAST_RETURN, SLJIT_R1, 0);
3022
3023         codeA.code = sljit_generate_code(compiler);
3024         CHECK(compiler);
3025         sljit_free_compiler(compiler);
3026
3027         /* B */
3028         compiler = sljit_create_compiler(NULL, NULL);
3029         FAILED(!compiler, "cannot create compiler\n");
3030         sljit_set_context(compiler, 0, 1, 5, 5, 0, 0, 2 * sizeof(sljit_p));
3031
3032         sljit_emit_op0(compiler, SLJIT_ENDBR);
3033         sljit_emit_fast_enter(compiler, SLJIT_R4, 0);
3034         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 6);
3035         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, SLJIT_FUNC_ADDR(codeA.code));
3036         sljit_emit_ijump(compiler, SLJIT_FAST_CALL, SLJIT_R1, 0);
3037         sljit_emit_op_src(compiler, SLJIT_FAST_RETURN, SLJIT_R4, 0);
3038
3039         codeB.code = sljit_generate_code(compiler);
3040         CHECK(compiler);
3041         sljit_free_compiler(compiler);
3042
3043         /* C */
3044         compiler = sljit_create_compiler(NULL, NULL);
3045         FAILED(!compiler, "cannot create compiler\n");
3046         sljit_set_context(compiler, 0, 1, 5, 5, 0, 0, 2 * sizeof(sljit_p));
3047
3048         sljit_emit_op0(compiler, SLJIT_ENDBR);
3049         sljit_emit_fast_enter(compiler, SLJIT_MEM1(SLJIT_SP), sizeof(sljit_p));
3050         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 8);
3051         jump = sljit_emit_jump(compiler, SLJIT_FAST_CALL | SLJIT_REWRITABLE_JUMP);
3052         sljit_set_target(jump, SLJIT_FUNC_UADDR(codeB.code));
3053         sljit_emit_op_src(compiler, SLJIT_FAST_RETURN, SLJIT_MEM1(SLJIT_SP), sizeof(sljit_p));
3054
3055         codeC.code = sljit_generate_code(compiler);
3056         CHECK(compiler);
3057         sljit_free_compiler(compiler);
3058
3059         /* D */
3060         compiler = sljit_create_compiler(NULL, NULL);
3061         FAILED(!compiler, "cannot create compiler\n");
3062         sljit_set_context(compiler, 0, 1, 5, 5, 0, 0, 2 * sizeof(sljit_p));
3063
3064         sljit_emit_op0(compiler, SLJIT_ENDBR);
3065         sljit_emit_fast_enter(compiler, SLJIT_MEM1(SLJIT_SP), 0);
3066         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 10);
3067         sljit_emit_ijump(compiler, SLJIT_FAST_CALL, SLJIT_IMM, SLJIT_FUNC_ADDR(codeC.code));
3068         sljit_emit_op_src(compiler, SLJIT_FAST_RETURN, SLJIT_MEM1(SLJIT_SP), 0);
3069
3070         codeD.code = sljit_generate_code(compiler);
3071         CHECK(compiler);
3072         sljit_free_compiler(compiler);
3073
3074         /* E */
3075         compiler = sljit_create_compiler(NULL, NULL);
3076         FAILED(!compiler, "cannot create compiler\n");
3077         sljit_set_context(compiler, 0, 1, 5, 5, 0, 0, 2 * sizeof(sljit_p));
3078
3079         sljit_emit_fast_enter(compiler, SLJIT_MEM1(SLJIT_S0), 0);
3080         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 12);
3081         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_p), SLJIT_IMM, SLJIT_FUNC_ADDR(codeD.code));
3082         sljit_emit_ijump(compiler, SLJIT_FAST_CALL, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_p));
3083         sljit_emit_op_src(compiler, SLJIT_FAST_RETURN, SLJIT_MEM1(SLJIT_S0), 0);
3084
3085         codeE.code = sljit_generate_code(compiler);
3086         CHECK(compiler);
3087         sljit_free_compiler(compiler);
3088
3089         /* F */
3090         compiler = sljit_create_compiler(NULL, NULL);
3091         FAILED(!compiler, "cannot create compiler\n");
3092
3093         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(W, P), 5, 5, 0, 0, 2 * sizeof(sljit_p));
3094         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0);
3095         sljit_emit_ijump(compiler, SLJIT_FAST_CALL, SLJIT_IMM, SLJIT_FUNC_ADDR(codeE.code));
3096         label = sljit_emit_label(compiler);
3097         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_R0, 0);
3098
3099         codeF.code = sljit_generate_code(compiler);
3100         CHECK(compiler);
3101         addr = sljit_get_label_addr(label);
3102         sljit_free_compiler(compiler);
3103
3104         FAILED(codeF.func1((sljit_sw)&buf) != 40, "test34 case 1 failed\n");
3105         FAILED(buf[0] != addr - SLJIT_RETURN_ADDRESS_OFFSET, "test34 case 2 failed\n");
3106
3107         sljit_free_code(codeA.code, NULL);
3108         sljit_free_code(codeB.code, NULL);
3109         sljit_free_code(codeC.code, NULL);
3110         sljit_free_code(codeD.code, NULL);
3111         sljit_free_code(codeE.code, NULL);
3112         sljit_free_code(codeF.code, NULL);
3113         successful_tests++;
3114 }
3115
3116 static void test35(void)
3117 {
3118         /* More complicated tests for fast calls. */
3119         executable_code codeA;
3120         executable_code codeB;
3121         executable_code codeC;
3122         struct sljit_compiler* compiler;
3123         struct sljit_jump *jump = NULL;
3124         struct sljit_label* label;
3125         sljit_sw executable_offset;
3126         sljit_uw return_addr;
3127         sljit_uw jump_addr = 0;
3128         sljit_p buf[1];
3129
3130         if (verbose)
3131                 printf("Run test35\n");
3132
3133         buf[0] = 0;
3134
3135         /* A */
3136         compiler = sljit_create_compiler(NULL, NULL);
3137         FAILED(!compiler, "cannot create compiler\n");
3138         sljit_set_context(compiler, 0, 0, 2, 2, 0, 0, 0);
3139
3140         sljit_emit_fast_enter(compiler, SLJIT_MEM0(), (sljit_sw)&buf[0]);
3141         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 5);
3142
3143         jump = sljit_emit_jump(compiler, SLJIT_FAST_CALL | SLJIT_REWRITABLE_JUMP);
3144         sljit_set_target(jump, 0);
3145
3146         label = sljit_emit_label(compiler);
3147         sljit_emit_op_src(compiler, SLJIT_FAST_RETURN, SLJIT_MEM0(), (sljit_sw)&buf[0]);
3148
3149         codeA.code = sljit_generate_code(compiler);
3150         CHECK(compiler);
3151         executable_offset = sljit_get_executable_offset(compiler);
3152         jump_addr = sljit_get_jump_addr(jump);
3153         sljit_free_compiler(compiler);
3154
3155         /* B */
3156         compiler = sljit_create_compiler(NULL, NULL);
3157         FAILED(!compiler, "cannot create compiler\n");
3158         sljit_set_context(compiler, 0, 0, 2, 2, 0, 0, 0);
3159
3160         sljit_emit_op0(compiler, SLJIT_ENDBR);
3161         sljit_emit_fast_enter(compiler, SLJIT_R1, 0);
3162         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 7);
3163         sljit_emit_op_src(compiler, SLJIT_FAST_RETURN, SLJIT_R1, 0);
3164
3165         codeB.code = sljit_generate_code(compiler);
3166         CHECK(compiler);
3167         sljit_free_compiler(compiler);
3168
3169         sljit_set_jump_addr(jump_addr, SLJIT_FUNC_UADDR(codeB.code), executable_offset);
3170
3171         /* C */
3172         compiler = sljit_create_compiler(NULL, NULL);
3173         FAILED(!compiler, "cannot create compiler\n");
3174
3175         sljit_emit_enter(compiler, 0, SLJIT_ARGS0(W), 2, 2, 0, 0, 0);
3176         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0);
3177         sljit_emit_ijump(compiler, SLJIT_FAST_CALL, SLJIT_IMM, SLJIT_FUNC_ADDR(codeA.code));
3178         label = sljit_emit_label(compiler);
3179         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_R0, 0);
3180
3181         codeC.code = sljit_generate_code(compiler);
3182         CHECK(compiler);
3183         return_addr = sljit_get_label_addr(label);
3184         sljit_free_compiler(compiler);
3185
3186         FAILED(codeC.func0() != 12, "test35 case 1 failed\n");
3187         FAILED(buf[0] != return_addr - SLJIT_RETURN_ADDRESS_OFFSET, "test35 case 2 failed\n");
3188
3189         sljit_free_code(codeA.code, NULL);
3190         sljit_free_code(codeB.code, NULL);
3191         sljit_free_code(codeC.code, NULL);
3192         successful_tests++;
3193 }
3194
3195 static void cmp_test(struct sljit_compiler *compiler, sljit_s32 type, sljit_s32 src1, sljit_sw src1w, sljit_s32 src2, sljit_sw src2w)
3196 {
3197         /* 2 = true, 1 = false */
3198         struct sljit_jump* jump;
3199         struct sljit_label* label;
3200
3201         sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_MEM1(SLJIT_S0), 1, SLJIT_IMM, 2);
3202         jump = sljit_emit_cmp(compiler, type, src1, src1w, src2, src2w);
3203         sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_MEM1(SLJIT_S0), 1, SLJIT_IMM, 1);
3204         label = sljit_emit_label(compiler);
3205         sljit_emit_op0(compiler, SLJIT_ENDBR);
3206         sljit_set_label(jump, label);
3207         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_S0, 0, SLJIT_S0, 0, SLJIT_IMM, 1);
3208 }
3209
3210 #define TEST_CASES      (7 + 10 + 12 + 11 + 4)
3211 static void test36(void)
3212 {
3213         /* Compare instruction. */
3214         executable_code code;
3215         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
3216
3217         sljit_s8 buf[TEST_CASES];
3218         sljit_s8 compare_buf[TEST_CASES] = {
3219                 1, 1, 2, 2, 1, 2, 2,
3220                 1, 1, 2, 2, 2, 1, 2, 2, 1, 1,
3221                 2, 2, 2, 1, 2, 2, 2, 2, 1, 1, 2, 2,
3222                 2, 1, 2, 1, 1, 1, 2, 1, 2, 1, 2,
3223                 2, 1, 1, 2
3224         };
3225         sljit_sw data[4];
3226         sljit_s32 i;
3227
3228         if (verbose)
3229                 printf("Run test36\n");
3230
3231         FAILED(!compiler, "cannot create compiler\n");
3232         for (i = 0; i < TEST_CASES; ++i)
3233                 buf[i] = 100;
3234         data[0] = 32;
3235         data[1] = -9;
3236         data[2] = 43;
3237         data[3] = -13;
3238
3239         sljit_emit_enter(compiler, 0, SLJIT_ARGS2(VOID, P, P), 3, 2, 0, 0, 0);
3240         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_S0, 0, SLJIT_S0, 0, SLJIT_IMM, 1);
3241
3242         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 13);
3243         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 15);
3244         cmp_test(compiler, SLJIT_EQUAL, SLJIT_IMM, 9, SLJIT_R0, 0);
3245         cmp_test(compiler, SLJIT_EQUAL, SLJIT_R0, 0, SLJIT_R1, 0);
3246         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 3);
3247         cmp_test(compiler, SLJIT_EQUAL, SLJIT_MEM2(SLJIT_S1, SLJIT_R0), SLJIT_WORD_SHIFT, SLJIT_IMM, -13);
3248         cmp_test(compiler, SLJIT_NOT_EQUAL, SLJIT_IMM, 0, SLJIT_R0, 0);
3249         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0);
3250         cmp_test(compiler, SLJIT_NOT_EQUAL | SLJIT_REWRITABLE_JUMP, SLJIT_IMM, 0, SLJIT_R0, 0);
3251         cmp_test(compiler, SLJIT_EQUAL, SLJIT_MEM2(SLJIT_S1, SLJIT_R0), SLJIT_WORD_SHIFT, SLJIT_MEM2(SLJIT_S1, SLJIT_R0), SLJIT_WORD_SHIFT);
3252         cmp_test(compiler, SLJIT_EQUAL | SLJIT_REWRITABLE_JUMP, SLJIT_R0, 0, SLJIT_IMM, 0);
3253
3254         cmp_test(compiler, SLJIT_SIG_LESS, SLJIT_MEM1(SLJIT_S1), 0, SLJIT_IMM, 0);
3255         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -8);
3256         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0);
3257         cmp_test(compiler, SLJIT_SIG_GREATER, SLJIT_R0, 0, SLJIT_IMM, 0);
3258         cmp_test(compiler, SLJIT_SIG_LESS_EQUAL, SLJIT_R0, 0, SLJIT_IMM, 0);
3259         cmp_test(compiler, SLJIT_SIG_LESS | SLJIT_REWRITABLE_JUMP, SLJIT_R0, 0, SLJIT_IMM, 0);
3260         cmp_test(compiler, SLJIT_SIG_GREATER_EQUAL, SLJIT_R1, 0, SLJIT_IMM, 0);
3261         cmp_test(compiler, SLJIT_SIG_GREATER, SLJIT_IMM, 0, SLJIT_MEM1(SLJIT_S1), 2 * sizeof(sljit_sw));
3262         cmp_test(compiler, SLJIT_SIG_LESS_EQUAL, SLJIT_IMM, 0, SLJIT_R1, 0);
3263         cmp_test(compiler, SLJIT_SIG_LESS, SLJIT_IMM, 0, SLJIT_MEM1(SLJIT_S1), 2 * sizeof(sljit_sw));
3264         cmp_test(compiler, SLJIT_SIG_LESS, SLJIT_IMM, 0, SLJIT_MEM1(SLJIT_S1), 3 * sizeof(sljit_sw));
3265         cmp_test(compiler, SLJIT_SIG_LESS | SLJIT_REWRITABLE_JUMP, SLJIT_IMM, 0, SLJIT_MEM1(SLJIT_S1), 3 * sizeof(sljit_sw));
3266
3267         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 8);
3268         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0);
3269         cmp_test(compiler, SLJIT_LESS, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_sw));
3270         cmp_test(compiler, SLJIT_GREATER_EQUAL, SLJIT_R0, 0, SLJIT_IMM, 8);
3271         cmp_test(compiler, SLJIT_LESS, SLJIT_R0, 0, SLJIT_IMM, -10);
3272         cmp_test(compiler, SLJIT_LESS, SLJIT_R0, 0, SLJIT_IMM, 8);
3273         cmp_test(compiler, SLJIT_GREATER_EQUAL, SLJIT_IMM, 8, SLJIT_R1, 0);
3274         cmp_test(compiler, SLJIT_GREATER_EQUAL | SLJIT_REWRITABLE_JUMP, SLJIT_IMM, 8, SLJIT_R1, 0);
3275         cmp_test(compiler, SLJIT_GREATER, SLJIT_IMM, 8, SLJIT_R1, 0);
3276         cmp_test(compiler, SLJIT_LESS_EQUAL, SLJIT_IMM, 7, SLJIT_R0, 0);
3277         cmp_test(compiler, SLJIT_GREATER, SLJIT_IMM, 1, SLJIT_MEM1(SLJIT_S1), 3 * sizeof(sljit_sw));
3278         cmp_test(compiler, SLJIT_LESS_EQUAL, SLJIT_R0, 0, SLJIT_R1, 0);
3279         cmp_test(compiler, SLJIT_GREATER, SLJIT_R0, 0, SLJIT_R1, 0);
3280         cmp_test(compiler, SLJIT_GREATER | SLJIT_REWRITABLE_JUMP, SLJIT_R0, 0, SLJIT_R1, 0);
3281
3282         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -3);
3283         cmp_test(compiler, SLJIT_SIG_LESS, SLJIT_R0, 0, SLJIT_R1, 0);
3284         cmp_test(compiler, SLJIT_SIG_GREATER_EQUAL, SLJIT_R0, 0, SLJIT_R1, 0);
3285         cmp_test(compiler, SLJIT_SIG_LESS, SLJIT_R0, 0, SLJIT_IMM, -1);
3286         cmp_test(compiler, SLJIT_SIG_GREATER_EQUAL, SLJIT_R0, 0, SLJIT_IMM, 1);
3287         cmp_test(compiler, SLJIT_SIG_LESS, SLJIT_MEM1(SLJIT_S1), 0, SLJIT_IMM, -1);
3288         cmp_test(compiler, SLJIT_SIG_LESS | SLJIT_REWRITABLE_JUMP, SLJIT_MEM1(SLJIT_S1), 0, SLJIT_IMM, -1);
3289         cmp_test(compiler, SLJIT_SIG_LESS_EQUAL, SLJIT_R0, 0, SLJIT_R1, 0);
3290         cmp_test(compiler, SLJIT_SIG_GREATER, SLJIT_R0, 0, SLJIT_R1, 0);
3291         cmp_test(compiler, SLJIT_SIG_LESS_EQUAL, SLJIT_IMM, -4, SLJIT_R0, 0);
3292         cmp_test(compiler, SLJIT_SIG_GREATER, SLJIT_IMM, -1, SLJIT_R1, 0);
3293         cmp_test(compiler, SLJIT_SIG_GREATER | SLJIT_REWRITABLE_JUMP, SLJIT_R1, 0, SLJIT_IMM, -1);
3294
3295 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
3296         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0xf00000004));
3297         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_R0, 0);
3298         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_R1, 0);
3299         cmp_test(compiler, SLJIT_LESS | SLJIT_32, SLJIT_R1, 0, SLJIT_IMM, 5);
3300         cmp_test(compiler, SLJIT_LESS, SLJIT_R0, 0, SLJIT_IMM, 5);
3301         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0xff0000004));
3302         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_R0, 0);
3303         cmp_test(compiler, SLJIT_SIG_GREATER | SLJIT_32, SLJIT_R1, 0, SLJIT_IMM, 5);
3304         cmp_test(compiler, SLJIT_SIG_GREATER, SLJIT_R0, 0, SLJIT_IMM, 5);
3305 #else
3306         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 4);
3307         cmp_test(compiler, SLJIT_LESS | SLJIT_32, SLJIT_R0, 0, SLJIT_IMM, 5);
3308         cmp_test(compiler, SLJIT_GREATER | SLJIT_32, SLJIT_R0, 0, SLJIT_IMM, 5);
3309         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)0xf0000004);
3310         cmp_test(compiler, SLJIT_SIG_GREATER | SLJIT_32, SLJIT_R0, 0, SLJIT_IMM, 5);
3311         cmp_test(compiler, SLJIT_SIG_LESS | SLJIT_32, SLJIT_R0, 0, SLJIT_IMM, 5);
3312 #endif
3313
3314         sljit_emit_return_void(compiler);
3315
3316         code.code = sljit_generate_code(compiler);
3317         CHECK(compiler);
3318         sljit_free_compiler(compiler);
3319
3320         code.func2((sljit_sw)&buf, (sljit_sw)&data);
3321
3322         for (i = 0; i < TEST_CASES; ++i)
3323                 if (SLJIT_UNLIKELY(buf[i] != compare_buf[i])) {
3324                         printf("test36 case %d failed\n", i + 1);
3325                         return;
3326                 }
3327
3328         sljit_free_code(code.code, NULL);
3329         successful_tests++;
3330 }
3331 #undef TEST_CASES
3332
3333 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
3334 #define BITN(n) (SLJIT_W(1) << (63 - (n)))
3335 #define RESN(n) (n)
3336 #else
3337 #define BITN(n) (1 << (31 - ((n) & 0x1f)))
3338 #define RESN(n) ((n) & 0x1f)
3339 #endif
3340
3341 static void test37(void)
3342 {
3343         /* Test count leading zeroes. */
3344         executable_code code;
3345         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
3346         sljit_sw buf[9];
3347         sljit_s32 ibuf[2];
3348         sljit_s32 i;
3349
3350         if (verbose)
3351                 printf("Run test37\n");
3352
3353         FAILED(!compiler, "cannot create compiler\n");
3354
3355         for (i = 0; i < 9; i++)
3356                 buf[i] = -1;
3357         buf[2] = 0;
3358         buf[4] = BITN(13);
3359         ibuf[0] = -1;
3360         ibuf[1] = -1;
3361         sljit_emit_enter(compiler, 0, SLJIT_ARGS2(VOID, P, P), 1, 3, 0, 0, 0);
3362         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, BITN(27));
3363         sljit_emit_op1(compiler, SLJIT_CLZ, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0);
3364         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, BITN(47));
3365         sljit_emit_op1(compiler, SLJIT_CLZ, SLJIT_R0, 0, SLJIT_S2, 0);
3366         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_R0, 0);
3367         sljit_emit_op1(compiler, SLJIT_CLZ, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw));
3368         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -1);
3369         sljit_emit_op1(compiler, SLJIT_CLZ, SLJIT_R0, 0, SLJIT_R0, 0);
3370         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_R0, 0);
3371         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 0);
3372         sljit_emit_op1(compiler, SLJIT_CLZ32, SLJIT_MEM1(SLJIT_S1), 0, SLJIT_R0, 0);
3373         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -1);
3374         sljit_emit_op1(compiler, SLJIT_CLZ, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw));
3375         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_R0, 0);
3376         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, BITN(58));
3377         sljit_emit_op1(compiler, SLJIT_CLZ, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_R0, 0);
3378         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0);
3379         sljit_emit_op1(compiler, SLJIT_CLZ, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_sw), SLJIT_R0, 0);
3380 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
3381         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0xff08a00000));
3382 #else
3383         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 0x08a00000);
3384 #endif
3385         sljit_emit_op1(compiler, SLJIT_CLZ32, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_s32), SLJIT_R0, 0);
3386         sljit_emit_op1(compiler, SLJIT_CLZ32, SLJIT_R0, 0, SLJIT_R0, 0);
3387         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_sw), SLJIT_R0, 0);
3388 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
3389         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0xffc8a00000));
3390 #else
3391         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)0xc8a00000);
3392 #endif
3393         sljit_emit_op1(compiler, SLJIT_CLZ32, SLJIT_R0, 0, SLJIT_R0, 0);
3394         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_sw), SLJIT_R0, 0);
3395
3396         sljit_emit_return_void(compiler);
3397
3398         code.code = sljit_generate_code(compiler);
3399         CHECK(compiler);
3400         sljit_free_compiler(compiler);
3401
3402         code.func2((sljit_sw)&buf, (sljit_sw)&ibuf);
3403         FAILED(buf[0] != RESN(27), "test37 case 1 failed\n");
3404         FAILED(buf[1] != RESN(47), "test37 case 2 failed\n");
3405 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
3406         FAILED(buf[2] != 64, "test37 case 3 failed\n");
3407 #else
3408         FAILED(buf[2] != 32, "test37 case 3 failed\n");
3409 #endif
3410         FAILED(buf[3] != 0, "test37 case 4 failed\n");
3411         FAILED(ibuf[0] != 32, "test37 case 5 failed\n");
3412         FAILED(buf[4] != RESN(13), "test37 case 6 failed\n");
3413         FAILED(buf[5] != RESN(58), "test37 case 7 failed\n");
3414 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
3415         FAILED(buf[6] != 64, "test37 case 8 failed\n");
3416 #else
3417         FAILED(buf[6] != 32, "test37 case 8 failed\n");
3418 #endif
3419         FAILED(ibuf[1] != 4, "test37 case 9 failed\n");
3420
3421         FAILED((buf[7] & (sljit_sw)0xffffffff) != 4, "test37 case 10 failed\n");
3422         FAILED((buf[8] & (sljit_sw)0xffffffff) != 0, "test37 case 11 failed\n");
3423
3424         sljit_free_code(code.code, NULL);
3425         successful_tests++;
3426 }
3427 #undef BITN
3428 #undef RESN
3429
3430 static void test38(void)
3431 {
3432 #if (defined SLJIT_UTIL_STACK && SLJIT_UTIL_STACK)
3433         /* Test stack utility. */
3434         executable_code code;
3435         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
3436         struct sljit_jump* alloc1_fail;
3437         struct sljit_jump* alloc2_fail;
3438         struct sljit_jump* alloc3_fail;
3439         struct sljit_jump* sanity1_fail;
3440         struct sljit_jump* sanity2_fail;
3441         struct sljit_jump* sanity3_fail;
3442         struct sljit_jump* sanity4_fail;
3443         struct sljit_jump* jump;
3444         struct sljit_label* label;
3445
3446         if (verbose)
3447                 printf("Run test38\n");
3448
3449         FAILED(!compiler, "cannot create compiler\n");
3450
3451         sljit_emit_enter(compiler, 0, SLJIT_ARGS0(W), 3, 1, 0, 0, 0);
3452
3453         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 8192);
3454         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 65536);
3455         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 0);
3456         sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_ARGS3(P, W, W, P), SLJIT_IMM, SLJIT_FUNC_ADDR(sljit_allocate_stack));
3457         alloc1_fail = sljit_emit_cmp(compiler, SLJIT_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 0);
3458         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_RETURN_REG, 0);
3459
3460         /* Write 8k data. */
3461         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), SLJIT_OFFSETOF(struct sljit_stack, start));
3462         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, 8192);
3463         label = sljit_emit_label(compiler);
3464         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_IMM, -1);
3465         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, sizeof(sljit_sw));
3466         jump = sljit_emit_cmp(compiler, SLJIT_LESS, SLJIT_R0, 0, SLJIT_R1, 0);
3467         sljit_set_label(jump, label);
3468
3469         /* Grow stack. */
3470         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_S0, 0);
3471         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_S0), SLJIT_OFFSETOF(struct sljit_stack, end), SLJIT_IMM, 65536);
3472         sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_ARGS2(P, P, P), SLJIT_IMM, SLJIT_FUNC_ADDR(sljit_stack_resize));
3473         alloc2_fail = sljit_emit_cmp(compiler, SLJIT_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 0);
3474         sanity1_fail = sljit_emit_cmp(compiler, SLJIT_NOT_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_MEM1(SLJIT_S0), SLJIT_OFFSETOF(struct sljit_stack, start));
3475
3476         /* Write 64k data. */
3477         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), SLJIT_OFFSETOF(struct sljit_stack, start));
3478         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, 65536);
3479         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_S0), SLJIT_OFFSETOF(struct sljit_stack, min_start));
3480         sanity2_fail = sljit_emit_cmp(compiler, SLJIT_NOT_EQUAL, SLJIT_R0, 0, SLJIT_R2, 0);
3481         label = sljit_emit_label(compiler);
3482         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_IMM, -1);
3483         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, sizeof(sljit_sw));
3484         jump = sljit_emit_cmp(compiler, SLJIT_LESS, SLJIT_R0, 0, SLJIT_R1, 0);
3485         sljit_set_label(jump, label);
3486
3487         /* Shrink stack. */
3488         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_S0, 0);
3489         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_S0), SLJIT_OFFSETOF(struct sljit_stack, end), SLJIT_IMM, 32768);
3490         sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_ARGS2(P, P, P), SLJIT_IMM, SLJIT_FUNC_ADDR(sljit_stack_resize));
3491         alloc3_fail = sljit_emit_cmp(compiler, SLJIT_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 0);
3492         sanity3_fail = sljit_emit_cmp(compiler, SLJIT_NOT_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_MEM1(SLJIT_S0), SLJIT_OFFSETOF(struct sljit_stack, start));
3493
3494         /* Write 32k data. */
3495         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), SLJIT_OFFSETOF(struct sljit_stack, start));
3496         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_S0), SLJIT_OFFSETOF(struct sljit_stack, end));
3497         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R2, 0, SLJIT_R1, 0, SLJIT_IMM, 32768);
3498         sanity4_fail = sljit_emit_cmp(compiler, SLJIT_NOT_EQUAL, SLJIT_R0, 0, SLJIT_R2, 0);
3499         label = sljit_emit_label(compiler);
3500         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_IMM, -1);
3501         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, sizeof(sljit_sw));
3502         jump = sljit_emit_cmp(compiler, SLJIT_LESS, SLJIT_R0, 0, SLJIT_R1, 0);
3503         sljit_set_label(jump, label);
3504
3505         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_S0, 0);
3506         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0);
3507         sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_ARGS2(VOID, P, P), SLJIT_IMM, SLJIT_FUNC_ADDR(sljit_free_stack));
3508
3509         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_IMM, 4567);
3510
3511         label = sljit_emit_label(compiler);
3512         sljit_set_label(alloc1_fail, label);
3513         sljit_set_label(alloc2_fail, label);
3514         sljit_set_label(alloc3_fail, label);
3515         sljit_set_label(sanity1_fail, label);
3516         sljit_set_label(sanity2_fail, label);
3517         sljit_set_label(sanity3_fail, label);
3518         sljit_set_label(sanity4_fail, label);
3519         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_IMM, 0);
3520
3521         code.code = sljit_generate_code(compiler);
3522         CHECK(compiler);
3523         sljit_free_compiler(compiler);
3524
3525         /* Just survive this. */
3526         FAILED(code.func0() != 4567, "test38 case 1 failed\n");
3527
3528         sljit_free_code(code.code, NULL);
3529 #endif
3530         successful_tests++;
3531 }
3532
3533 static void test39(void)
3534 {
3535         /* Test error handling. */
3536         executable_code code;
3537         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
3538         struct sljit_jump* jump;
3539
3540         if (verbose)
3541                 printf("Run test39\n");
3542
3543         FAILED(!compiler, "cannot create compiler\n");
3544
3545         /* Such assignment should never happen in a regular program. */
3546         compiler->error = -3967;
3547
3548         SLJIT_ASSERT(sljit_emit_enter(compiler, 0, SLJIT_ARGS2(VOID, W, W), 5, 5, 6, 0, 32) == -3967);
3549         SLJIT_ASSERT(sljit_emit_return(compiler, SLJIT_MOV, SLJIT_R1, 0) == -3967);
3550         SLJIT_ASSERT(sljit_emit_op0(compiler, SLJIT_NOP) == -3967);
3551         SLJIT_ASSERT(sljit_emit_op0(compiler, SLJIT_ENDBR) == -3967);
3552         SLJIT_ASSERT(sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM2(SLJIT_R0, SLJIT_R1), 1) == -3967);
3553         SLJIT_ASSERT(sljit_emit_op2(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_R0), 64, SLJIT_MEM1(SLJIT_S0), -64) == -3967);
3554         SLJIT_ASSERT(sljit_emit_fop1(compiler, SLJIT_ABS_F64, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_R1), 0) == -3967);
3555         SLJIT_ASSERT(sljit_emit_fop2(compiler, SLJIT_DIV_F64, SLJIT_FR2, 0, SLJIT_MEM2(SLJIT_R0, SLJIT_S0), 0, SLJIT_FR2, 0) == -3967);
3556         SLJIT_ASSERT(!sljit_emit_label(compiler));
3557         jump = sljit_emit_call(compiler, SLJIT_CALL, SLJIT_ARGS4(W, 32, P, F32, F64));
3558         SLJIT_ASSERT(!jump);
3559         sljit_set_label(jump, (struct sljit_label*)0x123450);
3560         sljit_set_target(jump, 0x123450);
3561         jump = sljit_emit_cmp(compiler, SLJIT_SIG_LESS_EQUAL, SLJIT_R0, 0, SLJIT_R1, 0);
3562         SLJIT_ASSERT(!jump);
3563         SLJIT_ASSERT(sljit_emit_ijump(compiler, SLJIT_JUMP, SLJIT_MEM1(SLJIT_R0), 8) == -3967);
3564         SLJIT_ASSERT(sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_OVERFLOW) == -3967);
3565         SLJIT_ASSERT(!sljit_emit_const(compiler, SLJIT_R0, 0, 99));
3566
3567         SLJIT_ASSERT(!compiler->labels && !compiler->jumps && !compiler->consts);
3568         SLJIT_ASSERT(!compiler->last_label && !compiler->last_jump && !compiler->last_const);
3569         SLJIT_ASSERT(!compiler->buf->next && !compiler->buf->used_size);
3570         SLJIT_ASSERT(!compiler->abuf->next && !compiler->abuf->used_size);
3571
3572         sljit_set_compiler_memory_error(compiler);
3573         FAILED(sljit_get_compiler_error(compiler) != -3967, "test39 case 1 failed\n");
3574
3575         code.code = sljit_generate_code(compiler);
3576         FAILED(sljit_get_compiler_error(compiler) != -3967, "test39 case 2 failed\n");
3577         FAILED(!!code.code, "test39 case 3 failed\n");
3578         sljit_free_compiler(compiler);
3579
3580         compiler = sljit_create_compiler(NULL, NULL);
3581         FAILED(!compiler, "cannot create compiler\n");
3582
3583         FAILED(sljit_get_compiler_error(compiler) != SLJIT_SUCCESS, "test39 case 4 failed\n");
3584         sljit_set_compiler_memory_error(compiler);
3585         FAILED(sljit_get_compiler_error(compiler) != SLJIT_ERR_ALLOC_FAILED, "test39 case 5 failed\n");
3586         sljit_free_compiler(compiler);
3587
3588         successful_tests++;
3589 }
3590
3591 static void test40(void)
3592 {
3593         /* Test emit_op_flags. */
3594         executable_code code;
3595         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
3596         sljit_sw buf[10];
3597
3598         if (verbose)
3599                 printf("Run test40\n");
3600
3601         FAILED(!compiler, "cannot create compiler\n");
3602         buf[0] = -100;
3603         buf[1] = -100;
3604         buf[2] = -100;
3605         buf[3] = -8;
3606         buf[4] = -100;
3607         buf[5] = -100;
3608         buf[6] = 0;
3609         buf[7] = 0;
3610         buf[8] = -100;
3611         buf[9] = -100;
3612
3613         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(W, P), 3, 4, 0, 0, sizeof(sljit_sw));
3614
3615         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -5);
3616         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_SIG_LESS, SLJIT_IMM, -6, SLJIT_R0, 0);
3617         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0x123456);
3618         sljit_emit_op_flags(compiler, SLJIT_OR, SLJIT_R1, 0, SLJIT_SIG_LESS);
3619         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R1, 0);
3620
3621         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -13);
3622         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_Z, SLJIT_IMM, -13, SLJIT_R0, 0);
3623         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), 0, SLJIT_IMM, 0);
3624         sljit_emit_op_flags(compiler, SLJIT_OR | SLJIT_SET_Z, SLJIT_MEM1(SLJIT_SP), 0, SLJIT_EQUAL);
3625         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_NOT_EQUAL);
3626         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);
3627         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_Z, SLJIT_IMM, -13, SLJIT_R0, 0);
3628         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0);
3629         sljit_emit_op_flags(compiler, SLJIT_OR | SLJIT_SET_Z, SLJIT_R1, 0, SLJIT_EQUAL);
3630         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 2, SLJIT_EQUAL);
3631
3632         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -13);
3633         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 3);
3634         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_SIG_LESS, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_R1, 0);
3635         sljit_emit_op_flags(compiler, SLJIT_OR, SLJIT_MEM2(SLJIT_S0, SLJIT_R1), SLJIT_WORD_SHIFT, SLJIT_SIG_LESS);
3636
3637         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -8);
3638         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 33);
3639         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_GREATER, SLJIT_R0, 0, SLJIT_R1, 0);
3640         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_IMM, 0);
3641         sljit_emit_op_flags(compiler, SLJIT_OR | SLJIT_SET_Z, SLJIT_R2, 0, SLJIT_GREATER);
3642         sljit_emit_op_flags(compiler, SLJIT_OR, SLJIT_S1, 0, SLJIT_EQUAL);
3643         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_Z, SLJIT_R0, 0, SLJIT_R1, 0);
3644         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S3, 0, SLJIT_IMM, 0x88);
3645         sljit_emit_op_flags(compiler, SLJIT_OR, SLJIT_S3, 0, SLJIT_NOT_EQUAL);
3646         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 4, SLJIT_S1, 0);
3647         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 5, SLJIT_S3, 0);
3648
3649         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0x84);
3650         sljit_emit_op2u(compiler, SLJIT_AND | SLJIT_SET_Z, SLJIT_IMM, 0x180, SLJIT_R0, 0);
3651         sljit_emit_op_flags(compiler, SLJIT_OR | SLJIT_SET_Z, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 6, SLJIT_EQUAL);
3652         sljit_emit_op_flags(compiler, SLJIT_OR, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 7, SLJIT_EQUAL);
3653
3654         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 1);
3655         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_Z, SLJIT_R0, 0, SLJIT_IMM, 1);
3656         sljit_emit_op_flags(compiler, SLJIT_OR | SLJIT_SET_Z, SLJIT_R0, 0, SLJIT_NOT_EQUAL);
3657         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 8, SLJIT_NOT_EQUAL);
3658
3659         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0x123456);
3660         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_GREATER, SLJIT_R0, 0, SLJIT_IMM, 1);
3661         sljit_emit_op_flags(compiler, SLJIT_OR, SLJIT_R0, 0, SLJIT_GREATER);
3662         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 9, SLJIT_R0, 0);
3663
3664         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), 0, SLJIT_IMM, 0xbaddead);
3665         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), 0);
3666
3667         code.code = sljit_generate_code(compiler);
3668         CHECK(compiler);
3669         sljit_free_compiler(compiler);
3670
3671         FAILED(code.func1((sljit_sw)&buf) != 0xbaddead, "test40 case 1 failed\n");
3672         FAILED(buf[0] != 0x123457, "test40 case 2 failed\n");
3673         FAILED(buf[1] != 1, "test40 case 3 failed\n");
3674         FAILED(buf[2] != 0, "test40 case 4 failed\n");
3675         FAILED(buf[3] != -7, "test40 case 5 failed\n");
3676         FAILED(buf[4] != 0, "test40 case 6 failed\n");
3677         FAILED(buf[5] != 0x89, "test40 case 7 failed\n");
3678         FAILED(buf[6] != 0, "test40 case 8 failed\n");
3679         FAILED(buf[7] != 1, "test40 case 9 failed\n");
3680         FAILED(buf[8] != 1, "test40 case 10 failed\n");
3681         FAILED(buf[9] != 0x123457, "test40 case 11 failed\n");
3682
3683         sljit_free_code(code.code, NULL);
3684         successful_tests++;
3685 }
3686
3687 static void test41(void)
3688 {
3689         /* Test inline assembly. */
3690         executable_code code;
3691         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
3692         sljit_s32 i;
3693         sljit_f64 buf[3];
3694 #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
3695         sljit_u8 inst[16];
3696 #elif (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
3697         sljit_u8 inst[16];
3698         sljit_s32 reg;
3699 #else
3700         sljit_u32 inst;
3701 #endif
3702
3703         if (verbose)
3704                 printf("Run test41\n");
3705
3706 #if !(defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
3707         SLJIT_ASSERT(sljit_has_cpu_feature(SLJIT_HAS_VIRTUAL_REGISTERS) == 0);
3708 #endif
3709
3710         for (i = 0; i < SLJIT_NUMBER_OF_REGISTERS; i++) {
3711 #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
3712                 if (SLJIT_R(i) >= SLJIT_R3 && SLJIT_R(i) <= SLJIT_R8) {
3713                         SLJIT_ASSERT(sljit_get_register_index(SLJIT_R(i)) == -1);
3714                         continue;
3715                 }
3716 #endif
3717                 SLJIT_ASSERT(sljit_get_register_index(SLJIT_R(i)) >= 0 && sljit_get_register_index(SLJIT_R(i)) < 64);
3718         }
3719
3720         FAILED(!compiler, "cannot create compiler\n");
3721         sljit_emit_enter(compiler, 0, SLJIT_ARGS2(W, W, W), 3, 3, 0, 0, 0);
3722
3723         /* Returns with the sum of SLJIT_S0 and SLJIT_S1. */
3724 #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
3725         /* lea SLJIT_RETURN_REG, [SLJIT_S0, SLJIT_S1] */
3726         inst[0] = 0x48;
3727         inst[1] = 0x8d;
3728         inst[2] = (sljit_u8)(0x04 | ((sljit_get_register_index(SLJIT_RETURN_REG) & 0x7) << 3));
3729         inst[3] = (sljit_u8)((sljit_get_register_index(SLJIT_S0) & 0x7)
3730                 | ((sljit_get_register_index(SLJIT_S1) & 0x7) << 3));
3731         sljit_emit_op_custom(compiler, inst, 4);
3732 #elif (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
3733         /* lea SLJIT_RETURN_REG, [SLJIT_S0, SLJIT_S1] */
3734         inst[0] = 0x48; /* REX_W */
3735         inst[1] = 0x8d;
3736         reg = sljit_get_register_index(SLJIT_RETURN_REG);
3737         inst[2] = (sljit_u8)(0x04 | ((reg & 0x7) << 3));
3738         if (reg > 7)
3739                 inst[0] |= 0x04; /* REX_R */
3740         reg = sljit_get_register_index(SLJIT_S0);
3741         inst[3] = (sljit_u8)(reg & 0x7);
3742         if (reg > 7)
3743                 inst[0] |= 0x01; /* REX_B */
3744         reg = sljit_get_register_index(SLJIT_S1);
3745         inst[3] = (sljit_u8)(inst[3] | ((reg & 0x7) << 3));
3746         if (reg > 7)
3747                 inst[0] |= 0x02; /* REX_X */
3748         sljit_emit_op_custom(compiler, inst, 4);
3749 #elif (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5) || (defined SLJIT_CONFIG_ARM_V7 && SLJIT_CONFIG_ARM_V7)
3750         /* add rd, rn, rm */
3751         inst = 0xe0800000 | ((sljit_u32)sljit_get_register_index(SLJIT_RETURN_REG) << 12)
3752                 | ((sljit_u32)sljit_get_register_index(SLJIT_S0) << 16)
3753                 | (sljit_u32)sljit_get_register_index(SLJIT_S1);
3754         sljit_emit_op_custom(compiler, &inst, sizeof(sljit_u32));
3755 #elif (defined SLJIT_CONFIG_ARM_THUMB2 && SLJIT_CONFIG_ARM_THUMB2)
3756         /* add rd, rn, rm */
3757         inst = 0xeb000000 | ((sljit_u32)sljit_get_register_index(SLJIT_RETURN_REG) << 8)
3758                 | ((sljit_u32)sljit_get_register_index(SLJIT_S0) << 16)
3759                 | (sljit_u32)sljit_get_register_index(SLJIT_S1);
3760         sljit_emit_op_custom(compiler, &inst, sizeof(sljit_u32));
3761 #elif (defined SLJIT_CONFIG_ARM_64 && SLJIT_CONFIG_ARM_64)
3762         /* add rd, rn, rm */
3763         inst = 0x8b000000 | (sljit_u32)sljit_get_register_index(SLJIT_RETURN_REG)
3764                 | ((sljit_u32)sljit_get_register_index(SLJIT_S0) << 5)
3765                 | ((sljit_u32)sljit_get_register_index(SLJIT_S1) << 16);
3766         sljit_emit_op_custom(compiler, &inst, sizeof(sljit_u32));
3767 #elif (defined SLJIT_CONFIG_PPC && SLJIT_CONFIG_PPC)
3768         /* add rD, rA, rB */
3769         inst = (31 << 26) | (266 << 1) | ((sljit_u32)sljit_get_register_index(SLJIT_RETURN_REG) << 21)
3770                 | ((sljit_u32)sljit_get_register_index(SLJIT_S0) << 16)
3771                 | ((sljit_u32)sljit_get_register_index(SLJIT_S1) << 11);
3772         sljit_emit_op_custom(compiler, &inst, sizeof(sljit_u32));
3773 #elif (defined SLJIT_CONFIG_MIPS_32 && SLJIT_CONFIG_MIPS_32)
3774         /* addu rd, rs, rt */
3775         inst = 33 | ((sljit_u32)sljit_get_register_index(SLJIT_RETURN_REG) << 11)
3776                 | ((sljit_u32)sljit_get_register_index(SLJIT_S0) << 21)
3777                 | ((sljit_u32)sljit_get_register_index(SLJIT_S1) << 16);
3778         sljit_emit_op_custom(compiler, &inst, sizeof(sljit_u32));
3779 #elif (defined SLJIT_CONFIG_MIPS_64 && SLJIT_CONFIG_MIPS_64)
3780         /* daddu rd, rs, rt */
3781         inst = 45 | ((sljit_u32)sljit_get_register_index(SLJIT_RETURN_REG) << 11)
3782                 | ((sljit_u32)sljit_get_register_index(SLJIT_S0) << 21)
3783                 | ((sljit_u32)sljit_get_register_index(SLJIT_S1) << 16);
3784         sljit_emit_op_custom(compiler, &inst, sizeof(sljit_u32));
3785 #elif (defined SLJIT_CONFIG_RISCV && SLJIT_CONFIG_RISCV)
3786         /* add rd, rs1, rs2 */
3787         inst = 0x33 | (0 << 12) | (0 << 25) | ((sljit_u32)sljit_get_register_index(SLJIT_RETURN_REG) << 7)
3788                 | ((sljit_u32)sljit_get_register_index(SLJIT_S0) << 15)
3789                 | ((sljit_u32)sljit_get_register_index(SLJIT_S1) << 20);
3790         sljit_emit_op_custom(compiler, &inst, sizeof(sljit_u32));
3791 #elif (defined SLJIT_CONFIG_SPARC_32 && SLJIT_CONFIG_SPARC_32)
3792         /* add rd, rs1, rs2 */
3793         inst = (0x2u << 30) | ((sljit_u32)sljit_get_register_index(SLJIT_RETURN_REG) << 25)
3794                 | ((sljit_u32)sljit_get_register_index(SLJIT_S0) << 14)
3795                 | (sljit_u32)sljit_get_register_index(SLJIT_S1);
3796         sljit_emit_op_custom(compiler, &inst, sizeof(sljit_u32));
3797 #elif (defined SLJIT_CONFIG_S390X && SLJIT_CONFIG_S390X)
3798         /* agrk rd, rs1, rs2 */
3799         inst = (0xb9e8u << 16)
3800                 | ((sljit_u32)sljit_get_register_index(SLJIT_RETURN_REG) << 4)
3801                 | ((sljit_u32)sljit_get_register_index(SLJIT_S0) << 12)
3802                 | (sljit_u32)sljit_get_register_index(SLJIT_S1);
3803         sljit_emit_op_custom(compiler, &inst, sizeof(inst));
3804 #else
3805         inst = 0;
3806         sljit_emit_op_custom(compiler, &inst, 0);
3807 #endif
3808
3809         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);
3810
3811         code.code = sljit_generate_code(compiler);
3812         CHECK(compiler);
3813         sljit_free_compiler(compiler);
3814
3815         FAILED(code.func2(32, -11) != 21, "test41 case 1 failed\n");
3816         FAILED(code.func2(1000, 234) != 1234, "test41 case 2 failed\n");
3817 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
3818         FAILED(code.func2(SLJIT_W(0x20f0a04090c06070), SLJIT_W(0x020f0a04090c0607)) != SLJIT_W(0x22ffaa4499cc6677), "test41 case 3 failed\n");
3819 #endif
3820
3821         sljit_free_code(code.code, NULL);
3822
3823         if (sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
3824                 buf[0] = 13.5;
3825                 buf[1] = -2.25;
3826                 buf[2] = 0.0;
3827
3828                 compiler = sljit_create_compiler(NULL, NULL);
3829                 sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, P), 0, 1, 2, 0, 0);
3830                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S0), 0);
3831                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64));
3832 #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
3833                 /* addsd x, xm */
3834                 inst[0] = 0xf2;
3835                 inst[1] = 0x0f;
3836                 inst[2] = 0x58;
3837                 inst[3] = (sljit_u8)(0xc0 | (sljit_get_float_register_index(SLJIT_FR0) << 3)
3838                         | sljit_get_float_register_index(SLJIT_FR1));
3839                 sljit_emit_op_custom(compiler, inst, 4);
3840 #elif (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
3841                 /* addsd x, xm */
3842                 if (sljit_get_float_register_index(SLJIT_FR0) > 7 || sljit_get_float_register_index(SLJIT_FR1) > 7) {
3843                         inst[0] = 0;
3844                         if (sljit_get_float_register_index(SLJIT_FR0) > 7)
3845                                 inst[0] |= 0x04; /* REX_R */
3846                         if (sljit_get_float_register_index(SLJIT_FR1) > 7)
3847                                 inst[0] |= 0x01; /* REX_B */
3848                         inst[1] = 0xf2;
3849                         inst[2] = 0x0f;
3850                         inst[3] = 0x58;
3851                         inst[4] = (sljit_u8)(0xc0 | ((sljit_get_float_register_index(SLJIT_FR0) & 0x7) << 3)
3852                                 | (sljit_get_float_register_index(SLJIT_FR1) & 0x7));
3853                         sljit_emit_op_custom(compiler, inst, 5);
3854                 }
3855                 else {
3856                         inst[0] = 0xf2;
3857                         inst[1] = 0x0f;
3858                         inst[2] = 0x58;
3859                         inst[3] = (sljit_u8)(0xc0 | (sljit_get_float_register_index(SLJIT_FR0) << 3)
3860                                 | sljit_get_float_register_index(SLJIT_FR1));
3861                         sljit_emit_op_custom(compiler, inst, 4);
3862                 }
3863 #elif (defined SLJIT_CONFIG_ARM_32 && SLJIT_CONFIG_ARM_32)
3864                 /* vadd.f64 dd, dn, dm */
3865                 inst = 0xee300b00 | (((sljit_u32)sljit_get_float_register_index(SLJIT_FR0) >> 1) << 12)
3866                         | (((sljit_u32)sljit_get_float_register_index(SLJIT_FR0) >> 1) << 16)
3867                         | ((sljit_u32)sljit_get_float_register_index(SLJIT_FR1) >> 1);
3868                 sljit_emit_op_custom(compiler, &inst, sizeof(sljit_u32));
3869 #elif (defined SLJIT_CONFIG_ARM_64 && SLJIT_CONFIG_ARM_64)
3870                 /* fadd rd, rn, rm */
3871                 inst = 0x1e602800 | (sljit_u32)sljit_get_float_register_index(SLJIT_FR0)
3872                         | ((sljit_u32)sljit_get_float_register_index(SLJIT_FR0) << 5)
3873                         | ((sljit_u32)sljit_get_float_register_index(SLJIT_FR1) << 16);
3874                 sljit_emit_op_custom(compiler, &inst, sizeof(sljit_u32));
3875 #elif (defined SLJIT_CONFIG_PPC && SLJIT_CONFIG_PPC)
3876                 /* fadd frD, frA, frB */
3877                 inst = (63u << 26) | (21u << 1) | ((sljit_u32)sljit_get_float_register_index(SLJIT_FR0) << 21)
3878                         | ((sljit_u32)sljit_get_float_register_index(SLJIT_FR0) << 16)
3879                         | ((sljit_u32)sljit_get_float_register_index(SLJIT_FR1) << 11);
3880                 sljit_emit_op_custom(compiler, &inst, sizeof(sljit_u32));
3881 #elif (defined SLJIT_CONFIG_MIPS && SLJIT_CONFIG_MIPS)
3882                 /* add.d fd, fs, ft */
3883                 inst = (17u << 26) | (17u << 21) | ((sljit_u32)sljit_get_float_register_index(SLJIT_FR0) << 6)
3884                         | ((sljit_u32)sljit_get_float_register_index(SLJIT_FR0) << 11)
3885                         | ((sljit_u32)sljit_get_float_register_index(SLJIT_FR1) << 16);
3886                 sljit_emit_op_custom(compiler, &inst, sizeof(sljit_u32));
3887 #elif (defined SLJIT_CONFIG_RISCV && SLJIT_CONFIG_RISCV)
3888                 /* fadd.d rd, rs1, rs2 */
3889                 inst = (0x1u << 25) | (0x7u << 12) | (0x53u)
3890                         | ((sljit_u32)sljit_get_float_register_index(SLJIT_FR0) << 7)
3891                         | ((sljit_u32)sljit_get_float_register_index(SLJIT_FR0) << 15)
3892                         | (sljit_u32)sljit_get_float_register_index(SLJIT_FR1) << 20;
3893                 sljit_emit_op_custom(compiler, &inst, sizeof(sljit_u32));
3894 #elif (defined SLJIT_CONFIG_SPARC_32 && SLJIT_CONFIG_SPARC_32)
3895                 /* faddd rd, rs1, rs2 */
3896                 inst = (0x2u << 30) | (0x34u << 19) | (0x42u << 5)
3897                         | ((sljit_u32)sljit_get_float_register_index(SLJIT_FR0) << 25)
3898                         | ((sljit_u32)sljit_get_float_register_index(SLJIT_FR0) << 14)
3899                         | (sljit_u32)sljit_get_float_register_index(SLJIT_FR1);
3900                 sljit_emit_op_custom(compiler, &inst, sizeof(sljit_u32));
3901 #elif (defined SLJIT_CONFIG_S390X && SLJIT_CONFIG_S390X)
3902                 /* adbr r1, r2 */
3903                 inst = 0xb31a0000
3904                         | ((sljit_u32)sljit_get_float_register_index(SLJIT_FR0) << 4)
3905                         | (sljit_u32)sljit_get_float_register_index(SLJIT_FR1);
3906                 sljit_emit_op_custom(compiler, &inst, sizeof(sljit_u32));
3907 #endif
3908                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_f64), SLJIT_FR0, 0);
3909                 sljit_emit_return_void(compiler);
3910
3911                 code.code = sljit_generate_code(compiler);
3912                 CHECK(compiler);
3913                 sljit_free_compiler(compiler);
3914
3915                 code.func1((sljit_sw)&buf);
3916                 FAILED(buf[2] != 11.25, "test41 case 4 failed\n");
3917
3918                 sljit_free_code(code.code, NULL);
3919         }
3920
3921         successful_tests++;
3922 }
3923
3924 static void test42(void)
3925 {
3926         /* Test long multiply and division. */
3927         executable_code code;
3928         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
3929         sljit_s32 i;
3930         sljit_sw buf[7 + 4 + 8 + 8];
3931
3932         if (verbose)
3933                 printf("Run test42\n");
3934
3935         FAILED(!compiler, "cannot create compiler\n");
3936         for (i = 0; i < 7 + 4 + 8 + 8; i++)
3937                 buf[i] = -1;
3938
3939         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, P), 5, 5, 0, 0, 0);
3940
3941         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, -0x1fb308a);
3942         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, 0xf50c873);
3943         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R4, 0, SLJIT_IMM, 0x8a0475b);
3944         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_IMM, 0x9dc849b);
3945         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, -0x7c69a35);
3946         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S3, 0, SLJIT_IMM, 0x5a4d0c4);
3947         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S4, 0, SLJIT_IMM, 0x9a3b06d);
3948
3949 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
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_LMUL_UW);
3953         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_sw), SLJIT_R0, 0);
3954         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_sw), SLJIT_R1, 0);
3955
3956         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(-0x5dc4f897b8cd67f5));
3957         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(0x3f8b5c026cb088df));
3958         sljit_emit_op0(compiler, SLJIT_LMUL_SW);
3959         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 9 * sizeof(sljit_sw), SLJIT_R0, 0);
3960         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 10 * sizeof(sljit_sw), SLJIT_R1, 0);
3961
3962         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(-0x5dc4f897b8cd67f5));
3963         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(0x3f8b5c026cb088df));
3964         sljit_emit_op0(compiler, SLJIT_DIVMOD_UW);
3965         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 11 * sizeof(sljit_sw), SLJIT_R0, 0);
3966         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 12 * sizeof(sljit_sw), SLJIT_R1, 0);
3967
3968         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(-0x5dc4f897b8cd67f5));
3969         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(0x3f8b5c026cb088df));
3970         sljit_emit_op0(compiler, SLJIT_DIVMOD_SW);
3971         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 13 * sizeof(sljit_sw), SLJIT_R0, 0);
3972         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 14 * sizeof(sljit_sw), SLJIT_R1, 0);
3973
3974         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0x5cf783d3cf0a74b0));
3975         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(0x3d5df42d03a28fc7));
3976         sljit_emit_op0(compiler, SLJIT_DIVMOD_U32);
3977         sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_R0, 0, SLJIT_R0, 0);
3978         sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_R1, 0, SLJIT_R1, 0);
3979         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 15 * sizeof(sljit_sw), SLJIT_R0, 0);
3980         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 16 * sizeof(sljit_sw), SLJIT_R1, 0);
3981
3982         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0x371df5197ba26a28));
3983         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(0x46c78a5cfd6a420c));
3984         sljit_emit_op0(compiler, SLJIT_DIVMOD_S32);
3985         sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_R0, 0, SLJIT_R0, 0);
3986         sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_R1, 0, SLJIT_R1, 0);
3987         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 17 * sizeof(sljit_sw), SLJIT_R0, 0);
3988         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 18 * sizeof(sljit_sw), SLJIT_R1, 0);
3989
3990         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)SLJIT_W(0xc456f048c28a611b));
3991         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(0x3d4af2c543));
3992         sljit_emit_op0(compiler, SLJIT_DIV_UW);
3993         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 19 * sizeof(sljit_sw), SLJIT_R0, 0);
3994         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 20 * sizeof(sljit_sw), SLJIT_R1, 0);
3995
3996         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(-0x720fa4b74c329b14));
3997         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(0xa64ae42b7d6));
3998         sljit_emit_op0(compiler, SLJIT_DIV_SW);
3999         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 21 * sizeof(sljit_sw), SLJIT_R0, 0);
4000         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 22 * sizeof(sljit_sw), SLJIT_R1, 0);
4001
4002         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0x4af51c027b34));
4003         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(0x9ba4ff2906b14));
4004         sljit_emit_op0(compiler, SLJIT_DIV_U32);
4005         sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_R0, 0, SLJIT_R0, 0);
4006         sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_R1, 0, SLJIT_R1, 0);
4007         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 23 * sizeof(sljit_sw), SLJIT_R0, 0);
4008         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 24 * sizeof(sljit_sw), SLJIT_R1, 0);
4009
4010         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0xc40b58a3f20d));
4011         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(-0xa63c923));
4012         sljit_emit_op0(compiler, SLJIT_DIV_S32);
4013         sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_R0, 0, SLJIT_R0, 0);
4014         sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_R1, 0, SLJIT_R1, 0);
4015         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 25 * sizeof(sljit_sw), SLJIT_R0, 0);
4016         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 26 * sizeof(sljit_sw), SLJIT_R1, 0);
4017
4018 #else
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_LMUL_UW);
4022         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_sw), SLJIT_R0, 0);
4023         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_sw), SLJIT_R1, 0);
4024
4025         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -0x58cd67f5);
4026         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0x3cb088df);
4027         sljit_emit_op0(compiler, SLJIT_LMUL_SW);
4028         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 9 * sizeof(sljit_sw), SLJIT_R0, 0);
4029         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 10 * sizeof(sljit_sw), SLJIT_R1, 0);
4030
4031         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -0x58cd67f5);
4032         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0x3cb088df);
4033         sljit_emit_op0(compiler, SLJIT_DIVMOD_UW);
4034         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 11 * sizeof(sljit_sw), SLJIT_R0, 0);
4035         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 12 * sizeof(sljit_sw), SLJIT_R1, 0);
4036
4037         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -0x58cd67f5);
4038         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0x3cb088df);
4039         sljit_emit_op0(compiler, SLJIT_DIVMOD_SW);
4040         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 13 * sizeof(sljit_sw), SLJIT_R0, 0);
4041         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 14 * sizeof(sljit_sw), SLJIT_R1, 0);
4042
4043         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)0xcf0a74b0);
4044         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, 0x03a28fc7);
4045         sljit_emit_op0(compiler, SLJIT_DIVMOD_U32);
4046         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 15 * sizeof(sljit_sw), SLJIT_R0, 0);
4047         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 16 * sizeof(sljit_sw), SLJIT_R1, 0);
4048
4049         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 0x7ba26a28);
4050         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, (sljit_sw)0xfd6a420c);
4051         sljit_emit_op0(compiler, SLJIT_DIVMOD_S32);
4052         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 17 * sizeof(sljit_sw), SLJIT_R0, 0);
4053         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 18 * sizeof(sljit_sw), SLJIT_R1, 0);
4054
4055         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)0x9d4b7036);
4056         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0xb86d0);
4057         sljit_emit_op0(compiler, SLJIT_DIV_UW);
4058         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 19 * sizeof(sljit_sw), SLJIT_R0, 0);
4059         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 20 * sizeof(sljit_sw), SLJIT_R1, 0);
4060
4061         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -0x58b0692c);
4062         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0xd357);
4063         sljit_emit_op0(compiler, SLJIT_DIV_SW);
4064         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 21 * sizeof(sljit_sw), SLJIT_R0, 0);
4065         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 22 * sizeof(sljit_sw), SLJIT_R1, 0);
4066
4067         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 0x1c027b34);
4068         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, (sljit_sw)0xf2906b14);
4069         sljit_emit_op0(compiler, SLJIT_DIV_U32);
4070         sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_R0, 0, SLJIT_R0, 0);
4071         sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_R1, 0, SLJIT_R1, 0);
4072         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 23 * sizeof(sljit_sw), SLJIT_R0, 0);
4073         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 24 * sizeof(sljit_sw), SLJIT_R1, 0);
4074
4075         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 0x58a3f20d);
4076         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, -0xa63c923);
4077         sljit_emit_op0(compiler, SLJIT_DIV_S32);
4078         sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_R0, 0, SLJIT_R0, 0);
4079         sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_R1, 0, SLJIT_R1, 0);
4080         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 25 * sizeof(sljit_sw), SLJIT_R0, 0);
4081         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 26 * sizeof(sljit_sw), SLJIT_R1, 0);
4082 #endif
4083
4084         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R2, 0);
4085         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_R3, 0);
4086         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_R4, 0);
4087         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_S1, 0);
4088         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_S2, 0);
4089         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_S3, 0);
4090         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_sw), SLJIT_S4, 0);
4091
4092         sljit_emit_return_void(compiler);
4093
4094         code.code = sljit_generate_code(compiler);
4095         CHECK(compiler);
4096         sljit_free_compiler(compiler);
4097
4098         code.func1((sljit_sw)&buf);
4099
4100         FAILED(buf[0] != -0x1fb308a, "test42 case 1 failed\n");
4101         FAILED(buf[1] != 0xf50c873, "test42 case 2 failed\n");
4102         FAILED(buf[2] != 0x8a0475b, "test42 case 3 failed\n");
4103         FAILED(buf[3] != 0x9dc849b, "test42 case 4 failed\n");
4104         FAILED(buf[4] != -0x7c69a35, "test42 case 5 failed\n");
4105         FAILED(buf[5] != 0x5a4d0c4, "test42 case 6 failed\n");
4106         FAILED(buf[6] != 0x9a3b06d, "test42 case 7 failed\n");
4107
4108 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
4109         FAILED(buf[7] != SLJIT_W(-4388959407985636971), "test42 case 8 failed\n");
4110         FAILED(buf[8] != SLJIT_W(2901680654366567099), "test42 case 9 failed\n");
4111         FAILED(buf[9] != SLJIT_W(-4388959407985636971), "test42 case 10 failed\n");
4112         FAILED(buf[10] != SLJIT_W(-1677173957268872740), "test42 case 11 failed\n");
4113         FAILED(buf[11] != SLJIT_W(2), "test42 case 12 failed\n");
4114         FAILED(buf[12] != SLJIT_W(2532236178951865933), "test42 case 13 failed\n");
4115         FAILED(buf[13] != SLJIT_W(-1), "test42 case 14 failed\n");
4116         FAILED(buf[14] != SLJIT_W(-2177944059851366166), "test42 case 15 failed\n");
4117 #else
4118         FAILED(buf[7] != -1587000939, "test42 case 8 failed\n");
4119         FAILED(buf[8] != 665003983, "test42 case 9 failed\n");
4120         FAILED(buf[9] != -1587000939, "test42 case 10 failed\n");
4121         FAILED(buf[10] != -353198352, "test42 case 11 failed\n");
4122         FAILED(buf[11] != 2, "test42 case 12 failed\n");
4123         FAILED(buf[12] != 768706125, "test42 case 13 failed\n");
4124         FAILED(buf[13] != -1, "test42 case 14 failed\n");
4125         FAILED(buf[14] != -471654166, "test42 case 15 failed\n");
4126 #endif
4127
4128         FAILED(buf[15] != 56, "test42 case 16 failed\n");
4129         FAILED(buf[16] != 58392872, "test42 case 17 failed\n");
4130         FAILED(buf[17] != -47, "test42 case 18 failed\n");
4131         FAILED(buf[18] != 35949148, "test42 case 19 failed\n");
4132
4133 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
4134         FAILED(buf[19] != SLJIT_W(0x3340bfc), "test42 case 20 failed\n");
4135         FAILED(buf[20] != SLJIT_W(0x3d4af2c543), "test42 case 21 failed\n");
4136         FAILED(buf[21] != SLJIT_W(-0xaf978), "test42 case 22 failed\n");
4137         FAILED(buf[22] != SLJIT_W(0xa64ae42b7d6), "test42 case 23 failed\n");
4138 #else
4139         FAILED(buf[19] != SLJIT_W(0xda5), "test42 case 20 failed\n");
4140         FAILED(buf[20] != SLJIT_W(0xb86d0), "test42 case 21 failed\n");
4141         FAILED(buf[21] != SLJIT_W(-0x6b6e), "test42 case 22 failed\n");
4142         FAILED(buf[22] != SLJIT_W(0xd357), "test42 case 23 failed\n");
4143 #endif
4144
4145         FAILED(buf[23] != 0x0, "test42 case 24 failed\n");
4146         FAILED(buf[24] != (sljit_sw)0xf2906b14, "test42 case 25 failed\n");
4147         FAILED(buf[25] != -0x8, "test42 case 26 failed\n");
4148         FAILED(buf[26] != -0xa63c923, "test42 case 27 failed\n");
4149
4150         sljit_free_code(code.code, NULL);
4151         successful_tests++;
4152 }
4153
4154 static void test43(void)
4155 {
4156         /* Test floating point compare. */
4157         executable_code code;
4158         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
4159         struct sljit_jump* jump;
4160
4161         union {
4162                 sljit_f64 value;
4163                 struct {
4164                         sljit_u32 value1;
4165                         sljit_u32 value2;
4166                 } u;
4167         } dbuf[4];
4168
4169         if (verbose)
4170                 printf("Run test43\n");
4171
4172         if (!sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
4173                 if (verbose)
4174                         printf("no fpu available, test43 skipped\n");
4175                 successful_tests++;
4176                 if (compiler)
4177                         sljit_free_compiler(compiler);
4178                 return;
4179         }
4180
4181         FAILED(!compiler, "cannot create compiler\n");
4182
4183         dbuf[0].value = 12.125;
4184         /* a NaN */
4185         dbuf[1].u.value1 = 0x7fffffff;
4186         dbuf[1].u.value2 = 0x7fffffff;
4187         dbuf[2].value = -13.5;
4188         dbuf[3].value = 12.125;
4189
4190         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(W, P), 1, 1, 3, 0, 0);
4191         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 2);
4192         /* dbuf[0] < dbuf[2] -> -2 */
4193         jump = sljit_emit_fcmp(compiler, SLJIT_F_GREATER_EQUAL, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_MEM2(SLJIT_S0, SLJIT_R0), SLJIT_F64_SHIFT);
4194         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_IMM, -2);
4195
4196         sljit_set_label(jump, sljit_emit_label(compiler));
4197         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S0), 0);
4198         /* dbuf[0] and dbuf[1] is not NaN -> 5 */
4199         jump = sljit_emit_fcmp(compiler, SLJIT_UNORDERED, SLJIT_MEM0(), (sljit_sw)&dbuf[1], SLJIT_FR1, 0);
4200         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_IMM, 5);
4201
4202         sljit_set_label(jump, sljit_emit_label(compiler));
4203         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_f64));
4204         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, 11);
4205         /* dbuf[0] == dbuf[3] -> 11 */
4206         jump = sljit_emit_fcmp(compiler, SLJIT_F_EQUAL, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_FR2, 0);
4207
4208         /* else -> -17 */
4209         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, -17);
4210         sljit_set_label(jump, sljit_emit_label(compiler));
4211         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);
4212
4213         code.code = sljit_generate_code(compiler);
4214         CHECK(compiler);
4215         sljit_free_compiler(compiler);
4216
4217         FAILED(code.func1((sljit_sw)&dbuf) != 11, "test43 case 1 failed\n");
4218         dbuf[3].value = 12;
4219         FAILED(code.func1((sljit_sw)&dbuf) != -17, "test43 case 2 failed\n");
4220         dbuf[1].value = 0;
4221         FAILED(code.func1((sljit_sw)&dbuf) != 5, "test43 case 3 failed\n");
4222         dbuf[2].value = 20;
4223         FAILED(code.func1((sljit_sw)&dbuf) != -2, "test43 case 4 failed\n");
4224
4225         sljit_free_code(code.code, NULL);
4226         successful_tests++;
4227 }
4228
4229 static void test44(void)
4230 {
4231         /* Test mov. */
4232         executable_code code;
4233         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
4234         void *buf[5];
4235
4236         if (verbose)
4237                 printf("Run test44\n");
4238
4239         FAILED(!compiler, "cannot create compiler\n");
4240
4241         buf[0] = buf + 2;
4242         buf[1] = NULL;
4243         buf[2] = NULL;
4244         buf[3] = NULL;
4245         buf[4] = NULL;
4246         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(P, P), 3, 2, 0, 0, 0);
4247
4248         sljit_emit_op1(compiler, SLJIT_MOV_P, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), 0);
4249         sljit_emit_op1(compiler, SLJIT_MOV_P, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_p), SLJIT_R0, 0);
4250         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, sizeof(sljit_p));
4251         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 2);
4252         sljit_emit_op1(compiler, SLJIT_MOV_P, SLJIT_MEM2(SLJIT_S0, SLJIT_R1), SLJIT_POINTER_SHIFT, SLJIT_R0, 0);
4253         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, sizeof(sljit_p));
4254         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 3 << SLJIT_POINTER_SHIFT);
4255         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_S0, 0);
4256         sljit_emit_op1(compiler, SLJIT_MOV_P, SLJIT_MEM2(SLJIT_R2, SLJIT_R1), 0, SLJIT_R0, 0);
4257         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 2 * sizeof(sljit_p));
4258         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 1 << SLJIT_POINTER_SHIFT);
4259         sljit_emit_op1(compiler, SLJIT_MOV_P, SLJIT_MEM2(SLJIT_R2, SLJIT_R1), 2, SLJIT_R0, 0);
4260
4261         sljit_emit_return(compiler, SLJIT_MOV_P, SLJIT_R0, 0);
4262
4263         code.code = sljit_generate_code(compiler);
4264         CHECK(compiler);
4265         sljit_free_compiler(compiler);
4266
4267         FAILED(code.func1((sljit_sw)&buf) != (sljit_sw)(buf + 2), "test44 case 1 failed\n");
4268         FAILED(buf[1] != buf + 2, "test44 case 2 failed\n");
4269         FAILED(buf[2] != buf + 3, "test44 case 3 failed\n");
4270         FAILED(buf[3] != buf + 4, "test44 case 4 failed\n");
4271         FAILED(buf[4] != buf + 2, "test44 case 5 failed\n");
4272
4273         sljit_free_code(code.code, NULL);
4274         successful_tests++;
4275 }
4276
4277 static void test45(void)
4278 {
4279         /* Test single precision floating point. */
4280
4281         executable_code code;
4282         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
4283         sljit_f32 buf[12];
4284         sljit_sw buf2[6];
4285         struct sljit_jump* jump;
4286
4287         if (verbose)
4288                 printf("Run test45\n");
4289
4290         if (!sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
4291                 if (verbose)
4292                         printf("no fpu available, test45 skipped\n");
4293                 successful_tests++;
4294                 if (compiler)
4295                         sljit_free_compiler(compiler);
4296                 return;
4297         }
4298
4299         FAILED(!compiler, "cannot create compiler\n");
4300
4301         buf[0] = 5.5;
4302         buf[1] = -7.25;
4303         buf[2] = 0;
4304         buf[3] = 0;
4305         buf[4] = 0;
4306         buf[5] = 0;
4307         buf[6] = 0;
4308         buf[7] = 8.75;
4309         buf[8] = 0;
4310         buf[9] = 16.5;
4311         buf[10] = 0;
4312         buf[11] = 0;
4313
4314         buf2[0] = -1;
4315         buf2[1] = -1;
4316         buf2[2] = -1;
4317         buf2[3] = -1;
4318         buf2[4] = -1;
4319         buf2[5] = -1;
4320
4321         sljit_emit_enter(compiler, 0, SLJIT_ARGS2(VOID, P, P), 3, 2, 6, 0, 0);
4322
4323         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S0), 0);
4324         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR5, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f32));
4325         sljit_emit_fop1(compiler, SLJIT_NEG_F32, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_f32), SLJIT_FR0, 0);
4326         sljit_emit_fop1(compiler, SLJIT_ABS_F32, SLJIT_FR1, 0, SLJIT_FR5, 0);
4327         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_f32), SLJIT_FR1, 0);
4328         sljit_emit_fop1(compiler, SLJIT_ABS_F32, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_f32), SLJIT_FR5, 0);
4329         sljit_emit_fop1(compiler, SLJIT_NEG_F32, SLJIT_FR4, 0, SLJIT_MEM1(SLJIT_S0), 0);
4330         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_f32), SLJIT_FR4, 0);
4331
4332         sljit_emit_fop2(compiler, SLJIT_ADD_F32, SLJIT_FR0, 0, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f32));
4333         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_f32), SLJIT_FR0, 0);
4334         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);
4335         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S0), 0);
4336         sljit_emit_fop2(compiler, SLJIT_MUL_F32, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_f32), SLJIT_FR0, 0, SLJIT_FR0, 0);
4337         sljit_emit_fop2(compiler, SLJIT_DIV_F32, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S0), 9 * sizeof(sljit_f32), SLJIT_FR0, 0);
4338         sljit_emit_fop1(compiler, SLJIT_ABS_F32, SLJIT_MEM1(SLJIT_S0), 9 * sizeof(sljit_f32), SLJIT_FR2, 0);
4339         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R0, 0, SLJIT_S0, 0, SLJIT_IMM, 0x3d0ac);
4340         sljit_emit_fop1(compiler, SLJIT_NEG_F32, SLJIT_MEM1(SLJIT_S0), 10 * sizeof(sljit_f32), SLJIT_MEM1(SLJIT_R0), 0x3d0ac);
4341         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_S0, 0, SLJIT_IMM, 0x3d0ac + sizeof(sljit_f32));
4342         sljit_emit_fop1(compiler, SLJIT_ABS_F32, SLJIT_MEM1(SLJIT_S0), 11 * sizeof(sljit_f32), SLJIT_MEM1(SLJIT_R0), -0x3d0ac);
4343
4344         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S0), 0);
4345         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f32));
4346         sljit_emit_fop1(compiler, SLJIT_CMP_F32 | SLJIT_SET_F_EQUAL, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S0), 0);
4347         cond_set(compiler, SLJIT_MEM1(SLJIT_S1), 0, SLJIT_F_EQUAL);
4348         sljit_emit_fop1(compiler, SLJIT_CMP_F32 | SLJIT_SET_F_LESS, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S0), 0);
4349         cond_set(compiler, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_sw), SLJIT_F_LESS);
4350         sljit_emit_fop1(compiler, SLJIT_CMP_F32 | SLJIT_SET_F_EQUAL, SLJIT_FR1, 0, SLJIT_FR2, 0);
4351         cond_set(compiler, SLJIT_MEM1(SLJIT_S1), 2 * sizeof(sljit_sw), SLJIT_F_EQUAL);
4352         sljit_emit_fop1(compiler, SLJIT_CMP_F32 | SLJIT_SET_F_GREATER_EQUAL, SLJIT_FR1, 0, SLJIT_FR2, 0);
4353         cond_set(compiler, SLJIT_MEM1(SLJIT_S1), 3 * sizeof(sljit_sw), SLJIT_F_GREATER_EQUAL);
4354
4355         jump = sljit_emit_fcmp(compiler, SLJIT_F_LESS_EQUAL | SLJIT_32, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f32));
4356         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S1), 4 * sizeof(sljit_sw), SLJIT_IMM, 7);
4357         sljit_set_label(jump, sljit_emit_label(compiler));
4358
4359         jump = sljit_emit_fcmp(compiler, SLJIT_F_GREATER | SLJIT_32, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_FR2, 0);
4360         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S1), 5 * sizeof(sljit_sw), SLJIT_IMM, 6);
4361         sljit_set_label(jump, sljit_emit_label(compiler));
4362
4363         sljit_emit_return_void(compiler);
4364
4365         code.code = sljit_generate_code(compiler);
4366         CHECK(compiler);
4367         sljit_free_compiler(compiler);
4368
4369         code.func2((sljit_sw)&buf, (sljit_sw)&buf2);
4370         FAILED(buf[2] != -5.5, "test45 case 1 failed\n");
4371         FAILED(buf[3] != 7.25, "test45 case 2 failed\n");
4372         FAILED(buf[4] != 7.25, "test45 case 3 failed\n");
4373         FAILED(buf[5] != -5.5, "test45 case 4 failed\n");
4374         FAILED(buf[6] != -1.75, "test45 case 5 failed\n");
4375         FAILED(buf[7] != 16.0, "test45 case 6 failed\n");
4376         FAILED(buf[8] != 30.25, "test45 case 7 failed\n");
4377         FAILED(buf[9] != 3, "test45 case 8 failed\n");
4378         FAILED(buf[10] != -5.5, "test45 case 9 failed\n");
4379         FAILED(buf[11] != 7.25, "test45 case 10 failed\n");
4380         FAILED(buf2[0] != 1, "test45 case 11 failed\n");
4381         FAILED(buf2[1] != 2, "test45 case 12 failed\n");
4382         FAILED(buf2[2] != 2, "test45 case 13 failed\n");
4383         FAILED(buf2[3] != 1, "test45 case 14 failed\n");
4384         FAILED(buf2[4] != 7, "test45 case 15 failed\n");
4385         FAILED(buf2[5] != -1, "test45 case 16 failed\n");
4386
4387         sljit_free_code(code.code, NULL);
4388         successful_tests++;
4389 }
4390
4391 static void test46(void)
4392 {
4393         /* Test sljit_emit_op_flags with 32 bit operations. */
4394
4395         executable_code code;
4396         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
4397         sljit_s32 buf[24];
4398         sljit_sw buf2[6];
4399         sljit_s32 i;
4400
4401         if (verbose)
4402                 printf("Run test46\n");
4403
4404         for (i = 0; i < 24; ++i)
4405                 buf[i] = -17;
4406         buf[16] = 0;
4407         for (i = 0; i < 6; ++i)
4408                 buf2[i] = -13;
4409         buf2[4] = -124;
4410
4411         sljit_emit_enter(compiler, 0, SLJIT_ARGS2(VOID, P, P), 3, 3, 0, 0, 0);
4412
4413         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, -7);
4414         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_Z | SLJIT_SET_LESS, SLJIT_R2, 0, SLJIT_IMM, 13);
4415         sljit_emit_op_flags(compiler, SLJIT_MOV32, SLJIT_MEM0(), (sljit_sw)&buf, SLJIT_LESS);
4416         sljit_emit_op_flags(compiler, SLJIT_AND32, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_s32), SLJIT_NOT_ZERO);
4417
4418         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_Z, SLJIT_R2, 0, SLJIT_IMM, -7);
4419         sljit_emit_op_flags(compiler, SLJIT_AND32 | SLJIT_SET_Z, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_s32), SLJIT_EQUAL);
4420         sljit_emit_op_flags(compiler, SLJIT_AND32, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_s32), SLJIT_NOT_EQUAL);
4421         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0x1235);
4422         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_Z, SLJIT_R0, 0, SLJIT_IMM, 0x1235);
4423         sljit_emit_op_flags(compiler, SLJIT_AND32 | SLJIT_SET_Z, SLJIT_R0, 0, SLJIT_ZERO);
4424         sljit_emit_op_flags(compiler, SLJIT_AND32, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_s32), SLJIT_ZERO);
4425         sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_MEM1(SLJIT_S0), 10 * sizeof(sljit_s32), SLJIT_R0, 0);
4426
4427         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_Z, SLJIT_R2, 0, SLJIT_IMM, -7);
4428         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 12);
4429         sljit_emit_op_flags(compiler, SLJIT_MOV32, SLJIT_MEM2(SLJIT_S0, SLJIT_R0), 2, SLJIT_EQUAL);
4430         sljit_emit_op_flags(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_EQUAL);
4431         sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_MEM1(SLJIT_S0), 14 * sizeof(sljit_s32), SLJIT_R0, 0);
4432         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 16);
4433         sljit_emit_op_flags(compiler, SLJIT_AND32 | SLJIT_SET_Z, SLJIT_MEM2(SLJIT_S0, SLJIT_R0), 2, SLJIT_EQUAL);
4434         sljit_emit_op_flags(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_S0), 18 * sizeof(sljit_s32), SLJIT_NOT_EQUAL);
4435
4436         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_Z, SLJIT_R2, 0, SLJIT_IMM, -7);
4437         sljit_emit_op_flags(compiler, SLJIT_XOR32 | SLJIT_SET_Z, SLJIT_MEM1(SLJIT_S0), 20 * sizeof(sljit_s32), SLJIT_ZERO);
4438         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 39);
4439         sljit_emit_op_flags(compiler, SLJIT_XOR32, SLJIT_R0, 0, SLJIT_NOT_ZERO);
4440         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_S0), 22 * sizeof(sljit_s32), SLJIT_R0, 0);
4441
4442         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_GREATER, SLJIT_R2, 0, SLJIT_IMM, -7);
4443         sljit_emit_op_flags(compiler, SLJIT_AND, SLJIT_MEM0(), (sljit_sw)&buf2, SLJIT_GREATER);
4444         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_SIG_LESS, SLJIT_R2, 0, SLJIT_IMM, 5);
4445         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 1);
4446         sljit_emit_op_flags(compiler, SLJIT_AND | SLJIT_SET_Z, SLJIT_MEM2(SLJIT_S1, SLJIT_R0), SLJIT_WORD_SHIFT, SLJIT_SIG_LESS);
4447         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 2);
4448         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_Z | SLJIT_SET_LESS, SLJIT_R2, 0, SLJIT_IMM, 5);
4449         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM2(SLJIT_S1, SLJIT_R0), SLJIT_WORD_SHIFT, SLJIT_LESS);
4450         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_NOT_EQUAL);
4451         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_SIG_LESS, SLJIT_R2, 0, SLJIT_IMM, 5);
4452         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S1), 3 * sizeof(sljit_sw), SLJIT_S2, 0);
4453         sljit_emit_op_flags(compiler, SLJIT_AND | SLJIT_SET_Z, SLJIT_MEM2(SLJIT_S1, SLJIT_R0), SLJIT_WORD_SHIFT, SLJIT_SIG_LESS);
4454         sljit_emit_op_flags(compiler, SLJIT_OR, SLJIT_MEM1(SLJIT_S1), 4 * sizeof(sljit_sw), SLJIT_ZERO);
4455         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_GREATER, SLJIT_R2, 0, SLJIT_IMM, 0);
4456         sljit_emit_op_flags(compiler, SLJIT_XOR, SLJIT_MEM1(SLJIT_S1), 5 * sizeof(sljit_sw), SLJIT_GREATER);
4457
4458         sljit_emit_return_void(compiler);
4459
4460         code.code = sljit_generate_code(compiler);
4461         CHECK(compiler);
4462         sljit_free_compiler(compiler);
4463
4464         code.func2((sljit_sw)&buf, (sljit_sw)&buf2);
4465         FAILED(buf[0] != 0, "test46 case 1 failed\n");
4466         FAILED(buf[1] != -17, "test46 case 2 failed\n");
4467         FAILED(buf[2] != 1, "test46 case 3 failed\n");
4468         FAILED(buf[3] != -17, "test46 case 4 failed\n");
4469         FAILED(buf[4] != 1, "test46 case 5 failed\n");
4470         FAILED(buf[5] != -17, "test46 case 6 failed\n");
4471         FAILED(buf[6] != 1, "test46 case 7 failed\n");
4472         FAILED(buf[7] != -17, "test46 case 8 failed\n");
4473         FAILED(buf[8] != 0, "test46 case 9 failed\n");
4474         FAILED(buf[9] != -17, "test46 case 10 failed\n");
4475         FAILED(buf[10] != 1, "test46 case 11 failed\n");
4476         FAILED(buf[11] != -17, "test46 case 12 failed\n");
4477         FAILED(buf[12] != 1, "test46 case 13 failed\n");
4478         FAILED(buf[13] != -17, "test46 case 14 failed\n");
4479         FAILED(buf[14] != 1, "test46 case 15 failed\n");
4480         FAILED(buf[15] != -17, "test46 case 16 failed\n");
4481         FAILED(buf[16] != 0, "test46 case 17 failed\n");
4482         FAILED(buf[17] != -17, "test46 case 18 failed\n");
4483         FAILED(buf[18] != 0, "test46 case 19 failed\n");
4484         FAILED(buf[19] != -17, "test46 case 20 failed\n");
4485         FAILED(buf[20] != -18, "test46 case 21 failed\n");
4486         FAILED(buf[21] != -17, "test46 case 22 failed\n");
4487         FAILED(buf[22] != 38, "test46 case 23 failed\n");
4488         FAILED(buf[23] != -17, "test46 case 24 failed\n");
4489
4490         FAILED(buf2[0] != 0, "test46 case 25 failed\n");
4491         FAILED(buf2[1] != 1, "test46 case 26 failed\n");
4492         FAILED(buf2[2] != 0, "test46 case 27 failed\n");
4493         FAILED(buf2[3] != 1, "test46 case 28 failed\n");
4494         FAILED(buf2[4] != -123, "test46 case 29 failed\n");
4495         FAILED(buf2[5] != -14, "test46 case 30 failed\n");
4496
4497         sljit_free_code(code.code, NULL);
4498         successful_tests++;
4499 }
4500
4501 static void test47(void)
4502 {
4503         /* Test jump optimizations. */
4504         executable_code code;
4505         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
4506         sljit_sw buf[3];
4507
4508         if (verbose)
4509                 printf("Run test47\n");
4510
4511         FAILED(!compiler, "cannot create compiler\n");
4512         buf[0] = 0;
4513         buf[1] = 0;
4514         buf[2] = 0;
4515
4516         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(W, P), 3, 1, 0, 0, 0);
4517         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0x3a5c6f);
4518         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_LESS, SLJIT_R0, 0, SLJIT_IMM, 3);
4519         sljit_set_target(sljit_emit_jump(compiler, SLJIT_LESS), 0x11223344);
4520         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0);
4521         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0xd37c10);
4522 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
4523         sljit_set_target(sljit_emit_jump(compiler, SLJIT_LESS), SLJIT_W(0x112233445566));
4524 #endif
4525         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_R0, 0);
4526         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0x59b48e);
4527 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
4528         sljit_set_target(sljit_emit_jump(compiler, SLJIT_LESS), SLJIT_W(0x1122334455667788));
4529 #endif
4530         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_R0, 0);
4531         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);
4532
4533         code.code = sljit_generate_code(compiler);
4534         CHECK(compiler);
4535         sljit_free_compiler(compiler);
4536
4537         FAILED(code.func1((sljit_sw)&buf) != 0x59b48e, "test47 case 1 failed\n");
4538         FAILED(buf[0] != 0x3a5c6f, "test47 case 2 failed\n");
4539         FAILED(buf[1] != 0xd37c10, "test47 case 3 failed\n");
4540         FAILED(buf[2] != 0x59b48e, "test47 case 4 failed\n");
4541
4542         sljit_free_code(code.code, NULL);
4543         successful_tests++;
4544 }
4545
4546 static void test48(void)
4547 {
4548         /* Test floating point conversions. */
4549         executable_code code;
4550         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
4551         int i;
4552         sljit_f64 dbuf[10];
4553         sljit_f32 sbuf[10];
4554         sljit_sw wbuf[10];
4555         sljit_s32 ibuf[10];
4556
4557         if (verbose)
4558                 printf("Run test48\n");
4559
4560         if (!sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
4561                 if (verbose)
4562                         printf("no fpu available, test48 skipped\n");
4563                 successful_tests++;
4564                 if (compiler)
4565                         sljit_free_compiler(compiler);
4566                 return;
4567         }
4568
4569         FAILED(!compiler, "cannot create compiler\n");
4570         for (i = 0; i < 10; i++) {
4571                 dbuf[i] = 0.0;
4572                 sbuf[i] = 0.0;
4573                 wbuf[i] = 0;
4574                 ibuf[i] = 0;
4575         }
4576
4577         dbuf[0] = 123.5;
4578         dbuf[1] = -367;
4579         dbuf[2] = 917.75;
4580
4581         sbuf[0] = 476.25;
4582         sbuf[1] = -1689.75;
4583
4584         wbuf[0] = 2345;
4585
4586         ibuf[0] = 312;
4587         ibuf[1] = -9324;
4588
4589         sljit_emit_enter(compiler, 0, SLJIT_ARGS0(VOID), 3, 3, 6, 0, 0);
4590         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, (sljit_sw)&dbuf);
4591         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_IMM, (sljit_sw)&sbuf);
4592         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, (sljit_sw)&wbuf);
4593         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, (sljit_sw)&ibuf);
4594
4595         /* sbuf[2] */
4596         sljit_emit_fop1(compiler, SLJIT_CONV_F32_FROM_F64, SLJIT_MEM1(SLJIT_S1), 2 * sizeof(sljit_f32), SLJIT_MEM1(SLJIT_S0), 0);
4597         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR5, 0, SLJIT_MEM1(SLJIT_S0), 0);
4598         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 3);
4599         /* sbuf[3] */
4600         sljit_emit_fop1(compiler, SLJIT_CONV_F32_FROM_F64, SLJIT_MEM2(SLJIT_S1, SLJIT_R0), SLJIT_F32_SHIFT, SLJIT_FR5, 0);
4601         sljit_emit_fop1(compiler, SLJIT_CONV_F64_FROM_F32, SLJIT_FR4, 0, SLJIT_MEM1(SLJIT_S1), 0);
4602         /* dbuf[3] */
4603         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_f64), SLJIT_FR4, 0);
4604         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR3, 0, SLJIT_MEM1(SLJIT_S1), 0);
4605         sljit_emit_fop1(compiler, SLJIT_CONV_F64_FROM_F32, SLJIT_FR2, 0, SLJIT_FR3, 0);
4606         /* dbuf[4] */
4607         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_f64), SLJIT_FR2, 0);
4608         /* sbuf[4] */
4609         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_S1), 4 * sizeof(sljit_f32), SLJIT_FR3, 0);
4610
4611         /* wbuf[1] */
4612         sljit_emit_fop1(compiler, SLJIT_CONV_SW_FROM_F64, SLJIT_MEM1(SLJIT_S2), sizeof(sljit_sw), SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64));
4613         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 2);
4614         sljit_emit_fop1(compiler, SLJIT_CONV_SW_FROM_F64, SLJIT_R0, 0, SLJIT_MEM2(SLJIT_S0, SLJIT_R0), SLJIT_F64_SHIFT);
4615         /* wbuf[2] */
4616         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S2), 2 * sizeof(sljit_sw), SLJIT_R0, 0);
4617         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR5, 0, SLJIT_MEM1(SLJIT_S1), 0);
4618         /* wbuf[3] */
4619         sljit_emit_fop1(compiler, SLJIT_CONV_SW_FROM_F32, SLJIT_MEM1(SLJIT_S2), 3 * sizeof(sljit_sw), SLJIT_FR5, 0);
4620         sljit_emit_fop1(compiler, SLJIT_NEG_F32, SLJIT_FR0, 0, SLJIT_FR5, 0);
4621         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 4);
4622         /* wbuf[4] */
4623         sljit_emit_fop1(compiler, SLJIT_CONV_SW_FROM_F32, SLJIT_MEM2(SLJIT_S2, SLJIT_R1), SLJIT_WORD_SHIFT, SLJIT_FR0, 0);
4624         sljit_emit_fop1(compiler, SLJIT_NEG_F64, SLJIT_FR4, 0, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_f64));
4625         /* ibuf[2] */
4626         sljit_emit_fop1(compiler, SLJIT_CONV_S32_FROM_F64, SLJIT_MEM1(SLJIT_R2), 2 * sizeof(sljit_s32), SLJIT_FR4, 0);
4627         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_f32));
4628         sljit_emit_fop1(compiler, SLJIT_CONV_S32_FROM_F32, SLJIT_R0, 0, SLJIT_FR1, 0);
4629         /* ibuf[3] */
4630         sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_MEM1(SLJIT_R2), 3 * sizeof(sljit_s32), SLJIT_R0, 0);
4631
4632         /* dbuf[5] */
4633         sljit_emit_fop1(compiler, SLJIT_CONV_F64_FROM_SW, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_f64), SLJIT_MEM1(SLJIT_S2), 0);
4634         sljit_emit_fop1(compiler, SLJIT_CONV_F64_FROM_SW, SLJIT_FR2, 0, SLJIT_IMM, -6213);
4635         /* dbuf[6] */
4636         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_f64), SLJIT_FR2, 0);
4637         /* dbuf[7] */
4638         sljit_emit_fop1(compiler, SLJIT_CONV_F64_FROM_S32, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_f64), SLJIT_MEM0(), (sljit_sw)&ibuf[0]);
4639         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_R2), sizeof(sljit_s32));
4640         sljit_emit_fop1(compiler, SLJIT_CONV_F64_FROM_S32, SLJIT_FR1, 0, SLJIT_R0, 0);
4641         /* dbuf[8] */
4642         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_f64), SLJIT_FR1, 0);
4643         /* dbuf[9] */
4644         sljit_emit_fop1(compiler, SLJIT_CONV_F64_FROM_SW, SLJIT_MEM0(), (sljit_sw)(dbuf + 9), SLJIT_IMM, -77);
4645         /* sbuf[5] */
4646         sljit_emit_fop1(compiler, SLJIT_CONV_F32_FROM_SW, SLJIT_MEM1(SLJIT_S1), 5 * sizeof(sljit_f32), SLJIT_IMM, -123);
4647         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 7190);
4648         sljit_emit_fop1(compiler, SLJIT_CONV_F32_FROM_SW, SLJIT_FR3, 0, SLJIT_R0, 0);
4649         /* sbuf[6] */
4650         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_S1), 6 * sizeof(sljit_f32), SLJIT_FR3, 0);
4651         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 123);
4652         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R1, 0, SLJIT_R2, 0, SLJIT_IMM, 123 * sizeof(sljit_s32));
4653         sljit_emit_fop1(compiler, SLJIT_CONV_F32_FROM_S32, SLJIT_FR1, 0, SLJIT_MEM2(SLJIT_R1, SLJIT_R0), 2);
4654         /* sbuf[7] */
4655         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_S1), 7 * sizeof(sljit_f32), SLJIT_FR1, 0);
4656         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 8);
4657         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, 3812);
4658         /* sbuf[8] */
4659         sljit_emit_fop1(compiler, SLJIT_CONV_F32_FROM_S32, SLJIT_MEM2(SLJIT_S1, SLJIT_R0), SLJIT_F32_SHIFT, SLJIT_R1, 0);
4660         /* sbuf[9] */
4661         sljit_emit_fop1(compiler, SLJIT_CONV_F32_FROM_SW, SLJIT_MEM0(), (sljit_sw)(sbuf + 9), SLJIT_IMM, -79);
4662
4663         sljit_emit_return_void(compiler);
4664
4665         code.code = sljit_generate_code(compiler);
4666         CHECK(compiler);
4667         sljit_free_compiler(compiler);
4668
4669         code.func0();
4670         FAILED(dbuf[3] != 476.25, "test48 case 1 failed\n");
4671         FAILED(dbuf[4] != 476.25, "test48 case 2 failed\n");
4672         FAILED(dbuf[5] != 2345.0, "test48 case 3 failed\n");
4673         FAILED(dbuf[6] != -6213.0, "test48 case 4 failed\n");
4674         FAILED(dbuf[7] != 312.0, "test48 case 5 failed\n");
4675         FAILED(dbuf[8] != -9324.0, "test48 case 6 failed\n");
4676         FAILED(dbuf[9] != -77.0, "test48 case 7 failed\n");
4677
4678         FAILED(sbuf[2] != 123.5, "test48 case 8 failed\n");
4679         FAILED(sbuf[3] != 123.5, "test48 case 9 failed\n");
4680         FAILED(sbuf[4] != 476.25, "test48 case 10 failed\n");
4681         FAILED(sbuf[5] != -123, "test48 case 11 failed\n");
4682         FAILED(sbuf[6] != 7190, "test48 case 12 failed\n");
4683         FAILED(sbuf[7] != 312, "test48 case 13 failed\n");
4684         FAILED(sbuf[8] != 3812, "test48 case 14 failed\n");
4685         FAILED(sbuf[9] != -79.0, "test48 case 15 failed\n");
4686
4687         FAILED(wbuf[1] != -367, "test48 case 16 failed\n");
4688         FAILED(wbuf[2] != 917, "test48 case 17 failed\n");
4689         FAILED(wbuf[3] != 476, "test48 case 18 failed\n");
4690         FAILED(wbuf[4] != -476, "test48 case 19 failed\n");
4691
4692         FAILED(ibuf[2] != -917, "test48 case 20 failed\n");
4693         FAILED(ibuf[3] != -1689, "test48 case 21 failed\n");
4694
4695         sljit_free_code(code.code, NULL);
4696         successful_tests++;
4697 }
4698
4699 static void test49(void)
4700 {
4701         /* Test floating point conversions. */
4702         executable_code code;
4703         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
4704         int i;
4705         sljit_f64 dbuf[10];
4706         sljit_f32 sbuf[9];
4707         sljit_sw wbuf[9];
4708         sljit_s32 ibuf[9];
4709         sljit_s32* dbuf_ptr = (sljit_s32*)dbuf;
4710         sljit_s32* sbuf_ptr = (sljit_s32*)sbuf;
4711
4712         if (verbose)
4713                 printf("Run test49\n");
4714
4715         if (!sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
4716                 if (verbose)
4717                         printf("no fpu available, test49 skipped\n");
4718                 successful_tests++;
4719                 if (compiler)
4720                         sljit_free_compiler(compiler);
4721                 return;
4722         }
4723
4724         FAILED(!compiler, "cannot create compiler\n");
4725
4726         for (i = 0; i < 9; i++) {
4727                 dbuf_ptr[i << 1] = -1;
4728                 dbuf_ptr[(i << 1) + 1] = -1;
4729                 sbuf_ptr[i] = -1;
4730                 wbuf[i] = -1;
4731                 ibuf[i] = -1;
4732         }
4733
4734 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
4735         dbuf[9] = (sljit_f64)SLJIT_W(0x1122334455);
4736 #endif
4737         dbuf[0] = 673.75;
4738         sbuf[0] = -879.75;
4739         wbuf[0] = 345;
4740         ibuf[0] = -249;
4741
4742         sljit_emit_enter(compiler, 0, SLJIT_ARGS0(VOID), 3, 3, 3, 0, 0);
4743         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, (sljit_sw)&dbuf);
4744         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_IMM, (sljit_sw)&sbuf);
4745         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, (sljit_sw)&wbuf);
4746         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, (sljit_sw)&ibuf);
4747
4748         /* dbuf[2] */
4749         sljit_emit_fop1(compiler, SLJIT_CONV_F64_FROM_F32, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_f64), SLJIT_MEM1(SLJIT_S1), 0);
4750         /* sbuf[2] */
4751         sljit_emit_fop1(compiler, SLJIT_CONV_F32_FROM_F64, SLJIT_MEM1(SLJIT_S1), 2 * sizeof(sljit_f32), SLJIT_MEM1(SLJIT_S0), 0);
4752         /* wbuf[2] */
4753         sljit_emit_fop1(compiler, SLJIT_CONV_SW_FROM_F64, SLJIT_MEM1(SLJIT_S2), 2 * sizeof(sljit_sw), SLJIT_MEM1(SLJIT_S0), 0);
4754         /* wbuf[4] */
4755         sljit_emit_fop1(compiler, SLJIT_CONV_SW_FROM_F32, SLJIT_MEM1(SLJIT_S2), 4 * sizeof(sljit_sw), SLJIT_MEM1(SLJIT_S1), 0);
4756         /* ibuf[2] */
4757         sljit_emit_fop1(compiler, SLJIT_CONV_S32_FROM_F64, SLJIT_MEM1(SLJIT_R2), 2 * sizeof(sljit_s32), SLJIT_MEM1(SLJIT_S0), 0);
4758         /* ibuf[4] */
4759         sljit_emit_fop1(compiler, SLJIT_CONV_S32_FROM_F32, SLJIT_MEM1(SLJIT_R2), 4 * sizeof(sljit_s32), SLJIT_MEM1(SLJIT_S1), 0);
4760         /* dbuf[4] */
4761         sljit_emit_fop1(compiler, SLJIT_CONV_F64_FROM_SW, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_f64), SLJIT_MEM1(SLJIT_S2), 0);
4762         /* sbuf[4] */
4763         sljit_emit_fop1(compiler, SLJIT_CONV_F32_FROM_SW, SLJIT_MEM1(SLJIT_S1), 4 * sizeof(sljit_f32), SLJIT_MEM1(SLJIT_S2), 0);
4764         /* dbuf[6] */
4765         sljit_emit_fop1(compiler, SLJIT_CONV_F64_FROM_S32, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_f64), SLJIT_MEM1(SLJIT_R2), 0);
4766         /* sbuf[6] */
4767         sljit_emit_fop1(compiler, SLJIT_CONV_F32_FROM_S32, SLJIT_MEM1(SLJIT_S1), 6 * sizeof(sljit_f32), SLJIT_MEM1(SLJIT_R2), 0);
4768
4769 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
4770         sljit_emit_fop1(compiler, SLJIT_CONV_SW_FROM_F64, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), 9 * sizeof(sljit_f64));
4771         /* wbuf[8] */
4772         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S2), 8 * sizeof(sljit_sw), SLJIT_R0, 0);
4773         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S0), 9 * sizeof(sljit_f64));
4774         sljit_emit_fop1(compiler, SLJIT_CONV_S32_FROM_F64, SLJIT_R0, 0, SLJIT_FR2, 0);
4775         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_R0, 0);
4776         sljit_emit_op2(compiler, SLJIT_AND32, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 0xffff);
4777         /* ibuf[8] */
4778         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_R2), 8 * sizeof(sljit_s32), SLJIT_R0, 0);
4779         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0x4455667788));
4780         /* dbuf[8] */
4781         sljit_emit_fop1(compiler, SLJIT_CONV_F64_FROM_SW, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_f64), SLJIT_R0, 0);
4782         /* dbuf[9] */
4783         sljit_emit_fop1(compiler, SLJIT_CONV_F64_FROM_S32, SLJIT_MEM1(SLJIT_S0), 9 * sizeof(sljit_f64), SLJIT_IMM, SLJIT_W(0x7766554433));
4784 #endif
4785
4786         sljit_emit_return_void(compiler);
4787
4788         code.code = sljit_generate_code(compiler);
4789         CHECK(compiler);
4790         sljit_free_compiler(compiler);
4791
4792         code.func0();
4793
4794         FAILED(dbuf_ptr[(1 * 2) + 0] != -1, "test49 case 1 failed\n");
4795         FAILED(dbuf_ptr[(1 * 2) + 1] != -1, "test49 case 2 failed\n");
4796         FAILED(dbuf[2] != -879.75, "test49 case 3 failed\n");
4797         FAILED(dbuf_ptr[(3 * 2) + 0] != -1, "test49 case 4 failed\n");
4798         FAILED(dbuf_ptr[(3 * 2) + 1] != -1, "test49 case 5 failed\n");
4799         FAILED(dbuf[4] != 345, "test49 case 6 failed\n");
4800         FAILED(dbuf_ptr[(5 * 2) + 0] != -1, "test49 case 7 failed\n");
4801         FAILED(dbuf_ptr[(5 * 2) + 1] != -1, "test49 case 8 failed\n");
4802         FAILED(dbuf[6] != -249, "test49 case 9 failed\n");
4803         FAILED(dbuf_ptr[(7 * 2) + 0] != -1, "test49 case 10 failed\n");
4804         FAILED(dbuf_ptr[(7 * 2) + 1] != -1, "test49 case 11 failed\n");
4805
4806         FAILED(sbuf_ptr[1] != -1, "test49 case 12 failed\n");
4807         FAILED(sbuf[2] != 673.75, "test49 case 13 failed\n");
4808         FAILED(sbuf_ptr[3] != -1, "test49 case 14 failed\n");
4809         FAILED(sbuf[4] != 345, "test49 case 15 failed\n");
4810         FAILED(sbuf_ptr[5] != -1, "test49 case 16 failed\n");
4811         FAILED(sbuf[6] != -249, "test49 case 17 failed\n");
4812         FAILED(sbuf_ptr[7] != -1, "test49 case 18 failed\n");
4813
4814         FAILED(wbuf[1] != -1, "test49 case 19 failed\n");
4815         FAILED(wbuf[2] != 673, "test49 case 20 failed\n");
4816         FAILED(wbuf[3] != -1, "test49 case 21 failed\n");
4817         FAILED(wbuf[4] != -879, "test49 case 22 failed\n");
4818         FAILED(wbuf[5] != -1, "test49 case 23 failed\n");
4819
4820         FAILED(ibuf[1] != -1, "test49 case 24 failed\n");
4821         FAILED(ibuf[2] != 673, "test49 case 25 failed\n");
4822         FAILED(ibuf[3] != -1, "test49 case 26 failed\n");
4823         FAILED(ibuf[4] != -879, "test49 case 27 failed\n");
4824         FAILED(ibuf[5] != -1, "test49 case 28 failed\n");
4825
4826 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
4827         FAILED(dbuf[8] != (sljit_f64)SLJIT_W(0x4455667788), "test49 case 29 failed\n");
4828         FAILED(dbuf[9] != (sljit_f64)SLJIT_W(0x66554433), "test49 case 30 failed\n");
4829         FAILED(wbuf[8] != SLJIT_W(0x1122334455), "test48 case 31 failed\n");
4830         FAILED(ibuf[8] == 0x4455, "test48 case 32 failed\n");
4831 #endif
4832
4833         sljit_free_code(code.code, NULL);
4834         successful_tests++;
4835 }
4836
4837 static void test50(void)
4838 {
4839         /* Test stack and floating point operations. */
4840         executable_code code;
4841         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
4842 #if !(defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86)
4843         sljit_uw size1, size2, size3;
4844         int result;
4845 #endif
4846         sljit_f32 sbuf[7];
4847
4848         if (verbose)
4849                 printf("Run test50\n");
4850
4851         if (!sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
4852                 if (verbose)
4853                         printf("no fpu available, test50 skipped\n");
4854                 successful_tests++;
4855                 if (compiler)
4856                         sljit_free_compiler(compiler);
4857                 return;
4858         }
4859
4860         FAILED(!compiler, "cannot create compiler\n");
4861
4862         sbuf[0] = 245.5;
4863         sbuf[1] = -100.25;
4864         sbuf[2] = 713.75;
4865
4866         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, P), 3, 3, 6, 0, 8 * sizeof(sljit_f32));
4867
4868         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), 0, SLJIT_MEM1(SLJIT_S0), 0);
4869         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_SP), sizeof(sljit_f32), SLJIT_MEM1(SLJIT_SP), 0);
4870         /* sbuf[3] */
4871         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_f32), SLJIT_MEM1(SLJIT_SP), sizeof(sljit_f32));
4872         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), sizeof(sljit_f32), SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f32));
4873         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));
4874         /* sbuf[4] */
4875         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_f32), SLJIT_MEM1(SLJIT_SP), 2 * sizeof(sljit_f32));
4876         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), 2 * sizeof(sljit_f32), SLJIT_IMM, 5934);
4877         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));
4878         /* sbuf[5] */
4879         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_f32), SLJIT_MEM1(SLJIT_SP), 3 * sizeof(sljit_f32));
4880
4881 #if !(defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86)
4882         size1 = compiler->size;
4883 #endif
4884         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_f32));
4885 #if !(defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86)
4886         size2 = compiler->size;
4887 #endif
4888         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR5, 0, SLJIT_FR2, 0);
4889 #if !(defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86)
4890         size3 = compiler->size;
4891 #endif
4892         /* sbuf[6] */
4893         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_f32), SLJIT_FR5, 0);
4894 #if !(defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86)
4895         result = (compiler->size - size3) == (size3 - size2) && (size3 - size2) == (size2 - size1);
4896 #endif
4897
4898         sljit_emit_return_void(compiler);
4899
4900         code.code = sljit_generate_code(compiler);
4901         CHECK(compiler);
4902         sljit_free_compiler(compiler);
4903
4904         code.func1((sljit_sw)&sbuf);
4905
4906         FAILED(sbuf[3] != 245.5, "test50 case 1 failed\n");
4907         FAILED(sbuf[4] != 145.25, "test50 case 2 failed\n");
4908         FAILED(sbuf[5] != 5934, "test50 case 3 failed\n");
4909         FAILED(sbuf[6] != 713.75, "test50 case 4 failed\n");
4910 #if !(defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86)
4911         FAILED(!result, "test50 case 5 failed\n");
4912 #endif
4913
4914         sljit_free_code(code.code, NULL);
4915         successful_tests++;
4916 }
4917
4918 static void test51(void)
4919 {
4920         /* Test all registers provided by the CPU. */
4921         executable_code code;
4922         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
4923         struct sljit_jump* jump;
4924         sljit_sw buf[2];
4925         sljit_s32 i;
4926
4927         if (verbose)
4928                 printf("Run test51\n");
4929
4930         FAILED(!compiler, "cannot create compiler\n");
4931
4932         buf[0] = 39;
4933
4934         sljit_emit_enter(compiler, 0, SLJIT_ARGS0(VOID), SLJIT_NUMBER_OF_REGISTERS, 0, 0, 0, 0);
4935
4936         for (i = 0; i < SLJIT_NUMBER_OF_REGISTERS; i++)
4937                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R(i), 0, SLJIT_IMM, 32);
4938
4939         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)buf);
4940         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0);
4941
4942         for (i = 2; i < SLJIT_NUMBER_OF_REGISTERS; i++) {
4943                 if (sljit_get_register_index(SLJIT_R(i)) >= 0) {
4944                         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R(i), 0, SLJIT_R0, 0);
4945                         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_R(i)), 0);
4946                 } else
4947                         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, buf[0]);
4948         }
4949
4950         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 32);
4951         for (i = 2; i < SLJIT_NUMBER_OF_REGISTERS; i++) {
4952                 if (sljit_get_register_index(SLJIT_R(i)) >= 0) {
4953                         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R(i), 0, SLJIT_R0, 0);
4954                         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_R(i)), 32);
4955                 } else
4956                         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, buf[0]);
4957         }
4958
4959         for (i = 2; i < SLJIT_NUMBER_OF_REGISTERS; i++) {
4960                 if (sljit_get_register_index(SLJIT_R(i)) >= 0) {
4961                         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R(i), 0, SLJIT_IMM, 32);
4962                         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_MEM2(SLJIT_R(i), SLJIT_R0), 0);
4963                         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_MEM2(SLJIT_R0, SLJIT_R(i)), 0);
4964                         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R(i), 0, SLJIT_IMM, 8);
4965                         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_MEM2(SLJIT_R0, SLJIT_R(i)), 2);
4966                 } else
4967                         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, 3 * buf[0]);
4968         }
4969
4970         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 32 + sizeof(sljit_sw), SLJIT_R1, 0);
4971
4972         sljit_emit_return_void(compiler);
4973
4974         code.code = sljit_generate_code(compiler);
4975         CHECK(compiler);
4976         sljit_free_compiler(compiler);
4977
4978         code.func0();
4979
4980         FAILED(buf[1] != (39 * 5 * (SLJIT_NUMBER_OF_REGISTERS - 2)), "test51 case 1 failed\n");
4981
4982         sljit_free_code(code.code, NULL);
4983
4984         /* Next test. */
4985
4986         compiler = sljit_create_compiler(NULL, NULL);
4987
4988         FAILED(!compiler, "cannot create compiler\n");
4989
4990         sljit_emit_enter(compiler, 0, SLJIT_ARGS0(W), SLJIT_NUMBER_OF_SCRATCH_REGISTERS, SLJIT_NUMBER_OF_SAVED_REGISTERS, 0, 0, 0);
4991
4992         for (i = 0; i < SLJIT_NUMBER_OF_REGISTERS; i++)
4993                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R(i), 0, SLJIT_IMM, 17);
4994
4995         jump = sljit_emit_call(compiler, SLJIT_CALL, SLJIT_ARGS0(W));
4996         /* SLJIT_R0 contains the first value. */
4997         for (i = 1; i < SLJIT_NUMBER_OF_REGISTERS; i++)
4998                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_R(i), 0);
4999
5000         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_R0, 0);
5001
5002         sljit_set_label(jump, sljit_emit_label(compiler));
5003         sljit_emit_enter(compiler, 0, SLJIT_ARGS0(VOID), SLJIT_NUMBER_OF_REGISTERS, 0, 0, 0, 0);
5004         for (i = 0; i < SLJIT_NUMBER_OF_REGISTERS; i++)
5005                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R(i), 0, SLJIT_IMM, 35);
5006         sljit_emit_return_void(compiler);
5007
5008         code.code = sljit_generate_code(compiler);
5009         CHECK(compiler);
5010         sljit_free_compiler(compiler);
5011
5012         FAILED(code.func0() != (SLJIT_NUMBER_OF_SCRATCH_REGISTERS * 35 + SLJIT_NUMBER_OF_SAVED_REGISTERS * 17), "test51 case 2 failed\n");
5013
5014         sljit_free_code(code.code, NULL);
5015
5016         /* Next test. */
5017
5018         compiler = sljit_create_compiler(NULL, NULL);
5019
5020         FAILED(!compiler, "cannot create compiler\n");
5021
5022         sljit_emit_enter(compiler, 0, SLJIT_ARGS0(W), SLJIT_NUMBER_OF_SCRATCH_REGISTERS, SLJIT_NUMBER_OF_SAVED_REGISTERS, 0, 0, 0);
5023
5024         for (i = 0; i < SLJIT_NUMBER_OF_SCRATCH_REGISTERS; i++)
5025                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R(i), 0, SLJIT_IMM, 68);
5026         for (i = 0; i < SLJIT_NUMBER_OF_SAVED_REGISTERS; i++)
5027                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S(i), 0, SLJIT_IMM, 68);
5028
5029         jump = sljit_emit_call(compiler, SLJIT_CALL, SLJIT_ARGS0(W));
5030         /* SLJIT_R0 contains the first value. */
5031         for (i = 1; i < SLJIT_NUMBER_OF_REGISTERS; i++)
5032                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_R(i), 0);
5033
5034         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_R0, 0);
5035
5036         sljit_set_label(jump, sljit_emit_label(compiler));
5037         sljit_emit_enter(compiler, 0, SLJIT_ARGS0(VOID), SLJIT_NUMBER_OF_REGISTERS, 0, 0, 0, 0);
5038         for (i = 0; i < SLJIT_NUMBER_OF_REGISTERS; i++)
5039                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R(i), 0, SLJIT_IMM, 43);
5040         sljit_emit_return_void(compiler);
5041
5042         code.code = sljit_generate_code(compiler);
5043         CHECK(compiler);
5044         sljit_free_compiler(compiler);
5045
5046         FAILED(code.func0() != (SLJIT_NUMBER_OF_SCRATCH_REGISTERS * 43 + SLJIT_NUMBER_OF_SAVED_REGISTERS * 68), "test51 case 3 failed\n");
5047
5048         sljit_free_code(code.code, NULL);
5049         successful_tests++;
5050 }
5051
5052 static void test52(void)
5053 {
5054         /* Test all registers provided by the CPU. */
5055         executable_code code;
5056         struct sljit_compiler* compiler;
5057         struct sljit_jump* jump;
5058         sljit_f64 buf[3];
5059         sljit_s32 i;
5060
5061         if (verbose)
5062                 printf("Run test52\n");
5063
5064         if (!sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
5065                 if (verbose)
5066                         printf("no fpu available, test52 skipped\n");
5067                 successful_tests++;
5068                 return;
5069         }
5070
5071         /* Next test. */
5072
5073         compiler = sljit_create_compiler(NULL, NULL);
5074         FAILED(!compiler, "cannot create compiler\n");
5075         buf[0] = 6.25;
5076         buf[1] = 17.75;
5077
5078         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, P), 0, 1, SLJIT_NUMBER_OF_SCRATCH_FLOAT_REGISTERS, SLJIT_NUMBER_OF_SAVED_FLOAT_REGISTERS, 0);
5079
5080         for (i = 0; i < SLJIT_NUMBER_OF_FLOAT_REGISTERS; i++)
5081                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR(i), 0, SLJIT_MEM1(SLJIT_S0), 0);
5082
5083         jump = sljit_emit_call(compiler, SLJIT_CALL, SLJIT_ARGS0(VOID));
5084         /* SLJIT_FR0 contains the first value. */
5085         for (i = 1; i < SLJIT_NUMBER_OF_FLOAT_REGISTERS; i++)
5086                 sljit_emit_fop2(compiler, SLJIT_ADD_F64, SLJIT_FR0, 0, SLJIT_FR0, 0, SLJIT_FR(i), 0);
5087         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_f64), SLJIT_FR0, 0);
5088
5089         sljit_emit_return_void(compiler);
5090
5091         sljit_set_label(jump, sljit_emit_label(compiler));
5092         sljit_emit_enter(compiler, 0, SLJIT_ARGS0(VOID), 1, 0, SLJIT_NUMBER_OF_FLOAT_REGISTERS, 0, 0);
5093         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&buf[1]);
5094         for (i = 0; i < SLJIT_NUMBER_OF_FLOAT_REGISTERS; i++)
5095                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR(i), 0, SLJIT_MEM1(SLJIT_R0), 0);
5096         sljit_emit_return_void(compiler);
5097
5098         code.code = sljit_generate_code(compiler);
5099         CHECK(compiler);
5100         sljit_free_compiler(compiler);
5101
5102         code.func1((sljit_sw)&buf);
5103         FAILED(buf[2] != (SLJIT_NUMBER_OF_SCRATCH_FLOAT_REGISTERS * 17.75 + SLJIT_NUMBER_OF_SAVED_FLOAT_REGISTERS * 6.25), "test52 case 1 failed\n");
5104
5105         sljit_free_code(code.code, NULL);
5106
5107         /* Next test. */
5108
5109         compiler = sljit_create_compiler(NULL, NULL);
5110         FAILED(!compiler, "cannot create compiler\n");
5111         buf[0] = -32.5;
5112         buf[1] = -11.25;
5113
5114         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, P), 0, 1, SLJIT_NUMBER_OF_SCRATCH_FLOAT_REGISTERS, SLJIT_NUMBER_OF_SAVED_FLOAT_REGISTERS, 0);
5115
5116         for (i = 0; i < SLJIT_NUMBER_OF_SCRATCH_FLOAT_REGISTERS; i++)
5117                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR(i), 0, SLJIT_MEM1(SLJIT_S0), 0);
5118         for (i = 0; i < SLJIT_NUMBER_OF_SAVED_FLOAT_REGISTERS; i++)
5119                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FS(i), 0, SLJIT_MEM1(SLJIT_S0), 0);
5120
5121         jump = sljit_emit_call(compiler, SLJIT_CALL, SLJIT_ARGS0(VOID));
5122         /* SLJIT_FR0 contains the first value. */
5123         for (i = 1; i < SLJIT_NUMBER_OF_FLOAT_REGISTERS; i++)
5124                 sljit_emit_fop2(compiler, SLJIT_ADD_F64, SLJIT_FR0, 0, SLJIT_FR0, 0, SLJIT_FR(i), 0);
5125         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_f64), SLJIT_FR0, 0);
5126
5127         sljit_emit_return_void(compiler);
5128
5129         sljit_set_label(jump, sljit_emit_label(compiler));
5130         sljit_emit_enter(compiler, 0, SLJIT_ARGS0(VOID), 1, 0, SLJIT_NUMBER_OF_FLOAT_REGISTERS, 0, 0);
5131         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&buf[1]);
5132         for (i = 0; i < SLJIT_NUMBER_OF_FLOAT_REGISTERS; i++)
5133                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR(i), 0, SLJIT_MEM1(SLJIT_R0), 0);
5134         sljit_emit_return_void(compiler);
5135
5136         code.code = sljit_generate_code(compiler);
5137         CHECK(compiler);
5138         sljit_free_compiler(compiler);
5139
5140         code.func1((sljit_sw)&buf);
5141         FAILED(buf[2] != (SLJIT_NUMBER_OF_SCRATCH_FLOAT_REGISTERS * -11.25 + SLJIT_NUMBER_OF_SAVED_FLOAT_REGISTERS * -32.5), "test52 case 2 failed\n");
5142
5143         sljit_free_code(code.code, NULL);
5144         successful_tests++;
5145 }
5146
5147 static void test53(void)
5148 {
5149         /* Check cdecl calls. */
5150         executable_code code;
5151         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
5152         sljit_sw buf[3];
5153
5154         if (verbose)
5155                 printf("Run test53\n");
5156
5157         FAILED(!compiler, "cannot create compiler\n");
5158         buf[0] = -1;
5159
5160         sljit_emit_enter(compiler, SLJIT_ENTER_CDECL, SLJIT_ARGS3(VOID, W, W, W), 1, 3, 0, 0, 2 * sizeof(sljit_sw));
5161
5162         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)buf);
5163         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_S0, 0);
5164         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_sw), SLJIT_S1, 0);
5165         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 2 * sizeof(sljit_sw), SLJIT_S2, 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.test53_f1(7895, -3812, 4087);
5174
5175         FAILED(buf[0] != 7895, "test53 case 1 failed\n");
5176         FAILED(buf[1] != -3812, "test53 case 2 failed\n");
5177         FAILED(buf[2] != 4087, "test53 case 3 failed\n");
5178
5179         sljit_free_code(code.code, NULL);
5180
5181         successful_tests++;
5182 }
5183
5184 static void test54(void)
5185 {
5186         /* Check cmov. */
5187         executable_code code;
5188         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
5189 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
5190         sljit_sw large_num = SLJIT_W(0x1234567812345678);
5191 #else
5192         sljit_sw large_num = SLJIT_W(0x12345678);
5193 #endif
5194         int i;
5195         sljit_sw buf[19];
5196         sljit_s32 ibuf[4];
5197
5198         union {
5199                 sljit_f32 value;
5200                 sljit_s32 s32_value;
5201         } sbuf[3];
5202
5203         sbuf[0].s32_value = 0x7fffffff;
5204         sbuf[1].value = 7.5;
5205         sbuf[2].value = -14.75;
5206
5207         if (verbose)
5208                 printf("Run test54\n");
5209
5210         FAILED(!compiler, "cannot create compiler\n");
5211
5212         for (i = 0; i < 19; i++)
5213                 buf[i] = 0;
5214         for (i = 0; i < 4; i++)
5215                 ibuf[i] = 0;
5216
5217         sljit_emit_enter(compiler, 0, SLJIT_ARGS3(VOID, P, P, P), 5, 3, 3, 0, 0);
5218
5219         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 17);
5220         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 34);
5221         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_SIG_LESS, SLJIT_R0, 0, SLJIT_IMM, -10);
5222         sljit_emit_cmov(compiler, SLJIT_SIG_LESS, SLJIT_R0, SLJIT_R1, 0);
5223         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0);
5224         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_SIG_GREATER, SLJIT_R0, 0, SLJIT_IMM, -10);
5225         sljit_emit_cmov(compiler, SLJIT_SIG_GREATER, SLJIT_R0, SLJIT_R1, 0);
5226         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_R0, 0);
5227
5228         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 24);
5229         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_Z, SLJIT_R0, 0, SLJIT_IMM, 24);
5230         sljit_emit_cmov(compiler, SLJIT_NOT_EQUAL, SLJIT_R0, SLJIT_IMM, 66);
5231         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_R0, 0);
5232         sljit_emit_cmov(compiler, SLJIT_EQUAL, SLJIT_R0, SLJIT_IMM, 78);
5233         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_R0, 0);
5234         sljit_emit_cmov(compiler, SLJIT_EQUAL, SLJIT_R0, SLJIT_IMM, large_num);
5235         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_R0, 0);
5236
5237 #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
5238         SLJIT_ASSERT(sljit_get_register_index(SLJIT_R3) == -1 && sljit_get_register_index(SLJIT_R4) == -1);
5239 #endif
5240         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 7);
5241         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, -45);
5242         sljit_emit_op2(compiler, SLJIT_MUL | SLJIT_SET_OVERFLOW, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, 8);
5243         sljit_emit_cmov(compiler, SLJIT_OVERFLOW, SLJIT_R3, SLJIT_IMM, 35);
5244         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_R3, 0);
5245         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, large_num);
5246         sljit_emit_op2u(compiler, SLJIT_MUL | SLJIT_SET_OVERFLOW, SLJIT_R0, 0, SLJIT_IMM, large_num);
5247         sljit_emit_cmov(compiler, SLJIT_OVERFLOW, SLJIT_R3, SLJIT_IMM, 35);
5248         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_sw), SLJIT_R3, 0);
5249
5250         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 71);
5251         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, 13);
5252         sljit_emit_op2(compiler, SLJIT_LSHR | SLJIT_SET_Z, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, 8);
5253         sljit_emit_cmov(compiler, SLJIT_EQUAL, SLJIT_R3, SLJIT_R0, 0);
5254         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_sw), SLJIT_R3, 0);
5255
5256         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 12);
5257         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, -29);
5258         sljit_emit_op2(compiler, SLJIT_MUL | SLJIT_SET_OVERFLOW, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 8);
5259         sljit_emit_cmov(compiler, SLJIT_NOT_OVERFLOW, SLJIT_R0, SLJIT_R3, 0);
5260         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_sw), SLJIT_R3, 0);
5261
5262         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 16);
5263         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, -12);
5264         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R4, 0, SLJIT_IMM, 21);
5265         sljit_emit_op2u(compiler, SLJIT_AND | SLJIT_SET_Z, SLJIT_R0, 0, SLJIT_IMM, 8);
5266         sljit_emit_cmov(compiler, SLJIT_NOT_EQUAL, SLJIT_R3, SLJIT_R4, 0);
5267         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 9 * sizeof(sljit_sw), SLJIT_R3, 0);
5268         sljit_emit_cmov(compiler, SLJIT_EQUAL, SLJIT_R3, SLJIT_R4, 0);
5269         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 10 * sizeof(sljit_sw), SLJIT_R3, 0);
5270
5271         if (sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
5272                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S2), 0);
5273                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S2), sizeof(sljit_f32));
5274                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S2), 2 * sizeof(sljit_f32));
5275
5276                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 16);
5277                 sljit_emit_fop1(compiler, SLJIT_CMP_F32 | SLJIT_SET_F_EQUAL, SLJIT_FR1, 0, SLJIT_FR2, 0);
5278                 sljit_emit_cmov(compiler, SLJIT_F_EQUAL, SLJIT_R0, SLJIT_IMM, -45);
5279                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 11 * sizeof(sljit_sw), SLJIT_R0, 0);
5280                 sljit_emit_fop1(compiler, SLJIT_CMP_F32 | SLJIT_SET_F_GREATER, SLJIT_FR1, 0, SLJIT_FR2, 0);
5281                 sljit_emit_cmov(compiler, SLJIT_F_GREATER, SLJIT_R0, SLJIT_IMM, -45);
5282                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 12 * sizeof(sljit_sw), SLJIT_R0, 0);
5283                 sljit_emit_fop1(compiler, SLJIT_CMP_F32 | SLJIT_SET_F_GREATER_EQUAL, SLJIT_FR1, 0, SLJIT_FR2, 0);
5284                 sljit_emit_cmov(compiler, SLJIT_F_GREATER_EQUAL, SLJIT_R0, SLJIT_IMM, 33);
5285                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 13 * sizeof(sljit_sw), SLJIT_R0, 0);
5286
5287                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 8);
5288                 sljit_emit_fop1(compiler, SLJIT_CMP_F32 | SLJIT_SET_F_LESS, SLJIT_FR1, 0, SLJIT_FR2, 0);
5289                 sljit_emit_cmov(compiler, SLJIT_F_LESS, SLJIT_R0, SLJIT_IMM, -70);
5290                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 14 * sizeof(sljit_sw), SLJIT_R0, 0);
5291                 sljit_emit_fop1(compiler, SLJIT_CMP_F32 | SLJIT_SET_F_LESS_EQUAL, SLJIT_FR2, 0, SLJIT_FR1, 0);
5292                 sljit_emit_cmov(compiler, SLJIT_F_LESS_EQUAL, SLJIT_R0, SLJIT_IMM, -60);
5293                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 15 * sizeof(sljit_sw), SLJIT_R0, 0);
5294                 sljit_emit_fop1(compiler, SLJIT_CMP_F32 | SLJIT_SET_F_NOT_EQUAL, SLJIT_FR1, 0, SLJIT_FR2, 0);
5295                 sljit_emit_cmov(compiler, SLJIT_F_NOT_EQUAL, SLJIT_R0, SLJIT_IMM, 31);
5296                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 16 * sizeof(sljit_sw), SLJIT_R0, 0);
5297
5298                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 53);
5299                 sljit_emit_fop1(compiler, SLJIT_CMP_F32 | SLJIT_SET_ORDERED, SLJIT_FR1, 0, SLJIT_FR0, 0);
5300                 sljit_emit_cmov(compiler, SLJIT_ORDERED, SLJIT_R0, SLJIT_IMM, 17);
5301                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 17 * sizeof(sljit_sw), SLJIT_R0, 0);
5302                 sljit_emit_fop1(compiler, SLJIT_CMP_F32 | SLJIT_SET_UNORDERED, SLJIT_FR1, 0, SLJIT_FR0, 0);
5303                 sljit_emit_cmov(compiler, SLJIT_UNORDERED, SLJIT_R0, SLJIT_IMM, 59);
5304                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 18 * sizeof(sljit_sw), SLJIT_R0, 0);
5305         }
5306
5307         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 177);
5308         sljit_emit_op2u(compiler, SLJIT_SUB32 | SLJIT_SET_LESS, SLJIT_R0, 0, SLJIT_IMM, 178);
5309         sljit_emit_cmov(compiler, SLJIT_LESS, SLJIT_R0 | SLJIT_32, SLJIT_IMM, 200);
5310         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_S1), 0, SLJIT_R0, 0);
5311
5312         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 95);
5313         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R3, 0, SLJIT_IMM, 177);
5314         sljit_emit_op2u(compiler, SLJIT_SUB32 | SLJIT_SET_LESS_EQUAL, SLJIT_R0, 0, SLJIT_IMM, 95);
5315         sljit_emit_cmov(compiler, SLJIT_LESS_EQUAL, SLJIT_R3 | SLJIT_32, SLJIT_R0, 0);
5316         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 0);
5317         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_s32), SLJIT_R3, 0);
5318
5319         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R3, 0, SLJIT_IMM, 56);
5320         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R4, 0, SLJIT_IMM, -63);
5321         sljit_emit_op2u(compiler, SLJIT_SUB32 | SLJIT_SET_SIG_LESS, SLJIT_R3, 0, SLJIT_R4, 0);
5322         sljit_emit_cmov(compiler, SLJIT_SIG_LESS, SLJIT_R3 | SLJIT_32, SLJIT_R4, 0);
5323         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_S1), 2 * sizeof(sljit_s32), SLJIT_R3, 0);
5324         sljit_emit_op2u(compiler, SLJIT_SUB32 | SLJIT_SET_SIG_GREATER, SLJIT_R3, 0, SLJIT_R4, 0);
5325         sljit_emit_cmov(compiler, SLJIT_SIG_GREATER, SLJIT_R3 | SLJIT_32, SLJIT_R4, 0);
5326         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_S1), 3 * sizeof(sljit_s32), SLJIT_R3, 0);
5327
5328         sljit_emit_return_void(compiler);
5329
5330         code.code = sljit_generate_code(compiler);
5331         CHECK(compiler);
5332         sljit_free_compiler(compiler);
5333
5334         code.func3((sljit_sw)&buf, (sljit_sw)&ibuf, (sljit_sw)&sbuf);
5335
5336         FAILED(buf[0] != 17, "test54 case 1 failed\n");
5337         FAILED(buf[1] != 34, "test54 case 2 failed\n");
5338         FAILED(buf[2] != 24, "test54 case 3 failed\n");
5339         FAILED(buf[3] != 78, "test54 case 4 failed\n");
5340         FAILED(buf[4] != large_num, "test54 case 5 failed\n");
5341         FAILED(buf[5] != -45, "test54 case 6 failed\n");
5342         FAILED(buf[6] != 35, "test54 case 7 failed\n");
5343         FAILED(buf[7] != 71, "test54 case 8 failed\n");
5344         FAILED(buf[8] != -29, "test54 case 9 failed\n");
5345         FAILED(buf[9] != -12, "test54 case 10 failed\n");
5346         FAILED(buf[10] != 21, "test54 case 11 failed\n");
5347
5348         if (sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
5349                 FAILED(buf[11] != 16, "test54 case 12 failed\n");
5350                 FAILED(buf[12] != -45, "test54 case 13 failed\n");
5351                 FAILED(buf[13] != 33, "test54 case 14 failed\n");
5352                 FAILED(buf[14] != 8, "test54 case 15 failed\n");
5353                 FAILED(buf[15] != -60, "test54 case 16 failed\n");
5354                 FAILED(buf[16] != 31, "test54 case 17 failed\n");
5355                 FAILED(buf[17] != 53, "test54 case 18 failed\n");
5356                 FAILED(buf[18] != 59, "test54 case 19 failed\n");
5357         }
5358
5359         FAILED(ibuf[0] != 200, "test54 case 12 failed\n");
5360         FAILED(ibuf[1] != 95, "test54 case 13 failed\n");
5361         FAILED(ibuf[2] != 56, "test54 case 14 failed\n");
5362         FAILED(ibuf[3] != -63, "test54 case 15 failed\n");
5363
5364         sljit_free_code(code.code, NULL);
5365         successful_tests++;
5366 }
5367
5368 static void test55(void)
5369 {
5370         /* Check value preservation. */
5371         executable_code code;
5372         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
5373         sljit_sw buf[2];
5374         sljit_s32 i;
5375
5376         if (verbose)
5377                 printf("Run test55\n");
5378
5379         FAILED(!compiler, "cannot create compiler\n");
5380         buf[0] = 0;
5381         buf[1] = 0;
5382
5383         sljit_emit_enter(compiler, 0, SLJIT_ARGS0(VOID), SLJIT_NUMBER_OF_REGISTERS, 0, 0, 0, sizeof (sljit_sw));
5384
5385         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), 0, SLJIT_IMM, 217);
5386
5387         /* Check 1 */
5388         for (i = 0; i < SLJIT_NUMBER_OF_REGISTERS; i++)
5389                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R(i), 0, SLJIT_IMM, 118);
5390
5391         sljit_emit_op0(compiler, SLJIT_DIVMOD_SW);
5392
5393         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0);
5394
5395         for (i = 2; i < SLJIT_NUMBER_OF_REGISTERS; i++)
5396                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_R(i), 0);
5397         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_SP), 0);
5398
5399         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM0(), (sljit_sw)(buf + 0), SLJIT_R0, 0);
5400
5401         /* Check 2 */
5402         for (i = 0; i < SLJIT_NUMBER_OF_REGISTERS; i++)
5403                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R(i), 0, SLJIT_IMM, 146);
5404
5405         sljit_emit_op0(compiler, SLJIT_DIV_SW);
5406
5407         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0);
5408
5409         for (i = 1; i < SLJIT_NUMBER_OF_REGISTERS; i++)
5410                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_R(i), 0);
5411         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_SP), 0);
5412
5413         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM0(), (sljit_sw)(buf + 1), SLJIT_R0, 0);
5414
5415         sljit_emit_return_void(compiler);
5416
5417         code.code = sljit_generate_code(compiler);
5418         CHECK(compiler);
5419         sljit_free_compiler(compiler);
5420
5421         code.func0();
5422
5423         FAILED(buf[0] != (SLJIT_NUMBER_OF_REGISTERS - 2) * 118 + 217, "test55 case 1 failed\n");
5424         FAILED(buf[1] != (SLJIT_NUMBER_OF_REGISTERS - 1) * 146 + 217, "test55 case 2 failed\n");
5425
5426         sljit_free_code(code.code, NULL);
5427         successful_tests++;
5428 }
5429
5430 static void test56(void)
5431 {
5432         /* Check integer substraction with negative immediate. */
5433         executable_code code;
5434         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
5435         sljit_sw buf[13];
5436         sljit_s32 i;
5437
5438         if (verbose)
5439                 printf("Run test56\n");
5440
5441         for (i = 0; i < 13; i++)
5442                 buf[i] = 77;
5443
5444         FAILED(!compiler, "cannot create compiler\n");
5445
5446         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, P), 3, 1, 0, 0, 0);
5447
5448         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 90 << 12);
5449         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_SIG_GREATER, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, -(91 << 12));
5450         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R1, 0);
5451         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_SIG_GREATER);
5452         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_LESS, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, -(91 << 12));
5453         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_R1, 0);
5454         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_LESS);
5455         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_SIG_GREATER_EQUAL, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, -(91 << 12));
5456         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_SIG_GREATER_EQUAL);
5457         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, -(91 << 12));
5458         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_LESS_EQUAL);
5459         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_GREATER, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, -(91 << 12));
5460         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_sw), SLJIT_GREATER);
5461         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_SIG_LESS, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, -(91 << 12));
5462         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_sw), SLJIT_SIG_LESS);
5463
5464         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 90);
5465         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_SIG_GREATER, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, -91);
5466         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_sw), SLJIT_R0, 0);
5467         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 9 * sizeof(sljit_sw), SLJIT_SIG_GREATER);
5468         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 90);
5469         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, -91);
5470         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 10 * sizeof(sljit_sw), SLJIT_LESS_EQUAL);
5471
5472         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, -0x7fffffff);
5473         sljit_emit_op2(compiler, SLJIT_ADD32 | SLJIT_SET_OVERFLOW, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, -(91 << 12));
5474         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 11 * sizeof(sljit_sw), SLJIT_OVERFLOW);
5475
5476         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, -0x7fffffff-1);
5477         sljit_emit_op2(compiler, SLJIT_SUB32 | SLJIT_SET_OVERFLOW, SLJIT_R0, 0, SLJIT_IMM, 0, SLJIT_R0, 0);
5478         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 12 * sizeof(sljit_sw), SLJIT_OVERFLOW);
5479
5480         sljit_emit_return_void(compiler);
5481
5482         code.code = sljit_generate_code(compiler);
5483         CHECK(compiler);
5484         sljit_free_compiler(compiler);
5485
5486         code.func1((sljit_sw)&buf);
5487
5488         FAILED(buf[0] != (181 << 12), "test56 case 1 failed\n");
5489         FAILED(buf[1] != 1, "test56 case 2 failed\n");
5490         FAILED(buf[2] != (181 << 12), "test56 case 3 failed\n");
5491         FAILED(buf[3] != 1, "test56 case 4 failed\n");
5492         FAILED(buf[4] != 1, "test56 case 5 failed\n");
5493         FAILED(buf[5] != 1, "test56 case 6 failed\n");
5494         FAILED(buf[6] != 0, "test56 case 7 failed\n");
5495         FAILED(buf[7] != 0, "test56 case 8 failed\n");
5496         FAILED(buf[8] != 181, "test56 case 9 failed\n");
5497         FAILED(buf[9] != 1, "test56 case 10 failed\n");
5498         FAILED(buf[10] != 1, "test56 case 11 failed\n");
5499         FAILED(buf[11] != 1, "test56 case 12 failed\n");
5500         FAILED(buf[12] != 1, "test56 case 13 failed\n");
5501
5502         sljit_free_code(code.code, NULL);
5503         successful_tests++;
5504 }
5505
5506 static void test57(void)
5507 {
5508         /* Check prefetch instructions. */
5509         executable_code code;
5510         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
5511         struct sljit_label* labels[5];
5512         sljit_p addr[5];
5513         int i;
5514
5515         if (verbose)
5516                 printf("Run test57\n");
5517
5518         FAILED(!compiler, "cannot create compiler\n");
5519
5520         sljit_emit_enter(compiler, 0, SLJIT_ARGS0(VOID), 3, 1, 0, 0, 0);
5521
5522         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0);
5523         labels[0] = sljit_emit_label(compiler);
5524         /* Should never crash. */
5525         sljit_emit_op_src(compiler, SLJIT_PREFETCH_L1, SLJIT_MEM2(SLJIT_R0, SLJIT_R0), 2);
5526         labels[1] = sljit_emit_label(compiler);
5527         sljit_emit_op_src(compiler, SLJIT_PREFETCH_L2, SLJIT_MEM0(), 0);
5528         labels[2] = sljit_emit_label(compiler);
5529 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
5530         sljit_emit_op_src(compiler, SLJIT_PREFETCH_L3, SLJIT_MEM1(SLJIT_R0), SLJIT_W(0x1122334455667788));
5531 #else
5532         sljit_emit_op_src(compiler, SLJIT_PREFETCH_L3, SLJIT_MEM1(SLJIT_R0), 0x11223344);
5533 #endif
5534         labels[3] = sljit_emit_label(compiler);
5535         sljit_emit_op_src(compiler, SLJIT_PREFETCH_ONCE, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_sw));
5536         labels[4] = sljit_emit_label(compiler);
5537
5538         sljit_emit_return_void(compiler);
5539
5540         code.code = sljit_generate_code(compiler);
5541         CHECK(compiler);
5542
5543         for (i = 0; i < 5; i++)
5544                 addr[i] = sljit_get_label_addr(labels[i]);
5545
5546         sljit_free_compiler(compiler);
5547
5548         code.func0();
5549
5550         if (sljit_has_cpu_feature(SLJIT_HAS_PREFETCH)) {
5551                 FAILED(addr[0] == addr[1], "test57 case 1 failed\n");
5552                 FAILED(addr[1] == addr[2], "test57 case 2 failed\n");
5553                 FAILED(addr[2] == addr[3], "test57 case 3 failed\n");
5554                 FAILED(addr[3] == addr[4], "test57 case 4 failed\n");
5555         }
5556         else {
5557                 FAILED(addr[0] != addr[1], "test57 case 1 failed\n");
5558                 FAILED(addr[1] != addr[2], "test57 case 2 failed\n");
5559                 FAILED(addr[2] != addr[3], "test57 case 3 failed\n");
5560                 FAILED(addr[3] != addr[4], "test57 case 4 failed\n");
5561         }
5562
5563         sljit_free_code(code.code, NULL);
5564         successful_tests++;
5565 }
5566
5567 static sljit_f64 SLJIT_FUNC test58_f1(sljit_f32 a, sljit_f32 b, sljit_f64 c)
5568 {
5569         return (sljit_f64)a + (sljit_f64)b + c;
5570 }
5571
5572 static sljit_f32 SLJIT_FUNC test58_f2(sljit_sw a, sljit_f64 b, sljit_f32 c)
5573 {
5574         return (sljit_f32)((sljit_f64)a + b + (sljit_f64)c);
5575 }
5576
5577 static sljit_f64 SLJIT_FUNC test58_f3(sljit_sw a, sljit_f32 b, sljit_sw c)
5578 {
5579         return (sljit_f64)a + (sljit_f64)b + (sljit_f64)c;
5580 }
5581
5582 static sljit_f64 test58_f4(sljit_f32 a, sljit_sw b)
5583 {
5584         return (sljit_f64)a + (sljit_f64)b;
5585 }
5586
5587 static sljit_f32 test58_f5(sljit_f32 a, sljit_f64 b, sljit_s32 c)
5588 {
5589         return (sljit_f32)((sljit_f64)a + b + (sljit_f64)c);
5590 }
5591
5592 static sljit_sw SLJIT_FUNC test58_f6(sljit_f64 a, sljit_sw b)
5593 {
5594         return (sljit_sw)(a + (sljit_f64)b);
5595 }
5596
5597 static void test58(void)
5598 {
5599         /* Check function calls with floating point arguments. */
5600         executable_code code;
5601         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
5602         struct sljit_jump* jump = NULL;
5603         sljit_f64 dbuf[7];
5604         sljit_f32 sbuf[7];
5605         sljit_sw wbuf[2];
5606
5607         if (verbose)
5608                 printf("Run test58\n");
5609
5610         if (!sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
5611                 if (verbose)
5612                         printf("no fpu available, test58 skipped\n");
5613                 successful_tests++;
5614                 if (compiler)
5615                         sljit_free_compiler(compiler);
5616                 return;
5617         }
5618
5619         dbuf[0] = 5.25;
5620         dbuf[1] = 0.0;
5621         dbuf[2] = 2.5;
5622         dbuf[3] = 0.0;
5623         dbuf[4] = 0.0;
5624         dbuf[5] = 0.0;
5625         dbuf[6] = -18.0;
5626
5627         sbuf[0] = 6.75;
5628         sbuf[1] = -3.5;
5629         sbuf[2] = 1.5;
5630         sbuf[3] = 0.0;
5631         sbuf[4] = 0.0;
5632
5633         wbuf[0] = 0;
5634         wbuf[1] = 0;
5635
5636         FAILED(!compiler, "cannot create compiler\n");
5637
5638         sljit_emit_enter(compiler, 0, SLJIT_ARGS3(VOID, P, P, P), 3, 3, 4, 0, sizeof(sljit_sw));
5639
5640         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S1), 0);
5641         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_f32));
5642         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S0), 0);
5643         sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_ARGS3(F64, F32, F32, F64), SLJIT_IMM, SLJIT_FUNC_ADDR(test58_f1));
5644         /* dbuf[1] */
5645         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64), SLJIT_FR0, 0);
5646
5647         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_f32));
5648         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S1), 2 * sizeof(sljit_f32));
5649         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_f64));
5650         jump = sljit_emit_call(compiler, SLJIT_CALL, SLJIT_ARGS3(F64, F32, F32, F64));
5651         sljit_set_target(jump, SLJIT_FUNC_UADDR(test58_f1));
5652         /* dbuf[3] */
5653         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_f64), SLJIT_FR0, 0);
5654
5655         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), 0, SLJIT_IMM, SLJIT_FUNC_ADDR(test58_f2));
5656         sljit_get_local_base(compiler, SLJIT_R1, 0, -16);
5657         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 16);
5658         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S0), 0);
5659         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_f32));
5660         sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_ARGS3(F32, W, F64, F32), SLJIT_MEM2(SLJIT_R1, SLJIT_R0), 0);
5661         /* sbuf[3] */
5662         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_S1), 3 * sizeof(sljit_f32), SLJIT_FR0, 0);
5663
5664         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -4);
5665         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 9);
5666         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 0);
5667         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S1), 0);
5668         jump = sljit_emit_call(compiler, SLJIT_CALL, SLJIT_ARGS3(F64, W, F32, W));
5669         sljit_set_target(jump, SLJIT_FUNC_UADDR(test58_f3));
5670         /* dbuf[4] */
5671         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_f64), SLJIT_FR0, 0);
5672
5673         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_f32));
5674         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -6);
5675         jump = sljit_emit_call(compiler, SLJIT_CALL_CDECL, SLJIT_ARGS2(F64, F32, W));
5676         sljit_set_target(jump, SLJIT_FUNC_UADDR(test58_f4));
5677         /* dbuf[5] */
5678         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_f64), SLJIT_FR0, 0);
5679
5680         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), 0, SLJIT_IMM, SLJIT_FUNC_ADDR(test58_f5));
5681         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S1), 2 * sizeof(sljit_f32));
5682         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_f64));
5683         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 8);
5684         sljit_emit_icall(compiler, SLJIT_CALL_CDECL, SLJIT_ARGS3(F32, F32, F64, 32), SLJIT_MEM1(SLJIT_SP), 0);
5685         /* sbuf[4] */
5686         sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_S1), 4 * sizeof(sljit_f32), SLJIT_FR0, 0);
5687
5688         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_f64));
5689         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_FUNC_ADDR(test58_f6));
5690         sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_ARGS2(W, F64, W), SLJIT_R0, 0);
5691         /* wbuf[0] */
5692         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S2), 0, SLJIT_R0, 0);
5693
5694         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_f64));
5695         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 319);
5696         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, SLJIT_FUNC_ADDR(test58_f6));
5697         sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_ARGS2(W, F64, W), SLJIT_R1, 0);
5698         /* wbuf[1] */
5699         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S2), sizeof(sljit_sw), SLJIT_R0, 0);
5700
5701         sljit_emit_return_void(compiler);
5702
5703         code.code = sljit_generate_code(compiler);
5704         CHECK(compiler);
5705         sljit_free_compiler(compiler);
5706
5707         code.func3((sljit_sw)&dbuf, (sljit_sw)&sbuf, (sljit_sw)&wbuf);
5708
5709         FAILED(dbuf[1] != 8.5, "test58 case 1 failed\n");
5710         FAILED(dbuf[3] != 0.5, "test58 case 2 failed\n");
5711         FAILED(sbuf[3] != 17.75, "test58 case 3 failed\n");
5712         FAILED(dbuf[4] != 11.75, "test58 case 4 failed\n");
5713         FAILED(dbuf[5] != -9.5, "test58 case 5 failed\n");
5714         FAILED(sbuf[4] != 12, "test58 case 6 failed\n");
5715         FAILED(wbuf[0] != SLJIT_FUNC_ADDR(test58_f6) - 18, "test58 case 7 failed\n");
5716         FAILED(wbuf[1] != 301, "test58 case 8 failed\n");
5717
5718         sljit_free_code(code.code, NULL);
5719         successful_tests++;
5720 }
5721
5722 static sljit_sw SLJIT_FUNC test59_f1(sljit_sw a, sljit_s32 b, sljit_sw c, sljit_sw d)
5723 {
5724         return (sljit_sw)(a + b + c + d - SLJIT_FUNC_ADDR(test59_f1));
5725 }
5726
5727 static sljit_sw test59_f2(sljit_sw a, sljit_s32 b, sljit_sw c, sljit_sw d)
5728 {
5729         return (sljit_sw)(a + b + c + d - SLJIT_FUNC_ADDR(test59_f2));
5730 }
5731
5732 static sljit_s32 SLJIT_FUNC test59_f3(sljit_f64 a, sljit_f32 b, sljit_f64 c, sljit_sw d)
5733 {
5734         return (sljit_s32)(a + b + c + (sljit_f64)d);
5735 }
5736
5737 static sljit_f32 SLJIT_FUNC test59_f4(sljit_f32 a, sljit_s32 b, sljit_f64 c, sljit_sw d)
5738 {
5739         return (sljit_f32)(a + (sljit_f64)b + c + (sljit_f64)d);
5740 }
5741
5742 static sljit_f32 SLJIT_FUNC test59_f5(sljit_f32 a, sljit_f64 b, sljit_f32 c, sljit_f64 d)
5743 {
5744         return (sljit_f32)(a + b + c + (sljit_f64)d);
5745 }
5746
5747 static void test59(void)
5748 {
5749         /* Check function calls with four arguments. */
5750         executable_code code;
5751         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
5752         struct sljit_jump* jump = NULL;
5753         sljit_sw wbuf[6];
5754         sljit_f64 dbuf[3];
5755         sljit_f32 sbuf[4];
5756
5757         if (verbose)
5758                 printf("Run test59\n");
5759
5760         wbuf[0] = 0;
5761         wbuf[1] = 0;
5762         wbuf[2] = 0;
5763         wbuf[3] = SLJIT_FUNC_ADDR(test59_f1);
5764         wbuf[4] = 0;
5765         wbuf[5] = 0;
5766
5767         if (sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
5768                 dbuf[0] = 5.125;
5769                 dbuf[1] = 6.125;
5770                 dbuf[2] = 4.25;
5771
5772                 sbuf[0] = 0.75;
5773                 sbuf[1] = -1.5;
5774                 sbuf[2] = 0.0;
5775                 sbuf[3] = 0.0;
5776         }
5777
5778         FAILED(!compiler, "cannot create compiler\n");
5779
5780         sljit_emit_enter(compiler, 0, SLJIT_ARGS3(VOID, P, P, P), 4, 3, 4, 0, sizeof(sljit_sw));
5781
5782         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 33);
5783         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, -20);
5784         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, SLJIT_FUNC_ADDR(test59_f1));
5785         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, -40);
5786         sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_ARGS4(W, W, 32, W, W), SLJIT_R2, 0);
5787         /* wbuf[0] */
5788         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0);
5789
5790         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 16);
5791         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, -30);
5792         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 50);
5793         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, SLJIT_FUNC_ADDR(test59_f2));
5794         sljit_emit_icall(compiler, SLJIT_CALL_CDECL, SLJIT_ARGS4(W, W, 32, W, W), SLJIT_R3, 0);
5795         /* wbuf[1] */
5796         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_R0, 0);
5797
5798         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_FUNC_ADDR(test59_f1));
5799         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, -25);
5800         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 100);
5801         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, -10);
5802         sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_ARGS4(W, W, 32, W, W), SLJIT_R0, 0);
5803         /* wbuf[2] */
5804         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_R0, 0);
5805
5806         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_S0, 0);
5807         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, 231);
5808         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 3);
5809         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, SLJIT_FUNC_ADDR(test59_f1) - 100);
5810         sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_ARGS4(W, W, 32, W, W), SLJIT_MEM2(SLJIT_R0, SLJIT_R2), SLJIT_WORD_SHIFT);
5811         /* wbuf[4] */
5812         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_R0, 0);
5813
5814         if (sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
5815                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S1), 0);
5816                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S2), 0);
5817                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_f64));
5818                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -100);
5819                 sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_ARGS4(32, F64, F32, F64, W), SLJIT_IMM, SLJIT_FUNC_ADDR(test59_f3));
5820                 sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_R0, 0, SLJIT_R0, 0);
5821                 /* wbuf[5] */
5822                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_R0, 0);
5823
5824                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S2), sizeof(sljit_f32));
5825                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S1), 2 * sizeof(sljit_f64));
5826                 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 36);
5827                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 41);
5828                 jump = sljit_emit_call(compiler, SLJIT_CALL, SLJIT_ARGS4(F32, F32, 32, F64, W));
5829                 sljit_set_target(jump, SLJIT_FUNC_UADDR(test59_f4));
5830                 /* sbuf[2] */
5831                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_S2), 2 * sizeof(sljit_f32), SLJIT_FR0, 0);
5832
5833                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_FUNC_ADDR(test59_f5));
5834                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S2), 0);
5835                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S1), 0);
5836                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S2), sizeof(sljit_f32));
5837                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR3, 0, SLJIT_MEM1(SLJIT_S1), 2 * sizeof(sljit_f64));
5838                 sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_ARGS4(F32, F32, F64, F32, F64), SLJIT_R0, 0);
5839                 /* sbuf[2] */
5840                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_S2), 3 * sizeof(sljit_f32), SLJIT_FR0, 0);
5841         }
5842
5843         sljit_emit_return_void(compiler);
5844
5845         code.code = sljit_generate_code(compiler);
5846         CHECK(compiler);
5847         sljit_free_compiler(compiler);
5848
5849         code.func3((sljit_sw)&wbuf, (sljit_sw)&dbuf, (sljit_sw)&sbuf);
5850
5851         FAILED(wbuf[0] != -27, "test59 case 1 failed\n");
5852         FAILED(wbuf[1] != 36, "test59 case 2 failed\n");
5853         FAILED(wbuf[2] != 65, "test59 case 3 failed\n");
5854         FAILED(wbuf[4] != (sljit_sw)wbuf + 134, "test59 case 4 failed\n");
5855
5856         if (sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
5857                 FAILED(wbuf[5] != -88, "test59 case 5 failed\n");
5858                 FAILED(sbuf[2] != 79.75, "test59 case 6 failed\n");
5859                 FAILED(sbuf[3] != 8.625, "test59 case 7 failed\n");
5860         }
5861
5862         sljit_free_code(code.code, NULL);
5863         successful_tests++;
5864 }
5865
5866 static void test60(void)
5867 {
5868         /* Test memory accesses with pre/post updates. */
5869         executable_code code;
5870         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
5871         sljit_u32 i;
5872         sljit_s32 supported[10];
5873         sljit_sw wbuf[18];
5874         sljit_s8 bbuf[4];
5875         sljit_s32 ibuf[4];
5876
5877 #if (defined SLJIT_CONFIG_ARM_64 && SLJIT_CONFIG_ARM_64) || (defined SLJIT_CONFIG_ARM_THUMB2 && SLJIT_CONFIG_ARM_THUMB2)
5878         static sljit_u8 expected[10] = { 1, 1, 1, 1, 1, 1, 0, 0, 0, 0 };
5879 #elif (defined SLJIT_CONFIG_ARM_32 && SLJIT_CONFIG_ARM_32)
5880         static sljit_u8 expected[10] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
5881 #elif (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32)
5882         static sljit_u8 expected[10] = { 1, 0, 1, 1, 0, 1, 1, 1, 0, 0 };
5883 #elif (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
5884         static sljit_u8 expected[10] = { 1, 0, 0, 1, 0, 0, 1, 1, 0, 0 };
5885 #else
5886         static sljit_u8 expected[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
5887 #endif
5888
5889         if (verbose)
5890                 printf("Run test60\n");
5891
5892         for (i = 0; i < 18; i++)
5893                 wbuf[i] = 0;
5894         wbuf[2] = -887766;
5895
5896         bbuf[0] = 0;
5897         bbuf[1] = 0;
5898         bbuf[2] = -13;
5899
5900         ibuf[0] = -5678;
5901         ibuf[1] = 0;
5902         ibuf[2] = 0;
5903
5904         FAILED(!compiler, "cannot create compiler\n");
5905
5906         sljit_emit_enter(compiler, 0, SLJIT_ARGS3(VOID, P, P, P), 4, 3, 4, 0, sizeof(sljit_sw));
5907
5908         supported[0] = sljit_emit_mem(compiler, SLJIT_MOV | SLJIT_MEM_SUPP | SLJIT_MEM_PRE, SLJIT_R1, SLJIT_MEM1(SLJIT_R0), 2 * sizeof(sljit_sw));
5909         if (supported[0] == SLJIT_SUCCESS) {
5910                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_S0, 0);
5911                 sljit_emit_mem(compiler, SLJIT_MOV | SLJIT_MEM_PRE, SLJIT_R1, SLJIT_MEM1(SLJIT_R0), 2 * sizeof(sljit_sw));
5912                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R1, 0);
5913                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_R0, 0);
5914         }
5915
5916         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));
5917         if (supported[1] == SLJIT_SUCCESS) {
5918                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R2, 0, SLJIT_S1, 0, SLJIT_IMM, 2 * sizeof(sljit_s8));
5919                 sljit_emit_mem(compiler, SLJIT_MOV_S8 | SLJIT_MEM_POST, SLJIT_R0, SLJIT_MEM1(SLJIT_R2), -2 * (sljit_sw)sizeof(sljit_s8));
5920                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_R0, 0);
5921                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_R2, 0);
5922         }
5923
5924         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));
5925         if (supported[2] == SLJIT_SUCCESS) {
5926                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_S2, 0, SLJIT_IMM, 2 * sizeof(sljit_s32));
5927                 sljit_emit_mem(compiler, SLJIT_MOV_S32 | SLJIT_MEM_PRE, SLJIT_R2, SLJIT_MEM1(SLJIT_R1), -2 * (sljit_sw)sizeof(sljit_s32));
5928                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_R2, 0);
5929                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_sw), SLJIT_R1, 0);
5930         }
5931
5932         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));
5933         if (supported[3] == SLJIT_SUCCESS) {
5934                 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, -8765);
5935                 sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R2, 0, SLJIT_S2, 0, SLJIT_IMM, sizeof(sljit_s32));
5936                 sljit_emit_mem(compiler, SLJIT_MOV32 | SLJIT_MEM_STORE | SLJIT_MEM_PRE, SLJIT_R1, SLJIT_MEM1(SLJIT_R2), 2 * sizeof(sljit_s32));
5937                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_sw), SLJIT_R2, 0);
5938         }
5939
5940         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));
5941         if (supported[4] == SLJIT_SUCCESS) {
5942                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, -121);
5943                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_S1, 0);
5944                 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));
5945                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_sw), SLJIT_R2, 0);
5946         }
5947
5948         supported[5] = sljit_emit_mem(compiler, SLJIT_MOV | SLJIT_MEM_SUPP | SLJIT_MEM_STORE | SLJIT_MEM_PRE, SLJIT_R1, SLJIT_MEM1(SLJIT_R0), 1);
5949         if (supported[5] == SLJIT_SUCCESS) {
5950                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_S0, 0, SLJIT_IMM, 9 * sizeof(sljit_sw) - 1);
5951                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, -881199);
5952                 sljit_emit_mem(compiler, SLJIT_MOV | SLJIT_MEM_STORE | SLJIT_MEM_PRE, SLJIT_R1, SLJIT_MEM1(SLJIT_R0), 1);
5953                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 10 * sizeof(sljit_sw), SLJIT_R0, 0);
5954         }
5955
5956         supported[6] = sljit_emit_mem(compiler, SLJIT_MOV_S32 | SLJIT_MEM_SUPP | SLJIT_MEM_PRE, SLJIT_R0, SLJIT_MEM2(SLJIT_R1, SLJIT_R2), 0);
5957         if (supported[6] == SLJIT_SUCCESS) {
5958                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_S2, 0, SLJIT_IMM, 213);
5959                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, -213);
5960                 sljit_emit_mem(compiler, SLJIT_MOV_S32 | SLJIT_MEM_PRE, SLJIT_R0, SLJIT_MEM2(SLJIT_R1, SLJIT_R2), 0);
5961                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 11 * sizeof(sljit_sw), SLJIT_R0, 0);
5962                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 12 * sizeof(sljit_sw), SLJIT_R1, 0);
5963         }
5964
5965         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);
5966         if (supported[7] == SLJIT_SUCCESS) {
5967                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_S2, 0);
5968                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 2 * sizeof(sljit_s32));
5969                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -7890);
5970                 sljit_emit_mem(compiler, SLJIT_MOV_S32 | SLJIT_MEM_STORE | SLJIT_MEM_PRE, SLJIT_R0, SLJIT_MEM2(SLJIT_R1, SLJIT_R2), 0);
5971                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 13 * sizeof(sljit_sw), SLJIT_R1, 0);
5972         }
5973
5974         supported[8] = sljit_emit_mem(compiler, SLJIT_MOV | SLJIT_MEM_SUPP | SLJIT_MEM_POST, SLJIT_R0, SLJIT_MEM2(SLJIT_R1, SLJIT_R2), 2);
5975         if (supported[8] == SLJIT_SUCCESS) {
5976                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_S0, 0, SLJIT_IMM, 2 * sizeof(sljit_sw));
5977                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 2 * sizeof(sljit_sw));
5978                 sljit_emit_mem(compiler, SLJIT_MOV | SLJIT_MEM_POST, SLJIT_R0, SLJIT_MEM2(SLJIT_R1, SLJIT_R2), 2);
5979                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 14 * sizeof(sljit_sw), SLJIT_R0, 0);
5980                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 15 * sizeof(sljit_sw), SLJIT_R1, 0);
5981         }
5982
5983         supported[9] = sljit_emit_mem(compiler, SLJIT_MOV_S8 | SLJIT_MEM_SUPP | SLJIT_MEM_POST, SLJIT_R0, SLJIT_MEM2(SLJIT_R1, SLJIT_R2), 0);
5984         if (supported[9] == SLJIT_SUCCESS) {
5985                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_S1, 0, SLJIT_IMM, 2 * sizeof(sljit_s8));
5986                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, -2 * (sljit_sw)sizeof(sljit_s8));
5987                 sljit_emit_mem(compiler, SLJIT_MOV_S8 | SLJIT_MEM_POST, SLJIT_R0, SLJIT_MEM2(SLJIT_R1, SLJIT_R2), 0);
5988                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 16 * sizeof(sljit_sw), SLJIT_R0, 0);
5989                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 17 * sizeof(sljit_sw), SLJIT_R1, 0);
5990         }
5991
5992         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);
5993         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);
5994
5995 #if (defined SLJIT_CONFIG_ARM_THUMB2 && SLJIT_CONFIG_ARM_THUMB2) || (defined SLJIT_CONFIG_ARM_64 && SLJIT_CONFIG_ARM_64)
5996         /* TODO: at least for ARM (both V5 and V7) the range below needs further fixing */
5997         SLJIT_ASSERT(sljit_emit_mem(compiler, SLJIT_MOV | SLJIT_MEM_SUPP | SLJIT_MEM_PRE, SLJIT_R1, SLJIT_MEM1(SLJIT_R0), 256) == SLJIT_ERR_UNSUPPORTED);
5998         SLJIT_ASSERT(sljit_emit_mem(compiler, SLJIT_MOV | SLJIT_MEM_SUPP | SLJIT_MEM_POST, SLJIT_R1, SLJIT_MEM1(SLJIT_R0), -257) == SLJIT_ERR_UNSUPPORTED);
5999 #endif
6000
6001         sljit_emit_return_void(compiler);
6002
6003         code.code = sljit_generate_code(compiler);
6004         CHECK(compiler);
6005         sljit_free_compiler(compiler);
6006
6007         code.func3((sljit_sw)&wbuf, (sljit_sw)&bbuf, (sljit_sw)&ibuf);
6008
6009         FAILED(sizeof(expected) != sizeof(supported) / sizeof(sljit_s32), "test60 case 1 failed\n");
6010
6011         for (i = 0; i < sizeof(expected); i++) {
6012                 if (expected[i]) {
6013                         if (supported[i] != SLJIT_SUCCESS) {
6014                                 printf("tast60 case %d should be supported\n", i + 1);
6015                                 return;
6016                         }
6017                 } else {
6018                         if (supported[i] == SLJIT_SUCCESS) {
6019                                 printf("test60 case %d should not be supported\n", i + 1);
6020                                 return;
6021                         }
6022                 }
6023         }
6024
6025         FAILED(supported[0] == SLJIT_SUCCESS && wbuf[0] != -887766, "test60 case 2 failed\n");
6026         FAILED(supported[0] == SLJIT_SUCCESS && wbuf[1] != (sljit_sw)(wbuf + 2), "test60 case 3 failed\n");
6027         FAILED(supported[1] == SLJIT_SUCCESS && wbuf[3] != -13, "test60 case 4 failed\n");
6028         FAILED(supported[1] == SLJIT_SUCCESS && wbuf[4] != (sljit_sw)(bbuf), "test60 case 5 failed\n");
6029         FAILED(supported[2] == SLJIT_SUCCESS && wbuf[5] != -5678, "test60 case 6 failed\n");
6030         FAILED(supported[2] == SLJIT_SUCCESS && wbuf[6] != (sljit_sw)(ibuf), "test60 case 7 failed\n");
6031         FAILED(supported[3] == SLJIT_SUCCESS && ibuf[1] != -8765, "test60 case 8 failed\n");
6032         FAILED(supported[3] == SLJIT_SUCCESS && wbuf[7] != (sljit_sw)(ibuf + 1), "test60 case 9 failed\n");
6033         FAILED(supported[4] == SLJIT_SUCCESS && bbuf[0] != -121, "test60 case 10 failed\n");
6034         FAILED(supported[4] == SLJIT_SUCCESS && wbuf[8] != (sljit_sw)(bbuf) - 128 * (sljit_sw)sizeof(sljit_s8), "test60 case 11 failed\n");
6035         FAILED(supported[5] == SLJIT_SUCCESS && wbuf[9] != -881199, "test60 case 12 failed\n");
6036         FAILED(supported[5] == SLJIT_SUCCESS && wbuf[10] != (sljit_sw)(wbuf + 9), "test60 case 13 failed\n");
6037         FAILED(supported[6] == SLJIT_SUCCESS && wbuf[11] != -5678, "test60 case 14 failed\n");
6038         FAILED(supported[6] == SLJIT_SUCCESS && wbuf[12] != (sljit_sw)(ibuf), "test60 case 15 failed\n");
6039         FAILED(supported[7] == SLJIT_SUCCESS && ibuf[2] != -7890, "test60 case 16 failed\n");
6040         FAILED(supported[7] == SLJIT_SUCCESS && wbuf[13] != (sljit_sw)(ibuf + 2), "test60 case 17 failed\n");
6041         FAILED(supported[8] == SLJIT_SUCCESS && wbuf[14] != -887766, "test60 case 18 failed\n");
6042         FAILED(supported[8] == SLJIT_SUCCESS && wbuf[15] != (sljit_sw)(wbuf + 10), "test60 case 19 failed\n");
6043         FAILED(supported[9] == SLJIT_SUCCESS && wbuf[16] != -13, "test60 case 20 failed\n");
6044         FAILED(supported[9] == SLJIT_SUCCESS && wbuf[17] != (sljit_sw)(bbuf), "test60 case 21 failed\n");
6045
6046         sljit_free_code(code.code, NULL);
6047         successful_tests++;
6048 }
6049
6050 static void test61(void)
6051 {
6052         /* Test float memory accesses with pre/post updates. */
6053         executable_code code;
6054         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
6055         sljit_u32 i;
6056         sljit_s32 supported[6];
6057         sljit_sw wbuf[6];
6058         sljit_f64 dbuf[4];
6059         sljit_f32 sbuf[4];
6060 #if (defined SLJIT_CONFIG_ARM_64 && SLJIT_CONFIG_ARM_64)
6061         static sljit_u8 expected[6] = { 1, 1, 1, 1, 0, 0 };
6062 #elif (defined SLJIT_CONFIG_PPC && SLJIT_CONFIG_PPC)
6063         static sljit_u8 expected[6] = { 1, 0, 1, 0, 1, 1 };
6064 #else
6065         static sljit_u8 expected[6] = { 0, 0, 0, 0, 0, 0 };
6066 #endif
6067
6068         if (!sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
6069                 if (verbose)
6070                         printf("no fpu available, test61 skipped\n");
6071                 successful_tests++;
6072                 if (compiler)
6073                         sljit_free_compiler(compiler);
6074                 return;
6075         }
6076
6077         if (verbose)
6078                 printf("Run test61\n");
6079
6080         for (i = 0; i < 6; i++)
6081                 wbuf[i] = 0;
6082
6083         dbuf[0] = 66.725;
6084         dbuf[1] = 0.0;
6085         dbuf[2] = 0.0;
6086         dbuf[3] = 0.0;
6087
6088         sbuf[0] = 0.0;
6089         sbuf[1] = -22.125;
6090         sbuf[2] = 0.0;
6091         sbuf[3] = 0.0;
6092
6093         FAILED(!compiler, "cannot create compiler\n");
6094
6095         sljit_emit_enter(compiler, 0, SLJIT_ARGS3(VOID, P, P, P), 4, 3, 4, 0, sizeof(sljit_sw));
6096
6097         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));
6098         if (supported[0] == SLJIT_SUCCESS) {
6099                 sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R0, 0, SLJIT_S1, 0, SLJIT_IMM, 4 * sizeof(sljit_f64));
6100                 sljit_emit_fmem(compiler, SLJIT_MOV_F64 | SLJIT_MEM_PRE, SLJIT_FR0, SLJIT_MEM1(SLJIT_R0), 4 * sizeof(sljit_f64));
6101                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_f64), SLJIT_FR0, 0);
6102                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0);
6103         }
6104
6105         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));
6106         if (supported[1] == SLJIT_SUCCESS) {
6107                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_S1, 0, SLJIT_IMM, 2 * sizeof(sljit_f64));
6108                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S1), 0);
6109                 sljit_emit_fmem(compiler, SLJIT_MOV_F64 | SLJIT_MEM_STORE | SLJIT_MEM_POST, SLJIT_FR2, SLJIT_MEM1(SLJIT_R0), -(sljit_sw)sizeof(sljit_f64));
6110                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_R0, 0);
6111         }
6112
6113         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));
6114         if (supported[2] == SLJIT_SUCCESS) {
6115                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R2, 0, SLJIT_S2, 0, SLJIT_IMM, 4 * sizeof(sljit_f32));
6116                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S2), sizeof(sljit_f32));
6117                 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));
6118                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_R2, 0);
6119         }
6120
6121         supported[3] = sljit_emit_fmem(compiler, SLJIT_MOV_F32 | SLJIT_MEM_SUPP | SLJIT_MEM_POST, SLJIT_FR1, SLJIT_MEM1(SLJIT_R1), sizeof(sljit_f32));
6122         if (supported[3] == SLJIT_SUCCESS) {
6123                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_S2, 0, SLJIT_IMM, sizeof(sljit_f32));
6124                 sljit_emit_fmem(compiler, SLJIT_MOV_F32 | SLJIT_MEM_POST, SLJIT_FR1, SLJIT_MEM1(SLJIT_R1), sizeof(sljit_f32));
6125                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_S2), 2 * sizeof(sljit_f32), SLJIT_FR1, 0);
6126                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_R1, 0);
6127         }
6128
6129         supported[4] = sljit_emit_fmem(compiler, SLJIT_MOV_F64 | SLJIT_MEM_SUPP | SLJIT_MEM_PRE, SLJIT_FR0, SLJIT_MEM2(SLJIT_R1, SLJIT_R0), 0);
6130         if (supported[4] == SLJIT_SUCCESS) {
6131                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_S1, 0, SLJIT_IMM, 8 * sizeof(sljit_f64));
6132                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -8 * (sljit_sw)sizeof(sljit_f64));
6133                 sljit_emit_fmem(compiler, SLJIT_MOV_F64 | SLJIT_MEM_PRE, SLJIT_FR0, SLJIT_MEM2(SLJIT_R1, SLJIT_R0), 0);
6134                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S1), 3 * sizeof(sljit_f64), SLJIT_FR0, 0);
6135                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_R1, 0);
6136         }
6137
6138         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);
6139         if (supported[5] == SLJIT_SUCCESS) {
6140                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_S2, 0);
6141                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 3 * sizeof(sljit_f32));
6142                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S2), sizeof(sljit_f32));
6143                 sljit_emit_fmem(compiler, SLJIT_MOV_F32 | SLJIT_MEM_STORE | SLJIT_MEM_PRE, SLJIT_FR2, SLJIT_MEM2(SLJIT_R2, SLJIT_R1), 0);
6144                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_R2, 0);
6145         }
6146
6147         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);
6148         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);
6149
6150 #if (defined SLJIT_CONFIG_ARM_64 && SLJIT_CONFIG_ARM_64)
6151         /* TODO: at least for ARM (both V5 and V7) the range below needs further fixing */
6152         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);
6153         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);
6154 #endif
6155
6156         sljit_emit_return_void(compiler);
6157
6158         code.code = sljit_generate_code(compiler);
6159         CHECK(compiler);
6160         sljit_free_compiler(compiler);
6161
6162         code.func3((sljit_sw)&wbuf, (sljit_sw)&dbuf, (sljit_sw)&sbuf);
6163
6164         FAILED(sizeof(expected) != sizeof(supported) / sizeof(sljit_s32), "test61 case 1 failed\n");
6165
6166         for (i = 0; i < sizeof(expected); i++) {
6167                 if (expected[i]) {
6168                         if (supported[i] != SLJIT_SUCCESS) {
6169                                 printf("tast61 case %d should be supported\n", i + 1);
6170                                 return;
6171                         }
6172                 } else {
6173                         if (supported[i] == SLJIT_SUCCESS) {
6174                                 printf("test61 case %d should not be supported\n", i + 1);
6175                                 return;
6176                         }
6177                 }
6178         }
6179
6180         FAILED(supported[0] == SLJIT_SUCCESS && dbuf[1] != 66.725, "test61 case 2 failed\n");
6181         FAILED(supported[0] == SLJIT_SUCCESS && wbuf[0] != (sljit_sw)(dbuf), "test61 case 3 failed\n");
6182         FAILED(supported[1] == SLJIT_SUCCESS && dbuf[2] != 66.725, "test61 case 4 failed\n");
6183         FAILED(supported[1] == SLJIT_SUCCESS && wbuf[1] != (sljit_sw)(dbuf + 1), "test61 case 5 failed\n");
6184         FAILED(supported[2] == SLJIT_SUCCESS && sbuf[0] != -22.125, "test61 case 6 failed\n");
6185         FAILED(supported[2] == SLJIT_SUCCESS && wbuf[2] != (sljit_sw)(sbuf), "test61 case 7 failed\n");
6186         FAILED(supported[3] == SLJIT_SUCCESS && sbuf[2] != -22.125, "test61 case 8 failed\n");
6187         FAILED(supported[3] == SLJIT_SUCCESS && wbuf[3] != (sljit_sw)(sbuf + 2), "test61 case 9 failed\n");
6188         FAILED(supported[4] == SLJIT_SUCCESS && dbuf[3] != 66.725, "test61 case 10 failed\n");
6189         FAILED(supported[4] == SLJIT_SUCCESS && wbuf[4] != (sljit_sw)(dbuf), "test61 case 11 failed\n");
6190         FAILED(supported[5] == SLJIT_SUCCESS && sbuf[3] != -22.125, "test61 case 12 failed\n");
6191         FAILED(supported[5] == SLJIT_SUCCESS && wbuf[5] != (sljit_sw)(sbuf + 3), "test61 case 13 failed\n");
6192
6193         sljit_free_code(code.code, NULL);
6194         successful_tests++;
6195 }
6196
6197 static void test62(void)
6198 {
6199         /* Test fast calls flag preservation. */
6200         executable_code code1;
6201         executable_code code2;
6202         struct sljit_compiler* compiler;
6203
6204         if (verbose)
6205                 printf("Run test62\n");
6206
6207         /* A */
6208         compiler = sljit_create_compiler(NULL, NULL);
6209         FAILED(!compiler, "cannot create compiler\n");
6210         sljit_set_context(compiler, 0, SLJIT_ARGS1(W, W), 1, 1, 0, 0, 0);
6211
6212         sljit_emit_fast_enter(compiler, SLJIT_R0, 0);
6213         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_Z | SLJIT_SET_LESS, SLJIT_S0, 0, SLJIT_IMM, 42);
6214         sljit_emit_op_src(compiler, SLJIT_FAST_RETURN, SLJIT_R0, 0);
6215
6216         code1.code = sljit_generate_code(compiler);
6217         CHECK(compiler);
6218         sljit_free_compiler(compiler);
6219
6220         /* B */
6221         compiler = sljit_create_compiler(NULL, NULL);
6222         FAILED(!compiler, "cannot create compiler\n");
6223
6224         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(W, W), 1, 1, 0, 0, 0);
6225         sljit_emit_ijump(compiler, SLJIT_FAST_CALL, SLJIT_IMM, SLJIT_FUNC_ADDR(code1.code));
6226         sljit_set_current_flags(compiler, SLJIT_CURRENT_FLAGS_SUB | SLJIT_CURRENT_FLAGS_COMPARE | SLJIT_SET_Z | SLJIT_SET_LESS);
6227         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_ZERO);
6228         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_LESS);
6229         sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_S0, 0, SLJIT_S0, 0, SLJIT_IMM, 1);
6230         sljit_emit_op2(compiler, SLJIT_OR, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_S0, 0);
6231         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_R0, 0);
6232
6233         code2.code = sljit_generate_code(compiler);
6234         CHECK(compiler);
6235         sljit_free_compiler(compiler);
6236
6237         FAILED(code2.func1(88) != 0, "test62 case 1 failed\n");
6238         FAILED(code2.func1(42) != 1, "test62 case 2 failed\n");
6239         FAILED(code2.func1(0) != 2, "test62 case 3 failed\n");
6240
6241         sljit_free_code(code1.code, NULL);
6242         sljit_free_code(code2.code, NULL);
6243         successful_tests++;
6244 }
6245
6246 static void test63(void)
6247 {
6248         /* Test put label. */
6249         executable_code code;
6250         struct sljit_label *label[2];
6251         struct sljit_put_label *put_label[5];
6252         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
6253         sljit_uw addr[2];
6254         sljit_uw buf[4];
6255 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
6256         sljit_sw offs = SLJIT_W(0x123456789012);
6257 #else
6258         sljit_sw offs = 0x12345678;
6259 #endif
6260
6261         if (verbose)
6262                 printf("Run test63\n");
6263
6264         FAILED(!compiler, "cannot create compiler\n");
6265         buf[0] = 0;
6266         buf[1] = 0;
6267         buf[2] = 0;
6268         buf[3] = 0;
6269
6270         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(W, P), 3, 1, 0, 0, 2 * sizeof(sljit_sw));
6271
6272         put_label[0] = sljit_emit_put_label(compiler, SLJIT_R0, 0);
6273         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0);
6274
6275         put_label[1] = sljit_emit_put_label(compiler, SLJIT_MEM1(SLJIT_SP), sizeof(sljit_uw));
6276         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_uw), SLJIT_MEM1(SLJIT_SP), sizeof(sljit_uw));
6277
6278         label[0] = sljit_emit_label(compiler);
6279         sljit_set_put_label(put_label[0], label[0]);
6280         sljit_set_put_label(put_label[1], label[0]);
6281
6282         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)(buf + 2) - offs);
6283         put_label[2] = sljit_emit_put_label(compiler, SLJIT_MEM1(SLJIT_R0), offs);
6284
6285         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, (offs + (sljit_sw)sizeof(sljit_uw)) >> 1);
6286         put_label[3] = sljit_emit_put_label(compiler, SLJIT_MEM2(SLJIT_R0, SLJIT_R1), 1);
6287
6288         label[1] = sljit_emit_label(compiler);
6289         sljit_set_put_label(put_label[2], label[1]);
6290         sljit_set_put_label(put_label[3], label[1]);
6291
6292         put_label[4] = sljit_emit_put_label(compiler, SLJIT_RETURN_REG, 0);
6293         sljit_set_put_label(put_label[4], label[0]);
6294         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);
6295
6296         code.code = sljit_generate_code(compiler);
6297         CHECK(compiler);
6298
6299         addr[0] = sljit_get_label_addr(label[0]);
6300         addr[1] = sljit_get_label_addr(label[1]);
6301
6302         sljit_free_compiler(compiler);
6303
6304         FAILED(code.func1((sljit_sw)&buf) != (sljit_sw)addr[0], "test63 case 1 failed\n");
6305         FAILED(buf[0] != addr[0], "test63 case 2 failed\n");
6306         FAILED(buf[1] != addr[0], "test63 case 3 failed\n");
6307         FAILED(buf[2] != addr[1], "test63 case 4 failed\n");
6308         FAILED(buf[3] != addr[1], "test63 case 5 failed\n");
6309
6310         sljit_free_code(code.code, NULL);
6311         successful_tests++;
6312 }
6313
6314 static void test64(void)
6315 {
6316         /* Test put label with absolute label addresses */
6317         executable_code code;
6318         sljit_uw malloc_addr;
6319         struct sljit_label label[6];
6320         struct sljit_put_label *put_label[2];
6321         struct sljit_compiler* compiler;
6322         sljit_uw buf[7];
6323         sljit_s32 i;
6324 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
6325         /* Must be even because it is also used for addressing. */
6326         sljit_sw offs1 = SLJIT_W(0x1234567812l);
6327         sljit_sw offs2 = SLJIT_W(0x123456781122l);
6328         sljit_sw offs3 = SLJIT_W(0x7fffffff7ffl);
6329         sljit_sw offs4 = SLJIT_W(0x1234567811223344l);
6330 #else /* !SLJIT_64BIT_ARCHITECTURE */
6331         sljit_sw offs1 = (sljit_sw)0x80000000;
6332         sljit_sw offs2 = (sljit_sw)0xe0000000;
6333         sljit_sw offs3 = (sljit_sw)0x87654321;
6334         sljit_sw offs4 = (sljit_sw)0xffffffff;
6335 #endif /* SLJIT_64BIT_ARCHITECTURE */
6336
6337         if (verbose)
6338                 printf("Run test64\n");
6339
6340         /* lock next allocation; see sljit_test_malloc_exec() */
6341 #if !(defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED)
6342         malloc_addr = (sljit_uw)SLJIT_MALLOC_EXEC(1024, NULL);
6343
6344         if (!malloc_addr) {
6345                 printf("Cannot allocate executable memory\n");
6346                 return;
6347         }
6348
6349         compiler = sljit_create_compiler(NULL, (void*)malloc_addr);
6350         malloc_addr += (sljit_uw)SLJIT_EXEC_OFFSET((void*)malloc_addr);
6351 #else /* SLJIT_CONFIG_UNSUPPORTED */
6352         malloc_addr = 0;
6353         compiler = sljit_create_compiler(NULL, (void*)malloc_addr);
6354 #endif /* !SLJIT_CONFIG_UNSUPPORTED */
6355
6356         label[0].addr = 0x1234;
6357         label[0].size = (sljit_uw)0x1234 - malloc_addr;
6358
6359         label[1].addr = 0x12345678;
6360         label[1].size = (sljit_uw)0x12345678 - malloc_addr;
6361
6362         label[2].addr = (sljit_uw)offs1;
6363         label[2].size = (sljit_uw)offs1 - malloc_addr;
6364
6365         label[3].addr = (sljit_uw)offs2;
6366         label[3].size = (sljit_uw)offs2 - malloc_addr;
6367
6368         label[4].addr = (sljit_uw)offs3;
6369         label[4].size = (sljit_uw)offs3 - malloc_addr;
6370
6371         label[5].addr = (sljit_uw)offs4;
6372         label[5].size = (sljit_uw)offs4 - malloc_addr;
6373
6374         FAILED(!compiler, "cannot create compiler\n");
6375
6376         for (i = 0; i < 6; i++)
6377                 buf[i] = 0;
6378
6379         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(W, P), 3, 1, 0, 0, 2 * sizeof(sljit_sw));
6380
6381         put_label[0] = sljit_emit_put_label(compiler, SLJIT_R0, 0);
6382         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0);
6383
6384         put_label[1] = sljit_emit_put_label(compiler, SLJIT_MEM1(SLJIT_SP), sizeof(sljit_uw));
6385         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_uw), SLJIT_MEM1(SLJIT_SP), sizeof(sljit_uw));
6386
6387         sljit_set_put_label(put_label[0], &label[0]);
6388         sljit_set_put_label(put_label[1], &label[0]);
6389
6390         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)(buf + 2) - offs1);
6391         put_label[0] = sljit_emit_put_label(compiler, SLJIT_MEM1(SLJIT_R0), offs1);
6392
6393         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, (offs1 + (sljit_sw)sizeof(sljit_uw)) >> 1);
6394         put_label[1] = sljit_emit_put_label(compiler, SLJIT_MEM2(SLJIT_R0, SLJIT_R1), 1);
6395
6396         sljit_set_put_label(put_label[0], &label[1]);
6397         sljit_set_put_label(put_label[1], &label[1]);
6398
6399         put_label[0] = sljit_emit_put_label(compiler, SLJIT_R1, 0);
6400         sljit_set_put_label(put_label[0], &label[2]);
6401         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_uw), SLJIT_R1, 0);
6402
6403         put_label[0] = sljit_emit_put_label(compiler, SLJIT_R2, 0);
6404         sljit_set_put_label(put_label[0], &label[3]);
6405         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_uw), SLJIT_R2, 0);
6406
6407         put_label[0] = sljit_emit_put_label(compiler, SLJIT_R1, 0);
6408         sljit_set_put_label(put_label[0], &label[4]);
6409         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_uw), SLJIT_R1, 0);
6410
6411         put_label[0] = sljit_emit_put_label(compiler, SLJIT_RETURN_REG, 0);
6412         sljit_set_put_label(put_label[0], &label[5]);
6413         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);
6414
6415         code.code = sljit_generate_code(compiler);
6416         CHECK(compiler);
6417         sljit_free_compiler(compiler);
6418         SLJIT_ASSERT(SLJIT_FUNC_UADDR(code.code) >= malloc_addr && SLJIT_FUNC_UADDR(code.code) <= malloc_addr + 8);
6419
6420         FAILED(code.func1((sljit_sw)&buf) != (sljit_sw)label[5].addr, "test64 case 1 failed\n");
6421         FAILED(buf[0] != label[0].addr, "test64 case 2 failed\n");
6422         FAILED(buf[1] != label[0].addr, "test64 case 3 failed\n");
6423         FAILED(buf[2] != label[1].addr, "test64 case 4 failed\n");
6424         FAILED(buf[3] != label[1].addr, "test64 case 5 failed\n");
6425         FAILED(buf[4] != label[2].addr, "test64 case 6 failed\n");
6426         FAILED(buf[5] != label[3].addr, "test64 case 7 failed\n");
6427         FAILED(buf[6] != label[4].addr, "test64 case 8 failed\n");
6428
6429         sljit_free_code(code.code, NULL);
6430
6431         successful_tests++;
6432 }
6433
6434 static void test65(void)
6435 {
6436         /* Test jump tables. */
6437         executable_code code;
6438         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
6439         sljit_s32 i;
6440         /* Normally this table is allocated on the heap. */
6441         sljit_uw addr[64];
6442         struct sljit_label *labels[64];
6443         struct sljit_jump *jump;
6444
6445         if (verbose)
6446                 printf("Run test65\n");
6447
6448         FAILED(!compiler, "cannot create compiler\n");
6449
6450         sljit_emit_enter(compiler, 0, SLJIT_ARGS2(W, W, W), 1, 2, 0, 0, 0);
6451
6452         jump = sljit_emit_cmp(compiler, SLJIT_GREATER_EQUAL, SLJIT_S0, 0, SLJIT_IMM, 64);
6453         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)addr);
6454         sljit_emit_ijump(compiler, SLJIT_JUMP, SLJIT_MEM2(SLJIT_R0, SLJIT_S0), SLJIT_WORD_SHIFT);
6455
6456         for (i = 0; i < 64; i++) {
6457                 labels[i] = sljit_emit_label(compiler);
6458                 sljit_emit_op0(compiler, SLJIT_ENDBR);
6459                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_S1, 0, SLJIT_IMM, i * 2);
6460                 sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);
6461         }
6462
6463         sljit_set_label(jump, sljit_emit_label(compiler));
6464         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_IMM, -1);
6465
6466         code.code = sljit_generate_code(compiler);
6467         CHECK(compiler);
6468
6469         for (i = 0; i < 64; i++) {
6470                 addr[i] = sljit_get_label_addr(labels[i]);
6471         }
6472
6473         sljit_free_compiler(compiler);
6474
6475         FAILED(code.func2(64, 0) != -1, "test65 case 1 failed\n");
6476
6477         for (i = 0; i < 64; i++) {
6478                 FAILED(code.func2(i, i * 2) != i * 4, "test65 case 2 failed\n");
6479         }
6480
6481         sljit_free_code(code.code, NULL);
6482         successful_tests++;
6483 }
6484
6485 static void test66(void)
6486 {
6487         /* Test direct jumps (computed goto). */
6488         executable_code code;
6489         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
6490         sljit_s32 i;
6491         sljit_uw addr[64];
6492         struct sljit_label *labels[64];
6493
6494         if (verbose)
6495                 printf("Run test66\n");
6496
6497         FAILED(!compiler, "cannot create compiler\n");
6498
6499         sljit_emit_enter(compiler, 0, SLJIT_ARGS2(W, W, W), 1, 2, 0, 0, 0);
6500         sljit_emit_ijump(compiler, SLJIT_JUMP, SLJIT_S0, 0);
6501
6502         for (i = 0; i < 64; i++) {
6503                 labels[i] = sljit_emit_label(compiler);
6504                 sljit_emit_op0(compiler, SLJIT_ENDBR);
6505                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_S1, 0, SLJIT_IMM, i * 2);
6506                 sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);
6507         }
6508
6509         code.code = sljit_generate_code(compiler);
6510         CHECK(compiler);
6511
6512         for (i = 0; i < 64; i++) {
6513                 addr[i] = sljit_get_label_addr(labels[i]);
6514         }
6515
6516         sljit_free_compiler(compiler);
6517
6518         for (i = 0; i < 64; i++) {
6519                 FAILED(code.func2((sljit_sw)addr[i], i) != i * 3, "test66 case 1 failed\n");
6520         }
6521
6522         sljit_free_code(code.code, NULL);
6523         successful_tests++;
6524 }
6525
6526 static void test67(void)
6527 {
6528         /* Test skipping returns from fast calls (return type is fast). */
6529         executable_code code;
6530         struct sljit_compiler *compiler = sljit_create_compiler(NULL, NULL);
6531         struct sljit_jump *call, *jump;
6532         struct sljit_label *label;
6533
6534         if (verbose)
6535                 printf("Run test67\n");
6536
6537         FAILED(!compiler, "cannot create compiler\n");
6538
6539         sljit_emit_enter(compiler, 0, SLJIT_ARGS0(W), 3, 1, 0, 0, 0);
6540
6541         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0);
6542         call = sljit_emit_jump(compiler, SLJIT_FAST_CALL);
6543
6544         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_R0, 0);
6545
6546         /* First function, never returns. */
6547         label = sljit_emit_label(compiler);
6548         sljit_set_label(call, label);
6549         sljit_emit_fast_enter(compiler, SLJIT_R1, 0);
6550
6551         call = sljit_emit_jump(compiler, SLJIT_FAST_CALL);
6552
6553         /* Should never return here, marked by a segmentation fault if it does. */
6554         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM0(), 0);
6555
6556         /* Second function, skips the first function. */
6557         sljit_set_label(call, sljit_emit_label(compiler));
6558         sljit_emit_fast_enter(compiler, SLJIT_R2, 0);
6559
6560         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 1);
6561
6562         jump = sljit_emit_cmp(compiler, SLJIT_NOT_EQUAL, SLJIT_R0, 0, SLJIT_IMM, 1);
6563
6564         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_R1, 0);
6565         sljit_set_label(sljit_emit_jump(compiler, SLJIT_FAST_CALL), label);
6566         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 1);
6567         sljit_emit_op_src(compiler, SLJIT_SKIP_FRAMES_BEFORE_FAST_RETURN, SLJIT_S0, 0);
6568         sljit_emit_op_src(compiler, SLJIT_FAST_RETURN, SLJIT_S0, 0);
6569
6570         sljit_set_label(jump, sljit_emit_label(compiler));
6571         sljit_emit_op_src(compiler, SLJIT_SKIP_FRAMES_BEFORE_FAST_RETURN, SLJIT_R1, 0);
6572         sljit_emit_op_src(compiler, SLJIT_FAST_RETURN, SLJIT_R1, 0);
6573
6574         code.code = sljit_generate_code(compiler);
6575         CHECK(compiler);
6576
6577         sljit_free_compiler(compiler);
6578
6579         FAILED(code.func0() != 3, "test67 case 1 failed\n");
6580
6581         sljit_free_code(code.code, NULL);
6582         successful_tests++;
6583 }
6584
6585 static void test68(void)
6586 {
6587         /* Test skipping returns from fast calls (return type is normal). */
6588         executable_code code;
6589         struct sljit_compiler *compiler;
6590         struct sljit_jump *call, *jump;
6591         struct sljit_label *label;
6592         int i;
6593
6594         if (verbose)
6595                 printf("Run test68\n");
6596
6597         for (i = 0; i < 6; i++) {
6598                 compiler = sljit_create_compiler(NULL, NULL);
6599                 FAILED(!compiler, "cannot create compiler\n");
6600
6601                 sljit_emit_enter(compiler, 0, SLJIT_ARGS0(W), 2 + (i % 6), (i % 6), 0, 0, 0);
6602
6603                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0);
6604                 call = sljit_emit_jump(compiler, SLJIT_FAST_CALL);
6605
6606                 /* Should never return here, marked by a segmentation fault if it does. */
6607                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM0(), 0);
6608
6609                 /* Recursive fast call. */
6610                 label = sljit_emit_label(compiler);
6611                 sljit_set_label(call, label);
6612                 sljit_emit_fast_enter(compiler, SLJIT_R1, 0);
6613
6614                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 1);
6615
6616                 jump = sljit_emit_cmp(compiler, SLJIT_GREATER_EQUAL, SLJIT_R0, 0, SLJIT_IMM, 4);
6617
6618                 sljit_set_label(sljit_emit_jump(compiler, SLJIT_FAST_CALL), label);
6619
6620                 sljit_set_label(jump, sljit_emit_label(compiler));
6621                 sljit_emit_op0(compiler, SLJIT_SKIP_FRAMES_BEFORE_RETURN);
6622                 sljit_emit_return(compiler, SLJIT_MOV, SLJIT_R0, 0);
6623
6624                 code.code = sljit_generate_code(compiler);
6625                 CHECK(compiler);
6626
6627                 sljit_free_compiler(compiler);
6628
6629                 if (SLJIT_UNLIKELY(code.func0() != 4)) {
6630                         printf("test68 case %d failed\n", i + 1);
6631                         return;
6632                 }
6633                 sljit_free_code(code.code, NULL);
6634         }
6635
6636         successful_tests++;
6637 }
6638
6639 static void test69(void)
6640 {
6641         /* Test sljit_set_current_flags. */
6642         executable_code code;
6643         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
6644         sljit_sw buf[8];
6645         sljit_s32 i;
6646
6647         if (verbose)
6648                 printf("Run test69\n");
6649
6650         for (i = 0; i < 8; i++)
6651                 buf[i] = 4;
6652
6653         FAILED(!compiler, "cannot create compiler\n");
6654
6655         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, P), 3, 1, 0, 0, 0);
6656
6657         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)1 << ((sizeof (sljit_sw) * 8) - 2));
6658         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_R0, 0);
6659         sljit_emit_op2(compiler, SLJIT_ADD | SLJIT_SET_OVERFLOW, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_R1, 0);
6660         sljit_emit_label(compiler);
6661         sljit_set_current_flags(compiler, SLJIT_SET_OVERFLOW | SLJIT_CURRENT_FLAGS_ADD);
6662         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_OVERFLOW);
6663
6664         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 5);
6665         sljit_emit_op2(compiler, SLJIT_ADD | SLJIT_SET_OVERFLOW, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_R1, 0);
6666         sljit_emit_label(compiler);
6667         sljit_set_current_flags(compiler, SLJIT_SET_OVERFLOW | SLJIT_CURRENT_FLAGS_ADD);
6668         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_OVERFLOW);
6669
6670         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_R0, 0);
6671         sljit_emit_op2(compiler, SLJIT_MUL | SLJIT_SET_OVERFLOW, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_R1, 0);
6672         sljit_emit_label(compiler);
6673         sljit_set_current_flags(compiler, SLJIT_SET_OVERFLOW);
6674         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_OVERFLOW);
6675
6676         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 5);
6677         sljit_emit_op2(compiler, SLJIT_MUL | SLJIT_SET_OVERFLOW, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_R1, 0);
6678         sljit_emit_label(compiler);
6679         sljit_set_current_flags(compiler, SLJIT_SET_OVERFLOW);
6680         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_OVERFLOW);
6681
6682         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 6);
6683         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 5);
6684         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_GREATER, SLJIT_R1, 0, SLJIT_R2, 0);
6685         sljit_emit_label(compiler);
6686         sljit_set_current_flags(compiler, SLJIT_SET_GREATER | SLJIT_CURRENT_FLAGS_SUB | SLJIT_CURRENT_FLAGS_COMPARE);
6687         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_GREATER);
6688
6689         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_Z, SLJIT_R1, 0, SLJIT_R2, 0);
6690         sljit_emit_label(compiler);
6691         sljit_set_current_flags(compiler, SLJIT_SET_Z | SLJIT_CURRENT_FLAGS_SUB | SLJIT_CURRENT_FLAGS_COMPARE);
6692         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_ZERO);
6693
6694         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, (sljit_sw)(1u << 31));
6695         sljit_emit_op2u(compiler, SLJIT_ADD32 | SLJIT_SET_Z, SLJIT_R1, 0, SLJIT_R1, 0);
6696         sljit_emit_label(compiler);
6697         sljit_set_current_flags(compiler, SLJIT_SET_Z | SLJIT_CURRENT_FLAGS_32 | SLJIT_CURRENT_FLAGS_ADD);
6698         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_sw), SLJIT_ZERO);
6699
6700         sljit_emit_op2u(compiler, SLJIT_SHL32 | SLJIT_SET_Z, SLJIT_R1, 0, SLJIT_IMM, 1);
6701         sljit_emit_label(compiler);
6702         sljit_set_current_flags(compiler, SLJIT_SET_Z | SLJIT_CURRENT_FLAGS_32);
6703         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_sw), SLJIT_NOT_ZERO);
6704
6705         sljit_emit_return_void(compiler);
6706
6707         code.code = sljit_generate_code(compiler);
6708         CHECK(compiler);
6709         sljit_free_compiler(compiler);
6710
6711         code.func1((sljit_sw)&buf);
6712
6713         FAILED(buf[0] != 1, "test69 case 1 failed\n");
6714         FAILED(buf[1] != 2, "test69 case 2 failed\n");
6715         FAILED(buf[2] != 1, "test69 case 3 failed\n");
6716         FAILED(buf[3] != 2, "test69 case 4 failed\n");
6717         FAILED(buf[4] != 1, "test69 case 5 failed\n");
6718         FAILED(buf[5] != 2, "test69 case 6 failed\n");
6719         FAILED(buf[6] != 1, "test69 case 7 failed\n");
6720         FAILED(buf[7] != 2, "test69 case 8 failed\n");
6721
6722         sljit_free_code(code.code, NULL);
6723         successful_tests++;
6724 }
6725
6726 static void test70(void)
6727 {
6728         /* Test argument passing to sljit_emit_enter. */
6729         executable_code code;
6730         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
6731         sljit_sw wbuf[2];
6732         sljit_s32 ibuf[2];
6733         sljit_f64 dbuf[3];
6734         sljit_f32 fbuf[2];
6735
6736         if (verbose)
6737                 printf("Run test70\n");
6738
6739         wbuf[0] = 0;
6740         wbuf[1] = 0;
6741         ibuf[0] = 0;
6742         ibuf[1] = 0;
6743
6744         FAILED(!compiler, "cannot create compiler\n");
6745
6746         sljit_emit_enter(compiler, 0, SLJIT_ARGS4(VOID, 32, W, 32, W), 1, 4, 0, 0, 0);
6747         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&wbuf);
6748         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_S1, 0);
6749         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_sw), SLJIT_S3, 0);
6750         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&ibuf);
6751         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_S0, 0);
6752         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_s32), SLJIT_S2, 0);
6753         sljit_emit_return_void(compiler);
6754
6755         code.code = sljit_generate_code(compiler);
6756         CHECK(compiler);
6757         sljit_free_compiler(compiler);
6758
6759         code.test70_f1(-1478, 9476, 4928, -6832);
6760
6761         FAILED(wbuf[0] != 9476, "test70 case 1 failed\n");
6762         FAILED(wbuf[1] != -6832, "test70 case 2 failed\n");
6763         FAILED(ibuf[0] != -1478, "test70 case 3 failed\n");
6764         FAILED(ibuf[1] != 4928, "test70 case 4 failed\n");
6765
6766         sljit_free_code(code.code, NULL);
6767
6768         compiler = sljit_create_compiler(NULL, NULL);
6769         FAILED(!compiler, "cannot create compiler\n");
6770
6771         sljit_emit_enter(compiler, SLJIT_ENTER_CDECL, SLJIT_ARGS4(VOID, 32, 32, W, W), 1, 4, 0, 0, 0);
6772         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&wbuf);
6773         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_S0, 0);
6774         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_sw), SLJIT_S1, 0);
6775         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&ibuf);
6776         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_S2, 0);
6777         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_s32), SLJIT_S3, 0);
6778         sljit_emit_return_void(compiler);
6779
6780         code.code = sljit_generate_code(compiler);
6781         CHECK(compiler);
6782         sljit_free_compiler(compiler);
6783
6784         code.test70_f2(4721, 7892, -3579, -4830);
6785
6786         FAILED(wbuf[0] != 4721, "test70 case 5 failed\n");
6787         FAILED(wbuf[1] != 7892, "test70 case 6 failed\n");
6788         FAILED(ibuf[0] != -3579, "test70 case 7 failed\n");
6789         FAILED(ibuf[1] != -4830, "test70 case 8 failed\n");
6790
6791         sljit_free_code(code.code, NULL);
6792
6793         if (sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
6794                 wbuf[0] = 0;
6795                 ibuf[0] = 0;
6796                 dbuf[0] = 0;
6797                 fbuf[0] = 0;
6798
6799                 compiler = sljit_create_compiler(NULL, NULL);
6800                 FAILED(!compiler, "cannot create compiler\n");
6801
6802                 sljit_emit_enter(compiler, 0, SLJIT_ARGS4(VOID, 32, F32, W, F64), 2, 2, 2, 0, 0);
6803                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM0(), (sljit_sw)&wbuf, SLJIT_S1, 0);
6804                 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM0(), (sljit_sw)&ibuf, SLJIT_S0, 0);
6805                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM0(), (sljit_sw)&dbuf, SLJIT_FR1, 0);
6806                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM0(), (sljit_sw)&fbuf, SLJIT_FR0, 0);
6807                 sljit_emit_return_void(compiler);
6808
6809                 code.code = sljit_generate_code(compiler);
6810                 CHECK(compiler);
6811                 sljit_free_compiler(compiler);
6812
6813                 code.test70_f3(-6834, 674.5, 2789, -895.25);
6814
6815                 FAILED(wbuf[0] != 2789, "test70 case 9 failed\n");
6816                 FAILED(ibuf[0] != -6834, "test70 case 10 failed\n");
6817                 FAILED(dbuf[0] != -895.25, "test70 case 11 failed\n");
6818                 FAILED(fbuf[0] != 674.5, "test70 case 12 failed\n");
6819
6820                 ibuf[0] = 0;
6821                 dbuf[0] = 0;
6822                 fbuf[0] = 0;
6823                 fbuf[1] = 0;
6824
6825                 compiler = sljit_create_compiler(NULL, NULL);
6826                 FAILED(!compiler, "cannot create compiler\n");
6827
6828                 sljit_emit_enter(compiler, 0, SLJIT_ARGS4(VOID, F32, F64, F32, 32), 1, 1, 3, 0, 0);
6829                 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM0(), (sljit_sw)&ibuf, SLJIT_S0, 0);
6830                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM0(), (sljit_sw)&dbuf, SLJIT_FR1, 0);
6831                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&fbuf);
6832                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_FR0, 0);
6833                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_f32), SLJIT_FR2, 0);
6834                 sljit_emit_return_void(compiler);
6835
6836                 code.code = sljit_generate_code(compiler);
6837                 CHECK(compiler);
6838                 sljit_free_compiler(compiler);
6839
6840                 code.test70_f4(-4712.5, 5342.25, 2904.25, -4607);
6841
6842                 FAILED(ibuf[0] != -4607, "test70 case 13 failed\n");
6843                 FAILED(dbuf[0] != 5342.25, "test70 case 14 failed\n");
6844                 FAILED(fbuf[0] != -4712.5, "test70 case 15 failed\n");
6845                 FAILED(fbuf[1] != 2904.25, "test70 case 16 failed\n");
6846
6847                 ibuf[0] = 0;
6848                 dbuf[0] = 0;
6849                 fbuf[0] = 0;
6850                 fbuf[1] = 0;
6851
6852                 compiler = sljit_create_compiler(NULL, NULL);
6853                 FAILED(!compiler, "cannot create compiler\n");
6854
6855                 sljit_emit_enter(compiler, 0, SLJIT_ARGS4(VOID, F64, F32, 32, F32), 1, 1, 3, 0, 0);
6856                 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM0(), (sljit_sw)&ibuf, SLJIT_S0, 0);
6857                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM0(), (sljit_sw)&dbuf, SLJIT_FR0, 0);
6858                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&fbuf);
6859                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_FR1, 0);
6860                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_f32), SLJIT_FR2, 0);
6861
6862                 sljit_emit_return_void(compiler);
6863
6864                 code.code = sljit_generate_code(compiler);
6865                 CHECK(compiler);
6866                 sljit_free_compiler(compiler);
6867
6868                 code.test70_f5(3578.5, 4619.25, 6859, -1807.75);
6869
6870                 FAILED(ibuf[0] != 6859, "test70 case 17 failed\n");
6871                 FAILED(dbuf[0] != 3578.5, "test70 case 18 failed\n");
6872                 FAILED(fbuf[0] != 4619.25, "test70 case 19 failed\n");
6873                 FAILED(fbuf[1] != -1807.75, "test70 case 20 failed\n");
6874
6875                 ibuf[0] = 0;
6876                 dbuf[0] = 0;
6877                 dbuf[1] = 0;
6878                 fbuf[0] = 0;
6879
6880                 compiler = sljit_create_compiler(NULL, NULL);
6881                 FAILED(!compiler, "cannot create compiler\n");
6882
6883                 sljit_emit_enter(compiler, 0, SLJIT_ARGS4(VOID, F64, 32, F32, F64), SLJIT_NUMBER_OF_SCRATCH_REGISTERS + 2, 1, 3, 0, 33);
6884                 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM0(), (sljit_sw)&ibuf, SLJIT_S0, 0);
6885                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&dbuf);
6886                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_FR0, 0);
6887                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_f64), SLJIT_FR2, 0);
6888                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM0(), (sljit_sw)&fbuf, SLJIT_FR1, 0);
6889                 sljit_emit_return_void(compiler);
6890
6891                 code.code = sljit_generate_code(compiler);
6892                 CHECK(compiler);
6893                 sljit_free_compiler(compiler);
6894
6895                 code.test70_f6(2740.75, -2651, -7909.25, 3671.5);
6896
6897                 FAILED(ibuf[0] != -2651, "test70 case 21 failed\n");
6898                 FAILED(dbuf[0] != 2740.75, "test70 case 22 failed\n");
6899                 FAILED(dbuf[1] != 3671.5, "test70 case 23 failed\n");
6900                 FAILED(fbuf[0] != -7909.25, "test70 case 24 failed\n");
6901
6902                 wbuf[0] = 0;
6903                 ibuf[0] = 0;
6904                 ibuf[1] = 0;
6905                 fbuf[0] = 0;
6906
6907                 compiler = sljit_create_compiler(NULL, NULL);
6908                 FAILED(!compiler, "cannot create compiler\n");
6909
6910                 sljit_emit_enter(compiler, 0, SLJIT_ARGS4(VOID, F32, 32, W, 32), 1, 3, 1, 0, 1);
6911                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM0(), (sljit_sw)&wbuf, SLJIT_S1, 0);
6912                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&ibuf);
6913                 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_S0, 0);
6914                 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_s32), SLJIT_S2, 0);
6915                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM0(), (sljit_sw)&fbuf, SLJIT_FR0, 0);
6916                 sljit_emit_return_void(compiler);
6917
6918                 code.code = sljit_generate_code(compiler);
6919                 CHECK(compiler);
6920                 sljit_free_compiler(compiler);
6921
6922                 code.test70_f7(-5219.25, -4530, 7214, 6741);
6923
6924                 FAILED(wbuf[0] != 7214, "test70 case 25 failed\n");
6925                 FAILED(ibuf[0] != -4530, "test70 case 26 failed\n");
6926                 FAILED(ibuf[1] != 6741, "test70 case 27 failed\n");
6927                 FAILED(fbuf[0] != -5219.25, "test70 case 28 failed\n");
6928
6929                 wbuf[0] = 0;
6930                 wbuf[1] = 0;
6931                 dbuf[0] = 0;
6932                 dbuf[1] = 0;
6933
6934                 compiler = sljit_create_compiler(NULL, NULL);
6935                 FAILED(!compiler, "cannot create compiler\n");
6936
6937                 sljit_emit_enter(compiler, 0, SLJIT_ARGS4(VOID, F64, F64, W, W), 1, 5, 2, 0, SLJIT_MAX_LOCAL_SIZE - 1);
6938                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), 0, SLJIT_S0, 0);
6939                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_SP), SLJIT_MAX_LOCAL_SIZE - 2 * sizeof(sljit_f64), SLJIT_FR0, 0);
6940                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&wbuf);
6941                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_S0, 0);
6942                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_sw), SLJIT_S1, 0);
6943                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&dbuf);
6944                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_FR0, 0);
6945                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_f64), SLJIT_FR1, 0);
6946                 sljit_emit_return_void(compiler);
6947
6948                 code.code = sljit_generate_code(compiler);
6949                 CHECK(compiler);
6950                 sljit_free_compiler(compiler);
6951
6952                 code.test70_f8(-3749.75, 5280.5, 9134, -6506);
6953
6954                 FAILED(wbuf[0] != 9134, "test70 case 29 failed\n");
6955                 FAILED(wbuf[1] != -6506, "test70 case 30 failed\n");
6956                 FAILED(dbuf[0] != -3749.75, "test70 case 31 failed\n");
6957                 FAILED(dbuf[1] != 5280.5, "test70 case 32 failed\n");
6958
6959                 wbuf[0] = 0;
6960                 dbuf[0] = 0;
6961                 dbuf[1] = 0;
6962                 dbuf[2] = 0;
6963
6964                 compiler = sljit_create_compiler(NULL, NULL);
6965                 FAILED(!compiler, "cannot create compiler\n");
6966
6967                 sljit_emit_enter(compiler, 0, SLJIT_ARGS4(VOID, F64, F64, W, F64), 1, 1, 3, 0, SLJIT_MAX_LOCAL_SIZE);
6968                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM0(), (sljit_sw)&wbuf, SLJIT_S0, 0);
6969                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&dbuf);
6970                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_FR0, 0);
6971                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_f64), SLJIT_FR1, 0);
6972                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_R0), 2 * sizeof(sljit_f64), SLJIT_FR2, 0);
6973
6974                 sljit_emit_return_void(compiler);
6975
6976                 code.code = sljit_generate_code(compiler);
6977                 CHECK(compiler);
6978                 sljit_free_compiler(compiler);
6979
6980                 code.test70_f9(-6049.25, 7301.5, 4610, -4312.75);
6981
6982                 FAILED(wbuf[0] != 4610, "test70 case 33 failed\n");
6983                 FAILED(dbuf[0] != -6049.25, "test70 case 34 failed\n");
6984                 FAILED(dbuf[1] != 7301.5, "test70 case 35 failed\n");
6985                 FAILED(dbuf[2] != -4312.75, "test70 case 36 failed\n");
6986
6987                 ibuf[0] = 0;
6988                 dbuf[0] = 0;
6989                 dbuf[1] = 0;
6990                 dbuf[2] = 0;
6991
6992                 compiler = sljit_create_compiler(NULL, NULL);
6993                 FAILED(!compiler, "cannot create compiler\n");
6994
6995                 sljit_emit_enter(compiler, 0, SLJIT_ARGS4(VOID, F64, F64, F64, 32), 1, 1, 3, 0, 0);
6996                 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM0(), (sljit_sw)&ibuf, SLJIT_S0, 0);
6997                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&dbuf);
6998                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_FR0, 0);
6999                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_f64), SLJIT_FR1, 0);
7000                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_R0), 2 * sizeof(sljit_f64), SLJIT_FR2, 0);
7001
7002                 sljit_emit_return_void(compiler);
7003
7004                 code.code = sljit_generate_code(compiler);
7005                 CHECK(compiler);
7006                 sljit_free_compiler(compiler);
7007
7008                 code.test70_f10(4810.5, -9148.75, 8601.25, 6703);
7009
7010                 FAILED(ibuf[0] != 6703, "test70 case 37 failed\n");
7011                 FAILED(dbuf[0] != 4810.5, "test70 case 38 failed\n");
7012                 FAILED(dbuf[1] != -9148.75, "test70 case 39 failed\n");
7013                 FAILED(dbuf[2] != 8601.25, "test70 case 40 failed\n");
7014         }
7015
7016         successful_tests++;
7017 }
7018
7019 #if !(defined SLJIT_CONFIG_SPARC && SLJIT_CONFIG_SPARC)
7020
7021 static sljit_sw SLJIT_FUNC test71_f1(sljit_sw a)
7022 {
7023         return a + 10000;
7024 }
7025
7026 static sljit_sw SLJIT_FUNC test71_f2(sljit_sw a, sljit_s32 b, sljit_s32 c, sljit_sw d)
7027 {
7028         return a | b | c | d;
7029 }
7030
7031 static sljit_sw test71_f3(sljit_sw a, sljit_s32 b, sljit_s32 c, sljit_sw d)
7032 {
7033         return a | b | c | d;
7034 }
7035
7036 static sljit_sw test71_f4(sljit_sw a, sljit_s32 b, sljit_s32 c, sljit_sw d)
7037 {
7038         SLJIT_UNUSED_ARG(a);
7039         return b | c | d;
7040 }
7041
7042 static sljit_sw test71_f5(void)
7043 {
7044         return 7461932;
7045 }
7046
7047 static sljit_sw SLJIT_FUNC test71_f6(sljit_f64 a, sljit_f64 b, sljit_f64 c, sljit_f64 d)
7048 {
7049         if (a == 1345.5 && b == -8724.25 && c == 9034.75 && d == 6307.5)
7050                 return 8920567;
7051         return 0;
7052 }
7053
7054 static sljit_sw SLJIT_FUNC test71_f7(sljit_f64 a, sljit_f64 b, sljit_f64 c, sljit_sw d)
7055 {
7056         if (a == 4061.25 && b == -3291.75 && c == 8703.5 && d == 1706)
7057                 return 5074526;
7058         return 0;
7059 }
7060
7061 #endif /* !SLJIT_CONFIG_SPARC */
7062
7063 static void test71(void)
7064 {
7065 #if !(defined SLJIT_CONFIG_SPARC && SLJIT_CONFIG_SPARC)
7066         /* Test tail calls. */
7067         executable_code code;
7068         struct sljit_compiler* compiler;
7069         struct sljit_jump *jump;
7070         sljit_uw jump_addr;
7071         sljit_sw executable_offset;
7072         sljit_sw wbuf[1];
7073         sljit_f64 dbuf[4];
7074
7075         if (verbose)
7076                 printf("Run test71\n");
7077
7078         /* Next test. */
7079
7080         compiler = sljit_create_compiler(NULL, NULL);
7081         FAILED(!compiler, "cannot create compiler\n");
7082
7083         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(W, W), 4, 4, 0, 0, 0);
7084         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_S0, 0);
7085         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0);
7086         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 0);
7087         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, 0);
7088         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, -1);
7089         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_IMM, -1);
7090         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, -1);
7091         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S3, 0, SLJIT_IMM, -1);
7092         sljit_emit_icall(compiler, SLJIT_CALL | SLJIT_CALL_RETURN, SLJIT_ARGS1(W, W), SLJIT_IMM, SLJIT_FUNC_ADDR(test71_f1));
7093         /* Should crash. */
7094         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM0(), 0);
7095
7096         code.code = sljit_generate_code(compiler);
7097         CHECK(compiler);
7098         sljit_free_compiler(compiler);
7099
7100         FAILED(code.func1(7987) != 17987, "test71 case 1 failed\n");
7101
7102         /* Next test. */
7103
7104         compiler = sljit_create_compiler(NULL, NULL);
7105         FAILED(!compiler, "cannot create compiler\n");
7106
7107         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(W, W), 1, 4, 0, 0, 0);
7108         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_S0, 0);
7109         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, -1);
7110         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_IMM, -1);
7111         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, -1);
7112         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S3, 0, SLJIT_IMM, -1);
7113         jump = sljit_emit_call(compiler, SLJIT_CALL | SLJIT_REWRITABLE_JUMP | SLJIT_CALL_RETURN, SLJIT_ARGS1(W, W));
7114         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM0(), 0);
7115
7116         sljit_set_target(jump, 0);
7117
7118         code.code = sljit_generate_code(compiler);
7119         CHECK(compiler);
7120
7121         executable_offset = sljit_get_executable_offset(compiler);
7122         jump_addr = sljit_get_jump_addr(jump);
7123         sljit_free_compiler(compiler);
7124
7125         sljit_set_jump_addr(jump_addr, SLJIT_FUNC_UADDR(test71_f1), executable_offset);
7126
7127         FAILED(code.func1(3903) != 13903, "test71 case 2 failed\n");
7128
7129         /* Next test. */
7130
7131         compiler = sljit_create_compiler(NULL, NULL);
7132         FAILED(!compiler, "cannot create compiler\n");
7133
7134         sljit_emit_enter(compiler, 0, SLJIT_ARGS0(W), 4, 2, 0, 0, SLJIT_MAX_LOCAL_SIZE);
7135         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), 0, SLJIT_IMM, SLJIT_FUNC_ADDR(test71_f2));
7136         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0x28000000);
7137         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, 0x00140000);
7138         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R2, 0, SLJIT_IMM, 0x00002800);
7139         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, 0x00000041);
7140         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, -1);
7141         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_IMM, -1);
7142         sljit_emit_icall(compiler, SLJIT_CALL | SLJIT_CALL_RETURN, SLJIT_ARGS4(W, W, 32, 32, W), SLJIT_MEM1(SLJIT_SP), 0);
7143         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM0(), 0);
7144
7145         code.code = sljit_generate_code(compiler);
7146         CHECK(compiler);
7147         sljit_free_compiler(compiler);
7148
7149         FAILED(code.func0() != 0x28142841, "test71 case 3 failed\n");
7150
7151         /* Next test. */
7152
7153         compiler = sljit_create_compiler(NULL, NULL);
7154         FAILED(!compiler, "cannot create compiler\n");
7155
7156         sljit_emit_enter(compiler, SLJIT_ENTER_CDECL, SLJIT_ARGS4(W, W, 32, 32, W), 4, 4, 0, 0, 9);
7157         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_S0, 0);
7158         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_S1, 0);
7159         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R2, 0, SLJIT_S2, 0);
7160         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_S3, 0);
7161         sljit_emit_icall(compiler, SLJIT_CALL | SLJIT_CALL_RETURN, SLJIT_ARGS4(W, W, 32, 32, W), SLJIT_IMM, SLJIT_FUNC_ADDR(test71_f2));
7162         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM0(), 0);
7163
7164         code.code = sljit_generate_code(compiler);
7165         CHECK(compiler);
7166         sljit_free_compiler(compiler);
7167
7168         FAILED(code.test71_f1(0x650000, 0x13, 0x8400, 0x29000000) != 0x29658413, "test71 case 4 failed\n");
7169
7170         sljit_free_code(code.code, NULL);
7171
7172         /* Next test. */
7173
7174         compiler = sljit_create_compiler(NULL, NULL);
7175         FAILED(!compiler, "cannot create compiler\n");
7176
7177         sljit_emit_enter(compiler, 0, SLJIT_ARGS0(W), 4, 4, 0, 0, SLJIT_MAX_LOCAL_SIZE);
7178         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S3, 0, SLJIT_IMM, SLJIT_FUNC_ADDR(test71_f2));
7179         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)0x81000000);
7180         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, 0x00480000);
7181         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R2, 0, SLJIT_IMM, 0x00002100);
7182         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, 0x00000014);
7183         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, -1);
7184         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_IMM, -1);
7185         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, -1);
7186         sljit_emit_icall(compiler, SLJIT_CALL | SLJIT_CALL_RETURN, SLJIT_ARGS4(W, W, 32, 32, W), SLJIT_S3, 0);
7187         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM0(), 0);
7188
7189         code.code = sljit_generate_code(compiler);
7190         CHECK(compiler);
7191         sljit_free_compiler(compiler);
7192
7193         FAILED(code.func0() != (sljit_sw)0x81482114, "test71 case 5 failed\n");
7194
7195         sljit_free_code(code.code, NULL);
7196
7197         /* Next test. */
7198
7199         compiler = sljit_create_compiler(NULL, NULL);
7200         FAILED(!compiler, "cannot create compiler\n");
7201
7202         sljit_emit_enter(compiler, 0, SLJIT_ARGS3(W, W, W, W), 4, 4, 0, 0, 0);
7203         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_S0, 0);
7204         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_S1, 0);
7205         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R2, 0, SLJIT_S2, 0);
7206         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, 0x48000000);
7207         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, -1);
7208         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_IMM, -1);
7209         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, -1);
7210         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S3, 0, SLJIT_IMM, -1);
7211         sljit_emit_icall(compiler, SLJIT_CALL_CDECL | SLJIT_CALL_RETURN, SLJIT_ARGS4(W, W, 32, 32, W), SLJIT_IMM, SLJIT_FUNC_ADDR(test71_f3));
7212         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM0(), 0);
7213
7214         code.code = sljit_generate_code(compiler);
7215         CHECK(compiler);
7216         sljit_free_compiler(compiler);
7217
7218         FAILED(code.func3(0x12, 0x8800, 0x240000) != 0x48248812, "test71 case 6 failed\n");
7219
7220         sljit_free_code(code.code, NULL);
7221
7222         /* Next test. */
7223
7224         compiler = sljit_create_compiler(NULL, NULL);
7225         FAILED(!compiler, "cannot create compiler\n");
7226
7227         sljit_emit_enter(compiler, SLJIT_ENTER_CDECL, SLJIT_ARGS0(W), 4, 0, 0, 0, 0);
7228         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_FUNC_ADDR(test71_f4));
7229         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, 0x342);
7230         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R2, 0, SLJIT_IMM, 0x451000);
7231         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, 0x21000000);
7232         sljit_emit_icall(compiler, SLJIT_CALL_CDECL | SLJIT_CALL_RETURN, SLJIT_ARGS4(W, W, 32, 32, W), SLJIT_R0, 0);
7233         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM0(), 0);
7234
7235         code.code = sljit_generate_code(compiler);
7236         CHECK(compiler);
7237         sljit_free_compiler(compiler);
7238
7239         FAILED(code.func0() != 0x21451342, "test71 case 7 failed\n");
7240
7241         sljit_free_code(code.code, NULL);
7242
7243         /* Next test. */
7244
7245         compiler = sljit_create_compiler(NULL, NULL);
7246         FAILED(!compiler, "cannot create compiler\n");
7247
7248         sljit_emit_enter(compiler, SLJIT_ENTER_CDECL, SLJIT_ARGS0(W), 1, 0, 0, 0, 9);
7249         sljit_emit_icall(compiler, SLJIT_CALL_CDECL | SLJIT_CALL_RETURN, SLJIT_ARGS0(W), SLJIT_IMM, SLJIT_FUNC_ADDR(test71_f5));
7250         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM0(), 0);
7251
7252         code.code = sljit_generate_code(compiler);
7253         CHECK(compiler);
7254         sljit_free_compiler(compiler);
7255
7256         FAILED(code.func0() != 7461932, "test71 case 8 failed\n");
7257
7258         sljit_free_code(code.code, NULL);
7259
7260         if (sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
7261                 /* Next test. */
7262
7263                 dbuf[0] = 9034.75;
7264                 dbuf[1] = 6307.5;
7265
7266                 compiler = sljit_create_compiler(NULL, NULL);
7267                 FAILED(!compiler, "cannot create compiler\n");
7268
7269                 sljit_emit_enter(compiler, SLJIT_ENTER_CDECL, SLJIT_ARGS2(W, F64, F64), 1, 1, 4, 0, 0);
7270                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&dbuf);
7271                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_R0), 0);
7272                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR3, 0, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_f64));
7273                 sljit_emit_icall(compiler, SLJIT_CALL | SLJIT_CALL_RETURN, SLJIT_ARGS4(W, F64, F64, F64, F64), SLJIT_IMM, SLJIT_FUNC_ADDR(test71_f6));
7274                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM0(), 0);
7275
7276                 code.code = sljit_generate_code(compiler);
7277                 CHECK(compiler);
7278                 sljit_free_compiler(compiler);
7279
7280                 FAILED(code.test71_f2(1345.5, -8724.25) != 8920567, "test71 case 9 failed\n");
7281
7282                 sljit_free_code(code.code, NULL);
7283
7284                 /* Next test. */
7285
7286                 wbuf[0] = SLJIT_FUNC_ADDR(test71_f6);
7287
7288                 compiler = sljit_create_compiler(NULL, NULL);
7289                 FAILED(!compiler, "cannot create compiler\n");
7290
7291                 sljit_emit_enter(compiler, 0, SLJIT_ARGS4(W, F64, F64, F64, F64), 1, 0, 4, 0, 0);
7292                 sljit_emit_icall(compiler, SLJIT_CALL | SLJIT_CALL_RETURN, SLJIT_ARGS4(W, F64, F64, F64, F64), SLJIT_MEM0(), (sljit_sw)wbuf);
7293                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM0(), 0);
7294
7295                 code.code = sljit_generate_code(compiler);
7296                 CHECK(compiler);
7297                 sljit_free_compiler(compiler);
7298
7299                 FAILED(code.test71_f3(1345.5, -8724.25, 9034.75, 6307.5) != 8920567, "test71 case 10 failed\n");
7300
7301                 sljit_free_code(code.code, NULL);
7302
7303                 /* Next test. */
7304
7305                 compiler = sljit_create_compiler(NULL, NULL);
7306                 FAILED(!compiler, "cannot create compiler\n");
7307
7308                 sljit_emit_enter(compiler, 0, SLJIT_ARGS3(W, F64, F64, F64), 1, 0, 4, 0, 0);
7309                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 1706);
7310                 jump = sljit_emit_call(compiler, SLJIT_CALL | SLJIT_CALL_RETURN, SLJIT_ARGS4(W, F64, F64, F64, W));
7311                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM0(), 0);
7312
7313                 sljit_set_target(jump, SLJIT_FUNC_UADDR(test71_f7));
7314
7315                 code.code = sljit_generate_code(compiler);
7316                 CHECK(compiler);
7317                 sljit_free_compiler(compiler);
7318
7319                 FAILED(code.test71_f4(4061.25, -3291.75, 8703.5) != 5074526, "test71 case 11 failed\n");
7320
7321                 sljit_free_code(code.code, NULL);
7322
7323                 /* Next test. */
7324
7325                 compiler = sljit_create_compiler(NULL, NULL);
7326                 FAILED(!compiler, "cannot create compiler\n");
7327
7328                 sljit_emit_enter(compiler, 0, SLJIT_ARGS3(W, F64, F64, F64), SLJIT_NUMBER_OF_SCRATCH_REGISTERS + 1, 0, 4, 0, 0);
7329                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 1706);
7330                 jump = sljit_emit_call(compiler, SLJIT_CALL | SLJIT_CALL_RETURN, SLJIT_ARGS4(W, F64, F64, F64, W));
7331                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM0(), 0);
7332
7333                 sljit_set_target(jump, SLJIT_FUNC_UADDR(test71_f7));
7334
7335                 code.code = sljit_generate_code(compiler);
7336                 CHECK(compiler);
7337                 sljit_free_compiler(compiler);
7338
7339                 FAILED(code.test71_f4(4061.25, -3291.75, 8703.5) != 5074526, "test71 case 12 failed\n");
7340
7341                 sljit_free_code(code.code, NULL);
7342
7343                 /* Next test. */
7344
7345                 compiler = sljit_create_compiler(NULL, NULL);
7346                 FAILED(!compiler, "cannot create compiler\n");
7347
7348                 sljit_emit_enter(compiler, 0, SLJIT_ARGS3(W, F64, F64, F64), SLJIT_NUMBER_OF_SCRATCH_REGISTERS + 1, 1, 3, 0, SLJIT_MAX_LOCAL_SIZE);
7349                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 1706);
7350                 jump = sljit_emit_call(compiler, SLJIT_CALL | SLJIT_CALL_RETURN, SLJIT_ARGS4(W, F64, F64, F64, W));
7351                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM0(), 0);
7352
7353                 sljit_set_target(jump, SLJIT_FUNC_UADDR(test71_f7));
7354
7355                 code.code = sljit_generate_code(compiler);
7356                 CHECK(compiler);
7357                 sljit_free_compiler(compiler);
7358
7359                 FAILED(code.test71_f4(4061.25, -3291.75, 8703.5) != 5074526, "test71 case 13 failed\n");
7360
7361                 sljit_free_code(code.code, NULL);
7362         }
7363 #endif /* !SLJIT_CONFIG_SPARC */
7364
7365         successful_tests++;
7366 }
7367
7368 static void test72(void)
7369 {
7370         /* Test using all fpu registers. */
7371         executable_code code;
7372         struct sljit_compiler* compiler = sljit_create_compiler(NULL, NULL);
7373         sljit_f64 buf[SLJIT_NUMBER_OF_FLOAT_REGISTERS];
7374         sljit_f64 buf2[2];
7375         struct sljit_jump *jump;
7376         sljit_s32 i;
7377
7378         if (verbose)
7379                 printf("Run test72\n");
7380
7381         if (!sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
7382                 if (verbose)
7383                         printf("no fpu available, test72 skipped\n");
7384                 successful_tests++;
7385                 if (compiler)
7386                         sljit_free_compiler(compiler);
7387                 return;
7388         }
7389
7390         /* Next test. */
7391         FAILED(!compiler, "cannot create compiler\n");
7392
7393         buf2[0] = 7.75;
7394         buf2[1] = -8.25;
7395
7396         for (i = 0; i < SLJIT_NUMBER_OF_FLOAT_REGISTERS; i++)
7397                 buf[i] = 0.0;
7398
7399         sljit_emit_enter(compiler, 0, SLJIT_ARGS2(VOID, P, P), 1, 2, SLJIT_NUMBER_OF_FLOAT_REGISTERS, 0, 0);
7400         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S1), 0);
7401         for (i = 1; i < SLJIT_NUMBER_OF_FLOAT_REGISTERS; i++)
7402                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR(i), 0, SLJIT_FR0, 0);
7403
7404         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_S1, 0);
7405         jump = sljit_emit_call(compiler, SLJIT_CALL, SLJIT_ARGS1(VOID, W));
7406
7407         for (i = 0; i < SLJIT_NUMBER_OF_FLOAT_REGISTERS; i++)
7408                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), i * (sljit_sw)sizeof(sljit_f64), SLJIT_FR(i), 0);
7409         sljit_emit_return_void(compiler);
7410
7411         /* Called function. */
7412         sljit_set_label(jump, sljit_emit_label(compiler));
7413         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, P), 0, 1, SLJIT_NUMBER_OF_FLOAT_REGISTERS, 0, 0);
7414
7415         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64));
7416         for (i = 1; i < SLJIT_NUMBER_OF_FLOAT_REGISTERS; i++)
7417                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR(i), 0, SLJIT_FR0, 0);
7418
7419         sljit_set_context(compiler, 0, SLJIT_ARGS1(VOID, P), 0, 1, SLJIT_NUMBER_OF_FLOAT_REGISTERS, 0, 0);
7420         sljit_emit_return_void(compiler);
7421
7422         code.code = sljit_generate_code(compiler);
7423         CHECK(compiler);
7424         sljit_free_compiler(compiler);
7425
7426         code.func2((sljit_sw)buf, (sljit_sw)buf2);
7427
7428         for (i = 0; i < SLJIT_NUMBER_OF_SCRATCH_FLOAT_REGISTERS; i++) {
7429                 FAILED(buf[i] != -8.25, "test72 case 1 failed\n");
7430         }
7431
7432         for (i = SLJIT_NUMBER_OF_SCRATCH_FLOAT_REGISTERS; i < SLJIT_NUMBER_OF_FLOAT_REGISTERS; i++) {
7433                 FAILED(buf[i] != 7.75, "test72 case 2 failed\n");
7434         }
7435
7436         sljit_free_code(code.code, NULL);
7437
7438         /* Next test. */
7439         if (SLJIT_NUMBER_OF_SAVED_FLOAT_REGISTERS >= 3) {
7440                 compiler = sljit_create_compiler(NULL, NULL);
7441                 FAILED(!compiler, "cannot create compiler\n");
7442
7443                 buf2[0] = -6.25;
7444                 buf2[1] = 3.75;
7445
7446                 for (i = 0; i < SLJIT_NUMBER_OF_FLOAT_REGISTERS; i++)
7447                         buf[i] = 0.0;
7448
7449                 sljit_emit_enter(compiler, 0, SLJIT_ARGS2(VOID, P, P), 1, 2, SLJIT_NUMBER_OF_FLOAT_REGISTERS - 2, 1, SLJIT_MAX_LOCAL_SIZE);
7450                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FS0, 0, SLJIT_MEM1(SLJIT_S1), 0);
7451                 for (i = 0; i < SLJIT_NUMBER_OF_FLOAT_REGISTERS - 2; i++)
7452                         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR(i), 0, SLJIT_FS0, 0);
7453
7454                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_S1, 0);
7455                 jump = sljit_emit_call(compiler, SLJIT_CALL, SLJIT_ARGS1(VOID, W));
7456
7457                 for (i = 0; i < SLJIT_NUMBER_OF_FLOAT_REGISTERS - 2; i++)
7458                         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), i * (sljit_sw)sizeof(sljit_f64), SLJIT_FR(i), 0);
7459                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), (SLJIT_NUMBER_OF_FLOAT_REGISTERS - 1) * (sljit_sw)sizeof(sljit_f64), SLJIT_FS0, 0);
7460                 sljit_emit_return_void(compiler);
7461
7462                 /* Called function. */
7463                 sljit_set_label(jump, sljit_emit_label(compiler));
7464                 sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, P), 0, 1, SLJIT_NUMBER_OF_FLOAT_REGISTERS, 0, SLJIT_MAX_LOCAL_SIZE);
7465
7466                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64));
7467                 for (i = 1; i < SLJIT_NUMBER_OF_FLOAT_REGISTERS; i++)
7468                         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR(i), 0, SLJIT_FR0, 0);
7469
7470                 sljit_set_context(compiler, 0, SLJIT_ARGS1(VOID, P), 0, 1, SLJIT_NUMBER_OF_FLOAT_REGISTERS, 0, SLJIT_MAX_LOCAL_SIZE);
7471                 sljit_emit_return_void(compiler);
7472
7473                 code.code = sljit_generate_code(compiler);
7474                 CHECK(compiler);
7475                 sljit_free_compiler(compiler);
7476
7477                 code.func2((sljit_sw)buf, (sljit_sw)buf2);
7478
7479                 for (i = 0; i < SLJIT_NUMBER_OF_SCRATCH_FLOAT_REGISTERS; i++) {
7480                         FAILED(buf[i] != 3.75, "test72 case 3 failed\n");
7481                 }
7482
7483                 for (i = SLJIT_NUMBER_OF_SCRATCH_FLOAT_REGISTERS; i < SLJIT_NUMBER_OF_FLOAT_REGISTERS - 2; i++) {
7484                         FAILED(buf[i] != -6.25, "test72 case 4 failed\n");
7485                 }
7486
7487                 FAILED(buf[SLJIT_NUMBER_OF_FLOAT_REGISTERS - 2] != 0, "test72 case 5 failed\n");
7488                 FAILED(buf[SLJIT_NUMBER_OF_FLOAT_REGISTERS - 1] != -6.25, "test72 case 6 failed\n");
7489
7490                 sljit_free_code(code.code, NULL);
7491         }
7492         successful_tests++;
7493 }
7494
7495 static void test73(void)
7496 {
7497         /* Test tail calls. */
7498         executable_code code;
7499         struct sljit_compiler* compiler;
7500         sljit_sw wbuf[2];
7501         sljit_s32 ibuf[2];
7502         sljit_f64 dbuf[3];
7503
7504         if (verbose)
7505                 printf("Run test73\n");
7506
7507         /* Next test. */
7508
7509         compiler = sljit_create_compiler(NULL, NULL);
7510         FAILED(!compiler, "cannot create compiler\n");
7511
7512         sljit_emit_enter(compiler, 0, SLJIT_ARGS4(VOID, 32_R, W, W_R, 32), 3, 2, 0, 0, 0);
7513         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, (sljit_sw)&wbuf);
7514         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), 0, SLJIT_S0, 0);
7515         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), sizeof(sljit_sw), SLJIT_R2, 0);
7516         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, (sljit_sw)&ibuf);
7517         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_R1), 0, SLJIT_R0, 0);
7518         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_R1), sizeof(sljit_s32), SLJIT_S1, 0);
7519         sljit_emit_return_void(compiler);
7520
7521         code.code = sljit_generate_code(compiler);
7522         CHECK(compiler);
7523         sljit_free_compiler(compiler);
7524
7525         code.test73_f1(3467, -6781, 5038, 6310);
7526
7527         FAILED(wbuf[0] != -6781, "test73 case 1 failed\n");
7528         FAILED(wbuf[1] != 5038, "test73 case 2 failed\n");
7529         FAILED(ibuf[0] != 3467, "test73 case 3 failed\n");
7530         FAILED(ibuf[1] != 6310, "test73 case 4 failed\n");
7531         sljit_free_code(code.code, NULL);
7532
7533         /* Next test. */
7534
7535         compiler = sljit_create_compiler(NULL, NULL);
7536         FAILED(!compiler, "cannot create compiler\n");
7537
7538         sljit_emit_enter(compiler, 0, SLJIT_ARGS4(VOID, 32, W_R, W, 32_R), 4, 2, 0, 0, 8192);
7539         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&wbuf);
7540         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_R1, 0);
7541         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_sw), SLJIT_S1, 0);
7542         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&ibuf);
7543         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_S0, 0);
7544         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_s32), SLJIT_R3, 0);
7545         sljit_emit_return_void(compiler);
7546
7547         code.code = sljit_generate_code(compiler);
7548         CHECK(compiler);
7549         sljit_free_compiler(compiler);
7550
7551         code.test73_f1(-9723, 5208, 4761, 5084);
7552
7553         FAILED(wbuf[0] != 5208, "test73 case 5 failed\n");
7554         FAILED(wbuf[1] != 4761, "test73 case 6 failed\n");
7555         FAILED(ibuf[0] != -9723, "test73 case 7 failed\n");
7556         FAILED(ibuf[1] != 5084, "test73 case 8 failed\n");
7557         sljit_free_code(code.code, NULL);
7558
7559         /* Next test. */
7560
7561         compiler = sljit_create_compiler(NULL, NULL);
7562         FAILED(!compiler, "cannot create compiler\n");
7563
7564         sljit_emit_enter(compiler, 0, SLJIT_ARGS4(VOID, 32_R, W_R, W_R, 32_R), 4, 1, 0, 0, SLJIT_MAX_LOCAL_SIZE);
7565         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, (sljit_sw)&wbuf);
7566         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R1, 0);
7567         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_R2, 0);
7568         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, (sljit_sw)&ibuf);
7569         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0);
7570         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_s32), SLJIT_R3, 0);
7571         sljit_emit_return_void(compiler);
7572
7573         code.code = sljit_generate_code(compiler);
7574         CHECK(compiler);
7575         sljit_free_compiler(compiler);
7576
7577         code.test73_f1(5934, 6043, -8572, -3861);
7578
7579         FAILED(wbuf[0] != 6043, "test73 case 9 failed\n");
7580         FAILED(wbuf[1] != -8572, "test73 case 10 failed\n");
7581         FAILED(ibuf[0] != 5934, "test73 case 11 failed\n");
7582         FAILED(ibuf[1] != -3861, "test73 case 12 failed\n");
7583         sljit_free_code(code.code, NULL);
7584
7585         /* Next test. */
7586
7587         compiler = sljit_create_compiler(NULL, NULL);
7588         FAILED(!compiler, "cannot create compiler\n");
7589
7590         sljit_emit_enter(compiler, SLJIT_ENTER_CDECL, SLJIT_ARGS4(VOID, W_R, W_R, 32_R, 32_R), 4, 1, 0, 0, SLJIT_MAX_LOCAL_SIZE);
7591         sljit_set_context(compiler, SLJIT_ENTER_CDECL, SLJIT_ARGS4(VOID, W_R, W_R, 32_R, 32_R), 4, 1, 0, 0, SLJIT_MAX_LOCAL_SIZE);
7592         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, (sljit_sw)&wbuf);
7593         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0);
7594         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_R1, 0);
7595         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, (sljit_sw)&ibuf);
7596         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R2, 0);
7597         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_s32), SLJIT_R3, 0);
7598         sljit_emit_return_void(compiler);
7599
7600         code.code = sljit_generate_code(compiler);
7601         CHECK(compiler);
7602         sljit_free_compiler(compiler);
7603
7604         code.test73_f2(6732, -5916, 2740, -3621);
7605
7606         FAILED(wbuf[0] != 6732, "test73 case 13 failed\n");
7607         FAILED(wbuf[1] != -5916, "test73 case 14 failed\n");
7608         FAILED(ibuf[0] != 2740, "test73 case 15 failed\n");
7609         FAILED(ibuf[1] != -3621, "test73 case 16 failed\n");
7610         sljit_free_code(code.code, NULL);
7611
7612         if (sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
7613                 /* Next test. */
7614
7615                 compiler = sljit_create_compiler(NULL, NULL);
7616                 FAILED(!compiler, "cannot create compiler\n");
7617
7618                 sljit_emit_enter(compiler, 0, SLJIT_ARGS4(VOID, F64, F64, F64, W_R), 1, 0, 3, 0, SLJIT_MAX_LOCAL_SIZE);
7619                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM0(), (sljit_sw)&wbuf, SLJIT_R0, 0);
7620                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&dbuf);
7621                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_FR0, 0);
7622                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_f64), SLJIT_FR1, 0);
7623                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_R0), 2 * sizeof(sljit_f64), SLJIT_FR2, 0);
7624
7625                 sljit_emit_return_void(compiler);
7626
7627                 code.code = sljit_generate_code(compiler);
7628                 CHECK(compiler);
7629                 sljit_free_compiler(compiler);
7630
7631                 code.test73_f3(7390.25, -8045.5, 1390.75, 8201);
7632
7633                 FAILED(wbuf[0] != 8201, "test73 case 17 failed\n");
7634                 FAILED(dbuf[0] != 7390.25, "test73 case 18 failed\n");
7635                 FAILED(dbuf[1] != -8045.5, "test73 case 19 failed\n");
7636                 FAILED(dbuf[2] != 1390.75, "test73 case 20 failed\n");
7637
7638                 /* Next test. */
7639
7640                 compiler = sljit_create_compiler(NULL, NULL);
7641                 FAILED(!compiler, "cannot create compiler\n");
7642
7643                 sljit_emit_enter(compiler, 0, SLJIT_ARGS4(VOID, F64, F64, W, W_R), 2, 1, 2, 0, SLJIT_MAX_LOCAL_SIZE);
7644                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&wbuf);
7645                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_S0, 0);
7646                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_sw), SLJIT_R1, 0);
7647                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&dbuf);
7648                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_FR0, 0);
7649                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_f64), SLJIT_FR1, 0);
7650
7651                 sljit_emit_return_void(compiler);
7652
7653                 code.code = sljit_generate_code(compiler);
7654                 CHECK(compiler);
7655                 sljit_free_compiler(compiler);
7656
7657                 code.test73_f4(4892.75, -3702.5, 4731, 8530);
7658
7659                 FAILED(wbuf[0] != 4731, "test73 case 21 failed\n");
7660                 FAILED(wbuf[1] != 8530, "test73 case 22 failed\n");
7661                 FAILED(dbuf[0] != 4892.75, "test73 case 23 failed\n");
7662                 FAILED(dbuf[1] != -3702.5, "test73 case 24 failed\n");
7663         }
7664
7665         successful_tests++;
7666 }
7667
7668 static void test74(void)
7669 {
7670         /* Test carry flag. */
7671         executable_code code;
7672         struct sljit_compiler* compiler;
7673         sljit_sw wbuf[15];
7674         sljit_s32 i;
7675
7676         if (verbose)
7677                 printf("Run test74\n");
7678
7679         for (i = 0; i < 15; i++)
7680                 wbuf[i] = -1;
7681
7682         compiler = sljit_create_compiler(NULL, NULL);
7683         FAILED(!compiler, "cannot create compiler\n");
7684
7685         sljit_emit_enter(compiler, 0, SLJIT_ARGS1(VOID, W), 3, 2, 0, 0, 0);
7686
7687         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -1);
7688         sljit_emit_op2u(compiler, SLJIT_ADD | SLJIT_SET_CARRY, SLJIT_R0, 0, SLJIT_IMM, 1);
7689         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_CARRY);
7690         /* wbuf[0] */
7691         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R1, 0);
7692         cond_set(compiler, SLJIT_R1, 0, SLJIT_CARRY);
7693         /* wbuf[1] */
7694         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_R1, 0);
7695
7696         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 2);
7697         sljit_emit_op2(compiler, SLJIT_ADD | SLJIT_SET_CARRY, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, -1);
7698         sljit_set_current_flags(compiler, SLJIT_SET_CARRY | SLJIT_CURRENT_FLAGS_ADD);
7699         /* wbuf[2] */
7700         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_NOT_CARRY);
7701
7702         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 1);
7703         sljit_emit_op2(compiler, SLJIT_SHL32, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 31);
7704         sljit_emit_op2u(compiler, SLJIT_ADD32 | SLJIT_SET_CARRY, SLJIT_R0, 0, SLJIT_R0, 0);
7705         cond_set(compiler, SLJIT_R1, 0, SLJIT_CARRY);
7706         /* wbuf[3] */
7707         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_R1, 0);
7708
7709         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 5);
7710         sljit_emit_op2(compiler, SLJIT_ADD32 | SLJIT_SET_CARRY, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 5);
7711         cond_set(compiler, SLJIT_R1, 0, SLJIT_CARRY);
7712         /* wbuf[4] */
7713         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_R1, 0);
7714
7715         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0);
7716         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_CARRY, SLJIT_R0, 0, SLJIT_IMM, 1);
7717         cond_set(compiler, SLJIT_R1, 0, SLJIT_CARRY);
7718         /* wbuf[5] */
7719         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_R1, 0);
7720
7721         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 1);
7722         sljit_emit_op2u(compiler, SLJIT_SUB | SLJIT_SET_CARRY, SLJIT_R0, 0, SLJIT_IMM, 1);
7723         cond_set(compiler, SLJIT_R1, 0, SLJIT_NOT_CARRY);
7724         /* wbuf[6] */
7725         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_sw), SLJIT_R1, 0);
7726
7727         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 0);
7728         sljit_emit_op2u(compiler, SLJIT_SUB32 | SLJIT_SET_CARRY, SLJIT_R0, 0, SLJIT_IMM, 1);
7729         /* wbuf[7] */
7730         cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_sw), SLJIT_CARRY);
7731
7732         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 0);
7733         sljit_emit_op2u(compiler, SLJIT_SUB32 | SLJIT_SET_CARRY, SLJIT_R0, 0, SLJIT_IMM, 1);
7734         sljit_set_current_flags(compiler, SLJIT_SET_CARRY | SLJIT_CURRENT_FLAGS_32 | SLJIT_CURRENT_FLAGS_SUB);
7735         cond_set(compiler, SLJIT_R1, 0, SLJIT_NOT_CARRY);
7736         /* wbuf[8] */
7737         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_sw), SLJIT_R1, 0);
7738
7739         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 1);
7740         sljit_emit_op2(compiler, SLJIT_SHL32, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 31);
7741         sljit_emit_op2(compiler, SLJIT_SUB32, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, 1);
7742         sljit_emit_op2(compiler, SLJIT_SUB32 | SLJIT_SET_CARRY, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_R0, 0);
7743         cond_set(compiler, SLJIT_R1, 0, SLJIT_NOT_CARRY);
7744         /* wbuf[9] */
7745         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 9 * sizeof(sljit_sw), SLJIT_R1, 0);
7746
7747         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -1);
7748         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_CARRY, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, -2);
7749         cond_set(compiler, SLJIT_R1, 0, SLJIT_NOT_CARRY);
7750         /* wbuf[10] */
7751         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 10 * sizeof(sljit_sw), SLJIT_R1, 0);
7752
7753         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 1);
7754         sljit_emit_op2(compiler, SLJIT_ADD | SLJIT_SET_CARRY, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 1);
7755         sljit_emit_op2(compiler, SLJIT_ADDC | SLJIT_SET_CARRY, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_R0, 0);
7756         cond_set(compiler, SLJIT_R1, 0, SLJIT_CARRY);
7757         /* wbuf[11] */
7758         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 11 * sizeof(sljit_sw), SLJIT_R1, 0);
7759
7760         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 1);
7761         sljit_emit_op2(compiler, SLJIT_SHL32, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 31);
7762         sljit_emit_op2(compiler, SLJIT_ADD32 | SLJIT_SET_CARRY, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 0);
7763         sljit_emit_op2(compiler, SLJIT_ADDC32 | SLJIT_SET_CARRY, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_R0, 0);
7764         cond_set(compiler, SLJIT_R1, 0, SLJIT_CARRY);
7765         /* wbuf[12] */
7766         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 12 * sizeof(sljit_sw), SLJIT_R1, 0);
7767
7768         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0);
7769         sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_CARRY, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 0);
7770         sljit_emit_op2(compiler, SLJIT_SUBC | SLJIT_SET_CARRY, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 1);
7771         cond_set(compiler, SLJIT_R1, 0, SLJIT_CARRY);
7772         /* wbuf[13] */
7773         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 13 * sizeof(sljit_sw), SLJIT_R1, 0);
7774
7775         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 0);
7776         sljit_emit_op2(compiler, SLJIT_SUB32 | SLJIT_SET_CARRY, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 1);
7777         sljit_emit_op2(compiler, SLJIT_SUBC32 | SLJIT_SET_CARRY, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 1);
7778         cond_set(compiler, SLJIT_R1, 0, SLJIT_NOT_CARRY);
7779         /* wbuf[14] */
7780         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 14 * sizeof(sljit_sw), SLJIT_R1, 0);
7781
7782         sljit_emit_return_void(compiler);
7783
7784         code.code = sljit_generate_code(compiler);
7785         CHECK(compiler);
7786         sljit_free_compiler(compiler);
7787
7788         code.func1((sljit_sw)&wbuf);
7789
7790         FAILED(wbuf[0] != 1, "test74 case 1 failed\n");
7791         FAILED(wbuf[1] != 1, "test74 case 2 failed\n");
7792         FAILED(wbuf[2] != 2, "test74 case 3 failed\n");
7793         FAILED(wbuf[3] != 1, "test74 case 4 failed\n");
7794         FAILED(wbuf[4] != 2, "test74 case 5 failed\n");
7795         FAILED(wbuf[5] != 1, "test74 case 6 failed\n");
7796         FAILED(wbuf[6] != 1, "test74 case 7 failed\n");
7797         FAILED(wbuf[7] != 1, "test74 case 8 failed\n");
7798         FAILED(wbuf[8] != 2, "test74 case 9 failed\n");
7799         FAILED(wbuf[9] != 2, "test74 case 10 failed\n");
7800         FAILED(wbuf[10] != 1, "test74 case 11 failed\n");
7801         FAILED(wbuf[11] != 2, "test74 case 12 failed\n");
7802         FAILED(wbuf[12] != 1, "test74 case 13 failed\n");
7803         FAILED(wbuf[13] != 1, "test74 case 14 failed\n");
7804         FAILED(wbuf[14] != 1, "test74 case 15 failed\n");
7805
7806         successful_tests++;
7807 }
7808
7809 static void test75_set(struct sljit_compiler *compiler, sljit_s32 compare, sljit_s32 type, sljit_s32 left_fr, sljit_s32 right_fr)
7810 {
7811         /* Testing both sljit_emit_op_flags and sljit_emit_jump. */
7812         struct sljit_jump* jump1;
7813         struct sljit_jump* jump2;
7814         sljit_s32 is_ordered;
7815
7816         if (sljit_cmp_info(type)) {
7817                 sljit_emit_fop1(compiler, compare | SLJIT_SET(type), left_fr, 0, right_fr, 0);
7818                 sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_R0, 0, type);
7819                 jump1 = sljit_emit_jump(compiler, type);
7820                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 2);
7821                 sljit_set_label(jump1, sljit_emit_label(compiler));
7822         } else {
7823                 if (type < SLJIT_UNORDERED_OR_EQUAL) {
7824                         is_ordered = (type & 0x1) ^ 0x1;
7825                         type += SLJIT_UNORDERED_OR_EQUAL - SLJIT_ORDERED_EQUAL;
7826                 } else {
7827                         is_ordered = type & 0x1;
7828                         type -= SLJIT_UNORDERED_OR_EQUAL - SLJIT_ORDERED_EQUAL;
7829                 }
7830                 SLJIT_ASSERT(sljit_cmp_info(type) && sljit_cmp_info(SLJIT_UNORDERED) && sljit_cmp_info(SLJIT_ORDERED));
7831
7832                 sljit_emit_fop1(compiler, compare | SLJIT_SET(type), left_fr, 0, right_fr, 0);
7833                 sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_R0, 0, type);
7834                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 0);
7835
7836                 if (is_ordered) {
7837                         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_ORDERED);
7838
7839                         jump1 = sljit_emit_jump(compiler, SLJIT_UNORDERED);
7840                         jump2 = sljit_emit_jump(compiler, type);
7841                         sljit_set_label(jump1, sljit_emit_label(compiler));
7842                         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 2);
7843                         sljit_set_label(jump2, sljit_emit_label(compiler));
7844
7845                         sljit_emit_op2(compiler, SLJIT_AND, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_R1, 0);
7846                 } else {
7847                         sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_UNORDERED);
7848
7849                         jump1 = sljit_emit_jump(compiler, SLJIT_UNORDERED);
7850                         jump2 = sljit_emit_jump(compiler, type);
7851                         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 2);
7852                         sljit_set_label(jump1, sljit_emit_label(compiler));
7853                         sljit_set_label(jump2, sljit_emit_label(compiler));
7854
7855                         sljit_emit_op2(compiler, SLJIT_OR, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_R1, 0);
7856                 }
7857
7858                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_R2, 0);
7859         }
7860
7861         sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0);
7862         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_S0, 0, SLJIT_S0, 0, SLJIT_IMM, sizeof(sljit_s8));
7863 }
7864
7865 static void test75(void)
7866 {
7867         /* Test floating point comparison. */
7868         executable_code code;
7869         struct sljit_compiler* compiler;
7870         sljit_s8 bbuf[96];
7871         sljit_s32 i;
7872
7873         union {
7874                 sljit_f64 value;
7875                 struct {
7876                         sljit_s32 value1;
7877                         sljit_s32 value2;
7878                 } u;
7879         } dbuf[3];
7880
7881         union {
7882                 sljit_f32 value;
7883                 sljit_s32 value1;
7884         } sbuf[3];
7885
7886         dbuf[0].u.value1 = 0x7fffffff;
7887         dbuf[0].u.value2 = 0x7fffffff;
7888         dbuf[1].value = -13.0;
7889         dbuf[2].value = 27.0;
7890
7891         sbuf[0].value1 = 0x7fffffff;
7892         sbuf[1].value = -13.0;
7893         sbuf[2].value = 27.0;
7894
7895         if (verbose)
7896                 printf("Run test75\n");
7897
7898         if (!sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
7899                 if (verbose)
7900                         printf("no fpu available, test75 skipped\n");
7901                 successful_tests++;
7902                 return;
7903         }
7904
7905         for (i = 0; i < 96; i++)
7906                 bbuf[i] = -3;
7907
7908         compiler = sljit_create_compiler(NULL, NULL);
7909         FAILED(!compiler, "cannot create compiler\n");
7910
7911         sljit_emit_enter(compiler, 0, SLJIT_ARGS3(VOID, P, P, P), 3, 3, 6, 0, 0);
7912
7913         i = SLJIT_CMP_F64;
7914         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S1), 0);
7915         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S1), 0);
7916         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_f64));
7917         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR3, 0, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_f64));
7918         sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR4, 0, SLJIT_MEM1(SLJIT_S1), 2 * sizeof(sljit_f64));
7919
7920         while (1) {
7921                 /* bbuf[0] and bbuf[48] */
7922                 test75_set(compiler, i, SLJIT_ORDERED_EQUAL, SLJIT_FR2, SLJIT_FR3);
7923                 /* bbuf[1] and bbuf[49] */
7924                 test75_set(compiler, i, SLJIT_ORDERED_EQUAL, SLJIT_FR2, SLJIT_FR4);
7925                 /* bbuf[2] and bbuf[50] */
7926                 test75_set(compiler, i, SLJIT_ORDERED_EQUAL, SLJIT_FR0, SLJIT_FR1);
7927                 /* bbuf[3] and bbuf[51] */
7928                 test75_set(compiler, i, SLJIT_ORDERED_EQUAL, SLJIT_FR0, SLJIT_FR2);
7929
7930                 /* bbuf[4] and bbuf[52] */
7931                 test75_set(compiler, i, SLJIT_UNORDERED_OR_NOT_EQUAL, SLJIT_FR2, SLJIT_FR3);
7932                 /* bbuf[5] and bbuf[53] */
7933                 test75_set(compiler, i, SLJIT_UNORDERED_OR_NOT_EQUAL, SLJIT_FR2, SLJIT_FR4);
7934                 /* bbuf[6] and bbuf[54] */
7935                 test75_set(compiler, i, SLJIT_UNORDERED_OR_NOT_EQUAL, SLJIT_FR0, SLJIT_FR1);
7936                 /* bbuf[7] and bbuf[55] */
7937                 test75_set(compiler, i, SLJIT_UNORDERED_OR_NOT_EQUAL, SLJIT_FR0, SLJIT_FR2);
7938
7939                 /* bbuf[8] and bbuf[56] */
7940                 test75_set(compiler, i, SLJIT_ORDERED_LESS, SLJIT_FR2, SLJIT_FR3);
7941                 /* bbuf[9] and bbuf[57] */
7942                 test75_set(compiler, i, SLJIT_ORDERED_LESS, SLJIT_FR2, SLJIT_FR4);
7943                 /* bbuf[10] and bbuf[58] */
7944                 test75_set(compiler, i, SLJIT_ORDERED_LESS, SLJIT_FR0, SLJIT_FR1);
7945                 /* bbuf[11] and bbuf[59] */
7946                 test75_set(compiler, i, SLJIT_ORDERED_LESS, SLJIT_FR0, SLJIT_FR2);
7947
7948                 /* bbuf[12] and bbuf[60] */
7949                 test75_set(compiler, i, SLJIT_UNORDERED_OR_GREATER_EQUAL, SLJIT_FR2, SLJIT_FR4);
7950                 /* bbuf[13] and bbuf[61] */
7951                 test75_set(compiler, i, SLJIT_UNORDERED_OR_GREATER_EQUAL, SLJIT_FR4, SLJIT_FR2);
7952                 /* bbuf[14] and bbuf[62] */
7953                 test75_set(compiler, i, SLJIT_UNORDERED_OR_GREATER_EQUAL, SLJIT_FR0, SLJIT_FR1);
7954                 /* bbuf[15] and bbuf[63] */
7955                 test75_set(compiler, i, SLJIT_UNORDERED_OR_GREATER_EQUAL, SLJIT_FR0, SLJIT_FR2);
7956
7957                 /* bbuf[16] and bbuf[64] */
7958                 test75_set(compiler, i, SLJIT_ORDERED_GREATER, SLJIT_FR2, SLJIT_FR4);
7959                 /* bbuf[17] and bbuf[65] */
7960                 test75_set(compiler, i, SLJIT_ORDERED_GREATER, SLJIT_FR4, SLJIT_FR2);
7961                 /* bbuf[18] and bbuf[66] */
7962                 test75_set(compiler, i, SLJIT_ORDERED_GREATER, SLJIT_FR0, SLJIT_FR1);
7963                 /* bbuf[19] and bbuf[67] */
7964                 test75_set(compiler, i, SLJIT_ORDERED_GREATER, SLJIT_FR0, SLJIT_FR2);
7965
7966                 /* bbuf[20] and bbuf[68] */
7967                 test75_set(compiler, i, SLJIT_UNORDERED_OR_LESS_EQUAL, SLJIT_FR2, SLJIT_FR4);
7968                 /* bbuf[21] and bbuf[69] */
7969                 test75_set(compiler, i, SLJIT_UNORDERED_OR_LESS_EQUAL, SLJIT_FR4, SLJIT_FR2);
7970                 /* bbuf[22] and bbuf[70] */
7971                 test75_set(compiler, i, SLJIT_UNORDERED_OR_LESS_EQUAL, SLJIT_FR0, SLJIT_FR1);
7972                 /* bbuf[23] and bbuf[71] */
7973                 test75_set(compiler, i, SLJIT_UNORDERED_OR_LESS_EQUAL, SLJIT_FR0, SLJIT_FR2);
7974
7975                 /* bbuf[24] and bbuf[72] */
7976                 test75_set(compiler, i, SLJIT_UNORDERED_OR_EQUAL, SLJIT_FR2, SLJIT_FR4);
7977                 /* bbuf[25] and bbuf[73] */
7978                 test75_set(compiler, i, SLJIT_UNORDERED_OR_EQUAL, SLJIT_FR2, SLJIT_FR3);
7979                 /* bbuf[26] and bbuf[74] */
7980                 test75_set(compiler, i, SLJIT_UNORDERED_OR_EQUAL, SLJIT_FR0, SLJIT_FR1);
7981                 /* bbuf[27] and bbuf[75] */
7982                 test75_set(compiler, i, SLJIT_UNORDERED_OR_EQUAL, SLJIT_FR0, SLJIT_FR2);
7983
7984                 /* bbuf[28] and bbuf[76] */
7985                 test75_set(compiler, i, SLJIT_ORDERED_NOT_EQUAL, SLJIT_FR2, SLJIT_FR3);
7986                 /* bbuf[29] and bbuf[77] */
7987                 test75_set(compiler, i, SLJIT_ORDERED_NOT_EQUAL, SLJIT_FR2, SLJIT_FR4);
7988                 /* bbuf[30] and bbuf[78] */
7989                 test75_set(compiler, i, SLJIT_ORDERED_NOT_EQUAL, SLJIT_FR0, SLJIT_FR1);
7990                 /* bbuf[31] and bbuf[79] */
7991                 test75_set(compiler, i, SLJIT_ORDERED_NOT_EQUAL, SLJIT_FR0, SLJIT_FR2);
7992
7993                 /* bbuf[32] and bbuf[80] */
7994                 test75_set(compiler, i, SLJIT_UNORDERED_OR_LESS, SLJIT_FR2, SLJIT_FR4);
7995                 /* bbuf[33] and bbuf[81] */
7996                 test75_set(compiler, i, SLJIT_UNORDERED_OR_LESS, SLJIT_FR2, SLJIT_FR3);
7997                 /* bbuf[34] and bbuf[82] */
7998                 test75_set(compiler, i, SLJIT_UNORDERED_OR_LESS, SLJIT_FR0, SLJIT_FR1);
7999                 /* bbuf[35] and bbuf[83] */
8000                 test75_set(compiler, i, SLJIT_UNORDERED_OR_LESS, SLJIT_FR0, SLJIT_FR2);
8001
8002                 /* bbuf[36] and bbuf[84] */
8003                 test75_set(compiler, i, SLJIT_ORDERED_GREATER_EQUAL, SLJIT_FR2, SLJIT_FR4);
8004                 /* bbuf[37] and bbuf[85] */
8005                 test75_set(compiler, i, SLJIT_ORDERED_GREATER_EQUAL, SLJIT_FR4, SLJIT_FR2);
8006                 /* bbuf[38] and bbuf[86] */
8007                 test75_set(compiler, i, SLJIT_ORDERED_GREATER_EQUAL, SLJIT_FR0, SLJIT_FR1);
8008                 /* bbuf[39] and bbuf[87] */
8009                 test75_set(compiler, i, SLJIT_ORDERED_GREATER_EQUAL, SLJIT_FR0, SLJIT_FR2);
8010
8011                 /* bbuf[40] and bbuf[88] */
8012                 test75_set(compiler, i, SLJIT_UNORDERED_OR_GREATER, SLJIT_FR2, SLJIT_FR4);
8013                 /* bbuf[41] and bbuf[89] */
8014                 test75_set(compiler, i, SLJIT_UNORDERED_OR_GREATER, SLJIT_FR4, SLJIT_FR2);
8015                 /* bbuf[42] and bbuf[90] */
8016                 test75_set(compiler, i, SLJIT_UNORDERED_OR_GREATER, SLJIT_FR0, SLJIT_FR1);
8017                 /* bbuf[43] and bbuf[91] */
8018                 test75_set(compiler, i, SLJIT_UNORDERED_OR_GREATER, SLJIT_FR0, SLJIT_FR2);
8019
8020                 /* bbuf[44] and bbuf[92] */
8021                 test75_set(compiler, i, SLJIT_ORDERED_LESS_EQUAL, SLJIT_FR2, SLJIT_FR3);
8022                 /* bbuf[45] and bbuf[93] */
8023                 test75_set(compiler, i, SLJIT_ORDERED_LESS_EQUAL, SLJIT_FR4, SLJIT_FR2);
8024                 /* bbuf[46] and bbuf[94] */
8025                 test75_set(compiler, i, SLJIT_ORDERED_LESS_EQUAL, SLJIT_FR0, SLJIT_FR1);
8026                 /* bbuf[47] and bbuf[95] */
8027                 test75_set(compiler, i, SLJIT_ORDERED_LESS_EQUAL, SLJIT_FR0, SLJIT_FR2);
8028
8029                 if (i == SLJIT_CMP_F32)
8030                         break;
8031
8032                 i = SLJIT_CMP_F32;
8033                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S2), 0);
8034                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S2), 0);
8035                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S2), sizeof(sljit_f32));
8036                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR3, 0, SLJIT_MEM1(SLJIT_S2), sizeof(sljit_f32));
8037                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR4, 0, SLJIT_MEM1(SLJIT_S2), 2 * sizeof(sljit_f32));
8038         }
8039
8040         sljit_emit_return_void(compiler);
8041
8042         code.code = sljit_generate_code(compiler);
8043         CHECK(compiler);
8044         sljit_free_compiler(compiler);
8045
8046         code.func3((sljit_sw)&bbuf, (sljit_sw)&dbuf, (sljit_sw)&sbuf);
8047
8048         /* SLJIT_CMP_F64 */
8049         FAILED(bbuf[0] != 1, "test75 case 1 failed\n");
8050         FAILED(bbuf[1] != 2, "test75 case 2 failed\n");
8051         FAILED(bbuf[2] != 2, "test75 case 3 failed\n");
8052         FAILED(bbuf[3] != 2, "test75 case 4 failed\n");
8053
8054         FAILED(bbuf[4] != 2, "test75 case 5 failed\n");
8055         FAILED(bbuf[5] != 1, "test75 case 6 failed\n");
8056         FAILED(bbuf[6] != 1, "test75 case 7 failed\n");
8057         FAILED(bbuf[7] != 1, "test75 case 8 failed\n");
8058
8059         FAILED(bbuf[8] != 2, "test75 case 9 failed\n");
8060         FAILED(bbuf[9] != 1, "test75 case 10 failed\n");
8061         FAILED(bbuf[10] != 2, "test75 case 11 failed\n");
8062         FAILED(bbuf[11] != 2, "test75 case 12 failed\n");
8063
8064         FAILED(bbuf[12] != 2, "test75 case 13 failed\n");
8065         FAILED(bbuf[13] != 1, "test75 case 14 failed\n");
8066         FAILED(bbuf[14] != 1, "test75 case 15 failed\n");
8067         FAILED(bbuf[15] != 1, "test75 case 16 failed\n");
8068
8069         FAILED(bbuf[16] != 2, "test75 case 17 failed\n");
8070         FAILED(bbuf[17] != 1, "test75 case 18 failed\n");
8071         FAILED(bbuf[18] != 2, "test75 case 19 failed\n");
8072         FAILED(bbuf[19] != 2, "test75 case 20 failed\n");
8073
8074         FAILED(bbuf[20] != 1, "test75 case 21 failed\n");
8075         FAILED(bbuf[21] != 2, "test75 case 22 failed\n");
8076         FAILED(bbuf[22] != 1, "test75 case 23 failed\n");
8077         FAILED(bbuf[23] != 1, "test75 case 24 failed\n");
8078
8079         FAILED(bbuf[24] != 2, "test75 case 25 failed\n");
8080         FAILED(bbuf[25] != 1, "test75 case 26 failed\n");
8081         FAILED(bbuf[26] != 1, "test75 case 27 failed\n");
8082         FAILED(bbuf[27] != 1, "test75 case 28 failed\n");
8083
8084         FAILED(bbuf[28] != 2, "test75 case 29 failed\n");
8085         FAILED(bbuf[29] != 1, "test75 case 30 failed\n");
8086         FAILED(bbuf[30] != 2, "test75 case 31 failed\n");
8087         FAILED(bbuf[31] != 2, "test75 case 32 failed\n");
8088
8089         FAILED(bbuf[32] != 1, "test75 case 33 failed\n");
8090         FAILED(bbuf[33] != 2, "test75 case 34 failed\n");
8091         FAILED(bbuf[34] != 1, "test75 case 35 failed\n");
8092         FAILED(bbuf[35] != 1, "test75 case 36 failed\n");
8093
8094         FAILED(bbuf[36] != 2, "test75 case 37 failed\n");
8095         FAILED(bbuf[37] != 1, "test75 case 38 failed\n");
8096         FAILED(bbuf[38] != 2, "test75 case 39 failed\n");
8097         FAILED(bbuf[39] != 2, "test75 case 40 failed\n");
8098
8099         FAILED(bbuf[40] != 2, "test75 case 41 failed\n");
8100         FAILED(bbuf[41] != 1, "test75 case 42 failed\n");
8101         FAILED(bbuf[42] != 1, "test75 case 43 failed\n");
8102         FAILED(bbuf[43] != 1, "test75 case 44 failed\n");
8103
8104         FAILED(bbuf[44] != 1, "test75 case 45 failed\n");
8105         FAILED(bbuf[45] != 2, "test75 case 46 failed\n");
8106         FAILED(bbuf[46] != 2, "test75 case 47 failed\n");
8107         FAILED(bbuf[47] != 2, "test75 case 48 failed\n");
8108
8109         /* SLJIT_CMP_F32 */
8110         FAILED(bbuf[48] != 1, "test75 case 49 failed\n");
8111         FAILED(bbuf[49] != 2, "test75 case 50 failed\n");
8112         FAILED(bbuf[50] != 2, "test75 case 51 failed\n");
8113         FAILED(bbuf[51] != 2, "test75 case 52 failed\n");
8114
8115         FAILED(bbuf[52] != 2, "test75 case 53 failed\n");
8116         FAILED(bbuf[53] != 1, "test75 case 54 failed\n");
8117         FAILED(bbuf[54] != 1, "test75 case 55 failed\n");
8118         FAILED(bbuf[55] != 1, "test75 case 56 failed\n");
8119
8120         FAILED(bbuf[56] != 2, "test75 case 57 failed\n");
8121         FAILED(bbuf[57] != 1, "test75 case 58 failed\n");
8122         FAILED(bbuf[58] != 2, "test75 case 59 failed\n");
8123         FAILED(bbuf[59] != 2, "test75 case 60 failed\n");
8124
8125         FAILED(bbuf[60] != 2, "test75 case 61 failed\n");
8126         FAILED(bbuf[61] != 1, "test75 case 62 failed\n");
8127         FAILED(bbuf[62] != 1, "test75 case 63 failed\n");
8128         FAILED(bbuf[63] != 1, "test75 case 64 failed\n");
8129
8130         FAILED(bbuf[64] != 2, "test75 case 65 failed\n");
8131         FAILED(bbuf[65] != 1, "test75 case 66 failed\n");
8132         FAILED(bbuf[66] != 2, "test75 case 67 failed\n");
8133         FAILED(bbuf[67] != 2, "test75 case 68 failed\n");
8134
8135         FAILED(bbuf[68] != 1, "test75 case 69 failed\n");
8136         FAILED(bbuf[69] != 2, "test75 case 70 failed\n");
8137         FAILED(bbuf[70] != 1, "test75 case 71 failed\n");
8138         FAILED(bbuf[71] != 1, "test75 case 72 failed\n");
8139
8140         FAILED(bbuf[72] != 2, "test75 case 73 failed\n");
8141         FAILED(bbuf[73] != 1, "test75 case 74 failed\n");
8142         FAILED(bbuf[74] != 1, "test75 case 75 failed\n");
8143         FAILED(bbuf[75] != 1, "test75 case 76 failed\n");
8144
8145         FAILED(bbuf[76] != 2, "test75 case 77 failed\n");
8146         FAILED(bbuf[77] != 1, "test75 case 78 failed\n");
8147         FAILED(bbuf[78] != 2, "test75 case 79 failed\n");
8148         FAILED(bbuf[79] != 2, "test75 case 80 failed\n");
8149
8150         FAILED(bbuf[80] != 1, "test75 case 81 failed\n");
8151         FAILED(bbuf[81] != 2, "test75 case 82 failed\n");
8152         FAILED(bbuf[82] != 1, "test75 case 83 failed\n");
8153         FAILED(bbuf[83] != 1, "test75 case 84 failed\n");
8154
8155         FAILED(bbuf[84] != 2, "test75 case 85 failed\n");
8156         FAILED(bbuf[85] != 1, "test75 case 86 failed\n");
8157         FAILED(bbuf[86] != 2, "test75 case 87 failed\n");
8158         FAILED(bbuf[87] != 2, "test75 case 88 failed\n");
8159
8160         FAILED(bbuf[88] != 2, "test75 case 89 failed\n");
8161         FAILED(bbuf[89] != 1, "test75 case 90 failed\n");
8162         FAILED(bbuf[90] != 1, "test75 case 91 failed\n");
8163         FAILED(bbuf[91] != 1, "test75 case 92 failed\n");
8164
8165         FAILED(bbuf[92] != 1, "test75 case 93 failed\n");
8166         FAILED(bbuf[93] != 2, "test75 case 94 failed\n");
8167         FAILED(bbuf[94] != 2, "test75 case 95 failed\n");
8168         FAILED(bbuf[95] != 2, "test75 case 96 failed\n");
8169
8170         successful_tests++;
8171 }
8172
8173 static void test76(void)
8174 {
8175 #if !(defined SLJIT_CONFIG_SPARC && SLJIT_CONFIG_SPARC)
8176         /* Test keep saved registers. */
8177         executable_code code;
8178         struct sljit_compiler* compiler;
8179         struct sljit_jump* jump;
8180         sljit_sw buf[9];
8181         sljit_f64 dbuf[3];
8182         sljit_s32 i;
8183
8184         if (verbose)
8185                 printf("Run test76\n");
8186
8187         /* Next test. */
8188         for (i = 0; i < 9; i++)
8189                 buf[i] = -1;
8190
8191         compiler = sljit_create_compiler(NULL, NULL);
8192         FAILED(!compiler, "cannot create compiler\n");
8193
8194         sljit_emit_enter(compiler, 0, SLJIT_ARGS0(VOID), 4, 2, 0, 0, 0);
8195
8196         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 7945);
8197         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, -9267);
8198         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 4309);
8199         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, -8321);
8200
8201         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, 6803);
8202         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_IMM, -5497);
8203
8204         jump = sljit_emit_call(compiler, SLJIT_CALL, SLJIT_ARGS4(W, W, W, W, W));
8205
8206         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, (sljit_sw)&buf);
8207         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), 0, SLJIT_R0, 0);
8208         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), sizeof(sljit_sw), SLJIT_S0, 0);
8209         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), 2 * sizeof(sljit_sw), SLJIT_S1, 0);
8210         sljit_emit_return_void(compiler);
8211
8212         sljit_set_label(jump, sljit_emit_label(compiler));
8213         sljit_emit_enter(compiler, SLJIT_ENTER_KEEP_S0_S1, SLJIT_ARGS4(W, W, W, W, W), 1, 6, 0, 0, 32);
8214
8215         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&buf);
8216         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 3 * sizeof(sljit_sw), SLJIT_S0, 0);
8217         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 4 * sizeof(sljit_sw), SLJIT_S1, 0);
8218         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 5 * sizeof(sljit_sw), SLJIT_S2, 0);
8219         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 6 * sizeof(sljit_sw), SLJIT_S3, 0);
8220         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 7 * sizeof(sljit_sw), SLJIT_S4, 0);
8221         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 8 * sizeof(sljit_sw), SLJIT_S5, 0);
8222
8223         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 6028);
8224         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, 4982);
8225         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_IMM, -1289);
8226
8227         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_R0, 0);
8228
8229         code.code = sljit_generate_code(compiler);
8230         CHECK(compiler);
8231         sljit_free_compiler(compiler);
8232
8233         code.func1((sljit_sw)&buf);
8234
8235         FAILED(buf[0] != 6028, "test76 case 1 failed\n");
8236         FAILED(buf[1] != 4982, "test76 case 2 failed\n");
8237         FAILED(buf[2] != -1289, "test76 case 3 failed\n");
8238         FAILED(buf[3] != 6803, "test76 case 4 failed\n");
8239         FAILED(buf[4] != -5497, "test76 case 5 failed\n");
8240         FAILED(buf[5] != 7945, "test76 case 6 failed\n");
8241         FAILED(buf[6] != -9267, "test76 case 7 failed\n");
8242         FAILED(buf[7] != 4309, "test76 case 8 failed\n");
8243         FAILED(buf[8] != -8321, "test76 case 9 failed\n");
8244
8245         /* Next test. */
8246
8247         for (i = 0; i < 9; i++)
8248                 buf[i] = -1;
8249
8250         compiler = sljit_create_compiler(NULL, NULL);
8251         FAILED(!compiler, "cannot create compiler\n");
8252
8253         sljit_emit_enter(compiler, 0, SLJIT_ARGS0(VOID), 4, 1, 0, 0, 0);
8254
8255         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -2608);
8256         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 4751);
8257         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 5740);
8258         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, -9704);
8259
8260         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, -8749);
8261
8262         jump = sljit_emit_call(compiler, SLJIT_CALL, SLJIT_ARGS4(W, W, W, W, W));
8263
8264         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, (sljit_sw)&buf);
8265         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), 0, SLJIT_R0, 0);
8266         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), sizeof(sljit_sw), SLJIT_S0, 0);
8267         sljit_emit_return_void(compiler);
8268
8269         sljit_set_label(jump, sljit_emit_label(compiler));
8270         sljit_emit_enter(compiler, SLJIT_ENTER_KEEP_S0, SLJIT_ARGS4(W, W_R, W, W_R, W), 3, 3, 0, 0, SLJIT_MAX_LOCAL_SIZE);
8271         sljit_set_context(compiler, SLJIT_ENTER_KEEP_S0, SLJIT_ARGS4(W, W_R, W, W_R, W), 3, 3, 0, 0, SLJIT_MAX_LOCAL_SIZE);
8272
8273         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, (sljit_sw)&buf);
8274         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), 2 * sizeof(sljit_sw), SLJIT_S0, 0);
8275         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), 3 * sizeof(sljit_sw), SLJIT_R0, 0);
8276         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), 4 * sizeof(sljit_sw), SLJIT_S1, 0);
8277         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), 5 * sizeof(sljit_sw), SLJIT_R2, 0);
8278         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), 6 * sizeof(sljit_sw), SLJIT_S2, 0);
8279
8280         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -7351);
8281         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, 3628);
8282
8283         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_R0, 0);
8284
8285         code.code = sljit_generate_code(compiler);
8286         CHECK(compiler);
8287         sljit_free_compiler(compiler);
8288
8289         code.func1((sljit_sw)&buf);
8290
8291         FAILED(buf[0] != -7351, "test76 case 10 failed\n");
8292         FAILED(buf[1] != 3628, "test76 case 11 failed\n");
8293         FAILED(buf[2] != -8749, "test76 case 12 failed\n");
8294         FAILED(buf[3] != -2608, "test76 case 13 failed\n");
8295         FAILED(buf[4] != 4751, "test76 case 14 failed\n");
8296         FAILED(buf[5] != 5740, "test76 case 15 failed\n");
8297         FAILED(buf[6] != -9704, "test76 case 16 failed\n");
8298         FAILED(buf[7] != -1, "test76 case 17 failed\n");
8299
8300         /* Next test. */
8301
8302         for (i = 0; i < 9; i++)
8303                 buf[i] = -1;
8304
8305         compiler = sljit_create_compiler(NULL, NULL);
8306         FAILED(!compiler, "cannot create compiler\n");
8307
8308         sljit_emit_enter(compiler, 0, SLJIT_ARGS0(VOID), 4, 1, 0, 0, 0);
8309
8310         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 8653);
8311         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 7245);
8312         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, -3610);
8313         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, 4591);
8314
8315         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, -2865);
8316
8317         jump = sljit_emit_call(compiler, SLJIT_CALL_CDECL, SLJIT_ARGS4(VOID, W, W, W, W));
8318
8319         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM0(), (sljit_sw)&buf, SLJIT_S0, 0);
8320         sljit_emit_return_void(compiler);
8321
8322         sljit_set_label(jump, sljit_emit_label(compiler));
8323         sljit_emit_enter(compiler, SLJIT_ENTER_CDECL | SLJIT_ENTER_KEEP_S0, SLJIT_ARGS4(W, W_R, W, W, W_R), 4, 3, 0, 0, SLJIT_MAX_LOCAL_SIZE);
8324
8325         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, (sljit_sw)&buf);
8326         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), sizeof(sljit_sw), SLJIT_S0, 0);
8327         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), 2 * sizeof(sljit_sw), SLJIT_R0, 0);
8328         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), 3 * sizeof(sljit_sw), SLJIT_S1, 0);
8329         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), 4 * sizeof(sljit_sw), SLJIT_S2, 0);
8330         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), 5 * sizeof(sljit_sw), SLJIT_R3, 0);
8331
8332         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, 5789);
8333
8334         sljit_emit_return(compiler, SLJIT_MOV, SLJIT_R0, 0);
8335
8336         code.code = sljit_generate_code(compiler);
8337         CHECK(compiler);
8338         sljit_free_compiler(compiler);
8339
8340         code.func1((sljit_sw)&buf);
8341
8342         FAILED(buf[0] != 5789, "test76 case 18 failed\n");
8343         FAILED(buf[1] != -2865, "test76 case 19 failed\n");
8344         FAILED(buf[2] != 8653, "test76 case 20 failed\n");
8345         FAILED(buf[3] != 7245, "test76 case 21 failed\n");
8346         FAILED(buf[4] != -3610, "test76 case 22 failed\n");
8347         FAILED(buf[5] != 4591, "test76 case 23 failed\n");
8348         FAILED(buf[6] != -1, "test76 case 24 failed\n");
8349
8350         /* Next test. */
8351
8352         for (i = 0; i < 9; i++)
8353                 buf[i] = -1;
8354
8355         compiler = sljit_create_compiler(NULL, NULL);
8356         FAILED(!compiler, "cannot create compiler\n");
8357
8358         sljit_emit_enter(compiler, 0, SLJIT_ARGS0(VOID), 2, 3, 0, 0, 0);
8359
8360         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, 6071);
8361         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_IMM, -3817);
8362         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, 9250);
8363
8364         jump = sljit_emit_call(compiler, SLJIT_CALL_CDECL, SLJIT_ARGS0(W));
8365
8366         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, (sljit_sw)&buf);
8367         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), 0, SLJIT_R0, 0);
8368         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), sizeof(sljit_sw), SLJIT_S0, 0);
8369         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), 2 * sizeof(sljit_sw), SLJIT_S1, 0);
8370         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), 3 * sizeof(sljit_sw), SLJIT_S2, 0);
8371         sljit_emit_return_void(compiler);
8372
8373         sljit_set_label(jump, sljit_emit_label(compiler));
8374         sljit_emit_enter(compiler, SLJIT_ENTER_CDECL | SLJIT_ENTER_KEEP_S0_S1, SLJIT_ARGS0(W), 4, 3, 0, 0, SLJIT_MAX_LOCAL_SIZE);
8375
8376         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&buf);
8377         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 4 * sizeof(sljit_sw), SLJIT_S0, 0);
8378         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 5 * sizeof(sljit_sw), SLJIT_S1, 0);
8379
8380         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0x15000000);
8381         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0x93);
8382         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 0x280000);
8383         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, 0x4600);
8384
8385         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, 4892);
8386         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_IMM, -7513);
8387         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, -1);
8388
8389         sljit_emit_icall(compiler, SLJIT_CALL | SLJIT_CALL_RETURN, SLJIT_ARGS4(W, W, 32, 32, W), SLJIT_IMM, SLJIT_FUNC_ADDR(test71_f2));
8390         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM0(), 0);
8391
8392         code.code = sljit_generate_code(compiler);
8393         CHECK(compiler);
8394         sljit_free_compiler(compiler);
8395
8396         code.func1((sljit_sw)&buf);
8397
8398         FAILED(buf[0] != 0x15284693, "test76 case 25 failed\n");
8399         FAILED(buf[1] != 4892, "test76 case 26 failed\n");
8400         FAILED(buf[2] != -7513, "test76 case 27 failed\n");
8401         FAILED(buf[3] != 9250, "test76 case 28 failed\n");
8402         FAILED(buf[4] != 6071, "test76 case 29 failed\n");
8403         FAILED(buf[5] != -3817, "test76 case 30 failed\n");
8404         FAILED(buf[6] != -1, "test76 case 31 failed\n");
8405
8406         if (sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
8407                 /* Next test. */
8408
8409                 for (i = 0; i < 9; i++)
8410                         buf[i] = -1;
8411
8412                 dbuf[0] = 4061.25;
8413                 dbuf[1] = -3291.75;
8414                 dbuf[2] = 8703.5;
8415
8416                 compiler = sljit_create_compiler(NULL, NULL);
8417                 FAILED(!compiler, "cannot create compiler\n");
8418
8419                 sljit_emit_enter(compiler, 0, SLJIT_ARGS0(VOID), 2, 3, 3, 0, 0);
8420
8421                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, (sljit_sw)&dbuf);
8422                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_R1), 0);
8423                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_R1), sizeof(sljit_f64));
8424                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_R1), 2 * sizeof(sljit_f64));
8425
8426                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 1706);
8427                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, -8956);
8428                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_IMM, 4381);
8429                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, -5314);
8430
8431                 jump = sljit_emit_call(compiler, SLJIT_CALL, SLJIT_ARGS4(W, F64, F64, F64, W));
8432
8433                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, (sljit_sw)&buf);
8434                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), 0, SLJIT_R0, 0);
8435                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), sizeof(sljit_sw), SLJIT_S0, 0);
8436                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), 2 * sizeof(sljit_sw), SLJIT_S1, 0);
8437                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), 3 * sizeof(sljit_sw), SLJIT_S2, 0);
8438                 sljit_emit_return_void(compiler);
8439
8440                 sljit_set_label(jump, sljit_emit_label(compiler));
8441                 sljit_emit_enter(compiler, SLJIT_ENTER_KEEP_S0, SLJIT_ARGS4(W, F64, F64, F64, W), 1, 3, 3, 0, SLJIT_MAX_LOCAL_SIZE);
8442
8443                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&buf);
8444                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 4 * sizeof(sljit_sw), SLJIT_S0, 0);
8445                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 5 * sizeof(sljit_sw), SLJIT_S1, 0);
8446
8447                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&dbuf);
8448                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_FR2, 0);
8449                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_f64), SLJIT_FR0, 0);
8450                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_R0), 2 * sizeof(sljit_f64), SLJIT_FR1, 0);
8451
8452                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 2784);
8453                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, 1503);
8454                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_IMM, -1);
8455                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, -1);
8456
8457                 sljit_emit_return(compiler, SLJIT_MOV, SLJIT_R0, 0);
8458
8459                 code.code = sljit_generate_code(compiler);
8460                 CHECK(compiler);
8461                 sljit_free_compiler(compiler);
8462
8463                 code.func1((sljit_sw)&buf);
8464
8465                 FAILED(buf[0] != 2784, "test76 case 32 failed\n");
8466                 FAILED(buf[1] != 1503, "test76 case 33 failed\n");
8467                 FAILED(buf[2] != 4381, "test76 case 34 failed\n");
8468                 FAILED(buf[3] != -5314, "test76 case 35 failed\n");
8469                 FAILED(buf[4] != -8956, "test76 case 36 failed\n");
8470                 FAILED(buf[5] != 1706, "test76 case 37 failed\n");
8471                 FAILED(buf[6] != -1, "test76 case 38 failed\n");
8472                 FAILED(dbuf[0] != 8703.5, "test76 case 39 failed\n");
8473                 FAILED(dbuf[1] != 4061.25, "test76 case 40 failed\n");
8474                 FAILED(dbuf[2] != -3291.75, "test76 case 41 failed\n");
8475
8476                 /* Next test. */
8477
8478                 for (i = 0; i < 9; i++)
8479                         buf[i] = -1;
8480
8481                 dbuf[0] = 4061.25;
8482
8483                 compiler = sljit_create_compiler(NULL, NULL);
8484                 FAILED(!compiler, "cannot create compiler\n");
8485
8486                 sljit_emit_enter(compiler, 0, SLJIT_ARGS0(VOID), 3, 3, 1, 0, 0);
8487
8488                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR0, 0, SLJIT_MEM0(), (sljit_sw)&dbuf);
8489
8490                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 8793);
8491                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, -4027);
8492                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 2910);
8493                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, 4619);
8494                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_IMM, -1502);
8495                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, 5316);
8496
8497                 jump = sljit_emit_call(compiler, SLJIT_CALL, SLJIT_ARGS4(VOID, F64, W, W, W));
8498
8499                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&buf);
8500                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_S0, 0);
8501                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_sw), SLJIT_S1, 0);
8502                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 2 * sizeof(sljit_sw), SLJIT_S2, 0);
8503                 sljit_emit_return_void(compiler);
8504
8505                 sljit_set_label(jump, sljit_emit_label(compiler));
8506                 sljit_emit_enter(compiler, SLJIT_ENTER_KEEP_S0_S1, SLJIT_ARGS4(VOID, F64, W, W, W), 1, 5, 3, 0, SLJIT_MAX_LOCAL_SIZE);
8507
8508                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&buf);
8509                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 3 * sizeof(sljit_sw), SLJIT_S0, 0);
8510                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 4 * sizeof(sljit_sw), SLJIT_S1, 0);
8511                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 5 * sizeof(sljit_sw), SLJIT_S2, 0);
8512                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 6 * sizeof(sljit_sw), SLJIT_S3, 0);
8513                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 7 * sizeof(sljit_sw), SLJIT_S4, 0);
8514
8515                 sljit_emit_fop1(compiler, SLJIT_NEG_F64, SLJIT_MEM0(), (sljit_sw)&dbuf, SLJIT_FR0, 0);
8516
8517                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, 7839);
8518                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_IMM, -9215);
8519                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, -1);
8520
8521                 sljit_emit_return_void(compiler);
8522
8523                 code.code = sljit_generate_code(compiler);
8524                 CHECK(compiler);
8525                 sljit_free_compiler(compiler);
8526
8527                 code.func1((sljit_sw)&buf);
8528
8529                 FAILED(buf[0] != 7839, "test76 case 42 failed\n");
8530                 FAILED(buf[1] != -9215, "test76 case 43 failed\n");
8531                 FAILED(buf[2] != 5316, "test76 case 44 failed\n");
8532                 FAILED(buf[3] != 4619, "test76 case 45 failed\n");
8533                 FAILED(buf[4] != -1502, "test76 case 46 failed\n");
8534                 FAILED(buf[5] != 8793, "test76 case 47 failed\n");
8535                 FAILED(buf[6] != -4027, "test76 case 48 failed\n");
8536                 FAILED(buf[7] != 2910, "test76 case 49 failed\n");
8537                 FAILED(buf[8] != -1, "test76 case 50 failed\n");
8538                 FAILED(dbuf[0] != -4061.25, "test76 case 51 failed\n");
8539
8540                 /* Next test. */
8541
8542                 for (i = 0; i < 9; i++)
8543                         buf[i] = -1;
8544
8545                 dbuf[0] = 4061.25;
8546                 dbuf[1] = -3291.75;
8547                 dbuf[2] = 8703.5;
8548
8549                 compiler = sljit_create_compiler(NULL, NULL);
8550                 FAILED(!compiler, "cannot create compiler\n");
8551
8552                 sljit_emit_enter(compiler, 0, SLJIT_ARGS0(VOID), 2, 3, 0, 0, 0);
8553
8554                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, 7869);
8555                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_IMM, -5406);
8556                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, 4951);
8557
8558                 jump = sljit_emit_call(compiler, SLJIT_CALL, SLJIT_ARGS0(W));
8559
8560                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, (sljit_sw)&buf);
8561                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), 0, SLJIT_R0, 0);
8562                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), sizeof(sljit_sw), SLJIT_S0, 0);
8563                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), 2 * sizeof(sljit_sw), SLJIT_S1, 0);
8564                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), 3 * sizeof(sljit_sw), SLJIT_S2, 0);
8565                 sljit_emit_return_void(compiler);
8566
8567                 sljit_set_label(jump, sljit_emit_label(compiler));
8568                 sljit_emit_enter(compiler, SLJIT_ENTER_KEEP_S0_S1, SLJIT_ARGS0(W), 1, 3, 3, 0, SLJIT_MAX_LOCAL_SIZE);
8569
8570                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&buf);
8571                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 4 * sizeof(sljit_sw), SLJIT_S0, 0);
8572                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 5 * sizeof(sljit_sw), SLJIT_S1, 0);
8573
8574                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&dbuf);
8575                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_R0), 0);
8576                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_f64));
8577                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_R0), 2 * sizeof(sljit_f64));
8578
8579                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 1706);
8580
8581                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, 4713);
8582                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_IMM, -2078);
8583                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, -1);
8584
8585                 sljit_emit_icall(compiler, SLJIT_CALL | SLJIT_CALL_RETURN, SLJIT_ARGS4(W, F64, F64, F64, W), SLJIT_IMM, SLJIT_FUNC_ADDR(test71_f7));
8586                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM0(), 0);
8587
8588                 code.code = sljit_generate_code(compiler);
8589                 CHECK(compiler);
8590                 sljit_free_compiler(compiler);
8591
8592                 code.func1((sljit_sw)&buf);
8593
8594                 FAILED(buf[0] != 5074526, "test76 case 52 failed\n");
8595                 FAILED(buf[1] != 4713, "test76 case 53 failed\n");
8596                 FAILED(buf[2] != -2078, "test76 case 54 failed\n");
8597                 FAILED(buf[3] != 4951, "test76 case 55 failed\n");
8598                 FAILED(buf[4] != 7869, "test76 case 56 failed\n");
8599                 FAILED(buf[5] != -5406, "test76 case 57 failed\n");
8600                 FAILED(buf[6] != -1, "test76 case 58 failed\n");
8601         }
8602 #endif /* !SLJIT_CONFIG_SPARC */
8603
8604         successful_tests++;
8605 }
8606
8607 static void copy_u8(void *dst, sljit_sw offset, const void *src, sljit_uw length)
8608 {
8609         sljit_u8 *dst_p = (sljit_u8 *)dst + offset;
8610         const sljit_u8 *src_p = (sljit_u8 *)src;
8611
8612         while (length-- != 0)
8613                 *dst_p++ = *src_p++;
8614 }
8615
8616 static int cmp_u8(const void *src1, sljit_sw offset, const void *src2, sljit_uw length)
8617 {
8618         const sljit_u8 *src1_p = (sljit_u8 *)src1 + offset;
8619         const sljit_u8 *src2_p = (sljit_u8 *)src2;
8620
8621         while (--length != 0) {
8622                 if (*src1_p != *src2_p)
8623                         return 0;
8624                 src1_p++;
8625                 src2_p++;
8626         }
8627         return 1;
8628 }
8629
8630 static void test77(void)
8631 {
8632         /* Test unaligned access */
8633         executable_code code;
8634         struct sljit_compiler* compiler;
8635         sljit_sw i;
8636         sljit_sw wbuf[13];
8637         sljit_s32 ibuf[1];
8638         sljit_s16 hbuf[1];
8639         sljit_f64 dbuf[5];
8640         sljit_f32 sbuf[3];
8641         sljit_s8 bbuf_start[40 + 8 /* for alignment */];
8642         sljit_s8 *bbuf = (sljit_s8 *)(((sljit_uw)bbuf_start + 7) & ~(sljit_uw)7);
8643
8644         SLJIT_ASSERT(((sljit_uw)bbuf & 0x7) == 0);
8645
8646         if (verbose)
8647                 printf("Run test77\n");
8648
8649         for (i = 0; i < 13; i++)
8650                 wbuf[i] = -3;
8651
8652         for (i = 0; i < 40; i++)
8653                 bbuf[i] = -3;
8654
8655         wbuf[0] = -46870;
8656         ibuf[0] = -38512;
8657         hbuf[0] = -28531;
8658         copy_u8(bbuf, 3, hbuf, sizeof(sljit_s16));
8659         copy_u8(bbuf, 5, ibuf, sizeof(sljit_s32));
8660         copy_u8(bbuf, 9, wbuf, sizeof(sljit_sw));
8661         copy_u8(bbuf, 18, ibuf, sizeof(sljit_s32));
8662         copy_u8(bbuf, 22, wbuf, sizeof(sljit_sw));
8663         copy_u8(bbuf, 32, wbuf, sizeof(sljit_sw));
8664
8665         wbuf[0] = -62945;
8666         ibuf[0] = -90678;
8667         hbuf[0] = -17249;
8668         bbuf[0] = -73;
8669
8670         compiler = sljit_create_compiler(NULL, NULL);
8671         FAILED(!compiler, "cannot create compiler\n");
8672
8673         sljit_emit_enter(compiler, 0, SLJIT_ARGS2(VOID, P, P), 2, 2, 0, 0, 0);
8674
8675         sljit_emit_mem(compiler, SLJIT_MOV_S8 | SLJIT_MEM_UNALIGNED, SLJIT_R0, SLJIT_MEM0(), (sljit_sw)bbuf);
8676         /* wbuf[1] */
8677         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_R0, 0);
8678
8679         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0);
8680         sljit_emit_mem(compiler, SLJIT_MOV_U8 | SLJIT_MEM_UNALIGNED, SLJIT_R0, SLJIT_MEM2(SLJIT_S1, SLJIT_R0), 0);
8681         /* wbuf[2] */
8682         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_R0, 0);
8683
8684         sljit_emit_op1(compiler, SLJIT_MOV_S8, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S1), 0);
8685         /* bbuf[1] */
8686         sljit_emit_mem(compiler, SLJIT_MOV_U8 | SLJIT_MEM_STORE | SLJIT_MEM_UNALIGNED, SLJIT_R0, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_s8));
8687
8688         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R1, 0, SLJIT_S1, 0, SLJIT_IMM, 100000);
8689         sljit_emit_mem(compiler, SLJIT_MOV_S16 | SLJIT_MEM_UNALIGNED, SLJIT_R0, SLJIT_MEM1(SLJIT_R1), 100000 + 3);
8690         /* wbuf[3] */
8691         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_R0, 0);
8692
8693         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_S1, 0, SLJIT_IMM, 1000);
8694         sljit_emit_mem(compiler, SLJIT_MOV_U16 | SLJIT_MEM_UNALIGNED, SLJIT_R0, SLJIT_MEM1(SLJIT_R1), -1000 + 3);
8695         /* wbuf[4] */
8696         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_R0, 0);
8697
8698         sljit_emit_op1(compiler, SLJIT_MOV_S16, SLJIT_R0, 0, SLJIT_MEM0(), (sljit_sw)&hbuf);
8699         /* bbuf[3] */
8700         sljit_emit_mem(compiler, SLJIT_MOV_S16 | SLJIT_MEM_STORE | SLJIT_MEM_UNALIGNED, SLJIT_R0, SLJIT_MEM1(SLJIT_S1), 3);
8701
8702         sljit_emit_mem(compiler, SLJIT_MOV_S32 | SLJIT_MEM_UNALIGNED, SLJIT_R0, SLJIT_MEM1(SLJIT_S1), 5);
8703         /* wbuf[5] */
8704         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_R0, 0);
8705
8706         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 5);
8707         sljit_emit_mem(compiler, SLJIT_MOV_U32 | SLJIT_MEM_UNALIGNED, SLJIT_R0, SLJIT_MEM2(SLJIT_R0, SLJIT_S1), 0);
8708         /* wbuf[6] */
8709         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_sw), SLJIT_R0, 0);
8710
8711         sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R1, 0, SLJIT_S1, 0, SLJIT_IMM, 100000);
8712         sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_MEM0(), (sljit_sw)&ibuf);
8713         /* bbuf[5] */
8714         sljit_emit_mem(compiler, SLJIT_MOV32 | SLJIT_MEM_STORE | SLJIT_MEM_UNALIGNED, SLJIT_R0, SLJIT_MEM1(SLJIT_R1), 100000 + 5);
8715
8716         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_S1, 0, SLJIT_IMM, 100000);
8717         sljit_emit_mem(compiler, SLJIT_MOV | SLJIT_MEM_UNALIGNED, SLJIT_R0, SLJIT_MEM1(SLJIT_R1), -100000 + 9);
8718         /* wbuf[7] */
8719         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_sw), SLJIT_R0, 0);
8720
8721         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), 0);
8722         /* bbuf[9] */
8723         sljit_emit_mem(compiler, SLJIT_MOV | SLJIT_MEM_STORE | SLJIT_MEM_UNALIGNED, SLJIT_R0, SLJIT_MEM1(SLJIT_R1), -100000 + 9);
8724
8725         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 18 >> 1);
8726         sljit_emit_mem(compiler, SLJIT_MOV_S32 | SLJIT_MEM_UNALIGNED | SLJIT_MEM_ALIGNED_16, SLJIT_R0, SLJIT_MEM2(SLJIT_S1, SLJIT_R1), 1);
8727         /* wbuf[8] */
8728         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_sw), SLJIT_R0, 0);
8729
8730         sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_R0, 0, SLJIT_MEM0(), (sljit_sw)&ibuf);
8731         /* bbuf[18] */
8732         sljit_emit_mem(compiler, SLJIT_MOV_S32 | SLJIT_MEM_STORE | SLJIT_MEM_UNALIGNED | SLJIT_MEM_ALIGNED_16, SLJIT_R0, SLJIT_MEM2(SLJIT_S1, SLJIT_R1), 1);
8733
8734         sljit_emit_mem(compiler, SLJIT_MOV | SLJIT_MEM_UNALIGNED | SLJIT_MEM_ALIGNED_16, SLJIT_R0, SLJIT_MEM0(), (sljit_sw)bbuf + 22);
8735         /* wbuf[9] */
8736         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 9 * sizeof(sljit_sw), SLJIT_R0, 0);
8737
8738         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), 0);
8739         /* bbuf[22] */
8740         sljit_emit_mem(compiler, SLJIT_MOV | SLJIT_MEM_STORE | SLJIT_MEM_UNALIGNED | SLJIT_MEM_ALIGNED_16, SLJIT_R0, SLJIT_MEM0(), (sljit_sw)bbuf + 22);
8741
8742         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_S1, 0, SLJIT_IMM, 128);
8743         sljit_emit_mem(compiler, SLJIT_MOV | SLJIT_MEM_UNALIGNED | SLJIT_MEM_ALIGNED_32, SLJIT_R0, SLJIT_MEM1(SLJIT_R0), -128 + 32);
8744         /* wbuf[10] */
8745         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 10 * sizeof(sljit_sw), SLJIT_R0, 0);
8746
8747         sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_S1, 0, SLJIT_IMM, 128);
8748         sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), 0);
8749         /* bbuf[32] */
8750         sljit_emit_mem(compiler, SLJIT_MOV | SLJIT_MEM_STORE | SLJIT_MEM_UNALIGNED | SLJIT_MEM_ALIGNED_32, SLJIT_R0, SLJIT_MEM1(SLJIT_R1), -128 + 32);
8751
8752         sljit_emit_mem(compiler, SLJIT_MOV | SLJIT_MEM_UNALIGNED, SLJIT_R0, SLJIT_MEM1(SLJIT_S0), 0);
8753         /* wbuf[11] */
8754         sljit_emit_mem(compiler, SLJIT_MOV | SLJIT_MEM_STORE | SLJIT_MEM_UNALIGNED, SLJIT_R0, SLJIT_MEM1(SLJIT_S0), 11 * sizeof(sljit_sw));
8755         /* wbuf[12] */
8756         sljit_emit_mem(compiler, SLJIT_MOV | SLJIT_MEM_STORE | SLJIT_MEM_UNALIGNED, SLJIT_S0, SLJIT_MEM1(SLJIT_S0), 12 * sizeof(sljit_sw));
8757
8758         sljit_emit_return_void(compiler);
8759
8760         code.code = sljit_generate_code(compiler);
8761         CHECK(compiler);
8762         sljit_free_compiler(compiler);
8763
8764         code.func2((sljit_sw)&wbuf, (sljit_sw)bbuf);
8765
8766         FAILED(wbuf[1] != -73, "test77 case 1 failed\n");
8767         FAILED(wbuf[2] != (sljit_u8)-73, "test77 case 2 failed\n");
8768         FAILED(bbuf[1] != -73, "test77 case 3 failed\n");
8769         FAILED(wbuf[3] != -28531, "test77 case 4 failed\n");
8770         FAILED(wbuf[4] != (sljit_u16)-28531, "test77 case 5 failed\n");
8771         FAILED(cmp_u8(bbuf, 3, hbuf, sizeof(sljit_s16)) != 1, "test77 case 6 failed\n");
8772         FAILED(wbuf[5] != -38512, "test77 case 7 failed\n");
8773 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
8774         FAILED(wbuf[6] != (sljit_u32)-38512, "test77 case 8 failed\n");
8775 #else
8776         FAILED(wbuf[6] != -38512, "test77 case 8 failed\n");
8777 #endif
8778         FAILED(cmp_u8(bbuf, 5, ibuf, sizeof(sljit_s32)) != 1, "test77 case 9 failed\n");
8779         FAILED(wbuf[7] != -46870, "test77 case 10 failed\n");
8780         FAILED(cmp_u8(bbuf, 9, wbuf, sizeof(sljit_sw)) != 1, "test77 case 11 failed\n");
8781         FAILED(wbuf[8] != -38512, "test77 case 12 failed\n");
8782         FAILED(cmp_u8(bbuf, 18, ibuf, sizeof(sljit_s32)) != 1, "test77 case 13 failed\n");
8783         FAILED(wbuf[9] != -46870, "test77 case 14 failed\n");
8784         FAILED(cmp_u8(bbuf, 22, wbuf, sizeof(sljit_sw)) != 1, "test77 case 15 failed\n");
8785         FAILED(wbuf[10] != -46870, "test77 case 16 failed\n");
8786         FAILED(cmp_u8(bbuf, 32, wbuf, sizeof(sljit_sw)) != 1, "test77 case 17 failed\n");
8787         FAILED(wbuf[11] != -62945, "test77 case 18 failed\n");
8788         FAILED(wbuf[12] != (sljit_sw)&wbuf, "test77 case 19 failed\n");
8789
8790         sljit_free_code(code.code, NULL);
8791
8792         if (sljit_has_cpu_feature(SLJIT_HAS_FPU)) {
8793                 for (i = 0; i < 40; i++)
8794                         bbuf[i] = -3;
8795
8796                 for (i = 0; i < 5; i++)
8797                         dbuf[i] = 0;
8798
8799                 dbuf[0] = 6897.75;
8800                 sbuf[0] = -8812.25;
8801                 copy_u8(bbuf, 1, sbuf, sizeof(sljit_f32));
8802                 copy_u8(bbuf, 5, dbuf, sizeof(sljit_f64));
8803                 copy_u8(bbuf, 14, sbuf, sizeof(sljit_f32));
8804                 copy_u8(bbuf, 18, dbuf, sizeof(sljit_f64));
8805                 copy_u8(bbuf, 28, dbuf, sizeof(sljit_f64));
8806
8807                 dbuf[0] = -18046.5;
8808                 sbuf[0] = 3751.75;
8809
8810                 compiler = sljit_create_compiler(NULL, NULL);
8811                 FAILED(!compiler, "cannot create compiler\n");
8812
8813                 sljit_emit_enter(compiler, 0, SLJIT_ARGS3(VOID, P, P, P), 1, 3, 1, 0, 0);
8814
8815                 sljit_emit_fmem(compiler, SLJIT_MOV_F32 | SLJIT_MEM_UNALIGNED, SLJIT_FR0, SLJIT_MEM0(), (sljit_sw)bbuf + 1);
8816                 /* sbuf[1] */
8817                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_f32), SLJIT_FR0, 0);
8818
8819                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S1), 0);
8820                 /* bbuf[1] */
8821                 sljit_emit_fmem(compiler, SLJIT_MOV_F32 | SLJIT_MEM_STORE | SLJIT_MEM_UNALIGNED, SLJIT_FR0, SLJIT_MEM0(), (sljit_sw)bbuf + 1);
8822
8823                 sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R0, 0, SLJIT_S2, 0, SLJIT_IMM, 100000);
8824                 sljit_emit_fmem(compiler, SLJIT_MOV_F64 | SLJIT_MEM_UNALIGNED, SLJIT_FR0, SLJIT_MEM1(SLJIT_R0), 100000 + 5);
8825                 /* dbuf[1] */
8826                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64), SLJIT_FR0, 0);
8827
8828                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S0), 0);
8829                 /* bbuf[5] */
8830                 sljit_emit_fmem(compiler, SLJIT_MOV_F64 | SLJIT_MEM_STORE | SLJIT_MEM_UNALIGNED, SLJIT_FR0, SLJIT_MEM1(SLJIT_R0), 100000 + 5);
8831
8832                 sljit_emit_fmem(compiler, SLJIT_MOV_F32 | SLJIT_MEM_UNALIGNED | SLJIT_MEM_ALIGNED_16, SLJIT_FR0, SLJIT_MEM1(SLJIT_S2), 14);
8833                 /* sbuf[2] */
8834                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_S1), 2 * sizeof(sljit_f32), SLJIT_FR0, 0);
8835
8836                 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S1), 0);
8837                 /* bbuf[14] */
8838                 sljit_emit_fmem(compiler, SLJIT_MOV_F32 | SLJIT_MEM_STORE | SLJIT_MEM_UNALIGNED | SLJIT_MEM_ALIGNED_16, SLJIT_FR0, SLJIT_MEM1(SLJIT_S2), 14);
8839
8840                 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 18 >> 1);
8841                 sljit_emit_fmem(compiler, SLJIT_MOV_F64 | SLJIT_MEM_UNALIGNED | SLJIT_MEM_ALIGNED_16, SLJIT_FR0, SLJIT_MEM2(SLJIT_S2, SLJIT_R0), 1);
8842                 /* dbuf[2] */
8843                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_f64), SLJIT_FR0, 0);
8844
8845                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S0), 0);
8846                 /* bbuf[18] */
8847                 sljit_emit_fmem(compiler, SLJIT_MOV_F64 | SLJIT_MEM_STORE | SLJIT_MEM_UNALIGNED | SLJIT_MEM_ALIGNED_16, SLJIT_FR0, SLJIT_MEM2(SLJIT_S2, SLJIT_R0), 1);
8848
8849                 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_S2, 0, SLJIT_IMM, 128);
8850                 sljit_emit_fmem(compiler, SLJIT_MOV_F64 | SLJIT_MEM_UNALIGNED | SLJIT_MEM_ALIGNED_32, SLJIT_FR0, SLJIT_MEM1(SLJIT_R0), -128 + 28);
8851                 /* dbuf[3] */
8852                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_f64), SLJIT_FR0, 0);
8853
8854                 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S0), 0);
8855                 /* bbuf[28] */
8856                 sljit_emit_fmem(compiler, SLJIT_MOV_F64 | SLJIT_MEM_STORE | SLJIT_MEM_UNALIGNED | SLJIT_MEM_ALIGNED_32, SLJIT_FR0, SLJIT_MEM1(SLJIT_R0), -128 + 28);
8857
8858                 sljit_emit_fmem(compiler, SLJIT_MOV_F64 | SLJIT_MEM_UNALIGNED | SLJIT_MEM_ALIGNED_32, SLJIT_FR0, SLJIT_MEM1(SLJIT_S0), 0);
8859                 /* dbuf[4] */
8860                 sljit_emit_fmem(compiler, SLJIT_MOV_F64 | SLJIT_MEM_STORE | SLJIT_MEM_UNALIGNED | SLJIT_MEM_ALIGNED_32, SLJIT_FR0, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_f64));
8861
8862                 sljit_emit_return_void(compiler);
8863
8864                 code.code = sljit_generate_code(compiler);
8865                 CHECK(compiler);
8866                 sljit_free_compiler(compiler);
8867
8868                 code.func3((sljit_sw)&dbuf, (sljit_sw)&sbuf, (sljit_sw)bbuf);
8869
8870                 FAILED(sbuf[1] != -8812.25, "test77 case 20 failed\n");
8871                 FAILED(cmp_u8(bbuf, 1, sbuf, sizeof(sljit_f32)) != 1, "test77 case 21 failed\n");
8872                 FAILED(dbuf[1] != 6897.75, "test77 case 22 failed\n");
8873                 FAILED(cmp_u8(bbuf, 5, dbuf, sizeof(sljit_f64)) != 1, "test77 case 23 failed\n");
8874                 FAILED(sbuf[2] != -8812.25, "test77 case 24 failed\n");
8875                 FAILED(cmp_u8(bbuf, 14, sbuf, sizeof(sljit_f32)) != 1, "test77 case 25 failed\n");
8876                 FAILED(dbuf[2] != 6897.75, "test77 case 26 failed\n");
8877                 FAILED(cmp_u8(bbuf, 18, dbuf, sizeof(sljit_f64)) != 1, "test77 case 27 failed\n");
8878                 FAILED(dbuf[3] != 6897.75, "test77 case 28 failed\n");
8879                 FAILED(cmp_u8(bbuf, 28, dbuf, sizeof(sljit_f64)) != 1, "test77 case 29 failed\n");
8880                 FAILED(dbuf[4] != -18046.5, "test77 case 30 failed\n");
8881
8882                 sljit_free_code(code.code, NULL);
8883         }
8884
8885         successful_tests++;
8886 }
8887
8888 int sljit_test(int argc, char* argv[])
8889 {
8890         sljit_s32 has_arg = (argc >= 2 && argv[1][0] == '-' && argv[1][2] == '\0');
8891         verbose = has_arg && argv[1][1] == 'v';
8892         silent = has_arg && argv[1][1] == 's';
8893
8894         if (!verbose && !silent)
8895                 printf("Pass -v to enable verbose, -s to disable this hint.\n\n");
8896
8897 #if !(defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED)
8898         test_exec_allocator();
8899 #endif
8900         test1();
8901         test2();
8902         test3();
8903         test4();
8904         test5();
8905         test6();
8906         test7();
8907         test8();
8908         test9();
8909         test10();
8910         test11();
8911         test12();
8912         test13();
8913         test14();
8914         test15();
8915         test16();
8916         test17();
8917         test18();
8918         test19();
8919         test20();
8920         test21();
8921         test22();
8922         test23();
8923         test24();
8924         test25();
8925         test26();
8926         test27();
8927         test28();
8928         test29();
8929         test30();
8930         test31();
8931         test32();
8932         test33();
8933         test34();
8934         test35();
8935         test36();
8936         test37();
8937         test38();
8938         test39();
8939         test40();
8940         test41();
8941         test42();
8942         test43();
8943         test44();
8944         test45();
8945         test46();
8946         test47();
8947         test48();
8948         test49();
8949         test50();
8950         test51();
8951         test52();
8952         test53();
8953         test54();
8954         test55();
8955         test56();
8956         test57();
8957         test58();
8958         test59();
8959         test60();
8960         test61();
8961         test62();
8962         test63();
8963         test64();
8964         test65();
8965         test66();
8966         test67();
8967         test68();
8968         test69();
8969         test70();
8970         test71();
8971         test72();
8972         test73();
8973         test74();
8974         test75();
8975         test76();
8976         test77();
8977
8978 #if (defined SLJIT_EXECUTABLE_ALLOCATOR && SLJIT_EXECUTABLE_ALLOCATOR)
8979         sljit_free_unused_memory_exec();
8980 #endif
8981
8982 #       define TEST_COUNT 77
8983
8984         printf("SLJIT tests: ");
8985         if (successful_tests == TEST_COUNT)
8986                 printf("all tests are " COLOR_GREEN "PASSED" COLOR_DEFAULT " ");
8987         else
8988                 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);
8989         printf("on " COLOR_ARCH "%s" COLOR_DEFAULT "%s\n", sljit_get_platform_name(), sljit_has_cpu_feature(SLJIT_HAS_FPU) ? " (with fpu)" : " (without fpu)");
8990
8991         return TEST_COUNT - successful_tests;
8992
8993 #       undef TEST_COUNT
8994 }
8995
8996 #ifdef _MSC_VER
8997 #pragma warning(pop)
8998 #endif