GDB (xrefs)
/tmp/gdb-7.10/gdb/dwarf2-frame.c
Go to the documentation of this file.
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. */
56 
57  /* Constant that is factored out of all advance location
58  instructions. */
60 
61  /* Constants that is factored out of all offset instructions. */
63 
64  /* Return address column. */
66 
67  /* Instruction sequence to initialize a register set. */
69  const gdb_byte *end;
70 
71  /* Saved augmentation, in case it's needed later. */
72  char *augmentation;
73 
74  /* Encoding of addresses. */
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 
97 {
99  struct dwarf2_cie **entries;
100 };
101 
102 /* Frame Description Entry (FDE). */
103 
105 {
106  /* CIE for this FDE. */
107  struct dwarf2_cie *cie;
108 
109  /* First location associated with this FDE. */
111 
112  /* Number of bytes of program instructions described by this FDE. */
114 
115  /* Instruction sequence. */
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 
125 {
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. */
142 
143  /* Length of the loaded .debug_frame section. */
144  bfd_size_type dwarf_frame_size;
145 
146  /* Pointer to the .debug_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 
163  int ptr_len, const gdb_byte *buf,
164  unsigned int *bytes_read_ptr,
165  CORE_ADDR func_base);
166 
167 
169 {
173 };
174 
176 {
178  int num_regs;
179 
184 
185  /* Used to implement DW_CFA_remember_state. */
187 };
188 
189 /* Structure describing a frame state. */
190 
192 {
193  /* Each register save state can be described in terms of a CFA slot,
194  another register, or a location expression. */
196 
197  /* The PC described by the current frame state. */
199 
200  /* Initial register set from the CIE.
201  Used to implement DW_CFA_restore. */
203 
204  /* The information we care about from the CIE. */
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. */
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. */
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
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 *
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
263 {
264  if (rs)
265  {
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
277 {
278  struct dwarf2_frame_state *fs = p;
279 
282  xfree (fs->initial.reg);
283  xfree (fs->regs.reg);
284  xfree (fs);
285 }
286 
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
337 
338  if (fs->regs.reg[reg].how == DWARF2_FRAME_REG_UNSPECIFIED)
340 incomplete CFI data; DW_CFA_restore unspecified\n\
341 register %s (#%d) at %s"),
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 {
354  read_mem,
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);
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;
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 
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);
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);
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);
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);
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);
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;
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  {
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;
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);
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;
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);
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;
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;
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;
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;
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 
659  for (reg = 8; reg < 16; reg++)
660  {
662  fs->regs.reg[reg].loc.reg = reg + 16;
663  }
664  for (reg = 16; reg < 32; reg++)
665  {
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);
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. */
698  fs->regs.prev = NULL;
699  }
700 
701  return insn_ptr;
702 }
703 
704 
705 /* Architecture-specific operations. */
706 
707 /* Per-architecture data key. */
709 
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 *
768 {
769  struct dwarf2_frame_ops *ops;
770 
771  ops = OBSTACK_ZALLOC (obstack, struct dwarf2_frame_ops);
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 = gdbarch_data (gdbarch, dwarf2_frame_data);
786 
787  ops->init_reg = init_reg;
788 }
789 
790 /* Pre-initialize the register state REG for register REGNUM. */
791 
792 static void
793 dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
794  struct dwarf2_frame_state_reg *reg,
795  struct frame_info *this_frame)
796 {
797  struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
798 
799  ops->init_reg (gdbarch, regnum, reg, this_frame);
800 }
801 
802 /* Set the architecture-specific signal trampoline recognition
803  function for GDBARCH to SIGNAL_FRAME_P. */
804 
805 void
806 dwarf2_frame_set_signal_frame_p (struct gdbarch *gdbarch,
807  int (*signal_frame_p) (struct gdbarch *,
808  struct frame_info *))
809 {
810  struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
811 
813 }
814 
815 /* Query the architecture-specific signal frame recognizer for
816  THIS_FRAME. */
817 
818 static int
819 dwarf2_frame_signal_frame_p (struct gdbarch *gdbarch,
820  struct frame_info *this_frame)
821 {
822  struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
823 
824  if (ops->signal_frame_p == NULL)
825  return 0;
826  return ops->signal_frame_p (gdbarch, this_frame);
827 }
828 
829 /* Set the architecture-specific adjustment of .eh_frame and .debug_frame
830  register numbers. */
831 
832 void
833 dwarf2_frame_set_adjust_regnum (struct gdbarch *gdbarch,
834  int (*adjust_regnum) (struct gdbarch *,
835  int, int))
836 {
837  struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
838 
840 }
841 
842 /* Translate a .eh_frame register to DWARF register, or adjust a .debug_frame
843  register. */
844 
845 static int
846 dwarf2_frame_adjust_regnum (struct gdbarch *gdbarch,
847  int regnum, int eh_frame_p)
848 {
849  struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
850 
851  if (ops->adjust_regnum == NULL)
852  return regnum;
853  return ops->adjust_regnum (gdbarch, regnum, eh_frame_p);
854 }
855 
856 static void
858  struct dwarf2_fde *fde)
859 {
860  struct compunit_symtab *cust;
861 
862  cust = find_pc_compunit_symtab (fs->pc);
863  if (cust == NULL)
864  return;
865 
867  {
868  if (fde->cie->version == 1)
869  fs->armcc_cfa_offsets_sf = 1;
870 
871  if (fde->cie->version == 1)
873 
874  /* The reversed offset problem is present in some compilers
875  using DWARF3, but it was eventually fixed. Check the ARM
876  defined augmentations, which are in the format "armcc" followed
877  by a list of one-character options. The "+" option means
878  this problem is fixed (no quirk needed). If the armcc
879  augmentation is missing, the quirk is needed. */
880  if (fde->cie->version == 3
881  && (!startswith (fde->cie->augmentation, "armcc")
882  || strchr (fde->cie->augmentation + 5, '+') == NULL))
884 
885  return;
886  }
887 }
888 
889 
890 /* See dwarf2-frame.h. */
891 
892 int
893 dwarf2_fetch_cfa_info (struct gdbarch *gdbarch, CORE_ADDR pc,
894  struct dwarf2_per_cu_data *data,
895  int *regnum_out, LONGEST *offset_out,
896  CORE_ADDR *text_offset_out,
897  const gdb_byte **cfa_start_out,
898  const gdb_byte **cfa_end_out)
899 {
900  struct dwarf2_fde *fde;
901  CORE_ADDR text_offset;
902  struct dwarf2_frame_state fs;
903  int addr_size;
904 
905  memset (&fs, 0, sizeof (struct dwarf2_frame_state));
906 
907  fs.pc = pc;
908 
909  /* Find the correct FDE. */
910  fde = dwarf2_frame_find_fde (&fs.pc, &text_offset);
911  if (fde == NULL)
912  error (_("Could not compute CFA; needed to translate this expression"));
913 
914  /* Extract any interesting information from the CIE. */
918  addr_size = fde->cie->addr_size;
919 
920  /* Check for "quirks" - known bugs in producers. */
921  dwarf2_frame_find_quirks (&fs, fde);
922 
923  /* First decode all the insns in the CIE. */
925  fde->cie->end, gdbarch, pc, &fs);
926 
927  /* Save the initialized register set. */
928  fs.initial = fs.regs;
930 
931  /* Then decode the insns in the FDE up to our target PC. */
932  execute_cfa_program (fde, fde->instructions, fde->end, gdbarch, pc, &fs);
933 
934  /* Calculate the CFA. */
935  switch (fs.regs.cfa_how)
936  {
937  case CFA_REG_OFFSET:
938  {
939  int regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, fs.regs.cfa_reg);
940 
941  if (regnum == -1)
942  error (_("Unable to access DWARF register number %d"),
943  (int) fs.regs.cfa_reg); /* FIXME */
944 
945  *regnum_out = regnum;
947  *offset_out = -fs.regs.cfa_offset;
948  else
949  *offset_out = fs.regs.cfa_offset;
950  return 1;
951  }
952 
953  case CFA_EXP:
954  *text_offset_out = text_offset;
955  *cfa_start_out = fs.regs.cfa_exp;
956  *cfa_end_out = fs.regs.cfa_exp + fs.regs.cfa_exp_len;
957  return 0;
958 
959  default:
960  internal_error (__FILE__, __LINE__, _("Unknown CFA rule."));
961  }
962 }
963 
964 
966 {
967  /* DWARF Call Frame Address. */
969 
970  /* Set if the return address column was marked as unavailable
971  (required non-collected memory or registers to compute). */
973 
974  /* Set if the return address column was marked as undefined. */
976 
977  /* Saved registers, indexed by GDB register number, not by DWARF
978  register number. */
980 
981  /* Return address register. */
983 
984  /* Target address size in bytes. */
986 
987  /* The .text offset. */
989 
990  /* True if we already checked whether this frame is the bottom frame
991  of a virtual tail call frame chain. */
993 
994  /* If not NULL then this frame is the bottom frame of a TAILCALL_FRAME
995  sequence. If NULL then it is a normal case with no TAILCALL_FRAME
996  involved. Non-bottom frames of a virtual tail call frames chain use
997  dwarf2_tailcall_frame_unwind unwinder so this field does not apply for
998  them. */
1000 
1001  /* The number of bytes to subtract from TAILCALL_FRAME frames frame
1002  base to get the SP, to simulate the return address pushed on the
1003  stack. */
1006 };
1007 
1008 /* A cleanup that sets a pointer to NULL. */
1009 
1010 static void
1012 {
1013  void **ptr = arg;
1014 
1015  *ptr = NULL;
1016 }
1017 
1018 static struct dwarf2_frame_cache *
1019 dwarf2_frame_cache (struct frame_info *this_frame, void **this_cache)
1020 {
1021  struct cleanup *reset_cache_cleanup, *old_chain;
1022  struct gdbarch *gdbarch = get_frame_arch (this_frame);
1023  const int num_regs = gdbarch_num_regs (gdbarch)
1024  + gdbarch_num_pseudo_regs (gdbarch);
1025  struct dwarf2_frame_cache *cache;
1026  struct dwarf2_frame_state *fs;
1027  struct dwarf2_fde *fde;
1028  CORE_ADDR entry_pc;
1029  const gdb_byte *instr;
1030 
1031  if (*this_cache)
1032  return *this_cache;
1033 
1034  /* Allocate a new cache. */
1035  cache = FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache);
1036  cache->reg = FRAME_OBSTACK_CALLOC (num_regs, struct dwarf2_frame_state_reg);
1037  *this_cache = cache;
1038  reset_cache_cleanup = make_cleanup (clear_pointer_cleanup, this_cache);
1039 
1040  /* Allocate and initialize the frame state. */
1041  fs = XCNEW (struct dwarf2_frame_state);
1042  old_chain = make_cleanup (dwarf2_frame_state_free, fs);
1043 
1044  /* Unwind the PC.
1045 
1046  Note that if the next frame is never supposed to return (i.e. a call
1047  to abort), the compiler might optimize away the instruction at
1048  its return address. As a result the return address will
1049  point at some random instruction, and the CFI for that
1050  instruction is probably worthless to us. GCC's unwinder solves
1051  this problem by substracting 1 from the return address to get an
1052  address in the middle of a presumed call instruction (or the
1053  instruction in the associated delay slot). This should only be
1054  done for "normal" frames and not for resume-type frames (signal
1055  handlers, sentinel frames, dummy frames). The function
1056  get_frame_address_in_block does just this. It's not clear how
1057  reliable the method is though; there is the potential for the
1058  register state pre-call being different to that on return. */
1059  fs->pc = get_frame_address_in_block (this_frame);
1060 
1061  /* Find the correct FDE. */
1062  fde = dwarf2_frame_find_fde (&fs->pc, &cache->text_offset);
1063  gdb_assert (fde != NULL);
1064 
1065  /* Extract any interesting information from the CIE. */
1066  fs->data_align = fde->cie->data_alignment_factor;
1067  fs->code_align = fde->cie->code_alignment_factor;
1069  cache->addr_size = fde->cie->addr_size;
1070 
1071  /* Check for "quirks" - known bugs in producers. */
1072  dwarf2_frame_find_quirks (fs, fde);
1073 
1074  /* First decode all the insns in the CIE. */
1076  fde->cie->end, gdbarch,
1077  get_frame_address_in_block (this_frame), fs);
1078 
1079  /* Save the initialized register set. */
1080  fs->initial = fs->regs;
1082 
1083  if (get_frame_func_if_available (this_frame, &entry_pc))
1084  {
1085  /* Decode the insns in the FDE up to the entry PC. */
1086  instr = execute_cfa_program (fde, fde->instructions, fde->end, gdbarch,
1087  entry_pc, fs);
1088 
1089  if (fs->regs.cfa_how == CFA_REG_OFFSET
1090  && (gdbarch_dwarf2_reg_to_regnum (gdbarch, fs->regs.cfa_reg)
1091  == gdbarch_sp_regnum (gdbarch)))
1092  {
1093  cache->entry_cfa_sp_offset = fs->regs.cfa_offset;
1094  cache->entry_cfa_sp_offset_p = 1;
1095  }
1096  }
1097  else
1098  instr = fde->instructions;
1099 
1100  /* Then decode the insns in the FDE up to our target PC. */
1101  execute_cfa_program (fde, instr, fde->end, gdbarch,
1102  get_frame_address_in_block (this_frame), fs);
1103 
1104  TRY
1105  {
1106  /* Calculate the CFA. */
1107  switch (fs->regs.cfa_how)
1108  {
1109  case CFA_REG_OFFSET:
1110  cache->cfa = read_addr_from_reg (this_frame, fs->regs.cfa_reg);
1112  cache->cfa -= fs->regs.cfa_offset;
1113  else
1114  cache->cfa += fs->regs.cfa_offset;
1115  break;
1116 
1117  case CFA_EXP:
1118  cache->cfa =
1119  execute_stack_op (fs->regs.cfa_exp, fs->regs.cfa_exp_len,
1120  cache->addr_size, cache->text_offset,
1121  this_frame, 0, 0);
1122  break;
1123 
1124  default:
1125  internal_error (__FILE__, __LINE__, _("Unknown CFA rule."));
1126  }
1127  }
1128  CATCH (ex, RETURN_MASK_ERROR)
1129  {
1130  if (ex.error == NOT_AVAILABLE_ERROR)
1131  {
1132  cache->unavailable_retaddr = 1;
1133  do_cleanups (old_chain);
1134  discard_cleanups (reset_cache_cleanup);
1135  return cache;
1136  }
1137 
1138  throw_exception (ex);
1139  }
1140  END_CATCH
1141 
1142  /* Initialize the register state. */
1143  {
1144  int regnum;
1145 
1146  for (regnum = 0; regnum < num_regs; regnum++)
1147  dwarf2_frame_init_reg (gdbarch, regnum, &cache->reg[regnum], this_frame);
1148  }
1149 
1150  /* Go through the DWARF2 CFI generated table and save its register
1151  location information in the cache. Note that we don't skip the
1152  return address column; it's perfectly all right for it to
1153  correspond to a real register. If it doesn't correspond to a
1154  real register, or if we shouldn't treat it as such,
1155  gdbarch_dwarf2_reg_to_regnum should be defined to return a number outside
1156  the range [0, gdbarch_num_regs). */
1157  {
1158  int column; /* CFI speak for "register number". */
1159 
1160  for (column = 0; column < fs->regs.num_regs; column++)
1161  {
1162  /* Use the GDB register number as the destination index. */
1163  int regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, column);
1164 
1165  /* If there's no corresponding GDB register, ignore it. */
1166  if (regnum < 0 || regnum >= num_regs)
1167  continue;
1168 
1169  /* NOTE: cagney/2003-09-05: CFI should specify the disposition
1170  of all debug info registers. If it doesn't, complain (but
1171  not too loudly). It turns out that GCC assumes that an
1172  unspecified register implies "same value" when CFI (draft
1173  7) specifies nothing at all. Such a register could equally
1174  be interpreted as "undefined". Also note that this check
1175  isn't sufficient; it only checks that all registers in the
1176  range [0 .. max column] are specified, and won't detect
1177  problems when a debug info register falls outside of the
1178  table. We need a way of iterating through all the valid
1179  DWARF2 register numbers. */
1180  if (fs->regs.reg[column].how == DWARF2_FRAME_REG_UNSPECIFIED)
1181  {
1182  if (cache->reg[regnum].how == DWARF2_FRAME_REG_UNSPECIFIED)
1184 incomplete CFI data; unspecified registers (e.g., %s) at %s"),
1185  gdbarch_register_name (gdbarch, regnum),
1186  paddress (gdbarch, fs->pc));
1187  }
1188  else
1189  cache->reg[regnum] = fs->regs.reg[column];
1190  }
1191  }
1192 
1193  /* Eliminate any DWARF2_FRAME_REG_RA rules, and save the information
1194  we need for evaluating DWARF2_FRAME_REG_RA_OFFSET rules. */
1195  {
1196  int regnum;
1197 
1198  for (regnum = 0; regnum < num_regs; regnum++)
1199  {
1200  if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA
1201  || cache->reg[regnum].how == DWARF2_FRAME_REG_RA_OFFSET)
1202  {
1203  struct dwarf2_frame_state_reg *retaddr_reg =
1204  &fs->regs.reg[fs->retaddr_column];
1205 
1206  /* It seems rather bizarre to specify an "empty" column as
1207  the return adress column. However, this is exactly
1208  what GCC does on some targets. It turns out that GCC
1209  assumes that the return address can be found in the
1210  register corresponding to the return address column.
1211  Incidentally, that's how we should treat a return
1212  address column specifying "same value" too. */
1213  if (fs->retaddr_column < fs->regs.num_regs
1214  && retaddr_reg->how != DWARF2_FRAME_REG_UNSPECIFIED
1215  && retaddr_reg->how != DWARF2_FRAME_REG_SAME_VALUE)
1216  {
1217  if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
1218  cache->reg[regnum] = *retaddr_reg;
1219  else
1220  cache->retaddr_reg = *retaddr_reg;
1221  }
1222  else
1223  {
1224  if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
1225  {
1226  cache->reg[regnum].loc.reg = fs->retaddr_column;
1228  }
1229  else
1230  {
1231  cache->retaddr_reg.loc.reg = fs->retaddr_column;
1233  }
1234  }
1235  }
1236  }
1237  }
1238 
1239  if (fs->retaddr_column < fs->regs.num_regs
1241  cache->undefined_retaddr = 1;
1242 
1243  do_cleanups (old_chain);
1244  discard_cleanups (reset_cache_cleanup);
1245  return cache;
1246 }
1247 
1248 static enum unwind_stop_reason
1250  void **this_cache)
1251 {
1252  struct dwarf2_frame_cache *cache
1253  = dwarf2_frame_cache (this_frame, this_cache);
1254 
1255  if (cache->unavailable_retaddr)
1256  return UNWIND_UNAVAILABLE;
1257 
1258  if (cache->undefined_retaddr)
1259  return UNWIND_OUTERMOST;
1260 
1261  return UNWIND_NO_REASON;
1262 }
1263 
1264 static void
1265 dwarf2_frame_this_id (struct frame_info *this_frame, void **this_cache,
1266  struct frame_id *this_id)
1267 {
1268  struct dwarf2_frame_cache *cache =
1269  dwarf2_frame_cache (this_frame, this_cache);
1270 
1271  if (cache->unavailable_retaddr)
1272  (*this_id) = frame_id_build_unavailable_stack (get_frame_func (this_frame));
1273  else if (cache->undefined_retaddr)
1274  return;
1275  else
1276  (*this_id) = frame_id_build (cache->cfa, get_frame_func (this_frame));
1277 }
1278 
1279 static struct value *
1280 dwarf2_frame_prev_register (struct frame_info *this_frame, void **this_cache,
1281  int regnum)
1282 {
1283  struct gdbarch *gdbarch = get_frame_arch (this_frame);
1284  struct dwarf2_frame_cache *cache =
1285  dwarf2_frame_cache (this_frame, this_cache);
1286  CORE_ADDR addr;
1287  int realnum;
1288 
1289  /* Check whether THIS_FRAME is the bottom frame of a virtual tail
1290  call frame chain. */
1291  if (!cache->checked_tailcall_bottom)
1292  {
1293  cache->checked_tailcall_bottom = 1;
1294  dwarf2_tailcall_sniffer_first (this_frame, &cache->tailcall_cache,
1295  (cache->entry_cfa_sp_offset_p
1296  ? &cache->entry_cfa_sp_offset : NULL));
1297  }
1298 
1299  /* Non-bottom frames of a virtual tail call frames chain use
1300  dwarf2_tailcall_frame_unwind unwinder so this code does not apply for
1301  them. If dwarf2_tailcall_prev_register_first does not have specific value
1302  unwind the register, tail call frames are assumed to have the register set
1303  of the top caller. */
1304  if (cache->tailcall_cache)
1305  {
1306  struct value *val;
1307 
1308  val = dwarf2_tailcall_prev_register_first (this_frame,
1309  &cache->tailcall_cache,
1310  regnum);
1311  if (val)
1312  return val;
1313  }
1314 
1315  switch (cache->reg[regnum].how)
1316  {
1318  /* If CFI explicitly specified that the value isn't defined,
1319  mark it as optimized away; the value isn't available. */
1320  return frame_unwind_got_optimized (this_frame, regnum);
1321 
1323  addr = cache->cfa + cache->reg[regnum].loc.offset;
1324  return frame_unwind_got_memory (this_frame, regnum, addr);
1325 
1327  realnum
1328  = gdbarch_dwarf2_reg_to_regnum (gdbarch, cache->reg[regnum].loc.reg);
1329  return frame_unwind_got_register (this_frame, regnum, realnum);
1330 
1332  addr = execute_stack_op (cache->reg[regnum].loc.exp,
1333  cache->reg[regnum].exp_len,
1334  cache->addr_size, cache->text_offset,
1335  this_frame, cache->cfa, 1);
1336  return frame_unwind_got_memory (this_frame, regnum, addr);
1337 
1339  addr = cache->cfa + cache->reg[regnum].loc.offset;
1340  return frame_unwind_got_constant (this_frame, regnum, addr);
1341 
1343  addr = execute_stack_op (cache->reg[regnum].loc.exp,
1344  cache->reg[regnum].exp_len,
1345  cache->addr_size, cache->text_offset,
1346  this_frame, cache->cfa, 1);
1347  return frame_unwind_got_constant (this_frame, regnum, addr);
1348 
1350  /* GCC, in its infinite wisdom decided to not provide unwind
1351  information for registers that are "same value". Since
1352  DWARF2 (3 draft 7) doesn't define such behavior, said
1353  registers are actually undefined (which is different to CFI
1354  "undefined"). Code above issues a complaint about this.
1355  Here just fudge the books, assume GCC, and that the value is
1356  more inner on the stack. */
1357  return frame_unwind_got_register (this_frame, regnum, regnum);
1358 
1360  return frame_unwind_got_register (this_frame, regnum, regnum);
1361 
1362  case DWARF2_FRAME_REG_CFA:
1363  return frame_unwind_got_address (this_frame, regnum, cache->cfa);
1364 
1366  addr = cache->cfa + cache->reg[regnum].loc.offset;
1367  return frame_unwind_got_address (this_frame, regnum, addr);
1368 
1370  addr = cache->reg[regnum].loc.offset;
1372  (gdbarch, cache->retaddr_reg.loc.reg);
1373  addr += get_frame_register_unsigned (this_frame, regnum);
1374  return frame_unwind_got_address (this_frame, regnum, addr);
1375 
1376  case DWARF2_FRAME_REG_FN:
1377  return cache->reg[regnum].loc.fn (this_frame, this_cache, regnum);
1378 
1379  default:
1380  internal_error (__FILE__, __LINE__, _("Unknown register rule."));
1381  }
1382 }
1383 
1384 /* Proxy for tailcall_frame_dealloc_cache for bottom frame of a virtual tail
1385  call frames chain. */
1386 
1387 static void
1388 dwarf2_frame_dealloc_cache (struct frame_info *self, void *this_cache)
1389 {
1390  struct dwarf2_frame_cache *cache = dwarf2_frame_cache (self, &this_cache);
1391 
1392  if (cache->tailcall_cache)
1394 }
1395 
1396 static int
1398  struct frame_info *this_frame, void **this_cache)
1399 {
1400  /* Grab an address that is guarenteed to reside somewhere within the
1401  function. get_frame_pc(), with a no-return next function, can
1402  end up returning something past the end of this function's body.
1403  If the frame we're sniffing for is a signal frame whose start
1404  address is placed on the stack by the OS, its FDE must
1405  extend one byte before its start address or we could potentially
1406  select the FDE of the previous function. */
1407  CORE_ADDR block_addr = get_frame_address_in_block (this_frame);
1408  struct dwarf2_fde *fde = dwarf2_frame_find_fde (&block_addr, NULL);
1409 
1410  if (!fde)
1411  return 0;
1412 
1413  /* On some targets, signal trampolines may have unwind information.
1414  We need to recognize them so that we set the frame type
1415  correctly. */
1416 
1417  if (fde->cie->signal_frame
1419  this_frame))
1420  return self->type == SIGTRAMP_FRAME;
1421 
1422  if (self->type != NORMAL_FRAME)
1423  return 0;
1424 
1425  return 1;
1426 }
1427 
1428 static const struct frame_unwind dwarf2_frame_unwind =
1429 {
1430  NORMAL_FRAME,
1434  NULL,
1437 };
1438 
1439 static const struct frame_unwind dwarf2_signal_frame_unwind =
1440 {
1445  NULL,
1447 
1448  /* TAILCALL_CACHE can never be in such frame to need dealloc_cache. */
1449  NULL
1450 };
1451 
1452 /* Append the DWARF-2 frame unwinders to GDBARCH's list. */
1453 
1454 void
1455 dwarf2_append_unwinders (struct gdbarch *gdbarch)
1456 {
1457  /* TAILCALL_FRAME must be first to find the record by
1458  dwarf2_tailcall_sniffer_first. */
1460 
1461  frame_unwind_append_unwinder (gdbarch, &dwarf2_frame_unwind);
1462  frame_unwind_append_unwinder (gdbarch, &dwarf2_signal_frame_unwind);
1463 }
1464 
1465 
1466 /* There is no explicitly defined relationship between the CFA and the
1467  location of frame's local variables and arguments/parameters.
1468  Therefore, frame base methods on this page should probably only be
1469  used as a last resort, just to avoid printing total garbage as a
1470  response to the "info frame" command. */
1471 
1472 static CORE_ADDR
1473 dwarf2_frame_base_address (struct frame_info *this_frame, void **this_cache)
1474 {
1475  struct dwarf2_frame_cache *cache =
1476  dwarf2_frame_cache (this_frame, this_cache);
1477 
1478  return cache->cfa;
1479 }
1480 
1481 static const struct frame_base dwarf2_frame_base =
1482 {
1486  dwarf2_frame_base_address
1487 };
1488 
1489 const struct frame_base *
1491 {
1492  CORE_ADDR block_addr = get_frame_address_in_block (this_frame);
1493 
1494  if (dwarf2_frame_find_fde (&block_addr, NULL))
1495  return &dwarf2_frame_base;
1496 
1497  return NULL;
1498 }
1499 
1500 /* Compute the CFA for THIS_FRAME, but only if THIS_FRAME came from
1501  the DWARF unwinder. This is used to implement
1502  DW_OP_call_frame_cfa. */
1503 
1504 CORE_ADDR
1505 dwarf2_frame_cfa (struct frame_info *this_frame)
1506 {
1510  _("cfa not available for record btrace target"));
1511 
1512  while (get_frame_type (this_frame) == INLINE_FRAME)
1513  this_frame = get_prev_frame (this_frame);
1514  if (get_frame_unwind_stop_reason (this_frame) == UNWIND_UNAVAILABLE)
1516  _("can't compute CFA for this frame: "
1517  "required registers or memory are unavailable"));
1518 
1519  if (get_frame_id (this_frame).stack_status != FID_STACK_VALID)
1521  _("can't compute CFA for this frame: "
1522  "frame base not available"));
1523 
1524  return get_frame_base (this_frame);
1525 }
1526 
1527 const struct objfile_data *dwarf2_frame_objfile_data;
1528 
1529 static unsigned int
1530 read_1_byte (bfd *abfd, const gdb_byte *buf)
1531 {
1532  return bfd_get_8 (abfd, buf);
1533 }
1534 
1535 static unsigned int
1536 read_4_bytes (bfd *abfd, const gdb_byte *buf)
1537 {
1538  return bfd_get_32 (abfd, buf);
1539 }
1540 
1541 static ULONGEST
1542 read_8_bytes (bfd *abfd, const gdb_byte *buf)
1543 {
1544  return bfd_get_64 (abfd, buf);
1545 }
1546 
1547 static ULONGEST
1548 read_initial_length (bfd *abfd, const gdb_byte *buf,
1549  unsigned int *bytes_read_ptr)
1550 {
1551  LONGEST result;
1552 
1553  result = bfd_get_32 (abfd, buf);
1554  if (result == 0xffffffff)
1555  {
1556  result = bfd_get_64 (abfd, buf + 4);
1557  *bytes_read_ptr = 12;
1558  }
1559  else
1560  *bytes_read_ptr = 4;
1561 
1562  return result;
1563 }
1564 
1565 
1566 /* Pointer encoding helper functions. */
1567 
1568 /* GCC supports exception handling based on DWARF2 CFI. However, for
1569  technical reasons, it encodes addresses in its FDE's in a different
1570  way. Several "pointer encodings" are supported. The encoding
1571  that's used for a particular FDE is determined by the 'R'
1572  augmentation in the associated CIE. The argument of this
1573  augmentation is a single byte.
1574 
1575  The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a
1576  LEB128. This is encoded in bits 0, 1 and 2. Bit 3 encodes whether
1577  the address is signed or unsigned. Bits 4, 5 and 6 encode how the
1578  address should be interpreted (absolute, relative to the current
1579  position in the FDE, ...). Bit 7, indicates that the address
1580  should be dereferenced. */
1581 
1582 static gdb_byte
1583 encoding_for_size (unsigned int size)
1584 {
1585  switch (size)
1586  {
1587  case 2:
1588  return DW_EH_PE_udata2;
1589  case 4:
1590  return DW_EH_PE_udata4;
1591  case 8:
1592  return DW_EH_PE_udata8;
1593  default:
1594  internal_error (__FILE__, __LINE__, _("Unsupported address size"));
1595  }
1596 }
1597 
1598 static CORE_ADDR
1600  int ptr_len, const gdb_byte *buf,
1601  unsigned int *bytes_read_ptr,
1602  CORE_ADDR func_base)
1603 {
1604  ptrdiff_t offset;
1605  CORE_ADDR base;
1606 
1607  /* GCC currently doesn't generate DW_EH_PE_indirect encodings for
1608  FDE's. */
1609  if (encoding & DW_EH_PE_indirect)
1610  internal_error (__FILE__, __LINE__,
1611  _("Unsupported encoding: DW_EH_PE_indirect"));
1612 
1613  *bytes_read_ptr = 0;
1614 
1615  switch (encoding & 0x70)
1616  {
1617  case DW_EH_PE_absptr:
1618  base = 0;
1619  break;
1620  case DW_EH_PE_pcrel:
1621  base = bfd_get_section_vma (unit->abfd, unit->dwarf_frame_section);
1622  base += (buf - unit->dwarf_frame_buffer);
1623  break;
1624  case DW_EH_PE_datarel:
1625  base = unit->dbase;
1626  break;
1627  case DW_EH_PE_textrel:
1628  base = unit->tbase;
1629  break;
1630  case DW_EH_PE_funcrel:
1631  base = func_base;
1632  break;
1633  case DW_EH_PE_aligned:
1634  base = 0;
1635  offset = buf - unit->dwarf_frame_buffer;
1636  if ((offset % ptr_len) != 0)
1637  {
1638  *bytes_read_ptr = ptr_len - (offset % ptr_len);
1639  buf += *bytes_read_ptr;
1640  }
1641  break;
1642  default:
1643  internal_error (__FILE__, __LINE__,
1644  _("Invalid or unsupported encoding"));
1645  }
1646 
1647  if ((encoding & 0x07) == 0x00)
1648  {
1649  encoding |= encoding_for_size (ptr_len);
1650  if (bfd_get_sign_extend_vma (unit->abfd))
1651  encoding |= DW_EH_PE_signed;
1652  }
1653 
1654  switch (encoding & 0x0f)
1655  {
1656  case DW_EH_PE_uleb128:
1657  {
1658  uint64_t value;
1659  const gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1660 
1661  *bytes_read_ptr += safe_read_uleb128 (buf, end_buf, &value) - buf;
1662  return base + value;
1663  }
1664  case DW_EH_PE_udata2:
1665  *bytes_read_ptr += 2;
1666  return (base + bfd_get_16 (unit->abfd, (bfd_byte *) buf));
1667  case DW_EH_PE_udata4:
1668  *bytes_read_ptr += 4;
1669  return (base + bfd_get_32 (unit->abfd, (bfd_byte *) buf));
1670  case DW_EH_PE_udata8:
1671  *bytes_read_ptr += 8;
1672  return (base + bfd_get_64 (unit->abfd, (bfd_byte *) buf));
1673  case DW_EH_PE_sleb128:
1674  {
1675  int64_t value;
1676  const gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1677 
1678  *bytes_read_ptr += safe_read_sleb128 (buf, end_buf, &value) - buf;
1679  return base + value;
1680  }
1681  case DW_EH_PE_sdata2:
1682  *bytes_read_ptr += 2;
1683  return (base + bfd_get_signed_16 (unit->abfd, (bfd_byte *) buf));
1684  case DW_EH_PE_sdata4:
1685  *bytes_read_ptr += 4;
1686  return (base + bfd_get_signed_32 (unit->abfd, (bfd_byte *) buf));
1687  case DW_EH_PE_sdata8:
1688  *bytes_read_ptr += 8;
1689  return (base + bfd_get_signed_64 (unit->abfd, (bfd_byte *) buf));
1690  default:
1691  internal_error (__FILE__, __LINE__,
1692  _("Invalid or unsupported encoding"));
1693  }
1694 }
1695 
1696 
1697 static int
1698 bsearch_cie_cmp (const void *key, const void *element)
1699 {
1700  ULONGEST cie_pointer = *(ULONGEST *) key;
1701  struct dwarf2_cie *cie = *(struct dwarf2_cie **) element;
1702 
1703  if (cie_pointer == cie->cie_pointer)
1704  return 0;
1705 
1706  return (cie_pointer < cie->cie_pointer) ? -1 : 1;
1707 }
1708 
1709 /* Find CIE with the given CIE_POINTER in CIE_TABLE. */
1710 static struct dwarf2_cie *
1712 {
1713  struct dwarf2_cie **p_cie;
1714 
1715  /* The C standard (ISO/IEC 9899:TC2) requires the BASE argument to
1716  bsearch be non-NULL. */
1717  if (cie_table->entries == NULL)
1718  {
1719  gdb_assert (cie_table->num_entries == 0);
1720  return NULL;
1721  }
1722 
1723  p_cie = bsearch (&cie_pointer, cie_table->entries, cie_table->num_entries,
1724  sizeof (cie_table->entries[0]), bsearch_cie_cmp);
1725  if (p_cie != NULL)
1726  return *p_cie;
1727  return NULL;
1728 }
1729 
1730 /* Add a pointer to new CIE to the CIE_TABLE, allocating space for it. */
1731 static void
1732 add_cie (struct dwarf2_cie_table *cie_table, struct dwarf2_cie *cie)
1733 {
1734  const int n = cie_table->num_entries;
1735 
1736  gdb_assert (n < 1
1737  || cie_table->entries[n - 1]->cie_pointer < cie->cie_pointer);
1738 
1739  cie_table->entries =
1740  xrealloc (cie_table->entries, (n + 1) * sizeof (cie_table->entries[0]));
1741  cie_table->entries[n] = cie;
1742  cie_table->num_entries = n + 1;
1743 }
1744 
1745 static int
1746 bsearch_fde_cmp (const void *key, const void *element)
1747 {
1748  CORE_ADDR seek_pc = *(CORE_ADDR *) key;
1749  struct dwarf2_fde *fde = *(struct dwarf2_fde **) element;
1750 
1751  if (seek_pc < fde->initial_location)
1752  return -1;
1753  if (seek_pc < fde->initial_location + fde->address_range)
1754  return 0;
1755  return 1;
1756 }
1757 
1758 /* Find the FDE for *PC. Return a pointer to the FDE, and store the
1759  inital location associated with it into *PC. */
1760 
1761 static struct dwarf2_fde *
1763 {
1764  struct objfile *objfile;
1765 
1766  ALL_OBJFILES (objfile)
1767  {
1768  struct dwarf2_fde_table *fde_table;
1769  struct dwarf2_fde **p_fde;
1770  CORE_ADDR offset;
1771  CORE_ADDR seek_pc;
1772 
1773  fde_table = objfile_data (objfile, dwarf2_frame_objfile_data);
1774  if (fde_table == NULL)
1775  {
1776  dwarf2_build_frame_info (objfile);
1777  fde_table = objfile_data (objfile, dwarf2_frame_objfile_data);
1778  }
1779  gdb_assert (fde_table != NULL);
1780 
1781  if (fde_table->num_entries == 0)
1782  continue;
1783 
1784  gdb_assert (objfile->section_offsets);
1785  offset = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1786 
1787  gdb_assert (fde_table->num_entries > 0);
1788  if (*pc < offset + fde_table->entries[0]->initial_location)
1789  continue;
1790 
1791  seek_pc = *pc - offset;
1792  p_fde = bsearch (&seek_pc, fde_table->entries, fde_table->num_entries,
1793  sizeof (fde_table->entries[0]), bsearch_fde_cmp);
1794  if (p_fde != NULL)
1795  {
1796  *pc = (*p_fde)->initial_location + offset;
1797  if (out_offset)
1798  *out_offset = offset;
1799  return *p_fde;
1800  }
1801  }
1802  return NULL;
1803 }
1804 
1805 /* Add a pointer to new FDE to the FDE_TABLE, allocating space for it. */
1806 static void
1807 add_fde (struct dwarf2_fde_table *fde_table, struct dwarf2_fde *fde)
1808 {
1809  if (fde->address_range == 0)
1810  /* Discard useless FDEs. */
1811  return;
1812 
1813  fde_table->num_entries += 1;
1814  fde_table->entries =
1815  xrealloc (fde_table->entries,
1816  fde_table->num_entries * sizeof (fde_table->entries[0]));
1817  fde_table->entries[fde_table->num_entries - 1] = fde;
1818 }
1819 
1820 #define DW64_CIE_ID 0xffffffffffffffffULL
1821 
1822 /* Defines the type of eh_frames that are expected to be decoded: CIE, FDE
1823  or any of them. */
1824 
1826 {
1827  EH_CIE_TYPE_ID = 1 << 0,
1828  EH_FDE_TYPE_ID = 1 << 1,
1830 };
1831 
1832 static const gdb_byte *decode_frame_entry (struct comp_unit *unit,
1833  const gdb_byte *start,
1834  int eh_frame_p,
1835  struct dwarf2_cie_table *cie_table,
1836  struct dwarf2_fde_table *fde_table,
1837  enum eh_frame_type entry_type);
1838 
1839 /* Decode the next CIE or FDE, entry_type specifies the expected type.
1840  Return NULL if invalid input, otherwise the next byte to be processed. */
1841 
1842 static const gdb_byte *
1843 decode_frame_entry_1 (struct comp_unit *unit, const gdb_byte *start,
1844  int eh_frame_p,
1845  struct dwarf2_cie_table *cie_table,
1846  struct dwarf2_fde_table *fde_table,
1847  enum eh_frame_type entry_type)
1848 {
1849  struct gdbarch *gdbarch = get_objfile_arch (unit->objfile);
1850  const gdb_byte *buf, *end;
1851  LONGEST length;
1852  unsigned int bytes_read;
1853  int dwarf64_p;
1854  ULONGEST cie_id;
1855  ULONGEST cie_pointer;
1856  int64_t sleb128;
1857  uint64_t uleb128;
1858 
1859  buf = start;
1860  length = read_initial_length (unit->abfd, buf, &bytes_read);
1861  buf += bytes_read;
1862  end = buf + length;
1863 
1864  /* Are we still within the section? */
1865  if (end > unit->dwarf_frame_buffer + unit->dwarf_frame_size)
1866  return NULL;
1867 
1868  if (length == 0)
1869  return end;
1870 
1871  /* Distinguish between 32 and 64-bit encoded frame info. */
1872  dwarf64_p = (bytes_read == 12);
1873 
1874  /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs. */
1875  if (eh_frame_p)
1876  cie_id = 0;
1877  else if (dwarf64_p)
1878  cie_id = DW64_CIE_ID;
1879  else
1880  cie_id = DW_CIE_ID;
1881 
1882  if (dwarf64_p)
1883  {
1884  cie_pointer = read_8_bytes (unit->abfd, buf);
1885  buf += 8;
1886  }
1887  else
1888  {
1889  cie_pointer = read_4_bytes (unit->abfd, buf);
1890  buf += 4;
1891  }
1892 
1893  if (cie_pointer == cie_id)
1894  {
1895  /* This is a CIE. */
1896  struct dwarf2_cie *cie;
1897  char *augmentation;
1898  unsigned int cie_version;
1899 
1900  /* Check that a CIE was expected. */
1901  if ((entry_type & EH_CIE_TYPE_ID) == 0)
1902  error (_("Found a CIE when not expecting it."));
1903 
1904  /* Record the offset into the .debug_frame section of this CIE. */
1905  cie_pointer = start - unit->dwarf_frame_buffer;
1906 
1907  /* Check whether we've already read it. */
1908  if (find_cie (cie_table, cie_pointer))
1909  return end;
1910 
1911  cie = (struct dwarf2_cie *)
1912  obstack_alloc (&unit->objfile->objfile_obstack,
1913  sizeof (struct dwarf2_cie));
1914  cie->initial_instructions = NULL;
1915  cie->cie_pointer = cie_pointer;
1916 
1917  /* The encoding for FDE's in a normal .debug_frame section
1918  depends on the target address size. */
1919  cie->encoding = DW_EH_PE_absptr;
1920 
1921  /* We'll determine the final value later, but we need to
1922  initialize it conservatively. */
1923  cie->signal_frame = 0;
1924 
1925  /* Check version number. */
1926  cie_version = read_1_byte (unit->abfd, buf);
1927  if (cie_version != 1 && cie_version != 3 && cie_version != 4)
1928  return NULL;
1929  cie->version = cie_version;
1930  buf += 1;
1931 
1932  /* Interpret the interesting bits of the augmentation. */
1933  cie->augmentation = augmentation = (char *) buf;
1934  buf += (strlen (augmentation) + 1);
1935 
1936  /* Ignore armcc augmentations. We only use them for quirks,
1937  and that doesn't happen until later. */
1938  if (startswith (augmentation, "armcc"))
1939  augmentation += strlen (augmentation);
1940 
1941  /* The GCC 2.x "eh" augmentation has a pointer immediately
1942  following the augmentation string, so it must be handled
1943  first. */
1944  if (augmentation[0] == 'e' && augmentation[1] == 'h')
1945  {
1946  /* Skip. */
1947  buf += gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
1948  augmentation += 2;
1949  }
1950 
1951  if (cie->version >= 4)
1952  {
1953  /* FIXME: check that this is the same as from the CU header. */
1954  cie->addr_size = read_1_byte (unit->abfd, buf);
1955  ++buf;
1956  cie->segment_size = read_1_byte (unit->abfd, buf);
1957  ++buf;
1958  }
1959  else
1960  {
1961  cie->addr_size = gdbarch_dwarf2_addr_size (gdbarch);
1962  cie->segment_size = 0;
1963  }
1964  /* Address values in .eh_frame sections are defined to have the
1965  target's pointer size. Watchout: This breaks frame info for
1966  targets with pointer size < address size, unless a .debug_frame
1967  section exists as well. */
1968  if (eh_frame_p)
1969  cie->ptr_size = gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
1970  else
1971  cie->ptr_size = cie->addr_size;
1972 
1973  buf = gdb_read_uleb128 (buf, end, &uleb128);
1974  if (buf == NULL)
1975  return NULL;
1976  cie->code_alignment_factor = uleb128;
1977 
1978  buf = gdb_read_sleb128 (buf, end, &sleb128);
1979  if (buf == NULL)
1980  return NULL;
1981  cie->data_alignment_factor = sleb128;
1982 
1983  if (cie_version == 1)
1984  {
1985  cie->return_address_register = read_1_byte (unit->abfd, buf);
1986  ++buf;
1987  }
1988  else
1989  {
1990  buf = gdb_read_uleb128 (buf, end, &uleb128);
1991  if (buf == NULL)
1992  return NULL;
1993  cie->return_address_register = uleb128;
1994  }
1995 
1997  = dwarf2_frame_adjust_regnum (gdbarch,
1999  eh_frame_p);
2000 
2001  cie->saw_z_augmentation = (*augmentation == 'z');
2002  if (cie->saw_z_augmentation)
2003  {
2004  uint64_t length;
2005 
2006  buf = gdb_read_uleb128 (buf, end, &length);
2007  if (buf == NULL)
2008  return NULL;
2009  cie->initial_instructions = buf + length;
2010  augmentation++;
2011  }
2012 
2013  while (*augmentation)
2014  {
2015  /* "L" indicates a byte showing how the LSDA pointer is encoded. */
2016  if (*augmentation == 'L')
2017  {
2018  /* Skip. */
2019  buf++;
2020  augmentation++;
2021  }
2022 
2023  /* "R" indicates a byte indicating how FDE addresses are encoded. */
2024  else if (*augmentation == 'R')
2025  {
2026  cie->encoding = *buf++;
2027  augmentation++;
2028  }
2029 
2030  /* "P" indicates a personality routine in the CIE augmentation. */
2031  else if (*augmentation == 'P')
2032  {
2033  /* Skip. Avoid indirection since we throw away the result. */
2034  gdb_byte encoding = (*buf++) & ~DW_EH_PE_indirect;
2035  read_encoded_value (unit, encoding, cie->ptr_size,
2036  buf, &bytes_read, 0);
2037  buf += bytes_read;
2038  augmentation++;
2039  }
2040 
2041  /* "S" indicates a signal frame, such that the return
2042  address must not be decremented to locate the call frame
2043  info for the previous frame; it might even be the first
2044  instruction of a function, so decrementing it would take
2045  us to a different function. */
2046  else if (*augmentation == 'S')
2047  {
2048  cie->signal_frame = 1;
2049  augmentation++;
2050  }
2051 
2052  /* Otherwise we have an unknown augmentation. Assume that either
2053  there is no augmentation data, or we saw a 'z' prefix. */
2054  else
2055  {
2056  if (cie->initial_instructions)
2057  buf = cie->initial_instructions;
2058  break;
2059  }
2060  }
2061 
2062  cie->initial_instructions = buf;
2063  cie->end = end;
2064  cie->unit = unit;
2065 
2066  add_cie (cie_table, cie);
2067  }
2068  else
2069  {
2070  /* This is a FDE. */
2071  struct dwarf2_fde *fde;
2072  CORE_ADDR addr;
2073 
2074  /* Check that an FDE was expected. */
2075  if ((entry_type & EH_FDE_TYPE_ID) == 0)
2076  error (_("Found an FDE when not expecting it."));
2077 
2078  /* In an .eh_frame section, the CIE pointer is the delta between the
2079  address within the FDE where the CIE pointer is stored and the
2080  address of the CIE. Convert it to an offset into the .eh_frame
2081  section. */
2082  if (eh_frame_p)
2083  {
2084  cie_pointer = buf - unit->dwarf_frame_buffer - cie_pointer;
2085  cie_pointer -= (dwarf64_p ? 8 : 4);
2086  }
2087 
2088  /* In either case, validate the result is still within the section. */
2089  if (cie_pointer >= unit->dwarf_frame_size)
2090  return NULL;
2091 
2092  fde = (struct dwarf2_fde *)
2093  obstack_alloc (&unit->objfile->objfile_obstack,
2094  sizeof (struct dwarf2_fde));
2095  fde->cie = find_cie (cie_table, cie_pointer);
2096  if (fde->cie == NULL)
2097  {
2098  decode_frame_entry (unit, unit->dwarf_frame_buffer + cie_pointer,
2099  eh_frame_p, cie_table, fde_table,
2100  EH_CIE_TYPE_ID);
2101  fde->cie = find_cie (cie_table, cie_pointer);
2102  }
2103 
2104  gdb_assert (fde->cie != NULL);
2105 
2106  addr = read_encoded_value (unit, fde->cie->encoding, fde->cie->ptr_size,
2107  buf, &bytes_read, 0);
2108  fde->initial_location = gdbarch_adjust_dwarf2_addr (gdbarch, addr);
2109  buf += bytes_read;
2110 
2111  fde->address_range =
2112  read_encoded_value (unit, fde->cie->encoding & 0x0f,
2113  fde->cie->ptr_size, buf, &bytes_read, 0);
2114  addr = gdbarch_adjust_dwarf2_addr (gdbarch, addr + fde->address_range);
2115  fde->address_range = addr - fde->initial_location;
2116  buf += bytes_read;
2117 
2118  /* A 'z' augmentation in the CIE implies the presence of an
2119  augmentation field in the FDE as well. The only thing known
2120  to be in here at present is the LSDA entry for EH. So we
2121  can skip the whole thing. */
2122  if (fde->cie->saw_z_augmentation)
2123  {
2124  uint64_t length;
2125 
2126  buf = gdb_read_uleb128 (buf, end, &length);
2127  if (buf == NULL)
2128  return NULL;
2129  buf += length;
2130  if (buf > end)
2131  return NULL;
2132  }
2133 
2134  fde->instructions = buf;
2135  fde->end = end;
2136 
2137  fde->eh_frame_p = eh_frame_p;
2138 
2139  add_fde (fde_table, fde);
2140  }
2141 
2142  return end;
2143 }
2144 
2145 /* Read a CIE or FDE in BUF and decode it. Entry_type specifies whether we
2146  expect an FDE or a CIE. */
2147 
2148 static const gdb_byte *
2149 decode_frame_entry (struct comp_unit *unit, const gdb_byte *start,
2150  int eh_frame_p,
2151  struct dwarf2_cie_table *cie_table,
2152  struct dwarf2_fde_table *fde_table,
2153  enum eh_frame_type entry_type)
2154 {
2155  enum { NONE, ALIGN4, ALIGN8, FAIL } workaround = NONE;
2156  const gdb_byte *ret;
2157  ptrdiff_t start_offset;
2158 
2159  while (1)
2160  {
2161  ret = decode_frame_entry_1 (unit, start, eh_frame_p,
2162  cie_table, fde_table, entry_type);
2163  if (ret != NULL)
2164  break;
2165 
2166  /* We have corrupt input data of some form. */
2167 
2168  /* ??? Try, weakly, to work around compiler/assembler/linker bugs
2169  and mismatches wrt padding and alignment of debug sections. */
2170  /* Note that there is no requirement in the standard for any
2171  alignment at all in the frame unwind sections. Testing for
2172  alignment before trying to interpret data would be incorrect.
2173 
2174  However, GCC traditionally arranged for frame sections to be
2175  sized such that the FDE length and CIE fields happen to be
2176  aligned (in theory, for performance). This, unfortunately,
2177  was done with .align directives, which had the side effect of
2178  forcing the section to be aligned by the linker.
2179 
2180  This becomes a problem when you have some other producer that
2181  creates frame sections that are not as strictly aligned. That
2182  produces a hole in the frame info that gets filled by the
2183  linker with zeros.
2184 
2185  The GCC behaviour is arguably a bug, but it's effectively now
2186  part of the ABI, so we're now stuck with it, at least at the
2187  object file level. A smart linker may decide, in the process
2188  of compressing duplicate CIE information, that it can rewrite
2189  the entire output section without this extra padding. */
2190 
2191  start_offset = start - unit->dwarf_frame_buffer;
2192  if (workaround < ALIGN4 && (start_offset & 3) != 0)
2193  {
2194  start += 4 - (start_offset & 3);
2195  workaround = ALIGN4;
2196  continue;
2197  }
2198  if (workaround < ALIGN8 && (start_offset & 7) != 0)
2199  {
2200  start += 8 - (start_offset & 7);
2201  workaround = ALIGN8;
2202  continue;
2203  }
2204 
2205  /* Nothing left to try. Arrange to return as if we've consumed
2206  the entire input section. Hopefully we'll get valid info from
2207  the other of .debug_frame/.eh_frame. */
2208  workaround = FAIL;
2209  ret = unit->dwarf_frame_buffer + unit->dwarf_frame_size;
2210  break;
2211  }
2212 
2213  switch (workaround)
2214  {
2215  case NONE:
2216  break;
2217 
2218  case ALIGN4:
2220 Corrupt data in %s:%s; align 4 workaround apparently succeeded"),
2221  unit->dwarf_frame_section->owner->filename,
2222  unit->dwarf_frame_section->name);
2223  break;
2224 
2225  case ALIGN8:
2227 Corrupt data in %s:%s; align 8 workaround apparently succeeded"),
2228  unit->dwarf_frame_section->owner->filename,
2229  unit->dwarf_frame_section->name);
2230  break;
2231 
2232  default:
2234  _("Corrupt data in %s:%s"),
2235  unit->dwarf_frame_section->owner->filename,
2236  unit->dwarf_frame_section->name);
2237  break;
2238  }
2239 
2240  return ret;
2241 }
2242 
2243 static int
2244 qsort_fde_cmp (const void *a, const void *b)
2245 {
2246  struct dwarf2_fde *aa = *(struct dwarf2_fde **)a;
2247  struct dwarf2_fde *bb = *(struct dwarf2_fde **)b;
2248 
2249  if (aa->initial_location == bb->initial_location)
2250  {
2251  if (aa->address_range != bb->address_range
2252  && aa->eh_frame_p == 0 && bb->eh_frame_p == 0)
2253  /* Linker bug, e.g. gold/10400.
2254  Work around it by keeping stable sort order. */
2255  return (a < b) ? -1 : 1;
2256  else
2257  /* Put eh_frame entries after debug_frame ones. */
2258  return aa->eh_frame_p - bb->eh_frame_p;
2259  }
2260 
2261  return (aa->initial_location < bb->initial_location) ? -1 : 1;
2262 }
2263 
2264 void
2266 {
2267  struct comp_unit *unit;
2268  const gdb_byte *frame_ptr;
2269  struct dwarf2_cie_table cie_table;
2270  struct dwarf2_fde_table fde_table;
2271  struct dwarf2_fde_table *fde_table2;
2272 
2273  cie_table.num_entries = 0;
2274  cie_table.entries = NULL;
2275 
2276  fde_table.num_entries = 0;
2277  fde_table.entries = NULL;
2278 
2279  /* Build a minimal decoding of the DWARF2 compilation unit. */
2280  unit = (struct comp_unit *) obstack_alloc (&objfile->objfile_obstack,
2281  sizeof (struct comp_unit));
2282  unit->abfd = objfile->obfd;
2283  unit->objfile = objfile;
2284  unit->dbase = 0;
2285  unit->tbase = 0;
2286 
2287  if (objfile->separate_debug_objfile_backlink == NULL)
2288  {
2289  /* Do not read .eh_frame from separate file as they must be also
2290  present in the main file. */
2292  &unit->dwarf_frame_section,
2293  &unit->dwarf_frame_buffer,
2294  &unit->dwarf_frame_size);
2295  if (unit->dwarf_frame_size)
2296  {
2297  asection *got, *txt;
2298 
2299  /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
2300  that is used for the i386/amd64 target, which currently is
2301  the only target in GCC that supports/uses the
2302  DW_EH_PE_datarel encoding. */
2303  got = bfd_get_section_by_name (unit->abfd, ".got");
2304  if (got)
2305  unit->dbase = got->vma;
2306 
2307  /* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64
2308  so far. */
2309  txt = bfd_get_section_by_name (unit->abfd, ".text");
2310  if (txt)
2311  unit->tbase = txt->vma;
2312 
2313  TRY
2314  {
2315  frame_ptr = unit->dwarf_frame_buffer;
2316  while (frame_ptr < unit->dwarf_frame_buffer + unit->dwarf_frame_size)
2317  frame_ptr = decode_frame_entry (unit, frame_ptr, 1,
2318  &cie_table, &fde_table,
2320  }
2321 
2323  {
2324  warning (_("skipping .eh_frame info of %s: %s"),
2325  objfile_name (objfile), e.message);
2326 
2327  if (fde_table.num_entries != 0)
2328  {
2329  xfree (fde_table.entries);
2330  fde_table.entries = NULL;
2331  fde_table.num_entries = 0;
2332  }
2333  /* The cie_table is discarded by the next if. */
2334  }
2335  END_CATCH
2336 
2337  if (cie_table.num_entries != 0)
2338  {
2339  /* Reinit cie_table: debug_frame has different CIEs. */
2340  xfree (cie_table.entries);
2341  cie_table.num_entries = 0;
2342  cie_table.entries = NULL;
2343  }
2344  }
2345  }
2346 
2348  &unit->dwarf_frame_section,
2349  &unit->dwarf_frame_buffer,
2350  &unit->dwarf_frame_size);
2351  if (unit->dwarf_frame_size)
2352  {
2353  int num_old_fde_entries = fde_table.num_entries;
2354 
2355  TRY
2356  {
2357  frame_ptr = unit->dwarf_frame_buffer;
2358  while (frame_ptr < unit->dwarf_frame_buffer + unit->dwarf_frame_size)
2359  frame_ptr = decode_frame_entry (unit, frame_ptr, 0,
2360  &cie_table, &fde_table,
2362  }
2364  {
2365  warning (_("skipping .debug_frame info of %s: %s"),
2366  objfile_name (objfile), e.message);
2367 
2368  if (fde_table.num_entries != 0)
2369  {
2370  fde_table.num_entries = num_old_fde_entries;
2371  if (num_old_fde_entries == 0)
2372  {
2373  xfree (fde_table.entries);
2374  fde_table.entries = NULL;
2375  }
2376  else
2377  {
2378  fde_table.entries = xrealloc (fde_table.entries,
2379  fde_table.num_entries *
2380  sizeof (fde_table.entries[0]));
2381  }
2382  }
2383  fde_table.num_entries = num_old_fde_entries;
2384  /* The cie_table is discarded by the next if. */
2385  }
2386  END_CATCH
2387  }
2388 
2389  /* Discard the cie_table, it is no longer needed. */
2390  if (cie_table.num_entries != 0)
2391  {
2392  xfree (cie_table.entries);
2393  cie_table.entries = NULL; /* Paranoia. */
2394  cie_table.num_entries = 0; /* Paranoia. */
2395  }
2396 
2397  /* Copy fde_table to obstack: it is needed at runtime. */
2398  fde_table2 = (struct dwarf2_fde_table *)
2399  obstack_alloc (&objfile->objfile_obstack, sizeof (*fde_table2));
2400 
2401  if (fde_table.num_entries == 0)
2402  {
2403  fde_table2->entries = NULL;
2404  fde_table2->num_entries = 0;
2405  }
2406  else
2407  {
2408  struct dwarf2_fde *fde_prev = NULL;
2409  struct dwarf2_fde *first_non_zero_fde = NULL;
2410  int i;
2411 
2412  /* Prepare FDE table for lookups. */
2413  qsort (fde_table.entries, fde_table.num_entries,
2414  sizeof (fde_table.entries[0]), qsort_fde_cmp);
2415 
2416  /* Check for leftovers from --gc-sections. The GNU linker sets
2417  the relevant symbols to zero, but doesn't zero the FDE *end*
2418  ranges because there's no relocation there. It's (offset,
2419  length), not (start, end). On targets where address zero is
2420  just another valid address this can be a problem, since the
2421  FDEs appear to be non-empty in the output --- we could pick
2422  out the wrong FDE. To work around this, when overlaps are
2423  detected, we prefer FDEs that do not start at zero.
2424 
2425  Start by finding the first FDE with non-zero start. Below
2426  we'll discard all FDEs that start at zero and overlap this
2427  one. */
2428  for (i = 0; i < fde_table.num_entries; i++)
2429  {
2430  struct dwarf2_fde *fde = fde_table.entries[i];
2431 
2432  if (fde->initial_location != 0)
2433  {
2434  first_non_zero_fde = fde;
2435  break;
2436  }
2437  }
2438 
2439  /* Since we'll be doing bsearch, squeeze out identical (except
2440  for eh_frame_p) fde entries so bsearch result is predictable.
2441  Also discard leftovers from --gc-sections. */
2442  fde_table2->num_entries = 0;
2443  for (i = 0; i < fde_table.num_entries; i++)
2444  {
2445  struct dwarf2_fde *fde = fde_table.entries[i];
2446 
2447  if (fde->initial_location == 0
2448  && first_non_zero_fde != NULL
2449  && (first_non_zero_fde->initial_location
2450  < fde->initial_location + fde->address_range))
2451  continue;
2452 
2453  if (fde_prev != NULL
2454  && fde_prev->initial_location == fde->initial_location)
2455  continue;
2456 
2457  obstack_grow (&objfile->objfile_obstack, &fde_table.entries[i],
2458  sizeof (fde_table.entries[0]));
2459  ++fde_table2->num_entries;
2460  fde_prev = fde;
2461  }
2462  fde_table2->entries = obstack_finish (&objfile->objfile_obstack);
2463 
2464  /* Discard the original fde_table. */
2465  xfree (fde_table.entries);
2466  }
2467 
2468  set_objfile_data (objfile, dwarf2_frame_objfile_data, fde_table2);
2469 }
2470 
2471 /* Provide a prototype to silence -Wmissing-prototypes. */
2472 void _initialize_dwarf2_frame (void);
2473 
2474 void
2476 {
2477  dwarf2_frame_data = gdbarch_data_register_pre_init (dwarf2_frame_init);
2478  dwarf2_frame_objfile_data = register_objfile_data ();
2479 }
void dwarf_expr_push_address(struct dwarf_expr_context *ctx, CORE_ADDR value, int in_stack_memory)
Definition: dwarf2expr.c:167
const gdb_byte * end
Definition: dwarf2-frame.c:69
ULONGEST extract_unsigned_integer(const gdb_byte *, int, enum bfd_endian)
Definition: findvar.c:84
const struct frame_unwind record_btrace_tailcall_frame_unwind
struct value * value_mark(void)
Definition: value.c:1499
ULONGEST retaddr_column
Definition: dwarf2-frame.c:207
int num_regs
Definition: gdbarch.c:188
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
Definition: frame.c:554
static void dwarf2_frame_state_free(void *p)
Definition: dwarf2-frame.c:276
static gdb_byte encoding_for_size(unsigned int size)
CORE_ADDR get_frame_address_in_block(struct frame_info *this_frame)
Definition: frame.c:2248
static const struct frame_unwind dwarf2_frame_unwind
bfd * obfd
Definition: objfiles.h:313
#define SECT_OFF_TEXT(objfile)
Definition: objfiles.h:683
static void dwarf2_frame_state_free_regs(struct dwarf2_frame_state_reg_info *rs)
Definition: dwarf2-frame.c:262
void dwarf2_build_frame_info(struct objfile *objfile)
int dwarf2_fetch_cfa_info(struct gdbarch *gdbarch, CORE_ADDR pc, struct dwarf2_per_cu_data *data, int *regnum_out, LONGEST *offset_out, CORE_ADDR *text_offset_out, const gdb_byte **cfa_start_out, const gdb_byte **cfa_end_out)
Definition: dwarf2-frame.c:893
bfd_vma CORE_ADDR
Definition: common-types.h:41
static void dwarf2_frame_this_id(struct frame_info *this_frame, void **this_cache, struct frame_id *this_id)
static int dwarf2_frame_adjust_regnum(struct gdbarch *gdbarch, int regnum, int eh_frame_p)
Definition: dwarf2-frame.c:846
CORE_ADDR ctx_no_get_frame_pc(void *baton)
Definition: dwarf2expr.c:1527
void xfree(void *)
Definition: common-utils.c:97
struct objfile * separate_debug_objfile_backlink
Definition: objfiles.h:401
static void add_fde(struct dwarf2_fde_table *fde_table, struct dwarf2_fde *fde)
static CORE_ADDR read_encoded_value(struct comp_unit *unit, gdb_byte encoding, int ptr_len, const gdb_byte *buf, unsigned int *bytes_read_ptr, CORE_ADDR func_base)
struct frame_info * get_prev_frame(struct frame_info *this_frame)
Definition: frame.c:2122
LONGEST value_as_long(struct value *val)
Definition: value.c:2654
struct value * frame_unwind_got_memory(struct frame_info *frame, int regnum, CORE_ADDR addr)
Definition: frame-unwind.c:228
if(!(yy_init))
Definition: ada-lex.c:1072
static void dwarf2_frame_state_alloc_regs(struct dwarf2_frame_state_reg_info *rs, int num_regs)
Definition: dwarf2-frame.c:228
unsigned char segment_size
Definition: dwarf2-frame.c:93
void warning(const char *fmt,...)
Definition: errors.c:26
static void dwarf2_frame_init_reg(struct gdbarch *gdbarch, int regnum, struct dwarf2_frame_state_reg *reg, struct frame_info *this_frame)
Definition: dwarf2-frame.c:793
static const gdb_byte * decode_frame_entry_1(struct comp_unit *unit, const gdb_byte *start, int eh_frame_p, struct dwarf2_cie_table *cie_table, struct dwarf2_fde_table *fde_table, enum eh_frame_type entry_type)
CORE_ADDR dwarf2_frame_cfa(struct frame_info *this_frame)
static void clear_pointer_cleanup(void *arg)
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1690
static const struct dwarf_expr_context_funcs dwarf2_frame_ctx_funcs
Definition: dwarf2-frame.c:350
void * gdbarch_data(struct gdbarch *gdbarch, struct gdbarch_data *data)
Definition: gdbarch.c:4845
struct frame_id frame_id_build_unavailable_stack(CORE_ADDR code_addr)
Definition: frame.c:527
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
struct gdbarch * gdbarch
Definition: dwarf2expr.h:141
struct type * ctx_no_get_base_type(struct dwarf_expr_context *ctx, cu_offset die)
Definition: dwarf2expr.c:1551
union dwarf2_frame_state_reg::@51 loc
void ctx_no_get_frame_base(void *baton, const gdb_byte **start, size_t *length)
Definition: dwarf2expr.c:1511
CORE_ADDR initial_location
Definition: dwarf2-frame.c:110
unwind_stop_reason
Definition: frame.h:486
static int bsearch_fde_cmp(const void *key, const void *element)
static enum unwind_stop_reason dwarf2_frame_unwind_stop_reason(struct frame_info *this_frame, void **this_cache)
frame_dealloc_cache_ftype * dealloc_cache
Definition: frame-unwind.h:155
void dwarf2_frame_set_signal_frame_p(struct gdbarch *gdbarch, int(*signal_frame_p)(struct gdbarch *, struct frame_info *))
Definition: dwarf2-frame.c:806
const gdb_byte * safe_read_uleb128(const gdb_byte *buf, const gdb_byte *buf_end, uint64_t *r)
Definition: dwarf2expr.c:373
ULONGEST cie_pointer
Definition: dwarf2-frame.c:55
struct gdbarch_data * gdbarch_data_register_pre_init(gdbarch_data_pre_init_ftype *pre_init)
Definition: gdbarch.c:4806
int gdbarch_num_regs(struct gdbarch *gdbarch)
Definition: gdbarch.c:1898
#define _(String)
Definition: gdb_locale.h:40
struct dwarf2_frame_state_reg_info initial
Definition: dwarf2-frame.c:202
struct obstack * obstack
Definition: gdbarch.c:124
const struct objfile_data * dwarf2_frame_objfile_data
struct objfile * objfile
Definition: dwarf2-frame.c:138
int producer_is_realview(const char *producer)
Definition: symtab.c:6052
struct dwarf2_cie ** entries
Definition: dwarf2-frame.c:99
#define END_CATCH
void frame_unwind_append_unwinder(struct gdbarch *gdbarch, const struct frame_unwind *unwinder)
Definition: frame-unwind.c:78
struct value * dwarf_expr_fetch(struct dwarf_expr_context *ctx, int n)
Definition: dwarf2expr.c:188
#define FRAME_OBSTACK_ZALLOC(TYPE)
Definition: frame.h:660
const struct frame_unwind record_btrace_frame_unwind
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2743
CORE_ADDR ctx_no_get_addr_index(void *baton, unsigned int index)
Definition: dwarf2expr.c:1572
struct value * frame_unwind_got_constant(struct frame_info *frame, int regnum, ULONGEST val)
Definition: frame-unwind.c:241
struct comp_unit * unit
Definition: dwarf2-frame.c:51
struct compunit_symtab * find_pc_compunit_symtab(CORE_ADDR pc)
Definition: symtab.c:3051
struct obstack objfile_obstack
Definition: objfiles.h:328
static struct dwarf2_frame_cache * dwarf2_frame_cache(struct frame_info *this_frame, void **this_cache)
int gdbarch_num_pseudo_regs(struct gdbarch *gdbarch)
Definition: gdbarch.c:1916
#define TRY
unsigned char signal_frame
Definition: dwarf2-frame.c:87
struct value * value_from_register(struct type *type, int regnum, struct frame_info *frame)
Definition: findvar.c:699
#define ALL_OBJFILES(obj)
Definition: objfiles.h:579
static void read_mem(void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
Definition: dwarf2-frame.c:313
enum frame_type get_frame_type(struct frame_info *frame)
Definition: frame.c:2463
struct frame_id get_frame_id(struct frame_info *fi)
Definition: frame.c:473
const struct frame_base * dwarf2_frame_base_sniffer(struct frame_info *this_frame)
bfd_size_type dwarf_frame_size
Definition: dwarf2-frame.c:144
#define CATCH(EXCEPTION, MASK)
asection * dwarf_frame_section
Definition: dwarf2-frame.c:147
const struct dwarf_expr_context_funcs * funcs
Definition: dwarf2expr.h:158
void dwarf2_frame_set_init_reg(struct gdbarch *gdbarch, void(*init_reg)(struct gdbarch *, int, struct dwarf2_frame_state_reg *, struct frame_info *))
Definition: dwarf2-frame.c:780
struct dwarf2_fde ** entries
Definition: dwarf2-frame.c:127
int gdbarch_sp_regnum(struct gdbarch *gdbarch)
Definition: gdbarch.c:1981
enum unwind_stop_reason get_frame_unwind_stop_reason(struct frame_info *frame)
Definition: frame.c:2598
struct dwarf2_frame_state_reg * reg
Definition: dwarf2-frame.c:979
static int dwarf2_frame_signal_frame_p(struct gdbarch *gdbarch, struct frame_info *this_frame)
Definition: dwarf2-frame.c:819
static void dwarf2_frame_dealloc_cache(struct frame_info *self, void *this_cache)
bfd * abfd
Definition: dwarf2-frame.c:136
unsigned char version
Definition: dwarf2-frame.c:90
int gdbarch_dwarf2_addr_size(struct gdbarch *gdbarch)
Definition: gdbarch.c:1725
static struct dwarf2_frame_state_reg * dwarf2_frame_state_copy_regs(struct dwarf2_frame_state_reg_info *rs)
Definition: dwarf2-frame.c:248
struct dwarf2_cie * cie
Definition: dwarf2-frame.c:107
enum cfa_how_kind cfa_how
Definition: dwarf2-frame.c:182
CORE_ADDR text_offset
Definition: dwarf2-frame.c:988
struct cleanup * make_cleanup_value_free_to_mark(struct value *mark)
Definition: utils.c:388
void dwarf2_get_section_info(struct objfile *objfile, enum dwarf2_section_enum sect, asection **sectp, const gdb_byte **bufp, bfd_size_type *sizep)
Definition: dwarf2read.c:2362
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1420
void complaint(struct complaints **complaints, const char *fmt,...)
Definition: complaints.c:251
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
#define ANOFFSET(secoff, whichone)
Definition: symtab.h:910
struct gdbarch * get_objfile_arch(const struct objfile *objfile)
Definition: objfiles.c:368
#define TARGET_CHAR_BIT
Definition: host-defs.h:29
static const gdb_byte * execute_cfa_program(struct dwarf2_fde *fde, const gdb_byte *insn_ptr, const gdb_byte *insn_end, struct gdbarch *gdbarch, CORE_ADDR pc, struct dwarf2_frame_state *fs)
Definition: dwarf2-frame.c:413
Definition: gdbtypes.h:749
const gdb_byte * instructions
Definition: dwarf2-frame.c:116
static unsigned int read_1_byte(bfd *abfd, const gdb_byte *buf)
static const gdb_byte * gdb_read_uleb128(const gdb_byte *buf, const gdb_byte *buf_end, uint64_t *r)
Definition: dwarf2expr.h:303
#define COMPUNIT_PRODUCER(cust)
Definition: symtab.h:1097
CORE_ADDR ctx_no_get_tls_address(void *baton, CORE_ADDR offset)
Definition: dwarf2expr.c:1535
void dwarf2_tailcall_sniffer_first(struct frame_info *this_frame, void **tailcall_cachep, const LONGEST *entry_cfa_sp_offsetp)
const gdb_byte * exp
Definition: dwarf2-frame.h:77
#define gdb_assert(expr)
Definition: gdb_assert.h:33
void _initialize_dwarf2_frame(void)
CORE_ADDR gdbarch_adjust_dwarf2_addr(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition: gdbarch.c:3200
const char * gdbarch_register_name(struct gdbarch *gdbarch, int regnr)
Definition: gdbarch.c:2117
struct dwarf_expr_context * new_dwarf_expr_context(void)
Definition: dwarf2expr.c:93
static const gdb_byte * decode_frame_entry(struct comp_unit *unit, const gdb_byte *start, int eh_frame_p, struct dwarf2_cie_table *cie_table, struct dwarf2_fde_table *fde_table, enum eh_frame_type entry_type)
static int startswith(const char *string, const char *pattern)
Definition: common-utils.h:75
void(* init_reg)(struct gdbarch *, int, struct dwarf2_frame_state_reg *, struct frame_info *)
Definition: dwarf2-frame.c:713
const gdb_byte * cfa_exp
Definition: dwarf2-frame.c:183
const gdb_byte * end
Definition: dwarf2-frame.c:117
ULONGEST return_address_register
Definition: dwarf2-frame.c:65
int regnum
Definition: aarch64-tdep.c:69
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: corefile.c:244
static char encoding[]
Definition: remote-mips.c:2988
const char * objfile_name(const struct objfile *objfile)
Definition: objfiles.c:1499
ULONGEST get_frame_register_unsigned(struct frame_info *frame, int regnum)
Definition: frame.c:1194
void * xmalloc(YYSIZE_T)
LONGEST entry_cfa_sp_offset
static ULONGEST read_8_bytes(bfd *abfd, const gdb_byte *buf)
CORE_ADDR address_from_register(int regnum, struct frame_info *frame)
Definition: findvar.c:749
const gdb_byte * safe_read_sleb128(const gdb_byte *buf, const gdb_byte *buf_end, int64_t *r)
Definition: dwarf2expr.c:385
Definition: regdef.h:22
static void * dwarf2_frame_init(struct obstack *obstack)
Definition: dwarf2-frame.c:767
Definition: value.c:172
static int dwarf2_frame_sniffer(const struct frame_unwind *self, struct frame_info *this_frame, void **this_cache)
const gdb_byte * initial_instructions
Definition: dwarf2-frame.c:68
ULONGEST code_alignment_factor
Definition: dwarf2-frame.c:59
PTR xrealloc(PTR ptr, size_t size)
Definition: common-utils.c:51
int gdbarch_dwarf2_reg_to_regnum(struct gdbarch *gdbarch, int dwarf2_regnr)
Definition: gdbarch.c:2100
struct value * frame_unwind_got_optimized(struct frame_info *frame, int regnum)
Definition: frame-unwind.c:197
cfa_how_kind
Definition: dwarf2-frame.c:168
static CORE_ADDR read_addr_from_reg(void *baton, int reg)
Definition: dwarf2-frame.c:291
void throw_exception(struct gdb_exception exception)
const struct frame_unwind dwarf2_tailcall_frame_unwind
const char const char int
Definition: command.h:229
bfd_byte gdb_byte
Definition: common-types.h:38
int get_frame_func_if_available(struct frame_info *this_frame, CORE_ADDR *pc)
Definition: frame.c:876
bfd_vma tbase
Definition: dwarf2-frame.c:153
void discard_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:213
static CORE_ADDR execute_stack_op(const gdb_byte *exp, ULONGEST len, int addr_size, CORE_ADDR offset, struct frame_info *this_frame, CORE_ADDR initial, int initial_in_stack_memory)
Definition: dwarf2-frame.c:366
const gdb_byte * dwarf_frame_buffer
Definition: dwarf2-frame.c:141
gdb_byte encoding
Definition: dwarf2-frame.c:75
CORE_ADDR get_frame_base(struct frame_info *fi)
Definition: frame.c:2388
struct value * frame_unwind_got_register(struct frame_info *frame, int regnum, int new_regnum)
Definition: frame-unwind.c:218
static unsigned int read_4_bytes(bfd *abfd, const gdb_byte *buf)
struct complaints * symfile_complaints
Definition: complaints.c:105
unsigned char saw_z_augmentation
Definition: dwarf2-frame.c:84
bfd_vma dbase
Definition: dwarf2-frame.c:150
int offset
Definition: agent.c:65
char * augmentation
Definition: dwarf2-frame.c:72
CORE_ADDR offset
Definition: dwarf2expr.h:151
#define qsort
Definition: ada-exp.c:2747
void dwarf2_append_unwinders(struct gdbarch *gdbarch)
static void dwarf2_restore_rule(struct gdbarch *gdbarch, ULONGEST reg_num, struct dwarf2_frame_state *fs, int eh_frame_p)
Definition: dwarf2-frame.c:321
CORE_ADDR ctx_no_get_frame_cfa(void *baton)
Definition: dwarf2expr.c:1519
static struct dwarf2_fde * dwarf2_frame_find_fde(CORE_ADDR *pc, CORE_ADDR *out_offset)
static const struct frame_base dwarf2_frame_base
struct value * dwarf2_tailcall_prev_register_first(struct frame_info *this_frame, void **tailcall_cachep, int regnum)
enum dwarf_value_location location
Definition: dwarf2expr.h:166
static struct gdbarch_data * dwarf2_frame_data
Definition: dwarf2-frame.c:708
void ctx_no_push_dwarf_reg_entry_value(struct dwarf_expr_context *ctx, enum call_site_parameter_kind kind, union call_site_parameter_u kind_u, int deref_size)
Definition: dwarf2expr.c:1560
static void dwarf2_frame_default_init_reg(struct gdbarch *gdbarch, int regnum, struct dwarf2_frame_state_reg *reg, struct frame_info *this_frame)
Definition: dwarf2-frame.c:728
CORE_ADDR address_range
Definition: dwarf2-frame.c:113
unsigned long long ULONGEST
Definition: common-types.h:53
static CORE_ADDR dwarf2_frame_base_address(struct frame_info *this_frame, void **this_cache)
struct value * frame_unwind_got_address(struct frame_info *frame, int regnum, CORE_ADDR addr)
Definition: frame-unwind.c:270
int register_size(struct gdbarch *gdbarch, int regnum)
Definition: regcache.c:169
static const gdb_byte * gdb_read_sleb128(const gdb_byte *buf, const gdb_byte *buf_end, int64_t *r)
Definition: dwarf2expr.h:314
static ULONGEST read_initial_length(bfd *abfd, const gdb_byte *buf, unsigned int *bytes_read_ptr)
static struct value * dwarf2_frame_prev_register(struct frame_info *this_frame, void **this_cache, int regnum)
int gdbarch_pc_regnum(struct gdbarch *gdbarch)
Definition: gdbarch.c:1998
struct dwarf2_frame_state_reg retaddr_reg
Definition: dwarf2-frame.c:982
CORE_ADDR dwarf_expr_fetch_address(struct dwarf_expr_context *ctx, int n)
Definition: dwarf2expr.c:255
struct dwarf2_frame_state_reg * reg
Definition: dwarf2-frame.c:177
#define OBSTACK_ZALLOC(OBSTACK, TYPE)
Definition: gdb_obstack.h:27
struct dwarf2_frame_state_reg_info regs
Definition: dwarf2-frame.c:195
LONGEST data_alignment_factor
Definition: dwarf2-frame.c:62
struct section_offsets * section_offsets
Definition: objfiles.h:362
void dwarf_expr_eval(struct dwarf_expr_context *ctx, const gdb_byte *addr, size_t len)
Definition: dwarf2expr.c:358
eh_frame_type
static int qsort_fde_cmp(const void *a, const void *b)
static void add_cie(struct dwarf2_cie_table *cie_table, struct dwarf2_cie *cie)
void ctx_no_dwarf_call(struct dwarf_expr_context *ctx, cu_offset die_offset)
Definition: dwarf2expr.c:1543
CORE_ADDR get_frame_func(struct frame_info *this_frame)
Definition: frame.c:920
static struct dwarf2_cie * find_cie(struct dwarf2_cie_table *cie_table, ULONGEST cie_pointer)
enum dwarf2_frame_reg_rule how
Definition: dwarf2-frame.h:82
void error(const char *fmt,...)
Definition: errors.c:38
size_t size
Definition: go32-nat.c:242
int(* signal_frame_p)(struct gdbarch *, struct frame_info *)
Definition: dwarf2-frame.c:717
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
Definition: frame.c:2535
#define FRAME_OBSTACK_CALLOC(NUMBER, TYPE)
Definition: frame.h:662
void throw_error(enum errors error, const char *fmt,...)
long long LONGEST
Definition: common-types.h:52
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
static int bsearch_cie_cmp(const void *key, const void *element)
static void dwarf2_frame_find_quirks(struct dwarf2_frame_state *fs, struct dwarf2_fde *fde)
Definition: dwarf2-frame.c:857
int frame_unwinder_is(struct frame_info *fi, const struct frame_unwind *unwinder)
Definition: frame.c:2443
static struct value * get_reg_value(void *baton, struct type *type, int reg)
Definition: dwarf2-frame.c:303
struct value *(* fn)(struct frame_info *this_frame, void **this_cache, int regnum)
Definition: dwarf2-frame.h:78
struct dwarf2_frame_state_reg_info * prev
Definition: dwarf2-frame.c:186
unsigned char eh_frame_p
Definition: dwarf2-frame.c:121
struct cleanup * make_cleanup_free_dwarf_expr_context(struct dwarf_expr_context *ctx)
Definition: dwarf2expr.c:129
void dwarf2_frame_set_adjust_regnum(struct gdbarch *gdbarch, int(*adjust_regnum)(struct gdbarch *, int, int))
Definition: dwarf2-frame.c:833
#define DW64_CIE_ID
int(* adjust_regnum)(struct gdbarch *, int, int)
Definition: dwarf2-frame.c:721
const ULONGEST const LONGEST len
Definition: target.h:309