1
/* Frame unwinder for frames with DWARF Call Frame Information.
3
Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009, 2010
4
Free Software Foundation, Inc.
6
Contributed by Mark Kettenis.
8
This file is part of GDB.
10
This program is free software; you can redistribute it and/or modify
11
it under the terms of the GNU General Public License as published by
12
the Free Software Foundation; either version 3 of the License, or
13
(at your option) any later version.
15
This program is distributed in the hope that it will be useful,
16
but WITHOUT ANY WARRANTY; without even the implied warranty of
17
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18
GNU General Public License for more details.
20
You should have received a copy of the GNU General Public License
21
along with this program. If not, see <http://www.gnu.org/licenses/>. */
24
#include "dwarf2expr.h"
27
#include "frame-base.h"
28
#include "frame-unwind.h"
36
#include "gdb_assert.h"
37
#include "gdb_string.h"
39
#include "complaints.h"
40
#include "dwarf2-frame.h"
44
/* Call Frame Information (CFI). */
46
/* Common Information Entry (CIE). */
50
/* Computation Unit for this CIE. */
51
struct comp_unit *unit;
53
/* Offset into the .debug_frame section where this CIE was found.
54
Used to identify this CIE. */
57
/* Constant that is factored out of all advance location
59
ULONGEST code_alignment_factor;
61
/* Constants that is factored out of all offset instructions. */
62
LONGEST data_alignment_factor;
64
/* Return address column. */
65
ULONGEST return_address_register;
67
/* Instruction sequence to initialize a register set. */
68
gdb_byte *initial_instructions;
71
/* Saved augmentation, in case it's needed later. */
74
/* Encoding of addresses. */
77
/* Target address size in bytes. */
80
/* True if a 'z' augmentation existed. */
81
unsigned char saw_z_augmentation;
83
/* True if an 'S' augmentation existed. */
84
unsigned char signal_frame;
86
/* The version recorded in the CIE. */
87
unsigned char version;
90
struct dwarf2_cie_table
93
struct dwarf2_cie **entries;
96
/* Frame Description Entry (FDE). */
100
/* CIE for this FDE. */
101
struct dwarf2_cie *cie;
103
/* First location associated with this FDE. */
104
CORE_ADDR initial_location;
106
/* Number of bytes of program instructions described by this FDE. */
107
CORE_ADDR address_range;
109
/* Instruction sequence. */
110
gdb_byte *instructions;
113
/* True if this FDE is read from a .eh_frame instead of a .debug_frame
115
unsigned char eh_frame_p;
118
struct dwarf2_fde_table
121
struct dwarf2_fde **entries;
124
/* A minimal decoding of DWARF2 compilation units. We only decode
125
what's needed to get to the call frame information. */
129
/* Keep the bfd convenient. */
132
struct objfile *objfile;
134
/* Pointer to the .debug_frame section loaded into memory. */
135
gdb_byte *dwarf_frame_buffer;
137
/* Length of the loaded .debug_frame section. */
138
bfd_size_type dwarf_frame_size;
140
/* Pointer to the .debug_frame section. */
141
asection *dwarf_frame_section;
143
/* Base for DW_EH_PE_datarel encodings. */
146
/* Base for DW_EH_PE_textrel encodings. */
150
static struct dwarf2_fde *dwarf2_frame_find_fde (CORE_ADDR *pc);
152
static int dwarf2_frame_adjust_regnum (struct gdbarch *gdbarch, int regnum,
155
static CORE_ADDR read_encoded_value (struct comp_unit *unit, gdb_byte encoding,
156
int ptr_len, gdb_byte *buf,
157
unsigned int *bytes_read_ptr,
158
CORE_ADDR func_base);
161
/* Structure describing a frame state. */
163
struct dwarf2_frame_state
165
/* Each register save state can be described in terms of a CFA slot,
166
another register, or a location expression. */
167
struct dwarf2_frame_state_reg_info
169
struct dwarf2_frame_state_reg *reg;
181
/* Used to implement DW_CFA_remember_state. */
182
struct dwarf2_frame_state_reg_info *prev;
185
/* The PC described by the current frame state. */
188
/* Initial register set from the CIE.
189
Used to implement DW_CFA_restore. */
190
struct dwarf2_frame_state_reg_info initial;
192
/* The information we care about from the CIE. */
195
ULONGEST retaddr_column;
197
/* Flags for known producer quirks. */
199
/* The ARM compilers, in DWARF2 mode, assume that DW_CFA_def_cfa
200
and DW_CFA_def_cfa_offset takes a factored offset. */
201
int armcc_cfa_offsets_sf;
203
/* The ARM compilers, in DWARF2 or DWARF3 mode, may assume that
204
the CFA is defined as REG - OFFSET rather than REG + OFFSET. */
205
int armcc_cfa_offsets_reversed;
208
/* Store the length the expression for the CFA in the `cfa_reg' field,
209
which is unused in that case. */
210
#define cfa_exp_len cfa_reg
212
/* Assert that the register set RS is large enough to store gdbarch_num_regs
213
columns. If necessary, enlarge the register set. */
216
dwarf2_frame_state_alloc_regs (struct dwarf2_frame_state_reg_info *rs,
219
size_t size = sizeof (struct dwarf2_frame_state_reg);
221
if (num_regs <= rs->num_regs)
224
rs->reg = (struct dwarf2_frame_state_reg *)
225
xrealloc (rs->reg, num_regs * size);
227
/* Initialize newly allocated registers. */
228
memset (rs->reg + rs->num_regs, 0, (num_regs - rs->num_regs) * size);
229
rs->num_regs = num_regs;
232
/* Copy the register columns in register set RS into newly allocated
233
memory and return a pointer to this newly created copy. */
235
static struct dwarf2_frame_state_reg *
236
dwarf2_frame_state_copy_regs (struct dwarf2_frame_state_reg_info *rs)
238
size_t size = rs->num_regs * sizeof (struct dwarf2_frame_state_reg);
239
struct dwarf2_frame_state_reg *reg;
241
reg = (struct dwarf2_frame_state_reg *) xmalloc (size);
242
memcpy (reg, rs->reg, size);
247
/* Release the memory allocated to register set RS. */
250
dwarf2_frame_state_free_regs (struct dwarf2_frame_state_reg_info *rs)
254
dwarf2_frame_state_free_regs (rs->prev);
261
/* Release the memory allocated to the frame state FS. */
264
dwarf2_frame_state_free (void *p)
266
struct dwarf2_frame_state *fs = p;
268
dwarf2_frame_state_free_regs (fs->initial.prev);
269
dwarf2_frame_state_free_regs (fs->regs.prev);
270
xfree (fs->initial.reg);
271
xfree (fs->regs.reg);
276
/* Helper functions for execute_stack_op. */
279
read_reg (void *baton, int reg)
281
struct frame_info *this_frame = (struct frame_info *) baton;
282
struct gdbarch *gdbarch = get_frame_arch (this_frame);
286
regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, reg);
288
buf = alloca (register_size (gdbarch, regnum));
289
get_frame_register (this_frame, regnum, buf);
291
/* Convert the register to an integer. This returns a LONGEST
292
rather than a CORE_ADDR, but unpack_pointer does the same thing
293
under the covers, and this makes more sense for non-pointer
294
registers. Maybe read_reg and the associated interfaces should
295
deal with "struct value" instead of CORE_ADDR. */
296
return unpack_long (register_type (gdbarch, regnum), buf);
300
read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
302
read_memory (addr, buf, len);
306
no_get_frame_base (void *baton, gdb_byte **start, size_t *length)
308
internal_error (__FILE__, __LINE__,
309
_("Support for DW_OP_fbreg is unimplemented"));
312
/* Helper function for execute_stack_op. */
315
no_get_frame_cfa (void *baton)
317
internal_error (__FILE__, __LINE__,
318
_("Support for DW_OP_call_frame_cfa is unimplemented"));
322
no_get_tls_address (void *baton, CORE_ADDR offset)
324
internal_error (__FILE__, __LINE__,
325
_("Support for DW_OP_GNU_push_tls_address is unimplemented"));
328
/* Execute the required actions for both the DW_CFA_restore and
329
DW_CFA_restore_extended instructions. */
331
dwarf2_restore_rule (struct gdbarch *gdbarch, ULONGEST reg_num,
332
struct dwarf2_frame_state *fs, int eh_frame_p)
336
gdb_assert (fs->initial.reg);
337
reg = dwarf2_frame_adjust_regnum (gdbarch, reg_num, eh_frame_p);
338
dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
340
/* Check if this register was explicitly initialized in the
341
CIE initial instructions. If not, default the rule to
343
if (reg < fs->initial.num_regs)
344
fs->regs.reg[reg] = fs->initial.reg[reg];
346
fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNSPECIFIED;
348
if (fs->regs.reg[reg].how == DWARF2_FRAME_REG_UNSPECIFIED)
349
complaint (&symfile_complaints, _("\
350
incomplete CFI data; DW_CFA_restore unspecified\n\
351
register %s (#%d) at %s"),
352
gdbarch_register_name
353
(gdbarch, gdbarch_dwarf2_reg_to_regnum (gdbarch, reg)),
354
gdbarch_dwarf2_reg_to_regnum (gdbarch, reg),
355
paddress (gdbarch, fs->pc));
359
execute_stack_op (gdb_byte *exp, ULONGEST len, int addr_size,
360
struct frame_info *this_frame, CORE_ADDR initial,
361
int initial_in_stack_memory)
363
struct dwarf_expr_context *ctx;
365
struct cleanup *old_chain;
367
ctx = new_dwarf_expr_context ();
368
old_chain = make_cleanup_free_dwarf_expr_context (ctx);
370
ctx->gdbarch = get_frame_arch (this_frame);
371
ctx->addr_size = addr_size;
372
ctx->baton = this_frame;
373
ctx->read_reg = read_reg;
374
ctx->read_mem = read_mem;
375
ctx->get_frame_base = no_get_frame_base;
376
ctx->get_frame_cfa = no_get_frame_cfa;
377
ctx->get_tls_address = no_get_tls_address;
379
dwarf_expr_push (ctx, initial, initial_in_stack_memory);
380
dwarf_expr_eval (ctx, exp, len);
381
result = dwarf_expr_fetch (ctx, 0);
383
if (ctx->location == DWARF_VALUE_REGISTER)
384
result = read_reg (this_frame, result);
385
else if (ctx->location != DWARF_VALUE_MEMORY)
387
/* This is actually invalid DWARF, but if we ever do run across
388
it somehow, we might as well support it. So, instead, report
389
it as unimplemented. */
390
error (_("Not implemented: computing unwound register using explicit value operator"));
393
do_cleanups (old_chain);
400
execute_cfa_program (struct dwarf2_fde *fde, gdb_byte *insn_ptr,
401
gdb_byte *insn_end, struct frame_info *this_frame,
402
struct dwarf2_frame_state *fs)
404
int eh_frame_p = fde->eh_frame_p;
405
CORE_ADDR pc = get_frame_pc (this_frame);
407
struct gdbarch *gdbarch = get_frame_arch (this_frame);
408
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
410
while (insn_ptr < insn_end && fs->pc <= pc)
412
gdb_byte insn = *insn_ptr++;
416
if ((insn & 0xc0) == DW_CFA_advance_loc)
417
fs->pc += (insn & 0x3f) * fs->code_align;
418
else if ((insn & 0xc0) == DW_CFA_offset)
421
reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
422
insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
423
offset = utmp * fs->data_align;
424
dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
425
fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
426
fs->regs.reg[reg].loc.offset = offset;
428
else if ((insn & 0xc0) == DW_CFA_restore)
431
dwarf2_restore_rule (gdbarch, reg, fs, eh_frame_p);
438
fs->pc = read_encoded_value (fde->cie->unit, fde->cie->encoding,
439
fde->cie->addr_size, insn_ptr,
440
&bytes_read, fde->initial_location);
441
/* Apply the objfile offset for relocatable objects. */
442
fs->pc += ANOFFSET (fde->cie->unit->objfile->section_offsets,
443
SECT_OFF_TEXT (fde->cie->unit->objfile));
444
insn_ptr += bytes_read;
447
case DW_CFA_advance_loc1:
448
utmp = extract_unsigned_integer (insn_ptr, 1, byte_order);
449
fs->pc += utmp * fs->code_align;
452
case DW_CFA_advance_loc2:
453
utmp = extract_unsigned_integer (insn_ptr, 2, byte_order);
454
fs->pc += utmp * fs->code_align;
457
case DW_CFA_advance_loc4:
458
utmp = extract_unsigned_integer (insn_ptr, 4, byte_order);
459
fs->pc += utmp * fs->code_align;
463
case DW_CFA_offset_extended:
464
insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
465
reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
466
insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
467
offset = utmp * fs->data_align;
468
dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
469
fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
470
fs->regs.reg[reg].loc.offset = offset;
473
case DW_CFA_restore_extended:
474
insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
475
dwarf2_restore_rule (gdbarch, reg, fs, eh_frame_p);
478
case DW_CFA_undefined:
479
insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
480
reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
481
dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
482
fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNDEFINED;
485
case DW_CFA_same_value:
486
insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
487
reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
488
dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
489
fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAME_VALUE;
492
case DW_CFA_register:
493
insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
494
reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
495
insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
496
utmp = dwarf2_frame_adjust_regnum (gdbarch, utmp, eh_frame_p);
497
dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
498
fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
499
fs->regs.reg[reg].loc.reg = utmp;
502
case DW_CFA_remember_state:
504
struct dwarf2_frame_state_reg_info *new_rs;
506
new_rs = XMALLOC (struct dwarf2_frame_state_reg_info);
508
fs->regs.reg = dwarf2_frame_state_copy_regs (&fs->regs);
509
fs->regs.prev = new_rs;
513
case DW_CFA_restore_state:
515
struct dwarf2_frame_state_reg_info *old_rs = fs->regs.prev;
519
complaint (&symfile_complaints, _("\
520
bad CFI data; mismatched DW_CFA_restore_state at %s"),
521
paddress (gdbarch, fs->pc));
525
xfree (fs->regs.reg);
533
insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->regs.cfa_reg);
534
insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
536
if (fs->armcc_cfa_offsets_sf)
537
utmp *= fs->data_align;
539
fs->regs.cfa_offset = utmp;
540
fs->regs.cfa_how = CFA_REG_OFFSET;
543
case DW_CFA_def_cfa_register:
544
insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->regs.cfa_reg);
545
fs->regs.cfa_reg = dwarf2_frame_adjust_regnum (gdbarch,
548
fs->regs.cfa_how = CFA_REG_OFFSET;
551
case DW_CFA_def_cfa_offset:
552
insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
554
if (fs->armcc_cfa_offsets_sf)
555
utmp *= fs->data_align;
557
fs->regs.cfa_offset = utmp;
558
/* cfa_how deliberately not set. */
564
case DW_CFA_def_cfa_expression:
565
insn_ptr = read_uleb128 (insn_ptr, insn_end,
566
&fs->regs.cfa_exp_len);
567
fs->regs.cfa_exp = insn_ptr;
568
fs->regs.cfa_how = CFA_EXP;
569
insn_ptr += fs->regs.cfa_exp_len;
572
case DW_CFA_expression:
573
insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
574
reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
575
dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
576
insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
577
fs->regs.reg[reg].loc.exp = insn_ptr;
578
fs->regs.reg[reg].exp_len = utmp;
579
fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_EXP;
583
case DW_CFA_offset_extended_sf:
584
insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
585
reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
586
insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
587
offset *= fs->data_align;
588
dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
589
fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
590
fs->regs.reg[reg].loc.offset = offset;
593
case DW_CFA_val_offset:
594
insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
595
dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
596
insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
597
offset = utmp * fs->data_align;
598
fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_OFFSET;
599
fs->regs.reg[reg].loc.offset = offset;
602
case DW_CFA_val_offset_sf:
603
insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
604
dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
605
insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
606
offset *= fs->data_align;
607
fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_OFFSET;
608
fs->regs.reg[reg].loc.offset = offset;
611
case DW_CFA_val_expression:
612
insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
613
dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
614
insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
615
fs->regs.reg[reg].loc.exp = insn_ptr;
616
fs->regs.reg[reg].exp_len = utmp;
617
fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_EXP;
621
case DW_CFA_def_cfa_sf:
622
insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->regs.cfa_reg);
623
fs->regs.cfa_reg = dwarf2_frame_adjust_regnum (gdbarch,
626
insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
627
fs->regs.cfa_offset = offset * fs->data_align;
628
fs->regs.cfa_how = CFA_REG_OFFSET;
631
case DW_CFA_def_cfa_offset_sf:
632
insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
633
fs->regs.cfa_offset = offset * fs->data_align;
634
/* cfa_how deliberately not set. */
637
case DW_CFA_GNU_window_save:
638
/* This is SPARC-specific code, and contains hard-coded
639
constants for the register numbering scheme used by
640
GCC. Rather than having a architecture-specific
641
operation that's only ever used by a single
642
architecture, we provide the implementation here.
643
Incidentally that's what GCC does too in its
646
int size = register_size (gdbarch, 0);
647
dwarf2_frame_state_alloc_regs (&fs->regs, 32);
648
for (reg = 8; reg < 16; reg++)
650
fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
651
fs->regs.reg[reg].loc.reg = reg + 16;
653
for (reg = 16; reg < 32; reg++)
655
fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
656
fs->regs.reg[reg].loc.offset = (reg - 16) * size;
661
case DW_CFA_GNU_args_size:
663
insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
666
case DW_CFA_GNU_negative_offset_extended:
667
insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
668
reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
669
insn_ptr = read_uleb128 (insn_ptr, insn_end, &offset);
670
offset *= fs->data_align;
671
dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
672
fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
673
fs->regs.reg[reg].loc.offset = -offset;
677
internal_error (__FILE__, __LINE__, _("Unknown CFI encountered."));
682
/* Don't allow remember/restore between CIE and FDE programs. */
683
dwarf2_frame_state_free_regs (fs->regs.prev);
684
fs->regs.prev = NULL;
688
/* Architecture-specific operations. */
690
/* Per-architecture data key. */
691
static struct gdbarch_data *dwarf2_frame_data;
693
struct dwarf2_frame_ops
695
/* Pre-initialize the register state REG for register REGNUM. */
696
void (*init_reg) (struct gdbarch *, int, struct dwarf2_frame_state_reg *,
697
struct frame_info *);
699
/* Check whether the THIS_FRAME is a signal trampoline. */
700
int (*signal_frame_p) (struct gdbarch *, struct frame_info *);
702
/* Convert .eh_frame register number to DWARF register number, or
703
adjust .debug_frame register number. */
704
int (*adjust_regnum) (struct gdbarch *, int, int);
707
/* Default architecture-specific register state initialization
711
dwarf2_frame_default_init_reg (struct gdbarch *gdbarch, int regnum,
712
struct dwarf2_frame_state_reg *reg,
713
struct frame_info *this_frame)
715
/* If we have a register that acts as a program counter, mark it as
716
a destination for the return address. If we have a register that
717
serves as the stack pointer, arrange for it to be filled with the
718
call frame address (CFA). The other registers are marked as
721
We copy the return address to the program counter, since many
722
parts in GDB assume that it is possible to get the return address
723
by unwinding the program counter register. However, on ISA's
724
with a dedicated return address register, the CFI usually only
725
contains information to unwind that return address register.
727
The reason we're treating the stack pointer special here is
728
because in many cases GCC doesn't emit CFI for the stack pointer
729
and implicitly assumes that it is equal to the CFA. This makes
730
some sense since the DWARF specification (version 3, draft 8,
733
"Typically, the CFA is defined to be the value of the stack
734
pointer at the call site in the previous frame (which may be
735
different from its value on entry to the current frame)."
737
However, this isn't true for all platforms supported by GCC
738
(e.g. IBM S/390 and zSeries). Those architectures should provide
739
their own architecture-specific initialization function. */
741
if (regnum == gdbarch_pc_regnum (gdbarch))
742
reg->how = DWARF2_FRAME_REG_RA;
743
else if (regnum == gdbarch_sp_regnum (gdbarch))
744
reg->how = DWARF2_FRAME_REG_CFA;
747
/* Return a default for the architecture-specific operations. */
750
dwarf2_frame_init (struct obstack *obstack)
752
struct dwarf2_frame_ops *ops;
754
ops = OBSTACK_ZALLOC (obstack, struct dwarf2_frame_ops);
755
ops->init_reg = dwarf2_frame_default_init_reg;
759
/* Set the architecture-specific register state initialization
760
function for GDBARCH to INIT_REG. */
763
dwarf2_frame_set_init_reg (struct gdbarch *gdbarch,
764
void (*init_reg) (struct gdbarch *, int,
765
struct dwarf2_frame_state_reg *,
766
struct frame_info *))
768
struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
770
ops->init_reg = init_reg;
773
/* Pre-initialize the register state REG for register REGNUM. */
776
dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
777
struct dwarf2_frame_state_reg *reg,
778
struct frame_info *this_frame)
780
struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
782
ops->init_reg (gdbarch, regnum, reg, this_frame);
785
/* Set the architecture-specific signal trampoline recognition
786
function for GDBARCH to SIGNAL_FRAME_P. */
789
dwarf2_frame_set_signal_frame_p (struct gdbarch *gdbarch,
790
int (*signal_frame_p) (struct gdbarch *,
791
struct frame_info *))
793
struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
795
ops->signal_frame_p = signal_frame_p;
798
/* Query the architecture-specific signal frame recognizer for
802
dwarf2_frame_signal_frame_p (struct gdbarch *gdbarch,
803
struct frame_info *this_frame)
805
struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
807
if (ops->signal_frame_p == NULL)
809
return ops->signal_frame_p (gdbarch, this_frame);
812
/* Set the architecture-specific adjustment of .eh_frame and .debug_frame
816
dwarf2_frame_set_adjust_regnum (struct gdbarch *gdbarch,
817
int (*adjust_regnum) (struct gdbarch *,
820
struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
822
ops->adjust_regnum = adjust_regnum;
825
/* Translate a .eh_frame register to DWARF register, or adjust a .debug_frame
829
dwarf2_frame_adjust_regnum (struct gdbarch *gdbarch, int regnum, int eh_frame_p)
831
struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
833
if (ops->adjust_regnum == NULL)
835
return ops->adjust_regnum (gdbarch, regnum, eh_frame_p);
839
dwarf2_frame_find_quirks (struct dwarf2_frame_state *fs,
840
struct dwarf2_fde *fde)
842
static const char *arm_idents[] = {
843
"ARM C Compiler, ADS",
844
"Thumb C Compiler, ADS",
845
"ARM C++ Compiler, ADS",
846
"Thumb C++ Compiler, ADS",
847
"ARM/Thumb C/C++ Compiler, RVCT"
853
s = find_pc_symtab (fs->pc);
854
if (s == NULL || s->producer == NULL)
857
for (i = 0; i < ARRAY_SIZE (arm_idents); i++)
858
if (strncmp (s->producer, arm_idents[i], strlen (arm_idents[i])) == 0)
860
if (fde->cie->version == 1)
861
fs->armcc_cfa_offsets_sf = 1;
863
if (fde->cie->version == 1)
864
fs->armcc_cfa_offsets_reversed = 1;
866
/* The reversed offset problem is present in some compilers
867
using DWARF3, but it was eventually fixed. Check the ARM
868
defined augmentations, which are in the format "armcc" followed
869
by a list of one-character options. The "+" option means
870
this problem is fixed (no quirk needed). If the armcc
871
augmentation is missing, the quirk is needed. */
872
if (fde->cie->version == 3
873
&& (strncmp (fde->cie->augmentation, "armcc", 5) != 0
874
|| strchr (fde->cie->augmentation + 5, '+') == NULL))
875
fs->armcc_cfa_offsets_reversed = 1;
882
struct dwarf2_frame_cache
884
/* DWARF Call Frame Address. */
887
/* Set if the return address column was marked as undefined. */
888
int undefined_retaddr;
890
/* Saved registers, indexed by GDB register number, not by DWARF
892
struct dwarf2_frame_state_reg *reg;
894
/* Return address register. */
895
struct dwarf2_frame_state_reg retaddr_reg;
897
/* Target address size in bytes. */
901
static struct dwarf2_frame_cache *
902
dwarf2_frame_cache (struct frame_info *this_frame, void **this_cache)
904
struct cleanup *old_chain;
905
struct gdbarch *gdbarch = get_frame_arch (this_frame);
906
const int num_regs = gdbarch_num_regs (gdbarch)
907
+ gdbarch_num_pseudo_regs (gdbarch);
908
struct dwarf2_frame_cache *cache;
909
struct dwarf2_frame_state *fs;
910
struct dwarf2_fde *fde;
915
/* Allocate a new cache. */
916
cache = FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache);
917
cache->reg = FRAME_OBSTACK_CALLOC (num_regs, struct dwarf2_frame_state_reg);
919
/* Allocate and initialize the frame state. */
920
fs = XMALLOC (struct dwarf2_frame_state);
921
memset (fs, 0, sizeof (struct dwarf2_frame_state));
922
old_chain = make_cleanup (dwarf2_frame_state_free, fs);
926
Note that if the next frame is never supposed to return (i.e. a call
927
to abort), the compiler might optimize away the instruction at
928
its return address. As a result the return address will
929
point at some random instruction, and the CFI for that
930
instruction is probably worthless to us. GCC's unwinder solves
931
this problem by substracting 1 from the return address to get an
932
address in the middle of a presumed call instruction (or the
933
instruction in the associated delay slot). This should only be
934
done for "normal" frames and not for resume-type frames (signal
935
handlers, sentinel frames, dummy frames). The function
936
get_frame_address_in_block does just this. It's not clear how
937
reliable the method is though; there is the potential for the
938
register state pre-call being different to that on return. */
939
fs->pc = get_frame_address_in_block (this_frame);
941
/* Find the correct FDE. */
942
fde = dwarf2_frame_find_fde (&fs->pc);
943
gdb_assert (fde != NULL);
945
/* Extract any interesting information from the CIE. */
946
fs->data_align = fde->cie->data_alignment_factor;
947
fs->code_align = fde->cie->code_alignment_factor;
948
fs->retaddr_column = fde->cie->return_address_register;
949
cache->addr_size = fde->cie->addr_size;
951
/* Check for "quirks" - known bugs in producers. */
952
dwarf2_frame_find_quirks (fs, fde);
954
/* First decode all the insns in the CIE. */
955
execute_cfa_program (fde, fde->cie->initial_instructions,
956
fde->cie->end, this_frame, fs);
958
/* Save the initialized register set. */
959
fs->initial = fs->regs;
960
fs->initial.reg = dwarf2_frame_state_copy_regs (&fs->regs);
962
/* Then decode the insns in the FDE up to our target PC. */
963
execute_cfa_program (fde, fde->instructions, fde->end, this_frame, fs);
965
/* Calculate the CFA. */
966
switch (fs->regs.cfa_how)
969
cache->cfa = read_reg (this_frame, fs->regs.cfa_reg);
970
if (fs->armcc_cfa_offsets_reversed)
971
cache->cfa -= fs->regs.cfa_offset;
973
cache->cfa += fs->regs.cfa_offset;
978
execute_stack_op (fs->regs.cfa_exp, fs->regs.cfa_exp_len,
979
cache->addr_size, this_frame, 0, 0);
983
internal_error (__FILE__, __LINE__, _("Unknown CFA rule."));
986
/* Initialize the register state. */
990
for (regnum = 0; regnum < num_regs; regnum++)
991
dwarf2_frame_init_reg (gdbarch, regnum, &cache->reg[regnum], this_frame);
994
/* Go through the DWARF2 CFI generated table and save its register
995
location information in the cache. Note that we don't skip the
996
return address column; it's perfectly all right for it to
997
correspond to a real register. If it doesn't correspond to a
998
real register, or if we shouldn't treat it as such,
999
gdbarch_dwarf2_reg_to_regnum should be defined to return a number outside
1000
the range [0, gdbarch_num_regs). */
1002
int column; /* CFI speak for "register number". */
1004
for (column = 0; column < fs->regs.num_regs; column++)
1006
/* Use the GDB register number as the destination index. */
1007
int regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, column);
1009
/* If there's no corresponding GDB register, ignore it. */
1010
if (regnum < 0 || regnum >= num_regs)
1013
/* NOTE: cagney/2003-09-05: CFI should specify the disposition
1014
of all debug info registers. If it doesn't, complain (but
1015
not too loudly). It turns out that GCC assumes that an
1016
unspecified register implies "same value" when CFI (draft
1017
7) specifies nothing at all. Such a register could equally
1018
be interpreted as "undefined". Also note that this check
1019
isn't sufficient; it only checks that all registers in the
1020
range [0 .. max column] are specified, and won't detect
1021
problems when a debug info register falls outside of the
1022
table. We need a way of iterating through all the valid
1023
DWARF2 register numbers. */
1024
if (fs->regs.reg[column].how == DWARF2_FRAME_REG_UNSPECIFIED)
1026
if (cache->reg[regnum].how == DWARF2_FRAME_REG_UNSPECIFIED)
1027
complaint (&symfile_complaints, _("\
1028
incomplete CFI data; unspecified registers (e.g., %s) at %s"),
1029
gdbarch_register_name (gdbarch, regnum),
1030
paddress (gdbarch, fs->pc));
1033
cache->reg[regnum] = fs->regs.reg[column];
1037
/* Eliminate any DWARF2_FRAME_REG_RA rules, and save the information
1038
we need for evaluating DWARF2_FRAME_REG_RA_OFFSET rules. */
1042
for (regnum = 0; regnum < num_regs; regnum++)
1044
if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA
1045
|| cache->reg[regnum].how == DWARF2_FRAME_REG_RA_OFFSET)
1047
struct dwarf2_frame_state_reg *retaddr_reg =
1048
&fs->regs.reg[fs->retaddr_column];
1050
/* It seems rather bizarre to specify an "empty" column as
1051
the return adress column. However, this is exactly
1052
what GCC does on some targets. It turns out that GCC
1053
assumes that the return address can be found in the
1054
register corresponding to the return address column.
1055
Incidentally, that's how we should treat a return
1056
address column specifying "same value" too. */
1057
if (fs->retaddr_column < fs->regs.num_regs
1058
&& retaddr_reg->how != DWARF2_FRAME_REG_UNSPECIFIED
1059
&& retaddr_reg->how != DWARF2_FRAME_REG_SAME_VALUE)
1061
if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
1062
cache->reg[regnum] = *retaddr_reg;
1064
cache->retaddr_reg = *retaddr_reg;
1068
if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
1070
cache->reg[regnum].loc.reg = fs->retaddr_column;
1071
cache->reg[regnum].how = DWARF2_FRAME_REG_SAVED_REG;
1075
cache->retaddr_reg.loc.reg = fs->retaddr_column;
1076
cache->retaddr_reg.how = DWARF2_FRAME_REG_SAVED_REG;
1083
if (fs->retaddr_column < fs->regs.num_regs
1084
&& fs->regs.reg[fs->retaddr_column].how == DWARF2_FRAME_REG_UNDEFINED)
1085
cache->undefined_retaddr = 1;
1087
do_cleanups (old_chain);
1089
*this_cache = cache;
1094
dwarf2_frame_this_id (struct frame_info *this_frame, void **this_cache,
1095
struct frame_id *this_id)
1097
struct dwarf2_frame_cache *cache =
1098
dwarf2_frame_cache (this_frame, this_cache);
1100
if (cache->undefined_retaddr)
1103
(*this_id) = frame_id_build (cache->cfa, get_frame_func (this_frame));
1106
static struct value *
1107
dwarf2_frame_prev_register (struct frame_info *this_frame, void **this_cache,
1110
struct gdbarch *gdbarch = get_frame_arch (this_frame);
1111
struct dwarf2_frame_cache *cache =
1112
dwarf2_frame_cache (this_frame, this_cache);
1116
switch (cache->reg[regnum].how)
1118
case DWARF2_FRAME_REG_UNDEFINED:
1119
/* If CFI explicitly specified that the value isn't defined,
1120
mark it as optimized away; the value isn't available. */
1121
return frame_unwind_got_optimized (this_frame, regnum);
1123
case DWARF2_FRAME_REG_SAVED_OFFSET:
1124
addr = cache->cfa + cache->reg[regnum].loc.offset;
1125
return frame_unwind_got_memory (this_frame, regnum, addr);
1127
case DWARF2_FRAME_REG_SAVED_REG:
1129
= gdbarch_dwarf2_reg_to_regnum (gdbarch, cache->reg[regnum].loc.reg);
1130
return frame_unwind_got_register (this_frame, regnum, realnum);
1132
case DWARF2_FRAME_REG_SAVED_EXP:
1133
addr = execute_stack_op (cache->reg[regnum].loc.exp,
1134
cache->reg[regnum].exp_len,
1135
cache->addr_size, this_frame, cache->cfa, 1);
1136
return frame_unwind_got_memory (this_frame, regnum, addr);
1138
case DWARF2_FRAME_REG_SAVED_VAL_OFFSET:
1139
addr = cache->cfa + cache->reg[regnum].loc.offset;
1140
return frame_unwind_got_constant (this_frame, regnum, addr);
1142
case DWARF2_FRAME_REG_SAVED_VAL_EXP:
1143
addr = execute_stack_op (cache->reg[regnum].loc.exp,
1144
cache->reg[regnum].exp_len,
1145
cache->addr_size, this_frame, cache->cfa, 1);
1146
return frame_unwind_got_constant (this_frame, regnum, addr);
1148
case DWARF2_FRAME_REG_UNSPECIFIED:
1149
/* GCC, in its infinite wisdom decided to not provide unwind
1150
information for registers that are "same value". Since
1151
DWARF2 (3 draft 7) doesn't define such behavior, said
1152
registers are actually undefined (which is different to CFI
1153
"undefined"). Code above issues a complaint about this.
1154
Here just fudge the books, assume GCC, and that the value is
1155
more inner on the stack. */
1156
return frame_unwind_got_register (this_frame, regnum, regnum);
1158
case DWARF2_FRAME_REG_SAME_VALUE:
1159
return frame_unwind_got_register (this_frame, regnum, regnum);
1161
case DWARF2_FRAME_REG_CFA:
1162
return frame_unwind_got_address (this_frame, regnum, cache->cfa);
1164
case DWARF2_FRAME_REG_CFA_OFFSET:
1165
addr = cache->cfa + cache->reg[regnum].loc.offset;
1166
return frame_unwind_got_address (this_frame, regnum, addr);
1168
case DWARF2_FRAME_REG_RA_OFFSET:
1169
addr = cache->reg[regnum].loc.offset;
1170
regnum = gdbarch_dwarf2_reg_to_regnum
1171
(gdbarch, cache->retaddr_reg.loc.reg);
1172
addr += get_frame_register_unsigned (this_frame, regnum);
1173
return frame_unwind_got_address (this_frame, regnum, addr);
1175
case DWARF2_FRAME_REG_FN:
1176
return cache->reg[regnum].loc.fn (this_frame, this_cache, regnum);
1179
internal_error (__FILE__, __LINE__, _("Unknown register rule."));
1184
dwarf2_frame_sniffer (const struct frame_unwind *self,
1185
struct frame_info *this_frame, void **this_cache)
1187
/* Grab an address that is guarenteed to reside somewhere within the
1188
function. get_frame_pc(), with a no-return next function, can
1189
end up returning something past the end of this function's body.
1190
If the frame we're sniffing for is a signal frame whose start
1191
address is placed on the stack by the OS, its FDE must
1192
extend one byte before its start address or we could potentially
1193
select the FDE of the previous function. */
1194
CORE_ADDR block_addr = get_frame_address_in_block (this_frame);
1195
struct dwarf2_fde *fde = dwarf2_frame_find_fde (&block_addr);
1199
/* On some targets, signal trampolines may have unwind information.
1200
We need to recognize them so that we set the frame type
1203
if (fde->cie->signal_frame
1204
|| dwarf2_frame_signal_frame_p (get_frame_arch (this_frame),
1206
return self->type == SIGTRAMP_FRAME;
1208
return self->type != SIGTRAMP_FRAME;
1211
static const struct frame_unwind dwarf2_frame_unwind =
1214
dwarf2_frame_this_id,
1215
dwarf2_frame_prev_register,
1217
dwarf2_frame_sniffer
1220
static const struct frame_unwind dwarf2_signal_frame_unwind =
1223
dwarf2_frame_this_id,
1224
dwarf2_frame_prev_register,
1226
dwarf2_frame_sniffer
1229
/* Append the DWARF-2 frame unwinders to GDBARCH's list. */
1232
dwarf2_append_unwinders (struct gdbarch *gdbarch)
1234
frame_unwind_append_unwinder (gdbarch, &dwarf2_frame_unwind);
1235
frame_unwind_append_unwinder (gdbarch, &dwarf2_signal_frame_unwind);
1239
/* There is no explicitly defined relationship between the CFA and the
1240
location of frame's local variables and arguments/parameters.
1241
Therefore, frame base methods on this page should probably only be
1242
used as a last resort, just to avoid printing total garbage as a
1243
response to the "info frame" command. */
1246
dwarf2_frame_base_address (struct frame_info *this_frame, void **this_cache)
1248
struct dwarf2_frame_cache *cache =
1249
dwarf2_frame_cache (this_frame, this_cache);
1254
static const struct frame_base dwarf2_frame_base =
1256
&dwarf2_frame_unwind,
1257
dwarf2_frame_base_address,
1258
dwarf2_frame_base_address,
1259
dwarf2_frame_base_address
1262
const struct frame_base *
1263
dwarf2_frame_base_sniffer (struct frame_info *this_frame)
1265
CORE_ADDR block_addr = get_frame_address_in_block (this_frame);
1266
if (dwarf2_frame_find_fde (&block_addr))
1267
return &dwarf2_frame_base;
1272
/* Compute the CFA for THIS_FRAME, but only if THIS_FRAME came from
1273
the DWARF unwinder. This is used to implement
1274
DW_OP_call_frame_cfa. */
1277
dwarf2_frame_cfa (struct frame_info *this_frame)
1279
while (get_frame_type (this_frame) == INLINE_FRAME)
1280
this_frame = get_prev_frame (this_frame);
1281
/* This restriction could be lifted if other unwinders are known to
1282
compute the frame base in a way compatible with the DWARF
1284
if (! frame_unwinder_is (this_frame, &dwarf2_frame_unwind))
1285
error (_("can't compute CFA for this frame"));
1286
return get_frame_base (this_frame);
1289
const struct objfile_data *dwarf2_frame_objfile_data;
1292
read_1_byte (bfd *abfd, gdb_byte *buf)
1294
return bfd_get_8 (abfd, buf);
1298
read_4_bytes (bfd *abfd, gdb_byte *buf)
1300
return bfd_get_32 (abfd, buf);
1304
read_8_bytes (bfd *abfd, gdb_byte *buf)
1306
return bfd_get_64 (abfd, buf);
1310
read_unsigned_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1313
unsigned int num_read;
1323
byte = bfd_get_8 (abfd, (bfd_byte *) buf);
1326
result |= ((byte & 0x7f) << shift);
1329
while (byte & 0x80);
1331
*bytes_read_ptr = num_read;
1337
read_signed_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1341
unsigned int num_read;
1350
byte = bfd_get_8 (abfd, (bfd_byte *) buf);
1353
result |= ((byte & 0x7f) << shift);
1356
while (byte & 0x80);
1358
if (shift < 8 * sizeof (result) && (byte & 0x40))
1359
result |= -(((LONGEST)1) << shift);
1361
*bytes_read_ptr = num_read;
1367
read_initial_length (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1371
result = bfd_get_32 (abfd, buf);
1372
if (result == 0xffffffff)
1374
result = bfd_get_64 (abfd, buf + 4);
1375
*bytes_read_ptr = 12;
1378
*bytes_read_ptr = 4;
1384
/* Pointer encoding helper functions. */
1386
/* GCC supports exception handling based on DWARF2 CFI. However, for
1387
technical reasons, it encodes addresses in its FDE's in a different
1388
way. Several "pointer encodings" are supported. The encoding
1389
that's used for a particular FDE is determined by the 'R'
1390
augmentation in the associated CIE. The argument of this
1391
augmentation is a single byte.
1393
The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a
1394
LEB128. This is encoded in bits 0, 1 and 2. Bit 3 encodes whether
1395
the address is signed or unsigned. Bits 4, 5 and 6 encode how the
1396
address should be interpreted (absolute, relative to the current
1397
position in the FDE, ...). Bit 7, indicates that the address
1398
should be dereferenced. */
1401
encoding_for_size (unsigned int size)
1406
return DW_EH_PE_udata2;
1408
return DW_EH_PE_udata4;
1410
return DW_EH_PE_udata8;
1412
internal_error (__FILE__, __LINE__, _("Unsupported address size"));
1417
read_encoded_value (struct comp_unit *unit, gdb_byte encoding,
1418
int ptr_len, gdb_byte *buf, unsigned int *bytes_read_ptr,
1419
CORE_ADDR func_base)
1424
/* GCC currently doesn't generate DW_EH_PE_indirect encodings for
1426
if (encoding & DW_EH_PE_indirect)
1427
internal_error (__FILE__, __LINE__,
1428
_("Unsupported encoding: DW_EH_PE_indirect"));
1430
*bytes_read_ptr = 0;
1432
switch (encoding & 0x70)
1434
case DW_EH_PE_absptr:
1437
case DW_EH_PE_pcrel:
1438
base = bfd_get_section_vma (unit->abfd, unit->dwarf_frame_section);
1439
base += (buf - unit->dwarf_frame_buffer);
1441
case DW_EH_PE_datarel:
1444
case DW_EH_PE_textrel:
1447
case DW_EH_PE_funcrel:
1450
case DW_EH_PE_aligned:
1452
offset = buf - unit->dwarf_frame_buffer;
1453
if ((offset % ptr_len) != 0)
1455
*bytes_read_ptr = ptr_len - (offset % ptr_len);
1456
buf += *bytes_read_ptr;
1460
internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
1463
if ((encoding & 0x07) == 0x00)
1465
encoding |= encoding_for_size (ptr_len);
1466
if (bfd_get_sign_extend_vma (unit->abfd))
1467
encoding |= DW_EH_PE_signed;
1470
switch (encoding & 0x0f)
1472
case DW_EH_PE_uleb128:
1475
gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1476
*bytes_read_ptr += read_uleb128 (buf, end_buf, &value) - buf;
1477
return base + value;
1479
case DW_EH_PE_udata2:
1480
*bytes_read_ptr += 2;
1481
return (base + bfd_get_16 (unit->abfd, (bfd_byte *) buf));
1482
case DW_EH_PE_udata4:
1483
*bytes_read_ptr += 4;
1484
return (base + bfd_get_32 (unit->abfd, (bfd_byte *) buf));
1485
case DW_EH_PE_udata8:
1486
*bytes_read_ptr += 8;
1487
return (base + bfd_get_64 (unit->abfd, (bfd_byte *) buf));
1488
case DW_EH_PE_sleb128:
1491
gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1492
*bytes_read_ptr += read_sleb128 (buf, end_buf, &value) - buf;
1493
return base + value;
1495
case DW_EH_PE_sdata2:
1496
*bytes_read_ptr += 2;
1497
return (base + bfd_get_signed_16 (unit->abfd, (bfd_byte *) buf));
1498
case DW_EH_PE_sdata4:
1499
*bytes_read_ptr += 4;
1500
return (base + bfd_get_signed_32 (unit->abfd, (bfd_byte *) buf));
1501
case DW_EH_PE_sdata8:
1502
*bytes_read_ptr += 8;
1503
return (base + bfd_get_signed_64 (unit->abfd, (bfd_byte *) buf));
1505
internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
1511
bsearch_cie_cmp (const void *key, const void *element)
1513
ULONGEST cie_pointer = *(ULONGEST *) key;
1514
struct dwarf2_cie *cie = *(struct dwarf2_cie **) element;
1516
if (cie_pointer == cie->cie_pointer)
1519
return (cie_pointer < cie->cie_pointer) ? -1 : 1;
1522
/* Find CIE with the given CIE_POINTER in CIE_TABLE. */
1523
static struct dwarf2_cie *
1524
find_cie (struct dwarf2_cie_table *cie_table, ULONGEST cie_pointer)
1526
struct dwarf2_cie **p_cie;
1528
/* The C standard (ISO/IEC 9899:TC2) requires the BASE argument to
1529
bsearch be non-NULL. */
1530
if (cie_table->entries == NULL)
1532
gdb_assert (cie_table->num_entries == 0);
1536
p_cie = bsearch (&cie_pointer, cie_table->entries, cie_table->num_entries,
1537
sizeof (cie_table->entries[0]), bsearch_cie_cmp);
1543
/* Add a pointer to new CIE to the CIE_TABLE, allocating space for it. */
1545
add_cie (struct dwarf2_cie_table *cie_table, struct dwarf2_cie *cie)
1547
const int n = cie_table->num_entries;
1550
|| cie_table->entries[n - 1]->cie_pointer < cie->cie_pointer);
1552
cie_table->entries =
1553
xrealloc (cie_table->entries, (n + 1) * sizeof (cie_table->entries[0]));
1554
cie_table->entries[n] = cie;
1555
cie_table->num_entries = n + 1;
1559
bsearch_fde_cmp (const void *key, const void *element)
1561
CORE_ADDR seek_pc = *(CORE_ADDR *) key;
1562
struct dwarf2_fde *fde = *(struct dwarf2_fde **) element;
1563
if (seek_pc < fde->initial_location)
1565
if (seek_pc < fde->initial_location + fde->address_range)
1570
/* Find the FDE for *PC. Return a pointer to the FDE, and store the
1571
inital location associated with it into *PC. */
1573
static struct dwarf2_fde *
1574
dwarf2_frame_find_fde (CORE_ADDR *pc)
1576
struct objfile *objfile;
1578
ALL_OBJFILES (objfile)
1580
struct dwarf2_fde_table *fde_table;
1581
struct dwarf2_fde **p_fde;
1585
fde_table = objfile_data (objfile, dwarf2_frame_objfile_data);
1586
if (fde_table == NULL)
1589
gdb_assert (objfile->section_offsets);
1590
offset = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1592
gdb_assert (fde_table->num_entries > 0);
1593
if (*pc < offset + fde_table->entries[0]->initial_location)
1596
seek_pc = *pc - offset;
1597
p_fde = bsearch (&seek_pc, fde_table->entries, fde_table->num_entries,
1598
sizeof (fde_table->entries[0]), bsearch_fde_cmp);
1601
*pc = (*p_fde)->initial_location + offset;
1608
/* Add a pointer to new FDE to the FDE_TABLE, allocating space for it. */
1610
add_fde (struct dwarf2_fde_table *fde_table, struct dwarf2_fde *fde)
1612
if (fde->address_range == 0)
1613
/* Discard useless FDEs. */
1616
fde_table->num_entries += 1;
1617
fde_table->entries =
1618
xrealloc (fde_table->entries,
1619
fde_table->num_entries * sizeof (fde_table->entries[0]));
1620
fde_table->entries[fde_table->num_entries - 1] = fde;
1623
#ifdef CC_HAS_LONG_LONG
1624
#define DW64_CIE_ID 0xffffffffffffffffULL
1626
#define DW64_CIE_ID ~0
1629
static gdb_byte *decode_frame_entry (struct comp_unit *unit, gdb_byte *start,
1631
struct dwarf2_cie_table *cie_table,
1632
struct dwarf2_fde_table *fde_table);
1634
/* Decode the next CIE or FDE. Return NULL if invalid input, otherwise
1635
the next byte to be processed. */
1637
decode_frame_entry_1 (struct comp_unit *unit, gdb_byte *start, int eh_frame_p,
1638
struct dwarf2_cie_table *cie_table,
1639
struct dwarf2_fde_table *fde_table)
1641
struct gdbarch *gdbarch = get_objfile_arch (unit->objfile);
1642
gdb_byte *buf, *end;
1644
unsigned int bytes_read;
1647
ULONGEST cie_pointer;
1650
length = read_initial_length (unit->abfd, buf, &bytes_read);
1654
/* Are we still within the section? */
1655
if (end > unit->dwarf_frame_buffer + unit->dwarf_frame_size)
1661
/* Distinguish between 32 and 64-bit encoded frame info. */
1662
dwarf64_p = (bytes_read == 12);
1664
/* In a .eh_frame section, zero is used to distinguish CIEs from FDEs. */
1668
cie_id = DW64_CIE_ID;
1674
cie_pointer = read_8_bytes (unit->abfd, buf);
1679
cie_pointer = read_4_bytes (unit->abfd, buf);
1683
if (cie_pointer == cie_id)
1685
/* This is a CIE. */
1686
struct dwarf2_cie *cie;
1688
unsigned int cie_version;
1690
/* Record the offset into the .debug_frame section of this CIE. */
1691
cie_pointer = start - unit->dwarf_frame_buffer;
1693
/* Check whether we've already read it. */
1694
if (find_cie (cie_table, cie_pointer))
1697
cie = (struct dwarf2_cie *)
1698
obstack_alloc (&unit->objfile->objfile_obstack,
1699
sizeof (struct dwarf2_cie));
1700
cie->initial_instructions = NULL;
1701
cie->cie_pointer = cie_pointer;
1703
/* The encoding for FDE's in a normal .debug_frame section
1704
depends on the target address size. */
1705
cie->encoding = DW_EH_PE_absptr;
1707
/* The target address size. For .eh_frame FDEs this is considered
1708
equal to the size of a target pointer. For .dwarf_frame FDEs,
1709
this is supposed to be the target address size from the associated
1710
CU header. FIXME: We do not have a good way to determine the
1711
latter. Always use the target pointer size for now. */
1712
cie->addr_size = gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
1714
/* We'll determine the final value later, but we need to
1715
initialize it conservatively. */
1716
cie->signal_frame = 0;
1718
/* Check version number. */
1719
cie_version = read_1_byte (unit->abfd, buf);
1720
if (cie_version != 1 && cie_version != 3)
1722
cie->version = cie_version;
1725
/* Interpret the interesting bits of the augmentation. */
1726
cie->augmentation = augmentation = (char *) buf;
1727
buf += (strlen (augmentation) + 1);
1729
/* Ignore armcc augmentations. We only use them for quirks,
1730
and that doesn't happen until later. */
1731
if (strncmp (augmentation, "armcc", 5) == 0)
1732
augmentation += strlen (augmentation);
1734
/* The GCC 2.x "eh" augmentation has a pointer immediately
1735
following the augmentation string, so it must be handled
1737
if (augmentation[0] == 'e' && augmentation[1] == 'h')
1740
buf += gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
1744
cie->code_alignment_factor =
1745
read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1748
cie->data_alignment_factor =
1749
read_signed_leb128 (unit->abfd, buf, &bytes_read);
1752
if (cie_version == 1)
1754
cie->return_address_register = read_1_byte (unit->abfd, buf);
1758
cie->return_address_register = read_unsigned_leb128 (unit->abfd, buf,
1760
cie->return_address_register
1761
= dwarf2_frame_adjust_regnum (gdbarch,
1762
cie->return_address_register,
1767
cie->saw_z_augmentation = (*augmentation == 'z');
1768
if (cie->saw_z_augmentation)
1772
length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1776
cie->initial_instructions = buf + length;
1780
while (*augmentation)
1782
/* "L" indicates a byte showing how the LSDA pointer is encoded. */
1783
if (*augmentation == 'L')
1790
/* "R" indicates a byte indicating how FDE addresses are encoded. */
1791
else if (*augmentation == 'R')
1793
cie->encoding = *buf++;
1797
/* "P" indicates a personality routine in the CIE augmentation. */
1798
else if (*augmentation == 'P')
1800
/* Skip. Avoid indirection since we throw away the result. */
1801
gdb_byte encoding = (*buf++) & ~DW_EH_PE_indirect;
1802
read_encoded_value (unit, encoding, cie->addr_size,
1803
buf, &bytes_read, 0);
1808
/* "S" indicates a signal frame, such that the return
1809
address must not be decremented to locate the call frame
1810
info for the previous frame; it might even be the first
1811
instruction of a function, so decrementing it would take
1812
us to a different function. */
1813
else if (*augmentation == 'S')
1815
cie->signal_frame = 1;
1819
/* Otherwise we have an unknown augmentation. Assume that either
1820
there is no augmentation data, or we saw a 'z' prefix. */
1823
if (cie->initial_instructions)
1824
buf = cie->initial_instructions;
1829
cie->initial_instructions = buf;
1833
add_cie (cie_table, cie);
1837
/* This is a FDE. */
1838
struct dwarf2_fde *fde;
1840
/* In an .eh_frame section, the CIE pointer is the delta between the
1841
address within the FDE where the CIE pointer is stored and the
1842
address of the CIE. Convert it to an offset into the .eh_frame
1846
cie_pointer = buf - unit->dwarf_frame_buffer - cie_pointer;
1847
cie_pointer -= (dwarf64_p ? 8 : 4);
1850
/* In either case, validate the result is still within the section. */
1851
if (cie_pointer >= unit->dwarf_frame_size)
1854
fde = (struct dwarf2_fde *)
1855
obstack_alloc (&unit->objfile->objfile_obstack,
1856
sizeof (struct dwarf2_fde));
1857
fde->cie = find_cie (cie_table, cie_pointer);
1858
if (fde->cie == NULL)
1860
decode_frame_entry (unit, unit->dwarf_frame_buffer + cie_pointer,
1861
eh_frame_p, cie_table, fde_table);
1862
fde->cie = find_cie (cie_table, cie_pointer);
1865
gdb_assert (fde->cie != NULL);
1867
fde->initial_location =
1868
read_encoded_value (unit, fde->cie->encoding, fde->cie->addr_size,
1869
buf, &bytes_read, 0);
1872
fde->address_range =
1873
read_encoded_value (unit, fde->cie->encoding & 0x0f,
1874
fde->cie->addr_size, buf, &bytes_read, 0);
1877
/* A 'z' augmentation in the CIE implies the presence of an
1878
augmentation field in the FDE as well. The only thing known
1879
to be in here at present is the LSDA entry for EH. So we
1880
can skip the whole thing. */
1881
if (fde->cie->saw_z_augmentation)
1885
length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1886
buf += bytes_read + length;
1891
fde->instructions = buf;
1894
fde->eh_frame_p = eh_frame_p;
1896
add_fde (fde_table, fde);
1902
/* Read a CIE or FDE in BUF and decode it. */
1904
decode_frame_entry (struct comp_unit *unit, gdb_byte *start, int eh_frame_p,
1905
struct dwarf2_cie_table *cie_table,
1906
struct dwarf2_fde_table *fde_table)
1908
enum { NONE, ALIGN4, ALIGN8, FAIL } workaround = NONE;
1911
ptrdiff_t start_offset;
1915
ret = decode_frame_entry_1 (unit, start, eh_frame_p,
1916
cie_table, fde_table);
1920
/* We have corrupt input data of some form. */
1922
/* ??? Try, weakly, to work around compiler/assembler/linker bugs
1923
and mismatches wrt padding and alignment of debug sections. */
1924
/* Note that there is no requirement in the standard for any
1925
alignment at all in the frame unwind sections. Testing for
1926
alignment before trying to interpret data would be incorrect.
1928
However, GCC traditionally arranged for frame sections to be
1929
sized such that the FDE length and CIE fields happen to be
1930
aligned (in theory, for performance). This, unfortunately,
1931
was done with .align directives, which had the side effect of
1932
forcing the section to be aligned by the linker.
1934
This becomes a problem when you have some other producer that
1935
creates frame sections that are not as strictly aligned. That
1936
produces a hole in the frame info that gets filled by the
1939
The GCC behaviour is arguably a bug, but it's effectively now
1940
part of the ABI, so we're now stuck with it, at least at the
1941
object file level. A smart linker may decide, in the process
1942
of compressing duplicate CIE information, that it can rewrite
1943
the entire output section without this extra padding. */
1945
start_offset = start - unit->dwarf_frame_buffer;
1946
if (workaround < ALIGN4 && (start_offset & 3) != 0)
1948
start += 4 - (start_offset & 3);
1949
workaround = ALIGN4;
1952
if (workaround < ALIGN8 && (start_offset & 7) != 0)
1954
start += 8 - (start_offset & 7);
1955
workaround = ALIGN8;
1959
/* Nothing left to try. Arrange to return as if we've consumed
1960
the entire input section. Hopefully we'll get valid info from
1961
the other of .debug_frame/.eh_frame. */
1963
ret = unit->dwarf_frame_buffer + unit->dwarf_frame_size;
1973
complaint (&symfile_complaints,
1974
_("Corrupt data in %s:%s; align 4 workaround apparently succeeded"),
1975
unit->dwarf_frame_section->owner->filename,
1976
unit->dwarf_frame_section->name);
1980
complaint (&symfile_complaints,
1981
_("Corrupt data in %s:%s; align 8 workaround apparently succeeded"),
1982
unit->dwarf_frame_section->owner->filename,
1983
unit->dwarf_frame_section->name);
1987
complaint (&symfile_complaints,
1988
_("Corrupt data in %s:%s"),
1989
unit->dwarf_frame_section->owner->filename,
1990
unit->dwarf_frame_section->name);
1998
/* Imported from dwarf2read.c. */
1999
extern void dwarf2_get_section_info (struct objfile *, const char *, asection **,
2000
gdb_byte **, bfd_size_type *);
2003
qsort_fde_cmp (const void *a, const void *b)
2005
struct dwarf2_fde *aa = *(struct dwarf2_fde **)a;
2006
struct dwarf2_fde *bb = *(struct dwarf2_fde **)b;
2008
if (aa->initial_location == bb->initial_location)
2010
if (aa->address_range != bb->address_range
2011
&& aa->eh_frame_p == 0 && bb->eh_frame_p == 0)
2012
/* Linker bug, e.g. gold/10400.
2013
Work around it by keeping stable sort order. */
2014
return (a < b) ? -1 : 1;
2016
/* Put eh_frame entries after debug_frame ones. */
2017
return aa->eh_frame_p - bb->eh_frame_p;
2020
return (aa->initial_location < bb->initial_location) ? -1 : 1;
2024
dwarf2_build_frame_info (struct objfile *objfile)
2026
struct comp_unit *unit;
2027
gdb_byte *frame_ptr;
2028
struct dwarf2_cie_table cie_table;
2029
struct dwarf2_fde_table fde_table;
2031
cie_table.num_entries = 0;
2032
cie_table.entries = NULL;
2034
fde_table.num_entries = 0;
2035
fde_table.entries = NULL;
2037
/* Build a minimal decoding of the DWARF2 compilation unit. */
2038
unit = (struct comp_unit *) obstack_alloc (&objfile->objfile_obstack,
2039
sizeof (struct comp_unit));
2040
unit->abfd = objfile->obfd;
2041
unit->objfile = objfile;
2045
dwarf2_get_section_info (objfile, ".eh_frame",
2046
&unit->dwarf_frame_section,
2047
&unit->dwarf_frame_buffer,
2048
&unit->dwarf_frame_size);
2049
if (unit->dwarf_frame_size)
2051
asection *got, *txt;
2053
/* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
2054
that is used for the i386/amd64 target, which currently is
2055
the only target in GCC that supports/uses the
2056
DW_EH_PE_datarel encoding. */
2057
got = bfd_get_section_by_name (unit->abfd, ".got");
2059
unit->dbase = got->vma;
2061
/* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64
2063
txt = bfd_get_section_by_name (unit->abfd, ".text");
2065
unit->tbase = txt->vma;
2067
frame_ptr = unit->dwarf_frame_buffer;
2068
while (frame_ptr < unit->dwarf_frame_buffer + unit->dwarf_frame_size)
2069
frame_ptr = decode_frame_entry (unit, frame_ptr, 1,
2070
&cie_table, &fde_table);
2072
if (cie_table.num_entries != 0)
2074
/* Reinit cie_table: debug_frame has different CIEs. */
2075
xfree (cie_table.entries);
2076
cie_table.num_entries = 0;
2077
cie_table.entries = NULL;
2081
dwarf2_get_section_info (objfile, ".debug_frame",
2082
&unit->dwarf_frame_section,
2083
&unit->dwarf_frame_buffer,
2084
&unit->dwarf_frame_size);
2085
if (unit->dwarf_frame_size)
2087
frame_ptr = unit->dwarf_frame_buffer;
2088
while (frame_ptr < unit->dwarf_frame_buffer + unit->dwarf_frame_size)
2089
frame_ptr = decode_frame_entry (unit, frame_ptr, 0,
2090
&cie_table, &fde_table);
2093
/* Discard the cie_table, it is no longer needed. */
2094
if (cie_table.num_entries != 0)
2096
xfree (cie_table.entries);
2097
cie_table.entries = NULL; /* Paranoia. */
2098
cie_table.num_entries = 0; /* Paranoia. */
2101
if (fde_table.num_entries != 0)
2103
struct dwarf2_fde_table *fde_table2;
2104
struct dwarf2_fde *fde_prev = NULL;
2105
struct dwarf2_fde *first_non_zero_fde = NULL;
2108
/* Prepare FDE table for lookups. */
2109
qsort (fde_table.entries, fde_table.num_entries,
2110
sizeof (fde_table.entries[0]), qsort_fde_cmp);
2112
/* Copy fde_table to obstack: it is needed at runtime. */
2113
fde_table2 = (struct dwarf2_fde_table *)
2114
obstack_alloc (&objfile->objfile_obstack, sizeof (*fde_table2));
2115
fde_table2->num_entries = 0;
2117
/* Check for leftovers from --gc-sections. The GNU linker sets
2118
the relevant symbols to zero, but doesn't zero the FDE *end*
2119
ranges because there's no relocation there. It's (offset,
2120
length), not (start, end). On targets where address zero is
2121
just another valid address this can be a problem, since the
2122
FDEs appear to be non-empty in the output --- we could pick
2123
out the wrong FDE. To work around this, when overlaps are
2124
detected, we prefer FDEs that do not start at zero.
2126
Start by finding the first FDE with non-zero start. Below
2127
we'll discard all FDEs that start at zero and overlap this
2129
for (i = 0; i < fde_table.num_entries; i++)
2131
struct dwarf2_fde *fde = fde_table.entries[i];
2133
if (fde->initial_location != 0)
2135
first_non_zero_fde = fde;
2140
/* Since we'll be doing bsearch, squeeze out identical (except
2141
for eh_frame_p) fde entries so bsearch result is predictable.
2142
Also discard leftovers from --gc-sections. */
2143
for (i = 0; i < fde_table.num_entries; i++)
2145
struct dwarf2_fde *fde = fde_table.entries[i];
2147
if (fde->initial_location == 0
2148
&& first_non_zero_fde != NULL
2149
&& (first_non_zero_fde->initial_location
2150
< fde->initial_location + fde->address_range))
2153
if (fde_prev != NULL
2154
&& fde_prev->initial_location == fde->initial_location)
2157
obstack_grow (&objfile->objfile_obstack, &fde_table.entries[i],
2158
sizeof (fde_table.entries[0]));
2159
++fde_table2->num_entries;
2162
fde_table2->entries = obstack_finish (&objfile->objfile_obstack);
2163
set_objfile_data (objfile, dwarf2_frame_objfile_data, fde_table2);
2165
/* Discard the original fde_table. */
2166
xfree (fde_table.entries);
2170
/* Provide a prototype to silence -Wmissing-prototypes. */
2171
void _initialize_dwarf2_frame (void);
2174
_initialize_dwarf2_frame (void)
2176
dwarf2_frame_data = gdbarch_data_register_pre_init (dwarf2_frame_init);
2177
dwarf2_frame_objfile_data = register_objfile_data ();
added
removed
.pc/dwarf2-cfi-warning.patch/gdb/dwarf2-frame.c
