diff options
| -rw-r--r-- | src/intel/Makefile.am | 4 | ||||
| -rw-r--r-- | src/intel/tools/aubinator_viewer.cpp | 1137 | ||||
| -rw-r--r-- | src/intel/tools/aubinator_viewer.h | 71 | ||||
| -rw-r--r-- | src/intel/tools/aubinator_viewer_decoder.cpp | 860 | ||||
| -rw-r--r-- | src/intel/tools/imgui/imgui_memory_editor.h | 704 | ||||
| -rw-r--r-- | src/intel/tools/meson.build | 12 |
6 files changed, 2788 insertions, 0 deletions
diff --git a/src/intel/Makefile.am b/src/intel/Makefile.am index f585221ac9d..cc43669d6be 100644 --- a/src/intel/Makefile.am +++ b/src/intel/Makefile.am @@ -69,6 +69,9 @@ EXTRA_DIST = \ dev/meson.build \ genxml/meson.build \ isl/meson.build \ + tools/aubinator_viewer.cpp \ + tools/aubinator_viewer.h \ + tools/aubinator_viewer_decoder.cpp \ tools/imgui/README \ tools/imgui/stb_textedit.h \ tools/imgui/meson.build \ @@ -82,6 +85,7 @@ EXTRA_DIST = \ tools/imgui/imgui_impl_gtk3.h \ tools/imgui/imgui_impl_opengl3.cpp \ tools/imgui/imgui_impl_opengl3.h \ + tools/imgui/imgui_memory_editor.h \ tools/imgui/stb_truetype.h \ tools/imgui/stb_rect_pack.h \ tools/imgui/LICENSE.txt \ diff --git a/src/intel/tools/aubinator_viewer.cpp b/src/intel/tools/aubinator_viewer.cpp new file mode 100644 index 00000000000..7ef56aa035f --- /dev/null +++ b/src/intel/tools/aubinator_viewer.cpp @@ -0,0 +1,1137 @@ +/* + * Copyright © 2016 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 <stdio.h> +#include <stdlib.h> +#include <stdint.h> +#include <getopt.h> +#include <unistd.h> +#include <fcntl.h> +#include <string.h> +#include <errno.h> +#include <sys/stat.h> +#include <sys/mman.h> +#include <sys/types.h> +#include <ctype.h> + +#include "util/macros.h" + +#include "aub_read.h" +#include "aub_mem.h" + +#include "common/gen_disasm.h" + +#define xtzalloc(name) ((decltype(&name)) calloc(1, sizeof(name))) +#define xtalloc(name) ((decltype(&name)) malloc(sizeof(name))) + +struct aub_file { + uint8_t *map, *end, *cursor; + + uint16_t pci_id; + char app_name[33]; + + /* List of batch buffers to process */ + struct { + const uint8_t *start; + const uint8_t *end; + } *execs; + int n_execs; + int n_allocated_execs; + + uint32_t idx_reg_write; + + /* Device state */ + struct gen_device_info devinfo; + struct gen_spec *spec; + struct gen_disasm *disasm; +}; + +static void +store_exec_begin(struct aub_file *file) +{ + if (unlikely(file->n_execs >= file->n_allocated_execs)) { + file->n_allocated_execs = MAX2(2U * file->n_allocated_execs, + 4096 / sizeof(file->execs[0])); + file->execs = (decltype(file->execs)) + realloc(static_cast<void *>(file->execs), + file->n_allocated_execs * sizeof(file->execs[0])); + } + + file->execs[file->n_execs++].start = file->cursor; +} + +static void +store_exec_end(struct aub_file *file) +{ + if (file->n_execs > 0 && file->execs[file->n_execs - 1].end == NULL) + file->execs[file->n_execs - 1].end = file->cursor; +} + +static void +handle_mem_write(void *user_data, uint64_t phys_addr, + const void *data, uint32_t data_len) +{ + struct aub_file *file = (struct aub_file *) user_data; + file->idx_reg_write = 0; + store_exec_end(file); +} + +static void +handle_ring_write(void *user_data, enum gen_engine engine, + const void *ring_data, uint32_t ring_data_len) +{ + struct aub_file *file = (struct aub_file *) user_data; + file->idx_reg_write = 0; + store_exec_begin(file); +} + +static void +handle_reg_write(void *user_data, uint32_t reg_offset, uint32_t reg_value) +{ + struct aub_file *file = (struct aub_file *) user_data; + + /* Only store the first register write of a series (execlist writes take + * involve 2 dwords). + */ + if (file->idx_reg_write++ == 0) + store_exec_begin(file); +} + +static void +handle_info(void *user_data, int pci_id, const char *app_name) +{ + struct aub_file *file = (struct aub_file *) user_data; + store_exec_end(file); + + file->pci_id = pci_id; + snprintf(file->app_name, sizeof(app_name), "%s", app_name); + + if (!gen_get_device_info(file->pci_id, &file->devinfo)) { + fprintf(stderr, "can't find device information: pci_id=0x%x\n", file->pci_id); + exit(EXIT_FAILURE); + } + file->spec = gen_spec_load(&file->devinfo); + file->disasm = gen_disasm_create(&file->devinfo); +} + +static void +handle_error(void *user_data, const void *aub_data, const char *msg) +{ + fprintf(stderr, "ERROR: %s\n", msg); +} + +static struct aub_file * +aub_file_open(const char *filename) +{ + struct aub_file *file; + struct stat sb; + int fd; + + file = xtzalloc(*file); + fd = open(filename, O_RDWR); + if (fd == -1) { + fprintf(stderr, "open %s failed: %s\n", filename, strerror(errno)); + exit(EXIT_FAILURE); + } + + if (fstat(fd, &sb) == -1) { + fprintf(stderr, "stat failed: %s\n", strerror(errno)); + exit(EXIT_FAILURE); + } + + file->map = (uint8_t *) mmap(NULL, sb.st_size, + PROT_READ, MAP_SHARED, fd, 0); + if (file->map == MAP_FAILED) { + fprintf(stderr, "mmap failed: %s\n", strerror(errno)); + exit(EXIT_FAILURE); + } + + close(fd); + + file->cursor = file->map; + file->end = file->map + sb.st_size; + + struct aub_read aub_read = {}; + aub_read.user_data = file; + aub_read.info = handle_info; + aub_read.error = handle_error; + aub_read.reg_write = handle_reg_write; + aub_read.ring_write = handle_ring_write; + aub_read.local_write = handle_mem_write; + aub_read.phys_write = handle_mem_write; + aub_read.ggtt_write = handle_mem_write; + aub_read.ggtt_entry_write = handle_mem_write; + + int consumed; + while (file->cursor < file->end && + (consumed = aub_read_command(&aub_read, file->cursor, + file->end - file->cursor)) > 0) { + file->cursor += consumed; + } + + /* Ensure we have an end on the last register write. */ + if (file->n_execs > 0 && file->execs[file->n_execs - 1].end == NULL) + file->execs[file->n_execs - 1].end = file->end; + + return file; +} + +/**/ + +static void +update_mem_for_exec(struct aub_mem *mem, struct aub_file *file, int exec_idx) +{ + struct aub_read read = {}; + read.user_data = mem; + read.local_write = aub_mem_local_write; + read.phys_write = aub_mem_phys_write; + read.ggtt_write = aub_mem_ggtt_write; + read.ggtt_entry_write = aub_mem_ggtt_entry_write; + + /* Replay the aub file from the beginning up to just before the + * commands we want to read. where the context setup happens. + */ + const uint8_t *iter = file->map; + while (iter < file->execs[exec_idx].start) { + iter += aub_read_command(&read, iter, file->execs[exec_idx].start - iter); + } +} + +/* UI */ + +#include <epoxy/gl.h> + +#include "imgui.h" +#include "imgui_impl_gtk3.h" +#include "imgui_impl_opengl3.h" + +#include "aubinator_viewer.h" +#include "imgui_memory_editor.h" + +struct window { + struct list_head link; /* link in the global list of windows */ + struct list_head parent_link; /* link in parent window list of children */ + + struct list_head children_windows; /* list of children windows */ + + char name[128]; + bool opened; + + ImVec2 position; + ImVec2 size; + + void (*display)(struct window*); + void (*destroy)(struct window*); +}; + +struct edit_window { + struct window base; + + struct aub_mem *mem; + uint64_t address; + uint32_t len; + + struct gen_batch_decode_bo aub_bo; + uint64_t aub_offset; + + struct gen_batch_decode_bo gtt_bo; + uint64_t gtt_offset; + + struct MemoryEditor editor; +}; + +struct pml4_window { + struct window base; + + struct aub_mem *mem; +}; + +struct shader_window { + struct window base; + + uint64_t address; + char *shader; + size_t shader_size; +}; + +struct batch_window { + struct window base; + + struct aub_mem mem; + struct aub_read read; + + bool uses_ppgtt; + + bool collapsed; + int exec_idx; + + struct aub_viewer_decode_cfg decode_cfg; + struct aub_viewer_decode_ctx decode_ctx; + + struct pml4_window pml4_window; + + char edit_address[20]; +}; + +static struct Context { + struct aub_file *file; + char *input_file; + char *xml_path; + + GtkWidget *gtk_window; + + /* UI state*/ + bool show_commands_window; + bool show_registers_window; + + struct aub_viewer_cfg cfg; + + struct list_head windows; + + struct window file_window; + struct window commands_window; + struct window registers_window; +} context; + +static int +map_key(int k) +{ + return ImGuiKey_COUNT + k; +} + +static bool +has_ctrl_key(int key) +{ + return ImGui::GetIO().KeyCtrl && ImGui::IsKeyPressed(map_key(key)); +} + +static bool +window_has_ctrl_key(int key) +{ + return ImGui::IsRootWindowOrAnyChildFocused() && has_ctrl_key(key); +} + +static void +destroy_window_noop(struct window *win) +{ +} + +/* Shader windows */ + +static void +display_shader_window(struct window *win) +{ + struct shader_window *window = (struct shader_window *) win; + + if (window->shader) { + ImGui::InputTextMultiline("Assembly", + window->shader, window->shader_size, + ImGui::GetContentRegionAvail(), + ImGuiInputTextFlags_ReadOnly); + } else { + ImGui::Text("Shader not available"); + } +} + +static void +destroy_shader_window(struct window *win) +{ + struct shader_window *window = (struct shader_window *) win; + + free(window->shader); + free(window); +} + +static struct shader_window * +new_shader_window(struct aub_mem *mem, uint64_t address, const char *desc) +{ + struct shader_window *window = xtzalloc(*window); + + snprintf(window->base.name, sizeof(window->base.name), + "%s (0x%lx)##%p", desc, address, window); + + list_inithead(&window->base.parent_link); + window->base.position = ImVec2(-1, -1); + window->base.size = ImVec2(700, 300); + window->base.opened = true; + window->base.display = display_shader_window; + window->base.destroy = destroy_shader_window; + + struct gen_batch_decode_bo shader_bo; + if (mem->pml4) + shader_bo = aub_mem_get_ppgtt_bo(mem, address); + else + shader_bo = aub_mem_get_ggtt_bo(mem, address); + + if (shader_bo.map) { + FILE *f = open_memstream(&window->shader, &window->shader_size); + if (f) { + gen_disasm_disassemble(context.file->disasm, shader_bo.map, 0, f); + fclose(f); + } + } + + list_addtail(&window->base.link, &context.windows); + + return window; +} + +/* Memory editor windows */ + +static uint8_t +read_edit_window(const uint8_t *data, size_t off) +{ + struct edit_window *window = (struct edit_window *) data; + + return *((const uint8_t *) window->gtt_bo.map + window->gtt_offset + off); +} + +static void +write_edit_window(uint8_t *data, size_t off, uint8_t d) +{ + struct edit_window *window = (struct edit_window *) data; + uint8_t *gtt = (uint8_t *) window->gtt_bo.map + window->gtt_offset + off; + uint8_t *aub = (uint8_t *) window->aub_bo.map + window->aub_offset + off; + + *gtt = *aub = d; +} + +static void +display_edit_window(struct window *win) +{ + struct edit_window *window = (struct edit_window *) win; + + if (window->aub_bo.map && window->gtt_bo.map) { + ImGui::BeginChild(ImGui::GetID("##block")); + window->editor.DrawContents((uint8_t *) window, + MIN3(window->len, + window->gtt_bo.size - window->gtt_offset, + window->aub_bo.size - window->aub_offset), + window->address); + ImGui::EndChild(); + } else { + ImGui::Text("Memory view at 0x%lx not available", window->address); + } +} + +static void +destroy_edit_window(struct window *win) +{ + struct edit_window *window = (struct edit_window *) win; + + if (window->aub_bo.map) + mprotect((void *) window->aub_bo.map, 4096, PROT_READ); + free(window); +} + +static struct edit_window * +new_edit_window(struct aub_mem *mem, uint64_t address, uint32_t len) +{ + struct edit_window *window = xtzalloc(*window); + + snprintf(window->base.name, sizeof(window->base.name), + "Editing aub at 0x%lx##%p", address, window); + + list_inithead(&window->base.parent_link); + window->base.position = ImVec2(-1, -1); + window->base.size = ImVec2(500, 600); + window->base.opened = true; + window->base.display = display_edit_window; + window->base.destroy = destroy_edit_window; + + window->mem = mem; + window->address = address; + window->aub_bo = aub_mem_get_ppgtt_addr_aub_data(mem, address); + window->gtt_bo = aub_mem_get_ppgtt_addr_data(mem, address); + window->len = len; + window->editor = MemoryEditor(); + window->editor.OptShowDataPreview = true; + window->editor.OptShowAscii = false; + window->editor.ReadFn = read_edit_window; + window->editor.WriteFn = write_edit_window; + + if (window->aub_bo.map) { + uint64_t unaligned_map = (uint64_t) window->aub_bo.map; + window->aub_bo.map = (const void *)(unaligned_map & ~0xffful); + window->aub_offset = unaligned_map - (uint64_t) window->aub_bo.map; + + if (mprotect((void *) window->aub_bo.map, window->aub_bo.size, PROT_READ | PROT_WRITE) != 0) { + window->aub_bo.map = NULL; + } + } + + window->gtt_offset = address - window->gtt_bo.addr; + + list_addtail(&window->base.link, &context.windows); + + return window; +} + +/* 4 level page table walk windows */ + +static void +display_pml4_level(struct aub_mem *mem, uint64_t table_addr, uint64_t table_virt_addr, int level) +{ + if (level == 0) + return; + + struct gen_batch_decode_bo table_bo = + aub_mem_get_phys_addr_data(mem, table_addr); + const uint64_t *table = (const uint64_t *) ((const uint8_t *) table_bo.map + + table_addr - table_bo.addr); + if (!table) { + ImGui::TextColored(context.cfg.missing_color, "Page not available"); + return; + } + + uint64_t addr_increment = 1ULL << (12 + 9 * (level - 1)); + + if (level == 1) { + for (int e = 0; e < 512; e++) { + bool available = (table[e] & 1) != 0; + uint64_t entry_virt_addr = table_virt_addr + e * addr_increment; + if (!available) + continue; + ImGui::Text("Entry%03i - phys_addr=0x%lx - virt_addr=0x%lx", + e, table[e], entry_virt_addr); + } + } else { + for (int e = 0; e < 512; e++) { + bool available = (table[e] & 1) != 0; + uint64_t entry_virt_addr = table_virt_addr + e * addr_increment; + if (available && + ImGui::TreeNodeEx(&table[e], + available ? ImGuiTreeNodeFlags_Framed : 0, + "Entry%03i - phys_addr=0x%lx - virt_addr=0x%lx", + e, table[e], entry_virt_addr)) { + display_pml4_level(mem, table[e] & ~0xffful, entry_virt_addr, level -1); + ImGui::TreePop(); + } + } + } +} + +static void +display_pml4_window(struct window *win) +{ + struct pml4_window *window = (struct pml4_window *) win; + + ImGui::Text("pml4: %lx", window->mem->pml4); + ImGui::BeginChild(ImGui::GetID("##block")); + display_pml4_level(window->mem, window->mem->pml4, 0, 4); + ImGui::EndChild(); +} + +static void +show_pml4_window(struct pml4_window *window, struct aub_mem *mem) +{ + if (window->base.opened) { + window->base.opened = false; + return; + } + + snprintf(window->base.name, sizeof(window->base.name), + "4-Level page tables##%p", window); + + list_inithead(&window->base.parent_link); + window->base.position = ImVec2(-1, -1); + window->base.size = ImVec2(500, 600); + window->base.opened = true; + window->base.display = display_pml4_window; + window->base.destroy = destroy_window_noop; + + window->mem = mem; + + list_addtail(&window->base.link, &context.windows); +} + +/* Batch decoding windows */ + +static void +display_decode_options(struct aub_viewer_decode_cfg *cfg) +{ + char name[40]; + snprintf(name, sizeof(name), "command filter##%p", &cfg->command_filter); + cfg->command_filter.Draw(name); ImGui::SameLine(); + snprintf(name, sizeof(name), "field filter##%p", &cfg->field_filter); + cfg->field_filter.Draw(name); ImGui::SameLine(); + if (ImGui::Button("Dwords")) cfg->show_dwords ^= 1; +} + +static void +batch_display_shader(void *user_data, const char *shader_desc, uint64_t address) +{ + struct batch_window *window = (struct batch_window *) user_data; + struct shader_window *shader_window = + new_shader_window(&window->mem, address, shader_desc); + + list_add(&shader_window->base.parent_link, &window->base.children_windows); +} + +static void +batch_edit_address(void *user_data, uint64_t address, uint32_t len) +{ + struct batch_window *window = (struct batch_window *) user_data; + struct edit_window *edit_window = + new_edit_window(&window->mem, address, len); + + list_add(&edit_window->base.parent_link, &window->base.children_windows); +} + +static struct gen_batch_decode_bo +batch_get_bo(void *user_data, uint64_t address) +{ + struct batch_window *window = (struct batch_window *) user_data; + + if (window->uses_ppgtt) + return aub_mem_get_ppgtt_bo(&window->mem, address); + else + return aub_mem_get_ggtt_bo(&window->mem, address); +} + +static void +update_batch_window(struct batch_window *window, bool reset, int exec_idx) +{ + if (reset) + aub_mem_fini(&window->mem); + aub_mem_init(&window->mem); + + window->exec_idx = MAX2(MIN2(context.file->n_execs - 1, exec_idx), 0); + update_mem_for_exec(&window->mem, context.file, window->exec_idx); +} + +static void +display_batch_ring_write(void *user_data, enum gen_engine engine, + const void *data, uint32_t data_len) +{ + struct batch_window *window = (struct batch_window *) user_data; + + window->uses_ppgtt = false; + + aub_viewer_render_batch(&window->decode_ctx, data, data_len, 0); +} + +static void +display_batch_execlist_write(void *user_data, enum gen_engine engine, + uint64_t context_descriptor) +{ + struct batch_window *window = (struct batch_window *) user_data; + + const uint32_t pphwsp_size = 4096; + uint32_t pphwsp_addr = context_descriptor & 0xfffff000; + struct gen_batch_decode_bo pphwsp_bo = + aub_mem_get_ggtt_bo(&window->mem, pphwsp_addr); + uint32_t *context_img = (uint32_t *)((uint8_t *)pphwsp_bo.map + + (pphwsp_addr - pphwsp_bo.addr) + + pphwsp_size); + + uint32_t ring_buffer_head = context_img[5]; + uint32_t ring_buffer_tail = context_img[7]; + uint32_t ring_buffer_start = context_img[9]; + + window->mem.pml4 = (uint64_t)context_img[49] << 32 | context_img[51]; + + struct gen_batch_decode_bo ring_bo = + aub_mem_get_ggtt_bo(&window->mem, ring_buffer_start); + assert(ring_bo.size > 0); + void *commands = (uint8_t *)ring_bo.map + (ring_buffer_start - ring_bo.addr); + + window->uses_ppgtt = true; + + aub_viewer_render_batch(&window->decode_ctx, commands, + ring_buffer_tail - ring_buffer_head, + ring_buffer_start); +} + +static void +display_batch_window(struct window *win) +{ + struct batch_window *window = (struct batch_window *) win; + + ImGui::PushItemWidth(ImGui::GetContentRegionAvailWidth() / (2 * 2)); + if (window_has_ctrl_key('f')) ImGui::SetKeyboardFocusHere(); + display_decode_options(&window->decode_cfg); + ImGui::PopItemWidth(); + + if (ImGui::InputInt("Execbuf", &window->exec_idx)) + update_batch_window(window, true, window->exec_idx); + + if (window_has_ctrl_key('p')) + update_batch_window(window, true, window->exec_idx - 1); + if (window_has_ctrl_key('n')) + update_batch_window(window, true, window->exec_idx + 1); + + ImGui::Text("execbuf %i", window->exec_idx); + if (ImGui::Button("Show PPGTT")) { show_pml4_window(&window->pml4_window, &window->mem); } + + ImGui::BeginChild(ImGui::GetID("##block")); + + struct aub_read read = {}; + read.user_data = window; + read.ring_write = display_batch_ring_write; + read.execlist_write = display_batch_execlist_write; + + const uint8_t *iter = context.file->execs[window->exec_idx].start; + while (iter < context.file->execs[window->exec_idx].end) { + iter += aub_read_command(&read, iter, + context.file->execs[window->exec_idx].end - iter); + } + + ImGui::EndChild(); +} + +static void +destroy_batch_window(struct window *win) +{ + struct batch_window *window = (struct batch_window *) win; + + aub_mem_fini(&window->mem); + + /* This works because children windows are inserted at the back of the + * list, ensuring the deletion loop goes through the children after calling + * this function. + */ + list_for_each_entry(struct window, child_window, + &window->base.children_windows, parent_link) + child_window->opened = false; + window->pml4_window.base.opened = false; + + free(window); +} + +static void +new_batch_window(int exec_idx) +{ + struct batch_window *window = xtzalloc(*window); + + snprintf(window->base.name, sizeof(window->base.name), + "Batch view##%p", window); + + list_inithead(&window->base.parent_link); + list_inithead(&window->base.children_windows); + window->base.position = ImVec2(-1, -1); + window->base.size = ImVec2(600, 700); + window->base.opened = true; + window->base.display = display_batch_window; + window->base.destroy = destroy_batch_window; + + window->collapsed = true; + window->decode_cfg = aub_viewer_decode_cfg(); + + aub_viewer_decode_ctx_init(&window->decode_ctx, + &context.cfg, + &window->decode_cfg, + context.file->spec, + context.file->disasm, + batch_get_bo, + NULL, + window); + window->decode_ctx.display_shader = batch_display_shader; + window->decode_ctx.edit_address = batch_edit_address; + + update_batch_window(window, false, exec_idx); + + list_addtail(&window->base.link, &context.windows); +} + +/**/ + +static void +display_registers_window(struct window *win) +{ + static struct ImGuiTextFilter filter; + if (window_has_ctrl_key('f')) ImGui::SetKeyboardFocusHere(); + filter.Draw(); + + ImGui::BeginChild(ImGui::GetID("##block")); + struct hash_entry *entry; + hash_table_foreach(context.file->spec->registers_by_name, entry) { + struct gen_group *reg = (struct gen_group *) entry->data; + if (filter.PassFilter(reg->name) && + ImGui::CollapsingHeader(reg->name)) { + const struct gen_field *field = reg->fields; + while (field) { + ImGui::Text("%s : %i -> %i\n", field->name, field->start, field->end); + field = field->next; + } + } + } + ImGui::EndChild(); +} + +static void +show_register_window(void) +{ + struct window *window = &context.registers_window; + + if (window->opened) { + window->opened = false; + return; + } + + snprintf(window->name, sizeof(window->name), "Registers"); + + list_inithead(&window->parent_link); + window->position = ImVec2(-1, -1); + window->size = ImVec2(200, 400); + window->opened = true; + window->display = display_registers_window; + window->destroy = destroy_window_noop; + + list_addtail(&window->link, &context.windows); +} + +static void +display_commands_window(struct window *win) +{ + static struct ImGuiTextFilter cmd_filter; + if (window_has_ctrl_key('f')) ImGui::SetKeyboardFocusHere(); + cmd_filter.Draw("name filter"); + static struct ImGuiTextFilter field_filter; + field_filter.Draw("field filter"); + + static char opcode_str[9] = { 0, }; + ImGui::InputText("opcode filter", opcode_str, sizeof(opcode_str), + ImGuiInputTextFlags_CharsHexadecimal); + size_t opcode_len = strlen(opcode_str); + uint64_t opcode = strtol(opcode_str, NULL, 16); + + static bool show_dwords = true; + if (ImGui::Button("Dwords")) show_dwords ^= 1; + + ImGui::BeginChild(ImGui::GetID("##block")); + struct hash_entry *entry; + hash_table_foreach(context.file->spec->commands, entry) { + struct gen_group *cmd = (struct gen_group *) entry->data; + if ((cmd_filter.PassFilter(cmd->name) && + (opcode_len == 0 || (opcode & cmd->opcode_mask) == cmd->opcode)) && + ImGui::CollapsingHeader(cmd->name)) { + const struct gen_field *field = cmd->fields; + int32_t last_dword = -1; + while (field) { + if (show_dwords && field->start / 32 != last_dword) { + for (last_dword = MAX2(0, last_dword + 1); + last_dword < field->start / 32; last_dword++) { + ImGui::TextColored(context.cfg.dwords_color, + "Dword %d", last_dword); + } + ImGui::TextColored(context.cfg.dwords_color, "Dword %d", last_dword); + } + if (field_filter.PassFilter(field->name)) + ImGui::Text("%s : %i -> %i\n", field->name, field->start, field->end); + field = field->next; + } + } + } + hash_table_foreach(context.file->spec->structs, entry) { + struct gen_group *cmd = (struct gen_group *) entry->data; + if (cmd_filter.PassFilter(cmd->name) && opcode_len == 0 && + ImGui::CollapsingHeader(cmd->name)) { + const struct gen_field *field = cmd->fields; + int32_t last_dword = -1; + while (field) { + if (show_dwords && field->start / 32 != last_dword) { + last_dword = field->start / 32; + ImGui::TextColored(context.cfg.dwords_color, + "Dword %d", last_dword); + } + if (field_filter.PassFilter(field->name)) + ImGui::Text("%s : %i -> %i\n", field->name, field->start, field->end); + field = field->next; + } + } + } + ImGui::EndChild(); +} + +static void +show_commands_window(void) +{ + struct window *window = &context.commands_window; + + if (window->opened) { + window->opened = false; + return; + } + + snprintf(window->name, sizeof(window->name), "Commands & structs"); + + list_inithead(&window->parent_link); + window->position = ImVec2(-1, -1); + window->size = ImVec2(300, 400); + window->opened = true; + window->display = display_commands_window; + window->destroy = destroy_window_noop; + + list_addtail(&window->link, &context.windows); +} + +/* Main window */ + +static const char * +human_size(size_t size) +{ + unsigned divisions = 0; + double v = size; + double divider = 1024; + while (v >= divider) { + v /= divider; + divisions++; + } + + static const char *units[] = { "Bytes", "Kilobytes", "Megabytes", "Gigabytes" }; + static char result[20]; + snprintf(result, sizeof(result), "%.2f %s", + v, divisions >= ARRAY_SIZE(units) ? "Too much!" : units[divisions]); + return result; +} + +static void +display_aubfile_window(struct window *win) +{ + ImGuiColorEditFlags cflags = (ImGuiColorEditFlags_NoAlpha | + ImGuiColorEditFlags_NoLabel | + ImGuiColorEditFlags_NoInputs); + struct aub_viewer_cfg *cfg = &context.cfg; + + ImGui::ColorEdit3("background", (float *)&cfg->clear_color, cflags); ImGui::SameLine(); + ImGui::ColorEdit3("missing", (float *)&cfg->missing_color, cflags); ImGui::SameLine(); + ImGui::ColorEdit3("error", (float *)&cfg->error_color, cflags); ImGui::SameLine(); + ImGui::ColorEdit3("highlight", (float *)&cfg->highlight_color, cflags); ImGui::SameLine(); + ImGui::ColorEdit3("dwords", (float *)&cfg->dwords_color, cflags); ImGui::SameLine(); + + if (ImGui::Button("Commands list") || has_ctrl_key('c')) { show_commands_window(); } ImGui::SameLine(); + if (ImGui::Button("Registers list") || has_ctrl_key('r')) { show_register_window(); } ImGui::SameLine(); + if (ImGui::Button("Help") || has_ctrl_key('h')) { ImGui::OpenPopup("Help"); } + + if (ImGui::Button("New batch window") || has_ctrl_key('b')) { new_batch_window(0); } + + ImGui::Text("File name: %s", context.input_file); + ImGui::Text("File size: %s", human_size(context.file->end - context.file->map)); + ImGui::Text("Execbufs %u", context.file->n_execs); + ImGui::Text("PCI ID: 0x%x", context.file->pci_id); + ImGui::Text("Application name: %s", context.file->app_name); + ImGui::Text(gen_get_device_name(context.file->pci_id)); + + ImGui::SetNextWindowContentWidth(500); + if (ImGui::BeginPopupModal("Help", NULL, ImGuiWindowFlags_AlwaysAutoResize)) { + ImGui::Text("Some global keybindings:"); + ImGui::Separator(); + + static const char *texts[] = { + "Ctrl-h", "show this screen", + "Ctrl-c", "show commands list", + "Ctrl-r", "show registers list", + "Ctrl-b", "new batch window", + "Ctrl-p/n", "switch to previous/next batch buffer", + "Ctrl-Tab", "switch focus between window", + "Ctrl-left/right", "align window to the side of the screen", + }; + float align = 0.0f; + for (uint32_t i = 0; i < ARRAY_SIZE(texts); i += 2) + align = MAX2(align, ImGui::CalcTextSize(texts[i]).x); + align += ImGui::GetStyle().WindowPadding.x + 10; + + for (uint32_t i = 0; i < ARRAY_SIZE(texts); i += 2) { + ImGui::Text(texts[i]); ImGui::SameLine(align); ImGui::Text(texts[i + 1]); + } + + if (ImGui::Button("Done") || ImGui::IsKeyPressed(ImGuiKey_Escape)) + ImGui::CloseCurrentPopup(); + ImGui::EndPopup(); + } +} + +static void +show_aubfile_window(void) +{ + struct window *window = &context.file_window; + + if (window->opened) + return; + + snprintf(window->name, sizeof(window->name), + "Aubinator Viewer: Intel AUB file decoder/editor"); + + list_inithead(&window->parent_link); + window->size = ImVec2(-1, 250); + window->position = + ImVec2(0, ImGui::GetIO().DisplaySize.y - window->size.y); + window->opened = true; + window->display = display_aubfile_window; + window->destroy = NULL; + + list_addtail(&window->link, &context.windows); +} + +/* Main redrawing */ + +static void +display_windows(void) +{ + /* Start by disposing closed windows, we don't want to destroy windows that + * have already been scheduled to be painted. So destroy always happens on + * the next draw cycle, prior to any drawing. + */ + list_for_each_entry_safe(struct window, window, &context.windows, link) { + if (window->opened) + continue; + + /* Can't close this one. */ + if (window == &context.file_window) { + window->opened = true; + continue; + } + + list_del(&window->link); + list_del(&window->parent_link); + if (window->destroy) + window->destroy(window); + } + + list_for_each_entry(struct window, window, &context.windows, link) { + ImGui::SetNextWindowPos(window->position, ImGuiCond_FirstUseEver); + ImGui::SetNextWindowSize(window->size, ImGuiCond_FirstUseEver); + if (ImGui::Begin(window->name, &window->opened)) { + window->display(window); + window->position = ImGui::GetWindowPos(); + window->size = ImGui::GetWindowSize(); + } + if (window_has_ctrl_key('w')) + window->opened = false; + ImGui::End(); + } +} + +static void +repaint_area(GtkGLArea *area, GdkGLContext *gdk_gl_context) +{ + ImGui_ImplOpenGL3_NewFrame(); + ImGui_ImplGtk3_NewFrame(); + ImGui::NewFrame(); + + display_windows(); + + ImGui::EndFrame(); + ImGui::Render(); + + glClearColor(context.cfg.clear_color.Value.x, + context.cfg.clear_color.Value.y, + context.cfg.clear_color.Value.z, 1.0); + glClear(GL_COLOR_BUFFER_BIT); + ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData()); +} + +static void +realize_area(GtkGLArea *area) +{ + ImGui::CreateContext(); + ImGui_ImplGtk3_Init(GTK_WIDGET(area), true); + ImGui_ImplOpenGL3_Init("#version 130"); + + list_inithead(&context.windows); + + ImGui::StyleColorsDark(); + context.cfg = aub_viewer_cfg(); + + ImGuiIO& io = ImGui::GetIO(); + io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; +} + +static void +unrealize_area(GtkGLArea *area) +{ + gtk_gl_area_make_current(area); + + ImGui_ImplOpenGL3_Shutdown(); + ImGui_ImplGtk3_Shutdown(); + ImGui::DestroyContext(); +} + +static void +print_help(const char *progname, FILE *file) +{ + fprintf(file, + "Usage: %s [OPTION]... FILE\n" + "Decode aub file contents from FILE.\n\n" + " --help display this help and exit\n" + " -x, --xml=DIR load hardware xml description from directory DIR\n", + progname); +} + +int main(int argc, char *argv[]) +{ + int c, i; + bool help = false; + const struct option aubinator_opts[] = { + { "help", no_argument, (int *) &help, true }, + { "xml", required_argument, NULL, 'x' }, + { NULL, 0, NULL, 0 } + }; + + memset(&context, 0, sizeof(context)); + + i = 0; + while ((c = getopt_long(argc, argv, "x:s:", aubinator_opts, &i)) != -1) { + switch (c) { + case 'x': + context.xml_path = strdup(optarg); + break; + default: + break; + } + } + + if (optind < argc) + context.input_file = argv[optind]; + + if (help || !context.input_file) { + print_help(argv[0], stderr); + exit(0); + } + + context.file = aub_file_open(context.input_file); + + gtk_init(NULL, NULL); + + context.gtk_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); + gtk_window_set_title(GTK_WINDOW(context.gtk_window), "Aubinator Viewer"); + g_signal_connect(context.gtk_window, "delete-event", G_CALLBACK(gtk_main_quit), NULL); + gtk_window_resize(GTK_WINDOW(context.gtk_window), 1280, 720); + + GtkWidget* gl_area = gtk_gl_area_new(); + g_signal_connect(gl_area, "render", G_CALLBACK(repaint_area), NULL); + g_signal_connect(gl_area, "realize", G_CALLBACK(realize_area), NULL); + g_signal_connect(gl_area, "unrealize", G_CALLBACK(unrealize_area), NULL); + gtk_container_add(GTK_CONTAINER(context.gtk_window), gl_area); + + gtk_widget_show_all(context.gtk_window); + + show_aubfile_window(); + + gtk_main(); + + free(context.xml_path); + + return EXIT_SUCCESS; +} diff --git a/src/intel/tools/aubinator_viewer.h b/src/intel/tools/aubinator_viewer.h new file mode 100644 index 00000000000..2d89d9cf658 --- /dev/null +++ b/src/intel/tools/aubinator_viewer.h @@ -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 */ diff --git a/src/intel/tools/aubinator_viewer_decoder.cpp b/src/intel/tools/aubinator_viewer_decoder.cpp new file mode 100644 index 00000000000..a2ea3ba4a64 --- /dev/null +++ b/src/intel/tools/aubinator_viewer_decoder.cpp @@ -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; + } + } +} diff --git a/src/intel/tools/imgui/imgui_memory_editor.h b/src/intel/tools/imgui/imgui_memory_editor.h new file mode 100644 index 00000000000..d1e54f0f4f0 --- /dev/null +++ b/src/intel/tools/imgui/imgui_memory_editor.h @@ -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 diff --git a/src/intel/tools/meson.build b/src/intel/tools/meson.build index 396c19ecfaa..0fe39fa4873 100644 --- a/src/intel/tools/meson.build +++ b/src/intel/tools/meson.build @@ -108,4 +108,16 @@ libintel_dump_gpu = shared_library( if with_tools.contains('intel-ui') 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 |