fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2025-12-23 22:00:13 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

intel: tools: add aubinator viewer

Browse source 
A graphical user interface version of aubinator.
Allows you to :

   - simultaneously look at multiple points in the aub file (using all
     the goodness of the existing decoding in aubinator)

   - edit an aub file

v2: Switch from GLFW to GTK+3

v3: Fix warning when exiting

Signed-off-by: Lionel Landwerlin <lionel.g.landwerlin@intel.com>
Acked-by: Rafael Antognolli <rafael.antognolli@intel.com> (v1)
This commit is contained in:
Lionel Landwerlin 2018-07-28 19:13:28 +01:00
parent ea83a1d304
commit 38f10d5a03
6 changed files with 2788 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
src/intel/Makefile.am
View file

@ -69,6 +69,9 @@ EXTRA_DIST = \
dev/meson.build \ dev/meson.build \
genxml/meson.build \ genxml/meson.build \
isl/meson.build \ isl/meson.build \
tools/aubinator_viewer.cpp \
tools/aubinator_viewer.h \
tools/aubinator_viewer_decoder.cpp \
tools/imgui/README \ tools/imgui/README \
tools/imgui/stb_textedit.h \ tools/imgui/stb_textedit.h \
tools/imgui/meson.build \ tools/imgui/meson.build \
@ -82,6 +85,7 @@ EXTRA_DIST = \
tools/imgui/imgui_impl_gtk3.h \ tools/imgui/imgui_impl_gtk3.h \
tools/imgui/imgui_impl_opengl3.cpp \ tools/imgui/imgui_impl_opengl3.cpp \
tools/imgui/imgui_impl_opengl3.h \ tools/imgui/imgui_impl_opengl3.h \
tools/imgui/imgui_memory_editor.h \
tools/imgui/stb_truetype.h \ tools/imgui/stb_truetype.h \
tools/imgui/stb_rect_pack.h \ tools/imgui/stb_rect_pack.h \
tools/imgui/LICENSE.txt \ tools/imgui/LICENSE.txt \

1137
src/intel/tools/aubinator_viewer.cpp Normal file
View file

File diff suppressed because it is too large Load diff

71
src/intel/tools/aubinator_viewer.h Normal file
View file

@ -0,0 +1,71 @@
#ifndef AUBINATOR_VIEWER_H
#define AUBINATOR_VIEWER_H
#include "imgui.h"
#include "common/gen_decoder.h"
#include "common/gen_disasm.h"
struct aub_viewer_cfg {
ImColor clear_color;
ImColor dwords_color;
ImColor highlight_color;
ImColor error_color;
ImColor missing_color;
aub_viewer_cfg() :
clear_color(114, 144, 154),
dwords_color(29, 177, 194, 255),
highlight_color(0, 230, 0, 255),
error_color(236, 255, 0, 255),
missing_color(230, 0, 230, 255) {}
};
struct aub_viewer_decode_cfg {
struct ImGuiTextFilter command_filter;
struct ImGuiTextFilter field_filter;
bool drop_filtered;
bool show_dwords;
aub_viewer_decode_cfg() :
drop_filtered(false),
show_dwords(true) {}
};
struct aub_viewer_decode_ctx {
struct gen_batch_decode_bo (*get_bo)(void *user_data, uint64_t address);
unsigned (*get_state_size)(void *user_data,
uint32_t offset_from_dynamic_state_base_addr);
void (*display_shader)(void *user_data, const char *shader_desc, uint64_t address);
void (*edit_address)(void *user_data, uint64_t address, uint32_t length);
void *user_data;
struct gen_spec *spec;
struct gen_disasm *disasm;
struct aub_viewer_cfg *cfg;
struct aub_viewer_decode_cfg *decode_cfg;
uint64_t surface_base;
uint64_t dynamic_base;
uint64_t instruction_base;
};
void aub_viewer_decode_ctx_init(struct aub_viewer_decode_ctx *ctx,
struct aub_viewer_cfg *cfg,
struct aub_viewer_decode_cfg *decode_cfg,
struct gen_spec *spec,
struct gen_disasm *disasm,
struct gen_batch_decode_bo (*get_bo)(void *, uint64_t),
unsigned (*get_state_size)(void *, uint32_t),
void *user_data);
void aub_viewer_render_batch(struct aub_viewer_decode_ctx *ctx,
const void *batch, uint32_t batch_size,
uint64_t batch_addr);
#endif /* AUBINATOR_VIEWER_H */

860
src/intel/tools/aubinator_viewer_decoder.cpp Normal file
View file

@ -0,0 +1,860 @@
/*
* Copyright © 2017 Intel Corporation
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
* IN THE SOFTWARE.
*/
#include <string.h>
#include "util/macros.h"
#include "aubinator_viewer.h"
void
aub_viewer_decode_ctx_init(struct aub_viewer_decode_ctx *ctx,
struct aub_viewer_cfg *cfg,
struct aub_viewer_decode_cfg *decode_cfg,
struct gen_spec *spec,
struct gen_disasm *disasm,
struct gen_batch_decode_bo (*get_bo)(void *, uint64_t),
unsigned (*get_state_size)(void *, uint32_t),
void *user_data)
{
memset(ctx, 0, sizeof(*ctx));
ctx->get_bo = get_bo;
ctx->get_state_size = get_state_size;
ctx->user_data = user_data;
ctx->cfg = cfg;
ctx->decode_cfg = decode_cfg;
ctx->spec = spec;
ctx->disasm = disasm;
}
static void
aub_viewer_print_group(struct aub_viewer_decode_ctx *ctx,
struct gen_group *group,
uint64_t address, const void *map)
{
struct gen_field_iterator iter;
int last_dword = -1;
const uint32_t *p = (const uint32_t *) map;
gen_field_iterator_init(&iter, group, p, 0, false);
while (gen_field_iterator_next(&iter)) {
if (ctx->decode_cfg->show_dwords) {
int iter_dword = iter.end_bit / 32;
if (last_dword != iter_dword) {
for (int i = last_dword + 1; i <= iter_dword; i++) {
ImGui::TextColored(ctx->cfg->dwords_color,
"0x%08" PRIx64 ": 0x%08x : Dword %d",
address + 4 * i, iter.p[i], i);
}
last_dword = iter_dword;
}
}
if (!gen_field_is_header(iter.field)) {
if (ctx->decode_cfg->field_filter.PassFilter(iter.name)) {
ImGui::Text("%s: %s", iter.name, iter.value);
if (iter.struct_desc) {
int struct_dword = iter.start_bit / 32;
uint64_t struct_address = address + 4 * struct_dword;
aub_viewer_print_group(ctx, iter.struct_desc, struct_address,
&p[struct_dword]);
}
}
}
}
}
static struct gen_batch_decode_bo
ctx_get_bo(struct aub_viewer_decode_ctx *ctx, uint64_t addr)
{
if (gen_spec_get_gen(ctx->spec) >= gen_make_gen(8,0)) {
/* On Broadwell and above, we have 48-bit addresses which consume two
* dwords. Some packets require that these get stored in a "canonical
* form" which means that bit 47 is sign-extended through the upper
* bits. In order to correctly handle those aub dumps, we need to mask
* off the top 16 bits.
*/
addr &= (~0ull >> 16);
}
struct gen_batch_decode_bo bo = ctx->get_bo(ctx->user_data, addr);
if (gen_spec_get_gen(ctx->spec) >= gen_make_gen(8,0))
bo.addr &= (~0ull >> 16);
/* We may actually have an offset into the bo */
if (bo.map != NULL) {
assert(bo.addr <= addr);
uint64_t offset = addr - bo.addr;
bo.map = (const uint8_t *)bo.map + offset;
bo.addr += offset;
bo.size -= offset;
}
return bo;
}
static int
update_count(struct aub_viewer_decode_ctx *ctx,
uint32_t offset_from_dsba,
unsigned element_dwords,
unsigned guess)
{
unsigned size = 0;
if (ctx->get_state_size)
size = ctx->get_state_size(ctx->user_data, offset_from_dsba);
if (size > 0)
return size / (sizeof(uint32_t) * element_dwords);
/* In the absence of any information, just guess arbitrarily. */
return guess;
}
static void
ctx_disassemble_program(struct aub_viewer_decode_ctx *ctx,
uint32_t ksp, const char *type)
{
uint64_t addr = ctx->instruction_base + ksp;
struct gen_batch_decode_bo bo = ctx_get_bo(ctx, addr);
if (!bo.map) {
ImGui::TextColored(ctx->cfg->missing_color, "Shader unavailable");
return;
}
ImGui::PushID(addr);
if (ImGui::Button(type) && ctx->display_shader)
ctx->display_shader(ctx->user_data, type, addr);
ImGui::PopID();
}
static void
handle_state_base_address(struct aub_viewer_decode_ctx *ctx,
struct gen_group *inst,
const uint32_t *p)
{
struct gen_field_iterator iter;
gen_field_iterator_init(&iter, inst, p, 0, false);
while (gen_field_iterator_next(&iter)) {
if (strcmp(iter.name, "Surface State Base Address") == 0) {
ctx->surface_base = iter.raw_value;
} else if (strcmp(iter.name, "Dynamic State Base Address") == 0) {
ctx->dynamic_base = iter.raw_value;
} else if (strcmp(iter.name, "Instruction Base Address") == 0) {
ctx->instruction_base = iter.raw_value;
}
}
}
static void
dump_binding_table(struct aub_viewer_decode_ctx *ctx, uint32_t offset, int count)
{
struct gen_group *strct =
gen_spec_find_struct(ctx->spec, "RENDER_SURFACE_STATE");
if (strct == NULL) {
ImGui::TextColored(ctx->cfg->missing_color, "did not find RENDER_SURFACE_STATE info");
return;
}
if (count < 0)
count = update_count(ctx, offset, 1, 8);
if (offset % 32 != 0 || offset >= UINT16_MAX) {
ImGui::TextColored(ctx->cfg->missing_color, "invalid binding table pointer");
return;
}
struct gen_batch_decode_bo bind_bo =
ctx_get_bo(ctx, ctx->surface_base + offset);
if (bind_bo.map == NULL) {
ImGui::TextColored(ctx->cfg->missing_color,
"binding table unavailable addr=0x%08" PRIx64,
ctx->surface_base + offset);
return;
}
const uint32_t *pointers = (const uint32_t *) bind_bo.map;
for (int i = 0; i < count; i++) {
if (pointers[i] == 0)
continue;
uint64_t addr = ctx->surface_base + pointers[i];
struct gen_batch_decode_bo bo = ctx_get_bo(ctx, addr);
uint32_t size = strct->dw_length * 4;
if (pointers[i] % 32 != 0 ||
addr < bo.addr || addr + size >= bo.addr + bo.size) {
ImGui::TextColored(ctx->cfg->missing_color,
"pointer %u: %08x <not valid>", i, pointers[i]);
continue;
}
ImGui::Text("pointer %u: %08x", i, pointers[i]);
aub_viewer_print_group(ctx, strct, addr, (const uint8_t *) bo.map + (addr - bo.addr));
}
}
static void
dump_samplers(struct aub_viewer_decode_ctx *ctx, uint32_t offset, int count)
{
struct gen_group *strct = gen_spec_find_struct(ctx->spec, "SAMPLER_STATE");
if (count < 0)
count = update_count(ctx, offset, strct->dw_length, 4);
uint64_t state_addr = ctx->dynamic_base + offset;
struct gen_batch_decode_bo bo = ctx_get_bo(ctx, state_addr);
const uint8_t *state_map = (const uint8_t *) bo.map;
if (state_map == NULL) {
ImGui::TextColored(ctx->cfg->missing_color,
"samplers unavailable addr=0x%08" PRIx64, state_addr);
return;
}
if (offset % 32 != 0 || state_addr - bo.addr >= bo.size) {
ImGui::TextColored(ctx->cfg->missing_color, "invalid sampler state pointer");
return;
}
for (int i = 0; i < count; i++) {
ImGui::Text("sampler state %d", i);
aub_viewer_print_group(ctx, strct, state_addr, state_map);
state_addr += 16;
state_map += 16;
}
}
static void
handle_media_interface_descriptor_load(struct aub_viewer_decode_ctx *ctx,
struct gen_group *inst,
const uint32_t *p)
{
struct gen_group *desc =
gen_spec_find_struct(ctx->spec, "INTERFACE_DESCRIPTOR_DATA");
struct gen_field_iterator iter;
gen_field_iterator_init(&iter, inst, p, 0, false);
uint32_t descriptor_offset = 0;
int descriptor_count = 0;
while (gen_field_iterator_next(&iter)) {
if (strcmp(iter.name, "Interface Descriptor Data Start Address") == 0) {
descriptor_offset = strtol(iter.value, NULL, 16);
} else if (strcmp(iter.name, "Interface Descriptor Total Length") == 0) {
descriptor_count =
strtol(iter.value, NULL, 16) / (desc->dw_length * 4);
}
}
uint64_t desc_addr = ctx->dynamic_base + descriptor_offset;
struct gen_batch_decode_bo bo = ctx_get_bo(ctx, desc_addr);
const uint32_t *desc_map = (const uint32_t *) bo.map;
if (desc_map == NULL) {
ImGui::TextColored(ctx->cfg->missing_color,
"interface descriptors unavailable addr=0x%08" PRIx64, desc_addr);
return;
}
for (int i = 0; i < descriptor_count; i++) {
ImGui::Text("descriptor %d: %08x", i, descriptor_offset);
aub_viewer_print_group(ctx, desc, desc_addr, desc_map);
gen_field_iterator_init(&iter, desc, desc_map, 0, false);
uint64_t ksp = 0;
uint32_t sampler_offset = 0, sampler_count = 0;
uint32_t binding_table_offset = 0, binding_entry_count = 0;
while (gen_field_iterator_next(&iter)) {
if (strcmp(iter.name, "Kernel Start Pointer") == 0) {
ksp = strtoll(iter.value, NULL, 16);
} else if (strcmp(iter.name, "Sampler State Pointer") == 0) {
sampler_offset = strtol(iter.value, NULL, 16);
} else if (strcmp(iter.name, "Sampler Count") == 0) {
sampler_count = strtol(iter.value, NULL, 10);
} else if (strcmp(iter.name, "Binding Table Pointer") == 0) {
binding_table_offset = strtol(iter.value, NULL, 16);
} else if (strcmp(iter.name, "Binding Table Entry Count") == 0) {
binding_entry_count = strtol(iter.value, NULL, 10);
}
}
ctx_disassemble_program(ctx, ksp, "compute shader");
dump_samplers(ctx, sampler_offset, sampler_count);
dump_binding_table(ctx, binding_table_offset, binding_entry_count);
desc_map += desc->dw_length;
desc_addr += desc->dw_length * 4;
}
}
static void
handle_3dstate_vertex_buffers(struct aub_viewer_decode_ctx *ctx,
struct gen_group *inst,
const uint32_t *p)
{
struct gen_group *vbs = gen_spec_find_struct(ctx->spec, "VERTEX_BUFFER_STATE");
struct gen_batch_decode_bo vb = {};
uint32_t vb_size = 0;
int index = -1;
int pitch = -1;
bool ready = false;
struct gen_field_iterator iter;
gen_field_iterator_init(&iter, inst, p, 0, false);
while (gen_field_iterator_next(&iter)) {
if (iter.struct_desc != vbs)
continue;
uint64_t buffer_addr;
struct gen_field_iterator vbs_iter;
gen_field_iterator_init(&vbs_iter, vbs, &iter.p[iter.start_bit / 32], 0, false);
while (gen_field_iterator_next(&vbs_iter)) {
if (strcmp(vbs_iter.name, "Vertex Buffer Index") == 0) {
index = vbs_iter.raw_value;
} else if (strcmp(vbs_iter.name, "Buffer Pitch") == 0) {
pitch = vbs_iter.raw_value;
} else if (strcmp(vbs_iter.name, "Buffer Starting Address") == 0) {
buffer_addr = vbs_iter.raw_value;
vb = ctx_get_bo(ctx, buffer_addr);
} else if (strcmp(vbs_iter.name, "Buffer Size") == 0) {
vb_size = vbs_iter.raw_value;
ready = true;
} else if (strcmp(vbs_iter.name, "End Address") == 0) {
if (vb.map && vbs_iter.raw_value >= vb.addr)
vb_size = vbs_iter.raw_value - vb.addr;
else
vb_size = 0;
ready = true;
}
if (!ready)
continue;
ImGui::Text("vertex buffer %d, size %d", index, vb_size);
if (vb.map == NULL) {
ImGui::TextColored(ctx->cfg->missing_color,
"buffer contents unavailable addr=0x%08" PRIx64, buffer_addr);
continue;
}
if (vb.map == 0 || vb_size == 0)
continue;
vb.map = NULL;
vb_size = 0;
index = -1;
pitch = -1;
ready = false;
}
}
}
static void
handle_3dstate_index_buffer(struct aub_viewer_decode_ctx *ctx,
struct gen_group *inst,
const uint32_t *p)
{
struct gen_batch_decode_bo ib = {};
uint64_t buffer_addr = 0;
uint32_t ib_size = 0;
uint32_t format = 0;
struct gen_field_iterator iter;
gen_field_iterator_init(&iter, inst, p, 0, false);
while (gen_field_iterator_next(&iter)) {
if (strcmp(iter.name, "Index Format") == 0) {
format = iter.raw_value;
} else if (strcmp(iter.name, "Buffer Starting Address") == 0) {
buffer_addr = iter.raw_value;
ib = ctx_get_bo(ctx, buffer_addr);
} else if (strcmp(iter.name, "Buffer Size") == 0) {
ib_size = iter.raw_value;
}
}
if (ib.map == NULL) {
ImGui::TextColored(ctx->cfg->missing_color,
"buffer contents unavailable addr=0x%08" PRIx64,
buffer_addr);
return;
}
const uint8_t *m = (const uint8_t *) ib.map;
const uint8_t *ib_end = m + MIN2(ib.size, ib_size);
for (int i = 0; m < ib_end && i < 10; i++) {
switch (format) {
case 0:
m += 1;
break;
case 1:
m += 2;
break;
case 2:
m += 4;
break;
}
}
}
static void
decode_single_ksp(struct aub_viewer_decode_ctx *ctx,
struct gen_group *inst,
const uint32_t *p)
{
uint64_t ksp = 0;
bool is_simd8 = false; /* vertex shaders on Gen8+ only */
bool is_enabled = true;
struct gen_field_iterator iter;
gen_field_iterator_init(&iter, inst, p, 0, false);
while (gen_field_iterator_next(&iter)) {
if (strcmp(iter.name, "Kernel Start Pointer") == 0) {
ksp = iter.raw_value;
} else if (strcmp(iter.name, "SIMD8 Dispatch Enable") == 0) {
is_simd8 = iter.raw_value;
} else if (strcmp(iter.name, "Dispatch Mode") == 0) {
is_simd8 = strcmp(iter.value, "SIMD8") == 0;
} else if (strcmp(iter.name, "Dispatch Enable") == 0) {
is_simd8 = strcmp(iter.value, "SIMD8") == 0;
} else if (strcmp(iter.name, "Enable") == 0) {
is_enabled = iter.raw_value;
}
}
const char *type =
strcmp(inst->name, "VS_STATE") == 0 ? "vertex shader" :
strcmp(inst->name, "GS_STATE") == 0 ? "geometry shader" :
strcmp(inst->name, "SF_STATE") == 0 ? "strips and fans shader" :
strcmp(inst->name, "CLIP_STATE") == 0 ? "clip shader" :
strcmp(inst->name, "3DSTATE_DS") == 0 ? "tessellation evaluation shader" :
strcmp(inst->name, "3DSTATE_HS") == 0 ? "tessellation control shader" :
strcmp(inst->name, "3DSTATE_VS") == 0 ? (is_simd8 ? "SIMD8 vertex shader" : "vec4 vertex shader") :
strcmp(inst->name, "3DSTATE_GS") == 0 ? (is_simd8 ? "SIMD8 geometry shader" : "vec4 geometry shader") :
NULL;
if (is_enabled)
ctx_disassemble_program(ctx, ksp, type);
}
static void
decode_ps_kernels(struct aub_viewer_decode_ctx *ctx,
struct gen_group *inst,
const uint32_t *p)
{
uint64_t ksp[3] = {0, 0, 0};
bool enabled[3] = {false, false, false};
struct gen_field_iterator iter;
gen_field_iterator_init(&iter, inst, p, 0, false);
while (gen_field_iterator_next(&iter)) {
if (strncmp(iter.name, "Kernel Start Pointer ",
strlen("Kernel Start Pointer ")) == 0) {
int idx = iter.name[strlen("Kernel Start Pointer ")] - '0';
ksp[idx] = strtol(iter.value, NULL, 16);
} else if (strcmp(iter.name, "8 Pixel Dispatch Enable") == 0) {
enabled[0] = strcmp(iter.value, "true") == 0;
} else if (strcmp(iter.name, "16 Pixel Dispatch Enable") == 0) {
enabled[1] = strcmp(iter.value, "true") == 0;
} else if (strcmp(iter.name, "32 Pixel Dispatch Enable") == 0) {
enabled[2] = strcmp(iter.value, "true") == 0;
}
}
/* Reorder KSPs to be [8, 16, 32] instead of the hardware order. */
if (enabled[0] + enabled[1] + enabled[2] == 1) {
if (enabled[1]) {
ksp[1] = ksp[0];
ksp[0] = 0;
} else if (enabled[2]) {
ksp[2] = ksp[0];
ksp[0] = 0;
}
} else {
uint64_t tmp = ksp[1];
ksp[1] = ksp[2];
ksp[2] = tmp;
}
if (enabled[0])
ctx_disassemble_program(ctx, ksp[0], "SIMD8 fragment shader");
if (enabled[1])
ctx_disassemble_program(ctx, ksp[1], "SIMD16 fragment shader");
if (enabled[2])
ctx_disassemble_program(ctx, ksp[2], "SIMD32 fragment shader");
}
static void
decode_3dstate_constant(struct aub_viewer_decode_ctx *ctx,
struct gen_group *inst,
const uint32_t *p)
{
struct gen_group *body =
gen_spec_find_struct(ctx->spec, "3DSTATE_CONSTANT_BODY");
uint32_t read_length[4] = {0};
uint64_t read_addr[4];
struct gen_field_iterator outer;
gen_field_iterator_init(&outer, inst, p, 0, false);
while (gen_field_iterator_next(&outer)) {
if (outer.struct_desc != body)
continue;
struct gen_field_iterator iter;
gen_field_iterator_init(&iter, body, &outer.p[outer.start_bit / 32],
0, false);
while (gen_field_iterator_next(&iter)) {
int idx;
if (sscanf(iter.name, "Read Length[%d]", &idx) == 1) {
read_length[idx] = iter.raw_value;
} else if (sscanf(iter.name, "Buffer[%d]", &idx) == 1) {
read_addr[idx] = iter.raw_value;
}
}
for (int i = 0; i < 4; i++) {
if (read_length[i] == 0)
continue;
struct gen_batch_decode_bo buffer = ctx_get_bo(ctx, read_addr[i]);
if (!buffer.map) {
ImGui::TextColored(ctx->cfg->missing_color,
"constant buffer %d unavailable addr=0x%08" PRIx64,
i, read_addr[i]);
continue;
}
unsigned size = read_length[i] * 32;
ImGui::Text("constant buffer %d, size %u", i, size);
if (ctx->edit_address) {
if (ImGui::Button("Show/Edit buffer"))
ctx->edit_address(ctx->user_data, read_addr[i], size);
}
}
}
}
static void
decode_3dstate_binding_table_pointers(struct aub_viewer_decode_ctx *ctx,
struct gen_group *inst,
const uint32_t *p)
{
dump_binding_table(ctx, p[1], -1);
}
static void
decode_3dstate_sampler_state_pointers(struct aub_viewer_decode_ctx *ctx,
struct gen_group *inst,
const uint32_t *p)
{
dump_samplers(ctx, p[1], -1);
}
static void
decode_3dstate_sampler_state_pointers_gen6(struct aub_viewer_decode_ctx *ctx,
struct gen_group *inst,
const uint32_t *p)
{
dump_samplers(ctx, p[1], -1);
dump_samplers(ctx, p[2], -1);
dump_samplers(ctx, p[3], -1);
}
static bool
str_ends_with(const char *str, const char *end)
{
int offset = strlen(str) - strlen(end);
if (offset < 0)
return false;
return strcmp(str + offset, end) == 0;
}
static void
decode_dynamic_state_pointers(struct aub_viewer_decode_ctx *ctx,
struct gen_group *inst, const uint32_t *p,
const char *struct_type, int count)
{
struct gen_group *state = gen_spec_find_struct(ctx->spec, struct_type);
uint32_t state_offset = 0;
struct gen_field_iterator iter;
gen_field_iterator_init(&iter, inst, p, 0, false);
while (gen_field_iterator_next(&iter)) {
if (str_ends_with(iter.name, "Pointer")) {
state_offset = iter.raw_value;
break;
}
}
uint64_t state_addr = ctx->dynamic_base + state_offset;
struct gen_batch_decode_bo bo = ctx_get_bo(ctx, state_addr);
const uint8_t *state_map = (const uint8_t *) bo.map;
if (state_map == NULL) {
ImGui::TextColored(ctx->cfg->missing_color,
"dynamic %s state unavailable addr=0x%08" PRIx64,
struct_type, state_addr);
return;
}
for (int i = 0; i < count; i++) {
ImGui::Text("%s %d", struct_type, i);
aub_viewer_print_group(ctx, state, state_offset, state_map);
state_addr += state->dw_length * 4;
state_map += state->dw_length;
}
}
static void
decode_3dstate_viewport_state_pointers_cc(struct aub_viewer_decode_ctx *ctx,
struct gen_group *inst,
const uint32_t *p)
{
decode_dynamic_state_pointers(ctx, inst, p, "CC_VIEWPORT", 4);
}
static void
decode_3dstate_viewport_state_pointers_sf_clip(struct aub_viewer_decode_ctx *ctx,
struct gen_group *inst,
const uint32_t *p)
{
decode_dynamic_state_pointers(ctx, inst, p, "SF_CLIP_VIEWPORT", 4);
}
static void
decode_3dstate_blend_state_pointers(struct aub_viewer_decode_ctx *ctx,
struct gen_group *inst,
const uint32_t *p)
{
decode_dynamic_state_pointers(ctx, inst, p, "BLEND_STATE", 1);
}
static void
decode_3dstate_cc_state_pointers(struct aub_viewer_decode_ctx *ctx,
struct gen_group *inst,
const uint32_t *p)
{
decode_dynamic_state_pointers(ctx, inst, p, "COLOR_CALC_STATE", 1);
}
static void
decode_3dstate_scissor_state_pointers(struct aub_viewer_decode_ctx *ctx,
struct gen_group *inst,
const uint32_t *p)
{
decode_dynamic_state_pointers(ctx, inst, p, "SCISSOR_RECT", 1);
}
static void
decode_load_register_imm(struct aub_viewer_decode_ctx *ctx,
struct gen_group *inst,
const uint32_t *p)
{
struct gen_group *reg = gen_spec_find_register(ctx->spec, p[1]);
if (reg != NULL &&
ImGui::TreeNodeEx(&p[1], ImGuiTreeNodeFlags_Framed,
"%s (0x%x) = 0x%x",
reg->name, reg->register_offset, p[2])) {
aub_viewer_print_group(ctx, reg, reg->register_offset, &p[2]);
ImGui::TreePop();
}
}
struct custom_decoder {
const char *cmd_name;
void (*decode)(struct aub_viewer_decode_ctx *ctx,
struct gen_group *inst,
const uint32_t *p);
} display_decoders[] = {
{ "STATE_BASE_ADDRESS", handle_state_base_address },
{ "MEDIA_INTERFACE_DESCRIPTOR_LOAD", handle_media_interface_descriptor_load },
{ "3DSTATE_VERTEX_BUFFERS", handle_3dstate_vertex_buffers },
{ "3DSTATE_INDEX_BUFFER", handle_3dstate_index_buffer },
{ "3DSTATE_VS", decode_single_ksp },
{ "3DSTATE_GS", decode_single_ksp },
{ "3DSTATE_DS", decode_single_ksp },
{ "3DSTATE_HS", decode_single_ksp },
{ "3DSTATE_PS", decode_ps_kernels },
{ "3DSTATE_CONSTANT_VS", decode_3dstate_constant },
{ "3DSTATE_CONSTANT_GS", decode_3dstate_constant },
{ "3DSTATE_CONSTANT_PS", decode_3dstate_constant },
{ "3DSTATE_CONSTANT_HS", decode_3dstate_constant },
{ "3DSTATE_CONSTANT_DS", decode_3dstate_constant },
{ "3DSTATE_BINDING_TABLE_POINTERS_VS", decode_3dstate_binding_table_pointers },
{ "3DSTATE_BINDING_TABLE_POINTERS_HS", decode_3dstate_binding_table_pointers },
{ "3DSTATE_BINDING_TABLE_POINTERS_DS", decode_3dstate_binding_table_pointers },
{ "3DSTATE_BINDING_TABLE_POINTERS_GS", decode_3dstate_binding_table_pointers },
{ "3DSTATE_BINDING_TABLE_POINTERS_PS", decode_3dstate_binding_table_pointers },
{ "3DSTATE_SAMPLER_STATE_POINTERS_VS", decode_3dstate_sampler_state_pointers },
{ "3DSTATE_SAMPLER_STATE_POINTERS_HS", decode_3dstate_sampler_state_pointers },
{ "3DSTATE_SAMPLER_STATE_POINTERS_DS", decode_3dstate_sampler_state_pointers },
{ "3DSTATE_SAMPLER_STATE_POINTERS_GS", decode_3dstate_sampler_state_pointers },
{ "3DSTATE_SAMPLER_STATE_POINTERS_PS", decode_3dstate_sampler_state_pointers },
{ "3DSTATE_SAMPLER_STATE_POINTERS", decode_3dstate_sampler_state_pointers_gen6 },
{ "3DSTATE_VIEWPORT_STATE_POINTERS_CC", decode_3dstate_viewport_state_pointers_cc },
{ "3DSTATE_VIEWPORT_STATE_POINTERS_SF_CLIP", decode_3dstate_viewport_state_pointers_sf_clip },
{ "3DSTATE_BLEND_STATE_POINTERS", decode_3dstate_blend_state_pointers },
{ "3DSTATE_CC_STATE_POINTERS", decode_3dstate_cc_state_pointers },
{ "3DSTATE_SCISSOR_STATE_POINTERS", decode_3dstate_scissor_state_pointers },
{ "MI_LOAD_REGISTER_IMM", decode_load_register_imm }
};
struct custom_decoder info_decoders[] = {
{ "STATE_BASE_ADDRESS", handle_state_base_address },
};
static inline uint64_t
get_address(struct gen_spec *spec, const uint32_t *p)
{
/* Addresses are always guaranteed to be page-aligned and sometimes
* hardware packets have extra stuff stuffed in the bottom 12 bits.
*/
uint64_t addr = p[0] & ~0xfffu;
if (gen_spec_get_gen(spec) >= gen_make_gen(8,0)) {
/* On Broadwell and above, we have 48-bit addresses which consume two
* dwords. Some packets require that these get stored in a "canonical
* form" which means that bit 47 is sign-extended through the upper
* bits. In order to correctly handle those aub dumps, we need to mask
* off the top 16 bits.
*/
addr |= ((uint64_t)p[1] & 0xffff) << 32;
}
return addr;
}
void
aub_viewer_render_batch(struct aub_viewer_decode_ctx *ctx,
const void *_batch, uint32_t batch_size,
uint64_t batch_addr)
{
struct gen_group *inst;
const uint32_t *p, *batch = (const uint32_t *) _batch, *end = batch + batch_size;
int length;
for (p = batch; p < end; p += length) {
inst = gen_spec_find_instruction(ctx->spec, p);
length = gen_group_get_length(inst, p);
assert(inst == NULL || length > 0);
length = MAX2(1, length);
uint64_t offset = batch_addr + ((char *)p - (char *)batch);
if (inst == NULL) {
ImGui::TextColored(ctx->cfg->error_color,
"x%08" PRIx64 ": unknown instruction %08x",
offset, p[0]);
continue;
}
const char *inst_name = gen_group_get_name(inst);
for (unsigned i = 0; i < ARRAY_SIZE(info_decoders); i++) {
if (strcmp(inst_name, info_decoders[i].cmd_name) == 0) {
info_decoders[i].decode(ctx, inst, p);
break;
}
}
if (ctx->decode_cfg->command_filter.PassFilter(inst->name) &&
ImGui::TreeNodeEx(p,
ImGuiTreeNodeFlags_Framed,
"0x%08" PRIx64 ": %s",
offset, inst->name)) {
aub_viewer_print_group(ctx, inst, offset, p);
for (unsigned i = 0; i < ARRAY_SIZE(display_decoders); i++) {
if (strcmp(inst_name, display_decoders[i].cmd_name) == 0) {
display_decoders[i].decode(ctx, inst, p);
break;
}
}
if (ctx->edit_address) {
if (ImGui::Button("Edit instruction"))
ctx->edit_address(ctx->user_data, offset, length * 4);
}
ImGui::TreePop();
}
if (strcmp(inst_name, "MI_BATCH_BUFFER_START") == 0) {
struct gen_batch_decode_bo next_batch = {};
bool second_level;
struct gen_field_iterator iter;
gen_field_iterator_init(&iter, inst, p, 0, false);
while (gen_field_iterator_next(&iter)) {
if (strcmp(iter.name, "Batch Buffer Start Address") == 0) {
next_batch = ctx_get_bo(ctx, iter.raw_value);
} else if (strcmp(iter.name, "Second Level Batch Buffer") == 0) {
second_level = iter.raw_value;
}
}
if (next_batch.map == NULL) {
ImGui::TextColored(ctx->cfg->missing_color,
"Secondary batch at 0x%08" PRIx64 " unavailable",
next_batch.addr);
} else {
aub_viewer_render_batch(ctx, next_batch.map, next_batch.size,
next_batch.addr);
}
if (second_level) {
/* MI_BATCH_BUFFER_START with "2nd Level Batch Buffer" set acts
* like a subroutine call. Commands that come afterwards get
* processed once the 2nd level batch buffer returns with
* MI_BATCH_BUFFER_END.
*/
continue;
} else {
/* MI_BATCH_BUFFER_START with "2nd Level Batch Buffer" unset acts
* like a goto. Nothing after it will ever get processed. In
* order to prevent the recursion from growing, we just reset the
* loop and continue;
*/
break;
}
} else if (strcmp(inst_name, "MI_BATCH_BUFFER_END") == 0) {
break;
}
}
}

704
src/intel/tools/imgui/imgui_memory_editor.h Normal file
View file

@ -0,0 +1,704 @@
// Mini memory editor for Dear ImGui (to embed in your game/tools)
// Animated GIF: https://twitter.com/ocornut/status/894242704317530112
// Get latest version at http://www.github.com/ocornut/imgui_club
//
// Right-click anywhere to access the Options menu!
// You can adjust the keyboard repeat delay/rate in ImGuiIO.
// The code assume a mono-space font for simplicity! If you don't use the default font, use ImGui::PushFont()/PopFont() to switch to a mono-space font before caling this.
//
// Usage:
// static MemoryEditor mem_edit_1; // store your state somewhere
// mem_edit_1.DrawWindow("Memory Editor", mem_block, mem_block_size, 0x0000); // create a window and draw memory editor (if you already have a window, use DrawContents())
//
// Usage:
// static MemoryEditor mem_edit_2;
// ImGui::Begin("MyWindow")
// mem_edit_2.DrawContents(this, sizeof(*this), (size_t)this);
// ImGui::End();
//
// Changelog:
// - v0.10: initial version
// - v0.11: always refresh active text input with the latest byte from source memory if it's not being edited.
// - v0.12: added OptMidRowsCount to allow extra spacing every XX rows.
// - v0.13: added optional ReadFn/WriteFn handlers to access memory via a function. various warning fixes for 64-bits.
// - v0.14: added GotoAddr member, added GotoAddrAndHighlight() and highlighting. fixed minor scrollbar glitch when resizing.
// - v0.15: added maximum window width. minor optimization.
// - v0.16: added OptGreyOutZeroes option. various sizing fixes when resizing using the "Rows" drag.
// - v0.17: added HighlightFn handler for optional non-contiguous highlighting.
// - v0.18: fixes for displaying 64-bits addresses, fixed mouse click gaps introduced in recent changes, cursor tracking scrolling fixes.
// - v0.19: fixed auto-focus of next byte leaving WantCaptureKeyboard=false for one frame. we now capture the keyboard during that transition.
// - v0.20: added options menu. added OptShowAscii checkbox. added optional HexII display. split Draw() in DrawWindow()/DrawContents(). fixing glyph width. refactoring/cleaning code.
// - v0.21: fixes for using DrawContents() in our own window. fixed HexII to actually be useful and not on the wrong side.
// - v0.22: clicking Ascii view select the byte in the Hex view. Ascii view highlight selection.
// - v0.23: fixed right-arrow triggering a byte write.
// - v0.24: changed DragInt("Rows" to use a %d data format (which is desirable since imgui 1.61).
// - v0.25: fixed wording: all occurrences of "Rows" renamed to "Columns".
// - v0.26: fixed clicking on hex region
// - v0.30: added data preview for common data types
//
// Todo/Bugs:
// - Arrows are being sent to the InputText() about to disappear which for LeftArrow makes the text cursor appear at position 1 for one frame.
// - Using InputText() is awkward and maybe overkill here, consider implementing something custom.
#pragma once
#include <stdio.h> // sprintf, scanf
#include <stdint.h> // uint8_t, etc.
#ifdef _MSC_VER
#define _PRISizeT "IX"
#define snprintf _snprintf
#else
#define _PRISizeT "zX"
#endif
struct MemoryEditor
{
typedef unsigned char u8;
enum DataType
{
DataType_S8,
DataType_U8,
DataType_S16,
DataType_U16,
DataType_S32,
DataType_U32,
DataType_S64,
DataType_U64,
DataType_Float,
DataType_Double,
DataType_COUNT
};
enum DataFormat
{
DataFormat_Bin = 0,
DataFormat_Dec = 1,
DataFormat_Hex = 2,
DataFormat_COUNT
};
// Settings
bool Open; // = true // set to false when DrawWindow() was closed. ignore if not using DrawWindow
bool ReadOnly; // = false // set to true to disable any editing
int Cols; // = 16 //
bool OptShowDataPreview; // = false //
bool OptShowHexII; // = false //
bool OptShowAscii; // = true //
bool OptGreyOutZeroes; // = true //
int OptMidColsCount; // = 8 // set to 0 to disable extra spacing between every mid-cols
int OptAddrDigitsCount; // = 0 // number of addr digits to display (default calculated based on maximum displayed addr)
ImU32 HighlightColor; // // color of highlight
u8 (*ReadFn)(const u8* data, size_t off); // = NULL // optional handler to read bytes
void (*WriteFn)(u8* data, size_t off, u8 d); // = NULL // optional handler to write bytes
bool (*HighlightFn)(const u8* data, size_t off);//NULL // optional handler to return Highlight property (to support non-contiguous highlighting)
// State/Internals
bool ContentsWidthChanged;
size_t DataPreviewAddr;
size_t DataEditingAddr;
bool DataEditingTakeFocus;
char DataInputBuf[32];
char AddrInputBuf[32];
size_t GotoAddr;
size_t HighlightMin, HighlightMax;
int PreviewEndianess;
DataType PreviewDataType;
MemoryEditor()
{
// Settings
Open = true;
ReadOnly = false;
Cols = 16;
OptShowDataPreview = false;
OptShowHexII = false;
OptShowAscii = true;
OptGreyOutZeroes = true;
OptMidColsCount = 8;
OptAddrDigitsCount = 0;
HighlightColor = IM_COL32(255, 255, 255, 50);
ReadFn = NULL;
WriteFn = NULL;
HighlightFn = NULL;
// State/Internals
ContentsWidthChanged = false;
DataPreviewAddr = DataEditingAddr = (size_t)-1;
DataEditingTakeFocus = false;
memset(DataInputBuf, 0, sizeof(DataInputBuf));
memset(AddrInputBuf, 0, sizeof(AddrInputBuf));
GotoAddr = (size_t)-1;
HighlightMin = HighlightMax = (size_t)-1;
PreviewEndianess = 0;
PreviewDataType = DataType_S32;
}
void GotoAddrAndHighlight(size_t addr_min, size_t addr_max)
{
GotoAddr = addr_min;
HighlightMin = addr_min;
HighlightMax = addr_max;
}
struct Sizes
{
int AddrDigitsCount;
float LineHeight;
float GlyphWidth;
float HexCellWidth;
float SpacingBetweenMidCols;
float PosHexStart;
float PosHexEnd;
float PosAsciiStart;
float PosAsciiEnd;
float WindowWidth;
};
void CalcSizes(Sizes& s, size_t mem_size, size_t base_display_addr)
{
ImGuiStyle& style = ImGui::GetStyle();
s.AddrDigitsCount = OptAddrDigitsCount;
if (s.AddrDigitsCount == 0)
for (size_t n = base_display_addr + mem_size - 1; n > 0; n >>= 4)
s.AddrDigitsCount++;
s.LineHeight = ImGui::GetTextLineHeight();
s.GlyphWidth = ImGui::CalcTextSize("F").x + 1; // We assume the font is mono-space
s.HexCellWidth = (float)(int)(s.GlyphWidth * 2.5f); // "FF " we include trailing space in the width to easily catch clicks everywhere
s.SpacingBetweenMidCols = (float)(int)(s.HexCellWidth * 0.25f); // Every OptMidColsCount columns we add a bit of extra spacing
s.PosHexStart = (s.AddrDigitsCount + 2) * s.GlyphWidth;
s.PosHexEnd = s.PosHexStart + (s.HexCellWidth * Cols);
s.PosAsciiStart = s.PosAsciiEnd = s.PosHexEnd;
if (OptShowAscii)
{
s.PosAsciiStart = s.PosHexEnd + s.GlyphWidth * 1;
if (OptMidColsCount > 0)
s.PosAsciiStart += ((Cols + OptMidColsCount - 1) / OptMidColsCount) * s.SpacingBetweenMidCols;
s.PosAsciiEnd = s.PosAsciiStart + Cols * s.GlyphWidth;
}
s.WindowWidth = s.PosAsciiEnd + style.ScrollbarSize + style.WindowPadding.x * 2 + s.GlyphWidth;
}
// Standalone Memory Editor window
void DrawWindow(const char* title, u8* mem_data, size_t mem_size, size_t base_display_addr = 0x0000)
{
Sizes s;
CalcSizes(s, mem_size, base_display_addr);
ImGui::SetNextWindowSizeConstraints(ImVec2(0.0f, 0.0f), ImVec2(s.WindowWidth, FLT_MAX));
Open = true;
if (ImGui::Begin(title, &Open, ImGuiWindowFlags_NoScrollbar))
{
if (ImGui::IsWindowHovered(ImGuiHoveredFlags_RootAndChildWindows) && ImGui::IsMouseClicked(1))
ImGui::OpenPopup("context");
DrawContents(mem_data, mem_size, base_display_addr);
if (ContentsWidthChanged)
{
CalcSizes(s, mem_size, base_display_addr);
ImGui::SetWindowSize(ImVec2(s.WindowWidth, ImGui::GetWindowSize().y));
}
}
ImGui::End();
}
// Memory Editor contents only
void DrawContents(u8* mem_data, size_t mem_size, size_t base_display_addr = 0x0000)
{
Sizes s;
CalcSizes(s, mem_size, base_display_addr);
ImGuiStyle& style = ImGui::GetStyle();
// We begin into our scrolling region with the 'ImGuiWindowFlags_NoMove' in order to prevent click from moving the window.
// This is used as a facility since our main click detection code doesn't assign an ActiveId so the click would normally be caught as a window-move.
const float height_separator = style.ItemSpacing.y;
float footer_height = height_separator + ImGui::GetFrameHeightWithSpacing() * 1;
if (OptShowDataPreview)
footer_height += height_separator + ImGui::GetFrameHeightWithSpacing() * 1 + ImGui::GetTextLineHeightWithSpacing() * 3;
ImGui::BeginChild("##scrolling", ImVec2(0, -footer_height), false, ImGuiWindowFlags_NoMove);
ImDrawList* draw_list = ImGui::GetWindowDrawList();
ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(0, 0));
ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0, 0));
const int line_total_count = (int)((mem_size + Cols - 1) / Cols);
ImGuiListClipper clipper(line_total_count, s.LineHeight);
const size_t visible_start_addr = clipper.DisplayStart * Cols;
const size_t visible_end_addr = clipper.DisplayEnd * Cols;
bool data_next = false;
if (ReadOnly || DataEditingAddr >= mem_size)
DataEditingAddr = (size_t)-1;
if (DataPreviewAddr >= mem_size)
DataPreviewAddr = (size_t)-1;
size_t preview_data_type_size = OptShowDataPreview ? DataTypeGetSize(PreviewDataType) : 0;
size_t data_editing_addr_backup = DataEditingAddr;
size_t data_editing_addr_next = (size_t)-1;
if (DataEditingAddr != (size_t)-1)
{
// Move cursor but only apply on next frame so scrolling with be synchronized (because currently we can't change the scrolling while the window is being rendered)
if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_UpArrow)) && DataEditingAddr >= (size_t)Cols) { data_editing_addr_next = DataEditingAddr - Cols; DataEditingTakeFocus = true; }
else if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_DownArrow)) && DataEditingAddr < mem_size - Cols) { data_editing_addr_next = DataEditingAddr + Cols; DataEditingTakeFocus = true; }
else if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_LeftArrow)) && DataEditingAddr > 0) { data_editing_addr_next = DataEditingAddr - 1; DataEditingTakeFocus = true; }
else if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_RightArrow)) && DataEditingAddr < mem_size - 1) { data_editing_addr_next = DataEditingAddr + 1; DataEditingTakeFocus = true; }
}
if (data_editing_addr_next != (size_t)-1 && (data_editing_addr_next / Cols) != (data_editing_addr_backup / Cols))
{
// Track cursor movements
const int scroll_offset = ((int)(data_editing_addr_next / Cols) - (int)(data_editing_addr_backup / Cols));
const bool scroll_desired = (scroll_offset < 0 && data_editing_addr_next < visible_start_addr + Cols * 2) || (scroll_offset > 0 && data_editing_addr_next > visible_end_addr - Cols * 2);
if (scroll_desired)
ImGui::SetScrollY(ImGui::GetScrollY() + scroll_offset * s.LineHeight);
}
// Draw vertical separator
ImVec2 window_pos = ImGui::GetWindowPos();
if (OptShowAscii)
draw_list->AddLine(ImVec2(window_pos.x + s.PosAsciiStart - s.GlyphWidth, window_pos.y), ImVec2(window_pos.x + s.PosAsciiStart - s.GlyphWidth, window_pos.y + 9999), ImGui::GetColorU32(ImGuiCol_Border));
const ImU32 color_text = ImGui::GetColorU32(ImGuiCol_Text);
const ImU32 color_disabled = OptGreyOutZeroes ? ImGui::GetColorU32(ImGuiCol_TextDisabled) : color_text;
for (int line_i = clipper.DisplayStart; line_i < clipper.DisplayEnd; line_i++) // display only visible lines
{
size_t addr = (size_t)(line_i * Cols);
ImGui::Text("%0*" _PRISizeT ": ", s.AddrDigitsCount, base_display_addr + addr);
// Draw Hexadecimal
for (int n = 0; n < Cols && addr < mem_size; n++, addr++)
{
float byte_pos_x = s.PosHexStart + s.HexCellWidth * n;
if (OptMidColsCount > 0)
byte_pos_x += (n / OptMidColsCount) * s.SpacingBetweenMidCols;
ImGui::SameLine(byte_pos_x);
// Draw highlight
bool is_highlight_from_user_range = (addr >= HighlightMin && addr < HighlightMax);
bool is_highlight_from_user_func = (HighlightFn && HighlightFn(mem_data, addr));
bool is_highlight_from_preview = (addr >= DataPreviewAddr && addr < DataPreviewAddr + preview_data_type_size);
if (is_highlight_from_user_range || is_highlight_from_user_func || is_highlight_from_preview)
{
ImVec2 pos = ImGui::GetCursorScreenPos();
float highlight_width = s.GlyphWidth * 2;
bool is_next_byte_highlighted = (addr + 1 < mem_size) && ((HighlightMax != (size_t)-1 && addr + 1 < HighlightMax) || (HighlightFn && HighlightFn(mem_data, addr + 1)));
if (is_next_byte_highlighted || (n + 1 == Cols))
{
highlight_width = s.HexCellWidth;
if (OptMidColsCount > 0 && n > 0 && (n + 1) < Cols && ((n + 1) % OptMidColsCount) == 0)
highlight_width += s.SpacingBetweenMidCols;
}
draw_list->AddRectFilled(pos, ImVec2(pos.x + highlight_width, pos.y + s.LineHeight), HighlightColor);
}
if (DataEditingAddr == addr)
{
// Display text input on current byte
bool data_write = false;
ImGui::PushID((void*)addr);
if (DataEditingTakeFocus)
{
ImGui::SetKeyboardFocusHere();
ImGui::CaptureKeyboardFromApp(true);
sprintf(AddrInputBuf, "%0*" _PRISizeT, s.AddrDigitsCount, base_display_addr + addr);
sprintf(DataInputBuf, "%02X", ReadFn ? ReadFn(mem_data, addr) : mem_data[addr]);
}
ImGui::PushItemWidth(s.GlyphWidth * 2);
struct UserData
{
// FIXME: We should have a way to retrieve the text edit cursor position more easily in the API, this is rather tedious. This is such a ugly mess we may be better off not using InputText() at all here.
static int Callback(ImGuiTextEditCallbackData* data)
{
UserData* user_data = (UserData*)data->UserData;
if (!data->HasSelection())
user_data->CursorPos = data->CursorPos;
if (data->SelectionStart == 0 && data->SelectionEnd == data->BufTextLen)
{
// When not editing a byte, always rewrite its content (this is a bit tricky, since InputText technically "owns" the master copy of the buffer we edit it in there)
data->DeleteChars(0, data->BufTextLen);
data->InsertChars(0, user_data->CurrentBufOverwrite);
data->SelectionStart = 0;
data->SelectionEnd = data->CursorPos = 2;
}
return 0;
}
char CurrentBufOverwrite[3]; // Input
int CursorPos; // Output
};
UserData user_data;
user_data.CursorPos = -1;
sprintf(user_data.CurrentBufOverwrite, "%02X", ReadFn ? ReadFn(mem_data, addr) : mem_data[addr]);
ImGuiInputTextFlags flags = ImGuiInputTextFlags_CharsHexadecimal | ImGuiInputTextFlags_EnterReturnsTrue | ImGuiInputTextFlags_AutoSelectAll | ImGuiInputTextFlags_NoHorizontalScroll | ImGuiInputTextFlags_AlwaysInsertMode | ImGuiInputTextFlags_CallbackAlways;
if (ImGui::InputText("##data", DataInputBuf, 32, flags, UserData::Callback, &user_data))
data_write = data_next = true;
else if (!DataEditingTakeFocus && !ImGui::IsItemActive())
DataEditingAddr = data_editing_addr_next = (size_t)-1;
DataEditingTakeFocus = false;
ImGui::PopItemWidth();
if (user_data.CursorPos >= 2)
data_write = data_next = true;
if (data_editing_addr_next != (size_t)-1)
data_write = data_next = false;
int data_input_value;
if (data_write && sscanf(DataInputBuf, "%X", &data_input_value) == 1)
{
if (WriteFn)
WriteFn(mem_data, addr, (u8)data_input_value);
else
mem_data[addr] = (u8)data_input_value;
}
ImGui::PopID();
}
else
{
// NB: The trailing space is not visible but ensure there's no gap that the mouse cannot click on.
u8 b = ReadFn ? ReadFn(mem_data, addr) : mem_data[addr];
if (OptShowHexII)
{
if ((b >= 32 && b < 128))
ImGui::Text(".%c ", b);
else if (b == 0xFF && OptGreyOutZeroes)
ImGui::TextDisabled("## ");
else if (b == 0x00)
ImGui::Text(" ");
else
ImGui::Text("%02X ", b);
}
else
{
if (b == 0 && OptGreyOutZeroes)
ImGui::TextDisabled("00 ");
else
ImGui::Text("%02X ", b);
}
if (!ReadOnly && ImGui::IsItemHovered() && ImGui::IsMouseClicked(0))
{
DataEditingTakeFocus = true;
data_editing_addr_next = addr;
}
}
}
if (OptShowAscii)
{
// Draw ASCII values
ImGui::SameLine(s.PosAsciiStart);
ImVec2 pos = ImGui::GetCursorScreenPos();
addr = line_i * Cols;
ImGui::PushID(line_i);
if (ImGui::InvisibleButton("ascii", ImVec2(s.PosAsciiEnd - s.PosAsciiStart, s.LineHeight)))
{
DataEditingAddr = DataPreviewAddr = addr + (size_t)((ImGui::GetIO().MousePos.x - pos.x) / s.GlyphWidth);
DataEditingTakeFocus = true;
}
ImGui::PopID();
for (int n = 0; n < Cols && addr < mem_size; n++, addr++)
{
if (addr == DataEditingAddr)
{
draw_list->AddRectFilled(pos, ImVec2(pos.x + s.GlyphWidth, pos.y + s.LineHeight), ImGui::GetColorU32(ImGuiCol_FrameBg));
draw_list->AddRectFilled(pos, ImVec2(pos.x + s.GlyphWidth, pos.y + s.LineHeight), ImGui::GetColorU32(ImGuiCol_TextSelectedBg));
}
unsigned char c = ReadFn ? ReadFn(mem_data, addr) : mem_data[addr];
char display_c = (c < 32 || c >= 128) ? '.' : c;
draw_list->AddText(pos, (display_c == '.') ? color_disabled : color_text, &display_c, &display_c + 1);
pos.x += s.GlyphWidth;
}
}
}
clipper.End();
ImGui::PopStyleVar(2);
ImGui::EndChild();
if (data_next && DataEditingAddr < mem_size)
{
DataEditingAddr = DataPreviewAddr = DataEditingAddr + 1;
DataEditingTakeFocus = true;
}
else if (data_editing_addr_next != (size_t)-1)
{
DataEditingAddr = DataPreviewAddr = data_editing_addr_next;
}
ImGui::Separator();
// Options menu
bool next_show_data_preview = OptShowDataPreview;
if (ImGui::Button("Options"))
ImGui::OpenPopup("context");
if (ImGui::BeginPopup("context"))
{
ImGui::PushItemWidth(56);
if (ImGui::DragInt("##cols", &Cols, 0.2f, 4, 32, "%d cols")) { ContentsWidthChanged = true; }
ImGui::PopItemWidth();
ImGui::Checkbox("Show Data Preview", &next_show_data_preview);
ImGui::Checkbox("Show HexII", &OptShowHexII);
if (ImGui::Checkbox("Show Ascii", &OptShowAscii)) { ContentsWidthChanged = true; }
ImGui::Checkbox("Grey out zeroes", &OptGreyOutZeroes);
ImGui::EndPopup();
}
ImGui::SameLine();
ImGui::Text("Range %0*" _PRISizeT "..%0*" _PRISizeT, s.AddrDigitsCount, base_display_addr, s.AddrDigitsCount, base_display_addr + mem_size - 1);
ImGui::SameLine();
ImGui::PushItemWidth((s.AddrDigitsCount + 1) * s.GlyphWidth + style.FramePadding.x * 2.0f);
if (ImGui::InputText("##addr", AddrInputBuf, 32, ImGuiInputTextFlags_CharsHexadecimal | ImGuiInputTextFlags_EnterReturnsTrue))
{
size_t goto_addr;
if (sscanf(AddrInputBuf, "%" _PRISizeT, &goto_addr) == 1)
{
GotoAddr = goto_addr - base_display_addr;
HighlightMin = HighlightMax = (size_t)-1;
}
}
ImGui::PopItemWidth();
if (GotoAddr != (size_t)-1)
{
if (GotoAddr < mem_size)
{
ImGui::BeginChild("##scrolling");
ImGui::SetScrollFromPosY(ImGui::GetCursorStartPos().y + (GotoAddr / Cols) * ImGui::GetTextLineHeight());
ImGui::EndChild();
DataEditingAddr = DataPreviewAddr = GotoAddr;
DataEditingTakeFocus = true;
}
GotoAddr = (size_t)-1;
}
if (OptShowDataPreview)
{
ImGui::Separator();
ImGui::AlignTextToFramePadding();
ImGui::Text("Preview as:");
ImGui::SameLine();
ImGui::PushItemWidth((s.GlyphWidth * 10.0f) + style.FramePadding.x * 2.0f + style.ItemInnerSpacing.x);
if (ImGui::BeginCombo("##combo_type", DataTypeGetDesc(PreviewDataType), ImGuiComboFlags_HeightLargest))
{
for (int n = 0; n < DataType_COUNT; n++)
if (ImGui::Selectable(DataTypeGetDesc((DataType)n), PreviewDataType == n))
PreviewDataType = (DataType)n;
ImGui::EndCombo();
}
ImGui::PopItemWidth();
ImGui::SameLine();
ImGui::PushItemWidth((s.GlyphWidth * 6.0f) + style.FramePadding.x * 2.0f + style.ItemInnerSpacing.x);
ImGui::Combo("##combo_endianess", &PreviewEndianess, "LE\0BE\0\0");
ImGui::PopItemWidth();
char buf[128];
float x = s.GlyphWidth * 6.0f;
bool has_value = DataPreviewAddr != (size_t)-1;
if (has_value)
DisplayPreviewData(DataPreviewAddr, mem_data, mem_size, PreviewDataType, DataFormat_Dec, buf, (size_t)IM_ARRAYSIZE(buf));
ImGui::Text("Dec"); ImGui::SameLine(x); ImGui::TextUnformatted(has_value ? buf : "N/A");
if (has_value)
DisplayPreviewData(DataPreviewAddr, mem_data, mem_size, PreviewDataType, DataFormat_Hex, buf, (size_t)IM_ARRAYSIZE(buf));
ImGui::Text("Hex"); ImGui::SameLine(x); ImGui::TextUnformatted(has_value ? buf : "N/A");
if (has_value)
DisplayPreviewData(DataPreviewAddr, mem_data, mem_size, PreviewDataType, DataFormat_Bin, buf, (size_t)IM_ARRAYSIZE(buf));
ImGui::Text("Bin"); ImGui::SameLine(x); ImGui::TextUnformatted(has_value ? buf : "N/A");
}
OptShowDataPreview = next_show_data_preview;
// Notify the main window of our ideal child content size (FIXME: we are missing an API to get the contents size from the child)
ImGui::SetCursorPosX(s.WindowWidth);
}
// Utilities for Data Preview
const char* DataTypeGetDesc(DataType data_type) const
{
const char* descs[] = { "Int8", "Uint8", "Int16", "Uint16", "Int32", "Uint32", "Int64", "Uint64", "Float", "Double" };
IM_ASSERT(data_type >= 0 && data_type < DataType_COUNT);
return descs[data_type];
}
size_t DataTypeGetSize(DataType data_type) const
{
const size_t sizes[] = { 1, 1, 2, 2, 4, 4, 8, 8, 4, 8 };
IM_ASSERT(data_type >= 0 && data_type < DataType_COUNT);
return sizes[data_type];
}
const char* DataFormatGetDesc(DataFormat data_format) const
{
const char* descs[] = { "Bin", "Dec", "Hex" };
IM_ASSERT(data_format >= 0 && data_format < DataFormat_COUNT);
return descs[data_format];
}
bool IsBigEndian() const
{
uint16_t x = 1;
char c[2];
memcpy(c, &x, 2);
return c[0] != 0;
}
static void* EndianessCopyBigEndian(void* _dst, void* _src, size_t s, int is_little_endian)
{
if (is_little_endian)
{
uint8_t* dst = (uint8_t*)_dst;
uint8_t* src = (uint8_t*)_src + s - 1;
for (int i = 0, n = (int)s; i < n; ++i)
memcpy(dst++, src--, 1);
return _dst;
}
else
{
return memcpy(_dst, _src, s);
}
}
static void* EndianessCopyLittleEndian(void* _dst, void* _src, size_t s, int is_little_endian)
{
if (is_little_endian)
{
return memcpy(_dst, _src, s);
}
else
{
uint8_t* dst = (uint8_t*)_dst;
uint8_t* src = (uint8_t*)_src + s - 1;
for (int i = 0, n = (int)s; i < n; ++i)
memcpy(dst++, src--, 1);
return _dst;
}
}
void* EndianessCopy(void *dst, void *src, size_t size) const
{
static void *(*fp)(void *, void *, size_t, int) = NULL;
if (fp == NULL)
fp = IsBigEndian() ? EndianessCopyBigEndian : EndianessCopyLittleEndian;
return fp(dst, src, size, PreviewEndianess);
}
const char* FormatBinary(const uint8_t* buf, int width) const
{
IM_ASSERT(width <= 64);
size_t out_n = 0;
static char out_buf[64 + 8 + 1];
for (int j = 0, n = width / 8; j < n; ++j)
{
for (int i = 0; i < 8; ++i)
out_buf[out_n++] = (buf[j] & (1 << (7 - i))) ? '1' : '0';
out_buf[out_n++] = ' ';
}
out_buf[out_n] = 0;
IM_ASSERT(out_n < IM_ARRAYSIZE(out_buf));
return out_buf;
}
void DisplayPreviewData(size_t addr, const u8* mem_data, size_t mem_size, DataType data_type, DataFormat data_format, char* out_buf, size_t out_buf_size) const
{
uint8_t buf[8];
int elem_size = DataTypeGetSize(data_type);
size_t size = addr + elem_size > mem_size ? mem_size - addr : elem_size;
if (ReadFn)
for (int i = 0, n = (int)size; i < n; ++i)
buf[i] = ReadFn(mem_data, addr + i);
else
memcpy(buf, mem_data + addr, size);
if (data_format == DataFormat_Bin)
{
snprintf(out_buf, out_buf_size, "%s", FormatBinary(buf, size * 8));
return;
}
out_buf[0] = 0;
switch (data_type)
{
case DataType_S8:
{
int8_t int8 = 0;
EndianessCopy(&int8, buf, size);
if (data_format == DataFormat_Dec) { snprintf(out_buf, out_buf_size, "%hhd", int8); return; }
if (data_format == DataFormat_Hex) { snprintf(out_buf, out_buf_size, "0x%02x", int8 & 0xFF); return; }
break;
}
case DataType_U8:
{
uint8_t uint8 = 0;
EndianessCopy(&uint8, buf, size);
if (data_format == DataFormat_Dec) { snprintf(out_buf, out_buf_size, "%hhu", uint8); return; }
if (data_format == DataFormat_Hex) { snprintf(out_buf, out_buf_size, "0x%02x", uint8 & 0XFF); return; }
break;
}
case DataType_S16:
{
int16_t int16 = 0;
EndianessCopy(&int16, buf, size);
if (data_format == DataFormat_Dec) { snprintf(out_buf, out_buf_size, "%hd", int16); return; }
if (data_format == DataFormat_Hex) { snprintf(out_buf, out_buf_size, "0x%04x", int16 & 0xFFFF); return; }
break;
}
case DataType_U16:
{
uint16_t uint16 = 0;
EndianessCopy(&uint16, buf, size);
if (data_format == DataFormat_Dec) { snprintf(out_buf, out_buf_size, "%hu", uint16); return; }
if (data_format == DataFormat_Hex) { snprintf(out_buf, out_buf_size, "0x%04x", uint16 & 0xFFFF); return; }
break;
}
case DataType_S32:
{
int32_t int32 = 0;
EndianessCopy(&int32, buf, size);
if (data_format == DataFormat_Dec) { snprintf(out_buf, out_buf_size, "%d", int32); return; }
if (data_format == DataFormat_Hex) { snprintf(out_buf, out_buf_size, "0x%08x", int32); return; }
break;
}
case DataType_U32:
{
uint32_t uint32 = 0;
EndianessCopy(&uint32, buf, size);
if (data_format == DataFormat_Dec) { snprintf(out_buf, out_buf_size, "%u", uint32); return; }
if (data_format == DataFormat_Hex) { snprintf(out_buf, out_buf_size, "0x%08x", uint32); return; }
break;
}
case DataType_S64:
{
int64_t int64 = 0;
EndianessCopy(&int64, buf, size);
if (data_format == DataFormat_Dec) { snprintf(out_buf, out_buf_size, "%lld", (long long)int64); return; }
if (data_format == DataFormat_Hex) { snprintf(out_buf, out_buf_size, "0x%016llx", (long long)int64); return; }
break;
}
case DataType_U64:
{
uint64_t uint64 = 0;
EndianessCopy(&uint64, buf, size);
if (data_format == DataFormat_Dec) { snprintf(out_buf, out_buf_size, "%llu", (long long)uint64); return; }
if (data_format == DataFormat_Hex) { snprintf(out_buf, out_buf_size, "0x%016llx", (long long)uint64); return; }
break;
}
case DataType_Float:
{
float float32 = 0.0f;
EndianessCopy(&float32, buf, size);
if (data_format == DataFormat_Dec) { snprintf(out_buf, out_buf_size, "%f", float32); return; }
if (data_format == DataFormat_Hex) { snprintf(out_buf, out_buf_size, "%a", float32); return; }
break;
}
case DataType_Double:
{
double float64 = 0.0;
EndianessCopy(&float64, buf, size);
if (data_format == DataFormat_Dec) { snprintf(out_buf, out_buf_size, "%f", float64); return; }
if (data_format == DataFormat_Hex) { snprintf(out_buf, out_buf_size, "%a", float64); return; }
break;
}
} // Switch
IM_ASSERT(0); // Shouldn't reach
}
};
#undef _PRISizeT

12
src/intel/tools/meson.build
View file

@ -108,4 +108,16 @@ libintel_dump_gpu = shared_library(
if with_tools.contains('intel-ui') if with_tools.contains('intel-ui')
subdir('imgui') subdir('imgui')
aubinator_viewer = executable(
'aubinator_viewer',
files('aubinator_viewer.cpp', 'aubinator_viewer_decoder.cpp'),
dependencies : [dep_zlib, dep_dl, dep_thread, dep_m, libintel_imgui_gtk_dep],
include_directories : [inc_common, inc_intel],
link_with : [libintel_common, libintel_compiler, libintel_dev, libmesa_util, libaub],
c_args : [c_vis_args, no_override_init_args],
cpp_args : [ '-fpermissive', '-std=c++11', '-Wno-parentheses', '-Wno-class-memaccess' ],
build_by_default : true,
install : true
)
endif endif