1 /* Frame unwinder for frames with DWARF Call Frame Information.
3 Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
6 Contributed by Mark Kettenis.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "dwarf2expr.h"
27 #include "frame-base.h"
28 #include "frame-unwind.h"
36 #include "gdb_assert.h"
37 #include "gdb_string.h"
39 #include "complaints.h"
40 #include "dwarf2-frame.h"
44 /* Call Frame Information (CFI). */
46 /* Common Information Entry (CIE). */
50 /* Computation Unit for this CIE. */
51 struct comp_unit
*unit
;
53 /* Offset into the .debug_frame section where this CIE was found.
54 Used to identify this CIE. */
57 /* Constant that is factored out of all advance location
59 ULONGEST code_alignment_factor
;
61 /* Constants that is factored out of all offset instructions. */
62 LONGEST data_alignment_factor
;
64 /* Return address column. */
65 ULONGEST return_address_register
;
67 /* Instruction sequence to initialize a register set. */
68 gdb_byte
*initial_instructions
;
71 /* Saved augmentation, in case it's needed later. */
74 /* Encoding of addresses. */
77 /* Target address size in bytes. */
80 /* True if a 'z' augmentation existed. */
81 unsigned char saw_z_augmentation
;
83 /* True if an 'S' augmentation existed. */
84 unsigned char signal_frame
;
86 /* The version recorded in the CIE. */
87 unsigned char version
;
89 /* The segment size. */
90 unsigned char segment_size
;
93 struct dwarf2_cie_table
96 struct dwarf2_cie
**entries
;
99 /* Frame Description Entry (FDE). */
103 /* CIE for this FDE. */
104 struct dwarf2_cie
*cie
;
106 /* First location associated with this FDE. */
107 CORE_ADDR initial_location
;
109 /* Number of bytes of program instructions described by this FDE. */
110 CORE_ADDR address_range
;
112 /* Instruction sequence. */
113 gdb_byte
*instructions
;
116 /* True if this FDE is read from a .eh_frame instead of a .debug_frame
118 unsigned char eh_frame_p
;
121 struct dwarf2_fde_table
124 struct dwarf2_fde
**entries
;
127 /* A minimal decoding of DWARF2 compilation units. We only decode
128 what's needed to get to the call frame information. */
132 /* Keep the bfd convenient. */
135 struct objfile
*objfile
;
137 /* Pointer to the .debug_frame section loaded into memory. */
138 gdb_byte
*dwarf_frame_buffer
;
140 /* Length of the loaded .debug_frame section. */
141 bfd_size_type dwarf_frame_size
;
143 /* Pointer to the .debug_frame section. */
144 asection
*dwarf_frame_section
;
146 /* Base for DW_EH_PE_datarel encodings. */
149 /* Base for DW_EH_PE_textrel encodings. */
153 static struct dwarf2_fde
*dwarf2_frame_find_fde (CORE_ADDR
*pc
,
154 CORE_ADDR
*out_offset
);
156 static int dwarf2_frame_adjust_regnum (struct gdbarch
*gdbarch
, int regnum
,
159 static CORE_ADDR
read_encoded_value (struct comp_unit
*unit
, gdb_byte encoding
,
160 int ptr_len
, const gdb_byte
*buf
,
161 unsigned int *bytes_read_ptr
,
162 CORE_ADDR func_base
);
165 /* Structure describing a frame state. */
167 struct dwarf2_frame_state
169 /* Each register save state can be described in terms of a CFA slot,
170 another register, or a location expression. */
171 struct dwarf2_frame_state_reg_info
173 struct dwarf2_frame_state_reg
*reg
;
183 const gdb_byte
*cfa_exp
;
185 /* Used to implement DW_CFA_remember_state. */
186 struct dwarf2_frame_state_reg_info
*prev
;
189 /* The PC described by the current frame state. */
192 /* Initial register set from the CIE.
193 Used to implement DW_CFA_restore. */
194 struct dwarf2_frame_state_reg_info initial
;
196 /* The information we care about from the CIE. */
199 ULONGEST retaddr_column
;
201 /* Flags for known producer quirks. */
203 /* The ARM compilers, in DWARF2 mode, assume that DW_CFA_def_cfa
204 and DW_CFA_def_cfa_offset takes a factored offset. */
205 int armcc_cfa_offsets_sf
;
207 /* The ARM compilers, in DWARF2 or DWARF3 mode, may assume that
208 the CFA is defined as REG - OFFSET rather than REG + OFFSET. */
209 int armcc_cfa_offsets_reversed
;
212 /* Store the length the expression for the CFA in the `cfa_reg' field,
213 which is unused in that case. */
214 #define cfa_exp_len cfa_reg
216 /* Assert that the register set RS is large enough to store gdbarch_num_regs
217 columns. If necessary, enlarge the register set. */
220 dwarf2_frame_state_alloc_regs (struct dwarf2_frame_state_reg_info
*rs
,
223 size_t size
= sizeof (struct dwarf2_frame_state_reg
);
225 if (num_regs
<= rs
->num_regs
)
228 rs
->reg
= (struct dwarf2_frame_state_reg
*)
229 xrealloc (rs
->reg
, num_regs
* size
);
231 /* Initialize newly allocated registers. */
232 memset (rs
->reg
+ rs
->num_regs
, 0, (num_regs
- rs
->num_regs
) * size
);
233 rs
->num_regs
= num_regs
;
236 /* Copy the register columns in register set RS into newly allocated
237 memory and return a pointer to this newly created copy. */
239 static struct dwarf2_frame_state_reg
*
240 dwarf2_frame_state_copy_regs (struct dwarf2_frame_state_reg_info
*rs
)
242 size_t size
= rs
->num_regs
* sizeof (struct dwarf2_frame_state_reg
);
243 struct dwarf2_frame_state_reg
*reg
;
245 reg
= (struct dwarf2_frame_state_reg
*) xmalloc (size
);
246 memcpy (reg
, rs
->reg
, size
);
251 /* Release the memory allocated to register set RS. */
254 dwarf2_frame_state_free_regs (struct dwarf2_frame_state_reg_info
*rs
)
258 dwarf2_frame_state_free_regs (rs
->prev
);
265 /* Release the memory allocated to the frame state FS. */
268 dwarf2_frame_state_free (void *p
)
270 struct dwarf2_frame_state
*fs
= p
;
272 dwarf2_frame_state_free_regs (fs
->initial
.prev
);
273 dwarf2_frame_state_free_regs (fs
->regs
.prev
);
274 xfree (fs
->initial
.reg
);
275 xfree (fs
->regs
.reg
);
280 /* Helper functions for execute_stack_op. */
283 read_reg (void *baton
, int reg
)
285 struct frame_info
*this_frame
= (struct frame_info
*) baton
;
286 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
290 regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, reg
);
292 buf
= alloca (register_size (gdbarch
, regnum
));
293 get_frame_register (this_frame
, regnum
, buf
);
295 /* Convert the register to an integer. This returns a LONGEST
296 rather than a CORE_ADDR, but unpack_pointer does the same thing
297 under the covers, and this makes more sense for non-pointer
298 registers. Maybe read_reg and the associated interfaces should
299 deal with "struct value" instead of CORE_ADDR. */
300 return unpack_long (register_type (gdbarch
, regnum
), buf
);
304 read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
306 read_memory (addr
, buf
, len
);
310 no_get_frame_base (void *baton
, const gdb_byte
**start
, size_t *length
)
312 internal_error (__FILE__
, __LINE__
,
313 _("Support for DW_OP_fbreg is unimplemented"));
316 /* Helper function for execute_stack_op. */
319 no_get_frame_cfa (void *baton
)
321 internal_error (__FILE__
, __LINE__
,
322 _("Support for DW_OP_call_frame_cfa is unimplemented"));
326 no_get_tls_address (void *baton
, CORE_ADDR offset
)
328 internal_error (__FILE__
, __LINE__
,
329 _("Support for DW_OP_GNU_push_tls_address is unimplemented"));
332 /* Helper function for execute_stack_op. */
335 no_dwarf_call (struct dwarf_expr_context
*ctx
, size_t die_offset
)
337 internal_error (__FILE__
, __LINE__
,
338 _("Support for DW_OP_call* is invalid in CFI"));
341 /* Execute the required actions for both the DW_CFA_restore and
342 DW_CFA_restore_extended instructions. */
344 dwarf2_restore_rule (struct gdbarch
*gdbarch
, ULONGEST reg_num
,
345 struct dwarf2_frame_state
*fs
, int eh_frame_p
)
349 gdb_assert (fs
->initial
.reg
);
350 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg_num
, eh_frame_p
);
351 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
353 /* Check if this register was explicitly initialized in the
354 CIE initial instructions. If not, default the rule to
356 if (reg
< fs
->initial
.num_regs
)
357 fs
->regs
.reg
[reg
] = fs
->initial
.reg
[reg
];
359 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_UNSPECIFIED
;
361 if (fs
->regs
.reg
[reg
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
362 complaint (&symfile_complaints
, _("\
363 incomplete CFI data; DW_CFA_restore unspecified\n\
364 register %s (#%d) at %s"),
365 gdbarch_register_name
366 (gdbarch
, gdbarch_dwarf2_reg_to_regnum (gdbarch
, reg
)),
367 gdbarch_dwarf2_reg_to_regnum (gdbarch
, reg
),
368 paddress (gdbarch
, fs
->pc
));
372 execute_stack_op (const gdb_byte
*exp
, ULONGEST len
, int addr_size
,
373 CORE_ADDR offset
, struct frame_info
*this_frame
,
374 CORE_ADDR initial
, int initial_in_stack_memory
)
376 struct dwarf_expr_context
*ctx
;
378 struct cleanup
*old_chain
;
380 ctx
= new_dwarf_expr_context ();
381 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
383 ctx
->gdbarch
= get_frame_arch (this_frame
);
384 ctx
->addr_size
= addr_size
;
385 ctx
->offset
= offset
;
386 ctx
->baton
= this_frame
;
387 ctx
->read_reg
= read_reg
;
388 ctx
->read_mem
= read_mem
;
389 ctx
->get_frame_base
= no_get_frame_base
;
390 ctx
->get_frame_cfa
= no_get_frame_cfa
;
391 ctx
->get_tls_address
= no_get_tls_address
;
392 ctx
->dwarf_call
= no_dwarf_call
;
394 dwarf_expr_push (ctx
, initial
, initial_in_stack_memory
);
395 dwarf_expr_eval (ctx
, exp
, len
);
397 if (ctx
->location
== DWARF_VALUE_MEMORY
)
398 result
= dwarf_expr_fetch_address (ctx
, 0);
399 else if (ctx
->location
== DWARF_VALUE_REGISTER
)
400 result
= read_reg (this_frame
, dwarf_expr_fetch (ctx
, 0));
403 /* This is actually invalid DWARF, but if we ever do run across
404 it somehow, we might as well support it. So, instead, report
405 it as unimplemented. */
406 error (_("Not implemented: computing unwound register using explicit value operator"));
409 do_cleanups (old_chain
);
416 execute_cfa_program (struct dwarf2_fde
*fde
, const gdb_byte
*insn_ptr
,
417 const gdb_byte
*insn_end
, struct frame_info
*this_frame
,
418 struct dwarf2_frame_state
*fs
)
420 int eh_frame_p
= fde
->eh_frame_p
;
421 CORE_ADDR pc
= get_frame_pc (this_frame
);
423 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
424 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
426 while (insn_ptr
< insn_end
&& fs
->pc
<= pc
)
428 gdb_byte insn
= *insn_ptr
++;
432 if ((insn
& 0xc0) == DW_CFA_advance_loc
)
433 fs
->pc
+= (insn
& 0x3f) * fs
->code_align
;
434 else if ((insn
& 0xc0) == DW_CFA_offset
)
437 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
438 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
439 offset
= utmp
* fs
->data_align
;
440 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
441 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
442 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
444 else if ((insn
& 0xc0) == DW_CFA_restore
)
447 dwarf2_restore_rule (gdbarch
, reg
, fs
, eh_frame_p
);
454 fs
->pc
= read_encoded_value (fde
->cie
->unit
, fde
->cie
->encoding
,
455 fde
->cie
->addr_size
, insn_ptr
,
456 &bytes_read
, fde
->initial_location
);
457 /* Apply the objfile offset for relocatable objects. */
458 fs
->pc
+= ANOFFSET (fde
->cie
->unit
->objfile
->section_offsets
,
459 SECT_OFF_TEXT (fde
->cie
->unit
->objfile
));
460 insn_ptr
+= bytes_read
;
463 case DW_CFA_advance_loc1
:
464 utmp
= extract_unsigned_integer (insn_ptr
, 1, byte_order
);
465 fs
->pc
+= utmp
* fs
->code_align
;
468 case DW_CFA_advance_loc2
:
469 utmp
= extract_unsigned_integer (insn_ptr
, 2, byte_order
);
470 fs
->pc
+= utmp
* fs
->code_align
;
473 case DW_CFA_advance_loc4
:
474 utmp
= extract_unsigned_integer (insn_ptr
, 4, byte_order
);
475 fs
->pc
+= utmp
* fs
->code_align
;
479 case DW_CFA_offset_extended
:
480 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
481 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
482 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
483 offset
= utmp
* fs
->data_align
;
484 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
485 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
486 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
489 case DW_CFA_restore_extended
:
490 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
491 dwarf2_restore_rule (gdbarch
, reg
, fs
, eh_frame_p
);
494 case DW_CFA_undefined
:
495 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
496 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
497 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
498 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_UNDEFINED
;
501 case DW_CFA_same_value
:
502 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
503 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
504 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
505 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAME_VALUE
;
508 case DW_CFA_register
:
509 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
510 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
511 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
512 utmp
= dwarf2_frame_adjust_regnum (gdbarch
, utmp
, eh_frame_p
);
513 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
514 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_REG
;
515 fs
->regs
.reg
[reg
].loc
.reg
= utmp
;
518 case DW_CFA_remember_state
:
520 struct dwarf2_frame_state_reg_info
*new_rs
;
522 new_rs
= XMALLOC (struct dwarf2_frame_state_reg_info
);
524 fs
->regs
.reg
= dwarf2_frame_state_copy_regs (&fs
->regs
);
525 fs
->regs
.prev
= new_rs
;
529 case DW_CFA_restore_state
:
531 struct dwarf2_frame_state_reg_info
*old_rs
= fs
->regs
.prev
;
535 complaint (&symfile_complaints
, _("\
536 bad CFI data; mismatched DW_CFA_restore_state at %s"),
537 paddress (gdbarch
, fs
->pc
));
541 xfree (fs
->regs
.reg
);
549 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &fs
->regs
.cfa_reg
);
550 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
552 if (fs
->armcc_cfa_offsets_sf
)
553 utmp
*= fs
->data_align
;
555 fs
->regs
.cfa_offset
= utmp
;
556 fs
->regs
.cfa_how
= CFA_REG_OFFSET
;
559 case DW_CFA_def_cfa_register
:
560 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &fs
->regs
.cfa_reg
);
561 fs
->regs
.cfa_reg
= dwarf2_frame_adjust_regnum (gdbarch
,
564 fs
->regs
.cfa_how
= CFA_REG_OFFSET
;
567 case DW_CFA_def_cfa_offset
:
568 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
570 if (fs
->armcc_cfa_offsets_sf
)
571 utmp
*= fs
->data_align
;
573 fs
->regs
.cfa_offset
= utmp
;
574 /* cfa_how deliberately not set. */
580 case DW_CFA_def_cfa_expression
:
581 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
,
582 &fs
->regs
.cfa_exp_len
);
583 fs
->regs
.cfa_exp
= insn_ptr
;
584 fs
->regs
.cfa_how
= CFA_EXP
;
585 insn_ptr
+= fs
->regs
.cfa_exp_len
;
588 case DW_CFA_expression
:
589 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
590 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
591 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
592 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
593 fs
->regs
.reg
[reg
].loc
.exp
= insn_ptr
;
594 fs
->regs
.reg
[reg
].exp_len
= utmp
;
595 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_EXP
;
599 case DW_CFA_offset_extended_sf
:
600 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
601 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
602 insn_ptr
= read_sleb128 (insn_ptr
, insn_end
, &offset
);
603 offset
*= fs
->data_align
;
604 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
605 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
606 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
609 case DW_CFA_val_offset
:
610 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
611 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
612 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
613 offset
= utmp
* fs
->data_align
;
614 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_VAL_OFFSET
;
615 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
618 case DW_CFA_val_offset_sf
:
619 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
620 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
621 insn_ptr
= read_sleb128 (insn_ptr
, insn_end
, &offset
);
622 offset
*= fs
->data_align
;
623 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_VAL_OFFSET
;
624 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
627 case DW_CFA_val_expression
:
628 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
629 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
630 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
631 fs
->regs
.reg
[reg
].loc
.exp
= insn_ptr
;
632 fs
->regs
.reg
[reg
].exp_len
= utmp
;
633 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_VAL_EXP
;
637 case DW_CFA_def_cfa_sf
:
638 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &fs
->regs
.cfa_reg
);
639 fs
->regs
.cfa_reg
= dwarf2_frame_adjust_regnum (gdbarch
,
642 insn_ptr
= read_sleb128 (insn_ptr
, insn_end
, &offset
);
643 fs
->regs
.cfa_offset
= offset
* fs
->data_align
;
644 fs
->regs
.cfa_how
= CFA_REG_OFFSET
;
647 case DW_CFA_def_cfa_offset_sf
:
648 insn_ptr
= read_sleb128 (insn_ptr
, insn_end
, &offset
);
649 fs
->regs
.cfa_offset
= offset
* fs
->data_align
;
650 /* cfa_how deliberately not set. */
653 case DW_CFA_GNU_window_save
:
654 /* This is SPARC-specific code, and contains hard-coded
655 constants for the register numbering scheme used by
656 GCC. Rather than having a architecture-specific
657 operation that's only ever used by a single
658 architecture, we provide the implementation here.
659 Incidentally that's what GCC does too in its
662 int size
= register_size (gdbarch
, 0);
664 dwarf2_frame_state_alloc_regs (&fs
->regs
, 32);
665 for (reg
= 8; reg
< 16; reg
++)
667 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_REG
;
668 fs
->regs
.reg
[reg
].loc
.reg
= reg
+ 16;
670 for (reg
= 16; reg
< 32; reg
++)
672 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
673 fs
->regs
.reg
[reg
].loc
.offset
= (reg
- 16) * size
;
678 case DW_CFA_GNU_args_size
:
680 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
683 case DW_CFA_GNU_negative_offset_extended
:
684 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
685 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
686 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &offset
);
687 offset
*= fs
->data_align
;
688 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
689 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
690 fs
->regs
.reg
[reg
].loc
.offset
= -offset
;
694 internal_error (__FILE__
, __LINE__
, _("Unknown CFI encountered."));
699 /* Don't allow remember/restore between CIE and FDE programs. */
700 dwarf2_frame_state_free_regs (fs
->regs
.prev
);
701 fs
->regs
.prev
= NULL
;
705 /* Architecture-specific operations. */
707 /* Per-architecture data key. */
708 static struct gdbarch_data
*dwarf2_frame_data
;
710 struct dwarf2_frame_ops
712 /* Pre-initialize the register state REG for register REGNUM. */
713 void (*init_reg
) (struct gdbarch
*, int, struct dwarf2_frame_state_reg
*,
714 struct frame_info
*);
716 /* Check whether the THIS_FRAME is a signal trampoline. */
717 int (*signal_frame_p
) (struct gdbarch
*, struct frame_info
*);
719 /* Convert .eh_frame register number to DWARF register number, or
720 adjust .debug_frame register number. */
721 int (*adjust_regnum
) (struct gdbarch
*, int, int);
724 /* Default architecture-specific register state initialization
728 dwarf2_frame_default_init_reg (struct gdbarch
*gdbarch
, int regnum
,
729 struct dwarf2_frame_state_reg
*reg
,
730 struct frame_info
*this_frame
)
732 /* If we have a register that acts as a program counter, mark it as
733 a destination for the return address. If we have a register that
734 serves as the stack pointer, arrange for it to be filled with the
735 call frame address (CFA). The other registers are marked as
738 We copy the return address to the program counter, since many
739 parts in GDB assume that it is possible to get the return address
740 by unwinding the program counter register. However, on ISA's
741 with a dedicated return address register, the CFI usually only
742 contains information to unwind that return address register.
744 The reason we're treating the stack pointer special here is
745 because in many cases GCC doesn't emit CFI for the stack pointer
746 and implicitly assumes that it is equal to the CFA. This makes
747 some sense since the DWARF specification (version 3, draft 8,
750 "Typically, the CFA is defined to be the value of the stack
751 pointer at the call site in the previous frame (which may be
752 different from its value on entry to the current frame)."
754 However, this isn't true for all platforms supported by GCC
755 (e.g. IBM S/390 and zSeries). Those architectures should provide
756 their own architecture-specific initialization function. */
758 if (regnum
== gdbarch_pc_regnum (gdbarch
))
759 reg
->how
= DWARF2_FRAME_REG_RA
;
760 else if (regnum
== gdbarch_sp_regnum (gdbarch
))
761 reg
->how
= DWARF2_FRAME_REG_CFA
;
764 /* Return a default for the architecture-specific operations. */
767 dwarf2_frame_init (struct obstack
*obstack
)
769 struct dwarf2_frame_ops
*ops
;
771 ops
= OBSTACK_ZALLOC (obstack
, struct dwarf2_frame_ops
);
772 ops
->init_reg
= dwarf2_frame_default_init_reg
;
776 /* Set the architecture-specific register state initialization
777 function for GDBARCH to INIT_REG. */
780 dwarf2_frame_set_init_reg (struct gdbarch
*gdbarch
,
781 void (*init_reg
) (struct gdbarch
*, int,
782 struct dwarf2_frame_state_reg
*,
783 struct frame_info
*))
785 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
787 ops
->init_reg
= init_reg
;
790 /* Pre-initialize the register state REG for register REGNUM. */
793 dwarf2_frame_init_reg (struct gdbarch
*gdbarch
, int regnum
,
794 struct dwarf2_frame_state_reg
*reg
,
795 struct frame_info
*this_frame
)
797 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
799 ops
->init_reg (gdbarch
, regnum
, reg
, this_frame
);
802 /* Set the architecture-specific signal trampoline recognition
803 function for GDBARCH to SIGNAL_FRAME_P. */
806 dwarf2_frame_set_signal_frame_p (struct gdbarch
*gdbarch
,
807 int (*signal_frame_p
) (struct gdbarch
*,
808 struct frame_info
*))
810 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
812 ops
->signal_frame_p
= signal_frame_p
;
815 /* Query the architecture-specific signal frame recognizer for
819 dwarf2_frame_signal_frame_p (struct gdbarch
*gdbarch
,
820 struct frame_info
*this_frame
)
822 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
824 if (ops
->signal_frame_p
== NULL
)
826 return ops
->signal_frame_p (gdbarch
, this_frame
);
829 /* Set the architecture-specific adjustment of .eh_frame and .debug_frame
833 dwarf2_frame_set_adjust_regnum (struct gdbarch
*gdbarch
,
834 int (*adjust_regnum
) (struct gdbarch
*,
837 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
839 ops
->adjust_regnum
= adjust_regnum
;
842 /* Translate a .eh_frame register to DWARF register, or adjust a .debug_frame
846 dwarf2_frame_adjust_regnum (struct gdbarch
*gdbarch
, int regnum
, int eh_frame_p
)
848 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
850 if (ops
->adjust_regnum
== NULL
)
852 return ops
->adjust_regnum (gdbarch
, regnum
, eh_frame_p
);
856 dwarf2_frame_find_quirks (struct dwarf2_frame_state
*fs
,
857 struct dwarf2_fde
*fde
)
861 s
= find_pc_symtab (fs
->pc
);
865 if (producer_is_realview (s
->producer
))
867 if (fde
->cie
->version
== 1)
868 fs
->armcc_cfa_offsets_sf
= 1;
870 if (fde
->cie
->version
== 1)
871 fs
->armcc_cfa_offsets_reversed
= 1;
873 /* The reversed offset problem is present in some compilers
874 using DWARF3, but it was eventually fixed. Check the ARM
875 defined augmentations, which are in the format "armcc" followed
876 by a list of one-character options. The "+" option means
877 this problem is fixed (no quirk needed). If the armcc
878 augmentation is missing, the quirk is needed. */
879 if (fde
->cie
->version
== 3
880 && (strncmp (fde
->cie
->augmentation
, "armcc", 5) != 0
881 || strchr (fde
->cie
->augmentation
+ 5, '+') == NULL
))
882 fs
->armcc_cfa_offsets_reversed
= 1;
889 struct dwarf2_frame_cache
891 /* DWARF Call Frame Address. */
894 /* Set if the return address column was marked as undefined. */
895 int undefined_retaddr
;
897 /* Saved registers, indexed by GDB register number, not by DWARF
899 struct dwarf2_frame_state_reg
*reg
;
901 /* Return address register. */
902 struct dwarf2_frame_state_reg retaddr_reg
;
904 /* Target address size in bytes. */
907 /* The .text offset. */
908 CORE_ADDR text_offset
;
911 static struct dwarf2_frame_cache
*
912 dwarf2_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
914 struct cleanup
*old_chain
;
915 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
916 const int num_regs
= gdbarch_num_regs (gdbarch
)
917 + gdbarch_num_pseudo_regs (gdbarch
);
918 struct dwarf2_frame_cache
*cache
;
919 struct dwarf2_frame_state
*fs
;
920 struct dwarf2_fde
*fde
;
925 /* Allocate a new cache. */
926 cache
= FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache
);
927 cache
->reg
= FRAME_OBSTACK_CALLOC (num_regs
, struct dwarf2_frame_state_reg
);
929 /* Allocate and initialize the frame state. */
930 fs
= XMALLOC (struct dwarf2_frame_state
);
931 memset (fs
, 0, sizeof (struct dwarf2_frame_state
));
932 old_chain
= make_cleanup (dwarf2_frame_state_free
, fs
);
936 Note that if the next frame is never supposed to return (i.e. a call
937 to abort), the compiler might optimize away the instruction at
938 its return address. As a result the return address will
939 point at some random instruction, and the CFI for that
940 instruction is probably worthless to us. GCC's unwinder solves
941 this problem by substracting 1 from the return address to get an
942 address in the middle of a presumed call instruction (or the
943 instruction in the associated delay slot). This should only be
944 done for "normal" frames and not for resume-type frames (signal
945 handlers, sentinel frames, dummy frames). The function
946 get_frame_address_in_block does just this. It's not clear how
947 reliable the method is though; there is the potential for the
948 register state pre-call being different to that on return. */
949 fs
->pc
= get_frame_address_in_block (this_frame
);
951 /* Find the correct FDE. */
952 fde
= dwarf2_frame_find_fde (&fs
->pc
, &cache
->text_offset
);
953 gdb_assert (fde
!= NULL
);
955 /* Extract any interesting information from the CIE. */
956 fs
->data_align
= fde
->cie
->data_alignment_factor
;
957 fs
->code_align
= fde
->cie
->code_alignment_factor
;
958 fs
->retaddr_column
= fde
->cie
->return_address_register
;
959 cache
->addr_size
= fde
->cie
->addr_size
;
961 /* Check for "quirks" - known bugs in producers. */
962 dwarf2_frame_find_quirks (fs
, fde
);
964 /* First decode all the insns in the CIE. */
965 execute_cfa_program (fde
, fde
->cie
->initial_instructions
,
966 fde
->cie
->end
, this_frame
, fs
);
968 /* Save the initialized register set. */
969 fs
->initial
= fs
->regs
;
970 fs
->initial
.reg
= dwarf2_frame_state_copy_regs (&fs
->regs
);
972 /* Then decode the insns in the FDE up to our target PC. */
973 execute_cfa_program (fde
, fde
->instructions
, fde
->end
, this_frame
, fs
);
975 /* Calculate the CFA. */
976 switch (fs
->regs
.cfa_how
)
979 cache
->cfa
= read_reg (this_frame
, fs
->regs
.cfa_reg
);
980 if (fs
->armcc_cfa_offsets_reversed
)
981 cache
->cfa
-= fs
->regs
.cfa_offset
;
983 cache
->cfa
+= fs
->regs
.cfa_offset
;
988 execute_stack_op (fs
->regs
.cfa_exp
, fs
->regs
.cfa_exp_len
,
989 cache
->addr_size
, cache
->text_offset
,
994 internal_error (__FILE__
, __LINE__
, _("Unknown CFA rule."));
997 /* Initialize the register state. */
1001 for (regnum
= 0; regnum
< num_regs
; regnum
++)
1002 dwarf2_frame_init_reg (gdbarch
, regnum
, &cache
->reg
[regnum
], this_frame
);
1005 /* Go through the DWARF2 CFI generated table and save its register
1006 location information in the cache. Note that we don't skip the
1007 return address column; it's perfectly all right for it to
1008 correspond to a real register. If it doesn't correspond to a
1009 real register, or if we shouldn't treat it as such,
1010 gdbarch_dwarf2_reg_to_regnum should be defined to return a number outside
1011 the range [0, gdbarch_num_regs). */
1013 int column
; /* CFI speak for "register number". */
1015 for (column
= 0; column
< fs
->regs
.num_regs
; column
++)
1017 /* Use the GDB register number as the destination index. */
1018 int regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, column
);
1020 /* If there's no corresponding GDB register, ignore it. */
1021 if (regnum
< 0 || regnum
>= num_regs
)
1024 /* NOTE: cagney/2003-09-05: CFI should specify the disposition
1025 of all debug info registers. If it doesn't, complain (but
1026 not too loudly). It turns out that GCC assumes that an
1027 unspecified register implies "same value" when CFI (draft
1028 7) specifies nothing at all. Such a register could equally
1029 be interpreted as "undefined". Also note that this check
1030 isn't sufficient; it only checks that all registers in the
1031 range [0 .. max column] are specified, and won't detect
1032 problems when a debug info register falls outside of the
1033 table. We need a way of iterating through all the valid
1034 DWARF2 register numbers. */
1035 if (fs
->regs
.reg
[column
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
1037 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
1038 complaint (&symfile_complaints
, _("\
1039 incomplete CFI data; unspecified registers (e.g., %s) at %s"),
1040 gdbarch_register_name (gdbarch
, regnum
),
1041 paddress (gdbarch
, fs
->pc
));
1044 cache
->reg
[regnum
] = fs
->regs
.reg
[column
];
1048 /* Eliminate any DWARF2_FRAME_REG_RA rules, and save the information
1049 we need for evaluating DWARF2_FRAME_REG_RA_OFFSET rules. */
1053 for (regnum
= 0; regnum
< num_regs
; regnum
++)
1055 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
1056 || cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA_OFFSET
)
1058 struct dwarf2_frame_state_reg
*retaddr_reg
=
1059 &fs
->regs
.reg
[fs
->retaddr_column
];
1061 /* It seems rather bizarre to specify an "empty" column as
1062 the return adress column. However, this is exactly
1063 what GCC does on some targets. It turns out that GCC
1064 assumes that the return address can be found in the
1065 register corresponding to the return address column.
1066 Incidentally, that's how we should treat a return
1067 address column specifying "same value" too. */
1068 if (fs
->retaddr_column
< fs
->regs
.num_regs
1069 && retaddr_reg
->how
!= DWARF2_FRAME_REG_UNSPECIFIED
1070 && retaddr_reg
->how
!= DWARF2_FRAME_REG_SAME_VALUE
)
1072 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
)
1073 cache
->reg
[regnum
] = *retaddr_reg
;
1075 cache
->retaddr_reg
= *retaddr_reg
;
1079 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
)
1081 cache
->reg
[regnum
].loc
.reg
= fs
->retaddr_column
;
1082 cache
->reg
[regnum
].how
= DWARF2_FRAME_REG_SAVED_REG
;
1086 cache
->retaddr_reg
.loc
.reg
= fs
->retaddr_column
;
1087 cache
->retaddr_reg
.how
= DWARF2_FRAME_REG_SAVED_REG
;
1094 if (fs
->retaddr_column
< fs
->regs
.num_regs
1095 && fs
->regs
.reg
[fs
->retaddr_column
].how
== DWARF2_FRAME_REG_UNDEFINED
)
1096 cache
->undefined_retaddr
= 1;
1098 do_cleanups (old_chain
);
1100 *this_cache
= cache
;
1105 dwarf2_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
1106 struct frame_id
*this_id
)
1108 struct dwarf2_frame_cache
*cache
=
1109 dwarf2_frame_cache (this_frame
, this_cache
);
1111 if (cache
->undefined_retaddr
)
1114 (*this_id
) = frame_id_build (cache
->cfa
, get_frame_func (this_frame
));
1117 static struct value
*
1118 dwarf2_frame_prev_register (struct frame_info
*this_frame
, void **this_cache
,
1121 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1122 struct dwarf2_frame_cache
*cache
=
1123 dwarf2_frame_cache (this_frame
, this_cache
);
1127 switch (cache
->reg
[regnum
].how
)
1129 case DWARF2_FRAME_REG_UNDEFINED
:
1130 /* If CFI explicitly specified that the value isn't defined,
1131 mark it as optimized away; the value isn't available. */
1132 return frame_unwind_got_optimized (this_frame
, regnum
);
1134 case DWARF2_FRAME_REG_SAVED_OFFSET
:
1135 addr
= cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
;
1136 return frame_unwind_got_memory (this_frame
, regnum
, addr
);
1138 case DWARF2_FRAME_REG_SAVED_REG
:
1140 = gdbarch_dwarf2_reg_to_regnum (gdbarch
, cache
->reg
[regnum
].loc
.reg
);
1141 return frame_unwind_got_register (this_frame
, regnum
, realnum
);
1143 case DWARF2_FRAME_REG_SAVED_EXP
:
1144 addr
= execute_stack_op (cache
->reg
[regnum
].loc
.exp
,
1145 cache
->reg
[regnum
].exp_len
,
1146 cache
->addr_size
, cache
->text_offset
,
1147 this_frame
, cache
->cfa
, 1);
1148 return frame_unwind_got_memory (this_frame
, regnum
, addr
);
1150 case DWARF2_FRAME_REG_SAVED_VAL_OFFSET
:
1151 addr
= cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
;
1152 return frame_unwind_got_constant (this_frame
, regnum
, addr
);
1154 case DWARF2_FRAME_REG_SAVED_VAL_EXP
:
1155 addr
= execute_stack_op (cache
->reg
[regnum
].loc
.exp
,
1156 cache
->reg
[regnum
].exp_len
,
1157 cache
->addr_size
, cache
->text_offset
,
1158 this_frame
, cache
->cfa
, 1);
1159 return frame_unwind_got_constant (this_frame
, regnum
, addr
);
1161 case DWARF2_FRAME_REG_UNSPECIFIED
:
1162 /* GCC, in its infinite wisdom decided to not provide unwind
1163 information for registers that are "same value". Since
1164 DWARF2 (3 draft 7) doesn't define such behavior, said
1165 registers are actually undefined (which is different to CFI
1166 "undefined"). Code above issues a complaint about this.
1167 Here just fudge the books, assume GCC, and that the value is
1168 more inner on the stack. */
1169 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
1171 case DWARF2_FRAME_REG_SAME_VALUE
:
1172 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
1174 case DWARF2_FRAME_REG_CFA
:
1175 return frame_unwind_got_address (this_frame
, regnum
, cache
->cfa
);
1177 case DWARF2_FRAME_REG_CFA_OFFSET
:
1178 addr
= cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
;
1179 return frame_unwind_got_address (this_frame
, regnum
, addr
);
1181 case DWARF2_FRAME_REG_RA_OFFSET
:
1182 addr
= cache
->reg
[regnum
].loc
.offset
;
1183 regnum
= gdbarch_dwarf2_reg_to_regnum
1184 (gdbarch
, cache
->retaddr_reg
.loc
.reg
);
1185 addr
+= get_frame_register_unsigned (this_frame
, regnum
);
1186 return frame_unwind_got_address (this_frame
, regnum
, addr
);
1188 case DWARF2_FRAME_REG_FN
:
1189 return cache
->reg
[regnum
].loc
.fn (this_frame
, this_cache
, regnum
);
1192 internal_error (__FILE__
, __LINE__
, _("Unknown register rule."));
1197 dwarf2_frame_sniffer (const struct frame_unwind
*self
,
1198 struct frame_info
*this_frame
, void **this_cache
)
1200 /* Grab an address that is guarenteed to reside somewhere within the
1201 function. get_frame_pc(), with a no-return next function, can
1202 end up returning something past the end of this function's body.
1203 If the frame we're sniffing for is a signal frame whose start
1204 address is placed on the stack by the OS, its FDE must
1205 extend one byte before its start address or we could potentially
1206 select the FDE of the previous function. */
1207 CORE_ADDR block_addr
= get_frame_address_in_block (this_frame
);
1208 struct dwarf2_fde
*fde
= dwarf2_frame_find_fde (&block_addr
, NULL
);
1213 /* On some targets, signal trampolines may have unwind information.
1214 We need to recognize them so that we set the frame type
1217 if (fde
->cie
->signal_frame
1218 || dwarf2_frame_signal_frame_p (get_frame_arch (this_frame
),
1220 return self
->type
== SIGTRAMP_FRAME
;
1222 return self
->type
!= SIGTRAMP_FRAME
;
1225 static const struct frame_unwind dwarf2_frame_unwind
=
1228 dwarf2_frame_this_id
,
1229 dwarf2_frame_prev_register
,
1231 dwarf2_frame_sniffer
1234 static const struct frame_unwind dwarf2_signal_frame_unwind
=
1237 dwarf2_frame_this_id
,
1238 dwarf2_frame_prev_register
,
1240 dwarf2_frame_sniffer
1243 /* Append the DWARF-2 frame unwinders to GDBARCH's list. */
1246 dwarf2_append_unwinders (struct gdbarch
*gdbarch
)
1248 frame_unwind_append_unwinder (gdbarch
, &dwarf2_frame_unwind
);
1249 frame_unwind_append_unwinder (gdbarch
, &dwarf2_signal_frame_unwind
);
1253 /* There is no explicitly defined relationship between the CFA and the
1254 location of frame's local variables and arguments/parameters.
1255 Therefore, frame base methods on this page should probably only be
1256 used as a last resort, just to avoid printing total garbage as a
1257 response to the "info frame" command. */
1260 dwarf2_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
1262 struct dwarf2_frame_cache
*cache
=
1263 dwarf2_frame_cache (this_frame
, this_cache
);
1268 static const struct frame_base dwarf2_frame_base
=
1270 &dwarf2_frame_unwind
,
1271 dwarf2_frame_base_address
,
1272 dwarf2_frame_base_address
,
1273 dwarf2_frame_base_address
1276 const struct frame_base
*
1277 dwarf2_frame_base_sniffer (struct frame_info
*this_frame
)
1279 CORE_ADDR block_addr
= get_frame_address_in_block (this_frame
);
1281 if (dwarf2_frame_find_fde (&block_addr
, NULL
))
1282 return &dwarf2_frame_base
;
1287 /* Compute the CFA for THIS_FRAME, but only if THIS_FRAME came from
1288 the DWARF unwinder. This is used to implement
1289 DW_OP_call_frame_cfa. */
1292 dwarf2_frame_cfa (struct frame_info
*this_frame
)
1294 while (get_frame_type (this_frame
) == INLINE_FRAME
)
1295 this_frame
= get_prev_frame (this_frame
);
1296 /* This restriction could be lifted if other unwinders are known to
1297 compute the frame base in a way compatible with the DWARF
1299 if (! frame_unwinder_is (this_frame
, &dwarf2_frame_unwind
))
1300 error (_("can't compute CFA for this frame"));
1301 return get_frame_base (this_frame
);
1304 const struct objfile_data
*dwarf2_frame_objfile_data
;
1307 read_1_byte (bfd
*abfd
, gdb_byte
*buf
)
1309 return bfd_get_8 (abfd
, buf
);
1313 read_4_bytes (bfd
*abfd
, gdb_byte
*buf
)
1315 return bfd_get_32 (abfd
, buf
);
1319 read_8_bytes (bfd
*abfd
, gdb_byte
*buf
)
1321 return bfd_get_64 (abfd
, buf
);
1325 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1328 unsigned int num_read
;
1338 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
1341 result
|= ((byte
& 0x7f) << shift
);
1344 while (byte
& 0x80);
1346 *bytes_read_ptr
= num_read
;
1352 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1356 unsigned int num_read
;
1365 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
1368 result
|= ((byte
& 0x7f) << shift
);
1371 while (byte
& 0x80);
1373 if (shift
< 8 * sizeof (result
) && (byte
& 0x40))
1374 result
|= -(((LONGEST
)1) << shift
);
1376 *bytes_read_ptr
= num_read
;
1382 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1386 result
= bfd_get_32 (abfd
, buf
);
1387 if (result
== 0xffffffff)
1389 result
= bfd_get_64 (abfd
, buf
+ 4);
1390 *bytes_read_ptr
= 12;
1393 *bytes_read_ptr
= 4;
1399 /* Pointer encoding helper functions. */
1401 /* GCC supports exception handling based on DWARF2 CFI. However, for
1402 technical reasons, it encodes addresses in its FDE's in a different
1403 way. Several "pointer encodings" are supported. The encoding
1404 that's used for a particular FDE is determined by the 'R'
1405 augmentation in the associated CIE. The argument of this
1406 augmentation is a single byte.
1408 The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a
1409 LEB128. This is encoded in bits 0, 1 and 2. Bit 3 encodes whether
1410 the address is signed or unsigned. Bits 4, 5 and 6 encode how the
1411 address should be interpreted (absolute, relative to the current
1412 position in the FDE, ...). Bit 7, indicates that the address
1413 should be dereferenced. */
1416 encoding_for_size (unsigned int size
)
1421 return DW_EH_PE_udata2
;
1423 return DW_EH_PE_udata4
;
1425 return DW_EH_PE_udata8
;
1427 internal_error (__FILE__
, __LINE__
, _("Unsupported address size"));
1432 read_encoded_value (struct comp_unit
*unit
, gdb_byte encoding
,
1433 int ptr_len
, const gdb_byte
*buf
,
1434 unsigned int *bytes_read_ptr
,
1435 CORE_ADDR func_base
)
1440 /* GCC currently doesn't generate DW_EH_PE_indirect encodings for
1442 if (encoding
& DW_EH_PE_indirect
)
1443 internal_error (__FILE__
, __LINE__
,
1444 _("Unsupported encoding: DW_EH_PE_indirect"));
1446 *bytes_read_ptr
= 0;
1448 switch (encoding
& 0x70)
1450 case DW_EH_PE_absptr
:
1453 case DW_EH_PE_pcrel
:
1454 base
= bfd_get_section_vma (unit
->abfd
, unit
->dwarf_frame_section
);
1455 base
+= (buf
- unit
->dwarf_frame_buffer
);
1457 case DW_EH_PE_datarel
:
1460 case DW_EH_PE_textrel
:
1463 case DW_EH_PE_funcrel
:
1466 case DW_EH_PE_aligned
:
1468 offset
= buf
- unit
->dwarf_frame_buffer
;
1469 if ((offset
% ptr_len
) != 0)
1471 *bytes_read_ptr
= ptr_len
- (offset
% ptr_len
);
1472 buf
+= *bytes_read_ptr
;
1476 internal_error (__FILE__
, __LINE__
, _("Invalid or unsupported encoding"));
1479 if ((encoding
& 0x07) == 0x00)
1481 encoding
|= encoding_for_size (ptr_len
);
1482 if (bfd_get_sign_extend_vma (unit
->abfd
))
1483 encoding
|= DW_EH_PE_signed
;
1486 switch (encoding
& 0x0f)
1488 case DW_EH_PE_uleb128
:
1491 const gdb_byte
*end_buf
= buf
+ (sizeof (value
) + 1) * 8 / 7;
1493 *bytes_read_ptr
+= read_uleb128 (buf
, end_buf
, &value
) - buf
;
1494 return base
+ value
;
1496 case DW_EH_PE_udata2
:
1497 *bytes_read_ptr
+= 2;
1498 return (base
+ bfd_get_16 (unit
->abfd
, (bfd_byte
*) buf
));
1499 case DW_EH_PE_udata4
:
1500 *bytes_read_ptr
+= 4;
1501 return (base
+ bfd_get_32 (unit
->abfd
, (bfd_byte
*) buf
));
1502 case DW_EH_PE_udata8
:
1503 *bytes_read_ptr
+= 8;
1504 return (base
+ bfd_get_64 (unit
->abfd
, (bfd_byte
*) buf
));
1505 case DW_EH_PE_sleb128
:
1508 const gdb_byte
*end_buf
= buf
+ (sizeof (value
) + 1) * 8 / 7;
1510 *bytes_read_ptr
+= read_sleb128 (buf
, end_buf
, &value
) - buf
;
1511 return base
+ value
;
1513 case DW_EH_PE_sdata2
:
1514 *bytes_read_ptr
+= 2;
1515 return (base
+ bfd_get_signed_16 (unit
->abfd
, (bfd_byte
*) buf
));
1516 case DW_EH_PE_sdata4
:
1517 *bytes_read_ptr
+= 4;
1518 return (base
+ bfd_get_signed_32 (unit
->abfd
, (bfd_byte
*) buf
));
1519 case DW_EH_PE_sdata8
:
1520 *bytes_read_ptr
+= 8;
1521 return (base
+ bfd_get_signed_64 (unit
->abfd
, (bfd_byte
*) buf
));
1523 internal_error (__FILE__
, __LINE__
, _("Invalid or unsupported encoding"));
1529 bsearch_cie_cmp (const void *key
, const void *element
)
1531 ULONGEST cie_pointer
= *(ULONGEST
*) key
;
1532 struct dwarf2_cie
*cie
= *(struct dwarf2_cie
**) element
;
1534 if (cie_pointer
== cie
->cie_pointer
)
1537 return (cie_pointer
< cie
->cie_pointer
) ? -1 : 1;
1540 /* Find CIE with the given CIE_POINTER in CIE_TABLE. */
1541 static struct dwarf2_cie
*
1542 find_cie (struct dwarf2_cie_table
*cie_table
, ULONGEST cie_pointer
)
1544 struct dwarf2_cie
**p_cie
;
1546 /* The C standard (ISO/IEC 9899:TC2) requires the BASE argument to
1547 bsearch be non-NULL. */
1548 if (cie_table
->entries
== NULL
)
1550 gdb_assert (cie_table
->num_entries
== 0);
1554 p_cie
= bsearch (&cie_pointer
, cie_table
->entries
, cie_table
->num_entries
,
1555 sizeof (cie_table
->entries
[0]), bsearch_cie_cmp
);
1561 /* Add a pointer to new CIE to the CIE_TABLE, allocating space for it. */
1563 add_cie (struct dwarf2_cie_table
*cie_table
, struct dwarf2_cie
*cie
)
1565 const int n
= cie_table
->num_entries
;
1568 || cie_table
->entries
[n
- 1]->cie_pointer
< cie
->cie_pointer
);
1570 cie_table
->entries
=
1571 xrealloc (cie_table
->entries
, (n
+ 1) * sizeof (cie_table
->entries
[0]));
1572 cie_table
->entries
[n
] = cie
;
1573 cie_table
->num_entries
= n
+ 1;
1577 bsearch_fde_cmp (const void *key
, const void *element
)
1579 CORE_ADDR seek_pc
= *(CORE_ADDR
*) key
;
1580 struct dwarf2_fde
*fde
= *(struct dwarf2_fde
**) element
;
1582 if (seek_pc
< fde
->initial_location
)
1584 if (seek_pc
< fde
->initial_location
+ fde
->address_range
)
1589 /* Find the FDE for *PC. Return a pointer to the FDE, and store the
1590 inital location associated with it into *PC. */
1592 static struct dwarf2_fde
*
1593 dwarf2_frame_find_fde (CORE_ADDR
*pc
, CORE_ADDR
*out_offset
)
1595 struct objfile
*objfile
;
1597 ALL_OBJFILES (objfile
)
1599 struct dwarf2_fde_table
*fde_table
;
1600 struct dwarf2_fde
**p_fde
;
1604 fde_table
= objfile_data (objfile
, dwarf2_frame_objfile_data
);
1605 if (fde_table
== NULL
)
1607 dwarf2_build_frame_info (objfile
);
1608 fde_table
= objfile_data (objfile
, dwarf2_frame_objfile_data
);
1610 gdb_assert (fde_table
!= NULL
);
1612 if (fde_table
->num_entries
== 0)
1615 gdb_assert (objfile
->section_offsets
);
1616 offset
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1618 gdb_assert (fde_table
->num_entries
> 0);
1619 if (*pc
< offset
+ fde_table
->entries
[0]->initial_location
)
1622 seek_pc
= *pc
- offset
;
1623 p_fde
= bsearch (&seek_pc
, fde_table
->entries
, fde_table
->num_entries
,
1624 sizeof (fde_table
->entries
[0]), bsearch_fde_cmp
);
1627 *pc
= (*p_fde
)->initial_location
+ offset
;
1629 *out_offset
= offset
;
1636 /* Add a pointer to new FDE to the FDE_TABLE, allocating space for it. */
1638 add_fde (struct dwarf2_fde_table
*fde_table
, struct dwarf2_fde
*fde
)
1640 if (fde
->address_range
== 0)
1641 /* Discard useless FDEs. */
1644 fde_table
->num_entries
+= 1;
1645 fde_table
->entries
=
1646 xrealloc (fde_table
->entries
,
1647 fde_table
->num_entries
* sizeof (fde_table
->entries
[0]));
1648 fde_table
->entries
[fde_table
->num_entries
- 1] = fde
;
1651 #ifdef CC_HAS_LONG_LONG
1652 #define DW64_CIE_ID 0xffffffffffffffffULL
1654 #define DW64_CIE_ID ~0
1657 static gdb_byte
*decode_frame_entry (struct comp_unit
*unit
, gdb_byte
*start
,
1659 struct dwarf2_cie_table
*cie_table
,
1660 struct dwarf2_fde_table
*fde_table
);
1662 /* Decode the next CIE or FDE. Return NULL if invalid input, otherwise
1663 the next byte to be processed. */
1665 decode_frame_entry_1 (struct comp_unit
*unit
, gdb_byte
*start
, int eh_frame_p
,
1666 struct dwarf2_cie_table
*cie_table
,
1667 struct dwarf2_fde_table
*fde_table
)
1669 struct gdbarch
*gdbarch
= get_objfile_arch (unit
->objfile
);
1670 gdb_byte
*buf
, *end
;
1672 unsigned int bytes_read
;
1675 ULONGEST cie_pointer
;
1678 length
= read_initial_length (unit
->abfd
, buf
, &bytes_read
);
1682 /* Are we still within the section? */
1683 if (end
> unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
)
1689 /* Distinguish between 32 and 64-bit encoded frame info. */
1690 dwarf64_p
= (bytes_read
== 12);
1692 /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs. */
1696 cie_id
= DW64_CIE_ID
;
1702 cie_pointer
= read_8_bytes (unit
->abfd
, buf
);
1707 cie_pointer
= read_4_bytes (unit
->abfd
, buf
);
1711 if (cie_pointer
== cie_id
)
1713 /* This is a CIE. */
1714 struct dwarf2_cie
*cie
;
1716 unsigned int cie_version
;
1718 /* Record the offset into the .debug_frame section of this CIE. */
1719 cie_pointer
= start
- unit
->dwarf_frame_buffer
;
1721 /* Check whether we've already read it. */
1722 if (find_cie (cie_table
, cie_pointer
))
1725 cie
= (struct dwarf2_cie
*)
1726 obstack_alloc (&unit
->objfile
->objfile_obstack
,
1727 sizeof (struct dwarf2_cie
));
1728 cie
->initial_instructions
= NULL
;
1729 cie
->cie_pointer
= cie_pointer
;
1731 /* The encoding for FDE's in a normal .debug_frame section
1732 depends on the target address size. */
1733 cie
->encoding
= DW_EH_PE_absptr
;
1735 /* The target address size. For .eh_frame FDEs this is considered
1736 equal to the size of a target pointer. For .dwarf_frame FDEs,
1737 this is supposed to be the target address size from the associated
1738 CU header. FIXME: We do not have a good way to determine the
1739 latter. Always use the target pointer size for now. */
1740 cie
->addr_size
= gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
;
1742 /* We'll determine the final value later, but we need to
1743 initialize it conservatively. */
1744 cie
->signal_frame
= 0;
1746 /* Check version number. */
1747 cie_version
= read_1_byte (unit
->abfd
, buf
);
1748 if (cie_version
!= 1 && cie_version
!= 3 && cie_version
!= 4)
1750 cie
->version
= cie_version
;
1753 /* Interpret the interesting bits of the augmentation. */
1754 cie
->augmentation
= augmentation
= (char *) buf
;
1755 buf
+= (strlen (augmentation
) + 1);
1757 /* Ignore armcc augmentations. We only use them for quirks,
1758 and that doesn't happen until later. */
1759 if (strncmp (augmentation
, "armcc", 5) == 0)
1760 augmentation
+= strlen (augmentation
);
1762 /* The GCC 2.x "eh" augmentation has a pointer immediately
1763 following the augmentation string, so it must be handled
1765 if (augmentation
[0] == 'e' && augmentation
[1] == 'h')
1768 buf
+= gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
;
1772 if (cie
->version
>= 4)
1774 /* FIXME: check that this is the same as from the CU header. */
1775 cie
->addr_size
= read_1_byte (unit
->abfd
, buf
);
1777 cie
->segment_size
= read_1_byte (unit
->abfd
, buf
);
1782 cie
->addr_size
= gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
;
1783 cie
->segment_size
= 0;
1786 cie
->code_alignment_factor
=
1787 read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1790 cie
->data_alignment_factor
=
1791 read_signed_leb128 (unit
->abfd
, buf
, &bytes_read
);
1794 if (cie_version
== 1)
1796 cie
->return_address_register
= read_1_byte (unit
->abfd
, buf
);
1800 cie
->return_address_register
= read_unsigned_leb128 (unit
->abfd
, buf
,
1802 cie
->return_address_register
1803 = dwarf2_frame_adjust_regnum (gdbarch
,
1804 cie
->return_address_register
,
1809 cie
->saw_z_augmentation
= (*augmentation
== 'z');
1810 if (cie
->saw_z_augmentation
)
1814 length
= read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1818 cie
->initial_instructions
= buf
+ length
;
1822 while (*augmentation
)
1824 /* "L" indicates a byte showing how the LSDA pointer is encoded. */
1825 if (*augmentation
== 'L')
1832 /* "R" indicates a byte indicating how FDE addresses are encoded. */
1833 else if (*augmentation
== 'R')
1835 cie
->encoding
= *buf
++;
1839 /* "P" indicates a personality routine in the CIE augmentation. */
1840 else if (*augmentation
== 'P')
1842 /* Skip. Avoid indirection since we throw away the result. */
1843 gdb_byte encoding
= (*buf
++) & ~DW_EH_PE_indirect
;
1844 read_encoded_value (unit
, encoding
, cie
->addr_size
,
1845 buf
, &bytes_read
, 0);
1850 /* "S" indicates a signal frame, such that the return
1851 address must not be decremented to locate the call frame
1852 info for the previous frame; it might even be the first
1853 instruction of a function, so decrementing it would take
1854 us to a different function. */
1855 else if (*augmentation
== 'S')
1857 cie
->signal_frame
= 1;
1861 /* Otherwise we have an unknown augmentation. Assume that either
1862 there is no augmentation data, or we saw a 'z' prefix. */
1865 if (cie
->initial_instructions
)
1866 buf
= cie
->initial_instructions
;
1871 cie
->initial_instructions
= buf
;
1875 add_cie (cie_table
, cie
);
1879 /* This is a FDE. */
1880 struct dwarf2_fde
*fde
;
1882 /* In an .eh_frame section, the CIE pointer is the delta between the
1883 address within the FDE where the CIE pointer is stored and the
1884 address of the CIE. Convert it to an offset into the .eh_frame
1888 cie_pointer
= buf
- unit
->dwarf_frame_buffer
- cie_pointer
;
1889 cie_pointer
-= (dwarf64_p
? 8 : 4);
1892 /* In either case, validate the result is still within the section. */
1893 if (cie_pointer
>= unit
->dwarf_frame_size
)
1896 fde
= (struct dwarf2_fde
*)
1897 obstack_alloc (&unit
->objfile
->objfile_obstack
,
1898 sizeof (struct dwarf2_fde
));
1899 fde
->cie
= find_cie (cie_table
, cie_pointer
);
1900 if (fde
->cie
== NULL
)
1902 decode_frame_entry (unit
, unit
->dwarf_frame_buffer
+ cie_pointer
,
1903 eh_frame_p
, cie_table
, fde_table
);
1904 fde
->cie
= find_cie (cie_table
, cie_pointer
);
1907 gdb_assert (fde
->cie
!= NULL
);
1909 fde
->initial_location
=
1910 read_encoded_value (unit
, fde
->cie
->encoding
, fde
->cie
->addr_size
,
1911 buf
, &bytes_read
, 0);
1914 fde
->address_range
=
1915 read_encoded_value (unit
, fde
->cie
->encoding
& 0x0f,
1916 fde
->cie
->addr_size
, buf
, &bytes_read
, 0);
1919 /* A 'z' augmentation in the CIE implies the presence of an
1920 augmentation field in the FDE as well. The only thing known
1921 to be in here at present is the LSDA entry for EH. So we
1922 can skip the whole thing. */
1923 if (fde
->cie
->saw_z_augmentation
)
1927 length
= read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1928 buf
+= bytes_read
+ length
;
1933 fde
->instructions
= buf
;
1936 fde
->eh_frame_p
= eh_frame_p
;
1938 add_fde (fde_table
, fde
);
1944 /* Read a CIE or FDE in BUF and decode it. */
1946 decode_frame_entry (struct comp_unit
*unit
, gdb_byte
*start
, int eh_frame_p
,
1947 struct dwarf2_cie_table
*cie_table
,
1948 struct dwarf2_fde_table
*fde_table
)
1950 enum { NONE
, ALIGN4
, ALIGN8
, FAIL
} workaround
= NONE
;
1952 ptrdiff_t start_offset
;
1956 ret
= decode_frame_entry_1 (unit
, start
, eh_frame_p
,
1957 cie_table
, fde_table
);
1961 /* We have corrupt input data of some form. */
1963 /* ??? Try, weakly, to work around compiler/assembler/linker bugs
1964 and mismatches wrt padding and alignment of debug sections. */
1965 /* Note that there is no requirement in the standard for any
1966 alignment at all in the frame unwind sections. Testing for
1967 alignment before trying to interpret data would be incorrect.
1969 However, GCC traditionally arranged for frame sections to be
1970 sized such that the FDE length and CIE fields happen to be
1971 aligned (in theory, for performance). This, unfortunately,
1972 was done with .align directives, which had the side effect of
1973 forcing the section to be aligned by the linker.
1975 This becomes a problem when you have some other producer that
1976 creates frame sections that are not as strictly aligned. That
1977 produces a hole in the frame info that gets filled by the
1980 The GCC behaviour is arguably a bug, but it's effectively now
1981 part of the ABI, so we're now stuck with it, at least at the
1982 object file level. A smart linker may decide, in the process
1983 of compressing duplicate CIE information, that it can rewrite
1984 the entire output section without this extra padding. */
1986 start_offset
= start
- unit
->dwarf_frame_buffer
;
1987 if (workaround
< ALIGN4
&& (start_offset
& 3) != 0)
1989 start
+= 4 - (start_offset
& 3);
1990 workaround
= ALIGN4
;
1993 if (workaround
< ALIGN8
&& (start_offset
& 7) != 0)
1995 start
+= 8 - (start_offset
& 7);
1996 workaround
= ALIGN8
;
2000 /* Nothing left to try. Arrange to return as if we've consumed
2001 the entire input section. Hopefully we'll get valid info from
2002 the other of .debug_frame/.eh_frame. */
2004 ret
= unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
;
2014 complaint (&symfile_complaints
,
2015 _("Corrupt data in %s:%s; align 4 workaround apparently succeeded"),
2016 unit
->dwarf_frame_section
->owner
->filename
,
2017 unit
->dwarf_frame_section
->name
);
2021 complaint (&symfile_complaints
,
2022 _("Corrupt data in %s:%s; align 8 workaround apparently succeeded"),
2023 unit
->dwarf_frame_section
->owner
->filename
,
2024 unit
->dwarf_frame_section
->name
);
2028 complaint (&symfile_complaints
,
2029 _("Corrupt data in %s:%s"),
2030 unit
->dwarf_frame_section
->owner
->filename
,
2031 unit
->dwarf_frame_section
->name
);
2039 /* Imported from dwarf2read.c. */
2040 extern void dwarf2_get_section_info (struct objfile
*, const char *, asection
**,
2041 gdb_byte
**, bfd_size_type
*);
2044 qsort_fde_cmp (const void *a
, const void *b
)
2046 struct dwarf2_fde
*aa
= *(struct dwarf2_fde
**)a
;
2047 struct dwarf2_fde
*bb
= *(struct dwarf2_fde
**)b
;
2049 if (aa
->initial_location
== bb
->initial_location
)
2051 if (aa
->address_range
!= bb
->address_range
2052 && aa
->eh_frame_p
== 0 && bb
->eh_frame_p
== 0)
2053 /* Linker bug, e.g. gold/10400.
2054 Work around it by keeping stable sort order. */
2055 return (a
< b
) ? -1 : 1;
2057 /* Put eh_frame entries after debug_frame ones. */
2058 return aa
->eh_frame_p
- bb
->eh_frame_p
;
2061 return (aa
->initial_location
< bb
->initial_location
) ? -1 : 1;
2065 dwarf2_build_frame_info (struct objfile
*objfile
)
2067 struct comp_unit
*unit
;
2068 gdb_byte
*frame_ptr
;
2069 struct dwarf2_cie_table cie_table
;
2070 struct dwarf2_fde_table fde_table
;
2071 struct dwarf2_fde_table
*fde_table2
;
2073 cie_table
.num_entries
= 0;
2074 cie_table
.entries
= NULL
;
2076 fde_table
.num_entries
= 0;
2077 fde_table
.entries
= NULL
;
2079 /* Build a minimal decoding of the DWARF2 compilation unit. */
2080 unit
= (struct comp_unit
*) obstack_alloc (&objfile
->objfile_obstack
,
2081 sizeof (struct comp_unit
));
2082 unit
->abfd
= objfile
->obfd
;
2083 unit
->objfile
= objfile
;
2087 dwarf2_get_section_info (objfile
, ".eh_frame",
2088 &unit
->dwarf_frame_section
,
2089 &unit
->dwarf_frame_buffer
,
2090 &unit
->dwarf_frame_size
);
2091 if (unit
->dwarf_frame_size
)
2093 asection
*got
, *txt
;
2095 /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
2096 that is used for the i386/amd64 target, which currently is
2097 the only target in GCC that supports/uses the
2098 DW_EH_PE_datarel encoding. */
2099 got
= bfd_get_section_by_name (unit
->abfd
, ".got");
2101 unit
->dbase
= got
->vma
;
2103 /* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64
2105 txt
= bfd_get_section_by_name (unit
->abfd
, ".text");
2107 unit
->tbase
= txt
->vma
;
2109 frame_ptr
= unit
->dwarf_frame_buffer
;
2110 while (frame_ptr
< unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
)
2111 frame_ptr
= decode_frame_entry (unit
, frame_ptr
, 1,
2112 &cie_table
, &fde_table
);
2114 if (cie_table
.num_entries
!= 0)
2116 /* Reinit cie_table: debug_frame has different CIEs. */
2117 xfree (cie_table
.entries
);
2118 cie_table
.num_entries
= 0;
2119 cie_table
.entries
= NULL
;
2123 dwarf2_get_section_info (objfile
, ".debug_frame",
2124 &unit
->dwarf_frame_section
,
2125 &unit
->dwarf_frame_buffer
,
2126 &unit
->dwarf_frame_size
);
2127 if (unit
->dwarf_frame_size
)
2129 frame_ptr
= unit
->dwarf_frame_buffer
;
2130 while (frame_ptr
< unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
)
2131 frame_ptr
= decode_frame_entry (unit
, frame_ptr
, 0,
2132 &cie_table
, &fde_table
);
2135 /* Discard the cie_table, it is no longer needed. */
2136 if (cie_table
.num_entries
!= 0)
2138 xfree (cie_table
.entries
);
2139 cie_table
.entries
= NULL
; /* Paranoia. */
2140 cie_table
.num_entries
= 0; /* Paranoia. */
2143 /* Copy fde_table to obstack: it is needed at runtime. */
2144 fde_table2
= (struct dwarf2_fde_table
*)
2145 obstack_alloc (&objfile
->objfile_obstack
, sizeof (*fde_table2
));
2147 if (fde_table
.num_entries
== 0)
2149 fde_table2
->entries
= NULL
;
2150 fde_table2
->num_entries
= 0;
2154 struct dwarf2_fde
*fde_prev
= NULL
;
2155 struct dwarf2_fde
*first_non_zero_fde
= NULL
;
2158 /* Prepare FDE table for lookups. */
2159 qsort (fde_table
.entries
, fde_table
.num_entries
,
2160 sizeof (fde_table
.entries
[0]), qsort_fde_cmp
);
2162 /* Check for leftovers from --gc-sections. The GNU linker sets
2163 the relevant symbols to zero, but doesn't zero the FDE *end*
2164 ranges because there's no relocation there. It's (offset,
2165 length), not (start, end). On targets where address zero is
2166 just another valid address this can be a problem, since the
2167 FDEs appear to be non-empty in the output --- we could pick
2168 out the wrong FDE. To work around this, when overlaps are
2169 detected, we prefer FDEs that do not start at zero.
2171 Start by finding the first FDE with non-zero start. Below
2172 we'll discard all FDEs that start at zero and overlap this
2174 for (i
= 0; i
< fde_table
.num_entries
; i
++)
2176 struct dwarf2_fde
*fde
= fde_table
.entries
[i
];
2178 if (fde
->initial_location
!= 0)
2180 first_non_zero_fde
= fde
;
2185 /* Since we'll be doing bsearch, squeeze out identical (except
2186 for eh_frame_p) fde entries so bsearch result is predictable.
2187 Also discard leftovers from --gc-sections. */
2188 fde_table2
->num_entries
= 0;
2189 for (i
= 0; i
< fde_table
.num_entries
; i
++)
2191 struct dwarf2_fde
*fde
= fde_table
.entries
[i
];
2193 if (fde
->initial_location
== 0
2194 && first_non_zero_fde
!= NULL
2195 && (first_non_zero_fde
->initial_location
2196 < fde
->initial_location
+ fde
->address_range
))
2199 if (fde_prev
!= NULL
2200 && fde_prev
->initial_location
== fde
->initial_location
)
2203 obstack_grow (&objfile
->objfile_obstack
, &fde_table
.entries
[i
],
2204 sizeof (fde_table
.entries
[0]));
2205 ++fde_table2
->num_entries
;
2208 fde_table2
->entries
= obstack_finish (&objfile
->objfile_obstack
);
2210 /* Discard the original fde_table. */
2211 xfree (fde_table
.entries
);
2214 set_objfile_data (objfile
, dwarf2_frame_objfile_data
, fde_table2
);
2217 /* Provide a prototype to silence -Wmissing-prototypes. */
2218 void _initialize_dwarf2_frame (void);
2221 _initialize_dwarf2_frame (void)
2223 dwarf2_frame_data
= gdbarch_data_register_pre_init (dwarf2_frame_init
);
2224 dwarf2_frame_objfile_data
= register_objfile_data ();