2 * Copyright © 2016 Intel Corporation
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
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
33 #include <sys/types.h>
39 #include "intel_aub.h"
40 #include "gen_disasm.h"
42 /* Below is the only command missing from intel_aub.h in libdrm
43 * So, reuse intel_aub.h from libdrm and #define the
44 * AUB_MI_BATCH_BUFFER_END as below
46 #define AUB_MI_BATCH_BUFFER_END (0x0500 << 16)
49 #define HEADER CSI "37;44m"
50 #define NORMAL CSI "0m"
51 #define CLEAR_TO_EOL CSI "0K"
55 static bool option_full_decode
= true;
56 static bool option_print_offsets
= true;
57 static enum { COLOR_AUTO
, COLOR_ALWAYS
, COLOR_NEVER
} option_color
;
61 struct gen_disasm
*disasm
;
63 uint64_t gtt_size
, gtt_end
;
65 uint64_t general_state_base
;
66 uint64_t surface_state_base
;
67 uint64_t dynamic_state_base
;
68 uint64_t instruction_base
;
69 uint64_t instruction_bound
;
71 static inline uint32_t
72 field(uint32_t value
, int start
, int end
)
76 mask
= ~0U >> (31 - end
+ start
);
78 return (value
>> start
) & mask
;
81 struct brw_instruction
;
84 valid_offset(uint32_t offset
)
86 return offset
< gtt_end
;
90 print_dword_val(struct gen_field_iterator
*iter
, uint64_t offset
,
95 f
= iter
->group
->fields
[iter
->i
- 1];
96 const int dword
= f
->start
/ 32;
98 if (*dword_num
!= dword
) {
99 printf("0x%08lx: 0x%08x : Dword %d\n",
100 offset
+ 4 * dword
, iter
->p
[dword
], dword
);
106 print_iterator_values(struct gen_field_iterator
*iter
, int *idx
)
109 if (strstr(iter
->value
, "struct") == NULL
) {
110 printf(" %s: %s\n", iter
->name
, iter
->value
);
112 token
= strtok(iter
->value
, " ");
114 token
= strtok(NULL
, " ");
115 *idx
= atoi(strtok(NULL
, ">"));
119 printf(" %s:<struct %s>\n", iter
->name
, token
);
125 decode_structure(struct gen_spec
*spec
, struct gen_group
*strct
,
128 struct gen_field_iterator iter
;
130 int idx
= 0, dword_num
= 0;
133 if (option_print_offsets
)
134 offset
= (void *) p
- gtt
;
138 gen_field_iterator_init(&iter
, strct
, p
);
139 while (gen_field_iterator_next(&iter
)) {
141 print_dword_val(&iter
, offset
, &dword_num
);
142 token
= print_iterator_values(&iter
, &idx
);
144 struct gen_group
*struct_val
= gen_spec_find_struct(spec
, token
);
145 decode_structure(spec
, struct_val
, &p
[idx
]);
152 handle_struct_decode(struct gen_spec
*spec
, char *struct_name
, uint32_t *p
)
154 if (struct_name
== NULL
)
156 struct gen_group
*struct_val
= gen_spec_find_struct(spec
, struct_name
);
157 decode_structure(spec
, struct_val
, p
);
161 dump_binding_table(struct gen_spec
*spec
, uint32_t offset
)
163 uint32_t *pointers
, i
;
165 struct gen_group
*surface_state
;
167 surface_state
= gen_spec_find_struct(spec
, "RENDER_SURFACE_STATE");
168 if (surface_state
== NULL
) {
169 printf("did not find RENDER_SURFACE_STATE info\n");
173 start
= surface_state_base
+ offset
;
174 pointers
= gtt
+ start
;
175 for (i
= 0; i
< 16; i
++) {
176 if (pointers
[i
] == 0)
178 start
= pointers
[i
] + surface_state_base
;
179 if (!valid_offset(start
)) {
180 printf("pointer %u: %08x <not valid>\n",
184 printf("pointer %u: %08x\n", i
, pointers
[i
]);
187 decode_structure(spec
, surface_state
, gtt
+ start
);
192 handle_3dstate_index_buffer(struct gen_spec
*spec
, uint32_t *p
)
195 uint32_t length
, i
, type
, size
;
198 type
= (p
[1] >> 8) & 3;
200 length
= p
[4] / size
;
206 for (i
= 0; i
< length
; i
++) {
209 printf("%3d ", ((uint8_t *)start
)[i
]);
212 printf("%3d ", ((uint16_t *)start
)[i
]);
215 printf("%3d ", ((uint32_t *)start
)[i
]);
219 if (length
< p
[4] / size
)
225 static inline uint64_t
226 get_qword(uint32_t *p
)
228 return ((uint64_t) p
[1] << 32) | p
[0];
232 handle_state_base_address(struct gen_spec
*spec
, uint32_t *p
)
234 uint64_t mask
= ~((1 << 12) - 1);
236 if (gen_spec_get_gen(spec
) >= gen_make_gen(8,0)) {
238 general_state_base
= get_qword(&p
[1]) & mask
;
240 surface_state_base
= get_qword(&p
[4]) & mask
;
242 dynamic_state_base
= get_qword(&p
[6]) & mask
;
244 instruction_base
= get_qword(&p
[10]) & mask
;
246 instruction_bound
= p
[15] & mask
;
249 surface_state_base
= p
[2] & mask
;
251 dynamic_state_base
= p
[3] & mask
;
253 instruction_base
= p
[5] & mask
;
255 instruction_bound
= p
[9] & mask
;
260 dump_samplers(struct gen_spec
*spec
, uint32_t offset
)
264 struct gen_group
*sampler_state
;
266 sampler_state
= gen_spec_find_struct(spec
, "SAMPLER_STATE");
268 start
= dynamic_state_base
+ offset
;
269 for (i
= 0; i
< 4; i
++) {
270 printf("sampler state %d\n", i
);
271 decode_structure(spec
, sampler_state
, gtt
+ start
+ i
* 16);
276 handle_media_interface_descriptor_load(struct gen_spec
*spec
, uint32_t *p
)
278 int i
, length
= p
[2] / 32;
279 struct gen_group
*descriptor_structure
;
280 uint32_t *descriptors
;
282 struct brw_instruction
*insns
;
284 descriptor_structure
=
285 gen_spec_find_struct(spec
, "INTERFACE_DESCRIPTOR_DATA");
286 if (descriptor_structure
== NULL
) {
287 printf("did not find INTERFACE_DESCRIPTOR_DATA info\n");
291 start
= dynamic_state_base
+ p
[3];
292 descriptors
= gtt
+ start
;
293 for (i
= 0; i
< length
; i
++, descriptors
+= 8) {
294 printf("descriptor %u: %08x\n", i
, *descriptors
);
295 decode_structure(spec
, descriptor_structure
, descriptors
);
297 start
= instruction_base
+ descriptors
[0];
298 if (!valid_offset(start
)) {
299 printf("kernel: %08lx <not valid>\n", start
);
302 printf("kernel: %08lx\n", start
);
305 insns
= (struct brw_instruction
*) (gtt
+ start
);
306 gen_disasm_disassemble(disasm
, insns
, 0, stdout
);
308 dump_samplers(spec
, descriptors
[3] & ~0x1f);
309 dump_binding_table(spec
, descriptors
[4] & ~0x1f);
313 /* Heuristic to determine whether a uint32_t is probably actually a float
314 * (http://stackoverflow.com/a/2953466)
318 probably_float(uint32_t bits
)
320 int exp
= ((bits
& 0x7f800000U
) >> 23) - 127;
321 uint32_t mant
= bits
& 0x007fffff;
324 if (exp
== -127 && mant
== 0)
327 /* +- 1 billionth to 1 billion */
328 if (-30 <= exp
&& exp
<= 30)
331 /* some value with only a few binary digits */
332 if ((mant
& 0x0000ffff) == 0)
339 handle_3dstate_vertex_buffers(struct gen_spec
*spec
, uint32_t *p
)
341 uint32_t *end
, *s
, *dw
, *dwend
;
343 int n
, i
, count
, stride
;
345 end
= (p
[0] & 0xff) + p
+ 2;
346 for (s
= &p
[1], n
= 0; s
< end
; s
+= 4, n
++) {
347 if (gen_spec_get_gen(spec
) >= gen_make_gen(8, 0)) {
348 offset
= *(uint64_t *) &s
[1];
349 dwend
= gtt
+ offset
+ s
[3];
352 dwend
= gtt
+ s
[2] + 1;
355 stride
= field(s
[0], 0, 11);
357 printf("vertex buffer %d, size %d\n", n
, s
[3]);
358 for (dw
= gtt
+ offset
, i
= 0; dw
< dwend
&& i
< 256; dw
++) {
359 if (count
== 0 && count
% (8 * 4) == 0)
362 if (probably_float(*dw
))
363 printf(" %8.2f", *(float *) dw
);
365 printf(" 0x%08x", *dw
);
370 if (count
== stride
) {
373 } else if (count
% (8 * 4) == 0) {
379 if (count
> 0 && count
% (8 * 4) != 0)
385 handle_3dstate_vs(struct gen_spec
*spec
, uint32_t *p
)
388 struct brw_instruction
*insns
;
391 if (gen_spec_get_gen(spec
) >= gen_make_gen(8, 0)) {
392 start
= get_qword(&p
[1]);
393 vs_enable
= p
[7] & 1;
396 vs_enable
= p
[5] & 1;
400 printf("instruction_base %08lx, start %08lx\n",
401 instruction_base
, start
);
403 insns
= (struct brw_instruction
*) (gtt
+ instruction_base
+ start
);
404 gen_disasm_disassemble(disasm
, insns
, 0, stdout
);
409 handle_3dstate_hs(struct gen_spec
*spec
, uint32_t *p
)
412 struct brw_instruction
*insns
;
415 if (gen_spec_get_gen(spec
) >= gen_make_gen(8, 0)) {
416 start
= get_qword(&p
[4]);
421 hs_enable
= p
[2] & 0x80000000;
424 printf("instruction_base %08lx, start %08lx\n",
425 instruction_base
, start
);
427 insns
= (struct brw_instruction
*) (gtt
+ instruction_base
+ start
);
428 gen_disasm_disassemble(disasm
, insns
, 0, stdout
);
433 handle_3dstate_constant(struct gen_spec
*spec
, uint32_t *p
)
439 for (i
= 0; i
< 4; i
++) {
440 length
= (p
[1 + i
/ 2] >> (i
& 1) * 16) & 0xffff;
441 f
= (float *) (gtt
+ p
[3 + i
* 2] + dynamic_state_base
);
443 for (j
= 0; j
< length
* 8; j
++) {
444 if (probably_float(dw
[j
]))
445 printf(" %04.3f", f
[j
]);
447 printf(" 0x%08x", dw
[j
]);
456 handle_3dstate_ps(struct gen_spec
*spec
, uint32_t *p
)
458 uint32_t mask
= ~((1 << 6) - 1);
460 struct brw_instruction
*insns
;
461 static const char unused
[] = "unused";
462 static const char *pixel_type
[3] = {"8 pixel", "16 pixel", "32 pixel"};
463 const char *k0
, *k1
, *k2
;
464 uint32_t k_mask
, k1_offset
, k2_offset
;
466 if (gen_spec_get_gen(spec
) >= gen_make_gen(8, 0)) {
477 #define DISPATCH_16 2
478 #define DISPATCH_32 4
491 case DISPATCH_8
| DISPATCH_16
:
501 case DISPATCH_16
| DISPATCH_32
:
506 case DISPATCH_8
| DISPATCH_16
| DISPATCH_32
:
518 start
= instruction_base
+ (p
[1] & mask
);
519 printf(" Kernel[0] %s\n", k0
);
521 insns
= (struct brw_instruction
*) (gtt
+ start
);
522 gen_disasm_disassemble(disasm
, insns
, 0, stdout
);
525 start
= instruction_base
+ (p
[k1_offset
] & mask
);
526 printf(" Kernel[1] %s\n", k1
);
528 insns
= (struct brw_instruction
*) (gtt
+ start
);
529 gen_disasm_disassemble(disasm
, insns
, 0, stdout
);
532 start
= instruction_base
+ (p
[k2_offset
] & mask
);
533 printf(" Kernel[2] %s\n", k2
);
535 insns
= (struct brw_instruction
*) (gtt
+ start
);
536 gen_disasm_disassemble(disasm
, insns
, 0, stdout
);
541 handle_3dstate_binding_table_pointers(struct gen_spec
*spec
, uint32_t *p
)
543 dump_binding_table(spec
, p
[1]);
547 handle_3dstate_sampler_state_pointers(struct gen_spec
*spec
, uint32_t *p
)
549 dump_samplers(spec
, p
[1]);
553 handle_3dstate_viewport_state_pointers_cc(struct gen_spec
*spec
, uint32_t *p
)
556 struct gen_group
*cc_viewport
;
558 cc_viewport
= gen_spec_find_struct(spec
, "CC_VIEWPORT");
560 start
= dynamic_state_base
+ (p
[1] & ~0x1fu
);
561 for (uint32_t i
= 0; i
< 4; i
++) {
562 printf("viewport %d\n", i
);
563 decode_structure(spec
, cc_viewport
, gtt
+ start
+ i
* 8);
568 handle_3dstate_viewport_state_pointers_sf_clip(struct gen_spec
*spec
,
572 struct gen_group
*sf_clip_viewport
;
574 sf_clip_viewport
= gen_spec_find_struct(spec
, "SF_CLIP_VIEWPORT");
576 start
= dynamic_state_base
+ (p
[1] & ~0x3fu
);
577 for (uint32_t i
= 0; i
< 4; i
++) {
578 printf("viewport %d\n", i
);
579 decode_structure(spec
, sf_clip_viewport
, gtt
+ start
+ i
* 64);
584 handle_3dstate_blend_state_pointers(struct gen_spec
*spec
, uint32_t *p
)
587 struct gen_group
*blend_state
;
589 blend_state
= gen_spec_find_struct(spec
, "BLEND_STATE");
591 start
= dynamic_state_base
+ (p
[1] & ~0x3fu
);
592 decode_structure(spec
, blend_state
, gtt
+ start
);
596 handle_3dstate_cc_state_pointers(struct gen_spec
*spec
, uint32_t *p
)
599 struct gen_group
*cc_state
;
601 cc_state
= gen_spec_find_struct(spec
, "COLOR_CALC_STATE");
603 start
= dynamic_state_base
+ (p
[1] & ~0x3fu
);
604 decode_structure(spec
, cc_state
, gtt
+ start
);
608 handle_3dstate_scissor_state_pointers(struct gen_spec
*spec
, uint32_t *p
)
611 struct gen_group
*scissor_rect
;
613 scissor_rect
= gen_spec_find_struct(spec
, "SCISSOR_RECT");
615 start
= dynamic_state_base
+ (p
[1] & ~0x1fu
);
616 decode_structure(spec
, scissor_rect
, gtt
+ start
);
619 #define ARRAY_LENGTH(a) (sizeof (a) / sizeof (a)[0])
621 #define STATE_BASE_ADDRESS 0x61010000
623 #define MEDIA_INTERFACE_DESCRIPTOR_LOAD 0x70020000
625 #define _3DSTATE_INDEX_BUFFER 0x780a0000
626 #define _3DSTATE_VERTEX_BUFFERS 0x78080000
628 #define _3DSTATE_VS 0x78100000
629 #define _3DSTATE_GS 0x78110000
630 #define _3DSTATE_HS 0x781b0000
631 #define _3DSTATE_DS 0x781d0000
633 #define _3DSTATE_CONSTANT_VS 0x78150000
634 #define _3DSTATE_CONSTANT_GS 0x78160000
635 #define _3DSTATE_CONSTANT_PS 0x78170000
636 #define _3DSTATE_CONSTANT_HS 0x78190000
637 #define _3DSTATE_CONSTANT_DS 0x781A0000
639 #define _3DSTATE_PS 0x78200000
641 #define _3DSTATE_BINDING_TABLE_POINTERS_VS 0x78260000
642 #define _3DSTATE_BINDING_TABLE_POINTERS_HS 0x78270000
643 #define _3DSTATE_BINDING_TABLE_POINTERS_DS 0x78280000
644 #define _3DSTATE_BINDING_TABLE_POINTERS_GS 0x78290000
645 #define _3DSTATE_BINDING_TABLE_POINTERS_PS 0x782a0000
647 #define _3DSTATE_SAMPLER_STATE_POINTERS_VS 0x782b0000
648 #define _3DSTATE_SAMPLER_STATE_POINTERS_GS 0x782e0000
649 #define _3DSTATE_SAMPLER_STATE_POINTERS_PS 0x782f0000
651 #define _3DSTATE_VIEWPORT_STATE_POINTERS_CC 0x78230000
652 #define _3DSTATE_VIEWPORT_STATE_POINTERS_SF_CLIP 0x78210000
653 #define _3DSTATE_BLEND_STATE_POINTERS 0x78240000
654 #define _3DSTATE_CC_STATE_POINTERS 0x780e0000
655 #define _3DSTATE_SCISSOR_STATE_POINTERS 0x780f0000
657 struct custom_handler
{
659 void (*handle
)(struct gen_spec
*spec
, uint32_t *p
);
660 } custom_handlers
[] = {
661 { STATE_BASE_ADDRESS
, handle_state_base_address
},
662 { MEDIA_INTERFACE_DESCRIPTOR_LOAD
, handle_media_interface_descriptor_load
},
663 { _3DSTATE_VERTEX_BUFFERS
, handle_3dstate_vertex_buffers
},
664 { _3DSTATE_INDEX_BUFFER
, handle_3dstate_index_buffer
},
665 { _3DSTATE_VS
, handle_3dstate_vs
},
666 { _3DSTATE_GS
, handle_3dstate_vs
},
667 { _3DSTATE_DS
, handle_3dstate_vs
},
668 { _3DSTATE_HS
, handle_3dstate_hs
},
669 { _3DSTATE_CONSTANT_VS
, handle_3dstate_constant
},
670 { _3DSTATE_CONSTANT_GS
, handle_3dstate_constant
},
671 { _3DSTATE_CONSTANT_PS
, handle_3dstate_constant
},
672 { _3DSTATE_CONSTANT_HS
, handle_3dstate_constant
},
673 { _3DSTATE_CONSTANT_DS
, handle_3dstate_constant
},
674 { _3DSTATE_PS
, handle_3dstate_ps
},
676 { _3DSTATE_BINDING_TABLE_POINTERS_VS
, handle_3dstate_binding_table_pointers
},
677 { _3DSTATE_BINDING_TABLE_POINTERS_HS
, handle_3dstate_binding_table_pointers
},
678 { _3DSTATE_BINDING_TABLE_POINTERS_DS
, handle_3dstate_binding_table_pointers
},
679 { _3DSTATE_BINDING_TABLE_POINTERS_GS
, handle_3dstate_binding_table_pointers
},
680 { _3DSTATE_BINDING_TABLE_POINTERS_PS
, handle_3dstate_binding_table_pointers
},
682 { _3DSTATE_SAMPLER_STATE_POINTERS_VS
, handle_3dstate_sampler_state_pointers
},
683 { _3DSTATE_SAMPLER_STATE_POINTERS_GS
, handle_3dstate_sampler_state_pointers
},
684 { _3DSTATE_SAMPLER_STATE_POINTERS_PS
, handle_3dstate_sampler_state_pointers
},
686 { _3DSTATE_VIEWPORT_STATE_POINTERS_CC
, handle_3dstate_viewport_state_pointers_cc
},
687 { _3DSTATE_VIEWPORT_STATE_POINTERS_SF_CLIP
, handle_3dstate_viewport_state_pointers_sf_clip
},
688 { _3DSTATE_BLEND_STATE_POINTERS
, handle_3dstate_blend_state_pointers
},
689 { _3DSTATE_CC_STATE_POINTERS
, handle_3dstate_cc_state_pointers
},
690 { _3DSTATE_SCISSOR_STATE_POINTERS
, handle_3dstate_scissor_state_pointers
}
694 parse_commands(struct gen_spec
*spec
, uint32_t *cmds
, int size
, int engine
)
696 uint32_t *p
, *end
= cmds
+ size
/ 4;
697 unsigned int length
, i
;
698 struct gen_group
*inst
;
700 for (p
= cmds
; p
< end
; p
+= length
) {
701 inst
= gen_spec_find_instruction(spec
, p
);
703 printf("unknown instruction %08x\n", p
[0]);
704 length
= (p
[0] & 0xff) + 2;
707 length
= gen_group_get_length(inst
, p
);
709 const char *color
, *reset_color
= CLEAR_TO_EOL NORMAL
;
712 if (option_full_decode
)
717 if (option_color
== COLOR_NEVER
) {
722 if (option_print_offsets
)
723 offset
= (void *) p
- gtt
;
727 printf("%s0x%08lx: 0x%08x: %s%s\n",
729 gen_group_get_name(inst
), reset_color
);
731 if (option_full_decode
) {
732 struct gen_field_iterator iter
;
734 int idx
= 0, dword_num
= 0;
735 gen_field_iterator_init(&iter
, inst
, p
);
736 while (gen_field_iterator_next(&iter
)) {
738 print_dword_val(&iter
, offset
, &dword_num
);
740 token
= print_iterator_values(&iter
, &idx
);
742 printf("0x%08lx: 0x%08x : Dword %d\n",
743 offset
+ 4 * idx
, p
[idx
], idx
);
744 handle_struct_decode(spec
,token
, &p
[idx
]);
749 for (i
= 0; i
< ARRAY_LENGTH(custom_handlers
); i
++) {
750 if (gen_group_get_opcode(inst
) ==
751 custom_handlers
[i
].opcode
)
752 custom_handlers
[i
].handle(spec
, p
);
756 if ((p
[0] & 0xffff0000) == AUB_MI_BATCH_BUFFER_START
) {
758 if (gen_spec_get_gen(spec
) >= gen_make_gen(8,0))
759 start
= get_qword(&p
[1]);
763 parse_commands(spec
, gtt
+ start
, 1 << 20, engine
);
764 } else if ((p
[0] & 0xffff0000) == AUB_MI_BATCH_BUFFER_END
) {
770 #define GEN_ENGINE_RENDER 1
771 #define GEN_ENGINE_BLITTER 2
774 handle_trace_block(struct gen_spec
*spec
, uint32_t *p
)
776 int operation
= p
[1] & AUB_TRACE_OPERATION_MASK
;
777 int type
= p
[1] & AUB_TRACE_TYPE_MASK
;
778 int address_space
= p
[1] & AUB_TRACE_ADDRESS_SPACE_MASK
;
779 uint64_t offset
= p
[3];
780 uint32_t size
= p
[4];
781 int header_length
= p
[0] & 0xffff;
782 uint32_t *data
= p
+ header_length
+ 2;
783 int engine
= GEN_ENGINE_RENDER
;
785 if (gen_spec_get_gen(spec
) >= gen_make_gen(8,0))
786 offset
+= (uint64_t) p
[5] << 32;
789 case AUB_TRACE_OP_DATA_WRITE
:
790 if (address_space
!= AUB_TRACE_MEMTYPE_GTT
)
792 if (gtt_size
< offset
+ size
) {
793 fprintf(stderr
, "overflow gtt space: %s", strerror(errno
));
796 memcpy((char *) gtt
+ offset
, data
, size
);
797 if (gtt_end
< offset
+ size
)
798 gtt_end
= offset
+ size
;
800 case AUB_TRACE_OP_COMMAND_WRITE
:
802 case AUB_TRACE_TYPE_RING_PRB0
:
803 engine
= GEN_ENGINE_RENDER
;
805 case AUB_TRACE_TYPE_RING_PRB2
:
806 engine
= GEN_ENGINE_BLITTER
;
809 printf("command write to unknown ring %d\n", type
);
813 parse_commands(spec
, data
, size
, engine
);
823 uint32_t *map
, *end
, *cursor
;
826 static struct aub_file
*
827 aub_file_open(const char *filename
)
829 struct aub_file
*file
;
831 file
= malloc(sizeof *file
);
832 file
->filename
= strdup(filename
);
833 file
->fd
= open(file
->filename
, O_RDONLY
);
834 if (file
->fd
== -1) {
835 fprintf(stderr
, "open %s failed: %s", file
->filename
, strerror(errno
));
839 if (fstat(file
->fd
, &file
->sb
) == -1) {
840 fprintf(stderr
, "stat failed: %s", strerror(errno
));
844 file
->map
= mmap(NULL
, file
->sb
.st_size
,
845 PROT_READ
, MAP_SHARED
, file
->fd
, 0);
846 if (file
->map
== MAP_FAILED
) {
847 fprintf(stderr
, "mmap failed: %s", strerror(errno
));
851 file
->cursor
= file
->map
;
852 file
->end
= file
->map
+ file
->sb
.st_size
/ 4;
854 /* mmap a terabyte for our gtt space. */
855 gtt_size
= 1ul << 40;
856 gtt
= mmap(NULL
, gtt_size
, PROT_READ
| PROT_WRITE
,
857 MAP_PRIVATE
| MAP_ANONYMOUS
| MAP_NORESERVE
, -1, 0);
858 if (gtt
== MAP_FAILED
) {
859 fprintf(stderr
, "failed to alloc gtt space: %s", strerror(errno
));
866 #define TYPE(dw) (((dw) >> 29) & 7)
867 #define OPCODE(dw) (((dw) >> 23) & 0x3f)
868 #define SUBOPCODE(dw) (((dw) >> 16) & 0x7f)
870 #define MAKE_HEADER(type, opcode, subopcode) \
871 (((type) << 29) | ((opcode) << 23) | ((subopcode) << 16))
875 /* Classic AUB opcodes */
876 #define OPCODE_AUB 0x01
877 #define SUBOPCODE_HEADER 0x05
878 #define SUBOPCODE_BLOCK 0x41
879 #define SUBOPCODE_BMP 0x1e
881 /* Newer version AUB opcode */
882 #define OPCODE_NEW_AUB 0x2e
883 #define SUBOPCODE_VERSION 0x00
884 #define SUBOPCODE_REG_WRITE 0x03
885 #define SUBOPCODE_MEM_POLL 0x05
886 #define SUBOPCODE_MEM_WRITE 0x06
888 #define MAKE_GEN(major, minor) ( ((major) << 8) | (minor) )
894 { "bwr", MAKE_GEN(4, 0) },
895 { "cln", MAKE_GEN(4, 0) },
896 { "blc", MAKE_GEN(4, 0) },
897 { "ctg", MAKE_GEN(4, 0) },
898 { "el", MAKE_GEN(4, 0) },
899 { "il", MAKE_GEN(4, 0) },
900 { "sbr", MAKE_GEN(6, 0) },
901 { "ivb", MAKE_GEN(7, 0) },
902 { "lrb2", MAKE_GEN(0, 0) },
903 { "hsw", MAKE_GEN(7, 5) },
904 { "vlv", MAKE_GEN(7, 0) },
905 { "bdw", MAKE_GEN(8, 0) },
906 { "skl", MAKE_GEN(9, 0) },
907 { "chv", MAKE_GEN(8, 0) },
908 { "bxt", MAKE_GEN(9, 0) }
912 aub_file_decode_batch(struct aub_file
*file
, struct gen_spec
*spec
)
914 uint32_t *p
, h
, device
, data_type
;
915 int header_length
, payload_size
, bias
;
919 header_length
= h
& 0xffff;
929 printf("unknown opcode %d at %ld/%ld\n",
930 OPCODE(h
), file
->cursor
- file
->map
,
931 file
->end
- file
->map
);
932 file
->cursor
= file
->end
;
937 switch (h
& 0xffff0000) {
938 case MAKE_HEADER(TYPE_AUB
, OPCODE_AUB
, SUBOPCODE_HEADER
):
939 payload_size
= p
[12];
941 case MAKE_HEADER(TYPE_AUB
, OPCODE_AUB
, SUBOPCODE_BLOCK
):
943 handle_trace_block(spec
, p
);
945 case MAKE_HEADER(TYPE_AUB
, OPCODE_AUB
, SUBOPCODE_BMP
):
948 case MAKE_HEADER(TYPE_AUB
, OPCODE_NEW_AUB
, SUBOPCODE_VERSION
):
949 printf("version block: dw1 %08x\n", p
[1]);
950 device
= (p
[1] >> 8) & 0xff;
951 printf(" device %s\n", device_map
[device
].name
);
953 case MAKE_HEADER(TYPE_AUB
, OPCODE_NEW_AUB
, SUBOPCODE_REG_WRITE
):
954 printf("register write block: (dwords %d)\n", h
& 0xffff);
955 printf(" reg 0x%x, data 0x%x\n", p
[1], p
[5]);
957 case MAKE_HEADER(TYPE_AUB
, OPCODE_NEW_AUB
, SUBOPCODE_MEM_WRITE
):
958 printf("memory write block (dwords %d):\n", h
& 0xffff);
959 printf(" address 0x%lx\n", *(uint64_t *) &p
[1]);
960 data_type
= (p
[3] >> 20) & 0xff;
962 printf(" data type 0x%x\n", data_type
);
963 printf(" address space 0x%x\n", (p
[3] >> 28) & 0xf);
965 case MAKE_HEADER(TYPE_AUB
, OPCODE_NEW_AUB
, SUBOPCODE_MEM_POLL
):
966 printf("memory poll block (dwords %d):\n", h
& 0xffff);
969 printf("unknown block type=0x%x, opcode=0x%x, "
970 "subopcode=0x%x (%08x)\n", TYPE(h
), OPCODE(h
), SUBOPCODE(h
), h
);
973 file
->cursor
= p
+ header_length
+ bias
+ payload_size
/ 4;
977 aub_file_more_stuff(struct aub_file
*file
)
979 return file
->cursor
< file
->end
;
1001 execlp("less", "less", "-rFi", NULL
);
1010 print_help(const char *progname
, FILE *file
)
1013 "Usage: %s [OPTION]... FILE\n"
1014 "Decode aub file contents.\n\n"
1015 "A valid --gen option must be provided.\n\n"
1016 " --help display this help and exit\n"
1017 " --gen=platform decode for given platform (ivb, byt, hsw, bdw, chv, skl, kbl or bxt)\n"
1018 " --headers decode only command headers\n"
1019 " --color[=WHEN] colorize the output; WHEN can be 'auto' (default\n"
1020 " if omitted), 'always', or 'never'\n"
1021 " --no-pager don't launch pager\n"
1022 " --no-offsets don't print instruction offsets\n",
1027 is_prefix(const char *arg
, const char *prefix
, const char **value
)
1029 int l
= strlen(prefix
);
1031 if (strncmp(arg
, prefix
, l
) == 0 && (arg
[l
] == '\0' || arg
[l
] == '=')) {
1033 *value
= arg
+ l
+ 1;
1043 int main(int argc
, char *argv
[])
1045 struct gen_spec
*spec
;
1046 struct aub_file
*file
;
1048 bool found_arg_gen
= false, pager
= true;
1049 int gen_major
, gen_minor
;
1051 char gen_file
[256], gen_val
[24];
1054 print_help(argv
[0], stderr
);
1058 for (i
= 1; i
< argc
; ++i
) {
1059 if (strcmp(argv
[i
], "--no-pager") == 0) {
1061 } else if (strcmp(argv
[i
], "--no-offsets") == 0) {
1062 option_print_offsets
= false;
1063 } else if (is_prefix(argv
[i
], "--gen", &value
)) {
1064 if (value
== NULL
) {
1065 fprintf(stderr
, "option '--gen' requires an argument\n");
1068 found_arg_gen
= true;
1071 snprintf(gen_val
, sizeof(gen_val
), "%s", value
);
1072 } else if (strcmp(argv
[i
], "--headers") == 0) {
1073 option_full_decode
= false;
1074 } else if (is_prefix(argv
[i
], "--color", &value
)) {
1075 if (value
== NULL
|| strcmp(value
, "always") == 0)
1076 option_color
= COLOR_ALWAYS
;
1077 else if (strcmp(value
, "never") == 0)
1078 option_color
= COLOR_NEVER
;
1079 else if (strcmp(value
, "auto") == 0)
1080 option_color
= COLOR_AUTO
;
1082 fprintf(stderr
, "invalid value for --color: %s", value
);
1085 } else if (strcmp(argv
[i
], "--help") == 0) {
1086 print_help(argv
[0], stdout
);
1089 if (argv
[i
][0] == '-') {
1090 fprintf(stderr
, "unknown option %s\n", argv
[i
]);
1097 if (!found_arg_gen
) {
1098 fprintf(stderr
, "argument --gen is required\n");
1102 if (strstr(gen_val
, "ivb") != NULL
) {
1103 /* Intel(R) Ivybridge Mobile GT2 */
1107 } else if (strstr(gen_val
, "hsw") != NULL
) {
1108 /* Intel(R) Haswell Mobile GT2 */
1112 } else if (strstr(gen_val
, "byt") != NULL
) {
1113 /* Intel(R) Bay Trail */
1117 } else if (strstr(gen_val
, "bdw") != NULL
) {
1118 /* Intel(R) HD Graphics 5500 (Broadwell GT2) */
1122 } else if (strstr(gen_val
, "chv") != NULL
) {
1123 /* Intel(R) HD Graphics (Cherryview) */
1127 } else if (strstr(gen_val
, "skl") != NULL
) {
1128 /* Intel(R) HD Graphics 530 (Skylake GT2) */
1132 } else if (strstr(gen_val
, "kbl") != NULL
) {
1133 /* Intel(R) Kabylake GT2 */
1137 } else if (strstr(gen_val
, "bxt") != NULL
) {
1138 /* Intel(R) HD Graphics (Broxton) */
1143 fprintf(stderr
, "can't parse gen: %s, expected ivb, byt, hsw, "
1144 "bdw, chv, skl, kbl or bxt\n", gen_val
);
1148 /* Do this before we redirect stdout to pager. */
1149 if (option_color
== COLOR_AUTO
)
1150 option_color
= isatty(1) ? COLOR_ALWAYS
: COLOR_NEVER
;
1152 if (isatty(1) && pager
)
1155 if (gen_minor
> 0) {
1156 snprintf(gen_file
, sizeof(gen_file
), "../genxml/gen%d%d.xml",
1157 gen_major
, gen_minor
);
1159 snprintf(gen_file
, sizeof(gen_file
), "../genxml/gen%d.xml", gen_major
);
1162 spec
= gen_spec_load(gen_file
);
1163 disasm
= gen_disasm_create(pci_id
);
1165 if (argv
[i
] == NULL
) {
1166 print_help(argv
[0], stderr
);
1169 file
= aub_file_open(argv
[i
]);
1172 while (aub_file_more_stuff(file
))
1173 aub_file_decode_batch(file
, spec
);
1176 /* close the stdout which is opened to write the output */
1181 return EXIT_SUCCESS
;