[RFA/m32r] Fix breakpoint bug

["Kei Sakamoto" <sakamoto.kei@renesas.com>]

[-- Attachment #1: Type: text/plain, Size: 487 bytes --]

Hello,

m32r-tdep.c can't handle breakpoints on instructions executed
in parallel. It does not remove unnecessary parallel execution
bit from instructions and causes illegal instruction errors.

The attached patch fixes this problem.

OK to commit?

2004-10-07    Kei Sakamoto  <sakamoto.kei@renesas.com>

    * m32r-tdep.c (m32r_memory_insert_breakpoint): Remove
    unnecessary parallel execution bit.
    (m32r_memory_remove_breakpoint): Ditto.
    (m32r_breakpoint_from_pc): Update.

[-- Attachment #2: m32r-tdep.patch --]
[-- Type: application/octet-stream, Size: 5182 bytes --]

Index: m32r-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/m32r-tdep.c,v
retrieving revision 1.33
diff -u -r1.33 m32r-tdep.c
--- m32r-tdep.c	7 Oct 2004 01:21:53 -0000	1.33
+++ m32r-tdep.c	7 Oct 2004 04:27:00 -0000
@@ -56,62 +56,56 @@
 }
 
 
-/* BREAKPOINT */
-#define M32R_BE_BREAKPOINT32 {0x10, 0xf1, 0x70, 0x00}
-#define M32R_LE_BREAKPOINT32 {0xf1, 0x10, 0x00, 0x70}
-#define M32R_BE_BREAKPOINT16 {0x10, 0xf1}
-#define M32R_LE_BREAKPOINT16 {0xf1, 0x10}
-
 static int
 m32r_memory_insert_breakpoint (CORE_ADDR addr, char *contents_cache)
 {
   int val;
-  unsigned char *bp;
-  int bplen;
-
-  bplen = (addr & 3) ? 2 : 4;
+  char buf[4];
+  char bp_entry[] = { 0x10, 0xf1 };	/* dpt */
 
   /* Save the memory contents.  */
-  val = target_read_memory (addr, contents_cache, bplen);
+  val = target_read_memory (addr & 0xfffffffc, contents_cache, 4);
   if (val != 0)
     return val;			/* return error */
 
   /* Determine appropriate breakpoint contents and size for this address.  */
   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
     {
-      if (((addr & 3) == 0)
-	  && ((contents_cache[0] & 0x80) || (contents_cache[2] & 0x80)))
+      if ((addr & 3) == 0)
 	{
-	  static unsigned char insn[] = M32R_BE_BREAKPOINT32;
-	  bp = insn;
-	  bplen = sizeof (insn);
+	  buf[0] = bp_entry[0];
+	  buf[1] = bp_entry[1];
+	  buf[2] = contents_cache[2] & 0x7f;
+	  buf[3] = contents_cache[3];
 	}
       else
 	{
-	  static unsigned char insn[] = M32R_BE_BREAKPOINT16;
-	  bp = insn;
-	  bplen = sizeof (insn);
+	  buf[0] = contents_cache[0];
+	  buf[1] = contents_cache[1];
+	  buf[2] = bp_entry[0];
+	  buf[3] = bp_entry[1];
 	}
     }
-  else
-    {				/* little-endian */
-      if (((addr & 3) == 0)
-	  && ((contents_cache[1] & 0x80) || (contents_cache[3] & 0x80)))
-	{
-	  static unsigned char insn[] = M32R_LE_BREAKPOINT32;
-	  bp = insn;
-	  bplen = sizeof (insn);
+  else				/* little-endian */
+    {
+      if ((addr & 3) == 0)
+	{
+	  buf[0] = contents_cache[0];
+	  buf[1] = contents_cache[1] & 0x7f;
+	  buf[2] = bp_entry[1];
+	  buf[3] = bp_entry[0];
 	}
       else
 	{
-	  static unsigned char insn[] = M32R_LE_BREAKPOINT16;
-	  bp = insn;
-	  bplen = sizeof (insn);
+	  buf[0] = bp_entry[1];
+	  buf[1] = bp_entry[0];
+	  buf[2] = contents_cache[2];
+	  buf[3] = contents_cache[3];
 	}
     }
 
   /* Write the breakpoint.  */
-  val = target_write_memory (addr, (char *) bp, bplen);
+  val = target_write_memory (addr & 0xfffffffc, buf, 4);
   return val;
 }
 
@@ -119,47 +113,35 @@
 m32r_memory_remove_breakpoint (CORE_ADDR addr, char *contents_cache)
 {
   int val;
-  int bplen;
+  char buf[4];
 
-  /* Determine appropriate breakpoint contents and size for this address.  */
+  buf[0] = contents_cache[0];
+  buf[1] = contents_cache[1];
+  buf[2] = contents_cache[2];
+  buf[3] = contents_cache[3];
+
+  /* Remove parallel bit.  */
   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
     {
-      if (((addr & 3) == 0)
-	  && ((contents_cache[0] & 0x80) || (contents_cache[2] & 0x80)))
-	{
-	  static unsigned char insn[] = M32R_BE_BREAKPOINT32;
-	  bplen = sizeof (insn);
-	}
-      else
-	{
-	  static unsigned char insn[] = M32R_BE_BREAKPOINT16;
-	  bplen = sizeof (insn);
-	}
+      if ((buf[0] & 0x80) == 0 && (buf[2] & 0x80) != 0)
+	buf[2] &= 0x7f;
     }
-  else
+  else				/* little-endian */
     {
-      /* little-endian */
-      if (((addr & 3) == 0)
-	  && ((contents_cache[1] & 0x80) || (contents_cache[3] & 0x80)))
-	{
-	  static unsigned char insn[] = M32R_BE_BREAKPOINT32;
-	  bplen = sizeof (insn);
-	}
-      else
-	{
-	  static unsigned char insn[] = M32R_BE_BREAKPOINT16;
-	  bplen = sizeof (insn);
-	}
+      if ((buf[3] & 0x80) == 0 && (buf[1] & 0x80) != 0)
+	buf[1] &= 0x7f;
     }
 
   /* Write contents.  */
-  val = target_write_memory (addr, contents_cache, bplen);
+  val = target_write_memory (addr & 0xfffffffc, buf, 4);
   return val;
 }
 
 static const unsigned char *
 m32r_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
 {
+  static char be_bp_entry[] = { 0x10, 0xf1, 0x70, 0x00 };	/* dpt -> nop */
+  static char le_bp_entry[] = { 0x00, 0x70, 0xf1, 0x10 };	/* dpt -> nop */
   unsigned char *bp;
 
   /* Determine appropriate breakpoint.  */
@@ -167,30 +149,26 @@
     {
       if ((*pcptr & 3) == 0)
 	{
-	  static unsigned char insn[] = M32R_BE_BREAKPOINT32;
-	  bp = insn;
-	  *lenptr = sizeof (insn);
+	  bp = be_bp_entry;
+	  *lenptr = 4;
 	}
       else
 	{
-	  static unsigned char insn[] = M32R_BE_BREAKPOINT16;
-	  bp = insn;
-	  *lenptr = sizeof (insn);
+	  bp = be_bp_entry;
+	  *lenptr = 2;
 	}
     }
   else
     {
       if ((*pcptr & 3) == 0)
 	{
-	  static unsigned char insn[] = M32R_LE_BREAKPOINT32;
-	  bp = insn;
-	  *lenptr = sizeof (insn);
+	  bp = le_bp_entry;
+	  *lenptr = 4;
 	}
       else
 	{
-	  static unsigned char insn[] = M32R_LE_BREAKPOINT16;
-	  bp = insn;
-	  *lenptr = sizeof (insn);
+	  bp = le_bp_entry + 2;
+	  *lenptr = 2;
 	}
     }