This is the mail archive of the gdb-patches@sourceware.org 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]
Other format: [Raw text]

[rfc] [11/12] Get rid of current_gdbarch in xtensa-tdep.c


Hi,

this patch gets rid of some of the current_gdbarch's in xtensa-tdep.c

Is this ok to commit?

ChangeLog:

	* xtensa-tdep.c (xtensa_register_type, xtensa_pseudo_register_read)
	(xtensa_pseudo_register_write, xtensa_register_reggroup_p)
	(xtensa_unwind_pc, xtensa_frame_cache, xtensa_frame_prev_register)
	(xtensa_push_dummy_call): Replace current_gdbarch by frame-specific
	architecture recognition.
	(xtensa_dump_tdep): Rename parameter to gdbarch.

--
Markus Deuling
GNU Toolchain for Linux on Cell BE
deuling@de.ibm.com




diff -urpN src/gdb/xtensa-tdep.c dev/gdb/xtensa-tdep.c
--- src/gdb/xtensa-tdep.c	2007-06-19 05:22:05.000000000 +0200
+++ dev/gdb/xtensa-tdep.c	2007-08-01 09:44:38.000000000 +0200
@@ -209,12 +209,12 @@ xtensa_register_type (struct gdbarch *gd
       || (regnum >= A0_BASE && regnum < A0_BASE + 16))
     return builtin_type_int;
 
-  if (regnum == gdbarch_pc_regnum (current_gdbarch) || regnum == A1_REGNUM)
+  if (regnum == gdbarch_pc_regnum (gdbarch) || regnum == A1_REGNUM)
     return lookup_pointer_type (builtin_type_void);
 
   /* Return the stored type for all other registers.  */
-  else if (regnum >= 0 && regnum < gdbarch_num_regs (current_gdbarch)
-				   + gdbarch_num_pseudo_regs (current_gdbarch))
+  else if (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch)
+				   + gdbarch_num_pseudo_regs (gdbarch))
     {
       xtensa_register_t* reg = &REGMAP[regnum];
 
@@ -509,13 +509,13 @@ xtensa_pseudo_register_read (struct gdba
     }
 
   /* We can always read 'regular' registers.  */
-  if (regnum >= 0 && regnum < gdbarch_num_regs (current_gdbarch))
+  if (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch))
     regcache_raw_read (regcache, regnum, buffer);
 
   /* Pseudo registers.  */
   else if (regnum >= 0
-	    && regnum < gdbarch_num_regs (current_gdbarch)
-			+ gdbarch_num_pseudo_regs (current_gdbarch))
+	    && regnum < gdbarch_num_regs (gdbarch)
+			+ gdbarch_num_pseudo_regs (gdbarch))
     {
       xtensa_register_t *reg = &REGMAP[regnum];
       xtensa_register_type_t type = reg->type;
@@ -594,13 +594,13 @@ xtensa_pseudo_register_write (struct gdb
 
   /* We can always write 'core' registers.
      Note: We might have converted Ax->ARy.  */
-  if (regnum >= 0 && regnum < gdbarch_num_regs (current_gdbarch))
+  if (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch))
     regcache_raw_write (regcache, regnum, buffer);
 
   /* Pseudo registers.  */
   else if (regnum >= 0
-	   && regnum < gdbarch_num_regs (current_gdbarch)
-		       + gdbarch_num_pseudo_regs (current_gdbarch))
+	   && regnum < gdbarch_num_regs (gdbarch)
+		       + gdbarch_num_pseudo_regs (gdbarch))
     {
       xtensa_register_t *reg = &REGMAP[regnum];
       xtensa_register_type_t type = reg->type;
@@ -723,7 +723,7 @@ xtensa_register_reggroup_p (struct gdbar
   if (group == vector_reggroup || group == xtensa_vectra_reggroup)
     return rg & xtRegisterGroupVectra;
   if (group == save_reggroup || group == restore_reggroup)
-    return (regnum < gdbarch_num_regs (current_gdbarch)
+    return (regnum < gdbarch_num_regs (gdbarch)
 	    && (reg->flags & SAVE_REST_FLAGS) == SAVE_REST_VALID);
   else
     return 1;
@@ -871,7 +871,7 @@ xtensa_unwind_pc (struct gdbarch *gdbarc
 
   DEBUGTRACE ("xtensa_unwind_pc (next_frame = %p)\n", next_frame);
 
-  frame_unwind_register (next_frame, gdbarch_pc_regnum (current_gdbarch), buf);
+  frame_unwind_register (next_frame, gdbarch_pc_regnum (gdbarch), buf);
 
   DEBUGINFO ("[xtensa_unwind_pc] pc = 0x%08x\n", (unsigned int)
 	     extract_typed_address (buf, builtin_type_void_func_ptr));
@@ -902,6 +902,7 @@ xtensa_unwind_dummy_id (struct gdbarch *
 static struct xtensa_frame_cache *
 xtensa_frame_cache (struct frame_info *next_frame, void **this_cache)
 {
+  struct gdbarch *gdbarch = get_frame_arch (next_frame);
   xtensa_frame_cache_t *cache;
   char buf[4];
   CORE_ADDR ra, wb, ws, pc, sp, ps;
@@ -922,9 +923,9 @@ xtensa_frame_cache (struct frame_info *n
   wb = frame_unwind_register_unsigned (next_frame, WB_REGNUM);
   ws = frame_unwind_register_unsigned (next_frame, WS_REGNUM);
   ps = frame_unwind_register_unsigned (next_frame,
-				       gdbarch_ps_regnum (current_gdbarch));
+				       gdbarch_ps_regnum (gdbarch));
   pc = frame_unwind_register_unsigned (next_frame,
-				       gdbarch_pc_regnum (current_gdbarch));
+				       gdbarch_pc_regnum (gdbarch));
 
   op1 = read_memory_integer (pc, 1);
   if (XTENSA_IS_ENTRY (op1) || !windowing_enabled (ps))
@@ -994,7 +995,7 @@ xtensa_frame_cache (struct frame_info *n
 	     We can read caller's frame SP from the proper spill loction.  */
 	  cache->prev_sp =
 		  read_memory_integer (cache->aregs[1],
-				       register_size (current_gdbarch,
+				       register_size (gdbarch,
 						      A1_REGNUM));
 	}
       else
@@ -1047,6 +1048,7 @@ xtensa_frame_prev_register (struct frame
 			    int *realnump,
 			    gdb_byte *valuep)
 {
+  struct gdbarch *gdbarch = get_frame_arch (next_frame);
   struct xtensa_frame_cache *cache =
     xtensa_frame_cache (next_frame, this_cache);
   CORE_ADDR saved_reg = 0;
@@ -1067,9 +1069,9 @@ xtensa_frame_prev_register (struct frame
     }
   else if (regnum == WB_REGNUM)
     saved_reg = cache->wb;
-  else if (regnum == gdbarch_pc_regnum (current_gdbarch))
+  else if (regnum == gdbarch_pc_regnum (gdbarch))
     saved_reg = cache->pc;
-  else if (regnum == gdbarch_ps_regnum (current_gdbarch))
+  else if (regnum == gdbarch_ps_regnum (gdbarch))
     saved_reg = cache->ps;
   else
     done = 0;
@@ -1106,7 +1108,7 @@ xtensa_frame_prev_register (struct frame
 
 	  if (valuep)
 	    read_memory (*addrp, valuep,
-			 register_size (current_gdbarch, regnum));
+			 register_size (gdbarch, regnum));
 
 	  DEBUGINFO ("[xtensa_frame_prev_register] register on stack\n");
 	  return;
@@ -1448,7 +1450,7 @@ xtensa_push_dummy_call (struct gdbarch *
 	     applies for structures smaller than one word.  */
 
 	  if (n < REGISTER_SIZE
-	      && gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
+	      && gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
 	    offset += (REGISTER_SIZE - n);
 
 	  write_memory (offset, info->contents, info->length);
@@ -1467,7 +1469,7 @@ xtensa_push_dummy_call (struct gdbarch *
 	     will be left-aligned in the register on both endiannesses.  */
 
 	  if (n < REGISTER_SIZE
-	      && gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
+	      && gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
 	    {
 	      ULONGEST v = extract_unsigned_integer (cp, REGISTER_SIZE);
 	      v = v >> ((REGISTER_SIZE - n) * TARGET_CHAR_BIT);
@@ -1499,11 +1501,11 @@ xtensa_push_dummy_call (struct gdbarch *
      saved in the dummy frame, so we can savely overwrite A0 here.  */
 
   ra = (bp_addr & 0x3fffffff) | 0x40000000;
-  regcache_raw_read (regcache, gdbarch_ps_regnum (current_gdbarch), buf);
+  regcache_raw_read (regcache, gdbarch_ps_regnum (gdbarch), buf);
   ps = extract_unsigned_integer (buf, 4) & ~0x00030000;
   regcache_cooked_write_unsigned (regcache, A4_REGNUM, ra);
   regcache_cooked_write_unsigned (regcache,
-				  gdbarch_ps_regnum (current_gdbarch),
+				  gdbarch_ps_regnum (gdbarch),
 				  ps | 0x00010000);
 
   /* Set new stack pointer and return it.  */
@@ -1744,7 +1746,7 @@ xtensa_gdbarch_init (struct gdbarch_info
 /* Dump xtensa tdep structure.  */
 
 static void
-xtensa_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
+xtensa_dump_tdep (struct gdbarch *gdbarch, struct ui_file *file)
 {
   error (_("xtensa_dump_tdep(): not implemented"));
 }




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