GDB (xrefs)

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