* Bringing over SKY PKE disassembler feature from sky branch.

[deliverable/binutils-gdb.git] / gdb / irix5-nat.c

diff --git a/gdb/irix5-nat.c b/gdb/irix5-nat.c
index 992c46d72cbdc42e18bc3599dca7c6b753344b88..88bbf96e102e6154f6af6e7040560b413f853ca7 100644 (file)
--- a/gdb/irix5-nat.c
+++ b/gdb/irix5-nat.c
@@ -1,5 +1,5 @@
 /* Native support for the SGI Iris running IRIX version 5, for GDB.
-   Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996
+   Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998
    Free Software Foundation, Inc.
    Contributed by Alessandro Forin(af@cs.cmu.edu) at CMU
    and by Per Bothner(bothner@cs.wisc.edu) at U.Wisconsin.
@@ -52,15 +52,16 @@ supply_gregset (gregsetp)
 {
   register int regi;
   register greg_t *regp = &(*gregsetp)[0];
+  int gregoff = sizeof (greg_t) - MIPS_REGSIZE;
   static char zerobuf[MAX_REGISTER_RAW_SIZE] = {0};
 
   for(regi = 0; regi <= CTX_RA; regi++)
-    supply_register (regi, (char *)(regp + regi));
+    supply_register (regi, (char *)(regp + regi) + gregoff);
 
-  supply_register (PC_REGNUM, (char *)(regp + CTX_EPC));
-  supply_register (HI_REGNUM, (char *)(regp + CTX_MDHI));
-  supply_register (LO_REGNUM, (char *)(regp + CTX_MDLO));
-  supply_register (CAUSE_REGNUM, (char *)(regp + CTX_CAUSE));
+  supply_register (PC_REGNUM, (char *)(regp + CTX_EPC) + gregoff);
+  supply_register (HI_REGNUM, (char *)(regp + CTX_MDHI) + gregoff);
+  supply_register (LO_REGNUM, (char *)(regp + CTX_MDLO) + gregoff);
+  supply_register (CAUSE_REGNUM, (char *)(regp + CTX_CAUSE) + gregoff);
 
   /* Fill inaccessible registers with zero.  */
   supply_register (BADVADDR_REGNUM, zerobuf);
@@ -74,21 +75,35 @@ fill_gregset (gregsetp, regno)
   int regi;
   register greg_t *regp = &(*gregsetp)[0];
 
+  /* Under Irix6, if GDB is built with N32 ABI and is debugging an O32
+     executable, we have to sign extend the registers to 64 bits before
+     filling in the gregset structure.  */
+
   for (regi = 0; regi <= CTX_RA; regi++)
     if ((regno == -1) || (regno == regi))
-      *(regp + regi) = *(greg_t *) &registers[REGISTER_BYTE (regi)];
+      *(regp + regi) =
+       extract_signed_integer (&registers[REGISTER_BYTE (regi)],
+                               REGISTER_RAW_SIZE (regi));
 
   if ((regno == -1) || (regno == PC_REGNUM))
-    *(regp + CTX_EPC) = *(greg_t *) &registers[REGISTER_BYTE (PC_REGNUM)];
+    *(regp + CTX_EPC) =
+      extract_signed_integer (&registers[REGISTER_BYTE (PC_REGNUM)],
+                             REGISTER_RAW_SIZE (PC_REGNUM));
 
   if ((regno == -1) || (regno == CAUSE_REGNUM))
-    *(regp + CTX_CAUSE) = *(greg_t *) &registers[REGISTER_BYTE (CAUSE_REGNUM)];
+    *(regp + CTX_CAUSE) =
+      extract_signed_integer (&registers[REGISTER_BYTE (CAUSE_REGNUM)],
+                             REGISTER_RAW_SIZE (CAUSE_REGNUM));
 
   if ((regno == -1) || (regno == HI_REGNUM))
-    *(regp + CTX_MDHI) = *(greg_t *) &registers[REGISTER_BYTE (HI_REGNUM)];
+    *(regp + CTX_MDHI) =
+      extract_signed_integer (&registers[REGISTER_BYTE (HI_REGNUM)],
+                             REGISTER_RAW_SIZE (HI_REGNUM));
 
   if ((regno == -1) || (regno == LO_REGNUM))
-    *(regp + CTX_MDLO) = *(greg_t *) &registers[REGISTER_BYTE (LO_REGNUM)];
+    *(regp + CTX_MDLO) =
+      extract_signed_integer (&registers[REGISTER_BYTE (LO_REGNUM)],
+                             REGISTER_RAW_SIZE (LO_REGNUM));
 }
 
 /*
@@ -106,6 +121,8 @@ supply_fpregset (fpregsetp)
   register int regi;
   static char zerobuf[MAX_REGISTER_RAW_SIZE] = {0};
 
+  /* FIXME, this is wrong for the N32 ABI which has 64 bit FP regs. */
+
   for (regi = 0; regi < 32; regi++)
     supply_register (FP0_REGNUM + regi,
                     (char *)&fpregsetp->fp_r.fp_regs[regi]);
@@ -124,6 +141,8 @@ fill_fpregset (fpregsetp, regno)
   int regi;
   char *from, *to;
 
+  /* FIXME, this is wrong for the N32 ABI which has 64 bit FP regs. */
+
   for (regi = FP0_REGNUM; regi < FP0_REGNUM + 32; regi++)
     {
       if ((regno == -1) || (regno == regi))
@@ -173,7 +192,8 @@ fetch_core_registers (core_reg_sect, core_reg_size, which, reg_addr)
     {
       memcpy ((char *)registers, core_reg_sect, core_reg_size);
     }
-  else if (core_reg_size == (2 * REGISTER_BYTES) && MIPS_REGSIZE == 4)
+  else if (MIPS_REGSIZE == 4 &&
+          core_reg_size == (2 * MIPS_REGSIZE) * NUM_REGS)
     {
       /* This is a core file from a N32 executable, 64 bits are saved
         for all registers.  */
@@ -191,7 +211,20 @@ fetch_core_registers (core_reg_sect, core_reg_size, which, reg_addr)
              *dstp++ = *srcp++;
              *dstp++ = *srcp++;
              *dstp++ = *srcp++;
-             srcp += 4;
+             if (REGISTER_RAW_SIZE(regno) == 4)
+               {
+                 /* copying 4 bytes from eight bytes?
+                    I don't see how this can be right...  */
+                 srcp += 4;    
+               }
+             else
+               {
+                 /* copy all 8 bytes (sizeof(double)) */
+                 *dstp++ = *srcp++;
+                 *dstp++ = *srcp++;
+                 *dstp++ = *srcp++;
+                 *dstp++ = *srcp++;
+               }
            }
          else
            {
@@ -333,8 +366,8 @@ xfer_link_map_member PARAMS ((struct so_list *, struct link_map *));
 static CORE_ADDR
 locate_base PARAMS ((void));
 
-static void
-solib_map_sections PARAMS ((struct so_list *));
+static int
+solib_map_sections PARAMS ((char *));
 
 /*
 
@@ -344,7 +377,7 @@ LOCAL FUNCTION
 
 SYNOPSIS
 
-       static void solib_map_sections (struct so_list *so)
+       static int solib_map_sections (struct so_list *so)
 
 DESCRIPTION
 
@@ -363,10 +396,11 @@ FIXMES
        expansion stuff?).
  */
 
-static void
-solib_map_sections (so)
-     struct so_list *so;
+static int
+solib_map_sections (arg)
+     char *arg;
 {
+  struct so_list *so = (struct so_list *) arg; /* catch_errors bogon */
   char *filename;
   char *scratch_pathname;
   int scratch_chan;
@@ -428,6 +462,8 @@ solib_map_sections (so)
 
   /* Free the file names, close the file now.  */
   do_cleanups (old_chain);
+
+  return (1);
 }
 
 /*
@@ -669,12 +705,32 @@ xfer_link_map_member (so_list_ptr, lm)
        memory_error (errcode, (CORE_ADDR) list_32.oi_pathname);
 
       LM_ADDR (so_list_ptr) = (CORE_ADDR) list_32.oi_ehdr;
-      LM_OFFSET (so_list_ptr)
-       = (CORE_ADDR) list_32.oi_ehdr - (CORE_ADDR) list_32.oi_orig_ehdr;
+      LM_OFFSET (so_list_ptr) =
+       (CORE_ADDR) list_32.oi_ehdr - (CORE_ADDR) list_32.oi_orig_ehdr;
     }
   else
 #endif
     {
+#if defined (_MIPS_SIM_NABI32) && _MIPS_SIM == _MIPS_SIM_NABI32
+      /* If we are compiling GDB under N32 ABI, the alignments in
+        the obj struct are different from the O32 ABI and we will get
+        wrong values when accessing the struct.
+        As a workaround we use fixed values which are good for
+        Irix 6.2.  */
+      char buf[432];
+
+      read_memory ((CORE_ADDR) list_old.data, buf, sizeof (buf));
+
+      target_read_string (extract_address (&buf[236], 4),
+                         &so_list_ptr -> so_name,
+                         INT_MAX, &errcode);
+      if (errcode != 0)
+       memory_error (errcode, extract_address (&buf[236], 4));
+
+      LM_ADDR (so_list_ptr) = extract_address (&buf[196], 4);
+      LM_OFFSET (so_list_ptr) =
+       extract_address (&buf[196], 4) - extract_address (&buf[248], 4);
+#else
       struct obj obj_old;
 
       read_memory ((CORE_ADDR) list_old.data, (char *) &obj_old,
@@ -687,11 +743,14 @@ xfer_link_map_member (so_list_ptr, lm)
        memory_error (errcode, (CORE_ADDR) obj_old.o_path);
 
       LM_ADDR (so_list_ptr) = (CORE_ADDR) obj_old.o_praw;
-      LM_OFFSET (so_list_ptr)
-       = (CORE_ADDR) obj_old.o_praw - obj_old.o_base_address;
+      LM_OFFSET (so_list_ptr) =
+       (CORE_ADDR) obj_old.o_praw - obj_old.o_base_address;
+#endif
     }
 
-  solib_map_sections (so_list_ptr);
+  catch_errors (solib_map_sections, (char *) so_list_ptr,
+               "Error while mapping shared library sections:\n",
+               RETURN_MASK_ALL);
 }
 
 
@@ -770,7 +829,7 @@ symbol_add_stub (arg)
 
   if (so -> textsection)
     text_addr = so -> textsection -> addr;
-  else
+  else if (so -> abfd != NULL)
     {
       asection *lowest_sect;