#include "gdbcore.h"
#include "inferior.h"
#include "target.h"
-#include <string.h>
-#include "gdb_assert.h"
#include "floatformat.h"
#include "symfile.h" /* for overlay functions */
#include "regcache.h"
switch (SYMBOL_CLASS (var))
{
case LOC_CONST:
- /* Put the constant back in target format. */
+ if (is_dynamic_type (type))
+ {
+ /* Value is a constant byte-sequence and needs no memory access. */
+ type = resolve_dynamic_type (type, /* Unused address. */ 0);
+ }
+ /* 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)),
return v;
case LOC_CONST_BYTES:
+ if (is_dynamic_type (type))
+ {
+ /* Value is a constant byte-sequence and needs no memory access. */
+ type = resolve_dynamic_type (type, /* Unused address. */ 0);
+ }
v = allocate_value (type);
memcpy (value_contents_raw (v), SYMBOL_VALUE_BYTES (var),
TYPE_LENGTH (type));
lookup_data.name = SYMBOL_LINKAGE_NAME (var);
gdbarch_iterate_over_objfiles_in_search_order
- (get_objfile_arch (SYMBOL_SYMTAB (var)->objfile),
+ (get_objfile_arch (SYMBOL_OBJFILE (var)),
minsym_lookup_iterator_cb, &lookup_data,
- SYMBOL_SYMTAB (var)->objfile);
+ SYMBOL_OBJFILE (var));
msym = lookup_data.result.minsym;
if (msym == NULL)
/* Install default attributes for register values. */
struct value *
-default_value_from_register (struct type *type, int regnum,
- struct frame_info *frame)
+default_value_from_register (struct gdbarch *gdbarch, struct type *type,
+ int regnum, struct frame_id frame_id)
{
- struct gdbarch *gdbarch = get_frame_arch (frame);
int len = TYPE_LENGTH (type);
struct value *value = allocate_value (type);
VALUE_LVAL (value) = lval_register;
- VALUE_FRAME_ID (value) = get_frame_id (frame);
+ VALUE_FRAME_ID (value) = frame_id;
VALUE_REGNUM (value) = regnum;
/* Any structure stored in more than one register will always be
struct value *regval = get_frame_register_value (frame, regnum);
int reg_len = TYPE_LENGTH (value_type (regval)) - reg_offset;
- if (value_optimized_out (regval))
- {
- set_value_optimized_out (value, 1);
- break;
- }
-
/* If the register length is larger than the number of bytes
remaining to copy, then only copy the appropriate bytes. */
if (reg_len > len)
if (!ok)
{
if (optim)
- set_value_optimized_out (v, 1);
+ mark_value_bytes_optimized_out (v, 0, TYPE_LENGTH (type));
if (unavail)
mark_value_bytes_unavailable (v, 0, TYPE_LENGTH (type));
}
else
{
/* Construct the value. */
- v = gdbarch_value_from_register (gdbarch, type, regnum, frame);
+ v = gdbarch_value_from_register (gdbarch, type,
+ regnum, get_frame_id (frame));
/* Get the data. */
read_frame_register_value (v, frame);
return v;
}
-/* Return contents of register REGNUM in frame FRAME as address,
- interpreted as value of type TYPE. Will abort if register
- value is not available. */
+/* Return contents of register REGNUM in frame FRAME as address.
+ Will abort if register value is not available. */
CORE_ADDR
-address_from_register (struct type *type, int regnum, struct frame_info *frame)
+address_from_register (int regnum, struct frame_info *frame)
{
+ struct gdbarch *gdbarch = get_frame_arch (frame);
+ struct type *type = builtin_type (gdbarch)->builtin_data_ptr;
struct value *value;
CORE_ADDR result;
- value = value_from_register (type, regnum, frame);
- gdb_assert (value);
+ /* This routine may be called during early unwinding, at a time
+ where the ID of FRAME is not yet known. Calling value_from_register
+ would therefore abort in get_frame_id. However, since we only need
+ a temporary value that is never used as lvalue, we actually do not
+ really need to set its VALUE_FRAME_ID. Therefore, we re-implement
+ the core of value_from_register, but use the null_frame_id. */
+
+ /* Some targets require a special conversion routine even for plain
+ pointer types. Avoid constructing a value object in those cases. */
+ if (gdbarch_convert_register_p (gdbarch, regnum, type))
+ {
+ gdb_byte *buf = alloca (TYPE_LENGTH (type));
+ int optim, unavail, ok;
+
+ ok = gdbarch_register_to_value (gdbarch, frame, regnum, type,
+ buf, &optim, &unavail);
+ if (!ok)
+ {
+ /* This function is used while computing a location expression.
+ Complain about the value being optimized out, rather than
+ letting value_as_address complain about some random register
+ the expression depends on not being saved. */
+ error_value_optimized_out ();
+ }
+
+ return unpack_long (type, buf);
+ }
+
+ value = gdbarch_value_from_register (gdbarch, type, regnum, null_frame_id);
+ read_frame_register_value (value, frame);
if (value_optimized_out (value))
{
projects / deliverable / binutils-gdb.git / blobdiff