← Back to branch summary

~ubuntu-branches/ubuntu/karmic/insight/karmic

« back to all changes in this revision

Viewing changes to gdb/dwarf2-frame.c

  • Committer: Bazaar Package Importer
  • Author(s): Masayuki Hatta (mhatta)
  • Date: 2007-12-04 22:37:09 UTC
  • mfrom: (1.2.5 upstream)
  • Revision ID: james.westby@ubuntu.com-20071204223709-jxj396d1ox92s8ox
Tags: 6.7.1.dfsg.1-1
http://bugs.debian.org/314037
* New upstream release.
* This typo has been fixed in the upstream - closes: #314037.
* Removed non-free documents (GFDL'd with Invariant Sections, etc.).

Show diffs side-by-side

added added

removed removed

Lines of Context:
gdb/dwarf2-frame.c
1
1
/* Frame unwinder for frames with DWARF Call Frame Information.
2
2
 
3
 
   Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
 
3
   Copyright (C) 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
4
4
 
5
5
   Contributed by Mark Kettenis.
6
6
 
8
8
 
9
9
   This program is free software; you can redistribute it and/or modify
10
10
   it under the terms of the GNU General Public License as published by
11
 
   the Free Software Foundation; either version 2 of the License, or
 
11
   the Free Software Foundation; either version 3 of the License, or
12
12
   (at your option) any later version.
13
13
 
14
14
   This program is distributed in the hope that it will be useful,
17
17
   GNU General Public License for more details.
18
18
 
19
19
   You should have received a copy of the GNU General Public License
20
 
   along with this program; if not, write to the Free Software
21
 
   Foundation, Inc., 51 Franklin Street, Fifth Floor,
22
 
   Boston, MA 02110-1301, USA.  */
 
20
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
23
21
 
24
22
#include "defs.h"
25
23
#include "dwarf2expr.h"
64
62
  gdb_byte *initial_instructions;
65
63
  gdb_byte *end;
66
64
 
 
65
  /* Saved augmentation, in case it's needed later.  */
 
66
  char *augmentation;
 
67
 
67
68
  /* Encoding of addresses.  */
68
69
  gdb_byte encoding;
69
70
 
73
74
  /* True if an 'S' augmentation existed.  */
74
75
  unsigned char signal_frame;
75
76
 
 
77
  /* The version recorded in the CIE.  */
 
78
  unsigned char version;
 
79
 
76
80
  struct dwarf2_cie *next;
77
81
};
78
82
 
101
105
};
102
106
 
103
107
static struct dwarf2_fde *dwarf2_frame_find_fde (CORE_ADDR *pc);
 
108
 
 
109
static int dwarf2_frame_adjust_regnum (struct gdbarch *gdbarch, int regnum,
 
110
                                       int eh_frame_p);
104
111
 
105
112
 
106
113
/* Structure describing a frame state.  */
138
145
  LONGEST data_align;
139
146
  ULONGEST code_align;
140
147
  ULONGEST retaddr_column;
 
148
 
 
149
  /* Flags for known producer quirks.  */
 
150
 
 
151
  /* The ARM compilers, in DWARF2 mode, assume that DW_CFA_def_cfa
 
152
     and DW_CFA_def_cfa_offset takes a factored offset.  */
 
153
  int armcc_cfa_offsets_sf;
 
154
 
 
155
  /* The ARM compilers, in DWARF2 or DWARF3 mode, may assume that
 
156
     the CFA is defined as REG - OFFSET rather than REG + OFFSET.  */
 
157
  int armcc_cfa_offsets_reversed;
141
158
};
142
159
 
143
160
/* Store the length the expression for the CFA in the `cfa_reg' field,
144
161
   which is unused in that case.  */
145
162
#define cfa_exp_len cfa_reg
146
163
 
147
 
/* Assert that the register set RS is large enough to store NUM_REGS
 
164
/* Assert that the register set RS is large enough to store gdbarch_num_regs
148
165
   columns.  If necessary, enlarge the register set.  */
149
166
 
150
167
static void
218
235
  int regnum;
219
236
  gdb_byte *buf;
220
237
 
221
 
  regnum = DWARF2_REG_TO_REGNUM (reg);
 
238
  regnum = gdbarch_dwarf2_reg_to_regnum (current_gdbarch, reg);
222
239
 
223
240
  buf = alloca (register_size (gdbarch, regnum));
224
241
  frame_unwind_register (next_frame, regnum, buf);
298
315
      else if ((insn & 0xc0) == DW_CFA_offset)
299
316
        {
300
317
          reg = insn & 0x3f;
301
 
          if (eh_frame_p)
302
 
            reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
 
318
          reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
303
319
          insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
304
320
          offset = utmp * fs->data_align;
305
321
          dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
310
326
        {
311
327
          gdb_assert (fs->initial.reg);
312
328
          reg = insn & 0x3f;
313
 
          if (eh_frame_p)
314
 
            reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
 
329
          reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
315
330
          dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
316
331
          if (reg < fs->initial.num_regs)
317
332
            fs->regs.reg[reg] = fs->initial.reg[reg];
322
337
            complaint (&symfile_complaints, _("\
323
338
incomplete CFI data; DW_CFA_restore unspecified\n\
324
339
register %s (#%d) at 0x%s"),
325
 
                       REGISTER_NAME(DWARF2_REG_TO_REGNUM(reg)),
326
 
                       DWARF2_REG_TO_REGNUM(reg), paddr (fs->pc));
 
340
                       gdbarch_register_name
 
341
                         (current_gdbarch, gdbarch_dwarf2_reg_to_regnum
 
342
                                             (current_gdbarch, reg)),
 
343
                       gdbarch_dwarf2_reg_to_regnum (current_gdbarch, reg),
 
344
                       paddr (fs->pc));
327
345
        }
328
346
      else
329
347
        {
352
370
 
353
371
            case DW_CFA_offset_extended:
354
372
              insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
355
 
              if (eh_frame_p)
356
 
                reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
 
373
              reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
357
374
              insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
358
375
              offset = utmp * fs->data_align;
359
376
              dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
364
381
            case DW_CFA_restore_extended:
365
382
              gdb_assert (fs->initial.reg);
366
383
              insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
367
 
              if (eh_frame_p)
368
 
                reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
 
384
              reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
369
385
              dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
370
386
              fs->regs.reg[reg] = fs->initial.reg[reg];
371
387
              break;
372
388
 
373
389
            case DW_CFA_undefined:
374
390
              insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
375
 
              if (eh_frame_p)
376
 
                reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
 
391
              reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
377
392
              dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
378
393
              fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNDEFINED;
379
394
              break;
380
395
 
381
396
            case DW_CFA_same_value:
382
397
              insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
383
 
              if (eh_frame_p)
384
 
                reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
 
398
              reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
385
399
              dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
386
400
              fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAME_VALUE;
387
401
              break;
388
402
 
389
403
            case DW_CFA_register:
390
404
              insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
391
 
              if (eh_frame_p)
392
 
                reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
 
405
              reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
393
406
              insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
394
 
              if (eh_frame_p)
395
 
                utmp = dwarf2_frame_eh_frame_regnum (gdbarch, utmp);
 
407
              utmp = dwarf2_frame_adjust_regnum (gdbarch, utmp, eh_frame_p);
396
408
              dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
397
409
              fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
398
410
              fs->regs.reg[reg].loc.reg = utmp;
430
442
            case DW_CFA_def_cfa:
431
443
              insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_reg);
432
444
              insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
 
445
 
 
446
              if (fs->armcc_cfa_offsets_sf)
 
447
                utmp *= fs->data_align;
 
448
 
433
449
              fs->cfa_offset = utmp;
434
450
              fs->cfa_how = CFA_REG_OFFSET;
435
451
              break;
436
452
 
437
453
            case DW_CFA_def_cfa_register:
438
454
              insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_reg);
439
 
              if (eh_frame_p)
440
 
                fs->cfa_reg = dwarf2_frame_eh_frame_regnum (gdbarch,
441
 
                                                            fs->cfa_reg);
 
455
              fs->cfa_reg = dwarf2_frame_adjust_regnum (gdbarch, fs->cfa_reg,
 
456
                                                        eh_frame_p);
442
457
              fs->cfa_how = CFA_REG_OFFSET;
443
458
              break;
444
459
 
445
460
            case DW_CFA_def_cfa_offset:
446
461
              insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
 
462
 
 
463
              if (fs->armcc_cfa_offsets_sf)
 
464
                utmp *= fs->data_align;
 
465
 
447
466
              fs->cfa_offset = utmp;
448
467
              /* cfa_how deliberately not set.  */
449
468
              break;
460
479
 
461
480
            case DW_CFA_expression:
462
481
              insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
463
 
              if (eh_frame_p)
464
 
                reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
 
482
              reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
465
483
              dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
466
484
              insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
467
485
              fs->regs.reg[reg].loc.exp = insn_ptr;
472
490
 
473
491
            case DW_CFA_offset_extended_sf:
474
492
              insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
475
 
              if (eh_frame_p)
476
 
                reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
 
493
              reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
477
494
              insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
478
495
              offset *= fs->data_align;
479
496
              dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
511
528
 
512
529
            case DW_CFA_def_cfa_sf:
513
530
              insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_reg);
514
 
              if (eh_frame_p)
515
 
                fs->cfa_reg = dwarf2_frame_eh_frame_regnum (gdbarch,
516
 
                                                            fs->cfa_reg);
 
531
              fs->cfa_reg = dwarf2_frame_adjust_regnum (gdbarch, fs->cfa_reg,
 
532
                                                        eh_frame_p);
517
533
              insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
518
534
              fs->cfa_offset = offset * fs->data_align;
519
535
              fs->cfa_how = CFA_REG_OFFSET;
555
571
              insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
556
572
              break;
557
573
 
 
574
            case DW_CFA_GNU_negative_offset_extended:
 
575
              insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
 
576
              reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
 
577
              insn_ptr = read_uleb128 (insn_ptr, insn_end, &offset);
 
578
              offset *= fs->data_align;
 
579
              dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 
580
              fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
 
581
              fs->regs.reg[reg].loc.offset = -offset;
 
582
              break;
 
583
 
558
584
            default:
559
585
              internal_error (__FILE__, __LINE__, _("Unknown CFI encountered."));
560
586
            }
582
608
     trampoline.  */
583
609
  int (*signal_frame_p) (struct gdbarch *, struct frame_info *);
584
610
 
585
 
  /* Convert .eh_frame register number to DWARF register number.  */
586
 
  int (*eh_frame_regnum) (struct gdbarch *, int);
 
611
  /* Convert .eh_frame register number to DWARF register number, or
 
612
     adjust .debug_frame register number.  */
 
613
  int (*adjust_regnum) (struct gdbarch *, int, int);
587
614
};
588
615
 
589
616
/* Default architecture-specific register state initialization
620
647
     (e.g. IBM S/390 and zSeries).  Those architectures should provide
621
648
     their own architecture-specific initialization function.  */
622
649
 
623
 
  if (regnum == PC_REGNUM)
 
650
  if (regnum == gdbarch_pc_regnum (current_gdbarch))
624
651
    reg->how = DWARF2_FRAME_REG_RA;
625
 
  else if (regnum == SP_REGNUM)
 
652
  else if (regnum == gdbarch_sp_regnum (current_gdbarch))
626
653
    reg->how = DWARF2_FRAME_REG_CFA;
627
654
}
628
655
 
691
718
  return ops->signal_frame_p (gdbarch, next_frame);
692
719
}
693
720
 
694
 
/* Set the architecture-specific mapping of .eh_frame register numbers to
695
 
   DWARF register numbers.  */
 
721
/* Set the architecture-specific adjustment of .eh_frame and .debug_frame
 
722
   register numbers.  */
696
723
 
697
724
void
698
 
dwarf2_frame_set_eh_frame_regnum (struct gdbarch *gdbarch,
699
 
                                  int (*eh_frame_regnum) (struct gdbarch *,
700
 
                                                          int))
 
725
dwarf2_frame_set_adjust_regnum (struct gdbarch *gdbarch,
 
726
                                int (*adjust_regnum) (struct gdbarch *,
 
727
                                                      int, int))
701
728
{
702
729
  struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
703
730
 
704
 
  ops->eh_frame_regnum = eh_frame_regnum;
 
731
  ops->adjust_regnum = adjust_regnum;
705
732
}
706
733
 
707
 
/* Translate a .eh_frame register to DWARF register.  */
 
734
/* Translate a .eh_frame register to DWARF register, or adjust a .debug_frame
 
735
   register.  */
708
736
 
709
 
int
710
 
dwarf2_frame_eh_frame_regnum (struct gdbarch *gdbarch, int regnum)
 
737
static int
 
738
dwarf2_frame_adjust_regnum (struct gdbarch *gdbarch, int regnum, int eh_frame_p)
711
739
{
712
740
  struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
713
741
 
714
 
  if (ops->eh_frame_regnum == NULL)
 
742
  if (ops->adjust_regnum == NULL)
715
743
    return regnum;
716
 
  return ops->eh_frame_regnum (gdbarch, regnum);
 
744
  return ops->adjust_regnum (gdbarch, regnum, eh_frame_p);
 
745
}
 
746
 
 
747
static void
 
748
dwarf2_frame_find_quirks (struct dwarf2_frame_state *fs,
 
749
                          struct dwarf2_fde *fde)
 
750
{
 
751
  static const char *arm_idents[] = {
 
752
    "ARM C Compiler, ADS",
 
753
    "Thumb C Compiler, ADS",
 
754
    "ARM C++ Compiler, ADS",
 
755
    "Thumb C++ Compiler, ADS",
 
756
    "ARM/Thumb C/C++ Compiler, RVCT"
 
757
  };
 
758
  int i;
 
759
 
 
760
  struct symtab *s;
 
761
 
 
762
  s = find_pc_symtab (fs->pc);
 
763
  if (s == NULL || s->producer == NULL)
 
764
    return;
 
765
 
 
766
  for (i = 0; i < ARRAY_SIZE (arm_idents); i++)
 
767
    if (strncmp (s->producer, arm_idents[i], strlen (arm_idents[i])) == 0)
 
768
      {
 
769
        if (fde->cie->version == 1)
 
770
          fs->armcc_cfa_offsets_sf = 1;
 
771
 
 
772
        if (fde->cie->version == 1)
 
773
          fs->armcc_cfa_offsets_reversed = 1;
 
774
 
 
775
        /* The reversed offset problem is present in some compilers
 
776
           using DWARF3, but it was eventually fixed.  Check the ARM
 
777
           defined augmentations, which are in the format "armcc" followed
 
778
           by a list of one-character options.  The "+" option means
 
779
           this problem is fixed (no quirk needed).  If the armcc
 
780
           augmentation is missing, the quirk is needed.  */
 
781
        if (fde->cie->version == 3
 
782
            && (strncmp (fde->cie->augmentation, "armcc", 5) != 0
 
783
                || strchr (fde->cie->augmentation + 5, '+') == NULL))
 
784
          fs->armcc_cfa_offsets_reversed = 1;
 
785
 
 
786
        return;
 
787
      }
717
788
}
718
789
 
719
790
 
738
809
{
739
810
  struct cleanup *old_chain;
740
811
  struct gdbarch *gdbarch = get_frame_arch (next_frame);
741
 
  const int num_regs = NUM_REGS + NUM_PSEUDO_REGS;
 
812
  const int num_regs = gdbarch_num_regs (current_gdbarch)
 
813
                       + gdbarch_num_pseudo_regs (current_gdbarch);
742
814
  struct dwarf2_frame_cache *cache;
743
815
  struct dwarf2_frame_state *fs;
744
816
  struct dwarf2_fde *fde;
770
842
     frame_unwind_address_in_block does just this.  It's not clear how
771
843
     reliable the method is though; there is the potential for the
772
844
     register state pre-call being different to that on return.  */
773
 
  fs->pc = frame_unwind_address_in_block (next_frame);
 
845
  fs->pc = frame_unwind_address_in_block (next_frame, NORMAL_FRAME);
774
846
 
775
847
  /* Find the correct FDE.  */
776
848
  fde = dwarf2_frame_find_fde (&fs->pc);
781
853
  fs->code_align = fde->cie->code_alignment_factor;
782
854
  fs->retaddr_column = fde->cie->return_address_register;
783
855
 
 
856
  /* Check for "quirks" - known bugs in producers.  */
 
857
  dwarf2_frame_find_quirks (fs, fde);
 
858
 
784
859
  /* First decode all the insns in the CIE.  */
785
860
  execute_cfa_program (fde->cie->initial_instructions,
786
861
                       fde->cie->end, next_frame, fs, fde->eh_frame_p);
798
873
    {
799
874
    case CFA_REG_OFFSET:
800
875
      cache->cfa = read_reg (next_frame, fs->cfa_reg);
801
 
      cache->cfa += fs->cfa_offset;
 
876
      if (fs->armcc_cfa_offsets_reversed)
 
877
        cache->cfa -= fs->cfa_offset;
 
878
      else
 
879
        cache->cfa += fs->cfa_offset;
802
880
      break;
803
881
 
804
882
    case CFA_EXP:
823
901
     return address column; it's perfectly all right for it to
824
902
     correspond to a real register.  If it doesn't correspond to a
825
903
     real register, or if we shouldn't treat it as such,
826
 
     DWARF2_REG_TO_REGNUM should be defined to return a number outside
827
 
     the range [0, NUM_REGS).  */
 
904
     gdbarch_dwarf2_reg_to_regnum should be defined to return a number outside
 
905
     the range [0, gdbarch_num_regs).  */
828
906
  {
829
907
    int column;         /* CFI speak for "register number".  */
830
908
 
831
909
    for (column = 0; column < fs->regs.num_regs; column++)
832
910
      {
833
911
        /* Use the GDB register number as the destination index.  */
834
 
        int regnum = DWARF2_REG_TO_REGNUM (column);
 
912
        int regnum = gdbarch_dwarf2_reg_to_regnum (current_gdbarch, column);
835
913
 
836
914
        /* If there's no corresponding GDB register, ignore it.  */
837
915
        if (regnum < 0 || regnum >= num_regs)
927
1005
  if (cache->undefined_retaddr)
928
1006
    return;
929
1007
 
930
 
  (*this_id) = frame_id_build (cache->cfa, frame_func_unwind (next_frame));
 
1008
  (*this_id) = frame_id_build (cache->cfa,
 
1009
                               frame_func_unwind (next_frame, NORMAL_FRAME));
 
1010
}
 
1011
 
 
1012
static void
 
1013
dwarf2_signal_frame_this_id (struct frame_info *next_frame, void **this_cache,
 
1014
                             struct frame_id *this_id)
 
1015
{
 
1016
  struct dwarf2_frame_cache *cache =
 
1017
    dwarf2_frame_cache (next_frame, this_cache);
 
1018
 
 
1019
  if (cache->undefined_retaddr)
 
1020
    return;
 
1021
 
 
1022
  (*this_id) = frame_id_build (cache->cfa,
 
1023
                               frame_func_unwind (next_frame, SIGTRAMP_FRAME));
931
1024
}
932
1025
 
933
1026
static void
974
1067
      *optimizedp = 0;
975
1068
      *lvalp = lval_register;
976
1069
      *addrp = 0;
977
 
      *realnump = DWARF2_REG_TO_REGNUM (cache->reg[regnum].loc.reg);
 
1070
      *realnump = gdbarch_dwarf2_reg_to_regnum
 
1071
                    (current_gdbarch, cache->reg[regnum].loc.reg);
978
1072
      if (valuep)
979
1073
        frame_unwind_register (next_frame, (*realnump), valuep);
980
1074
      break;
1046
1140
      *addrp = 0;
1047
1141
      *realnump = -1;
1048
1142
      if (valuep)
1049
 
        {
1050
 
          /* Store the value.  */
1051
 
          store_typed_address (valuep, builtin_type_void_data_ptr, cache->cfa);
1052
 
        }
 
1143
        pack_long (valuep, register_type (gdbarch, regnum), cache->cfa);
1053
1144
      break;
1054
1145
 
1055
1146
    case DWARF2_FRAME_REG_CFA_OFFSET:
1058
1149
      *addrp = 0;
1059
1150
      *realnump = -1;
1060
1151
      if (valuep)
1061
 
        {
1062
 
          /* Store the value.  */
1063
 
          store_typed_address (valuep, builtin_type_void_data_ptr,
1064
 
                               cache->cfa + cache->reg[regnum].loc.offset);
1065
 
        }
 
1152
        pack_long (valuep, register_type (gdbarch, regnum),
 
1153
                   cache->cfa + cache->reg[regnum].loc.offset);
1066
1154
      break;
1067
1155
 
1068
1156
    case DWARF2_FRAME_REG_RA_OFFSET:
1074
1162
        {
1075
1163
          CORE_ADDR pc = cache->reg[regnum].loc.offset;
1076
1164
 
1077
 
          regnum = DWARF2_REG_TO_REGNUM (cache->retaddr_reg.loc.reg);
 
1165
          regnum = gdbarch_dwarf2_reg_to_regnum
 
1166
                     (current_gdbarch, cache->retaddr_reg.loc.reg);
1078
1167
          pc += frame_unwind_register_unsigned (next_frame, regnum);
1079
 
          store_typed_address (valuep, builtin_type_void_func_ptr, pc);
 
1168
          pack_long (valuep, register_type (gdbarch, regnum), pc);
1080
1169
        }
1081
1170
      break;
1082
1171
 
1095
1184
static const struct frame_unwind dwarf2_signal_frame_unwind =
1096
1185
{
1097
1186
  SIGTRAMP_FRAME,
1098
 
  dwarf2_frame_this_id,
 
1187
  dwarf2_signal_frame_this_id,
1099
1188
  dwarf2_frame_prev_register
1100
1189
};
1101
1190
 
1104
1193
{
1105
1194
  /* Grab an address that is guarenteed to reside somewhere within the
1106
1195
     function.  frame_pc_unwind(), for a no-return next function, can
1107
 
     end up returning something past the end of this function's body.  */
1108
 
  CORE_ADDR block_addr = frame_unwind_address_in_block (next_frame);
 
1196
     end up returning something past the end of this function's body.
 
1197
     If the frame we're sniffing for is a signal frame whose start
 
1198
     address is placed on the stack by the OS, its FDE must
 
1199
     extend one byte before its start address or we will miss it.  */
 
1200
  CORE_ADDR block_addr = frame_unwind_address_in_block (next_frame,
 
1201
                                                        NORMAL_FRAME);
1109
1202
  struct dwarf2_fde *fde = dwarf2_frame_find_fde (&block_addr);
1110
1203
  if (!fde)
1111
1204
    return NULL;
1149
1242
const struct frame_base *
1150
1243
dwarf2_frame_base_sniffer (struct frame_info *next_frame)
1151
1244
{
1152
 
  CORE_ADDR pc = frame_pc_unwind (next_frame);
1153
 
  if (dwarf2_frame_find_fde (&pc))
 
1245
  CORE_ADDR block_addr = frame_unwind_address_in_block (next_frame,
 
1246
                                                        NORMAL_FRAME);
 
1247
  if (dwarf2_frame_find_fde (&block_addr))
1154
1248
    return &dwarf2_frame_base;
1155
1249
 
1156
1250
  return NULL;
1355
1449
      base = 0;
1356
1450
      break;
1357
1451
    case DW_EH_PE_pcrel:
1358
 
      base = bfd_get_section_vma (unit->bfd, unit->dwarf_frame_section);
 
1452
      base = bfd_get_section_vma (unit->abfd, unit->dwarf_frame_section);
1359
1453
      base += (buf - unit->dwarf_frame_buffer);
1360
1454
      break;
1361
1455
    case DW_EH_PE_datarel:
1386
1480
    }
1387
1481
 
1388
1482
  if ((encoding & 0x07) == 0x00)
1389
 
    encoding |= encoding_for_size (ptr_len);
 
1483
    {
 
1484
      encoding |= encoding_for_size (ptr_len);
 
1485
      if (bfd_get_sign_extend_vma (unit->abfd))
 
1486
        encoding |= DW_EH_PE_signed;
 
1487
    }
1390
1488
 
1391
1489
  switch (encoding & 0x0f)
1392
1490
    {
1584
1682
      cie_version = read_1_byte (unit->abfd, buf);
1585
1683
      if (cie_version != 1 && cie_version != 3)
1586
1684
        return NULL;
 
1685
      cie->version = cie_version;
1587
1686
      buf += 1;
1588
1687
 
1589
1688
      /* Interpret the interesting bits of the augmentation.  */
1590
 
      augmentation = (char *) buf;
 
1689
      cie->augmentation = augmentation = (char *) buf;
1591
1690
      buf += (strlen (augmentation) + 1);
1592
1691
 
 
1692
      /* Ignore armcc augmentations.  We only use them for quirks,
 
1693
         and that doesn't happen until later.  */
 
1694
      if (strncmp (augmentation, "armcc", 5) == 0)
 
1695
        augmentation += strlen (augmentation);
 
1696
 
1593
1697
      /* The GCC 2.x "eh" augmentation has a pointer immediately
1594
1698
         following the augmentation string, so it must be handled
1595
1699
         first.  */
1616
1720
      else
1617
1721
        cie->return_address_register = read_unsigned_leb128 (unit->abfd, buf,
1618
1722
                                                             &bytes_read);
1619
 
      if (eh_frame_p)
1620
 
        cie->return_address_register
1621
 
          = dwarf2_frame_eh_frame_regnum (current_gdbarch,
1622
 
                                          cie->return_address_register);
 
1723
      cie->return_address_register
 
1724
        = dwarf2_frame_adjust_regnum (current_gdbarch,
 
1725
                                      cie->return_address_register,
 
1726
                                      eh_frame_p);
1623
1727
 
1624
1728
      buf += bytes_read;
1625
1729
 
1674
1778
              augmentation++;
1675
1779
            }
1676
1780
 
1677
 
          /* Otherwise we have an unknown augmentation.
1678
 
             Bail out unless we saw a 'z' prefix.  */
 
1781
          /* Otherwise we have an unknown augmentation.  Assume that either
 
1782
             there is no augmentation data, or we saw a 'z' prefix.  */
1679
1783
          else
1680
1784
            {
1681
 
              if (cie->initial_instructions == NULL)
1682
 
                return end;
1683
 
 
1684
 
              /* Skip unknown augmentations.  */
1685
 
              buf = cie->initial_instructions;
 
1785
              if (cie->initial_instructions)
 
1786
                buf = cie->initial_instructions;
1686
1787
              break;
1687
1788
            }
1688
1789
        }