2011-07-15 Fawzi Mohamed <fawzi.mohamed@nokia.com>
[external/binutils.git] / gdb / dwarf2-frame.c
1 /* Frame unwinder for frames with DWARF Call Frame Information.
2
3    Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011
4    Free Software Foundation, Inc.
5
6    Contributed by Mark Kettenis.
7
8    This file is part of GDB.
9
10    This program is free software; you can redistribute it and/or modify
11    it under the terms of the GNU General Public License as published by
12    the Free Software Foundation; either version 3 of the License, or
13    (at your option) any later version.
14
15    This program is distributed in the hope that it will be useful,
16    but WITHOUT ANY WARRANTY; without even the implied warranty of
17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18    GNU General Public License for more details.
19
20    You should have received a copy of the GNU General Public License
21    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
22
23 #include "defs.h"
24 #include "dwarf2expr.h"
25 #include "dwarf2.h"
26 #include "frame.h"
27 #include "frame-base.h"
28 #include "frame-unwind.h"
29 #include "gdbcore.h"
30 #include "gdbtypes.h"
31 #include "symtab.h"
32 #include "objfiles.h"
33 #include "regcache.h"
34 #include "value.h"
35
36 #include "gdb_assert.h"
37 #include "gdb_string.h"
38
39 #include "complaints.h"
40 #include "dwarf2-frame.h"
41 #include "ax.h"
42 #include "dwarf2loc.h"
43 #include "exceptions.h"
44
45 struct comp_unit;
46
47 /* Call Frame Information (CFI).  */
48
49 /* Common Information Entry (CIE).  */
50
51 struct dwarf2_cie
52 {
53   /* Computation Unit for this CIE.  */
54   struct comp_unit *unit;
55
56   /* Offset into the .debug_frame section where this CIE was found.
57      Used to identify this CIE.  */
58   ULONGEST cie_pointer;
59
60   /* Constant that is factored out of all advance location
61      instructions.  */
62   ULONGEST code_alignment_factor;
63
64   /* Constants that is factored out of all offset instructions.  */
65   LONGEST data_alignment_factor;
66
67   /* Return address column.  */
68   ULONGEST return_address_register;
69
70   /* Instruction sequence to initialize a register set.  */
71   gdb_byte *initial_instructions;
72   gdb_byte *end;
73
74   /* Saved augmentation, in case it's needed later.  */
75   char *augmentation;
76
77   /* Encoding of addresses.  */
78   gdb_byte encoding;
79
80   /* Target address size in bytes.  */
81   int addr_size;
82
83   /* Target pointer size in bytes.  */
84   int ptr_size;
85
86   /* True if a 'z' augmentation existed.  */
87   unsigned char saw_z_augmentation;
88
89   /* True if an 'S' augmentation existed.  */
90   unsigned char signal_frame;
91
92   /* The version recorded in the CIE.  */
93   unsigned char version;
94
95   /* The segment size.  */
96   unsigned char segment_size;
97 };
98
99 struct dwarf2_cie_table
100 {
101   int num_entries;
102   struct dwarf2_cie **entries;
103 };
104
105 /* Frame Description Entry (FDE).  */
106
107 struct dwarf2_fde
108 {
109   /* CIE for this FDE.  */
110   struct dwarf2_cie *cie;
111
112   /* First location associated with this FDE.  */
113   CORE_ADDR initial_location;
114
115   /* Number of bytes of program instructions described by this FDE.  */
116   CORE_ADDR address_range;
117
118   /* Instruction sequence.  */
119   gdb_byte *instructions;
120   gdb_byte *end;
121
122   /* True if this FDE is read from a .eh_frame instead of a .debug_frame
123      section.  */
124   unsigned char eh_frame_p;
125 };
126
127 struct dwarf2_fde_table
128 {
129   int num_entries;
130   struct dwarf2_fde **entries;
131 };
132
133 /* A minimal decoding of DWARF2 compilation units.  We only decode
134    what's needed to get to the call frame information.  */
135
136 struct comp_unit
137 {
138   /* Keep the bfd convenient.  */
139   bfd *abfd;
140
141   struct objfile *objfile;
142
143   /* Pointer to the .debug_frame section loaded into memory.  */
144   gdb_byte *dwarf_frame_buffer;
145
146   /* Length of the loaded .debug_frame section.  */
147   bfd_size_type dwarf_frame_size;
148
149   /* Pointer to the .debug_frame section.  */
150   asection *dwarf_frame_section;
151
152   /* Base for DW_EH_PE_datarel encodings.  */
153   bfd_vma dbase;
154
155   /* Base for DW_EH_PE_textrel encodings.  */
156   bfd_vma tbase;
157 };
158
159 static struct dwarf2_fde *dwarf2_frame_find_fde (CORE_ADDR *pc,
160                                                  CORE_ADDR *out_offset);
161
162 static int dwarf2_frame_adjust_regnum (struct gdbarch *gdbarch, int regnum,
163                                        int eh_frame_p);
164
165 static CORE_ADDR read_encoded_value (struct comp_unit *unit, gdb_byte encoding,
166                                      int ptr_len, const gdb_byte *buf,
167                                      unsigned int *bytes_read_ptr,
168                                      CORE_ADDR func_base);
169 \f
170
171 /* Structure describing a frame state.  */
172
173 struct dwarf2_frame_state
174 {
175   /* Each register save state can be described in terms of a CFA slot,
176      another register, or a location expression.  */
177   struct dwarf2_frame_state_reg_info
178   {
179     struct dwarf2_frame_state_reg *reg;
180     int num_regs;
181
182     LONGEST cfa_offset;
183     ULONGEST cfa_reg;
184     enum {
185       CFA_UNSET,
186       CFA_REG_OFFSET,
187       CFA_EXP
188     } cfa_how;
189     const gdb_byte *cfa_exp;
190
191     /* Used to implement DW_CFA_remember_state.  */
192     struct dwarf2_frame_state_reg_info *prev;
193   } regs;
194
195   /* The PC described by the current frame state.  */
196   CORE_ADDR pc;
197
198   /* Initial register set from the CIE.
199      Used to implement DW_CFA_restore.  */
200   struct dwarf2_frame_state_reg_info initial;
201
202   /* The information we care about from the CIE.  */
203   LONGEST data_align;
204   ULONGEST code_align;
205   ULONGEST retaddr_column;
206
207   /* Flags for known producer quirks.  */
208
209   /* The ARM compilers, in DWARF2 mode, assume that DW_CFA_def_cfa
210      and DW_CFA_def_cfa_offset takes a factored offset.  */
211   int armcc_cfa_offsets_sf;
212
213   /* The ARM compilers, in DWARF2 or DWARF3 mode, may assume that
214      the CFA is defined as REG - OFFSET rather than REG + OFFSET.  */
215   int armcc_cfa_offsets_reversed;
216 };
217
218 /* Store the length the expression for the CFA in the `cfa_reg' field,
219    which is unused in that case.  */
220 #define cfa_exp_len cfa_reg
221
222 /* Assert that the register set RS is large enough to store gdbarch_num_regs
223    columns.  If necessary, enlarge the register set.  */
224
225 static void
226 dwarf2_frame_state_alloc_regs (struct dwarf2_frame_state_reg_info *rs,
227                                int num_regs)
228 {
229   size_t size = sizeof (struct dwarf2_frame_state_reg);
230
231   if (num_regs <= rs->num_regs)
232     return;
233
234   rs->reg = (struct dwarf2_frame_state_reg *)
235     xrealloc (rs->reg, num_regs * size);
236
237   /* Initialize newly allocated registers.  */
238   memset (rs->reg + rs->num_regs, 0, (num_regs - rs->num_regs) * size);
239   rs->num_regs = num_regs;
240 }
241
242 /* Copy the register columns in register set RS into newly allocated
243    memory and return a pointer to this newly created copy.  */
244
245 static struct dwarf2_frame_state_reg *
246 dwarf2_frame_state_copy_regs (struct dwarf2_frame_state_reg_info *rs)
247 {
248   size_t size = rs->num_regs * sizeof (struct dwarf2_frame_state_reg);
249   struct dwarf2_frame_state_reg *reg;
250
251   reg = (struct dwarf2_frame_state_reg *) xmalloc (size);
252   memcpy (reg, rs->reg, size);
253
254   return reg;
255 }
256
257 /* Release the memory allocated to register set RS.  */
258
259 static void
260 dwarf2_frame_state_free_regs (struct dwarf2_frame_state_reg_info *rs)
261 {
262   if (rs)
263     {
264       dwarf2_frame_state_free_regs (rs->prev);
265
266       xfree (rs->reg);
267       xfree (rs);
268     }
269 }
270
271 /* Release the memory allocated to the frame state FS.  */
272
273 static void
274 dwarf2_frame_state_free (void *p)
275 {
276   struct dwarf2_frame_state *fs = p;
277
278   dwarf2_frame_state_free_regs (fs->initial.prev);
279   dwarf2_frame_state_free_regs (fs->regs.prev);
280   xfree (fs->initial.reg);
281   xfree (fs->regs.reg);
282   xfree (fs);
283 }
284 \f
285
286 /* Helper functions for execute_stack_op.  */
287
288 static CORE_ADDR
289 read_reg (void *baton, int reg)
290 {
291   struct frame_info *this_frame = (struct frame_info *) baton;
292   struct gdbarch *gdbarch = get_frame_arch (this_frame);
293   int regnum;
294   gdb_byte *buf;
295
296   regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, reg);
297
298   buf = alloca (register_size (gdbarch, regnum));
299   get_frame_register (this_frame, regnum, buf);
300
301   /* Convert the register to an integer.  This returns a LONGEST
302      rather than a CORE_ADDR, but unpack_pointer does the same thing
303      under the covers, and this makes more sense for non-pointer
304      registers.  Maybe read_reg and the associated interfaces should
305      deal with "struct value" instead of CORE_ADDR.  */
306   return unpack_long (register_type (gdbarch, regnum), buf);
307 }
308
309 static void
310 read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
311 {
312   read_memory (addr, buf, len);
313 }
314
315 static void
316 no_get_frame_base (void *baton, const gdb_byte **start, size_t *length)
317 {
318   internal_error (__FILE__, __LINE__,
319                   _("Support for DW_OP_fbreg is unimplemented"));
320 }
321
322 /* Helper function for execute_stack_op.  */
323
324 static CORE_ADDR
325 no_get_frame_cfa (void *baton)
326 {
327   internal_error (__FILE__, __LINE__,
328                   _("Support for DW_OP_call_frame_cfa is unimplemented"));
329 }
330
331 /* Helper function for execute_stack_op.  */
332
333 static CORE_ADDR
334 no_get_frame_pc (void *baton)
335 {
336   internal_error (__FILE__, __LINE__, _("\
337 Support for DW_OP_GNU_implicit_pointer is unimplemented"));
338 }
339
340 static CORE_ADDR
341 no_get_tls_address (void *baton, CORE_ADDR offset)
342 {
343   internal_error (__FILE__, __LINE__, _("\
344 Support for DW_OP_GNU_push_tls_address is unimplemented"));
345 }
346
347 /* Helper function for execute_stack_op.  */
348
349 static void
350 no_dwarf_call (struct dwarf_expr_context *ctx, size_t die_offset)
351 {
352   internal_error (__FILE__, __LINE__,
353                   _("Support for DW_OP_call* is invalid in CFI"));
354 }
355
356 /* Helper function for execute_stack_op.  */
357
358 static struct type *
359 no_base_type (struct dwarf_expr_context *ctx, size_t die)
360 {
361   error (_("Support for typed DWARF is not supported in CFI"));
362 }
363
364 /* Execute the required actions for both the DW_CFA_restore and
365 DW_CFA_restore_extended instructions.  */
366 static void
367 dwarf2_restore_rule (struct gdbarch *gdbarch, ULONGEST reg_num,
368                      struct dwarf2_frame_state *fs, int eh_frame_p)
369 {
370   ULONGEST reg;
371
372   gdb_assert (fs->initial.reg);
373   reg = dwarf2_frame_adjust_regnum (gdbarch, reg_num, eh_frame_p);
374   dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
375
376   /* Check if this register was explicitly initialized in the
377   CIE initial instructions.  If not, default the rule to
378   UNSPECIFIED.  */
379   if (reg < fs->initial.num_regs)
380     fs->regs.reg[reg] = fs->initial.reg[reg];
381   else
382     fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNSPECIFIED;
383
384   if (fs->regs.reg[reg].how == DWARF2_FRAME_REG_UNSPECIFIED)
385     complaint (&symfile_complaints, _("\
386 incomplete CFI data; DW_CFA_restore unspecified\n\
387 register %s (#%d) at %s"),
388                        gdbarch_register_name
389                        (gdbarch, gdbarch_dwarf2_reg_to_regnum (gdbarch, reg)),
390                        gdbarch_dwarf2_reg_to_regnum (gdbarch, reg),
391                        paddress (gdbarch, fs->pc));
392 }
393
394 static CORE_ADDR
395 execute_stack_op (const gdb_byte *exp, ULONGEST len, int addr_size,
396                   CORE_ADDR offset, struct frame_info *this_frame,
397                   CORE_ADDR initial, int initial_in_stack_memory)
398 {
399   struct dwarf_expr_context *ctx;
400   CORE_ADDR result;
401   struct cleanup *old_chain;
402
403   ctx = new_dwarf_expr_context ();
404   old_chain = make_cleanup_free_dwarf_expr_context (ctx);
405   make_cleanup_value_free_to_mark (value_mark ());
406
407   ctx->gdbarch = get_frame_arch (this_frame);
408   ctx->addr_size = addr_size;
409   ctx->offset = offset;
410   ctx->baton = this_frame;
411   ctx->read_reg = read_reg;
412   ctx->read_mem = read_mem;
413   ctx->get_frame_base = no_get_frame_base;
414   ctx->get_frame_cfa = no_get_frame_cfa;
415   ctx->get_frame_pc = no_get_frame_pc;
416   ctx->get_tls_address = no_get_tls_address;
417   ctx->dwarf_call = no_dwarf_call;
418   ctx->get_base_type = no_base_type;
419
420   dwarf_expr_push_address (ctx, initial, initial_in_stack_memory);
421   dwarf_expr_eval (ctx, exp, len);
422
423   if (ctx->location == DWARF_VALUE_MEMORY)
424     result = dwarf_expr_fetch_address (ctx, 0);
425   else if (ctx->location == DWARF_VALUE_REGISTER)
426     result = read_reg (this_frame, value_as_long (dwarf_expr_fetch (ctx, 0)));
427   else
428     {
429       /* This is actually invalid DWARF, but if we ever do run across
430          it somehow, we might as well support it.  So, instead, report
431          it as unimplemented.  */
432       error (_("\
433 Not implemented: computing unwound register using explicit value operator"));
434     }
435
436   do_cleanups (old_chain);
437
438   return result;
439 }
440 \f
441
442 static void
443 execute_cfa_program (struct dwarf2_fde *fde, const gdb_byte *insn_ptr,
444                      const gdb_byte *insn_end, struct gdbarch *gdbarch,
445                      CORE_ADDR pc, struct dwarf2_frame_state *fs)
446 {
447   int eh_frame_p = fde->eh_frame_p;
448   int bytes_read;
449   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
450
451   while (insn_ptr < insn_end && fs->pc <= pc)
452     {
453       gdb_byte insn = *insn_ptr++;
454       ULONGEST utmp, reg;
455       LONGEST offset;
456
457       if ((insn & 0xc0) == DW_CFA_advance_loc)
458         fs->pc += (insn & 0x3f) * fs->code_align;
459       else if ((insn & 0xc0) == DW_CFA_offset)
460         {
461           reg = insn & 0x3f;
462           reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
463           insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
464           offset = utmp * fs->data_align;
465           dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
466           fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
467           fs->regs.reg[reg].loc.offset = offset;
468         }
469       else if ((insn & 0xc0) == DW_CFA_restore)
470         {
471           reg = insn & 0x3f;
472           dwarf2_restore_rule (gdbarch, reg, fs, eh_frame_p);
473         }
474       else
475         {
476           switch (insn)
477             {
478             case DW_CFA_set_loc:
479               fs->pc = read_encoded_value (fde->cie->unit, fde->cie->encoding,
480                                            fde->cie->ptr_size, insn_ptr,
481                                            &bytes_read, fde->initial_location);
482               /* Apply the objfile offset for relocatable objects.  */
483               fs->pc += ANOFFSET (fde->cie->unit->objfile->section_offsets,
484                                   SECT_OFF_TEXT (fde->cie->unit->objfile));
485               insn_ptr += bytes_read;
486               break;
487
488             case DW_CFA_advance_loc1:
489               utmp = extract_unsigned_integer (insn_ptr, 1, byte_order);
490               fs->pc += utmp * fs->code_align;
491               insn_ptr++;
492               break;
493             case DW_CFA_advance_loc2:
494               utmp = extract_unsigned_integer (insn_ptr, 2, byte_order);
495               fs->pc += utmp * fs->code_align;
496               insn_ptr += 2;
497               break;
498             case DW_CFA_advance_loc4:
499               utmp = extract_unsigned_integer (insn_ptr, 4, byte_order);
500               fs->pc += utmp * fs->code_align;
501               insn_ptr += 4;
502               break;
503
504             case DW_CFA_offset_extended:
505               insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
506               reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
507               insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
508               offset = utmp * fs->data_align;
509               dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
510               fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
511               fs->regs.reg[reg].loc.offset = offset;
512               break;
513
514             case DW_CFA_restore_extended:
515               insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
516               dwarf2_restore_rule (gdbarch, reg, fs, eh_frame_p);
517               break;
518
519             case DW_CFA_undefined:
520               insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
521               reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
522               dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
523               fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNDEFINED;
524               break;
525
526             case DW_CFA_same_value:
527               insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
528               reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
529               dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
530               fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAME_VALUE;
531               break;
532
533             case DW_CFA_register:
534               insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
535               reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
536               insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
537               utmp = dwarf2_frame_adjust_regnum (gdbarch, utmp, eh_frame_p);
538               dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
539               fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
540               fs->regs.reg[reg].loc.reg = utmp;
541               break;
542
543             case DW_CFA_remember_state:
544               {
545                 struct dwarf2_frame_state_reg_info *new_rs;
546
547                 new_rs = XMALLOC (struct dwarf2_frame_state_reg_info);
548                 *new_rs = fs->regs;
549                 fs->regs.reg = dwarf2_frame_state_copy_regs (&fs->regs);
550                 fs->regs.prev = new_rs;
551               }
552               break;
553
554             case DW_CFA_restore_state:
555               {
556                 struct dwarf2_frame_state_reg_info *old_rs = fs->regs.prev;
557
558                 if (old_rs == NULL)
559                   {
560                     complaint (&symfile_complaints, _("\
561 bad CFI data; mismatched DW_CFA_restore_state at %s"),
562                                paddress (gdbarch, fs->pc));
563                   }
564                 else
565                   {
566                     xfree (fs->regs.reg);
567                     fs->regs = *old_rs;
568                     xfree (old_rs);
569                   }
570               }
571               break;
572
573             case DW_CFA_def_cfa:
574               insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->regs.cfa_reg);
575               insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
576
577               if (fs->armcc_cfa_offsets_sf)
578                 utmp *= fs->data_align;
579
580               fs->regs.cfa_offset = utmp;
581               fs->regs.cfa_how = CFA_REG_OFFSET;
582               break;
583
584             case DW_CFA_def_cfa_register:
585               insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->regs.cfa_reg);
586               fs->regs.cfa_reg = dwarf2_frame_adjust_regnum (gdbarch,
587                                                              fs->regs.cfa_reg,
588                                                              eh_frame_p);
589               fs->regs.cfa_how = CFA_REG_OFFSET;
590               break;
591
592             case DW_CFA_def_cfa_offset:
593               insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
594
595               if (fs->armcc_cfa_offsets_sf)
596                 utmp *= fs->data_align;
597
598               fs->regs.cfa_offset = utmp;
599               /* cfa_how deliberately not set.  */
600               break;
601
602             case DW_CFA_nop:
603               break;
604
605             case DW_CFA_def_cfa_expression:
606               insn_ptr = read_uleb128 (insn_ptr, insn_end,
607                                        &fs->regs.cfa_exp_len);
608               fs->regs.cfa_exp = insn_ptr;
609               fs->regs.cfa_how = CFA_EXP;
610               insn_ptr += fs->regs.cfa_exp_len;
611               break;
612
613             case DW_CFA_expression:
614               insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
615               reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
616               dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
617               insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
618               fs->regs.reg[reg].loc.exp = insn_ptr;
619               fs->regs.reg[reg].exp_len = utmp;
620               fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_EXP;
621               insn_ptr += utmp;
622               break;
623
624             case DW_CFA_offset_extended_sf:
625               insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
626               reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
627               insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
628               offset *= fs->data_align;
629               dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
630               fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
631               fs->regs.reg[reg].loc.offset = offset;
632               break;
633
634             case DW_CFA_val_offset:
635               insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
636               dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
637               insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
638               offset = utmp * fs->data_align;
639               fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_OFFSET;
640               fs->regs.reg[reg].loc.offset = offset;
641               break;
642
643             case DW_CFA_val_offset_sf:
644               insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
645               dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
646               insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
647               offset *= fs->data_align;
648               fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_OFFSET;
649               fs->regs.reg[reg].loc.offset = offset;
650               break;
651
652             case DW_CFA_val_expression:
653               insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
654               dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
655               insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
656               fs->regs.reg[reg].loc.exp = insn_ptr;
657               fs->regs.reg[reg].exp_len = utmp;
658               fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_EXP;
659               insn_ptr += utmp;
660               break;
661
662             case DW_CFA_def_cfa_sf:
663               insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->regs.cfa_reg);
664               fs->regs.cfa_reg = dwarf2_frame_adjust_regnum (gdbarch,
665                                                              fs->regs.cfa_reg,
666                                                              eh_frame_p);
667               insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
668               fs->regs.cfa_offset = offset * fs->data_align;
669               fs->regs.cfa_how = CFA_REG_OFFSET;
670               break;
671
672             case DW_CFA_def_cfa_offset_sf:
673               insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
674               fs->regs.cfa_offset = offset * fs->data_align;
675               /* cfa_how deliberately not set.  */
676               break;
677
678             case DW_CFA_GNU_window_save:
679               /* This is SPARC-specific code, and contains hard-coded
680                  constants for the register numbering scheme used by
681                  GCC.  Rather than having a architecture-specific
682                  operation that's only ever used by a single
683                  architecture, we provide the implementation here.
684                  Incidentally that's what GCC does too in its
685                  unwinder.  */
686               {
687                 int size = register_size (gdbarch, 0);
688
689                 dwarf2_frame_state_alloc_regs (&fs->regs, 32);
690                 for (reg = 8; reg < 16; reg++)
691                   {
692                     fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
693                     fs->regs.reg[reg].loc.reg = reg + 16;
694                   }
695                 for (reg = 16; reg < 32; reg++)
696                   {
697                     fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
698                     fs->regs.reg[reg].loc.offset = (reg - 16) * size;
699                   }
700               }
701               break;
702
703             case DW_CFA_GNU_args_size:
704               /* Ignored.  */
705               insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
706               break;
707
708             case DW_CFA_GNU_negative_offset_extended:
709               insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
710               reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
711               insn_ptr = read_uleb128 (insn_ptr, insn_end, &offset);
712               offset *= fs->data_align;
713               dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
714               fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
715               fs->regs.reg[reg].loc.offset = -offset;
716               break;
717
718             default:
719               internal_error (__FILE__, __LINE__,
720                               _("Unknown CFI encountered."));
721             }
722         }
723     }
724
725   /* Don't allow remember/restore between CIE and FDE programs.  */
726   dwarf2_frame_state_free_regs (fs->regs.prev);
727   fs->regs.prev = NULL;
728 }
729 \f
730
731 /* Architecture-specific operations.  */
732
733 /* Per-architecture data key.  */
734 static struct gdbarch_data *dwarf2_frame_data;
735
736 struct dwarf2_frame_ops
737 {
738   /* Pre-initialize the register state REG for register REGNUM.  */
739   void (*init_reg) (struct gdbarch *, int, struct dwarf2_frame_state_reg *,
740                     struct frame_info *);
741
742   /* Check whether the THIS_FRAME is a signal trampoline.  */
743   int (*signal_frame_p) (struct gdbarch *, struct frame_info *);
744
745   /* Convert .eh_frame register number to DWARF register number, or
746      adjust .debug_frame register number.  */
747   int (*adjust_regnum) (struct gdbarch *, int, int);
748 };
749
750 /* Default architecture-specific register state initialization
751    function.  */
752
753 static void
754 dwarf2_frame_default_init_reg (struct gdbarch *gdbarch, int regnum,
755                                struct dwarf2_frame_state_reg *reg,
756                                struct frame_info *this_frame)
757 {
758   /* If we have a register that acts as a program counter, mark it as
759      a destination for the return address.  If we have a register that
760      serves as the stack pointer, arrange for it to be filled with the
761      call frame address (CFA).  The other registers are marked as
762      unspecified.
763
764      We copy the return address to the program counter, since many
765      parts in GDB assume that it is possible to get the return address
766      by unwinding the program counter register.  However, on ISA's
767      with a dedicated return address register, the CFI usually only
768      contains information to unwind that return address register.
769
770      The reason we're treating the stack pointer special here is
771      because in many cases GCC doesn't emit CFI for the stack pointer
772      and implicitly assumes that it is equal to the CFA.  This makes
773      some sense since the DWARF specification (version 3, draft 8,
774      p. 102) says that:
775
776      "Typically, the CFA is defined to be the value of the stack
777      pointer at the call site in the previous frame (which may be
778      different from its value on entry to the current frame)."
779
780      However, this isn't true for all platforms supported by GCC
781      (e.g. IBM S/390 and zSeries).  Those architectures should provide
782      their own architecture-specific initialization function.  */
783
784   if (regnum == gdbarch_pc_regnum (gdbarch))
785     reg->how = DWARF2_FRAME_REG_RA;
786   else if (regnum == gdbarch_sp_regnum (gdbarch))
787     reg->how = DWARF2_FRAME_REG_CFA;
788 }
789
790 /* Return a default for the architecture-specific operations.  */
791
792 static void *
793 dwarf2_frame_init (struct obstack *obstack)
794 {
795   struct dwarf2_frame_ops *ops;
796   
797   ops = OBSTACK_ZALLOC (obstack, struct dwarf2_frame_ops);
798   ops->init_reg = dwarf2_frame_default_init_reg;
799   return ops;
800 }
801
802 /* Set the architecture-specific register state initialization
803    function for GDBARCH to INIT_REG.  */
804
805 void
806 dwarf2_frame_set_init_reg (struct gdbarch *gdbarch,
807                            void (*init_reg) (struct gdbarch *, int,
808                                              struct dwarf2_frame_state_reg *,
809                                              struct frame_info *))
810 {
811   struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
812
813   ops->init_reg = init_reg;
814 }
815
816 /* Pre-initialize the register state REG for register REGNUM.  */
817
818 static void
819 dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
820                        struct dwarf2_frame_state_reg *reg,
821                        struct frame_info *this_frame)
822 {
823   struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
824
825   ops->init_reg (gdbarch, regnum, reg, this_frame);
826 }
827
828 /* Set the architecture-specific signal trampoline recognition
829    function for GDBARCH to SIGNAL_FRAME_P.  */
830
831 void
832 dwarf2_frame_set_signal_frame_p (struct gdbarch *gdbarch,
833                                  int (*signal_frame_p) (struct gdbarch *,
834                                                         struct frame_info *))
835 {
836   struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
837
838   ops->signal_frame_p = signal_frame_p;
839 }
840
841 /* Query the architecture-specific signal frame recognizer for
842    THIS_FRAME.  */
843
844 static int
845 dwarf2_frame_signal_frame_p (struct gdbarch *gdbarch,
846                              struct frame_info *this_frame)
847 {
848   struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
849
850   if (ops->signal_frame_p == NULL)
851     return 0;
852   return ops->signal_frame_p (gdbarch, this_frame);
853 }
854
855 /* Set the architecture-specific adjustment of .eh_frame and .debug_frame
856    register numbers.  */
857
858 void
859 dwarf2_frame_set_adjust_regnum (struct gdbarch *gdbarch,
860                                 int (*adjust_regnum) (struct gdbarch *,
861                                                       int, int))
862 {
863   struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
864
865   ops->adjust_regnum = adjust_regnum;
866 }
867
868 /* Translate a .eh_frame register to DWARF register, or adjust a .debug_frame
869    register.  */
870
871 static int
872 dwarf2_frame_adjust_regnum (struct gdbarch *gdbarch,
873                             int regnum, int eh_frame_p)
874 {
875   struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
876
877   if (ops->adjust_regnum == NULL)
878     return regnum;
879   return ops->adjust_regnum (gdbarch, regnum, eh_frame_p);
880 }
881
882 static void
883 dwarf2_frame_find_quirks (struct dwarf2_frame_state *fs,
884                           struct dwarf2_fde *fde)
885 {
886   struct symtab *s;
887
888   s = find_pc_symtab (fs->pc);
889   if (s == NULL)
890     return;
891
892   if (producer_is_realview (s->producer))
893     {
894       if (fde->cie->version == 1)
895         fs->armcc_cfa_offsets_sf = 1;
896
897       if (fde->cie->version == 1)
898         fs->armcc_cfa_offsets_reversed = 1;
899
900       /* The reversed offset problem is present in some compilers
901          using DWARF3, but it was eventually fixed.  Check the ARM
902          defined augmentations, which are in the format "armcc" followed
903          by a list of one-character options.  The "+" option means
904          this problem is fixed (no quirk needed).  If the armcc
905          augmentation is missing, the quirk is needed.  */
906       if (fde->cie->version == 3
907           && (strncmp (fde->cie->augmentation, "armcc", 5) != 0
908               || strchr (fde->cie->augmentation + 5, '+') == NULL))
909         fs->armcc_cfa_offsets_reversed = 1;
910
911       return;
912     }
913 }
914 \f
915
916 void
917 dwarf2_compile_cfa_to_ax (struct agent_expr *expr, struct axs_value *loc,
918                           struct gdbarch *gdbarch,
919                           CORE_ADDR pc,
920                           struct dwarf2_per_cu_data *data)
921 {
922   const int num_regs = gdbarch_num_regs (gdbarch)
923                        + gdbarch_num_pseudo_regs (gdbarch);
924   struct dwarf2_fde *fde;
925   CORE_ADDR text_offset, cfa;
926   struct dwarf2_frame_state fs;
927   int addr_size;
928
929   memset (&fs, 0, sizeof (struct dwarf2_frame_state));
930
931   fs.pc = pc;
932
933   /* Find the correct FDE.  */
934   fde = dwarf2_frame_find_fde (&fs.pc, &text_offset);
935   if (fde == NULL)
936     error (_("Could not compute CFA; needed to translate this expression"));
937
938   /* Extract any interesting information from the CIE.  */
939   fs.data_align = fde->cie->data_alignment_factor;
940   fs.code_align = fde->cie->code_alignment_factor;
941   fs.retaddr_column = fde->cie->return_address_register;
942   addr_size = fde->cie->addr_size;
943
944   /* Check for "quirks" - known bugs in producers.  */
945   dwarf2_frame_find_quirks (&fs, fde);
946
947   /* First decode all the insns in the CIE.  */
948   execute_cfa_program (fde, fde->cie->initial_instructions,
949                        fde->cie->end, gdbarch, pc, &fs);
950
951   /* Save the initialized register set.  */
952   fs.initial = fs.regs;
953   fs.initial.reg = dwarf2_frame_state_copy_regs (&fs.regs);
954
955   /* Then decode the insns in the FDE up to our target PC.  */
956   execute_cfa_program (fde, fde->instructions, fde->end, gdbarch, pc, &fs);
957
958   /* Calculate the CFA.  */
959   switch (fs.regs.cfa_how)
960     {
961     case CFA_REG_OFFSET:
962       {
963         int regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, fs.regs.cfa_reg);
964
965         if (regnum == -1)
966           error (_("Unable to access DWARF register number %d"),
967                  (int) fs.regs.cfa_reg); /* FIXME */
968         ax_reg (expr, regnum);
969
970         if (fs.regs.cfa_offset != 0)
971           {
972             if (fs.armcc_cfa_offsets_reversed)
973               ax_const_l (expr, -fs.regs.cfa_offset);
974             else
975               ax_const_l (expr, fs.regs.cfa_offset);
976             ax_simple (expr, aop_add);
977           }
978       }
979       break;
980
981     case CFA_EXP:
982       ax_const_l (expr, text_offset);
983       dwarf2_compile_expr_to_ax (expr, loc, gdbarch, addr_size,
984                                  fs.regs.cfa_exp,
985                                  fs.regs.cfa_exp + fs.regs.cfa_exp_len,
986                                  data);
987       break;
988
989     default:
990       internal_error (__FILE__, __LINE__, _("Unknown CFA rule."));
991     }
992 }
993
994 \f
995 struct dwarf2_frame_cache
996 {
997   /* DWARF Call Frame Address.  */
998   CORE_ADDR cfa;
999
1000   /* Set if the return address column was marked as unavailable
1001      (required non-collected memory or registers to compute).  */
1002   int unavailable_retaddr;
1003
1004   /* Set if the return address column was marked as undefined.  */
1005   int undefined_retaddr;
1006
1007   /* Saved registers, indexed by GDB register number, not by DWARF
1008      register number.  */
1009   struct dwarf2_frame_state_reg *reg;
1010
1011   /* Return address register.  */
1012   struct dwarf2_frame_state_reg retaddr_reg;
1013
1014   /* Target address size in bytes.  */
1015   int addr_size;
1016
1017   /* The .text offset.  */
1018   CORE_ADDR text_offset;
1019 };
1020
1021 static struct dwarf2_frame_cache *
1022 dwarf2_frame_cache (struct frame_info *this_frame, void **this_cache)
1023 {
1024   struct cleanup *old_chain;
1025   struct gdbarch *gdbarch = get_frame_arch (this_frame);
1026   const int num_regs = gdbarch_num_regs (gdbarch)
1027                        + gdbarch_num_pseudo_regs (gdbarch);
1028   struct dwarf2_frame_cache *cache;
1029   struct dwarf2_frame_state *fs;
1030   struct dwarf2_fde *fde;
1031   volatile struct gdb_exception ex;
1032
1033   if (*this_cache)
1034     return *this_cache;
1035
1036   /* Allocate a new cache.  */
1037   cache = FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache);
1038   cache->reg = FRAME_OBSTACK_CALLOC (num_regs, struct dwarf2_frame_state_reg);
1039   *this_cache = cache;
1040
1041   /* Allocate and initialize the frame state.  */
1042   fs = XZALLOC (struct dwarf2_frame_state);
1043   old_chain = make_cleanup (dwarf2_frame_state_free, fs);
1044
1045   /* Unwind the PC.
1046
1047      Note that if the next frame is never supposed to return (i.e. a call
1048      to abort), the compiler might optimize away the instruction at
1049      its return address.  As a result the return address will
1050      point at some random instruction, and the CFI for that
1051      instruction is probably worthless to us.  GCC's unwinder solves
1052      this problem by substracting 1 from the return address to get an
1053      address in the middle of a presumed call instruction (or the
1054      instruction in the associated delay slot).  This should only be
1055      done for "normal" frames and not for resume-type frames (signal
1056      handlers, sentinel frames, dummy frames).  The function
1057      get_frame_address_in_block does just this.  It's not clear how
1058      reliable the method is though; there is the potential for the
1059      register state pre-call being different to that on return.  */
1060   fs->pc = get_frame_address_in_block (this_frame);
1061
1062   /* Find the correct FDE.  */
1063   fde = dwarf2_frame_find_fde (&fs->pc, &cache->text_offset);
1064   gdb_assert (fde != NULL);
1065
1066   /* Extract any interesting information from the CIE.  */
1067   fs->data_align = fde->cie->data_alignment_factor;
1068   fs->code_align = fde->cie->code_alignment_factor;
1069   fs->retaddr_column = fde->cie->return_address_register;
1070   cache->addr_size = fde->cie->addr_size;
1071
1072   /* Check for "quirks" - known bugs in producers.  */
1073   dwarf2_frame_find_quirks (fs, fde);
1074
1075   /* First decode all the insns in the CIE.  */
1076   execute_cfa_program (fde, fde->cie->initial_instructions,
1077                        fde->cie->end, gdbarch, get_frame_pc (this_frame), fs);
1078
1079   /* Save the initialized register set.  */
1080   fs->initial = fs->regs;
1081   fs->initial.reg = dwarf2_frame_state_copy_regs (&fs->regs);
1082
1083   /* Then decode the insns in the FDE up to our target PC.  */
1084   execute_cfa_program (fde, fde->instructions, fde->end, gdbarch,
1085                        get_frame_pc (this_frame), fs);
1086
1087   TRY_CATCH (ex, RETURN_MASK_ERROR)
1088     {
1089       /* Calculate the CFA.  */
1090       switch (fs->regs.cfa_how)
1091         {
1092         case CFA_REG_OFFSET:
1093           cache->cfa = read_reg (this_frame, fs->regs.cfa_reg);
1094           if (fs->armcc_cfa_offsets_reversed)
1095             cache->cfa -= fs->regs.cfa_offset;
1096           else
1097             cache->cfa += fs->regs.cfa_offset;
1098           break;
1099
1100         case CFA_EXP:
1101           cache->cfa =
1102             execute_stack_op (fs->regs.cfa_exp, fs->regs.cfa_exp_len,
1103                               cache->addr_size, cache->text_offset,
1104                               this_frame, 0, 0);
1105           break;
1106
1107         default:
1108           internal_error (__FILE__, __LINE__, _("Unknown CFA rule."));
1109         }
1110     }
1111   if (ex.reason < 0)
1112     {
1113       if (ex.error == NOT_AVAILABLE_ERROR)
1114         {
1115           cache->unavailable_retaddr = 1;
1116           return cache;
1117         }
1118
1119       throw_exception (ex);
1120     }
1121
1122   /* Initialize the register state.  */
1123   {
1124     int regnum;
1125
1126     for (regnum = 0; regnum < num_regs; regnum++)
1127       dwarf2_frame_init_reg (gdbarch, regnum, &cache->reg[regnum], this_frame);
1128   }
1129
1130   /* Go through the DWARF2 CFI generated table and save its register
1131      location information in the cache.  Note that we don't skip the
1132      return address column; it's perfectly all right for it to
1133      correspond to a real register.  If it doesn't correspond to a
1134      real register, or if we shouldn't treat it as such,
1135      gdbarch_dwarf2_reg_to_regnum should be defined to return a number outside
1136      the range [0, gdbarch_num_regs).  */
1137   {
1138     int column;         /* CFI speak for "register number".  */
1139
1140     for (column = 0; column < fs->regs.num_regs; column++)
1141       {
1142         /* Use the GDB register number as the destination index.  */
1143         int regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, column);
1144
1145         /* If there's no corresponding GDB register, ignore it.  */
1146         if (regnum < 0 || regnum >= num_regs)
1147           continue;
1148
1149         /* NOTE: cagney/2003-09-05: CFI should specify the disposition
1150            of all debug info registers.  If it doesn't, complain (but
1151            not too loudly).  It turns out that GCC assumes that an
1152            unspecified register implies "same value" when CFI (draft
1153            7) specifies nothing at all.  Such a register could equally
1154            be interpreted as "undefined".  Also note that this check
1155            isn't sufficient; it only checks that all registers in the
1156            range [0 .. max column] are specified, and won't detect
1157            problems when a debug info register falls outside of the
1158            table.  We need a way of iterating through all the valid
1159            DWARF2 register numbers.  */
1160         if (fs->regs.reg[column].how == DWARF2_FRAME_REG_UNSPECIFIED)
1161           {
1162             if (cache->reg[regnum].how == DWARF2_FRAME_REG_UNSPECIFIED)
1163               complaint (&symfile_complaints, _("\
1164 incomplete CFI data; unspecified registers (e.g., %s) at %s"),
1165                          gdbarch_register_name (gdbarch, regnum),
1166                          paddress (gdbarch, fs->pc));
1167           }
1168         else
1169           cache->reg[regnum] = fs->regs.reg[column];
1170       }
1171   }
1172
1173   /* Eliminate any DWARF2_FRAME_REG_RA rules, and save the information
1174      we need for evaluating DWARF2_FRAME_REG_RA_OFFSET rules.  */
1175   {
1176     int regnum;
1177
1178     for (regnum = 0; regnum < num_regs; regnum++)
1179       {
1180         if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA
1181             || cache->reg[regnum].how == DWARF2_FRAME_REG_RA_OFFSET)
1182           {
1183             struct dwarf2_frame_state_reg *retaddr_reg =
1184               &fs->regs.reg[fs->retaddr_column];
1185
1186             /* It seems rather bizarre to specify an "empty" column as
1187                the return adress column.  However, this is exactly
1188                what GCC does on some targets.  It turns out that GCC
1189                assumes that the return address can be found in the
1190                register corresponding to the return address column.
1191                Incidentally, that's how we should treat a return
1192                address column specifying "same value" too.  */
1193             if (fs->retaddr_column < fs->regs.num_regs
1194                 && retaddr_reg->how != DWARF2_FRAME_REG_UNSPECIFIED
1195                 && retaddr_reg->how != DWARF2_FRAME_REG_SAME_VALUE)
1196               {
1197                 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
1198                   cache->reg[regnum] = *retaddr_reg;
1199                 else
1200                   cache->retaddr_reg = *retaddr_reg;
1201               }
1202             else
1203               {
1204                 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
1205                   {
1206                     cache->reg[regnum].loc.reg = fs->retaddr_column;
1207                     cache->reg[regnum].how = DWARF2_FRAME_REG_SAVED_REG;
1208                   }
1209                 else
1210                   {
1211                     cache->retaddr_reg.loc.reg = fs->retaddr_column;
1212                     cache->retaddr_reg.how = DWARF2_FRAME_REG_SAVED_REG;
1213                   }
1214               }
1215           }
1216       }
1217   }
1218
1219   if (fs->retaddr_column < fs->regs.num_regs
1220       && fs->regs.reg[fs->retaddr_column].how == DWARF2_FRAME_REG_UNDEFINED)
1221     cache->undefined_retaddr = 1;
1222
1223   do_cleanups (old_chain);
1224
1225   return cache;
1226 }
1227
1228 static enum unwind_stop_reason
1229 dwarf2_frame_unwind_stop_reason (struct frame_info *this_frame,
1230                                  void **this_cache)
1231 {
1232   struct dwarf2_frame_cache *cache
1233     = dwarf2_frame_cache (this_frame, this_cache);
1234
1235   if (cache->unavailable_retaddr)
1236     return UNWIND_UNAVAILABLE;
1237
1238   if (cache->undefined_retaddr)
1239     return UNWIND_OUTERMOST;
1240
1241   return UNWIND_NO_REASON;
1242 }
1243
1244 static void
1245 dwarf2_frame_this_id (struct frame_info *this_frame, void **this_cache,
1246                       struct frame_id *this_id)
1247 {
1248   struct dwarf2_frame_cache *cache =
1249     dwarf2_frame_cache (this_frame, this_cache);
1250
1251   if (cache->unavailable_retaddr)
1252     return;
1253
1254   if (cache->undefined_retaddr)
1255     return;
1256
1257   (*this_id) = frame_id_build (cache->cfa, get_frame_func (this_frame));
1258 }
1259
1260 static struct value *
1261 dwarf2_frame_prev_register (struct frame_info *this_frame, void **this_cache,
1262                             int regnum)
1263 {
1264   struct gdbarch *gdbarch = get_frame_arch (this_frame);
1265   struct dwarf2_frame_cache *cache =
1266     dwarf2_frame_cache (this_frame, this_cache);
1267   CORE_ADDR addr;
1268   int realnum;
1269
1270   switch (cache->reg[regnum].how)
1271     {
1272     case DWARF2_FRAME_REG_UNDEFINED:
1273       /* If CFI explicitly specified that the value isn't defined,
1274          mark it as optimized away; the value isn't available.  */
1275       return frame_unwind_got_optimized (this_frame, regnum);
1276
1277     case DWARF2_FRAME_REG_SAVED_OFFSET:
1278       addr = cache->cfa + cache->reg[regnum].loc.offset;
1279       return frame_unwind_got_memory (this_frame, regnum, addr);
1280
1281     case DWARF2_FRAME_REG_SAVED_REG:
1282       realnum
1283         = gdbarch_dwarf2_reg_to_regnum (gdbarch, cache->reg[regnum].loc.reg);
1284       return frame_unwind_got_register (this_frame, regnum, realnum);
1285
1286     case DWARF2_FRAME_REG_SAVED_EXP:
1287       addr = execute_stack_op (cache->reg[regnum].loc.exp,
1288                                cache->reg[regnum].exp_len,
1289                                cache->addr_size, cache->text_offset,
1290                                this_frame, cache->cfa, 1);
1291       return frame_unwind_got_memory (this_frame, regnum, addr);
1292
1293     case DWARF2_FRAME_REG_SAVED_VAL_OFFSET:
1294       addr = cache->cfa + cache->reg[regnum].loc.offset;
1295       return frame_unwind_got_constant (this_frame, regnum, addr);
1296
1297     case DWARF2_FRAME_REG_SAVED_VAL_EXP:
1298       addr = execute_stack_op (cache->reg[regnum].loc.exp,
1299                                cache->reg[regnum].exp_len,
1300                                cache->addr_size, cache->text_offset,
1301                                this_frame, cache->cfa, 1);
1302       return frame_unwind_got_constant (this_frame, regnum, addr);
1303
1304     case DWARF2_FRAME_REG_UNSPECIFIED:
1305       /* GCC, in its infinite wisdom decided to not provide unwind
1306          information for registers that are "same value".  Since
1307          DWARF2 (3 draft 7) doesn't define such behavior, said
1308          registers are actually undefined (which is different to CFI
1309          "undefined").  Code above issues a complaint about this.
1310          Here just fudge the books, assume GCC, and that the value is
1311          more inner on the stack.  */
1312       return frame_unwind_got_register (this_frame, regnum, regnum);
1313
1314     case DWARF2_FRAME_REG_SAME_VALUE:
1315       return frame_unwind_got_register (this_frame, regnum, regnum);
1316
1317     case DWARF2_FRAME_REG_CFA:
1318       return frame_unwind_got_address (this_frame, regnum, cache->cfa);
1319
1320     case DWARF2_FRAME_REG_CFA_OFFSET:
1321       addr = cache->cfa + cache->reg[regnum].loc.offset;
1322       return frame_unwind_got_address (this_frame, regnum, addr);
1323
1324     case DWARF2_FRAME_REG_RA_OFFSET:
1325       addr = cache->reg[regnum].loc.offset;
1326       regnum = gdbarch_dwarf2_reg_to_regnum
1327         (gdbarch, cache->retaddr_reg.loc.reg);
1328       addr += get_frame_register_unsigned (this_frame, regnum);
1329       return frame_unwind_got_address (this_frame, regnum, addr);
1330
1331     case DWARF2_FRAME_REG_FN:
1332       return cache->reg[regnum].loc.fn (this_frame, this_cache, regnum);
1333
1334     default:
1335       internal_error (__FILE__, __LINE__, _("Unknown register rule."));
1336     }
1337 }
1338
1339 static int
1340 dwarf2_frame_sniffer (const struct frame_unwind *self,
1341                       struct frame_info *this_frame, void **this_cache)
1342 {
1343   /* Grab an address that is guarenteed to reside somewhere within the
1344      function.  get_frame_pc(), with a no-return next function, can
1345      end up returning something past the end of this function's body.
1346      If the frame we're sniffing for is a signal frame whose start
1347      address is placed on the stack by the OS, its FDE must
1348      extend one byte before its start address or we could potentially
1349      select the FDE of the previous function.  */
1350   CORE_ADDR block_addr = get_frame_address_in_block (this_frame);
1351   struct dwarf2_fde *fde = dwarf2_frame_find_fde (&block_addr, NULL);
1352
1353   if (!fde)
1354     return 0;
1355
1356   /* On some targets, signal trampolines may have unwind information.
1357      We need to recognize them so that we set the frame type
1358      correctly.  */
1359
1360   if (fde->cie->signal_frame
1361       || dwarf2_frame_signal_frame_p (get_frame_arch (this_frame),
1362                                       this_frame))
1363     return self->type == SIGTRAMP_FRAME;
1364
1365   return self->type != SIGTRAMP_FRAME;
1366 }
1367
1368 static const struct frame_unwind dwarf2_frame_unwind =
1369 {
1370   NORMAL_FRAME,
1371   dwarf2_frame_unwind_stop_reason,
1372   dwarf2_frame_this_id,
1373   dwarf2_frame_prev_register,
1374   NULL,
1375   dwarf2_frame_sniffer
1376 };
1377
1378 static const struct frame_unwind dwarf2_signal_frame_unwind =
1379 {
1380   SIGTRAMP_FRAME,
1381   dwarf2_frame_unwind_stop_reason,
1382   dwarf2_frame_this_id,
1383   dwarf2_frame_prev_register,
1384   NULL,
1385   dwarf2_frame_sniffer
1386 };
1387
1388 /* Append the DWARF-2 frame unwinders to GDBARCH's list.  */
1389
1390 void
1391 dwarf2_append_unwinders (struct gdbarch *gdbarch)
1392 {
1393   frame_unwind_append_unwinder (gdbarch, &dwarf2_frame_unwind);
1394   frame_unwind_append_unwinder (gdbarch, &dwarf2_signal_frame_unwind);
1395 }
1396 \f
1397
1398 /* There is no explicitly defined relationship between the CFA and the
1399    location of frame's local variables and arguments/parameters.
1400    Therefore, frame base methods on this page should probably only be
1401    used as a last resort, just to avoid printing total garbage as a
1402    response to the "info frame" command.  */
1403
1404 static CORE_ADDR
1405 dwarf2_frame_base_address (struct frame_info *this_frame, void **this_cache)
1406 {
1407   struct dwarf2_frame_cache *cache =
1408     dwarf2_frame_cache (this_frame, this_cache);
1409
1410   return cache->cfa;
1411 }
1412
1413 static const struct frame_base dwarf2_frame_base =
1414 {
1415   &dwarf2_frame_unwind,
1416   dwarf2_frame_base_address,
1417   dwarf2_frame_base_address,
1418   dwarf2_frame_base_address
1419 };
1420
1421 const struct frame_base *
1422 dwarf2_frame_base_sniffer (struct frame_info *this_frame)
1423 {
1424   CORE_ADDR block_addr = get_frame_address_in_block (this_frame);
1425
1426   if (dwarf2_frame_find_fde (&block_addr, NULL))
1427     return &dwarf2_frame_base;
1428
1429   return NULL;
1430 }
1431
1432 /* Compute the CFA for THIS_FRAME, but only if THIS_FRAME came from
1433    the DWARF unwinder.  This is used to implement
1434    DW_OP_call_frame_cfa.  */
1435
1436 CORE_ADDR
1437 dwarf2_frame_cfa (struct frame_info *this_frame)
1438 {
1439   while (get_frame_type (this_frame) == INLINE_FRAME)
1440     this_frame = get_prev_frame (this_frame);
1441   /* This restriction could be lifted if other unwinders are known to
1442      compute the frame base in a way compatible with the DWARF
1443      unwinder.  */
1444   if (! frame_unwinder_is (this_frame, &dwarf2_frame_unwind))
1445     error (_("can't compute CFA for this frame"));
1446   return get_frame_base (this_frame);
1447 }
1448 \f
1449 const struct objfile_data *dwarf2_frame_objfile_data;
1450
1451 static unsigned int
1452 read_1_byte (bfd *abfd, gdb_byte *buf)
1453 {
1454   return bfd_get_8 (abfd, buf);
1455 }
1456
1457 static unsigned int
1458 read_4_bytes (bfd *abfd, gdb_byte *buf)
1459 {
1460   return bfd_get_32 (abfd, buf);
1461 }
1462
1463 static ULONGEST
1464 read_8_bytes (bfd *abfd, gdb_byte *buf)
1465 {
1466   return bfd_get_64 (abfd, buf);
1467 }
1468
1469 static ULONGEST
1470 read_unsigned_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1471 {
1472   ULONGEST result;
1473   unsigned int num_read;
1474   int shift;
1475   gdb_byte byte;
1476
1477   result = 0;
1478   shift = 0;
1479   num_read = 0;
1480
1481   do
1482     {
1483       byte = bfd_get_8 (abfd, (bfd_byte *) buf);
1484       buf++;
1485       num_read++;
1486       result |= ((byte & 0x7f) << shift);
1487       shift += 7;
1488     }
1489   while (byte & 0x80);
1490
1491   *bytes_read_ptr = num_read;
1492
1493   return result;
1494 }
1495
1496 static LONGEST
1497 read_signed_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1498 {
1499   LONGEST result;
1500   int shift;
1501   unsigned int num_read;
1502   gdb_byte byte;
1503
1504   result = 0;
1505   shift = 0;
1506   num_read = 0;
1507
1508   do
1509     {
1510       byte = bfd_get_8 (abfd, (bfd_byte *) buf);
1511       buf++;
1512       num_read++;
1513       result |= ((byte & 0x7f) << shift);
1514       shift += 7;
1515     }
1516   while (byte & 0x80);
1517
1518   if (shift < 8 * sizeof (result) && (byte & 0x40))
1519     result |= -(((LONGEST)1) << shift);
1520
1521   *bytes_read_ptr = num_read;
1522
1523   return result;
1524 }
1525
1526 static ULONGEST
1527 read_initial_length (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1528 {
1529   LONGEST result;
1530
1531   result = bfd_get_32 (abfd, buf);
1532   if (result == 0xffffffff)
1533     {
1534       result = bfd_get_64 (abfd, buf + 4);
1535       *bytes_read_ptr = 12;
1536     }
1537   else
1538     *bytes_read_ptr = 4;
1539
1540   return result;
1541 }
1542 \f
1543
1544 /* Pointer encoding helper functions.  */
1545
1546 /* GCC supports exception handling based on DWARF2 CFI.  However, for
1547    technical reasons, it encodes addresses in its FDE's in a different
1548    way.  Several "pointer encodings" are supported.  The encoding
1549    that's used for a particular FDE is determined by the 'R'
1550    augmentation in the associated CIE.  The argument of this
1551    augmentation is a single byte.  
1552
1553    The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a
1554    LEB128.  This is encoded in bits 0, 1 and 2.  Bit 3 encodes whether
1555    the address is signed or unsigned.  Bits 4, 5 and 6 encode how the
1556    address should be interpreted (absolute, relative to the current
1557    position in the FDE, ...).  Bit 7, indicates that the address
1558    should be dereferenced.  */
1559
1560 static gdb_byte
1561 encoding_for_size (unsigned int size)
1562 {
1563   switch (size)
1564     {
1565     case 2:
1566       return DW_EH_PE_udata2;
1567     case 4:
1568       return DW_EH_PE_udata4;
1569     case 8:
1570       return DW_EH_PE_udata8;
1571     default:
1572       internal_error (__FILE__, __LINE__, _("Unsupported address size"));
1573     }
1574 }
1575
1576 static CORE_ADDR
1577 read_encoded_value (struct comp_unit *unit, gdb_byte encoding,
1578                     int ptr_len, const gdb_byte *buf,
1579                     unsigned int *bytes_read_ptr,
1580                     CORE_ADDR func_base)
1581 {
1582   ptrdiff_t offset;
1583   CORE_ADDR base;
1584
1585   /* GCC currently doesn't generate DW_EH_PE_indirect encodings for
1586      FDE's.  */
1587   if (encoding & DW_EH_PE_indirect)
1588     internal_error (__FILE__, __LINE__, 
1589                     _("Unsupported encoding: DW_EH_PE_indirect"));
1590
1591   *bytes_read_ptr = 0;
1592
1593   switch (encoding & 0x70)
1594     {
1595     case DW_EH_PE_absptr:
1596       base = 0;
1597       break;
1598     case DW_EH_PE_pcrel:
1599       base = bfd_get_section_vma (unit->abfd, unit->dwarf_frame_section);
1600       base += (buf - unit->dwarf_frame_buffer);
1601       break;
1602     case DW_EH_PE_datarel:
1603       base = unit->dbase;
1604       break;
1605     case DW_EH_PE_textrel:
1606       base = unit->tbase;
1607       break;
1608     case DW_EH_PE_funcrel:
1609       base = func_base;
1610       break;
1611     case DW_EH_PE_aligned:
1612       base = 0;
1613       offset = buf - unit->dwarf_frame_buffer;
1614       if ((offset % ptr_len) != 0)
1615         {
1616           *bytes_read_ptr = ptr_len - (offset % ptr_len);
1617           buf += *bytes_read_ptr;
1618         }
1619       break;
1620     default:
1621       internal_error (__FILE__, __LINE__,
1622                       _("Invalid or unsupported encoding"));
1623     }
1624
1625   if ((encoding & 0x07) == 0x00)
1626     {
1627       encoding |= encoding_for_size (ptr_len);
1628       if (bfd_get_sign_extend_vma (unit->abfd))
1629         encoding |= DW_EH_PE_signed;
1630     }
1631
1632   switch (encoding & 0x0f)
1633     {
1634     case DW_EH_PE_uleb128:
1635       {
1636         ULONGEST value;
1637         const gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1638
1639         *bytes_read_ptr += read_uleb128 (buf, end_buf, &value) - buf;
1640         return base + value;
1641       }
1642     case DW_EH_PE_udata2:
1643       *bytes_read_ptr += 2;
1644       return (base + bfd_get_16 (unit->abfd, (bfd_byte *) buf));
1645     case DW_EH_PE_udata4:
1646       *bytes_read_ptr += 4;
1647       return (base + bfd_get_32 (unit->abfd, (bfd_byte *) buf));
1648     case DW_EH_PE_udata8:
1649       *bytes_read_ptr += 8;
1650       return (base + bfd_get_64 (unit->abfd, (bfd_byte *) buf));
1651     case DW_EH_PE_sleb128:
1652       {
1653         LONGEST value;
1654         const gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1655
1656         *bytes_read_ptr += read_sleb128 (buf, end_buf, &value) - buf;
1657         return base + value;
1658       }
1659     case DW_EH_PE_sdata2:
1660       *bytes_read_ptr += 2;
1661       return (base + bfd_get_signed_16 (unit->abfd, (bfd_byte *) buf));
1662     case DW_EH_PE_sdata4:
1663       *bytes_read_ptr += 4;
1664       return (base + bfd_get_signed_32 (unit->abfd, (bfd_byte *) buf));
1665     case DW_EH_PE_sdata8:
1666       *bytes_read_ptr += 8;
1667       return (base + bfd_get_signed_64 (unit->abfd, (bfd_byte *) buf));
1668     default:
1669       internal_error (__FILE__, __LINE__,
1670                       _("Invalid or unsupported encoding"));
1671     }
1672 }
1673 \f
1674
1675 static int
1676 bsearch_cie_cmp (const void *key, const void *element)
1677 {
1678   ULONGEST cie_pointer = *(ULONGEST *) key;
1679   struct dwarf2_cie *cie = *(struct dwarf2_cie **) element;
1680
1681   if (cie_pointer == cie->cie_pointer)
1682     return 0;
1683
1684   return (cie_pointer < cie->cie_pointer) ? -1 : 1;
1685 }
1686
1687 /* Find CIE with the given CIE_POINTER in CIE_TABLE.  */
1688 static struct dwarf2_cie *
1689 find_cie (struct dwarf2_cie_table *cie_table, ULONGEST cie_pointer)
1690 {
1691   struct dwarf2_cie **p_cie;
1692
1693   /* The C standard (ISO/IEC 9899:TC2) requires the BASE argument to
1694      bsearch be non-NULL.  */
1695   if (cie_table->entries == NULL)
1696     {
1697       gdb_assert (cie_table->num_entries == 0);
1698       return NULL;
1699     }
1700
1701   p_cie = bsearch (&cie_pointer, cie_table->entries, cie_table->num_entries,
1702                    sizeof (cie_table->entries[0]), bsearch_cie_cmp);
1703   if (p_cie != NULL)
1704     return *p_cie;
1705   return NULL;
1706 }
1707
1708 /* Add a pointer to new CIE to the CIE_TABLE, allocating space for it.  */
1709 static void
1710 add_cie (struct dwarf2_cie_table *cie_table, struct dwarf2_cie *cie)
1711 {
1712   const int n = cie_table->num_entries;
1713
1714   gdb_assert (n < 1
1715               || cie_table->entries[n - 1]->cie_pointer < cie->cie_pointer);
1716
1717   cie_table->entries =
1718       xrealloc (cie_table->entries, (n + 1) * sizeof (cie_table->entries[0]));
1719   cie_table->entries[n] = cie;
1720   cie_table->num_entries = n + 1;
1721 }
1722
1723 static int
1724 bsearch_fde_cmp (const void *key, const void *element)
1725 {
1726   CORE_ADDR seek_pc = *(CORE_ADDR *) key;
1727   struct dwarf2_fde *fde = *(struct dwarf2_fde **) element;
1728
1729   if (seek_pc < fde->initial_location)
1730     return -1;
1731   if (seek_pc < fde->initial_location + fde->address_range)
1732     return 0;
1733   return 1;
1734 }
1735
1736 /* Find the FDE for *PC.  Return a pointer to the FDE, and store the
1737    inital location associated with it into *PC.  */
1738
1739 static struct dwarf2_fde *
1740 dwarf2_frame_find_fde (CORE_ADDR *pc, CORE_ADDR *out_offset)
1741 {
1742   struct objfile *objfile;
1743
1744   ALL_OBJFILES (objfile)
1745     {
1746       struct dwarf2_fde_table *fde_table;
1747       struct dwarf2_fde **p_fde;
1748       CORE_ADDR offset;
1749       CORE_ADDR seek_pc;
1750
1751       fde_table = objfile_data (objfile, dwarf2_frame_objfile_data);
1752       if (fde_table == NULL)
1753         {
1754           dwarf2_build_frame_info (objfile);
1755           fde_table = objfile_data (objfile, dwarf2_frame_objfile_data);
1756         }
1757       gdb_assert (fde_table != NULL);
1758
1759       if (fde_table->num_entries == 0)
1760         continue;
1761
1762       gdb_assert (objfile->section_offsets);
1763       offset = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1764
1765       gdb_assert (fde_table->num_entries > 0);
1766       if (*pc < offset + fde_table->entries[0]->initial_location)
1767         continue;
1768
1769       seek_pc = *pc - offset;
1770       p_fde = bsearch (&seek_pc, fde_table->entries, fde_table->num_entries,
1771                        sizeof (fde_table->entries[0]), bsearch_fde_cmp);
1772       if (p_fde != NULL)
1773         {
1774           *pc = (*p_fde)->initial_location + offset;
1775           if (out_offset)
1776             *out_offset = offset;
1777           return *p_fde;
1778         }
1779     }
1780   return NULL;
1781 }
1782
1783 /* Add a pointer to new FDE to the FDE_TABLE, allocating space for it.  */
1784 static void
1785 add_fde (struct dwarf2_fde_table *fde_table, struct dwarf2_fde *fde)
1786 {
1787   if (fde->address_range == 0)
1788     /* Discard useless FDEs.  */
1789     return;
1790
1791   fde_table->num_entries += 1;
1792   fde_table->entries =
1793       xrealloc (fde_table->entries,
1794                 fde_table->num_entries * sizeof (fde_table->entries[0]));
1795   fde_table->entries[fde_table->num_entries - 1] = fde;
1796 }
1797
1798 #ifdef CC_HAS_LONG_LONG
1799 #define DW64_CIE_ID 0xffffffffffffffffULL
1800 #else
1801 #define DW64_CIE_ID ~0
1802 #endif
1803
1804 /* Defines the type of eh_frames that are expected to be decoded: CIE, FDE
1805    or any of them.  */
1806
1807 enum eh_frame_type
1808 {
1809   EH_CIE_TYPE_ID = 1 << 0,
1810   EH_FDE_TYPE_ID = 1 << 1,
1811   EH_CIE_OR_FDE_TYPE_ID = EH_CIE_TYPE_ID | EH_FDE_TYPE_ID
1812 };
1813
1814 static gdb_byte *decode_frame_entry (struct comp_unit *unit, gdb_byte *start,
1815                                      int eh_frame_p,
1816                                      struct dwarf2_cie_table *cie_table,
1817                                      struct dwarf2_fde_table *fde_table,
1818                                      enum eh_frame_type entry_type);
1819
1820 /* Decode the next CIE or FDE, entry_type specifies the expected type.
1821    Return NULL if invalid input, otherwise the next byte to be processed.  */
1822
1823 static gdb_byte *
1824 decode_frame_entry_1 (struct comp_unit *unit, gdb_byte *start, int eh_frame_p,
1825                       struct dwarf2_cie_table *cie_table,
1826                       struct dwarf2_fde_table *fde_table,
1827                       enum eh_frame_type entry_type)
1828 {
1829   struct gdbarch *gdbarch = get_objfile_arch (unit->objfile);
1830   gdb_byte *buf, *end;
1831   LONGEST length;
1832   unsigned int bytes_read;
1833   int dwarf64_p;
1834   ULONGEST cie_id;
1835   ULONGEST cie_pointer;
1836
1837   buf = start;
1838   length = read_initial_length (unit->abfd, buf, &bytes_read);
1839   buf += bytes_read;
1840   end = buf + length;
1841
1842   /* Are we still within the section?  */
1843   if (end > unit->dwarf_frame_buffer + unit->dwarf_frame_size)
1844     return NULL;
1845
1846   if (length == 0)
1847     return end;
1848
1849   /* Distinguish between 32 and 64-bit encoded frame info.  */
1850   dwarf64_p = (bytes_read == 12);
1851
1852   /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs.  */
1853   if (eh_frame_p)
1854     cie_id = 0;
1855   else if (dwarf64_p)
1856     cie_id = DW64_CIE_ID;
1857   else
1858     cie_id = DW_CIE_ID;
1859
1860   if (dwarf64_p)
1861     {
1862       cie_pointer = read_8_bytes (unit->abfd, buf);
1863       buf += 8;
1864     }
1865   else
1866     {
1867       cie_pointer = read_4_bytes (unit->abfd, buf);
1868       buf += 4;
1869     }
1870
1871   if (cie_pointer == cie_id)
1872     {
1873       /* This is a CIE.  */
1874       struct dwarf2_cie *cie;
1875       char *augmentation;
1876       unsigned int cie_version;
1877
1878       /* Check that a CIE was expected.  */
1879       if ((entry_type & EH_CIE_TYPE_ID) == 0)
1880         error (_("Found a CIE when not expecting it."));
1881
1882       /* Record the offset into the .debug_frame section of this CIE.  */
1883       cie_pointer = start - unit->dwarf_frame_buffer;
1884
1885       /* Check whether we've already read it.  */
1886       if (find_cie (cie_table, cie_pointer))
1887         return end;
1888
1889       cie = (struct dwarf2_cie *)
1890         obstack_alloc (&unit->objfile->objfile_obstack,
1891                        sizeof (struct dwarf2_cie));
1892       cie->initial_instructions = NULL;
1893       cie->cie_pointer = cie_pointer;
1894
1895       /* The encoding for FDE's in a normal .debug_frame section
1896          depends on the target address size.  */
1897       cie->encoding = DW_EH_PE_absptr;
1898
1899       /* We'll determine the final value later, but we need to
1900          initialize it conservatively.  */
1901       cie->signal_frame = 0;
1902
1903       /* Check version number.  */
1904       cie_version = read_1_byte (unit->abfd, buf);
1905       if (cie_version != 1 && cie_version != 3 && cie_version != 4)
1906         return NULL;
1907       cie->version = cie_version;
1908       buf += 1;
1909
1910       /* Interpret the interesting bits of the augmentation.  */
1911       cie->augmentation = augmentation = (char *) buf;
1912       buf += (strlen (augmentation) + 1);
1913
1914       /* Ignore armcc augmentations.  We only use them for quirks,
1915          and that doesn't happen until later.  */
1916       if (strncmp (augmentation, "armcc", 5) == 0)
1917         augmentation += strlen (augmentation);
1918
1919       /* The GCC 2.x "eh" augmentation has a pointer immediately
1920          following the augmentation string, so it must be handled
1921          first.  */
1922       if (augmentation[0] == 'e' && augmentation[1] == 'h')
1923         {
1924           /* Skip.  */
1925           buf += gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
1926           augmentation += 2;
1927         }
1928
1929       if (cie->version >= 4)
1930         {
1931           /* FIXME: check that this is the same as from the CU header.  */
1932           cie->addr_size = read_1_byte (unit->abfd, buf);
1933           ++buf;
1934           cie->segment_size = read_1_byte (unit->abfd, buf);
1935           ++buf;
1936         }
1937       else
1938         {
1939           cie->addr_size = gdbarch_dwarf2_addr_size (gdbarch);
1940           cie->segment_size = 0;
1941         }
1942       /* Address values in .eh_frame sections are defined to have the
1943          target's pointer size.  Watchout: This breaks frame info for
1944          targets with pointer size < address size, unless a .debug_frame
1945          section exists as well.  */
1946       if (eh_frame_p)
1947         cie->ptr_size = gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
1948       else
1949         cie->ptr_size = cie->addr_size;
1950
1951       cie->code_alignment_factor =
1952         read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1953       buf += bytes_read;
1954
1955       cie->data_alignment_factor =
1956         read_signed_leb128 (unit->abfd, buf, &bytes_read);
1957       buf += bytes_read;
1958
1959       if (cie_version == 1)
1960         {
1961           cie->return_address_register = read_1_byte (unit->abfd, buf);
1962           bytes_read = 1;
1963         }
1964       else
1965         cie->return_address_register = read_unsigned_leb128 (unit->abfd, buf,
1966                                                              &bytes_read);
1967       cie->return_address_register
1968         = dwarf2_frame_adjust_regnum (gdbarch,
1969                                       cie->return_address_register,
1970                                       eh_frame_p);
1971
1972       buf += bytes_read;
1973
1974       cie->saw_z_augmentation = (*augmentation == 'z');
1975       if (cie->saw_z_augmentation)
1976         {
1977           ULONGEST length;
1978
1979           length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1980           buf += bytes_read;
1981           if (buf > end)
1982             return NULL;
1983           cie->initial_instructions = buf + length;
1984           augmentation++;
1985         }
1986
1987       while (*augmentation)
1988         {
1989           /* "L" indicates a byte showing how the LSDA pointer is encoded.  */
1990           if (*augmentation == 'L')
1991             {
1992               /* Skip.  */
1993               buf++;
1994               augmentation++;
1995             }
1996
1997           /* "R" indicates a byte indicating how FDE addresses are encoded.  */
1998           else if (*augmentation == 'R')
1999             {
2000               cie->encoding = *buf++;
2001               augmentation++;
2002             }
2003
2004           /* "P" indicates a personality routine in the CIE augmentation.  */
2005           else if (*augmentation == 'P')
2006             {
2007               /* Skip.  Avoid indirection since we throw away the result.  */
2008               gdb_byte encoding = (*buf++) & ~DW_EH_PE_indirect;
2009               read_encoded_value (unit, encoding, cie->ptr_size,
2010                                   buf, &bytes_read, 0);
2011               buf += bytes_read;
2012               augmentation++;
2013             }
2014
2015           /* "S" indicates a signal frame, such that the return
2016              address must not be decremented to locate the call frame
2017              info for the previous frame; it might even be the first
2018              instruction of a function, so decrementing it would take
2019              us to a different function.  */
2020           else if (*augmentation == 'S')
2021             {
2022               cie->signal_frame = 1;
2023               augmentation++;
2024             }
2025
2026           /* Otherwise we have an unknown augmentation.  Assume that either
2027              there is no augmentation data, or we saw a 'z' prefix.  */
2028           else
2029             {
2030               if (cie->initial_instructions)
2031                 buf = cie->initial_instructions;
2032               break;
2033             }
2034         }
2035
2036       cie->initial_instructions = buf;
2037       cie->end = end;
2038       cie->unit = unit;
2039
2040       add_cie (cie_table, cie);
2041     }
2042   else
2043     {
2044       /* This is a FDE.  */
2045       struct dwarf2_fde *fde;
2046
2047       /* Check that an FDE was expected.  */
2048       if ((entry_type & EH_FDE_TYPE_ID) == 0)
2049         error (_("Found an FDE when not expecting it."));
2050
2051       /* In an .eh_frame section, the CIE pointer is the delta between the
2052          address within the FDE where the CIE pointer is stored and the
2053          address of the CIE.  Convert it to an offset into the .eh_frame
2054          section.  */
2055       if (eh_frame_p)
2056         {
2057           cie_pointer = buf - unit->dwarf_frame_buffer - cie_pointer;
2058           cie_pointer -= (dwarf64_p ? 8 : 4);
2059         }
2060
2061       /* In either case, validate the result is still within the section.  */
2062       if (cie_pointer >= unit->dwarf_frame_size)
2063         return NULL;
2064
2065       fde = (struct dwarf2_fde *)
2066         obstack_alloc (&unit->objfile->objfile_obstack,
2067                        sizeof (struct dwarf2_fde));
2068       fde->cie = find_cie (cie_table, cie_pointer);
2069       if (fde->cie == NULL)
2070         {
2071           decode_frame_entry (unit, unit->dwarf_frame_buffer + cie_pointer,
2072                               eh_frame_p, cie_table, fde_table,
2073                               EH_CIE_TYPE_ID);
2074           fde->cie = find_cie (cie_table, cie_pointer);
2075         }
2076
2077       gdb_assert (fde->cie != NULL);
2078
2079       fde->initial_location =
2080         read_encoded_value (unit, fde->cie->encoding, fde->cie->ptr_size,
2081                             buf, &bytes_read, 0);
2082       buf += bytes_read;
2083
2084       fde->address_range =
2085         read_encoded_value (unit, fde->cie->encoding & 0x0f,
2086                             fde->cie->ptr_size, buf, &bytes_read, 0);
2087       buf += bytes_read;
2088
2089       /* A 'z' augmentation in the CIE implies the presence of an
2090          augmentation field in the FDE as well.  The only thing known
2091          to be in here at present is the LSDA entry for EH.  So we
2092          can skip the whole thing.  */
2093       if (fde->cie->saw_z_augmentation)
2094         {
2095           ULONGEST length;
2096
2097           length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
2098           buf += bytes_read + length;
2099           if (buf > end)
2100             return NULL;
2101         }
2102
2103       fde->instructions = buf;
2104       fde->end = end;
2105
2106       fde->eh_frame_p = eh_frame_p;
2107
2108       add_fde (fde_table, fde);
2109     }
2110
2111   return end;
2112 }
2113
2114 /* Read a CIE or FDE in BUF and decode it. Entry_type specifies whether we
2115    expect an FDE or a CIE.  */
2116
2117 static gdb_byte *
2118 decode_frame_entry (struct comp_unit *unit, gdb_byte *start, int eh_frame_p,
2119                     struct dwarf2_cie_table *cie_table,
2120                     struct dwarf2_fde_table *fde_table,
2121                     enum eh_frame_type entry_type)
2122 {
2123   enum { NONE, ALIGN4, ALIGN8, FAIL } workaround = NONE;
2124   gdb_byte *ret;
2125   ptrdiff_t start_offset;
2126
2127   while (1)
2128     {
2129       ret = decode_frame_entry_1 (unit, start, eh_frame_p,
2130                                   cie_table, fde_table, entry_type);
2131       if (ret != NULL)
2132         break;
2133
2134       /* We have corrupt input data of some form.  */
2135
2136       /* ??? Try, weakly, to work around compiler/assembler/linker bugs
2137          and mismatches wrt padding and alignment of debug sections.  */
2138       /* Note that there is no requirement in the standard for any
2139          alignment at all in the frame unwind sections.  Testing for
2140          alignment before trying to interpret data would be incorrect.
2141
2142          However, GCC traditionally arranged for frame sections to be
2143          sized such that the FDE length and CIE fields happen to be
2144          aligned (in theory, for performance).  This, unfortunately,
2145          was done with .align directives, which had the side effect of
2146          forcing the section to be aligned by the linker.
2147
2148          This becomes a problem when you have some other producer that
2149          creates frame sections that are not as strictly aligned.  That
2150          produces a hole in the frame info that gets filled by the 
2151          linker with zeros.
2152
2153          The GCC behaviour is arguably a bug, but it's effectively now
2154          part of the ABI, so we're now stuck with it, at least at the
2155          object file level.  A smart linker may decide, in the process
2156          of compressing duplicate CIE information, that it can rewrite
2157          the entire output section without this extra padding.  */
2158
2159       start_offset = start - unit->dwarf_frame_buffer;
2160       if (workaround < ALIGN4 && (start_offset & 3) != 0)
2161         {
2162           start += 4 - (start_offset & 3);
2163           workaround = ALIGN4;
2164           continue;
2165         }
2166       if (workaround < ALIGN8 && (start_offset & 7) != 0)
2167         {
2168           start += 8 - (start_offset & 7);
2169           workaround = ALIGN8;
2170           continue;
2171         }
2172
2173       /* Nothing left to try.  Arrange to return as if we've consumed
2174          the entire input section.  Hopefully we'll get valid info from
2175          the other of .debug_frame/.eh_frame.  */
2176       workaround = FAIL;
2177       ret = unit->dwarf_frame_buffer + unit->dwarf_frame_size;
2178       break;
2179     }
2180
2181   switch (workaround)
2182     {
2183     case NONE:
2184       break;
2185
2186     case ALIGN4:
2187       complaint (&symfile_complaints, _("\
2188 Corrupt data in %s:%s; align 4 workaround apparently succeeded"),
2189                  unit->dwarf_frame_section->owner->filename,
2190                  unit->dwarf_frame_section->name);
2191       break;
2192
2193     case ALIGN8:
2194       complaint (&symfile_complaints, _("\
2195 Corrupt data in %s:%s; align 8 workaround apparently succeeded"),
2196                  unit->dwarf_frame_section->owner->filename,
2197                  unit->dwarf_frame_section->name);
2198       break;
2199
2200     default:
2201       complaint (&symfile_complaints,
2202                  _("Corrupt data in %s:%s"),
2203                  unit->dwarf_frame_section->owner->filename,
2204                  unit->dwarf_frame_section->name);
2205       break;
2206     }
2207
2208   return ret;
2209 }
2210 \f
2211 static int
2212 qsort_fde_cmp (const void *a, const void *b)
2213 {
2214   struct dwarf2_fde *aa = *(struct dwarf2_fde **)a;
2215   struct dwarf2_fde *bb = *(struct dwarf2_fde **)b;
2216
2217   if (aa->initial_location == bb->initial_location)
2218     {
2219       if (aa->address_range != bb->address_range
2220           && aa->eh_frame_p == 0 && bb->eh_frame_p == 0)
2221         /* Linker bug, e.g. gold/10400.
2222            Work around it by keeping stable sort order.  */
2223         return (a < b) ? -1 : 1;
2224       else
2225         /* Put eh_frame entries after debug_frame ones.  */
2226         return aa->eh_frame_p - bb->eh_frame_p;
2227     }
2228
2229   return (aa->initial_location < bb->initial_location) ? -1 : 1;
2230 }
2231
2232 void
2233 dwarf2_build_frame_info (struct objfile *objfile)
2234 {
2235   struct comp_unit *unit;
2236   gdb_byte *frame_ptr;
2237   struct dwarf2_cie_table cie_table;
2238   struct dwarf2_fde_table fde_table;
2239   struct dwarf2_fde_table *fde_table2;
2240   volatile struct gdb_exception e;
2241
2242   cie_table.num_entries = 0;
2243   cie_table.entries = NULL;
2244
2245   fde_table.num_entries = 0;
2246   fde_table.entries = NULL;
2247
2248   /* Build a minimal decoding of the DWARF2 compilation unit.  */
2249   unit = (struct comp_unit *) obstack_alloc (&objfile->objfile_obstack,
2250                                              sizeof (struct comp_unit));
2251   unit->abfd = objfile->obfd;
2252   unit->objfile = objfile;
2253   unit->dbase = 0;
2254   unit->tbase = 0;
2255
2256   if (objfile->separate_debug_objfile_backlink == NULL)
2257     {
2258       /* Do not read .eh_frame from separate file as they must be also
2259          present in the main file.  */
2260       dwarf2_get_section_info (objfile, DWARF2_EH_FRAME,
2261                                &unit->dwarf_frame_section,
2262                                &unit->dwarf_frame_buffer,
2263                                &unit->dwarf_frame_size);
2264       if (unit->dwarf_frame_size)
2265         {
2266           asection *got, *txt;
2267
2268           /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
2269              that is used for the i386/amd64 target, which currently is
2270              the only target in GCC that supports/uses the
2271              DW_EH_PE_datarel encoding.  */
2272           got = bfd_get_section_by_name (unit->abfd, ".got");
2273           if (got)
2274             unit->dbase = got->vma;
2275
2276           /* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64
2277              so far.  */
2278           txt = bfd_get_section_by_name (unit->abfd, ".text");
2279           if (txt)
2280             unit->tbase = txt->vma;
2281
2282           TRY_CATCH (e, RETURN_MASK_ERROR)
2283             {
2284               frame_ptr = unit->dwarf_frame_buffer;
2285               while (frame_ptr < unit->dwarf_frame_buffer + unit->dwarf_frame_size)
2286                 frame_ptr = decode_frame_entry (unit, frame_ptr, 1,
2287                                                 &cie_table, &fde_table,
2288                                                 EH_CIE_OR_FDE_TYPE_ID);
2289             }
2290
2291           if (e.reason < 0)
2292             {
2293               warning (_("skipping .eh_frame info of %s: %s"),
2294                        objfile->name, e.message);
2295
2296               if (fde_table.num_entries != 0)
2297                 {
2298                   xfree (fde_table.entries);
2299                   fde_table.entries = NULL;
2300                   fde_table.num_entries = 0;
2301                 }
2302               /* The cie_table is discarded by the next if.  */
2303             }
2304
2305           if (cie_table.num_entries != 0)
2306             {
2307               /* Reinit cie_table: debug_frame has different CIEs.  */
2308               xfree (cie_table.entries);
2309               cie_table.num_entries = 0;
2310               cie_table.entries = NULL;
2311             }
2312         }
2313     }
2314
2315   dwarf2_get_section_info (objfile, DWARF2_DEBUG_FRAME,
2316                            &unit->dwarf_frame_section,
2317                            &unit->dwarf_frame_buffer,
2318                            &unit->dwarf_frame_size);
2319   if (unit->dwarf_frame_size)
2320     {
2321       int num_old_fde_entries = fde_table.num_entries;
2322
2323       TRY_CATCH (e, RETURN_MASK_ERROR)
2324         {
2325           frame_ptr = unit->dwarf_frame_buffer;
2326           while (frame_ptr < unit->dwarf_frame_buffer + unit->dwarf_frame_size)
2327             frame_ptr = decode_frame_entry (unit, frame_ptr, 0,
2328                                             &cie_table, &fde_table,
2329                                             EH_CIE_OR_FDE_TYPE_ID);
2330         }
2331       if (e.reason < 0)
2332         {
2333           warning (_("skipping .debug_frame info of %s: %s"),
2334                    objfile->name, e.message);
2335
2336           if (fde_table.num_entries != 0)
2337             {
2338               fde_table.num_entries = num_old_fde_entries;
2339               if (num_old_fde_entries == 0)
2340                 {
2341                   xfree (fde_table.entries);
2342                   fde_table.entries = NULL;
2343                 }
2344               else
2345                 {
2346                   fde_table.entries = xrealloc (fde_table.entries,
2347                                                 fde_table.num_entries *
2348                                                 sizeof (fde_table.entries[0]));
2349                 }
2350             }
2351           fde_table.num_entries = num_old_fde_entries;
2352           /* The cie_table is discarded by the next if.  */
2353         }
2354     }
2355
2356   /* Discard the cie_table, it is no longer needed.  */
2357   if (cie_table.num_entries != 0)
2358     {
2359       xfree (cie_table.entries);
2360       cie_table.entries = NULL;   /* Paranoia.  */
2361       cie_table.num_entries = 0;  /* Paranoia.  */
2362     }
2363
2364   /* Copy fde_table to obstack: it is needed at runtime.  */
2365   fde_table2 = (struct dwarf2_fde_table *)
2366     obstack_alloc (&objfile->objfile_obstack, sizeof (*fde_table2));
2367
2368   if (fde_table.num_entries == 0)
2369     {
2370       fde_table2->entries = NULL;
2371       fde_table2->num_entries = 0;
2372     }
2373   else
2374     {
2375       struct dwarf2_fde *fde_prev = NULL;
2376       struct dwarf2_fde *first_non_zero_fde = NULL;
2377       int i;
2378
2379       /* Prepare FDE table for lookups.  */
2380       qsort (fde_table.entries, fde_table.num_entries,
2381              sizeof (fde_table.entries[0]), qsort_fde_cmp);
2382
2383       /* Check for leftovers from --gc-sections.  The GNU linker sets
2384          the relevant symbols to zero, but doesn't zero the FDE *end*
2385          ranges because there's no relocation there.  It's (offset,
2386          length), not (start, end).  On targets where address zero is
2387          just another valid address this can be a problem, since the
2388          FDEs appear to be non-empty in the output --- we could pick
2389          out the wrong FDE.  To work around this, when overlaps are
2390          detected, we prefer FDEs that do not start at zero.
2391
2392          Start by finding the first FDE with non-zero start.  Below
2393          we'll discard all FDEs that start at zero and overlap this
2394          one.  */
2395       for (i = 0; i < fde_table.num_entries; i++)
2396         {
2397           struct dwarf2_fde *fde = fde_table.entries[i];
2398
2399           if (fde->initial_location != 0)
2400             {
2401               first_non_zero_fde = fde;
2402               break;
2403             }
2404         }
2405
2406       /* Since we'll be doing bsearch, squeeze out identical (except
2407          for eh_frame_p) fde entries so bsearch result is predictable.
2408          Also discard leftovers from --gc-sections.  */
2409       fde_table2->num_entries = 0;
2410       for (i = 0; i < fde_table.num_entries; i++)
2411         {
2412           struct dwarf2_fde *fde = fde_table.entries[i];
2413
2414           if (fde->initial_location == 0
2415               && first_non_zero_fde != NULL
2416               && (first_non_zero_fde->initial_location
2417                   < fde->initial_location + fde->address_range))
2418             continue;
2419
2420           if (fde_prev != NULL
2421               && fde_prev->initial_location == fde->initial_location)
2422             continue;
2423
2424           obstack_grow (&objfile->objfile_obstack, &fde_table.entries[i],
2425                         sizeof (fde_table.entries[0]));
2426           ++fde_table2->num_entries;
2427           fde_prev = fde;
2428         }
2429       fde_table2->entries = obstack_finish (&objfile->objfile_obstack);
2430
2431       /* Discard the original fde_table.  */
2432       xfree (fde_table.entries);
2433     }
2434
2435   set_objfile_data (objfile, dwarf2_frame_objfile_data, fde_table2);
2436 }
2437
2438 /* Provide a prototype to silence -Wmissing-prototypes.  */
2439 void _initialize_dwarf2_frame (void);
2440
2441 void
2442 _initialize_dwarf2_frame (void)
2443 {
2444   dwarf2_frame_data = gdbarch_data_register_pre_init (dwarf2_frame_init);
2445   dwarf2_frame_objfile_data = register_objfile_data ();
2446 }