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