qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2024-11-13 08:27:39 +00:00
Code Issues Projects Releases Packages Wiki Activity
quakeforge/libs/gamecode/test/test-conv4.c

199 lines
7.6 KiB
C
Raw Normal View History

[gamecode] Correct incorrect bool64-bool32 conversion And add tests for float, uint and bool32 conversions.
2022-01-14 04:38:05 +00:00
#include "head.c"
#include "QF/mathlib.h"
static pr_ivec4_t uint_conv_init[] = {
{ 5, -5, 0x80000000, 0x7fffffff}, //int
{ 0x3fc00000, 0xbfc00000, 0x7149f2ca, 0xf149f2ca}, //float 1e30, -1e30
{ 99, 0x80000000, 0x80000000, 99}, //long
{ 256, 0, 0x7fffffff, 0}, //long
{ 0x39a08cea, 0x46293e59, 0x39a08cea, 0xc6293e59}, //double 1e30, -1e30
{ 0, 0x3ff80000, 0, 0xbff80000}, //double 1.5, -1.5
{ 5, -5, 0x80000000, 0x7fffffff}, //uint
{ ~0, 1, 0x80000000, 0}, //bool32
{ 99, 0x80000000, 0x80000000, 99}, //ulong
{ 256, 0, 0x7fffffff, 0}, //ulong
{ ~0, ~0, ~0, 0}, //bool64
{ 0, ~0, 0, 0}, //bool64
{ 0, 0, 0, 0},
{ 0, 0, 0, 0},
{ 0, 0, 0, 0},
{ 0, 0, 0, 0},
{ 0, 0, 0, 0},
{ 0, 0, 0, 0},
{ 0, 0, 0, 0},
{ 0, 0, 0, 0},
};
[gamecode] Document the tests that fail under clang The tests fail due to differences in how clang and gcc treat floating point to unsigned integral type conversions when the values overflow. It wouldn't be so bad if clang was consistent with conversions to 32-bit unsigned integers, like it seems to be with conversion to 64-bit unsigned integers. With this, the "get QF building with clang" mini-project is done and I won't have to panic when someone comes to me and asks if it will work. At worst, there'll be a little bit-rot.
2022-03-31 05:47:04 +00:00
/* Note that these tests (specifically 1, 3a and 3b) fail when compiled with
* clang and optimzing due to difference between clang and gcc, and more
* interestingly, within clang itself: with optimization enabled, the entries
* marked with "undef?" produce 0x80000000 instead of 0, but with optimization
* disabled, the expected 0 is produced.
* Inspecting the results, it seems that clang sets negative floats and doubles
* to 0 when casting to unsigned long, but not consistently.
*/
[gamecode] Correct incorrect bool64-bool32 conversion And add tests for float, uint and bool32 conversions.
2022-01-14 04:38:05 +00:00
static pr_ivec4_t uint_conv_expect[] = {
{ 5, -5, 0x80000000, 0x7fffffff}, //int
{ 0x3fc00000, 0xbfc00000, 0x7149f2ca, 0xf149f2ca}, //float
{ 99, 0x80000000, 0x80000000, 99}, //long
{ 256, 0, 0x7fffffff, 0}, //long
{ 0x39a08cea, 0x46293e59, 0x39a08cea, 0xc6293e59}, //double 1e30, -1e30
{ 0, 0x3ff80000, 0, 0xbff80000}, //double 1.5, -1.5
{ 5, -5, 0x80000000, 0x7fffffff}, //uint
{ ~0, 1, 0x80000000, 0}, //bool32
{ 99, 0x80000000, 0x80000000, 99}, //ulong
{ 256, 0, 0x7fffffff, 0}, //ulong
{ ~0, ~0, ~0, 0}, //bool64
{ 0, ~0, 0, 0}, //bool64
[gamecode] Make no-op conversions simple copies Most useful for 64-bit values as only one instruction is needed to move the data around rather than two, but could be slightly faster for 32-bit as the addressing is simpler (needs profiling).
2022-01-15 06:44:53 +00:00
{ 5, -5, 0x80000000, 0x7fffffff}, // int
[gamecode] Mention possibly undefined behavior It seems casting from float/double to [unsigned] int/long when the value doesn't fit is undefined (which would explain the inconsistent results). Mentioning the possibility seems like a good idea should the results for such casts change and cause the tests to fail.
2022-01-14 07:52:44 +00:00
{ 1, 0xffffffff, 0, 0}, // float undef?
[gamecode] Correct incorrect bool64-bool32 conversion And add tests for float, uint and bool32 conversions.
2022-01-14 04:38:05 +00:00
{ 99, 0x80000000, 256, 0x7fffffff}, // long
[gamecode] Mention possibly undefined behavior It seems casting from float/double to [unsigned] int/long when the value doesn't fit is undefined (which would explain the inconsistent results). Mentioning the possibility seems like a good idea should the results for such casts change and cause the tests to fail.
2022-01-14 07:52:44 +00:00
{ 0, 0, 1, 0xffffffff}, // double undef?
[gamecode] Make no-op conversions simple copies Most useful for 64-bit values as only one instruction is needed to move the data around rather than two, but could be slightly faster for 32-bit as the addressing is simpler (needs profiling).
2022-01-15 06:44:53 +00:00
{ 5, -5, 0x80000000, 0x7fffffff}, // uint
[gamecode] Correct incorrect bool64-bool32 conversion And add tests for float, uint and bool32 conversions.
2022-01-14 04:38:05 +00:00
{ 1, 1, 1, 0}, // bool32
{ 99, 0x80000000, 256, 0x7fffffff}, // ulong
{ 1, 1, 1, 0}, // bool64
};
static dstatement_t uint_conv_1_statements[] = {
{ OP(0, 0, 0, OP_LEA_A), 4, 0, 80 }, // init index
{ OP(0, 0, 0, OP_LEA_A), 8, 0, 81 }, // init index for 64-bits
//loop:
{ OP(0, 0, 0, OP_LEA_C), 80, -1, 80 }, // dec index
{ OP(0, 0, 0, OP_LEA_C), 81, -2, 81 }, // dec index for 64-bits
[gamecode] Rearrange several instructions ANY/ALL/NONE have been temporarily removed until I implement the HOPS (horizontal operations) sub-instructions, which will all both 32-bit and 64-bit operands and several other operations (eg, horizontal add). All the fancy addressing modes for the conditional branch instructions have been permanently removed: I decided the gain was too little for the cost (24 instructions vs 6). JUMP and CALL retain their addressing modes, though. Other instructions have been shuffled around a little to fill most of the holes in the upper block of 256 instructions: just a single small 7-instruction hole. Rearrangements in the actual engine are mostly just to keep the code organized. The only real changes were the various IF statements and dealing with the resulting changes in their addressing.
2022-01-16 05:22:04 +00:00
{ OP(0, 0, 0, OP_IFAE), 2, 0, 80 },
[gamecode] Correct incorrect bool64-bool32 conversion And add tests for float, uint and bool32 conversions.
2022-01-14 04:38:05 +00:00
{ OP(0, 0, 0, OP_BREAK), 0, 0, 0 },
{ OP(0, 0, 0, OP_WITH), 4, 80, 1 },
{ OP(0, 0, 0, OP_WITH), 4, 81, 2 },
[gamecode] Make no-op conversions simple copies Most useful for 64-bit values as only one instruction is needed to move the data around rather than two, but could be slightly faster for 32-bit as the addressing is simpler (needs profiling).
2022-01-15 06:44:53 +00:00
{ OP(1, 1, 1, OP_CONV), 0, 0004, 48 },
[gamecode] Correct incorrect bool64-bool32 conversion And add tests for float, uint and bool32 conversions.
2022-01-14 04:38:05 +00:00
{ OP(1, 1, 1, OP_CONV), 4, 0014, 52 },
{ OP(2, 1, 1, OP_CONV), 8, 0024, 56 },
{ OP(2, 1, 1, OP_CONV), 16, 0034, 60 },
[gamecode] Make no-op conversions simple copies Most useful for 64-bit values as only one instruction is needed to move the data around rather than two, but could be slightly faster for 32-bit as the addressing is simpler (needs profiling).
2022-01-15 06:44:53 +00:00
{ OP(1, 1, 1, OP_CONV), 24, 0044, 64 },
[gamecode] Correct incorrect bool64-bool32 conversion And add tests for float, uint and bool32 conversions.
2022-01-14 04:38:05 +00:00
{ OP(1, 1, 1, OP_CONV), 28, 0054, 68 },
{ OP(2, 1, 1, OP_CONV), 32, 0064, 72 },
{ OP(2, 1, 1, OP_CONV), 40, 0074, 76 },
[gamecode] Make no-op conversions simple copies Most useful for 64-bit values as only one instruction is needed to move the data around rather than two, but could be slightly faster for 32-bit as the addressing is simpler (needs profiling).
2022-01-15 06:44:53 +00:00
{ OP(1, 1, 1, OP_JUMP_A), -14, 0, 0 },
[gamecode] Correct incorrect bool64-bool32 conversion And add tests for float, uint and bool32 conversions.
2022-01-14 04:38:05 +00:00
};
static dstatement_t uint_conv_2_statements[] = {
{ OP(0, 0, 0, OP_LEA_A), 4, 0, 80 }, // index
{ OP(0, 0, 0, OP_LEA_A), 8, 0, 81 }, // init index for 64-bits
//loop:
{ OP(0, 0, 0, OP_LEA_C), 80, -2, 80 }, // dec index
{ OP(0, 0, 0, OP_LEA_C), 81, -4, 81 }, // dec index for 64-bits
[gamecode] Rearrange several instructions ANY/ALL/NONE have been temporarily removed until I implement the HOPS (horizontal operations) sub-instructions, which will all both 32-bit and 64-bit operands and several other operations (eg, horizontal add). All the fancy addressing modes for the conditional branch instructions have been permanently removed: I decided the gain was too little for the cost (24 instructions vs 6). JUMP and CALL retain their addressing modes, though. Other instructions have been shuffled around a little to fill most of the holes in the upper block of 256 instructions: just a single small 7-instruction hole. Rearrangements in the actual engine are mostly just to keep the code organized. The only real changes were the various IF statements and dealing with the resulting changes in their addressing.
2022-01-16 05:22:04 +00:00
{ OP(0, 0, 0, OP_IFAE), 2, 0, 80 },
[gamecode] Correct incorrect bool64-bool32 conversion And add tests for float, uint and bool32 conversions.
2022-01-14 04:38:05 +00:00
{ OP(0, 0, 0, OP_BREAK), 0, 0, 0 },
{ OP(0, 0, 0, OP_WITH), 4, 80, 1 },
{ OP(0, 0, 0, OP_WITH), 4, 81, 2 },
[gamecode] Make no-op conversions simple copies Most useful for 64-bit values as only one instruction is needed to move the data around rather than two, but could be slightly faster for 32-bit as the addressing is simpler (needs profiling).
2022-01-15 06:44:53 +00:00
{ OP(1, 1, 1, OP_CONV), 0, 0104, 48 },
[gamecode] Correct incorrect bool64-bool32 conversion And add tests for float, uint and bool32 conversions.
2022-01-14 04:38:05 +00:00
{ OP(1, 1, 1, OP_CONV), 4, 0114, 52 },
{ OP(2, 1, 1, OP_CONV), 8, 0124, 56 },
{ OP(2, 1, 1, OP_CONV), 16, 0134, 60 },
[gamecode] Make no-op conversions simple copies Most useful for 64-bit values as only one instruction is needed to move the data around rather than two, but could be slightly faster for 32-bit as the addressing is simpler (needs profiling).
2022-01-15 06:44:53 +00:00
{ OP(1, 1, 1, OP_CONV), 24, 0144, 64 },
[gamecode] Correct incorrect bool64-bool32 conversion And add tests for float, uint and bool32 conversions.
2022-01-14 04:38:05 +00:00
{ OP(1, 1, 1, OP_CONV), 28, 0154, 68 },
{ OP(2, 1, 1, OP_CONV), 32, 0164, 72 },
{ OP(2, 1, 1, OP_CONV), 40, 0174, 76 },
[gamecode] Make no-op conversions simple copies Most useful for 64-bit values as only one instruction is needed to move the data around rather than two, but could be slightly faster for 32-bit as the addressing is simpler (needs profiling).
2022-01-15 06:44:53 +00:00
{ OP(1, 1, 1, OP_JUMP_A), -14, 0, 0 },
[gamecode] Correct incorrect bool64-bool32 conversion And add tests for float, uint and bool32 conversions.
2022-01-14 04:38:05 +00:00
};
static dstatement_t uint_conv_3a_statements[] = {
[gamecode] Make no-op conversions simple copies Most useful for 64-bit values as only one instruction is needed to move the data around rather than two, but could be slightly faster for 32-bit as the addressing is simpler (needs profiling).
2022-01-15 06:44:53 +00:00
{ OP(1, 1, 1, OP_CONV), 0, 0204, 48 },
{ OP(1, 1, 1, OP_CONV), 3, 0004, 51 },
[gamecode] Correct incorrect bool64-bool32 conversion And add tests for float, uint and bool32 conversions.
2022-01-14 04:38:05 +00:00
{ OP(1, 1, 1, OP_CONV), 4, 0214, 52 },
{ OP(1, 1, 1, OP_CONV), 7, 0014, 55 },
{ OP(2, 1, 1, OP_CONV), 8, 0224, 56 },
{ OP(2, 1, 1, OP_CONV), 14, 0024, 59 },
{ OP(2, 1, 1, OP_CONV), 16, 0234, 60 },
{ OP(2, 1, 1, OP_CONV), 22, 0034, 63 },
[gamecode] Make no-op conversions simple copies Most useful for 64-bit values as only one instruction is needed to move the data around rather than two, but could be slightly faster for 32-bit as the addressing is simpler (needs profiling).
2022-01-15 06:44:53 +00:00
{ OP(1, 1, 1, OP_CONV), 24, 0244, 64 },
{ OP(1, 1, 1, OP_CONV), 27, 0044, 67 },
[gamecode] Correct incorrect bool64-bool32 conversion And add tests for float, uint and bool32 conversions.
2022-01-14 04:38:05 +00:00
{ OP(1, 1, 1, OP_CONV), 28, 0254, 68 },
{ OP(1, 1, 1, OP_CONV), 31, 0054, 71 },
{ OP(2, 1, 1, OP_CONV), 32, 0264, 72 },
{ OP(2, 1, 1, OP_CONV), 38, 0064, 75 },
{ OP(2, 1, 1, OP_CONV), 40, 0274, 76 },
{ OP(2, 1, 1, OP_CONV), 46, 0074, 79 },
};
static dstatement_t uint_conv_3b_statements[] = {
[gamecode] Make no-op conversions simple copies Most useful for 64-bit values as only one instruction is needed to move the data around rather than two, but could be slightly faster for 32-bit as the addressing is simpler (needs profiling).
2022-01-15 06:44:53 +00:00
{ OP(1, 1, 1, OP_CONV), 0, 0004, 48 },
{ OP(1, 1, 1, OP_CONV), 1, 0204, 49 },
[gamecode] Correct incorrect bool64-bool32 conversion And add tests for float, uint and bool32 conversions.
2022-01-14 04:38:05 +00:00
{ OP(1, 1, 1, OP_CONV), 4, 0014, 52 },
{ OP(1, 1, 1, OP_CONV), 5, 0214, 53 },
{ OP(2, 1, 1, OP_CONV), 8, 0024, 56 },
{ OP(2, 1, 1, OP_CONV), 10, 0224, 57 },
{ OP(2, 1, 1, OP_CONV), 16, 0034, 60 },
{ OP(2, 1, 1, OP_CONV), 18, 0234, 61 },
[gamecode] Make no-op conversions simple copies Most useful for 64-bit values as only one instruction is needed to move the data around rather than two, but could be slightly faster for 32-bit as the addressing is simpler (needs profiling).
2022-01-15 06:44:53 +00:00
{ OP(1, 1, 1, OP_CONV), 24, 0044, 64 },
{ OP(1, 1, 1, OP_CONV), 25, 0244, 65 },
[gamecode] Correct incorrect bool64-bool32 conversion And add tests for float, uint and bool32 conversions.
2022-01-14 04:38:05 +00:00
{ OP(1, 1, 1, OP_CONV), 28, 0054, 68 },
{ OP(1, 1, 1, OP_CONV), 29, 0254, 69 },
{ OP(2, 1, 1, OP_CONV), 32, 0064, 72 },
{ OP(2, 1, 1, OP_CONV), 34, 0264, 73 },
{ OP(2, 1, 1, OP_CONV), 40, 0074, 76 },
{ OP(2, 1, 1, OP_CONV), 42, 0274, 77 },
};
static dstatement_t uint_conv_4_statements[] = {
[gamecode] Make no-op conversions simple copies Most useful for 64-bit values as only one instruction is needed to move the data around rather than two, but could be slightly faster for 32-bit as the addressing is simpler (needs profiling).
2022-01-15 06:44:53 +00:00
{ OP(1, 1, 1, OP_CONV), 0, 0304, 48 },
[gamecode] Correct incorrect bool64-bool32 conversion And add tests for float, uint and bool32 conversions.
2022-01-14 04:38:05 +00:00
{ OP(1, 1, 1, OP_CONV), 4, 0314, 52 },
{ OP(2, 1, 1, OP_CONV), 8, 0324, 56 },
{ OP(2, 1, 1, OP_CONV), 16, 0334, 60 },
[gamecode] Make no-op conversions simple copies Most useful for 64-bit values as only one instruction is needed to move the data around rather than two, but could be slightly faster for 32-bit as the addressing is simpler (needs profiling).
2022-01-15 06:44:53 +00:00
{ OP(1, 1, 1, OP_CONV), 24, 0344, 64 },
[gamecode] Correct incorrect bool64-bool32 conversion And add tests for float, uint and bool32 conversions.
2022-01-14 04:38:05 +00:00
{ OP(1, 1, 1, OP_CONV), 28, 0354, 68 },
{ OP(2, 1, 1, OP_CONV), 32, 0364, 72 },
{ OP(2, 1, 1, OP_CONV), 40, 0374, 76 },
};
test_t tests[] = {
{
.desc = "uint conv 1",
.extra_globals = 4 * 1,
[gamecode] Make num_globals() calculate actual globals It calculating only the size of the array (which was often 4 or 8 globals per element) proved to be a pain when I forgot to alter the size for the new scale tests. Fixing the size calculation even found a bug in the shiftop tests.
2022-01-14 10:43:34 +00:00
.num_globals = num_globals(uint_conv_init,uint_conv_expect),
[gamecode] Correct incorrect bool64-bool32 conversion And add tests for float, uint and bool32 conversions.
2022-01-14 04:38:05 +00:00
.num_statements = num_statements (uint_conv_1_statements),
.statements = uint_conv_1_statements,
.init_globals = (pr_int_t *) uint_conv_init,
.expect_globals = (pr_int_t *) uint_conv_expect,
},
{
.desc = "uint conv 2",
.extra_globals = 4 * 1,
[gamecode] Make num_globals() calculate actual globals It calculating only the size of the array (which was often 4 or 8 globals per element) proved to be a pain when I forgot to alter the size for the new scale tests. Fixing the size calculation even found a bug in the shiftop tests.
2022-01-14 10:43:34 +00:00
.num_globals = num_globals(uint_conv_init,uint_conv_expect),
[gamecode] Correct incorrect bool64-bool32 conversion And add tests for float, uint and bool32 conversions.
2022-01-14 04:38:05 +00:00
.num_statements = num_statements (uint_conv_2_statements),
.statements = uint_conv_2_statements,
.init_globals = (pr_int_t *) uint_conv_init,
.expect_globals = (pr_int_t *) uint_conv_expect,
},
{
.desc = "uint conv 3a",
.extra_globals = 4 * 1,
[gamecode] Make num_globals() calculate actual globals It calculating only the size of the array (which was often 4 or 8 globals per element) proved to be a pain when I forgot to alter the size for the new scale tests. Fixing the size calculation even found a bug in the shiftop tests.
2022-01-14 10:43:34 +00:00
.num_globals = num_globals(uint_conv_init,uint_conv_expect),
[gamecode] Correct incorrect bool64-bool32 conversion And add tests for float, uint and bool32 conversions.
2022-01-14 04:38:05 +00:00
.num_statements = num_statements (uint_conv_3a_statements),
.statements = uint_conv_3a_statements,
.init_globals = (pr_int_t *) uint_conv_init,
.expect_globals = (pr_int_t *) uint_conv_expect,
},
{
.desc = "uint conv 3b",
.extra_globals = 4 * 1,
[gamecode] Make num_globals() calculate actual globals It calculating only the size of the array (which was often 4 or 8 globals per element) proved to be a pain when I forgot to alter the size for the new scale tests. Fixing the size calculation even found a bug in the shiftop tests.
2022-01-14 10:43:34 +00:00
.num_globals = num_globals(uint_conv_init,uint_conv_expect),
[gamecode] Correct incorrect bool64-bool32 conversion And add tests for float, uint and bool32 conversions.
2022-01-14 04:38:05 +00:00
.num_statements = num_statements (uint_conv_3b_statements),
.statements = uint_conv_3b_statements,
.init_globals = (pr_int_t *) uint_conv_init,
.expect_globals = (pr_int_t *) uint_conv_expect,
},
{
.desc = "uint conv 4",
.extra_globals = 4 * 1,
[gamecode] Make num_globals() calculate actual globals It calculating only the size of the array (which was often 4 or 8 globals per element) proved to be a pain when I forgot to alter the size for the new scale tests. Fixing the size calculation even found a bug in the shiftop tests.
2022-01-14 10:43:34 +00:00
.num_globals = num_globals(uint_conv_init,uint_conv_expect),
[gamecode] Correct incorrect bool64-bool32 conversion And add tests for float, uint and bool32 conversions.
2022-01-14 04:38:05 +00:00
.num_statements = num_statements (uint_conv_4_statements),
.statements = uint_conv_4_statements,
.init_globals = (pr_int_t *) uint_conv_init,
.expect_globals = (pr_int_t *) uint_conv_expect,
},
};
#include "main.c"
Reference in a new issue Copy permalink