This is the mail archive of the gdb-patches@sources.redhat.com mailing list for the GDB project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]

RFA: Revised: Remove D10V-specific code from arch-independent modules



Below is a revision of my I-hate-the-D10V patch, meant to implement
Andrew's suggestions:

- d10v-tdep.c uses builtin_type_void_func_ptr, instead of kludgily
  building its own type.

- As an independent, "obvious" fix, I have changed d10v-tdep.c to call
  the D10V address conversion functions directly, rather than calling
  the corresponding gdbarch macros.  This removes a lot of noise from
  the patch.

- d10v-tdep.c no longer says anything whatsoever about virtual/raw
  conversions.


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 (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.
	(d10v_register_convertible, d10v_register_convert_to_virtual,
	d10v_register_convert_to_raw): Delete function; no registers
	are convertible now, so we use
	generic_register_convertible_not instead.
	(d10v_address_to_pointer, d10v_pointer_to_address): New gdbarch
	methods.
	(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
        d10v_register_convert_to_virtual,
	d10v_register_convert_to_raw, 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.
	
Index: gdb/d10v-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/d10v-tdep.c,v
retrieving revision 1.21
diff -c -r1.21 d10v-tdep.c
*** gdb/d10v-tdep.c	2001/07/05 21:26:29	1.21
--- gdb/d10v-tdep.c	2001/07/05 23:01:19
***************
*** 332,378 ****
  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);
- }
- 
- 
  static CORE_ADDR
  d10v_make_daddr (CORE_ADDR x)
  {
--- 332,346 ----
  static struct type *
  d10v_register_virtual_type (int reg_nr)
  {
!   if (reg_nr == PC_REGNUM)
!     return builtin_type_void_func_ptr;
!   else if (reg_nr >= A0_REGNUM
        && reg_nr < (A0_REGNUM + NR_A_REGS))
      return builtin_type_int64;
    else
      return builtin_type_int16;
  }
  
  static CORE_ADDR
  d10v_make_daddr (CORE_ADDR x)
  {
***************
*** 410,415 ****
--- 378,425 ----
    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. 
  
***************
*** 1011,1049 ****
        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)
--- 1021,1026 ----
***************
*** 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)
--- 1075,1080 ----
***************
*** 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);
--- 1474,1483 ----
    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,1578 ****
    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);
- 
    set_gdbarch_extract_return_value (gdbarch, d10v_extract_return_value);
    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);
--- 1519,1528 ----
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/07/05 23:01:19
***************
*** 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/07/05 23:01:21
***************
*** 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/07/05 23:01:22
***************
*** 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/07/05 23:01:23
***************
*** 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/07/05 23:01:27
***************
*** 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),
--- 1940,1945 ----
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/07/05 23:01:29
***************
*** 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;
--- 463,469 ----
  
    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;
--- 511,517 ----
    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/07/05 23:01:30
***************
*** 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 ----


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]