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