bytes. If SOURCE_SIZE is greater than DEST_SIZE, then truncate the most
significant bytes. If SOURCE_SIZE is less than DEST_SIZE then either sign
or zero extended according to IS_SIGNED. Values are stored in memory with
- endianess BYTE_ORDER. */
+ endianness BYTE_ORDER. */
void
copy_integer_to_size (gdb_byte *dest, int dest_size, const gdb_byte *source,
unsigned_pointer_to_address (struct gdbarch *gdbarch,
struct type *type, const gdb_byte *buf)
{
- enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+ enum bfd_endian byte_order = type_byte_order (type);
return extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);
}
signed_pointer_to_address (struct gdbarch *gdbarch,
struct type *type, const gdb_byte *buf)
{
- enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+ enum bfd_endian byte_order = type_byte_order (type);
return extract_signed_integer (buf, TYPE_LENGTH (type), byte_order);
}
unsigned_address_to_pointer (struct gdbarch *gdbarch, struct type *type,
gdb_byte *buf, CORE_ADDR addr)
{
- enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+ enum bfd_endian byte_order = type_byte_order (type);
store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order, addr);
}
address_to_signed_pointer (struct gdbarch *gdbarch, struct type *type,
gdb_byte *buf, CORE_ADDR addr)
{
- enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+ enum bfd_endian byte_order = type_byte_order (type);
store_signed_integer (buf, TYPE_LENGTH (type), byte_order, addr);
}
QUIT;
/* If we don't know how to compute FRAME's base address, don't give up:
- maybe the frame we are looking for is upper in the stace frame. */
+ maybe the frame we are looking for is upper in the stack frame. */
if (framefunc != NULL
&& SYMBOL_BLOCK_OPS (framefunc) != NULL
&& SYMBOL_BLOCK_OPS (framefunc)->get_frame_base != NULL
{
if (BLOCK_FUNCTION (var_block)
&& !block_inlined_p (var_block)
- && SYMBOL_PRINT_NAME (BLOCK_FUNCTION (var_block)))
+ && BLOCK_FUNCTION (var_block)->print_name ())
error (_("No frame is currently executing in block %s."),
- SYMBOL_PRINT_NAME (BLOCK_FUNCTION (var_block)));
+ BLOCK_FUNCTION (var_block)->print_name ());
else
error (_("No frame is currently executing in specified"
" block"));
if (sym_need == SYMBOL_NEEDS_FRAME)
gdb_assert (frame != NULL);
else if (sym_need == SYMBOL_NEEDS_REGISTERS && !target_has_registers)
- error (_("Cannot read `%s' without registers"), SYMBOL_PRINT_NAME (var));
+ error (_("Cannot read `%s' without registers"), var->print_name ());
if (frame != NULL)
frame = get_hosting_frame (var, var_block, frame);
/* Put the constant back in target format. */
v = allocate_value (type);
store_signed_integer (value_contents_raw (v), TYPE_LENGTH (type),
- gdbarch_byte_order (get_type_arch (type)),
+ type_byte_order (type),
(LONGEST) SYMBOL_VALUE (var));
VALUE_LVAL (v) = not_lval;
return v;
addr = get_frame_args_address (frame);
if (!addr)
error (_("Unknown argument list address for `%s'."),
- SYMBOL_PRINT_NAME (var));
+ var->print_name ());
addr += SYMBOL_VALUE (var);
break;
argref = get_frame_args_address (frame);
if (!argref)
error (_("Unknown argument list address for `%s'."),
- SYMBOL_PRINT_NAME (var));
+ var->print_name ());
argref += SYMBOL_VALUE (var);
ref = value_at (lookup_pointer_type (type), argref);
addr = value_as_address (ref);
case LOC_TYPEDEF:
error (_("Cannot look up value of a typedef `%s'."),
- SYMBOL_PRINT_NAME (var));
+ var->print_name ());
break;
case LOC_BLOCK:
if (regval == NULL)
error (_("Value of register variable not available for `%s'."),
- SYMBOL_PRINT_NAME (var));
+ var->print_name ());
addr = value_as_address (regval);
}
if (regval == NULL)
error (_("Value of register variable not available for `%s'."),
- SYMBOL_PRINT_NAME (var));
+ var->print_name ());
return regval;
}
}
struct obj_section *obj_section;
memset (&lookup_data, 0, sizeof (lookup_data));
- lookup_data.name = SYMBOL_LINKAGE_NAME (var);
+ lookup_data.name = var->linkage_name ();
gdbarch_iterate_over_objfiles_in_search_order
(symbol_arch (var),
can't be NULL. */
gdb_assert (flavour_name != NULL);
error (_("Missing %s symbol \"%s\"."),
- flavour_name, SYMBOL_LINKAGE_NAME (var));
+ flavour_name, var->linkage_name ());
}
obj_section = MSYMBOL_OBJ_SECTION (lookup_data.result.objfile, msym);
/* Relocate address, unless there is no section or the variable is
default:
error (_("Cannot look up value of a botched symbol `%s'."),
- SYMBOL_PRINT_NAME (var));
+ var->print_name ());
break;
}
read_var_value (struct symbol *var, const struct block *var_block,
struct frame_info *frame)
{
- const struct language_defn *lang = language_def (SYMBOL_LANGUAGE (var));
+ const struct language_defn *lang = language_def (var->language ());
gdb_assert (lang != NULL);
gdb_assert (lang->la_read_var_value != NULL);
an integral number of registers. Otherwise, you need to do
some fiddling with the last register copied here for little
endian machines. */
- if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG
+ if (type_byte_order (type) == BFD_ENDIAN_BIG
&& len < register_size (gdbarch, regnum))
/* Big-endian, and we want less than full size. */
set_value_offset (value, register_size (gdbarch, regnum) - len);