1 /* Frame unwinder for frames with DWARF Call Frame Information.
3 Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
5 Contributed by Mark Kettenis.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
25 #include "dwarf2expr.h"
26 #include "elf/dwarf2.h"
28 #include "frame-base.h"
29 #include "frame-unwind.h"
37 #include "gdb_assert.h"
38 #include "gdb_string.h"
40 #include "complaints.h"
41 #include "dwarf2-frame.h"
43 /* Call Frame Information (CFI). */
45 /* Common Information Entry (CIE). */
49 /* Offset into the .debug_frame section where this CIE was found.
50 Used to identify this CIE. */
53 /* Constant that is factored out of all advance location
55 ULONGEST code_alignment_factor
;
57 /* Constants that is factored out of all offset instructions. */
58 LONGEST data_alignment_factor
;
60 /* Return address column. */
61 ULONGEST return_address_register
;
63 /* Instruction sequence to initialize a register set. */
64 gdb_byte
*initial_instructions
;
67 /* Encoding of addresses. */
70 /* True if a 'z' augmentation existed. */
71 unsigned char saw_z_augmentation
;
73 struct dwarf2_cie
*next
;
76 /* Frame Description Entry (FDE). */
80 /* CIE for this FDE. */
81 struct dwarf2_cie
*cie
;
83 /* First location associated with this FDE. */
84 CORE_ADDR initial_location
;
86 /* Number of bytes of program instructions described by this FDE. */
87 CORE_ADDR address_range
;
89 /* Instruction sequence. */
90 gdb_byte
*instructions
;
93 /* True if this FDE is read from a .eh_frame instead of a .debug_frame
95 unsigned char eh_frame_p
;
97 struct dwarf2_fde
*next
;
100 static struct dwarf2_fde
*dwarf2_frame_find_fde (CORE_ADDR
*pc
);
103 /* Structure describing a frame state. */
105 struct dwarf2_frame_state
107 /* Each register save state can be described in terms of a CFA slot,
108 another register, or a location expression. */
109 struct dwarf2_frame_state_reg_info
111 struct dwarf2_frame_state_reg
*reg
;
114 /* Used to implement DW_CFA_remember_state. */
115 struct dwarf2_frame_state_reg_info
*prev
;
127 /* The PC described by the current frame state. */
130 /* Initial register set from the CIE.
131 Used to implement DW_CFA_restore. */
132 struct dwarf2_frame_state_reg_info initial
;
134 /* The information we care about from the CIE. */
137 ULONGEST retaddr_column
;
140 /* Store the length the expression for the CFA in the `cfa_reg' field,
141 which is unused in that case. */
142 #define cfa_exp_len cfa_reg
144 /* Assert that the register set RS is large enough to store NUM_REGS
145 columns. If necessary, enlarge the register set. */
148 dwarf2_frame_state_alloc_regs (struct dwarf2_frame_state_reg_info
*rs
,
151 size_t size
= sizeof (struct dwarf2_frame_state_reg
);
153 if (num_regs
<= rs
->num_regs
)
156 rs
->reg
= (struct dwarf2_frame_state_reg
*)
157 xrealloc (rs
->reg
, num_regs
* size
);
159 /* Initialize newly allocated registers. */
160 memset (rs
->reg
+ rs
->num_regs
, 0, (num_regs
- rs
->num_regs
) * size
);
161 rs
->num_regs
= num_regs
;
164 /* Copy the register columns in register set RS into newly allocated
165 memory and return a pointer to this newly created copy. */
167 static struct dwarf2_frame_state_reg
*
168 dwarf2_frame_state_copy_regs (struct dwarf2_frame_state_reg_info
*rs
)
170 size_t size
= rs
->num_regs
* sizeof (struct dwarf2_frame_state_reg
);
171 struct dwarf2_frame_state_reg
*reg
;
173 reg
= (struct dwarf2_frame_state_reg
*) xmalloc (size
);
174 memcpy (reg
, rs
->reg
, size
);
179 /* Release the memory allocated to register set RS. */
182 dwarf2_frame_state_free_regs (struct dwarf2_frame_state_reg_info
*rs
)
186 dwarf2_frame_state_free_regs (rs
->prev
);
193 /* Release the memory allocated to the frame state FS. */
196 dwarf2_frame_state_free (void *p
)
198 struct dwarf2_frame_state
*fs
= p
;
200 dwarf2_frame_state_free_regs (fs
->initial
.prev
);
201 dwarf2_frame_state_free_regs (fs
->regs
.prev
);
202 xfree (fs
->initial
.reg
);
203 xfree (fs
->regs
.reg
);
208 /* Helper functions for execute_stack_op. */
211 read_reg (void *baton
, int reg
)
213 struct frame_info
*next_frame
= (struct frame_info
*) baton
;
214 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
218 regnum
= DWARF2_REG_TO_REGNUM (reg
);
220 buf
= alloca (register_size (gdbarch
, regnum
));
221 frame_unwind_register (next_frame
, regnum
, buf
);
223 /* Convert the register to an integer. This returns a LONGEST
224 rather than a CORE_ADDR, but unpack_pointer does the same thing
225 under the covers, and this makes more sense for non-pointer
226 registers. Maybe read_reg and the associated interfaces should
227 deal with "struct value" instead of CORE_ADDR. */
228 return unpack_long (register_type (gdbarch
, regnum
), buf
);
232 read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
234 read_memory (addr
, buf
, len
);
238 no_get_frame_base (void *baton
, gdb_byte
**start
, size_t *length
)
240 internal_error (__FILE__
, __LINE__
,
241 _("Support for DW_OP_fbreg is unimplemented"));
245 no_get_tls_address (void *baton
, CORE_ADDR offset
)
247 internal_error (__FILE__
, __LINE__
,
248 _("Support for DW_OP_GNU_push_tls_address is unimplemented"));
252 execute_stack_op (gdb_byte
*exp
, ULONGEST len
,
253 struct frame_info
*next_frame
, CORE_ADDR initial
)
255 struct dwarf_expr_context
*ctx
;
258 ctx
= new_dwarf_expr_context ();
259 ctx
->baton
= next_frame
;
260 ctx
->read_reg
= read_reg
;
261 ctx
->read_mem
= read_mem
;
262 ctx
->get_frame_base
= no_get_frame_base
;
263 ctx
->get_tls_address
= no_get_tls_address
;
265 dwarf_expr_push (ctx
, initial
);
266 dwarf_expr_eval (ctx
, exp
, len
);
267 result
= dwarf_expr_fetch (ctx
, 0);
270 result
= read_reg (next_frame
, result
);
272 free_dwarf_expr_context (ctx
);
279 execute_cfa_program (gdb_byte
*insn_ptr
, gdb_byte
*insn_end
,
280 struct frame_info
*next_frame
,
281 struct dwarf2_frame_state
*fs
, int eh_frame_p
)
283 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
285 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
287 while (insn_ptr
< insn_end
&& fs
->pc
<= pc
)
289 gdb_byte insn
= *insn_ptr
++;
293 if ((insn
& 0xc0) == DW_CFA_advance_loc
)
294 fs
->pc
+= (insn
& 0x3f) * fs
->code_align
;
295 else if ((insn
& 0xc0) == DW_CFA_offset
)
299 reg
= dwarf2_frame_eh_frame_regnum (gdbarch
, reg
);
300 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
301 offset
= utmp
* fs
->data_align
;
302 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
303 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
304 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
306 else if ((insn
& 0xc0) == DW_CFA_restore
)
308 gdb_assert (fs
->initial
.reg
);
311 reg
= dwarf2_frame_eh_frame_regnum (gdbarch
, reg
);
312 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
313 if (reg
< fs
->initial
.num_regs
)
314 fs
->regs
.reg
[reg
] = fs
->initial
.reg
[reg
];
316 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_UNSPECIFIED
;
318 if (fs
->regs
.reg
[reg
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
319 complaint (&symfile_complaints
, _("\
320 incomplete CFI data; DW_CFA_restore unspecified\n\
321 register %s (#%d) at 0x%s"),
322 REGISTER_NAME(DWARF2_REG_TO_REGNUM(reg
)),
323 DWARF2_REG_TO_REGNUM(reg
), paddr (fs
->pc
));
330 fs
->pc
= dwarf2_read_address (insn_ptr
, insn_end
, &bytes_read
);
331 insn_ptr
+= bytes_read
;
334 case DW_CFA_advance_loc1
:
335 utmp
= extract_unsigned_integer (insn_ptr
, 1);
336 fs
->pc
+= utmp
* fs
->code_align
;
339 case DW_CFA_advance_loc2
:
340 utmp
= extract_unsigned_integer (insn_ptr
, 2);
341 fs
->pc
+= utmp
* fs
->code_align
;
344 case DW_CFA_advance_loc4
:
345 utmp
= extract_unsigned_integer (insn_ptr
, 4);
346 fs
->pc
+= utmp
* fs
->code_align
;
350 case DW_CFA_offset_extended
:
351 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
353 reg
= dwarf2_frame_eh_frame_regnum (gdbarch
, reg
);
354 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
355 offset
= utmp
* fs
->data_align
;
356 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
357 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
358 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
361 case DW_CFA_restore_extended
:
362 gdb_assert (fs
->initial
.reg
);
363 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
365 reg
= dwarf2_frame_eh_frame_regnum (gdbarch
, reg
);
366 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
367 fs
->regs
.reg
[reg
] = fs
->initial
.reg
[reg
];
370 case DW_CFA_undefined
:
371 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
373 reg
= dwarf2_frame_eh_frame_regnum (gdbarch
, reg
);
374 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
375 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_UNDEFINED
;
378 case DW_CFA_same_value
:
379 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
381 reg
= dwarf2_frame_eh_frame_regnum (gdbarch
, reg
);
382 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
383 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAME_VALUE
;
386 case DW_CFA_register
:
387 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
389 reg
= dwarf2_frame_eh_frame_regnum (gdbarch
, reg
);
390 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
392 utmp
= dwarf2_frame_eh_frame_regnum (gdbarch
, utmp
);
393 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
394 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_REG
;
395 fs
->regs
.reg
[reg
].loc
.reg
= utmp
;
398 case DW_CFA_remember_state
:
400 struct dwarf2_frame_state_reg_info
*new_rs
;
402 new_rs
= XMALLOC (struct dwarf2_frame_state_reg_info
);
404 fs
->regs
.reg
= dwarf2_frame_state_copy_regs (&fs
->regs
);
405 fs
->regs
.prev
= new_rs
;
409 case DW_CFA_restore_state
:
411 struct dwarf2_frame_state_reg_info
*old_rs
= fs
->regs
.prev
;
415 complaint (&symfile_complaints
, _("\
416 bad CFI data; mismatched DW_CFA_restore_state at 0x%s"), paddr (fs
->pc
));
420 xfree (fs
->regs
.reg
);
428 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &fs
->cfa_reg
);
429 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
430 fs
->cfa_offset
= utmp
;
431 fs
->cfa_how
= CFA_REG_OFFSET
;
434 case DW_CFA_def_cfa_register
:
435 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &fs
->cfa_reg
);
437 fs
->cfa_reg
= dwarf2_frame_eh_frame_regnum (gdbarch
,
439 fs
->cfa_how
= CFA_REG_OFFSET
;
442 case DW_CFA_def_cfa_offset
:
443 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
444 fs
->cfa_offset
= utmp
;
445 /* cfa_how deliberately not set. */
451 case DW_CFA_def_cfa_expression
:
452 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &fs
->cfa_exp_len
);
453 fs
->cfa_exp
= insn_ptr
;
454 fs
->cfa_how
= CFA_EXP
;
455 insn_ptr
+= fs
->cfa_exp_len
;
458 case DW_CFA_expression
:
459 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
461 reg
= dwarf2_frame_eh_frame_regnum (gdbarch
, reg
);
462 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
463 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
464 fs
->regs
.reg
[reg
].loc
.exp
= insn_ptr
;
465 fs
->regs
.reg
[reg
].exp_len
= utmp
;
466 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_EXP
;
470 case DW_CFA_offset_extended_sf
:
471 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
473 reg
= dwarf2_frame_eh_frame_regnum (gdbarch
, reg
);
474 insn_ptr
= read_sleb128 (insn_ptr
, insn_end
, &offset
);
475 offset
*= fs
->data_align
;
476 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
477 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
478 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
481 case DW_CFA_def_cfa_sf
:
482 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &fs
->cfa_reg
);
484 fs
->cfa_reg
= dwarf2_frame_eh_frame_regnum (gdbarch
,
486 insn_ptr
= read_sleb128 (insn_ptr
, insn_end
, &offset
);
487 fs
->cfa_offset
= offset
* fs
->data_align
;
488 fs
->cfa_how
= CFA_REG_OFFSET
;
491 case DW_CFA_def_cfa_offset_sf
:
492 insn_ptr
= read_sleb128 (insn_ptr
, insn_end
, &offset
);
493 fs
->cfa_offset
= offset
* fs
->data_align
;
494 /* cfa_how deliberately not set. */
497 case DW_CFA_GNU_window_save
:
498 /* This is SPARC-specific code, and contains hard-coded
499 constants for the register numbering scheme used by
500 GCC. Rather than having a architecture-specific
501 operation that's only ever used by a single
502 architecture, we provide the implementation here.
503 Incidentally that's what GCC does too in its
506 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
507 int size
= register_size(gdbarch
, 0);
508 dwarf2_frame_state_alloc_regs (&fs
->regs
, 32);
509 for (reg
= 8; reg
< 16; reg
++)
511 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_REG
;
512 fs
->regs
.reg
[reg
].loc
.reg
= reg
+ 16;
514 for (reg
= 16; reg
< 32; reg
++)
516 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
517 fs
->regs
.reg
[reg
].loc
.offset
= (reg
- 16) * size
;
522 case DW_CFA_GNU_args_size
:
524 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
528 internal_error (__FILE__
, __LINE__
, _("Unknown CFI encountered."));
533 /* Don't allow remember/restore between CIE and FDE programs. */
534 dwarf2_frame_state_free_regs (fs
->regs
.prev
);
535 fs
->regs
.prev
= NULL
;
539 /* Architecture-specific operations. */
541 /* Per-architecture data key. */
542 static struct gdbarch_data
*dwarf2_frame_data
;
544 struct dwarf2_frame_ops
546 /* Pre-initialize the register state REG for register REGNUM. */
547 void (*init_reg
) (struct gdbarch
*, int, struct dwarf2_frame_state_reg
*,
548 struct frame_info
*);
550 /* Check whether the frame preceding NEXT_FRAME will be a signal
552 int (*signal_frame_p
) (struct gdbarch
*, struct frame_info
*);
554 /* Convert .eh_frame register number to DWARF register number. */
555 int (*eh_frame_regnum
) (struct gdbarch
*, int);
558 /* Default architecture-specific register state initialization
562 dwarf2_frame_default_init_reg (struct gdbarch
*gdbarch
, int regnum
,
563 struct dwarf2_frame_state_reg
*reg
,
564 struct frame_info
*next_frame
)
566 /* If we have a register that acts as a program counter, mark it as
567 a destination for the return address. If we have a register that
568 serves as the stack pointer, arrange for it to be filled with the
569 call frame address (CFA). The other registers are marked as
572 We copy the return address to the program counter, since many
573 parts in GDB assume that it is possible to get the return address
574 by unwinding the program counter register. However, on ISA's
575 with a dedicated return address register, the CFI usually only
576 contains information to unwind that return address register.
578 The reason we're treating the stack pointer special here is
579 because in many cases GCC doesn't emit CFI for the stack pointer
580 and implicitly assumes that it is equal to the CFA. This makes
581 some sense since the DWARF specification (version 3, draft 8,
584 "Typically, the CFA is defined to be the value of the stack
585 pointer at the call site in the previous frame (which may be
586 different from its value on entry to the current frame)."
588 However, this isn't true for all platforms supported by GCC
589 (e.g. IBM S/390 and zSeries). Those architectures should provide
590 their own architecture-specific initialization function. */
592 if (regnum
== PC_REGNUM
)
593 reg
->how
= DWARF2_FRAME_REG_RA
;
594 else if (regnum
== SP_REGNUM
)
595 reg
->how
= DWARF2_FRAME_REG_CFA
;
598 /* Return a default for the architecture-specific operations. */
601 dwarf2_frame_init (struct obstack
*obstack
)
603 struct dwarf2_frame_ops
*ops
;
605 ops
= OBSTACK_ZALLOC (obstack
, struct dwarf2_frame_ops
);
606 ops
->init_reg
= dwarf2_frame_default_init_reg
;
610 /* Set the architecture-specific register state initialization
611 function for GDBARCH to INIT_REG. */
614 dwarf2_frame_set_init_reg (struct gdbarch
*gdbarch
,
615 void (*init_reg
) (struct gdbarch
*, int,
616 struct dwarf2_frame_state_reg
*,
617 struct frame_info
*))
619 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
621 ops
->init_reg
= init_reg
;
624 /* Pre-initialize the register state REG for register REGNUM. */
627 dwarf2_frame_init_reg (struct gdbarch
*gdbarch
, int regnum
,
628 struct dwarf2_frame_state_reg
*reg
,
629 struct frame_info
*next_frame
)
631 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
633 ops
->init_reg (gdbarch
, regnum
, reg
, next_frame
);
636 /* Set the architecture-specific signal trampoline recognition
637 function for GDBARCH to SIGNAL_FRAME_P. */
640 dwarf2_frame_set_signal_frame_p (struct gdbarch
*gdbarch
,
641 int (*signal_frame_p
) (struct gdbarch
*,
642 struct frame_info
*))
644 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
646 ops
->signal_frame_p
= signal_frame_p
;
649 /* Query the architecture-specific signal frame recognizer for
653 dwarf2_frame_signal_frame_p (struct gdbarch
*gdbarch
,
654 struct frame_info
*next_frame
)
656 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
658 if (ops
->signal_frame_p
== NULL
)
660 return ops
->signal_frame_p (gdbarch
, next_frame
);
663 /* Set the architecture-specific mapping of .eh_frame register numbers to
664 DWARF register numbers. */
667 dwarf2_frame_set_eh_frame_regnum (struct gdbarch
*gdbarch
,
668 int (*eh_frame_regnum
) (struct gdbarch
*,
671 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
673 ops
->eh_frame_regnum
= eh_frame_regnum
;
676 /* Translate a .eh_frame register to DWARF register. */
679 dwarf2_frame_eh_frame_regnum (struct gdbarch
*gdbarch
, int regnum
)
681 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
683 if (ops
->eh_frame_regnum
== NULL
)
685 return ops
->eh_frame_regnum (gdbarch
, regnum
);
689 struct dwarf2_frame_cache
691 /* DWARF Call Frame Address. */
694 /* Set if the return address column was marked as undefined. */
695 int undefined_retaddr
;
697 /* Saved registers, indexed by GDB register number, not by DWARF
699 struct dwarf2_frame_state_reg
*reg
;
701 /* Return address register. */
702 struct dwarf2_frame_state_reg retaddr_reg
;
705 static struct dwarf2_frame_cache
*
706 dwarf2_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
708 struct cleanup
*old_chain
;
709 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
710 const int num_regs
= NUM_REGS
+ NUM_PSEUDO_REGS
;
711 struct dwarf2_frame_cache
*cache
;
712 struct dwarf2_frame_state
*fs
;
713 struct dwarf2_fde
*fde
;
718 /* Allocate a new cache. */
719 cache
= FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache
);
720 cache
->reg
= FRAME_OBSTACK_CALLOC (num_regs
, struct dwarf2_frame_state_reg
);
722 /* Allocate and initialize the frame state. */
723 fs
= XMALLOC (struct dwarf2_frame_state
);
724 memset (fs
, 0, sizeof (struct dwarf2_frame_state
));
725 old_chain
= make_cleanup (dwarf2_frame_state_free
, fs
);
729 Note that if NEXT_FRAME is never supposed to return (i.e. a call
730 to abort), the compiler might optimize away the instruction at
731 NEXT_FRAME's return address. As a result the return address will
732 point at some random instruction, and the CFI for that
733 instruction is probably worthless to us. GCC's unwinder solves
734 this problem by substracting 1 from the return address to get an
735 address in the middle of a presumed call instruction (or the
736 instruction in the associated delay slot). This should only be
737 done for "normal" frames and not for resume-type frames (signal
738 handlers, sentinel frames, dummy frames). The function
739 frame_unwind_address_in_block does just this. It's not clear how
740 reliable the method is though; there is the potential for the
741 register state pre-call being different to that on return. */
742 fs
->pc
= frame_unwind_address_in_block (next_frame
);
744 /* Find the correct FDE. */
745 fde
= dwarf2_frame_find_fde (&fs
->pc
);
746 gdb_assert (fde
!= NULL
);
748 /* Extract any interesting information from the CIE. */
749 fs
->data_align
= fde
->cie
->data_alignment_factor
;
750 fs
->code_align
= fde
->cie
->code_alignment_factor
;
751 fs
->retaddr_column
= fde
->cie
->return_address_register
;
753 /* First decode all the insns in the CIE. */
754 execute_cfa_program (fde
->cie
->initial_instructions
,
755 fde
->cie
->end
, next_frame
, fs
, fde
->eh_frame_p
);
757 /* Save the initialized register set. */
758 fs
->initial
= fs
->regs
;
759 fs
->initial
.reg
= dwarf2_frame_state_copy_regs (&fs
->regs
);
761 /* Then decode the insns in the FDE up to our target PC. */
762 execute_cfa_program (fde
->instructions
, fde
->end
, next_frame
, fs
,
765 /* Caclulate the CFA. */
769 cache
->cfa
= read_reg (next_frame
, fs
->cfa_reg
);
770 cache
->cfa
+= fs
->cfa_offset
;
775 execute_stack_op (fs
->cfa_exp
, fs
->cfa_exp_len
, next_frame
, 0);
779 internal_error (__FILE__
, __LINE__
, _("Unknown CFA rule."));
782 /* Initialize the register state. */
786 for (regnum
= 0; regnum
< num_regs
; regnum
++)
787 dwarf2_frame_init_reg (gdbarch
, regnum
, &cache
->reg
[regnum
], next_frame
);
790 /* Go through the DWARF2 CFI generated table and save its register
791 location information in the cache. Note that we don't skip the
792 return address column; it's perfectly all right for it to
793 correspond to a real register. If it doesn't correspond to a
794 real register, or if we shouldn't treat it as such,
795 DWARF2_REG_TO_REGNUM should be defined to return a number outside
796 the range [0, NUM_REGS). */
798 int column
; /* CFI speak for "register number". */
800 for (column
= 0; column
< fs
->regs
.num_regs
; column
++)
802 /* Use the GDB register number as the destination index. */
803 int regnum
= DWARF2_REG_TO_REGNUM (column
);
805 /* If there's no corresponding GDB register, ignore it. */
806 if (regnum
< 0 || regnum
>= num_regs
)
809 /* NOTE: cagney/2003-09-05: CFI should specify the disposition
810 of all debug info registers. If it doesn't, complain (but
811 not too loudly). It turns out that GCC assumes that an
812 unspecified register implies "same value" when CFI (draft
813 7) specifies nothing at all. Such a register could equally
814 be interpreted as "undefined". Also note that this check
815 isn't sufficient; it only checks that all registers in the
816 range [0 .. max column] are specified, and won't detect
817 problems when a debug info register falls outside of the
818 table. We need a way of iterating through all the valid
819 DWARF2 register numbers. */
820 if (fs
->regs
.reg
[column
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
822 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
823 complaint (&symfile_complaints
, _("\
824 incomplete CFI data; unspecified registers (e.g., %s) at 0x%s"),
825 gdbarch_register_name (gdbarch
, regnum
),
829 cache
->reg
[regnum
] = fs
->regs
.reg
[column
];
833 /* Eliminate any DWARF2_FRAME_REG_RA rules, and save the information
834 we need for evaluating DWARF2_FRAME_REG_RA_OFFSET rules. */
838 for (regnum
= 0; regnum
< num_regs
; regnum
++)
840 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
841 || cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA_OFFSET
)
843 struct dwarf2_frame_state_reg
*retaddr_reg
=
844 &fs
->regs
.reg
[fs
->retaddr_column
];
846 /* It seems rather bizarre to specify an "empty" column as
847 the return adress column. However, this is exactly
848 what GCC does on some targets. It turns out that GCC
849 assumes that the return address can be found in the
850 register corresponding to the return address column.
851 Incidentally, that's how we should treat a return
852 address column specifying "same value" too. */
853 if (fs
->retaddr_column
< fs
->regs
.num_regs
854 && retaddr_reg
->how
!= DWARF2_FRAME_REG_UNSPECIFIED
855 && retaddr_reg
->how
!= DWARF2_FRAME_REG_SAME_VALUE
)
857 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
)
858 cache
->reg
[regnum
] = *retaddr_reg
;
860 cache
->retaddr_reg
= *retaddr_reg
;
864 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
)
866 cache
->reg
[regnum
].loc
.reg
= fs
->retaddr_column
;
867 cache
->reg
[regnum
].how
= DWARF2_FRAME_REG_SAVED_REG
;
871 cache
->retaddr_reg
.loc
.reg
= fs
->retaddr_column
;
872 cache
->retaddr_reg
.how
= DWARF2_FRAME_REG_SAVED_REG
;
879 if (fs
->retaddr_column
< fs
->regs
.num_regs
880 && fs
->regs
.reg
[fs
->retaddr_column
].how
== DWARF2_FRAME_REG_UNDEFINED
)
881 cache
->undefined_retaddr
= 1;
883 do_cleanups (old_chain
);
890 dwarf2_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
891 struct frame_id
*this_id
)
893 struct dwarf2_frame_cache
*cache
=
894 dwarf2_frame_cache (next_frame
, this_cache
);
896 if (cache
->undefined_retaddr
)
899 (*this_id
) = frame_id_build (cache
->cfa
, frame_func_unwind (next_frame
));
903 dwarf2_frame_prev_register (struct frame_info
*next_frame
, void **this_cache
,
904 int regnum
, int *optimizedp
,
905 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
906 int *realnump
, gdb_byte
*valuep
)
908 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
909 struct dwarf2_frame_cache
*cache
=
910 dwarf2_frame_cache (next_frame
, this_cache
);
912 switch (cache
->reg
[regnum
].how
)
914 case DWARF2_FRAME_REG_UNDEFINED
:
915 /* If CFI explicitly specified that the value isn't defined,
916 mark it as optimized away; the value isn't available. */
923 /* In some cases, for example %eflags on the i386, we have
924 to provide a sane value, even though this register wasn't
925 saved. Assume we can get it from NEXT_FRAME. */
926 frame_unwind_register (next_frame
, regnum
, valuep
);
930 case DWARF2_FRAME_REG_SAVED_OFFSET
:
932 *lvalp
= lval_memory
;
933 *addrp
= cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
;
937 /* Read the value in from memory. */
938 read_memory (*addrp
, valuep
, register_size (gdbarch
, regnum
));
942 case DWARF2_FRAME_REG_SAVED_REG
:
944 *lvalp
= lval_register
;
946 *realnump
= DWARF2_REG_TO_REGNUM (cache
->reg
[regnum
].loc
.reg
);
948 frame_unwind_register (next_frame
, (*realnump
), valuep
);
951 case DWARF2_FRAME_REG_SAVED_EXP
:
953 *lvalp
= lval_memory
;
954 *addrp
= execute_stack_op (cache
->reg
[regnum
].loc
.exp
,
955 cache
->reg
[regnum
].exp_len
,
956 next_frame
, cache
->cfa
);
960 /* Read the value in from memory. */
961 read_memory (*addrp
, valuep
, register_size (gdbarch
, regnum
));
965 case DWARF2_FRAME_REG_UNSPECIFIED
:
966 /* GCC, in its infinite wisdom decided to not provide unwind
967 information for registers that are "same value". Since
968 DWARF2 (3 draft 7) doesn't define such behavior, said
969 registers are actually undefined (which is different to CFI
970 "undefined"). Code above issues a complaint about this.
971 Here just fudge the books, assume GCC, and that the value is
972 more inner on the stack. */
974 *lvalp
= lval_register
;
978 frame_unwind_register (next_frame
, (*realnump
), valuep
);
981 case DWARF2_FRAME_REG_SAME_VALUE
:
983 *lvalp
= lval_register
;
987 frame_unwind_register (next_frame
, (*realnump
), valuep
);
990 case DWARF2_FRAME_REG_CFA
:
997 /* Store the value. */
998 store_typed_address (valuep
, builtin_type_void_data_ptr
, cache
->cfa
);
1002 case DWARF2_FRAME_REG_CFA_OFFSET
:
1009 /* Store the value. */
1010 store_typed_address (valuep
, builtin_type_void_data_ptr
,
1011 cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
);
1015 case DWARF2_FRAME_REG_RA_OFFSET
:
1022 CORE_ADDR pc
= cache
->reg
[regnum
].loc
.offset
;
1024 regnum
= DWARF2_REG_TO_REGNUM (cache
->retaddr_reg
.loc
.reg
);
1025 pc
+= frame_unwind_register_unsigned (next_frame
, regnum
);
1026 store_typed_address (valuep
, builtin_type_void_func_ptr
, pc
);
1031 internal_error (__FILE__
, __LINE__
, _("Unknown register rule."));
1035 static const struct frame_unwind dwarf2_frame_unwind
=
1038 dwarf2_frame_this_id
,
1039 dwarf2_frame_prev_register
1042 static const struct frame_unwind dwarf2_signal_frame_unwind
=
1045 dwarf2_frame_this_id
,
1046 dwarf2_frame_prev_register
1049 const struct frame_unwind
*
1050 dwarf2_frame_sniffer (struct frame_info
*next_frame
)
1052 /* Grab an address that is guarenteed to reside somewhere within the
1053 function. frame_pc_unwind(), for a no-return next function, can
1054 end up returning something past the end of this function's body. */
1055 CORE_ADDR block_addr
= frame_unwind_address_in_block (next_frame
);
1056 if (!dwarf2_frame_find_fde (&block_addr
))
1059 /* On some targets, signal trampolines may have unwind information.
1060 We need to recognize them so that we set the frame type
1063 if (dwarf2_frame_signal_frame_p (get_frame_arch (next_frame
),
1065 return &dwarf2_signal_frame_unwind
;
1067 return &dwarf2_frame_unwind
;
1071 /* There is no explicitly defined relationship between the CFA and the
1072 location of frame's local variables and arguments/parameters.
1073 Therefore, frame base methods on this page should probably only be
1074 used as a last resort, just to avoid printing total garbage as a
1075 response to the "info frame" command. */
1078 dwarf2_frame_base_address (struct frame_info
*next_frame
, void **this_cache
)
1080 struct dwarf2_frame_cache
*cache
=
1081 dwarf2_frame_cache (next_frame
, this_cache
);
1086 static const struct frame_base dwarf2_frame_base
=
1088 &dwarf2_frame_unwind
,
1089 dwarf2_frame_base_address
,
1090 dwarf2_frame_base_address
,
1091 dwarf2_frame_base_address
1094 const struct frame_base
*
1095 dwarf2_frame_base_sniffer (struct frame_info
*next_frame
)
1097 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
1098 if (dwarf2_frame_find_fde (&pc
))
1099 return &dwarf2_frame_base
;
1104 /* A minimal decoding of DWARF2 compilation units. We only decode
1105 what's needed to get to the call frame information. */
1109 /* Keep the bfd convenient. */
1112 struct objfile
*objfile
;
1114 /* Linked list of CIEs for this object. */
1115 struct dwarf2_cie
*cie
;
1117 /* Pointer to the .debug_frame section loaded into memory. */
1118 gdb_byte
*dwarf_frame_buffer
;
1120 /* Length of the loaded .debug_frame section. */
1121 unsigned long dwarf_frame_size
;
1123 /* Pointer to the .debug_frame section. */
1124 asection
*dwarf_frame_section
;
1126 /* Base for DW_EH_PE_datarel encodings. */
1129 /* Base for DW_EH_PE_textrel encodings. */
1133 const struct objfile_data
*dwarf2_frame_objfile_data
;
1136 read_1_byte (bfd
*abfd
, gdb_byte
*buf
)
1138 return bfd_get_8 (abfd
, buf
);
1142 read_4_bytes (bfd
*abfd
, gdb_byte
*buf
)
1144 return bfd_get_32 (abfd
, buf
);
1148 read_8_bytes (bfd
*abfd
, gdb_byte
*buf
)
1150 return bfd_get_64 (abfd
, buf
);
1154 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1157 unsigned int num_read
;
1167 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
1170 result
|= ((byte
& 0x7f) << shift
);
1173 while (byte
& 0x80);
1175 *bytes_read_ptr
= num_read
;
1181 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1185 unsigned int num_read
;
1194 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
1197 result
|= ((byte
& 0x7f) << shift
);
1200 while (byte
& 0x80);
1202 if (shift
< 8 * sizeof (result
) && (byte
& 0x40))
1203 result
|= -(((LONGEST
)1) << shift
);
1205 *bytes_read_ptr
= num_read
;
1211 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1215 result
= bfd_get_32 (abfd
, buf
);
1216 if (result
== 0xffffffff)
1218 result
= bfd_get_64 (abfd
, buf
+ 4);
1219 *bytes_read_ptr
= 12;
1222 *bytes_read_ptr
= 4;
1228 /* Pointer encoding helper functions. */
1230 /* GCC supports exception handling based on DWARF2 CFI. However, for
1231 technical reasons, it encodes addresses in its FDE's in a different
1232 way. Several "pointer encodings" are supported. The encoding
1233 that's used for a particular FDE is determined by the 'R'
1234 augmentation in the associated CIE. The argument of this
1235 augmentation is a single byte.
1237 The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a
1238 LEB128. This is encoded in bits 0, 1 and 2. Bit 3 encodes whether
1239 the address is signed or unsigned. Bits 4, 5 and 6 encode how the
1240 address should be interpreted (absolute, relative to the current
1241 position in the FDE, ...). Bit 7, indicates that the address
1242 should be dereferenced. */
1245 encoding_for_size (unsigned int size
)
1250 return DW_EH_PE_udata2
;
1252 return DW_EH_PE_udata4
;
1254 return DW_EH_PE_udata8
;
1256 internal_error (__FILE__
, __LINE__
, _("Unsupported address size"));
1261 size_of_encoded_value (gdb_byte encoding
)
1263 if (encoding
== DW_EH_PE_omit
)
1266 switch (encoding
& 0x07)
1268 case DW_EH_PE_absptr
:
1269 return TYPE_LENGTH (builtin_type_void_data_ptr
);
1270 case DW_EH_PE_udata2
:
1272 case DW_EH_PE_udata4
:
1274 case DW_EH_PE_udata8
:
1277 internal_error (__FILE__
, __LINE__
, _("Invalid or unsupported encoding"));
1282 read_encoded_value (struct comp_unit
*unit
, gdb_byte encoding
,
1283 gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1285 int ptr_len
= size_of_encoded_value (DW_EH_PE_absptr
);
1289 /* GCC currently doesn't generate DW_EH_PE_indirect encodings for
1291 if (encoding
& DW_EH_PE_indirect
)
1292 internal_error (__FILE__
, __LINE__
,
1293 _("Unsupported encoding: DW_EH_PE_indirect"));
1295 *bytes_read_ptr
= 0;
1297 switch (encoding
& 0x70)
1299 case DW_EH_PE_absptr
:
1302 case DW_EH_PE_pcrel
:
1303 base
= bfd_get_section_vma (unit
->bfd
, unit
->dwarf_frame_section
);
1304 base
+= (buf
- unit
->dwarf_frame_buffer
);
1306 case DW_EH_PE_datarel
:
1309 case DW_EH_PE_textrel
:
1312 case DW_EH_PE_funcrel
:
1313 /* FIXME: kettenis/20040501: For now just pretend
1314 DW_EH_PE_funcrel is equivalent to DW_EH_PE_absptr. For
1315 reading the initial location of an FDE it should be treated
1316 as such, and currently that's the only place where this code
1320 case DW_EH_PE_aligned
:
1322 offset
= buf
- unit
->dwarf_frame_buffer
;
1323 if ((offset
% ptr_len
) != 0)
1325 *bytes_read_ptr
= ptr_len
- (offset
% ptr_len
);
1326 buf
+= *bytes_read_ptr
;
1330 internal_error (__FILE__
, __LINE__
, _("Invalid or unsupported encoding"));
1333 if ((encoding
& 0x07) == 0x00)
1334 encoding
|= encoding_for_size (ptr_len
);
1336 switch (encoding
& 0x0f)
1338 case DW_EH_PE_uleb128
:
1341 gdb_byte
*end_buf
= buf
+ (sizeof (value
) + 1) * 8 / 7;
1342 *bytes_read_ptr
+= read_uleb128 (buf
, end_buf
, &value
) - buf
;
1343 return base
+ value
;
1345 case DW_EH_PE_udata2
:
1346 *bytes_read_ptr
+= 2;
1347 return (base
+ bfd_get_16 (unit
->abfd
, (bfd_byte
*) buf
));
1348 case DW_EH_PE_udata4
:
1349 *bytes_read_ptr
+= 4;
1350 return (base
+ bfd_get_32 (unit
->abfd
, (bfd_byte
*) buf
));
1351 case DW_EH_PE_udata8
:
1352 *bytes_read_ptr
+= 8;
1353 return (base
+ bfd_get_64 (unit
->abfd
, (bfd_byte
*) buf
));
1354 case DW_EH_PE_sleb128
:
1357 gdb_byte
*end_buf
= buf
+ (sizeof (value
) + 1) * 8 / 7;
1358 *bytes_read_ptr
+= read_sleb128 (buf
, end_buf
, &value
) - buf
;
1359 return base
+ value
;
1361 case DW_EH_PE_sdata2
:
1362 *bytes_read_ptr
+= 2;
1363 return (base
+ bfd_get_signed_16 (unit
->abfd
, (bfd_byte
*) buf
));
1364 case DW_EH_PE_sdata4
:
1365 *bytes_read_ptr
+= 4;
1366 return (base
+ bfd_get_signed_32 (unit
->abfd
, (bfd_byte
*) buf
));
1367 case DW_EH_PE_sdata8
:
1368 *bytes_read_ptr
+= 8;
1369 return (base
+ bfd_get_signed_64 (unit
->abfd
, (bfd_byte
*) buf
));
1371 internal_error (__FILE__
, __LINE__
, _("Invalid or unsupported encoding"));
1376 /* GCC uses a single CIE for all FDEs in a .debug_frame section.
1377 That's why we use a simple linked list here. */
1379 static struct dwarf2_cie
*
1380 find_cie (struct comp_unit
*unit
, ULONGEST cie_pointer
)
1382 struct dwarf2_cie
*cie
= unit
->cie
;
1386 if (cie
->cie_pointer
== cie_pointer
)
1396 add_cie (struct comp_unit
*unit
, struct dwarf2_cie
*cie
)
1398 cie
->next
= unit
->cie
;
1402 /* Find the FDE for *PC. Return a pointer to the FDE, and store the
1403 inital location associated with it into *PC. */
1405 static struct dwarf2_fde
*
1406 dwarf2_frame_find_fde (CORE_ADDR
*pc
)
1408 struct objfile
*objfile
;
1410 ALL_OBJFILES (objfile
)
1412 struct dwarf2_fde
*fde
;
1415 fde
= objfile_data (objfile
, dwarf2_frame_objfile_data
);
1419 gdb_assert (objfile
->section_offsets
);
1420 offset
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1424 if (*pc
>= fde
->initial_location
+ offset
1425 && *pc
< fde
->initial_location
+ offset
+ fde
->address_range
)
1427 *pc
= fde
->initial_location
+ offset
;
1439 add_fde (struct comp_unit
*unit
, struct dwarf2_fde
*fde
)
1441 fde
->next
= objfile_data (unit
->objfile
, dwarf2_frame_objfile_data
);
1442 set_objfile_data (unit
->objfile
, dwarf2_frame_objfile_data
, fde
);
1445 #ifdef CC_HAS_LONG_LONG
1446 #define DW64_CIE_ID 0xffffffffffffffffULL
1448 #define DW64_CIE_ID ~0
1451 static gdb_byte
*decode_frame_entry (struct comp_unit
*unit
, gdb_byte
*start
,
1454 /* Decode the next CIE or FDE. Return NULL if invalid input, otherwise
1455 the next byte to be processed. */
1457 decode_frame_entry_1 (struct comp_unit
*unit
, gdb_byte
*start
, int eh_frame_p
)
1459 gdb_byte
*buf
, *end
;
1461 unsigned int bytes_read
;
1464 ULONGEST cie_pointer
;
1467 length
= read_initial_length (unit
->abfd
, buf
, &bytes_read
);
1471 /* Are we still within the section? */
1472 if (end
> unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
)
1478 /* Distinguish between 32 and 64-bit encoded frame info. */
1479 dwarf64_p
= (bytes_read
== 12);
1481 /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs. */
1485 cie_id
= DW64_CIE_ID
;
1491 cie_pointer
= read_8_bytes (unit
->abfd
, buf
);
1496 cie_pointer
= read_4_bytes (unit
->abfd
, buf
);
1500 if (cie_pointer
== cie_id
)
1502 /* This is a CIE. */
1503 struct dwarf2_cie
*cie
;
1505 unsigned int cie_version
;
1507 /* Record the offset into the .debug_frame section of this CIE. */
1508 cie_pointer
= start
- unit
->dwarf_frame_buffer
;
1510 /* Check whether we've already read it. */
1511 if (find_cie (unit
, cie_pointer
))
1514 cie
= (struct dwarf2_cie
*)
1515 obstack_alloc (&unit
->objfile
->objfile_obstack
,
1516 sizeof (struct dwarf2_cie
));
1517 cie
->initial_instructions
= NULL
;
1518 cie
->cie_pointer
= cie_pointer
;
1520 /* The encoding for FDE's in a normal .debug_frame section
1521 depends on the target address size. */
1522 cie
->encoding
= DW_EH_PE_absptr
;
1524 /* Check version number. */
1525 cie_version
= read_1_byte (unit
->abfd
, buf
);
1526 if (cie_version
!= 1 && cie_version
!= 3)
1530 /* Interpret the interesting bits of the augmentation. */
1531 augmentation
= (char *) buf
;
1532 buf
+= (strlen (augmentation
) + 1);
1534 /* The GCC 2.x "eh" augmentation has a pointer immediately
1535 following the augmentation string, so it must be handled
1537 if (augmentation
[0] == 'e' && augmentation
[1] == 'h')
1540 buf
+= TYPE_LENGTH (builtin_type_void_data_ptr
);
1544 cie
->code_alignment_factor
=
1545 read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1548 cie
->data_alignment_factor
=
1549 read_signed_leb128 (unit
->abfd
, buf
, &bytes_read
);
1552 if (cie_version
== 1)
1554 cie
->return_address_register
= read_1_byte (unit
->abfd
, buf
);
1558 cie
->return_address_register
= read_unsigned_leb128 (unit
->abfd
, buf
,
1561 cie
->return_address_register
1562 = dwarf2_frame_eh_frame_regnum (current_gdbarch
,
1563 cie
->return_address_register
);
1567 cie
->saw_z_augmentation
= (*augmentation
== 'z');
1568 if (cie
->saw_z_augmentation
)
1572 length
= read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1576 cie
->initial_instructions
= buf
+ length
;
1580 while (*augmentation
)
1582 /* "L" indicates a byte showing how the LSDA pointer is encoded. */
1583 if (*augmentation
== 'L')
1590 /* "R" indicates a byte indicating how FDE addresses are encoded. */
1591 else if (*augmentation
== 'R')
1593 cie
->encoding
= *buf
++;
1597 /* "P" indicates a personality routine in the CIE augmentation. */
1598 else if (*augmentation
== 'P')
1600 /* Skip. Avoid indirection since we throw away the result. */
1601 gdb_byte encoding
= (*buf
++) & ~DW_EH_PE_indirect
;
1602 read_encoded_value (unit
, encoding
, buf
, &bytes_read
);
1607 /* Otherwise we have an unknown augmentation.
1608 Bail out unless we saw a 'z' prefix. */
1611 if (cie
->initial_instructions
== NULL
)
1614 /* Skip unknown augmentations. */
1615 buf
= cie
->initial_instructions
;
1620 cie
->initial_instructions
= buf
;
1623 add_cie (unit
, cie
);
1627 /* This is a FDE. */
1628 struct dwarf2_fde
*fde
;
1630 /* In an .eh_frame section, the CIE pointer is the delta between the
1631 address within the FDE where the CIE pointer is stored and the
1632 address of the CIE. Convert it to an offset into the .eh_frame
1636 cie_pointer
= buf
- unit
->dwarf_frame_buffer
- cie_pointer
;
1637 cie_pointer
-= (dwarf64_p
? 8 : 4);
1640 /* In either case, validate the result is still within the section. */
1641 if (cie_pointer
>= unit
->dwarf_frame_size
)
1644 fde
= (struct dwarf2_fde
*)
1645 obstack_alloc (&unit
->objfile
->objfile_obstack
,
1646 sizeof (struct dwarf2_fde
));
1647 fde
->cie
= find_cie (unit
, cie_pointer
);
1648 if (fde
->cie
== NULL
)
1650 decode_frame_entry (unit
, unit
->dwarf_frame_buffer
+ cie_pointer
,
1652 fde
->cie
= find_cie (unit
, cie_pointer
);
1655 gdb_assert (fde
->cie
!= NULL
);
1657 fde
->initial_location
=
1658 read_encoded_value (unit
, fde
->cie
->encoding
, buf
, &bytes_read
);
1661 fde
->address_range
=
1662 read_encoded_value (unit
, fde
->cie
->encoding
& 0x0f, buf
, &bytes_read
);
1665 /* A 'z' augmentation in the CIE implies the presence of an
1666 augmentation field in the FDE as well. The only thing known
1667 to be in here at present is the LSDA entry for EH. So we
1668 can skip the whole thing. */
1669 if (fde
->cie
->saw_z_augmentation
)
1673 length
= read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1674 buf
+= bytes_read
+ length
;
1679 fde
->instructions
= buf
;
1682 fde
->eh_frame_p
= eh_frame_p
;
1684 add_fde (unit
, fde
);
1690 /* Read a CIE or FDE in BUF and decode it. */
1692 decode_frame_entry (struct comp_unit
*unit
, gdb_byte
*start
, int eh_frame_p
)
1694 enum { NONE
, ALIGN4
, ALIGN8
, FAIL
} workaround
= NONE
;
1697 ptrdiff_t start_offset
;
1701 ret
= decode_frame_entry_1 (unit
, start
, eh_frame_p
);
1705 /* We have corrupt input data of some form. */
1707 /* ??? Try, weakly, to work around compiler/assembler/linker bugs
1708 and mismatches wrt padding and alignment of debug sections. */
1709 /* Note that there is no requirement in the standard for any
1710 alignment at all in the frame unwind sections. Testing for
1711 alignment before trying to interpret data would be incorrect.
1713 However, GCC traditionally arranged for frame sections to be
1714 sized such that the FDE length and CIE fields happen to be
1715 aligned (in theory, for performance). This, unfortunately,
1716 was done with .align directives, which had the side effect of
1717 forcing the section to be aligned by the linker.
1719 This becomes a problem when you have some other producer that
1720 creates frame sections that are not as strictly aligned. That
1721 produces a hole in the frame info that gets filled by the
1724 The GCC behaviour is arguably a bug, but it's effectively now
1725 part of the ABI, so we're now stuck with it, at least at the
1726 object file level. A smart linker may decide, in the process
1727 of compressing duplicate CIE information, that it can rewrite
1728 the entire output section without this extra padding. */
1730 start_offset
= start
- unit
->dwarf_frame_buffer
;
1731 if (workaround
< ALIGN4
&& (start_offset
& 3) != 0)
1733 start
+= 4 - (start_offset
& 3);
1734 workaround
= ALIGN4
;
1737 if (workaround
< ALIGN8
&& (start_offset
& 7) != 0)
1739 start
+= 8 - (start_offset
& 7);
1740 workaround
= ALIGN8
;
1744 /* Nothing left to try. Arrange to return as if we've consumed
1745 the entire input section. Hopefully we'll get valid info from
1746 the other of .debug_frame/.eh_frame. */
1748 ret
= unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
;
1758 complaint (&symfile_complaints
,
1759 _("Corrupt data in %s:%s; align 4 workaround apparently succeeded"),
1760 unit
->dwarf_frame_section
->owner
->filename
,
1761 unit
->dwarf_frame_section
->name
);
1765 complaint (&symfile_complaints
,
1766 _("Corrupt data in %s:%s; align 8 workaround apparently succeeded"),
1767 unit
->dwarf_frame_section
->owner
->filename
,
1768 unit
->dwarf_frame_section
->name
);
1772 complaint (&symfile_complaints
,
1773 _("Corrupt data in %s:%s"),
1774 unit
->dwarf_frame_section
->owner
->filename
,
1775 unit
->dwarf_frame_section
->name
);
1783 /* FIXME: kettenis/20030504: This still needs to be integrated with
1784 dwarf2read.c in a better way. */
1786 /* Imported from dwarf2read.c. */
1787 extern asection
*dwarf_frame_section
;
1788 extern asection
*dwarf_eh_frame_section
;
1790 /* Imported from dwarf2read.c. */
1791 extern gdb_byte
*dwarf2_read_section (struct objfile
*objfile
, asection
*sectp
);
1794 dwarf2_build_frame_info (struct objfile
*objfile
)
1796 struct comp_unit unit
;
1797 gdb_byte
*frame_ptr
;
1799 /* Build a minimal decoding of the DWARF2 compilation unit. */
1800 unit
.abfd
= objfile
->obfd
;
1801 unit
.objfile
= objfile
;
1805 /* First add the information from the .eh_frame section. That way,
1806 the FDEs from that section are searched last. */
1807 if (dwarf_eh_frame_section
)
1809 asection
*got
, *txt
;
1812 unit
.dwarf_frame_buffer
= dwarf2_read_section (objfile
,
1813 dwarf_eh_frame_section
);
1815 unit
.dwarf_frame_size
= bfd_get_section_size (dwarf_eh_frame_section
);
1816 unit
.dwarf_frame_section
= dwarf_eh_frame_section
;
1818 /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
1819 that is used for the i386/amd64 target, which currently is
1820 the only target in GCC that supports/uses the
1821 DW_EH_PE_datarel encoding. */
1822 got
= bfd_get_section_by_name (unit
.abfd
, ".got");
1824 unit
.dbase
= got
->vma
;
1826 /* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64
1828 txt
= bfd_get_section_by_name (unit
.abfd
, ".text");
1830 unit
.tbase
= txt
->vma
;
1832 frame_ptr
= unit
.dwarf_frame_buffer
;
1833 while (frame_ptr
< unit
.dwarf_frame_buffer
+ unit
.dwarf_frame_size
)
1834 frame_ptr
= decode_frame_entry (&unit
, frame_ptr
, 1);
1837 if (dwarf_frame_section
)
1840 unit
.dwarf_frame_buffer
= dwarf2_read_section (objfile
,
1841 dwarf_frame_section
);
1842 unit
.dwarf_frame_size
= bfd_get_section_size (dwarf_frame_section
);
1843 unit
.dwarf_frame_section
= dwarf_frame_section
;
1845 frame_ptr
= unit
.dwarf_frame_buffer
;
1846 while (frame_ptr
< unit
.dwarf_frame_buffer
+ unit
.dwarf_frame_size
)
1847 frame_ptr
= decode_frame_entry (&unit
, frame_ptr
, 0);
1851 /* Provide a prototype to silence -Wmissing-prototypes. */
1852 void _initialize_dwarf2_frame (void);
1855 _initialize_dwarf2_frame (void)
1857 dwarf2_frame_data
= gdbarch_data_register_pre_init (dwarf2_frame_init
);
1858 dwarf2_frame_objfile_data
= register_objfile_data ();