sljitTest.c revision 1.1.1.4
1 /* 2 * Stack-less Just-In-Time compiler 3 * 4 * Copyright 2009-2010 Zoltan Herczeg (hzmester (at) 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 #if defined _WIN32 || defined _WIN64 35 #define COLOR_RED 36 #define COLOR_GREEN 37 #define COLOR_ARCH 38 #define COLOR_DEFAULT 39 #else 40 #define COLOR_RED "\33[31m" 41 #define COLOR_GREEN "\33[32m" 42 #define COLOR_ARCH "\33[33m" 43 #define COLOR_DEFAULT "\33[0m" 44 #endif 45 46 union executable_code { 47 void* code; 48 sljit_sw (SLJIT_CALL *func0)(void); 49 sljit_sw (SLJIT_CALL *func1)(sljit_sw a); 50 sljit_sw (SLJIT_CALL *func2)(sljit_sw a, sljit_sw b); 51 sljit_sw (SLJIT_CALL *func3)(sljit_sw a, sljit_sw b, sljit_sw c); 52 }; 53 typedef union executable_code executable_code; 54 55 static sljit_s32 successful_tests = 0; 56 static sljit_s32 verbose = 0; 57 static sljit_s32 silent = 0; 58 59 #define FAILED(cond, text) \ 60 if (SLJIT_UNLIKELY(cond)) { \ 61 printf(text); \ 62 return; \ 63 } 64 65 #define CHECK(compiler) \ 66 if (sljit_get_compiler_error(compiler) != SLJIT_ERR_COMPILED) { \ 67 printf("Compiler error: %d\n", sljit_get_compiler_error(compiler)); \ 68 sljit_free_compiler(compiler); \ 69 return; \ 70 } 71 72 static void cond_set(struct sljit_compiler *compiler, sljit_s32 dst, sljit_sw dstw, sljit_s32 type) 73 { 74 /* Testing both sljit_emit_op_flags and sljit_emit_jump. */ 75 struct sljit_jump* jump; 76 struct sljit_label* label; 77 78 sljit_emit_op_flags(compiler, SLJIT_MOV, dst, dstw, SLJIT_UNUSED, 0, type); 79 jump = sljit_emit_jump(compiler, type); 80 sljit_emit_op2(compiler, SLJIT_ADD | SLJIT_KEEP_FLAGS, dst, dstw, dst, dstw, SLJIT_IMM, 2); 81 label = sljit_emit_label(compiler); 82 sljit_set_label(jump, label); 83 } 84 85 #if !(defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED) 86 87 #define MALLOC_EXEC(result, size) \ 88 result = SLJIT_MALLOC_EXEC(size); \ 89 if (!result) { \ 90 printf("Cannot allocate executable memory\n"); \ 91 return; \ 92 } \ 93 memset(result, 255, size); 94 95 static void test_exec_allocator(void) 96 { 97 /* This is not an sljit test. */ 98 void *ptr1; 99 void *ptr2; 100 void *ptr3; 101 102 if (verbose) 103 printf("Run executable allocator test\n"); 104 105 MALLOC_EXEC(ptr1, 32); 106 MALLOC_EXEC(ptr2, 512); 107 MALLOC_EXEC(ptr3, 512); 108 SLJIT_FREE_EXEC(ptr2); 109 SLJIT_FREE_EXEC(ptr3); 110 SLJIT_FREE_EXEC(ptr1); 111 MALLOC_EXEC(ptr1, 262104); 112 MALLOC_EXEC(ptr2, 32000); 113 SLJIT_FREE_EXEC(ptr1); 114 MALLOC_EXEC(ptr1, 262104); 115 SLJIT_FREE_EXEC(ptr1); 116 SLJIT_FREE_EXEC(ptr2); 117 MALLOC_EXEC(ptr1, 512); 118 MALLOC_EXEC(ptr2, 512); 119 MALLOC_EXEC(ptr3, 512); 120 SLJIT_FREE_EXEC(ptr2); 121 MALLOC_EXEC(ptr2, 512); 122 #if (defined SLJIT_EXECUTABLE_ALLOCATOR && SLJIT_EXECUTABLE_ALLOCATOR) 123 sljit_free_unused_memory_exec(); 124 #endif 125 SLJIT_FREE_EXEC(ptr3); 126 SLJIT_FREE_EXEC(ptr1); 127 SLJIT_FREE_EXEC(ptr2); 128 #if (defined SLJIT_UTIL_GLOBAL_LOCK && SLJIT_UTIL_GLOBAL_LOCK) 129 /* Just call the global locks. */ 130 sljit_grab_lock(); 131 sljit_release_lock(); 132 #endif 133 134 #if (defined SLJIT_EXECUTABLE_ALLOCATOR && SLJIT_EXECUTABLE_ALLOCATOR) 135 sljit_free_unused_memory_exec(); 136 #endif 137 } 138 139 #undef MALLOC_EXEC 140 141 #endif /* !(defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED) */ 142 143 static void test1(void) 144 { 145 /* Enter and return from an sljit function. */ 146 executable_code code; 147 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 148 149 if (verbose) 150 printf("Run test1\n"); 151 152 FAILED(!compiler, "cannot create compiler\n"); 153 154 /* 3 arguments passed, 3 arguments used. */ 155 sljit_emit_enter(compiler, 0, 3, 3, 3, 0, 0, 0); 156 sljit_emit_return(compiler, SLJIT_MOV, SLJIT_S1, 0); 157 158 SLJIT_ASSERT(sljit_get_generated_code_size(compiler) == 0); 159 code.code = sljit_generate_code(compiler); 160 CHECK(compiler); 161 SLJIT_ASSERT(compiler->error == SLJIT_ERR_COMPILED); 162 SLJIT_ASSERT(sljit_get_generated_code_size(compiler) > 0); 163 sljit_free_compiler(compiler); 164 165 FAILED(code.func3(3, -21, 86) != -21, "test1 case 1 failed\n"); 166 FAILED(code.func3(4789, 47890, 997) != 47890, "test1 case 2 failed\n"); 167 168 sljit_free_code(code.code); 169 successful_tests++; 170 } 171 172 static void test2(void) 173 { 174 /* Test mov. */ 175 executable_code code; 176 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 177 sljit_sw buf[8]; 178 static sljit_sw data[2] = { 0, -9876 }; 179 180 if (verbose) 181 printf("Run test2\n"); 182 183 FAILED(!compiler, "cannot create compiler\n"); 184 185 buf[0] = 5678; 186 buf[1] = 0; 187 buf[2] = 0; 188 buf[3] = 0; 189 buf[4] = 0; 190 buf[5] = 0; 191 buf[6] = 0; 192 buf[7] = 0; 193 sljit_emit_enter(compiler, 0, 1, 3, 2, 0, 0, 0); 194 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_UNUSED, 0, SLJIT_MEM0(), (sljit_sw)&buf); 195 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 9999); 196 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_S0, 0); 197 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_sw), SLJIT_R0, 0); 198 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, sizeof(sljit_sw)); 199 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_MEM2(SLJIT_S1, SLJIT_R1), 0); 200 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, 2); 201 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM2(SLJIT_S1, SLJIT_S0), SLJIT_WORD_SHIFT, SLJIT_MEM2(SLJIT_S1, SLJIT_R1), 0); 202 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, 3); 203 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM2(SLJIT_S1, SLJIT_S0), SLJIT_WORD_SHIFT, SLJIT_MEM0(), (sljit_sw)&buf); 204 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, sizeof(sljit_sw)); 205 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_R0), (sljit_sw)&data); 206 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S1), 4 * sizeof(sljit_sw), SLJIT_R0, 0); 207 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&buf - 0x12345678); 208 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_R0), 0x12345678); 209 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S1), 5 * sizeof(sljit_sw), SLJIT_R0, 0); 210 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 3456); 211 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, (sljit_sw)&buf - 0xff890 + 6 * sizeof(sljit_sw)); 212 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), 0xff890, SLJIT_R0, 0); 213 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, (sljit_sw)&buf + 0xff890 + 7 * sizeof(sljit_sw)); 214 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), -0xff890, SLJIT_R0, 0); 215 sljit_emit_return(compiler, SLJIT_MOV, SLJIT_R2, 0); 216 217 code.code = sljit_generate_code(compiler); 218 CHECK(compiler); 219 sljit_free_compiler(compiler); 220 221 FAILED(code.func1((sljit_sw)&buf) != 9999, "test2 case 1 failed\n"); 222 FAILED(buf[1] != 9999, "test2 case 2 failed\n"); 223 FAILED(buf[2] != 9999, "test2 case 3 failed\n"); 224 FAILED(buf[3] != 5678, "test2 case 4 failed\n"); 225 FAILED(buf[4] != -9876, "test2 case 5 failed\n"); 226 FAILED(buf[5] != 5678, "test2 case 6 failed\n"); 227 FAILED(buf[6] != 3456, "test2 case 6 failed\n"); 228 FAILED(buf[7] != 3456, "test2 case 6 failed\n"); 229 230 sljit_free_code(code.code); 231 successful_tests++; 232 } 233 234 static void test3(void) 235 { 236 /* Test not. */ 237 executable_code code; 238 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 239 sljit_sw buf[5]; 240 241 if (verbose) 242 printf("Run test3\n"); 243 244 FAILED(!compiler, "cannot create compiler\n"); 245 buf[0] = 1234; 246 buf[1] = 0; 247 buf[2] = 9876; 248 buf[3] = 0; 249 buf[4] = 0x12345678; 250 251 sljit_emit_enter(compiler, 0, 1, 3, 1, 0, 0, 0); 252 sljit_emit_op1(compiler, SLJIT_NOT, SLJIT_UNUSED, 0, SLJIT_MEM0(), (sljit_sw)&buf); 253 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_MEM1(SLJIT_S0), 0); 254 sljit_emit_op1(compiler, SLJIT_NOT, SLJIT_MEM0(), (sljit_sw)&buf[1], SLJIT_MEM0(), (sljit_sw)&buf[1]); 255 sljit_emit_op1(compiler, SLJIT_NOT, SLJIT_RETURN_REG, 0, SLJIT_MEM1(SLJIT_S0), 0); 256 sljit_emit_op1(compiler, SLJIT_NOT, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 3, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 2); 257 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, (sljit_sw)&buf[4] - 0xff0000 - 0x20); 258 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, (sljit_sw)&buf[4] - 0xff0000); 259 sljit_emit_op1(compiler, SLJIT_NOT, SLJIT_MEM1(SLJIT_R1), 0xff0000 + 0x20, SLJIT_MEM1(SLJIT_R2), 0xff0000); 260 sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0); 261 262 code.code = sljit_generate_code(compiler); 263 CHECK(compiler); 264 sljit_free_compiler(compiler); 265 266 FAILED(code.func1((sljit_sw)&buf) != ~1234, "test3 case 1 failed\n"); 267 FAILED(buf[1] != ~1234, "test3 case 2 failed\n"); 268 FAILED(buf[3] != ~9876, "test3 case 3 failed\n"); 269 FAILED(buf[4] != ~0x12345678, "test3 case 4 failed\n"); 270 271 sljit_free_code(code.code); 272 successful_tests++; 273 } 274 275 static void test4(void) 276 { 277 /* Test neg. */ 278 executable_code code; 279 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 280 sljit_sw buf[4]; 281 282 if (verbose) 283 printf("Run test4\n"); 284 285 FAILED(!compiler, "cannot create compiler\n"); 286 buf[0] = 0; 287 buf[1] = 1234; 288 buf[2] = 0; 289 buf[3] = 0; 290 291 sljit_emit_enter(compiler, 0, 2, 3, 2, 0, 0, 0); 292 sljit_emit_op1(compiler, SLJIT_NEG, SLJIT_UNUSED, 0, SLJIT_MEM1(SLJIT_S0), 0); 293 sljit_emit_op1(compiler, SLJIT_NEG, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 2, SLJIT_S1, 0); 294 sljit_emit_op1(compiler, SLJIT_NEG, SLJIT_MEM0(), (sljit_sw)&buf[0], SLJIT_MEM0(), (sljit_sw)&buf[1]); 295 sljit_emit_op1(compiler, SLJIT_NEG, SLJIT_RETURN_REG, 0, SLJIT_S1, 0); 296 sljit_emit_op1(compiler, SLJIT_NEG, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 3, SLJIT_IMM, 299); 297 sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0); 298 299 code.code = sljit_generate_code(compiler); 300 CHECK(compiler); 301 sljit_free_compiler(compiler); 302 303 FAILED(code.func2((sljit_sw)&buf, 4567) != -4567, "test4 case 1 failed\n"); 304 FAILED(buf[0] != -1234, "test4 case 2 failed\n"); 305 FAILED(buf[2] != -4567, "test4 case 3 failed\n"); 306 FAILED(buf[3] != -299, "test4 case 4 failed\n"); 307 308 sljit_free_code(code.code); 309 successful_tests++; 310 } 311 312 static void test5(void) 313 { 314 /* Test add. */ 315 executable_code code; 316 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 317 sljit_sw buf[9]; 318 319 if (verbose) 320 printf("Run test5\n"); 321 322 FAILED(!compiler, "cannot create compiler\n"); 323 buf[0] = 100; 324 buf[1] = 200; 325 buf[2] = 300; 326 buf[3] = 0; 327 buf[4] = 0; 328 buf[5] = 0; 329 buf[6] = 0; 330 buf[7] = 0; 331 buf[8] = 313; 332 333 sljit_emit_enter(compiler, 0, 1, 3, 2, 0, 0, 0); 334 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_UNUSED, 0, SLJIT_IMM, 16, SLJIT_IMM, 16); 335 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_UNUSED, 0, SLJIT_IMM, 255, SLJIT_IMM, 255); 336 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_UNUSED, 0, SLJIT_S0, 0, SLJIT_S0, 0); 337 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, sizeof(sljit_sw)); 338 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 50); 339 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); 340 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, sizeof(sljit_sw) + 2); 341 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, 50); 342 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), 0); 343 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0); 344 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_IMM, 4, SLJIT_R0, 0); 345 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_IMM, 50, SLJIT_R1, 0); 346 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)); 347 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_R1, 0); 348 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)); 349 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)); 350 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); 351 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0x1e7d39f2); 352 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_sw), SLJIT_R1, 0, SLJIT_IMM, 0x23de7c06); 353 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_sw), SLJIT_IMM, 0x3d72e452, SLJIT_R1, 0); 354 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)); 355 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_IMM, 1000, SLJIT_R0, 0); 356 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 1430); 357 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_IMM, -99, SLJIT_R0, 0); 358 359 sljit_emit_return(compiler, SLJIT_MOV, SLJIT_R0, 0); 360 361 code.code = sljit_generate_code(compiler); 362 CHECK(compiler); 363 sljit_free_compiler(compiler); 364 365 FAILED(code.func1((sljit_sw)&buf) != 2437 + 2 * sizeof(sljit_sw), "test5 case 1 failed\n"); 366 FAILED(buf[0] != 202 + 2 * sizeof(sljit_sw), "test5 case 2 failed\n"); 367 FAILED(buf[2] != 500, "test5 case 3 failed\n"); 368 FAILED(buf[3] != 400, "test5 case 4 failed\n"); 369 FAILED(buf[4] != 200, "test5 case 5 failed\n"); 370 FAILED(buf[5] != 250, "test5 case 6 failed\n"); 371 FAILED(buf[6] != 0x425bb5f8, "test5 case 7 failed\n"); 372 FAILED(buf[7] != 0x5bf01e44, "test5 case 8 failed\n"); 373 FAILED(buf[8] != 270, "test5 case 9 failed\n"); 374 375 sljit_free_code(code.code); 376 successful_tests++; 377 } 378 379 static void test6(void) 380 { 381 /* Test addc, sub, subc. */ 382 executable_code code; 383 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 384 sljit_sw buf[10]; 385 386 if (verbose) 387 printf("Run test6\n"); 388 389 FAILED(!compiler, "cannot create compiler\n"); 390 buf[0] = 0; 391 buf[1] = 0; 392 buf[2] = 0; 393 buf[3] = 0; 394 buf[4] = 0; 395 buf[5] = 0; 396 buf[6] = 0; 397 buf[7] = 0; 398 buf[8] = 0; 399 buf[9] = 0; 400 401 sljit_emit_enter(compiler, 0, 1, 3, 1, 0, 0, 0); 402 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -1); 403 sljit_emit_op2(compiler, SLJIT_ADD | SLJIT_SET_C, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, -1); 404 sljit_emit_op2(compiler, SLJIT_ADDC, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_IMM, 0, SLJIT_IMM, 0); 405 sljit_emit_op2(compiler, SLJIT_ADD | SLJIT_SET_C, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_R0, 0); 406 sljit_emit_op2(compiler, SLJIT_ADDC, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_IMM, 4); 407 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 100); 408 sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 2, SLJIT_R0, 0, SLJIT_IMM, 50); 409 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_C, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 6000); 410 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 3, SLJIT_IMM, 10); 411 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); 412 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 100); 413 sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 2); 414 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 4, SLJIT_R0, 0); 415 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 5000); 416 sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 4, SLJIT_R0, 0); 417 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_R1, 0); 418 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 5, SLJIT_R1, 0); 419 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 5000); 420 sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R0, 0, SLJIT_IMM, 6000, SLJIT_R0, 0); 421 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 6, SLJIT_R0, 0); 422 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 100); 423 sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, 32768); 424 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 7, SLJIT_R1, 0); 425 sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, -32767); 426 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 8, SLJIT_R1, 0); 427 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0x52cd3bf4); 428 sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 9, SLJIT_R0, 0, SLJIT_IMM, 0x3da297c6); 429 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, 10); 430 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_C, SLJIT_RETURN_REG, 0, SLJIT_RETURN_REG, 0, SLJIT_IMM, 5); 431 sljit_emit_op2(compiler, SLJIT_SUBC, SLJIT_RETURN_REG, 0, SLJIT_RETURN_REG, 0, SLJIT_IMM, 2); 432 sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_RETURN_REG, 0, SLJIT_RETURN_REG, 0, SLJIT_IMM, -2220); 433 sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0); 434 435 code.code = sljit_generate_code(compiler); 436 CHECK(compiler); 437 sljit_free_compiler(compiler); 438 439 FAILED(code.func1((sljit_sw)&buf) != 2223, "test6 case 1 failed\n"); 440 FAILED(buf[0] != 1, "test6 case 2 failed\n"); 441 FAILED(buf[1] != 5, "test6 case 3 failed\n"); 442 FAILED(buf[2] != 50, "test6 case 4 failed\n"); 443 FAILED(buf[3] != 4, "test6 case 5 failed\n"); 444 FAILED(buf[4] != 50, "test6 case 6 failed\n"); 445 FAILED(buf[5] != 50, "test6 case 7 failed\n"); 446 FAILED(buf[6] != 1000, "test6 case 8 failed\n"); 447 FAILED(buf[7] != 100 - 32768, "test6 case 9 failed\n"); 448 FAILED(buf[8] != 100 + 32767, "test6 case 10 failed\n"); 449 FAILED(buf[9] != 0x152aa42e, "test6 case 11 failed\n"); 450 451 sljit_free_code(code.code); 452 successful_tests++; 453 } 454 455 static void test7(void) 456 { 457 /* Test logical operators. */ 458 executable_code code; 459 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 460 sljit_sw buf[8]; 461 462 if (verbose) 463 printf("Run test7\n"); 464 465 FAILED(!compiler, "cannot create compiler\n"); 466 buf[0] = 0xff80; 467 buf[1] = 0x0f808080; 468 buf[2] = 0; 469 buf[3] = 0xaaaaaa; 470 buf[4] = 0; 471 buf[5] = 0x4040; 472 buf[6] = 0; 473 buf[7] = 0xc43a7f95; 474 475 sljit_emit_enter(compiler, 0, 1, 3, 1, 0, 0, 0); 476 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0xf0C000); 477 sljit_emit_op2(compiler, SLJIT_OR, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 2, SLJIT_R0, 0, SLJIT_IMM, 0x308f); 478 sljit_emit_op2(compiler, SLJIT_XOR, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw)); 479 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); 480 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0xC0F0); 481 sljit_emit_op2(compiler, SLJIT_XOR, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 5); 482 sljit_emit_op2(compiler, SLJIT_OR, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 0xff0000); 483 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 4, SLJIT_R0, 0); 484 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 0xC0F0); 485 sljit_emit_op2(compiler, SLJIT_AND, SLJIT_R2, 0, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 5); 486 sljit_emit_op2(compiler, SLJIT_OR, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 5, SLJIT_R2, 0, SLJIT_IMM, 0xff0000); 487 sljit_emit_op2(compiler, SLJIT_XOR, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_IMM, 0xFFFFFF, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw)); 488 sljit_emit_op2(compiler, SLJIT_OR, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 6, SLJIT_IMM, 0xa56c82c0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 6); 489 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 7); 490 sljit_emit_op2(compiler, SLJIT_XOR, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 7, SLJIT_IMM, 0xff00ff00, SLJIT_R0, 0); 491 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0xff00ff00); 492 sljit_emit_op2(compiler, SLJIT_OR, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, 0x0f); 493 sljit_emit_op2(compiler, SLJIT_AND, SLJIT_RETURN_REG, 0, SLJIT_IMM, 0x888888, SLJIT_R1, 0); 494 sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0); 495 496 code.code = sljit_generate_code(compiler); 497 CHECK(compiler); 498 sljit_free_compiler(compiler); 499 500 FAILED(code.func1((sljit_sw)&buf) != 0x8808, "test7 case 1 failed\n"); 501 FAILED(buf[0] != 0x0F807F00, "test7 case 2 failed\n"); 502 FAILED(buf[1] != 0x0F7F7F7F, "test7 case 3 failed\n"); 503 FAILED(buf[2] != 0x00F0F08F, "test7 case 4 failed\n"); 504 FAILED(buf[3] != 0x00A0A0A0, "test7 case 5 failed\n"); 505 FAILED(buf[4] != 0x00FF80B0, "test7 case 6 failed\n"); 506 FAILED(buf[5] != 0x00FF4040, "test7 case 7 failed\n"); 507 FAILED(buf[6] != 0xa56c82c0, "test7 case 8 failed\n"); 508 FAILED(buf[7] != 0x3b3a8095, "test7 case 9 failed\n"); 509 510 sljit_free_code(code.code); 511 successful_tests++; 512 } 513 514 static void test8(void) 515 { 516 /* Test flags (neg, cmp, test). */ 517 executable_code code; 518 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 519 sljit_sw buf[13]; 520 521 if (verbose) 522 printf("Run test8\n"); 523 524 FAILED(!compiler, "cannot create compiler\n"); 525 buf[0] = 100; 526 buf[1] = 3; 527 buf[2] = 3; 528 buf[3] = 3; 529 buf[4] = 3; 530 buf[5] = 3; 531 buf[6] = 3; 532 buf[7] = 3; 533 buf[8] = 3; 534 buf[9] = 3; 535 buf[10] = 3; 536 buf[11] = 3; 537 buf[12] = 3; 538 539 sljit_emit_enter(compiler, 0, 1, 3, 2, 0, 0, 0); 540 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 20); 541 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 10); 542 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, SLJIT_IMM, 6, SLJIT_IMM, 5); 543 sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_UNUSED, 0, SLJIT_NOT_EQUAL); 544 sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 2, SLJIT_UNUSED, 0, SLJIT_EQUAL); 545 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, SLJIT_R0, 0, SLJIT_IMM, 3000); 546 sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_UNUSED, 0, SLJIT_GREATER); 547 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 3, SLJIT_S1, 0); 548 sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_UNUSED, 0, SLJIT_LESS); 549 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 4, SLJIT_R2, 0); 550 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_S, SLJIT_UNUSED, 0, SLJIT_R0, 0, SLJIT_IMM, -15); 551 sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_UNUSED, 0, SLJIT_SIG_GREATER); 552 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 5, SLJIT_R2, 0); 553 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_E | SLJIT_SET_O, SLJIT_UNUSED, 0, SLJIT_R0, 0, SLJIT_R1, 0); 554 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_E | SLJIT_SET_O, SLJIT_UNUSED, 0, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0); 555 sljit_emit_op1(compiler, SLJIT_NEG | SLJIT_SET_E | SLJIT_SET_O, SLJIT_UNUSED, 0, SLJIT_IMM, (sljit_sw)1 << ((sizeof(sljit_sw) << 3) - 1)); 556 sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 6, SLJIT_UNUSED, 0, SLJIT_OVERFLOW); 557 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -1); 558 sljit_emit_op1(compiler, SLJIT_NOT | SLJIT_SET_E, SLJIT_R1, 0, SLJIT_R0, 0); 559 sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 7, SLJIT_UNUSED, 0, SLJIT_ZERO); 560 sljit_emit_op1(compiler, SLJIT_NOT | SLJIT_SET_E, SLJIT_UNUSED, 0, SLJIT_R1, 0); 561 sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 8, SLJIT_UNUSED, 0, SLJIT_ZERO); 562 sljit_emit_op2(compiler, SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, SLJIT_IMM, 0xffff, SLJIT_R0, 0); 563 sljit_emit_op2(compiler, SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, SLJIT_R0, 0, SLJIT_IMM, 0xffff); 564 sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 9, SLJIT_UNUSED, 0, SLJIT_NOT_ZERO); 565 sljit_emit_op2(compiler, SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, SLJIT_IMM, 0xffff, SLJIT_R1, 0); 566 sljit_emit_op2(compiler, SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, SLJIT_R1, 0, SLJIT_IMM, 0xffff); 567 sljit_emit_op2(compiler, SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R1, 0); 568 sljit_emit_op2(compiler, SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_S0), 0); 569 sljit_emit_op2(compiler, SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_MEM1(SLJIT_S0), 0); 570 sljit_emit_op2(compiler, SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_IMM, 0x1); 571 sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 10, SLJIT_UNUSED, 0, SLJIT_NOT_ZERO); 572 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(1) << ((sizeof(sljit_sw) << 3) - 1)); 573 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0); 574 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_O, SLJIT_UNUSED, 0, SLJIT_R1, 0, SLJIT_R0, 0); 575 sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 11, SLJIT_UNUSED, 0, SLJIT_OVERFLOW); 576 sljit_emit_op2(compiler, SLJIT_ADD | SLJIT_SET_O, SLJIT_UNUSED, 0, SLJIT_R1, 0, SLJIT_R0, 0); 577 sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 12, SLJIT_UNUSED, 0, SLJIT_OVERFLOW); 578 sljit_emit_return(compiler, SLJIT_UNUSED, 0, 0); 579 580 code.code = sljit_generate_code(compiler); 581 CHECK(compiler); 582 sljit_free_compiler(compiler); 583 584 code.func1((sljit_sw)&buf); 585 FAILED(buf[1] != 1, "test8 case 1 failed\n"); 586 FAILED(buf[2] != 0, "test8 case 2 failed\n"); 587 FAILED(buf[3] != 0, "test8 case 3 failed\n"); 588 FAILED(buf[4] != 1, "test8 case 4 failed\n"); 589 FAILED(buf[5] != 1, "test8 case 5 failed\n"); 590 FAILED(buf[6] != 1, "test8 case 6 failed\n"); 591 FAILED(buf[7] != 1, "test8 case 7 failed\n"); 592 FAILED(buf[8] != 0, "test8 case 8 failed\n"); 593 FAILED(buf[9] != 1, "test8 case 9 failed\n"); 594 FAILED(buf[10] != 0, "test8 case 10 failed\n"); 595 FAILED(buf[11] != 1, "test8 case 11 failed\n"); 596 FAILED(buf[12] != 0, "test8 case 12 failed\n"); 597 598 sljit_free_code(code.code); 599 successful_tests++; 600 } 601 602 static void test9(void) 603 { 604 /* Test shift. */ 605 executable_code code; 606 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 607 sljit_sw buf[13]; 608 609 if (verbose) 610 printf("Run test9\n"); 611 612 FAILED(!compiler, "cannot create compiler\n"); 613 buf[0] = 0; 614 buf[1] = 0; 615 buf[2] = 0; 616 buf[3] = 0; 617 buf[4] = 1 << 10; 618 buf[5] = 0; 619 buf[6] = 0; 620 buf[7] = 0; 621 buf[8] = 0; 622 buf[9] = 3; 623 buf[10] = 0; 624 buf[11] = 0; 625 buf[12] = 0; 626 627 sljit_emit_enter(compiler, 0, 1, 3, 2, 0, 0, 0); 628 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0xf); 629 sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 3); 630 sljit_emit_op2(compiler, SLJIT_LSHR, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 1); 631 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0); 632 sljit_emit_op2(compiler, SLJIT_ASHR, SLJIT_UNUSED, 0, SLJIT_R0, 0, SLJIT_IMM, 2); 633 sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, 1); 634 sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_R1, 0, SLJIT_IMM, 1); 635 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -64); 636 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_PREF_SHIFT_REG, 0, SLJIT_IMM, 2); 637 sljit_emit_op2(compiler, SLJIT_ASHR, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 2, SLJIT_R0, 0, SLJIT_PREF_SHIFT_REG, 0); 638 639 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_PREF_SHIFT_REG, 0, SLJIT_IMM, 0xff); 640 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 4); 641 sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_PREF_SHIFT_REG, 0, SLJIT_PREF_SHIFT_REG, 0, SLJIT_R0, 0); 642 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 3, SLJIT_PREF_SHIFT_REG, 0); 643 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_PREF_SHIFT_REG, 0, SLJIT_IMM, 0xff); 644 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 8); 645 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); 646 sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 5, SLJIT_PREF_SHIFT_REG, 0, SLJIT_R0, 0); 647 648 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_IMM, 0xf); 649 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 2); 650 sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_S1, 0, SLJIT_S1, 0, SLJIT_R0, 0); 651 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 6, SLJIT_S1, 0); 652 sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_R0, 0, SLJIT_S1, 0, SLJIT_R0, 0); 653 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 7, SLJIT_R0, 0); 654 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 0xf00); 655 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 4); 656 sljit_emit_op2(compiler, SLJIT_LSHR, SLJIT_R1, 0, SLJIT_R2, 0, SLJIT_R0, 0); 657 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 8, SLJIT_R1, 0); 658 659 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)buf); 660 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 9); 661 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); 662 663 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_PREF_SHIFT_REG, 0, SLJIT_IMM, 4); 664 sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_PREF_SHIFT_REG, 0, SLJIT_IMM, 2, SLJIT_PREF_SHIFT_REG, 0); 665 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 10, SLJIT_PREF_SHIFT_REG, 0); 666 667 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0xa9); 668 sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, 0); 669 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 0x7d00); 670 sljit_emit_op2(compiler, SLJIT_LSHR32, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 32); 671 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 672 sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_R0, 0, SLJIT_R0, 0); 673 #endif 674 sljit_emit_op2(compiler, SLJIT_OR, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_R0, 0); 675 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0xe30000); 676 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 677 sljit_emit_op2(compiler, SLJIT_ASHR, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 0xffc0); 678 #else 679 sljit_emit_op2(compiler, SLJIT_ASHR, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 0xffe0); 680 #endif 681 sljit_emit_op2(compiler, SLJIT_OR, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_R0, 0); 682 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 0x25000000); 683 sljit_emit_op2(compiler, SLJIT_SHL32, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 0xfffe1); 684 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 685 sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_R0, 0, SLJIT_R0, 0); 686 #endif 687 sljit_emit_op2(compiler, SLJIT_OR, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 11, SLJIT_R1, 0, SLJIT_R0, 0); 688 689 SLJIT_ASSERT(SLJIT_R2 == SLJIT_PREF_SHIFT_REG); 690 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_PREF_SHIFT_REG, 0, SLJIT_IMM, 0); 691 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0x5c); 692 sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_PREF_SHIFT_REG, 0); 693 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 0xf600); 694 sljit_emit_op2(compiler, SLJIT_LSHR32, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_PREF_SHIFT_REG, 0); 695 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 696 /* Alternative form of uint32 type cast. */ 697 sljit_emit_op2(compiler, SLJIT_AND, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 0xffffffff); 698 #endif 699 sljit_emit_op2(compiler, SLJIT_OR, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_R0, 0); 700 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0x630000); 701 sljit_emit_op2(compiler, SLJIT_ASHR, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_PREF_SHIFT_REG, 0); 702 sljit_emit_op2(compiler, SLJIT_OR, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 12, SLJIT_R1, 0, SLJIT_R0, 0); 703 704 sljit_emit_return(compiler, SLJIT_UNUSED, 0, 0); 705 706 code.code = sljit_generate_code(compiler); 707 CHECK(compiler); 708 sljit_free_compiler(compiler); 709 710 code.func1((sljit_sw)&buf); 711 FAILED(buf[0] != 0x3c, "test9 case 1 failed\n"); 712 FAILED(buf[1] != 0xf0, "test9 case 2 failed\n"); 713 FAILED(buf[2] != -16, "test9 case 3 failed\n"); 714 FAILED(buf[3] != 0xff0, "test9 case 4 failed\n"); 715 FAILED(buf[4] != 4, "test9 case 5 failed\n"); 716 FAILED(buf[5] != 0xff00, "test9 case 6 failed\n"); 717 FAILED(buf[6] != 0x3c, "test9 case 7 failed\n"); 718 FAILED(buf[7] != 0xf0, "test9 case 8 failed\n"); 719 FAILED(buf[8] != 0xf0, "test9 case 9 failed\n"); 720 FAILED(buf[9] != 0x18, "test9 case 10 failed\n"); 721 FAILED(buf[10] != 32, "test9 case 11 failed\n"); 722 FAILED(buf[11] != 0x4ae37da9, "test9 case 12 failed\n"); 723 FAILED(buf[12] != 0x63f65c, "test9 case 13 failed\n"); 724 725 sljit_free_code(code.code); 726 successful_tests++; 727 } 728 729 static void test10(void) 730 { 731 /* Test multiplications. */ 732 executable_code code; 733 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 734 sljit_sw buf[7]; 735 736 if (verbose) 737 printf("Run test10\n"); 738 739 FAILED(!compiler, "cannot create compiler\n"); 740 buf[0] = 3; 741 buf[1] = 0; 742 buf[2] = 0; 743 buf[3] = 6; 744 buf[4] = -10; 745 buf[5] = 0; 746 buf[6] = 0; 747 748 sljit_emit_enter(compiler, 0, 1, 3, 1, 0, 0, 0); 749 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 5); 750 sljit_emit_op2(compiler, SLJIT_MUL, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0); 751 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0); 752 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 7); 753 sljit_emit_op2(compiler, SLJIT_MUL, SLJIT_R0, 0, SLJIT_R2, 0, SLJIT_IMM, 8); 754 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_R0, 0); 755 sljit_emit_op2(compiler, SLJIT_MUL, SLJIT_R0, 0, SLJIT_IMM, -3, SLJIT_IMM, -4); 756 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 2, SLJIT_R0, 0); 757 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -2); 758 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); 759 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, sizeof(sljit_sw) / 2); 760 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, (sljit_sw)&buf[3]); 761 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); 762 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 9); 763 sljit_emit_op2(compiler, SLJIT_MUL, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_R0, 0); 764 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 5, SLJIT_R0, 0); 765 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 766 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 3); 767 sljit_emit_op2(compiler, SLJIT_MUL, SLJIT_R0, 0, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(0x123456789)); 768 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 6, SLJIT_R0, 0); 769 #endif 770 sljit_emit_op2(compiler, SLJIT_MUL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 11, SLJIT_IMM, 10); 771 sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0); 772 773 code.code = sljit_generate_code(compiler); 774 CHECK(compiler); 775 sljit_free_compiler(compiler); 776 777 FAILED(code.func1((sljit_sw)&buf) != 110, "test10 case 1 failed\n"); 778 FAILED(buf[0] != 15, "test10 case 2 failed\n"); 779 FAILED(buf[1] != 56, "test10 case 3 failed\n"); 780 FAILED(buf[2] != 12, "test10 case 4 failed\n"); 781 FAILED(buf[3] != -12, "test10 case 5 failed\n"); 782 FAILED(buf[4] != 100, "test10 case 6 failed\n"); 783 FAILED(buf[5] != 81, "test10 case 7 failed\n"); 784 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 785 FAILED(buf[6] != SLJIT_W(0x123456789) * 3, "test10 case 8 failed\n"); 786 #endif 787 788 sljit_free_code(code.code); 789 successful_tests++; 790 } 791 792 static void test11(void) 793 { 794 /* Test rewritable constants. */ 795 executable_code code; 796 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 797 struct sljit_const* const1; 798 struct sljit_const* const2; 799 struct sljit_const* const3; 800 struct sljit_const* const4; 801 void* value; 802 sljit_uw const1_addr; 803 sljit_uw const2_addr; 804 sljit_uw const3_addr; 805 sljit_uw const4_addr; 806 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 807 sljit_sw word_value1 = SLJIT_W(0xaaaaaaaaaaaaaaaa); 808 sljit_sw word_value2 = SLJIT_W(0xfee1deadfbadf00d); 809 #else 810 sljit_sw word_value1 = 0xaaaaaaaal; 811 sljit_sw word_value2 = 0xfbadf00dl; 812 #endif 813 sljit_sw buf[3]; 814 815 if (verbose) 816 printf("Run test11\n"); 817 818 FAILED(!compiler, "cannot create compiler\n"); 819 buf[0] = 0; 820 buf[1] = 0; 821 buf[2] = 0; 822 823 sljit_emit_enter(compiler, 0, 1, 3, 1, 0, 0, 0); 824 825 const1 = sljit_emit_const(compiler, SLJIT_MEM0(), (sljit_sw)&buf[0], -0x81b9); 826 SLJIT_ASSERT(!sljit_alloc_memory(compiler, 0)); 827 SLJIT_ASSERT(!sljit_alloc_memory(compiler, 16 * sizeof(sljit_sw) + 1)); 828 value = sljit_alloc_memory(compiler, 16 * sizeof(sljit_sw)); 829 SLJIT_ASSERT(!((sljit_sw)value & (sizeof(sljit_sw) - 1))); 830 memset(value, 255, 16 * sizeof(sljit_sw)); 831 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 2); 832 const2 = sljit_emit_const(compiler, SLJIT_MEM2(SLJIT_S0, SLJIT_R0), SLJIT_WORD_SHIFT - 1, -65535); 833 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&buf[0] + 2 * sizeof(sljit_sw) - 2); 834 const3 = sljit_emit_const(compiler, SLJIT_MEM1(SLJIT_R0), 0, word_value1); 835 value = sljit_alloc_memory(compiler, 17); 836 SLJIT_ASSERT(!((sljit_sw)value & (sizeof(sljit_sw) - 1))); 837 memset(value, 255, 16); 838 const4 = sljit_emit_const(compiler, SLJIT_RETURN_REG, 0, 0xf7afcdb7); 839 840 sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0); 841 842 code.code = sljit_generate_code(compiler); 843 CHECK(compiler); 844 const1_addr = sljit_get_const_addr(const1); 845 const2_addr = sljit_get_const_addr(const2); 846 const3_addr = sljit_get_const_addr(const3); 847 const4_addr = sljit_get_const_addr(const4); 848 sljit_free_compiler(compiler); 849 850 FAILED(code.func1((sljit_sw)&buf) != 0xf7afcdb7, "test11 case 1 failed\n"); 851 FAILED(buf[0] != -0x81b9, "test11 case 2 failed\n"); 852 FAILED(buf[1] != -65535, "test11 case 3 failed\n"); 853 FAILED(buf[2] != word_value1, "test11 case 4 failed\n"); 854 855 sljit_set_const(const1_addr, -1); 856 sljit_set_const(const2_addr, word_value2); 857 sljit_set_const(const3_addr, 0xbab0fea1); 858 sljit_set_const(const4_addr, -60089); 859 860 FAILED(code.func1((sljit_sw)&buf) != -60089, "test11 case 5 failed\n"); 861 FAILED(buf[0] != -1, "test11 case 6 failed\n"); 862 FAILED(buf[1] != word_value2, "test11 case 7 failed\n"); 863 FAILED(buf[2] != 0xbab0fea1, "test11 case 8 failed\n"); 864 865 sljit_free_code(code.code); 866 successful_tests++; 867 } 868 869 static void test12(void) 870 { 871 /* Test rewriteable jumps. */ 872 executable_code code; 873 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 874 struct sljit_label *label1; 875 struct sljit_label *label2; 876 struct sljit_label *label3; 877 struct sljit_jump *jump1; 878 struct sljit_jump *jump2; 879 struct sljit_jump *jump3; 880 void* value; 881 sljit_uw jump1_addr; 882 sljit_uw label1_addr; 883 sljit_uw label2_addr; 884 sljit_sw buf[1]; 885 886 if (verbose) 887 printf("Run test12\n"); 888 889 FAILED(!compiler, "cannot create compiler\n"); 890 buf[0] = 0; 891 892 sljit_emit_enter(compiler, 0, 2, 3, 2, 0, 0, 0); 893 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_S, SLJIT_UNUSED, 0, SLJIT_S1, 0, SLJIT_IMM, 10); 894 jump1 = sljit_emit_jump(compiler, SLJIT_REWRITABLE_JUMP | SLJIT_SIG_GREATER); 895 /* Default handler. */ 896 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_IMM, 5); 897 jump2 = sljit_emit_jump(compiler, SLJIT_JUMP); 898 value = sljit_alloc_memory(compiler, 15); 899 SLJIT_ASSERT(!((sljit_sw)value & (sizeof(sljit_sw) - 1))); 900 memset(value, 255, 15); 901 /* Handler 1. */ 902 label1 = sljit_emit_label(compiler); 903 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_IMM, 6); 904 jump3 = sljit_emit_jump(compiler, SLJIT_JUMP); 905 /* Handler 2. */ 906 label2 = sljit_emit_label(compiler); 907 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_IMM, 7); 908 /* Exit. */ 909 label3 = sljit_emit_label(compiler); 910 sljit_set_label(jump2, label3); 911 sljit_set_label(jump3, label3); 912 /* By default, set to handler 1. */ 913 sljit_set_label(jump1, label1); 914 sljit_emit_return(compiler, SLJIT_UNUSED, 0, 0); 915 916 value = sljit_alloc_memory(compiler, 8); 917 SLJIT_ASSERT(!((sljit_sw)value & (sizeof(sljit_sw) - 1))); 918 memset(value, 255, 8); 919 920 code.code = sljit_generate_code(compiler); 921 CHECK(compiler); 922 jump1_addr = sljit_get_jump_addr(jump1); 923 label1_addr = sljit_get_label_addr(label1); 924 label2_addr = sljit_get_label_addr(label2); 925 sljit_free_compiler(compiler); 926 927 code.func2((sljit_sw)&buf, 4); 928 FAILED(buf[0] != 5, "test12 case 1 failed\n"); 929 930 code.func2((sljit_sw)&buf, 11); 931 FAILED(buf[0] != 6, "test12 case 2 failed\n"); 932 933 sljit_set_jump_addr(jump1_addr, label2_addr); 934 code.func2((sljit_sw)&buf, 12); 935 FAILED(buf[0] != 7, "test12 case 3 failed\n"); 936 937 sljit_set_jump_addr(jump1_addr, label1_addr); 938 code.func2((sljit_sw)&buf, 13); 939 FAILED(buf[0] != 6, "test12 case 4 failed\n"); 940 941 sljit_free_code(code.code); 942 successful_tests++; 943 } 944 945 static void test13(void) 946 { 947 /* Test fpu monadic functions. */ 948 executable_code code; 949 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 950 sljit_f64 buf[7]; 951 sljit_sw buf2[6]; 952 953 if (verbose) 954 printf("Run test13\n"); 955 956 if (!sljit_is_fpu_available()) { 957 if (verbose) 958 printf("no fpu available, test13 skipped\n"); 959 successful_tests++; 960 if (compiler) 961 sljit_free_compiler(compiler); 962 return; 963 } 964 965 FAILED(!compiler, "cannot create compiler\n"); 966 buf[0] = 7.75; 967 buf[1] = -4.5; 968 buf[2] = 0.0; 969 buf[3] = 0.0; 970 buf[4] = 0.0; 971 buf[5] = 0.0; 972 buf[6] = 0.0; 973 974 buf2[0] = 10; 975 buf2[1] = 10; 976 buf2[2] = 10; 977 buf2[3] = 10; 978 buf2[4] = 10; 979 buf2[5] = 10; 980 981 sljit_emit_enter(compiler, 0, 2, 3, 2, 6, 0, 0); 982 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM0(), (sljit_sw)&buf[2], SLJIT_MEM0(), (sljit_sw)&buf[1]); 983 sljit_emit_fop1(compiler, SLJIT_ABS_F64, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_f64), SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64)); 984 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR0, 0, SLJIT_MEM0(), (sljit_sw)&buf[0]); 985 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 2 * sizeof(sljit_f64)); 986 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR1, 0, SLJIT_MEM2(SLJIT_S0, SLJIT_R0), 0); 987 sljit_emit_fop1(compiler, SLJIT_NEG_F64, SLJIT_FR2, 0, SLJIT_FR0, 0); 988 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR3, 0, SLJIT_FR2, 0); 989 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM0(), (sljit_sw)&buf[4], SLJIT_FR3, 0); 990 sljit_emit_fop1(compiler, SLJIT_ABS_F64, SLJIT_FR4, 0, SLJIT_FR1, 0); 991 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_f64), SLJIT_FR4, 0); 992 sljit_emit_fop1(compiler, SLJIT_NEG_F64, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_f64), SLJIT_FR4, 0); 993 994 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR5, 0, SLJIT_MEM1(SLJIT_S0), 0); 995 sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_S, SLJIT_FR5, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64)); 996 sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S1), 0, SLJIT_UNUSED, 0, SLJIT_GREATER_F64); 997 sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_S, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64), SLJIT_FR5, 0); 998 sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_sw), SLJIT_UNUSED, 0, SLJIT_GREATER_F64); 999 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR1, 0, SLJIT_FR5, 0); 1000 sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_E | SLJIT_SET_S, SLJIT_FR1, 0, SLJIT_FR1, 0); 1001 sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S1), 2 * sizeof(sljit_sw), SLJIT_UNUSED, 0, SLJIT_EQUAL_F64); 1002 sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S1), 3 * sizeof(sljit_sw), SLJIT_UNUSED, 0, SLJIT_LESS_F64); 1003 sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_E, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64)); 1004 sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S1), 4 * sizeof(sljit_sw), SLJIT_UNUSED, 0, SLJIT_EQUAL_F64); 1005 sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S1), 5 * sizeof(sljit_sw), SLJIT_UNUSED, 0, SLJIT_NOT_EQUAL_F64); 1006 1007 sljit_emit_return(compiler, SLJIT_UNUSED, 0, 0); 1008 1009 code.code = sljit_generate_code(compiler); 1010 CHECK(compiler); 1011 sljit_free_compiler(compiler); 1012 1013 code.func2((sljit_sw)&buf, (sljit_sw)&buf2); 1014 FAILED(buf[2] != -4.5, "test13 case 1 failed\n"); 1015 FAILED(buf[3] != 4.5, "test13 case 2 failed\n"); 1016 FAILED(buf[4] != -7.75, "test13 case 3 failed\n"); 1017 FAILED(buf[5] != 4.5, "test13 case 4 failed\n"); 1018 FAILED(buf[6] != -4.5, "test13 case 5 failed\n"); 1019 1020 FAILED(buf2[0] != 1, "test13 case 6 failed\n"); 1021 FAILED(buf2[1] != 0, "test13 case 7 failed\n"); 1022 FAILED(buf2[2] != 1, "test13 case 8 failed\n"); 1023 FAILED(buf2[3] != 0, "test13 case 9 failed\n"); 1024 FAILED(buf2[4] != 0, "test13 case 10 failed\n"); 1025 FAILED(buf2[5] != 1, "test13 case 11 failed\n"); 1026 1027 sljit_free_code(code.code); 1028 successful_tests++; 1029 } 1030 1031 static void test14(void) 1032 { 1033 /* Test fpu diadic functions. */ 1034 executable_code code; 1035 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 1036 sljit_f64 buf[15]; 1037 1038 if (verbose) 1039 printf("Run test14\n"); 1040 1041 if (!sljit_is_fpu_available()) { 1042 if (verbose) 1043 printf("no fpu available, test14 skipped\n"); 1044 successful_tests++; 1045 if (compiler) 1046 sljit_free_compiler(compiler); 1047 return; 1048 } 1049 buf[0] = 7.25; 1050 buf[1] = 3.5; 1051 buf[2] = 1.75; 1052 buf[3] = 0.0; 1053 buf[4] = 0.0; 1054 buf[5] = 0.0; 1055 buf[6] = 0.0; 1056 buf[7] = 0.0; 1057 buf[8] = 0.0; 1058 buf[9] = 0.0; 1059 buf[10] = 0.0; 1060 buf[11] = 0.0; 1061 buf[12] = 8.0; 1062 buf[13] = 4.0; 1063 buf[14] = 0.0; 1064 1065 FAILED(!compiler, "cannot create compiler\n"); 1066 sljit_emit_enter(compiler, 0, 1, 3, 1, 6, 0, 0); 1067 1068 /* ADD */ 1069 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, sizeof(sljit_f64)); 1070 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64)); 1071 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 2); 1072 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); 1073 sljit_emit_fop2(compiler, SLJIT_ADD_F64, SLJIT_FR0, 0, SLJIT_FR0, 0, SLJIT_FR1, 0); 1074 sljit_emit_fop2(compiler, SLJIT_ADD_F64, SLJIT_FR1, 0, SLJIT_FR0, 0, SLJIT_FR1, 0); 1075 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 4, SLJIT_FR0, 0); 1076 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 5, SLJIT_FR1, 0); 1077 1078 /* SUB */ 1079 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S0), 0); 1080 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR3, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 2); 1081 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 2); 1082 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); 1083 sljit_emit_fop2(compiler, SLJIT_SUB_F64, SLJIT_FR2, 0, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 2); 1084 sljit_emit_fop2(compiler, SLJIT_SUB_F64, SLJIT_FR3, 0, SLJIT_FR2, 0, SLJIT_FR3, 0); 1085 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 7, SLJIT_FR2, 0); 1086 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 8, SLJIT_FR3, 0); 1087 1088 /* MUL */ 1089 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 1); 1090 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); 1091 sljit_emit_fop2(compiler, SLJIT_MUL_F64, SLJIT_FR1, 0, SLJIT_FR1, 0, SLJIT_FR2, 0); 1092 sljit_emit_fop2(compiler, SLJIT_MUL_F64, SLJIT_FR5, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 2, SLJIT_FR2, 0); 1093 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 10, SLJIT_FR1, 0); 1094 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 11, SLJIT_FR5, 0); 1095 1096 /* DIV */ 1097 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR5, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 12); 1098 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 13); 1099 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR4, 0, SLJIT_FR5, 0); 1100 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); 1101 sljit_emit_fop2(compiler, SLJIT_DIV_F64, SLJIT_FR5, 0, SLJIT_FR5, 0, SLJIT_FR1, 0); 1102 sljit_emit_fop2(compiler, SLJIT_DIV_F64, SLJIT_FR4, 0, SLJIT_FR1, 0, SLJIT_FR4, 0); 1103 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 13, SLJIT_FR5, 0); 1104 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64) * 14, SLJIT_FR4, 0); 1105 1106 sljit_emit_return(compiler, SLJIT_UNUSED, 0, 0); 1107 1108 code.code = sljit_generate_code(compiler); 1109 CHECK(compiler); 1110 sljit_free_compiler(compiler); 1111 1112 code.func1((sljit_sw)&buf); 1113 FAILED(buf[3] != 10.75, "test14 case 1 failed\n"); 1114 FAILED(buf[4] != 5.25, "test14 case 2 failed\n"); 1115 FAILED(buf[5] != 7.0, "test14 case 3 failed\n"); 1116 FAILED(buf[6] != 0.0, "test14 case 4 failed\n"); 1117 FAILED(buf[7] != 5.5, "test14 case 5 failed\n"); 1118 FAILED(buf[8] != 3.75, "test14 case 6 failed\n"); 1119 FAILED(buf[9] != 24.5, "test14 case 7 failed\n"); 1120 FAILED(buf[10] != 38.5, "test14 case 8 failed\n"); 1121 FAILED(buf[11] != 9.625, "test14 case 9 failed\n"); 1122 FAILED(buf[12] != 2.0, "test14 case 10 failed\n"); 1123 FAILED(buf[13] != 2.0, "test14 case 11 failed\n"); 1124 FAILED(buf[14] != 0.5, "test14 case 12 failed\n"); 1125 1126 sljit_free_code(code.code); 1127 successful_tests++; 1128 } 1129 1130 static sljit_sw SLJIT_CALL func(sljit_sw a, sljit_sw b, sljit_sw c) 1131 { 1132 return a + b + c + 5; 1133 } 1134 1135 static void test15(void) 1136 { 1137 /* Test function call. */ 1138 executable_code code; 1139 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 1140 struct sljit_jump* jump; 1141 sljit_sw buf[7]; 1142 1143 if (verbose) 1144 printf("Run test15\n"); 1145 1146 FAILED(!compiler, "cannot create compiler\n"); 1147 buf[0] = 0; 1148 buf[1] = 0; 1149 buf[2] = 0; 1150 buf[3] = 0; 1151 buf[4] = 0; 1152 buf[5] = 0; 1153 buf[6] = SLJIT_FUNC_OFFSET(func); 1154 1155 sljit_emit_enter(compiler, 0, 1, 4, 1, 0, 0, 0); 1156 1157 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 5); 1158 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 7); 1159 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, -3); 1160 sljit_emit_ijump(compiler, SLJIT_CALL3, SLJIT_IMM, SLJIT_FUNC_OFFSET(func)); 1161 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_RETURN_REG, 0); 1162 1163 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -5); 1164 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, -10); 1165 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 2); 1166 jump = sljit_emit_jump(compiler, SLJIT_CALL3 | SLJIT_REWRITABLE_JUMP); 1167 sljit_set_target(jump, (sljit_sw)-1); 1168 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_RETURN_REG, 0); 1169 1170 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_FUNC_OFFSET(func)); 1171 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 40); 1172 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, -3); 1173 sljit_emit_ijump(compiler, SLJIT_CALL3, SLJIT_R0, 0); 1174 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_RETURN_REG, 0); 1175 1176 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -60); 1177 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, SLJIT_FUNC_OFFSET(func)); 1178 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, -30); 1179 sljit_emit_ijump(compiler, SLJIT_CALL3, SLJIT_R1, 0); 1180 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_RETURN_REG, 0); 1181 1182 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 10); 1183 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 16); 1184 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, SLJIT_FUNC_OFFSET(func)); 1185 sljit_emit_ijump(compiler, SLJIT_CALL3, SLJIT_R2, 0); 1186 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_RETURN_REG, 0); 1187 1188 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 100); 1189 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 110); 1190 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 120); 1191 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, SLJIT_FUNC_OFFSET(func)); 1192 sljit_emit_ijump(compiler, SLJIT_CALL3, SLJIT_R3, 0); 1193 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_RETURN_REG, 0); 1194 1195 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -10); 1196 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, -16); 1197 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 6); 1198 sljit_emit_ijump(compiler, SLJIT_CALL3, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_sw)); 1199 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_sw), SLJIT_RETURN_REG, 0); 1200 1201 sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0); 1202 1203 code.code = sljit_generate_code(compiler); 1204 CHECK(compiler); 1205 sljit_set_jump_addr(sljit_get_jump_addr(jump), SLJIT_FUNC_OFFSET(func)); 1206 sljit_free_compiler(compiler); 1207 1208 FAILED(code.func1((sljit_sw)&buf) != -15, "test15 case 1 failed\n"); 1209 FAILED(buf[0] != 14, "test15 case 2 failed\n"); 1210 FAILED(buf[1] != -8, "test15 case 3 failed\n"); 1211 FAILED(buf[2] != SLJIT_FUNC_OFFSET(func) + 42, "test15 case 4 failed\n"); 1212 FAILED(buf[3] != SLJIT_FUNC_OFFSET(func) - 85, "test15 case 5 failed\n"); 1213 FAILED(buf[4] != SLJIT_FUNC_OFFSET(func) + 31, "test15 case 6 failed\n"); 1214 FAILED(buf[5] != 335, "test15 case 7 failed\n"); 1215 FAILED(buf[6] != -15, "test15 case 8 failed\n"); 1216 1217 sljit_free_code(code.code); 1218 successful_tests++; 1219 } 1220 1221 static void test16(void) 1222 { 1223 /* Ackermann benchmark. */ 1224 executable_code code; 1225 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 1226 struct sljit_label *entry; 1227 struct sljit_label *label; 1228 struct sljit_jump *jump; 1229 struct sljit_jump *jump1; 1230 struct sljit_jump *jump2; 1231 1232 if (verbose) 1233 printf("Run test16\n"); 1234 1235 FAILED(!compiler, "cannot create compiler\n"); 1236 1237 entry = sljit_emit_label(compiler); 1238 sljit_emit_enter(compiler, 0, 2, 3, 2, 0, 0, 0); 1239 /* If x == 0. */ 1240 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, SLJIT_S0, 0, SLJIT_IMM, 0); 1241 jump1 = sljit_emit_jump(compiler, SLJIT_EQUAL); 1242 /* If y == 0. */ 1243 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, SLJIT_S1, 0, SLJIT_IMM, 0); 1244 jump2 = sljit_emit_jump(compiler, SLJIT_EQUAL); 1245 1246 /* Ack(x,y-1). */ 1247 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_S0, 0); 1248 sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R1, 0, SLJIT_S1, 0, SLJIT_IMM, 1); 1249 jump = sljit_emit_jump(compiler, SLJIT_CALL2); 1250 sljit_set_label(jump, entry); 1251 1252 /* Returns with Ack(x-1, Ack(x,y-1)). */ 1253 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_RETURN_REG, 0); 1254 sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R0, 0, SLJIT_S0, 0, SLJIT_IMM, 1); 1255 jump = sljit_emit_jump(compiler, SLJIT_CALL2); 1256 sljit_set_label(jump, entry); 1257 sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0); 1258 1259 /* Returns with y+1. */ 1260 label = sljit_emit_label(compiler); 1261 sljit_set_label(jump1, label); 1262 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_RETURN_REG, 0, SLJIT_IMM, 1, SLJIT_S1, 0); 1263 sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0); 1264 1265 /* Returns with Ack(x-1,1) */ 1266 label = sljit_emit_label(compiler); 1267 sljit_set_label(jump2, label); 1268 sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R0, 0, SLJIT_S0, 0, SLJIT_IMM, 1); 1269 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 1); 1270 jump = sljit_emit_jump(compiler, SLJIT_CALL2); 1271 sljit_set_label(jump, entry); 1272 sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0); 1273 1274 code.code = sljit_generate_code(compiler); 1275 CHECK(compiler); 1276 sljit_free_compiler(compiler); 1277 1278 FAILED(code.func2(3, 3) != 61, "test16 case 1 failed\n"); 1279 /* For benchmarking. */ 1280 /* FAILED(code.func2(3, 11) != 16381, "test16 case 1 failed\n"); */ 1281 1282 sljit_free_code(code.code); 1283 successful_tests++; 1284 } 1285 1286 static void test17(void) 1287 { 1288 /* Test arm constant pool. */ 1289 executable_code code; 1290 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 1291 sljit_s32 i; 1292 sljit_sw buf[5]; 1293 1294 if (verbose) 1295 printf("Run test17\n"); 1296 1297 FAILED(!compiler, "cannot create compiler\n"); 1298 buf[0] = 0; 1299 buf[1] = 0; 1300 buf[2] = 0; 1301 buf[3] = 0; 1302 buf[4] = 0; 1303 1304 sljit_emit_enter(compiler, 0, 1, 3, 1, 0, 0, 0); 1305 for (i = 0; i <= 0xfff; i++) { 1306 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0x81818000 | i); 1307 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0x81818000 | i); 1308 if ((i & 0x3ff) == 0) 1309 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), (i >> 10) * sizeof(sljit_sw), SLJIT_R0, 0); 1310 } 1311 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_R0, 0); 1312 sljit_emit_return(compiler, SLJIT_UNUSED, 0, 0); 1313 1314 code.code = sljit_generate_code(compiler); 1315 CHECK(compiler); 1316 sljit_free_compiler(compiler); 1317 1318 code.func1((sljit_sw)&buf); 1319 FAILED((sljit_uw)buf[0] != 0x81818000, "test17 case 1 failed\n"); 1320 FAILED((sljit_uw)buf[1] != 0x81818400, "test17 case 2 failed\n"); 1321 FAILED((sljit_uw)buf[2] != 0x81818800, "test17 case 3 failed\n"); 1322 FAILED((sljit_uw)buf[3] != 0x81818c00, "test17 case 4 failed\n"); 1323 FAILED((sljit_uw)buf[4] != 0x81818fff, "test17 case 5 failed\n"); 1324 1325 sljit_free_code(code.code); 1326 successful_tests++; 1327 } 1328 1329 static void test18(void) 1330 { 1331 /* Test 64 bit. */ 1332 executable_code code; 1333 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 1334 sljit_sw buf[11]; 1335 1336 if (verbose) 1337 printf("Run test18\n"); 1338 1339 FAILED(!compiler, "cannot create compiler\n"); 1340 buf[0] = 0; 1341 buf[1] = 0; 1342 buf[2] = 0; 1343 buf[3] = 0; 1344 buf[4] = 0; 1345 buf[5] = 100; 1346 buf[6] = 100; 1347 buf[7] = 100; 1348 buf[8] = 100; 1349 buf[9] = 0; 1350 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) && (defined SLJIT_BIG_ENDIAN && SLJIT_BIG_ENDIAN) 1351 buf[10] = SLJIT_W(1) << 32; 1352 #else 1353 buf[10] = 1; 1354 #endif 1355 1356 sljit_emit_enter(compiler, 0, 1, 3, 2, 0, 0, 0); 1357 1358 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 1359 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_IMM, SLJIT_W(0x1122334455667788)); 1360 sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_IMM, SLJIT_W(0x1122334455667788)); 1361 1362 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(1000000000000)); 1363 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 2, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(1000000000000)); 1364 sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 3, SLJIT_IMM, SLJIT_W(5000000000000), SLJIT_R0, 0); 1365 1366 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(0x1108080808)); 1367 sljit_emit_op2(compiler, SLJIT_ADD32, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 4, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(0x1120202020)); 1368 1369 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0x1108080808)); 1370 sljit_emit_op2(compiler, SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0x1120202020)); 1371 sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_UNUSED, 0, SLJIT_ZERO); 1372 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 5, SLJIT_S1, 0); 1373 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_R0, 0); 1374 sljit_emit_op2(compiler, SLJIT_AND32 | SLJIT_SET_E, SLJIT_UNUSED, 0, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0x1120202020)); 1375 sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 6, SLJIT_UNUSED, 0, SLJIT_ZERO32); 1376 1377 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0x1108080808)); 1378 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0x2208080808)); 1379 sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 7, SLJIT_UNUSED, 0, SLJIT_LESS); 1380 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_R0, 0); 1381 sljit_emit_op2(compiler, SLJIT_AND32 | SLJIT_SET_E, SLJIT_UNUSED, 0, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0x1104040404)); 1382 sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 8, SLJIT_UNUSED, 0, SLJIT_NOT_ZERO32); 1383 1384 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 4); 1385 sljit_emit_op2(compiler, SLJIT_SHL32, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 9, SLJIT_IMM, SLJIT_W(0xffff0000), SLJIT_R0, 0); 1386 1387 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); 1388 #else 1389 /* 32 bit operations. */ 1390 1391 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_IMM, 0x11223344); 1392 sljit_emit_op2(compiler, SLJIT_ADD32, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_IMM, 0x44332211); 1393 1394 #endif 1395 1396 sljit_emit_return(compiler, SLJIT_UNUSED, 0, 0); 1397 1398 code.code = sljit_generate_code(compiler); 1399 CHECK(compiler); 1400 sljit_free_compiler(compiler); 1401 1402 code.func1((sljit_sw)&buf); 1403 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 1404 FAILED(buf[0] != SLJIT_W(0x1122334455667788), "test18 case 1 failed\n"); 1405 #if (defined SLJIT_LITTLE_ENDIAN && SLJIT_LITTLE_ENDIAN) 1406 FAILED(buf[1] != 0x55667788, "test18 case 2 failed\n"); 1407 #else 1408 FAILED(buf[1] != SLJIT_W(0x5566778800000000), "test18 case 2 failed\n"); 1409 #endif 1410 FAILED(buf[2] != SLJIT_W(2000000000000), "test18 case 3 failed\n"); 1411 FAILED(buf[3] != SLJIT_W(4000000000000), "test18 case 4 failed\n"); 1412 #if (defined SLJIT_LITTLE_ENDIAN && SLJIT_LITTLE_ENDIAN) 1413 FAILED(buf[4] != 0x28282828, "test18 case 5 failed\n"); 1414 #else 1415 FAILED(buf[4] != SLJIT_W(0x2828282800000000), "test18 case 5 failed\n"); 1416 #endif 1417 FAILED(buf[5] != 0, "test18 case 6 failed\n"); 1418 FAILED(buf[6] != 1, "test18 case 7 failed\n"); 1419 FAILED(buf[7] != 1, "test18 case 8 failed\n"); 1420 FAILED(buf[8] != 0, "test18 case 9 failed\n"); 1421 #if (defined SLJIT_LITTLE_ENDIAN && SLJIT_LITTLE_ENDIAN) 1422 FAILED(buf[9] != 0xfff00000, "test18 case 10 failed\n"); 1423 FAILED(buf[10] != 0xffffffff, "test18 case 11 failed\n"); 1424 #else 1425 FAILED(buf[9] != SLJIT_W(0xfff0000000000000), "test18 case 10 failed\n"); 1426 FAILED(buf[10] != SLJIT_W(0xffffffff00000000), "test18 case 11 failed\n"); 1427 #endif 1428 #else 1429 FAILED(buf[0] != 0x11223344, "test18 case 1 failed\n"); 1430 FAILED(buf[1] != 0x44332211, "test18 case 2 failed\n"); 1431 #endif 1432 1433 sljit_free_code(code.code); 1434 successful_tests++; 1435 } 1436 1437 static void test19(void) 1438 { 1439 /* Test arm partial instruction caching. */ 1440 executable_code code; 1441 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 1442 sljit_sw buf[10]; 1443 1444 if (verbose) 1445 printf("Run test19\n"); 1446 1447 FAILED(!compiler, "cannot create compiler\n"); 1448 buf[0] = 6; 1449 buf[1] = 4; 1450 buf[2] = 0; 1451 buf[3] = 0; 1452 buf[4] = 0; 1453 buf[5] = 0; 1454 buf[6] = 2; 1455 buf[7] = 0; 1456 1457 sljit_emit_enter(compiler, 0, 1, 3, 1, 0, 0, 0); 1458 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw)); 1459 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM0(), (sljit_sw)&buf[2], SLJIT_MEM0(), (sljit_sw)&buf[1], SLJIT_MEM0(), (sljit_sw)&buf[0]); 1460 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0); 1461 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, sizeof(sljit_sw)); 1462 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]); 1463 sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 4, SLJIT_MEM0(), (sljit_sw)&buf[0], SLJIT_IMM, 2); 1464 sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 5, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 2, SLJIT_MEM1(SLJIT_R0), (sljit_sw)&buf[0] + 4 * sizeof(sljit_sw)); 1465 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 7, SLJIT_IMM, 10); 1466 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 7); 1467 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]); 1468 1469 sljit_emit_return(compiler, SLJIT_UNUSED, 0, 0); 1470 1471 code.code = sljit_generate_code(compiler); 1472 CHECK(compiler); 1473 sljit_free_compiler(compiler); 1474 1475 code.func1((sljit_sw)&buf); 1476 FAILED(buf[0] != 10, "test19 case 1 failed\n"); 1477 FAILED(buf[1] != 4, "test19 case 2 failed\n"); 1478 FAILED(buf[2] != 14, "test19 case 3 failed\n"); 1479 FAILED(buf[3] != 14, "test19 case 4 failed\n"); 1480 FAILED(buf[4] != 8, "test19 case 5 failed\n"); 1481 FAILED(buf[5] != 6, "test19 case 6 failed\n"); 1482 FAILED(buf[6] != 12, "test19 case 7 failed\n"); 1483 FAILED(buf[7] != 10, "test19 case 8 failed\n"); 1484 1485 sljit_free_code(code.code); 1486 successful_tests++; 1487 } 1488 1489 static void test20(void) 1490 { 1491 /* Test stack. */ 1492 executable_code code; 1493 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 1494 struct sljit_jump* jump; 1495 struct sljit_label* label; 1496 sljit_sw buf[6]; 1497 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 1498 sljit_sw offset_value = SLJIT_W(0x1234567812345678); 1499 #else 1500 sljit_sw offset_value = SLJIT_W(0x12345678); 1501 #endif 1502 1503 if (verbose) 1504 printf("Run test20\n"); 1505 1506 FAILED(!compiler, "cannot create compiler\n"); 1507 buf[0] = 5; 1508 buf[1] = 12; 1509 buf[2] = 0; 1510 buf[3] = 0; 1511 buf[4] = 111; 1512 buf[5] = -12345; 1513 1514 sljit_emit_enter(compiler, 0, 1, 5, 5, 0, 0, 4 * sizeof(sljit_sw)); 1515 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), sizeof(sljit_uw), SLJIT_MEM1(SLJIT_S0), 0); 1516 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_uw)); 1517 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, -1); 1518 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R4, 0, SLJIT_IMM, -1); 1519 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S3, 0, SLJIT_IMM, -1); 1520 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S4, 0, SLJIT_IMM, -1); 1521 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)); 1522 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); 1523 sljit_get_local_base(compiler, SLJIT_R0, 0, -offset_value); 1524 sljit_get_local_base(compiler, SLJIT_MEM1(SLJIT_S0), 0, -0x1234); 1525 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_S0), 0); 1526 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)); 1527 sljit_emit_return(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_uw)); 1528 /* Dummy last instructions. */ 1529 sljit_emit_const(compiler, SLJIT_R0, 0, -9); 1530 sljit_emit_label(compiler); 1531 1532 code.code = sljit_generate_code(compiler); 1533 CHECK(compiler); 1534 sljit_free_compiler(compiler); 1535 1536 FAILED(code.func1((sljit_sw)&buf) != -12345, "test20 case 1 failed\n") 1537 1538 FAILED(buf[2] != 60, "test20 case 2 failed\n"); 1539 FAILED(buf[3] != 17, "test20 case 3 failed\n"); 1540 FAILED(buf[4] != 7, "test20 case 4 failed\n"); 1541 1542 sljit_free_code(code.code); 1543 1544 compiler = sljit_create_compiler(NULL); 1545 sljit_emit_enter(compiler, 0, 0, 3, 0, 0, 0, SLJIT_MAX_LOCAL_SIZE); 1546 1547 sljit_get_local_base(compiler, SLJIT_R0, 0, SLJIT_MAX_LOCAL_SIZE - sizeof(sljit_sw)); 1548 sljit_get_local_base(compiler, SLJIT_R1, 0, -(sljit_sw)sizeof(sljit_sw)); 1549 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, -1); 1550 label = sljit_emit_label(compiler); 1551 sljit_emit_op1(compiler, SLJIT_MOVU, SLJIT_MEM1(SLJIT_R1), sizeof(sljit_sw), SLJIT_R2, 0); 1552 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, SLJIT_R1, 0, SLJIT_R0, 0); 1553 jump = sljit_emit_jump(compiler, SLJIT_NOT_EQUAL); 1554 sljit_set_label(jump, label); 1555 1556 sljit_emit_return(compiler, SLJIT_UNUSED, 0, 0); 1557 1558 code.code = sljit_generate_code(compiler); 1559 CHECK(compiler); 1560 sljit_free_compiler(compiler); 1561 1562 /* Just survive this code. */ 1563 code.func0(); 1564 1565 sljit_free_code(code.code); 1566 successful_tests++; 1567 } 1568 1569 static void test21(void) 1570 { 1571 /* Test fake enter. The parts of the jit code can be separated in the memory. */ 1572 executable_code code1; 1573 executable_code code2; 1574 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 1575 struct sljit_jump* jump; 1576 sljit_uw addr; 1577 sljit_sw buf[4]; 1578 1579 if (verbose) 1580 printf("Run test21\n"); 1581 1582 FAILED(!compiler, "cannot create compiler\n"); 1583 buf[0] = 9; 1584 buf[1] = -6; 1585 buf[2] = 0; 1586 buf[3] = 0; 1587 1588 sljit_emit_enter(compiler, 0, 1, 3, 2, 0, 0, 2 * sizeof(sljit_sw)); 1589 1590 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), 0, SLJIT_IMM, 10); 1591 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM1(SLJIT_SP), sizeof(sljit_sw), SLJIT_MEM1(SLJIT_S0), 0, SLJIT_MEM1(SLJIT_SP), 0); 1592 jump = sljit_emit_jump(compiler, SLJIT_JUMP | SLJIT_REWRITABLE_JUMP); 1593 sljit_set_target(jump, 0); 1594 1595 code1.code = sljit_generate_code(compiler); 1596 CHECK(compiler); 1597 addr = sljit_get_jump_addr(jump); 1598 sljit_free_compiler(compiler); 1599 1600 compiler = sljit_create_compiler(NULL); 1601 FAILED(!compiler, "cannot create compiler\n"); 1602 1603 /* Other part of the jit code. */ 1604 sljit_set_context(compiler, 0, 1, 3, 2, 0, 0, 2 * sizeof(sljit_sw)); 1605 1606 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); 1607 sljit_emit_op2(compiler, SLJIT_MUL, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 3, SLJIT_MEM1(SLJIT_SP), 0, SLJIT_MEM1(SLJIT_SP), 0); 1608 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_MEM1(SLJIT_SP), sizeof(sljit_sw)); 1609 1610 sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0); 1611 1612 code2.code = sljit_generate_code(compiler); 1613 CHECK(compiler); 1614 sljit_free_compiler(compiler); 1615 1616 sljit_set_jump_addr(addr, SLJIT_FUNC_OFFSET(code2.code)); 1617 1618 FAILED(code1.func1((sljit_sw)&buf) != 19, "test21 case 1 failed\n"); 1619 FAILED(buf[2] != -16, "test21 case 2 failed\n"); 1620 FAILED(buf[3] != 100, "test21 case 3 failed\n"); 1621 1622 sljit_free_code(code1.code); 1623 sljit_free_code(code2.code); 1624 successful_tests++; 1625 } 1626 1627 static void test22(void) 1628 { 1629 /* Test simple byte and half-int data transfers. */ 1630 executable_code code; 1631 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 1632 sljit_sw buf[9]; 1633 sljit_s16 sbuf[7]; 1634 sljit_s8 bbuf[5]; 1635 1636 if (verbose) 1637 printf("Run test22\n"); 1638 1639 FAILED(!compiler, "cannot create compiler\n"); 1640 buf[0] = 5; 1641 buf[1] = 0; 1642 buf[2] = 0; 1643 buf[3] = 0; 1644 buf[4] = 0; 1645 buf[5] = 0; 1646 buf[6] = 0; 1647 buf[7] = 0; 1648 buf[8] = 0; 1649 1650 sbuf[0] = 0; 1651 sbuf[1] = 0; 1652 sbuf[2] = -9; 1653 sbuf[3] = 0; 1654 sbuf[4] = 0; 1655 sbuf[5] = 0; 1656 sbuf[6] = 0; 1657 1658 bbuf[0] = 0; 1659 bbuf[1] = 0; 1660 bbuf[2] = -56; 1661 bbuf[3] = 0; 1662 bbuf[4] = 0; 1663 1664 sljit_emit_enter(compiler, 0, 3, 3, 3, 0, 0, 0); 1665 1666 sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R0, 0, SLJIT_S0, 0, SLJIT_IMM, sizeof(sljit_sw)); 1667 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_S0, 0); 1668 sljit_emit_op1(compiler, SLJIT_MOVU, SLJIT_MEM1(SLJIT_R1), sizeof(sljit_sw), SLJIT_IMM, -13); 1669 sljit_emit_op1(compiler, SLJIT_MOVU, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_sw)); 1670 sljit_emit_op1(compiler, SLJIT_MOVU, SLJIT_MEM1(SLJIT_R1), sizeof(sljit_sw), SLJIT_R2, 0); 1671 sljit_emit_op1(compiler, SLJIT_MOVU, SLJIT_MEM1(SLJIT_R1), sizeof(sljit_sw), SLJIT_MEM1(SLJIT_R0), sizeof(sljit_sw)); 1672 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 1); 1673 sljit_emit_op1(compiler, SLJIT_MOVU, SLJIT_MEM2(SLJIT_R1, SLJIT_R0), SLJIT_WORD_SHIFT, SLJIT_R1, 0); 1674 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, sizeof(sljit_sw)); 1675 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM2(SLJIT_R1, SLJIT_R0), 0, SLJIT_R1, 0); 1676 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 2); 1677 sljit_emit_op1(compiler, SLJIT_MOVU, SLJIT_MEM2(SLJIT_R1, SLJIT_R0), SLJIT_WORD_SHIFT, SLJIT_R1, 0); 1678 1679 sljit_emit_op1(compiler, SLJIT_MOV_S16, SLJIT_MEM1(SLJIT_S1), 0, SLJIT_IMM, -13); 1680 sljit_emit_op1(compiler, SLJIT_MOVU_U16, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_s16), SLJIT_IMM, 0x1234); 1681 sljit_emit_op1(compiler, SLJIT_MOVU_S16, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_s16)); 1682 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_sw), SLJIT_R0, 0); 1683 sljit_emit_op1(compiler, SLJIT_MOV_U16, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_s16), SLJIT_MEM1(SLJIT_S1), -(sljit_sw)sizeof(sljit_s16)); 1684 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0xff0000 + 8000); 1685 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 2); 1686 sljit_emit_op1(compiler, SLJIT_MOV_S16, SLJIT_MEM2(SLJIT_S1, SLJIT_R1), 1, SLJIT_R0, 0); 1687 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 3); 1688 sljit_emit_op1(compiler, SLJIT_MOVU_S16, SLJIT_MEM2(SLJIT_S1, SLJIT_R1), 1, SLJIT_R0, 0); 1689 sljit_emit_op1(compiler, SLJIT_MOV_S16, SLJIT_MEM1(SLJIT_S1), 0, SLJIT_IMM, -9317); 1690 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_S1, 0, SLJIT_IMM, 5 * sizeof(sljit_s16)); 1691 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -5); 1692 sljit_emit_op1(compiler, SLJIT_MOV_U16, SLJIT_R1, 0, SLJIT_MEM2(SLJIT_R1, SLJIT_R0), 1); 1693 sljit_emit_op1(compiler, SLJIT_MOV_U16, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_s16), SLJIT_R1, 0); 1694 1695 sljit_emit_op1(compiler, SLJIT_MOV_S8, SLJIT_MEM1(SLJIT_S2), 0, SLJIT_IMM, -45); 1696 sljit_emit_op1(compiler, SLJIT_MOVU_U8, SLJIT_MEM1(SLJIT_S2), sizeof(sljit_s8), SLJIT_IMM, 0x12); 1697 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 2 * sizeof(sljit_s8)); 1698 sljit_emit_op1(compiler, SLJIT_MOVU_S8, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_S2), sizeof(sljit_s8)); 1699 sljit_emit_op1(compiler, SLJIT_MOV_S8, SLJIT_S1, 0, SLJIT_R1, 0); 1700 sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_S1, 0, SLJIT_S1, 0); 1701 sljit_emit_op1(compiler, SLJIT_MOV_S8, SLJIT_R2, 0, SLJIT_S1, 0); 1702 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_sw), SLJIT_R2, 0); 1703 sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_MEM1(SLJIT_S2), sizeof(sljit_s8), SLJIT_S1, 0); 1704 sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_MEM2(SLJIT_S2, SLJIT_R0), 0, SLJIT_R0, 0); 1705 1706 sljit_emit_return(compiler, SLJIT_UNUSED, 0, 0); 1707 1708 code.code = sljit_generate_code(compiler); 1709 CHECK(compiler); 1710 sljit_free_compiler(compiler); 1711 1712 code.func3((sljit_sw)&buf, (sljit_sw)&sbuf, (sljit_sw)&bbuf); 1713 FAILED(buf[1] != -13, "test22 case 1 failed\n"); 1714 FAILED(buf[2] != 5, "test22 case 2 failed\n"); 1715 FAILED(buf[3] != -13, "test22 case 3 failed\n"); 1716 FAILED(buf[4] != (sljit_sw)&buf[3], "test22 case 4 failed\n"); 1717 FAILED(buf[5] != (sljit_sw)&buf[4], "test22 case 5 failed\n"); 1718 FAILED(buf[6] != (sljit_sw)&buf[4], "test22 case 6 failed\n"); 1719 FAILED(buf[7] != -9, "test22 case 7 failed\n"); 1720 FAILED(buf[8] != -56, "test22 case 8 failed\n"); 1721 1722 FAILED(sbuf[0] != -13, "test22 case 9 failed\n"); 1723 FAILED(sbuf[1] != 0x1234, "test22 case 10 failed\n"); 1724 FAILED(sbuf[3] != 0x1234, "test22 case 11 failed\n"); 1725 FAILED(sbuf[4] != 8000, "test22 case 12 failed\n"); 1726 FAILED(sbuf[5] != -9317, "test22 case 13 failed\n"); 1727 FAILED(sbuf[6] != -9317, "test22 case 14 failed\n"); 1728 1729 FAILED(bbuf[0] != -45, "test22 case 15 failed\n"); 1730 FAILED(bbuf[1] != 0x12, "test22 case 16 failed\n"); 1731 FAILED(bbuf[3] != -56, "test22 case 17 failed\n"); 1732 FAILED(bbuf[4] != 2, "test22 case 18 failed\n"); 1733 1734 sljit_free_code(code.code); 1735 successful_tests++; 1736 } 1737 1738 static void test23(void) 1739 { 1740 /* Test 32 bit / 64 bit signed / unsigned int transfer and conversion. 1741 This test has do real things on 64 bit systems, but works on 32 bit systems as well. */ 1742 executable_code code; 1743 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 1744 sljit_sw buf[9]; 1745 sljit_s32 ibuf[5]; 1746 union { 1747 sljit_s32 asint; 1748 sljit_u8 asbytes[4]; 1749 } u; 1750 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 1751 sljit_sw garbage = SLJIT_W(0x1234567812345678); 1752 #else 1753 sljit_sw garbage = 0x12345678; 1754 #endif 1755 1756 if (verbose) 1757 printf("Run test23\n"); 1758 1759 FAILED(!compiler, "cannot create compiler\n"); 1760 buf[0] = 0; 1761 buf[1] = 0; 1762 buf[2] = 0; 1763 buf[3] = 0; 1764 buf[4] = 0; 1765 buf[5] = 0; 1766 buf[6] = 0; 1767 buf[7] = 0; 1768 buf[8] = 0; 1769 1770 ibuf[0] = 0; 1771 ibuf[1] = 0; 1772 ibuf[2] = -5791; 1773 ibuf[3] = 43579; 1774 ibuf[4] = 658923; 1775 1776 sljit_emit_enter(compiler, 0, 2, 3, 3, 0, 0, 0); 1777 sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_MEM1(SLJIT_S1), 0, SLJIT_IMM, 34567); 1778 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 1); 1779 sljit_emit_op1(compiler, SLJIT_MOVU_S32, SLJIT_MEM2(SLJIT_S1, SLJIT_R0), 2, SLJIT_IMM, -7654); 1780 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, garbage); 1781 sljit_emit_op1(compiler, SLJIT_MOVU_S32, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_s32)); 1782 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0); 1783 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, garbage); 1784 sljit_emit_op1(compiler, SLJIT_MOVU_U32, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_s32)); 1785 sljit_emit_op1(compiler, SLJIT_MOVU, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_R0, 0); 1786 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, garbage); 1787 sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_s32)); 1788 sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_R0, 0, SLJIT_R0, 0); 1789 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_R0, 0); 1790 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0x0f00f00); 1791 sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_S0, 0, SLJIT_S0, 0, SLJIT_IMM, 0x7777); 1792 sljit_emit_op1(compiler, SLJIT_MOVU, SLJIT_MEM1(SLJIT_S0), 0x7777 + 2 * sizeof(sljit_sw), SLJIT_R0, 0); 1793 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_S0, 0, SLJIT_S0, 0, SLJIT_IMM, 0x7777); 1794 sljit_emit_op1(compiler, SLJIT_MOVU, SLJIT_MEM1(SLJIT_S0), -0x7777 + (sljit_sw)sizeof(sljit_sw), SLJIT_R0, 0); 1795 sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R1, 0, SLJIT_S0, 0, SLJIT_IMM, 16 - sizeof(sljit_sw)); 1796 sljit_emit_op2(compiler, SLJIT_LSHR, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, 1); 1797 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 16); 1798 sljit_emit_op1(compiler, SLJIT_MOVU, SLJIT_MEM2(SLJIT_R0, SLJIT_R1), 1, SLJIT_R0, 0); 1799 sljit_emit_op2(compiler, SLJIT_OR, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_IMM, 64, SLJIT_MEM1(SLJIT_R0), 0); 1800 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0); 1801 sljit_emit_op1(compiler, SLJIT_MOVU, SLJIT_MEM1(SLJIT_R0), (sljit_sw)&buf[6], SLJIT_MEM0(), (sljit_sw)&buf[6]); 1802 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_IMM, 0x123456); 1803 sljit_emit_op1(compiler, SLJIT_MOVU, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_S0, 0); 1804 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_IMM, sizeof(sljit_sw)); 1805 sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_S0, 0, SLJIT_S0, 0, SLJIT_IMM, 100000 * sizeof(sljit_sw)); 1806 sljit_emit_op1(compiler, SLJIT_MOVU, SLJIT_MEM1(SLJIT_S0), 100001 * sizeof(sljit_sw), SLJIT_S0, 0); 1807 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_IMM, sizeof(sljit_sw)); 1808 sljit_emit_op1(compiler, SLJIT_MOVU_S32, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_s32), SLJIT_IMM, 0x12345678); 1809 1810 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0x2bd700 | 243); 1811 sljit_emit_return(compiler, SLJIT_MOV_S8, SLJIT_R1, 0); 1812 1813 code.code = sljit_generate_code(compiler); 1814 CHECK(compiler); 1815 sljit_free_compiler(compiler); 1816 1817 FAILED(code.func2((sljit_sw)&buf, (sljit_sw)&ibuf) != -13, "test23 case 1 failed\n"); 1818 FAILED(buf[0] != -5791, "test23 case 2 failed\n"); 1819 FAILED(buf[1] != 43579, "test23 case 3 failed\n"); 1820 FAILED(buf[2] != 658923, "test23 case 4 failed\n"); 1821 FAILED(buf[3] != 0x0f00f00, "test23 case 5 failed\n"); 1822 FAILED(buf[4] != 0x0f00f00, "test23 case 6 failed\n"); 1823 FAILED(buf[5] != 80, "test23 case 7 failed\n"); 1824 FAILED(buf[6] != 0x123456, "test23 case 8 failed\n"); 1825 FAILED(buf[7] != (sljit_sw)&buf[5], "test23 case 9 failed\n"); 1826 FAILED(buf[8] != (sljit_sw)&buf[8] - 100000 * sizeof(sljit_sw), "test23 case 10 failed\n"); 1827 1828 FAILED(ibuf[0] != 34567, "test23 case 11 failed\n"); 1829 FAILED(ibuf[1] != -7654, "test23 case 12 failed\n"); 1830 u.asint = ibuf[4]; 1831 #if (defined SLJIT_LITTLE_ENDIAN && SLJIT_LITTLE_ENDIAN) 1832 FAILED(u.asbytes[0] != 0x78, "test23 case 13 failed\n"); 1833 FAILED(u.asbytes[1] != 0x56, "test23 case 14 failed\n"); 1834 FAILED(u.asbytes[2] != 0x34, "test23 case 15 failed\n"); 1835 FAILED(u.asbytes[3] != 0x12, "test23 case 16 failed\n"); 1836 #else 1837 FAILED(u.asbytes[0] != 0x12, "test23 case 13 failed\n"); 1838 FAILED(u.asbytes[1] != 0x34, "test23 case 14 failed\n"); 1839 FAILED(u.asbytes[2] != 0x56, "test23 case 15 failed\n"); 1840 FAILED(u.asbytes[3] != 0x78, "test23 case 16 failed\n"); 1841 #endif 1842 1843 sljit_free_code(code.code); 1844 successful_tests++; 1845 } 1846 1847 static void test24(void) 1848 { 1849 /* Some complicated addressing modes. */ 1850 executable_code code; 1851 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 1852 sljit_sw buf[9]; 1853 sljit_s16 sbuf[5]; 1854 sljit_s8 bbuf[7]; 1855 1856 if (verbose) 1857 printf("Run test24\n"); 1858 1859 FAILED(!compiler, "cannot create compiler\n"); 1860 1861 buf[0] = 100567; 1862 buf[1] = 75799; 1863 buf[2] = 0; 1864 buf[3] = -8; 1865 buf[4] = -50; 1866 buf[5] = 0; 1867 buf[6] = 0; 1868 buf[7] = 0; 1869 buf[8] = 0; 1870 1871 sbuf[0] = 30000; 1872 sbuf[1] = 0; 1873 sbuf[2] = 0; 1874 sbuf[3] = -12345; 1875 sbuf[4] = 0; 1876 1877 bbuf[0] = -128; 1878 bbuf[1] = 0; 1879 bbuf[2] = 0; 1880 bbuf[3] = 99; 1881 bbuf[4] = 0; 1882 bbuf[5] = 0; 1883 bbuf[6] = 0; 1884 1885 sljit_emit_enter(compiler, 0, 3, 3, 3, 0, 0, 0); 1886 1887 /* Nothing should be updated. */ 1888 sljit_emit_op1(compiler, SLJIT_MOVU_S16, SLJIT_MEM0(), (sljit_sw)&sbuf[1], SLJIT_MEM0(), (sljit_sw)&sbuf[0]); 1889 sljit_emit_op1(compiler, SLJIT_MOVU_S8, SLJIT_MEM0(), (sljit_sw)&bbuf[1], SLJIT_MEM0(), (sljit_sw)&bbuf[0]); 1890 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 2); 1891 sljit_emit_op1(compiler, SLJIT_MOV_U16, SLJIT_MEM2(SLJIT_S1, SLJIT_R0), 1, SLJIT_MEM0(), (sljit_sw)&sbuf[3]); 1892 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&buf[0]); 1893 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, sizeof(sljit_sw)); 1894 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 2); 1895 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); 1896 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, sizeof(sljit_s8)); 1897 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, sizeof(sljit_s8)); 1898 sljit_emit_op1(compiler, SLJIT_MOVU_U8, SLJIT_MEM1(SLJIT_R0), (sljit_sw)&bbuf[1], SLJIT_MEM1(SLJIT_R1), (sljit_sw)&bbuf[0]); 1899 sljit_emit_op1(compiler, SLJIT_MOVU_U8, SLJIT_MEM1(SLJIT_R0), 0, SLJIT_MEM1(SLJIT_R1), 2 * sizeof(sljit_s8)); 1900 1901 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, sizeof(sljit_s16)); 1902 sljit_emit_op1(compiler, SLJIT_MOV_S16, SLJIT_MEM1(SLJIT_R1), (sljit_sw)&sbuf[3], SLJIT_R1, 0); 1903 1904 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 3); 1905 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); 1906 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 4); 1907 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_S0, 0); 1908 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); 1909 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_S0, 0); 1910 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_S0, 0, SLJIT_IMM, sizeof(sljit_sw)); 1911 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 4); 1912 sljit_emit_op1(compiler, SLJIT_MOVU, SLJIT_MEM2(SLJIT_R1, SLJIT_R2), SLJIT_WORD_SHIFT, SLJIT_MEM2(SLJIT_R0, SLJIT_R2), SLJIT_WORD_SHIFT); 1913 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_R0, 0); 1914 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_R1, 0); 1915 1916 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&buf - 0x7fff8000 + 6 * sizeof(sljit_sw)); 1917 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 952467); 1918 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 0x7fff8000, SLJIT_R1, 0); 1919 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 0x7fff8000 + sizeof(sljit_sw), SLJIT_MEM1(SLJIT_R0), 0x7fff8000); 1920 1921 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&buf + 0x7fff7fff + 6 * sizeof(sljit_sw)); 1922 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM1(SLJIT_R0), -0x7fff7fff + 2 * sizeof(sljit_sw), SLJIT_MEM1(SLJIT_R0), -0x7fff7fff + sizeof(sljit_sw), SLJIT_MEM1(SLJIT_R0), -0x7fff7fff); 1923 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&bbuf - 0x7fff7ffe + 3 * sizeof(sljit_s8)); 1924 sljit_emit_op1(compiler, SLJIT_MOV_S8, SLJIT_MEM1(SLJIT_R0), 0x7fff7fff, SLJIT_MEM1(SLJIT_R0), 0x7fff7ffe); 1925 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&bbuf + 0x7fff7fff + 5 * sizeof(sljit_s8)); 1926 sljit_emit_op1(compiler, SLJIT_MOV_S8, SLJIT_MEM1(SLJIT_R0), -0x7fff7fff, SLJIT_MEM1(SLJIT_R0), -0x7fff8000); 1927 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 1928 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&bbuf - SLJIT_W(0x123456123456)); 1929 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, (sljit_sw)&bbuf - SLJIT_W(0x123456123456)); 1930 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)); 1931 #endif 1932 1933 sljit_emit_return(compiler, SLJIT_UNUSED, 0, 0); 1934 1935 code.code = sljit_generate_code(compiler); 1936 CHECK(compiler); 1937 sljit_free_compiler(compiler); 1938 1939 code.func3((sljit_sw)&buf, (sljit_sw)&sbuf, (sljit_sw)&bbuf); 1940 FAILED(buf[2] != 176366, "test24 case 1 failed\n"); 1941 FAILED(buf[3] != 64, "test24 case 2 failed\n"); 1942 FAILED(buf[4] != -100, "test24 case 3 failed\n"); 1943 FAILED(buf[5] != -100 + (sljit_sw)&buf[5] + (sljit_sw)&buf[4], "test24 case 4 failed\n"); 1944 FAILED(buf[6] != 952467, "test24 case 5 failed\n"); 1945 FAILED(buf[7] != 952467, "test24 case 6 failed\n"); 1946 FAILED(buf[8] != 952467 * 2, "test24 case 7 failed\n"); 1947 1948 FAILED(sbuf[1] != 30000, "test24 case 8 failed\n"); 1949 FAILED(sbuf[2] != -12345, "test24 case 9 failed\n"); 1950 FAILED(sbuf[4] != sizeof(sljit_s16), "test24 case 10 failed\n"); 1951 1952 FAILED(bbuf[1] != -128, "test24 case 11 failed\n"); 1953 FAILED(bbuf[2] != 99, "test24 case 12 failed\n"); 1954 FAILED(bbuf[4] != 99, "test24 case 13 failed\n"); 1955 FAILED(bbuf[5] != 99, "test24 case 14 failed\n"); 1956 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 1957 FAILED(bbuf[6] != -128, "test24 case 15 failed\n"); 1958 #endif 1959 1960 sljit_free_code(code.code); 1961 successful_tests++; 1962 } 1963 1964 static void test25(void) 1965 { 1966 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 1967 /* 64 bit loads. */ 1968 executable_code code; 1969 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 1970 sljit_sw buf[14]; 1971 1972 if (verbose) 1973 printf("Run test25\n"); 1974 1975 FAILED(!compiler, "cannot create compiler\n"); 1976 buf[0] = 7; 1977 buf[1] = 0; 1978 buf[2] = 0; 1979 buf[3] = 0; 1980 buf[4] = 0; 1981 buf[5] = 0; 1982 buf[6] = 0; 1983 buf[7] = 0; 1984 buf[8] = 0; 1985 buf[9] = 0; 1986 buf[10] = 0; 1987 buf[11] = 0; 1988 buf[12] = 0; 1989 buf[13] = 0; 1990 1991 sljit_emit_enter(compiler, 0, 1, 3, 1, 0, 0, 0); 1992 1993 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_IMM, 0); 1994 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 1 * sizeof(sljit_sw), SLJIT_IMM, 0x7fff); 1995 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_IMM, -0x8000); 1996 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_IMM, 0x7fffffff); 1997 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_IMM, SLJIT_W(-0x80000000)); 1998 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_IMM, SLJIT_W(0x1234567887654321)); 1999 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_sw), SLJIT_IMM, SLJIT_W(0xff80000000)); 2000 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_sw), SLJIT_IMM, SLJIT_W(0x3ff0000000)); 2001 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_sw), SLJIT_IMM, SLJIT_W(0xfffffff800100000)); 2002 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 9 * sizeof(sljit_sw), SLJIT_IMM, SLJIT_W(0xfffffff80010f000)); 2003 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 10 * sizeof(sljit_sw), SLJIT_IMM, SLJIT_W(0x07fff00000008001)); 2004 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 11 * sizeof(sljit_sw), SLJIT_IMM, SLJIT_W(0x07fff00080010000)); 2005 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 12 * sizeof(sljit_sw), SLJIT_IMM, SLJIT_W(0x07fff00080018001)); 2006 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 13 * sizeof(sljit_sw), SLJIT_IMM, SLJIT_W(0x07fff00ffff00000)); 2007 2008 sljit_emit_return(compiler, SLJIT_UNUSED, 0, 0); 2009 2010 code.code = sljit_generate_code(compiler); 2011 CHECK(compiler); 2012 sljit_free_compiler(compiler); 2013 2014 code.func1((sljit_sw)&buf); 2015 FAILED(buf[0] != 0, "test25 case 1 failed\n"); 2016 FAILED(buf[1] != 0x7fff, "test25 case 2 failed\n"); 2017 FAILED(buf[2] != -0x8000, "test25 case 3 failed\n"); 2018 FAILED(buf[3] != 0x7fffffff, "test25 case 4 failed\n"); 2019 FAILED(buf[4] != SLJIT_W(-0x80000000), "test25 case 5 failed\n"); 2020 FAILED(buf[5] != SLJIT_W(0x1234567887654321), "test25 case 6 failed\n"); 2021 FAILED(buf[6] != SLJIT_W(0xff80000000), "test25 case 7 failed\n"); 2022 FAILED(buf[7] != SLJIT_W(0x3ff0000000), "test25 case 8 failed\n"); 2023 FAILED((sljit_uw)buf[8] != SLJIT_W(0xfffffff800100000), "test25 case 9 failed\n"); 2024 FAILED((sljit_uw)buf[9] != SLJIT_W(0xfffffff80010f000), "test25 case 10 failed\n"); 2025 FAILED(buf[10] != SLJIT_W(0x07fff00000008001), "test25 case 11 failed\n"); 2026 FAILED(buf[11] != SLJIT_W(0x07fff00080010000), "test25 case 12 failed\n"); 2027 FAILED(buf[12] != SLJIT_W(0x07fff00080018001), "test25 case 13 failed\n"); 2028 FAILED(buf[13] != SLJIT_W(0x07fff00ffff00000), "test25 case 14 failed\n"); 2029 2030 sljit_free_code(code.code); 2031 #endif 2032 successful_tests++; 2033 } 2034 2035 static void test26(void) 2036 { 2037 /* Aligned access without aligned offsets. */ 2038 executable_code code; 2039 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 2040 sljit_sw buf[4]; 2041 sljit_s32 ibuf[4]; 2042 sljit_f64 dbuf[4]; 2043 2044 if (verbose) 2045 printf("Run test26\n"); 2046 2047 FAILED(!compiler, "cannot create compiler\n"); 2048 2049 buf[0] = -2789; 2050 buf[1] = 0; 2051 buf[2] = 4; 2052 buf[3] = -4; 2053 2054 ibuf[0] = -689; 2055 ibuf[1] = 0; 2056 ibuf[2] = -6; 2057 ibuf[3] = 3; 2058 2059 dbuf[0] = 5.75; 2060 dbuf[1] = 0.0; 2061 dbuf[2] = 0.0; 2062 dbuf[3] = -4.0; 2063 2064 sljit_emit_enter(compiler, 0, 3, 3, 3, 0, 0, 0); 2065 2066 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_S0, 0, SLJIT_S0, 0, SLJIT_IMM, 3); 2067 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_S1, 0, SLJIT_S1, 0, SLJIT_IMM, 1); 2068 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), -3); 2069 sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_s32) - 1, SLJIT_R0, 0); 2070 sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S1), -1); 2071 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) - 3, SLJIT_R0, 0); 2072 2073 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_S0, 0, SLJIT_IMM, 100); 2074 sljit_emit_op2(compiler, SLJIT_MUL, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_sw) * 2 - 103, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 2 - 3, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 3 - 3); 2075 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_S1, 0, SLJIT_IMM, 100); 2076 sljit_emit_op2(compiler, SLJIT_MUL32, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_s32) * 2 - 101, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_s32) * 2 - 1, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_s32) * 3 - 1); 2077 2078 if (sljit_is_fpu_available()) { 2079 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_S2, 0, SLJIT_S2, 0, SLJIT_IMM, 3); 2080 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S2), sizeof(sljit_f64) - 3, SLJIT_MEM1(SLJIT_S2), -3); 2081 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); 2082 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_S2, 0, SLJIT_IMM, 2); 2083 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, (sizeof(sljit_f64) * 3 - 4) >> 1); 2084 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R2, 0, SLJIT_S2, 0, SLJIT_IMM, 1); 2085 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); 2086 } 2087 2088 sljit_emit_return(compiler, SLJIT_UNUSED, 0, 0); 2089 2090 code.code = sljit_generate_code(compiler); 2091 CHECK(compiler); 2092 sljit_free_compiler(compiler); 2093 2094 code.func3((sljit_sw)&buf, (sljit_sw)&ibuf, (sljit_sw)&dbuf); 2095 2096 FAILED(buf[1] != -689, "test26 case 1 failed\n"); 2097 FAILED(buf[2] != -16, "test26 case 2 failed\n"); 2098 FAILED(ibuf[1] != -2789, "test26 case 3 failed\n"); 2099 FAILED(ibuf[2] != -18, "test26 case 4 failed\n"); 2100 2101 if (sljit_is_fpu_available()) { 2102 FAILED(dbuf[1] != 5.75, "test26 case 5 failed\n"); 2103 FAILED(dbuf[2] != 11.5, "test26 case 6 failed\n"); 2104 FAILED(dbuf[3] != -2.875, "test26 case 7 failed\n"); 2105 } 2106 2107 sljit_free_code(code.code); 2108 successful_tests++; 2109 } 2110 2111 static void test27(void) 2112 { 2113 #define SET_NEXT_BYTE(type) \ 2114 cond_set(compiler, SLJIT_R2, 0, type); \ 2115 sljit_emit_op1(compiler, SLJIT_MOVU_U8, SLJIT_MEM1(SLJIT_S0), 1, SLJIT_R2, 0); 2116 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 2117 #define RESULT(i) i 2118 #else 2119 #define RESULT(i) (3 - i) 2120 #endif 2121 2122 /* Playing with conditional flags. */ 2123 executable_code code; 2124 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 2125 sljit_s8 buf[37]; 2126 sljit_s32 i; 2127 2128 if (verbose) 2129 printf("Run test27\n"); 2130 2131 for (i = 0; i < 37; ++i) 2132 buf[i] = 10; 2133 2134 FAILED(!compiler, "cannot create compiler\n"); 2135 2136 /* 3 arguments passed, 3 arguments used. */ 2137 sljit_emit_enter(compiler, 0, 1, 3, 3, 0, 0, 0); 2138 2139 sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_S0, 0, SLJIT_S0, 0, SLJIT_IMM, 1); 2140 2141 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0x1001); 2142 sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 20); 2143 /* 0x100100000 on 64 bit machines, 0x100000 on 32 bit machines. */ 2144 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0x800000); 2145 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, SLJIT_R0, 0, SLJIT_R1, 0); 2146 sljit_emit_op0(compiler, SLJIT_NOP); /* Nop should keep the flags. */ 2147 SET_NEXT_BYTE(SLJIT_GREATER); 2148 SET_NEXT_BYTE(SLJIT_LESS); 2149 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_R0, 0); 2150 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_R1, 0); 2151 sljit_emit_op2(compiler, SLJIT_SUB32 | SLJIT_SET_U, SLJIT_UNUSED, 0, SLJIT_R0, 0, SLJIT_R1, 0); 2152 sljit_emit_op0(compiler, SLJIT_NOP); /* Nop should keep the flags. */ 2153 SET_NEXT_BYTE(SLJIT_GREATER32); 2154 SET_NEXT_BYTE(SLJIT_LESS32); 2155 2156 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0x1000); 2157 sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 20); 2158 sljit_emit_op2(compiler, SLJIT_OR, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 0x10); 2159 /* 0x100000010 on 64 bit machines, 0x10 on 32 bit machines. */ 2160 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, SLJIT_R0, 0, SLJIT_IMM, 0x80); 2161 SET_NEXT_BYTE(SLJIT_GREATER); 2162 SET_NEXT_BYTE(SLJIT_LESS); 2163 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_R0, 0); 2164 sljit_emit_op2(compiler, SLJIT_SUB32 | SLJIT_SET_U, SLJIT_UNUSED, 0, SLJIT_R0, 0, SLJIT_IMM, 0x80); 2165 SET_NEXT_BYTE(SLJIT_GREATER32); 2166 SET_NEXT_BYTE(SLJIT_LESS32); 2167 2168 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0); 2169 sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 1); 2170 /* 0xff..ff on all machines. */ 2171 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_U, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, 1); 2172 SET_NEXT_BYTE(SLJIT_LESS_EQUAL); 2173 SET_NEXT_BYTE(SLJIT_GREATER_EQUAL); 2174 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_S, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, -1); 2175 SET_NEXT_BYTE(SLJIT_SIG_GREATER); 2176 SET_NEXT_BYTE(SLJIT_SIG_LESS); 2177 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_E, SLJIT_R0, 0, SLJIT_R1, 0, SLJIT_R0, 0); 2178 SET_NEXT_BYTE(SLJIT_EQUAL); 2179 SET_NEXT_BYTE(SLJIT_NOT_EQUAL); 2180 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_O | SLJIT_SET_U, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, -2); 2181 SET_NEXT_BYTE(SLJIT_OVERFLOW); 2182 SET_NEXT_BYTE(SLJIT_NOT_OVERFLOW); 2183 SET_NEXT_BYTE(SLJIT_GREATER_EQUAL); 2184 SET_NEXT_BYTE(SLJIT_LESS_EQUAL); 2185 2186 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0x80000000); 2187 sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 16); 2188 sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 16); 2189 /* 0x80..0 on 64 bit machines, 0 on 32 bit machines. */ 2190 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0xffffffff); 2191 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_O, SLJIT_UNUSED, 0, SLJIT_R0, 0, SLJIT_R1, 0); 2192 SET_NEXT_BYTE(SLJIT_OVERFLOW); 2193 SET_NEXT_BYTE(SLJIT_NOT_OVERFLOW); 2194 sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_R0, 0, SLJIT_R0, 0); 2195 sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_R1, 0, SLJIT_R1, 0); 2196 sljit_emit_op2(compiler, SLJIT_SUB32 | SLJIT_SET_O, SLJIT_UNUSED, 0, SLJIT_R0, 0, SLJIT_R1, 0); 2197 SET_NEXT_BYTE(SLJIT_OVERFLOW32); 2198 SET_NEXT_BYTE(SLJIT_NOT_OVERFLOW32); 2199 2200 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0); 2201 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_C, SLJIT_UNUSED, 0, SLJIT_R0, 0, SLJIT_IMM, 1); 2202 sljit_emit_op2(compiler, SLJIT_SUBC | SLJIT_SET_C, SLJIT_UNUSED, 0, SLJIT_R0, 0, SLJIT_IMM, 0); 2203 sljit_emit_op2(compiler, SLJIT_SUBC, SLJIT_R0, 0, SLJIT_IMM, 6, SLJIT_R0, 0); 2204 sljit_emit_op1(compiler, SLJIT_MOVU_U8, SLJIT_MEM1(SLJIT_S0), 1, SLJIT_R0, 0); 2205 2206 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -1); 2207 sljit_emit_op2(compiler, SLJIT_ADD | SLJIT_SET_C, SLJIT_UNUSED, 0, SLJIT_R0, 0, SLJIT_IMM, 1); 2208 sljit_emit_op2(compiler, SLJIT_ADDC | SLJIT_SET_C, SLJIT_UNUSED, 0, SLJIT_R0, 0, SLJIT_IMM, 1); 2209 sljit_emit_op2(compiler, SLJIT_ADDC, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 9); 2210 sljit_emit_op1(compiler, SLJIT_MOVU_U8, SLJIT_MEM1(SLJIT_S0), 1, SLJIT_R0, 0); 2211 2212 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 1); 2213 sljit_emit_op2(compiler, SLJIT_SHL, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, (8 * sizeof(sljit_sw)) - 1); 2214 sljit_emit_op2(compiler, SLJIT_ADD | SLJIT_SET_E, SLJIT_UNUSED, 0, SLJIT_R0, 0, SLJIT_IMM, 0); 2215 SET_NEXT_BYTE(SLJIT_EQUAL); 2216 sljit_emit_op2(compiler, SLJIT_ADD | SLJIT_SET_E, SLJIT_UNUSED, 0, SLJIT_R0, 0, SLJIT_R0, 0); 2217 SET_NEXT_BYTE(SLJIT_EQUAL); 2218 2219 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0); 2220 sljit_emit_op2(compiler, SLJIT_ASHR | SLJIT_SET_E, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 0); 2221 SET_NEXT_BYTE(SLJIT_EQUAL); 2222 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 1); 2223 sljit_emit_op2(compiler, SLJIT_LSHR | SLJIT_SET_E, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 0xffffc0); 2224 SET_NEXT_BYTE(SLJIT_NOT_EQUAL); 2225 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_PREF_SHIFT_REG, 0, SLJIT_IMM, 0); 2226 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0); 2227 sljit_emit_op2(compiler, SLJIT_ASHR | SLJIT_SET_E, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_PREF_SHIFT_REG, 0); 2228 SET_NEXT_BYTE(SLJIT_EQUAL); 2229 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_PREF_SHIFT_REG, 0, SLJIT_IMM, 0); 2230 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 1); 2231 sljit_emit_op2(compiler, SLJIT_LSHR | SLJIT_SET_E, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_PREF_SHIFT_REG, 0); 2232 SET_NEXT_BYTE(SLJIT_NOT_EQUAL); 2233 2234 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0); 2235 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 1); 2236 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_C, SLJIT_UNUSED, 0, SLJIT_R0, 0, SLJIT_R0, 0); 2237 sljit_emit_op2(compiler, SLJIT_SUBC, SLJIT_R2, 0, SLJIT_IMM, 1, SLJIT_R0, 0); 2238 sljit_emit_op1(compiler, SLJIT_MOVU_U8, SLJIT_MEM1(SLJIT_S0), 1, SLJIT_R2, 0); 2239 sljit_emit_op2(compiler, SLJIT_SUBC | SLJIT_SET_C, SLJIT_UNUSED, 0, SLJIT_R0, 0, SLJIT_R1, 0); 2240 sljit_emit_op2(compiler, SLJIT_SUBC, SLJIT_R2, 0, SLJIT_IMM, 1, SLJIT_R0, 0); 2241 sljit_emit_op1(compiler, SLJIT_MOVU_U8, SLJIT_MEM1(SLJIT_S0), 1, SLJIT_R2, 0); 2242 2243 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -34); 2244 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_S | SLJIT_SET_U, SLJIT_UNUSED, 0, SLJIT_R0, 0, SLJIT_IMM, 0x1234); 2245 SET_NEXT_BYTE(SLJIT_LESS); 2246 SET_NEXT_BYTE(SLJIT_SIG_LESS); 2247 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 2248 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0x12300000000) - 43); 2249 #else 2250 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, -43); 2251 #endif 2252 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, -96); 2253 sljit_emit_op2(compiler, SLJIT_SUB32 | SLJIT_SET_S | SLJIT_SET_U, SLJIT_UNUSED, 0, SLJIT_R0, 0, SLJIT_R1, 0); 2254 SET_NEXT_BYTE(SLJIT_LESS32); 2255 SET_NEXT_BYTE(SLJIT_SIG_GREATER32); 2256 2257 sljit_emit_return(compiler, SLJIT_UNUSED, 0, 0); 2258 2259 code.code = sljit_generate_code(compiler); 2260 CHECK(compiler); 2261 sljit_free_compiler(compiler); 2262 2263 code.func1((sljit_sw)&buf); 2264 2265 FAILED(buf[0] != RESULT(1), "test27 case 1 failed\n"); 2266 FAILED(buf[1] != RESULT(2), "test27 case 2 failed\n"); 2267 FAILED(buf[2] != 2, "test27 case 3 failed\n"); 2268 FAILED(buf[3] != 1, "test27 case 4 failed\n"); 2269 FAILED(buf[4] != RESULT(1), "test27 case 5 failed\n"); 2270 FAILED(buf[5] != RESULT(2), "test27 case 6 failed\n"); 2271 FAILED(buf[6] != 2, "test27 case 7 failed\n"); 2272 FAILED(buf[7] != 1, "test27 case 8 failed\n"); 2273 2274 FAILED(buf[8] != 2, "test27 case 9 failed\n"); 2275 FAILED(buf[9] != 1, "test27 case 10 failed\n"); 2276 FAILED(buf[10] != 2, "test27 case 11 failed\n"); 2277 FAILED(buf[11] != 1, "test27 case 12 failed\n"); 2278 FAILED(buf[12] != 1, "test27 case 13 failed\n"); 2279 FAILED(buf[13] != 2, "test27 case 14 failed\n"); 2280 FAILED(buf[14] != 2, "test27 case 15 failed\n"); 2281 FAILED(buf[15] != 1, "test27 case 16 failed\n"); 2282 FAILED(buf[16] != 1, "test27 case 17 failed\n"); 2283 FAILED(buf[17] != 2, "test27 case 18 failed\n"); 2284 2285 FAILED(buf[18] != RESULT(1), "test27 case 19 failed\n"); 2286 FAILED(buf[19] != RESULT(2), "test27 case 20 failed\n"); 2287 FAILED(buf[20] != 2, "test27 case 21 failed\n"); 2288 FAILED(buf[21] != 1, "test27 case 22 failed\n"); 2289 2290 FAILED(buf[22] != 5, "test27 case 23 failed\n"); 2291 FAILED(buf[23] != 9, "test27 case 24 failed\n"); 2292 2293 FAILED(buf[24] != 2, "test27 case 25 failed\n"); 2294 FAILED(buf[25] != 1, "test27 case 26 failed\n"); 2295 2296 FAILED(buf[26] != 1, "test27 case 27 failed\n"); 2297 FAILED(buf[27] != 1, "test27 case 28 failed\n"); 2298 FAILED(buf[28] != 1, "test27 case 29 failed\n"); 2299 FAILED(buf[29] != 1, "test27 case 30 failed\n"); 2300 2301 FAILED(buf[30] != 1, "test27 case 31 failed\n"); 2302 FAILED(buf[31] != 0, "test27 case 32 failed\n"); 2303 2304 FAILED(buf[32] != 2, "test27 case 33 failed\n"); 2305 FAILED(buf[33] != 1, "test27 case 34 failed\n"); 2306 FAILED(buf[34] != 2, "test27 case 35 failed\n"); 2307 FAILED(buf[35] != 1, "test27 case 36 failed\n"); 2308 FAILED(buf[36] != 10, "test27 case 37 failed\n"); 2309 2310 sljit_free_code(code.code); 2311 successful_tests++; 2312 #undef SET_NEXT_BYTE 2313 #undef RESULT 2314 } 2315 2316 static void test28(void) 2317 { 2318 /* Test mov. */ 2319 executable_code code; 2320 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 2321 struct sljit_const* const1; 2322 struct sljit_label* label; 2323 sljit_uw label_addr; 2324 sljit_sw buf[5]; 2325 2326 if (verbose) 2327 printf("Run test28\n"); 2328 2329 FAILED(!compiler, "cannot create compiler\n"); 2330 2331 buf[0] = -36; 2332 buf[1] = 8; 2333 buf[2] = 0; 2334 buf[3] = 10; 2335 buf[4] = 0; 2336 2337 FAILED(!compiler, "cannot create compiler\n"); 2338 sljit_emit_enter(compiler, 0, 1, 5, 5, 0, 0, 0); 2339 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, -234); 2340 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R4, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw)); 2341 sljit_emit_op2(compiler, SLJIT_MUL, SLJIT_S3, 0, SLJIT_R3, 0, SLJIT_R4, 0); 2342 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_S3, 0); 2343 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, SLJIT_S3, 0, SLJIT_IMM, 0); 2344 sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_S3, 0, SLJIT_UNUSED, 0, SLJIT_NOT_ZERO); 2345 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_S3, 0); 2346 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S4, 0, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw)); 2347 sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_S4, 0, SLJIT_S4, 0, SLJIT_R4, 0); 2348 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_S4, 0); 2349 const1 = sljit_emit_const(compiler, SLJIT_S3, 0, 0); 2350 sljit_emit_ijump(compiler, SLJIT_JUMP, SLJIT_S3, 0); 2351 sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_S3, 0, SLJIT_S3, 0, SLJIT_IMM, 100); 2352 label = sljit_emit_label(compiler); 2353 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_S3, 0); 2354 sljit_emit_return(compiler, SLJIT_MOV, SLJIT_R4, 0); 2355 2356 code.code = sljit_generate_code(compiler); 2357 CHECK(compiler); 2358 label_addr = sljit_get_label_addr(label); 2359 sljit_set_const(sljit_get_const_addr(const1), label_addr); 2360 sljit_free_compiler(compiler); 2361 2362 FAILED(code.func1((sljit_sw)&buf) != 8, "test28 case 1 failed\n"); 2363 FAILED(buf[1] != -1872, "test28 case 2 failed\n"); 2364 FAILED(buf[2] != 1, "test28 case 3 failed\n"); 2365 FAILED(buf[3] != 2, "test28 case 4 failed\n"); 2366 FAILED(buf[4] != label_addr, "test28 case 5 failed\n"); 2367 2368 sljit_free_code(code.code); 2369 successful_tests++; 2370 } 2371 2372 static void test29(void) 2373 { 2374 /* Test signed/unsigned bytes and halfs. */ 2375 executable_code code; 2376 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 2377 sljit_sw buf[25]; 2378 2379 if (verbose) 2380 printf("Run test29\n"); 2381 2382 buf[0] = 0; 2383 buf[1] = 0; 2384 buf[2] = 0; 2385 buf[3] = 0; 2386 buf[4] = 0; 2387 buf[5] = 0; 2388 buf[6] = 0; 2389 buf[7] = 0; 2390 buf[8] = 0; 2391 buf[9] = 0; 2392 buf[10] = 0; 2393 buf[11] = 0; 2394 buf[12] = 0; 2395 buf[13] = 0; 2396 buf[14] = 0; 2397 buf[15] = 0; 2398 buf[16] = 0; 2399 buf[17] = 0; 2400 buf[18] = 0; 2401 buf[19] = 0; 2402 buf[20] = 0; 2403 buf[21] = 0; 2404 buf[22] = 0; 2405 buf[23] = 0; 2406 buf[24] = 0; 2407 2408 FAILED(!compiler, "cannot create compiler\n"); 2409 sljit_emit_enter(compiler, 0, 1, 5, 5, 0, 0, 0); 2410 2411 sljit_emit_op1(compiler, SLJIT_MOV_S8, SLJIT_R0, 0, SLJIT_IMM, -187); 2412 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0); 2413 sljit_emit_op1(compiler, SLJIT_MOVU_S8, SLJIT_R0, 0, SLJIT_IMM, -605); 2414 sljit_emit_op1(compiler, SLJIT_MOVU, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_uw), SLJIT_R0, 0); 2415 sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_R0, 0, SLJIT_IMM, -56); 2416 sljit_emit_op1(compiler, SLJIT_MOVU, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_uw), SLJIT_R0, 0); 2417 sljit_emit_op1(compiler, SLJIT_MOVU_U8, SLJIT_R4, 0, SLJIT_IMM, 0xcde5); 2418 sljit_emit_op1(compiler, SLJIT_MOVU, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_uw), SLJIT_R4, 0); 2419 2420 sljit_emit_op1(compiler, SLJIT_MOV_S16, SLJIT_R0, 0, SLJIT_IMM, -45896); 2421 sljit_emit_op1(compiler, SLJIT_MOVU, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_uw), SLJIT_R0, 0); 2422 sljit_emit_op1(compiler, SLJIT_MOVU_S16, SLJIT_R0, 0, SLJIT_IMM, -1472797); 2423 sljit_emit_op1(compiler, SLJIT_MOVU, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_uw), SLJIT_R0, 0); 2424 sljit_emit_op1(compiler, SLJIT_MOV_U16, SLJIT_R0, 0, SLJIT_IMM, -12890); 2425 sljit_emit_op1(compiler, SLJIT_MOVU, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_uw), SLJIT_R0, 0); 2426 sljit_emit_op1(compiler, SLJIT_MOVU_U16, SLJIT_R4, 0, SLJIT_IMM, 0x9cb0a6); 2427 sljit_emit_op1(compiler, SLJIT_MOVU, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_uw), SLJIT_R4, 0); 2428 2429 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 2430 sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(-3580429715)); 2431 sljit_emit_op1(compiler, SLJIT_MOVU, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_uw), SLJIT_R0, 0); 2432 sljit_emit_op1(compiler, SLJIT_MOVU_S32, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(-100722768662)); 2433 sljit_emit_op1(compiler, SLJIT_MOVU, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_uw), SLJIT_R0, 0); 2434 sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(-1457052677972)); 2435 sljit_emit_op1(compiler, SLJIT_MOVU, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_uw), SLJIT_R0, 0); 2436 sljit_emit_op1(compiler, SLJIT_MOVU_U32, SLJIT_R4, 0, SLJIT_IMM, SLJIT_W(0xcef97a70b5)); 2437 sljit_emit_op1(compiler, SLJIT_MOVU, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_uw), SLJIT_R4, 0); 2438 #else 2439 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_S0, 0, SLJIT_S0, 0, SLJIT_IMM, 4 * sizeof(sljit_uw)); 2440 #endif 2441 2442 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, -187); 2443 sljit_emit_op1(compiler, SLJIT_MOV_S8, SLJIT_R0, 0, SLJIT_R1, 0); 2444 sljit_emit_op1(compiler, SLJIT_MOVU, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_uw), SLJIT_R0, 0); 2445 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, -605); 2446 sljit_emit_op1(compiler, SLJIT_MOVU_S8, SLJIT_R0, 0, SLJIT_S2, 0); 2447 sljit_emit_op1(compiler, SLJIT_MOVU, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_uw), SLJIT_R0, 0); 2448 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, -56); 2449 sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_R0, 0, SLJIT_R2, 0); 2450 sljit_emit_op1(compiler, SLJIT_MOVU, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_uw), SLJIT_R0, 0); 2451 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, 0xcde5); 2452 sljit_emit_op1(compiler, SLJIT_MOVU_U8, SLJIT_R4, 0, SLJIT_R3, 0); 2453 sljit_emit_op1(compiler, SLJIT_MOVU, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_uw), SLJIT_R4, 0); 2454 2455 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, -45896); 2456 sljit_emit_op1(compiler, SLJIT_MOV_S16, SLJIT_R0, 0, SLJIT_R1, 0); 2457 sljit_emit_op1(compiler, SLJIT_MOVU, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_uw), SLJIT_R0, 0); 2458 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, -1472797); 2459 sljit_emit_op1(compiler, SLJIT_MOVU_S16, SLJIT_R0, 0, SLJIT_S2, 0); 2460 sljit_emit_op1(compiler, SLJIT_MOVU, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_uw), SLJIT_R0, 0); 2461 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, -12890); 2462 sljit_emit_op1(compiler, SLJIT_MOV_U16, SLJIT_R0, 0, SLJIT_R2, 0); 2463 sljit_emit_op1(compiler, SLJIT_MOVU, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_uw), SLJIT_R0, 0); 2464 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, 0x9cb0a6); 2465 sljit_emit_op1(compiler, SLJIT_MOVU_U16, SLJIT_R4, 0, SLJIT_R3, 0); 2466 sljit_emit_op1(compiler, SLJIT_MOVU, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_uw), SLJIT_R4, 0); 2467 2468 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 2469 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(-3580429715)); 2470 sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_R0, 0, SLJIT_R1, 0); 2471 sljit_emit_op1(compiler, SLJIT_MOVU, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_uw), SLJIT_R0, 0); 2472 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, SLJIT_W(-100722768662)); 2473 sljit_emit_op1(compiler, SLJIT_MOVU_S32, SLJIT_R0, 0, SLJIT_S2, 0); 2474 sljit_emit_op1(compiler, SLJIT_MOVU, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_uw), SLJIT_R0, 0); 2475 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, SLJIT_W(-1457052677972)); 2476 sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_R0, 0, SLJIT_R2, 0); 2477 sljit_emit_op1(compiler, SLJIT_MOVU, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_uw), SLJIT_R0, 0); 2478 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, SLJIT_W(0xcef97a70b5)); 2479 sljit_emit_op1(compiler, SLJIT_MOVU_U32, SLJIT_R4, 0, SLJIT_R3, 0); 2480 sljit_emit_op1(compiler, SLJIT_MOVU, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_uw), SLJIT_R4, 0); 2481 #else 2482 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_S0, 0, SLJIT_S0, 0, SLJIT_IMM, 4 * sizeof(sljit_uw)); 2483 #endif 2484 2485 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, 0x9faa5); 2486 sljit_emit_op1(compiler, SLJIT_MOV_S8, SLJIT_S2, 0, SLJIT_S2, 0); 2487 sljit_emit_op1(compiler, SLJIT_MOVU, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_uw), SLJIT_S2, 0); 2488 2489 sljit_emit_return(compiler, SLJIT_UNUSED, 0, 0); 2490 2491 code.code = sljit_generate_code(compiler); 2492 CHECK(compiler); 2493 sljit_free_compiler(compiler); 2494 2495 code.func1((sljit_sw)&buf); 2496 FAILED(buf[0] != 69, "test29 case 1 failed\n"); 2497 FAILED(buf[1] != -93, "test29 case 2 failed\n"); 2498 FAILED(buf[2] != 200, "test29 case 3 failed\n"); 2499 FAILED(buf[3] != 0xe5, "test29 case 4 failed\n"); 2500 FAILED(buf[4] != 19640, "test29 case 5 failed\n"); 2501 FAILED(buf[5] != -31005, "test29 case 6 failed\n"); 2502 FAILED(buf[6] != 52646, "test29 case 7 failed\n"); 2503 FAILED(buf[7] != 0xb0a6, "test29 case 8 failed\n"); 2504 2505 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 2506 FAILED(buf[8] != SLJIT_W(714537581), "test29 case 9 failed\n"); 2507 FAILED(buf[9] != SLJIT_W(-1938520854), "test29 case 10 failed\n"); 2508 FAILED(buf[10] != SLJIT_W(3236202668), "test29 case 11 failed\n"); 2509 FAILED(buf[11] != SLJIT_W(0xf97a70b5), "test29 case 12 failed\n"); 2510 #endif 2511 2512 FAILED(buf[12] != 69, "test29 case 13 failed\n"); 2513 FAILED(buf[13] != -93, "test29 case 14 failed\n"); 2514 FAILED(buf[14] != 200, "test29 case 15 failed\n"); 2515 FAILED(buf[15] != 0xe5, "test29 case 16 failed\n"); 2516 FAILED(buf[16] != 19640, "test29 case 17 failed\n"); 2517 FAILED(buf[17] != -31005, "test29 case 18 failed\n"); 2518 FAILED(buf[18] != 52646, "test29 case 19 failed\n"); 2519 FAILED(buf[19] != 0xb0a6, "test29 case 20 failed\n"); 2520 2521 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 2522 FAILED(buf[20] != SLJIT_W(714537581), "test29 case 21 failed\n"); 2523 FAILED(buf[21] != SLJIT_W(-1938520854), "test29 case 22 failed\n"); 2524 FAILED(buf[22] != SLJIT_W(3236202668), "test29 case 23 failed\n"); 2525 FAILED(buf[23] != SLJIT_W(0xf97a70b5), "test29 case 24 failed\n"); 2526 #endif 2527 2528 FAILED(buf[24] != -91, "test29 case 25 failed\n"); 2529 2530 sljit_free_code(code.code); 2531 successful_tests++; 2532 } 2533 2534 static void test30(void) 2535 { 2536 /* Test unused results. */ 2537 executable_code code; 2538 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 2539 sljit_sw buf[1]; 2540 2541 if (verbose) 2542 printf("Run test30\n"); 2543 2544 FAILED(!compiler, "cannot create compiler\n"); 2545 buf[0] = 0; 2546 sljit_emit_enter(compiler, 0, 1, 5, 5, 0, 0, 0); 2547 2548 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 1); 2549 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 1); 2550 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 1); 2551 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, 1); 2552 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R4, 0, SLJIT_IMM, 1); 2553 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 2554 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_S1, 0, SLJIT_IMM, SLJIT_W(-0x123ffffffff)); 2555 #else 2556 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_S1, 0, SLJIT_IMM, 1); 2557 #endif 2558 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, 1); 2559 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S3, 0, SLJIT_IMM, 1); 2560 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S4, 0, SLJIT_IMM, 1); 2561 2562 /* Some calculations with unused results. */ 2563 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_UNUSED, 0, SLJIT_R2, 0); 2564 sljit_emit_op1(compiler, SLJIT_NOT, SLJIT_UNUSED, 0, SLJIT_R1, 0); 2565 sljit_emit_op1(compiler, SLJIT_NEG, SLJIT_UNUSED, 0, SLJIT_MEM1(SLJIT_S0), 0); 2566 sljit_emit_op2(compiler, SLJIT_ADD | SLJIT_SET_E, SLJIT_UNUSED, 0, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_MEM1(SLJIT_S0), 0); 2567 sljit_emit_op2(compiler, SLJIT_SUB32 | SLJIT_SET_U, SLJIT_UNUSED, 0, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_MEM1(SLJIT_S0), 0); 2568 sljit_emit_op2(compiler, SLJIT_MUL, SLJIT_UNUSED, 0, SLJIT_S0, 0, SLJIT_MEM1(SLJIT_S0), 0); 2569 sljit_emit_op2(compiler, SLJIT_SHL | SLJIT_SET_E, SLJIT_UNUSED, 0, SLJIT_S3, 0, SLJIT_R2, 0); 2570 sljit_emit_op2(compiler, SLJIT_LSHR | SLJIT_SET_E, SLJIT_UNUSED, 0, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_IMM, 5); 2571 sljit_emit_op2(compiler, SLJIT_AND, SLJIT_UNUSED, 0, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_IMM, 0xff); 2572 sljit_emit_op1(compiler, SLJIT_NOT32 | SLJIT_SET_E, SLJIT_UNUSED, 0, SLJIT_S1, 0); 2573 2574 /* Testing that any change happens. */ 2575 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_R1, 0); 2576 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_R2, 0); 2577 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_R3, 0); 2578 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_R4, 0); 2579 sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_S1, 0, SLJIT_S1, 0); 2580 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_S1, 0); 2581 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_S2, 0); 2582 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_S3, 0); 2583 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0, SLJIT_S4, 0); 2584 2585 sljit_emit_return(compiler, SLJIT_UNUSED, 0, 0); 2586 2587 code.code = sljit_generate_code(compiler); 2588 CHECK(compiler); 2589 sljit_free_compiler(compiler); 2590 2591 code.func1((sljit_sw)&buf); 2592 FAILED(buf[0] != 9, "test30 case 1 failed\n"); 2593 2594 sljit_free_code(code.code); 2595 successful_tests++; 2596 } 2597 2598 static void test31(void) 2599 { 2600 /* Integer mul and set flags. */ 2601 executable_code code; 2602 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 2603 sljit_sw buf[12]; 2604 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 2605 sljit_sw big_word = SLJIT_W(0x7fffffff00000000); 2606 sljit_sw big_word2 = SLJIT_W(0x7fffffff00000012); 2607 #else 2608 sljit_sw big_word = 0x7fffffff; 2609 sljit_sw big_word2 = 0x00000012; 2610 #endif 2611 2612 if (verbose) 2613 printf("Run test31\n"); 2614 2615 buf[0] = 3; 2616 buf[1] = 3; 2617 buf[2] = 3; 2618 buf[3] = 3; 2619 buf[4] = 3; 2620 buf[5] = 3; 2621 buf[6] = 3; 2622 buf[7] = 3; 2623 buf[8] = 3; 2624 buf[9] = 3; 2625 buf[10] = 3; 2626 buf[11] = 3; 2627 2628 FAILED(!compiler, "cannot create compiler\n"); 2629 2630 sljit_emit_enter(compiler, 0, 1, 3, 5, 0, 0, 0); 2631 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0); 2632 sljit_emit_op2(compiler, SLJIT_MUL | SLJIT_SET_O, SLJIT_UNUSED, 0, SLJIT_R1, 0, SLJIT_IMM, -45); 2633 cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_MUL_NOT_OVERFLOW); 2634 cond_set(compiler, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_MUL_OVERFLOW); 2635 2636 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, big_word); 2637 sljit_emit_op2(compiler, SLJIT_MUL | SLJIT_SET_O, SLJIT_R2, 0, SLJIT_S2, 0, SLJIT_IMM, -2); 2638 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 33); /* Should not change flags. */ 2639 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0); /* Should not change flags. */ 2640 cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_MUL_OVERFLOW); 2641 cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_MUL_NOT_OVERFLOW); 2642 2643 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_S3, 0, SLJIT_IMM, 0x3f6b0); 2644 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_S4, 0, SLJIT_IMM, 0x2a783); 2645 sljit_emit_op2(compiler, SLJIT_MUL32 | SLJIT_SET_O, SLJIT_R1, 0, SLJIT_S3, 0, SLJIT_S4, 0); 2646 cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_MUL_OVERFLOW32); 2647 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_R1, 0); 2648 2649 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, big_word2); 2650 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R2, 0, SLJIT_R1, 0); 2651 sljit_emit_op2(compiler, SLJIT_MUL32 | SLJIT_SET_O, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, 23); 2652 cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_sw), SLJIT_MUL_OVERFLOW32); 2653 2654 sljit_emit_op2(compiler, SLJIT_MUL32 | SLJIT_SET_O, SLJIT_UNUSED, 0, SLJIT_R2, 0, SLJIT_IMM, -23); 2655 cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_sw), SLJIT_MUL_NOT_OVERFLOW32); 2656 sljit_emit_op2(compiler, SLJIT_MUL | SLJIT_SET_O, SLJIT_UNUSED, 0, SLJIT_R2, 0, SLJIT_IMM, -23); 2657 cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_sw), SLJIT_MUL_NOT_OVERFLOW); 2658 2659 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 67); 2660 sljit_emit_op2(compiler, SLJIT_MUL | SLJIT_SET_O, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, -23); 2661 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 9 * sizeof(sljit_sw), SLJIT_R1, 0); 2662 2663 sljit_emit_return(compiler, SLJIT_UNUSED, 0, 0); 2664 2665 code.code = sljit_generate_code(compiler); 2666 CHECK(compiler); 2667 sljit_free_compiler(compiler); 2668 2669 code.func1((sljit_sw)&buf); 2670 2671 FAILED(buf[0] != 1, "test31 case 1 failed\n"); 2672 FAILED(buf[1] != 2, "test31 case 2 failed\n"); 2673 /* Qemu issues for 64 bit muls. */ 2674 #if !(defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 2675 FAILED(buf[2] != 1, "test31 case 3 failed\n"); 2676 FAILED(buf[3] != 2, "test31 case 4 failed\n"); 2677 #endif 2678 FAILED(buf[4] != 1, "test31 case 5 failed\n"); 2679 FAILED((buf[5] & 0xffffffff) != 0x85540c10, "test31 case 6 failed\n"); 2680 FAILED(buf[6] != 2, "test31 case 7 failed\n"); 2681 FAILED(buf[7] != 1, "test31 case 8 failed\n"); 2682 #if !(defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 2683 FAILED(buf[8] != 1, "test31 case 9 failed\n"); 2684 #endif 2685 FAILED(buf[9] != -1541, "test31 case 10 failed\n"); 2686 2687 sljit_free_code(code.code); 2688 successful_tests++; 2689 } 2690 2691 static void test32(void) 2692 { 2693 /* Floating point set flags. */ 2694 executable_code code; 2695 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 2696 2697 sljit_sw buf[16]; 2698 union { 2699 sljit_f64 value; 2700 struct { 2701 sljit_s32 value1; 2702 sljit_s32 value2; 2703 } u; 2704 } dbuf[4]; 2705 2706 if (verbose) 2707 printf("Run test32\n"); 2708 2709 buf[0] = 5; 2710 buf[1] = 5; 2711 buf[2] = 5; 2712 buf[3] = 5; 2713 buf[4] = 5; 2714 buf[5] = 5; 2715 buf[6] = 5; 2716 buf[7] = 5; 2717 buf[8] = 5; 2718 buf[9] = 5; 2719 buf[10] = 5; 2720 buf[11] = 5; 2721 buf[12] = 5; 2722 buf[13] = 5; 2723 buf[14] = 5; 2724 buf[15] = 5; 2725 2726 /* Two NaNs */ 2727 dbuf[0].u.value1 = 0x7fffffff; 2728 dbuf[0].u.value2 = 0x7fffffff; 2729 dbuf[1].u.value1 = 0x7fffffff; 2730 dbuf[1].u.value2 = 0x7fffffff; 2731 dbuf[2].value = -13.0; 2732 dbuf[3].value = 27.0; 2733 2734 if (!sljit_is_fpu_available()) { 2735 if (verbose) 2736 printf("no fpu available, test32 skipped\n"); 2737 successful_tests++; 2738 if (compiler) 2739 sljit_free_compiler(compiler); 2740 return; 2741 } 2742 2743 FAILED(!compiler, "cannot create compiler\n"); 2744 SLJIT_ASSERT(sizeof(sljit_f64) == 8 && sizeof(sljit_s32) == 4 && sizeof(dbuf[0]) == 8); 2745 2746 sljit_emit_enter(compiler, 0, 2, 1, 2, 4, 0, 0); 2747 2748 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S1), 0); 2749 sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_E, SLJIT_MEM1(SLJIT_S1), 3 * sizeof(sljit_f64), SLJIT_FR0, 0); 2750 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S1), 2 * sizeof(sljit_f64)); 2751 cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_UNORDERED_F64); 2752 cond_set(compiler, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_ORDERED_F64); 2753 2754 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S1), 3 * sizeof(sljit_f64)); 2755 sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_E | SLJIT_SET_S, SLJIT_FR1, 0, SLJIT_FR2, 0); 2756 cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_UNORDERED_F64); 2757 cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_ORDERED_F64); 2758 cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_LESS_F64); 2759 cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_GREATER_EQUAL_F64); 2760 cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_sw), SLJIT_GREATER_F64); 2761 cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_sw), SLJIT_LESS_EQUAL_F64); 2762 cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_sw), SLJIT_EQUAL_F64); 2763 cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 9 * sizeof(sljit_sw), SLJIT_NOT_EQUAL_F64); 2764 2765 sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_E, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S1), 3 * sizeof(sljit_f64)); 2766 sljit_emit_fop2(compiler, SLJIT_ADD_F64, SLJIT_FR3, 0, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_f64)); 2767 cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 10 * sizeof(sljit_sw), SLJIT_UNORDERED_F64); 2768 cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 11 * sizeof(sljit_sw), SLJIT_EQUAL_F64); 2769 2770 sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_S, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_f64), SLJIT_FR0, 0); 2771 cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 12 * sizeof(sljit_sw), SLJIT_ORDERED_F64); 2772 2773 sljit_emit_fop1(compiler, SLJIT_CMP_F64 | SLJIT_SET_S, SLJIT_FR3, 0, SLJIT_FR2, 0); 2774 sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S1), 0); 2775 cond_set(compiler, SLJIT_MEM1(SLJIT_S0), 13 * sizeof(sljit_sw), SLJIT_UNORDERED_F64); 2776 2777 sljit_emit_return(compiler, SLJIT_UNUSED, 0, 0); 2778 2779 code.code = sljit_generate_code(compiler); 2780 CHECK(compiler); 2781 sljit_free_compiler(compiler); 2782 2783 code.func2((sljit_sw)&buf, (sljit_sw)&dbuf); 2784 2785 FAILED(buf[0] != 1, "test32 case 1 failed\n"); 2786 FAILED(buf[1] != 2, "test32 case 2 failed\n"); 2787 FAILED(buf[2] != 2, "test32 case 3 failed\n"); 2788 FAILED(buf[3] != 1, "test32 case 4 failed\n"); 2789 FAILED(buf[4] != 1, "test32 case 5 failed\n"); 2790 FAILED(buf[5] != 2, "test32 case 6 failed\n"); 2791 FAILED(buf[6] != 2, "test32 case 7 failed\n"); 2792 FAILED(buf[7] != 1, "test32 case 8 failed\n"); 2793 FAILED(buf[8] != 2, "test32 case 9 failed\n"); 2794 FAILED(buf[9] != 1, "test32 case 10 failed\n"); 2795 FAILED(buf[10] != 2, "test32 case 11 failed\n"); 2796 FAILED(buf[11] != 1, "test32 case 12 failed\n"); 2797 FAILED(buf[12] != 2, "test32 case 13 failed\n"); 2798 FAILED(buf[13] != 1, "test32 case 14 failed\n"); 2799 2800 sljit_free_code(code.code); 2801 successful_tests++; 2802 } 2803 2804 static void test33(void) 2805 { 2806 /* Test keep flags. */ 2807 executable_code code; 2808 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 2809 sljit_sw buf[7]; 2810 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 2811 sljit_sw big_word = SLJIT_W(0x8000000000000003); 2812 #else 2813 sljit_sw big_word = 0x80000003; 2814 #endif 2815 2816 if (verbose) 2817 printf("Run test33\n"); 2818 2819 buf[0] = 3; 2820 buf[1] = 3; 2821 buf[2] = 3; 2822 buf[3] = 3; 2823 buf[4] = 3; 2824 buf[5] = 3; 2825 buf[6] = 3; 2826 2827 FAILED(!compiler, "cannot create compiler\n"); 2828 2829 sljit_emit_enter(compiler, 0, 1, 3, 3, 0, 0, 0); 2830 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, big_word); 2831 sljit_emit_op2(compiler, SLJIT_ADD | SLJIT_SET_E | SLJIT_SET_C, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, big_word); 2832 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R1, 0); 2833 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 8); 2834 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_KEEP_FLAGS, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 8); 2835 sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_UNUSED, 0, SLJIT_NOT_ZERO); 2836 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0); 2837 sljit_emit_op2(compiler, SLJIT_ADDC | SLJIT_KEEP_FLAGS, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, 0); 2838 sljit_emit_op2(compiler, SLJIT_ADDC, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_R0, 0, SLJIT_IMM, 7); 2839 2840 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 8); 2841 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, SLJIT_R0, 0, SLJIT_IMM, 8); 2842 sljit_emit_op2(compiler, SLJIT_SHL | SLJIT_KEEP_FLAGS, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw)); 2843 sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_UNUSED, 0, SLJIT_EQUAL); 2844 2845 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_IMM, 0x124); 2846 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 2); 2847 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, SLJIT_R0, 0, SLJIT_IMM, 1); 2848 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_KEEP_FLAGS, SLJIT_UNUSED, 0, SLJIT_R0, 0, SLJIT_R0, 0); 2849 sljit_emit_op_flags(compiler, SLJIT_OR, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_NOT_EQUAL); 2850 2851 /* PowerPC specific test. */ 2852 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -1); 2853 sljit_emit_op2(compiler, SLJIT_ADD | SLJIT_SET_C, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 2); 2854 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0x80); 2855 sljit_emit_op2(compiler, SLJIT_ASHR | SLJIT_KEEP_FLAGS, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 1); 2856 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0); 2857 sljit_emit_op2(compiler, SLJIT_ADDC, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_sw), SLJIT_R1, 0, SLJIT_IMM, 0); 2858 2859 sljit_emit_return(compiler, SLJIT_UNUSED, 0, 0); 2860 2861 code.code = sljit_generate_code(compiler); 2862 CHECK(compiler); 2863 sljit_free_compiler(compiler); 2864 2865 code.func1((sljit_sw)&buf); 2866 2867 FAILED(buf[0] != 6, "test33 case 1 failed\n"); 2868 FAILED(buf[1] != 1, "test33 case 2 failed\n"); 2869 FAILED(buf[2] != 8, "test33 case 3 failed\n"); 2870 FAILED(buf[3] != 16, "test33 case 4 failed\n"); 2871 FAILED(buf[4] != 1, "test33 case 5 failed\n"); 2872 FAILED(buf[5] != 0x125, "test33 case 6 failed\n"); 2873 FAILED(buf[6] != 1, "test33 case 7 failed\n"); 2874 2875 sljit_free_code(code.code); 2876 successful_tests++; 2877 } 2878 2879 static void test34(void) 2880 { 2881 /* Test fast calls. */ 2882 executable_code codeA; 2883 executable_code codeB; 2884 executable_code codeC; 2885 executable_code codeD; 2886 executable_code codeE; 2887 executable_code codeF; 2888 struct sljit_compiler* compiler; 2889 struct sljit_jump *jump; 2890 struct sljit_label* label; 2891 sljit_uw addr; 2892 sljit_p buf[2]; 2893 2894 if (verbose) 2895 printf("Run test34\n"); 2896 2897 buf[0] = 0; 2898 buf[1] = 0; 2899 2900 /* A */ 2901 compiler = sljit_create_compiler(NULL); 2902 FAILED(!compiler, "cannot create compiler\n"); 2903 sljit_set_context(compiler, 0, 1, 5, 5, 0, 0, 2 * sizeof(sljit_p)); 2904 2905 sljit_emit_fast_enter(compiler, SLJIT_R1, 0); 2906 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 4); 2907 sljit_emit_fast_return(compiler, SLJIT_R1, 0); 2908 2909 codeA.code = sljit_generate_code(compiler); 2910 CHECK(compiler); 2911 sljit_free_compiler(compiler); 2912 2913 /* B */ 2914 compiler = sljit_create_compiler(NULL); 2915 FAILED(!compiler, "cannot create compiler\n"); 2916 sljit_set_context(compiler, 0, 1, 5, 5, 0, 0, 2 * sizeof(sljit_p)); 2917 2918 sljit_emit_fast_enter(compiler, SLJIT_R4, 0); 2919 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 6); 2920 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, SLJIT_FUNC_OFFSET(codeA.code)); 2921 sljit_emit_ijump(compiler, SLJIT_FAST_CALL, SLJIT_R1, 0); 2922 sljit_emit_fast_return(compiler, SLJIT_R4, 0); 2923 2924 codeB.code = sljit_generate_code(compiler); 2925 CHECK(compiler); 2926 sljit_free_compiler(compiler); 2927 2928 /* C */ 2929 compiler = sljit_create_compiler(NULL); 2930 FAILED(!compiler, "cannot create compiler\n"); 2931 sljit_set_context(compiler, 0, 1, 5, 5, 0, 0, 2 * sizeof(sljit_p)); 2932 2933 sljit_emit_fast_enter(compiler, SLJIT_MEM1(SLJIT_SP), sizeof(sljit_p)); 2934 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 8); 2935 jump = sljit_emit_jump(compiler, SLJIT_REWRITABLE_JUMP | SLJIT_FAST_CALL); 2936 sljit_set_target(jump, SLJIT_FUNC_OFFSET(codeB.code)); 2937 sljit_emit_fast_return(compiler, SLJIT_MEM1(SLJIT_SP), sizeof(sljit_p)); 2938 2939 codeC.code = sljit_generate_code(compiler); 2940 CHECK(compiler); 2941 sljit_free_compiler(compiler); 2942 2943 /* D */ 2944 compiler = sljit_create_compiler(NULL); 2945 FAILED(!compiler, "cannot create compiler\n"); 2946 sljit_set_context(compiler, 0, 1, 5, 5, 0, 0, 2 * sizeof(sljit_p)); 2947 2948 sljit_emit_fast_enter(compiler, SLJIT_MEM1(SLJIT_SP), 0); 2949 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 10); 2950 sljit_emit_ijump(compiler, SLJIT_FAST_CALL, SLJIT_IMM, SLJIT_FUNC_OFFSET(codeC.code)); 2951 sljit_emit_fast_return(compiler, SLJIT_MEM1(SLJIT_SP), 0); 2952 2953 codeD.code = sljit_generate_code(compiler); 2954 CHECK(compiler); 2955 sljit_free_compiler(compiler); 2956 2957 /* E */ 2958 compiler = sljit_create_compiler(NULL); 2959 FAILED(!compiler, "cannot create compiler\n"); 2960 sljit_set_context(compiler, 0, 1, 5, 5, 0, 0, 2 * sizeof(sljit_p)); 2961 2962 sljit_emit_fast_enter(compiler, SLJIT_MEM1(SLJIT_S0), 0); 2963 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 12); 2964 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_p), SLJIT_IMM, SLJIT_FUNC_OFFSET(codeD.code)); 2965 sljit_emit_ijump(compiler, SLJIT_FAST_CALL, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_p)); 2966 sljit_emit_fast_return(compiler, SLJIT_MEM1(SLJIT_S0), 0); 2967 2968 codeE.code = sljit_generate_code(compiler); 2969 CHECK(compiler); 2970 sljit_free_compiler(compiler); 2971 2972 /* F */ 2973 compiler = sljit_create_compiler(NULL); 2974 FAILED(!compiler, "cannot create compiler\n"); 2975 2976 sljit_emit_enter(compiler, 0, 1, 5, 5, 0, 0, 2 * sizeof(sljit_p)); 2977 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0); 2978 sljit_emit_ijump(compiler, SLJIT_FAST_CALL, SLJIT_IMM, SLJIT_FUNC_OFFSET(codeE.code)); 2979 label = sljit_emit_label(compiler); 2980 sljit_emit_return(compiler, SLJIT_MOV, SLJIT_R0, 0); 2981 2982 codeF.code = sljit_generate_code(compiler); 2983 CHECK(compiler); 2984 addr = sljit_get_label_addr(label); 2985 sljit_free_compiler(compiler); 2986 2987 FAILED(codeF.func1((sljit_sw)&buf) != 40, "test34 case 1 failed\n"); 2988 FAILED(buf[0] != addr - SLJIT_RETURN_ADDRESS_OFFSET, "test34 case 2 failed\n"); 2989 2990 sljit_free_code(codeA.code); 2991 sljit_free_code(codeB.code); 2992 sljit_free_code(codeC.code); 2993 sljit_free_code(codeD.code); 2994 sljit_free_code(codeE.code); 2995 sljit_free_code(codeF.code); 2996 successful_tests++; 2997 } 2998 2999 static void test35(void) 3000 { 3001 /* More complicated tests for fast calls. */ 3002 executable_code codeA; 3003 executable_code codeB; 3004 executable_code codeC; 3005 struct sljit_compiler* compiler; 3006 struct sljit_jump *jump; 3007 struct sljit_label* label; 3008 sljit_uw return_addr, jump_addr; 3009 sljit_p buf[1]; 3010 3011 if (verbose) 3012 printf("Run test35\n"); 3013 3014 buf[0] = 0; 3015 3016 /* A */ 3017 compiler = sljit_create_compiler(NULL); 3018 FAILED(!compiler, "cannot create compiler\n"); 3019 sljit_set_context(compiler, 0, 0, 2, 2, 0, 0, 0); 3020 3021 sljit_emit_fast_enter(compiler, SLJIT_MEM0(), (sljit_sw)&buf[0]); 3022 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 5); 3023 jump = sljit_emit_jump(compiler, SLJIT_REWRITABLE_JUMP | SLJIT_FAST_CALL); 3024 sljit_set_target(jump, 0); 3025 label = sljit_emit_label(compiler); 3026 sljit_emit_fast_return(compiler, SLJIT_MEM0(), (sljit_sw)&buf[0]); 3027 3028 codeA.code = sljit_generate_code(compiler); 3029 CHECK(compiler); 3030 return_addr = sljit_get_label_addr(label) - SLJIT_RETURN_ADDRESS_OFFSET; 3031 jump_addr = sljit_get_jump_addr(jump); 3032 sljit_free_compiler(compiler); 3033 3034 /* B */ 3035 compiler = sljit_create_compiler(NULL); 3036 FAILED(!compiler, "cannot create compiler\n"); 3037 sljit_set_context(compiler, 0, 0, 2, 2, 0, 0, 0); 3038 3039 sljit_emit_fast_enter(compiler, SLJIT_UNUSED, 0); 3040 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 7); 3041 sljit_emit_fast_return(compiler, SLJIT_IMM, return_addr); 3042 3043 codeB.code = sljit_generate_code(compiler); 3044 CHECK(compiler); 3045 sljit_free_compiler(compiler); 3046 sljit_set_jump_addr(jump_addr, SLJIT_FUNC_OFFSET(codeB.code)); 3047 3048 /* C */ 3049 compiler = sljit_create_compiler(NULL); 3050 FAILED(!compiler, "cannot create compiler\n"); 3051 3052 sljit_emit_enter(compiler, 0, 0, 2, 2, 0, 0, 0); 3053 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0); 3054 sljit_emit_ijump(compiler, SLJIT_FAST_CALL, SLJIT_IMM, SLJIT_FUNC_OFFSET(codeA.code)); 3055 label = sljit_emit_label(compiler); 3056 sljit_emit_return(compiler, SLJIT_MOV, SLJIT_R0, 0); 3057 3058 codeC.code = sljit_generate_code(compiler); 3059 CHECK(compiler); 3060 return_addr = sljit_get_label_addr(label); 3061 sljit_free_compiler(compiler); 3062 3063 FAILED(codeC.func0() != 12, "test35 case 1 failed\n"); 3064 FAILED(buf[0] != return_addr - SLJIT_RETURN_ADDRESS_OFFSET, "test35 case 2 failed\n"); 3065 3066 sljit_free_code(codeA.code); 3067 sljit_free_code(codeB.code); 3068 sljit_free_code(codeC.code); 3069 successful_tests++; 3070 } 3071 3072 static sljit_s32 cmp_test(struct sljit_compiler *compiler, sljit_s32 type, sljit_s32 src1, sljit_sw src1w, sljit_s32 src2, sljit_sw src2w) 3073 { 3074 /* 2 = true, 1 = false */ 3075 struct sljit_jump* jump; 3076 struct sljit_label* label; 3077 3078 if (sljit_emit_op1(compiler, SLJIT_MOVU_U8, SLJIT_MEM1(SLJIT_S0), 1, SLJIT_IMM, 2)) 3079 return compiler->error; 3080 jump = sljit_emit_cmp(compiler, type, src1, src1w, src2, src2w); 3081 if (!jump) 3082 return compiler->error; 3083 if (sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_IMM, 1)) 3084 return compiler->error; 3085 label = sljit_emit_label(compiler); 3086 if (!label) 3087 return compiler->error; 3088 sljit_set_label(jump, label); 3089 return SLJIT_SUCCESS; 3090 } 3091 3092 #define TEST_CASES (7 + 10 + 12 + 11 + 4) 3093 static void test36(void) 3094 { 3095 /* Compare instruction. */ 3096 executable_code code; 3097 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 3098 3099 sljit_s8 buf[TEST_CASES]; 3100 sljit_s8 compare_buf[TEST_CASES] = { 3101 1, 1, 2, 2, 1, 2, 2, 3102 1, 1, 2, 2, 2, 1, 2, 2, 1, 1, 3103 2, 2, 2, 1, 2, 2, 2, 2, 1, 1, 2, 2, 3104 2, 1, 2, 1, 1, 1, 2, 1, 2, 1, 2, 3105 2, 1, 1, 2 3106 }; 3107 sljit_sw data[4]; 3108 sljit_s32 i; 3109 3110 if (verbose) 3111 printf("Run test36\n"); 3112 3113 FAILED(!compiler, "cannot create compiler\n"); 3114 for (i = 0; i < TEST_CASES; ++i) 3115 buf[i] = 100; 3116 data[0] = 32; 3117 data[1] = -9; 3118 data[2] = 43; 3119 data[3] = -13; 3120 3121 sljit_emit_enter(compiler, 0, 2, 3, 2, 0, 0, 0); 3122 sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_S0, 0, SLJIT_S0, 0, SLJIT_IMM, 1); 3123 3124 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 13); 3125 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 15); 3126 cmp_test(compiler, SLJIT_EQUAL, SLJIT_IMM, 9, SLJIT_R0, 0); 3127 cmp_test(compiler, SLJIT_EQUAL, SLJIT_R0, 0, SLJIT_R1, 0); 3128 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 3); 3129 cmp_test(compiler, SLJIT_EQUAL, SLJIT_MEM2(SLJIT_S1, SLJIT_R0), SLJIT_WORD_SHIFT, SLJIT_IMM, -13); 3130 cmp_test(compiler, SLJIT_NOT_EQUAL, SLJIT_IMM, 0, SLJIT_R0, 0); 3131 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0); 3132 cmp_test(compiler, SLJIT_NOT_EQUAL | SLJIT_REWRITABLE_JUMP, SLJIT_IMM, 0, SLJIT_R0, 0); 3133 cmp_test(compiler, SLJIT_EQUAL, SLJIT_MEM2(SLJIT_S1, SLJIT_R0), SLJIT_WORD_SHIFT, SLJIT_MEM2(SLJIT_S1, SLJIT_R0), SLJIT_WORD_SHIFT); 3134 cmp_test(compiler, SLJIT_EQUAL | SLJIT_REWRITABLE_JUMP, SLJIT_R0, 0, SLJIT_IMM, 0); 3135 3136 cmp_test(compiler, SLJIT_SIG_LESS, SLJIT_MEM1(SLJIT_S1), 0, SLJIT_IMM, 0); 3137 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -8); 3138 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0); 3139 cmp_test(compiler, SLJIT_SIG_GREATER, SLJIT_R0, 0, SLJIT_IMM, 0); 3140 cmp_test(compiler, SLJIT_SIG_LESS_EQUAL, SLJIT_R0, 0, SLJIT_IMM, 0); 3141 cmp_test(compiler, SLJIT_SIG_LESS | SLJIT_REWRITABLE_JUMP, SLJIT_R0, 0, SLJIT_IMM, 0); 3142 cmp_test(compiler, SLJIT_SIG_GREATER_EQUAL, SLJIT_R1, 0, SLJIT_IMM, 0); 3143 cmp_test(compiler, SLJIT_SIG_GREATER, SLJIT_IMM, 0, SLJIT_MEM1(SLJIT_S1), 2 * sizeof(sljit_sw)); 3144 cmp_test(compiler, SLJIT_SIG_LESS_EQUAL, SLJIT_IMM, 0, SLJIT_R1, 0); 3145 cmp_test(compiler, SLJIT_SIG_LESS, SLJIT_IMM, 0, SLJIT_MEM1(SLJIT_S1), 2 * sizeof(sljit_sw)); 3146 cmp_test(compiler, SLJIT_SIG_LESS, SLJIT_IMM, 0, SLJIT_MEM1(SLJIT_S1), 3 * sizeof(sljit_sw)); 3147 cmp_test(compiler, SLJIT_SIG_LESS | SLJIT_REWRITABLE_JUMP, SLJIT_IMM, 0, SLJIT_MEM1(SLJIT_S1), 3 * sizeof(sljit_sw)); 3148 3149 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 8); 3150 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0); 3151 cmp_test(compiler, SLJIT_LESS, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_sw)); 3152 cmp_test(compiler, SLJIT_GREATER_EQUAL, SLJIT_R0, 0, SLJIT_IMM, 8); 3153 cmp_test(compiler, SLJIT_LESS, SLJIT_R0, 0, SLJIT_IMM, -10); 3154 cmp_test(compiler, SLJIT_LESS, SLJIT_R0, 0, SLJIT_IMM, 8); 3155 cmp_test(compiler, SLJIT_GREATER_EQUAL, SLJIT_IMM, 8, SLJIT_R1, 0); 3156 cmp_test(compiler, SLJIT_GREATER_EQUAL | SLJIT_REWRITABLE_JUMP, SLJIT_IMM, 8, SLJIT_R1, 0); 3157 cmp_test(compiler, SLJIT_GREATER, SLJIT_IMM, 8, SLJIT_R1, 0); 3158 cmp_test(compiler, SLJIT_LESS_EQUAL, SLJIT_IMM, 7, SLJIT_R0, 0); 3159 cmp_test(compiler, SLJIT_GREATER, SLJIT_IMM, 1, SLJIT_MEM1(SLJIT_S1), 3 * sizeof(sljit_sw)); 3160 cmp_test(compiler, SLJIT_LESS_EQUAL, SLJIT_R0, 0, SLJIT_R1, 0); 3161 cmp_test(compiler, SLJIT_GREATER, SLJIT_R0, 0, SLJIT_R1, 0); 3162 cmp_test(compiler, SLJIT_GREATER | SLJIT_REWRITABLE_JUMP, SLJIT_R0, 0, SLJIT_R1, 0); 3163 3164 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -3); 3165 cmp_test(compiler, SLJIT_SIG_LESS, SLJIT_R0, 0, SLJIT_R1, 0); 3166 cmp_test(compiler, SLJIT_SIG_GREATER_EQUAL, SLJIT_R0, 0, SLJIT_R1, 0); 3167 cmp_test(compiler, SLJIT_SIG_LESS, SLJIT_R0, 0, SLJIT_IMM, -1); 3168 cmp_test(compiler, SLJIT_SIG_GREATER_EQUAL, SLJIT_R0, 0, SLJIT_IMM, 1); 3169 cmp_test(compiler, SLJIT_SIG_LESS, SLJIT_MEM1(SLJIT_S1), 0, SLJIT_IMM, -1); 3170 cmp_test(compiler, SLJIT_SIG_LESS | SLJIT_REWRITABLE_JUMP, SLJIT_MEM1(SLJIT_S1), 0, SLJIT_IMM, -1); 3171 cmp_test(compiler, SLJIT_SIG_LESS_EQUAL, SLJIT_R0, 0, SLJIT_R1, 0); 3172 cmp_test(compiler, SLJIT_SIG_GREATER, SLJIT_R0, 0, SLJIT_R1, 0); 3173 cmp_test(compiler, SLJIT_SIG_LESS_EQUAL, SLJIT_IMM, -4, SLJIT_R0, 0); 3174 cmp_test(compiler, SLJIT_SIG_GREATER, SLJIT_IMM, -1, SLJIT_R1, 0); 3175 cmp_test(compiler, SLJIT_SIG_GREATER | SLJIT_REWRITABLE_JUMP, SLJIT_R1, 0, SLJIT_IMM, -1); 3176 3177 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 3178 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0xf00000004)); 3179 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_R0, 0); 3180 cmp_test(compiler, SLJIT_LESS32, SLJIT_R1, 0, SLJIT_IMM, 5); 3181 cmp_test(compiler, SLJIT_LESS, SLJIT_R0, 0, SLJIT_IMM, 5); 3182 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0xff0000004)); 3183 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_R0, 0); 3184 cmp_test(compiler, SLJIT_SIG_GREATER32, SLJIT_R1, 0, SLJIT_IMM, 5); 3185 cmp_test(compiler, SLJIT_SIG_GREATER, SLJIT_R0, 0, SLJIT_IMM, 5); 3186 #else 3187 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 4); 3188 cmp_test(compiler, SLJIT_LESS32, SLJIT_R0, 0, SLJIT_IMM, 5); 3189 cmp_test(compiler, SLJIT_GREATER32, SLJIT_R0, 0, SLJIT_IMM, 5); 3190 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 0xf0000004); 3191 cmp_test(compiler, SLJIT_SIG_GREATER32, SLJIT_R0, 0, SLJIT_IMM, 5); 3192 cmp_test(compiler, SLJIT_SIG_LESS32, SLJIT_R0, 0, SLJIT_IMM, 5); 3193 #endif 3194 3195 sljit_emit_return(compiler, SLJIT_UNUSED, 0, 0); 3196 3197 code.code = sljit_generate_code(compiler); 3198 CHECK(compiler); 3199 sljit_free_compiler(compiler); 3200 3201 code.func2((sljit_sw)&buf, (sljit_sw)&data); 3202 3203 for (i = 0; i < TEST_CASES; ++i) 3204 if (SLJIT_UNLIKELY(buf[i] != compare_buf[i])) { 3205 printf("test36 case %d failed\n", i + 1); 3206 return; 3207 } 3208 3209 sljit_free_code(code.code); 3210 successful_tests++; 3211 } 3212 #undef TEST_CASES 3213 3214 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 3215 #define BITN(n) (SLJIT_W(1) << (63 - (n))) 3216 #define RESN(n) (n) 3217 #else 3218 #define BITN(n) (1 << (31 - ((n) & 0x1f))) 3219 #define RESN(n) ((n) & 0x1f) 3220 #endif 3221 3222 static void test37(void) 3223 { 3224 /* Test count leading zeroes. */ 3225 executable_code code; 3226 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 3227 sljit_sw buf[15]; 3228 sljit_s32 ibuf[2]; 3229 sljit_s32 i; 3230 3231 if (verbose) 3232 printf("Run test37\n"); 3233 3234 FAILED(!compiler, "cannot create compiler\n"); 3235 3236 for (i = 0; i < 15; i++) 3237 buf[i] = -1; 3238 buf[3] = 0; 3239 buf[7] = BITN(13); 3240 ibuf[0] = -1; 3241 ibuf[1] = -1; 3242 sljit_emit_enter(compiler, 0, 2, 1, 2, 0, 0, 0); 3243 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, BITN(27)); 3244 sljit_emit_op1(compiler, SLJIT_CLZ, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0); 3245 sljit_emit_op1(compiler, SLJIT_CLZ | SLJIT_SET_E, SLJIT_R0, 0, SLJIT_IMM, BITN(47)); 3246 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_R0, 0); 3247 sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_UNUSED, 0, SLJIT_ZERO); 3248 sljit_emit_op1(compiler, SLJIT_CLZ, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw)); 3249 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -1); 3250 sljit_emit_op1(compiler, SLJIT_CLZ | SLJIT_SET_E, SLJIT_R0, 0, SLJIT_R0, 0); 3251 sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_UNUSED, 0, SLJIT_ZERO); 3252 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_R0, 0); 3253 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 0); 3254 sljit_emit_op1(compiler, SLJIT_CLZ32, SLJIT_MEM1(SLJIT_S1), 0, SLJIT_R0, 0); 3255 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -1); 3256 sljit_emit_op1(compiler, SLJIT_CLZ | SLJIT_SET_E, SLJIT_UNUSED, 0, SLJIT_R0, 0); 3257 sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_sw), SLJIT_UNUSED, 0, SLJIT_ZERO); 3258 sljit_emit_op1(compiler, SLJIT_CLZ | SLJIT_KEEP_FLAGS, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_sw)); 3259 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_sw), SLJIT_R0, 0); 3260 sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_sw), SLJIT_UNUSED, 0, SLJIT_NOT_ZERO); 3261 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, BITN(58)); 3262 sljit_emit_op1(compiler, SLJIT_CLZ, SLJIT_MEM1(SLJIT_S0), 9 * sizeof(sljit_sw), SLJIT_R0, 0); 3263 sljit_emit_op1(compiler, SLJIT_CLZ | SLJIT_SET_E, SLJIT_UNUSED, 0, SLJIT_MEM1(SLJIT_S0), 10 * sizeof(sljit_sw)); 3264 sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 10 * sizeof(sljit_sw), SLJIT_UNUSED, 0, SLJIT_NOT_ZERO); 3265 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0); 3266 sljit_emit_op1(compiler, SLJIT_CLZ, SLJIT_MEM1(SLJIT_S0), 11 * sizeof(sljit_sw), SLJIT_R0, 0); 3267 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 3268 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0xff08a00000)); 3269 #else 3270 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 0x08a00000); 3271 #endif 3272 sljit_emit_op1(compiler, SLJIT_CLZ32, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_s32), SLJIT_R0, 0); 3273 sljit_emit_op1(compiler, SLJIT_CLZ32, SLJIT_R0, 0, SLJIT_R0, 0); 3274 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 12 * sizeof(sljit_sw), SLJIT_R0, 0); 3275 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 3276 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0xffc8a00000)); 3277 #else 3278 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 0xc8a00000); 3279 #endif 3280 sljit_emit_op1(compiler, SLJIT_CLZ32 | SLJIT_SET_E, SLJIT_UNUSED, 0, SLJIT_R0, 0); 3281 sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 13 * sizeof(sljit_sw), SLJIT_UNUSED, 0, SLJIT_ZERO32); 3282 sljit_emit_op1(compiler, SLJIT_CLZ32 | SLJIT_SET_E, SLJIT_R0, 0, SLJIT_R0, 0); 3283 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 14 * sizeof(sljit_sw), SLJIT_R0, 0); 3284 3285 sljit_emit_return(compiler, SLJIT_UNUSED, 0, 0); 3286 3287 code.code = sljit_generate_code(compiler); 3288 CHECK(compiler); 3289 sljit_free_compiler(compiler); 3290 3291 code.func2((sljit_sw)&buf, (sljit_sw)&ibuf); 3292 FAILED(buf[0] != RESN(27), "test37 case 1 failed\n"); 3293 FAILED(buf[1] != RESN(47), "test37 case 2 failed\n"); 3294 FAILED(buf[2] != 0, "test37 case 3 failed\n"); 3295 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 3296 FAILED(buf[3] != 64, "test37 case 4 failed\n"); 3297 #else 3298 FAILED(buf[3] != 32, "test37 case 4 failed\n"); 3299 #endif 3300 FAILED(buf[4] != 1, "test37 case 5 failed\n"); 3301 FAILED(buf[5] != 0, "test37 case 6 failed\n"); 3302 FAILED(ibuf[0] != 32, "test37 case 7 failed\n"); 3303 FAILED(buf[6] != 1, "test37 case 8 failed\n"); 3304 FAILED(buf[7] != RESN(13), "test37 case 9 failed\n"); 3305 #if !(defined SLJIT_CONFIG_SPARC_32 && SLJIT_CONFIG_SPARC_32) 3306 FAILED(buf[8] != 0, "test37 case 10 failed\n"); 3307 #endif 3308 FAILED(buf[9] != RESN(58), "test37 case 11 failed\n"); 3309 FAILED(buf[10] != 0, "test37 case 12 failed\n"); 3310 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 3311 FAILED(buf[11] != 64, "test37 case 13 failed\n"); 3312 #else 3313 FAILED(buf[11] != 32, "test37 case 13 failed\n"); 3314 #endif 3315 FAILED(ibuf[1] != 4, "test37 case 14 failed\n"); 3316 FAILED((buf[12] & 0xffffffff) != 4, "test37 case 15 failed\n"); 3317 FAILED(buf[13] != 1, "test37 case 16 failed\n"); 3318 FAILED((buf[14] & 0xffffffff) != 0, "test37 case 17 failed\n"); 3319 3320 sljit_free_code(code.code); 3321 successful_tests++; 3322 } 3323 #undef BITN 3324 #undef RESN 3325 3326 static void test38(void) 3327 { 3328 #if (defined SLJIT_UTIL_STACK && SLJIT_UTIL_STACK) 3329 /* Test stack utility. */ 3330 executable_code code; 3331 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 3332 struct sljit_jump* alloc_fail; 3333 struct sljit_jump* alloc2_fail; 3334 struct sljit_jump* alloc3_fail; 3335 struct sljit_jump* jump; 3336 struct sljit_label* label; 3337 3338 if (verbose) 3339 printf("Run test38\n"); 3340 3341 FAILED(!compiler, "cannot create compiler\n"); 3342 3343 sljit_emit_enter(compiler, 0, 0, 3, 1, 0, 0, 0); 3344 3345 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 8192); 3346 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 65536); 3347 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, 0); 3348 sljit_emit_ijump(compiler, SLJIT_CALL3, SLJIT_IMM, SLJIT_FUNC_OFFSET(sljit_allocate_stack)); 3349 alloc_fail = sljit_emit_cmp(compiler, SLJIT_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 0); 3350 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_RETURN_REG, 0); 3351 3352 /* Write 8k data. */ 3353 sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), SLJIT_OFFSETOF(struct sljit_stack, base), SLJIT_IMM, sizeof(sljit_sw)); 3354 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, 8192); 3355 label = sljit_emit_label(compiler); 3356 sljit_emit_op1(compiler, SLJIT_MOVU, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_sw), SLJIT_IMM, -1); 3357 jump = sljit_emit_cmp(compiler, SLJIT_LESS, SLJIT_R0, 0, SLJIT_R1, 0); 3358 sljit_set_label(jump, label); 3359 3360 /* Grow stack. */ 3361 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_S0, 0); 3362 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_S0), SLJIT_OFFSETOF(struct sljit_stack, base), SLJIT_IMM, 65536); 3363 sljit_emit_ijump(compiler, SLJIT_CALL2, SLJIT_IMM, SLJIT_FUNC_OFFSET(sljit_stack_resize)); 3364 alloc2_fail = sljit_emit_cmp(compiler, SLJIT_NOT_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 0); 3365 3366 /* Write 64k data. */ 3367 sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), SLJIT_OFFSETOF(struct sljit_stack, base), SLJIT_IMM, sizeof(sljit_sw)); 3368 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_R0, 0, SLJIT_IMM, 65536); 3369 label = sljit_emit_label(compiler); 3370 sljit_emit_op1(compiler, SLJIT_MOVU, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_sw), SLJIT_IMM, -1); 3371 jump = sljit_emit_cmp(compiler, SLJIT_LESS, SLJIT_R0, 0, SLJIT_R1, 0); 3372 sljit_set_label(jump, label); 3373 3374 /* Shrink stack. */ 3375 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_S0, 0); 3376 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_S0), SLJIT_OFFSETOF(struct sljit_stack, base), SLJIT_IMM, 32768); 3377 sljit_emit_ijump(compiler, SLJIT_CALL2, SLJIT_IMM, SLJIT_FUNC_OFFSET(sljit_stack_resize)); 3378 alloc3_fail = sljit_emit_cmp(compiler, SLJIT_NOT_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 0); 3379 3380 /* Write 32k data. */ 3381 sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), SLJIT_OFFSETOF(struct sljit_stack, base), SLJIT_IMM, sizeof(sljit_sw)); 3382 sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_S0), SLJIT_OFFSETOF(struct sljit_stack, limit), SLJIT_IMM, sizeof(sljit_sw)); 3383 label = sljit_emit_label(compiler); 3384 sljit_emit_op1(compiler, SLJIT_MOVU, SLJIT_MEM1(SLJIT_R0), sizeof(sljit_sw), SLJIT_IMM, -1); 3385 jump = sljit_emit_cmp(compiler, SLJIT_LESS, SLJIT_R0, 0, SLJIT_R1, 0); 3386 sljit_set_label(jump, label); 3387 3388 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_S0, 0); 3389 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0); 3390 sljit_emit_ijump(compiler, SLJIT_CALL2, SLJIT_IMM, SLJIT_FUNC_OFFSET(sljit_free_stack)); 3391 3392 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, 1); 3393 label = sljit_emit_label(compiler); 3394 sljit_set_label(alloc_fail, label); 3395 sljit_set_label(alloc2_fail, label); 3396 sljit_set_label(alloc3_fail, label); 3397 sljit_emit_return(compiler, SLJIT_UNUSED, 0, 0); 3398 3399 code.code = sljit_generate_code(compiler); 3400 CHECK(compiler); 3401 sljit_free_compiler(compiler); 3402 3403 /* Just survive this. */ 3404 FAILED(code.func0() != 1, "test38 case 1 failed\n"); 3405 3406 sljit_free_code(code.code); 3407 #endif 3408 successful_tests++; 3409 } 3410 3411 static void test39(void) 3412 { 3413 /* Test error handling. */ 3414 executable_code code; 3415 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 3416 struct sljit_jump* jump; 3417 3418 if (verbose) 3419 printf("Run test39\n"); 3420 3421 FAILED(!compiler, "cannot create compiler\n"); 3422 3423 /* Such assignment should never happen in a regular program. */ 3424 compiler->error = -3967; 3425 3426 SLJIT_ASSERT(sljit_emit_enter(compiler, 0, 2, 5, 5, 6, 0, 32) == -3967); 3427 SLJIT_ASSERT(sljit_emit_return(compiler, SLJIT_MOV, SLJIT_R1, 0) == -3967); 3428 SLJIT_ASSERT(sljit_emit_op0(compiler, SLJIT_NOP) == -3967); 3429 SLJIT_ASSERT(sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM2(SLJIT_R0, SLJIT_R1), 1) == -3967); 3430 SLJIT_ASSERT(sljit_emit_op2(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_R0), 64, SLJIT_MEM1(SLJIT_S0), -64) == -3967); 3431 SLJIT_ASSERT(sljit_emit_fop1(compiler, SLJIT_ABS_F64, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_R1), 0) == -3967); 3432 SLJIT_ASSERT(sljit_emit_fop2(compiler, SLJIT_DIV_F64, SLJIT_FR2, 0, SLJIT_MEM2(SLJIT_R0, SLJIT_S0), 0, SLJIT_FR2, 0) == -3967); 3433 SLJIT_ASSERT(!sljit_emit_label(compiler)); 3434 jump = sljit_emit_jump(compiler, SLJIT_CALL3); 3435 SLJIT_ASSERT(!jump); 3436 sljit_set_label(jump, (struct sljit_label*)0x123450); 3437 sljit_set_target(jump, 0x123450); 3438 jump = sljit_emit_cmp(compiler, SLJIT_SIG_LESS_EQUAL, SLJIT_R0, 0, SLJIT_R1, 0); 3439 SLJIT_ASSERT(!jump); 3440 SLJIT_ASSERT(sljit_emit_ijump(compiler, SLJIT_JUMP, SLJIT_MEM1(SLJIT_R0), 8) == -3967); 3441 SLJIT_ASSERT(sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_UNUSED, 0, SLJIT_MUL_OVERFLOW) == -3967); 3442 SLJIT_ASSERT(!sljit_emit_const(compiler, SLJIT_R0, 0, 99)); 3443 3444 SLJIT_ASSERT(!compiler->labels && !compiler->jumps && !compiler->consts); 3445 SLJIT_ASSERT(!compiler->last_label && !compiler->last_jump && !compiler->last_const); 3446 SLJIT_ASSERT(!compiler->buf->next && !compiler->buf->used_size); 3447 SLJIT_ASSERT(!compiler->abuf->next && !compiler->abuf->used_size); 3448 3449 sljit_set_compiler_memory_error(compiler); 3450 FAILED(sljit_get_compiler_error(compiler) != -3967, "test39 case 1 failed\n"); 3451 3452 code.code = sljit_generate_code(compiler); 3453 FAILED(sljit_get_compiler_error(compiler) != -3967, "test39 case 2 failed\n"); 3454 FAILED(!!code.code, "test39 case 3 failed\n"); 3455 sljit_free_compiler(compiler); 3456 3457 compiler = sljit_create_compiler(NULL); 3458 FAILED(!compiler, "cannot create compiler\n"); 3459 3460 FAILED(sljit_get_compiler_error(compiler) != SLJIT_SUCCESS, "test39 case 4 failed\n"); 3461 sljit_set_compiler_memory_error(compiler); 3462 FAILED(sljit_get_compiler_error(compiler) != SLJIT_ERR_ALLOC_FAILED, "test39 case 5 failed\n"); 3463 sljit_free_compiler(compiler); 3464 3465 successful_tests++; 3466 } 3467 3468 static void test40(void) 3469 { 3470 /* Test emit_op_flags. */ 3471 executable_code code; 3472 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 3473 sljit_sw buf[10]; 3474 3475 if (verbose) 3476 printf("Run test40\n"); 3477 3478 FAILED(!compiler, "cannot create compiler\n"); 3479 buf[0] = -100; 3480 buf[1] = -100; 3481 buf[2] = -100; 3482 buf[3] = -8; 3483 buf[4] = -100; 3484 buf[5] = -100; 3485 buf[6] = 0; 3486 buf[7] = 0; 3487 buf[8] = -100; 3488 buf[9] = -100; 3489 3490 sljit_emit_enter(compiler, 0, 1, 3, 4, 0, 0, sizeof(sljit_sw)); 3491 3492 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -5); 3493 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_S, SLJIT_UNUSED, 0, SLJIT_IMM, -6, SLJIT_R0, 0); 3494 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0x123456); 3495 sljit_emit_op_flags(compiler, SLJIT_OR, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_SIG_LESS); 3496 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R1, 0); 3497 3498 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -13); 3499 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, SLJIT_IMM, -13, SLJIT_R0, 0); 3500 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), 0, SLJIT_IMM, 0); 3501 sljit_emit_op_flags(compiler, SLJIT_OR | SLJIT_KEEP_FLAGS, SLJIT_MEM1(SLJIT_SP), 0, SLJIT_MEM1(SLJIT_SP), 0, SLJIT_EQUAL); 3502 sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_UNUSED, 0, SLJIT_EQUAL); 3503 sljit_emit_op2(compiler, SLJIT_OR | SLJIT_KEEP_FLAGS, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_MEM1(SLJIT_SP), 0); 3504 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0); 3505 sljit_emit_op_flags(compiler, SLJIT_OR | SLJIT_SET_E, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_EQUAL); 3506 sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 2, SLJIT_UNUSED, 0, SLJIT_EQUAL); 3507 3508 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -13); 3509 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 3); 3510 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_S, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_R1, 0); 3511 sljit_emit_op_flags(compiler, SLJIT_OR, SLJIT_MEM2(SLJIT_S0, SLJIT_R1), SLJIT_WORD_SHIFT, SLJIT_MEM2(SLJIT_S0, SLJIT_R1), SLJIT_WORD_SHIFT, SLJIT_SIG_LESS); 3512 3513 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -8); 3514 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 33); 3515 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, SLJIT_R0, 0, SLJIT_R1, 0); 3516 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_IMM, 0); 3517 sljit_emit_op_flags(compiler, SLJIT_OR | SLJIT_SET_E, SLJIT_UNUSED, 0, SLJIT_UNUSED, 0, SLJIT_GREATER); 3518 sljit_emit_op_flags(compiler, SLJIT_OR | SLJIT_KEEP_FLAGS, SLJIT_S1, 0, SLJIT_S1, 0, SLJIT_EQUAL); 3519 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S3, 0, SLJIT_IMM, 0x88); 3520 sljit_emit_op_flags(compiler, SLJIT_OR | SLJIT_KEEP_FLAGS, SLJIT_S3, 0, SLJIT_S3, 0, SLJIT_NOT_EQUAL); 3521 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 4, SLJIT_S1, 0); 3522 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 5, SLJIT_S3, 0); 3523 3524 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0x84); 3525 sljit_emit_op2(compiler, SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, SLJIT_IMM, 0x180, SLJIT_R0, 0); 3526 sljit_emit_op_flags(compiler, SLJIT_OR | SLJIT_SET_E, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 6, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 6, SLJIT_EQUAL); 3527 sljit_emit_op_flags(compiler, SLJIT_OR, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 7, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 7, SLJIT_EQUAL); 3528 3529 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 1); 3530 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, SLJIT_R0, 0, SLJIT_IMM, 1); 3531 sljit_emit_op_flags(compiler, SLJIT_OR | SLJIT_SET_E, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_NOT_EQUAL); 3532 sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 8, SLJIT_UNUSED, 0, SLJIT_NOT_EQUAL); 3533 3534 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0x123456); 3535 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, SLJIT_R0, 0, SLJIT_IMM, 1); 3536 sljit_emit_op_flags(compiler, SLJIT_OR, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_GREATER); 3537 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw) * 9, SLJIT_R0, 0); 3538 3539 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), 0, SLJIT_IMM, 0xbaddead); 3540 sljit_emit_return(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), 0); 3541 3542 code.code = sljit_generate_code(compiler); 3543 CHECK(compiler); 3544 sljit_free_compiler(compiler); 3545 3546 FAILED(code.func1((sljit_sw)&buf) != 0xbaddead, "test40 case 1 failed\n"); 3547 FAILED(buf[0] != 0x123457, "test40 case 2 failed\n"); 3548 FAILED(buf[1] != 1, "test40 case 3 failed\n"); 3549 FAILED(buf[2] != 0, "test40 case 4 failed\n"); 3550 FAILED(buf[3] != -7, "test40 case 5 failed\n"); 3551 FAILED(buf[4] != 0, "test40 case 6 failed\n"); 3552 FAILED(buf[5] != 0x89, "test40 case 7 failed\n"); 3553 FAILED(buf[6] != 0, "test40 case 8 failed\n"); 3554 FAILED(buf[7] != 1, "test40 case 9 failed\n"); 3555 FAILED(buf[8] != 1, "test40 case 10 failed\n"); 3556 FAILED(buf[9] != 0x123457, "test40 case 11 failed\n"); 3557 3558 sljit_free_code(code.code); 3559 successful_tests++; 3560 } 3561 3562 static void test41(void) 3563 { 3564 /* Test inline assembly. */ 3565 executable_code code; 3566 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 3567 sljit_s32 i; 3568 sljit_f64 buf[3]; 3569 #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32) 3570 sljit_u8 inst[16]; 3571 #elif (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64) 3572 sljit_u8 inst[16]; 3573 sljit_s32 reg; 3574 #else 3575 sljit_u32 inst; 3576 #endif 3577 3578 if (verbose) 3579 printf("Run test41\n"); 3580 3581 for (i = 0; i < SLJIT_NUMBER_OF_REGISTERS; i++) { 3582 #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32) 3583 if (SLJIT_R(i) >= SLJIT_R3 && SLJIT_R(i) <= SLJIT_R6) { 3584 SLJIT_ASSERT(sljit_get_register_index(SLJIT_R(i)) == -1); 3585 continue; 3586 } 3587 #endif 3588 SLJIT_ASSERT(sljit_get_register_index(SLJIT_R(i)) >= 0 && sljit_get_register_index(SLJIT_R(i)) < 64); 3589 } 3590 3591 FAILED(!compiler, "cannot create compiler\n"); 3592 sljit_emit_enter(compiler, 0, 2, 3, 3, 0, 0, 0); 3593 3594 /* Returns with the sum of SLJIT_S0 and SLJIT_S1. */ 3595 #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32) 3596 /* lea SLJIT_RETURN_REG, [SLJIT_S0, SLJIT_S1] */ 3597 inst[0] = 0x48; 3598 inst[1] = 0x8d; 3599 inst[2] = 0x04 | ((sljit_get_register_index(SLJIT_RETURN_REG) & 0x7) << 3); 3600 inst[3] = (sljit_get_register_index(SLJIT_S0) & 0x7) 3601 | ((sljit_get_register_index(SLJIT_S1) & 0x7) << 3); 3602 sljit_emit_op_custom(compiler, inst, 4); 3603 #elif (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64) 3604 /* lea SLJIT_RETURN_REG, [SLJIT_S0, SLJIT_S1] */ 3605 inst[0] = 0x48; /* REX_W */ 3606 inst[1] = 0x8d; 3607 inst[2] = 0x04; 3608 reg = sljit_get_register_index(SLJIT_RETURN_REG); 3609 inst[2] |= ((reg & 0x7) << 3); 3610 if (reg > 7) 3611 inst[0] |= 0x04; /* REX_R */ 3612 reg = sljit_get_register_index(SLJIT_S0); 3613 inst[3] = reg & 0x7; 3614 if (reg > 7) 3615 inst[0] |= 0x01; /* REX_B */ 3616 reg = sljit_get_register_index(SLJIT_S1); 3617 inst[3] |= (reg & 0x7) << 3; 3618 if (reg > 7) 3619 inst[0] |= 0x02; /* REX_X */ 3620 sljit_emit_op_custom(compiler, inst, 4); 3621 #elif (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5) || (defined SLJIT_CONFIG_ARM_V7 && SLJIT_CONFIG_ARM_V7) 3622 /* add rd, rn, rm */ 3623 inst = 0xe0800000 | (sljit_get_register_index(SLJIT_RETURN_REG) << 12) 3624 | (sljit_get_register_index(SLJIT_S0) << 16) 3625 | sljit_get_register_index(SLJIT_S1); 3626 sljit_emit_op_custom(compiler, &inst, sizeof(sljit_u32)); 3627 #elif (defined SLJIT_CONFIG_ARM_THUMB2 && SLJIT_CONFIG_ARM_THUMB2) 3628 /* add rd, rn, rm */ 3629 inst = 0xeb000000 | (sljit_get_register_index(SLJIT_RETURN_REG) << 8) 3630 | (sljit_get_register_index(SLJIT_S0) << 16) 3631 | sljit_get_register_index(SLJIT_S1); 3632 sljit_emit_op_custom(compiler, &inst, sizeof(sljit_u32)); 3633 #elif (defined SLJIT_CONFIG_ARM_64 && SLJIT_CONFIG_ARM_64) 3634 /* add rd, rn, rm */ 3635 inst = 0x8b000000 | sljit_get_register_index(SLJIT_RETURN_REG) 3636 | (sljit_get_register_index(SLJIT_S0) << 5) 3637 | (sljit_get_register_index(SLJIT_S1) << 16); 3638 sljit_emit_op_custom(compiler, &inst, sizeof(sljit_u32)); 3639 #elif (defined SLJIT_CONFIG_PPC && SLJIT_CONFIG_PPC) 3640 /* add rD, rA, rB */ 3641 inst = (31 << 26) | (266 << 1) | (sljit_get_register_index(SLJIT_RETURN_REG) << 21) 3642 | (sljit_get_register_index(SLJIT_S0) << 16) 3643 | (sljit_get_register_index(SLJIT_S1) << 11); 3644 sljit_emit_op_custom(compiler, &inst, sizeof(sljit_u32)); 3645 #elif (defined SLJIT_CONFIG_MIPS_32 && SLJIT_CONFIG_MIPS_32) 3646 /* addu rd, rs, rt */ 3647 inst = 33 | (sljit_get_register_index(SLJIT_RETURN_REG) << 11) 3648 | (sljit_get_register_index(SLJIT_S0) << 21) 3649 | (sljit_get_register_index(SLJIT_S1) << 16); 3650 sljit_emit_op_custom(compiler, &inst, sizeof(sljit_u32)); 3651 #elif (defined SLJIT_CONFIG_MIPS_64 && SLJIT_CONFIG_MIPS_64) 3652 /* daddu rd, rs, rt */ 3653 inst = 45 | (sljit_get_register_index(SLJIT_RETURN_REG) << 11) 3654 | (sljit_get_register_index(SLJIT_S0) << 21) 3655 | (sljit_get_register_index(SLJIT_S1) << 16); 3656 sljit_emit_op_custom(compiler, &inst, sizeof(sljit_u32)); 3657 #elif (defined SLJIT_CONFIG_SPARC_32 && SLJIT_CONFIG_SPARC_32) 3658 /* add rd, rs1, rs2 */ 3659 inst = (0x2 << 30) | (sljit_get_register_index(SLJIT_RETURN_REG) << 25) 3660 | (sljit_get_register_index(SLJIT_S0) << 14) 3661 | sljit_get_register_index(SLJIT_S1); 3662 sljit_emit_op_custom(compiler, &inst, sizeof(sljit_u32)); 3663 #else 3664 inst = 0; 3665 sljit_emit_op_custom(compiler, &inst, 0); 3666 #endif 3667 3668 sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0); 3669 3670 code.code = sljit_generate_code(compiler); 3671 CHECK(compiler); 3672 sljit_free_compiler(compiler); 3673 3674 FAILED(code.func2(32, -11) != 21, "test41 case 1 failed\n"); 3675 FAILED(code.func2(1000, 234) != 1234, "test41 case 2 failed\n"); 3676 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 3677 FAILED(code.func2(SLJIT_W(0x20f0a04090c06070), SLJIT_W(0x020f0a04090c0607)) != SLJIT_W(0x22ffaa4499cc6677), "test41 case 3 failed\n"); 3678 #endif 3679 3680 sljit_free_code(code.code); 3681 3682 if (sljit_is_fpu_available()) { 3683 buf[0] = 13.5; 3684 buf[1] = -2.25; 3685 buf[2] = 0.0; 3686 3687 compiler = sljit_create_compiler(NULL); 3688 sljit_emit_enter(compiler, 0, 1, 0, 1, 2, 0, 0); 3689 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S0), 0); 3690 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64)); 3691 #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32) 3692 /* addsd x, xm */ 3693 inst[0] = 0xf2; 3694 inst[1] = 0x0f; 3695 inst[2] = 0x58; 3696 inst[3] = 0xc0 | (sljit_get_float_register_index(SLJIT_FR0) << 3) 3697 | sljit_get_float_register_index(SLJIT_FR1); 3698 sljit_emit_op_custom(compiler, inst, 4); 3699 #elif (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64) 3700 /* addsd x, xm */ 3701 if (sljit_get_float_register_index(SLJIT_FR0) > 7 || sljit_get_float_register_index(SLJIT_FR1) > 7) { 3702 inst[0] = 0; 3703 if (sljit_get_float_register_index(SLJIT_FR0) > 7) 3704 inst[0] |= 0x04; /* REX_R */ 3705 if (sljit_get_float_register_index(SLJIT_FR1) > 7) 3706 inst[0] |= 0x01; /* REX_B */ 3707 inst[1] = 0xf2; 3708 inst[2] = 0x0f; 3709 inst[3] = 0x58; 3710 inst[4] = 0xc0 | ((sljit_get_float_register_index(SLJIT_FR0) & 0x7) << 3) 3711 | (sljit_get_float_register_index(SLJIT_FR1) & 0x7); 3712 sljit_emit_op_custom(compiler, inst, 5); 3713 } 3714 else { 3715 inst[0] = 0xf2; 3716 inst[1] = 0x0f; 3717 inst[2] = 0x58; 3718 inst[3] = 0xc0 | (sljit_get_float_register_index(SLJIT_FR0) << 3) 3719 | sljit_get_float_register_index(SLJIT_FR1); 3720 sljit_emit_op_custom(compiler, inst, 4); 3721 } 3722 #elif (defined SLJIT_CONFIG_ARM_32 && SLJIT_CONFIG_ARM_32) 3723 /* vadd.f64 dd, dn, dm */ 3724 inst = 0xee300b00 | ((sljit_get_float_register_index(SLJIT_FR0) >> 1) << 12) 3725 | ((sljit_get_float_register_index(SLJIT_FR0) >> 1) << 16) 3726 | (sljit_get_float_register_index(SLJIT_FR1) >> 1); 3727 sljit_emit_op_custom(compiler, &inst, sizeof(sljit_u32)); 3728 #elif (defined SLJIT_CONFIG_ARM_64 && SLJIT_CONFIG_ARM_64) 3729 /* fadd rd, rn, rm */ 3730 inst = 0x1e602800 | sljit_get_float_register_index(SLJIT_FR0) 3731 | (sljit_get_float_register_index(SLJIT_FR0) << 5) 3732 | (sljit_get_float_register_index(SLJIT_FR1) << 16); 3733 sljit_emit_op_custom(compiler, &inst, sizeof(sljit_u32)); 3734 #elif (defined SLJIT_CONFIG_PPC && SLJIT_CONFIG_PPC) 3735 /* fadd frD, frA, frB */ 3736 inst = (63 << 26) | (21 << 1) | (sljit_get_float_register_index(SLJIT_FR0) << 21) 3737 | (sljit_get_float_register_index(SLJIT_FR0) << 16) 3738 | (sljit_get_float_register_index(SLJIT_FR1) << 11); 3739 sljit_emit_op_custom(compiler, &inst, sizeof(sljit_u32)); 3740 #elif (defined SLJIT_CONFIG_MIPS && SLJIT_CONFIG_MIPS) 3741 /* add.d fd, fs, ft */ 3742 inst = (17 << 26) | (17 << 21) | (sljit_get_float_register_index(SLJIT_FR0) << 6) 3743 | (sljit_get_float_register_index(SLJIT_FR0) << 11) 3744 | (sljit_get_float_register_index(SLJIT_FR1) << 16); 3745 sljit_emit_op_custom(compiler, &inst, sizeof(sljit_u32)); 3746 #elif (defined SLJIT_CONFIG_SPARC_32 && SLJIT_CONFIG_SPARC_32) 3747 /* faddd rd, rs1, rs2 */ 3748 inst = (0x2 << 30) | (0x34 << 19) | (0x42 << 5) 3749 | (sljit_get_float_register_index(SLJIT_FR0) << 25) 3750 | (sljit_get_float_register_index(SLJIT_FR0) << 14) 3751 | sljit_get_float_register_index(SLJIT_FR1); 3752 sljit_emit_op_custom(compiler, &inst, sizeof(sljit_u32)); 3753 #endif 3754 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_f64), SLJIT_FR0, 0); 3755 sljit_emit_return(compiler, SLJIT_UNUSED, 0, 0); 3756 3757 code.code = sljit_generate_code(compiler); 3758 CHECK(compiler); 3759 sljit_free_compiler(compiler); 3760 3761 code.func1((sljit_sw)&buf); 3762 FAILED(buf[2] != 11.25, "test41 case 3 failed\n"); 3763 3764 sljit_free_code(code.code); 3765 } 3766 3767 successful_tests++; 3768 } 3769 3770 static void test42(void) 3771 { 3772 /* Test long multiply and division. */ 3773 executable_code code; 3774 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 3775 sljit_s32 i; 3776 sljit_sw buf[7 + 4 + 8 + 8]; 3777 3778 if (verbose) 3779 printf("Run test42\n"); 3780 3781 FAILED(!compiler, "cannot create compiler\n"); 3782 for (i = 0; i < 7 + 4 + 8 + 8; i++) 3783 buf[i] = -1; 3784 3785 sljit_emit_enter(compiler, 0, 1, 5, 5, 0, 0, 0); 3786 3787 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, -0x1fb308a); 3788 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R3, 0, SLJIT_IMM, 0xf50c873); 3789 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R4, 0, SLJIT_IMM, 0x8a0475b); 3790 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_IMM, 0x9dc849b); 3791 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, -0x7c69a35); 3792 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S3, 0, SLJIT_IMM, 0x5a4d0c4); 3793 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S4, 0, SLJIT_IMM, 0x9a3b06d); 3794 3795 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 3796 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(-0x5dc4f897b8cd67f5)); 3797 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(0x3f8b5c026cb088df)); 3798 sljit_emit_op0(compiler, SLJIT_LMUL_UW); 3799 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_sw), SLJIT_R0, 0); 3800 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_sw), SLJIT_R1, 0); 3801 3802 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(-0x5dc4f897b8cd67f5)); 3803 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(0x3f8b5c026cb088df)); 3804 sljit_emit_op0(compiler, SLJIT_LMUL_SW); 3805 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 9 * sizeof(sljit_sw), SLJIT_R0, 0); 3806 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 10 * sizeof(sljit_sw), SLJIT_R1, 0); 3807 3808 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(-0x5dc4f897b8cd67f5)); 3809 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(0x3f8b5c026cb088df)); 3810 sljit_emit_op0(compiler, SLJIT_DIVMOD_UW); 3811 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 11 * sizeof(sljit_sw), SLJIT_R0, 0); 3812 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 12 * sizeof(sljit_sw), SLJIT_R1, 0); 3813 3814 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(-0x5dc4f897b8cd67f5)); 3815 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(0x3f8b5c026cb088df)); 3816 sljit_emit_op0(compiler, SLJIT_DIVMOD_SW); 3817 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 13 * sizeof(sljit_sw), SLJIT_R0, 0); 3818 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 14 * sizeof(sljit_sw), SLJIT_R1, 0); 3819 3820 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0x5cf783d3cf0a74b0)); 3821 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(0x3d5df42d03a28fc7)); 3822 sljit_emit_op0(compiler, SLJIT_DIVMOD_U32); 3823 sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_R0, 0, SLJIT_R0, 0); 3824 sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_R1, 0, SLJIT_R1, 0); 3825 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 15 * sizeof(sljit_sw), SLJIT_R0, 0); 3826 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 16 * sizeof(sljit_sw), SLJIT_R1, 0); 3827 3828 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0x371df5197ba26a28)); 3829 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(0x46c78a5cfd6a420c)); 3830 sljit_emit_op0(compiler, SLJIT_DIVMOD_S32); 3831 sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_R0, 0, SLJIT_R0, 0); 3832 sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_R1, 0, SLJIT_R1, 0); 3833 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 17 * sizeof(sljit_sw), SLJIT_R0, 0); 3834 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 18 * sizeof(sljit_sw), SLJIT_R1, 0); 3835 3836 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0xc456f048c28a611b)); 3837 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(0x3d4af2c543)); 3838 sljit_emit_op0(compiler, SLJIT_DIV_UW); 3839 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 19 * sizeof(sljit_sw), SLJIT_R0, 0); 3840 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 20 * sizeof(sljit_sw), SLJIT_R1, 0); 3841 3842 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(-0x720fa4b74c329b14)); 3843 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(0xa64ae42b7d6)); 3844 sljit_emit_op0(compiler, SLJIT_DIV_SW); 3845 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 21 * sizeof(sljit_sw), SLJIT_R0, 0); 3846 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 22 * sizeof(sljit_sw), SLJIT_R1, 0); 3847 3848 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0x4af51c027b34)); 3849 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(0x9ba4ff2906b14)); 3850 sljit_emit_op0(compiler, SLJIT_DIV_U32); 3851 sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_R0, 0, SLJIT_R0, 0); 3852 sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_R1, 0, SLJIT_R1, 0); 3853 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 23 * sizeof(sljit_sw), SLJIT_R0, 0); 3854 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 24 * sizeof(sljit_sw), SLJIT_R1, 0); 3855 3856 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0xc40b58a3f20d)); 3857 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(-0xa63c923)); 3858 sljit_emit_op0(compiler, SLJIT_DIV_S32); 3859 sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_R0, 0, SLJIT_R0, 0); 3860 sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_R1, 0, SLJIT_R1, 0); 3861 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 25 * sizeof(sljit_sw), SLJIT_R0, 0); 3862 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 26 * sizeof(sljit_sw), SLJIT_R1, 0); 3863 3864 #else 3865 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -0x58cd67f5); 3866 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0x3cb088df); 3867 sljit_emit_op0(compiler, SLJIT_LMUL_UW); 3868 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_sw), SLJIT_R0, 0); 3869 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_sw), SLJIT_R1, 0); 3870 3871 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -0x58cd67f5); 3872 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0x3cb088df); 3873 sljit_emit_op0(compiler, SLJIT_LMUL_SW); 3874 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 9 * sizeof(sljit_sw), SLJIT_R0, 0); 3875 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 10 * sizeof(sljit_sw), SLJIT_R1, 0); 3876 3877 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -0x58cd67f5); 3878 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0x3cb088df); 3879 sljit_emit_op0(compiler, SLJIT_DIVMOD_UW); 3880 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 11 * sizeof(sljit_sw), SLJIT_R0, 0); 3881 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 12 * sizeof(sljit_sw), SLJIT_R1, 0); 3882 3883 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, -0x58cd67f5); 3884 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0x3cb088df); 3885 sljit_emit_op0(compiler, SLJIT_DIVMOD_SW); 3886 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 13 * sizeof(sljit_sw), SLJIT_R0, 0); 3887 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 14 * sizeof(sljit_sw), SLJIT_R1, 0); 3888 3889 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 0xcf0a74b0); 3890 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, 0x03a28fc7); 3891 sljit_emit_op0(compiler, SLJIT_DIVMOD_U32); 3892 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 15 * sizeof(sljit_sw), SLJIT_R0, 0); 3893 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 16 * sizeof(sljit_sw), SLJIT_R1, 0); 3894 3895 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 0x7ba26a28); 3896 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, (sljit_sw)0xfd6a420c); 3897 sljit_emit_op0(compiler, SLJIT_DIVMOD_S32); 3898 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 17 * sizeof(sljit_sw), SLJIT_R0, 0); 3899 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 18 * sizeof(sljit_sw), SLJIT_R1, 0); 3900 3901 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0x9d4b7036)); 3902 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(0xb86d0)); 3903 sljit_emit_op0(compiler, SLJIT_DIV_UW); 3904 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 19 * sizeof(sljit_sw), SLJIT_R0, 0); 3905 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 20 * sizeof(sljit_sw), SLJIT_R1, 0); 3906 3907 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(-0x58b0692c)); 3908 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(0xd357)); 3909 sljit_emit_op0(compiler, SLJIT_DIV_SW); 3910 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 21 * sizeof(sljit_sw), SLJIT_R0, 0); 3911 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 22 * sizeof(sljit_sw), SLJIT_R1, 0); 3912 3913 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0x1c027b34)); 3914 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(0xf2906b14)); 3915 sljit_emit_op0(compiler, SLJIT_DIV_U32); 3916 sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_R0, 0, SLJIT_R0, 0); 3917 sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_R1, 0, SLJIT_R1, 0); 3918 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 23 * sizeof(sljit_sw), SLJIT_R0, 0); 3919 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 24 * sizeof(sljit_sw), SLJIT_R1, 0); 3920 3921 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0x58a3f20d)); 3922 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, SLJIT_W(-0xa63c923)); 3923 sljit_emit_op0(compiler, SLJIT_DIV_S32); 3924 sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_R0, 0, SLJIT_R0, 0); 3925 sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_R1, 0, SLJIT_R1, 0); 3926 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 25 * sizeof(sljit_sw), SLJIT_R0, 0); 3927 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 26 * sizeof(sljit_sw), SLJIT_R1, 0); 3928 #endif 3929 3930 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R2, 0); 3931 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_R3, 0); 3932 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_R4, 0); 3933 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_S1, 0); 3934 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_S2, 0); 3935 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_S3, 0); 3936 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_sw), SLJIT_S4, 0); 3937 3938 sljit_emit_return(compiler, SLJIT_UNUSED, 0, 0); 3939 3940 code.code = sljit_generate_code(compiler); 3941 CHECK(compiler); 3942 sljit_free_compiler(compiler); 3943 3944 code.func1((sljit_sw)&buf); 3945 3946 FAILED(buf[0] != -0x1fb308a, "test42 case 1 failed\n"); 3947 FAILED(buf[1] != 0xf50c873, "test42 case 2 failed\n"); 3948 FAILED(buf[2] != 0x8a0475b, "test42 case 3 failed\n"); 3949 FAILED(buf[3] != 0x9dc849b, "test42 case 4 failed\n"); 3950 FAILED(buf[4] != -0x7c69a35, "test42 case 5 failed\n"); 3951 FAILED(buf[5] != 0x5a4d0c4, "test42 case 6 failed\n"); 3952 FAILED(buf[6] != 0x9a3b06d, "test42 case 7 failed\n"); 3953 3954 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 3955 FAILED(buf[7] != SLJIT_W(-4388959407985636971), "test42 case 8 failed\n"); 3956 FAILED(buf[8] != SLJIT_W(2901680654366567099), "test42 case 9 failed\n"); 3957 FAILED(buf[9] != SLJIT_W(-4388959407985636971), "test42 case 10 failed\n"); 3958 FAILED(buf[10] != SLJIT_W(-1677173957268872740), "test42 case 11 failed\n"); 3959 FAILED(buf[11] != SLJIT_W(2), "test42 case 12 failed\n"); 3960 FAILED(buf[12] != SLJIT_W(2532236178951865933), "test42 case 13 failed\n"); 3961 FAILED(buf[13] != SLJIT_W(-1), "test42 case 14 failed\n"); 3962 FAILED(buf[14] != SLJIT_W(-2177944059851366166), "test42 case 15 failed\n"); 3963 #else 3964 FAILED(buf[7] != -1587000939, "test42 case 8 failed\n"); 3965 FAILED(buf[8] != 665003983, "test42 case 9 failed\n"); 3966 FAILED(buf[9] != -1587000939, "test42 case 10 failed\n"); 3967 FAILED(buf[10] != -353198352, "test42 case 11 failed\n"); 3968 FAILED(buf[11] != 2, "test42 case 12 failed\n"); 3969 FAILED(buf[12] != 768706125, "test42 case 13 failed\n"); 3970 FAILED(buf[13] != -1, "test42 case 14 failed\n"); 3971 FAILED(buf[14] != -471654166, "test42 case 15 failed\n"); 3972 #endif 3973 3974 FAILED(buf[15] != SLJIT_W(56), "test42 case 16 failed\n"); 3975 FAILED(buf[16] != SLJIT_W(58392872), "test42 case 17 failed\n"); 3976 FAILED(buf[17] != SLJIT_W(-47), "test42 case 18 failed\n"); 3977 FAILED(buf[18] != SLJIT_W(35949148), "test42 case 19 failed\n"); 3978 3979 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 3980 FAILED(buf[19] != SLJIT_W(0x3340bfc), "test42 case 20 failed\n"); 3981 FAILED(buf[20] != SLJIT_W(0x3d4af2c543), "test42 case 21 failed\n"); 3982 FAILED(buf[21] != SLJIT_W(-0xaf978), "test42 case 22 failed\n"); 3983 FAILED(buf[22] != SLJIT_W(0xa64ae42b7d6), "test42 case 23 failed\n"); 3984 #else 3985 FAILED(buf[19] != SLJIT_W(0xda5), "test42 case 20 failed\n"); 3986 FAILED(buf[20] != SLJIT_W(0xb86d0), "test42 case 21 failed\n"); 3987 FAILED(buf[21] != SLJIT_W(-0x6b6e), "test42 case 22 failed\n"); 3988 FAILED(buf[22] != SLJIT_W(0xd357), "test42 case 23 failed\n"); 3989 #endif 3990 3991 FAILED(buf[23] != SLJIT_W(0x0), "test42 case 24 failed\n"); 3992 FAILED(buf[24] != SLJIT_W(0xf2906b14), "test42 case 25 failed\n"); 3993 FAILED(buf[25] != SLJIT_W(-0x8), "test42 case 26 failed\n"); 3994 FAILED(buf[26] != SLJIT_W(-0xa63c923), "test42 case 27 failed\n"); 3995 3996 sljit_free_code(code.code); 3997 successful_tests++; 3998 } 3999 4000 static void test43(void) 4001 { 4002 /* Test floating point compare. */ 4003 executable_code code; 4004 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 4005 struct sljit_jump* jump; 4006 4007 union { 4008 sljit_f64 value; 4009 struct { 4010 sljit_u32 value1; 4011 sljit_u32 value2; 4012 } u; 4013 } dbuf[4]; 4014 4015 if (verbose) 4016 printf("Run test43\n"); 4017 4018 if (!sljit_is_fpu_available()) { 4019 if (verbose) 4020 printf("no fpu available, test43 skipped\n"); 4021 successful_tests++; 4022 if (compiler) 4023 sljit_free_compiler(compiler); 4024 return; 4025 } 4026 4027 FAILED(!compiler, "cannot create compiler\n"); 4028 4029 dbuf[0].value = 12.125; 4030 /* a NaN */ 4031 dbuf[1].u.value1 = 0x7fffffff; 4032 dbuf[1].u.value2 = 0x7fffffff; 4033 dbuf[2].value = -13.5; 4034 dbuf[3].value = 12.125; 4035 4036 sljit_emit_enter(compiler, 0, 1, 1, 1, 3, 0, 0); 4037 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 2); 4038 /* dbuf[0] < dbuf[2] -> -2 */ 4039 jump = sljit_emit_fcmp(compiler, SLJIT_GREATER_EQUAL_F64, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_MEM2(SLJIT_S0, SLJIT_R0), SLJIT_F64_SHIFT); 4040 sljit_emit_return(compiler, SLJIT_MOV, SLJIT_IMM, -2); 4041 4042 sljit_set_label(jump, sljit_emit_label(compiler)); 4043 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S0), 0); 4044 /* dbuf[0] and dbuf[1] is not NaN -> 5 */ 4045 jump = sljit_emit_fcmp(compiler, SLJIT_UNORDERED_F64, SLJIT_MEM0(), (sljit_sw)&dbuf[1], SLJIT_FR1, 0); 4046 sljit_emit_return(compiler, SLJIT_MOV, SLJIT_IMM, 5); 4047 4048 sljit_set_label(jump, sljit_emit_label(compiler)); 4049 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_f64)); 4050 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, 11); 4051 /* dbuf[0] == dbuf[3] -> 11 */ 4052 jump = sljit_emit_fcmp(compiler, SLJIT_EQUAL_F64, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_FR2, 0); 4053 4054 /* else -> -17 */ 4055 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, -17); 4056 sljit_set_label(jump, sljit_emit_label(compiler)); 4057 sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0); 4058 4059 code.code = sljit_generate_code(compiler); 4060 CHECK(compiler); 4061 sljit_free_compiler(compiler); 4062 4063 FAILED(code.func1((sljit_sw)&dbuf) != 11, "test43 case 1 failed\n"); 4064 dbuf[3].value = 12; 4065 FAILED(code.func1((sljit_sw)&dbuf) != -17, "test43 case 2 failed\n"); 4066 dbuf[1].value = 0; 4067 FAILED(code.func1((sljit_sw)&dbuf) != 5, "test43 case 3 failed\n"); 4068 dbuf[2].value = 20; 4069 FAILED(code.func1((sljit_sw)&dbuf) != -2, "test43 case 4 failed\n"); 4070 4071 sljit_free_code(code.code); 4072 successful_tests++; 4073 } 4074 4075 static void test44(void) 4076 { 4077 /* Test mov. */ 4078 executable_code code; 4079 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 4080 void *buf[5]; 4081 4082 if (verbose) 4083 printf("Run test44\n"); 4084 4085 FAILED(!compiler, "cannot create compiler\n"); 4086 4087 buf[0] = buf + 2; 4088 buf[1] = NULL; 4089 buf[2] = NULL; 4090 buf[3] = NULL; 4091 buf[4] = NULL; 4092 sljit_emit_enter(compiler, 0, 1, 3, 2, 0, 0, 0); 4093 4094 sljit_emit_op1(compiler, SLJIT_MOV_P, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), 0); 4095 sljit_emit_op1(compiler, SLJIT_MOV_P, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_p), SLJIT_R0, 0); 4096 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, sizeof(sljit_p)); 4097 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 2); 4098 sljit_emit_op1(compiler, SLJIT_MOV_P, SLJIT_MEM2(SLJIT_S0, SLJIT_R1), SLJIT_POINTER_SHIFT, SLJIT_R0, 0); 4099 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, sizeof(sljit_p)); 4100 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 3); 4101 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_S0, 0); 4102 sljit_emit_op1(compiler, SLJIT_MOVU_P, SLJIT_MEM2(SLJIT_R2, SLJIT_R1), SLJIT_POINTER_SHIFT, SLJIT_R0, 0); 4103 sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 2 * sizeof(sljit_p)); 4104 sljit_emit_op1(compiler, SLJIT_MOV_P, SLJIT_MEM1(SLJIT_R2), sizeof(sljit_p), SLJIT_R0, 0); 4105 4106 sljit_emit_return(compiler, SLJIT_MOV, SLJIT_R0, 0); 4107 4108 code.code = sljit_generate_code(compiler); 4109 CHECK(compiler); 4110 sljit_free_compiler(compiler); 4111 4112 FAILED(code.func1((sljit_sw)&buf) != (sljit_sw)(buf + 2), "test44 case 1 failed\n"); 4113 FAILED(buf[1] != buf + 2, "test44 case 2 failed\n"); 4114 FAILED(buf[2] != buf + 3, "test44 case 3 failed\n"); 4115 FAILED(buf[3] != buf + 4, "test44 case 4 failed\n"); 4116 FAILED(buf[4] != buf + 2, "test44 case 5 failed\n"); 4117 4118 sljit_free_code(code.code); 4119 successful_tests++; 4120 } 4121 4122 static void test45(void) 4123 { 4124 /* Test single precision floating point. */ 4125 4126 executable_code code; 4127 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 4128 sljit_f32 buf[12]; 4129 sljit_sw buf2[6]; 4130 struct sljit_jump* jump; 4131 4132 if (verbose) 4133 printf("Run test45\n"); 4134 4135 if (!sljit_is_fpu_available()) { 4136 if (verbose) 4137 printf("no fpu available, test45 skipped\n"); 4138 successful_tests++; 4139 if (compiler) 4140 sljit_free_compiler(compiler); 4141 return; 4142 } 4143 4144 FAILED(!compiler, "cannot create compiler\n"); 4145 4146 buf[0] = 5.5; 4147 buf[1] = -7.25; 4148 buf[2] = 0; 4149 buf[3] = 0; 4150 buf[4] = 0; 4151 buf[5] = 0; 4152 buf[6] = 0; 4153 buf[7] = 8.75; 4154 buf[8] = 0; 4155 buf[9] = 16.5; 4156 buf[10] = 0; 4157 buf[11] = 0; 4158 4159 buf2[0] = -1; 4160 buf2[1] = -1; 4161 buf2[2] = -1; 4162 buf2[3] = -1; 4163 buf2[4] = -1; 4164 buf2[5] = -1; 4165 4166 sljit_emit_enter(compiler, 0, 2, 3, 2, 6, 0, 0); 4167 4168 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S0), 0); 4169 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR5, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f32)); 4170 sljit_emit_fop1(compiler, SLJIT_NEG_F32, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_f32), SLJIT_FR0, 0); 4171 sljit_emit_fop1(compiler, SLJIT_ABS_F32, SLJIT_FR1, 0, SLJIT_FR5, 0); 4172 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_f32), SLJIT_FR1, 0); 4173 sljit_emit_fop1(compiler, SLJIT_ABS_F32, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_f32), SLJIT_FR5, 0); 4174 sljit_emit_fop1(compiler, SLJIT_NEG_F32, SLJIT_FR4, 0, SLJIT_MEM1(SLJIT_S0), 0); 4175 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_f32), SLJIT_FR4, 0); 4176 4177 sljit_emit_fop2(compiler, SLJIT_ADD_F32, SLJIT_FR0, 0, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f32)); 4178 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_f32), SLJIT_FR0, 0); 4179 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); 4180 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR0, 0, SLJIT_MEM1(SLJIT_S0), 0); 4181 sljit_emit_fop2(compiler, SLJIT_MUL_F32, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_f32), SLJIT_FR0, 0, SLJIT_FR0, 0); 4182 sljit_emit_fop2(compiler, SLJIT_DIV_F32, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S0), 9 * sizeof(sljit_f32), SLJIT_FR0, 0); 4183 sljit_emit_fop1(compiler, SLJIT_ABS_F32, SLJIT_MEM1(SLJIT_S0), 9 * sizeof(sljit_f32), SLJIT_FR2, 0); 4184 sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R0, 0, SLJIT_S0, 0, SLJIT_IMM, 0x3d0ac); 4185 sljit_emit_fop1(compiler, SLJIT_NEG_F32, SLJIT_MEM1(SLJIT_S0), 10 * sizeof(sljit_f32), SLJIT_MEM1(SLJIT_R0), 0x3d0ac); 4186 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_S0, 0, SLJIT_IMM, 0x3d0ac + sizeof(sljit_f32)); 4187 sljit_emit_fop1(compiler, SLJIT_ABS_F32, SLJIT_MEM1(SLJIT_S0), 11 * sizeof(sljit_f32), SLJIT_MEM1(SLJIT_R0), -0x3d0ac); 4188 4189 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S0), 0); 4190 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f32)); 4191 sljit_emit_fop1(compiler, SLJIT_CMP_F32 | SLJIT_SET_E | SLJIT_SET_S, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S0), 0); 4192 cond_set(compiler, SLJIT_MEM1(SLJIT_S1), 0, SLJIT_EQUAL_F32); 4193 cond_set(compiler, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_sw), SLJIT_LESS_F32); 4194 sljit_emit_fop1(compiler, SLJIT_CMP_F32 | SLJIT_SET_E, SLJIT_FR1, 0, SLJIT_FR2, 0); 4195 cond_set(compiler, SLJIT_MEM1(SLJIT_S1), 2 * sizeof(sljit_sw), SLJIT_EQUAL_F32); 4196 sljit_emit_fop1(compiler, SLJIT_CMP_F32 | SLJIT_SET_S, SLJIT_FR1, 0, SLJIT_FR2, 0); 4197 cond_set(compiler, SLJIT_MEM1(SLJIT_S1), 3 * sizeof(sljit_sw), SLJIT_GREATER_EQUAL_F32); 4198 4199 jump = sljit_emit_fcmp(compiler, SLJIT_LESS_EQUAL_F32, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f32)); 4200 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S1), 4 * sizeof(sljit_sw), SLJIT_IMM, 7); 4201 sljit_set_label(jump, sljit_emit_label(compiler)); 4202 4203 jump = sljit_emit_fcmp(compiler, SLJIT_GREATER_F32, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_FR2, 0); 4204 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S1), 5 * sizeof(sljit_sw), SLJIT_IMM, 6); 4205 sljit_set_label(jump, sljit_emit_label(compiler)); 4206 4207 sljit_emit_return(compiler, SLJIT_MOV, SLJIT_R0, 0); 4208 4209 code.code = sljit_generate_code(compiler); 4210 CHECK(compiler); 4211 sljit_free_compiler(compiler); 4212 4213 code.func2((sljit_sw)&buf, (sljit_sw)&buf2); 4214 FAILED(buf[2] != -5.5, "test45 case 1 failed\n"); 4215 FAILED(buf[3] != 7.25, "test45 case 2 failed\n"); 4216 FAILED(buf[4] != 7.25, "test45 case 3 failed\n"); 4217 FAILED(buf[5] != -5.5, "test45 case 4 failed\n"); 4218 FAILED(buf[6] != -1.75, "test45 case 5 failed\n"); 4219 FAILED(buf[7] != 16.0, "test45 case 6 failed\n"); 4220 FAILED(buf[8] != 30.25, "test45 case 7 failed\n"); 4221 FAILED(buf[9] != 3, "test45 case 8 failed\n"); 4222 FAILED(buf[10] != -5.5, "test45 case 9 failed\n"); 4223 FAILED(buf[11] != 7.25, "test45 case 10 failed\n"); 4224 FAILED(buf2[0] != 1, "test45 case 11 failed\n"); 4225 FAILED(buf2[1] != 2, "test45 case 12 failed\n"); 4226 FAILED(buf2[2] != 2, "test45 case 13 failed\n"); 4227 FAILED(buf2[3] != 1, "test45 case 14 failed\n"); 4228 FAILED(buf2[4] != 7, "test45 case 15 failed\n"); 4229 FAILED(buf2[5] != -1, "test45 case 16 failed\n"); 4230 4231 sljit_free_code(code.code); 4232 successful_tests++; 4233 } 4234 4235 static void test46(void) 4236 { 4237 /* Test sljit_emit_op_flags with 32 bit operations. */ 4238 4239 executable_code code; 4240 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 4241 sljit_s32 buf[24]; 4242 sljit_sw buf2[6]; 4243 sljit_s32 i; 4244 4245 if (verbose) 4246 printf("Run test46\n"); 4247 4248 for (i = 0; i < 24; ++i) 4249 buf[i] = -17; 4250 buf[16] = 0; 4251 for (i = 0; i < 6; ++i) 4252 buf2[i] = -13; 4253 buf2[4] = -124; 4254 4255 sljit_emit_enter(compiler, 0, 2, 3, 3, 0, 0, 0); 4256 4257 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, -7); 4258 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_E | SLJIT_SET_U, SLJIT_UNUSED, 0, SLJIT_R2, 0, SLJIT_IMM, 13); 4259 sljit_emit_op_flags(compiler, SLJIT_MOV_S32, SLJIT_MEM0(), (sljit_sw)&buf, SLJIT_UNUSED, 0, SLJIT_LESS); 4260 sljit_emit_op_flags(compiler, SLJIT_AND32, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_s32), SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_s32), SLJIT_GREATER); 4261 4262 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_E | SLJIT_SET_U, SLJIT_UNUSED, 0, SLJIT_R2, 0, SLJIT_IMM, -7); 4263 sljit_emit_op_flags(compiler, SLJIT_AND32 | SLJIT_KEEP_FLAGS, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_s32), SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_s32), SLJIT_EQUAL); 4264 sljit_emit_op_flags(compiler, SLJIT_AND32 | SLJIT_KEEP_FLAGS, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_s32), SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_s32), SLJIT_EQUAL); 4265 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0x1235); 4266 sljit_emit_op_flags(compiler, SLJIT_AND32 | SLJIT_SET_E, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_EQUAL); 4267 sljit_emit_op_flags(compiler, SLJIT_AND32, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_s32), SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_s32), SLJIT_EQUAL32); 4268 sljit_emit_op1(compiler, SLJIT_MOV_U32, SLJIT_MEM1(SLJIT_S0), 10 * sizeof(sljit_s32), SLJIT_R0, 0); 4269 4270 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, SLJIT_R2, 0, SLJIT_IMM, -7); 4271 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 12); 4272 sljit_emit_op_flags(compiler, SLJIT_MOV_U32, SLJIT_MEM2(SLJIT_S0, SLJIT_R0), 2, SLJIT_UNUSED, 0, SLJIT_EQUAL); 4273 sljit_emit_op_flags(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_UNUSED, 0, SLJIT_EQUAL); 4274 sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_MEM1(SLJIT_S0), 14 * sizeof(sljit_s32), SLJIT_R0, 0); 4275 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 16); 4276 sljit_emit_op_flags(compiler, SLJIT_AND32 | SLJIT_SET_E, SLJIT_MEM2(SLJIT_S0, SLJIT_R0), 2, SLJIT_MEM2(SLJIT_S0, SLJIT_R0), 2, SLJIT_EQUAL); 4277 sljit_emit_op_flags(compiler, SLJIT_MOV_U32, SLJIT_MEM1(SLJIT_S0), 18 * sizeof(sljit_s32), SLJIT_UNUSED, 0, SLJIT_NOT_EQUAL32); 4278 4279 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, SLJIT_R2, 0, SLJIT_IMM, -7); 4280 sljit_emit_op_flags(compiler, SLJIT_XOR32 | SLJIT_KEEP_FLAGS, SLJIT_MEM1(SLJIT_S0), 20 * sizeof(sljit_s32), SLJIT_MEM1(SLJIT_S0), 20 * sizeof(sljit_s32), SLJIT_EQUAL); 4281 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 39); 4282 sljit_emit_op_flags(compiler, SLJIT_XOR32, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_EQUAL); 4283 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_S0), 22 * sizeof(sljit_s32), SLJIT_R0, 0); 4284 4285 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_E | SLJIT_SET_U, SLJIT_UNUSED, 0, SLJIT_R2, 0, SLJIT_IMM, -7); 4286 sljit_emit_op_flags(compiler, SLJIT_AND, SLJIT_MEM0(), (sljit_sw)&buf2, SLJIT_MEM0(), (sljit_sw)&buf2, SLJIT_GREATER); 4287 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_E | SLJIT_SET_S | SLJIT_SET_U, SLJIT_UNUSED, 0, SLJIT_R2, 0, SLJIT_IMM, 5); 4288 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 1); 4289 sljit_emit_op_flags(compiler, SLJIT_AND | SLJIT_KEEP_FLAGS, SLJIT_MEM2(SLJIT_S1, SLJIT_R0), SLJIT_WORD_SHIFT, SLJIT_MEM2(SLJIT_S1, SLJIT_R0), SLJIT_WORD_SHIFT, SLJIT_SIG_LESS); 4290 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 2); 4291 sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_MEM2(SLJIT_S1, SLJIT_R0), SLJIT_WORD_SHIFT, SLJIT_UNUSED, 0, SLJIT_LESS); 4292 sljit_emit_op_flags(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_UNUSED, 0, SLJIT_NOT_EQUAL); 4293 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S1), 3 * sizeof(sljit_sw), SLJIT_S2, 0); 4294 sljit_emit_op_flags(compiler, SLJIT_OR, SLJIT_MEM1(SLJIT_S1), 4 * sizeof(sljit_sw), SLJIT_MEM1(SLJIT_S1), 4 * sizeof(sljit_sw), SLJIT_GREATER); 4295 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, SLJIT_R2, 0, SLJIT_IMM, 0); 4296 sljit_emit_op_flags(compiler, SLJIT_XOR, SLJIT_MEM1(SLJIT_S1), 5 * sizeof(sljit_sw), SLJIT_MEM1(SLJIT_S1), 5 * sizeof(sljit_sw), SLJIT_GREATER); 4297 4298 sljit_emit_return(compiler, SLJIT_UNUSED, 0, 0); 4299 4300 code.code = sljit_generate_code(compiler); 4301 CHECK(compiler); 4302 sljit_free_compiler(compiler); 4303 4304 code.func2((sljit_sw)&buf, (sljit_sw)&buf2); 4305 FAILED(buf[0] != 0, "test46 case 1 failed\n"); 4306 FAILED(buf[1] != -17, "test46 case 2 failed\n"); 4307 FAILED(buf[2] != 1, "test46 case 3 failed\n"); 4308 FAILED(buf[3] != -17, "test46 case 4 failed\n"); 4309 FAILED(buf[4] != 1, "test46 case 5 failed\n"); 4310 FAILED(buf[5] != -17, "test46 case 6 failed\n"); 4311 FAILED(buf[6] != 1, "test46 case 7 failed\n"); 4312 FAILED(buf[7] != -17, "test46 case 8 failed\n"); 4313 FAILED(buf[8] != 0, "test46 case 9 failed\n"); 4314 FAILED(buf[9] != -17, "test46 case 10 failed\n"); 4315 FAILED(buf[10] != 1, "test46 case 11 failed\n"); 4316 FAILED(buf[11] != -17, "test46 case 12 failed\n"); 4317 FAILED(buf[12] != 1, "test46 case 13 failed\n"); 4318 FAILED(buf[13] != -17, "test46 case 14 failed\n"); 4319 FAILED(buf[14] != 1, "test46 case 15 failed\n"); 4320 FAILED(buf[15] != -17, "test46 case 16 failed\n"); 4321 FAILED(buf[16] != 0, "test46 case 17 failed\n"); 4322 FAILED(buf[17] != -17, "test46 case 18 failed\n"); 4323 FAILED(buf[18] != 0, "test46 case 19 failed\n"); 4324 FAILED(buf[19] != -17, "test46 case 20 failed\n"); 4325 FAILED(buf[20] != -18, "test46 case 21 failed\n"); 4326 FAILED(buf[21] != -17, "test46 case 22 failed\n"); 4327 FAILED(buf[22] != 38, "test46 case 23 failed\n"); 4328 FAILED(buf[23] != -17, "test46 case 24 failed\n"); 4329 4330 FAILED(buf2[0] != 0, "test46 case 25 failed\n"); 4331 FAILED(buf2[1] != 1, "test46 case 26 failed\n"); 4332 FAILED(buf2[2] != 0, "test46 case 27 failed\n"); 4333 FAILED(buf2[3] != 1, "test46 case 28 failed\n"); 4334 FAILED(buf2[4] != -123, "test46 case 29 failed\n"); 4335 FAILED(buf2[5] != -14, "test46 case 30 failed\n"); 4336 4337 sljit_free_code(code.code); 4338 successful_tests++; 4339 } 4340 4341 static void test47(void) 4342 { 4343 /* Test jump optimizations. */ 4344 executable_code code; 4345 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 4346 sljit_sw buf[3]; 4347 4348 if (verbose) 4349 printf("Run test47\n"); 4350 4351 FAILED(!compiler, "cannot create compiler\n"); 4352 buf[0] = 0; 4353 buf[1] = 0; 4354 buf[2] = 0; 4355 4356 sljit_emit_enter(compiler, 0, 1, 3, 1, 0, 0, 0); 4357 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0x3a5c6f); 4358 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, SLJIT_R0, 0, SLJIT_IMM, 3); 4359 sljit_set_target(sljit_emit_jump(compiler, SLJIT_LESS), 0x11223344); 4360 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0); 4361 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0xd37c10); 4362 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 4363 sljit_set_target(sljit_emit_jump(compiler, SLJIT_LESS), SLJIT_W(0x112233445566)); 4364 #endif 4365 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_R0, 0); 4366 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 0x59b48e); 4367 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 4368 sljit_set_target(sljit_emit_jump(compiler, SLJIT_LESS), SLJIT_W(0x1122334455667788)); 4369 #endif 4370 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_R0, 0); 4371 sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0); 4372 4373 code.code = sljit_generate_code(compiler); 4374 CHECK(compiler); 4375 sljit_free_compiler(compiler); 4376 4377 code.func1((sljit_sw)&buf); 4378 FAILED(buf[0] != 0x3a5c6f, "test47 case 1 failed\n"); 4379 FAILED(buf[1] != 0xd37c10, "test47 case 2 failed\n"); 4380 FAILED(buf[2] != 0x59b48e, "test47 case 3 failed\n"); 4381 4382 sljit_free_code(code.code); 4383 successful_tests++; 4384 } 4385 4386 static void test48(void) 4387 { 4388 /* Test floating point conversions. */ 4389 executable_code code; 4390 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 4391 int i; 4392 sljit_f64 dbuf[9]; 4393 sljit_f32 sbuf[9]; 4394 sljit_sw wbuf[9]; 4395 sljit_s32 ibuf[9]; 4396 4397 if (verbose) 4398 printf("Run test48\n"); 4399 4400 if (!sljit_is_fpu_available()) { 4401 if (verbose) 4402 printf("no fpu available, test48 skipped\n"); 4403 successful_tests++; 4404 if (compiler) 4405 sljit_free_compiler(compiler); 4406 return; 4407 } 4408 4409 FAILED(!compiler, "cannot create compiler\n"); 4410 for (i = 0; i < 9; i++) { 4411 dbuf[i] = 0.0; 4412 sbuf[i] = 0.0; 4413 wbuf[i] = 0; 4414 ibuf[i] = 0; 4415 } 4416 4417 dbuf[0] = 123.5; 4418 dbuf[1] = -367; 4419 dbuf[2] = 917.75; 4420 4421 sbuf[0] = 476.25; 4422 sbuf[1] = -1689.75; 4423 4424 wbuf[0] = 2345; 4425 4426 ibuf[0] = 312; 4427 ibuf[1] = -9324; 4428 4429 sljit_emit_enter(compiler, 0, 0, 3, 3, 6, 0, 0); 4430 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, (sljit_sw)&dbuf); 4431 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_IMM, (sljit_sw)&sbuf); 4432 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, (sljit_sw)&wbuf); 4433 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, (sljit_sw)&ibuf); 4434 4435 /* sbuf[2] */ 4436 sljit_emit_fop1(compiler, SLJIT_CONV_F32_FROM_F64, SLJIT_MEM1(SLJIT_S1), 2 * sizeof(sljit_f32), SLJIT_MEM1(SLJIT_S0), 0); 4437 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR5, 0, SLJIT_MEM1(SLJIT_S0), 0); 4438 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 3); 4439 /* sbuf[3] */ 4440 sljit_emit_fop1(compiler, SLJIT_CONV_F32_FROM_F64, SLJIT_MEM2(SLJIT_S1, SLJIT_R0), SLJIT_F32_SHIFT, SLJIT_FR5, 0); 4441 sljit_emit_fop1(compiler, SLJIT_CONV_F64_FROM_F32, SLJIT_FR4, 0, SLJIT_MEM1(SLJIT_S1), 0); 4442 /* dbuf[3] */ 4443 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_f64), SLJIT_FR4, 0); 4444 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR3, 0, SLJIT_MEM1(SLJIT_S1), 0); 4445 sljit_emit_fop1(compiler, SLJIT_CONV_F64_FROM_F32, SLJIT_FR2, 0, SLJIT_FR3, 0); 4446 /* dbuf[4] */ 4447 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_f64), SLJIT_FR2, 0); 4448 /* sbuf[4] */ 4449 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_S1), 4 * sizeof(sljit_f32), SLJIT_FR3, 0); 4450 4451 /* wbuf[1] */ 4452 sljit_emit_fop1(compiler, SLJIT_CONV_SW_FROM_F64, SLJIT_MEM1(SLJIT_S2), sizeof(sljit_sw), SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f64)); 4453 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 2); 4454 sljit_emit_fop1(compiler, SLJIT_CONV_SW_FROM_F64, SLJIT_UNUSED, 0, SLJIT_MEM2(SLJIT_S0, SLJIT_R0), SLJIT_F64_SHIFT); 4455 sljit_emit_fop1(compiler, SLJIT_CONV_SW_FROM_F64, SLJIT_R0, 0, SLJIT_MEM2(SLJIT_S0, SLJIT_R0), SLJIT_F64_SHIFT); 4456 /* wbuf[2] */ 4457 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S2), 2 * sizeof(sljit_sw), SLJIT_R0, 0); 4458 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR5, 0, SLJIT_MEM1(SLJIT_S1), 0); 4459 /* wbuf[3] */ 4460 sljit_emit_fop1(compiler, SLJIT_CONV_SW_FROM_F32, SLJIT_MEM1(SLJIT_S2), 3 * sizeof(sljit_sw), SLJIT_FR5, 0); 4461 sljit_emit_fop1(compiler, SLJIT_NEG_F32, SLJIT_FR0, 0, SLJIT_FR5, 0); 4462 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 4); 4463 /* wbuf[4] */ 4464 sljit_emit_fop1(compiler, SLJIT_CONV_SW_FROM_F32, SLJIT_MEM2(SLJIT_S2, SLJIT_R1), SLJIT_WORD_SHIFT, SLJIT_FR0, 0); 4465 sljit_emit_fop1(compiler, SLJIT_NEG_F64, SLJIT_FR4, 0, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_f64)); 4466 /* ibuf[2] */ 4467 sljit_emit_fop1(compiler, SLJIT_CONV_S32_FROM_F64, SLJIT_MEM1(SLJIT_R2), 2 * sizeof(sljit_s32), SLJIT_FR4, 0); 4468 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR1, 0, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_f32)); 4469 sljit_emit_fop1(compiler, SLJIT_CONV_S32_FROM_F32, SLJIT_R0, 0, SLJIT_FR1, 0); 4470 /* ibuf[3] */ 4471 sljit_emit_op1(compiler, SLJIT_MOV_S32, SLJIT_MEM1(SLJIT_R2), 3 * sizeof(sljit_s32), SLJIT_R0, 0); 4472 4473 /* dbuf[5] */ 4474 sljit_emit_fop1(compiler, SLJIT_CONV_F64_FROM_SW, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_f64), SLJIT_MEM1(SLJIT_S2), 0); 4475 sljit_emit_fop1(compiler, SLJIT_CONV_F64_FROM_SW, SLJIT_FR2, 0, SLJIT_IMM, -6213); 4476 /* dbuf[6] */ 4477 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_f64), SLJIT_FR2, 0); 4478 /* dbuf[7] */ 4479 sljit_emit_fop1(compiler, SLJIT_CONV_F64_FROM_S32, SLJIT_MEM1(SLJIT_S0), 7 * sizeof(sljit_f64), SLJIT_MEM0(), (sljit_sw)&ibuf[0]); 4480 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_R2), sizeof(sljit_s32)); 4481 sljit_emit_fop1(compiler, SLJIT_CONV_F64_FROM_S32, SLJIT_FR1, 0, SLJIT_R0, 0); 4482 /* dbuf[8] */ 4483 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_f64), SLJIT_FR1, 0); 4484 /* sbuf[5] */ 4485 sljit_emit_fop1(compiler, SLJIT_CONV_F32_FROM_SW, SLJIT_MEM1(SLJIT_S1), 5 * sizeof(sljit_f32), SLJIT_IMM, -123); 4486 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 7190); 4487 sljit_emit_fop1(compiler, SLJIT_CONV_F32_FROM_SW, SLJIT_FR3, 0, SLJIT_R0, 0); 4488 /* sbuf[6] */ 4489 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_S1), 6 * sizeof(sljit_f32), SLJIT_FR3, 0); 4490 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 123); 4491 sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R1, 0, SLJIT_R2, 0, SLJIT_IMM, 123 * sizeof(sljit_s32)); 4492 sljit_emit_fop1(compiler, SLJIT_CONV_F32_FROM_S32, SLJIT_FR1, 0, SLJIT_MEM2(SLJIT_R1, SLJIT_R0), 2); 4493 /* sbuf[7] */ 4494 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_S1), 7 * sizeof(sljit_f32), SLJIT_FR1, 0); 4495 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 8); 4496 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, 3812); 4497 /* sbuf[8] */ 4498 sljit_emit_fop1(compiler, SLJIT_CONV_F32_FROM_S32, SLJIT_MEM2(SLJIT_S1, SLJIT_R0), SLJIT_F32_SHIFT, SLJIT_R1, 0); 4499 4500 sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0); 4501 4502 code.code = sljit_generate_code(compiler); 4503 CHECK(compiler); 4504 sljit_free_compiler(compiler); 4505 4506 code.func0(); 4507 FAILED(dbuf[3] != 476.25, "test48 case 1 failed\n"); 4508 FAILED(dbuf[4] != 476.25, "test48 case 2 failed\n"); 4509 FAILED(dbuf[5] != 2345.0, "test48 case 3 failed\n"); 4510 FAILED(dbuf[6] != -6213.0, "test48 case 4 failed\n"); 4511 FAILED(dbuf[7] != 312.0, "test48 case 5 failed\n"); 4512 FAILED(dbuf[8] != -9324.0, "test48 case 6 failed\n"); 4513 4514 FAILED(sbuf[2] != 123.5, "test48 case 7 failed\n"); 4515 FAILED(sbuf[3] != 123.5, "test48 case 8 failed\n"); 4516 FAILED(sbuf[4] != 476.25, "test48 case 9 failed\n"); 4517 FAILED(sbuf[5] != -123, "test48 case 10 failed\n"); 4518 FAILED(sbuf[6] != 7190, "test48 case 11 failed\n"); 4519 FAILED(sbuf[7] != 312, "test48 case 12 failed\n"); 4520 FAILED(sbuf[8] != 3812, "test48 case 13 failed\n"); 4521 4522 FAILED(wbuf[1] != -367, "test48 case 14 failed\n"); 4523 FAILED(wbuf[2] != 917, "test48 case 15 failed\n"); 4524 FAILED(wbuf[3] != 476, "test48 case 16 failed\n"); 4525 FAILED(wbuf[4] != -476, "test48 case 17 failed\n"); 4526 4527 FAILED(ibuf[2] != -917, "test48 case 18 failed\n"); 4528 FAILED(ibuf[3] != -1689, "test48 case 19 failed\n"); 4529 4530 sljit_free_code(code.code); 4531 successful_tests++; 4532 } 4533 4534 static void test49(void) 4535 { 4536 /* Test floating point conversions. */ 4537 executable_code code; 4538 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 4539 int i; 4540 sljit_f64 dbuf[10]; 4541 sljit_f32 sbuf[9]; 4542 sljit_sw wbuf[9]; 4543 sljit_s32 ibuf[9]; 4544 sljit_s32* dbuf_ptr = (sljit_s32*)dbuf; 4545 sljit_s32* sbuf_ptr = (sljit_s32*)sbuf; 4546 4547 if (verbose) 4548 printf("Run test49\n"); 4549 4550 if (!sljit_is_fpu_available()) { 4551 if (verbose) 4552 printf("no fpu available, test49 skipped\n"); 4553 successful_tests++; 4554 if (compiler) 4555 sljit_free_compiler(compiler); 4556 return; 4557 } 4558 4559 FAILED(!compiler, "cannot create compiler\n"); 4560 4561 for (i = 0; i < 9; i++) { 4562 dbuf_ptr[i << 1] = -1; 4563 dbuf_ptr[(i << 1) + 1] = -1; 4564 sbuf_ptr[i] = -1; 4565 wbuf[i] = -1; 4566 ibuf[i] = -1; 4567 } 4568 4569 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 4570 dbuf[9] = (sljit_f64)SLJIT_W(0x1122334455); 4571 #endif 4572 dbuf[0] = 673.75; 4573 sbuf[0] = -879.75; 4574 wbuf[0] = 345; 4575 ibuf[0] = -249; 4576 4577 sljit_emit_enter(compiler, 0, 0, 3, 3, 3, 0, 0); 4578 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S0, 0, SLJIT_IMM, (sljit_sw)&dbuf); 4579 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S1, 0, SLJIT_IMM, (sljit_sw)&sbuf); 4580 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S2, 0, SLJIT_IMM, (sljit_sw)&wbuf); 4581 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, (sljit_sw)&ibuf); 4582 4583 /* dbuf[2] */ 4584 sljit_emit_fop1(compiler, SLJIT_CONV_F64_FROM_F32, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_f64), SLJIT_MEM1(SLJIT_S1), 0); 4585 /* sbuf[2] */ 4586 sljit_emit_fop1(compiler, SLJIT_CONV_F32_FROM_F64, SLJIT_MEM1(SLJIT_S1), 2 * sizeof(sljit_f32), SLJIT_MEM1(SLJIT_S0), 0); 4587 /* wbuf[2] */ 4588 sljit_emit_fop1(compiler, SLJIT_CONV_SW_FROM_F64, SLJIT_MEM1(SLJIT_S2), 2 * sizeof(sljit_sw), SLJIT_MEM1(SLJIT_S0), 0); 4589 /* wbuf[4] */ 4590 sljit_emit_fop1(compiler, SLJIT_CONV_SW_FROM_F32, SLJIT_MEM1(SLJIT_S2), 4 * sizeof(sljit_sw), SLJIT_MEM1(SLJIT_S1), 0); 4591 /* ibuf[2] */ 4592 sljit_emit_fop1(compiler, SLJIT_CONV_S32_FROM_F64, SLJIT_MEM1(SLJIT_R2), 2 * sizeof(sljit_s32), SLJIT_MEM1(SLJIT_S0), 0); 4593 /* ibuf[4] */ 4594 sljit_emit_fop1(compiler, SLJIT_CONV_S32_FROM_F32, SLJIT_MEM1(SLJIT_R2), 4 * sizeof(sljit_s32), SLJIT_MEM1(SLJIT_S1), 0); 4595 /* dbuf[4] */ 4596 sljit_emit_fop1(compiler, SLJIT_CONV_F64_FROM_SW, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_f64), SLJIT_MEM1(SLJIT_S2), 0); 4597 /* sbuf[4] */ 4598 sljit_emit_fop1(compiler, SLJIT_CONV_F32_FROM_SW, SLJIT_MEM1(SLJIT_S1), 4 * sizeof(sljit_f32), SLJIT_MEM1(SLJIT_S2), 0); 4599 /* dbuf[6] */ 4600 sljit_emit_fop1(compiler, SLJIT_CONV_F64_FROM_S32, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_f64), SLJIT_MEM1(SLJIT_R2), 0); 4601 /* sbuf[6] */ 4602 sljit_emit_fop1(compiler, SLJIT_CONV_F32_FROM_S32, SLJIT_MEM1(SLJIT_S1), 6 * sizeof(sljit_f32), SLJIT_MEM1(SLJIT_R2), 0); 4603 4604 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 4605 sljit_emit_fop1(compiler, SLJIT_CONV_SW_FROM_F64, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), 9 * sizeof(sljit_f64)); 4606 /* wbuf[8] */ 4607 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S2), 8 * sizeof(sljit_sw), SLJIT_R0, 0); 4608 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S0), 9 * sizeof(sljit_f64)); 4609 sljit_emit_fop1(compiler, SLJIT_CONV_S32_FROM_F64, SLJIT_R0, 0, SLJIT_FR2, 0); 4610 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_R0, 0); 4611 sljit_emit_op2(compiler, SLJIT_AND32, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 0xffff); 4612 /* ibuf[8] */ 4613 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_R2), 8 * sizeof(sljit_s32), SLJIT_R0, 0); 4614 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, SLJIT_W(0x4455667788)); 4615 /* dbuf[8] */ 4616 sljit_emit_fop1(compiler, SLJIT_CONV_F64_FROM_SW, SLJIT_MEM1(SLJIT_S0), 8 * sizeof(sljit_f64), SLJIT_R0, 0); 4617 /* dbuf[9] */ 4618 sljit_emit_fop1(compiler, SLJIT_CONV_F64_FROM_S32, SLJIT_MEM1(SLJIT_S0), 9 * sizeof(sljit_f64), SLJIT_IMM, SLJIT_W(0x7766554433)); 4619 #endif 4620 4621 sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0); 4622 4623 code.code = sljit_generate_code(compiler); 4624 CHECK(compiler); 4625 sljit_free_compiler(compiler); 4626 4627 code.func0(); 4628 4629 FAILED(dbuf_ptr[(1 * 2) + 0] != -1, "test49 case 1 failed\n"); 4630 FAILED(dbuf_ptr[(1 * 2) + 1] != -1, "test49 case 2 failed\n"); 4631 FAILED(dbuf[2] != -879.75, "test49 case 3 failed\n"); 4632 FAILED(dbuf_ptr[(3 * 2) + 0] != -1, "test49 case 4 failed\n"); 4633 FAILED(dbuf_ptr[(3 * 2) + 1] != -1, "test49 case 5 failed\n"); 4634 FAILED(dbuf[4] != 345, "test49 case 6 failed\n"); 4635 FAILED(dbuf_ptr[(5 * 2) + 0] != -1, "test49 case 7 failed\n"); 4636 FAILED(dbuf_ptr[(5 * 2) + 1] != -1, "test49 case 8 failed\n"); 4637 FAILED(dbuf[6] != -249, "test49 case 9 failed\n"); 4638 FAILED(dbuf_ptr[(7 * 2) + 0] != -1, "test49 case 10 failed\n"); 4639 FAILED(dbuf_ptr[(7 * 2) + 1] != -1, "test49 case 11 failed\n"); 4640 4641 FAILED(sbuf_ptr[1] != -1, "test49 case 12 failed\n"); 4642 FAILED(sbuf[2] != 673.75, "test49 case 13 failed\n"); 4643 FAILED(sbuf_ptr[3] != -1, "test49 case 14 failed\n"); 4644 FAILED(sbuf[4] != 345, "test49 case 15 failed\n"); 4645 FAILED(sbuf_ptr[5] != -1, "test49 case 16 failed\n"); 4646 FAILED(sbuf[6] != -249, "test49 case 17 failed\n"); 4647 FAILED(sbuf_ptr[7] != -1, "test49 case 18 failed\n"); 4648 4649 FAILED(wbuf[1] != -1, "test49 case 19 failed\n"); 4650 FAILED(wbuf[2] != 673, "test49 case 20 failed\n"); 4651 FAILED(wbuf[3] != -1, "test49 case 21 failed\n"); 4652 FAILED(wbuf[4] != -879, "test49 case 22 failed\n"); 4653 FAILED(wbuf[5] != -1, "test49 case 23 failed\n"); 4654 4655 FAILED(ibuf[1] != -1, "test49 case 24 failed\n"); 4656 FAILED(ibuf[2] != 673, "test49 case 25 failed\n"); 4657 FAILED(ibuf[3] != -1, "test49 case 26 failed\n"); 4658 FAILED(ibuf[4] != -879, "test49 case 27 failed\n"); 4659 FAILED(ibuf[5] != -1, "test49 case 28 failed\n"); 4660 4661 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 4662 FAILED(dbuf[8] != (sljit_f64)SLJIT_W(0x4455667788), "test49 case 29 failed\n"); 4663 FAILED(dbuf[9] != (sljit_f64)SLJIT_W(0x66554433), "test49 case 30 failed\n"); 4664 FAILED(wbuf[8] != SLJIT_W(0x1122334455), "test48 case 31 failed\n"); 4665 FAILED(ibuf[8] == 0x4455, "test48 case 32 failed\n"); 4666 #endif 4667 4668 sljit_free_code(code.code); 4669 successful_tests++; 4670 } 4671 4672 static void test50(void) 4673 { 4674 /* Test stack and floating point operations. */ 4675 executable_code code; 4676 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 4677 #if !(defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86) 4678 sljit_uw size1, size2, size3; 4679 int result; 4680 #endif 4681 sljit_f32 sbuf[7]; 4682 4683 if (verbose) 4684 printf("Run test50\n"); 4685 4686 if (!sljit_is_fpu_available()) { 4687 if (verbose) 4688 printf("no fpu available, test50 skipped\n"); 4689 successful_tests++; 4690 if (compiler) 4691 sljit_free_compiler(compiler); 4692 return; 4693 } 4694 4695 FAILED(!compiler, "cannot create compiler\n"); 4696 4697 sbuf[0] = 245.5; 4698 sbuf[1] = -100.25; 4699 sbuf[2] = 713.75; 4700 4701 sljit_emit_enter(compiler, 0, 1, 3, 3, 6, 0, 8 * sizeof(sljit_f32)); 4702 4703 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), 0, SLJIT_MEM1(SLJIT_S0), 0); 4704 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_SP), sizeof(sljit_f32), SLJIT_MEM1(SLJIT_SP), 0); 4705 /* sbuf[3] */ 4706 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_f32), SLJIT_MEM1(SLJIT_SP), sizeof(sljit_f32)); 4707 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), sizeof(sljit_f32), SLJIT_MEM1(SLJIT_S0), sizeof(sljit_f32)); 4708 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)); 4709 /* sbuf[4] */ 4710 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_f32), SLJIT_MEM1(SLJIT_SP), 2 * sizeof(sljit_f32)); 4711 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), 2 * sizeof(sljit_f32), SLJIT_IMM, 5934); 4712 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)); 4713 /* sbuf[5] */ 4714 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_f32), SLJIT_MEM1(SLJIT_SP), 3 * sizeof(sljit_f32)); 4715 4716 #if !(defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86) 4717 size1 = compiler->size; 4718 #endif 4719 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR2, 0, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_f32)); 4720 #if !(defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86) 4721 size2 = compiler->size; 4722 #endif 4723 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_FR5, 0, SLJIT_FR2, 0); 4724 #if !(defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86) 4725 size3 = compiler->size; 4726 #endif 4727 /* sbuf[6] */ 4728 sljit_emit_fop1(compiler, SLJIT_MOV_F32, SLJIT_MEM1(SLJIT_S0), 6 * sizeof(sljit_f32), SLJIT_FR5, 0); 4729 #if !(defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86) 4730 result = (compiler->size - size3) == (size3 - size2) && (size3 - size2) == (size2 - size1); 4731 #endif 4732 4733 sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0); 4734 4735 code.code = sljit_generate_code(compiler); 4736 CHECK(compiler); 4737 sljit_free_compiler(compiler); 4738 4739 code.func1((sljit_sw)&sbuf); 4740 4741 FAILED(sbuf[3] != 245.5, "test50 case 1 failed\n"); 4742 FAILED(sbuf[4] != 145.25, "test50 case 2 failed\n"); 4743 FAILED(sbuf[5] != 5934, "test50 case 3 failed\n"); 4744 FAILED(sbuf[6] != 713.75, "test50 case 4 failed\n"); 4745 #if !(defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86) 4746 FAILED(!result, "test50 case 5 failed\n"); 4747 #endif 4748 4749 sljit_free_code(code.code); 4750 successful_tests++; 4751 } 4752 4753 static void test51(void) 4754 { 4755 /* Test all registers provided by the CPU. */ 4756 executable_code code; 4757 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 4758 struct sljit_jump* jump; 4759 sljit_sw buf[2]; 4760 sljit_s32 i; 4761 4762 FAILED(!compiler, "cannot create compiler\n"); 4763 4764 buf[0] = 39; 4765 4766 sljit_emit_enter(compiler, 0, 0, SLJIT_NUMBER_OF_REGISTERS, 0, 0, 0, 0); 4767 4768 for (i = 0; i < SLJIT_NUMBER_OF_REGISTERS; i++) 4769 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R(i), 0, SLJIT_IMM, 32); 4770 4771 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)buf); 4772 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 0); 4773 4774 for (i = 2; i < SLJIT_NUMBER_OF_REGISTERS; i++) { 4775 if (sljit_get_register_index(SLJIT_R(i)) >= 0) { 4776 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R(i), 0, SLJIT_R0, 0); 4777 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_R(i)), 0); 4778 } else 4779 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, buf[0]); 4780 } 4781 4782 sljit_emit_op2(compiler, SLJIT_SUB, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 32); 4783 for (i = 2; i < SLJIT_NUMBER_OF_REGISTERS; i++) { 4784 if (sljit_get_register_index(SLJIT_R(i)) >= 0) { 4785 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R(i), 0, SLJIT_R0, 0); 4786 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_R(i)), 32); 4787 } else 4788 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, buf[0]); 4789 } 4790 4791 for (i = 2; i < SLJIT_NUMBER_OF_REGISTERS; i++) { 4792 if (sljit_get_register_index(SLJIT_R(i)) >= 0) { 4793 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R(i), 0, SLJIT_IMM, 32); 4794 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_MEM2(SLJIT_R(i), SLJIT_R0), 0); 4795 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_MEM2(SLJIT_R0, SLJIT_R(i)), 0); 4796 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R(i), 0, SLJIT_IMM, 8); 4797 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_MEM2(SLJIT_R0, SLJIT_R(i)), 2); 4798 } else 4799 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, 3 * buf[0]); 4800 } 4801 4802 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), 32 + sizeof(sljit_sw), SLJIT_R1, 0); 4803 4804 sljit_emit_return(compiler, SLJIT_UNUSED, 0, 0); 4805 4806 code.code = sljit_generate_code(compiler); 4807 CHECK(compiler); 4808 sljit_free_compiler(compiler); 4809 4810 code.func0(); 4811 4812 FAILED(buf[1] != (39 * 5 * (SLJIT_NUMBER_OF_REGISTERS - 2)), "test51 case 1 failed\n"); 4813 4814 sljit_free_code(code.code); 4815 4816 /* Next test. */ 4817 4818 compiler = sljit_create_compiler(NULL); 4819 4820 FAILED(!compiler, "cannot create compiler\n"); 4821 4822 sljit_emit_enter(compiler, 0, 0, SLJIT_NUMBER_OF_SCRATCH_REGISTERS, SLJIT_NUMBER_OF_SAVED_REGISTERS, 0, 0, 0); 4823 4824 for (i = 0; i < SLJIT_NUMBER_OF_REGISTERS; i++) 4825 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R(i), 0, SLJIT_IMM, 17); 4826 4827 jump = sljit_emit_jump(compiler, SLJIT_CALL0); 4828 /* SLJIT_R0 contains the first value. */ 4829 for (i = 1; i < SLJIT_NUMBER_OF_REGISTERS; i++) 4830 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_R(i), 0); 4831 4832 sljit_emit_return(compiler, SLJIT_MOV, SLJIT_R0, 0); 4833 4834 sljit_set_label(jump, sljit_emit_label(compiler)); 4835 sljit_emit_enter(compiler, 0, 0, SLJIT_NUMBER_OF_REGISTERS, 0, 0, 0, 0); 4836 for (i = 0; i < SLJIT_NUMBER_OF_REGISTERS; i++) 4837 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R(i), 0, SLJIT_IMM, 35); 4838 sljit_emit_return(compiler, SLJIT_UNUSED, 0, 0); 4839 4840 code.code = sljit_generate_code(compiler); 4841 CHECK(compiler); 4842 sljit_free_compiler(compiler); 4843 4844 FAILED(code.func0() != (SLJIT_NUMBER_OF_SCRATCH_REGISTERS * 35 + SLJIT_NUMBER_OF_SAVED_REGISTERS * 17), "test51 case 2 failed\n"); 4845 4846 sljit_free_code(code.code); 4847 4848 /* Next test. */ 4849 4850 compiler = sljit_create_compiler(NULL); 4851 4852 FAILED(!compiler, "cannot create compiler\n"); 4853 4854 sljit_emit_enter(compiler, 0, 0, SLJIT_NUMBER_OF_SCRATCH_REGISTERS, SLJIT_NUMBER_OF_SAVED_REGISTERS, 0, 0, 0); 4855 4856 for (i = 0; i < SLJIT_NUMBER_OF_REGISTERS; i++) 4857 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R(i), 0, SLJIT_IMM, 68); 4858 4859 jump = sljit_emit_jump(compiler, SLJIT_CALL0); 4860 /* SLJIT_R0 contains the first value. */ 4861 for (i = 1; i < SLJIT_NUMBER_OF_REGISTERS; i++) 4862 sljit_emit_op2(compiler, SLJIT_ADD, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_R(i), 0); 4863 4864 sljit_emit_return(compiler, SLJIT_MOV, SLJIT_R0, 0); 4865 4866 sljit_set_label(jump, sljit_emit_label(compiler)); 4867 sljit_emit_enter(compiler, 0, 0, 0, SLJIT_NUMBER_OF_REGISTERS, 0, 0, 0); 4868 for (i = 0; i < SLJIT_NUMBER_OF_REGISTERS; i++) 4869 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_S(i), 0, SLJIT_IMM, 43); 4870 sljit_emit_return(compiler, SLJIT_UNUSED, 0, 0); 4871 4872 code.code = sljit_generate_code(compiler); 4873 CHECK(compiler); 4874 sljit_free_compiler(compiler); 4875 4876 FAILED(code.func0() != (SLJIT_NUMBER_OF_SCRATCH_REGISTERS * 43 + SLJIT_NUMBER_OF_SAVED_REGISTERS * 68), "test51 case 3 failed\n"); 4877 4878 sljit_free_code(code.code); 4879 successful_tests++; 4880 } 4881 4882 static void test52(void) 4883 { 4884 /* Test all registers provided by the CPU. */ 4885 executable_code code; 4886 struct sljit_compiler* compiler; 4887 struct sljit_jump* jump; 4888 sljit_f64 buf[3]; 4889 sljit_s32 i; 4890 4891 if (!sljit_is_fpu_available()) { 4892 if (verbose) 4893 printf("no fpu available, test52 skipped\n"); 4894 successful_tests++; 4895 return; 4896 } 4897 4898 /* Next test. */ 4899 4900 compiler = sljit_create_compiler(NULL); 4901 FAILED(!compiler, "cannot create compiler\n"); 4902 buf[0] = 6.25; 4903 buf[1] = 17.75; 4904 4905 sljit_emit_enter(compiler, 0, 1, 0, 1, SLJIT_NUMBER_OF_SCRATCH_FLOAT_REGISTERS, SLJIT_NUMBER_OF_SAVED_FLOAT_REGISTERS, 0); 4906 4907 for (i = 0; i < SLJIT_NUMBER_OF_FLOAT_REGISTERS; i++) 4908 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR(i), 0, SLJIT_MEM1(SLJIT_S0), 0); 4909 4910 jump = sljit_emit_jump(compiler, SLJIT_CALL0); 4911 /* SLJIT_FR0 contains the first value. */ 4912 for (i = 1; i < SLJIT_NUMBER_OF_FLOAT_REGISTERS; i++) 4913 sljit_emit_fop2(compiler, SLJIT_ADD_F64, SLJIT_FR0, 0, SLJIT_FR0, 0, SLJIT_FR(i), 0); 4914 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_f64), SLJIT_FR0, 0); 4915 4916 sljit_emit_return(compiler, SLJIT_UNUSED, 0, 0); 4917 4918 sljit_set_label(jump, sljit_emit_label(compiler)); 4919 sljit_emit_enter(compiler, 0, 0, 1, 0, SLJIT_NUMBER_OF_FLOAT_REGISTERS, 0, 0); 4920 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&buf[1]); 4921 for (i = 0; i < SLJIT_NUMBER_OF_FLOAT_REGISTERS; i++) 4922 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR(i), 0, SLJIT_MEM1(SLJIT_R0), 0); 4923 sljit_emit_return(compiler, SLJIT_UNUSED, 0, 0); 4924 4925 code.code = sljit_generate_code(compiler); 4926 CHECK(compiler); 4927 sljit_free_compiler(compiler); 4928 4929 code.func1((sljit_sw)&buf); 4930 FAILED(buf[2] != (SLJIT_NUMBER_OF_SCRATCH_FLOAT_REGISTERS * 17.75 + SLJIT_NUMBER_OF_SAVED_FLOAT_REGISTERS * 6.25), "test52 case 1 failed\n"); 4931 4932 sljit_free_code(code.code); 4933 4934 /* Next test. */ 4935 4936 compiler = sljit_create_compiler(NULL); 4937 FAILED(!compiler, "cannot create compiler\n"); 4938 buf[0] = -32.5; 4939 buf[1] = -11.25; 4940 4941 sljit_emit_enter(compiler, 0, 1, 0, 1, SLJIT_NUMBER_OF_SCRATCH_FLOAT_REGISTERS, SLJIT_NUMBER_OF_SAVED_FLOAT_REGISTERS, 0); 4942 4943 for (i = 0; i < SLJIT_NUMBER_OF_FLOAT_REGISTERS; i++) 4944 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FR(i), 0, SLJIT_MEM1(SLJIT_S0), 0); 4945 4946 jump = sljit_emit_jump(compiler, SLJIT_CALL0); 4947 /* SLJIT_FR0 contains the first value. */ 4948 for (i = 1; i < SLJIT_NUMBER_OF_FLOAT_REGISTERS; i++) 4949 sljit_emit_fop2(compiler, SLJIT_ADD_F64, SLJIT_FR0, 0, SLJIT_FR0, 0, SLJIT_FR(i), 0); 4950 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_f64), SLJIT_FR0, 0); 4951 4952 sljit_emit_return(compiler, SLJIT_UNUSED, 0, 0); 4953 4954 sljit_set_label(jump, sljit_emit_label(compiler)); 4955 sljit_emit_enter(compiler, 0, 0, 1, 0, 0, SLJIT_NUMBER_OF_FLOAT_REGISTERS, 0); 4956 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, (sljit_sw)&buf[1]); 4957 for (i = 0; i < SLJIT_NUMBER_OF_FLOAT_REGISTERS; i++) 4958 sljit_emit_fop1(compiler, SLJIT_MOV_F64, SLJIT_FS(i), 0, SLJIT_MEM1(SLJIT_R0), 0); 4959 sljit_emit_return(compiler, SLJIT_UNUSED, 0, 0); 4960 4961 code.code = sljit_generate_code(compiler); 4962 CHECK(compiler); 4963 sljit_free_compiler(compiler); 4964 4965 code.func1((sljit_sw)&buf); 4966 FAILED(buf[2] != (SLJIT_NUMBER_OF_SCRATCH_FLOAT_REGISTERS * -11.25 + SLJIT_NUMBER_OF_SAVED_FLOAT_REGISTERS * -32.5), "test52 case 2 failed\n"); 4967 4968 sljit_free_code(code.code); 4969 successful_tests++; 4970 } 4971 4972 static void test53(void) 4973 { 4974 /* Check SLJIT_DOUBLE_ALIGNMENT. */ 4975 executable_code code; 4976 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 4977 sljit_sw buf[1]; 4978 4979 if (verbose) 4980 printf("Run test53\n"); 4981 4982 FAILED(!compiler, "cannot create compiler\n"); 4983 buf[0] = -1; 4984 4985 sljit_emit_enter(compiler, SLJIT_DOUBLE_ALIGNMENT, 1, 1, 1, 0, 0, 2 * sizeof(sljit_sw)); 4986 4987 sljit_get_local_base(compiler, SLJIT_R0, 0, 0); 4988 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0); 4989 4990 sljit_emit_return(compiler, SLJIT_UNUSED, 0, 0); 4991 4992 code.code = sljit_generate_code(compiler); 4993 CHECK(compiler); 4994 sljit_free_compiler(compiler); 4995 4996 code.func1((sljit_sw)&buf); 4997 4998 FAILED((buf[0] & (sizeof(sljit_f64) - 1)) != 0, "test53 case 1 failed\n"); 4999 5000 sljit_free_code(code.code); 5001 5002 /* Next test. */ 5003 5004 compiler = sljit_create_compiler(NULL); 5005 FAILED(!compiler, "cannot create compiler\n"); 5006 buf[0] = -1; 5007 5008 /* One more saved register to break the alignment on x86-32. */ 5009 sljit_emit_enter(compiler, SLJIT_DOUBLE_ALIGNMENT, 1, 1, 2, 0, 0, 2 * sizeof(sljit_sw)); 5010 5011 sljit_get_local_base(compiler, SLJIT_R0, 0, 0); 5012 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0); 5013 5014 sljit_emit_return(compiler, SLJIT_UNUSED, 0, 0); 5015 5016 code.code = sljit_generate_code(compiler); 5017 CHECK(compiler); 5018 sljit_free_compiler(compiler); 5019 5020 code.func1((sljit_sw)&buf); 5021 5022 FAILED((buf[0] & (sizeof(sljit_f64) - 1)) != 0, "test53 case 2 failed\n"); 5023 5024 sljit_free_code(code.code); 5025 successful_tests++; 5026 } 5027 5028 static void test54(void) 5029 { 5030 /* Check x86 cmov. */ 5031 executable_code code; 5032 struct sljit_compiler* compiler = sljit_create_compiler(NULL); 5033 sljit_sw buf[6]; 5034 sljit_s32 ibuf[6]; 5035 5036 if (verbose) 5037 printf("Run test53\n"); 5038 5039 buf[0] = 98; 5040 buf[1] = 0; 5041 buf[2] = 0; 5042 buf[3] = 0; 5043 buf[4] = 0; 5044 buf[5] = 0; 5045 ibuf[0] = 0; 5046 ibuf[1] = 0; 5047 ibuf[2] = 0; 5048 ibuf[3] = 0; 5049 ibuf[4] = 67; 5050 ibuf[5] = 38; 5051 5052 sljit_emit_enter(compiler, 0, 2, 2, 2, 0, 0, 0); 5053 5054 #if (defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86) 5055 if (sljit_x86_is_cmov_available()) { 5056 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 17); 5057 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, 34); 5058 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_S, SLJIT_UNUSED, 0, SLJIT_R0, 0, SLJIT_IMM, -10); 5059 sljit_x86_emit_cmov(compiler, SLJIT_SIG_LESS, SLJIT_R0, SLJIT_R1, 0); 5060 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw), SLJIT_R0, 0); 5061 sljit_x86_emit_cmov(compiler, SLJIT_SIG_GREATER, SLJIT_R0, SLJIT_R1, 0); 5062 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 2 * sizeof(sljit_sw), SLJIT_R0, 0); 5063 5064 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_R0, 0, SLJIT_IMM, 24); 5065 sljit_emit_op2(compiler, SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, SLJIT_R0, 0, SLJIT_IMM, 24); 5066 sljit_x86_emit_cmov(compiler, SLJIT_NOT_EQUAL, SLJIT_R0, SLJIT_MEM1(SLJIT_S0), 0); 5067 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 3 * sizeof(sljit_sw), SLJIT_R0, 0); 5068 sljit_x86_emit_cmov(compiler, SLJIT_EQUAL, SLJIT_R0, SLJIT_MEM1(SLJIT_S0), 0); 5069 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 4 * sizeof(sljit_sw), SLJIT_R0, 0); 5070 sljit_x86_emit_cmov(compiler, SLJIT_EQUAL, SLJIT_R0, SLJIT_IMM, -135); 5071 sljit_emit_op1(compiler, SLJIT_MOV, SLJIT_MEM1(SLJIT_S0), 5 * sizeof(sljit_sw), SLJIT_R0, 0); 5072 5073 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R0, 0, SLJIT_IMM, 177); 5074 sljit_emit_op2(compiler, SLJIT_SUB32 | SLJIT_SET_U, SLJIT_UNUSED, 0, SLJIT_R0, 0, SLJIT_IMM, 177); 5075 sljit_x86_emit_cmov(compiler, SLJIT_LESS32, SLJIT_R0 | SLJIT_I32_OP, SLJIT_MEM1(SLJIT_S1), 4 * sizeof(sljit_s32)); 5076 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_S1), 3 * sizeof(sljit_s32), SLJIT_R0, 0); 5077 sljit_x86_emit_cmov(compiler, SLJIT_GREATER32, SLJIT_R0 | SLJIT_I32_OP, SLJIT_MEM1(SLJIT_S1), 4 * sizeof(sljit_s32)); 5078 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_S1), 2 * sizeof(sljit_s32), SLJIT_R0, 0); 5079 sljit_x86_emit_cmov(compiler, SLJIT_LESS_EQUAL32, SLJIT_R0 | SLJIT_I32_OP, SLJIT_MEM1(SLJIT_S1), 4 * sizeof(sljit_s32)); 5080 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_S1), sizeof(sljit_s32), SLJIT_R0, 0); 5081 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_R1, 0, SLJIT_IMM, 5 * sizeof(sljit_s32)); 5082 sljit_x86_emit_cmov(compiler, SLJIT_GREATER_EQUAL32, SLJIT_R0 | SLJIT_I32_OP, SLJIT_MEM2(SLJIT_S1, SLJIT_R1), 0); 5083 sljit_emit_op1(compiler, SLJIT_MOV32, SLJIT_MEM1(SLJIT_S1), 0, SLJIT_R0, 0); 5084 } 5085 #endif 5086 5087 sljit_emit_return(compiler, SLJIT_UNUSED, 0, 0); 5088 5089 code.code = sljit_generate_code(compiler); 5090 CHECK(compiler); 5091 sljit_free_compiler(compiler); 5092 5093 code.func2((sljit_sw)&buf, (sljit_sw)&ibuf); 5094 5095 #if (defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86) 5096 if (sljit_x86_is_cmov_available()) { 5097 FAILED(buf[1] != 17, "test54 case 1 failed\n"); 5098 FAILED(buf[2] != 34, "test54 case 2 failed\n"); 5099 FAILED(buf[3] != 24, "test54 case 3 failed\n"); 5100 FAILED(buf[4] != 98, "test54 case 4 failed\n"); 5101 FAILED(buf[5] != -135, "test54 case 5 failed\n"); 5102 FAILED(ibuf[0] != 38, "test54 case 6 failed\n"); 5103 FAILED(ibuf[1] != 67, "test54 case 7 failed\n"); 5104 FAILED(ibuf[2] != 177, "test54 case 8 failed\n"); 5105 FAILED(ibuf[3] != 177, "test54 case 9 failed\n"); 5106 } 5107 #endif 5108 5109 FAILED(!compiler, "cannot create compiler\n"); 5110 sljit_free_code(code.code); 5111 successful_tests++; 5112 } 5113 5114 void sljit_test(int argc, char* argv[]) 5115 { 5116 sljit_s32 has_arg = (argc >= 2 && argv[1][0] == '-' && argv[1][2] == '\0'); 5117 verbose = has_arg && argv[1][1] == 'v'; 5118 silent = has_arg && argv[1][1] == 's'; 5119 5120 if (!verbose && !silent) 5121 printf("Pass -v to enable verbose, -s to disable this hint.\n\n"); 5122 5123 #if !(defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED) 5124 test_exec_allocator(); 5125 #endif 5126 test1(); 5127 test2(); 5128 test3(); 5129 test4(); 5130 test5(); 5131 test6(); 5132 test7(); 5133 test8(); 5134 test9(); 5135 test10(); 5136 test11(); 5137 test12(); 5138 test13(); 5139 test14(); 5140 test15(); 5141 test16(); 5142 test17(); 5143 test18(); 5144 test19(); 5145 test20(); 5146 test21(); 5147 test22(); 5148 test23(); 5149 test24(); 5150 test25(); 5151 test26(); 5152 test27(); 5153 test28(); 5154 test29(); 5155 test30(); 5156 test31(); 5157 test32(); 5158 test33(); 5159 test34(); 5160 test35(); 5161 test36(); 5162 test37(); 5163 test38(); 5164 test39(); 5165 test40(); 5166 test41(); 5167 test42(); 5168 test43(); 5169 test44(); 5170 test45(); 5171 test46(); 5172 test47(); 5173 test48(); 5174 test49(); 5175 test50(); 5176 test51(); 5177 test52(); 5178 test53(); 5179 test54(); 5180 5181 #if (defined SLJIT_EXECUTABLE_ALLOCATOR && SLJIT_EXECUTABLE_ALLOCATOR) 5182 sljit_free_unused_memory_exec(); 5183 #endif 5184 5185 # define TEST_COUNT 54 5186 5187 printf("SLJIT tests: "); 5188 if (successful_tests == TEST_COUNT) 5189 printf("all tests are " COLOR_GREEN "PASSED" COLOR_DEFAULT " "); 5190 else 5191 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 / 47); 5192 printf("on " COLOR_ARCH "%s" COLOR_DEFAULT "%s\n", sljit_get_platform_name(), sljit_is_fpu_available() ? " (with fpu)" : " (without fpu)"); 5193 5194 # undef TEST_COUNT 5195 } 5196
Indexes created Tue Sep 30 20:09:53 GMT 2025