TEST(FirstPass, get_symbol_name) {
char a[] = "NAME: .entry XYZ";
char b[] = ".entry XYZ";
char c[] = "DATA: .extern A";
char d[] = ".extern HELLO";
char e[] = ".extern";
EXPECT_STREQ(get_symbol_name(a), "XYZ");
EXPECT_STREQ(get_symbol_name(b), "XYZ");
EXPECT_STREQ(get_symbol_name(c), "A");
EXPECT_STREQ(get_symbol_name(d), "HELLO");
EXPECT_STREQ(get_symbol_name(e), NULL);
}
static bfd_boolean
other_register_name (expressionS *expressionP)
{
int reg_number;
char *name;
char *start;
char c;
/* Find the spelling of the operand. */
start = input_line_pointer;
c = get_symbol_name (&name);
reg_number = reg_name_search (other_registers, OTHER_REG_NAME_CNT, name);
/* Put back the delimiting char. */
(void) restore_line_pointer (c);
/* Look to see if it's in the register table. */
if (reg_number >= 0)
{
expressionP->X_op = O_register;
expressionP->X_add_number = reg_number;
/* Make the rest nice. */
expressionP->X_add_symbol = NULL;
expressionP->X_op_symbol = NULL;
return TRUE;
}
/* Reset the line as if we had not done anything. */
input_line_pointer = start;
return FALSE;
}
static void update_debug_info(struct DebugInfo *info,
struct SymbolTableEntry *stab_entry)
{
char symbol_name[NAME_MAX_LENGTH];
get_symbol_name(stab_entry, symbol_name);
switch (stab_entry->n_type) {
case SYMBOL_SOURCE_FILE:
strcpy(info->file, symbol_name);
break;
case SYMBOL_FUNCTION:
strcpy(info->function, symbol_name);
info->function_address = stab_entry->n_value;
info->arg_count = 0;
break;
case SYMBOL_PARAMETER:
strcpy(info->arg_names[info->arg_count], symbol_name);
info->arg_positions[info->arg_count] = stab_entry->n_value;
info->arg_count++;
break;
case SYMBOL_SOURCE_LINE:
info->source_line_address = info->function_address +
stab_entry->n_value;
info->source_line_number = stab_entry->n_desc - 1;
break;
}
}
/*
* get_function_bounds finds a function with given name and puts its start
* and end addresses in the given output arguments.
*/
void get_function_bounds(const char *name, int *begin, int *end)
{
struct SymbolTableEntry *stab_entry = NULL;
char symbol_name[NAME_MAX_LENGTH];
*begin = *end = -1;
stab_entry = (struct SymbolTableEntry *) STAB_BEGIN;
while (stab_entry != STAB_END) {
if (stab_entry->n_type == SYMBOL_FUNCTION) {
get_symbol_name(stab_entry, symbol_name);
if (strcmp(symbol_name, name) == 0) {
*begin = stab_entry->n_value;
}
else if (*begin != -1) {
*end = stab_entry->n_value;
break;
}
}
stab_entry++;
}
if (*begin != -1 && *end == -1) {
*end = (int) STAB_END;
}
}
static symtab make_symtab(const ex& l)
{
symtab syms;
if (is_exactly_a<lst>(l)) {
for (std::size_t i = 0; i < l.nops(); i++) {
const ex &o = l.op(i);
if (is_a<symbol>(o) || (is_a<idx>(o) && is_a<symbol>(o.op(0))))
syms[get_symbol_name(o)] = o;
}
}
return syms;
}
void print_ir_node(FILE *out, IrNode *irn) {
fprintf(out, "(");
switch(irn->instruction) {
case BEGIN_PROC:
fprintf(out, "beginproc, \"%s\"", get_symbol_name(irn->s));
break;
case END_PROC:
fprintf(out, "endproc, \"%s\"", get_symbol_name(irn->s));
break;
case RETURN_FROM_PROC:
if (irn->RSRC == NO_ARG) {
fprintf(out, "return, \"LABEL_%d\"", irn->branch->LABIDX);
} else {
fprintf(out, "return, \"LABEL_%d\", $r%d",
irn->branch->LABIDX, irn->RSRC);
}
break;
case BEGIN_CALL:
fprintf(out, "begincall, \"%s\"", get_symbol_name(irn->s));
break;
case PARAM:
fprintf(out, "param, %d, $r%d", irn->RDEST, irn->RSRC);
break;
case CALL:
fprintf(out, "call, \"%s\"", get_symbol_name(irn->s));
break;
case END_CALL:
fprintf(out, "endcall, \"%s\"", get_symbol_name(irn->s));
break;
case STORE_WORD_INDIRECT:
fprintf(out, "storewordindirect, $r%d, $r%d",
irn->RSRC, irn->RDEST);
break;
case LOAD_ADDRESS:
fprintf(out, "loadaddress, $r%d, %s",
irn->RDEST, get_symbol_name(irn->s));
break;
case LOAD_WORD_INDIRECT:
fprintf(out, "loadwordindirect, $r%d, $r%d", irn->RDEST, irn->RSRC);
break;
case LOAD_CONSTANT:
fprintf(out, "loadconstant, $r%d, %d", irn->RDEST, irn->IMMVAL);
break;
case LOG_OR:
fprintf(out, "logicalor, $r%d, $r%d, $r%d",
irn->RDEST, irn->OPRND1, irn->OPRND2);
break;
case LABEL:
fprintf(out, "label, \"LABEL_%d\"", irn->LABIDX);
break;
default:
break;
}
fprintf(out, ")\n");
}
//--------------------------------------------------------------------------
static void load_symbols(linput_t *li, header &h, long fpos, int n)
{
if ( !n ) return;
qlseek(li, fpos);
char buf[MAXSTR];
for ( int i=0; i < n; i++ )
{
symbol_dictionary_record sr;
lread(li, &sr, sizeof(sr));
sr.swap();
if ( sr.symbol_scope() == SS_UNSAT ) continue;
char *name = get_symbol_name(li, h, sr.name.n_strx, buf, sizeof(buf));
ea_t ea = sr.symbol_value & ~3;
switch ( sr.symbol_type() )
{
case ST_NULL :
case ST_ABSOLUTE :
break;
case ST_DATA :
do_name_anyway(ea, name);
break;
case ST_STUB :
append_cmt(ea, "STUB", false);
case ST_CODE :
case ST_ENTRY :
case ST_MILLICODE:
case ST_MILLI_EXT:
add_entry(ea, ea, name, true);
add_entry(ea, ea, name, true);
break;
case ST_PRI_PROG :
case ST_STORAGE :
case ST_MODULE :
case ST_SYM_EXT :
case ST_ARG_EXT :
case ST_PLABEL :
case ST_OCT_DIS :
case ST_TSTORAGE :
break;
}
}
}
static ContextAddress find_module(Context * ctx, ELF_File * exe_file, ELF_File * module,
ContextAddress r_map, ContextAddress r_brk) {
#if ENABLE_Symbols
Symbol * sym = NULL;
int i = 0, n = 0;
Symbol ** children = NULL;
ContextAddress link = r_map;
Symbol * sym_l_addr = NULL;
Symbol * sym_l_next = NULL;
Symbol * sym_l_tls_modid = NULL;
if (find_symbol_by_name(ctx, STACK_NO_FRAME, r_brk, "link_map", &sym) < 0)
str_exception(errno, "Cannot find loader symbol: link_map");
if (get_symbol_children(sym, &children, &n) < 0) exception(errno);
for (i = 0; i < n; i++) {
char * name = NULL;
if (get_symbol_name(children[i], &name) < 0) exception(errno);
if (name == NULL) continue;
if (strcmp(name, "l_map_start") == 0) sym_l_addr = children[i];
else if (strcmp(name, "l_next") == 0) sym_l_next = children[i];
else if (strcmp(name, "l_tls_modid") == 0) sym_l_tls_modid = children[i];
}
if (sym_l_addr == NULL || sym_l_next == NULL || sym_l_tls_modid == NULL)
str_exception(ERR_OTHER, "Invalid 'link_map' fields");
while (link != 0) {
ContextAddress l_tls_modid = 0;
read_field(ctx, sym_l_tls_modid, link, &l_tls_modid);
if (l_tls_modid != 0) {
ContextAddress l_addr = 0;
ELF_File * link_file = NULL;
read_field(ctx, sym_l_addr, link, &l_addr);
elf_map_to_link_time_address(ctx, l_addr, 0, &link_file, NULL);
if (link_file != NULL) {
if (link_file == module) return l_tls_modid;
if (get_dwarf_file(link_file) == module) return l_tls_modid;
}
}
read_field(ctx, sym_l_next, link, &link);
}
#endif
return 0;
}
static void add_addr(uint64_t addr) {
add_hex_uint64(addr);
#if ENABLE_Symbols
if (ctx != NULL) {
Symbol * sym = NULL;
char * name = NULL;
ContextAddress sym_addr = 0;
if (find_symbol_by_addr(ctx, STACK_NO_FRAME, (ContextAddress)addr, &sym) < 0) return;
if (get_symbol_name(sym, &name) < 0 || name == NULL) return;
if (get_symbol_address(sym, &sym_addr) < 0) return;
if (sym_addr <= addr) {
add_str(" ; ");
add_str(name);
if (sym_addr < addr) {
add_str(" + 0x");
add_hex_uint64(addr - sym_addr);
}
}
}
#endif
}
void eval_symbol(void)
{
symbol* the_sym = (symbol*)input;
if(the_sym->meta_level == 0)
{
binding* the_binding = find_binding_delegating(the_sym->id,current_scope);
if(the_binding != NULL)
{
void* value = the_binding->value;
if(value != the_sym)
schedule_next(value);
else /* the symbol is a singleton */
execute_waiter();
}
else
printf("error:\nsymbol :%s is bound to nothing in this accumulative context", get_symbol_name(the_sym->id));
}
else
{
input = make_symbol(the_sym->id,the_sym->meta_level-1);
execute_waiter();
}
}
operatorT i386_operator (const char *name, unsigned int operands, char *pc)
{
unsigned int j;
if (!intel_syntax)
return O_absent;
if (!name)
{
if (operands != 2)
return O_illegal;
switch (*input_line_pointer)
{
case ':':
++input_line_pointer;
return O_full_ptr;
case '[':
++input_line_pointer;
return O_index;
case '@':
if (this_operand >= 0 && i.reloc[this_operand] == NO_RELOC)
{
int adjust = 0;
char *gotfree_input_line = lex_got (&i.reloc[this_operand],
&adjust,
&intel_state.reloc_types);
if (!gotfree_input_line)
break;
free (gotfree_input_line);
*input_line_pointer++ = '+';
memset (input_line_pointer, '0', adjust - 1);
input_line_pointer[adjust - 1] = ' ';
return O_add;
}
break;
}
return O_illegal;
}
for (j = 0; i386_operators[j].name; ++j)
if (strcasecmp (i386_operators[j].name, name) == 0)
{
if (i386_operators[j].operands
&& i386_operators[j].operands != operands)
return O_illegal;
return i386_operators[j].op;
}
for (j = 0; i386_types[j].name; ++j)
if (strcasecmp (i386_types[j].name, name) == 0)
break;
if (i386_types[j].name && *pc == ' ')
{
char *pname;
char c;
++input_line_pointer;
c = get_symbol_name (&pname);
if (strcasecmp (pname, "ptr") == 0)
{
/* FIXME: What if c == '"' ? */
pname[-1] = *pc;
*pc = c;
if (intel_syntax > 0 || operands != 1)
return O_illegal;
return i386_types[j].op;
}
(void) restore_line_pointer (c);
input_line_pointer = pname - 1;
}
return O_absent;
}
static void command_get_context(char * token, Channel * c) {
int err = 0;
char id[256];
Symbol sym;
json_read_string(&c->inp, id, sizeof(id));
if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);
if (read_stream(&c->inp) != MARKER_EOM) exception(ERR_JSON_SYNTAX);
if (id2symbol(id, &sym) < 0) err = errno;
write_stringz(&c->out, "R");
write_stringz(&c->out, token);
write_errno(&c->out, err);
if (err == 0) {
char * name = NULL;
int type_class = TYPE_CLASS_UNKNOWN;
Symbol type;
size_t size = 0;
void * value = NULL;
unsigned long length = 0;
unsigned long offset = 0;
ContextAddress address = 0;
int frame = STACK_NO_FRAME; /* TODO: symbol frame */
write_stream(&c->out, '{');
json_write_string(&c->out, "ID");
write_stream(&c->out, ':');
json_write_string(&c->out, id);
write_stream(&c->out, ',');
json_write_string(&c->out, "ExeID");
write_stream(&c->out, ':');
json_write_string(&c->out, container_id(sym.ctx));
write_stream(&c->out, ',');
if (get_symbol_name(&sym, &name) == 0 && name != NULL) {
json_write_string(&c->out, "Name");
write_stream(&c->out, ':');
json_write_string(&c->out, name);
write_stream(&c->out, ',');
loc_free(name);
}
if (get_symbol_type_class(&sym, &type_class) == 0 && 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 (get_symbol_type(&sym, &type) == 0) {
json_write_string(&c->out, "TypeID");
write_stream(&c->out, ':');
json_write_string(&c->out, symbol2id(&type));
write_stream(&c->out, ',');
}
if (get_symbol_base_type(&sym, &type) == 0) {
json_write_string(&c->out, "BaseTypeID");
write_stream(&c->out, ':');
json_write_string(&c->out, symbol2id(&type));
write_stream(&c->out, ',');
}
if (get_symbol_index_type(&sym, &type) == 0) {
json_write_string(&c->out, "IndexTypeID");
write_stream(&c->out, ':');
json_write_string(&c->out, symbol2id(&type));
write_stream(&c->out, ',');
}
if (get_symbol_size(&sym, frame, &size) == 0) {
json_write_string(&c->out, "Size");
write_stream(&c->out, ':');
json_write_long(&c->out, size);
write_stream(&c->out, ',');
}
if (get_symbol_length(&sym, frame, &length) == 0) {
json_write_string(&c->out, "Length");
write_stream(&c->out, ':');
json_write_long(&c->out, length);
write_stream(&c->out, ',');
}
if (sym.sym_class == SYM_CLASS_REFERENCE) {
if (get_symbol_offset(&sym, &offset) == 0) {
json_write_string(&c->out, "Offset");
write_stream(&c->out, ':');
json_write_long(&c->out, offset);
write_stream(&c->out, ',');
}
if (get_symbol_address(&sym, frame, &address) == 0) {
json_write_string(&c->out, "Address");
write_stream(&c->out, ':');
json_write_long(&c->out, address);
write_stream(&c->out, ',');
}
}
if (sym.sym_class == SYM_CLASS_VALUE && get_symbol_value(&sym, &value, &size) == 0) {
json_write_string(&c->out, "Value");
write_stream(&c->out, ':');
json_write_binary(&c->out, value, size);
write_stream(&c->out, ',');
}
json_write_string(&c->out, "Class");
write_stream(&c->out, ':');
json_write_long(&c->out, sym.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_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);
}
