2 * Copyright (C) 2019 Connor Abbott <cwabbott0@gmail.com>
3 * Copyright (C) 2019 Lyude Paul <thatslyude@gmail.com>
4 * Copyright (C) 2019 Ryan Houdek <Sonicadvance1@gmail.com>
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice (including the next
14 * paragraph) shall be included in all copies or substantial portions of the
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
34 #include "disassemble.h"
36 #include "util/macros.h"
38 // return bits (high, lo]
39 static uint64_t bits(uint32_t word
, unsigned lo
, unsigned high
)
43 return (word
& ((1 << high
) - 1)) >> lo
;
46 // each of these structs represents an instruction that's dispatched in one
47 // cycle. Note that these instructions are packed in funny ways within the
48 // clause, hence the need for a separate struct.
49 struct bifrost_alu_inst
{
55 static unsigned get_reg0(struct bifrost_regs regs
)
58 return regs
.reg0
| ((regs
.reg1
& 0x1) << 5);
60 return regs
.reg0
<= regs
.reg1
? regs
.reg0
: 63 - regs
.reg0
;
63 static unsigned get_reg1(struct bifrost_regs regs
)
65 return regs
.reg0
<= regs
.reg1
? regs
.reg1
: 63 - regs
.reg1
;
68 // this represents the decoded version of the ctrl register field.
69 struct bifrost_reg_ctrl
{
73 enum bifrost_reg_write_unit fma_write_unit
;
74 enum bifrost_reg_write_unit add_write_unit
;
100 enum fma_src_type src_type
;
115 ADD_TEX_COMPACT
, // texture instruction with embedded sampler
116 ADD_TEX
, // texture instruction with sampler/etc. in uniform port
127 enum add_src_type src_type
;
131 void dump_header(FILE *fp
, struct bifrost_header header
, bool verbose
);
132 void dump_instr(FILE *fp
, const struct bifrost_alu_inst
*instr
,
133 struct bifrost_regs next_regs
, uint64_t *consts
,
134 unsigned data_reg
, unsigned offset
, bool verbose
);
135 bool dump_clause(FILE *fp
, uint32_t *words
, unsigned *size
, unsigned offset
, bool verbose
);
137 void dump_header(FILE *fp
, struct bifrost_header header
, bool verbose
)
139 fprintf(fp
, "id(%du) ", header
.scoreboard_index
);
141 if (header
.clause_type
!= 0) {
142 const char *name
= bi_clause_type_name(header
.clause_type
);
145 fprintf(fp
, "unk%u ", header
.clause_type
);
147 fprintf(fp
, "%s ", name
);
150 if (header
.scoreboard_deps
!= 0) {
151 fprintf(fp
, "next-wait(");
153 for (unsigned i
= 0; i
< 8; i
++) {
154 if (header
.scoreboard_deps
& (1 << i
)) {
158 fprintf(fp
, "%d", i
);
165 if (header
.datareg_writebarrier
)
166 fprintf(fp
, "data-reg-barrier ");
168 if (!header
.no_end_of_shader
)
171 if (!header
.back_to_back
) {
173 if (header
.branch_cond
)
174 fprintf(fp
, "branch-cond ");
176 fprintf(fp
, "branch-uncond ");
179 if (header
.elide_writes
)
182 if (header
.suppress_inf
)
183 fprintf(fp
, "suppress-inf ");
184 if (header
.suppress_nan
)
185 fprintf(fp
, "suppress-nan ");
188 fprintf(fp
, "unk0 ");
190 fprintf(fp
, "unk1 ");
192 fprintf(fp
, "unk2 ");
194 fprintf(fp
, "unk3 ");
196 fprintf(fp
, "unk4 ");
201 fprintf(fp
, "# clause type %d, next clause type %d\n",
202 header
.clause_type
, header
.next_clause_type
);
206 static struct bifrost_reg_ctrl
DecodeRegCtrl(FILE *fp
, struct bifrost_regs regs
)
208 struct bifrost_reg_ctrl decoded
= {};
210 if (regs
.ctrl
== 0) {
211 ctrl
= regs
.reg1
>> 2;
212 decoded
.read_reg0
= !(regs
.reg1
& 0x2);
213 decoded
.read_reg1
= false;
216 decoded
.read_reg0
= decoded
.read_reg1
= true;
220 decoded
.fma_write_unit
= REG_WRITE_TWO
;
224 decoded
.fma_write_unit
= REG_WRITE_TWO
;
225 decoded
.read_reg3
= true;
228 decoded
.read_reg3
= true;
231 decoded
.add_write_unit
= REG_WRITE_TWO
;
234 decoded
.add_write_unit
= REG_WRITE_TWO
;
235 decoded
.read_reg3
= true;
238 decoded
.clause_start
= true;
241 decoded
.fma_write_unit
= REG_WRITE_TWO
;
242 decoded
.clause_start
= true;
247 decoded
.read_reg3
= true;
248 decoded
.clause_start
= true;
251 decoded
.add_write_unit
= REG_WRITE_TWO
;
252 decoded
.clause_start
= true;
257 decoded
.fma_write_unit
= REG_WRITE_THREE
;
258 decoded
.add_write_unit
= REG_WRITE_TWO
;
261 fprintf(fp
, "# unknown reg ctrl %d\n", ctrl
);
267 // Pass in the add_write_unit or fma_write_unit, and this returns which register
268 // the ADD/FMA units are writing to
269 static unsigned GetRegToWrite(enum bifrost_reg_write_unit unit
, struct bifrost_regs regs
)
274 case REG_WRITE_THREE
:
276 default: /* REG_WRITE_NONE */
282 static void dump_regs(FILE *fp
, struct bifrost_regs srcs
)
284 struct bifrost_reg_ctrl ctrl
= DecodeRegCtrl(fp
, srcs
);
287 fprintf(fp
, "port 0: R%d ", get_reg0(srcs
));
289 fprintf(fp
, "port 1: R%d ", get_reg1(srcs
));
291 if (ctrl
.fma_write_unit
== REG_WRITE_TWO
)
292 fprintf(fp
, "port 2: R%d (write FMA) ", srcs
.reg2
);
293 else if (ctrl
.add_write_unit
== REG_WRITE_TWO
)
294 fprintf(fp
, "port 2: R%d (write ADD) ", srcs
.reg2
);
296 if (ctrl
.fma_write_unit
== REG_WRITE_THREE
)
297 fprintf(fp
, "port 3: R%d (write FMA) ", srcs
.reg3
);
298 else if (ctrl
.add_write_unit
== REG_WRITE_THREE
)
299 fprintf(fp
, "port 3: R%d (write ADD) ", srcs
.reg3
);
300 else if (ctrl
.read_reg3
)
301 fprintf(fp
, "port 3: R%d (read) ", srcs
.reg3
);
303 if (srcs
.uniform_const
) {
304 if (srcs
.uniform_const
& 0x80) {
305 fprintf(fp
, "uniform: U%d", (srcs
.uniform_const
& 0x7f) * 2);
311 static void dump_const_imm(FILE *fp
, uint32_t imm
)
318 fprintf(fp
, "0x%08x /* %f */", imm
, fi
.f
);
321 static uint64_t get_const(uint64_t *consts
, struct bifrost_regs srcs
)
323 unsigned low_bits
= srcs
.uniform_const
& 0xf;
325 switch (srcs
.uniform_const
>> 4) {
348 return imm
| low_bits
;
351 static void dump_uniform_const_src(FILE *fp
, struct bifrost_regs srcs
, uint64_t *consts
, bool high32
)
353 if (srcs
.uniform_const
& 0x80) {
354 unsigned uniform
= (srcs
.uniform_const
& 0x7f) * 2;
355 fprintf(fp
, "U%d", uniform
+ (high32
? 1 : 0));
356 } else if (srcs
.uniform_const
>= 0x20) {
357 uint64_t imm
= get_const(consts
, srcs
);
359 dump_const_imm(fp
, imm
>> 32);
361 dump_const_imm(fp
, imm
);
363 switch (srcs
.uniform_const
) {
368 fprintf(fp
, "atest-data");
371 fprintf(fp
, "sample-ptr");
381 fprintf(fp
, "blend-descriptor%u", (unsigned) srcs
.uniform_const
- 8);
384 fprintf(fp
, "unkConst%u", (unsigned) srcs
.uniform_const
);
395 static void dump_src(FILE *fp
, unsigned src
, struct bifrost_regs srcs
, uint64_t *consts
, bool isFMA
)
399 fprintf(fp
, "R%d", get_reg0(srcs
));
402 fprintf(fp
, "R%d", get_reg1(srcs
));
405 fprintf(fp
, "R%d", srcs
.reg3
);
411 fprintf(fp
, "T"); // i.e. the output of FMA this cycle
414 dump_uniform_const_src(fp
, srcs
, consts
, false);
417 dump_uniform_const_src(fp
, srcs
, consts
, true);
428 static const struct fma_op_info FMAOpInfos
[] = {
429 { false, 0x00000, "FMA.f32", FMA_FMA
},
430 { false, 0x40000, "MAX.f32", FMA_FMINMAX
},
431 { false, 0x44000, "MIN.f32", FMA_FMINMAX
},
432 { false, 0x48000, "FCMP.GL", FMA_FCMP
},
433 { false, 0x4c000, "FCMP.D3D", FMA_FCMP
},
434 { false, 0x4ff98, "ADD.i32", FMA_TWO_SRC
},
435 { false, 0x4ffd8, "SUB.i32", FMA_TWO_SRC
},
436 { false, 0x4fff0, "SUBB.i32", FMA_TWO_SRC
},
437 { false, 0x50000, "FMA_MSCALE", FMA_FMA_MSCALE
},
438 { false, 0x58000, "ADD.f32", FMA_FADD
},
439 { false, 0x5c000, "CSEL4", FMA_CSEL4
},
440 { false, 0x5d8d0, "ICMP.D3D.GT.v2i16", FMA_TWO_SRC
},
441 { false, 0x5d9d0, "UCMP.D3D.GT.v2i16", FMA_TWO_SRC
},
442 { false, 0x5dad0, "ICMP.D3D.GE.v2i16", FMA_TWO_SRC
},
443 { false, 0x5dbd0, "UCMP.D3D.GE.v2i16", FMA_TWO_SRC
},
444 { false, 0x5dcd0, "ICMP.D3D.EQ.v2i16", FMA_TWO_SRC
},
445 { false, 0x5de40, "ICMP.GL.GT.i32", FMA_TWO_SRC
}, // src0 > src1 ? 1 : 0
446 { false, 0x5de48, "ICMP.GL.GE.i32", FMA_TWO_SRC
},
447 { false, 0x5de50, "UCMP.GL.GT.i32", FMA_TWO_SRC
},
448 { false, 0x5de58, "UCMP.GL.GE.i32", FMA_TWO_SRC
},
449 { false, 0x5de60, "ICMP.GL.EQ.i32", FMA_TWO_SRC
},
450 { false, 0x5dec0, "ICMP.D3D.GT.i32", FMA_TWO_SRC
}, // src0 > src1 ? ~0 : 0
451 { false, 0x5dec8, "ICMP.D3D.GE.i32", FMA_TWO_SRC
},
452 { false, 0x5ded0, "UCMP.D3D.GT.i32", FMA_TWO_SRC
},
453 { false, 0x5ded8, "UCMP.D3D.GE.i32", FMA_TWO_SRC
},
454 { false, 0x5dee0, "ICMP.D3D.EQ.i32", FMA_TWO_SRC
},
455 { false, 0x60000, "RSHIFT_NAND", FMA_SHIFT
},
456 { false, 0x61000, "RSHIFT_AND", FMA_SHIFT
},
457 { false, 0x62000, "LSHIFT_NAND", FMA_SHIFT
},
458 { false, 0x63000, "LSHIFT_AND", FMA_SHIFT
}, // (src0 << src2) & src1
459 { false, 0x64000, "RSHIFT_XOR", FMA_SHIFT
},
460 { false, 0x65200, "LSHIFT_ADD.i32", FMA_THREE_SRC
},
461 { false, 0x65600, "LSHIFT_SUB.i32", FMA_THREE_SRC
}, // (src0 << src2) - src1
462 { false, 0x65a00, "LSHIFT_RSUB.i32", FMA_THREE_SRC
}, // src1 - (src0 << src2)
463 { false, 0x65e00, "RSHIFT_ADD.i32", FMA_THREE_SRC
},
464 { false, 0x66200, "RSHIFT_SUB.i32", FMA_THREE_SRC
},
465 { false, 0x66600, "RSHIFT_RSUB.i32", FMA_THREE_SRC
},
466 { false, 0x66a00, "ARSHIFT_ADD.i32", FMA_THREE_SRC
},
467 { false, 0x66e00, "ARSHIFT_SUB.i32", FMA_THREE_SRC
},
468 { false, 0x67200, "ARSHIFT_RSUB.i32", FMA_THREE_SRC
},
469 { false, 0x80000, "FMA.v2f16", FMA_FMA16
},
470 { false, 0xc0000, "MAX.v2f16", FMA_FMINMAX16
},
471 { false, 0xc4000, "MIN.v2f16", FMA_FMINMAX16
},
472 { false, 0xc8000, "FCMP.GL", FMA_FCMP16
},
473 { false, 0xcc000, "FCMP.D3D", FMA_FCMP16
},
474 { false, 0xcf900, "ADD.v2i16", FMA_TWO_SRC
},
475 { false, 0xcfc10, "ADDC.i32", FMA_TWO_SRC
},
476 { false, 0xcfd80, "ADD.i32.i16.X", FMA_TWO_SRC
},
477 { false, 0xcfd90, "ADD.i32.u16.X", FMA_TWO_SRC
},
478 { false, 0xcfdc0, "ADD.i32.i16.Y", FMA_TWO_SRC
},
479 { false, 0xcfdd0, "ADD.i32.u16.Y", FMA_TWO_SRC
},
480 { false, 0xd8000, "ADD.v2f16", FMA_FADD16
},
481 { false, 0xdc000, "CSEL4.v16", FMA_CSEL4
},
482 { false, 0xdd000, "F32_TO_F16", FMA_TWO_SRC
},
484 /* TODO: Combine to bifrost_fma_f2i_i2f16 */
485 { true, 0x00046, "F16_TO_I16.XX", FMA_ONE_SRC
},
486 { true, 0x00047, "F16_TO_U16.XX", FMA_ONE_SRC
},
487 { true, 0x0004e, "F16_TO_I16.YX", FMA_ONE_SRC
},
488 { true, 0x0004f, "F16_TO_U16.YX", FMA_ONE_SRC
},
489 { true, 0x00056, "F16_TO_I16.XY", FMA_ONE_SRC
},
490 { true, 0x00057, "F16_TO_U16.XY", FMA_ONE_SRC
},
491 { true, 0x0005e, "F16_TO_I16.YY", FMA_ONE_SRC
},
492 { true, 0x0005f, "F16_TO_U16.YY", FMA_ONE_SRC
},
493 { true, 0x000c0, "I16_TO_F16.XX", FMA_ONE_SRC
},
494 { true, 0x000c1, "U16_TO_F16.XX", FMA_ONE_SRC
},
495 { true, 0x000c8, "I16_TO_F16.YX", FMA_ONE_SRC
},
496 { true, 0x000c9, "U16_TO_F16.YX", FMA_ONE_SRC
},
497 { true, 0x000d0, "I16_TO_F16.XY", FMA_ONE_SRC
},
498 { true, 0x000d1, "U16_TO_F16.XY", FMA_ONE_SRC
},
499 { true, 0x000d8, "I16_TO_F16.YY", FMA_ONE_SRC
},
500 { true, 0x000d9, "U16_TO_F16.YY", FMA_ONE_SRC
},
502 { true, 0x00136, "F32_TO_I32", FMA_ONE_SRC
},
503 { true, 0x00137, "F32_TO_U32", FMA_ONE_SRC
},
504 { true, 0x00178, "I32_TO_F32", FMA_ONE_SRC
},
505 { true, 0x00179, "U32_TO_F32", FMA_ONE_SRC
},
507 /* TODO: cleanup to use bifrost_fma_int16_to_32 */
508 { true, 0x00198, "I16_TO_I32.X", FMA_ONE_SRC
},
509 { true, 0x00199, "U16_TO_U32.X", FMA_ONE_SRC
},
510 { true, 0x0019a, "I16_TO_I32.Y", FMA_ONE_SRC
},
511 { true, 0x0019b, "U16_TO_U32.Y", FMA_ONE_SRC
},
512 { true, 0x0019c, "I16_TO_F32.X", FMA_ONE_SRC
},
513 { true, 0x0019d, "U16_TO_F32.X", FMA_ONE_SRC
},
514 { true, 0x0019e, "I16_TO_F32.Y", FMA_ONE_SRC
},
515 { true, 0x0019f, "U16_TO_F32.Y", FMA_ONE_SRC
},
517 { true, 0x001a2, "F16_TO_F32.X", FMA_ONE_SRC
},
518 { true, 0x001a3, "F16_TO_F32.Y", FMA_ONE_SRC
},
520 { true, 0x0032c, "NOP", FMA_ONE_SRC
},
521 { true, 0x0032d, "MOV", FMA_ONE_SRC
},
522 { true, 0x0032f, "SWZ.YY.v2i16", FMA_ONE_SRC
},
523 { true, 0x00345, "LOG_FREXPM", FMA_ONE_SRC
},
524 { true, 0x00365, "FRCP_FREXPM", FMA_ONE_SRC
},
525 { true, 0x00375, "FSQRT_FREXPM", FMA_ONE_SRC
},
526 { true, 0x0038d, "FRCP_FREXPE", FMA_ONE_SRC
},
527 { true, 0x003a5, "FSQRT_FREXPE", FMA_ONE_SRC
},
528 { true, 0x003ad, "FRSQ_FREXPE", FMA_ONE_SRC
},
529 { true, 0x003c5, "LOG_FREXPE", FMA_ONE_SRC
},
530 { true, 0x003fa, "CLZ", FMA_ONE_SRC
},
531 { true, 0x00b80, "IMAX3", FMA_THREE_SRC
},
532 { true, 0x00bc0, "UMAX3", FMA_THREE_SRC
},
533 { true, 0x00c00, "IMIN3", FMA_THREE_SRC
},
534 { true, 0x00c40, "UMIN3", FMA_THREE_SRC
},
535 { true, 0x00ec2, "ROUND.v2f16", FMA_ONE_SRC
},
536 { true, 0x00ec5, "ROUND.f32", FMA_ONE_SRC
},
537 { true, 0x00f40, "CSEL", FMA_THREE_SRC
}, // src2 != 0 ? src1 : src0
538 { true, 0x00fc0, "MUX.i32", FMA_THREE_SRC
}, // see ADD comment
539 { true, 0x01802, "ROUNDEVEN.v2f16", FMA_ONE_SRC
},
540 { true, 0x01805, "ROUNDEVEN.f32", FMA_ONE_SRC
},
541 { true, 0x01842, "CEIL.v2f16", FMA_ONE_SRC
},
542 { true, 0x01845, "CEIL.f32", FMA_ONE_SRC
},
543 { true, 0x01882, "FLOOR.v2f16", FMA_ONE_SRC
},
544 { true, 0x01885, "FLOOR.f32", FMA_ONE_SRC
},
545 { true, 0x018c2, "TRUNC.v2f16", FMA_ONE_SRC
},
546 { true, 0x018c5, "TRUNC.f32", FMA_ONE_SRC
},
547 { true, 0x019b0, "ATAN_LDEXP.Y.f32", FMA_TWO_SRC
},
548 { true, 0x019b8, "ATAN_LDEXP.X.f32", FMA_TWO_SRC
},
549 { true, 0x01c80, "LSHIFT_ADD_LOW32.u32", FMA_SHIFT_ADD64
},
550 { true, 0x01cc0, "LSHIFT_ADD_LOW32.i64", FMA_SHIFT_ADD64
},
551 { true, 0x01d80, "LSHIFT_ADD_LOW32.i32", FMA_SHIFT_ADD64
},
552 { true, 0x01e00, "SEL.XX.i16", FMA_TWO_SRC
},
553 { true, 0x01e08, "SEL.YX.i16", FMA_TWO_SRC
},
554 { true, 0x01e10, "SEL.XY.i16", FMA_TWO_SRC
},
555 { true, 0x01e18, "SEL.YY.i16", FMA_TWO_SRC
},
556 { true, 0x01e80, "ADD_FREXPM.f32", FMA_TWO_SRC
},
557 { true, 0x02000, "SWZ.XXXX.v4i8", FMA_ONE_SRC
},
558 { true, 0x03e00, "SWZ.ZZZZ.v4i8", FMA_ONE_SRC
},
559 { true, 0x00800, "IMAD", FMA_THREE_SRC
},
560 { true, 0x078db, "POPCNT", FMA_ONE_SRC
},
563 static struct fma_op_info
find_fma_op_info(unsigned op
, bool extended
)
565 for (unsigned i
= 0; i
< ARRAY_SIZE(FMAOpInfos
); i
++) {
568 if (FMAOpInfos
[i
].extended
!= extended
)
574 switch (FMAOpInfos
[i
].src_type
) {
583 opCmp
= op
& ~0x1fff;
586 case FMA_SHIFT_ADD64
:
593 opCmp
= op
& ~0x3fff;
597 opCmp
= op
& ~0x3ffff;
604 opCmp
= op
& ~0x7fff;
610 if (FMAOpInfos
[i
].op
== opCmp
)
611 return FMAOpInfos
[i
];
614 struct fma_op_info info
;
615 snprintf(info
.name
, sizeof(info
.name
), "op%04x", op
);
617 info
.src_type
= FMA_THREE_SRC
;
621 static void dump_fcmp(FILE *fp
, unsigned op
)
643 fprintf(fp
, ".unk%d", op
);
648 static void dump_16swizzle(FILE *fp
, unsigned swiz
)
652 fprintf(fp
, ".%c%c", "xy"[swiz
& 1], "xy"[(swiz
>> 1) & 1]);
655 static void dump_fma_expand_src0(FILE *fp
, unsigned ctrl
)
677 static void dump_fma_expand_src1(FILE *fp
, unsigned ctrl
)
699 static void dump_fma(FILE *fp
, uint64_t word
, struct bifrost_regs regs
, struct bifrost_regs next_regs
, uint64_t *consts
, bool verbose
)
702 fprintf(fp
, "# FMA: %016" PRIx64
"\n", word
);
704 struct bifrost_fma_inst FMA
;
705 memcpy((char *) &FMA
, (char *) &word
, sizeof(struct bifrost_fma_inst
));
706 struct fma_op_info info
= find_fma_op_info(FMA
.op
, (FMA
.op
& 0xe0000) == 0xe0000);
708 fprintf(fp
, "%s", info
.name
);
709 if (info
.src_type
== FMA_FADD
||
710 info
.src_type
== FMA_FMINMAX
||
711 info
.src_type
== FMA_FMA
||
712 info
.src_type
== FMA_FADD16
||
713 info
.src_type
== FMA_FMINMAX16
||
714 info
.src_type
== FMA_FMA16
) {
715 fprintf(fp
, "%s", bi_output_mod_name(bits(FMA
.op
, 12, 14)));
716 switch (info
.src_type
) {
721 fprintf(fp
, "%s", bi_round_mode_name(bits(FMA
.op
, 10, 12)));
725 fprintf(fp
, "%s", bi_minmax_mode_name(bits(FMA
.op
, 10, 12)));
730 } else if (info
.src_type
== FMA_FCMP
|| info
.src_type
== FMA_FCMP16
) {
731 dump_fcmp(fp
, bits(FMA
.op
, 10, 13));
732 if (info
.src_type
== FMA_FCMP
)
735 fprintf(fp
, ".v2f16");
736 } else if (info
.src_type
== FMA_FMA_MSCALE
) {
737 if (FMA
.op
& (1 << 11)) {
738 switch ((FMA
.op
>> 9) & 0x3) {
740 /* This mode seems to do a few things:
741 * - Makes 0 * infinity (and incidentally 0 * nan) return 0,
742 * since generating a nan would poison the result of
743 * 1/infinity and 1/0.
744 * - Fiddles with which nan is returned in nan * nan,
745 * presumably to make sure that the same exact nan is
746 * returned for 1/nan.
748 fprintf(fp
, ".rcp_mode");
751 /* Similar to the above, but src0 always wins when multiplying
754 fprintf(fp
, ".sqrt_mode");
757 fprintf(fp
, ".unk%d_mode", (int) (FMA
.op
>> 9) & 0x3);
760 fprintf(fp
, "%s", bi_output_mod_name(bits(FMA
.op
, 9, 11)));
762 } else if (info
.src_type
== FMA_SHIFT
) {
763 struct bifrost_shift_fma shift
;
764 memcpy(&shift
, &FMA
, sizeof(shift
));
766 if (shift
.half
== 0x7)
767 fprintf(fp
, ".v2i16");
768 else if (shift
.half
== 0)
770 else if (shift
.half
== 0x4)
771 fprintf(fp
, ".v4i8");
773 fprintf(fp
, ".unk%u", shift
.half
);
776 fprintf(fp
, ".no_unk");
779 fprintf(fp
, ".invert_1");
782 fprintf(fp
, ".invert_2");
787 struct bifrost_reg_ctrl next_ctrl
= DecodeRegCtrl(fp
, next_regs
);
788 if (next_ctrl
.fma_write_unit
!= REG_WRITE_NONE
) {
789 fprintf(fp
, "{R%d, T0}, ", GetRegToWrite(next_ctrl
.fma_write_unit
, next_regs
));
794 switch (info
.src_type
) {
796 dump_src(fp
, FMA
.src0
, regs
, consts
, true);
799 dump_src(fp
, FMA
.src0
, regs
, consts
, true);
801 dump_src(fp
, FMA
.op
& 0x7, regs
, consts
, true);
809 dump_src(fp
, FMA
.src0
, regs
, consts
, true);
810 dump_fma_expand_src0(fp
, (FMA
.op
>> 6) & 0x7);
818 dump_src(fp
, FMA
.op
& 0x7, regs
, consts
, true);
819 dump_fma_expand_src1(fp
, (FMA
.op
>> 6) & 0x7);
824 case FMA_FMINMAX16
: {
825 bool abs1
= FMA
.op
& 0x8;
826 bool abs2
= (FMA
.op
& 0x7) < FMA
.src0
;
831 dump_src(fp
, FMA
.src0
, regs
, consts
, true);
832 dump_16swizzle(fp
, (FMA
.op
>> 6) & 0x3);
840 dump_src(fp
, FMA
.op
& 0x7, regs
, consts
, true);
841 dump_16swizzle(fp
, (FMA
.op
>> 8) & 0x3);
849 dump_src(fp
, FMA
.src0
, regs
, consts
, true);
850 dump_fma_expand_src0(fp
, (FMA
.op
>> 6) & 0x7);
858 dump_src(fp
, FMA
.op
& 0x7, regs
, consts
, true);
859 dump_fma_expand_src1(fp
, (FMA
.op
>> 6) & 0x7);
864 dump_src(fp
, FMA
.src0
, regs
, consts
, true);
865 // Note: this is kinda a guess, I haven't seen the blob set this to
866 // anything other than the identity, but it matches FMA_TWO_SRCFmod16
867 dump_16swizzle(fp
, (FMA
.op
>> 6) & 0x3);
869 dump_src(fp
, FMA
.op
& 0x7, regs
, consts
, true);
870 dump_16swizzle(fp
, (FMA
.op
>> 8) & 0x3);
872 case FMA_SHIFT_ADD64
:
873 dump_src(fp
, FMA
.src0
, regs
, consts
, true);
875 dump_src(fp
, FMA
.op
& 0x7, regs
, consts
, true);
877 fprintf(fp
, "shift:%u", (FMA
.op
>> 3) & 0x7);
880 dump_src(fp
, FMA
.src0
, regs
, consts
, true);
882 dump_src(fp
, FMA
.op
& 0x7, regs
, consts
, true);
884 dump_src(fp
, (FMA
.op
>> 3) & 0x7, regs
, consts
, true);
887 struct bifrost_shift_fma shift
;
888 memcpy(&shift
, &FMA
, sizeof(shift
));
890 dump_src(fp
, shift
.src0
, regs
, consts
, true);
892 dump_src(fp
, shift
.src1
, regs
, consts
, true);
894 dump_src(fp
, shift
.src2
, regs
, consts
, true);
898 if (FMA
.op
& (1 << 14))
900 if (FMA
.op
& (1 << 9))
902 dump_src(fp
, FMA
.src0
, regs
, consts
, true);
903 dump_fma_expand_src0(fp
, (FMA
.op
>> 6) & 0x7);
904 if (FMA
.op
& (1 << 9))
907 if (FMA
.op
& (1 << 16))
909 dump_src(fp
, FMA
.op
& 0x7, regs
, consts
, true);
910 dump_fma_expand_src1(fp
, (FMA
.op
>> 6) & 0x7);
911 if (FMA
.op
& (1 << 16))
914 if (FMA
.op
& (1 << 15))
916 if (FMA
.op
& (1 << 17))
918 dump_src(fp
, (FMA
.op
>> 3) & 0x7, regs
, consts
, true);
919 if (FMA
.op
& (1 << 17))
923 if (FMA
.op
& (1 << 14))
925 dump_src(fp
, FMA
.src0
, regs
, consts
, true);
926 dump_16swizzle(fp
, (FMA
.op
>> 6) & 0x3);
928 dump_src(fp
, FMA
.op
& 0x7, regs
, consts
, true);
929 dump_16swizzle(fp
, (FMA
.op
>> 8) & 0x3);
931 if (FMA
.op
& (1 << 15))
933 dump_src(fp
, (FMA
.op
>> 3) & 0x7, regs
, consts
, true);
934 dump_16swizzle(fp
, (FMA
.op
>> 16) & 0x3);
937 struct bifrost_csel4 csel
;
938 memcpy(&csel
, &FMA
, sizeof(csel
));
939 fprintf(fp
, ".%s ", bi_csel_cond_name(csel
.cond
));
941 dump_src(fp
, csel
.src0
, regs
, consts
, true);
943 dump_src(fp
, csel
.src1
, regs
, consts
, true);
945 dump_src(fp
, csel
.src2
, regs
, consts
, true);
947 dump_src(fp
, csel
.src3
, regs
, consts
, true);
951 if (FMA
.op
& (1 << 12))
953 dump_src(fp
, FMA
.src0
, regs
, consts
, true);
954 if (FMA
.op
& (1 << 12))
957 if (FMA
.op
& (1 << 13))
959 dump_src(fp
, FMA
.op
& 0x7, regs
, consts
, true);
961 if (FMA
.op
& (1 << 14))
963 dump_src(fp
, (FMA
.op
>> 3) & 0x7, regs
, consts
, true);
965 dump_src(fp
, (FMA
.op
>> 6) & 0x7, regs
, consts
, true);
971 static const struct add_op_info add_op_infos
[] = {
972 { 0x00000, "MAX.f32", ADD_FMINMAX
},
973 { 0x02000, "MIN.f32", ADD_FMINMAX
},
974 { 0x04000, "ADD.f32", ADD_FADD
},
975 { 0x06000, "FCMP.GL", ADD_FCMP
},
976 { 0x07000, "FCMP.D3D", ADD_FCMP
},
977 { 0x07856, "F16_TO_I16", ADD_ONE_SRC
},
978 { 0x07857, "F16_TO_U16", ADD_ONE_SRC
},
979 { 0x078c0, "I16_TO_F16.XX", ADD_ONE_SRC
},
980 { 0x078c1, "U16_TO_F16.XX", ADD_ONE_SRC
},
981 { 0x078c8, "I16_TO_F16.YX", ADD_ONE_SRC
},
982 { 0x078c9, "U16_TO_F16.YX", ADD_ONE_SRC
},
983 { 0x078d0, "I16_TO_F16.XY", ADD_ONE_SRC
},
984 { 0x078d1, "U16_TO_F16.XY", ADD_ONE_SRC
},
985 { 0x078d8, "I16_TO_F16.YY", ADD_ONE_SRC
},
986 { 0x078d9, "U16_TO_F16.YY", ADD_ONE_SRC
},
987 { 0x07909, "B1_TO_F16", ADD_ONE_SRC
},
988 { 0x07936, "F32_TO_I32", ADD_ONE_SRC
},
989 { 0x07937, "F32_TO_U32", ADD_ONE_SRC
},
990 { 0x07971, "B1_TO_F32", ADD_ONE_SRC
},
991 { 0x07978, "I32_TO_F32", ADD_ONE_SRC
},
992 { 0x07979, "U32_TO_F32", ADD_ONE_SRC
},
993 { 0x07998, "I16_TO_I32.X", ADD_ONE_SRC
},
994 { 0x07999, "U16_TO_U32.X", ADD_ONE_SRC
},
995 { 0x0799a, "I16_TO_I32.Y", ADD_ONE_SRC
},
996 { 0x0799b, "U16_TO_U32.Y", ADD_ONE_SRC
},
997 { 0x0799c, "I16_TO_F32.X", ADD_ONE_SRC
},
998 { 0x0799d, "U16_TO_F32.X", ADD_ONE_SRC
},
999 { 0x0799e, "I16_TO_F32.Y", ADD_ONE_SRC
},
1000 { 0x0799f, "U16_TO_F32.Y", ADD_ONE_SRC
},
1001 { 0x079a2, "F16_TO_F32.X", ADD_ONE_SRC
},
1002 { 0x079a3, "F16_TO_F32.Y", ADD_ONE_SRC
},
1003 { 0x07b2b, "SWZ.YX.v2i16", ADD_ONE_SRC
},
1004 { 0x07b2c, "NOP", ADD_ONE_SRC
},
1005 { 0x07b29, "SWZ.XX.v2i16", ADD_ONE_SRC
},
1006 { 0x07b2d, "MOV", ADD_ONE_SRC
},
1007 { 0x07b2f, "SWZ.YY.v2i16", ADD_ONE_SRC
},
1008 { 0x07b65, "FRCP_FREXPM", ADD_ONE_SRC
},
1009 { 0x07b75, "FSQRT_FREXPM", ADD_ONE_SRC
},
1010 { 0x07b8d, "FRCP_FREXPE", ADD_ONE_SRC
},
1011 { 0x07ba5, "FSQRT_FREXPE", ADD_ONE_SRC
},
1012 { 0x07bad, "FRSQ_FREXPE", ADD_ONE_SRC
},
1013 { 0x07bc5, "FLOG_FREXPE", ADD_ONE_SRC
},
1014 { 0x07d42, "CEIL.v2f16", ADD_ONE_SRC
},
1015 { 0x07d45, "CEIL.f32", ADD_ONE_SRC
},
1016 { 0x07d82, "FLOOR.v2f16", ADD_ONE_SRC
},
1017 { 0x07d85, "FLOOR.f32", ADD_ONE_SRC
},
1018 { 0x07dc2, "TRUNC.v2f16", ADD_ONE_SRC
},
1019 { 0x07dc5, "TRUNC.f32", ADD_ONE_SRC
},
1020 { 0x07f18, "LSHIFT_ADD_HIGH32.i32", ADD_TWO_SRC
},
1021 { 0x08000, "LD_ATTR", ADD_LOAD_ATTR
, true },
1022 { 0x0a000, "LD_VAR.32", ADD_VARYING_INTERP
, true },
1023 { 0x0b000, "TEXC", ADD_TEX_COMPACT
, true },
1024 { 0x0b400, "TEXC.vtx", ADD_TEX_COMPACT
, true },
1025 { 0x0c188, "LOAD.i32", ADD_TWO_SRC
, true },
1026 { 0x0c1a0, "LD_UBO.i32", ADD_TWO_SRC
, true },
1027 { 0x0c1b8, "LD_SCRATCH.v2i32", ADD_TWO_SRC
, true },
1028 { 0x0c1c8, "LOAD.v2i32", ADD_TWO_SRC
, true },
1029 { 0x0c1e0, "LD_UBO.v2i32", ADD_TWO_SRC
, true },
1030 { 0x0c1f8, "LD_SCRATCH.v2i32", ADD_TWO_SRC
, true },
1031 { 0x0c208, "LOAD.v4i32", ADD_TWO_SRC
, true },
1032 { 0x0c220, "LD_UBO.v4i32", ADD_TWO_SRC
, true },
1033 { 0x0c238, "LD_SCRATCH.v4i32", ADD_TWO_SRC
, true },
1034 { 0x0c248, "STORE.v4i32", ADD_TWO_SRC
, true },
1035 { 0x0c278, "ST_SCRATCH.v4i32", ADD_TWO_SRC
, true },
1036 { 0x0c588, "STORE.i32", ADD_TWO_SRC
, true },
1037 { 0x0c5b8, "ST_SCRATCH.i32", ADD_TWO_SRC
, true },
1038 { 0x0c5c8, "STORE.v2i32", ADD_TWO_SRC
, true },
1039 { 0x0c5f8, "ST_SCRATCH.v2i32", ADD_TWO_SRC
, true },
1040 { 0x0c648, "LOAD.u16", ADD_TWO_SRC
, true }, // zero-extends
1041 { 0x0ca88, "LOAD.v3i32", ADD_TWO_SRC
, true },
1042 { 0x0caa0, "LD_UBO.v3i32", ADD_TWO_SRC
, true },
1043 { 0x0cab8, "LD_SCRATCH.v3i32", ADD_TWO_SRC
, true },
1044 { 0x0cb88, "STORE.v3i32", ADD_TWO_SRC
, true },
1045 { 0x0cbb8, "ST_SCRATCH.v3i32", ADD_TWO_SRC
, true },
1046 { 0x0cc00, "FRCP_FAST.f32", ADD_ONE_SRC
},
1047 { 0x0cc20, "FRSQ_FAST.f32", ADD_ONE_SRC
},
1048 { 0x0cc68, "FLOG2_U.f32", ADD_ONE_SRC
},
1049 { 0x0cd58, "FEXP2_FAST.f32", ADD_ONE_SRC
},
1050 { 0x0ce00, "FRCP_TABLE", ADD_ONE_SRC
},
1051 { 0x0ce10, "FRCP_FAST.f16.X", ADD_ONE_SRC
},
1052 { 0x0ce20, "FRSQ_TABLE", ADD_ONE_SRC
},
1053 { 0x0ce30, "FRCP_FAST.f16.Y", ADD_ONE_SRC
},
1054 { 0x0ce50, "FRSQ_FAST.f16.X", ADD_ONE_SRC
},
1055 { 0x0ce60, "FRCP_APPROX", ADD_ONE_SRC
},
1056 { 0x0ce70, "FRSQ_FAST.f16.Y", ADD_ONE_SRC
},
1057 { 0x0cf40, "ATAN_ASSIST", ADD_TWO_SRC
},
1058 { 0x0cf48, "ATAN_TABLE", ADD_TWO_SRC
},
1059 { 0x0cf50, "SIN_TABLE", ADD_ONE_SRC
},
1060 { 0x0cf51, "COS_TABLE", ADD_ONE_SRC
},
1061 { 0x0cf58, "EXP_TABLE", ADD_ONE_SRC
},
1062 { 0x0cf60, "FLOG2_TABLE", ADD_ONE_SRC
},
1063 { 0x0cf64, "FLOGE_TABLE", ADD_ONE_SRC
},
1064 { 0x0d000, "BRANCH", ADD_BRANCH
},
1065 { 0x0e8c0, "MUX", ADD_THREE_SRC
},
1066 { 0x0e9b0, "ATAN_LDEXP.Y.f32", ADD_TWO_SRC
},
1067 { 0x0e9b8, "ATAN_LDEXP.X.f32", ADD_TWO_SRC
},
1068 { 0x0ea60, "SEL.XX.i16", ADD_TWO_SRC
},
1069 { 0x0ea70, "SEL.XY.i16", ADD_TWO_SRC
},
1070 { 0x0ea68, "SEL.YX.i16", ADD_TWO_SRC
},
1071 { 0x0ea78, "SEL.YY.i16", ADD_TWO_SRC
},
1072 { 0x0ec00, "F32_TO_F16", ADD_TWO_SRC
},
1073 { 0x0e840, "CSEL.64", ADD_THREE_SRC
}, // u2u32(src2) ? src0 : src1
1074 { 0x0e940, "CSEL.8", ADD_THREE_SRC
}, // (src2 != 0) ? src0 : src1
1075 { 0x0f640, "ICMP.GL.GT", ADD_TWO_SRC
}, // src0 > src1 ? 1 : 0
1076 { 0x0f648, "ICMP.GL.GE", ADD_TWO_SRC
},
1077 { 0x0f650, "UCMP.GL.GT", ADD_TWO_SRC
},
1078 { 0x0f658, "UCMP.GL.GE", ADD_TWO_SRC
},
1079 { 0x0f660, "ICMP.GL.EQ", ADD_TWO_SRC
},
1080 { 0x0f669, "ICMP.GL.NEQ", ADD_TWO_SRC
},
1081 { 0x0f690, "UCMP.8.GT", ADD_TWO_SRC
},
1082 { 0x0f698, "UCMP.8.GE", ADD_TWO_SRC
},
1083 { 0x0f6a8, "ICMP.8.NE", ADD_TWO_SRC
},
1084 { 0x0f6c0, "ICMP.D3D.GT", ADD_TWO_SRC
}, // src0 > src1 ? ~0 : 0
1085 { 0x0f6c8, "ICMP.D3D.GE", ADD_TWO_SRC
},
1086 { 0x0f6d0, "UCMP.D3D.GT", ADD_TWO_SRC
},
1087 { 0x0f6d8, "UCMP.D3D.GE", ADD_TWO_SRC
},
1088 { 0x0f6e0, "ICMP.D3D.EQ", ADD_TWO_SRC
},
1089 { 0x0f700, "ICMP.64.GT.PT1", ADD_TWO_SRC
},
1090 { 0x0f708, "ICMP.64.GE.PT1", ADD_TWO_SRC
},
1091 { 0x0f710, "UCMP.64.GT.PT1", ADD_TWO_SRC
},
1092 { 0x0f718, "UCMP.64.GE.PT1", ADD_TWO_SRC
},
1093 { 0x0f720, "ICMP.64.EQ.PT1", ADD_TWO_SRC
},
1094 { 0x0f728, "ICMP.64.NE.PT1", ADD_TWO_SRC
},
1095 { 0x0f7c0, "ICMP.64.PT2", ADD_THREE_SRC
}, // src3 = result of PT1
1096 { 0x10000, "MAX.v2f16", ADD_FMINMAX16
},
1097 { 0x11000, "ADD_MSCALE.f32", ADD_FADDMscale
},
1098 { 0x12000, "MIN.v2f16", ADD_FMINMAX16
},
1099 { 0x14000, "ADD.v2f16", ADD_FADD16
},
1100 { 0x16000, "FCMP.GL", ADD_FCMP16
},
1101 { 0x17000, "FCMP.D3D", ADD_FCMP16
},
1102 { 0x17880, "ADD.v4i8", ADD_TWO_SRC
},
1103 { 0x178c0, "ADD.i32", ADD_TWO_SRC
},
1104 { 0x17900, "ADD.v2i16", ADD_TWO_SRC
},
1105 { 0x17a80, "SUB.v4i8", ADD_TWO_SRC
},
1106 { 0x17ac0, "SUB.i32", ADD_TWO_SRC
},
1107 { 0x17b00, "SUB.v2i16", ADD_TWO_SRC
},
1108 { 0x17c10, "ADDC.i32", ADD_TWO_SRC
}, // adds src0 to the bottom bit of src1
1109 { 0x17d80, "ADD.i32.i16.X", ADD_TWO_SRC
},
1110 { 0x17d90, "ADD.i32.u16.X", ADD_TWO_SRC
},
1111 { 0x17dc0, "ADD.i32.i16.Y", ADD_TWO_SRC
},
1112 { 0x17dd0, "ADD.i32.u16.Y", ADD_TWO_SRC
},
1113 { 0x18000, "LD_VAR_ADDR", ADD_VARYING_ADDRESS
, false },
1114 { 0x19100, "DISCARD.FEQ.f16", ADD_TWO_SRC
, false },
1115 { 0x19108, "DISCARD.FNE.f16", ADD_TWO_SRC
, false },
1116 { 0x19110, "DISCARD.FLE.f16", ADD_TWO_SRC
, false },
1117 { 0x19118, "DISCARD.FLT.f16", ADD_TWO_SRC
, false },
1118 { 0x19180, "DISCARD.FEQ.f32", ADD_TWO_SRC
, false },
1119 { 0x19188, "DISCARD.FNE.f32", ADD_TWO_SRC
, false },
1120 { 0x19190, "DISCARD.FLE.f32", ADD_TWO_SRC
, false },
1121 { 0x19198, "DISCARD.FLT.f32", ADD_TWO_SRC
, false },
1122 { 0x191e8, "ATEST.f32", ADD_TWO_SRC
, true },
1123 { 0x191f0, "ATEST.X.f16", ADD_TWO_SRC
, true },
1124 { 0x191f8, "ATEST.Y.f16", ADD_TWO_SRC
, true },
1125 { 0x19300, "ST_VAR.v1", ADD_THREE_SRC
, true },
1126 { 0x19340, "ST_VAR.v2", ADD_THREE_SRC
, true },
1127 { 0x19380, "ST_VAR.v3", ADD_THREE_SRC
, true },
1128 { 0x193c0, "ST_VAR.v4", ADD_THREE_SRC
, true },
1129 { 0x1952c, "BLEND", ADD_BLENDING
, true },
1130 { 0x1a000, "LD_VAR.16", ADD_VARYING_INTERP
, true },
1131 { 0x1ae20, "TEX.vtx", ADD_TEX
, true },
1132 { 0x1ae60, "TEX", ADD_TEX
, true },
1133 { 0x1b000, "TEX.f16", ADD_TEX_COMPACT
, true },
1134 { 0x1c000, "RSHIFT_NAND.i32", ADD_SHIFT
},
1135 { 0x1c400, "RSHIFT_AND.i32", ADD_SHIFT
},
1136 { 0x1c800, "LSHIFT_NAND.i32", ADD_SHIFT
},
1137 { 0x1cc00, "LSHIFT_AND.i32", ADD_SHIFT
},
1138 { 0x1d000, "RSHIFT_XOR.i32", ADD_SHIFT
},
1139 { 0x1d400, "LSHIFT_ADD.i32", ADD_SHIFT
},
1140 { 0x1d800, "RSHIFT_SUB.i32", ADD_SHIFT
},
1141 { 0x1dd18, "OR.i32", ADD_TWO_SRC
},
1142 { 0x1dd20, "AND.i32", ADD_TWO_SRC
},
1143 { 0x1dd60, "LSHIFT.i32", ADD_TWO_SRC
},
1144 { 0x1dd50, "XOR.i32", ADD_TWO_SRC
},
1145 { 0x1dd80, "RSHIFT.i32", ADD_TWO_SRC
},
1146 { 0x1dda0, "ARSHIFT.i32", ADD_TWO_SRC
},
1149 static struct add_op_info
find_add_op_info(unsigned op
)
1151 for (unsigned i
= 0; i
< ARRAY_SIZE(add_op_infos
); i
++) {
1152 unsigned opCmp
= ~0;
1153 switch (add_op_infos
[i
].src_type
) {
1165 opCmp
= op
& ~0x3ff;
1173 opCmp
= op
& ~0x1fff;
1176 case ADD_FADDMscale
:
1177 opCmp
= op
& ~0xfff;
1181 opCmp
= op
& ~0x7ff;
1183 case ADD_TEX_COMPACT
:
1184 opCmp
= op
& ~0x3ff;
1186 case ADD_VARYING_INTERP
:
1187 opCmp
= op
& ~0x7ff;
1189 case ADD_VARYING_ADDRESS
:
1190 opCmp
= op
& ~0xfff;
1194 opCmp
= op
& ~0xfff;
1200 if (add_op_infos
[i
].op
== opCmp
)
1201 return add_op_infos
[i
];
1204 struct add_op_info info
;
1205 snprintf(info
.name
, sizeof(info
.name
), "op%04x", op
);
1207 info
.src_type
= ADD_TWO_SRC
;
1208 info
.has_data_reg
= true;
1212 static void dump_add(FILE *fp
, uint64_t word
, struct bifrost_regs regs
,
1213 struct bifrost_regs next_regs
, uint64_t *consts
,
1214 unsigned data_reg
, unsigned offset
, bool verbose
)
1217 fprintf(fp
, "# ADD: %016" PRIx64
"\n", word
);
1219 struct bifrost_add_inst ADD
;
1220 memcpy((char *) &ADD
, (char *) &word
, sizeof(ADD
));
1221 struct add_op_info info
= find_add_op_info(ADD
.op
);
1223 fprintf(fp
, "%s", info
.name
);
1225 // float16 seems like it doesn't support output modifiers
1226 if (info
.src_type
== ADD_FADD
|| info
.src_type
== ADD_FMINMAX
) {
1228 fprintf(fp
, "%s", bi_output_mod_name(bits(ADD
.op
, 8, 10)));
1229 if (info
.src_type
== ADD_FADD
)
1230 fprintf(fp
, "%s", bi_round_mode_name(bits(ADD
.op
, 10, 12)));
1232 fprintf(fp
, "%s", bi_minmax_mode_name(bits(ADD
.op
, 10, 12)));
1233 } else if (info
.src_type
== ADD_FCMP
|| info
.src_type
== ADD_FCMP16
) {
1234 dump_fcmp(fp
, bits(ADD
.op
, 3, 6));
1235 if (info
.src_type
== ADD_FCMP
)
1236 fprintf(fp
, ".f32");
1238 fprintf(fp
, ".v2f16");
1239 } else if (info
.src_type
== ADD_FADDMscale
) {
1240 switch ((ADD
.op
>> 6) & 0x7) {
1243 // causes GPU hangs on G71
1245 fprintf(fp
, ".invalid");
1247 // Same as usual outmod value.
1249 fprintf(fp
, ".clamp_0_1");
1251 // If src0 is infinite or NaN, flush it to zero so that the other
1252 // source is passed through unmodified.
1254 fprintf(fp
, ".flush_src0_inf_nan");
1258 fprintf(fp
, ".flush_src1_inf_nan");
1260 // Every other case seems to behave the same as the above?
1262 fprintf(fp
, ".unk%d", (ADD
.op
>> 6) & 0x7);
1265 } else if (info
.src_type
== ADD_VARYING_INTERP
) {
1267 fprintf(fp
, ".reuse");
1269 fprintf(fp
, ".flat");
1270 fprintf(fp
, "%s", bi_interp_mode_name((ADD
.op
>> 7) & 0x3));
1271 fprintf(fp
, ".v%d", ((ADD
.op
>> 5) & 0x3) + 1);
1272 } else if (info
.src_type
== ADD_BRANCH
) {
1273 enum bifrost_branch_code branchCode
= (enum bifrost_branch_code
) ((ADD
.op
>> 6) & 0x3f);
1274 if (branchCode
== BR_ALWAYS
) {
1275 // unconditional branch
1277 enum bifrost_branch_cond cond
= (enum bifrost_branch_cond
) ((ADD
.op
>> 6) & 0x7);
1278 enum branch_bit_size size
= (enum branch_bit_size
) ((ADD
.op
>> 9) & 0x7);
1279 bool portSwapped
= (ADD
.op
& 0x7) < ADD
.src0
;
1280 // See the comment in branch_bit_size
1281 if (size
== BR_SIZE_16YX0
)
1283 if (size
== BR_SIZE_16YX1
)
1284 portSwapped
= false;
1285 // These sizes are only for floating point comparisons, so the
1286 // non-floating-point comparisons are reused to encode the flipped
1288 if (size
== BR_SIZE_32_AND_16X
|| size
== BR_SIZE_32_AND_16Y
)
1289 portSwapped
= false;
1290 // There's only one argument, so we reuse the extra argument to
1292 if (size
== BR_SIZE_ZERO
)
1293 portSwapped
= !(ADD
.op
& 1);
1298 fprintf(fp
, ".LT.u");
1300 fprintf(fp
, ".LT.i");
1303 if (size
== BR_SIZE_32_AND_16X
|| size
== BR_SIZE_32_AND_16Y
) {
1304 fprintf(fp
, ".UNE.f");
1307 fprintf(fp
, ".LE.u");
1309 fprintf(fp
, ".LE.i");
1314 fprintf(fp
, ".GT.u");
1316 fprintf(fp
, ".GT.i");
1320 fprintf(fp
, ".GE.u");
1322 fprintf(fp
, ".GE.i");
1326 fprintf(fp
, ".NE.i");
1328 fprintf(fp
, ".EQ.i");
1332 fprintf(fp
, ".UNE.f");
1334 fprintf(fp
, ".OEQ.f");
1338 fprintf(fp
, ".OGT.unk.f");
1340 fprintf(fp
, ".OGT.f");
1344 fprintf(fp
, ".OLT.unk.f");
1346 fprintf(fp
, ".OLT.f");
1351 case BR_SIZE_32_AND_16X
:
1352 case BR_SIZE_32_AND_16Y
:
1361 case BR_SIZE_ZERO
: {
1362 unsigned ctrl
= (ADD
.op
>> 1) & 0x3;
1364 fprintf(fp
, "32.Z");
1366 fprintf(fp
, "16.Z");
1371 } else if (info
.src_type
== ADD_SHIFT
) {
1372 struct bifrost_shift_add shift
;
1373 memcpy(&shift
, &ADD
, sizeof(ADD
));
1376 fprintf(fp
, ".invert_1");
1379 fprintf(fp
, ".invert_2");
1382 fprintf(fp
, ".unk%u", shift
.zero
);
1383 } else if (info
.src_type
== ADD_VARYING_ADDRESS
) {
1384 struct bifrost_ld_var_addr ld
;
1385 memcpy(&ld
, &ADD
, sizeof(ADD
));
1386 fprintf(fp
, ".%s", bi_ldst_type_name(ld
.type
));
1387 } else if (info
.src_type
== ADD_LOAD_ATTR
) {
1388 struct bifrost_ld_attr ld
;
1389 memcpy(&ld
, &ADD
, sizeof(ADD
));
1392 fprintf(fp
, ".v%d%s", ld
.channels
+ 1, bi_ldst_type_name(ld
.type
));
1394 fprintf(fp
, ".%s", bi_ldst_type_name(ld
.type
));
1399 struct bifrost_reg_ctrl next_ctrl
= DecodeRegCtrl(fp
, next_regs
);
1400 if (next_ctrl
.add_write_unit
!= REG_WRITE_NONE
) {
1401 fprintf(fp
, "{R%d, T1}, ", GetRegToWrite(next_ctrl
.add_write_unit
, next_regs
));
1403 fprintf(fp
, "T1, ");
1406 switch (info
.src_type
) {
1408 // Note: in this case, regs.uniform_const == location | 0x8
1409 // This probably means we can't load uniforms or immediates in the
1410 // same instruction. This re-uses the encoding that normally means
1411 // "disabled", where the low 4 bits are ignored. Perhaps the extra
1412 // 0x8 or'd in indicates this is happening.
1413 fprintf(fp
, "location:%d, ", regs
.uniform_const
& 0x7);
1416 dump_src(fp
, ADD
.src0
, regs
, consts
, false);
1419 case ADD_TEX_COMPACT
: {
1422 bool dualTex
= false;
1424 fprintf(fp
, "coords <");
1425 dump_src(fp
, ADD
.src0
, regs
, consts
, false);
1427 dump_src(fp
, ADD
.op
& 0x7, regs
, consts
, false);
1430 if (info
.src_type
== ADD_TEX_COMPACT
) {
1431 tex_index
= (ADD
.op
>> 3) & 0x7;
1432 sampler_index
= (ADD
.op
>> 7) & 0x7;
1433 bool unknown
= (ADD
.op
& 0x40);
1434 // TODO: figure out if the unknown bit is ever 0
1436 fprintf(fp
, "unknown ");
1438 uint64_t constVal
= get_const(consts
, regs
);
1439 uint32_t controlBits
= (ADD
.op
& 0x8) ? (constVal
>> 32) : constVal
;
1440 struct bifrost_tex_ctrl ctrl
;
1441 memcpy((char *) &ctrl
, (char *) &controlBits
, sizeof(ctrl
));
1443 /* Dual-tex triggered for adjacent texturing
1444 * instructions with the same coordinates to different
1445 * textures/samplers. Observed for the compact
1446 * (2D/normal) case. */
1448 if ((ctrl
.result_type
& 7) == 1) {
1449 bool f32
= ctrl
.result_type
& 8;
1451 struct bifrost_dual_tex_ctrl dualCtrl
;
1452 memcpy((char *) &dualCtrl
, (char *) &controlBits
, sizeof(ctrl
));
1453 fprintf(fp
, "(dualtex) tex0:%d samp0:%d tex1:%d samp1:%d %s",
1454 dualCtrl
.tex_index0
, dualCtrl
.sampler_index0
,
1455 dualCtrl
.tex_index1
, dualCtrl
.sampler_index1
,
1456 f32
? "f32" : "f16");
1457 if (dualCtrl
.unk0
!= 3)
1458 fprintf(fp
, "unk:%d ", dualCtrl
.unk0
);
1461 if (ctrl
.no_merge_index
) {
1462 tex_index
= ctrl
.tex_index
;
1463 sampler_index
= ctrl
.sampler_index
;
1465 tex_index
= sampler_index
= ctrl
.tex_index
;
1466 unsigned unk
= ctrl
.sampler_index
>> 2;
1468 fprintf(fp
, "unk:%d ", unk
);
1469 if (ctrl
.sampler_index
& 1)
1471 if (ctrl
.sampler_index
& 2)
1476 fprintf(fp
, "unk0:%d ", ctrl
.unk0
);
1478 fprintf(fp
, "unk1 ");
1479 if (ctrl
.unk2
!= 0xf)
1480 fprintf(fp
, "unk2:%x ", ctrl
.unk2
);
1482 switch (ctrl
.result_type
) {
1484 fprintf(fp
, "f32 ");
1487 fprintf(fp
, "i32 ");
1490 fprintf(fp
, "u32 ");
1493 fprintf(fp
, "unktype(%x) ", ctrl
.result_type
);
1496 switch (ctrl
.tex_type
) {
1498 fprintf(fp
, "cube ");
1501 fprintf(fp
, "buffer ");
1512 fprintf(fp
, "shadow ");
1514 fprintf(fp
, "array ");
1517 if (ctrl
.calc_gradients
) {
1518 int comp
= (controlBits
>> 20) & 0x3;
1519 fprintf(fp
, "txg comp:%d ", comp
);
1521 fprintf(fp
, "txf ");
1524 if (!ctrl
.not_supply_lod
) {
1525 if (ctrl
.compute_lod
)
1526 fprintf(fp
, "lod_bias ");
1528 fprintf(fp
, "lod ");
1531 if (!ctrl
.calc_gradients
)
1532 fprintf(fp
, "grad ");
1535 if (ctrl
.texel_offset
)
1536 fprintf(fp
, "offset ");
1541 if (tex_index
== -1)
1542 fprintf(fp
, "tex:indirect ");
1544 fprintf(fp
, "tex:%d ", tex_index
);
1546 if (sampler_index
== -1)
1547 fprintf(fp
, "samp:indirect ");
1549 fprintf(fp
, "samp:%d ", sampler_index
);
1553 case ADD_VARYING_INTERP
: {
1554 unsigned addr
= ADD
.op
& 0x1f;
1555 if (addr
< 0b10100) {
1557 fprintf(fp
, "%d", addr
);
1558 } else if (addr
< 0b11000) {
1560 fprintf(fp
, "fragw");
1561 else if (addr
== 23)
1562 fprintf(fp
, "fragz");
1564 fprintf(fp
, "unk%d", addr
);
1566 dump_src(fp
, ADD
.op
& 0x7, regs
, consts
, false);
1569 dump_src(fp
, ADD
.src0
, regs
, consts
, false);
1572 case ADD_VARYING_ADDRESS
: {
1573 dump_src(fp
, ADD
.src0
, regs
, consts
, false);
1575 dump_src(fp
, ADD
.op
& 0x7, regs
, consts
, false);
1577 unsigned location
= (ADD
.op
>> 3) & 0x1f;
1578 if (location
< 16) {
1579 fprintf(fp
, "location:%d", location
);
1580 } else if (location
== 20) {
1581 fprintf(fp
, "location:%u", (uint32_t) get_const(consts
, regs
));
1582 } else if (location
== 21) {
1583 fprintf(fp
, "location:%u", (uint32_t) (get_const(consts
, regs
) >> 32));
1585 fprintf(fp
, "location:%d(unk)", location
);
1590 fprintf(fp
, "location:%d, ", (ADD
.op
>> 3) & 0x1f);
1592 dump_src(fp
, ADD
.src0
, regs
, consts
, false);
1594 dump_src(fp
, ADD
.op
& 0x7, regs
, consts
, false);
1597 dump_src(fp
, ADD
.src0
, regs
, consts
, false);
1599 dump_src(fp
, ADD
.op
& 0x7, regs
, consts
, false);
1601 dump_src(fp
, (ADD
.op
>> 3) & 0x7, regs
, consts
, false);
1604 struct bifrost_shift_add shift
;
1605 memcpy(&shift
, &ADD
, sizeof(ADD
));
1606 dump_src(fp
, shift
.src0
, regs
, consts
, false);
1608 dump_src(fp
, shift
.src1
, regs
, consts
, false);
1610 dump_src(fp
, shift
.src2
, regs
, consts
, false);
1617 if (ADD
.op
& 0x1000)
1618 fprintf(fp
, "abs(");
1619 dump_src(fp
, ADD
.src0
, regs
, consts
, false);
1620 switch ((ADD
.op
>> 6) & 0x3) {
1627 if (ADD
.op
& 0x1000)
1633 fprintf(fp
, "abs(");
1634 dump_src(fp
, ADD
.op
& 0x7, regs
, consts
, false);
1635 switch ((ADD
.op
>> 6) & 0x3) {
1646 fprintf(fp
, ".unk");
1655 if (ADD
.op
& 0x1000)
1656 fprintf(fp
, "abs(");
1657 dump_src(fp
, ADD
.src0
, regs
, consts
, false);
1658 if (ADD
.op
& 0x1000)
1660 dump_16swizzle(fp
, (ADD
.op
>> 6) & 0x3);
1665 fprintf(fp
, "abs(");
1666 dump_src(fp
, ADD
.op
& 0x7, regs
, consts
, false);
1667 dump_16swizzle(fp
, (ADD
.op
>> 8) & 0x3);
1671 case ADD_FMINMAX16
: {
1672 bool abs1
= ADD
.op
& 0x8;
1673 bool abs2
= (ADD
.op
& 0x7) < ADD
.src0
;
1677 fprintf(fp
, "abs(");
1678 dump_src(fp
, ADD
.src0
, regs
, consts
, false);
1679 dump_16swizzle(fp
, (ADD
.op
>> 6) & 0x3);
1686 fprintf(fp
, "abs(");
1687 dump_src(fp
, ADD
.op
& 0x7, regs
, consts
, false);
1688 dump_16swizzle(fp
, (ADD
.op
>> 8) & 0x3);
1691 fprintf(fp
, "/* %X */\n", (ADD
.op
>> 10) & 0x3); /* mode */
1694 case ADD_FADDMscale
: {
1698 fprintf(fp
, "abs(");
1699 dump_src(fp
, ADD
.src0
, regs
, consts
, false);
1707 dump_src(fp
, ADD
.op
& 0x7, regs
, consts
, false);
1711 dump_src(fp
, (ADD
.op
>> 3) & 0x7, regs
, consts
, false);
1715 if (ADD
.op
& 0x400) {
1718 if (ADD
.op
& 0x100) {
1719 fprintf(fp
, "abs(");
1721 dump_src(fp
, ADD
.src0
, regs
, consts
, false);
1722 switch ((ADD
.op
>> 6) & 0x3) {
1729 if (ADD
.op
& 0x100) {
1733 if (ADD
.op
& 0x200) {
1734 fprintf(fp
, "abs(");
1736 dump_src(fp
, ADD
.op
& 0x7, regs
, consts
, false);
1737 switch ((ADD
.op
>> 6) & 0x3) {
1748 fprintf(fp
, ".unk");
1751 if (ADD
.op
& 0x200) {
1756 dump_src(fp
, ADD
.src0
, regs
, consts
, false);
1757 dump_16swizzle(fp
, (ADD
.op
>> 6) & 0x3);
1759 dump_src(fp
, ADD
.op
& 0x7, regs
, consts
, false);
1760 dump_16swizzle(fp
, (ADD
.op
>> 8) & 0x3);
1763 enum bifrost_branch_code code
= (enum bifrost_branch_code
) ((ADD
.op
>> 6) & 0x3f);
1764 enum branch_bit_size size
= (enum branch_bit_size
) ((ADD
.op
>> 9) & 0x7);
1765 if (code
!= BR_ALWAYS
) {
1766 dump_src(fp
, ADD
.src0
, regs
, consts
, false);
1776 case BR_SIZE_ZERO
: {
1777 unsigned ctrl
= (ADD
.op
>> 1) & 0x3;
1794 if (code
!= BR_ALWAYS
&& size
!= BR_SIZE_ZERO
) {
1795 dump_src(fp
, ADD
.op
& 0x7, regs
, consts
, false);
1800 case BR_SIZE_32_AND_16X
:
1804 case BR_SIZE_32_AND_16Y
:
1812 // I haven't had the chance to test if this actually specifies the
1813 // branch offset, since I couldn't get it to produce values other
1814 // than 5 (uniform/const high), but these three bits are always
1815 // consistent across branch instructions, so it makes sense...
1816 int offsetSrc
= (ADD
.op
>> 3) & 0x7;
1817 if (offsetSrc
== 4 || offsetSrc
== 5) {
1818 // If the offset is known/constant, we can decode it
1819 uint32_t raw_offset
;
1821 raw_offset
= get_const(consts
, regs
);
1823 raw_offset
= get_const(consts
, regs
) >> 32;
1824 // The high 4 bits are flags, while the rest is the
1825 // twos-complement offset in bytes (here we convert to
1827 int32_t branch_offset
= ((int32_t) raw_offset
<< 4) >> 8;
1829 // If high4 is the high 4 bits of the last 64-bit constant,
1830 // this is calculated as (high4 + 4) & 0xf, or 0 if the branch
1831 // offset itself is the last constant. Not sure if this is
1832 // actually used, or just garbage in unused bits, but in any
1833 // case, we can just ignore it here since it's redundant. Note
1834 // that if there is any padding, this will be 4 since the
1835 // padding counts as the last constant.
1836 unsigned flags
= raw_offset
>> 28;
1839 // Note: the offset is in bytes, relative to the beginning of the
1840 // current clause, so a zero offset would be a loop back to the
1841 // same clause (annoyingly different from Midgard).
1842 fprintf(fp
, "clause_%d", offset
+ branch_offset
);
1844 dump_src(fp
, offsetSrc
, regs
, consts
, false);
1848 if (info
.has_data_reg
) {
1849 fprintf(fp
, ", R%d", data_reg
);
1854 void dump_instr(FILE *fp
, const struct bifrost_alu_inst
*instr
,
1855 struct bifrost_regs next_regs
, uint64_t *consts
,
1856 unsigned data_reg
, unsigned offset
, bool verbose
)
1858 struct bifrost_regs regs
;
1859 memcpy((char *) ®s
, (char *) &instr
->reg_bits
, sizeof(regs
));
1862 fprintf(fp
, "# regs: %016" PRIx64
"\n", instr
->reg_bits
);
1863 dump_regs(fp
, regs
);
1865 dump_fma(fp
, instr
->fma_bits
, regs
, next_regs
, consts
, verbose
);
1866 dump_add(fp
, instr
->add_bits
, regs
, next_regs
, consts
, data_reg
, offset
, verbose
);
1869 bool dump_clause(FILE *fp
, uint32_t *words
, unsigned *size
, unsigned offset
, bool verbose
)
1871 // State for a decoded clause
1872 struct bifrost_alu_inst instrs
[8] = {};
1873 uint64_t consts
[6] = {};
1874 unsigned num_instrs
= 0;
1875 unsigned num_consts
= 0;
1876 uint64_t header_bits
= 0;
1877 bool stopbit
= false;
1880 for (i
= 0; ; i
++, words
+= 4) {
1883 for (int j
= 0; j
< 4; j
++)
1884 fprintf(fp
, "%08x ", words
[3 - j
]); // low bit on the right
1887 unsigned tag
= bits(words
[0], 0, 8);
1889 // speculatively decode some things that are common between many formats, so we can share some code
1890 struct bifrost_alu_inst main_instr
= {};
1892 main_instr
.add_bits
= bits(words
[2], 2, 32 - 13);
1894 main_instr
.fma_bits
= bits(words
[1], 11, 32) | bits(words
[2], 0, 2) << (32 - 11);
1896 main_instr
.reg_bits
= ((uint64_t) bits(words
[1], 0, 11)) << 24 | (uint64_t) bits(words
[0], 8, 32);
1898 uint64_t const0
= bits(words
[0], 8, 32) << 4 | (uint64_t) words
[1] << 28 | bits(words
[2], 0, 4) << 60;
1899 uint64_t const1
= bits(words
[2], 4, 32) << 4 | (uint64_t) words
[3] << 32;
1901 bool stop
= tag
& 0x40;
1904 fprintf(fp
, "# tag: 0x%02x\n", tag
);
1907 unsigned idx
= stop
? 5 : 2;
1908 main_instr
.add_bits
|= ((tag
>> 3) & 0x7) << 17;
1909 instrs
[idx
+ 1] = main_instr
;
1910 instrs
[idx
].add_bits
= bits(words
[3], 0, 17) | ((tag
& 0x7) << 17);
1911 instrs
[idx
].fma_bits
|= bits(words
[2], 19, 32) << 10;
1912 consts
[0] = bits(words
[3], 17, 32) << 4;
1915 switch ((tag
>> 3) & 0x7) {
1917 switch (tag
& 0x7) {
1919 main_instr
.add_bits
|= bits(words
[3], 29, 32) << 17;
1920 instrs
[1] = main_instr
;
1925 instrs
[2].add_bits
= bits(words
[3], 0, 17) | bits(words
[3], 29, 32) << 17;
1926 instrs
[2].fma_bits
|= bits(words
[2], 19, 32) << 10;
1934 instrs
[2].add_bits
= bits(words
[3], 0, 17) | bits(words
[3], 29, 32) << 17;
1935 instrs
[2].fma_bits
|= bits(words
[2], 19, 32) << 10;
1936 main_instr
.add_bits
|= bits(words
[3], 26, 29) << 17;
1937 instrs
[3] = main_instr
;
1938 if ((tag
& 0x7) == 0x5) {
1944 instrs
[5].add_bits
= bits(words
[3], 0, 17) | bits(words
[3], 29, 32) << 17;
1945 instrs
[5].fma_bits
|= bits(words
[2], 19, 32) << 10;
1952 instrs
[5].add_bits
= bits(words
[3], 0, 17) | bits(words
[3], 29, 32) << 17;
1953 instrs
[5].fma_bits
|= bits(words
[2], 19, 32) << 10;
1954 main_instr
.add_bits
|= bits(words
[3], 26, 29) << 17;
1955 instrs
[6] = main_instr
;
1960 fprintf(fp
, "unknown tag bits 0x%02x\n", tag
);
1965 unsigned idx
= ((tag
>> 3) & 0x7) == 2 ? 4 : 7;
1966 main_instr
.add_bits
|= (tag
& 0x7) << 17;
1967 instrs
[idx
] = main_instr
;
1968 consts
[0] |= (bits(words
[2], 19, 32) | ((uint64_t) words
[3] << 13)) << 19;
1970 num_instrs
= idx
+ 1;
1975 unsigned idx
= stop
? 4 : 1;
1976 main_instr
.add_bits
|= (tag
& 0x7) << 17;
1977 instrs
[idx
] = main_instr
;
1978 instrs
[idx
+ 1].fma_bits
|= bits(words
[3], 22, 32);
1979 instrs
[idx
+ 1].reg_bits
= bits(words
[2], 19, 32) | (bits(words
[3], 0, 22) << (32 - 19));
1983 // only constants can come after this
1987 header_bits
= bits(words
[2], 19, 32) | ((uint64_t) words
[3] << (32 - 19));
1988 main_instr
.add_bits
|= (tag
& 0x7) << 17;
1989 instrs
[0] = main_instr
;
1993 unsigned pos
= tag
& 0xf;
1994 // note that `pos' encodes both the total number of
1995 // instructions and the position in the constant stream,
1996 // presumably because decoded constants and instructions
1997 // share a buffer in the decoder, but we only care about
1998 // the position in the constant stream; the total number of
1999 // instructions is redundant.
2000 unsigned const_idx
= 0;
2027 fprintf(fp
, "# unknown pos 0x%x\n", pos
);
2031 if (num_consts
< const_idx
+ 2)
2032 num_consts
= const_idx
+ 2;
2034 consts
[const_idx
] = const0
;
2035 consts
[const_idx
+ 1] = const1
;
2051 fprintf(fp
, "# header: %012" PRIx64
"\n", header_bits
);
2054 struct bifrost_header header
;
2055 memcpy((char *) &header
, (char *) &header_bits
, sizeof(struct bifrost_header
));
2056 dump_header(fp
, header
, verbose
);
2057 if (!header
.no_end_of_shader
)
2061 for (i
= 0; i
< num_instrs
; i
++) {
2062 struct bifrost_regs next_regs
;
2063 if (i
+ 1 == num_instrs
) {
2064 memcpy((char *) &next_regs
, (char *) &instrs
[0].reg_bits
,
2067 memcpy((char *) &next_regs
, (char *) &instrs
[i
+ 1].reg_bits
,
2071 dump_instr(fp
, &instrs
[i
], next_regs
, consts
, header
.datareg
, offset
, verbose
);
2076 for (unsigned i
= 0; i
< num_consts
; i
++) {
2077 fprintf(fp
, "# const%d: %08" PRIx64
"\n", 2 * i
, consts
[i
] & 0xffffffff);
2078 fprintf(fp
, "# const%d: %08" PRIx64
"\n", 2 * i
+ 1, consts
[i
] >> 32);
2084 void disassemble_bifrost(FILE *fp
, uint8_t *code
, size_t size
, bool verbose
)
2086 uint32_t *words
= (uint32_t *) code
;
2087 uint32_t *words_end
= words
+ (size
/ 4);
2088 // used for displaying branch targets
2089 unsigned offset
= 0;
2090 while (words
!= words_end
) {
2091 // we don't know what the program-end bit is quite yet, so for now just
2092 // assume that an all-0 quadword is padding
2093 uint32_t zero
[4] = {};
2094 if (memcmp(words
, zero
, 4 * sizeof(uint32_t)) == 0)
2096 fprintf(fp
, "clause_%d:\n", offset
);
2098 if (dump_clause(fp
, words
, &size
, offset
, verbose
) == true) {