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