void x86_emu_dump_summary(FILE *f)
{
double time_in_sec;
double inst_per_sec;
/* No statistic dump if there was no x86 simulation */
if (!x86_emu->inst_count)
return;
/* Functional simulation */
time_in_sec = (double) m2s_timer_get_value(x86_emu->timer) / 1.0e6;
inst_per_sec = time_in_sec > 0.0 ? (double) x86_emu->inst_count / time_in_sec : 0.0;
fprintf(f, "[ x86 ]\n");
fprintf(f, "SimType = %s\n", str_map_value(&arch_sim_kind_map, x86_emu_sim_kind));
fprintf(f, "Time = %.2f\n", time_in_sec);
fprintf(f, "Contexts = %d\n", x86_emu->running_list_max);
fprintf(f, "Memory = %lu\n", mem_max_mapped_space);
fprintf(f, "EmulatedInstructions = %lld\n", x86_emu->inst_count);
fprintf(f, "EmulatedInstructionsPerSecond = %.0f\n", inst_per_sec);
/* Detailed simulation */
if (x86_emu_sim_kind == arch_sim_kind_detailed)
x86_cpu_dump_summary(f);
/* End */
fprintf(f, "\n");
}
static char *x86_uinst_dep_name_get(int dep)
{
if (X86_DEP_IS_VALID(dep))
return x86_uinst_dep_name[dep];
else
return str_map_value(&x86_uinst_dep_map, dep);
}
static void X86InstMoffsAddrDumpBuf(X86Inst *self, char **pbuf, int *psize)
{
X86InstReg reg;
reg = self->segment ? self->segment : X86InstRegDs;
str_printf(pbuf, psize, "%s:0x%x", str_map_value(&x86_inst_reg_map, reg), self->imm.d);
}
static void x86_inst_moffs_addr_dump_buf(struct x86_inst_t *inst, char **pbuf, int *psize)
{
enum x86_inst_reg_t reg;
reg = inst->segment ? inst->segment : x86_inst_reg_ds;
str_printf(pbuf, psize, "%s:0x%x", str_map_value(&x86_inst_reg_map, reg), inst->imm.d);
}
void mips_sys_call(struct mips_ctx_t *ctx)
{
struct mips_regs_t *regs = ctx->regs;
int code;
int err;
/* System call code */
code = regs->regs_R[2] - __NR_Linux;
if (code < 1 || code >= mips_sys_code_count)
fatal("%s: invalid system call code (%d)", __FUNCTION__, code);
/* Statistics */
mips_sys_call_freq[code]++;
/* Debug */
mips_sys_debug("'%s' (code %d, inst %lld, pid %d)\n",
mips_sys_call_name[code], code, asEmu(mips_emu)->instructions, ctx->pid);
mips_isa_call_debug("system call '%s' (code %d, inst %lld, pid %d)\n",
mips_sys_call_name[code], code, asEmu(mips_emu)->instructions, ctx->pid);
/* Perform system call */
err = mips_sys_call_func[code](ctx);
/* Set return value in 'eax', except for 'sigreturn' system call. Also, if the
* context got suspended, the wake up routine will set the return value. */
if (code != mips_sys_code_sigreturn && !mips_ctx_get_status(ctx, mips_ctx_suspended))
regs->regs_R[2] = err;
/* Debug */
mips_sys_debug(" ret=(%d, 0x%x)", err, err);
if (err < 0 && err >= -SIM_ERRNO_MAX)
mips_sys_debug(", errno=%s)", str_map_value(&mips_sys_error_code_map, -err));
mips_sys_debug("\n");
}
static void evg_config_dump(FILE *f)
{
/* Device configuration */
fprintf(f, "[ Config.Device ]\n");
fprintf(f, "Frequency = %d\n", evg_gpu_frequency);
fprintf(f, "NumComputeUnits = %d\n", evg_gpu_num_compute_units);
fprintf(f, "NumStreamCores = %d\n", evg_gpu_num_stream_cores);
fprintf(f, "NumRegisters = %d\n", evg_gpu_num_registers);
fprintf(f, "RegisterAllocSize = %d\n", evg_gpu_register_alloc_size);
fprintf(f, "RegisterAllocGranularity = %s\n", str_map_value(&evg_gpu_register_alloc_granularity_map, evg_gpu_register_alloc_granularity));
fprintf(f, "WavefrontSize = %d\n", evg_emu_wavefront_size);
fprintf(f, "MaxWorkGroupsPerComputeUnit = %d\n", evg_gpu_max_work_groups_per_compute_unit);
fprintf(f, "MaxWavefrontsPerComputeUnit = %d\n", evg_gpu_max_wavefronts_per_compute_unit);
fprintf(f, "SchedulingPolicy = %s\n", str_map_value(&evg_gpu_sched_policy_map, evg_gpu_sched_policy));
fprintf(f, "\n");
/* Local Memory */
fprintf(f, "[ Config.LocalMemory ]\n");
fprintf(f, "Size = %d\n", evg_gpu_local_mem_size);
fprintf(f, "AllocSize = %d\n", evg_gpu_local_mem_alloc_size);
fprintf(f, "BlockSize = %d\n", evg_gpu_local_mem_block_size);
fprintf(f, "Latency = %d\n", evg_gpu_local_mem_latency);
fprintf(f, "Ports = %d\n", evg_gpu_local_mem_num_ports);
fprintf(f, "\n");
/* CF Engine */
fprintf(f, "[ Config.CFEngine ]\n");
fprintf(f, "InstructionMemoryLatency = %d\n", evg_gpu_cf_engine_inst_mem_latency);
fprintf(f, "\n");
/* ALU Engine */
fprintf(f, "[ Config.ALUEngine ]\n");
fprintf(f, "InstructionMemoryLatency = %d\n", evg_gpu_alu_engine_inst_mem_latency);
fprintf(f, "FetchQueueSize = %d\n", evg_gpu_alu_engine_fetch_queue_size);
fprintf(f, "ProcessingElementLatency = %d\n", evg_gpu_alu_engine_pe_latency);
fprintf(f, "\n");
/* TEX Engine */
fprintf(f, "[ Config.TEXEngine ]\n");
fprintf(f, "InstructionMemoryLatency = %d\n", evg_gpu_tex_engine_inst_mem_latency);
fprintf(f, "FetchQueueSize = %d\n", evg_gpu_tex_engine_fetch_queue_size);
fprintf(f, "LoadQueueSize = %d\n", evg_gpu_tex_engine_load_queue_size);
fprintf(f, "\n");
/* End of configuration */
fprintf(f, "\n");
}
void __si2bin_arg_valid_types(struct si2bin_arg_t *arg, const char *user_message,
int num_types, ...)
{
va_list ap;
char msg[MAX_STRING_SIZE];
char *msg_ptr;
char *sep;
enum si2bin_arg_type_t types[64];
int msg_size;
int i;
/* Maximum number of types */
if (!IN_RANGE(num_types, 1, 64))
panic("%s: bad number of types", __FUNCTION__);
/* Check if argument type if valid */
va_start(ap, num_types);
for (i = 0; i < num_types; i++)
{
types[i] = va_arg(ap, enum si2bin_arg_type_t);
if (arg->type == types[i])
return;
}
/* Construct error message */
msg[0] = '\0';
msg_ptr = msg;
msg_size = sizeof msg;
str_printf(&msg_ptr, &msg_size, "argument of type %s found, {",
str_map_value(&si2bin_arg_type_map, arg->type));
/* List allowed types */
sep = "";
for (i = 0; i < num_types; i++)
{
str_printf(&msg_ptr, &msg_size, "%s%s", sep,
str_map_value(&si2bin_arg_type_map, types[i]));
sep = "|";
}
/* Message tail */
str_printf(&msg_ptr, &msg_size, "} expected");
fatal("%s: %s", user_message, msg);
}
static void X86InstAddrDumpBuf(X86Inst *self, char **pbuf, int *psize)
{
int putsign = 0;
char seg[20];
assert(self->modrm_mod != 0x03);
/* Segment */
seg[0] = 0;
if (self->segment) {
assert(self->segment >= 0 && self->segment < X86InstRegCount);
strcpy(seg, str_map_value(&x86_inst_reg_map, self->segment));
strcat(seg, ":");
}
/* When there is only a displacement */
if (!self->ea_base && !self->ea_index) {
if (!seg[0])
strcpy(seg, "ds:");
str_printf(pbuf, psize, "%s0x%x", seg, self->disp);
return;
}
str_printf(pbuf, psize, "%s[", seg);
if (self->ea_base) {
str_printf(pbuf, psize, "%s", str_map_value(&x86_inst_reg_map, self->ea_base));
putsign = 1;
}
if (self->ea_index) {
str_printf(pbuf, psize, "%s%s", putsign ? "+" : "",
str_map_value(&x86_inst_reg_map, self->ea_index));
if (self->ea_scale > 1)
str_printf(pbuf, psize, "*%d", self->ea_scale);
putsign = 1;
}
if (self->disp > 0)
str_printf(pbuf, psize, "%s0x%x", putsign ? "+" : "", self->disp);
if (self->disp < 0)
str_printf(pbuf, psize, "-0x%x", -self->disp);
str_printf(pbuf, psize, "]");
}
static void x86_inst_addr_dump_buf(struct x86_inst_t *inst, char **pbuf, int *psize)
{
int putsign = 0;
char seg[20];
assert(inst->modrm_mod != 0x03);
/* Segment */
seg[0] = 0;
if (inst->segment) {
assert(inst->segment >= 0 && inst->segment < x86_inst_reg_count);
strcpy(seg, str_map_value(&x86_inst_reg_map, inst->segment));
strcat(seg, ":");
}
/* When there is only a displacement */
if (!inst->ea_base && !inst->ea_index) {
if (!seg[0])
strcpy(seg, "ds:");
str_printf(pbuf, psize, "%s0x%x", seg, inst->disp);
return;
}
str_printf(pbuf, psize, "%s[", seg);
if (inst->ea_base) {
str_printf(pbuf, psize, "%s", str_map_value(&x86_inst_reg_map, inst->ea_base));
putsign = 1;
}
if (inst->ea_index) {
str_printf(pbuf, psize, "%s%s", putsign ? "+" : "",
str_map_value(&x86_inst_reg_map, inst->ea_index));
if (inst->ea_scale > 1)
str_printf(pbuf, psize, "*%d", inst->ea_scale);
putsign = 1;
}
if (inst->disp > 0)
str_printf(pbuf, psize, "%s0x%x", putsign ? "+" : "", inst->disp);
if (inst->disp < 0)
str_printf(pbuf, psize, "-0x%x", -inst->disp);
str_printf(pbuf, psize, "]");
}
void Llvm2siSymbolDump(Object *self, FILE *f)
{
Llvm2siSymbol *symbol;
/* Name, type, register */
symbol = asLlvm2siSymbol(self);
fprintf(f, "name='%s', type=%s, reg=%d", symbol->name,
str_map_value(&llvm2si_symbol_type_map, symbol->type),
symbol->reg);
/* UAV index */
if (symbol->address)
fprintf(f, ", uav%d", symbol->uav_index + 10);
/* End */
fprintf(f, "\n");
}
struct frm_arg_t *frm_arg_create_ccop(char *name)
{
struct frm_arg_t *arg;
int idx;
arg = frm_arg_create();
arg->type = frm_arg_ccop;
/* name: CC.op, count from the 4th element,
* go though the map to see which string matches */
for (idx = 0; idx < (frm_arg_ccop_map.count - 1); idx ++)
{
if (!strcmp(&(name[3]), str_map_value(&frm_arg_ccop_map, idx)))
arg->value.ccop.op = idx;
}
return arg;
}
void arch_dump(struct arch_t *arch, FILE *f)
{
double time_in_sec;
int i;
Emu *emu;
Timing *timing;
/* Get objects */
emu = arch->emu;
timing = arch->timing;
/* Nothing to print if architecture was not active */
if (!emu->instructions)
return;
/* Header */
for (i = 0; i < 80; i++)
fprintf(f, "=");
fprintf(f, "\nArchitecture '%s'\n", arch->name);
for (i = 0; i < 80; i++)
fprintf(f, "=");
fprintf(f, "\n\n");
/* Emulator */
time_in_sec = (double) m2s_timer_get_value(emu->timer) / 1.0e6;
fprintf(f, "SimKind = %s\n", str_map_value(&arch_sim_kind_map, arch->sim_kind));
fprintf(f, "Time = %.2f\n", time_in_sec);
fprintf(f, "Instructions = %lld\n", emu->instructions);
fprintf(f, "\n");
assert(emu->DumpSummary);
emu->DumpSummary(emu, f);
/* Continue with timing simulator only it active */
if (arch->sim_kind == arch_sim_kind_functional)
return;
/* Timing simulator */
fprintf(f, "Cycles = %lld\n", timing->cycle);
fprintf(f, "\n");
assert(timing->DumpSummary);
timing->DumpSummary(timing, f);
}
/* Read next note at the current position of the PT_NOTE segment */
static void si_bin_file_read_note_header(
struct si_bin_file_t *bin_file,
struct si_bin_enc_dict_entry_t *enc_dict_entry) {
struct elf_buffer_t *buffer;
struct pt_note_header_t *header;
void *desc;
int count;
char *note_type_str;
/* Read note header */
buffer = &enc_dict_entry->pt_note_buffer;
header = elf_buffer_tell(buffer);
count = elf_buffer_read(buffer, NULL, sizeof(struct pt_note_header_t));
if (count < sizeof(struct pt_note_header_t))
fatal("%s: error decoding note header", bin_file->elf_file->path);
/* Read note description (payload) */
desc = elf_buffer_tell(buffer);
count = elf_buffer_read(buffer, NULL, header->descsz);
if (count < header->descsz)
fatal("%s: error decoding note description", bin_file->elf_file->path);
/* Debug */
note_type_str = str_map_value(&pt_note_type_map, header->type);
elf_debug(" note: type=%d (%s), descsz=%d\n", header->type, note_type_str,
header->descsz);
/* Analyze note */
switch (header->type) {
case 1: /* ELF_NOTE_ATI_PROGINFO */
{
int prog_info_count;
struct pt_note_prog_info_entry_t *prog_info_entry;
int i;
/* Get number of entries */
assert(header->descsz % sizeof(struct pt_note_prog_info_entry_t) == 0);
prog_info_count =
header->descsz / sizeof(struct pt_note_prog_info_entry_t);
elf_debug(
"\tnote including device configuration unique to the program (%d "
"entries)\n",
prog_info_count);
/* Decode entries */
for (i = 0; i < prog_info_count; i++) {
prog_info_entry = desc + i * sizeof(struct pt_note_prog_info_entry_t);
elf_debug("\tprog_info_entry: addr=0x%x (%s), value=%u\n",
prog_info_entry->address,
str_map_value(&prog_info_entry_map, prog_info_entry->address),
prog_info_entry->value);
/* Analyze entry */
switch (prog_info_entry->address) {
case 0x00002e13: /* COMPUTE_PGM_RSRC2 */
enc_dict_entry->compute_pgm_rsrc2 =
(struct si_bin_compute_pgm_rsrc2_t *)&prog_info_entry->value;
break;
case 0x80000082: /* AMU_ABI_LDS_SIZE_USED */
enc_dict_entry->lds_size_used = prog_info_entry->value;
break;
case 0x80000084: /* AMU_ABI_STACK_SIZE_USED */
enc_dict_entry->stack_size_used = prog_info_entry->value;
break;
case 0x80001000: /* AMU_ABI_USER_ELEMENT_COUNT */
enc_dict_entry->userElementCount = prog_info_entry->value;
i++;
/* Analyze user elements */
for (int j = 0; j < 4 * enc_dict_entry->userElementCount; j++) {
prog_info_entry =
desc + i * sizeof(struct pt_note_prog_info_entry_t);
elf_debug(
"\tprog_info_entry: addr=0x%x (%s), value=%u\n",
prog_info_entry->address,
str_map_value(&prog_info_entry_map, prog_info_entry->address),
prog_info_entry->value);
switch (j % 4) {
case 0:
enc_dict_entry->userElements[j / 4].dataClass =
prog_info_entry->value;
break;
case 1:
enc_dict_entry->userElements[j / 4].apiSlot =
prog_info_entry->value;
break;
case 2:
enc_dict_entry->userElements[j / 4].startUserReg =
prog_info_entry->value;
break;
case 3:
enc_dict_entry->userElements[j / 4].userRegCount =
prog_info_entry->value;
break;
}
i++;
}
break;
case 0x80001041: /* NUM VGPRS */
enc_dict_entry->num_vgpr_used = prog_info_entry->value;
break;
case 0x80001042: /* NUM SGPRS */
enc_dict_entry->num_sgpr_used = prog_info_entry->value;
break;
}
}
break;
}
case 2: /* ELF_NOTE_ATI_INPUTS */
{
/* FIXME: Analyze program inputs */
if (header->descsz)
warning("%s: pt_note '%s' with descsz != 0 ignored (desc value = 0x%x)",
note_type_str, __FUNCTION__, *(unsigned int *)desc);
break;
}
case 3: /* ELF_NOTE_ATI_OUTPUTS */
{
/* FIXME: Analyze program inputs */
if (header->descsz)
warning("%s: pt_note '%s' with descsz != 0 ignored (desc value = 0x%x)",
note_type_str, __FUNCTION__, *(unsigned int *)desc);
break;
}
case 4: /* ELF_NOTE_ATI_CONDOUT */
break;
case 5: /* ELF_NOTE_ATI_FLOAT32CONSTS */
case 6: /* ELF_NOTE_ATI_INT32CONSTS */
case 7: /* ELF_NOTE_ATI_BOOL32CONSTS */
{
int data_segment_desc_count;
struct pt_note_data_segment_desc_t *data_segment_desc;
struct si_bin_enc_dict_entry_consts_t *consts;
char const_value[MAX_STRING_SIZE];
int j;
/* Get number of entries */
consts = enc_dict_entry->consts;
assert(header->descsz % sizeof(struct pt_note_data_segment_desc_t) == 0);
data_segment_desc_count =
header->descsz / sizeof(struct pt_note_data_segment_desc_t);
elf_debug("\tnote including data for constant buffers (%d entries)\n",
data_segment_desc_count);
/* Decode entries */
for (j = 0; j < data_segment_desc_count; j++) {
data_segment_desc =
desc + j * sizeof(struct pt_note_data_segment_desc_t);
if (header->type == 5)
snprintf(const_value, sizeof(const_value), "{%g,%g,%g,%g}",
consts->float_consts[data_segment_desc->offset][0],
consts->float_consts[data_segment_desc->offset][1],
consts->float_consts[data_segment_desc->offset][2],
consts->float_consts[data_segment_desc->offset][3]);
else if (header->type == 6)
snprintf(const_value, sizeof(const_value), "{%u,%u,%u,%u}",
consts->int_consts[data_segment_desc->offset][0],
consts->int_consts[data_segment_desc->offset][1],
consts->int_consts[data_segment_desc->offset][2],
consts->int_consts[data_segment_desc->offset][3]);
else
snprintf(const_value, sizeof(const_value), "%d",
consts->bool_consts[data_segment_desc->offset]);
elf_debug("\tdata_segment_desc[%d]: offset=0x%x, size=%d, value=%s\n",
j, data_segment_desc->offset, data_segment_desc->size,
const_value);
}
break;
}
case 8: /* ELF_NOTE_ATI_EARLYEXIT */
{
Elf32_Word early_exit;
/* Get 'early_exit' value */
early_exit = header->descsz ? *(uint32_t *)desc : 0;
elf_debug("\tearly_exit = %s\n", early_exit ? "TRUE" : "FALSE");
break;
}
case 9: /* ELF_NOTE_ATI_GLOBAL_BUFFERS */
{
Elf32_Word global_buffers;
global_buffers = header->descsz ? *(uint32_t *)desc : 0;
elf_debug("\tglobal_buffers = %s\n", global_buffers ? "TRUE" : "FALSE");
break;
}
case 10: /* ELF_NOTE_ATI_CONSTANT_BUFFERS */
{
int constant_buffer_count;
struct pt_note_constant_buffer_mask_t *constant_buffer_mask;
int i;
/* Get number of entries */
assert(header->descsz % sizeof(struct pt_note_constant_buffer_mask_t) ==
0);
constant_buffer_count =
header->descsz / sizeof(struct pt_note_constant_buffer_mask_t);
elf_debug(
"\tnote including number and size of constant "
"buffers (%d entries)\n",
constant_buffer_count);
/* Decode entries */
for (i = 0; i < constant_buffer_count; i++) {
constant_buffer_mask =
desc + i * sizeof(struct pt_note_constant_buffer_mask_t);
elf_debug(
"\tconstant_buffer[%d].size = %d "
"(vec4f constants)\n",
constant_buffer_mask->index, constant_buffer_mask->size);
}
break;
}
case 11: /* ELF_NOTE_ATI_INPUT_SAMPLERS */
break;
case 12: /* ELF_NOTE_ATI_PERSISTENT_BUFFERS */
{
Elf32_Word persistent_buffers;
persistent_buffers = header->descsz ? *(uint32_t *)desc : 0;
elf_debug("\tpersistent_buffers = %s\n",
persistent_buffers ? "TRUE" : "FALSE");
break;
}
case 13: /* ELF_NOTE_ATI_SCRATCH_BUFFERS */
{
Elf32_Word scratch_buffers;
scratch_buffers = header->descsz ? *(uint32_t *)desc : 0;
elf_debug("\tscratch_buffers = %s\n", scratch_buffers ? "TRUE" : "FALSE");
break;
}
case 14: /* ELF_NOTE_ATI_SUB_CONSTANT_BUFFERS */
break;
case 15: /* ELF_NOTE_ATI_UAV_MAILBOX_SIZE */
break;
case 16: /* ELF_NOTE_ATI_UAV */
{
int uav_entry_count;
struct pt_note_uav_entry_t *uav_entry;
int i;
assert(header->descsz % sizeof(struct pt_note_uav_entry_t) == 0);
uav_entry_count = header->descsz / sizeof(struct pt_note_uav_entry_t);
elf_debug("\tnote (%d entries)\n", uav_entry_count);
/* Decode entries */
for (i = 0; i < uav_entry_count; i++) {
uav_entry = desc + i * sizeof(struct pt_note_uav_entry_t);
elf_debug("\tuav_entry[%d].uav = %d [%d, %d, %d]\n", i, uav_entry->id,
uav_entry->unknown1, uav_entry->unknown2,
uav_entry->unknown3);
}
break;
}
case 17: /* ELF_NOTE_ATI_UAV_OP_MASK */
break;
default:
elf_debug("\tunknown type\n");
}
}
/* Event handler for EV_MEM_SYSTEM_END_COMMAND.
* The event data is a string of type 'char *' that needs to be deallocated
* after processing this event. */
void mem_system_end_command_handler(int event, void *data)
{
char *command_line = data;
char command[MAX_STRING_SIZE];
char msg[MAX_STRING_SIZE];
char msg_detail[MAX_STRING_SIZE];
char *msg_str = msg;
int msg_size = sizeof msg;
char *msg_detail_str = msg_detail;
int msg_detail_size = sizeof msg_detail;
int test_failed;
struct list_t *token_list;
/* Split command in tokens, skip command */
token_list = str_token_list_create(command_line, " ");
assert(list_count(token_list));
/* Get command */
mem_system_command_get_string(token_list, command_line, command, sizeof command);
/* Messages */
test_failed = 0;
*msg_str = '\0';
*msg_detail_str = '\0';
/* Command 'SetBlock' */
if (!strcasecmp(command, "CheckBlock"))
{
struct mod_t *mod;
int set;
int way;
int tag;
int tag_check;
int state;
int state_check;
mod = mem_system_command_get_mod(token_list, command_line);
mem_system_command_get_set_way(token_list, command_line, mod, &set, &way);
tag = mem_system_command_get_hex(token_list, command_line);
state = mem_system_command_get_state(token_list, command_line);
mem_system_command_end(token_list, command_line);
/* Check that module serves address */
if (!mod_serves_address(mod, tag))
fatal("%s: %s: module does not serve address 0x%x.\n\t> %s",
__FUNCTION__, mod->name, tag, command_line);
/* Output */
str_printf(&msg_str, &msg_size,
"check module %s, set %d, way %d - state %s, tag 0x%x",
mod->name, set, way, str_map_value(&cache_block_state_map, state), tag);
/* Check */
cache_get_block(mod->cache, set, way, &tag_check, &state_check);
if (tag != tag_check)
{
test_failed = 1;
str_printf(&msg_detail_str, &msg_detail_size,
"\ttag 0x%x found, but 0x%x expected\n",
tag_check, tag);
}
if (state != state_check)
{
test_failed = 1;
str_printf(&msg_detail_str, &msg_detail_size,
"\tstate %s found, but %s expected\n",
str_map_value(&cache_block_state_map, state_check),
str_map_value(&cache_block_state_map, state));
}
}
/* Command 'CheckOwner' */
else if (!strcasecmp(command, "CheckOwner"))
{
struct mod_t *mod;
struct mod_t *owner;
struct mod_t *owner_check = NULL;
struct net_node_t *net_node;
struct dir_entry_t *dir_entry;
int set;
int way;
int sub_block;
/* Read fields */
mod = mem_system_command_get_mod(token_list, command_line);
mem_system_command_get_set_way(token_list, command_line, mod, &set, &way);
sub_block = mem_system_command_get_sub_block(token_list, command_line, mod, set, way);
owner = mem_system_command_get_mod(token_list, command_line);
mem_system_command_end(token_list, command_line);
/* Get actual owner */
owner_check = NULL;
if (mod->dir)
{
dir_entry = dir_entry_get(mod->dir, set, way, sub_block);
if (dir_entry->owner >= 0)
{
assert(mod->high_net);
net_node = list_get(mod->high_net->node_list, dir_entry->owner);
owner_check = net_node->user_data;
}
}
/* Message */
str_printf(&msg_str, &msg_size,
"check owner at module %s, set %d, way %d, subblock %d - %s",
mod->name, set, way, sub_block, owner ? owner->name : "None");
/* Check match */
if (owner != owner_check)
{
test_failed = 1;
str_printf(&msg_detail_str, &msg_detail_size,
"\towner %s found, but %s expected\n",
owner_check ? owner_check->name : "None",
owner ? owner->name : "None");
}
}
/* Command 'CheckSharers' */
else if (!strcasecmp(command, "CheckSharers"))
{
struct mod_t *mod;
struct mod_t *sharer;
struct net_node_t *node;
int set;
int way;
int sub_block;
int node_index;
struct linked_list_t *sharers_list;
struct linked_list_t *sharers_check_list;
/* Read fields */
mod = mem_system_command_get_mod(token_list, command_line);
mem_system_command_get_set_way(token_list, command_line, mod, &set, &way);
sub_block = mem_system_command_get_sub_block(token_list, command_line, mod, set, way);
mem_system_command_expect(token_list, command_line);
/* Construct list of expected sharers */
sharers_list = linked_list_create();
while (list_count(token_list))
{
sharer = mem_system_command_get_mod(token_list, command_line);
linked_list_add(sharers_list, sharer);
}
/* Output */
str_printf(&msg_str, &msg_size,
"check sharers at module %s, set %d, way %d, subblock %d - { ",
mod->name, set, way, sub_block);
LINKED_LIST_FOR_EACH(sharers_list)
{
sharer = linked_list_get(sharers_list);
if (sharer)
str_printf(&msg_str, &msg_size, "%s ", sharer->name);
}
str_printf(&msg_str, &msg_size, "}");
/* Construct list of actual sharers */
sharers_check_list = linked_list_create();
assert(mod->high_net);
for (node_index = 0; node_index < mod->high_net->node_count; node_index++)
{
if (!dir_entry_is_sharer(mod->dir, set, way, sub_block, node_index))
continue;
node = list_get(mod->high_net->node_list, node_index);
sharer = node->user_data;
linked_list_add(sharers_check_list, sharer);
}
/* Remove in actual sharers everything from expected sharers */
LINKED_LIST_FOR_EACH(sharers_list)
{
/* Get expected sharer */
sharer = linked_list_get(sharers_list);
if (!sharer)
continue;
/* Check that it's an actual sharer */
linked_list_find(sharers_check_list, sharer);
if (sharers_check_list->error_code)
{
test_failed = 1;
str_printf(&msg_detail_str, &msg_detail_size,
"\tsharer %s expected, but not found\n",
sharer->name);
}
/* Remove from actual sharers */
linked_list_remove(sharers_check_list);
}
/* Check that there is no actual sharer left */
LINKED_LIST_FOR_EACH(sharers_check_list)
{
sharer = linked_list_get(sharers_check_list);
test_failed = 1;
str_printf(&msg_detail_str, &msg_detail_size,
"\tsharer %s found, but not expected\n",
sharer->name);
}
/* Free lists */
linked_list_free(sharers_list);
linked_list_free(sharers_check_list);
}
/* Command 'CheckLink' */
else if (!strcasecmp(command, "CheckLink"))
void X86InstDumpBuf(X86Inst *self, char *buf, int size)
{
X86Asm *as;
struct x86_inst_info_t *info;
int length;
int name_printed;
int name_length;
int i;
char *fmt;
char *fmt_first_arg;
/* Get instruction information from the globally initialized x86
* assembler. */
as = self->as;
assert(as);
assert(IN_RANGE(self->opcode, 0, X86InstOpcodeCount - 1));
info = &as->inst_info_list[self->opcode];
/* Null-terminate output string in case 'fmt' is empty */
if (size)
*buf = '\0';
/* Get instruction name length */
name_printed = 0;
fmt = info->fmt;
fmt_first_arg = index(fmt, '_');
name_length = fmt_first_arg ? fmt_first_arg - fmt : strlen(fmt);
/* Dump instruction */
while (*fmt)
{
/* Assume no token found */
length = 0;
/* Check tokens */
if (asm_is_token(fmt, "r8", &length))
{
str_printf(&buf, &size, "%s", str_map_value(&x86_inst_reg_map,
self->modrm_reg + X86InstRegAl));
}
else if (asm_is_token(fmt, "r16", &length))
{
str_printf(&buf, &size, "%s", str_map_value(&x86_inst_reg_map,
self->modrm_reg + X86InstRegAx));
}
else if (asm_is_token(fmt, "r32", &length))
{
str_printf(&buf, &size, "%s", str_map_value(&x86_inst_reg_map,
self->modrm_reg + X86InstRegEax));
}
else if (asm_is_token(fmt, "rm8", &length))
{
if (self->modrm_mod == 0x03)
str_printf(&buf, &size, "%s",
str_map_value(&x86_inst_reg_map,
self->modrm_rm + X86InstRegAl));
else
{
str_printf(&buf, &size, "BYTE PTR ");
X86InstAddrDumpBuf(self, &buf, &size);
}
}
else if (asm_is_token(fmt, "rm16", &length))
{
if (self->modrm_mod == 0x03)
str_printf(&buf, &size, "%s",
str_map_value(&x86_inst_reg_map,
self->modrm_rm + X86InstRegAx));
else
{
str_printf(&buf, &size, "WORD PTR ");
X86InstAddrDumpBuf(self, &buf, &size);
}
}
else if (asm_is_token(fmt, "rm32", &length))
{
if (self->modrm_mod == 0x03)
str_printf(&buf, &size, "%s",
str_map_value(&x86_inst_reg_map,
self->modrm_rm + X86InstRegEax));
else
{
str_printf(&buf, &size, "DWORD PTR ");
X86InstAddrDumpBuf(self, &buf, &size);
}
}
else if (asm_is_token(fmt, "r32m8", &length))
{
if (self->modrm_mod == 3)
str_printf(&buf, &size, "%s", str_map_value(&x86_inst_reg_map,
self->modrm_rm + X86InstRegEax));
else
{
str_printf(&buf, &size, "BYTE PTR ");
X86InstAddrDumpBuf(self, &buf, &size);
}
}
else if (asm_is_token(fmt, "r32m16", &length))
{
if (self->modrm_mod == 3)
str_printf(&buf, &size, "%s", str_map_value(&x86_inst_reg_map,
self->modrm_rm + X86InstRegEax));
else
{
str_printf(&buf, &size, "WORD PTR ");
X86InstAddrDumpBuf(self, &buf, &size);
}
}
else if (asm_is_token(fmt, "m", &length))
{
X86InstAddrDumpBuf(self, &buf, &size);
}
else if (asm_is_token(fmt, "imm8", &length))
{
str_printf(&buf, &size, "0x%x", self->imm.b);
}
else if (asm_is_token(fmt, "imm16", &length))
{
str_printf(&buf, &size, "0x%x", self->imm.w);
}
else if (asm_is_token(fmt, "imm32", &length))
{
str_printf(&buf, &size, "0x%x", self->imm.d);
}
else if (asm_is_token(fmt, "rel8", &length))
{
str_printf(&buf, &size, "%x", (int8_t) self->imm.b + self->eip + self->size);
}
else if (asm_is_token(fmt, "rel16", &length))
{
str_printf(&buf, &size, "%x", (int16_t) self->imm.w + self->eip + self->size);
}
else if (asm_is_token(fmt, "rel32", &length))
{
str_printf(&buf, &size, "%x", self->imm.d + self->eip + self->size);
}
else if (asm_is_token(fmt, "moffs8", &length))
{
X86InstMoffsAddrDumpBuf(self, &buf, &size);
}
else if (asm_is_token(fmt, "moffs16", &length))
{
X86InstMoffsAddrDumpBuf(self, &buf, &size);
}
else if (asm_is_token(fmt, "moffs32", &length))
{
X86InstMoffsAddrDumpBuf(self, &buf, &size);
}
else if (asm_is_token(fmt, "m8", &length))
{
str_printf(&buf, &size, "BYTE PTR ");
X86InstAddrDumpBuf(self, &buf, &size);
}
else if (asm_is_token(fmt, "m16", &length))
{
str_printf(&buf, &size, "WORD PTR ");
X86InstAddrDumpBuf(self, &buf, &size);
}
else if (asm_is_token(fmt, "m32", &length))
{
str_printf(&buf, &size, "DWORD PTR ");
X86InstAddrDumpBuf(self, &buf, &size);
}
else if (asm_is_token(fmt, "m64", &length))
{
str_printf(&buf, &size, "QWORD PTR ");
X86InstAddrDumpBuf(self, &buf, &size);
}
else if (asm_is_token(fmt, "m80", &length))
{
str_printf(&buf, &size, "TBYTE PTR ");
X86InstAddrDumpBuf(self, &buf, &size);
}
else if (asm_is_token(fmt, "m128", &length))
{
str_printf(&buf, &size, "XMMWORD PTR ");
X86InstAddrDumpBuf(self, &buf, &size);
}
else if (asm_is_token(fmt, "st0", &length))
{
str_printf(&buf, &size, "st");
}
else if (asm_is_token(fmt, "sti", &length))
{
str_printf(&buf, &size, "st(%d)", self->opindex);
}
else if (asm_is_token(fmt, "ir8", &length))
{
str_printf(&buf, &size, "%s", str_map_value(&x86_inst_reg_map,
self->opindex + X86InstRegAl));
}
else if (asm_is_token(fmt, "ir16", &length))
{
str_printf(&buf, &size, "%s", str_map_value(&x86_inst_reg_map,
self->opindex + X86InstRegAx));
}
else if (asm_is_token(fmt, "ir32", &length))
{
str_printf(&buf, &size, "%s", str_map_value(&x86_inst_reg_map,
self->opindex + X86InstRegEax));
}
else if (asm_is_token(fmt, "sreg", &length))
{
str_printf(&buf, &size, "%s", str_map_value(&x86_inst_reg_map,
self->reg + X86InstRegEs));
}
else if (asm_is_token(fmt, "xmmm32", &length))
{
if (self->modrm_mod == 3)
str_printf(&buf, &size, "xmm%d", self->modrm_rm);
else
{
str_printf(&buf, &size, "DWORD PTR ");
X86InstAddrDumpBuf(self, &buf, &size);
}
}
else if (asm_is_token(fmt, "xmmm64", &length))
{
if (self->modrm_mod == 0x03)
str_printf(&buf, &size, "xmm%d", self->modrm_rm);
else
{
str_printf(&buf, &size, "QWORD PTR ");
X86InstAddrDumpBuf(self, &buf, &size);
}
}
else if (asm_is_token(fmt, "xmmm128", &length))
{
if (self->modrm_mod == 0x03)
str_printf(&buf, &size, "xmm%d", self->modrm_rm);
else
{
str_printf(&buf, &size, "XMMWORD PTR ");
X86InstAddrDumpBuf(self, &buf, &size);
}
}
else if (asm_is_token(fmt, "xmm", &length))
{
str_printf(&buf, &size, "xmm%d", self->modrm_reg);
}
/* Token was found, advance format string and continue */
if (length)
{
fmt += length;
continue;
}
/* Print literal alphanumerics */
while (*fmt && isalnum(*fmt))
str_printf(&buf, &size, "%c", *fmt++);
/* Print literal non-alphanumerics */
while (*fmt && !isalnum(*fmt))
{
if (*fmt == '_')
{
if (name_printed)
{
str_printf(&buf, &size, ",");
}
else
{
name_printed = 1;
for (i = 0; i < 7 - name_length; i++)
str_printf(&buf, &size, " ");
}
}
else
{
str_printf(&buf, &size, "%c", *fmt);
}
fmt++;
}
}
}
void si2bin_arg_dump_assembly(struct si2bin_arg_t *arg, FILE *f)
{
switch (arg->type)
{
case si2bin_arg_invalid:
break;
case si2bin_arg_scalar_register:
fprintf(f, "s%d", arg->value.scalar_register.id);
break;
case si2bin_arg_vector_register:
fprintf(f, "v%d", arg->value.vector_register.id);
break;
case si2bin_arg_scalar_register_series:
fprintf(f, "s[%d:%d]",
arg->value.scalar_register_series.low,
arg->value.scalar_register_series.high);
break;
case si2bin_arg_vector_register_series:
fprintf(f, "v[%d:%d]",
arg->value.vector_register_series.low,
arg->value.vector_register_series.high);
break;
case si2bin_arg_literal:
case si2bin_arg_literal_reduced:
{
int value;
value = arg->value.literal.val;
fprintf(f, "0x%x", value);
break;
}
case si2bin_arg_literal_float:
case si2bin_arg_literal_float_reduced:
fprintf(f, "%g", arg->value.literal_float.val);
break;
case si2bin_arg_waitcnt:
{
if(arg->value.wait_cnt.vmcnt_active)
fprintf(f, "vmcnt(%d)", arg->value.wait_cnt.vmcnt_value);
else if (arg->value.wait_cnt.lgkmcnt_active)
fprintf(f, "lgkmcnt(%d)", arg->value.wait_cnt.lgkmcnt_value);
else if (arg->value.wait_cnt.expcnt_active)
fprintf(f, "expcnt(%d)", arg->value.wait_cnt.expcnt_value);
break;
}
case si2bin_arg_special_register:
fprintf(f, "%s", str_map_value(&si_inst_special_reg_map,
arg->value.special_register.reg));
break;
case si2bin_arg_mem_register:
fprintf(f, "m%d", arg->value.mem_register.id);
break;
case si2bin_arg_maddr:
si2bin_arg_dump_assembly(arg->value.maddr.soffset, f);
fprintf(f, " ");
si2bin_arg_dump_assembly(arg->value.maddr.qual, f);
fprintf(f, " format:[%s,%s]",
str_map_value(&si_inst_buf_data_format_map, arg->value.maddr.data_format),
str_map_value(&si_inst_buf_num_format_map, arg->value.maddr.num_format));
break;
case si2bin_arg_maddr_qual:
{
if (arg->value.maddr_qual.idxen)
fprintf(f, "idxen");
else if(arg->value.maddr_qual.offset)
fprintf(f, "offset");
else
fprintf(f, "offen");
break;
}
case si2bin_arg_label:
{
fprintf(f, " %s", arg->value.label.name);
break;
}
default:
fatal("%s: error - not a valid argument type", __FUNCTION__);
}
}
void si2bin_arg_dump(struct si2bin_arg_t *arg, FILE *f)
{
switch (arg->type)
{
case si2bin_arg_invalid:
fprintf(f, "<invalid>");
break;
case si2bin_arg_scalar_register:
fprintf(f, "<sreg> s%d", arg->value.scalar_register.id);
break;
case si2bin_arg_vector_register:
fprintf(f, "<vreg> v%d", arg->value.vector_register.id);
break;
case si2bin_arg_scalar_register_series:
fprintf(f, "<sreg_series> s[%d:%d]",
arg->value.scalar_register_series.low,
arg->value.scalar_register_series.high);
break;
case si2bin_arg_vector_register_series:
fprintf(f, "<vreg_series> v[%d:%d]",
arg->value.vector_register_series.low,
arg->value.vector_register_series.high);
break;
case si2bin_arg_literal:
{
int value;
value = arg->value.literal.val;
fprintf(f, "<const> %d", value);
if (value)
fprintf(f, " (0x%x)", value);
break;
}
case si2bin_arg_literal_reduced:
{
int value;
value = arg->value.literal.val;
fprintf(f, "<const_reduced> %d", value);
if (value)
fprintf(f, " (0x%x)", value);
break;
}
case si2bin_arg_literal_float:
fprintf(f, "<const_float> %g", arg->value.literal_float.val);
break;
case si2bin_arg_literal_float_reduced:
fprintf(f, "<const_float_reduced> %g", arg->value.literal_float.val);
break;
case si2bin_arg_waitcnt:
{
char buf[MAX_STRING_SIZE];
fprintf(f, "<waitcnt>");
snprintf(buf, sizeof buf, "%d", arg->value.wait_cnt.vmcnt_value);
fprintf(f, " vmcnt=%s", arg->value.wait_cnt.vmcnt_active ? buf : "x");
snprintf(buf, sizeof buf, "%d", arg->value.wait_cnt.expcnt_value);
fprintf(f, " expcnt=%s", arg->value.wait_cnt.expcnt_active ? buf : "x");
snprintf(buf, sizeof buf, "%d", arg->value.wait_cnt.lgkmcnt_value);
fprintf(f, " lgkmcnt=%s", arg->value.wait_cnt.lgkmcnt_active ? buf : "x");
break;
}
case si2bin_arg_special_register:
fprintf(f, "<special_reg> %s", str_map_value(&si_inst_special_reg_map,
arg->value.special_register.reg));
break;
case si2bin_arg_mem_register:
fprintf(f, "<mreg> m%d", arg->value.mem_register.id);
break;
case si2bin_arg_maddr:
fprintf(f, "<maddr>");
fprintf(f, " soffs={");
si2bin_arg_dump(arg->value.maddr.soffset, f);
fprintf(f, "}");
fprintf(f, " qual={");
si2bin_arg_dump(arg->value.maddr.qual, f);
fprintf(f, "}");
fprintf(f, " dfmt=%s", str_map_value(&si_inst_buf_data_format_map,
arg->value.maddr.data_format));
fprintf(f, " nfmt=%s", str_map_value(&si_inst_buf_num_format_map,
arg->value.maddr.num_format));
break;
case si2bin_arg_maddr_qual:
fprintf(f, "offen=%c", arg->value.maddr_qual.offen ? 't' : 'f');
fprintf(f, " idxen=%c", arg->value.maddr_qual.idxen ? 't' : 'f');
fprintf(f, " offset=%d", arg->value.maddr_qual.offset);
break;
case si2bin_arg_label:
fprintf(f, "<label>");
break;
default:
panic("%s: invalid argument type", __FUNCTION__);
break;
}
}
static void evg_bin_file_read_enc_dict(struct evg_bin_file_t *bin_file)
{
struct elf_file_t *elf_file;
struct elf_buffer_t *buffer;
Elf32_Ehdr *elf_header;
struct elf_program_header_t *program_header;
struct evg_bin_enc_dict_entry_t *enc_dict_entry;
struct evg_bin_enc_dict_entry_header_t *enc_dict_entry_header;
int enc_dict_entry_count;
int i;
/* ELF header */
elf_file = bin_file->elf_file;
elf_header = elf_file->header;
buffer = &elf_file->buffer;
elf_debug("**\n** Parsing AMD Binary (Internal ELF file)\n** %s\n**\n\n", elf_file->path);
EVG_BIN_FILE_NOT_SUPPORTED_NEQ(elf_header->e_ident[EI_CLASS], ELFCLASS32);
EVG_BIN_FILE_NOT_SUPPORTED_NEQ(elf_header->e_ident[EI_DATA], ELFDATA2LSB);
EVG_BIN_FILE_NOT_SUPPORTED_NEQ(elf_header->e_ident[EI_OSABI], 0x64);
EVG_BIN_FILE_NOT_SUPPORTED_NEQ(elf_header->e_ident[EI_ABIVERSION], 1);
EVG_BIN_FILE_NOT_SUPPORTED_NEQ(elf_header->e_type, ET_EXEC);
EVG_BIN_FILE_NOT_SUPPORTED_NEQ(elf_header->e_machine, 0x7d);
EVG_BIN_FILE_NOT_SUPPORTED_NEQ(elf_header->e_entry, 0);
/* Look for encoding dictionary (program header with type 'PT_LOPROC+2') */
program_header = NULL;
for (i = 0; i < list_count(elf_file->program_header_list); i++)
{
program_header = list_get(elf_file->program_header_list, i);
if (program_header->header->p_type == PT_LOPROC + 2)
break;
}
if (i == list_count(elf_file->program_header_list) || !program_header)
fatal("%s: no encoding dictionary", elf_file->path);
elf_debug("Encoding dictionary found in program header %d\n", i);
/* Parse encoding dictionary */
EVG_BIN_FILE_NOT_SUPPORTED_NEQ(program_header->header->p_vaddr, 0);
EVG_BIN_FILE_NOT_SUPPORTED_NEQ(program_header->header->p_paddr, 0);
EVG_BIN_FILE_NOT_SUPPORTED_NEQ(program_header->header->p_memsz, 0);
EVG_BIN_FILE_NOT_SUPPORTED_NEQ(program_header->header->p_flags, 0);
EVG_BIN_FILE_NOT_SUPPORTED_NEQ(program_header->header->p_align, 0);
assert(program_header->header->p_filesz % sizeof(struct evg_bin_enc_dict_entry_header_t) == 0);
enc_dict_entry_count = program_header->header->p_filesz / sizeof(struct evg_bin_enc_dict_entry_header_t);
elf_debug(" -> %d entries\n\n", enc_dict_entry_count);
/* Read encoding dictionary entries */
bin_file->enc_dict = list_create();
elf_buffer_seek(buffer, program_header->header->p_offset);
for (i = 0; i < enc_dict_entry_count; i++) {
/* Create entry */
enc_dict_entry = xcalloc(1, sizeof(struct evg_bin_enc_dict_entry_t));
enc_dict_entry->header = elf_buffer_tell(buffer);
elf_buffer_read(buffer, NULL, sizeof(struct evg_bin_enc_dict_entry_header_t));
list_add(bin_file->enc_dict, enc_dict_entry);
/* Store encoding dictionary entry for Evergreen (code 9) */
if (enc_dict_entry->header->d_machine == 9)
bin_file->enc_dict_entry_evergreen = enc_dict_entry;
}
/* Debug */
elf_debug("idx %-15s %-10s %-10s %-10s %-10s\n", "d_machine", "d_type",
"d_offset", "d_size", "d_flags");
for (i = 0; i < 80; i++)
elf_debug("-");
elf_debug("\n");
for (i = 0; i < list_count(bin_file->enc_dict); i++)
{
char machine_str[MAX_STRING_SIZE];
enc_dict_entry = list_get(bin_file->enc_dict, i);
enc_dict_entry_header = enc_dict_entry->header;
snprintf(machine_str, sizeof(machine_str), "%d (%s)",
enc_dict_entry_header->d_machine, str_map_value(&enc_dict_machine_map,
enc_dict_entry_header->d_machine - 1));
elf_debug("%3d %-15s 0x%-8x 0x%-8x %-10d 0x%-8x\n",
i, machine_str,
enc_dict_entry_header->d_type,
enc_dict_entry_header->d_offset,
enc_dict_entry_header->d_size,
enc_dict_entry_header->d_flags);
}
elf_debug("\n\n");
}
void frm_arg_dump(struct frm_arg_t *arg, FILE *f)
{
switch (arg->type)
{
case frm_arg_invalid:
fprintf(f, "<invalid>");
break;
case frm_arg_scalar_register:
fprintf(f, "<sreg> s%d", arg->value.scalar_register.id);
break;
case frm_arg_literal:
{
int value;
value = arg->value.literal.val;
fprintf(f, "<const> %d", value);
if (value)
fprintf(f, " (0x%x)", value);
break;
}
case frm_arg_special_register:
{
fprintf(f, "<special_reg> %s",
str_map_value(&frm_arg_special_register_map,
arg->value.special_register.type));
break;
}
// case frm_arg_maddr:
// {
// fprintf(f, "<maddr>");
//
// fprintf(f, " soffs={");
// frm_arg_dump(arg->value.maddr.soffset, f);
// fprintf(f, "}");
//
// fprintf(f, " qual={");
// frm_arg_dump(arg->value.maddr.qual, f);
// fprintf(f, "}");
//
// fprintf(f, " dfmt=%s", arg->value.maddr.data_format);
// fprintf(f, " nfmt=%s", arg->value.maddr.num_format);
//
// break;
// }
/*
case frm_arg_label:
fprintf(f, "<label>");
break;
*/
default:
panic("%s: invalid argument type", __FUNCTION__);
break;
}
}
static void si_bin_file_read_enc_dict(struct si_bin_file_t *bin_file) {
struct elf_file_t *elf_file;
struct elf_buffer_t *buffer;
Elf32_Ehdr *elf_header;
struct elf_program_header_t *program_header;
struct si_bin_enc_dict_entry_t *enc_dict_entry;
struct si_bin_enc_dict_entry_header_t *enc_dict_entry_header;
int enc_dict_entry_count;
int i;
/* ELF header */
elf_file = bin_file->elf_file;
elf_header = elf_file->header;
buffer = &elf_file->buffer;
elf_debug("**\n** Parsing AMD Binary (Internal ELF file)\n** %s\n**\n\n",
elf_file->path);
SI_BIN_FILE_NOT_SUPPORTED_NEQ(elf_header->e_ident[EI_CLASS], ELFCLASS32);
SI_BIN_FILE_NOT_SUPPORTED_NEQ(elf_header->e_ident[EI_DATA], ELFDATA2LSB);
SI_BIN_FILE_NOT_SUPPORTED_NEQ(elf_header->e_ident[EI_OSABI], 0x64);
SI_BIN_FILE_NOT_SUPPORTED_NEQ(elf_header->e_ident[EI_ABIVERSION], 1);
SI_BIN_FILE_NOT_SUPPORTED_NEQ(elf_header->e_type, ET_EXEC);
SI_BIN_FILE_NOT_SUPPORTED_NEQ(elf_header->e_machine, 0x7d);
SI_BIN_FILE_NOT_SUPPORTED_NEQ(elf_header->e_entry, 0);
/* Look for encoding dictionary (program header with type 'PT_LOPROC+2') */
program_header = NULL;
for (i = 0; i < list_count(elf_file->program_header_list); i++) {
program_header = list_get(elf_file->program_header_list, i);
if (program_header->header->p_type == PT_LOPROC + 2) break;
}
if (i == list_count(elf_file->program_header_list) || !program_header)
fatal("%s: no encoding dictionary", elf_file->path);
elf_debug("Encoding dictionary found in program header %d\n", i);
/* Parse encoding dictionary */
SI_BIN_FILE_NOT_SUPPORTED_NEQ(program_header->header->p_vaddr, 0);
SI_BIN_FILE_NOT_SUPPORTED_NEQ(program_header->header->p_paddr, 0);
SI_BIN_FILE_NOT_SUPPORTED_NEQ(program_header->header->p_memsz, 0);
SI_BIN_FILE_NOT_SUPPORTED_NEQ(program_header->header->p_flags, 0);
SI_BIN_FILE_NOT_SUPPORTED_NEQ(program_header->header->p_align, 0);
assert(program_header->header->p_filesz %
sizeof(struct si_bin_enc_dict_entry_header_t) ==
0);
enc_dict_entry_count = program_header->header->p_filesz /
sizeof(struct si_bin_enc_dict_entry_header_t);
elf_debug(" -> %d entries\n\n", enc_dict_entry_count);
/* Read encoding dictionary entries */
bin_file->enc_dict = list_create();
elf_buffer_seek(buffer, program_header->header->p_offset);
for (i = 0; i < enc_dict_entry_count; i++) {
/* Create entry */
enc_dict_entry = xcalloc(1, sizeof(struct si_bin_enc_dict_entry_t));
enc_dict_entry->header = elf_buffer_tell(buffer);
elf_buffer_read(buffer, NULL,
sizeof(struct si_bin_enc_dict_entry_header_t));
list_add(bin_file->enc_dict, enc_dict_entry);
/* Store encoding dictionary entry for Southern Islands.
* Apparently the valid code changes by driver version */
if (enc_dict_entry->header->d_machine == 9) {
/* Driver XXX */
elf_debug("machine = %d (tahiti or pitcairn)\n",
enc_dict_entry->header->d_machine);
bin_file->enc_dict_entry_southern_islands = enc_dict_entry;
} else if (enc_dict_entry->header->d_machine == 25) {
/* This entry is always present but doesn't seem
* useful information. We should probably figure
* out what is stored here. */
elf_debug("machine = 25 (skip this entry)\n");
} else if (enc_dict_entry->header->d_machine == 26) {
/* Driver XXX */
elf_debug("machine = %d (tahiti or pitcairn)\n",
enc_dict_entry->header->d_machine);
bin_file->enc_dict_entry_southern_islands = enc_dict_entry;
} else if (enc_dict_entry->header->d_machine == 27) {
/* Driver 12.4 */
elf_debug("machine = %d (tahiti or pitcairn)\n",
enc_dict_entry->header->d_machine);
bin_file->enc_dict_entry_southern_islands = enc_dict_entry;
} else if (enc_dict_entry->header->d_machine == 28) {
elf_debug("machine = %d (capeverde)\n",
enc_dict_entry->header->d_machine);
bin_file->enc_dict_entry_southern_islands = enc_dict_entry;
} else {
fatal("%s: unknown machine number (%d)\n", __FUNCTION__,
enc_dict_entry->header->d_machine);
}
}
/* Debug */
elf_debug("idx %-15s %-10s %-10s %-10s %-10s\n", "d_machine", "d_type",
"d_offset", "d_size", "d_flags");
for (i = 0; i < 80; i++) elf_debug("-");
elf_debug("\n");
for (i = 0; i < list_count(bin_file->enc_dict); i++) {
char machine_str[MAX_STRING_SIZE];
enc_dict_entry = list_get(bin_file->enc_dict, i);
enc_dict_entry_header = enc_dict_entry->header;
snprintf(machine_str, sizeof(machine_str), "%d (%s)",
enc_dict_entry_header->d_machine,
str_map_value(&enc_dict_machine_map,
enc_dict_entry_header->d_machine - 1));
elf_debug("%3d %-15s 0x%-8x 0x%-8x %-10d 0x%-8x\n", i, machine_str,
enc_dict_entry_header->d_type, enc_dict_entry_header->d_offset,
enc_dict_entry_header->d_size, enc_dict_entry_header->d_flags);
}
elf_debug("\n\n");
}
