return reg_val;
}
+/* Return a `value' with the contents of (virtual or cooked) register
+ REGNUM as found in the specified FRAME. The register's type is
+ determined by register_type(). The value is not fetched. */
+
+struct value *
+value_of_register_lazy (struct frame_info *frame, int regnum)
+{
+ struct gdbarch *gdbarch = get_frame_arch (frame);
+ struct value *reg_val;
+
+ gdb_assert (regnum < (gdbarch_num_regs (gdbarch)
+ + gdbarch_num_pseudo_regs (gdbarch)));
+
+ /* We should have a valid (i.e. non-sentinel) frame. */
+ gdb_assert (frame_id_p (get_frame_id (frame)));
+
+ reg_val = allocate_value (register_type (gdbarch, regnum));
+ VALUE_LVAL (reg_val) = lval_register;
+ VALUE_REGNUM (reg_val) = regnum;
+ VALUE_FRAME_ID (reg_val) = get_frame_id (frame);
+ set_value_lazy (reg_val, 1);
+ return reg_val;
+}
+
/* Given a pointer of type TYPE in target form in BUF, return the
address it represents. */
CORE_ADDR
/* All cases listed explicitly so that gcc -Wall will detect it if
we failed to consider one. */
case LOC_COMPUTED:
- case LOC_COMPUTED_ARG:
/* FIXME: cagney/2004-01-26: It should be possible to
unconditionally call the SYMBOL_OPS method when available.
Unfortunately DWARF 2 stores the frame-base (instead of the
case LOC_REGISTER:
case LOC_ARG:
case LOC_REF_ARG:
- case LOC_REGPARM:
case LOC_REGPARM_ADDR:
case LOC_LOCAL:
- case LOC_LOCAL_ARG:
- case LOC_BASEREG:
- case LOC_BASEREG_ARG:
- case LOC_HP_THREAD_LOCAL_STATIC:
return 1;
case LOC_UNDEF:
case LOC_CONST:
case LOC_STATIC:
- case LOC_INDIRECT:
case LOC_TYPEDEF:
case LOC_LABEL:
int len;
if (SYMBOL_CLASS (var) == LOC_COMPUTED
- || SYMBOL_CLASS (var) == LOC_COMPUTED_ARG
- || SYMBOL_CLASS (var) == LOC_REGISTER
- || SYMBOL_CLASS (var) == LOC_REGPARM)
+ || SYMBOL_CLASS (var) == LOC_REGISTER)
/* These cases do not use V. */
v = NULL;
else
addr = SYMBOL_VALUE_ADDRESS (var);
break;
- case LOC_INDIRECT:
- {
- /* The import slot does not have a real address in it from the
- dynamic loader (dld.sl on HP-UX), if the target hasn't
- begun execution yet, so check for that. */
- CORE_ADDR locaddr;
- struct value *loc;
- if (!target_has_execution)
- error (_("\
-Attempt to access variable defined in different shared object or load module when\n\
-addresses have not been bound by the dynamic loader. Try again when executable is running."));
-
- locaddr = SYMBOL_VALUE_ADDRESS (var);
- loc = value_at (lookup_pointer_type (type), locaddr);
- addr = value_as_address (loc);
- break;
- }
-
case LOC_ARG:
if (frame == NULL)
return 0;
}
case LOC_LOCAL:
- case LOC_LOCAL_ARG:
if (frame == NULL)
return 0;
addr = get_frame_locals_address (frame);
addr += SYMBOL_VALUE (var);
break;
- case LOC_BASEREG:
- case LOC_BASEREG_ARG:
- case LOC_HP_THREAD_LOCAL_STATIC:
- {
- struct value *regval;
-
- regval = value_from_register (lookup_pointer_type (type),
- SYMBOL_BASEREG (var), frame);
- if (regval == NULL)
- error (_("Value of base register not available."));
- addr = value_as_address (regval);
- addr += SYMBOL_VALUE (var);
- break;
- }
-
case LOC_TYPEDEF:
error (_("Cannot look up value of a typedef"));
break;
return v;
case LOC_REGISTER:
- case LOC_REGPARM:
case LOC_REGPARM_ADDR:
{
struct block *b;
break;
case LOC_COMPUTED:
- case LOC_COMPUTED_ARG:
/* FIXME: cagney/2004-01-26: It should be possible to
unconditionally call the SYMBOL_OPS method when available.
Unfortunately DWARF 2 stores the frame-base (instead of the
if (lazy_value == 0)
error (_("Address of \"%s\" is unknown."), SYMBOL_PRINT_NAME (var));
- if (value_lazy (lazy_value)
+ if ((VALUE_LVAL (lazy_value) == lval_memory && value_lazy (lazy_value))
|| TYPE_CODE (type) == TYPE_CODE_FUNC)
{
struct value *val;