This is the mail archive of the
gdb-patches@sources.redhat.com
mailing list for the GDB project.
RFA: Remove D10V-specific code from arch-independent modules
- To: gdb-patches at sources dot redhat dot com
- Subject: RFA: Remove D10V-specific code from arch-independent modules
- From: Jim Blandy <jimb at zwingli dot cygnus dot com>
- Date: Thu, 28 Jun 2001 19:07:35 -0500 (EST)
The following patch removes the D10V-specific code from GDB's
architecture-independent modules, and generally cleans up the D10V
port.
This patch has the following effect on the test suite results:
- Fifteen failures become passes --- mostly in pointer.exp.
- "gdb.base/long_long.exp: x/a &oct" used to pass, but now fails,
because the test assumes that pointers are 32 bits long. On the
D10V, pointers are 16 bits long.
- In gdb.base/overlays.exp, five passes become failures. This is
because the overlay tests for the D10V put unloaded overlays in
memory the processor can't directly address. It's possible to fix
the test, but I didn't do this.
So the results are not universally positive. However, I still think
this change should be committed because:
- GDB and the target currently disagree on how long D10V pointers
are. This is a horrible kludge, which this patch removes.
- As a direct consequence of that horrible kludge, we currently have
D10V-specific code scattered throughout the supposedly
machine-independent portions of GDB. This patch segregates all
D10V-specific code to d10v-tdep.c, and simplifies some fundamental
functions.
2001-06-28 Jim Blandy <jimb@redhat.com>
Clean up the D10V port so that GDB and the target program no
longer disagree on how big pointers are.
* findvar.c (value_from_register): Remove special case code for D10V.
* printcmd.c (print_frame_args): Same.
* valops.c (value_at, value_fetch_lazy): Same.
* values.c (unpack_long): Same.
* gdbarch.sh: Changes to effect the following:
* gdbarch.h (GDB_TARGET_IS_D10V, D10V_MAKE_DADDR,
gdbarch_d10v_make_daddr_ftype, gdbarch_d10v_make_daddr,
set_gdbarch_d10v_make_daddr, D10V_MAKE_IADDR,
gdbarch_d10v_make_iaddr_ftype, gdbarch_d10v_make_iaddr,
set_gdbarch_d10v_make_iaddr, D10V_DADDR_P,
gdbarch_d10v_daddr_p_ftype, gdbarch_d10v_daddr_p,
set_gdbarch_d10v_daddr_p, D10V_IADDR_P,
gdbarch_d10v_iaddr_p_ftype, gdbarch_d10v_iaddr_p,
set_gdbarch_d10v_iaddr_p, D10V_CONVERT_DADDR_TO_RAW,
gdbarch_d10v_convert_daddr_to_raw_ftype,
gdbarch_d10v_convert_daddr_to_raw,
set_gdbarch_d10v_convert_daddr_to_raw, D10V_CONVERT_IADDR_TO_RAW,
gdbarch_d10v_convert_iaddr_to_raw_ftype,
gdbarch_d10v_convert_iaddr_to_raw,
set_gdbarch_d10v_convert_iaddr_to_raw): Delete declarations.
* gdbarch.c: Delete the corresponding definitions.
(struct gdbarch): Delete members d10v_make_daddr,
d10v_make_iaddr, d10v_daddr_p, d10v_iaddr_p,
d10v_convert_daddr_to_raw, and d10v_convert_iaddr_to_raw.
(startup_gdbarch): Remove initializers for the above.
(verify_gdbarch, gdbarch_dump): Don't verify or dump them any
more.
* d10v-tdep.c (struct gdbarch_tdep): New member: `code_ptr_type'.
(d10v_register_virtual_type): Rather that claiming the stack
pointer and PC are 32 bits long (which they aren't), say that the
stack pointer is an int16_t, and the program counter is a function
pointer. This allows the rest of GDB to make the appropriate
conversions between the code pointer format and real addresses.
And if code_ptr_type isn't initialized, do so here.
(d10v_register_convertible): Delete function; no registers are
convertible now, so we use generic_register_convertible_not instead.
(d10v_register_convert_to_virtual, d10v_register_convert_to_raw):
Report an internal error if these functions are ever called.
(d10v_address_to_pointer, d10v_pointer_to_address): New gdbarch
methods.
(d10v_frame_chain, d10v_frame_init_saved_regs, show_regs,
d10v_read_pc, d10v_write_pc, d10v_read_sp, d10v_write_sp,
d10v_write_fp, d10v_read_fp, d10v_push_return_address): Call the
(now static) functions d10v_make_daddr, d10v_make_iaddr,
d10v_convert_iaddr_to_raw, and d10v_convert_daddr_to_raw, not the
(now gone) global macros D10V_MAKE_DADDR, D10V_MAKE_IADDR,
D10V_CONVERT_IADDR_TO_RAW, and D10V_CONVERT_DADDR_TO_RAW.
(d10v_push_arguments, d10v_extract_return_value): Remove special
cases for code and data pointers.
(d10v_gdbarch_init): Set gdbarch_ptr_bit to 16, so that GDB and
the target agree on how large pointers are. Say that addresses
are 32 bits long. Register the address_to_pointer and
pointer_to_address conversion functions. Since no registers are
convertible now, register generic_register_convertible_not as the
gdbarch_register_convertible method instead of
d10v_register_convertible. Remove registrations for
gdbarch_d10v_make_daddr, gdbarch_d10v_make_iaddr,
gdbarch_d10v_daddr_p, gdbarch_d10v_iaddr_p,
gdbarch_d10v_convert_daddr_to_raw, and
gdbarch_d10v_convert_iaddr_to_raw. Use memset to zero the
gdbarch_tdep structure.
Index: gdb/d10v-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/d10v-tdep.c,v
retrieving revision 1.20
diff -c -r1.20 d10v-tdep.c
*** gdb/d10v-tdep.c 2001/06/28 23:12:18 1.20
--- gdb/d10v-tdep.c 2001/06/28 23:47:08
***************
*** 57,62 ****
--- 57,63 ----
int nr_dmap_regs;
unsigned long (*dmap_register) (int nr);
unsigned long (*imap_register) (int nr);
+ struct type *code_ptr_type;
};
/* These are the addresses the D10V-EVA board maps data and
***************
*** 332,375 ****
static struct type *
d10v_register_virtual_type (int reg_nr)
{
! if (reg_nr >= A0_REGNUM
&& reg_nr < (A0_REGNUM + NR_A_REGS))
return builtin_type_int64;
- else if (reg_nr == PC_REGNUM
- || reg_nr == SP_REGNUM)
- return builtin_type_int32;
else
return builtin_type_int16;
}
- /* convert $pc and $sp to/from virtual addresses */
- static int
- d10v_register_convertible (int nr)
- {
- return ((nr) == PC_REGNUM || (nr) == SP_REGNUM);
- }
-
static void
d10v_register_convert_to_virtual (int regnum, struct type *type, char *from,
char *to)
{
! ULONGEST x = extract_unsigned_integer (from, REGISTER_RAW_SIZE (regnum));
! if (regnum == PC_REGNUM)
! x = (x << 2) | IMEM_START;
! else
! x |= DMEM_START;
! store_unsigned_integer (to, TYPE_LENGTH (type), x);
}
static void
d10v_register_convert_to_raw (struct type *type, int regnum, char *from,
char *to)
{
! ULONGEST x = extract_unsigned_integer (from, TYPE_LENGTH (type));
! x &= 0x3ffff;
! if (regnum == PC_REGNUM)
! x >>= 2;
! store_unsigned_integer (to, 2, x);
}
--- 333,373 ----
static struct type *
d10v_register_virtual_type (int reg_nr)
{
! struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
!
! /* We can't create this type until the D10V gdbarch object has been
! made current, or else the size will be wrong. This means we
! can't initialize it in d10v_gdbarch_init. So we do it here, the
! first time we need it. */
! if (! tdep->code_ptr_type)
! tdep->code_ptr_type
! = lookup_pointer_type (lookup_function_type (builtin_type_void));
!
! if (reg_nr == PC_REGNUM)
! return tdep->code_ptr_type;
! else if (reg_nr >= A0_REGNUM
&& reg_nr < (A0_REGNUM + NR_A_REGS))
return builtin_type_int64;
else
return builtin_type_int16;
}
static void
d10v_register_convert_to_virtual (int regnum, struct type *type, char *from,
char *to)
{
! internal_error (__FILE__, __LINE__,
! "d10v_register_convert_to_virtual: "
! "register %d isn't convertible", regnum);
}
static void
d10v_register_convert_to_raw (struct type *type, int regnum, char *from,
char *to)
{
! internal_error (__FILE__, __LINE__,
! "d10v_register_convert_to_raw: "
! "register %d isn't convertible", regnum);
}
***************
*** 410,415 ****
--- 408,455 ----
return ((x) & 0xffff);
}
+ static void
+ d10v_address_to_pointer (struct type *type, void *buf, CORE_ADDR addr)
+ {
+ /* Is it a code address? */
+ if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC
+ || TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_METHOD)
+ {
+ #if 0
+ if (! d10v_iaddr_p (addr))
+ {
+ warning_begin ();
+ fprintf_unfiltered (gdb_stderr, "address `");
+ print_address_numeric (addr, 1, gdb_stderr);
+ fprintf_unfiltered (gdb_stderr, "' is not a code address\n");
+ }
+ #endif
+
+ store_unsigned_integer (buf, TYPE_LENGTH (type),
+ d10v_convert_iaddr_to_raw (addr));
+ }
+ else
+ {
+ /* Strip off any upper segment bits. */
+ store_unsigned_integer (buf, TYPE_LENGTH (type),
+ d10v_convert_daddr_to_raw (addr));
+ }
+ }
+
+ static CORE_ADDR
+ d10v_pointer_to_address (struct type *type, void *buf)
+ {
+ CORE_ADDR addr = extract_address (buf, TYPE_LENGTH (type));
+
+ /* Is it a code address? */
+ if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC
+ || TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_METHOD)
+ return d10v_make_iaddr (addr);
+ else
+ return d10v_make_daddr (addr);
+ }
+
+
/* Store the address of the place in which to copy the structure the
subroutine will return. This is called from call_function.
***************
*** 617,625 ****
static CORE_ADDR
d10v_frame_chain (struct frame_info *fi)
{
d10v_frame_init_saved_regs (fi);
! if (fi->extra_info->return_pc == IMEM_START
|| inside_entry_file (fi->extra_info->return_pc))
return (CORE_ADDR) 0;
--- 657,667 ----
static CORE_ADDR
d10v_frame_chain (struct frame_info *fi)
{
+ CORE_ADDR addr;
+
d10v_frame_init_saved_regs (fi);
! if (fi->extra_info->return_pc == d10v_make_iaddr (0)
|| inside_entry_file (fi->extra_info->return_pc))
return (CORE_ADDR) 0;
***************
*** 632,643 ****
return fi->saved_regs[SP_REGNUM];
}
! if (!read_memory_unsigned_integer (fi->saved_regs[FP_REGNUM],
! REGISTER_RAW_SIZE (FP_REGNUM)))
return (CORE_ADDR) 0;
!
! return D10V_MAKE_DADDR (read_memory_unsigned_integer (fi->saved_regs[FP_REGNUM],
! REGISTER_RAW_SIZE (FP_REGNUM)));
}
static int next_addr, uses_frame;
--- 674,685 ----
return fi->saved_regs[SP_REGNUM];
}
! addr = read_memory_unsigned_integer (fi->saved_regs[FP_REGNUM],
! REGISTER_RAW_SIZE (FP_REGNUM));
! if (! addr)
return (CORE_ADDR) 0;
! else
! return d10v_make_daddr (addr);
}
static int next_addr, uses_frame;
***************
*** 780,786 ****
fi->extra_info->size = -next_addr;
if (!(fp & 0xffff))
! fp = D10V_MAKE_DADDR (read_register (SP_REGNUM));
for (i = 0; i < NUM_REGS - 1; i++)
if (fi->saved_regs[i])
--- 822,828 ----
fi->extra_info->size = -next_addr;
if (!(fp & 0xffff))
! fp = d10v_make_daddr (read_register (SP_REGNUM));
for (i = 0; i < NUM_REGS - 1; i++)
if (fi->saved_regs[i])
***************
*** 791,801 ****
if (fi->saved_regs[LR_REGNUM])
{
CORE_ADDR return_pc = read_memory_unsigned_integer (fi->saved_regs[LR_REGNUM], REGISTER_RAW_SIZE (LR_REGNUM));
! fi->extra_info->return_pc = D10V_MAKE_IADDR (return_pc);
}
else
{
! fi->extra_info->return_pc = D10V_MAKE_IADDR (read_register (LR_REGNUM));
}
/* th SP is not normally (ever?) saved, but check anyway */
--- 833,843 ----
if (fi->saved_regs[LR_REGNUM])
{
CORE_ADDR return_pc = read_memory_unsigned_integer (fi->saved_regs[LR_REGNUM], REGISTER_RAW_SIZE (LR_REGNUM));
! fi->extra_info->return_pc = d10v_make_iaddr (return_pc);
}
else
{
! fi->extra_info->return_pc = d10v_make_iaddr (read_register (LR_REGNUM));
}
/* th SP is not normally (ever?) saved, but check anyway */
***************
*** 843,849 ****
int a;
printf_filtered ("PC=%04lx (0x%lx) PSW=%04lx RPT_S=%04lx RPT_E=%04lx RPT_C=%04lx\n",
(long) read_register (PC_REGNUM),
! (long) D10V_MAKE_IADDR (read_register (PC_REGNUM)),
(long) read_register (PSW_REGNUM),
(long) read_register (24),
(long) read_register (25),
--- 885,891 ----
int a;
printf_filtered ("PC=%04lx (0x%lx) PSW=%04lx RPT_S=%04lx RPT_E=%04lx RPT_C=%04lx\n",
(long) read_register (PC_REGNUM),
! (long) d10v_make_iaddr (read_register (PC_REGNUM)),
(long) read_register (PSW_REGNUM),
(long) read_register (24),
(long) read_register (25),
***************
*** 908,914 ****
inferior_ptid = ptid;
pc = (int) read_register (PC_REGNUM);
inferior_ptid = save_ptid;
! retval = D10V_MAKE_IADDR (pc);
return retval;
}
--- 950,956 ----
inferior_ptid = ptid;
pc = (int) read_register (PC_REGNUM);
inferior_ptid = save_ptid;
! retval = d10v_make_iaddr (pc);
return retval;
}
***************
*** 919,950 ****
save_ptid = inferior_ptid;
inferior_ptid = ptid;
! write_register (PC_REGNUM, D10V_CONVERT_IADDR_TO_RAW (val));
inferior_ptid = save_ptid;
}
static CORE_ADDR
d10v_read_sp (void)
{
! return (D10V_MAKE_DADDR (read_register (SP_REGNUM)));
}
static void
d10v_write_sp (CORE_ADDR val)
{
! write_register (SP_REGNUM, D10V_CONVERT_DADDR_TO_RAW (val));
}
static void
d10v_write_fp (CORE_ADDR val)
{
! write_register (FP_REGNUM, D10V_CONVERT_DADDR_TO_RAW (val));
}
static CORE_ADDR
d10v_read_fp (void)
{
! return (D10V_MAKE_DADDR (read_register (FP_REGNUM)));
}
/* Function: push_return_address (pc)
--- 961,992 ----
save_ptid = inferior_ptid;
inferior_ptid = ptid;
! write_register (PC_REGNUM, d10v_convert_iaddr_to_raw (val));
inferior_ptid = save_ptid;
}
static CORE_ADDR
d10v_read_sp (void)
{
! return (d10v_make_daddr (read_register (SP_REGNUM)));
}
static void
d10v_write_sp (CORE_ADDR val)
{
! write_register (SP_REGNUM, d10v_convert_daddr_to_raw (val));
}
static void
d10v_write_fp (CORE_ADDR val)
{
! write_register (FP_REGNUM, d10v_convert_daddr_to_raw (val));
}
static CORE_ADDR
d10v_read_fp (void)
{
! return (d10v_make_daddr (read_register (FP_REGNUM)));
}
/* Function: push_return_address (pc)
***************
*** 954,960 ****
static CORE_ADDR
d10v_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
{
! write_register (LR_REGNUM, D10V_CONVERT_IADDR_TO_RAW (CALL_DUMMY_ADDRESS ()));
return sp;
}
--- 996,1002 ----
static CORE_ADDR
d10v_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
{
! write_register (LR_REGNUM, d10v_convert_iaddr_to_raw (CALL_DUMMY_ADDRESS ()));
return sp;
}
***************
*** 1011,1050 ****
char *contents = VALUE_CONTENTS (arg);
int len = TYPE_LENGTH (type);
/* printf ("push: type=%d len=%d\n", type->code, len); */
- if (TYPE_CODE (type) == TYPE_CODE_PTR)
{
- /* pointers require special handling - first convert and
- then store */
- long val = extract_signed_integer (contents, len);
- len = 2;
- if (TYPE_TARGET_TYPE (type)
- && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC))
- {
- /* function pointer */
- val = D10V_CONVERT_IADDR_TO_RAW (val);
- }
- else if (D10V_IADDR_P (val))
- {
- /* also function pointer! */
- val = D10V_CONVERT_DADDR_TO_RAW (val);
- }
- else
- {
- /* data pointer */
- val &= 0xFFFF;
- }
- if (regnum <= ARGN_REGNUM)
- write_register (regnum++, val & 0xffff);
- else
- {
- char ptr[2];
- /* arg will go onto stack */
- store_address (ptr, 2, val & 0xffff);
- si = push_stack_item (si, ptr, 2);
- }
- }
- else
- {
int aligned_regnum = (regnum + 1) & ~1;
if (len <= 2 && regnum <= ARGN_REGNUM)
/* fits in a single register, do not align */
--- 1053,1059 ----
***************
*** 1098,1122 ****
{
int len;
/* printf("RET: TYPE=%d len=%d r%d=0x%x\n",type->code, TYPE_LENGTH (type), RET1_REGNUM - R0_REGNUM, (int) extract_unsigned_integer (regbuf + REGISTER_BYTE(RET1_REGNUM), REGISTER_RAW_SIZE (RET1_REGNUM))); */
- if (TYPE_CODE (type) == TYPE_CODE_PTR
- && TYPE_TARGET_TYPE (type)
- && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC))
- {
- /* pointer to function */
- int num;
- short snum;
- snum = extract_address (regbuf + REGISTER_BYTE (RET1_REGNUM), REGISTER_RAW_SIZE (RET1_REGNUM));
- store_address (valbuf, 4, D10V_MAKE_IADDR (snum));
- }
- else if (TYPE_CODE (type) == TYPE_CODE_PTR)
- {
- /* pointer to data */
- int num;
- short snum;
- snum = extract_address (regbuf + REGISTER_BYTE (RET1_REGNUM), REGISTER_RAW_SIZE (RET1_REGNUM));
- store_address (valbuf, 4, D10V_MAKE_DADDR (snum));
- }
- else
{
len = TYPE_LENGTH (type);
if (len == 1)
--- 1107,1112 ----
***************
*** 1470,1475 ****
--- 1460,1466 ----
/* None found, create a new architecture from the information
provided. */
tdep = XMALLOC (struct gdbarch_tdep);
+ memset (tdep, 0, sizeof (*tdep));
gdbarch = gdbarch_alloc (&info, tdep);
switch (info.bfd_arch_info->mach)
***************
*** 1516,1522 ****
set_gdbarch_max_register_virtual_size (gdbarch, 8);
set_gdbarch_register_virtual_type (gdbarch, d10v_register_virtual_type);
! set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT);
set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
--- 1507,1516 ----
set_gdbarch_max_register_virtual_size (gdbarch, 8);
set_gdbarch_register_virtual_type (gdbarch, d10v_register_virtual_type);
! set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
! set_gdbarch_addr_bit (gdbarch, 32);
! set_gdbarch_address_to_pointer (gdbarch, d10v_address_to_pointer);
! set_gdbarch_pointer_to_address (gdbarch, d10v_pointer_to_address);
set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT);
set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
***************
*** 1558,1564 ****
set_gdbarch_get_saved_register (gdbarch, generic_get_saved_register);
set_gdbarch_fix_call_dummy (gdbarch, generic_fix_call_dummy);
! set_gdbarch_register_convertible (gdbarch, d10v_register_convertible);
set_gdbarch_register_convert_to_virtual (gdbarch, d10v_register_convert_to_virtual);
set_gdbarch_register_convert_to_raw (gdbarch, d10v_register_convert_to_raw);
--- 1552,1558 ----
set_gdbarch_get_saved_register (gdbarch, generic_get_saved_register);
set_gdbarch_fix_call_dummy (gdbarch, generic_fix_call_dummy);
! set_gdbarch_register_convertible (gdbarch, generic_register_convertible_not);
set_gdbarch_register_convert_to_virtual (gdbarch, d10v_register_convert_to_virtual);
set_gdbarch_register_convert_to_raw (gdbarch, d10v_register_convert_to_raw);
***************
*** 1566,1578 ****
set_gdbarch_push_arguments (gdbarch, d10v_push_arguments);
set_gdbarch_push_dummy_frame (gdbarch, generic_push_dummy_frame);
set_gdbarch_push_return_address (gdbarch, d10v_push_return_address);
-
- set_gdbarch_d10v_make_daddr (gdbarch, d10v_make_daddr);
- set_gdbarch_d10v_make_iaddr (gdbarch, d10v_make_iaddr);
- set_gdbarch_d10v_daddr_p (gdbarch, d10v_daddr_p);
- set_gdbarch_d10v_iaddr_p (gdbarch, d10v_iaddr_p);
- set_gdbarch_d10v_convert_daddr_to_raw (gdbarch, d10v_convert_daddr_to_raw);
- set_gdbarch_d10v_convert_iaddr_to_raw (gdbarch, d10v_convert_iaddr_to_raw);
set_gdbarch_store_struct_return (gdbarch, d10v_store_struct_return);
set_gdbarch_store_return_value (gdbarch, d10v_store_return_value);
--- 1560,1565 ----
Index: gdb/findvar.c
===================================================================
RCS file: /cvs/src/src/gdb/findvar.c,v
retrieving revision 1.19
diff -c -r1.19 findvar.c
*** gdb/findvar.c 2001/03/06 08:21:07 1.19
--- gdb/findvar.c 2001/06/28 23:47:09
***************
*** 729,739 ****
CHECK_TYPEDEF (type);
len = TYPE_LENGTH (type);
- /* Pointers on D10V are really only 16 bits,
- but we lie to gdb elsewhere... */
- if (GDB_TARGET_IS_D10V && TYPE_CODE (type) == TYPE_CODE_PTR)
- len = 2;
-
VALUE_REGNO (v) = regnum;
num_storage_locs = (len > REGISTER_VIRTUAL_SIZE (regnum) ?
--- 729,734 ----
***************
*** 931,954 ****
}
memcpy (VALUE_CONTENTS_RAW (v), raw_buffer + VALUE_OFFSET (v), len);
- }
-
- if (GDB_TARGET_IS_D10V
- && TYPE_CODE (type) == TYPE_CODE_PTR)
- {
- unsigned long num;
- unsigned short snum;
-
- snum = (unsigned short)
- extract_unsigned_integer (VALUE_CONTENTS_RAW (v), 2);
-
- if (TYPE_TARGET_TYPE (type) /* pointer to function */
- && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC))
- num = D10V_MAKE_IADDR (snum);
- else /* pointer to data */
- num = D10V_MAKE_DADDR (snum);
-
- store_address (VALUE_CONTENTS_RAW (v), 4, num);
}
return v;
--- 926,931 ----
Index: gdb/gdbarch.c
===================================================================
RCS file: /cvs/src/src/gdb/gdbarch.c,v
retrieving revision 1.68
diff -c -r1.68 gdbarch.c
*** gdb/gdbarch.c 2001/06/16 20:00:24 1.68
--- gdb/gdbarch.c 2001/06/28 23:47:12
***************
*** 211,222 ****
gdbarch_push_dummy_frame_ftype *push_dummy_frame;
gdbarch_push_return_address_ftype *push_return_address;
gdbarch_pop_frame_ftype *pop_frame;
- gdbarch_d10v_make_daddr_ftype *d10v_make_daddr;
- gdbarch_d10v_make_iaddr_ftype *d10v_make_iaddr;
- gdbarch_d10v_daddr_p_ftype *d10v_daddr_p;
- gdbarch_d10v_iaddr_p_ftype *d10v_iaddr_p;
- gdbarch_d10v_convert_daddr_to_raw_ftype *d10v_convert_daddr_to_raw;
- gdbarch_d10v_convert_iaddr_to_raw_ftype *d10v_convert_iaddr_to_raw;
gdbarch_store_struct_return_ftype *store_struct_return;
gdbarch_store_return_value_ftype *store_return_value;
gdbarch_extract_struct_value_address_ftype *extract_struct_value_address;
--- 211,216 ----
***************
*** 386,397 ****
0,
0,
0,
- 0,
- 0,
- 0,
- 0,
- 0,
- 0,
/* startup_gdbarch() */
};
--- 380,385 ----
***************
*** 695,706 ****
&& (gdbarch->pop_frame == 0))
internal_error (__FILE__, __LINE__,
"gdbarch: verify_gdbarch: pop_frame invalid");
- /* Skip verify of d10v_make_daddr, invalid_p == 0 */
- /* Skip verify of d10v_make_iaddr, invalid_p == 0 */
- /* Skip verify of d10v_daddr_p, invalid_p == 0 */
- /* Skip verify of d10v_iaddr_p, invalid_p == 0 */
- /* Skip verify of d10v_convert_daddr_to_raw, invalid_p == 0 */
- /* Skip verify of d10v_convert_iaddr_to_raw, invalid_p == 0 */
if ((GDB_MULTI_ARCH >= 2)
&& (gdbarch->store_struct_return == 0))
internal_error (__FILE__, __LINE__,
--- 683,688 ----
***************
*** 1259,1300 ****
"POP_FRAME(-)",
XSTRING (POP_FRAME (-)));
#endif
- #ifdef D10V_MAKE_DADDR
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "D10V_MAKE_DADDR(x)",
- XSTRING (D10V_MAKE_DADDR (x)));
- #endif
- #ifdef D10V_MAKE_IADDR
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "D10V_MAKE_IADDR(x)",
- XSTRING (D10V_MAKE_IADDR (x)));
- #endif
- #ifdef D10V_DADDR_P
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "D10V_DADDR_P(x)",
- XSTRING (D10V_DADDR_P (x)));
- #endif
- #ifdef D10V_IADDR_P
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "D10V_IADDR_P(x)",
- XSTRING (D10V_IADDR_P (x)));
- #endif
- #ifdef D10V_CONVERT_DADDR_TO_RAW
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "D10V_CONVERT_DADDR_TO_RAW(x)",
- XSTRING (D10V_CONVERT_DADDR_TO_RAW (x)));
- #endif
- #ifdef D10V_CONVERT_IADDR_TO_RAW
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "D10V_CONVERT_IADDR_TO_RAW(x)",
- XSTRING (D10V_CONVERT_IADDR_TO_RAW (x)));
- #endif
#if defined (STORE_STRUCT_RETURN) && GDB_MULTI_ARCH
/* Macro might contain `[{}]' when not multi-arch */
fprintf_unfiltered (file,
--- 1241,1246 ----
***************
*** 1999,2046 ****
(long) current_gdbarch->pop_frame
/*POP_FRAME ()*/);
#endif
- #ifdef D10V_MAKE_DADDR
- if (GDB_MULTI_ARCH)
- fprintf_unfiltered (file,
- "gdbarch_dump: D10V_MAKE_DADDR = 0x%08lx\n",
- (long) current_gdbarch->d10v_make_daddr
- /*D10V_MAKE_DADDR ()*/);
- #endif
- #ifdef D10V_MAKE_IADDR
- if (GDB_MULTI_ARCH)
- fprintf_unfiltered (file,
- "gdbarch_dump: D10V_MAKE_IADDR = 0x%08lx\n",
- (long) current_gdbarch->d10v_make_iaddr
- /*D10V_MAKE_IADDR ()*/);
- #endif
- #ifdef D10V_DADDR_P
- if (GDB_MULTI_ARCH)
- fprintf_unfiltered (file,
- "gdbarch_dump: D10V_DADDR_P = 0x%08lx\n",
- (long) current_gdbarch->d10v_daddr_p
- /*D10V_DADDR_P ()*/);
- #endif
- #ifdef D10V_IADDR_P
- if (GDB_MULTI_ARCH)
- fprintf_unfiltered (file,
- "gdbarch_dump: D10V_IADDR_P = 0x%08lx\n",
- (long) current_gdbarch->d10v_iaddr_p
- /*D10V_IADDR_P ()*/);
- #endif
- #ifdef D10V_CONVERT_DADDR_TO_RAW
- if (GDB_MULTI_ARCH)
- fprintf_unfiltered (file,
- "gdbarch_dump: D10V_CONVERT_DADDR_TO_RAW = 0x%08lx\n",
- (long) current_gdbarch->d10v_convert_daddr_to_raw
- /*D10V_CONVERT_DADDR_TO_RAW ()*/);
- #endif
- #ifdef D10V_CONVERT_IADDR_TO_RAW
- if (GDB_MULTI_ARCH)
- fprintf_unfiltered (file,
- "gdbarch_dump: D10V_CONVERT_IADDR_TO_RAW = 0x%08lx\n",
- (long) current_gdbarch->d10v_convert_iaddr_to_raw
- /*D10V_CONVERT_IADDR_TO_RAW ()*/);
- #endif
#ifdef STORE_STRUCT_RETURN
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
--- 1945,1950 ----
***************
*** 3706,3819 ****
gdbarch_pop_frame_ftype pop_frame)
{
gdbarch->pop_frame = pop_frame;
- }
-
- CORE_ADDR
- gdbarch_d10v_make_daddr (struct gdbarch *gdbarch, CORE_ADDR x)
- {
- if (gdbarch->d10v_make_daddr == 0)
- internal_error (__FILE__, __LINE__,
- "gdbarch: gdbarch_d10v_make_daddr invalid");
- if (gdbarch_debug >= 2)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_d10v_make_daddr called\n");
- return gdbarch->d10v_make_daddr (x);
- }
-
- void
- set_gdbarch_d10v_make_daddr (struct gdbarch *gdbarch,
- gdbarch_d10v_make_daddr_ftype d10v_make_daddr)
- {
- gdbarch->d10v_make_daddr = d10v_make_daddr;
- }
-
- CORE_ADDR
- gdbarch_d10v_make_iaddr (struct gdbarch *gdbarch, CORE_ADDR x)
- {
- if (gdbarch->d10v_make_iaddr == 0)
- internal_error (__FILE__, __LINE__,
- "gdbarch: gdbarch_d10v_make_iaddr invalid");
- if (gdbarch_debug >= 2)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_d10v_make_iaddr called\n");
- return gdbarch->d10v_make_iaddr (x);
- }
-
- void
- set_gdbarch_d10v_make_iaddr (struct gdbarch *gdbarch,
- gdbarch_d10v_make_iaddr_ftype d10v_make_iaddr)
- {
- gdbarch->d10v_make_iaddr = d10v_make_iaddr;
- }
-
- int
- gdbarch_d10v_daddr_p (struct gdbarch *gdbarch, CORE_ADDR x)
- {
- if (gdbarch->d10v_daddr_p == 0)
- internal_error (__FILE__, __LINE__,
- "gdbarch: gdbarch_d10v_daddr_p invalid");
- if (gdbarch_debug >= 2)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_d10v_daddr_p called\n");
- return gdbarch->d10v_daddr_p (x);
- }
-
- void
- set_gdbarch_d10v_daddr_p (struct gdbarch *gdbarch,
- gdbarch_d10v_daddr_p_ftype d10v_daddr_p)
- {
- gdbarch->d10v_daddr_p = d10v_daddr_p;
- }
-
- int
- gdbarch_d10v_iaddr_p (struct gdbarch *gdbarch, CORE_ADDR x)
- {
- if (gdbarch->d10v_iaddr_p == 0)
- internal_error (__FILE__, __LINE__,
- "gdbarch: gdbarch_d10v_iaddr_p invalid");
- if (gdbarch_debug >= 2)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_d10v_iaddr_p called\n");
- return gdbarch->d10v_iaddr_p (x);
- }
-
- void
- set_gdbarch_d10v_iaddr_p (struct gdbarch *gdbarch,
- gdbarch_d10v_iaddr_p_ftype d10v_iaddr_p)
- {
- gdbarch->d10v_iaddr_p = d10v_iaddr_p;
- }
-
- CORE_ADDR
- gdbarch_d10v_convert_daddr_to_raw (struct gdbarch *gdbarch, CORE_ADDR x)
- {
- if (gdbarch->d10v_convert_daddr_to_raw == 0)
- internal_error (__FILE__, __LINE__,
- "gdbarch: gdbarch_d10v_convert_daddr_to_raw invalid");
- if (gdbarch_debug >= 2)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_d10v_convert_daddr_to_raw called\n");
- return gdbarch->d10v_convert_daddr_to_raw (x);
- }
-
- void
- set_gdbarch_d10v_convert_daddr_to_raw (struct gdbarch *gdbarch,
- gdbarch_d10v_convert_daddr_to_raw_ftype d10v_convert_daddr_to_raw)
- {
- gdbarch->d10v_convert_daddr_to_raw = d10v_convert_daddr_to_raw;
- }
-
- CORE_ADDR
- gdbarch_d10v_convert_iaddr_to_raw (struct gdbarch *gdbarch, CORE_ADDR x)
- {
- if (gdbarch->d10v_convert_iaddr_to_raw == 0)
- internal_error (__FILE__, __LINE__,
- "gdbarch: gdbarch_d10v_convert_iaddr_to_raw invalid");
- if (gdbarch_debug >= 2)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_d10v_convert_iaddr_to_raw called\n");
- return gdbarch->d10v_convert_iaddr_to_raw (x);
- }
-
- void
- set_gdbarch_d10v_convert_iaddr_to_raw (struct gdbarch *gdbarch,
- gdbarch_d10v_convert_iaddr_to_raw_ftype d10v_convert_iaddr_to_raw)
- {
- gdbarch->d10v_convert_iaddr_to_raw = d10v_convert_iaddr_to_raw;
}
void
--- 3610,3615 ----
Index: gdb/gdbarch.h
===================================================================
RCS file: /cvs/src/src/gdb/gdbarch.h,v
retrieving revision 1.56
diff -c -r1.56 gdbarch.h
*** gdb/gdbarch.h 2001/06/18 13:14:40 1.56
--- gdb/gdbarch.h 2001/06/28 23:47:14
***************
*** 1293,1402 ****
#endif
#endif
- /* I wish that these would just go away.... */
-
- /* Default (function) for non- multi-arch platforms. */
- #if (!GDB_MULTI_ARCH) && !defined (D10V_MAKE_DADDR)
- #define D10V_MAKE_DADDR(x) (internal_error (__FILE__, __LINE__, "D10V_MAKE_DADDR"), 0)
- #endif
-
- typedef CORE_ADDR (gdbarch_d10v_make_daddr_ftype) (CORE_ADDR x);
- extern CORE_ADDR gdbarch_d10v_make_daddr (struct gdbarch *gdbarch, CORE_ADDR x);
- extern void set_gdbarch_d10v_make_daddr (struct gdbarch *gdbarch, gdbarch_d10v_make_daddr_ftype *d10v_make_daddr);
- #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (D10V_MAKE_DADDR)
- #error "Non multi-arch definition of D10V_MAKE_DADDR"
- #endif
- #if GDB_MULTI_ARCH
- #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (D10V_MAKE_DADDR)
- #define D10V_MAKE_DADDR(x) (gdbarch_d10v_make_daddr (current_gdbarch, x))
- #endif
- #endif
-
- /* Default (function) for non- multi-arch platforms. */
- #if (!GDB_MULTI_ARCH) && !defined (D10V_MAKE_IADDR)
- #define D10V_MAKE_IADDR(x) (internal_error (__FILE__, __LINE__, "D10V_MAKE_IADDR"), 0)
- #endif
-
- typedef CORE_ADDR (gdbarch_d10v_make_iaddr_ftype) (CORE_ADDR x);
- extern CORE_ADDR gdbarch_d10v_make_iaddr (struct gdbarch *gdbarch, CORE_ADDR x);
- extern void set_gdbarch_d10v_make_iaddr (struct gdbarch *gdbarch, gdbarch_d10v_make_iaddr_ftype *d10v_make_iaddr);
- #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (D10V_MAKE_IADDR)
- #error "Non multi-arch definition of D10V_MAKE_IADDR"
- #endif
- #if GDB_MULTI_ARCH
- #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (D10V_MAKE_IADDR)
- #define D10V_MAKE_IADDR(x) (gdbarch_d10v_make_iaddr (current_gdbarch, x))
- #endif
- #endif
-
- /* Default (function) for non- multi-arch platforms. */
- #if (!GDB_MULTI_ARCH) && !defined (D10V_DADDR_P)
- #define D10V_DADDR_P(x) (internal_error (__FILE__, __LINE__, "D10V_DADDR_P"), 0)
- #endif
-
- typedef int (gdbarch_d10v_daddr_p_ftype) (CORE_ADDR x);
- extern int gdbarch_d10v_daddr_p (struct gdbarch *gdbarch, CORE_ADDR x);
- extern void set_gdbarch_d10v_daddr_p (struct gdbarch *gdbarch, gdbarch_d10v_daddr_p_ftype *d10v_daddr_p);
- #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (D10V_DADDR_P)
- #error "Non multi-arch definition of D10V_DADDR_P"
- #endif
- #if GDB_MULTI_ARCH
- #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (D10V_DADDR_P)
- #define D10V_DADDR_P(x) (gdbarch_d10v_daddr_p (current_gdbarch, x))
- #endif
- #endif
-
- /* Default (function) for non- multi-arch platforms. */
- #if (!GDB_MULTI_ARCH) && !defined (D10V_IADDR_P)
- #define D10V_IADDR_P(x) (internal_error (__FILE__, __LINE__, "D10V_IADDR_P"), 0)
- #endif
-
- typedef int (gdbarch_d10v_iaddr_p_ftype) (CORE_ADDR x);
- extern int gdbarch_d10v_iaddr_p (struct gdbarch *gdbarch, CORE_ADDR x);
- extern void set_gdbarch_d10v_iaddr_p (struct gdbarch *gdbarch, gdbarch_d10v_iaddr_p_ftype *d10v_iaddr_p);
- #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (D10V_IADDR_P)
- #error "Non multi-arch definition of D10V_IADDR_P"
- #endif
- #if GDB_MULTI_ARCH
- #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (D10V_IADDR_P)
- #define D10V_IADDR_P(x) (gdbarch_d10v_iaddr_p (current_gdbarch, x))
- #endif
- #endif
-
- /* Default (function) for non- multi-arch platforms. */
- #if (!GDB_MULTI_ARCH) && !defined (D10V_CONVERT_DADDR_TO_RAW)
- #define D10V_CONVERT_DADDR_TO_RAW(x) (internal_error (__FILE__, __LINE__, "D10V_CONVERT_DADDR_TO_RAW"), 0)
- #endif
-
- typedef CORE_ADDR (gdbarch_d10v_convert_daddr_to_raw_ftype) (CORE_ADDR x);
- extern CORE_ADDR gdbarch_d10v_convert_daddr_to_raw (struct gdbarch *gdbarch, CORE_ADDR x);
- extern void set_gdbarch_d10v_convert_daddr_to_raw (struct gdbarch *gdbarch, gdbarch_d10v_convert_daddr_to_raw_ftype *d10v_convert_daddr_to_raw);
- #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (D10V_CONVERT_DADDR_TO_RAW)
- #error "Non multi-arch definition of D10V_CONVERT_DADDR_TO_RAW"
- #endif
- #if GDB_MULTI_ARCH
- #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (D10V_CONVERT_DADDR_TO_RAW)
- #define D10V_CONVERT_DADDR_TO_RAW(x) (gdbarch_d10v_convert_daddr_to_raw (current_gdbarch, x))
- #endif
- #endif
-
- /* Default (function) for non- multi-arch platforms. */
- #if (!GDB_MULTI_ARCH) && !defined (D10V_CONVERT_IADDR_TO_RAW)
- #define D10V_CONVERT_IADDR_TO_RAW(x) (internal_error (__FILE__, __LINE__, "D10V_CONVERT_IADDR_TO_RAW"), 0)
- #endif
-
- typedef CORE_ADDR (gdbarch_d10v_convert_iaddr_to_raw_ftype) (CORE_ADDR x);
- extern CORE_ADDR gdbarch_d10v_convert_iaddr_to_raw (struct gdbarch *gdbarch, CORE_ADDR x);
- extern void set_gdbarch_d10v_convert_iaddr_to_raw (struct gdbarch *gdbarch, gdbarch_d10v_convert_iaddr_to_raw_ftype *d10v_convert_iaddr_to_raw);
- #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (D10V_CONVERT_IADDR_TO_RAW)
- #error "Non multi-arch definition of D10V_CONVERT_IADDR_TO_RAW"
- #endif
- #if GDB_MULTI_ARCH
- #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (D10V_CONVERT_IADDR_TO_RAW)
- #define D10V_CONVERT_IADDR_TO_RAW(x) (gdbarch_d10v_convert_iaddr_to_raw (current_gdbarch, x))
- #endif
- #endif
-
typedef void (gdbarch_store_struct_return_ftype) (CORE_ADDR addr, CORE_ADDR sp);
extern void gdbarch_store_struct_return (struct gdbarch *gdbarch, CORE_ADDR addr, CORE_ADDR sp);
extern void set_gdbarch_store_struct_return (struct gdbarch *gdbarch, gdbarch_store_struct_return_ftype *store_struct_return);
--- 1293,1298 ----
***************
*** 2291,2302 ****
#define TARGET_PRINT_INSN_INFO (&tm_print_insn_info)
#endif
-
-
- /* Explicit test for D10V architecture.
- USE of these macro's is *STRONGLY* discouraged. */
-
- #define GDB_TARGET_IS_D10V (TARGET_ARCHITECTURE->arch == bfd_arch_d10v)
/* Set the dynamic target-system-dependent parameters (architecture,
--- 2187,2192 ----
Index: gdb/gdbarch.sh
===================================================================
RCS file: /cvs/src/src/gdb/gdbarch.sh,v
retrieving revision 1.72
diff -c -r1.72 gdbarch.sh
*** gdb/gdbarch.sh 2001/06/18 13:14:40 1.72
--- gdb/gdbarch.sh 2001/06/28 23:47:16
***************
*** 476,489 ****
f:1:PUSH_RETURN_ADDRESS:CORE_ADDR:push_return_address:CORE_ADDR pc, CORE_ADDR sp:pc, sp:::0
f:2:POP_FRAME:void:pop_frame:void:-:::0
#
- # I wish that these would just go away....
- f:2:D10V_MAKE_DADDR:CORE_ADDR:d10v_make_daddr:CORE_ADDR x:x:::0::0
- f:2:D10V_MAKE_IADDR:CORE_ADDR:d10v_make_iaddr:CORE_ADDR x:x:::0::0
- f:2:D10V_DADDR_P:int:d10v_daddr_p:CORE_ADDR x:x:::0::0
- f:2:D10V_IADDR_P:int:d10v_iaddr_p:CORE_ADDR x:x:::0::0
- f:2:D10V_CONVERT_DADDR_TO_RAW:CORE_ADDR:d10v_convert_daddr_to_raw:CORE_ADDR x:x:::0::0
- f:2:D10V_CONVERT_IADDR_TO_RAW:CORE_ADDR:d10v_convert_iaddr_to_raw:CORE_ADDR x:x:::0::0
- #
f:2:STORE_STRUCT_RETURN:void:store_struct_return:CORE_ADDR addr, CORE_ADDR sp:addr, sp:::0
f:2:STORE_RETURN_VALUE:void:store_return_value:struct type *type, char *valbuf:type, valbuf:::0
F:2:EXTRACT_STRUCT_VALUE_ADDRESS:CORE_ADDR:extract_struct_value_address:char *regbuf:regbuf:::0
--- 476,481 ----
***************
*** 1071,1082 ****
#define TARGET_PRINT_INSN_INFO (&tm_print_insn_info)
#endif
-
-
- /* Explicit test for D10V architecture.
- USE of these macro's is *STRONGLY* discouraged. */
-
- #define GDB_TARGET_IS_D10V (TARGET_ARCHITECTURE->arch == bfd_arch_d10v)
/* Set the dynamic target-system-dependent parameters (architecture,
--- 1063,1068 ----
Index: gdb/printcmd.c
===================================================================
RCS file: /cvs/src/src/gdb/printcmd.c,v
retrieving revision 1.21
diff -c -r1.21 printcmd.c
*** gdb/printcmd.c 2001/06/11 16:05:24 1.21
--- gdb/printcmd.c 2001/06/28 23:47:19
***************
*** 1940,1948 ****
if (val)
{
- if (GDB_TARGET_IS_D10V
- && SYMBOL_CLASS (sym) == LOC_REGPARM && TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_PTR)
- TYPE_LENGTH (VALUE_TYPE (val)) = 2;
#ifdef UI_OUT
val_print (VALUE_TYPE (val), VALUE_CONTENTS (val), 0,
VALUE_ADDRESS (val),
--- 1946,1951 ----
Index: gdb/valops.c
===================================================================
RCS file: /cvs/src/src/gdb/valops.c,v
retrieving revision 1.36
diff -c -r1.36 valops.c
*** gdb/valops.c 2001/05/19 15:20:14 1.36
--- gdb/valops.c 2001/06/28 23:47:23
***************
*** 463,492 ****
val = allocate_value (type);
! if (GDB_TARGET_IS_D10V
! && TYPE_CODE (type) == TYPE_CODE_PTR
! && TYPE_TARGET_TYPE (type)
! && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC))
! {
! /* pointer to function */
! unsigned long num;
! unsigned short snum;
! snum = read_memory_unsigned_integer (addr, 2);
! num = D10V_MAKE_IADDR (snum);
! store_address (VALUE_CONTENTS_RAW (val), 4, num);
! }
! else if (GDB_TARGET_IS_D10V
! && TYPE_CODE (type) == TYPE_CODE_PTR)
! {
! /* pointer to data */
! unsigned long num;
! unsigned short snum;
! snum = read_memory_unsigned_integer (addr, 2);
! num = D10V_MAKE_DADDR (snum);
! store_address (VALUE_CONTENTS_RAW (val), 4, num);
! }
! else
! read_memory (addr, VALUE_CONTENTS_ALL_RAW (val), TYPE_LENGTH (type));
VALUE_LVAL (val) = lval_memory;
VALUE_ADDRESS (val) = addr;
--- 474,480 ----
val = allocate_value (type);
! read_memory (addr, VALUE_CONTENTS_ALL_RAW (val), TYPE_LENGTH (type));
VALUE_LVAL (val) = lval_memory;
VALUE_ADDRESS (val) = addr;
***************
*** 534,562 ****
int length = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val));
struct type *type = VALUE_TYPE (val);
! if (GDB_TARGET_IS_D10V
! && TYPE_CODE (type) == TYPE_CODE_PTR
! && TYPE_TARGET_TYPE (type)
! && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC))
! {
! /* pointer to function */
! unsigned long num;
! unsigned short snum;
! snum = read_memory_unsigned_integer (addr, 2);
! num = D10V_MAKE_IADDR (snum);
! store_address (VALUE_CONTENTS_RAW (val), 4, num);
! }
! else if (GDB_TARGET_IS_D10V
! && TYPE_CODE (type) == TYPE_CODE_PTR)
! {
! /* pointer to data */
! unsigned long num;
! unsigned short snum;
! snum = read_memory_unsigned_integer (addr, 2);
! num = D10V_MAKE_DADDR (snum);
! store_address (VALUE_CONTENTS_RAW (val), 4, num);
! }
! else if (length)
read_memory (addr, VALUE_CONTENTS_ALL_RAW (val), length);
VALUE_LAZY (val) = 0;
--- 522,528 ----
int length = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val));
struct type *type = VALUE_TYPE (val);
! if (length)
read_memory (addr, VALUE_CONTENTS_ALL_RAW (val), length);
VALUE_LAZY (val) = 0;
Index: gdb/values.c
===================================================================
RCS file: /cvs/src/src/gdb/values.c,v
retrieving revision 1.19
diff -c -r1.19 values.c
*** gdb/values.c 2001/06/15 19:19:23 1.19
--- gdb/values.c 2001/06/28 23:47:25
***************
*** 649,657 ****
case TYPE_CODE_REF:
/* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
whether we want this to be true eventually. */
- if (GDB_TARGET_IS_D10V
- && len == 2)
- return D10V_MAKE_DADDR (extract_address (valaddr, len));
return extract_typed_address (valaddr, type);
case TYPE_CODE_MEMBER:
--- 649,654 ----