void json_write_uint64(OutputStream * out, uint64_t n) {
if (n >= 10) {
json_write_uint64(out, n / 10);
n = n % 10;
}
write_stream(out, (int)n + '0');
}
void json_write_int64(OutputStream * out, int64_t n) {
if (n < 0) {
write_stream(out, '-');
n = -n;
}
json_write_uint64(out, (uint64_t)n);
}
void send_event_memory_changed(Context * ctx, ContextAddress addr, unsigned long size) {
OutputStream * out = &broadcast_group->out;
if (!context_has_state(ctx) || is_intercepted(ctx)) {
write_stringz(out, "E");
write_stringz(out, MEMORY);
write_stringz(out, "memoryChanged");
json_write_string(out, ctx->id);
write_stream(out, 0);
/* <array of addres ranges> */
write_stream(out, '[');
write_stream(out, '{');
json_write_string(out, "addr");
write_stream(out, ':');
json_write_uint64(out, addr);
write_stream(out, ',');
json_write_string(out, "size");
write_stream(out, ':');
json_write_ulong(out, size);
write_stream(out, '}');
write_stream(out, ']');
write_stream(out, 0);
write_stream(out, MARKER_EOM);
}
}
static void write_ranges(OutputStream * out, ContextAddress addr, int offs, int status, MemoryErrorInfo * err_info) {
int cnt = 0;
size_t size_valid = 0;
size_t size_error = 0;
if (err_info->error) {
size_valid = err_info->size_valid + offs;
size_error = err_info->size_error;
}
else {
size_valid = offs;
}
write_stream(out, '[');
if (size_valid > 0) {
write_stream(out, '{');
json_write_string(out, "addr");
write_stream(out, ':');
json_write_uint64(out, addr);
write_stream(out, ',');
json_write_string(out, "size");
write_stream(out, ':');
json_write_ulong(out, size_valid);
write_stream(out, ',');
json_write_string(out, "stat");
write_stream(out, ':');
json_write_ulong(out, 0);
write_stream(out, '}');
cnt++;
}
if (size_error > 0) {
if (cnt > 0) write_stream(out, ',');
write_stream(out, '{');
json_write_string(out, "addr");
write_stream(out, ':');
json_write_uint64(out, addr + size_valid);
write_stream(out, ',');
json_write_string(out, "size");
write_stream(out, ':');
json_write_ulong(out, size_error);
write_stream(out, ',');
json_write_string(out, "stat");
write_stream(out, ':');
json_write_ulong(out, BYTE_INVALID | status);
write_stream(out, ',');
json_write_string(out, "msg");
write_stream(out, ':');
write_error_object(out, err_info->error);
write_stream(out, '}');
}
write_stream(out, ']');
write_stream(out, 0);
}
static void command_find_frame_props_cache_client(void * x) {
CommandFindFrameInfo * args = (CommandFindFrameInfo *)x;
Channel * c = cache_channel();
Context * ctx = NULL;
StackTracingInfo * info = NULL;
int err = 0;
ctx = id2ctx(args->id);
if (ctx == NULL) err = ERR_INV_CONTEXT;
else if (get_stack_tracing_info(ctx, args->addr, &info) < 0) err = errno;
cache_exit();
write_stringz(&c->out, "R");
write_stringz(&c->out, args->token);
write_errno(&c->out, err);
if (args->props) {
unsigned cnt = 0;
write_stream(&c->out, '{');
if (info != NULL && info->size) {
json_write_string(&c->out, "CodeAddr");
write_stream(&c->out, ':');
json_write_uint64(&c->out, info->addr);
write_stream(&c->out, ',');
json_write_string(&c->out, "CodeSize");
write_stream(&c->out, ':');
json_write_uint64(&c->out, info->size);
cnt++;
}
if (info != NULL && info->fp != NULL) {
if (cnt++ > 0) write_stream(&c->out, ',');
json_write_string(&c->out, "FP");
write_stream(&c->out, ':');
write_commands(&c->out, ctx, info->fp->cmds, info->fp->cmds_cnt);
}
if (info != NULL && info->regs != NULL) {
int i;
if (cnt++ > 0) write_stream(&c->out, ',');
json_write_string(&c->out, "Regs");
write_stream(&c->out, ':');
write_stream(&c->out, '{');
for (i = 0; i < info->reg_cnt; i++) {
if (i > 0) write_stream(&c->out, ',');
json_write_string(&c->out, register2id(ctx, STACK_NO_FRAME, info->regs[i]->reg));
write_stream(&c->out, ':');
write_commands(&c->out, ctx, info->regs[i]->cmds, info->regs[i]->cmds_cnt);
}
write_stream(&c->out, '}');
}
if (info != NULL && info->subs != NULL) {
int i;
if (cnt++ > 0) write_stream(&c->out, ',');
json_write_string(&c->out, "Inlined");
write_stream(&c->out, ':');
write_stream(&c->out, '[');
for (i = 0; i < info->sub_cnt; i++) {
if (i > 0) write_stream(&c->out, ',');
write_inlined_subroutine_info(&c->out, info->subs[i]);
}
write_stream(&c->out, ']');
}
write_stream(&c->out, '}');
write_stream(&c->out, 0);
}
else {
/* Deprecated, use findFrameProps */
json_write_uint64(&c->out, info ? info->addr : 0);
write_stream(&c->out, 0);
json_write_uint64(&c->out, info ? info->size : 0);
write_stream(&c->out, 0);
if (info == NULL || info->fp == NULL) write_string(&c->out, "null");
else write_commands(&c->out, ctx, info->fp->cmds, info->fp->cmds_cnt);
write_stream(&c->out, 0);
if (info != NULL && info->regs != NULL) {
int i;
write_stream(&c->out, '{');
for (i = 0; i < info->reg_cnt; i++) {
if (i > 0) write_stream(&c->out, ',');
json_write_string(&c->out, register2id(ctx, STACK_NO_FRAME, info->regs[i]->reg));
write_stream(&c->out, ':');
write_commands(&c->out, ctx, info->regs[i]->cmds, info->regs[i]->cmds_cnt);
}
write_stream(&c->out, '}');
}
else {
write_string(&c->out, "null");
}
write_stream(&c->out, 0);
}
write_stream(&c->out, MARKER_EOM);
}
static void command_get_location_info_cache_client(void * x) {
CommandGetLocationInfo * args = (CommandGetLocationInfo *)x;
Channel * c = cache_channel();
LocationInfo * info = NULL;
Context * ctx = NULL;
int frame = STACK_NO_FRAME;
Symbol * sym = NULL;
int err = 0;
if (id2symbol(args->id, &sym) < 0) err = errno;
else if (get_location_info(sym, &info) < 0) err = errno;
else if (get_symbol_frame(sym, &ctx, &frame) < 0) err = errno;
cache_exit();
write_stringz(&c->out, "R");
write_stringz(&c->out, args->token);
write_errno(&c->out, err);
if (info == NULL) {
write_stringz(&c->out, "null");
}
else {
write_stream(&c->out, '{');
json_write_string(&c->out, "BigEndian");
write_stream(&c->out, ':');
json_write_boolean(&c->out, info->big_endian);
write_stream(&c->out, ',');
json_write_string(&c->out, "ValueCmds");
write_stream(&c->out, ':');
write_commands(&c->out, ctx, info->value_cmds.cmds, info->value_cmds.cnt);
if (info->args_cnt) {
write_stream(&c->out, ',');
json_write_string(&c->out, "ArgCnt");
write_stream(&c->out, ':');
json_write_ulong(&c->out, info->args_cnt);
}
if (info->code_size) {
write_stream(&c->out, ',');
json_write_string(&c->out, "CodeAddr");
write_stream(&c->out, ':');
json_write_uint64(&c->out, info->code_addr);
write_stream(&c->out, ',');
json_write_string(&c->out, "CodeSize");
write_stream(&c->out, ':');
json_write_uint64(&c->out, info->code_size);
}
if (info->discr_cnt > 0) {
unsigned i;
write_stream(&c->out, ',');
json_write_string(&c->out, "Discriminant");
write_stream(&c->out, ':');
write_stream(&c->out, '[');
for (i = 0; i < info->discr_cnt; i++) {
DiscriminantRange * r = info->discr_lst + i;
if (i > 0) write_stream(&c->out, ',');
if (r->x == r->y) {
json_write_int64(&c->out, r->x);
}
else {
write_stream(&c->out, '{');
json_write_string(&c->out, "X");
write_stream(&c->out, ':');
json_write_int64(&c->out, r->x);
write_stream(&c->out, ',');
json_write_string(&c->out, "Y");
write_stream(&c->out, ':');
json_write_int64(&c->out, r->y);
write_stream(&c->out, '}');
}
}
write_stream(&c->out, ']');
}
write_stream(&c->out, '}');
write_stream(&c->out, 0);
}
write_stream(&c->out, MARKER_EOM);
}
static void command_get_context_cache_client(void * x) {
CommandGetContextArgs * args = (CommandGetContextArgs *)x;
Channel * c = cache_channel();
int err = 0;
Symbol * sym = NULL;
char * owner = NULL;
char * name = NULL;
int update_policy = 0;
int sym_class = SYM_CLASS_UNKNOWN;
int type_class = TYPE_CLASS_UNKNOWN;
Symbol * type = NULL;
Symbol * base = NULL;
Symbol * index = NULL;
Symbol * container = NULL;
int has_size = 0;
int has_length = 0;
int has_lower_bound = 0;
int has_offset = 0;
int has_address = 0;
int has_frame = 0;
int big_endian = 0;
ContextAddress size = 0;
ContextAddress length = 0;
int64_t lower_bound = 0;
ContextAddress offset = 0;
ContextAddress address = 0;
RegisterDefinition * reg = NULL;
SYM_FLAGS flags = 0;
void * value = NULL;
size_t value_size = 0;
Context * ctx = NULL;
int frame = STACK_NO_FRAME;
SymbolProperties props;
memset(&props, 0, sizeof(props));
if (id2symbol(args->id, &sym) < 0) err = errno;
if (err == 0) {
get_symbol_class(sym, &sym_class);
get_symbol_update_policy(sym, &owner, &update_policy);
get_symbol_name(sym, &name);
get_symbol_type_class(sym, &type_class);
get_symbol_type(sym, &type);
get_symbol_base_type(sym, &base);
get_symbol_index_type(sym, &index);
get_symbol_container(sym, &container);
has_frame = get_symbol_frame(sym, &ctx, &frame) == 0;
has_size = get_symbol_size(sym, &size) == 0;
if (type_class == TYPE_CLASS_ARRAY) {
has_length = get_symbol_length(sym, &length) == 0;
if (has_length) has_lower_bound = get_symbol_lower_bound(sym, &lower_bound) == 0;
}
if (sym_class == SYM_CLASS_REFERENCE || sym_class == SYM_CLASS_FUNCTION ||
sym_class == SYM_CLASS_VALUE || sym_class == SYM_CLASS_TYPE ||
sym_class == SYM_CLASS_VARIANT_PART) {
LocationInfo * loc_info = NULL;
if (has_frame && get_location_info(sym, &loc_info) == 0) {
LocationExpressionState * state = NULL;
if (loc_info->args_cnt == 0) {
/* Absolute location */
state = evaluate_location(ctx, frame, loc_info);
if (state != NULL) {
if (state->stk_pos == 1) {
address = (ContextAddress)state->stk[0];
has_address = 1;
}
if (state->pieces_cnt == 1 && state->pieces->reg != NULL &&
state->pieces->reg->size == state->pieces->size) {
reg = state->pieces->reg;
}
if (state->pieces_cnt > 0) {
Trap trap;
if (set_trap(&trap)) {
read_location_pieces(state->ctx, state->stack_frame,
state->pieces, state->pieces_cnt, loc_info->big_endian, &value, &value_size);
big_endian = loc_info->big_endian;
clear_trap(&trap);
}
}
}
}
else if (loc_info->args_cnt == 1) {
/* Relative location */
state = evaluate_location(ctx, frame, loc_info);
if (state != NULL && state->stk_pos == 1) {
offset = (ContextAddress)state->stk[0];
has_offset = 1;
}
}
}
}
get_symbol_flags(sym, &flags);
get_symbol_props(sym, &props);
}
cache_exit();
write_stringz(&c->out, "R");
write_stringz(&c->out, args->token);
write_errno(&c->out, err);
if (err == 0) {
write_stream(&c->out, '{');
json_write_string(&c->out, "ID");
write_stream(&c->out, ':');
json_write_string(&c->out, args->id);
write_stream(&c->out, ',');
if (owner != NULL) {
json_write_string(&c->out, "OwnerID");
write_stream(&c->out, ':');
json_write_string(&c->out, owner);
write_stream(&c->out, ',');
json_write_string(&c->out, "UpdatePolicy");
write_stream(&c->out, ':');
json_write_long(&c->out, update_policy);
write_stream(&c->out, ',');
}
if (name != NULL) {
json_write_string(&c->out, "Name");
write_stream(&c->out, ':');
json_write_string(&c->out, name);
write_stream(&c->out, ',');
}
if (type_class != TYPE_CLASS_UNKNOWN) {
json_write_string(&c->out, "TypeClass");
write_stream(&c->out, ':');
json_write_long(&c->out, type_class);
write_stream(&c->out, ',');
}
if (type != NULL) {
json_write_string(&c->out, "TypeID");
write_stream(&c->out, ':');
json_write_string(&c->out, symbol2id(type));
write_stream(&c->out, ',');
}
if (base != NULL) {
json_write_string(&c->out, "BaseTypeID");
write_stream(&c->out, ':');
json_write_string(&c->out, symbol2id(base));
write_stream(&c->out, ',');
}
if (index != NULL) {
json_write_string(&c->out, "IndexTypeID");
write_stream(&c->out, ':');
json_write_string(&c->out, symbol2id(index));
write_stream(&c->out, ',');
}
if (container != NULL) {
json_write_string(&c->out, "ContainerID");
write_stream(&c->out, ':');
json_write_string(&c->out, symbol2id(container));
write_stream(&c->out, ',');
}
if (has_size) {
json_write_string(&c->out, "Size");
write_stream(&c->out, ':');
json_write_uint64(&c->out, size);
write_stream(&c->out, ',');
}
if (has_length) {
json_write_string(&c->out, "Length");
write_stream(&c->out, ':');
json_write_uint64(&c->out, length);
write_stream(&c->out, ',');
if (has_lower_bound) {
json_write_string(&c->out, "LowerBound");
write_stream(&c->out, ':');
json_write_int64(&c->out, lower_bound);
write_stream(&c->out, ',');
json_write_string(&c->out, "UpperBound");
write_stream(&c->out, ':');
json_write_int64(&c->out, lower_bound + (int64_t)length - 1);
write_stream(&c->out, ',');
}
}
if (has_offset) {
json_write_string(&c->out, "Offset");
write_stream(&c->out, ':');
json_write_uint64(&c->out, offset);
write_stream(&c->out, ',');
}
if (has_address) {
json_write_string(&c->out, "Address");
write_stream(&c->out, ':');
json_write_uint64(&c->out, address);
write_stream(&c->out, ',');
}
if (reg != NULL && has_frame) {
json_write_string(&c->out, "Register");
write_stream(&c->out, ':');
json_write_string(&c->out, register2id(ctx, frame, reg));
write_stream(&c->out, ',');
}
if (flags) {
json_write_string(&c->out, "Flags");
write_stream(&c->out, ':');
json_write_long(&c->out, flags);
write_stream(&c->out, ',');
}
if (props.binary_scale != 0) {
json_write_string(&c->out, "BinaryScale");
write_stream(&c->out, ':');
json_write_long(&c->out, props.binary_scale);
write_stream(&c->out, ',');
}
if (props.decimal_scale != 0) {
json_write_string(&c->out, "DecimalScale");
write_stream(&c->out, ':');
json_write_long(&c->out, props.decimal_scale);
write_stream(&c->out, ',');
}
if (props.bit_stride != 0) {
json_write_string(&c->out, "BitStride");
write_stream(&c->out, ':');
json_write_ulong(&c->out, props.bit_stride);
write_stream(&c->out, ',');
}
if (props.local_entry_offset != 0) {
json_write_string(&c->out, "LocalEntryOffset");
write_stream(&c->out, ':');
json_write_ulong(&c->out, props.local_entry_offset);
write_stream(&c->out, ',');
}
if (value != NULL) {
json_write_string(&c->out, "Value");
write_stream(&c->out, ':');
json_write_binary(&c->out, value, value_size);
write_stream(&c->out, ',');
if (big_endian) {
json_write_string(&c->out, "BigEndian");
write_stream(&c->out, ':');
json_write_boolean(&c->out, 1);
write_stream(&c->out, ',');
}
}
if (has_frame && frame != STACK_NO_FRAME) {
json_write_string(&c->out, "Frame");
write_stream(&c->out, ':');
json_write_long(&c->out, frame);
write_stream(&c->out, ',');
}
json_write_string(&c->out, "Class");
write_stream(&c->out, ':');
json_write_long(&c->out, sym_class);
write_stream(&c->out, '}');
write_stream(&c->out, 0);
}
else {
write_stringz(&c->out, "null");
}
write_stream(&c->out, MARKER_EOM);
}
static void command_get_sym_file_info_cache_client(void * x) {
int err = 0;
MemoryMap * client_map = NULL;
MemoryMap * target_map = NULL;
MemoryRegion * region = NULL;
Channel * c = cache_channel();
CommandSymFileInfo * args = (CommandSymFileInfo *)x;
const char * sym_file = NULL;
Context * ctx = NULL;
int sym_error = 0;
ctx = id2ctx(args->id);
if (ctx == NULL) err = ERR_INV_CONTEXT;
if (!err && memory_map_get(ctx, &client_map, &target_map) < 0) err = errno;
if (!err) {
unsigned i;
for (i = 0; i < client_map->region_cnt; i++) {
MemoryRegion * r = client_map->regions + i;
if (r->addr <= args->addr && r->addr + r->size > args->addr) region = r;
}
if (region == NULL) {
for (i = 0; i < target_map->region_cnt; i++) {
MemoryRegion * r = target_map->regions + i;
if (r->addr <= args->addr && r->addr + r->size > args->addr) region = r;
}
}
#if ENABLE_ELF
/* TODO: need a generic way to support ELF program headers in getSymFileInfo command */
if (region == NULL) {
static MemoryMap map;
extern int elf_get_map(Context * ctx, ContextAddress addr0, ContextAddress addr1, MemoryMap * map);
if (elf_get_map(ctx, args->addr, args->addr, &map) == 0) {
for (i = 0; i < map.region_cnt; i++) {
MemoryRegion * r = map.regions + i;
if (r->addr <= args->addr && r->addr + r->size > args->addr) region = r;
}
}
}
#endif
sym_file = get_symbol_file_name(ctx, region);
sym_error = errno;
}
cache_exit();
write_stringz(&c->out, "R");
write_stringz(&c->out, args->token);
write_errno(&c->out, err);
if (region != NULL) {
write_stream(&c->out, '{');
json_write_string(&c->out, "Addr");
write_stream(&c->out, ':');
json_write_uint64(&c->out, region->addr);
write_stream(&c->out, ',');
json_write_string(&c->out, "Size");
write_stream(&c->out, ':');
json_write_uint64(&c->out, region->size);
if (sym_file != NULL) {
write_stream(&c->out, ',');
json_write_string(&c->out, "FileName");
write_stream(&c->out, ':');
json_write_string(&c->out, sym_file);
}
if (sym_error != 0) {
write_stream(&c->out, ',');
json_write_string(&c->out, "FileError");
write_stream(&c->out, ':');
write_error_object(&c->out, sym_error);
}
write_stream(&c->out, '}');
write_stream(&c->out, 0);
}
else {
write_stringz(&c->out, "null");
}
write_stream(&c->out, MARKER_EOM);
}
static void write_context(OutputStream * out, char * id,
Context * ctx, int frame, RegisterDefinition * reg_def) {
assert(!ctx->exited);
write_stream(out, '{');
json_write_string(out, "ID");
write_stream(out, ':');
json_write_string(out, id);
write_stream(out, ',');
json_write_string(out, "ParentID");
write_stream(out, ':');
if (reg_def->parent != NULL) {
json_write_string(out, register2id(ctx, frame, reg_def->parent));
}
else if (frame < 0 || is_top_frame(ctx, frame)) {
json_write_string(out, ctx->id);
}
else {
json_write_string(out, frame2id(ctx, frame));
}
write_stream(out, ',');
json_write_string(out, "ProcessID");
write_stream(out, ':');
json_write_string(out, context_get_group(ctx, CONTEXT_GROUP_PROCESS)->id);
write_stream(out, ',');
json_write_string(out, "Name");
write_stream(out, ':');
json_write_string(out, reg_def->name);
if (reg_def->size > 0) {
write_stream(out, ',');
json_write_string(out, "Size");
write_stream(out, ':');
json_write_long(out, reg_def->size);
}
if (reg_def->dwarf_id >= 0) {
write_stream(out, ',');
json_write_string(out, "DwarfID");
write_stream(out, ':');
json_write_long(out, reg_def->dwarf_id);
}
if (reg_def->eh_frame_id >= 0) {
write_stream(out, ',');
json_write_string(out, "EhFrameID");
write_stream(out, ':');
json_write_long(out, reg_def->eh_frame_id);
}
write_boolean_member(out, "BigEndian", reg_def->big_endian);
write_boolean_member(out, "Float", reg_def->fp_value);
write_boolean_member(out, "Readable", !reg_def->no_read);
write_boolean_member(out, "Writeable", !reg_def->no_write);
write_boolean_member(out, "ReadOnce", reg_def->read_once);
write_boolean_member(out, "WriteOnce", reg_def->write_once);
write_boolean_member(out, "Volatile", reg_def->volatile_value);
write_boolean_member(out, "SideEffects", reg_def->side_effects);
write_boolean_member(out, "LeftToRight", reg_def->left_to_right);
if (reg_def->first_bit > 0) {
write_stream(out, ',');
json_write_string(out, "FirstBit");
write_stream(out, ':');
json_write_long(out, reg_def->first_bit);
}
if (reg_def->bits != NULL) {
int i = 0;
write_stream(out, ',');
json_write_string(out, "Bits");
write_stream(out, ':');
write_stream(out, '[');
while (reg_def->bits[i] >= 0) {
if (i > 0) write_stream(out, ',');
json_write_long(out, reg_def->bits[i++]);
}
write_stream(out, ']');
}
if (reg_def->values != NULL) {
int i = 0;
write_stream(out, ',');
json_write_string(out, "Values");
write_stream(out, ':');
write_stream(out, '[');
while (reg_def->values[i] != NULL) {
NamedRegisterValue * v = reg_def->values[i++];
if (i > 1) write_stream(out, ',');
write_stream(out, '{');
json_write_string(out, "Value");
write_stream(out, ':');
json_write_binary(out, v->value, reg_def->size);
if (v->name != NULL) {
write_stream(out, ',');
json_write_string(out, "Name");
write_stream(out, ':');
json_write_string(out, v->name);
}
if (v->description != NULL) {
write_stream(out, ',');
json_write_string(out, "Description");
write_stream(out, ':');
json_write_string(out, v->description);
}
write_stream(out, '}');
}
write_stream(out, ']');
}
if (reg_def->memory_address > 0) {
write_stream(out, ',');
json_write_string(out, "MemoryAddress");
write_stream(out, ':');
json_write_uint64(out, reg_def->memory_address);
}
if (reg_def->memory_context != NULL) {
write_stream(out, ',');
json_write_string(out, "MemoryContext");
write_stream(out, ':');
json_write_string(out, reg_def->memory_context);
}
if (reg_def->role != NULL) {
write_stream(out, ',');
json_write_string(out, "Role");
write_stream(out, ':');
json_write_string(out, reg_def->role);
}
else if (reg_def == get_PC_definition(ctx)) {
write_stream(out, ',');
json_write_string(out, "Role");
write_stream(out, ':');
json_write_string(out, "PC");
}
if (reg_def->description != NULL) {
write_stream(out, ',');
json_write_string(out, "Description");
write_stream(out, ':');
json_write_string(out, reg_def->description);
}
if (reg_def->size > 0) {
RegisterDefinition * parent_reg_def = NULL;
parent_reg_def = reg_def->parent;
while (parent_reg_def != NULL && parent_reg_def->size == 0) parent_reg_def = parent_reg_def->parent;
if (parent_reg_def != NULL) {
if (reg_def->offset >= parent_reg_def->offset &&
reg_def->offset + reg_def->size <= parent_reg_def->offset + parent_reg_def->size) {
write_stream(out, ',');
json_write_string(out, "Offset");
write_stream(out, ':');
json_write_uint64(out, reg_def->offset - parent_reg_def->offset);
}
}
}
write_stream(out, '}');
write_stream(out, 0);
}
static int disassemble_block(Context * ctx, OutputStream * out, uint8_t * mem_buf,
ContextAddress buf_addr, ContextAddress buf_size,
ContextAddress mem_size, ContextISA * isa,
DisassembleCmdArgs * args) {
ContextAddress offs = 0;
Disassembler * disassembler = NULL;
Context * cpu = context_get_group(ctx, CONTEXT_GROUP_CPU);
int disassembler_ok = 0;
DisassemblerParams param;
param.ctx = ctx;
param.big_endian = ctx->big_endian;
param.pseudo_instr = args->pseudo_instr;
param.simplified = args->simplified;
if (args->isa) {
isa->isa = args->isa;
isa->addr = args->addr;
isa->size = args->size;
}
write_stream(out, '[');
while (offs < buf_size && offs < mem_size) {
ContextAddress addr = buf_addr + offs;
ContextAddress size = mem_size - offs;
DisassemblyResult * dr = NULL;
if (args->isa == NULL && (addr < isa->addr ||
(isa->addr + isa->size >= isa->addr && addr >= isa->addr + isa->size))) {
if (get_isa(ctx, addr, isa) < 0) return -1;
disassembler_ok = 0;
}
if (!disassembler_ok) {
disassembler = find_disassembler(cpu, isa->isa);
if (disassembler == NULL) disassembler = find_disassembler(cpu, isa->def);
disassembler_ok = 1;
}
if (disassembler) dr = disassembler(mem_buf + (size_t)offs, addr, size, ¶m);
if (dr == NULL) {
static char buf[32];
static DisassemblyResult dd;
memset(&dd, 0, sizeof(dd));
if (isa->alignment >= 4 && (addr & 0x3) == 0 && offs <= mem_size + 4) {
unsigned i;
uint32_t v = 0;
for (i = 0; i < 4; i++) v |= (uint32_t)mem_buf[offs + i] << (i * 8);
snprintf(buf, sizeof(buf), ".word 0x%08x", v);
dd.size = 4;
}
else if (isa->alignment >= 2 && (addr & 0x1) == 0 && offs <= mem_size + 2) {
unsigned i;
uint16_t v = 0;
for (i = 0; i < 2; i++) v |= (uint16_t)mem_buf[offs + i] << (i * 8);
snprintf(buf, sizeof(buf), ".half 0x%04x", v);
dd.size = 2;
}
else {
snprintf(buf, sizeof(buf), ".byte 0x%02x", mem_buf[offs]);
dd.size = 1;
}
dd.text = buf;
dr = ⅆ
}
assert(dr->size > 0);
if (offs > 0) write_stream(out, ',');
write_stream(out, '{');
json_write_string(out, "Address");
write_stream(out, ':');
json_write_uint64(out, addr);
write_stream(out, ',');
json_write_string(out, "Size");
write_stream(out, ':');
json_write_uint64(out, dr->size);
write_stream(out, ',');
json_write_string(out, "Instruction");
write_stream(out, ':');
write_stream(out, '[');
write_stream(out, '{');
json_write_string(out, "Type");
write_stream(out, ':');
json_write_string(out, "String");
write_stream(out, ',');
json_write_string(out, "Text");
write_stream(out, ':');
json_write_string(out, dr->text);
write_stream(out, '}');
write_stream(out, ']');
if (args->opcode_value) {
write_stream(out, ',');
json_write_string(out, "OpcodeValue");
write_stream(out, ':');
json_write_binary(out, mem_buf + (size_t)offs, (size_t)dr->size);
}
write_stream(out, '}');
offs += dr->size;
}
write_stream(out, ']');
return 0;
}
