return 1;
}
+/* Private data to be used with minsym_lookup_iterator_cb. */
+
+struct minsym_lookup_data
+{
+ /* The name of the minimal symbol we are searching for. */
+ const char *name;
+
+ /* 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;
+};
+
+/* A callback function for gdbarch_iterate_over_objfiles_in_search_order.
+ It searches by name for a minimal symbol within the given OBJFILE.
+ The arguments are passed via CB_DATA, which in reality is a pointer
+ to struct minsym_lookup_data. */
+
+static int
+minsym_lookup_iterator_cb (struct objfile *objfile, void *cb_data)
+{
+ struct minsym_lookup_data *data = (struct minsym_lookup_data *) cb_data;
+
+ gdb_assert (data->result == NULL);
+
+ data->result = lookup_minimal_symbol (data->name, NULL, objfile);
+
+ /* The iterator should stop iff a match was found. */
+ return (data->result != NULL);
+}
+
/* A default implementation for the "la_read_var_value" hook in
the language vector which should work in most situations. */
struct value *v;
struct type *type = SYMBOL_TYPE (var);
CORE_ADDR addr;
- int len;
/* Call check_typedef on our type to make sure that, if TYPE is
a TYPE_CODE_TYPEDEF, its length is set to the length of the target type
set the returned value type description correctly. */
check_typedef (type);
- len = TYPE_LENGTH (type);
-
if (symbol_read_needs_frame (var))
gdb_assert (frame);
case LOC_CONST:
/* Put the constant back in target format. */
v = allocate_value (type);
- store_signed_integer (value_contents_raw (v), len,
+ store_signed_integer (value_contents_raw (v), TYPE_LENGTH (type),
gdbarch_byte_order (get_type_arch (type)),
(LONGEST) SYMBOL_VALUE (var));
VALUE_LVAL (v) = not_lval;
case LOC_CONST_BYTES:
v = allocate_value (type);
- memcpy (value_contents_raw (v), SYMBOL_VALUE_BYTES (var), len);
+ memcpy (value_contents_raw (v), SYMBOL_VALUE_BYTES (var),
+ TYPE_LENGTH (type));
VALUE_LVAL (v) = not_lval;
return v;
case LOC_UNRESOLVED:
{
+ struct minsym_lookup_data lookup_data;
struct minimal_symbol *msym;
struct obj_section *obj_section;
- msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (var), NULL, NULL);
+ memset (&lookup_data, 0, sizeof (lookup_data));
+ lookup_data.name = SYMBOL_LINKAGE_NAME (var);
+
+ gdbarch_iterate_over_objfiles_in_search_order
+ (get_objfile_arch (SYMBOL_SYMTAB (var)->objfile),
+ minsym_lookup_iterator_cb, &lookup_data,
+ SYMBOL_SYMTAB (var)->objfile);
+ msym = lookup_data.result;
+
if (msym == NULL)
error (_("No global symbol \"%s\"."), SYMBOL_LINKAGE_NAME (var));
if (overlay_debugging)
/* VALUE must be an lval_register value. If regnum is the value's
associated register number, and len the length of the values type,
read one or more registers in FRAME, starting with register REGNUM,
- until we've read LEN bytes. */
+ until we've read LEN bytes.
+
+ If any of the registers we try to read are optimized out, then mark the
+ complete resulting value as optimized out. */
void
read_frame_register_value (struct value *value, struct frame_info *frame)
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)