1 /* Frame unwinder for frames with DWARF Call Frame Information.
3 Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009
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
)
362 struct dwarf_expr_context
*ctx
;
364 struct cleanup
*old_chain
;
366 ctx
= new_dwarf_expr_context ();
367 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
369 ctx
->gdbarch
= get_frame_arch (this_frame
);
370 ctx
->addr_size
= addr_size
;
371 ctx
->baton
= this_frame
;
372 ctx
->read_reg
= read_reg
;
373 ctx
->read_mem
= read_mem
;
374 ctx
->get_frame_base
= no_get_frame_base
;
375 ctx
->get_frame_cfa
= no_get_frame_cfa
;
376 ctx
->get_tls_address
= no_get_tls_address
;
378 dwarf_expr_push (ctx
, initial
);
379 dwarf_expr_eval (ctx
, exp
, len
);
380 result
= dwarf_expr_fetch (ctx
, 0);
383 result
= read_reg (this_frame
, result
);
385 do_cleanups (old_chain
);
392 execute_cfa_program (struct dwarf2_fde
*fde
, gdb_byte
*insn_ptr
,
393 gdb_byte
*insn_end
, struct frame_info
*this_frame
,
394 struct dwarf2_frame_state
*fs
)
396 int eh_frame_p
= fde
->eh_frame_p
;
397 CORE_ADDR pc
= get_frame_pc (this_frame
);
399 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
400 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
402 while (insn_ptr
< insn_end
&& fs
->pc
<= pc
)
404 gdb_byte insn
= *insn_ptr
++;
408 if ((insn
& 0xc0) == DW_CFA_advance_loc
)
409 fs
->pc
+= (insn
& 0x3f) * fs
->code_align
;
410 else if ((insn
& 0xc0) == DW_CFA_offset
)
413 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
414 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
415 offset
= utmp
* fs
->data_align
;
416 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
417 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
418 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
420 else if ((insn
& 0xc0) == DW_CFA_restore
)
423 dwarf2_restore_rule (gdbarch
, reg
, fs
, eh_frame_p
);
430 fs
->pc
= read_encoded_value (fde
->cie
->unit
, fde
->cie
->encoding
,
431 fde
->cie
->addr_size
, insn_ptr
,
432 &bytes_read
, fde
->initial_location
);
433 /* Apply the objfile offset for relocatable objects. */
434 fs
->pc
+= ANOFFSET (fde
->cie
->unit
->objfile
->section_offsets
,
435 SECT_OFF_TEXT (fde
->cie
->unit
->objfile
));
436 insn_ptr
+= bytes_read
;
439 case DW_CFA_advance_loc1
:
440 utmp
= extract_unsigned_integer (insn_ptr
, 1, byte_order
);
441 fs
->pc
+= utmp
* fs
->code_align
;
444 case DW_CFA_advance_loc2
:
445 utmp
= extract_unsigned_integer (insn_ptr
, 2, byte_order
);
446 fs
->pc
+= utmp
* fs
->code_align
;
449 case DW_CFA_advance_loc4
:
450 utmp
= extract_unsigned_integer (insn_ptr
, 4, byte_order
);
451 fs
->pc
+= utmp
* fs
->code_align
;
455 case DW_CFA_offset_extended
:
456 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
457 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
458 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
459 offset
= utmp
* fs
->data_align
;
460 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
461 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
462 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
465 case DW_CFA_restore_extended
:
466 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
467 dwarf2_restore_rule (gdbarch
, reg
, fs
, eh_frame_p
);
470 case DW_CFA_undefined
:
471 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
472 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
473 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
474 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_UNDEFINED
;
477 case DW_CFA_same_value
:
478 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
479 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
480 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
481 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAME_VALUE
;
484 case DW_CFA_register
:
485 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
486 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
487 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
488 utmp
= dwarf2_frame_adjust_regnum (gdbarch
, utmp
, eh_frame_p
);
489 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
490 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_REG
;
491 fs
->regs
.reg
[reg
].loc
.reg
= utmp
;
494 case DW_CFA_remember_state
:
496 struct dwarf2_frame_state_reg_info
*new_rs
;
498 new_rs
= XMALLOC (struct dwarf2_frame_state_reg_info
);
500 fs
->regs
.reg
= dwarf2_frame_state_copy_regs (&fs
->regs
);
501 fs
->regs
.prev
= new_rs
;
505 case DW_CFA_restore_state
:
507 struct dwarf2_frame_state_reg_info
*old_rs
= fs
->regs
.prev
;
511 complaint (&symfile_complaints
, _("\
512 bad CFI data; mismatched DW_CFA_restore_state at %s"),
513 paddress (gdbarch
, fs
->pc
));
517 xfree (fs
->regs
.reg
);
525 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &fs
->regs
.cfa_reg
);
526 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
528 if (fs
->armcc_cfa_offsets_sf
)
529 utmp
*= fs
->data_align
;
531 fs
->regs
.cfa_offset
= utmp
;
532 fs
->regs
.cfa_how
= CFA_REG_OFFSET
;
535 case DW_CFA_def_cfa_register
:
536 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &fs
->regs
.cfa_reg
);
537 fs
->regs
.cfa_reg
= dwarf2_frame_adjust_regnum (gdbarch
,
540 fs
->regs
.cfa_how
= CFA_REG_OFFSET
;
543 case DW_CFA_def_cfa_offset
:
544 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
546 if (fs
->armcc_cfa_offsets_sf
)
547 utmp
*= fs
->data_align
;
549 fs
->regs
.cfa_offset
= utmp
;
550 /* cfa_how deliberately not set. */
556 case DW_CFA_def_cfa_expression
:
557 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
,
558 &fs
->regs
.cfa_exp_len
);
559 fs
->regs
.cfa_exp
= insn_ptr
;
560 fs
->regs
.cfa_how
= CFA_EXP
;
561 insn_ptr
+= fs
->regs
.cfa_exp_len
;
564 case DW_CFA_expression
:
565 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
566 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
567 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
568 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
569 fs
->regs
.reg
[reg
].loc
.exp
= insn_ptr
;
570 fs
->regs
.reg
[reg
].exp_len
= utmp
;
571 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_EXP
;
575 case DW_CFA_offset_extended_sf
:
576 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
577 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
578 insn_ptr
= read_sleb128 (insn_ptr
, insn_end
, &offset
);
579 offset
*= fs
->data_align
;
580 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
581 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
582 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
585 case DW_CFA_val_offset
:
586 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
587 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
588 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
589 offset
= utmp
* fs
->data_align
;
590 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_VAL_OFFSET
;
591 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
594 case DW_CFA_val_offset_sf
:
595 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
596 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
597 insn_ptr
= read_sleb128 (insn_ptr
, insn_end
, &offset
);
598 offset
*= fs
->data_align
;
599 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_VAL_OFFSET
;
600 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
603 case DW_CFA_val_expression
:
604 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
605 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
606 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
607 fs
->regs
.reg
[reg
].loc
.exp
= insn_ptr
;
608 fs
->regs
.reg
[reg
].exp_len
= utmp
;
609 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_VAL_EXP
;
613 case DW_CFA_def_cfa_sf
:
614 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &fs
->regs
.cfa_reg
);
615 fs
->regs
.cfa_reg
= dwarf2_frame_adjust_regnum (gdbarch
,
618 insn_ptr
= read_sleb128 (insn_ptr
, insn_end
, &offset
);
619 fs
->regs
.cfa_offset
= offset
* fs
->data_align
;
620 fs
->regs
.cfa_how
= CFA_REG_OFFSET
;
623 case DW_CFA_def_cfa_offset_sf
:
624 insn_ptr
= read_sleb128 (insn_ptr
, insn_end
, &offset
);
625 fs
->regs
.cfa_offset
= offset
* fs
->data_align
;
626 /* cfa_how deliberately not set. */
629 case DW_CFA_GNU_window_save
:
630 /* This is SPARC-specific code, and contains hard-coded
631 constants for the register numbering scheme used by
632 GCC. Rather than having a architecture-specific
633 operation that's only ever used by a single
634 architecture, we provide the implementation here.
635 Incidentally that's what GCC does too in its
638 int size
= register_size (gdbarch
, 0);
639 dwarf2_frame_state_alloc_regs (&fs
->regs
, 32);
640 for (reg
= 8; reg
< 16; reg
++)
642 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_REG
;
643 fs
->regs
.reg
[reg
].loc
.reg
= reg
+ 16;
645 for (reg
= 16; reg
< 32; reg
++)
647 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
648 fs
->regs
.reg
[reg
].loc
.offset
= (reg
- 16) * size
;
653 case DW_CFA_GNU_args_size
:
655 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
658 case DW_CFA_GNU_negative_offset_extended
:
659 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
660 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
661 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &offset
);
662 offset
*= fs
->data_align
;
663 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
664 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
665 fs
->regs
.reg
[reg
].loc
.offset
= -offset
;
669 internal_error (__FILE__
, __LINE__
, _("Unknown CFI encountered."));
674 /* Don't allow remember/restore between CIE and FDE programs. */
675 dwarf2_frame_state_free_regs (fs
->regs
.prev
);
676 fs
->regs
.prev
= NULL
;
680 /* Architecture-specific operations. */
682 /* Per-architecture data key. */
683 static struct gdbarch_data
*dwarf2_frame_data
;
685 struct dwarf2_frame_ops
687 /* Pre-initialize the register state REG for register REGNUM. */
688 void (*init_reg
) (struct gdbarch
*, int, struct dwarf2_frame_state_reg
*,
689 struct frame_info
*);
691 /* Check whether the THIS_FRAME is a signal trampoline. */
692 int (*signal_frame_p
) (struct gdbarch
*, struct frame_info
*);
694 /* Convert .eh_frame register number to DWARF register number, or
695 adjust .debug_frame register number. */
696 int (*adjust_regnum
) (struct gdbarch
*, int, int);
699 /* Default architecture-specific register state initialization
703 dwarf2_frame_default_init_reg (struct gdbarch
*gdbarch
, int regnum
,
704 struct dwarf2_frame_state_reg
*reg
,
705 struct frame_info
*this_frame
)
707 /* If we have a register that acts as a program counter, mark it as
708 a destination for the return address. If we have a register that
709 serves as the stack pointer, arrange for it to be filled with the
710 call frame address (CFA). The other registers are marked as
713 We copy the return address to the program counter, since many
714 parts in GDB assume that it is possible to get the return address
715 by unwinding the program counter register. However, on ISA's
716 with a dedicated return address register, the CFI usually only
717 contains information to unwind that return address register.
719 The reason we're treating the stack pointer special here is
720 because in many cases GCC doesn't emit CFI for the stack pointer
721 and implicitly assumes that it is equal to the CFA. This makes
722 some sense since the DWARF specification (version 3, draft 8,
725 "Typically, the CFA is defined to be the value of the stack
726 pointer at the call site in the previous frame (which may be
727 different from its value on entry to the current frame)."
729 However, this isn't true for all platforms supported by GCC
730 (e.g. IBM S/390 and zSeries). Those architectures should provide
731 their own architecture-specific initialization function. */
733 if (regnum
== gdbarch_pc_regnum (gdbarch
))
734 reg
->how
= DWARF2_FRAME_REG_RA
;
735 else if (regnum
== gdbarch_sp_regnum (gdbarch
))
736 reg
->how
= DWARF2_FRAME_REG_CFA
;
739 /* Return a default for the architecture-specific operations. */
742 dwarf2_frame_init (struct obstack
*obstack
)
744 struct dwarf2_frame_ops
*ops
;
746 ops
= OBSTACK_ZALLOC (obstack
, struct dwarf2_frame_ops
);
747 ops
->init_reg
= dwarf2_frame_default_init_reg
;
751 /* Set the architecture-specific register state initialization
752 function for GDBARCH to INIT_REG. */
755 dwarf2_frame_set_init_reg (struct gdbarch
*gdbarch
,
756 void (*init_reg
) (struct gdbarch
*, int,
757 struct dwarf2_frame_state_reg
*,
758 struct frame_info
*))
760 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
762 ops
->init_reg
= init_reg
;
765 /* Pre-initialize the register state REG for register REGNUM. */
768 dwarf2_frame_init_reg (struct gdbarch
*gdbarch
, int regnum
,
769 struct dwarf2_frame_state_reg
*reg
,
770 struct frame_info
*this_frame
)
772 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
774 ops
->init_reg (gdbarch
, regnum
, reg
, this_frame
);
777 /* Set the architecture-specific signal trampoline recognition
778 function for GDBARCH to SIGNAL_FRAME_P. */
781 dwarf2_frame_set_signal_frame_p (struct gdbarch
*gdbarch
,
782 int (*signal_frame_p
) (struct gdbarch
*,
783 struct frame_info
*))
785 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
787 ops
->signal_frame_p
= signal_frame_p
;
790 /* Query the architecture-specific signal frame recognizer for
794 dwarf2_frame_signal_frame_p (struct gdbarch
*gdbarch
,
795 struct frame_info
*this_frame
)
797 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
799 if (ops
->signal_frame_p
== NULL
)
801 return ops
->signal_frame_p (gdbarch
, this_frame
);
804 /* Set the architecture-specific adjustment of .eh_frame and .debug_frame
808 dwarf2_frame_set_adjust_regnum (struct gdbarch
*gdbarch
,
809 int (*adjust_regnum
) (struct gdbarch
*,
812 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
814 ops
->adjust_regnum
= adjust_regnum
;
817 /* Translate a .eh_frame register to DWARF register, or adjust a .debug_frame
821 dwarf2_frame_adjust_regnum (struct gdbarch
*gdbarch
, int regnum
, int eh_frame_p
)
823 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
825 if (ops
->adjust_regnum
== NULL
)
827 return ops
->adjust_regnum (gdbarch
, regnum
, eh_frame_p
);
831 dwarf2_frame_find_quirks (struct dwarf2_frame_state
*fs
,
832 struct dwarf2_fde
*fde
)
834 static const char *arm_idents
[] = {
835 "ARM C Compiler, ADS",
836 "Thumb C Compiler, ADS",
837 "ARM C++ Compiler, ADS",
838 "Thumb C++ Compiler, ADS",
839 "ARM/Thumb C/C++ Compiler, RVCT"
845 s
= find_pc_symtab (fs
->pc
);
846 if (s
== NULL
|| s
->producer
== NULL
)
849 for (i
= 0; i
< ARRAY_SIZE (arm_idents
); i
++)
850 if (strncmp (s
->producer
, arm_idents
[i
], strlen (arm_idents
[i
])) == 0)
852 if (fde
->cie
->version
== 1)
853 fs
->armcc_cfa_offsets_sf
= 1;
855 if (fde
->cie
->version
== 1)
856 fs
->armcc_cfa_offsets_reversed
= 1;
858 /* The reversed offset problem is present in some compilers
859 using DWARF3, but it was eventually fixed. Check the ARM
860 defined augmentations, which are in the format "armcc" followed
861 by a list of one-character options. The "+" option means
862 this problem is fixed (no quirk needed). If the armcc
863 augmentation is missing, the quirk is needed. */
864 if (fde
->cie
->version
== 3
865 && (strncmp (fde
->cie
->augmentation
, "armcc", 5) != 0
866 || strchr (fde
->cie
->augmentation
+ 5, '+') == NULL
))
867 fs
->armcc_cfa_offsets_reversed
= 1;
874 struct dwarf2_frame_cache
876 /* DWARF Call Frame Address. */
879 /* Set if the return address column was marked as undefined. */
880 int undefined_retaddr
;
882 /* Saved registers, indexed by GDB register number, not by DWARF
884 struct dwarf2_frame_state_reg
*reg
;
886 /* Return address register. */
887 struct dwarf2_frame_state_reg retaddr_reg
;
889 /* Target address size in bytes. */
893 static struct dwarf2_frame_cache
*
894 dwarf2_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
896 struct cleanup
*old_chain
;
897 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
898 const int num_regs
= gdbarch_num_regs (gdbarch
)
899 + gdbarch_num_pseudo_regs (gdbarch
);
900 struct dwarf2_frame_cache
*cache
;
901 struct dwarf2_frame_state
*fs
;
902 struct dwarf2_fde
*fde
;
907 /* Allocate a new cache. */
908 cache
= FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache
);
909 cache
->reg
= FRAME_OBSTACK_CALLOC (num_regs
, struct dwarf2_frame_state_reg
);
911 /* Allocate and initialize the frame state. */
912 fs
= XMALLOC (struct dwarf2_frame_state
);
913 memset (fs
, 0, sizeof (struct dwarf2_frame_state
));
914 old_chain
= make_cleanup (dwarf2_frame_state_free
, fs
);
918 Note that if the next frame is never supposed to return (i.e. a call
919 to abort), the compiler might optimize away the instruction at
920 its return address. As a result the return address will
921 point at some random instruction, and the CFI for that
922 instruction is probably worthless to us. GCC's unwinder solves
923 this problem by substracting 1 from the return address to get an
924 address in the middle of a presumed call instruction (or the
925 instruction in the associated delay slot). This should only be
926 done for "normal" frames and not for resume-type frames (signal
927 handlers, sentinel frames, dummy frames). The function
928 get_frame_address_in_block does just this. It's not clear how
929 reliable the method is though; there is the potential for the
930 register state pre-call being different to that on return. */
931 fs
->pc
= get_frame_address_in_block (this_frame
);
933 /* Find the correct FDE. */
934 fde
= dwarf2_frame_find_fde (&fs
->pc
);
935 gdb_assert (fde
!= NULL
);
937 /* Extract any interesting information from the CIE. */
938 fs
->data_align
= fde
->cie
->data_alignment_factor
;
939 fs
->code_align
= fde
->cie
->code_alignment_factor
;
940 fs
->retaddr_column
= fde
->cie
->return_address_register
;
941 cache
->addr_size
= fde
->cie
->addr_size
;
943 /* Check for "quirks" - known bugs in producers. */
944 dwarf2_frame_find_quirks (fs
, fde
);
946 /* First decode all the insns in the CIE. */
947 execute_cfa_program (fde
, fde
->cie
->initial_instructions
,
948 fde
->cie
->end
, this_frame
, fs
);
950 /* Save the initialized register set. */
951 fs
->initial
= fs
->regs
;
952 fs
->initial
.reg
= dwarf2_frame_state_copy_regs (&fs
->regs
);
954 /* Then decode the insns in the FDE up to our target PC. */
955 execute_cfa_program (fde
, fde
->instructions
, fde
->end
, this_frame
, fs
);
957 /* Calculate the CFA. */
958 switch (fs
->regs
.cfa_how
)
961 cache
->cfa
= read_reg (this_frame
, fs
->regs
.cfa_reg
);
962 if (fs
->armcc_cfa_offsets_reversed
)
963 cache
->cfa
-= fs
->regs
.cfa_offset
;
965 cache
->cfa
+= fs
->regs
.cfa_offset
;
970 execute_stack_op (fs
->regs
.cfa_exp
, fs
->regs
.cfa_exp_len
,
971 cache
->addr_size
, this_frame
, 0);
975 internal_error (__FILE__
, __LINE__
, _("Unknown CFA rule."));
978 /* Initialize the register state. */
982 for (regnum
= 0; regnum
< num_regs
; regnum
++)
983 dwarf2_frame_init_reg (gdbarch
, regnum
, &cache
->reg
[regnum
], this_frame
);
986 /* Go through the DWARF2 CFI generated table and save its register
987 location information in the cache. Note that we don't skip the
988 return address column; it's perfectly all right for it to
989 correspond to a real register. If it doesn't correspond to a
990 real register, or if we shouldn't treat it as such,
991 gdbarch_dwarf2_reg_to_regnum should be defined to return a number outside
992 the range [0, gdbarch_num_regs). */
994 int column
; /* CFI speak for "register number". */
996 for (column
= 0; column
< fs
->regs
.num_regs
; column
++)
998 /* Use the GDB register number as the destination index. */
999 int regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, column
);
1001 /* If there's no corresponding GDB register, ignore it. */
1002 if (regnum
< 0 || regnum
>= num_regs
)
1005 /* NOTE: cagney/2003-09-05: CFI should specify the disposition
1006 of all debug info registers. If it doesn't, complain (but
1007 not too loudly). It turns out that GCC assumes that an
1008 unspecified register implies "same value" when CFI (draft
1009 7) specifies nothing at all. Such a register could equally
1010 be interpreted as "undefined". Also note that this check
1011 isn't sufficient; it only checks that all registers in the
1012 range [0 .. max column] are specified, and won't detect
1013 problems when a debug info register falls outside of the
1014 table. We need a way of iterating through all the valid
1015 DWARF2 register numbers. */
1016 if (fs
->regs
.reg
[column
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
1018 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
1019 complaint (&symfile_complaints
, _("\
1020 incomplete CFI data; unspecified registers (e.g., %s) at %s"),
1021 gdbarch_register_name (gdbarch
, regnum
),
1022 paddress (gdbarch
, fs
->pc
));
1025 cache
->reg
[regnum
] = fs
->regs
.reg
[column
];
1029 /* Eliminate any DWARF2_FRAME_REG_RA rules, and save the information
1030 we need for evaluating DWARF2_FRAME_REG_RA_OFFSET rules. */
1034 for (regnum
= 0; regnum
< num_regs
; regnum
++)
1036 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
1037 || cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA_OFFSET
)
1039 struct dwarf2_frame_state_reg
*retaddr_reg
=
1040 &fs
->regs
.reg
[fs
->retaddr_column
];
1042 /* It seems rather bizarre to specify an "empty" column as
1043 the return adress column. However, this is exactly
1044 what GCC does on some targets. It turns out that GCC
1045 assumes that the return address can be found in the
1046 register corresponding to the return address column.
1047 Incidentally, that's how we should treat a return
1048 address column specifying "same value" too. */
1049 if (fs
->retaddr_column
< fs
->regs
.num_regs
1050 && retaddr_reg
->how
!= DWARF2_FRAME_REG_UNSPECIFIED
1051 && retaddr_reg
->how
!= DWARF2_FRAME_REG_SAME_VALUE
)
1053 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
)
1054 cache
->reg
[regnum
] = *retaddr_reg
;
1056 cache
->retaddr_reg
= *retaddr_reg
;
1060 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
)
1062 cache
->reg
[regnum
].loc
.reg
= fs
->retaddr_column
;
1063 cache
->reg
[regnum
].how
= DWARF2_FRAME_REG_SAVED_REG
;
1067 cache
->retaddr_reg
.loc
.reg
= fs
->retaddr_column
;
1068 cache
->retaddr_reg
.how
= DWARF2_FRAME_REG_SAVED_REG
;
1075 if (fs
->retaddr_column
< fs
->regs
.num_regs
1076 && fs
->regs
.reg
[fs
->retaddr_column
].how
== DWARF2_FRAME_REG_UNDEFINED
)
1077 cache
->undefined_retaddr
= 1;
1079 do_cleanups (old_chain
);
1081 *this_cache
= cache
;
1086 dwarf2_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
1087 struct frame_id
*this_id
)
1089 struct dwarf2_frame_cache
*cache
=
1090 dwarf2_frame_cache (this_frame
, this_cache
);
1092 if (cache
->undefined_retaddr
)
1095 (*this_id
) = frame_id_build (cache
->cfa
, get_frame_func (this_frame
));
1098 static struct value
*
1099 dwarf2_frame_prev_register (struct frame_info
*this_frame
, void **this_cache
,
1102 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1103 struct dwarf2_frame_cache
*cache
=
1104 dwarf2_frame_cache (this_frame
, this_cache
);
1108 switch (cache
->reg
[regnum
].how
)
1110 case DWARF2_FRAME_REG_UNDEFINED
:
1111 /* If CFI explicitly specified that the value isn't defined,
1112 mark it as optimized away; the value isn't available. */
1113 return frame_unwind_got_optimized (this_frame
, regnum
);
1115 case DWARF2_FRAME_REG_SAVED_OFFSET
:
1116 addr
= cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
;
1117 return frame_unwind_got_memory (this_frame
, regnum
, addr
);
1119 case DWARF2_FRAME_REG_SAVED_REG
:
1121 = gdbarch_dwarf2_reg_to_regnum (gdbarch
, cache
->reg
[regnum
].loc
.reg
);
1122 return frame_unwind_got_register (this_frame
, regnum
, realnum
);
1124 case DWARF2_FRAME_REG_SAVED_EXP
:
1125 addr
= execute_stack_op (cache
->reg
[regnum
].loc
.exp
,
1126 cache
->reg
[regnum
].exp_len
,
1127 cache
->addr_size
, this_frame
, cache
->cfa
);
1128 return frame_unwind_got_memory (this_frame
, regnum
, addr
);
1130 case DWARF2_FRAME_REG_SAVED_VAL_OFFSET
:
1131 addr
= cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
;
1132 return frame_unwind_got_constant (this_frame
, regnum
, addr
);
1134 case DWARF2_FRAME_REG_SAVED_VAL_EXP
:
1135 addr
= execute_stack_op (cache
->reg
[regnum
].loc
.exp
,
1136 cache
->reg
[regnum
].exp_len
,
1137 cache
->addr_size
, this_frame
, cache
->cfa
);
1138 return frame_unwind_got_constant (this_frame
, regnum
, addr
);
1140 case DWARF2_FRAME_REG_UNSPECIFIED
:
1141 /* GCC, in its infinite wisdom decided to not provide unwind
1142 information for registers that are "same value". Since
1143 DWARF2 (3 draft 7) doesn't define such behavior, said
1144 registers are actually undefined (which is different to CFI
1145 "undefined"). Code above issues a complaint about this.
1146 Here just fudge the books, assume GCC, and that the value is
1147 more inner on the stack. */
1148 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
1150 case DWARF2_FRAME_REG_SAME_VALUE
:
1151 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
1153 case DWARF2_FRAME_REG_CFA
:
1154 return frame_unwind_got_address (this_frame
, regnum
, cache
->cfa
);
1156 case DWARF2_FRAME_REG_CFA_OFFSET
:
1157 addr
= cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
;
1158 return frame_unwind_got_address (this_frame
, regnum
, addr
);
1160 case DWARF2_FRAME_REG_RA_OFFSET
:
1161 addr
= cache
->reg
[regnum
].loc
.offset
;
1162 regnum
= gdbarch_dwarf2_reg_to_regnum
1163 (gdbarch
, cache
->retaddr_reg
.loc
.reg
);
1164 addr
+= get_frame_register_unsigned (this_frame
, regnum
);
1165 return frame_unwind_got_address (this_frame
, regnum
, addr
);
1167 case DWARF2_FRAME_REG_FN
:
1168 return cache
->reg
[regnum
].loc
.fn (this_frame
, this_cache
, regnum
);
1171 internal_error (__FILE__
, __LINE__
, _("Unknown register rule."));
1176 dwarf2_frame_sniffer (const struct frame_unwind
*self
,
1177 struct frame_info
*this_frame
, void **this_cache
)
1179 /* Grab an address that is guarenteed to reside somewhere within the
1180 function. get_frame_pc(), with a no-return next function, can
1181 end up returning something past the end of this function's body.
1182 If the frame we're sniffing for is a signal frame whose start
1183 address is placed on the stack by the OS, its FDE must
1184 extend one byte before its start address or we could potentially
1185 select the FDE of the previous function. */
1186 CORE_ADDR block_addr
= get_frame_address_in_block (this_frame
);
1187 struct dwarf2_fde
*fde
= dwarf2_frame_find_fde (&block_addr
);
1191 /* On some targets, signal trampolines may have unwind information.
1192 We need to recognize them so that we set the frame type
1195 if (fde
->cie
->signal_frame
1196 || dwarf2_frame_signal_frame_p (get_frame_arch (this_frame
),
1198 return self
->type
== SIGTRAMP_FRAME
;
1200 return self
->type
!= SIGTRAMP_FRAME
;
1203 static const struct frame_unwind dwarf2_frame_unwind
=
1206 dwarf2_frame_this_id
,
1207 dwarf2_frame_prev_register
,
1209 dwarf2_frame_sniffer
1212 static const struct frame_unwind dwarf2_signal_frame_unwind
=
1215 dwarf2_frame_this_id
,
1216 dwarf2_frame_prev_register
,
1218 dwarf2_frame_sniffer
1221 /* Append the DWARF-2 frame unwinders to GDBARCH's list. */
1224 dwarf2_append_unwinders (struct gdbarch
*gdbarch
)
1226 frame_unwind_append_unwinder (gdbarch
, &dwarf2_frame_unwind
);
1227 frame_unwind_append_unwinder (gdbarch
, &dwarf2_signal_frame_unwind
);
1231 /* There is no explicitly defined relationship between the CFA and the
1232 location of frame's local variables and arguments/parameters.
1233 Therefore, frame base methods on this page should probably only be
1234 used as a last resort, just to avoid printing total garbage as a
1235 response to the "info frame" command. */
1238 dwarf2_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
1240 struct dwarf2_frame_cache
*cache
=
1241 dwarf2_frame_cache (this_frame
, this_cache
);
1246 static const struct frame_base dwarf2_frame_base
=
1248 &dwarf2_frame_unwind
,
1249 dwarf2_frame_base_address
,
1250 dwarf2_frame_base_address
,
1251 dwarf2_frame_base_address
1254 const struct frame_base
*
1255 dwarf2_frame_base_sniffer (struct frame_info
*this_frame
)
1257 CORE_ADDR block_addr
= get_frame_address_in_block (this_frame
);
1258 if (dwarf2_frame_find_fde (&block_addr
))
1259 return &dwarf2_frame_base
;
1264 /* Compute the CFA for THIS_FRAME, but only if THIS_FRAME came from
1265 the DWARF unwinder. This is used to implement
1266 DW_OP_call_frame_cfa. */
1269 dwarf2_frame_cfa (struct frame_info
*this_frame
)
1271 while (get_frame_type (this_frame
) == INLINE_FRAME
)
1272 this_frame
= get_prev_frame (this_frame
);
1273 /* This restriction could be lifted if other unwinders are known to
1274 compute the frame base in a way compatible with the DWARF
1276 if (! frame_unwinder_is (this_frame
, &dwarf2_frame_unwind
))
1277 error (_("can't compute CFA for this frame"));
1278 return get_frame_base (this_frame
);
1281 const struct objfile_data
*dwarf2_frame_objfile_data
;
1284 read_1_byte (bfd
*abfd
, gdb_byte
*buf
)
1286 return bfd_get_8 (abfd
, buf
);
1290 read_4_bytes (bfd
*abfd
, gdb_byte
*buf
)
1292 return bfd_get_32 (abfd
, buf
);
1296 read_8_bytes (bfd
*abfd
, gdb_byte
*buf
)
1298 return bfd_get_64 (abfd
, buf
);
1302 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1305 unsigned int num_read
;
1315 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
1318 result
|= ((byte
& 0x7f) << shift
);
1321 while (byte
& 0x80);
1323 *bytes_read_ptr
= num_read
;
1329 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1333 unsigned int num_read
;
1342 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
1345 result
|= ((byte
& 0x7f) << shift
);
1348 while (byte
& 0x80);
1350 if (shift
< 8 * sizeof (result
) && (byte
& 0x40))
1351 result
|= -(((LONGEST
)1) << shift
);
1353 *bytes_read_ptr
= num_read
;
1359 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1363 result
= bfd_get_32 (abfd
, buf
);
1364 if (result
== 0xffffffff)
1366 result
= bfd_get_64 (abfd
, buf
+ 4);
1367 *bytes_read_ptr
= 12;
1370 *bytes_read_ptr
= 4;
1376 /* Pointer encoding helper functions. */
1378 /* GCC supports exception handling based on DWARF2 CFI. However, for
1379 technical reasons, it encodes addresses in its FDE's in a different
1380 way. Several "pointer encodings" are supported. The encoding
1381 that's used for a particular FDE is determined by the 'R'
1382 augmentation in the associated CIE. The argument of this
1383 augmentation is a single byte.
1385 The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a
1386 LEB128. This is encoded in bits 0, 1 and 2. Bit 3 encodes whether
1387 the address is signed or unsigned. Bits 4, 5 and 6 encode how the
1388 address should be interpreted (absolute, relative to the current
1389 position in the FDE, ...). Bit 7, indicates that the address
1390 should be dereferenced. */
1393 encoding_for_size (unsigned int size
)
1398 return DW_EH_PE_udata2
;
1400 return DW_EH_PE_udata4
;
1402 return DW_EH_PE_udata8
;
1404 internal_error (__FILE__
, __LINE__
, _("Unsupported address size"));
1409 read_encoded_value (struct comp_unit
*unit
, gdb_byte encoding
,
1410 int ptr_len
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
,
1411 CORE_ADDR func_base
)
1416 /* GCC currently doesn't generate DW_EH_PE_indirect encodings for
1418 if (encoding
& DW_EH_PE_indirect
)
1419 internal_error (__FILE__
, __LINE__
,
1420 _("Unsupported encoding: DW_EH_PE_indirect"));
1422 *bytes_read_ptr
= 0;
1424 switch (encoding
& 0x70)
1426 case DW_EH_PE_absptr
:
1429 case DW_EH_PE_pcrel
:
1430 base
= bfd_get_section_vma (unit
->abfd
, unit
->dwarf_frame_section
);
1431 base
+= (buf
- unit
->dwarf_frame_buffer
);
1433 case DW_EH_PE_datarel
:
1436 case DW_EH_PE_textrel
:
1439 case DW_EH_PE_funcrel
:
1442 case DW_EH_PE_aligned
:
1444 offset
= buf
- unit
->dwarf_frame_buffer
;
1445 if ((offset
% ptr_len
) != 0)
1447 *bytes_read_ptr
= ptr_len
- (offset
% ptr_len
);
1448 buf
+= *bytes_read_ptr
;
1452 internal_error (__FILE__
, __LINE__
, _("Invalid or unsupported encoding"));
1455 if ((encoding
& 0x07) == 0x00)
1457 encoding
|= encoding_for_size (ptr_len
);
1458 if (bfd_get_sign_extend_vma (unit
->abfd
))
1459 encoding
|= DW_EH_PE_signed
;
1462 switch (encoding
& 0x0f)
1464 case DW_EH_PE_uleb128
:
1467 gdb_byte
*end_buf
= buf
+ (sizeof (value
) + 1) * 8 / 7;
1468 *bytes_read_ptr
+= read_uleb128 (buf
, end_buf
, &value
) - buf
;
1469 return base
+ value
;
1471 case DW_EH_PE_udata2
:
1472 *bytes_read_ptr
+= 2;
1473 return (base
+ bfd_get_16 (unit
->abfd
, (bfd_byte
*) buf
));
1474 case DW_EH_PE_udata4
:
1475 *bytes_read_ptr
+= 4;
1476 return (base
+ bfd_get_32 (unit
->abfd
, (bfd_byte
*) buf
));
1477 case DW_EH_PE_udata8
:
1478 *bytes_read_ptr
+= 8;
1479 return (base
+ bfd_get_64 (unit
->abfd
, (bfd_byte
*) buf
));
1480 case DW_EH_PE_sleb128
:
1483 gdb_byte
*end_buf
= buf
+ (sizeof (value
) + 1) * 8 / 7;
1484 *bytes_read_ptr
+= read_sleb128 (buf
, end_buf
, &value
) - buf
;
1485 return base
+ value
;
1487 case DW_EH_PE_sdata2
:
1488 *bytes_read_ptr
+= 2;
1489 return (base
+ bfd_get_signed_16 (unit
->abfd
, (bfd_byte
*) buf
));
1490 case DW_EH_PE_sdata4
:
1491 *bytes_read_ptr
+= 4;
1492 return (base
+ bfd_get_signed_32 (unit
->abfd
, (bfd_byte
*) buf
));
1493 case DW_EH_PE_sdata8
:
1494 *bytes_read_ptr
+= 8;
1495 return (base
+ bfd_get_signed_64 (unit
->abfd
, (bfd_byte
*) buf
));
1497 internal_error (__FILE__
, __LINE__
, _("Invalid or unsupported encoding"));
1503 bsearch_cie_cmp (const void *key
, const void *element
)
1505 ULONGEST cie_pointer
= *(ULONGEST
*) key
;
1506 struct dwarf2_cie
*cie
= *(struct dwarf2_cie
**) element
;
1508 if (cie_pointer
== cie
->cie_pointer
)
1511 return (cie_pointer
< cie
->cie_pointer
) ? -1 : 1;
1514 /* Find CIE with the given CIE_POINTER in CIE_TABLE. */
1515 static struct dwarf2_cie
*
1516 find_cie (struct dwarf2_cie_table
*cie_table
, ULONGEST cie_pointer
)
1518 struct dwarf2_cie
**p_cie
;
1520 p_cie
= bsearch (&cie_pointer
, cie_table
->entries
, cie_table
->num_entries
,
1521 sizeof (cie_table
->entries
[0]), bsearch_cie_cmp
);
1527 /* Add a pointer to new CIE to the CIE_TABLE, allocating space for it. */
1529 add_cie (struct dwarf2_cie_table
*cie_table
, struct dwarf2_cie
*cie
)
1531 const int n
= cie_table
->num_entries
;
1534 || cie_table
->entries
[n
- 1]->cie_pointer
< cie
->cie_pointer
);
1536 cie_table
->entries
=
1537 xrealloc (cie_table
->entries
, (n
+ 1) * sizeof (cie_table
->entries
[0]));
1538 cie_table
->entries
[n
] = cie
;
1539 cie_table
->num_entries
= n
+ 1;
1543 bsearch_fde_cmp (const void *key
, const void *element
)
1545 CORE_ADDR seek_pc
= *(CORE_ADDR
*) key
;
1546 struct dwarf2_fde
*fde
= *(struct dwarf2_fde
**) element
;
1547 if (seek_pc
< fde
->initial_location
)
1549 if (seek_pc
< fde
->initial_location
+ fde
->address_range
)
1554 /* Find the FDE for *PC. Return a pointer to the FDE, and store the
1555 inital location associated with it into *PC. */
1557 static struct dwarf2_fde
*
1558 dwarf2_frame_find_fde (CORE_ADDR
*pc
)
1560 struct objfile
*objfile
;
1562 ALL_OBJFILES (objfile
)
1564 struct dwarf2_fde_table
*fde_table
;
1565 struct dwarf2_fde
**p_fde
;
1569 fde_table
= objfile_data (objfile
, dwarf2_frame_objfile_data
);
1570 if (fde_table
== NULL
)
1573 gdb_assert (objfile
->section_offsets
);
1574 offset
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1576 gdb_assert (fde_table
->num_entries
> 0);
1577 if (*pc
< offset
+ fde_table
->entries
[0]->initial_location
)
1580 seek_pc
= *pc
- offset
;
1581 p_fde
= bsearch (&seek_pc
, fde_table
->entries
, fde_table
->num_entries
,
1582 sizeof (fde_table
->entries
[0]), bsearch_fde_cmp
);
1585 *pc
= (*p_fde
)->initial_location
+ offset
;
1592 /* Add a pointer to new FDE to the FDE_TABLE, allocating space for it. */
1594 add_fde (struct dwarf2_fde_table
*fde_table
, struct dwarf2_fde
*fde
)
1596 if (fde
->address_range
== 0)
1597 /* Discard useless FDEs. */
1600 fde_table
->num_entries
+= 1;
1601 fde_table
->entries
=
1602 xrealloc (fde_table
->entries
,
1603 fde_table
->num_entries
* sizeof (fde_table
->entries
[0]));
1604 fde_table
->entries
[fde_table
->num_entries
- 1] = fde
;
1607 #ifdef CC_HAS_LONG_LONG
1608 #define DW64_CIE_ID 0xffffffffffffffffULL
1610 #define DW64_CIE_ID ~0
1613 static gdb_byte
*decode_frame_entry (struct comp_unit
*unit
, gdb_byte
*start
,
1615 struct dwarf2_cie_table
*cie_table
,
1616 struct dwarf2_fde_table
*fde_table
);
1618 /* Decode the next CIE or FDE. Return NULL if invalid input, otherwise
1619 the next byte to be processed. */
1621 decode_frame_entry_1 (struct comp_unit
*unit
, gdb_byte
*start
, int eh_frame_p
,
1622 struct dwarf2_cie_table
*cie_table
,
1623 struct dwarf2_fde_table
*fde_table
)
1625 struct gdbarch
*gdbarch
= get_objfile_arch (unit
->objfile
);
1626 gdb_byte
*buf
, *end
;
1628 unsigned int bytes_read
;
1631 ULONGEST cie_pointer
;
1634 length
= read_initial_length (unit
->abfd
, buf
, &bytes_read
);
1638 /* Are we still within the section? */
1639 if (end
> unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
)
1645 /* Distinguish between 32 and 64-bit encoded frame info. */
1646 dwarf64_p
= (bytes_read
== 12);
1648 /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs. */
1652 cie_id
= DW64_CIE_ID
;
1658 cie_pointer
= read_8_bytes (unit
->abfd
, buf
);
1663 cie_pointer
= read_4_bytes (unit
->abfd
, buf
);
1667 if (cie_pointer
== cie_id
)
1669 /* This is a CIE. */
1670 struct dwarf2_cie
*cie
;
1672 unsigned int cie_version
;
1674 /* Record the offset into the .debug_frame section of this CIE. */
1675 cie_pointer
= start
- unit
->dwarf_frame_buffer
;
1677 /* Check whether we've already read it. */
1678 if (find_cie (cie_table
, cie_pointer
))
1681 cie
= (struct dwarf2_cie
*)
1682 obstack_alloc (&unit
->objfile
->objfile_obstack
,
1683 sizeof (struct dwarf2_cie
));
1684 cie
->initial_instructions
= NULL
;
1685 cie
->cie_pointer
= cie_pointer
;
1687 /* The encoding for FDE's in a normal .debug_frame section
1688 depends on the target address size. */
1689 cie
->encoding
= DW_EH_PE_absptr
;
1691 /* The target address size. For .eh_frame FDEs this is considered
1692 equal to the size of a target pointer. For .dwarf_frame FDEs,
1693 this is supposed to be the target address size from the associated
1694 CU header. FIXME: We do not have a good way to determine the
1695 latter. Always use the target pointer size for now. */
1696 cie
->addr_size
= gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
;
1698 /* We'll determine the final value later, but we need to
1699 initialize it conservatively. */
1700 cie
->signal_frame
= 0;
1702 /* Check version number. */
1703 cie_version
= read_1_byte (unit
->abfd
, buf
);
1704 if (cie_version
!= 1 && cie_version
!= 3)
1706 cie
->version
= cie_version
;
1709 /* Interpret the interesting bits of the augmentation. */
1710 cie
->augmentation
= augmentation
= (char *) buf
;
1711 buf
+= (strlen (augmentation
) + 1);
1713 /* Ignore armcc augmentations. We only use them for quirks,
1714 and that doesn't happen until later. */
1715 if (strncmp (augmentation
, "armcc", 5) == 0)
1716 augmentation
+= strlen (augmentation
);
1718 /* The GCC 2.x "eh" augmentation has a pointer immediately
1719 following the augmentation string, so it must be handled
1721 if (augmentation
[0] == 'e' && augmentation
[1] == 'h')
1724 buf
+= gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
;
1728 cie
->code_alignment_factor
=
1729 read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1732 cie
->data_alignment_factor
=
1733 read_signed_leb128 (unit
->abfd
, buf
, &bytes_read
);
1736 if (cie_version
== 1)
1738 cie
->return_address_register
= read_1_byte (unit
->abfd
, buf
);
1742 cie
->return_address_register
= read_unsigned_leb128 (unit
->abfd
, buf
,
1744 cie
->return_address_register
1745 = dwarf2_frame_adjust_regnum (gdbarch
,
1746 cie
->return_address_register
,
1751 cie
->saw_z_augmentation
= (*augmentation
== 'z');
1752 if (cie
->saw_z_augmentation
)
1756 length
= read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1760 cie
->initial_instructions
= buf
+ length
;
1764 while (*augmentation
)
1766 /* "L" indicates a byte showing how the LSDA pointer is encoded. */
1767 if (*augmentation
== 'L')
1774 /* "R" indicates a byte indicating how FDE addresses are encoded. */
1775 else if (*augmentation
== 'R')
1777 cie
->encoding
= *buf
++;
1781 /* "P" indicates a personality routine in the CIE augmentation. */
1782 else if (*augmentation
== 'P')
1784 /* Skip. Avoid indirection since we throw away the result. */
1785 gdb_byte encoding
= (*buf
++) & ~DW_EH_PE_indirect
;
1786 read_encoded_value (unit
, encoding
, cie
->addr_size
,
1787 buf
, &bytes_read
, 0);
1792 /* "S" indicates a signal frame, such that the return
1793 address must not be decremented to locate the call frame
1794 info for the previous frame; it might even be the first
1795 instruction of a function, so decrementing it would take
1796 us to a different function. */
1797 else if (*augmentation
== 'S')
1799 cie
->signal_frame
= 1;
1803 /* Otherwise we have an unknown augmentation. Assume that either
1804 there is no augmentation data, or we saw a 'z' prefix. */
1807 if (cie
->initial_instructions
)
1808 buf
= cie
->initial_instructions
;
1813 cie
->initial_instructions
= buf
;
1817 add_cie (cie_table
, cie
);
1821 /* This is a FDE. */
1822 struct dwarf2_fde
*fde
;
1824 /* In an .eh_frame section, the CIE pointer is the delta between the
1825 address within the FDE where the CIE pointer is stored and the
1826 address of the CIE. Convert it to an offset into the .eh_frame
1830 cie_pointer
= buf
- unit
->dwarf_frame_buffer
- cie_pointer
;
1831 cie_pointer
-= (dwarf64_p
? 8 : 4);
1834 /* In either case, validate the result is still within the section. */
1835 if (cie_pointer
>= unit
->dwarf_frame_size
)
1838 fde
= (struct dwarf2_fde
*)
1839 obstack_alloc (&unit
->objfile
->objfile_obstack
,
1840 sizeof (struct dwarf2_fde
));
1841 fde
->cie
= find_cie (cie_table
, cie_pointer
);
1842 if (fde
->cie
== NULL
)
1844 decode_frame_entry (unit
, unit
->dwarf_frame_buffer
+ cie_pointer
,
1845 eh_frame_p
, cie_table
, fde_table
);
1846 fde
->cie
= find_cie (cie_table
, cie_pointer
);
1849 gdb_assert (fde
->cie
!= NULL
);
1851 fde
->initial_location
=
1852 read_encoded_value (unit
, fde
->cie
->encoding
, fde
->cie
->addr_size
,
1853 buf
, &bytes_read
, 0);
1856 fde
->address_range
=
1857 read_encoded_value (unit
, fde
->cie
->encoding
& 0x0f,
1858 fde
->cie
->addr_size
, buf
, &bytes_read
, 0);
1861 /* A 'z' augmentation in the CIE implies the presence of an
1862 augmentation field in the FDE as well. The only thing known
1863 to be in here at present is the LSDA entry for EH. So we
1864 can skip the whole thing. */
1865 if (fde
->cie
->saw_z_augmentation
)
1869 length
= read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1870 buf
+= bytes_read
+ length
;
1875 fde
->instructions
= buf
;
1878 fde
->eh_frame_p
= eh_frame_p
;
1880 add_fde (fde_table
, fde
);
1886 /* Read a CIE or FDE in BUF and decode it. */
1888 decode_frame_entry (struct comp_unit
*unit
, gdb_byte
*start
, int eh_frame_p
,
1889 struct dwarf2_cie_table
*cie_table
,
1890 struct dwarf2_fde_table
*fde_table
)
1892 enum { NONE
, ALIGN4
, ALIGN8
, FAIL
} workaround
= NONE
;
1895 ptrdiff_t start_offset
;
1899 ret
= decode_frame_entry_1 (unit
, start
, eh_frame_p
,
1900 cie_table
, fde_table
);
1904 /* We have corrupt input data of some form. */
1906 /* ??? Try, weakly, to work around compiler/assembler/linker bugs
1907 and mismatches wrt padding and alignment of debug sections. */
1908 /* Note that there is no requirement in the standard for any
1909 alignment at all in the frame unwind sections. Testing for
1910 alignment before trying to interpret data would be incorrect.
1912 However, GCC traditionally arranged for frame sections to be
1913 sized such that the FDE length and CIE fields happen to be
1914 aligned (in theory, for performance). This, unfortunately,
1915 was done with .align directives, which had the side effect of
1916 forcing the section to be aligned by the linker.
1918 This becomes a problem when you have some other producer that
1919 creates frame sections that are not as strictly aligned. That
1920 produces a hole in the frame info that gets filled by the
1923 The GCC behaviour is arguably a bug, but it's effectively now
1924 part of the ABI, so we're now stuck with it, at least at the
1925 object file level. A smart linker may decide, in the process
1926 of compressing duplicate CIE information, that it can rewrite
1927 the entire output section without this extra padding. */
1929 start_offset
= start
- unit
->dwarf_frame_buffer
;
1930 if (workaround
< ALIGN4
&& (start_offset
& 3) != 0)
1932 start
+= 4 - (start_offset
& 3);
1933 workaround
= ALIGN4
;
1936 if (workaround
< ALIGN8
&& (start_offset
& 7) != 0)
1938 start
+= 8 - (start_offset
& 7);
1939 workaround
= ALIGN8
;
1943 /* Nothing left to try. Arrange to return as if we've consumed
1944 the entire input section. Hopefully we'll get valid info from
1945 the other of .debug_frame/.eh_frame. */
1947 ret
= unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
;
1957 complaint (&symfile_complaints
,
1958 _("Corrupt data in %s:%s; align 4 workaround apparently succeeded"),
1959 unit
->dwarf_frame_section
->owner
->filename
,
1960 unit
->dwarf_frame_section
->name
);
1964 complaint (&symfile_complaints
,
1965 _("Corrupt data in %s:%s; align 8 workaround apparently succeeded"),
1966 unit
->dwarf_frame_section
->owner
->filename
,
1967 unit
->dwarf_frame_section
->name
);
1971 complaint (&symfile_complaints
,
1972 _("Corrupt data in %s:%s"),
1973 unit
->dwarf_frame_section
->owner
->filename
,
1974 unit
->dwarf_frame_section
->name
);
1982 /* Imported from dwarf2read.c. */
1983 extern void dwarf2_get_section_info (struct objfile
*, const char *, asection
**,
1984 gdb_byte
**, bfd_size_type
*);
1987 qsort_fde_cmp (const void *a
, const void *b
)
1989 struct dwarf2_fde
*aa
= *(struct dwarf2_fde
**)a
;
1990 struct dwarf2_fde
*bb
= *(struct dwarf2_fde
**)b
;
1992 if (aa
->initial_location
== bb
->initial_location
)
1994 if (aa
->address_range
!= bb
->address_range
1995 && aa
->eh_frame_p
== 0 && bb
->eh_frame_p
== 0)
1996 /* Linker bug, e.g. gold/10400.
1997 Work around it by keeping stable sort order. */
1998 return (a
< b
) ? -1 : 1;
2000 /* Put eh_frame entries after debug_frame ones. */
2001 return aa
->eh_frame_p
- bb
->eh_frame_p
;
2004 return (aa
->initial_location
< bb
->initial_location
) ? -1 : 1;
2008 dwarf2_build_frame_info (struct objfile
*objfile
)
2010 struct comp_unit
*unit
;
2011 gdb_byte
*frame_ptr
;
2012 struct dwarf2_cie_table cie_table
;
2013 struct dwarf2_fde_table fde_table
;
2015 cie_table
.num_entries
= 0;
2016 cie_table
.entries
= NULL
;
2018 fde_table
.num_entries
= 0;
2019 fde_table
.entries
= NULL
;
2021 /* Build a minimal decoding of the DWARF2 compilation unit. */
2022 unit
= (struct comp_unit
*) obstack_alloc (&objfile
->objfile_obstack
,
2023 sizeof (struct comp_unit
));
2024 unit
->abfd
= objfile
->obfd
;
2025 unit
->objfile
= objfile
;
2029 dwarf2_get_section_info (objfile
, ".eh_frame",
2030 &unit
->dwarf_frame_section
,
2031 &unit
->dwarf_frame_buffer
,
2032 &unit
->dwarf_frame_size
);
2033 if (unit
->dwarf_frame_size
)
2035 asection
*got
, *txt
;
2037 /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
2038 that is used for the i386/amd64 target, which currently is
2039 the only target in GCC that supports/uses the
2040 DW_EH_PE_datarel encoding. */
2041 got
= bfd_get_section_by_name (unit
->abfd
, ".got");
2043 unit
->dbase
= got
->vma
;
2045 /* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64
2047 txt
= bfd_get_section_by_name (unit
->abfd
, ".text");
2049 unit
->tbase
= txt
->vma
;
2051 frame_ptr
= unit
->dwarf_frame_buffer
;
2052 while (frame_ptr
< unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
)
2053 frame_ptr
= decode_frame_entry (unit
, frame_ptr
, 1,
2054 &cie_table
, &fde_table
);
2056 if (cie_table
.num_entries
!= 0)
2058 /* Reinit cie_table: debug_frame has different CIEs. */
2059 xfree (cie_table
.entries
);
2060 cie_table
.num_entries
= 0;
2061 cie_table
.entries
= NULL
;
2065 dwarf2_get_section_info (objfile
, ".debug_frame",
2066 &unit
->dwarf_frame_section
,
2067 &unit
->dwarf_frame_buffer
,
2068 &unit
->dwarf_frame_size
);
2069 if (unit
->dwarf_frame_size
)
2071 frame_ptr
= unit
->dwarf_frame_buffer
;
2072 while (frame_ptr
< unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
)
2073 frame_ptr
= decode_frame_entry (unit
, frame_ptr
, 0,
2074 &cie_table
, &fde_table
);
2077 /* Discard the cie_table, it is no longer needed. */
2078 if (cie_table
.num_entries
!= 0)
2080 xfree (cie_table
.entries
);
2081 cie_table
.entries
= NULL
; /* Paranoia. */
2082 cie_table
.num_entries
= 0; /* Paranoia. */
2085 if (fde_table
.num_entries
!= 0)
2087 struct dwarf2_fde_table
*fde_table2
;
2090 /* Prepare FDE table for lookups. */
2091 qsort (fde_table
.entries
, fde_table
.num_entries
,
2092 sizeof (fde_table
.entries
[0]), qsort_fde_cmp
);
2094 /* Copy fde_table to obstack: it is needed at runtime. */
2095 fde_table2
= (struct dwarf2_fde_table
*)
2096 obstack_alloc (&objfile
->objfile_obstack
, sizeof (*fde_table2
));
2098 /* Since we'll be doing bsearch, squeeze out identical (except for
2099 eh_frame_p) fde entries so bsearch result is predictable. */
2100 for (i
= 0, j
= 0; j
< fde_table
.num_entries
; ++i
)
2104 obstack_grow (&objfile
->objfile_obstack
, &fde_table
.entries
[j
],
2105 sizeof (fde_table
.entries
[0]));
2106 while (++j
< fde_table
.num_entries
2107 && (fde_table
.entries
[k
]->initial_location
==
2108 fde_table
.entries
[j
]->initial_location
))
2111 fde_table2
->entries
= obstack_finish (&objfile
->objfile_obstack
);
2112 fde_table2
->num_entries
= i
;
2113 set_objfile_data (objfile
, dwarf2_frame_objfile_data
, fde_table2
);
2115 /* Discard the original fde_table. */
2116 xfree (fde_table
.entries
);
2120 /* Provide a prototype to silence -Wmissing-prototypes. */
2121 void _initialize_dwarf2_frame (void);
2124 _initialize_dwarf2_frame (void)
2126 dwarf2_frame_data
= gdbarch_data_register_pre_init (dwarf2_frame_init
);
2127 dwarf2_frame_objfile_data
= register_objfile_data ();