/* Find a variable's value in memory, for GDB, the GNU debugger.
- Copyright (C) 1986-2014 Free Software Foundation, Inc.
+ Copyright (C) 1986-2015 Free Software Foundation, Inc.
This file is part of GDB.
#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"
if (is_dynamic_type (type))
{
/* Value is a constant byte-sequence and needs no memory access. */
- type = resolve_dynamic_type (type, /* Unused address. */ 0);
+ type = resolve_dynamic_type (type, NULL, /* Unused address. */ 0);
}
/* Put the constant back in target format. */
v = allocate_value (type);
{
CORE_ADDR addr
= symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
- SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (var),
+ SYMBOL_OBJ_SECTION (symbol_objfile (var),
var));
store_typed_address (value_contents_raw (v), type, addr);
if (is_dynamic_type (type))
{
/* Value is a constant byte-sequence and needs no memory access. */
- type = resolve_dynamic_type (type, /* Unused address. */ 0);
+ type = resolve_dynamic_type (type, NULL, /* Unused address. */ 0);
}
v = allocate_value (type);
memcpy (value_contents_raw (v), SYMBOL_VALUE_BYTES (var),
case LOC_STATIC:
if (overlay_debugging)
addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
- SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (var),
+ SYMBOL_OBJ_SECTION (symbol_objfile (var),
var));
else
addr = SYMBOL_VALUE_ADDRESS (var);
case LOC_BLOCK:
if (overlay_debugging)
addr = symbol_overlayed_address
- (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (var),
- var));
+ (BLOCK_START (SYMBOL_BLOCK_VALUE (var)),
+ SYMBOL_OBJ_SECTION (symbol_objfile (var), var));
else
addr = BLOCK_START (SYMBOL_BLOCK_VALUE (var));
break;
lookup_data.name = SYMBOL_LINKAGE_NAME (var);
gdbarch_iterate_over_objfiles_in_search_order
- (get_objfile_arch (SYMBOL_SYMTAB (var)->objfile),
+ (symbol_arch (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
int offset = 0;
int reg_offset = value_offset (value);
int regnum = VALUE_REGNUM (value);
- int len = TYPE_LENGTH (check_typedef (value_type (value)));
+ int len = type_length_units (check_typedef (value_type (value)));
gdb_assert (VALUE_LVAL (value) == lval_register);
while (len > 0)
{
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;
- }
+ int reg_len = type_length_units (value_type (regval)) - reg_offset;
/* If the register length is larger than the number of bytes
remaining to copy, then only copy the appropriate bytes. */
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