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