Add "make pdf" and "make install-pdf", from Brooks Moses
[deliverable/binutils-gdb.git] / gdb / dwarf2-frame.c
index 945d21647fd5bafc3880795c49d0371d4964a050..be61a0eca894b14fdb51c2a07b73fa866ce23758 100644 (file)
@@ -1,6 +1,6 @@
 /* Frame unwinder for frames with DWARF Call Frame Information.
 
-   Copyright 2003, 2004, 2005 Free Software Foundation, Inc.
+   Copyright (C) 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
 
    Contributed by Mark Kettenis.
 
@@ -18,8 +18,8 @@
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
+   Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.  */
 
 #include "defs.h"
 #include "dwarf2expr.h"
@@ -32,6 +32,7 @@
 #include "symtab.h"
 #include "objfiles.h"
 #include "regcache.h"
+#include "value.h"
 
 #include "gdb_assert.h"
 #include "gdb_string.h"
@@ -63,12 +64,21 @@ struct dwarf2_cie
   gdb_byte *initial_instructions;
   gdb_byte *end;
 
+  /* Saved augmentation, in case it's needed later.  */
+  char *augmentation;
+
   /* Encoding of addresses.  */
   gdb_byte encoding;
 
   /* True if a 'z' augmentation existed.  */
   unsigned char saw_z_augmentation;
 
+  /* True if an 'S' augmentation existed.  */
+  unsigned char signal_frame;
+
+  /* The version recorded in the CIE.  */
+  unsigned char version;
+
   struct dwarf2_cie *next;
 };
 
@@ -89,6 +99,10 @@ struct dwarf2_fde
   gdb_byte *instructions;
   gdb_byte *end;
 
+  /* True if this FDE is read from a .eh_frame instead of a .debug_frame
+     section.  */
+  unsigned char eh_frame_p;
+
   struct dwarf2_fde *next;
 };
 
@@ -130,6 +144,16 @@ struct dwarf2_frame_state
   LONGEST data_align;
   ULONGEST code_align;
   ULONGEST retaddr_column;
+
+  /* Flags for known producer quirks.  */
+
+  /* The ARM compilers, in DWARF2 mode, assume that DW_CFA_def_cfa
+     and DW_CFA_def_cfa_offset takes a factored offset.  */
+  int armcc_cfa_offsets_sf;
+
+  /* The ARM compilers, in DWARF2 or DWARF3 mode, may assume that
+     the CFA is defined as REG - OFFSET rather than REG + OFFSET.  */
+  int armcc_cfa_offsets_reversed;
 };
 
 /* Store the length the expression for the CFA in the `cfa_reg' field,
@@ -214,7 +238,13 @@ read_reg (void *baton, int reg)
 
   buf = alloca (register_size (gdbarch, regnum));
   frame_unwind_register (next_frame, regnum, buf);
-  return extract_typed_address (buf, builtin_type_void_data_ptr);
+
+  /* Convert the register to an integer.  This returns a LONGEST
+     rather than a CORE_ADDR, but unpack_pointer does the same thing
+     under the covers, and this makes more sense for non-pointer
+     registers.  Maybe read_reg and the associated interfaces should
+     deal with "struct value" instead of CORE_ADDR.  */
+  return unpack_long (register_type (gdbarch, regnum), buf);
 }
 
 static void
@@ -267,10 +297,11 @@ execute_stack_op (gdb_byte *exp, ULONGEST len,
 static void
 execute_cfa_program (gdb_byte *insn_ptr, gdb_byte *insn_end,
                     struct frame_info *next_frame,
-                    struct dwarf2_frame_state *fs)
+                    struct dwarf2_frame_state *fs, int eh_frame_p)
 {
   CORE_ADDR pc = frame_pc_unwind (next_frame);
   int bytes_read;
+  struct gdbarch *gdbarch = get_frame_arch (next_frame);
 
   while (insn_ptr < insn_end && fs->pc <= pc)
     {
@@ -283,6 +314,8 @@ execute_cfa_program (gdb_byte *insn_ptr, gdb_byte *insn_end,
       else if ((insn & 0xc0) == DW_CFA_offset)
        {
          reg = insn & 0x3f;
+         if (eh_frame_p)
+           reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
          insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
          offset = utmp * fs->data_align;
          dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
@@ -293,8 +326,20 @@ execute_cfa_program (gdb_byte *insn_ptr, gdb_byte *insn_end,
        {
          gdb_assert (fs->initial.reg);
          reg = insn & 0x3f;
+         if (eh_frame_p)
+           reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
          dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
-         fs->regs.reg[reg] = fs->initial.reg[reg];
+         if (reg < fs->initial.num_regs)
+           fs->regs.reg[reg] = fs->initial.reg[reg];
+         else 
+           fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNSPECIFIED;
+
+         if (fs->regs.reg[reg].how == DWARF2_FRAME_REG_UNSPECIFIED)
+           complaint (&symfile_complaints, _("\
+incomplete CFI data; DW_CFA_restore unspecified\n\
+register %s (#%d) at 0x%s"),
+                      REGISTER_NAME(DWARF2_REG_TO_REGNUM(reg)),
+                      DWARF2_REG_TO_REGNUM(reg), paddr (fs->pc));
        }
       else
        {
@@ -323,6 +368,8 @@ execute_cfa_program (gdb_byte *insn_ptr, gdb_byte *insn_end,
 
            case DW_CFA_offset_extended:
              insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
+             if (eh_frame_p)
+               reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
              insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
              offset = utmp * fs->data_align;
              dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
@@ -333,25 +380,35 @@ execute_cfa_program (gdb_byte *insn_ptr, gdb_byte *insn_end,
            case DW_CFA_restore_extended:
              gdb_assert (fs->initial.reg);
              insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
+             if (eh_frame_p)
+               reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
              dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
              fs->regs.reg[reg] = fs->initial.reg[reg];
              break;
 
            case DW_CFA_undefined:
              insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
+             if (eh_frame_p)
+               reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
              dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
              fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNDEFINED;
              break;
 
            case DW_CFA_same_value:
              insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
+             if (eh_frame_p)
+               reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
              dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
              fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAME_VALUE;
              break;
 
            case DW_CFA_register:
              insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
+             if (eh_frame_p)
+               reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
              insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
+             if (eh_frame_p)
+               utmp = dwarf2_frame_eh_frame_regnum (gdbarch, utmp);
              dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
              fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
              fs->regs.reg[reg].loc.reg = utmp;
@@ -389,17 +446,28 @@ bad CFI data; mismatched DW_CFA_restore_state at 0x%s"), paddr (fs->pc));
            case DW_CFA_def_cfa:
              insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_reg);
              insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
+
+             if (fs->armcc_cfa_offsets_sf)
+               utmp *= fs->data_align;
+
              fs->cfa_offset = utmp;
              fs->cfa_how = CFA_REG_OFFSET;
              break;
 
            case DW_CFA_def_cfa_register:
              insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_reg);
+             if (eh_frame_p)
+               fs->cfa_reg = dwarf2_frame_eh_frame_regnum (gdbarch,
+                                                           fs->cfa_reg);
              fs->cfa_how = CFA_REG_OFFSET;
              break;
 
            case DW_CFA_def_cfa_offset:
              insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
+
+             if (fs->armcc_cfa_offsets_sf)
+               utmp *= fs->data_align;
+
              fs->cfa_offset = utmp;
              /* cfa_how deliberately not set.  */
              break;
@@ -416,6 +484,8 @@ bad CFI data; mismatched DW_CFA_restore_state at 0x%s"), paddr (fs->pc));
 
            case DW_CFA_expression:
              insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
+             if (eh_frame_p)
+               reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
              dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
              insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
              fs->regs.reg[reg].loc.exp = insn_ptr;
@@ -426,6 +496,8 @@ bad CFI data; mismatched DW_CFA_restore_state at 0x%s"), paddr (fs->pc));
 
            case DW_CFA_offset_extended_sf:
              insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
+             if (eh_frame_p)
+               reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
              insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
              offset *= fs->data_align;
              dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
@@ -433,8 +505,39 @@ bad CFI data; mismatched DW_CFA_restore_state at 0x%s"), paddr (fs->pc));
              fs->regs.reg[reg].loc.offset = offset;
              break;
 
+           case DW_CFA_val_offset:
+             insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
+             dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
+             insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
+             offset = utmp * fs->data_align;
+             fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_OFFSET;
+             fs->regs.reg[reg].loc.offset = offset;
+             break;
+
+           case DW_CFA_val_offset_sf:
+             insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
+             dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
+             insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
+             offset *= fs->data_align;
+             fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_OFFSET;
+             fs->regs.reg[reg].loc.offset = offset;
+             break;
+
+           case DW_CFA_val_expression:
+             insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
+             dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
+             insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
+             fs->regs.reg[reg].loc.exp = insn_ptr;
+             fs->regs.reg[reg].exp_len = utmp;
+             fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_EXP;
+             insn_ptr += utmp;
+             break;
+
            case DW_CFA_def_cfa_sf:
              insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_reg);
+             if (eh_frame_p)
+               fs->cfa_reg = dwarf2_frame_eh_frame_regnum (gdbarch,
+                                                           fs->cfa_reg);
              insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
              fs->cfa_offset = offset * fs->data_align;
              fs->cfa_how = CFA_REG_OFFSET;
@@ -476,6 +579,17 @@ bad CFI data; mismatched DW_CFA_restore_state at 0x%s"), paddr (fs->pc));
              insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
              break;
 
+           case DW_CFA_GNU_negative_offset_extended:
+             insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
+             if (eh_frame_p)
+               reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
+             insn_ptr = read_uleb128 (insn_ptr, insn_end, &offset);
+             offset *= fs->data_align;
+             dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
+             fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
+             fs->regs.reg[reg].loc.offset = -offset;
+             break;
+
            default:
              internal_error (__FILE__, __LINE__, _("Unknown CFI encountered."));
            }
@@ -496,11 +610,15 @@ static struct gdbarch_data *dwarf2_frame_data;
 struct dwarf2_frame_ops
 {
   /* Pre-initialize the register state REG for register REGNUM.  */
-  void (*init_reg) (struct gdbarch *, int, struct dwarf2_frame_state_reg *);
+  void (*init_reg) (struct gdbarch *, int, struct dwarf2_frame_state_reg *,
+                   struct frame_info *);
 
   /* Check whether the frame preceding NEXT_FRAME will be a signal
      trampoline.  */
   int (*signal_frame_p) (struct gdbarch *, struct frame_info *);
+
+  /* Convert .eh_frame register number to DWARF register number.  */
+  int (*eh_frame_regnum) (struct gdbarch *, int);
 };
 
 /* Default architecture-specific register state initialization
@@ -508,7 +626,8 @@ struct dwarf2_frame_ops
 
 static void
 dwarf2_frame_default_init_reg (struct gdbarch *gdbarch, int regnum,
-                              struct dwarf2_frame_state_reg *reg)
+                              struct dwarf2_frame_state_reg *reg,
+                              struct frame_info *next_frame)
 {
   /* If we have a register that acts as a program counter, mark it as
      a destination for the return address.  If we have a register that
@@ -560,7 +679,8 @@ dwarf2_frame_init (struct obstack *obstack)
 void
 dwarf2_frame_set_init_reg (struct gdbarch *gdbarch,
                           void (*init_reg) (struct gdbarch *, int,
-                                            struct dwarf2_frame_state_reg *))
+                                            struct dwarf2_frame_state_reg *,
+                                            struct frame_info *))
 {
   struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
 
@@ -571,11 +691,12 @@ dwarf2_frame_set_init_reg (struct gdbarch *gdbarch,
 
 static void
 dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
-                      struct dwarf2_frame_state_reg *reg)
+                      struct dwarf2_frame_state_reg *reg,
+                      struct frame_info *next_frame)
 {
   struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
 
-  ops->init_reg (gdbarch, regnum, reg);
+  ops->init_reg (gdbarch, regnum, reg, next_frame);
 }
 
 /* Set the architecture-specific signal trampoline recognition
@@ -604,6 +725,74 @@ dwarf2_frame_signal_frame_p (struct gdbarch *gdbarch,
     return 0;
   return ops->signal_frame_p (gdbarch, next_frame);
 }
+
+/* Set the architecture-specific mapping of .eh_frame register numbers to
+   DWARF register numbers.  */
+
+void
+dwarf2_frame_set_eh_frame_regnum (struct gdbarch *gdbarch,
+                                 int (*eh_frame_regnum) (struct gdbarch *,
+                                                         int))
+{
+  struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
+
+  ops->eh_frame_regnum = eh_frame_regnum;
+}
+
+/* Translate a .eh_frame register to DWARF register.  */
+
+int
+dwarf2_frame_eh_frame_regnum (struct gdbarch *gdbarch, int regnum)
+{
+  struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
+
+  if (ops->eh_frame_regnum == NULL)
+    return regnum;
+  return ops->eh_frame_regnum (gdbarch, regnum);
+}
+
+static void
+dwarf2_frame_find_quirks (struct dwarf2_frame_state *fs,
+                         struct dwarf2_fde *fde)
+{
+  static const char *arm_idents[] = {
+    "ARM C Compiler, ADS",
+    "Thumb C Compiler, ADS",
+    "ARM C++ Compiler, ADS",
+    "Thumb C++ Compiler, ADS",
+    "ARM/Thumb C/C++ Compiler, RVCT"
+  };
+  int i;
+
+  struct symtab *s;
+
+  s = find_pc_symtab (fs->pc);
+  if (s == NULL || s->producer == NULL)
+    return;
+
+  for (i = 0; i < ARRAY_SIZE (arm_idents); i++)
+    if (strncmp (s->producer, arm_idents[i], strlen (arm_idents[i])) == 0)
+      {
+       if (fde->cie->version == 1)
+         fs->armcc_cfa_offsets_sf = 1;
+
+       if (fde->cie->version == 1)
+         fs->armcc_cfa_offsets_reversed = 1;
+
+       /* The reversed offset problem is present in some compilers
+          using DWARF3, but it was eventually fixed.  Check the ARM
+          defined augmentations, which are in the format "armcc" followed
+          by a list of one-character options.  The "+" option means
+          this problem is fixed (no quirk needed).  If the armcc
+          augmentation is missing, the quirk is needed.  */
+       if (fde->cie->version == 3
+           && (strncmp (fde->cie->augmentation, "armcc", 5) != 0
+               || strchr (fde->cie->augmentation + 5, '+') == NULL))
+         fs->armcc_cfa_offsets_reversed = 1;
+
+       return;
+      }
+}
 \f
 
 struct dwarf2_frame_cache
@@ -659,7 +848,7 @@ dwarf2_frame_cache (struct frame_info *next_frame, void **this_cache)
      frame_unwind_address_in_block does just this.  It's not clear how
      reliable the method is though; there is the potential for the
      register state pre-call being different to that on return.  */
-  fs->pc = frame_unwind_address_in_block (next_frame);
+  fs->pc = frame_unwind_address_in_block (next_frame, NORMAL_FRAME);
 
   /* Find the correct FDE.  */
   fde = dwarf2_frame_find_fde (&fs->pc);
@@ -670,23 +859,30 @@ dwarf2_frame_cache (struct frame_info *next_frame, void **this_cache)
   fs->code_align = fde->cie->code_alignment_factor;
   fs->retaddr_column = fde->cie->return_address_register;
 
+  /* Check for "quirks" - known bugs in producers.  */
+  dwarf2_frame_find_quirks (fs, fde);
+
   /* First decode all the insns in the CIE.  */
   execute_cfa_program (fde->cie->initial_instructions,
-                      fde->cie->end, next_frame, fs);
+                      fde->cie->end, next_frame, fs, fde->eh_frame_p);
 
   /* Save the initialized register set.  */
   fs->initial = fs->regs;
   fs->initial.reg = dwarf2_frame_state_copy_regs (&fs->regs);
 
   /* Then decode the insns in the FDE up to our target PC.  */
-  execute_cfa_program (fde->instructions, fde->end, next_frame, fs);
+  execute_cfa_program (fde->instructions, fde->end, next_frame, fs,
+                      fde->eh_frame_p);
 
   /* Caclulate the CFA.  */
   switch (fs->cfa_how)
     {
     case CFA_REG_OFFSET:
       cache->cfa = read_reg (next_frame, fs->cfa_reg);
-      cache->cfa += fs->cfa_offset;
+      if (fs->armcc_cfa_offsets_reversed)
+       cache->cfa -= fs->cfa_offset;
+      else
+       cache->cfa += fs->cfa_offset;
       break;
 
     case CFA_EXP:
@@ -703,7 +899,7 @@ dwarf2_frame_cache (struct frame_info *next_frame, void **this_cache)
     int regnum;
 
     for (regnum = 0; regnum < num_regs; regnum++)
-      dwarf2_frame_init_reg (gdbarch, regnum, &cache->reg[regnum]);
+      dwarf2_frame_init_reg (gdbarch, regnum, &cache->reg[regnum], next_frame);
   }
 
   /* Go through the DWARF2 CFI generated table and save its register
@@ -815,7 +1011,22 @@ dwarf2_frame_this_id (struct frame_info *next_frame, void **this_cache,
   if (cache->undefined_retaddr)
     return;
 
-  (*this_id) = frame_id_build (cache->cfa, frame_func_unwind (next_frame));
+  (*this_id) = frame_id_build (cache->cfa,
+                              frame_func_unwind (next_frame, NORMAL_FRAME));
+}
+
+static void
+dwarf2_signal_frame_this_id (struct frame_info *next_frame, void **this_cache,
+                            struct frame_id *this_id)
+{
+  struct dwarf2_frame_cache *cache =
+    dwarf2_frame_cache (next_frame, this_cache);
+
+  if (cache->undefined_retaddr)
+    return;
+
+  (*this_id) = frame_id_build (cache->cfa,
+                              frame_func_unwind (next_frame, SIGTRAMP_FRAME));
 }
 
 static void
@@ -881,6 +1092,28 @@ dwarf2_frame_prev_register (struct frame_info *next_frame, void **this_cache,
        }
       break;
 
+    case DWARF2_FRAME_REG_SAVED_VAL_OFFSET:
+      *optimizedp = 0;
+      *lvalp = not_lval;
+      *addrp = 0;
+      *realnump = -1;
+      if (valuep)
+       store_unsigned_integer (valuep, register_size (gdbarch, regnum),
+                               cache->cfa + cache->reg[regnum].loc.offset);
+      break;
+
+    case DWARF2_FRAME_REG_SAVED_VAL_EXP:
+      *optimizedp = 0;
+      *lvalp = not_lval;
+      *addrp = 0;
+      *realnump = -1;
+      if (valuep)
+       store_unsigned_integer (valuep, register_size (gdbarch, regnum),
+                               execute_stack_op (cache->reg[regnum].loc.exp,
+                                                 cache->reg[regnum].exp_len,
+                                                 next_frame, cache->cfa));
+      break;
+
     case DWARF2_FRAME_REG_UNSPECIFIED:
       /* GCC, in its infinite wisdom decided to not provide unwind
         information for registers that are "same value".  Since
@@ -918,6 +1151,19 @@ dwarf2_frame_prev_register (struct frame_info *next_frame, void **this_cache,
        }
       break;
 
+    case DWARF2_FRAME_REG_CFA_OFFSET:
+      *optimizedp = 0;
+      *lvalp = not_lval;
+      *addrp = 0;
+      *realnump = -1;
+      if (valuep)
+       {
+         /* Store the value.  */
+         store_typed_address (valuep, builtin_type_void_data_ptr,
+                              cache->cfa + cache->reg[regnum].loc.offset);
+       }
+      break;
+
     case DWARF2_FRAME_REG_RA_OFFSET:
       *optimizedp = 0;
       *lvalp = not_lval;
@@ -948,7 +1194,7 @@ static const struct frame_unwind dwarf2_frame_unwind =
 static const struct frame_unwind dwarf2_signal_frame_unwind =
 {
   SIGTRAMP_FRAME,
-  dwarf2_frame_this_id,
+  dwarf2_signal_frame_this_id,
   dwarf2_frame_prev_register
 };
 
@@ -957,17 +1203,23 @@ dwarf2_frame_sniffer (struct frame_info *next_frame)
 {
   /* Grab an address that is guarenteed to reside somewhere within the
      function.  frame_pc_unwind(), for a no-return next function, can
-     end up returning something past the end of this function's body.  */
-  CORE_ADDR block_addr = frame_unwind_address_in_block (next_frame);
-  if (!dwarf2_frame_find_fde (&block_addr))
+     end up returning something past the end of this function's body.
+     If the frame we're sniffing for is a signal frame whose start
+     address is placed on the stack by the OS, its FDE must
+     extend one byte before its start address or we will miss it.  */
+  CORE_ADDR block_addr = frame_unwind_address_in_block (next_frame,
+                                                       NORMAL_FRAME);
+  struct dwarf2_fde *fde = dwarf2_frame_find_fde (&block_addr);
+  if (!fde)
     return NULL;
 
   /* On some targets, signal trampolines may have unwind information.
      We need to recognize them so that we set the frame type
      correctly.  */
 
-  if (dwarf2_frame_signal_frame_p (get_frame_arch (next_frame),
-                                  next_frame))
+  if (fde->cie->signal_frame
+      || dwarf2_frame_signal_frame_p (get_frame_arch (next_frame),
+                                     next_frame))
     return &dwarf2_signal_frame_unwind;
 
   return &dwarf2_frame_unwind;
@@ -1000,8 +1252,9 @@ static const struct frame_base dwarf2_frame_base =
 const struct frame_base *
 dwarf2_frame_base_sniffer (struct frame_info *next_frame)
 {
-  CORE_ADDR pc = frame_pc_unwind (next_frame);
-  if (dwarf2_frame_find_fde (&pc))
+  CORE_ADDR block_addr = frame_unwind_address_in_block (next_frame,
+                                                       NORMAL_FRAME);
+  if (dwarf2_frame_find_fde (&block_addr))
     return &dwarf2_frame_base;
 
   return NULL;
@@ -1105,8 +1358,8 @@ read_signed_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
     }
   while (byte & 0x80);
 
-  if ((shift < 32) && (byte & 0x40))
-    result |= -(1 << shift);
+  if (shift < 8 * sizeof (result) && (byte & 0x40))
+    result |= -(((LONGEST)1) << shift);
 
   *bytes_read_ptr = num_read;
 
@@ -1427,16 +1680,26 @@ decode_frame_entry_1 (struct comp_unit *unit, gdb_byte *start, int eh_frame_p)
          depends on the target address size.  */
       cie->encoding = DW_EH_PE_absptr;
 
+      /* We'll determine the final value later, but we need to
+        initialize it conservatively.  */
+      cie->signal_frame = 0;
+
       /* Check version number.  */
       cie_version = read_1_byte (unit->abfd, buf);
       if (cie_version != 1 && cie_version != 3)
        return NULL;
+      cie->version = cie_version;
       buf += 1;
 
       /* Interpret the interesting bits of the augmentation.  */
-      augmentation = (char *) buf;
+      cie->augmentation = augmentation = (char *) buf;
       buf += (strlen (augmentation) + 1);
 
+      /* Ignore armcc augmentations.  We only use them for quirks,
+        and that doesn't happen until later.  */
+      if (strncmp (augmentation, "armcc", 5) == 0)
+       augmentation += strlen (augmentation);
+
       /* The GCC 2.x "eh" augmentation has a pointer immediately
          following the augmentation string, so it must be handled
          first.  */
@@ -1463,6 +1726,11 @@ decode_frame_entry_1 (struct comp_unit *unit, gdb_byte *start, int eh_frame_p)
       else
        cie->return_address_register = read_unsigned_leb128 (unit->abfd, buf,
                                                             &bytes_read);
+      if (eh_frame_p)
+       cie->return_address_register
+         = dwarf2_frame_eh_frame_regnum (current_gdbarch,
+                                         cie->return_address_register);
+
       buf += bytes_read;
 
       cie->saw_z_augmentation = (*augmentation == 'z');
@@ -1505,15 +1773,23 @@ decode_frame_entry_1 (struct comp_unit *unit, gdb_byte *start, int eh_frame_p)
              augmentation++;
            }
 
-         /* Otherwise we have an unknown augmentation.
-            Bail out unless we saw a 'z' prefix.  */
-         else
+         /* "S" indicates a signal frame, such that the return
+            address must not be decremented to locate the call frame
+            info for the previous frame; it might even be the first
+            instruction of a function, so decrementing it would take
+            us to a different function.  */
+         else if (*augmentation == 'S')
            {
-             if (cie->initial_instructions == NULL)
-               return end;
+             cie->signal_frame = 1;
+             augmentation++;
+           }
 
-             /* Skip unknown augmentations.  */
-             buf = cie->initial_instructions;
+         /* Otherwise we have an unknown augmentation.  Assume that either
+            there is no augmentation data, or we saw a 'z' prefix.  */
+         else
+           {
+             if (cie->initial_instructions)
+               buf = cie->initial_instructions;
              break;
            }
        }
@@ -1580,6 +1856,8 @@ decode_frame_entry_1 (struct comp_unit *unit, gdb_byte *start, int eh_frame_p)
       fde->instructions = buf;
       fde->end = end;
 
+      fde->eh_frame_p = eh_frame_p;
+
       add_fde (unit, fde);
     }
 
@@ -1687,7 +1965,7 @@ extern asection *dwarf_frame_section;
 extern asection *dwarf_eh_frame_section;
 
 /* Imported from dwarf2read.c.  */
-extern char *dwarf2_read_section (struct objfile *objfile, asection *sectp);
+extern gdb_byte *dwarf2_read_section (struct objfile *objfile, asection *sectp);
 
 void
 dwarf2_build_frame_info (struct objfile *objfile)
This page took 0.046083 seconds and 4 git commands to generate.