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>
5 * Copyright (C) 2019-2020 Collabora, Ltd.
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice (including the next
15 * paragraph) shall be included in all copies or substantial portions of the
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
21 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30 bi_clause_type_name(enum bifrost_clause_type T
)
33 case BIFROST_CLAUSE_NONE
: return "";
34 case BIFROST_CLAUSE_LOAD_VARY
: return "load_vary";
35 case BIFROST_CLAUSE_UBO
: return "ubo";
36 case BIFROST_CLAUSE_TEX
: return "tex";
37 case BIFROST_CLAUSE_SSBO_LOAD
: return "load";
38 case BIFROST_CLAUSE_SSBO_STORE
: return "store";
39 case BIFROST_CLAUSE_BLEND
: return "blend";
40 case BIFROST_CLAUSE_ATEST
: return "atest";
41 case BIFROST_CLAUSE_64BIT
: return "64";
47 bi_output_mod_name(enum bifrost_outmod mod
)
50 case BIFROST_NONE
: return "";
51 case BIFROST_POS
: return ".pos";
52 case BIFROST_SAT_SIGNED
: return ".sat_signed";
53 case BIFROST_SAT
: return ".sat";
54 default: return "invalid";
59 bi_minmax_mode_name(enum bifrost_minmax_mode mod
)
62 case BIFROST_MINMAX_NONE
: return "";
63 case BIFROST_NAN_WINS
: return ".nan_wins";
64 case BIFROST_SRC1_WINS
: return ".src1_wins";
65 case BIFROST_SRC0_WINS
: return ".src0_wins";
66 default: return "invalid";
71 bi_round_mode_name(enum bifrost_roundmode mod
)
74 case BIFROST_RTE
: return "";
75 case BIFROST_RTP
: return ".rtp";
76 case BIFROST_RTN
: return ".rtn";
77 case BIFROST_RTZ
: return ".rtz";
78 default: return "invalid";
83 bi_csel_cond_name(enum bifrost_csel_cond cond
)
86 case BIFROST_FEQ_F
: return "feq.f";
87 case BIFROST_FGT_F
: return "fgt.f";
88 case BIFROST_FGE_F
: return "fge.f";
89 case BIFROST_IEQ_F
: return "ieq.f";
90 case BIFROST_IGT_I
: return "igt.i";
91 case BIFROST_IGE_I
: return "uge.i";
92 case BIFROST_UGT_I
: return "ugt.i";
93 case BIFROST_UGE_I
: return "uge.i";
94 default: return "invalid";
99 bi_interp_mode_name(enum bifrost_interp_mode mode
)
102 case BIFROST_INTERP_PER_FRAG
: return ".per_frag";
103 case BIFROST_INTERP_CENTROID
: return ".centroid";
104 case BIFROST_INTERP_DEFAULT
: return "";
105 case BIFROST_INTERP_EXPLICIT
: return ".explicit";
106 default: return ".unknown";
111 bi_ldst_type_name(enum bifrost_ldst_type type
)
114 case BIFROST_LDST_F16
: return "f16";
115 case BIFROST_LDST_F32
: return "f32";
116 case BIFROST_LDST_I32
: return "i32";
117 case BIFROST_LDST_U32
: return "u32";
118 default: return "invalid";
122 /* The remaining functions in this file are for IR-internal
123 * structures; the disassembler doesn't use them */
126 bi_class_name(enum bi_class cl
)
129 case BI_ADD
: return "add";
130 case BI_ATEST
: return "atest";
131 case BI_BRANCH
: return "branch";
132 case BI_CMP
: return "cmp";
133 case BI_BLEND
: return "blend";
134 case BI_BITWISE
: return "bitwise";
135 case BI_COMBINE
: return "combine";
136 case BI_CONVERT
: return "convert";
137 case BI_CSEL
: return "csel";
138 case BI_DISCARD
: return "discard";
139 case BI_FMA
: return "fma";
140 case BI_FMOV
: return "fmov";
141 case BI_FREXP
: return "frexp";
142 case BI_ISUB
: return "isub";
143 case BI_LOAD
: return "load";
144 case BI_LOAD_UNIFORM
: return "load_uniform";
145 case BI_LOAD_ATTR
: return "load_attr";
146 case BI_LOAD_VAR
: return "load_var";
147 case BI_LOAD_VAR_ADDRESS
: return "load_var_address";
148 case BI_MINMAX
: return "minmax";
149 case BI_MOV
: return "mov";
150 case BI_SELECT
: return "select";
151 case BI_SHIFT
: return "shift";
152 case BI_STORE
: return "store";
153 case BI_STORE_VAR
: return "store_var";
154 case BI_SPECIAL
: return "special";
155 case BI_TABLE
: return "table";
156 case BI_TEX
: return "tex";
157 case BI_ROUND
: return "round";
158 default: return "unknown_class";
163 bi_print_dest_index(FILE *fp
, bi_instruction
*ins
, unsigned index
)
167 else if (index
& BIR_INDEX_REGISTER
)
168 fprintf(fp
, "br%u", index
& ~BIR_INDEX_REGISTER
);
169 else if (index
& BIR_IS_REG
)
170 fprintf(fp
, "r%u", index
>> 1);
171 else if (!(index
& BIR_SPECIAL
))
172 fprintf(fp
, "%u", (index
>> 1) - 1);
180 bi_print_index(FILE *fp
, bi_instruction
*ins
, unsigned index
, unsigned s
)
182 if (bi_print_dest_index(fp
, ins
, index
))
185 if (index
& BIR_INDEX_UNIFORM
)
186 fprintf(fp
, "u%u", index
& ~BIR_INDEX_UNIFORM
);
187 else if (index
& BIR_INDEX_CONSTANT
)
188 fprintf(fp
, "#0x%" PRIx64
, bi_get_immediate(ins
, s
));
189 else if (index
& BIR_INDEX_ZERO
)
196 bi_print_src(FILE *fp
, bi_instruction
*ins
, unsigned s
)
198 unsigned src
= ins
->src
[s
];
199 bool mods
= bi_has_source_mods(ins
);
200 bool abs
= ins
->src_abs
[s
] && mods
;
201 bool neg
= ins
->src_neg
[s
] && mods
;
209 bi_print_index(fp
, ins
, src
, s
);
215 /* Prints a NIR ALU type in Bifrost-style ".f32" ".i8" etc */
218 bi_print_alu_type(nir_alu_type t
, FILE *fp
)
220 unsigned size
= nir_alu_type_get_type_size(t
);
221 nir_alu_type base
= nir_alu_type_get_base_type(t
);
237 fprintf(fp
, ".unknown");
241 fprintf(fp
, "%u", size
);
245 bi_print_swizzle(bi_instruction
*ins
, unsigned src
, FILE *fp
)
249 for (unsigned u
= 0; u
< bi_get_component_count(ins
, src
); ++u
) {
250 assert(ins
->swizzle
[src
][u
] < 4);
251 fputc("xyzw"[ins
->swizzle
[src
][u
]], fp
);
256 bi_bitwise_op_name(enum bi_bitwise_op op
)
259 case BI_BITWISE_AND
: return "and";
260 case BI_BITWISE_OR
: return "or";
261 case BI_BITWISE_XOR
: return "xor";
262 default: return "invalid";
267 bi_table_op_name(enum bi_table_op op
)
270 case BI_TABLE_LOG2_U_OVER_U_1_LOW
: return "log2.help";
271 default: return "invalid";
276 bi_special_op_name(enum bi_special_op op
)
279 case BI_SPECIAL_FRCP
: return "frcp";
280 case BI_SPECIAL_FRSQ
: return "frsq";
281 case BI_SPECIAL_EXP2_LOW
: return "exp2_low";
282 default: return "invalid";
287 bi_reduce_op_name(enum bi_reduce_op op
)
290 case BI_REDUCE_ADD_FREXPM
: return "add_frexpm";
291 default: return "invalid";
296 bi_frexp_op_name(enum bi_frexp_op op
)
299 case BI_FREXPE_LOG
: return "frexpe_log";
300 default: return "invalid";
305 bi_tex_op_name(enum bi_tex_op op
)
308 case BI_TEX_NORMAL
: return "normal";
309 case BI_TEX_COMPACT
: return "compact";
310 case BI_TEX_DUAL
: return "dual";
311 default: return "invalid";
316 bi_print_load_vary(struct bi_load_vary
*load
, FILE *fp
)
318 fprintf(fp
, "%s", bi_interp_mode_name(load
->interp_mode
));
321 fprintf(fp
, ".reuse");
324 fprintf(fp
, ".flat");
328 bi_cond_name(enum bi_cond cond
)
331 case BI_COND_ALWAYS
: return "always";
332 case BI_COND_LT
: return "lt";
333 case BI_COND_LE
: return "le";
334 case BI_COND_GE
: return "ge";
335 case BI_COND_GT
: return "gt";
336 case BI_COND_EQ
: return "eq";
337 case BI_COND_NE
: return "ne";
338 default: return "invalid";
343 bi_print_branch(struct bi_branch
*branch
, FILE *fp
)
345 fprintf(fp
, ".%s", bi_cond_name(branch
->cond
));
349 bi_print_instruction(bi_instruction
*ins
, FILE *fp
)
351 if (ins
->type
== BI_MINMAX
)
352 fprintf(fp
, "%s", ins
->op
.minmax
== BI_MINMAX_MIN
? "min" : "max");
353 else if (ins
->type
== BI_BITWISE
)
354 fprintf(fp
, "%s", bi_bitwise_op_name(ins
->op
.bitwise
));
355 else if (ins
->type
== BI_ROUND
)
356 fprintf(fp
, ins
->op
.round
== BI_ROUND_MODE
? "roundMode": "round");
357 else if (ins
->type
== BI_SPECIAL
)
358 fprintf(fp
, "%s", bi_special_op_name(ins
->op
.special
));
359 else if (ins
->type
== BI_TABLE
)
360 fprintf(fp
, "%s", bi_table_op_name(ins
->op
.table
));
361 else if (ins
->type
== BI_REDUCE_FMA
)
362 fprintf(fp
, "%s", bi_reduce_op_name(ins
->op
.reduce
));
363 else if (ins
->type
== BI_FREXP
)
364 fprintf(fp
, "%s", bi_frexp_op_name(ins
->op
.frexp
));
365 else if (ins
->type
== BI_CMP
)
366 fprintf(fp
, "%s", bi_cond_name(ins
->op
.compare
));
368 fprintf(fp
, "%s", bi_class_name(ins
->type
));
370 if ((ins
->type
== BI_ADD
|| ins
->type
== BI_FMA
) && ins
->op
.mscale
)
371 fprintf(fp
, ".mscale");
373 if (ins
->type
== BI_MINMAX
)
374 fprintf(fp
, "%s", bi_minmax_mode_name(ins
->minmax
));
375 else if (ins
->type
== BI_LOAD_VAR
)
376 bi_print_load_vary(&ins
->load_vary
, fp
);
377 else if (ins
->type
== BI_BRANCH
)
378 bi_print_branch(&ins
->branch
, fp
);
379 else if (ins
->type
== BI_CSEL
)
380 fprintf(fp
, ".%s", bi_cond_name(ins
->csel_cond
));
381 else if (ins
->type
== BI_BLEND
)
382 fprintf(fp
, ".loc%u", ins
->blend_location
);
383 else if (ins
->type
== BI_TEX
)
384 fprintf(fp
, ".%s", bi_tex_op_name(ins
->op
.texture
));
386 if (ins
->vector_channels
)
387 fprintf(fp
, ".v%u", ins
->vector_channels
);
390 bi_print_alu_type(ins
->dest_type
, fp
);
392 if (bi_has_outmod(ins
))
393 fprintf(fp
, "%s", bi_output_mod_name(ins
->outmod
));
395 if (bi_class_props
[ins
->type
] & BI_ROUNDMODE
)
396 fprintf(fp
, "%s", bi_round_mode_name(ins
->roundmode
));
399 bool succ
= bi_print_dest_index(fp
, ins
, ins
->dest
);
402 if (ins
->dest_offset
)
403 fprintf(fp
, "+%u", ins
->dest_offset
);
407 bi_foreach_src(ins
, s
) {
408 bi_print_src(fp
, ins
, s
);
410 if (ins
->src
[s
] && !(ins
->src
[s
] & (BIR_INDEX_CONSTANT
| BIR_INDEX_ZERO
))) {
411 bi_print_alu_type(ins
->src_types
[s
], fp
);
412 bi_print_swizzle(ins
, s
, fp
);
415 if (s
< BIR_SRC_COUNT
)
419 if (ins
->type
== BI_BRANCH
) {
420 if (ins
->branch
.target
)
421 fprintf(fp
, "-> block%u", ins
->branch
.target
->base
.name
);
423 fprintf(fp
, "-> blockhole");
430 bi_print_bundle(bi_bundle
*bundle
, FILE *fp
)
432 bi_instruction
*ins
[2] = { bundle
->fma
, bundle
->add
};
434 for (unsigned i
= 0; i
< 2; ++i
) {
436 bi_print_instruction(ins
[i
], fp
);
438 fprintf(fp
, "nop\n");
443 bi_print_clause(bi_clause
*clause
, FILE *fp
)
445 fprintf(fp
, "\tid(%u)", clause
->scoreboard_id
);
447 if (clause
->dependencies
) {
448 fprintf(fp
, ", wait(");
450 for (unsigned i
= 0; i
< 8; ++i
) {
451 if (clause
->dependencies
& (1 << i
))
452 fprintf(fp
, "%u ", i
);
458 if (!clause
->back_to_back
)
459 fprintf(fp
, " nbb %s", clause
->branch_conditional
? "branch-cond" : "branch-uncond");
461 if (clause
->data_register_write_barrier
)
462 fprintf(fp
, " drwb");
466 if (clause
->instruction_count
) {
467 assert(!clause
->bundle_count
);
469 for (unsigned i
= 0; i
< clause
->instruction_count
; ++i
)
470 bi_print_instruction(clause
->instructions
[i
], fp
);
472 assert(clause
->bundle_count
);
474 for (unsigned i
= 0; i
< clause
->bundle_count
; ++i
)
475 bi_print_bundle(&clause
->bundles
[i
], fp
);
478 if (clause
->constant_count
) {
479 for (unsigned i
= 0; i
< clause
->constant_count
; ++i
)
480 fprintf(fp
, "%" PRIx64
" ", clause
->constants
[i
]);
487 bi_print_block(bi_block
*block
, FILE *fp
)
489 fprintf(fp
, "block%u {\n", block
->base
.name
);
491 if (block
->scheduled
) {
492 bi_foreach_clause_in_block(block
, clause
)
493 bi_print_clause(clause
, fp
);
495 bi_foreach_instr_in_block(block
, ins
)
496 bi_print_instruction(ins
, fp
);
501 if (block
->base
.successors
[0]) {
504 pan_foreach_successor((&block
->base
), succ
)
505 fprintf(fp
, "block%u ", succ
->name
);
508 if (block
->base
.predecessors
->entries
) {
509 fprintf(fp
, " from");
511 bi_foreach_predecessor(block
, pred
)
512 fprintf(fp
, " block%u", pred
->base
.name
);
519 bi_print_shader(bi_context
*ctx
, FILE *fp
)
521 bi_foreach_block(ctx
, block
)
522 bi_print_block((bi_block
*) block
, fp
);