diff --git a/libs/gamecode/extend.py b/libs/gamecode/extend.py index 99aa9ed81..3d792c469 100644 --- a/libs/gamecode/extend.py +++ b/libs/gamecode/extend.py @@ -1,4 +1,5 @@ -print("""// encoding is teemmm +print("""// encoding is rteemmm +// r = 0: forward, r = 1: reverse (also reverses component order for 2 and 3) // t = 0: 32-bit, t = 1: 64-bit // e = 00: 0 // e = 01: 1.0 @@ -29,9 +30,9 @@ extend = [ ["0", "INT64_C(0x3ff0000000000000)", "0", "INT64_C(0xbff0000000000000)"], ] -def case_str(type, ext, mode): - case = (type << 5) | (ext << 3) | (mode) - return f"case {case:03o}:" +def case_str(reverse, type, ext, mode): + case = (reverse << 6) | (type << 5) | (ext << 3) | (mode) + return f"case {case:04o}:" def dst_str(type, ext, mode): return f"OPC({types[type][mode]})" @@ -39,39 +40,61 @@ def dst_str(type, ext, mode): def cast_str(type, ext, mode): return f"(pr_{types[type][mode]}_t)" -def init_str(type, ext, mode): +def init_str(reverse, type, ext, mode): ext_str = extend[type][ext] src = f"OPA({src_types[type][mode]})" if mode == 0: if ext == 2: ext_str = src - return f"{src}, {ext_str}" + if reverse: + return f"{ext_str}, {src}" + else: + return f"{src}, {ext_str}" elif mode == 1: if ext == 2: ext_str = src - return f"{src}, {ext_str}, {ext_str}" + if reverse: + return f"{ext_str}, {ext_str}, {src}" + else: + return f"{src}, {ext_str}, {ext_str}" elif mode == 2: if ext == 2: ext_str = src - return f"{src}, {ext_str}, {ext_str}, {ext_str}" - elif mode == 3: - return f"{src}[0], {src}[1], {ext_str}" - elif mode == 4: - if ext == 2: - return f"{src}[0], {src}[1], {src}[0], {src}[1]" + if reverse: + return f"{ext_str}, {ext_str}, {ext_str}, {src}" else: - return f"{src}[0], {src}[1], {ext_str}, {ext_str}" - elif mode == 5: - return f"{src}[0], {src}[1], {src}[2], {ext_str}" - -for type in range(2): - for ext in range(4): - for mode in range(6): # 6, 7 are reserved - case = case_str(type, ext, mode) - dst = dst_str(type, ext, mode) - cast = cast_str(type, ext, mode) - init = init_str(type, ext, mode) - if mode in [1, 3]: - print(f"{case} VectorSet({init}, {dst}); break;"); + return f"{src}, {ext_str}, {ext_str}, {ext_str}" + elif mode == 3: + if reverse: + return f"{ext_str}, {src}[1], {src}[0]" + else: + return f"{src}[0], {src}[1], {ext_str}" + elif mode == 4: + if reverse: + if ext == 2: + return f"{src}[1], {src}[0], {src}[1], {src}[0]" else: - print(f"{case} {dst} = {cast} {{ {init} }}; break;"); + return f"{ext_str}, {ext_str}, {src}[1], {src}[0]" + else: + if ext == 2: + return f"{src}[0], {src}[1], {src}[0], {src}[1]" + else: + return f"{src}[0], {src}[1], {ext_str}, {ext_str}" + elif mode == 5: + if reverse: + return f"{ext_str}, {src}[2], {src}[1], {src}[0]" + else: + return f"{src}[0], {src}[1], {src}[2], {ext_str}" + +for reverse in range(2): + for type in range(2): + for ext in range(4): + for mode in range(6): # 6, 7 are reserved + case = case_str(reverse, type, ext, mode) + dst = dst_str(type, ext, mode) + cast = cast_str(type, ext, mode) + init = init_str(reverse, type, ext, mode) + if mode in [1, 3]: + print(f"{case} VectorSet({init}, {dst}); break;"); + else: + print(f"{case} {dst} = {cast} {{ {init} }}; break;"); diff --git a/libs/gamecode/test/test-extend.c b/libs/gamecode/test/test-extend.c index bd05ab394..4bd5287e3 100644 --- a/libs/gamecode/test/test-extend.c +++ b/libs/gamecode/test/test-extend.c @@ -101,6 +101,72 @@ static dstatement_t float_extend_statements[] = { { OP(0, 0, 3, OP_EXTEND), 24, 035, 20 }, }; +static pr_vec4_t reverse_float_extend_expect[] = { + { 0, 5, _, _ }, + { 0, 0, 4, _ }, + { 0, 0, 0, 3 }, + { 0, 5, 4, _ }, + { 0, 0, 3, 2 }, + { 0, 5, 4, 3 }, + { 2, 3, 4, 5 }, + { _, _, 1, 4 }, + { _, 1, 1, 3 }, + { 1, 1, 1, 2 }, + { _, 1, 5, 4 }, + { 1, 1, 3, 2 }, + { 1, 4, 3, 2 }, + { _, _, _, _ }, + { 5, 5, _, _ }, + { 4, 4, 4, _ }, + { 3, 3, 3, 3 }, + { 0, 5, 4, _ }, + { 3, 2, 3, 2 }, + { 0, 5, 4, 3 }, + { _, _, _, _ }, + { _, _, -1, 4 }, + { _, -1, -1, 3 }, + {-1, -1, -1, 2 }, + { _, -1, 5, 4 }, + {-1, -1, 3, 2 }, + {-1, 4, 3, 2 }, + { _, _, _, _ }, +}; + +static dstatement_t reverse_float_extend_statements[] = { + { OP(0, 0, 0, OP_WITH), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 0, 28, 1 }, + { OP(0, 0, 0, OP_WITH), 0, 56, 2 }, + { OP(0, 0, 0, OP_WITH), 0, 84, 3 }, + + { OP(0, 0, 0, OP_EXTEND), 27, 0100, 0 }, + { OP(0, 0, 0, OP_EXTEND), 26, 0101, 4 }, + { OP(0, 0, 0, OP_EXTEND), 25, 0102, 8 }, + { OP(0, 0, 0, OP_EXTEND), 26, 0103, 12 }, + { OP(0, 0, 0, OP_EXTEND), 24, 0104, 16 }, + { OP(0, 0, 0, OP_EXTEND), 25, 0105, 20 }, + + { OP(0, 0, 1, OP_EXTEND), 26, 0110, 2 }, + { OP(0, 0, 1, OP_EXTEND), 25, 0111, 5 }, + { OP(0, 0, 1, OP_EXTEND), 24, 0112, 8 }, + { OP(0, 0, 1, OP_EXTEND), 26, 0113, 13 }, + { OP(0, 0, 1, OP_EXTEND), 24, 0114, 16 }, + { OP(0, 0, 1, OP_EXTEND), 24, 0115, 20 }, + + { OP(0, 0, 2, OP_EXTEND), 27, 0120, 0 }, + { OP(0, 0, 2, OP_EXTEND), 26, 0121, 4 }, + { OP(0, 0, 2, OP_EXTEND), 25, 0122, 8 }, + { OP(0, 0, 2, OP_EXTEND), 26, 0123, 12 }, + { OP(0, 0, 2, OP_EXTEND), 24, 0124, 16 }, + { OP(0, 0, 2, OP_EXTEND), 25, 0125, 20 }, + + { OP(0, 0, 3, OP_EXTEND), 26, 0130, 2 }, + { OP(0, 0, 3, OP_EXTEND), 25, 0131, 5 }, + { OP(0, 0, 3, OP_EXTEND), 24, 0132, 8 }, + { OP(0, 0, 3, OP_EXTEND), 26, 0133, 13 }, + { OP(0, 0, 3, OP_EXTEND), 24, 0134, 16 }, + { OP(0, 0, 3, OP_EXTEND), 24, 0135, 20 }, +}; + #undef _ #define _ -1.1885959257070704e+148 // 0xdeadbeefdeadbeef @@ -201,6 +267,72 @@ static dstatement_t double_extend_statements[] = { { OP(0, 0, 3, OP_EXTEND), 48, 075, 40 }, }; +static pr_dvec4_t reverse_double_extend_expect[] = { + { 0, 5, _, _ }, + { 0, 0, 4, _ }, + { 0, 0, 0, 3 }, + { 0, 5, 4, _ }, + { 0, 0, 3, 2 }, + { 0, 5, 4, 3 }, + { 2, 3, 4, 5 }, + { _, _, 1, 4 }, + { _, 1, 1, 3 }, + { 1, 1, 1, 2 }, + { _, 1, 5, 4 }, + { 1, 1, 3, 2 }, + { 1, 4, 3, 2 }, + { _, _, _, _ }, + { 5, 5, _, _ }, + { 4, 4, 4, _ }, + { 3, 3, 3, 3 }, + { 0, 5, 4, _ }, + { 3, 2, 3, 2 }, + { 0, 5, 4, 3 }, + { _, _, _, _ }, + { _, _, -1, 4 }, + { _, -1, -1, 3 }, + {-1, -1, -1, 2 }, + { _, -1, 5, 4 }, + {-1, -1, 3, 2 }, + {-1, 4, 3, 2 }, + { _, _, _, _ }, +}; + +static dstatement_t reverse_double_extend_statements[] = { + { OP(0, 0, 0, OP_WITH), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 0, 56, 1 }, + { OP(0, 0, 0, OP_WITH), 0, 112, 2 }, + { OP(0, 0, 0, OP_WITH), 0, 168, 3 }, + + { OP(0, 0, 0, OP_EXTEND), 54, 0140, 0 }, + { OP(0, 0, 0, OP_EXTEND), 52, 0141, 8 }, + { OP(0, 0, 0, OP_EXTEND), 50, 0142, 16 }, + { OP(0, 0, 0, OP_EXTEND), 52, 0143, 24 }, + { OP(0, 0, 0, OP_EXTEND), 48, 0144, 32 }, + { OP(0, 0, 0, OP_EXTEND), 50, 0145, 40 }, + + { OP(0, 0, 1, OP_EXTEND), 52, 0150, 4 }, + { OP(0, 0, 1, OP_EXTEND), 50, 0151, 10 }, + { OP(0, 0, 1, OP_EXTEND), 48, 0152, 16 }, + { OP(0, 0, 1, OP_EXTEND), 52, 0153, 26 }, + { OP(0, 0, 1, OP_EXTEND), 48, 0154, 32 }, + { OP(0, 0, 1, OP_EXTEND), 48, 0155, 40 }, + + { OP(0, 0, 2, OP_EXTEND), 54, 0160, 0 }, + { OP(0, 0, 2, OP_EXTEND), 52, 0161, 8 }, + { OP(0, 0, 2, OP_EXTEND), 50, 0162, 16 }, + { OP(0, 0, 2, OP_EXTEND), 52, 0163, 24 }, + { OP(0, 0, 2, OP_EXTEND), 48, 0164, 32 }, + { OP(0, 0, 2, OP_EXTEND), 50, 0165, 40 }, + + { OP(0, 0, 3, OP_EXTEND), 52, 0170, 4 }, + { OP(0, 0, 3, OP_EXTEND), 50, 0171, 10 }, + { OP(0, 0, 3, OP_EXTEND), 48, 0172, 16 }, + { OP(0, 0, 3, OP_EXTEND), 52, 0173, 26 }, + { OP(0, 0, 3, OP_EXTEND), 48, 0174, 32 }, + { OP(0, 0, 3, OP_EXTEND), 48, 0175, 40 }, +}; + test_t tests[] = { { .desc = "float extend", @@ -210,14 +342,32 @@ test_t tests[] = { .init_globals = (pr_int_t *) float_extend_init, .expect_globals = (pr_int_t *) float_extend_expect, }, + { + .desc = "reverse float extend", + .num_globals = num_globals(float_extend_init, + reverse_float_extend_expect), + .num_statements = num_statements (reverse_float_extend_statements), + .statements = reverse_float_extend_statements, + .init_globals = (pr_int_t *) float_extend_init, + .expect_globals = (pr_int_t *) reverse_float_extend_expect, + }, { .desc = "double extend", - .num_globals = num_globals(double_extend_init,double_extend_expect), + .num_globals = num_globals(double_extend_init, double_extend_expect), .num_statements = num_statements (double_extend_statements), .statements = double_extend_statements, .init_globals = (pr_int_t *) double_extend_init, .expect_globals = (pr_int_t *) double_extend_expect, }, + { + .desc = "reverse double extend", + .num_globals = num_globals(double_extend_init, + reverse_double_extend_expect), + .num_statements = num_statements (reverse_double_extend_statements), + .statements = reverse_double_extend_statements, + .init_globals = (pr_int_t *) double_extend_init, + .expect_globals = (pr_int_t *) reverse_double_extend_expect, + }, }; #include "main.c"