qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2024-11-10 15:22:04 +00:00
Code Issues Projects Releases Packages Wiki Activity
quakeforge/libs/gamecode/test/test-conv0.c

191 lines
7.1 KiB
C
Raw Normal View History

[gamecode] Add tests for converting to int They currently fail because for vector values, gcc casts the view, not the value, so vec4 cast to ivec4 simply views the bits as int rather than doing the actual conversion.
2022-01-14 02:24:01 +00:00
#include "head.c"
#include "QF/mathlib.h"
static pr_ivec4_t int_conv_init[] = {
{ 5, -5, 0x80000000, 0x7fffffff}, //int
[gamecode] Fix a pile of UB in the test cases I always suspected the overflow conversions were UB, but with gcc doing different things on arm, I thought it was about time to abandon those particular tests. What I was not expecting was for the return value of strcmp to be "UB" (in that there's no guarantee of the exact value, just < = > 0). Fortunately, nothing actually relies on the value of the op other than the tests, so modify the test to make the behavior well defined.
2023-03-25 07:46:46 +00:00
{ 0x3fc00000, 0xbfc00000, 0x40100000, 0xc0100000}, //float 1.5, -1.5, 2.25, -2.25
[gamecode] Add tests for converting to int They currently fail because for vector values, gcc casts the view, not the value, so vec4 cast to ivec4 simply views the bits as int rather than doing the actual conversion.
2022-01-14 02:24:01 +00:00
{ 99, 0x80000000, 0x80000000, 99}, //long
{ 256, 0, 0x7fffffff, 0}, //long
{ 0, 0x3ff80000, 0, 0xbff80000}, //double 1.5, -1.5
[gamecode] Fix a pile of UB in the test cases I always suspected the overflow conversions were UB, but with gcc doing different things on arm, I thought it was about time to abandon those particular tests. What I was not expecting was for the return value of strcmp to be "UB" (in that there's no guarantee of the exact value, just < = > 0). Fortunately, nothing actually relies on the value of the op other than the tests, so modify the test to make the behavior well defined.
2023-03-25 07:46:46 +00:00
{ 0, 0x40020000, 0, 0xc0020000}, //double 2.25, -2.25
[gamecode] Add tests for converting to int They currently fail because for vector values, gcc casts the view, not the value, so vec4 cast to ivec4 simply views the bits as int rather than doing the actual conversion.
2022-01-14 02:24:01 +00:00
{ 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},
};
static pr_ivec4_t int_conv_expect[] = {
{ 5, -5, 0x80000000, 0x7fffffff}, //int
[gamecode] Fix a pile of UB in the test cases I always suspected the overflow conversions were UB, but with gcc doing different things on arm, I thought it was about time to abandon those particular tests. What I was not expecting was for the return value of strcmp to be "UB" (in that there's no guarantee of the exact value, just < = > 0). Fortunately, nothing actually relies on the value of the op other than the tests, so modify the test to make the behavior well defined.
2023-03-25 07:46:46 +00:00
{ 0x3fc00000, 0xbfc00000, 0x40100000, 0xc0100000}, //float 1.5, -1.5, 2.25, -2.25
[gamecode] Add tests for converting to int They currently fail because for vector values, gcc casts the view, not the value, so vec4 cast to ivec4 simply views the bits as int rather than doing the actual conversion.
2022-01-14 02:24:01 +00:00
{ 99, 0x80000000, 0x80000000, 99}, //long
{ 256, 0, 0x7fffffff, 0}, //long
{ 0, 0x3ff80000, 0, 0xbff80000}, //double 1.5, -1.5
[gamecode] Fix a pile of UB in the test cases I always suspected the overflow conversions were UB, but with gcc doing different things on arm, I thought it was about time to abandon those particular tests. What I was not expecting was for the return value of strcmp to be "UB" (in that there's no guarantee of the exact value, just < = > 0). Fortunately, nothing actually relies on the value of the op other than the tests, so modify the test to make the behavior well defined.
2023-03-25 07:46:46 +00:00
{ 0, 0x40020000, 0, 0xc0020000}, //double 2.25, -2.25
[gamecode] Add tests for converting to int They currently fail because for vector values, gcc casts the view, not the value, so vec4 cast to ivec4 simply views the bits as int rather than doing the actual conversion.
2022-01-14 02:24:01 +00:00
{ 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] Fix a pile of UB in the test cases I always suspected the overflow conversions were UB, but with gcc doing different things on arm, I thought it was about time to abandon those particular tests. What I was not expecting was for the return value of strcmp to be "UB" (in that there's no guarantee of the exact value, just < = > 0). Fortunately, nothing actually relies on the value of the op other than the tests, so modify the test to make the behavior well defined.
2023-03-25 07:46:46 +00:00
{ 1, -1, 2, -2}, // float
[gamecode] Add tests for converting to int They currently fail because for vector values, gcc casts the view, not the value, so vec4 cast to ivec4 simply views the bits as int rather than doing the actual conversion.
2022-01-14 02:24:01 +00:00
{ 99, 0x80000000, 256, 0x7fffffff}, // long
[gamecode] Fix a pile of UB in the test cases I always suspected the overflow conversions were UB, but with gcc doing different things on arm, I thought it was about time to abandon those particular tests. What I was not expecting was for the return value of strcmp to be "UB" (in that there's no guarantee of the exact value, just < = > 0). Fortunately, nothing actually relies on the value of the op other than the tests, so modify the test to make the behavior well defined.
2023-03-25 07:46:46 +00:00
{ 1, -1, 2, -2}, // double
[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] Add tests for converting to int They currently fail because for vector values, gcc casts the view, not the value, so vec4 cast to ivec4 simply views the bits as int rather than doing the actual conversion.
2022-01-14 02:24:01 +00:00
{ 1, 1, 1, 0}, // bool32
{ 99, 0x80000000, 256, 0x7fffffff}, // ulong
{ 1, 1, 1, 0}, // bool64
};
static dstatement_t int_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] Add tests for converting to int They currently fail because for vector values, gcc casts the view, not the value, so vec4 cast to ivec4 simply views the bits as int rather than doing the actual conversion.
2022-01-14 02:24:01 +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, 0000, 48 },
[gamecode] Add tests for converting to int They currently fail because for vector values, gcc casts the view, not the value, so vec4 cast to ivec4 simply views the bits as int rather than doing the actual conversion.
2022-01-14 02:24:01 +00:00
{ OP(1, 1, 1, OP_CONV), 4, 0010, 52 },
{ OP(2, 1, 1, OP_CONV), 8, 0020, 56 },
{ OP(2, 1, 1, OP_CONV), 16, 0030, 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, 0040, 64 },
[gamecode] Add tests for converting to int They currently fail because for vector values, gcc casts the view, not the value, so vec4 cast to ivec4 simply views the bits as int rather than doing the actual conversion.
2022-01-14 02:24:01 +00:00
{ OP(1, 1, 1, OP_CONV), 28, 0050, 68 },
{ OP(2, 1, 1, OP_CONV), 32, 0060, 72 },
{ OP(2, 1, 1, OP_CONV), 40, 0070, 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] Add tests for converting to int They currently fail because for vector values, gcc casts the view, not the value, so vec4 cast to ivec4 simply views the bits as int rather than doing the actual conversion.
2022-01-14 02:24:01 +00:00
};
static dstatement_t int_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] Add tests for converting to int They currently fail because for vector values, gcc casts the view, not the value, so vec4 cast to ivec4 simply views the bits as int rather than doing the actual conversion.
2022-01-14 02:24:01 +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, 0100, 48 },
[gamecode] Add tests for converting to int They currently fail because for vector values, gcc casts the view, not the value, so vec4 cast to ivec4 simply views the bits as int rather than doing the actual conversion.
2022-01-14 02:24:01 +00:00
{ OP(1, 1, 1, OP_CONV), 4, 0110, 52 },
{ OP(2, 1, 1, OP_CONV), 8, 0120, 56 },
{ OP(2, 1, 1, OP_CONV), 16, 0130, 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, 0140, 64 },
[gamecode] Add tests for converting to int They currently fail because for vector values, gcc casts the view, not the value, so vec4 cast to ivec4 simply views the bits as int rather than doing the actual conversion.
2022-01-14 02:24:01 +00:00
{ OP(1, 1, 1, OP_CONV), 28, 0150, 68 },
{ OP(2, 1, 1, OP_CONV), 32, 0160, 72 },
{ OP(2, 1, 1, OP_CONV), 40, 0170, 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] Add tests for converting to int They currently fail because for vector values, gcc casts the view, not the value, so vec4 cast to ivec4 simply views the bits as int rather than doing the actual conversion.
2022-01-14 02:24:01 +00:00
};
static dstatement_t int_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, 0200, 48 },
{ OP(1, 1, 1, OP_CONV), 3, 0200, 51 },
[gamecode] Add tests for converting to int They currently fail because for vector values, gcc casts the view, not the value, so vec4 cast to ivec4 simply views the bits as int rather than doing the actual conversion.
2022-01-14 02:24:01 +00:00
{ OP(1, 1, 1, OP_CONV), 4, 0210, 52 },
{ OP(1, 1, 1, OP_CONV), 7, 0010, 55 },
{ OP(2, 1, 1, OP_CONV), 8, 0220, 56 },
{ OP(2, 1, 1, OP_CONV), 14, 0020, 59 },
{ OP(2, 1, 1, OP_CONV), 16, 0230, 60 },
{ OP(2, 1, 1, OP_CONV), 22, 0030, 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, 0240, 64 },
{ OP(1, 1, 1, OP_CONV), 27, 0240, 67 },
[gamecode] Add tests for converting to int They currently fail because for vector values, gcc casts the view, not the value, so vec4 cast to ivec4 simply views the bits as int rather than doing the actual conversion.
2022-01-14 02:24:01 +00:00
{ OP(1, 1, 1, OP_CONV), 28, 0250, 68 },
{ OP(1, 1, 1, OP_CONV), 31, 0050, 71 },
{ OP(2, 1, 1, OP_CONV), 32, 0260, 72 },
{ OP(2, 1, 1, OP_CONV), 38, 0060, 75 },
{ OP(2, 1, 1, OP_CONV), 40, 0270, 76 },
{ OP(2, 1, 1, OP_CONV), 46, 0070, 79 },
};
static dstatement_t int_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, 0200, 48 },
{ OP(1, 1, 1, OP_CONV), 1, 0200, 49 },
[gamecode] Add tests for converting to int They currently fail because for vector values, gcc casts the view, not the value, so vec4 cast to ivec4 simply views the bits as int rather than doing the actual conversion.
2022-01-14 02:24:01 +00:00
{ OP(1, 1, 1, OP_CONV), 4, 0010, 52 },
{ OP(1, 1, 1, OP_CONV), 5, 0210, 53 },
{ OP(2, 1, 1, OP_CONV), 8, 0020, 56 },
{ OP(2, 1, 1, OP_CONV), 10, 0220, 57 },
{ OP(2, 1, 1, OP_CONV), 16, 0030, 60 },
{ OP(2, 1, 1, OP_CONV), 18, 0230, 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, 0240, 64 },
{ OP(1, 1, 1, OP_CONV), 25, 0240, 65 },
[gamecode] Add tests for converting to int They currently fail because for vector values, gcc casts the view, not the value, so vec4 cast to ivec4 simply views the bits as int rather than doing the actual conversion.
2022-01-14 02:24:01 +00:00
{ OP(1, 1, 1, OP_CONV), 28, 0050, 68 },
{ OP(1, 1, 1, OP_CONV), 29, 0250, 69 },
{ OP(2, 1, 1, OP_CONV), 32, 0060, 72 },
{ OP(2, 1, 1, OP_CONV), 34, 0260, 73 },
{ OP(2, 1, 1, OP_CONV), 40, 0070, 76 },
{ OP(2, 1, 1, OP_CONV), 42, 0270, 77 },
};
static dstatement_t int_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, 0300, 48 },
[gamecode] Add tests for converting to int They currently fail because for vector values, gcc casts the view, not the value, so vec4 cast to ivec4 simply views the bits as int rather than doing the actual conversion.
2022-01-14 02:24:01 +00:00
{ OP(1, 1, 1, OP_CONV), 4, 0310, 52 },
{ OP(2, 1, 1, OP_CONV), 8, 0320, 56 },
{ OP(2, 1, 1, OP_CONV), 16, 0330, 60 },
{ OP(1, 1, 1, OP_CONV), 28, 0350, 68 },
{ OP(2, 1, 1, OP_CONV), 32, 0360, 72 },
{ OP(2, 1, 1, OP_CONV), 40, 0370, 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_CONV), 24, 0340, 64 },
[gamecode] Add tests for converting to int They currently fail because for vector values, gcc casts the view, not the value, so vec4 cast to ivec4 simply views the bits as int rather than doing the actual conversion.
2022-01-14 02:24:01 +00:00
};
test_t tests[] = {
{
.desc = "int 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(int_conv_init,int_conv_expect),
[gamecode] Add tests for converting to int They currently fail because for vector values, gcc casts the view, not the value, so vec4 cast to ivec4 simply views the bits as int rather than doing the actual conversion.
2022-01-14 02:24:01 +00:00
.num_statements = num_statements (int_conv_1_statements),
.statements = int_conv_1_statements,
.init_globals = (pr_int_t *) int_conv_init,
.expect_globals = (pr_int_t *) int_conv_expect,
},
{
.desc = "int 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(int_conv_init,int_conv_expect),
[gamecode] Add tests for converting to int They currently fail because for vector values, gcc casts the view, not the value, so vec4 cast to ivec4 simply views the bits as int rather than doing the actual conversion.
2022-01-14 02:24:01 +00:00
.num_statements = num_statements (int_conv_2_statements),
.statements = int_conv_2_statements,
.init_globals = (pr_int_t *) int_conv_init,
.expect_globals = (pr_int_t *) int_conv_expect,
},
{
.desc = "int 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(int_conv_init,int_conv_expect),
[gamecode] Add tests for converting to int They currently fail because for vector values, gcc casts the view, not the value, so vec4 cast to ivec4 simply views the bits as int rather than doing the actual conversion.
2022-01-14 02:24:01 +00:00
.num_statements = num_statements (int_conv_3a_statements),
.statements = int_conv_3a_statements,
.init_globals = (pr_int_t *) int_conv_init,
.expect_globals = (pr_int_t *) int_conv_expect,
},
{
.desc = "int 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(int_conv_init,int_conv_expect),
[gamecode] Add tests for converting to int They currently fail because for vector values, gcc casts the view, not the value, so vec4 cast to ivec4 simply views the bits as int rather than doing the actual conversion.
2022-01-14 02:24:01 +00:00
.num_statements = num_statements (int_conv_3b_statements),
.statements = int_conv_3b_statements,
.init_globals = (pr_int_t *) int_conv_init,
.expect_globals = (pr_int_t *) int_conv_expect,
},
{
.desc = "int 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(int_conv_init,int_conv_expect),
[gamecode] Add tests for converting to int They currently fail because for vector values, gcc casts the view, not the value, so vec4 cast to ivec4 simply views the bits as int rather than doing the actual conversion.
2022-01-14 02:24:01 +00:00
.num_statements = num_statements (int_conv_4_statements),
.statements = int_conv_4_statements,
.init_globals = (pr_int_t *) int_conv_init,
.expect_globals = (pr_int_t *) int_conv_expect,
},
};
#include "main.c"
Reference in a new issue Copy permalink