gdb/dwarf2-frame.c

   1 /* Frame unwinder for frames with DWARF Call Frame Information.
   2
   3    Copyright (C) 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
   4
   5    Contributed by Mark Kettenis.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  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
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  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.  */
  23
  24 #include "defs.h"
  25 #include "dwarf2expr.h"
  26 #include "elf/dwarf2.h"
  27 #include "frame.h"
  28 #include "frame-base.h"
  29 #include "frame-unwind.h"
  30 #include "gdbcore.h"
  31 #include "gdbtypes.h"
  32 #include "symtab.h"
  33 #include "objfiles.h"
  34 #include "regcache.h"
  35 #include "value.h"
  36
  37 #include "gdb_assert.h"
  38 #include "gdb_string.h"
  39
  40 #include "complaints.h"
  41 #include "dwarf2-frame.h"
  42
  43 /* Call Frame Information (CFI).  */
  44
  45 /* Common Information Entry (CIE).  */
  46
  47 struct dwarf2_cie
  48 {
  49   /* Offset into the .debug_frame section where this CIE was found.
  50      Used to identify this CIE.  */
  51   ULONGEST cie_pointer;
  52
  53   /* Constant that is factored out of all advance location
  54      instructions.  */
  55   ULONGEST code_alignment_factor;
  56
  57   /* Constants that is factored out of all offset instructions.  */
  58   LONGEST data_alignment_factor;
  59
  60   /* Return address column.  */
  61   ULONGEST return_address_register;
  62
  63   /* Instruction sequence to initialize a register set.  */
  64   gdb_byte *initial_instructions;
  65   gdb_byte *end;
  66
  67   /* Saved augmentation, in case it's needed later.  */
  68   char *augmentation;
  69
  70   /* Encoding of addresses.  */
  71   gdb_byte encoding;
  72
  73   /* True if a 'z' augmentation existed.  */
  74   unsigned char saw_z_augmentation;
  75
  76   /* True if an 'S' augmentation existed.  */
  77   unsigned char signal_frame;
  78
  79   /* The version recorded in the CIE.  */
  80   unsigned char version;
  81
  82   struct dwarf2_cie *next;
  83 };
  84
  85 /* Frame Description Entry (FDE).  */
  86
  87 struct dwarf2_fde
  88 {
  89   /* CIE for this FDE.  */
  90   struct dwarf2_cie *cie;
  91
  92   /* First location associated with this FDE.  */
  93   CORE_ADDR initial_location;
  94
  95   /* Number of bytes of program instructions described by this FDE.  */
  96   CORE_ADDR address_range;
  97
  98   /* Instruction sequence.  */
  99   gdb_byte *instructions;
 100   gdb_byte *end;
 101
 102   /* True if this FDE is read from a .eh_frame instead of a .debug_frame
 103      section.  */
 104   unsigned char eh_frame_p;
 105
 106   struct dwarf2_fde *next;
 107 };
 108
 109 static struct dwarf2_fde *dwarf2_frame_find_fde (CORE_ADDR *pc);
 110 \f
 111
 112 /* Structure describing a frame state.  */
 113
 114 struct dwarf2_frame_state
 115 {
 116   /* Each register save state can be described in terms of a CFA slot,
 117      another register, or a location expression.  */
 118   struct dwarf2_frame_state_reg_info
 119   {
 120     struct dwarf2_frame_state_reg *reg;
 121     int num_regs;
 122
 123     /* Used to implement DW_CFA_remember_state.  */
 124     struct dwarf2_frame_state_reg_info *prev;
 125   } regs;
 126
 127   LONGEST cfa_offset;
 128   ULONGEST cfa_reg;
 129   gdb_byte *cfa_exp;
 130   enum {
 131     CFA_UNSET,
 132     CFA_REG_OFFSET,
 133     CFA_EXP
 134   } cfa_how;
 135
 136   /* The PC described by the current frame state.  */
 137   CORE_ADDR pc;
 138
 139   /* Initial register set from the CIE.
 140      Used to implement DW_CFA_restore.  */
 141   struct dwarf2_frame_state_reg_info initial;
 142
 143   /* The information we care about from the CIE.  */
 144   LONGEST data_align;
 145   ULONGEST code_align;
 146   ULONGEST retaddr_column;
 147
 148   /* Flags for known producer quirks.  */
 149
 150   /* The ARM compilers, in DWARF2 mode, assume that DW_CFA_def_cfa
 151      and DW_CFA_def_cfa_offset takes a factored offset.  */
 152   int armcc_cfa_offsets_sf;
 153
 154   /* The ARM compilers, in DWARF2 or DWARF3 mode, may assume that
 155      the CFA is defined as REG - OFFSET rather than REG + OFFSET.  */
 156   int armcc_cfa_offsets_reversed;
 157 };
 158
 159 /* Store the length the expression for the CFA in the `cfa_reg' field,
 160    which is unused in that case.  */
 161 #define cfa_exp_len cfa_reg
 162
 163 /* Assert that the register set RS is large enough to store NUM_REGS
 164    columns.  If necessary, enlarge the register set.  */
 165
 166 static void
 167 dwarf2_frame_state_alloc_regs (struct dwarf2_frame_state_reg_info *rs,
 168                                int num_regs)
 169 {
 170   size_t size = sizeof (struct dwarf2_frame_state_reg);
 171
 172   if (num_regs <= rs->num_regs)
 173     return;
 174
 175   rs->reg = (struct dwarf2_frame_state_reg *)
 176     xrealloc (rs->reg, num_regs * size);
 177
 178   /* Initialize newly allocated registers.  */
 179   memset (rs->reg + rs->num_regs, 0, (num_regs - rs->num_regs) * size);
 180   rs->num_regs = num_regs;
 181 }
 182
 183 /* Copy the register columns in register set RS into newly allocated
 184    memory and return a pointer to this newly created copy.  */
 185
 186 static struct dwarf2_frame_state_reg *
 187 dwarf2_frame_state_copy_regs (struct dwarf2_frame_state_reg_info *rs)
 188 {
 189   size_t size = rs->num_regs * sizeof (struct dwarf2_frame_state_reg);
 190   struct dwarf2_frame_state_reg *reg;
 191
 192   reg = (struct dwarf2_frame_state_reg *) xmalloc (size);
 193   memcpy (reg, rs->reg, size);
 194
 195   return reg;
 196 }
 197
 198 /* Release the memory allocated to register set RS.  */
 199
 200 static void
 201 dwarf2_frame_state_free_regs (struct dwarf2_frame_state_reg_info *rs)
 202 {
 203   if (rs)
 204     {
 205       dwarf2_frame_state_free_regs (rs->prev);
 206
 207       xfree (rs->reg);
 208       xfree (rs);
 209     }
 210 }
 211
 212 /* Release the memory allocated to the frame state FS.  */
 213
 214 static void
 215 dwarf2_frame_state_free (void *p)
 216 {
 217   struct dwarf2_frame_state *fs = p;
 218
 219   dwarf2_frame_state_free_regs (fs->initial.prev);
 220   dwarf2_frame_state_free_regs (fs->regs.prev);
 221   xfree (fs->initial.reg);
 222   xfree (fs->regs.reg);
 223   xfree (fs);
 224 }
 225 \f
 226
 227 /* Helper functions for execute_stack_op.  */
 228
 229 static CORE_ADDR
 230 read_reg (void *baton, int reg)
 231 {
 232   struct frame_info *next_frame = (struct frame_info *) baton;
 233   struct gdbarch *gdbarch = get_frame_arch (next_frame);
 234   int regnum;
 235   gdb_byte *buf;
 236
 237   regnum = DWARF2_REG_TO_REGNUM (reg);
 238
 239   buf = alloca (register_size (gdbarch, regnum));
 240   frame_unwind_register (next_frame, regnum, buf);
 241
 242   /* Convert the register to an integer.  This returns a LONGEST
 243      rather than a CORE_ADDR, but unpack_pointer does the same thing
 244      under the covers, and this makes more sense for non-pointer
 245      registers.  Maybe read_reg and the associated interfaces should
 246      deal with "struct value" instead of CORE_ADDR.  */
 247   return unpack_long (register_type (gdbarch, regnum), buf);
 248 }
 249
 250 static void
 251 read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
 252 {
 253   read_memory (addr, buf, len);
 254 }
 255
 256 static void
 257 no_get_frame_base (void *baton, gdb_byte **start, size_t *length)
 258 {
 259   internal_error (__FILE__, __LINE__,
 260                   _("Support for DW_OP_fbreg is unimplemented"));
 261 }
 262
 263 static CORE_ADDR
 264 no_get_tls_address (void *baton, CORE_ADDR offset)
 265 {
 266   internal_error (__FILE__, __LINE__,
 267                   _("Support for DW_OP_GNU_push_tls_address is unimplemented"));
 268 }
 269
 270 static CORE_ADDR
 271 execute_stack_op (gdb_byte *exp, ULONGEST len,
 272                   struct frame_info *next_frame, CORE_ADDR initial)
 273 {
 274   struct dwarf_expr_context *ctx;
 275   CORE_ADDR result;
 276
 277   ctx = new_dwarf_expr_context ();
 278   ctx->baton = next_frame;
 279   ctx->read_reg = read_reg;
 280   ctx->read_mem = read_mem;
 281   ctx->get_frame_base = no_get_frame_base;
 282   ctx->get_tls_address = no_get_tls_address;
 283
 284   dwarf_expr_push (ctx, initial);
 285   dwarf_expr_eval (ctx, exp, len);
 286   result = dwarf_expr_fetch (ctx, 0);
 287
 288   if (ctx->in_reg)
 289     result = read_reg (next_frame, result);
 290
 291   free_dwarf_expr_context (ctx);
 292
 293   return result;
 294 }
 295 \f
 296
 297 static void
 298 execute_cfa_program (gdb_byte *insn_ptr, gdb_byte *insn_end,
 299                      struct frame_info *next_frame,
 300                      struct dwarf2_frame_state *fs, int eh_frame_p)
 301 {
 302   CORE_ADDR pc = frame_pc_unwind (next_frame);
 303   int bytes_read;
 304   struct gdbarch *gdbarch = get_frame_arch (next_frame);
 305
 306   while (insn_ptr < insn_end && fs->pc <= pc)
 307     {
 308       gdb_byte insn = *insn_ptr++;
 309       ULONGEST utmp, reg;
 310       LONGEST offset;
 311
 312       if ((insn & 0xc0) == DW_CFA_advance_loc)
 313         fs->pc += (insn & 0x3f) * fs->code_align;
 314       else if ((insn & 0xc0) == DW_CFA_offset)
 315         {
 316           reg = insn & 0x3f;
 317           if (eh_frame_p)
 318             reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
 319           insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
 320           offset = utmp * fs->data_align;
 321           dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 322           fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
 323           fs->regs.reg[reg].loc.offset = offset;
 324         }
 325       else if ((insn & 0xc0) == DW_CFA_restore)
 326         {
 327           gdb_assert (fs->initial.reg);
 328           reg = insn & 0x3f;
 329           if (eh_frame_p)
 330             reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
 331           dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 332           if (reg < fs->initial.num_regs)
 333             fs->regs.reg[reg] = fs->initial.reg[reg];
 334           else
 335             fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNSPECIFIED;
 336
 337           if (fs->regs.reg[reg].how == DWARF2_FRAME_REG_UNSPECIFIED)
 338             complaint (&symfile_complaints, _("\
 339 incomplete CFI data; DW_CFA_restore unspecified\n\
 340 register %s (#%d) at 0x%s"),
 341                        REGISTER_NAME(DWARF2_REG_TO_REGNUM(reg)),
 342                        DWARF2_REG_TO_REGNUM(reg), paddr (fs->pc));
 343         }
 344       else
 345         {
 346           switch (insn)
 347             {
 348             case DW_CFA_set_loc:
 349               fs->pc = dwarf2_read_address (insn_ptr, insn_end, &bytes_read);
 350               insn_ptr += bytes_read;
 351               break;
 352
 353             case DW_CFA_advance_loc1:
 354               utmp = extract_unsigned_integer (insn_ptr, 1);
 355               fs->pc += utmp * fs->code_align;
 356               insn_ptr++;
 357               break;
 358             case DW_CFA_advance_loc2:
 359               utmp = extract_unsigned_integer (insn_ptr, 2);
 360               fs->pc += utmp * fs->code_align;
 361               insn_ptr += 2;
 362               break;
 363             case DW_CFA_advance_loc4:
 364               utmp = extract_unsigned_integer (insn_ptr, 4);
 365               fs->pc += utmp * fs->code_align;
 366               insn_ptr += 4;
 367               break;
 368
 369             case DW_CFA_offset_extended:
 370               insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
 371               if (eh_frame_p)
 372                 reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
 373               insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
 374               offset = utmp * fs->data_align;
 375               dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 376               fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
 377               fs->regs.reg[reg].loc.offset = offset;
 378               break;
 379
 380             case DW_CFA_restore_extended:
 381               gdb_assert (fs->initial.reg);
 382               insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
 383               if (eh_frame_p)
 384                 reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
 385               dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 386               fs->regs.reg[reg] = fs->initial.reg[reg];
 387               break;
 388
 389             case DW_CFA_undefined:
 390               insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
 391               if (eh_frame_p)
 392                 reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
 393               dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 394               fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNDEFINED;
 395               break;
 396
 397             case DW_CFA_same_value:
 398               insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
 399               if (eh_frame_p)
 400                 reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
 401               dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 402               fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAME_VALUE;
 403               break;
 404
 405             case DW_CFA_register:
 406               insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
 407               if (eh_frame_p)
 408                 reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
 409               insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
 410               if (eh_frame_p)
 411                 utmp = dwarf2_frame_eh_frame_regnum (gdbarch, utmp);
 412               dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 413               fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
 414               fs->regs.reg[reg].loc.reg = utmp;
 415               break;
 416
 417             case DW_CFA_remember_state:
 418               {
 419                 struct dwarf2_frame_state_reg_info *new_rs;
 420
 421                 new_rs = XMALLOC (struct dwarf2_frame_state_reg_info);
 422                 *new_rs = fs->regs;
 423                 fs->regs.reg = dwarf2_frame_state_copy_regs (&fs->regs);
 424                 fs->regs.prev = new_rs;
 425               }
 426               break;
 427
 428             case DW_CFA_restore_state:
 429               {
 430                 struct dwarf2_frame_state_reg_info *old_rs = fs->regs.prev;
 431
 432                 if (old_rs == NULL)
 433                   {
 434                     complaint (&symfile_complaints, _("\
 435 bad CFI data; mismatched DW_CFA_restore_state at 0x%s"), paddr (fs->pc));
 436                   }
 437                 else
 438                   {
 439                     xfree (fs->regs.reg);
 440                     fs->regs = *old_rs;
 441                     xfree (old_rs);
 442                   }
 443               }
 444               break;
 445
 446             case DW_CFA_def_cfa:
 447               insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_reg);
 448               insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
 449
 450               if (fs->armcc_cfa_offsets_sf)
 451                 utmp *= fs->data_align;
 452
 453               fs->cfa_offset = utmp;
 454               fs->cfa_how = CFA_REG_OFFSET;
 455               break;
 456
 457             case DW_CFA_def_cfa_register:
 458               insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_reg);
 459               if (eh_frame_p)
 460                 fs->cfa_reg = dwarf2_frame_eh_frame_regnum (gdbarch,
 461                                                             fs->cfa_reg);
 462               fs->cfa_how = CFA_REG_OFFSET;
 463               break;
 464
 465             case DW_CFA_def_cfa_offset:
 466               insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
 467
 468               if (fs->armcc_cfa_offsets_sf)
 469                 utmp *= fs->data_align;
 470
 471               fs->cfa_offset = utmp;
 472               /* cfa_how deliberately not set.  */
 473               break;
 474
 475             case DW_CFA_nop:
 476               break;
 477
 478             case DW_CFA_def_cfa_expression:
 479               insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_exp_len);
 480               fs->cfa_exp = insn_ptr;
 481               fs->cfa_how = CFA_EXP;
 482               insn_ptr += fs->cfa_exp_len;
 483               break;
 484
 485             case DW_CFA_expression:
 486               insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
 487               if (eh_frame_p)
 488                 reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
 489               dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 490               insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
 491               fs->regs.reg[reg].loc.exp = insn_ptr;
 492               fs->regs.reg[reg].exp_len = utmp;
 493               fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_EXP;
 494               insn_ptr += utmp;
 495               break;
 496
 497             case DW_CFA_offset_extended_sf:
 498               insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
 499               if (eh_frame_p)
 500                 reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
 501               insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
 502               offset *= fs->data_align;
 503               dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 504               fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
 505               fs->regs.reg[reg].loc.offset = offset;
 506               break;
 507
 508             case DW_CFA_val_offset:
 509               insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
 510               dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 511               insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
 512               offset = utmp * fs->data_align;
 513               fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_OFFSET;
 514               fs->regs.reg[reg].loc.offset = offset;
 515               break;
 516
 517             case DW_CFA_val_offset_sf:
 518               insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
 519               dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 520               insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
 521               offset *= fs->data_align;
 522               fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_OFFSET;
 523               fs->regs.reg[reg].loc.offset = offset;
 524               break;
 525
 526             case DW_CFA_val_expression:
 527               insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
 528               dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 529               insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
 530               fs->regs.reg[reg].loc.exp = insn_ptr;
 531               fs->regs.reg[reg].exp_len = utmp;
 532               fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_EXP;
 533               insn_ptr += utmp;
 534               break;
 535
 536             case DW_CFA_def_cfa_sf:
 537               insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_reg);
 538               if (eh_frame_p)
 539                 fs->cfa_reg = dwarf2_frame_eh_frame_regnum (gdbarch,
 540                                                             fs->cfa_reg);
 541               insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
 542               fs->cfa_offset = offset * fs->data_align;
 543               fs->cfa_how = CFA_REG_OFFSET;
 544               break;
 545
 546             case DW_CFA_def_cfa_offset_sf:
 547               insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
 548               fs->cfa_offset = offset * fs->data_align;
 549               /* cfa_how deliberately not set.  */
 550               break;
 551
 552             case DW_CFA_GNU_window_save:
 553               /* This is SPARC-specific code, and contains hard-coded
 554                  constants for the register numbering scheme used by
 555                  GCC.  Rather than having a architecture-specific
 556                  operation that's only ever used by a single
 557                  architecture, we provide the implementation here.
 558                  Incidentally that's what GCC does too in its
 559                  unwinder.  */
 560               {
 561                 struct gdbarch *gdbarch = get_frame_arch (next_frame);
 562                 int size = register_size(gdbarch, 0);
 563                 dwarf2_frame_state_alloc_regs (&fs->regs, 32);
 564                 for (reg = 8; reg < 16; reg++)
 565                   {
 566                     fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
 567                     fs->regs.reg[reg].loc.reg = reg + 16;
 568                   }
 569                 for (reg = 16; reg < 32; reg++)
 570                   {
 571                     fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
 572                     fs->regs.reg[reg].loc.offset = (reg - 16) * size;
 573                   }
 574               }
 575               break;
 576
 577             case DW_CFA_GNU_args_size:
 578               /* Ignored.  */
 579               insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
 580               break;
 581
 582             default:
 583               internal_error (__FILE__, __LINE__, _("Unknown CFI encountered."));
 584             }
 585         }
 586     }
 587
 588   /* Don't allow remember/restore between CIE and FDE programs.  */
 589   dwarf2_frame_state_free_regs (fs->regs.prev);
 590   fs->regs.prev = NULL;
 591 }
 592 \f
 593
 594 /* Architecture-specific operations.  */
 595
 596 /* Per-architecture data key.  */
 597 static struct gdbarch_data *dwarf2_frame_data;
 598
 599 struct dwarf2_frame_ops
 600 {
 601   /* Pre-initialize the register state REG for register REGNUM.  */
 602   void (*init_reg) (struct gdbarch *, int, struct dwarf2_frame_state_reg *,
 603                     struct frame_info *);
 604
 605   /* Check whether the frame preceding NEXT_FRAME will be a signal
 606      trampoline.  */
 607   int (*signal_frame_p) (struct gdbarch *, struct frame_info *);
 608
 609   /* Convert .eh_frame register number to DWARF register number.  */
 610   int (*eh_frame_regnum) (struct gdbarch *, int);
 611 };
 612
 613 /* Default architecture-specific register state initialization
 614    function.  */
 615
 616 static void
 617 dwarf2_frame_default_init_reg (struct gdbarch *gdbarch, int regnum,
 618                                struct dwarf2_frame_state_reg *reg,
 619                                struct frame_info *next_frame)
 620 {
 621   /* If we have a register that acts as a program counter, mark it as
 622      a destination for the return address.  If we have a register that
 623      serves as the stack pointer, arrange for it to be filled with the
 624      call frame address (CFA).  The other registers are marked as
 625      unspecified.
 626
 627      We copy the return address to the program counter, since many
 628      parts in GDB assume that it is possible to get the return address
 629      by unwinding the program counter register.  However, on ISA's
 630      with a dedicated return address register, the CFI usually only
 631      contains information to unwind that return address register.
 632
 633      The reason we're treating the stack pointer special here is
 634      because in many cases GCC doesn't emit CFI for the stack pointer
 635      and implicitly assumes that it is equal to the CFA.  This makes
 636      some sense since the DWARF specification (version 3, draft 8,
 637      p. 102) says that:
 638
 639      "Typically, the CFA is defined to be the value of the stack
 640      pointer at the call site in the previous frame (which may be
 641      different from its value on entry to the current frame)."
 642
 643      However, this isn't true for all platforms supported by GCC
 644      (e.g. IBM S/390 and zSeries).  Those architectures should provide
 645      their own architecture-specific initialization function.  */
 646
 647   if (regnum == PC_REGNUM)
 648     reg->how = DWARF2_FRAME_REG_RA;
 649   else if (regnum == SP_REGNUM)
 650     reg->how = DWARF2_FRAME_REG_CFA;
 651 }
 652
 653 /* Return a default for the architecture-specific operations.  */
 654
 655 static void *
 656 dwarf2_frame_init (struct obstack *obstack)
 657 {
 658   struct dwarf2_frame_ops *ops;
 659
 660   ops = OBSTACK_ZALLOC (obstack, struct dwarf2_frame_ops);
 661   ops->init_reg = dwarf2_frame_default_init_reg;
 662   return ops;
 663 }
 664
 665 /* Set the architecture-specific register state initialization
 666    function for GDBARCH to INIT_REG.  */
 667
 668 void
 669 dwarf2_frame_set_init_reg (struct gdbarch *gdbarch,
 670                            void (*init_reg) (struct gdbarch *, int,
 671                                              struct dwarf2_frame_state_reg *,
 672                                              struct frame_info *))
 673 {
 674   struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
 675
 676   ops->init_reg = init_reg;
 677 }
 678
 679 /* Pre-initialize the register state REG for register REGNUM.  */
 680
 681 static void
 682 dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
 683                        struct dwarf2_frame_state_reg *reg,
 684                        struct frame_info *next_frame)
 685 {
 686   struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
 687
 688   ops->init_reg (gdbarch, regnum, reg, next_frame);
 689 }
 690
 691 /* Set the architecture-specific signal trampoline recognition
 692    function for GDBARCH to SIGNAL_FRAME_P.  */
 693
 694 void
 695 dwarf2_frame_set_signal_frame_p (struct gdbarch *gdbarch,
 696                                  int (*signal_frame_p) (struct gdbarch *,
 697                                                         struct frame_info *))
 698 {
 699   struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
 700
 701   ops->signal_frame_p = signal_frame_p;
 702 }
 703
 704 /* Query the architecture-specific signal frame recognizer for
 705    NEXT_FRAME.  */
 706
 707 static int
 708 dwarf2_frame_signal_frame_p (struct gdbarch *gdbarch,
 709                              struct frame_info *next_frame)
 710 {
 711   struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
 712
 713   if (ops->signal_frame_p == NULL)
 714     return 0;
 715   return ops->signal_frame_p (gdbarch, next_frame);
 716 }
 717
 718 /* Set the architecture-specific mapping of .eh_frame register numbers to
 719    DWARF register numbers.  */
 720
 721 void
 722 dwarf2_frame_set_eh_frame_regnum (struct gdbarch *gdbarch,
 723                                   int (*eh_frame_regnum) (struct gdbarch *,
 724                                                           int))
 725 {
 726   struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
 727
 728   ops->eh_frame_regnum = eh_frame_regnum;
 729 }
 730
 731 /* Translate a .eh_frame register to DWARF register.  */
 732
 733 int
 734 dwarf2_frame_eh_frame_regnum (struct gdbarch *gdbarch, int regnum)
 735 {
 736   struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
 737
 738   if (ops->eh_frame_regnum == NULL)
 739     return regnum;
 740   return ops->eh_frame_regnum (gdbarch, regnum);
 741 }
 742
 743 static void
 744 dwarf2_frame_find_quirks (struct dwarf2_frame_state *fs,
 745                           struct dwarf2_fde *fde)
 746 {
 747   static const char *arm_idents[] = {
 748     "ARM C Compiler, ADS",
 749     "Thumb C Compiler, ADS",
 750     "ARM C++ Compiler, ADS",
 751     "Thumb C++ Compiler, ADS",
 752     "ARM/Thumb C/C++ Compiler, RVCT"
 753   };
 754   int i;
 755
 756   struct symtab *s;
 757
 758   s = find_pc_symtab (fs->pc);
 759   if (s == NULL || s->producer == NULL)
 760     return;
 761
 762   for (i = 0; i < ARRAY_SIZE (arm_idents); i++)
 763     if (strncmp (s->producer, arm_idents[i], strlen (arm_idents[i])) == 0)
 764       {
 765         if (fde->cie->version == 1)
 766           fs->armcc_cfa_offsets_sf = 1;
 767
 768         if (fde->cie->version == 1)
 769           fs->armcc_cfa_offsets_reversed = 1;
 770
 771         /* The reversed offset problem is present in some compilers
 772            using DWARF3, but it was eventually fixed.  Check the ARM
 773            defined augmentations, which are in the format "armcc" followed
 774            by a list of one-character options.  The "+" option means
 775            this problem is fixed (no quirk needed).  If the armcc
 776            augmentation is missing, the quirk is needed.  */
 777         if (fde->cie->version == 3
 778             && (strncmp (fde->cie->augmentation, "armcc", 5) != 0
 779                 || strchr (fde->cie->augmentation + 5, '+') == NULL))
 780           fs->armcc_cfa_offsets_reversed = 1;
 781
 782         return;
 783       }
 784 }
 785 \f
 786
 787 struct dwarf2_frame_cache
 788 {
 789   /* DWARF Call Frame Address.  */
 790   CORE_ADDR cfa;
 791
 792   /* Set if the return address column was marked as undefined.  */
 793   int undefined_retaddr;
 794
 795   /* Saved registers, indexed by GDB register number, not by DWARF
 796      register number.  */
 797   struct dwarf2_frame_state_reg *reg;
 798
 799   /* Return address register.  */
 800   struct dwarf2_frame_state_reg retaddr_reg;
 801 };
 802
 803 static struct dwarf2_frame_cache *
 804 dwarf2_frame_cache (struct frame_info *next_frame, void **this_cache)
 805 {
 806   struct cleanup *old_chain;
 807   struct gdbarch *gdbarch = get_frame_arch (next_frame);
 808   const int num_regs = NUM_REGS + NUM_PSEUDO_REGS;
 809   struct dwarf2_frame_cache *cache;
 810   struct dwarf2_frame_state *fs;
 811   struct dwarf2_fde *fde;
 812
 813   if (*this_cache)
 814     return *this_cache;
 815
 816   /* Allocate a new cache.  */
 817   cache = FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache);
 818   cache->reg = FRAME_OBSTACK_CALLOC (num_regs, struct dwarf2_frame_state_reg);
 819
 820   /* Allocate and initialize the frame state.  */
 821   fs = XMALLOC (struct dwarf2_frame_state);
 822   memset (fs, 0, sizeof (struct dwarf2_frame_state));
 823   old_chain = make_cleanup (dwarf2_frame_state_free, fs);
 824
 825   /* Unwind the PC.
 826
 827      Note that if NEXT_FRAME is never supposed to return (i.e. a call
 828      to abort), the compiler might optimize away the instruction at
 829      NEXT_FRAME's return address.  As a result the return address will
 830      point at some random instruction, and the CFI for that
 831      instruction is probably worthless to us.  GCC's unwinder solves
 832      this problem by substracting 1 from the return address to get an
 833      address in the middle of a presumed call instruction (or the
 834      instruction in the associated delay slot).  This should only be
 835      done for "normal" frames and not for resume-type frames (signal
 836      handlers, sentinel frames, dummy frames).  The function
 837      frame_unwind_address_in_block does just this.  It's not clear how
 838      reliable the method is though; there is the potential for the
 839      register state pre-call being different to that on return.  */
 840   fs->pc = frame_unwind_address_in_block (next_frame);
 841
 842   /* Find the correct FDE.  */
 843   fde = dwarf2_frame_find_fde (&fs->pc);
 844   gdb_assert (fde != NULL);
 845
 846   /* Extract any interesting information from the CIE.  */
 847   fs->data_align = fde->cie->data_alignment_factor;
 848   fs->code_align = fde->cie->code_alignment_factor;
 849   fs->retaddr_column = fde->cie->return_address_register;
 850
 851   /* Check for "quirks" - known bugs in producers.  */
 852   dwarf2_frame_find_quirks (fs, fde);
 853
 854   /* First decode all the insns in the CIE.  */
 855   execute_cfa_program (fde->cie->initial_instructions,
 856                        fde->cie->end, next_frame, fs, fde->eh_frame_p);
 857
 858   /* Save the initialized register set.  */
 859   fs->initial = fs->regs;
 860   fs->initial.reg = dwarf2_frame_state_copy_regs (&fs->regs);
 861
 862   /* Then decode the insns in the FDE up to our target PC.  */
 863   execute_cfa_program (fde->instructions, fde->end, next_frame, fs,
 864                        fde->eh_frame_p);
 865
 866   /* Caclulate the CFA.  */
 867   switch (fs->cfa_how)
 868     {
 869     case CFA_REG_OFFSET:
 870       cache->cfa = read_reg (next_frame, fs->cfa_reg);
 871       if (fs->armcc_cfa_offsets_reversed)
 872         cache->cfa -= fs->cfa_offset;
 873       else
 874         cache->cfa += fs->cfa_offset;
 875       break;
 876
 877     case CFA_EXP:
 878       cache->cfa =
 879         execute_stack_op (fs->cfa_exp, fs->cfa_exp_len, next_frame, 0);
 880       break;
 881
 882     default:
 883       internal_error (__FILE__, __LINE__, _("Unknown CFA rule."));
 884     }
 885
 886   /* Initialize the register state.  */
 887   {
 888     int regnum;
 889
 890     for (regnum = 0; regnum < num_regs; regnum++)
 891       dwarf2_frame_init_reg (gdbarch, regnum, &cache->reg[regnum], next_frame);
 892   }
 893
 894   /* Go through the DWARF2 CFI generated table and save its register
 895      location information in the cache.  Note that we don't skip the
 896      return address column; it's perfectly all right for it to
 897      correspond to a real register.  If it doesn't correspond to a
 898      real register, or if we shouldn't treat it as such,
 899      DWARF2_REG_TO_REGNUM should be defined to return a number outside
 900      the range [0, NUM_REGS).  */
 901   {
 902     int column;         /* CFI speak for "register number".  */
 903
 904     for (column = 0; column < fs->regs.num_regs; column++)
 905       {
 906         /* Use the GDB register number as the destination index.  */
 907         int regnum = DWARF2_REG_TO_REGNUM (column);
 908
 909         /* If there's no corresponding GDB register, ignore it.  */
 910         if (regnum < 0 || regnum >= num_regs)
 911           continue;
 912
 913         /* NOTE: cagney/2003-09-05: CFI should specify the disposition
 914            of all debug info registers.  If it doesn't, complain (but
 915            not too loudly).  It turns out that GCC assumes that an
 916            unspecified register implies "same value" when CFI (draft
 917            7) specifies nothing at all.  Such a register could equally
 918            be interpreted as "undefined".  Also note that this check
 919            isn't sufficient; it only checks that all registers in the
 920            range [0 .. max column] are specified, and won't detect
 921            problems when a debug info register falls outside of the
 922            table.  We need a way of iterating through all the valid
 923            DWARF2 register numbers.  */
 924         if (fs->regs.reg[column].how == DWARF2_FRAME_REG_UNSPECIFIED)
 925           {
 926             if (cache->reg[regnum].how == DWARF2_FRAME_REG_UNSPECIFIED)
 927               complaint (&symfile_complaints, _("\
 928 incomplete CFI data; unspecified registers (e.g., %s) at 0x%s"),
 929                          gdbarch_register_name (gdbarch, regnum),
 930                          paddr_nz (fs->pc));
 931           }
 932         else
 933           cache->reg[regnum] = fs->regs.reg[column];
 934       }
 935   }
 936
 937   /* Eliminate any DWARF2_FRAME_REG_RA rules, and save the information
 938      we need for evaluating DWARF2_FRAME_REG_RA_OFFSET rules.  */
 939   {
 940     int regnum;
 941
 942     for (regnum = 0; regnum < num_regs; regnum++)
 943       {
 944         if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA
 945             || cache->reg[regnum].how == DWARF2_FRAME_REG_RA_OFFSET)
 946           {
 947             struct dwarf2_frame_state_reg *retaddr_reg =
 948               &fs->regs.reg[fs->retaddr_column];
 949
 950             /* It seems rather bizarre to specify an "empty" column as
 951                the return adress column.  However, this is exactly
 952                what GCC does on some targets.  It turns out that GCC
 953                assumes that the return address can be found in the
 954                register corresponding to the return address column.
 955                Incidentally, that's how we should treat a return
 956                address column specifying "same value" too.  */
 957             if (fs->retaddr_column < fs->regs.num_regs
 958                 && retaddr_reg->how != DWARF2_FRAME_REG_UNSPECIFIED
 959                 && retaddr_reg->how != DWARF2_FRAME_REG_SAME_VALUE)
 960               {
 961                 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
 962                   cache->reg[regnum] = *retaddr_reg;
 963                 else
 964                   cache->retaddr_reg = *retaddr_reg;
 965               }
 966             else
 967               {
 968                 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
 969                   {
 970                     cache->reg[regnum].loc.reg = fs->retaddr_column;
 971                     cache->reg[regnum].how = DWARF2_FRAME_REG_SAVED_REG;
 972                   }
 973                 else
 974                   {
 975                     cache->retaddr_reg.loc.reg = fs->retaddr_column;
 976                     cache->retaddr_reg.how = DWARF2_FRAME_REG_SAVED_REG;
 977                   }
 978               }
 979           }
 980       }
 981   }
 982
 983   if (fs->retaddr_column < fs->regs.num_regs
 984       && fs->regs.reg[fs->retaddr_column].how == DWARF2_FRAME_REG_UNDEFINED)
 985     cache->undefined_retaddr = 1;
 986
 987   do_cleanups (old_chain);
 988
 989   *this_cache = cache;
 990   return cache;
 991 }
 992
 993 static void
 994 dwarf2_frame_this_id (struct frame_info *next_frame, void **this_cache,
 995                       struct frame_id *this_id)
 996 {
 997   struct dwarf2_frame_cache *cache =
 998     dwarf2_frame_cache (next_frame, this_cache);
 999
1000   if (cache->undefined_retaddr)
1001     return;
1002
1003   (*this_id) = frame_id_build (cache->cfa, frame_func_unwind (next_frame));
1004 }
1005
1006 static void
1007 dwarf2_frame_prev_register (struct frame_info *next_frame, void **this_cache,
1008                             int regnum, int *optimizedp,
1009                             enum lval_type *lvalp, CORE_ADDR *addrp,
1010                             int *realnump, gdb_byte *valuep)
1011 {
1012   struct gdbarch *gdbarch = get_frame_arch (next_frame);
1013   struct dwarf2_frame_cache *cache =
1014     dwarf2_frame_cache (next_frame, this_cache);
1015
1016   switch (cache->reg[regnum].how)
1017     {
1018     case DWARF2_FRAME_REG_UNDEFINED:
1019       /* If CFI explicitly specified that the value isn't defined,
1020          mark it as optimized away; the value isn't available.  */
1021       *optimizedp = 1;
1022       *lvalp = not_lval;
1023       *addrp = 0;
1024       *realnump = -1;
1025       if (valuep)
1026         {
1027           /* In some cases, for example %eflags on the i386, we have
1028              to provide a sane value, even though this register wasn't
1029              saved.  Assume we can get it from NEXT_FRAME.  */
1030           frame_unwind_register (next_frame, regnum, valuep);
1031         }
1032       break;
1033
1034     case DWARF2_FRAME_REG_SAVED_OFFSET:
1035       *optimizedp = 0;
1036       *lvalp = lval_memory;
1037       *addrp = cache->cfa + cache->reg[regnum].loc.offset;
1038       *realnump = -1;
1039       if (valuep)
1040         {
1041           /* Read the value in from memory.  */
1042           read_memory (*addrp, valuep, register_size (gdbarch, regnum));
1043         }
1044       break;
1045
1046     case DWARF2_FRAME_REG_SAVED_REG:
1047       *optimizedp = 0;
1048       *lvalp = lval_register;
1049       *addrp = 0;
1050       *realnump = DWARF2_REG_TO_REGNUM (cache->reg[regnum].loc.reg);
1051       if (valuep)
1052         frame_unwind_register (next_frame, (*realnump), valuep);
1053       break;
1054
1055     case DWARF2_FRAME_REG_SAVED_EXP:
1056       *optimizedp = 0;
1057       *lvalp = lval_memory;
1058       *addrp = execute_stack_op (cache->reg[regnum].loc.exp,
1059                                  cache->reg[regnum].exp_len,
1060                                  next_frame, cache->cfa);
1061       *realnump = -1;
1062       if (valuep)
1063         {
1064           /* Read the value in from memory.  */
1065           read_memory (*addrp, valuep, register_size (gdbarch, regnum));
1066         }
1067       break;
1068
1069     case DWARF2_FRAME_REG_SAVED_VAL_OFFSET:
1070       *optimizedp = 0;
1071       *lvalp = not_lval;
1072       *addrp = 0;
1073       *realnump = -1;
1074       if (valuep)
1075         store_unsigned_integer (valuep, register_size (gdbarch, regnum),
1076                                 cache->cfa + cache->reg[regnum].loc.offset);
1077       break;
1078
1079     case DWARF2_FRAME_REG_SAVED_VAL_EXP:
1080       *optimizedp = 0;
1081       *lvalp = not_lval;
1082       *addrp = 0;
1083       *realnump = -1;
1084       if (valuep)
1085         store_unsigned_integer (valuep, register_size (gdbarch, regnum),
1086                                 execute_stack_op (cache->reg[regnum].loc.exp,
1087                                                   cache->reg[regnum].exp_len,
1088                                                   next_frame, cache->cfa));
1089       break;
1090
1091     case DWARF2_FRAME_REG_UNSPECIFIED:
1092       /* GCC, in its infinite wisdom decided to not provide unwind
1093          information for registers that are "same value".  Since
1094          DWARF2 (3 draft 7) doesn't define such behavior, said
1095          registers are actually undefined (which is different to CFI
1096          "undefined").  Code above issues a complaint about this.
1097          Here just fudge the books, assume GCC, and that the value is
1098          more inner on the stack.  */
1099       *optimizedp = 0;
1100       *lvalp = lval_register;
1101       *addrp = 0;
1102       *realnump = regnum;
1103       if (valuep)
1104         frame_unwind_register (next_frame, (*realnump), valuep);
1105       break;
1106
1107     case DWARF2_FRAME_REG_SAME_VALUE:
1108       *optimizedp = 0;
1109       *lvalp = lval_register;
1110       *addrp = 0;
1111       *realnump = regnum;
1112       if (valuep)
1113         frame_unwind_register (next_frame, (*realnump), valuep);
1114       break;
1115
1116     case DWARF2_FRAME_REG_CFA:
1117       *optimizedp = 0;
1118       *lvalp = not_lval;
1119       *addrp = 0;
1120       *realnump = -1;
1121       if (valuep)
1122         {
1123           /* Store the value.  */
1124           store_typed_address (valuep, builtin_type_void_data_ptr, cache->cfa);
1125         }
1126       break;
1127
1128     case DWARF2_FRAME_REG_CFA_OFFSET:
1129       *optimizedp = 0;
1130       *lvalp = not_lval;
1131       *addrp = 0;
1132       *realnump = -1;
1133       if (valuep)
1134         {
1135           /* Store the value.  */
1136           store_typed_address (valuep, builtin_type_void_data_ptr,
1137                                cache->cfa + cache->reg[regnum].loc.offset);
1138         }
1139       break;
1140
1141     case DWARF2_FRAME_REG_RA_OFFSET:
1142       *optimizedp = 0;
1143       *lvalp = not_lval;
1144       *addrp = 0;
1145       *realnump = -1;
1146       if (valuep)
1147         {
1148           CORE_ADDR pc = cache->reg[regnum].loc.offset;
1149
1150           regnum = DWARF2_REG_TO_REGNUM (cache->retaddr_reg.loc.reg);
1151           pc += frame_unwind_register_unsigned (next_frame, regnum);
1152           store_typed_address (valuep, builtin_type_void_func_ptr, pc);
1153         }
1154       break;
1155
1156     default:
1157       internal_error (__FILE__, __LINE__, _("Unknown register rule."));
1158     }
1159 }
1160
1161 static const struct frame_unwind dwarf2_frame_unwind =
1162 {
1163   NORMAL_FRAME,
1164   dwarf2_frame_this_id,
1165   dwarf2_frame_prev_register
1166 };
1167
1168 static const struct frame_unwind dwarf2_signal_frame_unwind =
1169 {
1170   SIGTRAMP_FRAME,
1171   dwarf2_frame_this_id,
1172   dwarf2_frame_prev_register
1173 };
1174
1175 const struct frame_unwind *
1176 dwarf2_frame_sniffer (struct frame_info *next_frame)
1177 {
1178   /* Grab an address that is guarenteed to reside somewhere within the
1179      function.  frame_pc_unwind(), for a no-return next function, can
1180      end up returning something past the end of this function's body.  */
1181   CORE_ADDR block_addr = frame_unwind_address_in_block (next_frame);
1182   struct dwarf2_fde *fde = dwarf2_frame_find_fde (&block_addr);
1183   if (!fde)
1184     return NULL;
1185
1186   /* On some targets, signal trampolines may have unwind information.
1187      We need to recognize them so that we set the frame type
1188      correctly.  */
1189
1190   if (fde->cie->signal_frame
1191       || dwarf2_frame_signal_frame_p (get_frame_arch (next_frame),
1192                                       next_frame))
1193     return &dwarf2_signal_frame_unwind;
1194
1195   return &dwarf2_frame_unwind;
1196 }
1197 \f
1198
1199 /* There is no explicitly defined relationship between the CFA and the
1200    location of frame's local variables and arguments/parameters.
1201    Therefore, frame base methods on this page should probably only be
1202    used as a last resort, just to avoid printing total garbage as a
1203    response to the "info frame" command.  */
1204
1205 static CORE_ADDR
1206 dwarf2_frame_base_address (struct frame_info *next_frame, void **this_cache)
1207 {
1208   struct dwarf2_frame_cache *cache =
1209     dwarf2_frame_cache (next_frame, this_cache);
1210
1211   return cache->cfa;
1212 }
1213
1214 static const struct frame_base dwarf2_frame_base =
1215 {
1216   &dwarf2_frame_unwind,
1217   dwarf2_frame_base_address,
1218   dwarf2_frame_base_address,
1219   dwarf2_frame_base_address
1220 };
1221
1222 const struct frame_base *
1223 dwarf2_frame_base_sniffer (struct frame_info *next_frame)
1224 {
1225   CORE_ADDR pc = frame_pc_unwind (next_frame);
1226   if (dwarf2_frame_find_fde (&pc))
1227     return &dwarf2_frame_base;
1228
1229   return NULL;
1230 }
1231 \f
1232 /* A minimal decoding of DWARF2 compilation units.  We only decode
1233    what's needed to get to the call frame information.  */
1234
1235 struct comp_unit
1236 {
1237   /* Keep the bfd convenient.  */
1238   bfd *abfd;
1239
1240   struct objfile *objfile;
1241
1242   /* Linked list of CIEs for this object.  */
1243   struct dwarf2_cie *cie;
1244
1245   /* Pointer to the .debug_frame section loaded into memory.  */
1246   gdb_byte *dwarf_frame_buffer;
1247
1248   /* Length of the loaded .debug_frame section.  */
1249   unsigned long dwarf_frame_size;
1250
1251   /* Pointer to the .debug_frame section.  */
1252   asection *dwarf_frame_section;
1253
1254   /* Base for DW_EH_PE_datarel encodings.  */
1255   bfd_vma dbase;
1256
1257   /* Base for DW_EH_PE_textrel encodings.  */
1258   bfd_vma tbase;
1259 };
1260
1261 const struct objfile_data *dwarf2_frame_objfile_data;
1262
1263 static unsigned int
1264 read_1_byte (bfd *abfd, gdb_byte *buf)
1265 {
1266   return bfd_get_8 (abfd, buf);
1267 }
1268
1269 static unsigned int
1270 read_4_bytes (bfd *abfd, gdb_byte *buf)
1271 {
1272   return bfd_get_32 (abfd, buf);
1273 }
1274
1275 static ULONGEST
1276 read_8_bytes (bfd *abfd, gdb_byte *buf)
1277 {
1278   return bfd_get_64 (abfd, buf);
1279 }
1280
1281 static ULONGEST
1282 read_unsigned_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1283 {
1284   ULONGEST result;
1285   unsigned int num_read;
1286   int shift;
1287   gdb_byte byte;
1288
1289   result = 0;
1290   shift = 0;
1291   num_read = 0;
1292
1293   do
1294     {
1295       byte = bfd_get_8 (abfd, (bfd_byte *) buf);
1296       buf++;
1297       num_read++;
1298       result |= ((byte & 0x7f) << shift);
1299       shift += 7;
1300     }
1301   while (byte & 0x80);
1302
1303   *bytes_read_ptr = num_read;
1304
1305   return result;
1306 }
1307
1308 static LONGEST
1309 read_signed_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1310 {
1311   LONGEST result;
1312   int shift;
1313   unsigned int num_read;
1314   gdb_byte byte;
1315
1316   result = 0;
1317   shift = 0;
1318   num_read = 0;
1319
1320   do
1321     {
1322       byte = bfd_get_8 (abfd, (bfd_byte *) buf);
1323       buf++;
1324       num_read++;
1325       result |= ((byte & 0x7f) << shift);
1326       shift += 7;
1327     }
1328   while (byte & 0x80);
1329
1330   if (shift < 8 * sizeof (result) && (byte & 0x40))
1331     result |= -(((LONGEST)1) << shift);
1332
1333   *bytes_read_ptr = num_read;
1334
1335   return result;
1336 }
1337
1338 static ULONGEST
1339 read_initial_length (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1340 {
1341   LONGEST result;
1342
1343   result = bfd_get_32 (abfd, buf);
1344   if (result == 0xffffffff)
1345     {
1346       result = bfd_get_64 (abfd, buf + 4);
1347       *bytes_read_ptr = 12;
1348     }
1349   else
1350     *bytes_read_ptr = 4;
1351
1352   return result;
1353 }
1354 \f
1355
1356 /* Pointer encoding helper functions.  */
1357
1358 /* GCC supports exception handling based on DWARF2 CFI.  However, for
1359    technical reasons, it encodes addresses in its FDE's in a different
1360    way.  Several "pointer encodings" are supported.  The encoding
1361    that's used for a particular FDE is determined by the 'R'
1362    augmentation in the associated CIE.  The argument of this
1363    augmentation is a single byte.
1364
1365    The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a
1366    LEB128.  This is encoded in bits 0, 1 and 2.  Bit 3 encodes whether
1367    the address is signed or unsigned.  Bits 4, 5 and 6 encode how the
1368    address should be interpreted (absolute, relative to the current
1369    position in the FDE, ...).  Bit 7, indicates that the address
1370    should be dereferenced.  */
1371
1372 static gdb_byte
1373 encoding_for_size (unsigned int size)
1374 {
1375   switch (size)
1376     {
1377     case 2:
1378       return DW_EH_PE_udata2;
1379     case 4:
1380       return DW_EH_PE_udata4;
1381     case 8:
1382       return DW_EH_PE_udata8;
1383     default:
1384       internal_error (__FILE__, __LINE__, _("Unsupported address size"));
1385     }
1386 }
1387
1388 static unsigned int
1389 size_of_encoded_value (gdb_byte encoding)
1390 {
1391   if (encoding == DW_EH_PE_omit)
1392     return 0;
1393
1394   switch (encoding & 0x07)
1395     {
1396     case DW_EH_PE_absptr:
1397       return TYPE_LENGTH (builtin_type_void_data_ptr);
1398     case DW_EH_PE_udata2:
1399       return 2;
1400     case DW_EH_PE_udata4:
1401       return 4;
1402     case DW_EH_PE_udata8:
1403       return 8;
1404     default:
1405       internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
1406     }
1407 }
1408
1409 static CORE_ADDR
1410 read_encoded_value (struct comp_unit *unit, gdb_byte encoding,
1411                     gdb_byte *buf, unsigned int *bytes_read_ptr)
1412 {
1413   int ptr_len = size_of_encoded_value (DW_EH_PE_absptr);
1414   ptrdiff_t offset;
1415   CORE_ADDR base;
1416
1417   /* GCC currently doesn't generate DW_EH_PE_indirect encodings for
1418      FDE's.  */
1419   if (encoding & DW_EH_PE_indirect)
1420     internal_error (__FILE__, __LINE__,
1421                     _("Unsupported encoding: DW_EH_PE_indirect"));
1422
1423   *bytes_read_ptr = 0;
1424
1425   switch (encoding & 0x70)
1426     {
1427     case DW_EH_PE_absptr:
1428       base = 0;
1429       break;
1430     case DW_EH_PE_pcrel:
1431       base = bfd_get_section_vma (unit->bfd, unit->dwarf_frame_section);
1432       base += (buf - unit->dwarf_frame_buffer);
1433       break;
1434     case DW_EH_PE_datarel:
1435       base = unit->dbase;
1436       break;
1437     case DW_EH_PE_textrel:
1438       base = unit->tbase;
1439       break;
1440     case DW_EH_PE_funcrel:
1441       /* FIXME: kettenis/20040501: For now just pretend
1442          DW_EH_PE_funcrel is equivalent to DW_EH_PE_absptr.  For
1443          reading the initial location of an FDE it should be treated
1444          as such, and currently that's the only place where this code
1445          is used.  */
1446       base = 0;
1447       break;
1448     case DW_EH_PE_aligned:
1449       base = 0;
1450       offset = buf - unit->dwarf_frame_buffer;
1451       if ((offset % ptr_len) != 0)
1452         {
1453           *bytes_read_ptr = ptr_len - (offset % ptr_len);
1454           buf += *bytes_read_ptr;
1455         }
1456       break;
1457     default:
1458       internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
1459     }
1460
1461   if ((encoding & 0x07) == 0x00)
1462     encoding |= encoding_for_size (ptr_len);
1463
1464   switch (encoding & 0x0f)
1465     {
1466     case DW_EH_PE_uleb128:
1467       {
1468         ULONGEST value;
1469         gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1470         *bytes_read_ptr += read_uleb128 (buf, end_buf, &value) - buf;
1471         return base + value;
1472       }
1473     case DW_EH_PE_udata2:
1474       *bytes_read_ptr += 2;
1475       return (base + bfd_get_16 (unit->abfd, (bfd_byte *) buf));
1476     case DW_EH_PE_udata4:
1477       *bytes_read_ptr += 4;
1478       return (base + bfd_get_32 (unit->abfd, (bfd_byte *) buf));
1479     case DW_EH_PE_udata8:
1480       *bytes_read_ptr += 8;
1481       return (base + bfd_get_64 (unit->abfd, (bfd_byte *) buf));
1482     case DW_EH_PE_sleb128:
1483       {
1484         LONGEST value;
1485         gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1486         *bytes_read_ptr += read_sleb128 (buf, end_buf, &value) - buf;
1487         return base + value;
1488       }
1489     case DW_EH_PE_sdata2:
1490       *bytes_read_ptr += 2;
1491       return (base + bfd_get_signed_16 (unit->abfd, (bfd_byte *) buf));
1492     case DW_EH_PE_sdata4:
1493       *bytes_read_ptr += 4;
1494       return (base + bfd_get_signed_32 (unit->abfd, (bfd_byte *) buf));
1495     case DW_EH_PE_sdata8:
1496       *bytes_read_ptr += 8;
1497       return (base + bfd_get_signed_64 (unit->abfd, (bfd_byte *) buf));
1498     default:
1499       internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
1500     }
1501 }
1502 \f
1503
1504 /* GCC uses a single CIE for all FDEs in a .debug_frame section.
1505    That's why we use a simple linked list here.  */
1506
1507 static struct dwarf2_cie *
1508 find_cie (struct comp_unit *unit, ULONGEST cie_pointer)
1509 {
1510   struct dwarf2_cie *cie = unit->cie;
1511
1512   while (cie)
1513     {
1514       if (cie->cie_pointer == cie_pointer)
1515         return cie;
1516
1517       cie = cie->next;
1518     }
1519
1520   return NULL;
1521 }
1522
1523 static void
1524 add_cie (struct comp_unit *unit, struct dwarf2_cie *cie)
1525 {
1526   cie->next = unit->cie;
1527   unit->cie = cie;
1528 }
1529
1530 /* Find the FDE for *PC.  Return a pointer to the FDE, and store the
1531    inital location associated with it into *PC.  */
1532
1533 static struct dwarf2_fde *
1534 dwarf2_frame_find_fde (CORE_ADDR *pc)
1535 {
1536   struct objfile *objfile;
1537
1538   ALL_OBJFILES (objfile)
1539     {
1540       struct dwarf2_fde *fde;
1541       CORE_ADDR offset;
1542
1543       fde = objfile_data (objfile, dwarf2_frame_objfile_data);
1544       if (fde == NULL)
1545         continue;
1546
1547       gdb_assert (objfile->section_offsets);
1548       offset = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1549
1550       while (fde)
1551         {
1552           if (*pc >= fde->initial_location + offset
1553               && *pc < fde->initial_location + offset + fde->address_range)
1554             {
1555               *pc = fde->initial_location + offset;
1556               return fde;
1557             }
1558
1559           fde = fde->next;
1560         }
1561     }
1562
1563   return NULL;
1564 }
1565
1566 static void
1567 add_fde (struct comp_unit *unit, struct dwarf2_fde *fde)
1568 {
1569   fde->next = objfile_data (unit->objfile, dwarf2_frame_objfile_data);
1570   set_objfile_data (unit->objfile, dwarf2_frame_objfile_data, fde);
1571 }
1572
1573 #ifdef CC_HAS_LONG_LONG
1574 #define DW64_CIE_ID 0xffffffffffffffffULL
1575 #else
1576 #define DW64_CIE_ID ~0
1577 #endif
1578
1579 static gdb_byte *decode_frame_entry (struct comp_unit *unit, gdb_byte *start,
1580                                      int eh_frame_p);
1581
1582 /* Decode the next CIE or FDE.  Return NULL if invalid input, otherwise
1583    the next byte to be processed.  */
1584 static gdb_byte *
1585 decode_frame_entry_1 (struct comp_unit *unit, gdb_byte *start, int eh_frame_p)
1586 {
1587   gdb_byte *buf, *end;
1588   LONGEST length;
1589   unsigned int bytes_read;
1590   int dwarf64_p;
1591   ULONGEST cie_id;
1592   ULONGEST cie_pointer;
1593
1594   buf = start;
1595   length = read_initial_length (unit->abfd, buf, &bytes_read);
1596   buf += bytes_read;
1597   end = buf + length;
1598
1599   /* Are we still within the section? */
1600   if (end > unit->dwarf_frame_buffer + unit->dwarf_frame_size)
1601     return NULL;
1602
1603   if (length == 0)
1604     return end;
1605
1606   /* Distinguish between 32 and 64-bit encoded frame info.  */
1607   dwarf64_p = (bytes_read == 12);
1608
1609   /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs.  */
1610   if (eh_frame_p)
1611     cie_id = 0;
1612   else if (dwarf64_p)
1613     cie_id = DW64_CIE_ID;
1614   else
1615     cie_id = DW_CIE_ID;
1616
1617   if (dwarf64_p)
1618     {
1619       cie_pointer = read_8_bytes (unit->abfd, buf);
1620       buf += 8;
1621     }
1622   else
1623     {
1624       cie_pointer = read_4_bytes (unit->abfd, buf);
1625       buf += 4;
1626     }
1627
1628   if (cie_pointer == cie_id)
1629     {
1630       /* This is a CIE.  */
1631       struct dwarf2_cie *cie;
1632       char *augmentation;
1633       unsigned int cie_version;
1634
1635       /* Record the offset into the .debug_frame section of this CIE.  */
1636       cie_pointer = start - unit->dwarf_frame_buffer;
1637
1638       /* Check whether we've already read it.  */
1639       if (find_cie (unit, cie_pointer))
1640         return end;
1641
1642       cie = (struct dwarf2_cie *)
1643         obstack_alloc (&unit->objfile->objfile_obstack,
1644                        sizeof (struct dwarf2_cie));
1645       cie->initial_instructions = NULL;
1646       cie->cie_pointer = cie_pointer;
1647
1648       /* The encoding for FDE's in a normal .debug_frame section
1649          depends on the target address size.  */
1650       cie->encoding = DW_EH_PE_absptr;
1651
1652       /* We'll determine the final value later, but we need to
1653          initialize it conservatively.  */
1654       cie->signal_frame = 0;
1655
1656       /* Check version number.  */
1657       cie_version = read_1_byte (unit->abfd, buf);
1658       if (cie_version != 1 && cie_version != 3)
1659         return NULL;
1660       cie->version = cie_version;
1661       buf += 1;
1662
1663       /* Interpret the interesting bits of the augmentation.  */
1664       cie->augmentation = augmentation = (char *) buf;
1665       buf += (strlen (augmentation) + 1);
1666
1667       /* Ignore armcc augmentations.  We only use them for quirks,
1668          and that doesn't happen until later.  */
1669       if (strncmp (augmentation, "armcc", 5) == 0)
1670         augmentation += strlen (augmentation);
1671
1672       /* The GCC 2.x "eh" augmentation has a pointer immediately
1673          following the augmentation string, so it must be handled
1674          first.  */
1675       if (augmentation[0] == 'e' && augmentation[1] == 'h')
1676         {
1677           /* Skip.  */
1678           buf += TYPE_LENGTH (builtin_type_void_data_ptr);
1679           augmentation += 2;
1680         }
1681
1682       cie->code_alignment_factor =
1683         read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1684       buf += bytes_read;
1685
1686       cie->data_alignment_factor =
1687         read_signed_leb128 (unit->abfd, buf, &bytes_read);
1688       buf += bytes_read;
1689
1690       if (cie_version == 1)
1691         {
1692           cie->return_address_register = read_1_byte (unit->abfd, buf);
1693           bytes_read = 1;
1694         }
1695       else
1696         cie->return_address_register = read_unsigned_leb128 (unit->abfd, buf,
1697                                                              &bytes_read);
1698       if (eh_frame_p)
1699         cie->return_address_register
1700           = dwarf2_frame_eh_frame_regnum (current_gdbarch,
1701                                           cie->return_address_register);
1702
1703       buf += bytes_read;
1704
1705       cie->saw_z_augmentation = (*augmentation == 'z');
1706       if (cie->saw_z_augmentation)
1707         {
1708           ULONGEST length;
1709
1710           length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1711           buf += bytes_read;
1712           if (buf > end)
1713             return NULL;
1714           cie->initial_instructions = buf + length;
1715           augmentation++;
1716         }
1717
1718       while (*augmentation)
1719         {
1720           /* "L" indicates a byte showing how the LSDA pointer is encoded.  */
1721           if (*augmentation == 'L')
1722             {
1723               /* Skip.  */
1724               buf++;
1725               augmentation++;
1726             }
1727
1728           /* "R" indicates a byte indicating how FDE addresses are encoded.  */
1729           else if (*augmentation == 'R')
1730             {
1731               cie->encoding = *buf++;
1732               augmentation++;
1733             }
1734
1735           /* "P" indicates a personality routine in the CIE augmentation.  */
1736           else if (*augmentation == 'P')
1737             {
1738               /* Skip.  Avoid indirection since we throw away the result.  */
1739               gdb_byte encoding = (*buf++) & ~DW_EH_PE_indirect;
1740               read_encoded_value (unit, encoding, buf, &bytes_read);
1741               buf += bytes_read;
1742               augmentation++;
1743             }
1744
1745           /* "S" indicates a signal frame, such that the return
1746              address must not be decremented to locate the call frame
1747              info for the previous frame; it might even be the first
1748              instruction of a function, so decrementing it would take
1749              us to a different function.  */
1750           else if (*augmentation == 'S')
1751             {
1752               cie->signal_frame = 1;
1753               augmentation++;
1754             }
1755
1756           /* Otherwise we have an unknown augmentation.  Assume that either
1757              there is no augmentation data, or we saw a 'z' prefix.  */
1758           else
1759             {
1760               if (cie->initial_instructions)
1761                 buf = cie->initial_instructions;
1762               break;
1763             }
1764         }
1765
1766       cie->initial_instructions = buf;
1767       cie->end = end;
1768
1769       add_cie (unit, cie);
1770     }
1771   else
1772     {
1773       /* This is a FDE.  */
1774       struct dwarf2_fde *fde;
1775
1776       /* In an .eh_frame section, the CIE pointer is the delta between the
1777          address within the FDE where the CIE pointer is stored and the
1778          address of the CIE.  Convert it to an offset into the .eh_frame
1779          section.  */
1780       if (eh_frame_p)
1781         {
1782           cie_pointer = buf - unit->dwarf_frame_buffer - cie_pointer;
1783           cie_pointer -= (dwarf64_p ? 8 : 4);
1784         }
1785
1786       /* In either case, validate the result is still within the section.  */
1787       if (cie_pointer >= unit->dwarf_frame_size)
1788         return NULL;
1789
1790       fde = (struct dwarf2_fde *)
1791         obstack_alloc (&unit->objfile->objfile_obstack,
1792                        sizeof (struct dwarf2_fde));
1793       fde->cie = find_cie (unit, cie_pointer);
1794       if (fde->cie == NULL)
1795         {
1796           decode_frame_entry (unit, unit->dwarf_frame_buffer + cie_pointer,
1797                               eh_frame_p);
1798           fde->cie = find_cie (unit, cie_pointer);
1799         }
1800
1801       gdb_assert (fde->cie != NULL);
1802
1803       fde->initial_location =
1804         read_encoded_value (unit, fde->cie->encoding, buf, &bytes_read);
1805       buf += bytes_read;
1806
1807       fde->address_range =
1808         read_encoded_value (unit, fde->cie->encoding & 0x0f, buf, &bytes_read);
1809       buf += bytes_read;
1810
1811       /* A 'z' augmentation in the CIE implies the presence of an
1812          augmentation field in the FDE as well.  The only thing known
1813          to be in here at present is the LSDA entry for EH.  So we
1814          can skip the whole thing.  */
1815       if (fde->cie->saw_z_augmentation)
1816         {
1817           ULONGEST length;
1818
1819           length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1820           buf += bytes_read + length;
1821           if (buf > end)
1822             return NULL;
1823         }
1824
1825       fde->instructions = buf;
1826       fde->end = end;
1827
1828       fde->eh_frame_p = eh_frame_p;
1829
1830       add_fde (unit, fde);
1831     }
1832
1833   return end;
1834 }
1835
1836 /* Read a CIE or FDE in BUF and decode it.  */
1837 static gdb_byte *
1838 decode_frame_entry (struct comp_unit *unit, gdb_byte *start, int eh_frame_p)
1839 {
1840   enum { NONE, ALIGN4, ALIGN8, FAIL } workaround = NONE;
1841   gdb_byte *ret;
1842   const char *msg;
1843   ptrdiff_t start_offset;
1844
1845   while (1)
1846     {
1847       ret = decode_frame_entry_1 (unit, start, eh_frame_p);
1848       if (ret != NULL)
1849         break;
1850
1851       /* We have corrupt input data of some form.  */
1852
1853       /* ??? Try, weakly, to work around compiler/assembler/linker bugs
1854          and mismatches wrt padding and alignment of debug sections.  */
1855       /* Note that there is no requirement in the standard for any
1856          alignment at all in the frame unwind sections.  Testing for
1857          alignment before trying to interpret data would be incorrect.
1858
1859          However, GCC traditionally arranged for frame sections to be
1860          sized such that the FDE length and CIE fields happen to be
1861          aligned (in theory, for performance).  This, unfortunately,
1862          was done with .align directives, which had the side effect of
1863          forcing the section to be aligned by the linker.
1864
1865          This becomes a problem when you have some other producer that
1866          creates frame sections that are not as strictly aligned.  That
1867          produces a hole in the frame info that gets filled by the
1868          linker with zeros.
1869
1870          The GCC behaviour is arguably a bug, but it's effectively now
1871          part of the ABI, so we're now stuck with it, at least at the
1872          object file level.  A smart linker may decide, in the process
1873          of compressing duplicate CIE information, that it can rewrite
1874          the entire output section without this extra padding.  */
1875
1876       start_offset = start - unit->dwarf_frame_buffer;
1877       if (workaround < ALIGN4 && (start_offset & 3) != 0)
1878         {
1879           start += 4 - (start_offset & 3);
1880           workaround = ALIGN4;
1881           continue;
1882         }
1883       if (workaround < ALIGN8 && (start_offset & 7) != 0)
1884         {
1885           start += 8 - (start_offset & 7);
1886           workaround = ALIGN8;
1887           continue;
1888         }
1889
1890       /* Nothing left to try.  Arrange to return as if we've consumed
1891          the entire input section.  Hopefully we'll get valid info from
1892          the other of .debug_frame/.eh_frame.  */
1893       workaround = FAIL;
1894       ret = unit->dwarf_frame_buffer + unit->dwarf_frame_size;
1895       break;
1896     }
1897
1898   switch (workaround)
1899     {
1900     case NONE:
1901       break;
1902
1903     case ALIGN4:
1904       complaint (&symfile_complaints,
1905                  _("Corrupt data in %s:%s; align 4 workaround apparently succeeded"),
1906                  unit->dwarf_frame_section->owner->filename,
1907                  unit->dwarf_frame_section->name);
1908       break;
1909
1910     case ALIGN8:
1911       complaint (&symfile_complaints,
1912                  _("Corrupt data in %s:%s; align 8 workaround apparently succeeded"),
1913                  unit->dwarf_frame_section->owner->filename,
1914                  unit->dwarf_frame_section->name);
1915       break;
1916
1917     default:
1918       complaint (&symfile_complaints,
1919                  _("Corrupt data in %s:%s"),
1920                  unit->dwarf_frame_section->owner->filename,
1921                  unit->dwarf_frame_section->name);
1922       break;
1923     }
1924
1925   return ret;
1926 }
1927 \f
1928
1929 /* FIXME: kettenis/20030504: This still needs to be integrated with
1930    dwarf2read.c in a better way.  */
1931
1932 /* Imported from dwarf2read.c.  */
1933 extern asection *dwarf_frame_section;
1934 extern asection *dwarf_eh_frame_section;
1935
1936 /* Imported from dwarf2read.c.  */
1937 extern gdb_byte *dwarf2_read_section (struct objfile *objfile, asection *sectp);
1938
1939 void
1940 dwarf2_build_frame_info (struct objfile *objfile)
1941 {
1942   struct comp_unit unit;
1943   gdb_byte *frame_ptr;
1944
1945   /* Build a minimal decoding of the DWARF2 compilation unit.  */
1946   unit.abfd = objfile->obfd;
1947   unit.objfile = objfile;
1948   unit.dbase = 0;
1949   unit.tbase = 0;
1950
1951   /* First add the information from the .eh_frame section.  That way,
1952      the FDEs from that section are searched last.  */
1953   if (dwarf_eh_frame_section)
1954     {
1955       asection *got, *txt;
1956
1957       unit.cie = NULL;
1958       unit.dwarf_frame_buffer = dwarf2_read_section (objfile,
1959                                                      dwarf_eh_frame_section);
1960
1961       unit.dwarf_frame_size = bfd_get_section_size (dwarf_eh_frame_section);
1962       unit.dwarf_frame_section = dwarf_eh_frame_section;
1963
1964       /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
1965          that is used for the i386/amd64 target, which currently is
1966          the only target in GCC that supports/uses the
1967          DW_EH_PE_datarel encoding.  */
1968       got = bfd_get_section_by_name (unit.abfd, ".got");
1969       if (got)
1970         unit.dbase = got->vma;
1971
1972       /* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64
1973          so far.  */
1974       txt = bfd_get_section_by_name (unit.abfd, ".text");
1975       if (txt)
1976         unit.tbase = txt->vma;
1977
1978       frame_ptr = unit.dwarf_frame_buffer;
1979       while (frame_ptr < unit.dwarf_frame_buffer + unit.dwarf_frame_size)
1980         frame_ptr = decode_frame_entry (&unit, frame_ptr, 1);
1981     }
1982
1983   if (dwarf_frame_section)
1984     {
1985       unit.cie = NULL;
1986       unit.dwarf_frame_buffer = dwarf2_read_section (objfile,
1987                                                      dwarf_frame_section);
1988       unit.dwarf_frame_size = bfd_get_section_size (dwarf_frame_section);
1989       unit.dwarf_frame_section = dwarf_frame_section;
1990
1991       frame_ptr = unit.dwarf_frame_buffer;
1992       while (frame_ptr < unit.dwarf_frame_buffer + unit.dwarf_frame_size)
1993         frame_ptr = decode_frame_entry (&unit, frame_ptr, 0);
1994     }
1995 }
1996
1997 /* Provide a prototype to silence -Wmissing-prototypes.  */
1998 void _initialize_dwarf2_frame (void);
1999
2000 void
2001 _initialize_dwarf2_frame (void)
2002 {
2003   dwarf2_frame_data = gdbarch_data_register_pre_init (dwarf2_frame_init);
2004   dwarf2_frame_objfile_data = register_objfile_data ();
2005 }