/* Find a variable's value in memory, for GDB, the GNU debugger.
- Copyright (C) 1986-2013 Free Software Foundation, Inc.
+ Copyright (C) 1986-2014 Free Software Foundation, Inc.
This file is part of GDB.
#include "gdbcore.h"
#include "inferior.h"
#include "target.h"
-#include "gdb_string.h"
+#include <string.h>
#include "gdb_assert.h"
#include "floatformat.h"
#include "symfile.h" /* for overlay functions */
value_of_register (int regnum, struct frame_info *frame)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
- CORE_ADDR addr;
- int optim;
- int unavail;
struct value *reg_val;
- int realnum;
- gdb_byte raw_buffer[MAX_REGISTER_SIZE];
- enum lval_type lval;
/* User registers lie completely outside of the range of normal
registers. Catch them early so that the target never sees them. */
+ gdbarch_num_pseudo_regs (gdbarch))
return value_of_user_reg (regnum, frame);
- frame_register (frame, regnum, &optim, &unavail,
- &lval, &addr, &realnum, raw_buffer);
-
- reg_val = allocate_value (register_type (gdbarch, regnum));
-
- if (!optim && !unavail)
- memcpy (value_contents_raw (reg_val), raw_buffer,
- register_size (gdbarch, regnum));
- else
- memset (value_contents_raw (reg_val), 0,
- register_size (gdbarch, regnum));
-
- VALUE_LVAL (reg_val) = lval;
- set_value_address (reg_val, addr);
- VALUE_REGNUM (reg_val) = regnum;
- set_value_optimized_out (reg_val, optim);
- if (unavail)
- mark_value_bytes_unavailable (reg_val, 0, register_size (gdbarch, regnum));
- VALUE_FRAME_ID (reg_val) = get_frame_id (frame);
+ reg_val = value_of_register_lazy (frame, regnum);
+ value_fetch_lazy (reg_val);
return reg_val;
}
int
symbol_read_needs_frame (struct symbol *sym)
{
+ if (SYMBOL_COMPUTED_OPS (sym) != NULL)
+ return SYMBOL_COMPUTED_OPS (sym)->read_needs_frame (sym);
+
switch (SYMBOL_CLASS (sym))
{
/* All cases listed explicitly so that gcc -Wall will detect it if
we failed to consider one. */
case LOC_COMPUTED:
- /* FIXME: cagney/2004-01-26: It should be possible to
- unconditionally call the SYMBOL_COMPUTED_OPS method when available.
- Unfortunately DWARF 2 stores the frame-base (instead of the
- function) location in a function's symbol. Oops! For the
- moment enable this when/where applicable. */
- return SYMBOL_COMPUTED_OPS (sym)->read_needs_frame (sym);
+ gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
case LOC_REGISTER:
case LOC_ARG:
/* The field where the callback should store the minimal symbol
if found. It should be initialized to NULL before the search
is started. */
- struct minimal_symbol *result;
+ struct bound_minimal_symbol result;
};
/* A callback function for gdbarch_iterate_over_objfiles_in_search_order.
{
struct minsym_lookup_data *data = (struct minsym_lookup_data *) cb_data;
- gdb_assert (data->result == NULL);
+ gdb_assert (data->result.minsym == NULL);
data->result = lookup_minimal_symbol (data->name, NULL, objfile);
/* The iterator should stop iff a match was found. */
- return (data->result != NULL);
+ return (data->result.minsym != NULL);
}
/* A default implementation for the "la_read_var_value" hook in
if (symbol_read_needs_frame (var))
gdb_assert (frame);
+ if (SYMBOL_COMPUTED_OPS (var) != NULL)
+ return SYMBOL_COMPUTED_OPS (var)->read_variable (var, frame);
+
switch (SYMBOL_CLASS (var))
{
case LOC_CONST:
{
CORE_ADDR addr
= symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
- SYMBOL_OBJ_SECTION (var));
+ SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (var),
+ var));
store_typed_address (value_contents_raw (v), type, addr);
}
return v;
case LOC_STATIC:
- v = allocate_value_lazy (type);
if (overlay_debugging)
addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
- SYMBOL_OBJ_SECTION (var));
+ SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (var),
+ var));
else
addr = SYMBOL_VALUE_ADDRESS (var);
break;
error (_("Unknown argument list address for `%s'."),
SYMBOL_PRINT_NAME (var));
addr += SYMBOL_VALUE (var);
- v = allocate_value_lazy (type);
break;
case LOC_REF_ARG:
argref += SYMBOL_VALUE (var);
ref = value_at (lookup_pointer_type (type), argref);
addr = value_as_address (ref);
- v = allocate_value_lazy (type);
break;
}
case LOC_LOCAL:
addr = get_frame_locals_address (frame);
addr += SYMBOL_VALUE (var);
- v = allocate_value_lazy (type);
break;
case LOC_TYPEDEF:
break;
case LOC_BLOCK:
- v = allocate_value_lazy (type);
if (overlay_debugging)
addr = symbol_overlayed_address
- (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_OBJ_SECTION (var));
+ (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (var),
+ var));
else
addr = BLOCK_START (SYMBOL_BLOCK_VALUE (var));
break;
SYMBOL_PRINT_NAME (var));
addr = value_as_address (regval);
- v = allocate_value_lazy (type);
}
else
{
break;
case LOC_COMPUTED:
- /* FIXME: cagney/2004-01-26: It should be possible to
- unconditionally call the SYMBOL_COMPUTED_OPS method when available.
- Unfortunately DWARF 2 stores the frame-base (instead of the
- function) location in a function's symbol. Oops! For the
- moment enable this when/where applicable. */
- return SYMBOL_COMPUTED_OPS (var)->read_variable (var, frame);
+ gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
case LOC_UNRESOLVED:
{
(get_objfile_arch (SYMBOL_SYMTAB (var)->objfile),
minsym_lookup_iterator_cb, &lookup_data,
SYMBOL_SYMTAB (var)->objfile);
- msym = lookup_data.result;
+ msym = lookup_data.result.minsym;
if (msym == NULL)
error (_("No global symbol \"%s\"."), SYMBOL_LINKAGE_NAME (var));
if (overlay_debugging)
- addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym),
- SYMBOL_OBJ_SECTION (msym));
+ addr = symbol_overlayed_address (BMSYMBOL_VALUE_ADDRESS (lookup_data.result),
+ MSYMBOL_OBJ_SECTION (lookup_data.result.objfile,
+ msym));
else
- addr = SYMBOL_VALUE_ADDRESS (msym);
+ addr = BMSYMBOL_VALUE_ADDRESS (lookup_data.result);
- obj_section = SYMBOL_OBJ_SECTION (msym);
+ obj_section = MSYMBOL_OBJ_SECTION (lookup_data.result.objfile, msym);
if (obj_section
&& (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
addr = target_translate_tls_address (obj_section->objfile, addr);
- v = allocate_value_lazy (type);
}
break;
break;
}
- VALUE_LVAL (v) = lval_memory;
- set_value_address (v, addr);
+ v = value_at_lazy (type, addr);
return v;
}
value = value_from_register (type, regnum, frame);
gdb_assert (value);
+ if (value_optimized_out (value))
+ {
+ /* 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 ();
+ }
+
result = value_as_address (value);
release_value (value);
value_free (value);
projects / deliverable / binutils-gdb.git / blobdiff