2 * Copyright (c) 2012 Rob Clark <robdclark@gmail.com>
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
28 #include <sys/types.h>
34 #include "instr-a2xx.h"
36 static const char *levels
[] = {
54 static enum debug_t debug
;
60 static const char chan_names
[] = {
62 /* these only apply to FETCH dst's: */
66 static void print_srcreg(uint32_t num
, uint32_t type
,
67 uint32_t swiz
, uint32_t negate
, uint32_t abs
)
73 printf("%c%u", type
? 'R' : 'C', num
);
77 for (i
= 0; i
< 4; i
++) {
78 printf("%c", chan_names
[(swiz
+ i
) & 0x3]);
86 static void print_dstreg(uint32_t num
, uint32_t mask
, uint32_t dst_exp
)
88 printf("%s%u", dst_exp
? "export" : "R", num
);
92 for (i
= 0; i
< 4; i
++) {
93 printf("%c", (mask
& 0x1) ? chan_names
[i
] : '_');
99 static void print_export_comment(uint32_t num
, gl_shader_stage type
)
101 const char *name
= NULL
;
103 case MESA_SHADER_VERTEX
:
105 case 62: name
= "gl_Position"; break;
106 case 63: name
= "gl_PointSize"; break;
109 case MESA_SHADER_FRAGMENT
:
111 case 0: name
= "gl_FragColor"; break;
115 unreachable("not reached");
117 /* if we had a symbol table here, we could look
118 * up the name of the varying..
121 printf("\t; %s", name
);
128 } vector_instructions
[0x20] = {
129 #define INSTR(opc, num_srcs) [opc] = { num_srcs, #opc }
147 INSTR(DOT2ADDv
, 3), // ???
150 INSTR(PRED_SETE_PUSHv
, 2),
151 INSTR(PRED_SETNE_PUSHv
, 2),
152 INSTR(PRED_SETGT_PUSHv
, 2),
153 INSTR(PRED_SETGTE_PUSHv
, 2),
160 }, scalar_instructions
[0x40] = {
165 INSTR(MUL_PREV2s
, 1),
178 INSTR(RECIP_CLAMP
, 1),
180 INSTR(RECIP_IEEE
, 1),
181 INSTR(RECIPSQ_CLAMP
, 1),
182 INSTR(RECIPSQ_FF
, 1),
183 INSTR(RECIPSQ_IEEE
, 1),
185 INSTR(MOVA_FLOORs
, 1),
188 INSTR(PRED_SETEs
, 1),
189 INSTR(PRED_SETNEs
, 1),
190 INSTR(PRED_SETGTs
, 1),
191 INSTR(PRED_SETGTEs
, 1),
192 INSTR(PRED_SET_INVs
, 1),
193 INSTR(PRED_SET_POPs
, 1),
194 INSTR(PRED_SET_CLRs
, 1),
195 INSTR(PRED_SET_RESTOREs
, 1),
202 INSTR(MUL_CONST_0
, 1),
203 INSTR(MUL_CONST_1
, 1),
204 INSTR(ADD_CONST_0
, 1),
205 INSTR(ADD_CONST_1
, 1),
206 INSTR(SUB_CONST_0
, 1),
207 INSTR(SUB_CONST_1
, 1),
210 INSTR(RETAIN_PREV
, 1),
214 static int disasm_alu(uint32_t *dwords
, uint32_t alu_off
,
215 int level
, int sync
, gl_shader_stage type
)
217 instr_alu_t
*alu
= (instr_alu_t
*)dwords
;
219 printf("%s", levels
[level
]);
220 if (debug
& PRINT_RAW
) {
221 printf("%02x: %08x %08x %08x\t", alu_off
,
222 dwords
[0], dwords
[1], dwords
[2]);
225 printf(" %sALU:\t", sync
? "(S)" : " ");
227 printf("%s", vector_instructions
[alu
->vector_opc
].name
);
229 if (alu
->pred_select
& 0x2) {
230 /* seems to work similar to conditional execution in ARM instruction
231 * set, so let's use a similar syntax for now:
233 printf((alu
->pred_select
& 0x1) ? "EQ" : "NE");
238 print_dstreg(alu
->vector_dest
, alu
->vector_write_mask
, alu
->export_data
);
240 if (vector_instructions
[alu
->vector_opc
].num_srcs
== 3) {
241 print_srcreg(alu
->src3_reg
, alu
->src3_sel
, alu
->src3_swiz
,
242 alu
->src3_reg_negate
, alu
->src3_reg_abs
);
245 print_srcreg(alu
->src1_reg
, alu
->src1_sel
, alu
->src1_swiz
,
246 alu
->src1_reg_negate
, alu
->src1_reg_abs
);
247 if (vector_instructions
[alu
->vector_opc
].num_srcs
> 1) {
249 print_srcreg(alu
->src2_reg
, alu
->src2_sel
, alu
->src2_swiz
,
250 alu
->src2_reg_negate
, alu
->src2_reg_abs
);
253 if (alu
->vector_clamp
)
256 if (alu
->export_data
)
257 print_export_comment(alu
->vector_dest
, type
);
261 if (alu
->scalar_write_mask
|| !alu
->vector_write_mask
) {
262 /* 2nd optional scalar op: */
264 printf("%s", levels
[level
]);
265 if (debug
& PRINT_RAW
)
268 if (scalar_instructions
[alu
->scalar_opc
].name
) {
269 printf("\t \t%s\t", scalar_instructions
[alu
->scalar_opc
].name
);
271 printf("\t \tOP(%u)\t", alu
->scalar_opc
);
274 print_dstreg(alu
->scalar_dest
, alu
->scalar_write_mask
, alu
->export_data
);
276 print_srcreg(alu
->src3_reg
, alu
->src3_sel
, alu
->src3_swiz
,
277 alu
->src3_reg_negate
, alu
->src3_reg_abs
);
278 // TODO ADD/MUL must have another src?!?
279 if (alu
->scalar_clamp
)
281 if (alu
->export_data
)
282 print_export_comment(alu
->scalar_dest
, type
);
291 * FETCH instructions:
296 } fetch_types
[0xff] = {
297 #define TYPE(id) [id] = { #id }
300 TYPE(FMT_32_32_FLOAT
),
301 TYPE(FMT_32_32_32_FLOAT
),
302 TYPE(FMT_32_32_32_32_FLOAT
),
305 TYPE(FMT_16_16_16_16
),
311 TYPE(FMT_32_32_32_32
),
315 static void print_fetch_dst(uint32_t dst_reg
, uint32_t dst_swiz
)
318 printf("\tR%u.", dst_reg
);
319 for (i
= 0; i
< 4; i
++) {
320 printf("%c", chan_names
[dst_swiz
& 0x7]);
325 static void print_fetch_vtx(instr_fetch_t
*fetch
)
327 instr_fetch_vtx_t
*vtx
= &fetch
->vtx
;
329 if (vtx
->pred_select
) {
330 /* seems to work similar to conditional execution in ARM instruction
331 * set, so let's use a similar syntax for now:
333 printf(vtx
->pred_condition
? "EQ" : "NE");
336 print_fetch_dst(vtx
->dst_reg
, vtx
->dst_swiz
);
337 printf(" = R%u.", vtx
->src_reg
);
338 printf("%c", chan_names
[vtx
->src_swiz
& 0x3]);
339 if (fetch_types
[vtx
->format
].name
) {
340 printf(" %s", fetch_types
[vtx
->format
].name
);
342 printf(" TYPE(0x%x)", vtx
->format
);
344 printf(" %s", vtx
->format_comp_all
? "SIGNED" : "UNSIGNED");
345 if (!vtx
->num_format_all
)
346 printf(" NORMALIZED");
347 printf(" STRIDE(%u)", vtx
->stride
);
349 printf(" OFFSET(%u)", vtx
->offset
);
350 printf(" CONST(%u, %u)", vtx
->const_index
, vtx
->const_index_sel
);
353 printf(" src_reg_am=%u", vtx
->src_reg_am
);
354 printf(" dst_reg_am=%u", vtx
->dst_reg_am
);
355 printf(" num_format_all=%u", vtx
->num_format_all
);
356 printf(" signed_rf_mode_all=%u", vtx
->signed_rf_mode_all
);
357 printf(" exp_adjust_all=%u", vtx
->exp_adjust_all
);
361 static void print_fetch_tex(instr_fetch_t
*fetch
)
363 static const char *filter
[] = {
364 [TEX_FILTER_POINT
] = "POINT",
365 [TEX_FILTER_LINEAR
] = "LINEAR",
366 [TEX_FILTER_BASEMAP
] = "BASEMAP",
368 static const char *aniso_filter
[] = {
369 [ANISO_FILTER_DISABLED
] = "DISABLED",
370 [ANISO_FILTER_MAX_1_1
] = "MAX_1_1",
371 [ANISO_FILTER_MAX_2_1
] = "MAX_2_1",
372 [ANISO_FILTER_MAX_4_1
] = "MAX_4_1",
373 [ANISO_FILTER_MAX_8_1
] = "MAX_8_1",
374 [ANISO_FILTER_MAX_16_1
] = "MAX_16_1",
376 static const char *arbitrary_filter
[] = {
377 [ARBITRARY_FILTER_2X4_SYM
] = "2x4_SYM",
378 [ARBITRARY_FILTER_2X4_ASYM
] = "2x4_ASYM",
379 [ARBITRARY_FILTER_4X2_SYM
] = "4x2_SYM",
380 [ARBITRARY_FILTER_4X2_ASYM
] = "4x2_ASYM",
381 [ARBITRARY_FILTER_4X4_SYM
] = "4x4_SYM",
382 [ARBITRARY_FILTER_4X4_ASYM
] = "4x4_ASYM",
384 static const char *sample_loc
[] = {
385 [SAMPLE_CENTROID
] = "CENTROID",
386 [SAMPLE_CENTER
] = "CENTER",
388 instr_fetch_tex_t
*tex
= &fetch
->tex
;
389 uint32_t src_swiz
= tex
->src_swiz
;
392 if (tex
->pred_select
) {
393 /* seems to work similar to conditional execution in ARM instruction
394 * set, so let's use a similar syntax for now:
396 printf(tex
->pred_condition
? "EQ" : "NE");
399 print_fetch_dst(tex
->dst_reg
, tex
->dst_swiz
);
400 printf(" = R%u.", tex
->src_reg
);
401 for (i
= 0; i
< 3; i
++) {
402 printf("%c", chan_names
[src_swiz
& 0x3]);
405 printf(" CONST(%u)", tex
->const_idx
);
406 if (tex
->fetch_valid_only
)
407 printf(" VALID_ONLY");
408 if (tex
->tx_coord_denorm
)
410 if (tex
->mag_filter
!= TEX_FILTER_USE_FETCH_CONST
)
411 printf(" MAG(%s)", filter
[tex
->mag_filter
]);
412 if (tex
->min_filter
!= TEX_FILTER_USE_FETCH_CONST
)
413 printf(" MIN(%s)", filter
[tex
->min_filter
]);
414 if (tex
->mip_filter
!= TEX_FILTER_USE_FETCH_CONST
)
415 printf(" MIP(%s)", filter
[tex
->mip_filter
]);
416 if (tex
->aniso_filter
!= ANISO_FILTER_USE_FETCH_CONST
)
417 printf(" ANISO(%s)", aniso_filter
[tex
->aniso_filter
]);
418 if (tex
->arbitrary_filter
!= ARBITRARY_FILTER_USE_FETCH_CONST
)
419 printf(" ARBITRARY(%s)", arbitrary_filter
[tex
->arbitrary_filter
]);
420 if (tex
->vol_mag_filter
!= TEX_FILTER_USE_FETCH_CONST
)
421 printf(" VOL_MAG(%s)", filter
[tex
->vol_mag_filter
]);
422 if (tex
->vol_min_filter
!= TEX_FILTER_USE_FETCH_CONST
)
423 printf(" VOL_MIN(%s)", filter
[tex
->vol_min_filter
]);
424 if (!tex
->use_comp_lod
) {
425 printf(" LOD(%u)", tex
->use_comp_lod
);
426 printf(" LOD_BIAS(%u)", tex
->lod_bias
);
428 if (tex
->use_reg_gradients
)
429 printf(" USE_REG_GRADIENTS");
430 printf(" LOCATION(%s)", sample_loc
[tex
->sample_location
]);
431 if (tex
->offset_x
|| tex
->offset_y
|| tex
->offset_z
)
432 printf(" OFFSET(%u,%u,%u)", tex
->offset_x
, tex
->offset_y
, tex
->offset_z
);
437 void (*fxn
)(instr_fetch_t
*cf
);
438 } fetch_instructions
[] = {
439 #define INSTR(opc, name, fxn) [opc] = { name, fxn }
440 INSTR(VTX_FETCH
, "VERTEX", print_fetch_vtx
),
441 INSTR(TEX_FETCH
, "SAMPLE", print_fetch_tex
),
442 INSTR(TEX_GET_BORDER_COLOR_FRAC
, "?", print_fetch_tex
),
443 INSTR(TEX_GET_COMP_TEX_LOD
, "?", print_fetch_tex
),
444 INSTR(TEX_GET_GRADIENTS
, "?", print_fetch_tex
),
445 INSTR(TEX_GET_WEIGHTS
, "?", print_fetch_tex
),
446 INSTR(TEX_SET_TEX_LOD
, "SET_TEX_LOD", print_fetch_tex
),
447 INSTR(TEX_SET_GRADIENTS_H
, "?", print_fetch_tex
),
448 INSTR(TEX_SET_GRADIENTS_V
, "?", print_fetch_tex
),
449 INSTR(TEX_RESERVED_4
, "?", print_fetch_tex
),
453 static int disasm_fetch(uint32_t *dwords
, uint32_t alu_off
, int level
, int sync
)
455 instr_fetch_t
*fetch
= (instr_fetch_t
*)dwords
;
457 printf("%s", levels
[level
]);
458 if (debug
& PRINT_RAW
) {
459 printf("%02x: %08x %08x %08x\t", alu_off
,
460 dwords
[0], dwords
[1], dwords
[2]);
463 printf(" %sFETCH:\t", sync
? "(S)" : " ");
464 printf("%s", fetch_instructions
[fetch
->opc
].name
);
465 fetch_instructions
[fetch
->opc
].fxn(fetch
);
475 static int cf_exec(instr_cf_t
*cf
)
477 return (cf
->opc
== EXEC
) ||
478 (cf
->opc
== EXEC_END
) ||
479 (cf
->opc
== COND_EXEC
) ||
480 (cf
->opc
== COND_EXEC_END
) ||
481 (cf
->opc
== COND_PRED_EXEC
) ||
482 (cf
->opc
== COND_PRED_EXEC_END
) ||
483 (cf
->opc
== COND_EXEC_PRED_CLEAN
) ||
484 (cf
->opc
== COND_EXEC_PRED_CLEAN_END
);
487 static int cf_cond_exec(instr_cf_t
*cf
)
489 return (cf
->opc
== COND_EXEC
) ||
490 (cf
->opc
== COND_EXEC_END
) ||
491 (cf
->opc
== COND_PRED_EXEC
) ||
492 (cf
->opc
== COND_PRED_EXEC_END
) ||
493 (cf
->opc
== COND_EXEC_PRED_CLEAN
) ||
494 (cf
->opc
== COND_EXEC_PRED_CLEAN_END
);
497 static void print_cf_nop(instr_cf_t
*cf
)
501 static void print_cf_exec(instr_cf_t
*cf
)
503 printf(" ADDR(0x%x) CNT(0x%x)", cf
->exec
.address
, cf
->exec
.count
);
507 printf(" VC(0x%x)", cf
->exec
.vc
);
508 if (cf
->exec
.bool_addr
)
509 printf(" BOOL_ADDR(0x%x)", cf
->exec
.bool_addr
);
510 if (cf
->exec
.address_mode
== ABSOLUTE_ADDR
)
511 printf(" ABSOLUTE_ADDR");
512 if (cf_cond_exec(cf
))
513 printf(" COND(%d)", cf
->exec
.condition
);
516 static void print_cf_loop(instr_cf_t
*cf
)
518 printf(" ADDR(0x%x) LOOP_ID(%d)", cf
->loop
.address
, cf
->loop
.loop_id
);
519 if (cf
->loop
.address_mode
== ABSOLUTE_ADDR
)
520 printf(" ABSOLUTE_ADDR");
523 static void print_cf_jmp_call(instr_cf_t
*cf
)
525 printf(" ADDR(0x%x) DIR(%d)", cf
->jmp_call
.address
, cf
->jmp_call
.direction
);
526 if (cf
->jmp_call
.force_call
)
527 printf(" FORCE_CALL");
528 if (cf
->jmp_call
.predicated_jmp
)
529 printf(" COND(%d)", cf
->jmp_call
.condition
);
530 if (cf
->jmp_call
.bool_addr
)
531 printf(" BOOL_ADDR(0x%x)", cf
->jmp_call
.bool_addr
);
532 if (cf
->jmp_call
.address_mode
== ABSOLUTE_ADDR
)
533 printf(" ABSOLUTE_ADDR");
536 static void print_cf_alloc(instr_cf_t
*cf
)
538 static const char *bufname
[] = {
539 [SQ_NO_ALLOC
] = "NO ALLOC",
540 [SQ_POSITION
] = "POSITION",
541 [SQ_PARAMETER_PIXEL
] = "PARAM/PIXEL",
542 [SQ_MEMORY
] = "MEMORY",
544 printf(" %s SIZE(0x%x)", bufname
[cf
->alloc
.buffer_select
], cf
->alloc
.size
);
545 if (cf
->alloc
.no_serial
)
546 printf(" NO_SERIAL");
547 if (cf
->alloc
.alloc_mode
) // ???
548 printf(" ALLOC_MODE");
553 void (*fxn
)(instr_cf_t
*cf
);
554 } cf_instructions
[] = {
555 #define INSTR(opc, fxn) [opc] = { #opc, fxn }
556 INSTR(NOP
, print_cf_nop
),
557 INSTR(EXEC
, print_cf_exec
),
558 INSTR(EXEC_END
, print_cf_exec
),
559 INSTR(COND_EXEC
, print_cf_exec
),
560 INSTR(COND_EXEC_END
, print_cf_exec
),
561 INSTR(COND_PRED_EXEC
, print_cf_exec
),
562 INSTR(COND_PRED_EXEC_END
, print_cf_exec
),
563 INSTR(LOOP_START
, print_cf_loop
),
564 INSTR(LOOP_END
, print_cf_loop
),
565 INSTR(COND_CALL
, print_cf_jmp_call
),
566 INSTR(RETURN
, print_cf_jmp_call
),
567 INSTR(COND_JMP
, print_cf_jmp_call
),
568 INSTR(ALLOC
, print_cf_alloc
),
569 INSTR(COND_EXEC_PRED_CLEAN
, print_cf_exec
),
570 INSTR(COND_EXEC_PRED_CLEAN_END
, print_cf_exec
),
571 INSTR(MARK_VS_FETCH_DONE
, print_cf_nop
), // ??
575 static void print_cf(instr_cf_t
*cf
, int level
)
577 printf("%s", levels
[level
]);
578 if (debug
& PRINT_RAW
) {
579 uint16_t *words
= (uint16_t *)cf
;
580 printf(" %04x %04x %04x \t",
581 words
[0], words
[1], words
[2]);
583 printf("%s", cf_instructions
[cf
->opc
].name
);
584 cf_instructions
[cf
->opc
].fxn(cf
);
589 * The adreno shader microcode consists of two parts:
590 * 1) A CF (control-flow) program, at the header of the compiled shader,
591 * which refers to ALU/FETCH instructions that follow it by address.
592 * 2) ALU and FETCH instructions
595 int disasm_a2xx(uint32_t *dwords
, int sizedwords
, int level
, gl_shader_stage type
)
597 instr_cf_t
*cfs
= (instr_cf_t
*)dwords
;
600 for (idx
= 0; ; idx
++) {
601 instr_cf_t
*cf
= &cfs
[idx
];
603 max_idx
= 2 * cf
->exec
.address
;
608 for (idx
= 0; idx
< max_idx
; idx
++) {
609 instr_cf_t
*cf
= &cfs
[idx
];
614 uint32_t sequence
= cf
->exec
.serialize
;
616 for (i
= 0; i
< cf
->exec
.count
; i
++) {
617 uint32_t alu_off
= (cf
->exec
.address
+ i
);
618 if (sequence
& 0x1) {
619 disasm_fetch(dwords
+ alu_off
* 3, alu_off
, level
, sequence
& 0x2);
621 disasm_alu(dwords
+ alu_off
* 3, alu_off
, level
, sequence
& 0x2, type
);
631 void disasm_set_debug(enum debug_t d
)