#define CANNOT_STORE_REGISTER(regno) 0
#endif
-static void
-write_register_gen PARAMS ((int, char *));
+static void write_register_gen PARAMS ((int, char *));
/* Basic byte-swapping routines. GDB has needed these for a long time...
All extract a target-format integer at ADDR which is LEN bytes long. */
{
/* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
whether we want this to be true eventually. */
- return extract_unsigned_integer (addr, len);
+ return (CORE_ADDR)extract_unsigned_integer (addr, len);
}
void
}
}
+/* Store the literal address "val" into
+ gdb-local memory pointed to by "addr"
+ for "len" bytes. */
void
store_address (addr, len, val)
PTR addr;
int len;
- CORE_ADDR val;
+ LONGEST val;
{
- /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
- whether we want this to be true eventually. */
- store_unsigned_integer (addr, len, (LONGEST)val);
+ if( TARGET_BYTE_ORDER == BIG_ENDIAN
+ && len != sizeof( LONGEST )) {
+ /* On big-endian machines (e.g., HPPA 2.0, narrow mode)
+ * just letting this fall through to the call below will
+ * lead to the wrong bits being stored.
+ *
+ * Only the simplest case is fixed here, the others just
+ * get the old behavior.
+ */
+ if( (len == sizeof( CORE_ADDR ))
+ && (sizeof( LONGEST ) == 2 * sizeof( CORE_ADDR ))) {
+ /* Watch out! The high bits are garbage! */
+ CORE_ADDR coerce[2];
+ *(LONGEST*)&coerce = val;
+
+ store_unsigned_integer (addr, len, coerce[1] ); /* BIG_ENDIAN code! */
+ return;
+ }
+ }
+ store_unsigned_integer (addr, len, val);
}
\f
/* Swap LEN bytes at BUFFER between target and host byte-order. */
struct frame_info *frame;
int regnum;
{
- struct frame_saved_regs saved_regs;
-
register struct frame_info *frame1 = NULL;
register CORE_ADDR addr = 0;
if (regnum != SP_REGNUM)
frame1 = frame;
- get_frame_saved_regs (frame1, &saved_regs);
- return saved_regs.regs[regnum]; /* ... which might be zero */
+ FRAME_INIT_SAVED_REGS (frame1);
+ return frame1->saved_regs[regnum]; /* ... which might be zero */
}
#endif /* HAVE_REGISTER_WINDOWS */
frame1 = get_prev_frame (frame1);
if (frame1 == 0 || frame1 == frame)
break;
- get_frame_saved_regs (frame1, &saved_regs);
- if (saved_regs.regs[regnum])
- addr = saved_regs.regs[regnum];
+ FRAME_INIT_SAVED_REGS (frame1);
+ if (frame1->saved_regs[regnum])
+ addr = frame1->saved_regs[regnum];
}
return addr;
if (raw_buffer != NULL)
{
/* Put it back in target format. */
- store_address (raw_buffer, REGISTER_RAW_SIZE (regnum), addr);
+ store_address (raw_buffer, REGISTER_RAW_SIZE (regnum), (LONGEST)addr);
}
if (addrp != NULL)
*addrp = 0;
}
#endif /* GET_SAVED_REGISTER. */
-/* Copy the bytes of register REGNUM, relative to the current stack frame,
+/* Copy the bytes of register REGNUM, relative to the input stack frame,
into our memory at MYADDR, in target byte order.
The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
Returns 1 if could not be read, 0 if could. */
int
-read_relative_register_raw_bytes (regnum, myaddr)
+read_relative_register_raw_bytes_for_frame (regnum, myaddr, frame)
int regnum;
char *myaddr;
+ struct frame_info *frame;
{
int optim;
- if (regnum == FP_REGNUM && selected_frame)
+ if (regnum == FP_REGNUM && frame)
{
- /* Put it back in target format. */
+ /* Put it back in target format. */
store_address (myaddr, REGISTER_RAW_SIZE(FP_REGNUM),
- FRAME_FP(selected_frame));
+ (LONGEST)FRAME_FP(frame));
+
return 0;
}
- get_saved_register (myaddr, &optim, (CORE_ADDR *) NULL, selected_frame,
+ get_saved_register (myaddr, &optim, (CORE_ADDR *) NULL, frame,
regnum, (enum lval_type *)NULL);
if (register_valid [regnum] < 0)
return optim;
}
+/* Copy the bytes of register REGNUM, relative to the current stack frame,
+ into our memory at MYADDR, in target byte order.
+ The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
+
+ Returns 1 if could not be read, 0 if could. */
+
+int
+read_relative_register_raw_bytes (regnum, myaddr)
+ int regnum;
+ char *myaddr;
+{
+ return read_relative_register_raw_bytes_for_frame (regnum, myaddr,
+ selected_frame);
+}
+
/* Return a `value' with the contents of register REGNUM
in its virtual format, with the type specified by
REGISTER_VIRTUAL_TYPE.
register_valid [regno] = 1;
target_store_registers (regno);
-
- if (regno == PC_REGNUM && pc_changed_hook)
- pc_changed_hook ();
}
/* Copy INLEN bytes of consecutive data from memory at MYADDR
if (!register_valid[regno])
target_fetch_registers (regno);
- return extract_address (®isters[REGISTER_BYTE (regno)],
- REGISTER_RAW_SIZE(regno));
+ return (CORE_ADDR)extract_address (®isters[REGISTER_BYTE (regno)],
+ REGISTER_RAW_SIZE(regno));
}
CORE_ADDR
return retval;
}
-/* Store VALUE, into the raw contents of register number REGNO. */
+/* Store VALUE, into the raw contents of register number REGNO.
+ This should probably write a LONGEST rather than a CORE_ADDR */
void
write_register (regno, val)
size = REGISTER_RAW_SIZE(regno);
buf = alloca (size);
- store_signed_integer (buf, size, (LONGEST) val);
+ store_signed_integer (buf, size, (LONGEST)val);
/* If we have a valid copy of the register, and new value == old value,
then don't bother doing the actual store. */
void
write_register_pid (regno, val, pid)
int regno;
- LONGEST val;
+ CORE_ADDR val;
int pid;
{
int save_pid;
read_pc_pid (pid)
int pid;
{
+ int saved_inferior_pid;
+ CORE_ADDR pc_val;
+
+ /* In case pid != inferior_pid. */
+ saved_inferior_pid = inferior_pid;
+ inferior_pid = pid;
+
#ifdef TARGET_READ_PC
- return TARGET_READ_PC (pid);
+ pc_val = TARGET_READ_PC (pid);
#else
- return ADDR_BITS_REMOVE ((CORE_ADDR) read_register_pid (PC_REGNUM, pid));
+ pc_val = ADDR_BITS_REMOVE ((CORE_ADDR) read_register_pid (PC_REGNUM, pid));
#endif
+
+ inferior_pid = saved_inferior_pid;
+ return pc_val;
}
CORE_ADDR
CORE_ADDR pc;
int pid;
{
+ int saved_inferior_pid;
+
+ /* In case pid != inferior_pid. */
+ saved_inferior_pid = inferior_pid;
+ inferior_pid = pid;
+
#ifdef TARGET_WRITE_PC
TARGET_WRITE_PC (pc, pid);
#else
#endif
#endif
#endif
+
+ inferior_pid = saved_inferior_pid;
}
void
case LOC_LOCAL_ARG:
case LOC_BASEREG:
case LOC_BASEREG_ARG:
+ case LOC_THREAD_LOCAL_STATIC:
return 1;
case LOC_UNDEF:
case LOC_CONST:
case LOC_STATIC:
+ case LOC_INDIRECT:
case LOC_TYPEDEF:
case LOC_LABEL:
/* Put the constant back in target format. */
if (overlay_debugging)
store_address (VALUE_CONTENTS_RAW (v), len,
- symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
- SYMBOL_BFD_SECTION (var)));
+ (LONGEST)symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
+ SYMBOL_BFD_SECTION (var)));
else
- store_address (VALUE_CONTENTS_RAW (v), len,
- SYMBOL_VALUE_ADDRESS (var));
+ store_address (VALUE_CONTENTS_RAW (v), len,
+ (LONGEST)SYMBOL_VALUE_ADDRESS (var));
VALUE_LVAL (v) = not_lval;
return v;
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. */
+ 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.");
+
+ addr = SYMBOL_VALUE_ADDRESS (var);
+ addr = read_memory_unsigned_integer
+ (addr, TARGET_PTR_BIT / TARGET_CHAR_BIT);
+ break;
+
case LOC_ARG:
if (frame == NULL)
return 0;
break;
}
+ case LOC_THREAD_LOCAL_STATIC:
+ {
+ char buf[MAX_REGISTER_RAW_SIZE];
+
+ get_saved_register(buf, NULL, NULL, frame, SYMBOL_BASEREG (var),
+ NULL);
+ addr = extract_address (buf, REGISTER_RAW_SIZE (SYMBOL_BASEREG (var)));
+ addr += SYMBOL_VALUE (var );
+ break;
+ }
+
case LOC_TYPEDEF:
error ("Cannot look up value of a typedef");
break;