1 /* Frame unwinder for frames with DWARF Call Frame Information.
2
3 Copyright 2003, 2004, 2005 Free Software Foundation, Inc.
4
5 Contributed by Mark Kettenis.
6
7 This file is part of GDB.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
23
24 #include "defs.h"
25 #include "dwarf2expr.h"
26 #include "elf/dwarf2.h"
27 #include "frame.h"
28 #include "frame-base.h"
29 #include "frame-unwind.h"
30 #include "gdbcore.h"
31 #include "gdbtypes.h"
32 #include "symtab.h"
33 #include "objfiles.h"
34 #include "regcache.h"
35
36 #include "gdb_assert.h"
37 #include "gdb_string.h"
38
39 #include "complaints.h"
40 #include "dwarf2-frame.h"
41
42 /* Call Frame Information (CFI). */
43
44 /* Common Information Entry (CIE). */
45
46 struct dwarf2_cie
47 {
48 /* Offset into the .debug_frame section where this CIE was found.
49 Used to identify this CIE. */
50 ULONGEST cie_pointer;
51
52 /* Constant that is factored out of all advance location
53 instructions. */
54 ULONGEST code_alignment_factor;
55
56 /* Constants that is factored out of all offset instructions. */
57 LONGEST data_alignment_factor;
58
59 /* Return address column. */
60 ULONGEST return_address_register;
61
62 /* Instruction sequence to initialize a register set. */
63 unsigned char *initial_instructions;
64 unsigned char *end;
65
66 /* Encoding of addresses. */
67 unsigned char encoding;
68
69 /* True if a 'z' augmentation existed. */
70 unsigned char saw_z_augmentation;
71
72 struct dwarf2_cie *next;
73 };
74
75 /* Frame Description Entry (FDE). */
76
77 struct dwarf2_fde
78 {
79 /* CIE for this FDE. */
80 struct dwarf2_cie *cie;
81
82 /* First location associated with this FDE. */
83 CORE_ADDR initial_location;
84
85 /* Number of bytes of program instructions described by this FDE. */
86 CORE_ADDR address_range;
87
88 /* Instruction sequence. */
89 unsigned char *instructions;
90 unsigned char *end;
91
92 struct dwarf2_fde *next;
93 };
94
95 static struct dwarf2_fde *dwarf2_frame_find_fde (CORE_ADDR *pc);
96
97
98 /* Structure describing a frame state. */
99
100 struct dwarf2_frame_state
101 {
102 /* Each register save state can be described in terms of a CFA slot,
103 another register, or a location expression. */
104 struct dwarf2_frame_state_reg_info
105 {
106 struct dwarf2_frame_state_reg *reg;
107 int num_regs;
108
109 /* Used to implement DW_CFA_remember_state. */
110 struct dwarf2_frame_state_reg_info *prev;
111 } regs;
112
113 LONGEST cfa_offset;
114 ULONGEST cfa_reg;
115 unsigned char *cfa_exp;
116 enum {
117 CFA_UNSET,
118 CFA_REG_OFFSET,
119 CFA_EXP
120 } cfa_how;
121
122 /* The PC described by the current frame state. */
123 CORE_ADDR pc;
124
125 /* Initial register set from the CIE.
126 Used to implement DW_CFA_restore. */
127 struct dwarf2_frame_state_reg_info initial;
128
129 /* The information we care about from the CIE. */
130 LONGEST data_align;
131 ULONGEST code_align;
132 ULONGEST retaddr_column;
133 };
134
135 /* Store the length the expression for the CFA in the `cfa_reg' field,
136 which is unused in that case. */
137 #define cfa_exp_len cfa_reg
138
139 /* Assert that the register set RS is large enough to store NUM_REGS
140 columns. If necessary, enlarge the register set. */
141
142 static void
dwarf2_frame_state_alloc_regs(struct dwarf2_frame_state_reg_info * rs,int num_regs)143 dwarf2_frame_state_alloc_regs (struct dwarf2_frame_state_reg_info *rs,
144 int num_regs)
145 {
146 size_t size = sizeof (struct dwarf2_frame_state_reg);
147
148 if (num_regs <= rs->num_regs)
149 return;
150
151 rs->reg = (struct dwarf2_frame_state_reg *)
152 xrealloc (rs->reg, num_regs * size);
153
154 /* Initialize newly allocated registers. */
155 memset (rs->reg + rs->num_regs, 0, (num_regs - rs->num_regs) * size);
156 rs->num_regs = num_regs;
157 }
158
159 /* Copy the register columns in register set RS into newly allocated
160 memory and return a pointer to this newly created copy. */
161
162 static struct dwarf2_frame_state_reg *
dwarf2_frame_state_copy_regs(struct dwarf2_frame_state_reg_info * rs)163 dwarf2_frame_state_copy_regs (struct dwarf2_frame_state_reg_info *rs)
164 {
165 size_t size = rs->num_regs * sizeof (struct dwarf2_frame_state_reg);
166 struct dwarf2_frame_state_reg *reg;
167
168 reg = (struct dwarf2_frame_state_reg *) xmalloc (size);
169 memcpy (reg, rs->reg, size);
170
171 return reg;
172 }
173
174 /* Release the memory allocated to register set RS. */
175
176 static void
dwarf2_frame_state_free_regs(struct dwarf2_frame_state_reg_info * rs)177 dwarf2_frame_state_free_regs (struct dwarf2_frame_state_reg_info *rs)
178 {
179 if (rs)
180 {
181 dwarf2_frame_state_free_regs (rs->prev);
182
183 xfree (rs->reg);
184 xfree (rs);
185 }
186 }
187
188 /* Release the memory allocated to the frame state FS. */
189
190 static void
dwarf2_frame_state_free(void * p)191 dwarf2_frame_state_free (void *p)
192 {
193 struct dwarf2_frame_state *fs = p;
194
195 dwarf2_frame_state_free_regs (fs->initial.prev);
196 dwarf2_frame_state_free_regs (fs->regs.prev);
197 xfree (fs->initial.reg);
198 xfree (fs->regs.reg);
199 xfree (fs);
200 }
201
202
203 /* Helper functions for execute_stack_op. */
204
205 static CORE_ADDR
read_reg(void * baton,int reg)206 read_reg (void *baton, int reg)
207 {
208 struct frame_info *next_frame = (struct frame_info *) baton;
209 struct gdbarch *gdbarch = get_frame_arch (next_frame);
210 int regnum;
211 char *buf;
212
213 regnum = DWARF2_REG_TO_REGNUM (reg);
214
215 buf = (char *) alloca (register_size (gdbarch, regnum));
216 frame_unwind_register (next_frame, regnum, buf);
217 return extract_typed_address (buf, builtin_type_void_data_ptr);
218 }
219
220 static void
read_mem(void * baton,char * buf,CORE_ADDR addr,size_t len)221 read_mem (void *baton, char *buf, CORE_ADDR addr, size_t len)
222 {
223 read_memory (addr, buf, len);
224 }
225
226 static void
no_get_frame_base(void * baton,unsigned char ** start,size_t * length)227 no_get_frame_base (void *baton, unsigned char **start, size_t *length)
228 {
229 internal_error (__FILE__, __LINE__,
230 _("Support for DW_OP_fbreg is unimplemented"));
231 }
232
233 static CORE_ADDR
no_get_tls_address(void * baton,CORE_ADDR offset)234 no_get_tls_address (void *baton, CORE_ADDR offset)
235 {
236 internal_error (__FILE__, __LINE__,
237 _("Support for DW_OP_GNU_push_tls_address is unimplemented"));
238 }
239
240 static CORE_ADDR
execute_stack_op(unsigned char * exp,ULONGEST len,struct frame_info * next_frame,CORE_ADDR initial)241 execute_stack_op (unsigned char *exp, ULONGEST len,
242 struct frame_info *next_frame, CORE_ADDR initial)
243 {
244 struct dwarf_expr_context *ctx;
245 CORE_ADDR result;
246
247 ctx = new_dwarf_expr_context ();
248 ctx->baton = next_frame;
249 ctx->read_reg = read_reg;
250 ctx->read_mem = read_mem;
251 ctx->get_frame_base = no_get_frame_base;
252 ctx->get_tls_address = no_get_tls_address;
253
254 dwarf_expr_push (ctx, initial);
255 dwarf_expr_eval (ctx, exp, len);
256 result = dwarf_expr_fetch (ctx, 0);
257
258 if (ctx->in_reg)
259 result = read_reg (next_frame, result);
260
261 free_dwarf_expr_context (ctx);
262
263 return result;
264 }
265
266
267 static void
execute_cfa_program(unsigned char * insn_ptr,unsigned char * insn_end,struct frame_info * next_frame,struct dwarf2_frame_state * fs)268 execute_cfa_program (unsigned char *insn_ptr, unsigned char *insn_end,
269 struct frame_info *next_frame,
270 struct dwarf2_frame_state *fs)
271 {
272 CORE_ADDR pc = frame_pc_unwind (next_frame);
273 int bytes_read;
274
275 while (insn_ptr < insn_end && fs->pc <= pc)
276 {
277 unsigned char insn = *insn_ptr++;
278 ULONGEST utmp, reg;
279 LONGEST offset;
280
281 if ((insn & 0xc0) == DW_CFA_advance_loc)
282 fs->pc += (insn & 0x3f) * fs->code_align;
283 else if ((insn & 0xc0) == DW_CFA_offset)
284 {
285 reg = insn & 0x3f;
286 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
287 offset = utmp * fs->data_align;
288 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
289 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
290 fs->regs.reg[reg].loc.offset = offset;
291 }
292 else if ((insn & 0xc0) == DW_CFA_restore)
293 {
294 gdb_assert (fs->initial.reg);
295 reg = insn & 0x3f;
296 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
297 fs->regs.reg[reg] = fs->initial.reg[reg];
298 }
299 else
300 {
301 switch (insn)
302 {
303 case DW_CFA_set_loc:
304 fs->pc = dwarf2_read_address (insn_ptr, insn_end, &bytes_read);
305 insn_ptr += bytes_read;
306 break;
307
308 case DW_CFA_advance_loc1:
309 utmp = extract_unsigned_integer (insn_ptr, 1);
310 fs->pc += utmp * fs->code_align;
311 insn_ptr++;
312 break;
313 case DW_CFA_advance_loc2:
314 utmp = extract_unsigned_integer (insn_ptr, 2);
315 fs->pc += utmp * fs->code_align;
316 insn_ptr += 2;
317 break;
318 case DW_CFA_advance_loc4:
319 utmp = extract_unsigned_integer (insn_ptr, 4);
320 fs->pc += utmp * fs->code_align;
321 insn_ptr += 4;
322 break;
323
324 case DW_CFA_offset_extended:
325 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
326 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
327 offset = utmp * fs->data_align;
328 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
329 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
330 fs->regs.reg[reg].loc.offset = offset;
331 break;
332
333 case DW_CFA_restore_extended:
334 gdb_assert (fs->initial.reg);
335 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
336 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
337 fs->regs.reg[reg] = fs->initial.reg[reg];
338 break;
339
340 case DW_CFA_undefined:
341 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
342 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
343 fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNDEFINED;
344 break;
345
346 case DW_CFA_same_value:
347 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
348 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
349 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAME_VALUE;
350 break;
351
352 case DW_CFA_register:
353 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
354 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
355 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
356 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
357 fs->regs.reg[reg].loc.reg = utmp;
358 break;
359
360 case DW_CFA_remember_state:
361 {
362 struct dwarf2_frame_state_reg_info *new_rs;
363
364 new_rs = XMALLOC (struct dwarf2_frame_state_reg_info);
365 *new_rs = fs->regs;
366 fs->regs.reg = dwarf2_frame_state_copy_regs (&fs->regs);
367 fs->regs.prev = new_rs;
368 }
369 break;
370
371 case DW_CFA_restore_state:
372 {
373 struct dwarf2_frame_state_reg_info *old_rs = fs->regs.prev;
374
375 if (old_rs == NULL)
376 {
377 complaint (&symfile_complaints, _("\
378 bad CFI data; mismatched DW_CFA_restore_state at 0x%s"), paddr (fs->pc));
379 }
380 else
381 {
382 xfree (fs->regs.reg);
383 fs->regs = *old_rs;
384 xfree (old_rs);
385 }
386 }
387 break;
388
389 case DW_CFA_def_cfa:
390 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_reg);
391 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
392 fs->cfa_offset = utmp;
393 fs->cfa_how = CFA_REG_OFFSET;
394 break;
395
396 case DW_CFA_def_cfa_register:
397 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_reg);
398 fs->cfa_how = CFA_REG_OFFSET;
399 break;
400
401 case DW_CFA_def_cfa_offset:
402 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_offset);
403 /* cfa_how deliberately not set. */
404 break;
405
406 case DW_CFA_nop:
407 break;
408
409 case DW_CFA_def_cfa_expression:
410 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_exp_len);
411 fs->cfa_exp = insn_ptr;
412 fs->cfa_how = CFA_EXP;
413 insn_ptr += fs->cfa_exp_len;
414 break;
415
416 case DW_CFA_expression:
417 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
418 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
419 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
420 fs->regs.reg[reg].loc.exp = insn_ptr;
421 fs->regs.reg[reg].exp_len = utmp;
422 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_EXP;
423 insn_ptr += utmp;
424 break;
425
426 case DW_CFA_offset_extended_sf:
427 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
428 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
429 offset *= fs->data_align;
430 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
431 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
432 fs->regs.reg[reg].loc.offset = offset;
433 break;
434
435 case DW_CFA_def_cfa_sf:
436 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_reg);
437 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
438 fs->cfa_offset = offset * fs->data_align;
439 fs->cfa_how = CFA_REG_OFFSET;
440 break;
441
442 case DW_CFA_def_cfa_offset_sf:
443 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
444 fs->cfa_offset = offset * fs->data_align;
445 /* cfa_how deliberately not set. */
446 break;
447
448 case DW_CFA_GNU_window_save:
449 /* This is SPARC-specific code, and contains hard-coded
450 constants for the register numbering scheme used by
451 GCC. Rather than having a architecture-specific
452 operation that's only ever used by a single
453 architecture, we provide the implementation here.
454 Incidentally that's what GCC does too in its
455 unwinder. */
456 {
457 struct gdbarch *gdbarch = get_frame_arch (next_frame);
458 int size = register_size(gdbarch, 0);
459 dwarf2_frame_state_alloc_regs (&fs->regs, 32);
460 for (reg = 8; reg < 16; reg++)
461 {
462 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
463 fs->regs.reg[reg].loc.reg = reg + 16;
464 }
465 for (reg = 16; reg < 32; reg++)
466 {
467 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
468 fs->regs.reg[reg].loc.offset = (reg - 16) * size;
469 }
470 }
471 break;
472
473 case DW_CFA_GNU_args_size:
474 /* Ignored. */
475 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
476 break;
477
478 default:
479 internal_error (__FILE__, __LINE__, _("Unknown CFI encountered."));
480 }
481 }
482 }
483
484 /* Don't allow remember/restore between CIE and FDE programs. */
485 dwarf2_frame_state_free_regs (fs->regs.prev);
486 fs->regs.prev = NULL;
487 }
488
489
490 /* Architecture-specific operations. */
491
492 /* Per-architecture data key. */
493 static struct gdbarch_data *dwarf2_frame_data;
494
495 struct dwarf2_frame_ops
496 {
497 /* Pre-initialize the register state REG for register REGNUM. */
498 void (*init_reg) (struct gdbarch *, int, struct dwarf2_frame_state_reg *);
499
500 /* Check whether the frame preceding NEXT_FRAME will be a signal
501 trampoline. */
502 int (*signal_frame_p) (struct gdbarch *, struct frame_info *);
503 };
504
505 /* Default architecture-specific register state initialization
506 function. */
507
508 static void
dwarf2_frame_default_init_reg(struct gdbarch * gdbarch,int regnum,struct dwarf2_frame_state_reg * reg)509 dwarf2_frame_default_init_reg (struct gdbarch *gdbarch, int regnum,
510 struct dwarf2_frame_state_reg *reg)
511 {
512 /* If we have a register that acts as a program counter, mark it as
513 a destination for the return address. If we have a register that
514 serves as the stack pointer, arrange for it to be filled with the
515 call frame address (CFA). The other registers are marked as
516 unspecified.
517
518 We copy the return address to the program counter, since many
519 parts in GDB assume that it is possible to get the return address
520 by unwinding the program counter register. However, on ISA's
521 with a dedicated return address register, the CFI usually only
522 contains information to unwind that return address register.
523
524 The reason we're treating the stack pointer special here is
525 because in many cases GCC doesn't emit CFI for the stack pointer
526 and implicitly assumes that it is equal to the CFA. This makes
527 some sense since the DWARF specification (version 3, draft 8,
528 p. 102) says that:
529
530 "Typically, the CFA is defined to be the value of the stack
531 pointer at the call site in the previous frame (which may be
532 different from its value on entry to the current frame)."
533
534 However, this isn't true for all platforms supported by GCC
535 (e.g. IBM S/390 and zSeries). Those architectures should provide
536 their own architecture-specific initialization function. */
537
538 if (regnum == PC_REGNUM)
539 reg->how = DWARF2_FRAME_REG_RA;
540 else if (regnum == SP_REGNUM)
541 reg->how = DWARF2_FRAME_REG_CFA;
542 }
543
544 /* Return a default for the architecture-specific operations. */
545
546 static void *
dwarf2_frame_init(struct obstack * obstack)547 dwarf2_frame_init (struct obstack *obstack)
548 {
549 struct dwarf2_frame_ops *ops;
550
551 ops = OBSTACK_ZALLOC (obstack, struct dwarf2_frame_ops);
552 ops->init_reg = dwarf2_frame_default_init_reg;
553 return ops;
554 }
555
556 /* Set the architecture-specific register state initialization
557 function for GDBARCH to INIT_REG. */
558
559 void
dwarf2_frame_set_init_reg(struct gdbarch * gdbarch,void (* init_reg)(struct gdbarch *,int,struct dwarf2_frame_state_reg *))560 dwarf2_frame_set_init_reg (struct gdbarch *gdbarch,
561 void (*init_reg) (struct gdbarch *, int,
562 struct dwarf2_frame_state_reg *))
563 {
564 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
565
566 ops->init_reg = init_reg;
567 }
568
569 /* Pre-initialize the register state REG for register REGNUM. */
570
571 static void
dwarf2_frame_init_reg(struct gdbarch * gdbarch,int regnum,struct dwarf2_frame_state_reg * reg)572 dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
573 struct dwarf2_frame_state_reg *reg)
574 {
575 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
576
577 ops->init_reg (gdbarch, regnum, reg);
578 }
579
580 /* Set the architecture-specific signal trampoline recognition
581 function for GDBARCH to SIGNAL_FRAME_P. */
582
583 void
dwarf2_frame_set_signal_frame_p(struct gdbarch * gdbarch,int (* signal_frame_p)(struct gdbarch *,struct frame_info *))584 dwarf2_frame_set_signal_frame_p (struct gdbarch *gdbarch,
585 int (*signal_frame_p) (struct gdbarch *,
586 struct frame_info *))
587 {
588 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
589
590 ops->signal_frame_p = signal_frame_p;
591 }
592
593 /* Query the architecture-specific signal frame recognizer for
594 NEXT_FRAME. */
595
596 static int
dwarf2_frame_signal_frame_p(struct gdbarch * gdbarch,struct frame_info * next_frame)597 dwarf2_frame_signal_frame_p (struct gdbarch *gdbarch,
598 struct frame_info *next_frame)
599 {
600 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
601
602 if (ops->signal_frame_p == NULL)
603 return 0;
604 return ops->signal_frame_p (gdbarch, next_frame);
605 }
606
607
608 struct dwarf2_frame_cache
609 {
610 /* DWARF Call Frame Address. */
611 CORE_ADDR cfa;
612
613 /* Set if the return address column was marked as undefined. */
614 int undefined_retaddr;
615
616 /* Saved registers, indexed by GDB register number, not by DWARF
617 register number. */
618 struct dwarf2_frame_state_reg *reg;
619
620 /* Return address register. */
621 struct dwarf2_frame_state_reg retaddr_reg;
622 };
623
624 static struct dwarf2_frame_cache *
dwarf2_frame_cache(struct frame_info * next_frame,void ** this_cache)625 dwarf2_frame_cache (struct frame_info *next_frame, void **this_cache)
626 {
627 struct cleanup *old_chain;
628 struct gdbarch *gdbarch = get_frame_arch (next_frame);
629 const int num_regs = NUM_REGS + NUM_PSEUDO_REGS;
630 struct dwarf2_frame_cache *cache;
631 struct dwarf2_frame_state *fs;
632 struct dwarf2_fde *fde;
633
634 if (*this_cache)
635 return *this_cache;
636
637 /* Allocate a new cache. */
638 cache = FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache);
639 cache->reg = FRAME_OBSTACK_CALLOC (num_regs, struct dwarf2_frame_state_reg);
640
641 /* Allocate and initialize the frame state. */
642 fs = XMALLOC (struct dwarf2_frame_state);
643 memset (fs, 0, sizeof (struct dwarf2_frame_state));
644 old_chain = make_cleanup (dwarf2_frame_state_free, fs);
645
646 /* Unwind the PC.
647
648 Note that if NEXT_FRAME is never supposed to return (i.e. a call
649 to abort), the compiler might optimize away the instruction at
650 NEXT_FRAME's return address. As a result the return address will
651 point at some random instruction, and the CFI for that
652 instruction is probably worthless to us. GCC's unwinder solves
653 this problem by substracting 1 from the return address to get an
654 address in the middle of a presumed call instruction (or the
655 instruction in the associated delay slot). This should only be
656 done for "normal" frames and not for resume-type frames (signal
657 handlers, sentinel frames, dummy frames). The function
658 frame_unwind_address_in_block does just this. It's not clear how
659 reliable the method is though; there is the potential for the
660 register state pre-call being different to that on return. */
661 fs->pc = frame_unwind_address_in_block (next_frame);
662
663 /* Find the correct FDE. */
664 fde = dwarf2_frame_find_fde (&fs->pc);
665 gdb_assert (fde != NULL);
666
667 /* Extract any interesting information from the CIE. */
668 fs->data_align = fde->cie->data_alignment_factor;
669 fs->code_align = fde->cie->code_alignment_factor;
670 fs->retaddr_column = fde->cie->return_address_register;
671
672 /* First decode all the insns in the CIE. */
673 execute_cfa_program (fde->cie->initial_instructions,
674 fde->cie->end, next_frame, fs);
675
676 /* Save the initialized register set. */
677 fs->initial = fs->regs;
678 fs->initial.reg = dwarf2_frame_state_copy_regs (&fs->regs);
679
680 /* Then decode the insns in the FDE up to our target PC. */
681 execute_cfa_program (fde->instructions, fde->end, next_frame, fs);
682
683 /* Caclulate the CFA. */
684 switch (fs->cfa_how)
685 {
686 case CFA_REG_OFFSET:
687 cache->cfa = read_reg (next_frame, fs->cfa_reg);
688 cache->cfa += fs->cfa_offset;
689 break;
690
691 case CFA_EXP:
692 cache->cfa =
693 execute_stack_op (fs->cfa_exp, fs->cfa_exp_len, next_frame, 0);
694 break;
695
696 default:
697 internal_error (__FILE__, __LINE__, _("Unknown CFA rule."));
698 }
699
700 /* Initialize the register state. */
701 {
702 int regnum;
703
704 for (regnum = 0; regnum < num_regs; regnum++)
705 dwarf2_frame_init_reg (gdbarch, regnum, &cache->reg[regnum]);
706 }
707
708 /* Go through the DWARF2 CFI generated table and save its register
709 location information in the cache. Note that we don't skip the
710 return address column; it's perfectly all right for it to
711 correspond to a real register. If it doesn't correspond to a
712 real register, or if we shouldn't treat it as such,
713 DWARF2_REG_TO_REGNUM should be defined to return a number outside
714 the range [0, NUM_REGS). */
715 {
716 int column; /* CFI speak for "register number". */
717
718 for (column = 0; column < fs->regs.num_regs; column++)
719 {
720 /* Use the GDB register number as the destination index. */
721 int regnum = DWARF2_REG_TO_REGNUM (column);
722
723 /* If there's no corresponding GDB register, ignore it. */
724 if (regnum < 0 || regnum >= num_regs)
725 continue;
726
727 /* NOTE: cagney/2003-09-05: CFI should specify the disposition
728 of all debug info registers. If it doesn't, complain (but
729 not too loudly). It turns out that GCC assumes that an
730 unspecified register implies "same value" when CFI (draft
731 7) specifies nothing at all. Such a register could equally
732 be interpreted as "undefined". Also note that this check
733 isn't sufficient; it only checks that all registers in the
734 range [0 .. max column] are specified, and won't detect
735 problems when a debug info register falls outside of the
736 table. We need a way of iterating through all the valid
737 DWARF2 register numbers. */
738 if (fs->regs.reg[column].how == DWARF2_FRAME_REG_UNSPECIFIED)
739 {
740 if (cache->reg[regnum].how == DWARF2_FRAME_REG_UNSPECIFIED)
741 complaint (&symfile_complaints, _("\
742 incomplete CFI data; unspecified registers (e.g., %s) at 0x%s"),
743 gdbarch_register_name (gdbarch, regnum),
744 paddr_nz (fs->pc));
745 }
746 else
747 cache->reg[regnum] = fs->regs.reg[column];
748 }
749 }
750
751 /* Eliminate any DWARF2_FRAME_REG_RA rules, and save the information
752 we need for evaluating DWARF2_FRAME_REG_RA_OFFSET rules. */
753 {
754 int regnum;
755
756 for (regnum = 0; regnum < num_regs; regnum++)
757 {
758 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA
759 || cache->reg[regnum].how == DWARF2_FRAME_REG_RA_OFFSET)
760 {
761 struct dwarf2_frame_state_reg *retaddr_reg =
762 &fs->regs.reg[fs->retaddr_column];
763
764 /* It seems rather bizarre to specify an "empty" column as
765 the return adress column. However, this is exactly
766 what GCC does on some targets. It turns out that GCC
767 assumes that the return address can be found in the
768 register corresponding to the return address column.
769 Incidentally, that's how we should treat a return
770 address column specifying "same value" too. */
771 if (fs->retaddr_column < fs->regs.num_regs
772 && retaddr_reg->how != DWARF2_FRAME_REG_UNSPECIFIED
773 && retaddr_reg->how != DWARF2_FRAME_REG_SAME_VALUE)
774 {
775 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
776 cache->reg[regnum] = *retaddr_reg;
777 else
778 cache->retaddr_reg = *retaddr_reg;
779 }
780 else
781 {
782 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
783 {
784 cache->reg[regnum].loc.reg = fs->retaddr_column;
785 cache->reg[regnum].how = DWARF2_FRAME_REG_SAVED_REG;
786 }
787 else
788 {
789 cache->retaddr_reg.loc.reg = fs->retaddr_column;
790 cache->retaddr_reg.how = DWARF2_FRAME_REG_SAVED_REG;
791 }
792 }
793 }
794 }
795 }
796
797 if (fs->retaddr_column < fs->regs.num_regs
798 && fs->regs.reg[fs->retaddr_column].how == DWARF2_FRAME_REG_UNDEFINED)
799 cache->undefined_retaddr = 1;
800
801 do_cleanups (old_chain);
802
803 *this_cache = cache;
804 return cache;
805 }
806
807 static void
dwarf2_frame_this_id(struct frame_info * next_frame,void ** this_cache,struct frame_id * this_id)808 dwarf2_frame_this_id (struct frame_info *next_frame, void **this_cache,
809 struct frame_id *this_id)
810 {
811 struct dwarf2_frame_cache *cache =
812 dwarf2_frame_cache (next_frame, this_cache);
813
814 if (cache->undefined_retaddr)
815 return;
816
817 (*this_id) = frame_id_build (cache->cfa, frame_func_unwind (next_frame));
818 }
819
820 static void
dwarf2_frame_prev_register(struct frame_info * next_frame,void ** this_cache,int regnum,int * optimizedp,enum lval_type * lvalp,CORE_ADDR * addrp,int * realnump,gdb_byte * valuep)821 dwarf2_frame_prev_register (struct frame_info *next_frame, void **this_cache,
822 int regnum, int *optimizedp,
823 enum lval_type *lvalp, CORE_ADDR *addrp,
824 int *realnump, gdb_byte *valuep)
825 {
826 struct gdbarch *gdbarch = get_frame_arch (next_frame);
827 struct dwarf2_frame_cache *cache =
828 dwarf2_frame_cache (next_frame, this_cache);
829
830 switch (cache->reg[regnum].how)
831 {
832 case DWARF2_FRAME_REG_UNDEFINED:
833 /* If CFI explicitly specified that the value isn't defined,
834 mark it as optimized away; the value isn't available. */
835 *optimizedp = 1;
836 *lvalp = not_lval;
837 *addrp = 0;
838 *realnump = -1;
839 if (valuep)
840 {
841 /* In some cases, for example %eflags on the i386, we have
842 to provide a sane value, even though this register wasn't
843 saved. Assume we can get it from NEXT_FRAME. */
844 frame_unwind_register (next_frame, regnum, valuep);
845 }
846 break;
847
848 case DWARF2_FRAME_REG_SAVED_OFFSET:
849 *optimizedp = 0;
850 *lvalp = lval_memory;
851 *addrp = cache->cfa + cache->reg[regnum].loc.offset;
852 *realnump = -1;
853 if (valuep)
854 {
855 /* Read the value in from memory. */
856 read_memory (*addrp, valuep, register_size (gdbarch, regnum));
857 }
858 break;
859
860 case DWARF2_FRAME_REG_SAVED_REG:
861 *optimizedp = 0;
862 *lvalp = lval_register;
863 *addrp = 0;
864 *realnump = DWARF2_REG_TO_REGNUM (cache->reg[regnum].loc.reg);
865 if (valuep)
866 frame_unwind_register (next_frame, (*realnump), valuep);
867 break;
868
869 case DWARF2_FRAME_REG_SAVED_EXP:
870 *optimizedp = 0;
871 *lvalp = lval_memory;
872 *addrp = execute_stack_op (cache->reg[regnum].loc.exp,
873 cache->reg[regnum].exp_len,
874 next_frame, cache->cfa);
875 *realnump = -1;
876 if (valuep)
877 {
878 /* Read the value in from memory. */
879 read_memory (*addrp, valuep, register_size (gdbarch, regnum));
880 }
881 break;
882
883 case DWARF2_FRAME_REG_UNSPECIFIED:
884 /* GCC, in its infinite wisdom decided to not provide unwind
885 information for registers that are "same value". Since
886 DWARF2 (3 draft 7) doesn't define such behavior, said
887 registers are actually undefined (which is different to CFI
888 "undefined"). Code above issues a complaint about this.
889 Here just fudge the books, assume GCC, and that the value is
890 more inner on the stack. */
891 *optimizedp = 0;
892 *lvalp = lval_register;
893 *addrp = 0;
894 *realnump = regnum;
895 if (valuep)
896 frame_unwind_register (next_frame, (*realnump), valuep);
897 break;
898
899 case DWARF2_FRAME_REG_SAME_VALUE:
900 *optimizedp = 0;
901 *lvalp = lval_register;
902 *addrp = 0;
903 *realnump = regnum;
904 if (valuep)
905 frame_unwind_register (next_frame, (*realnump), valuep);
906 break;
907
908 case DWARF2_FRAME_REG_CFA:
909 *optimizedp = 0;
910 *lvalp = not_lval;
911 *addrp = 0;
912 *realnump = -1;
913 if (valuep)
914 {
915 /* Store the value. */
916 store_typed_address (valuep, builtin_type_void_data_ptr, cache->cfa);
917 }
918 break;
919
920 case DWARF2_FRAME_REG_RA_OFFSET:
921 *optimizedp = 0;
922 *lvalp = not_lval;
923 *addrp = 0;
924 *realnump = -1;
925 if (valuep)
926 {
927 CORE_ADDR pc = cache->reg[regnum].loc.offset;
928
929 regnum = DWARF2_REG_TO_REGNUM (cache->retaddr_reg.loc.reg);
930 pc += frame_unwind_register_unsigned (next_frame, regnum);
931 store_typed_address (valuep, builtin_type_void_func_ptr, pc);
932 }
933 break;
934
935 default:
936 internal_error (__FILE__, __LINE__, _("Unknown register rule."));
937 }
938 }
939
940 static const struct frame_unwind dwarf2_frame_unwind =
941 {
942 NORMAL_FRAME,
943 dwarf2_frame_this_id,
944 dwarf2_frame_prev_register
945 };
946
947 static const struct frame_unwind dwarf2_signal_frame_unwind =
948 {
949 SIGTRAMP_FRAME,
950 dwarf2_frame_this_id,
951 dwarf2_frame_prev_register
952 };
953
954 const struct frame_unwind *
dwarf2_frame_sniffer(struct frame_info * next_frame)955 dwarf2_frame_sniffer (struct frame_info *next_frame)
956 {
957 /* Grab an address that is guarenteed to reside somewhere within the
958 function. frame_pc_unwind(), for a no-return next function, can
959 end up returning something past the end of this function's body. */
960 CORE_ADDR block_addr = frame_unwind_address_in_block (next_frame);
961 if (!dwarf2_frame_find_fde (&block_addr))
962 return NULL;
963
964 /* On some targets, signal trampolines may have unwind information.
965 We need to recognize them so that we set the frame type
966 correctly. */
967
968 if (dwarf2_frame_signal_frame_p (get_frame_arch (next_frame),
969 next_frame))
970 return &dwarf2_signal_frame_unwind;
971
972 return &dwarf2_frame_unwind;
973 }
974
975
976 /* There is no explicitly defined relationship between the CFA and the
977 location of frame's local variables and arguments/parameters.
978 Therefore, frame base methods on this page should probably only be
979 used as a last resort, just to avoid printing total garbage as a
980 response to the "info frame" command. */
981
982 static CORE_ADDR
dwarf2_frame_base_address(struct frame_info * next_frame,void ** this_cache)983 dwarf2_frame_base_address (struct frame_info *next_frame, void **this_cache)
984 {
985 struct dwarf2_frame_cache *cache =
986 dwarf2_frame_cache (next_frame, this_cache);
987
988 return cache->cfa;
989 }
990
991 static const struct frame_base dwarf2_frame_base =
992 {
993 &dwarf2_frame_unwind,
994 dwarf2_frame_base_address,
995 dwarf2_frame_base_address,
996 dwarf2_frame_base_address
997 };
998
999 const struct frame_base *
dwarf2_frame_base_sniffer(struct frame_info * next_frame)1000 dwarf2_frame_base_sniffer (struct frame_info *next_frame)
1001 {
1002 CORE_ADDR pc = frame_pc_unwind (next_frame);
1003 if (dwarf2_frame_find_fde (&pc))
1004 return &dwarf2_frame_base;
1005
1006 return NULL;
1007 }
1008
1009 /* A minimal decoding of DWARF2 compilation units. We only decode
1010 what's needed to get to the call frame information. */
1011
1012 struct comp_unit
1013 {
1014 /* Keep the bfd convenient. */
1015 bfd *abfd;
1016
1017 struct objfile *objfile;
1018
1019 /* Linked list of CIEs for this object. */
1020 struct dwarf2_cie *cie;
1021
1022 /* Pointer to the .debug_frame section loaded into memory. */
1023 char *dwarf_frame_buffer;
1024
1025 /* Length of the loaded .debug_frame section. */
1026 unsigned long dwarf_frame_size;
1027
1028 /* Pointer to the .debug_frame section. */
1029 asection *dwarf_frame_section;
1030
1031 /* Base for DW_EH_PE_datarel encodings. */
1032 bfd_vma dbase;
1033
1034 /* Base for DW_EH_PE_textrel encodings. */
1035 bfd_vma tbase;
1036 };
1037
1038 const struct objfile_data *dwarf2_frame_objfile_data;
1039
1040 static unsigned int
read_1_byte(bfd * bfd,char * buf)1041 read_1_byte (bfd *bfd, char *buf)
1042 {
1043 return bfd_get_8 (abfd, (bfd_byte *) buf);
1044 }
1045
1046 static unsigned int
read_4_bytes(bfd * abfd,char * buf)1047 read_4_bytes (bfd *abfd, char *buf)
1048 {
1049 return bfd_get_32 (abfd, (bfd_byte *) buf);
1050 }
1051
1052 static ULONGEST
read_8_bytes(bfd * abfd,char * buf)1053 read_8_bytes (bfd *abfd, char *buf)
1054 {
1055 return bfd_get_64 (abfd, (bfd_byte *) buf);
1056 }
1057
1058 static ULONGEST
read_unsigned_leb128(bfd * abfd,char * buf,unsigned int * bytes_read_ptr)1059 read_unsigned_leb128 (bfd *abfd, char *buf, unsigned int *bytes_read_ptr)
1060 {
1061 ULONGEST result;
1062 unsigned int num_read;
1063 int shift;
1064 unsigned char byte;
1065
1066 result = 0;
1067 shift = 0;
1068 num_read = 0;
1069
1070 do
1071 {
1072 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
1073 buf++;
1074 num_read++;
1075 result |= ((byte & 0x7f) << shift);
1076 shift += 7;
1077 }
1078 while (byte & 0x80);
1079
1080 *bytes_read_ptr = num_read;
1081
1082 return result;
1083 }
1084
1085 static LONGEST
read_signed_leb128(bfd * abfd,char * buf,unsigned int * bytes_read_ptr)1086 read_signed_leb128 (bfd *abfd, char *buf, unsigned int *bytes_read_ptr)
1087 {
1088 LONGEST result;
1089 int shift;
1090 unsigned int num_read;
1091 unsigned char byte;
1092
1093 result = 0;
1094 shift = 0;
1095 num_read = 0;
1096
1097 do
1098 {
1099 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
1100 buf++;
1101 num_read++;
1102 result |= ((byte & 0x7f) << shift);
1103 shift += 7;
1104 }
1105 while (byte & 0x80);
1106
1107 if ((shift < 32) && (byte & 0x40))
1108 result |= -(1 << shift);
1109
1110 *bytes_read_ptr = num_read;
1111
1112 return result;
1113 }
1114
1115 static ULONGEST
read_initial_length(bfd * abfd,char * buf,unsigned int * bytes_read_ptr)1116 read_initial_length (bfd *abfd, char *buf, unsigned int *bytes_read_ptr)
1117 {
1118 LONGEST result;
1119
1120 result = bfd_get_32 (abfd, (bfd_byte *) buf);
1121 if (result == 0xffffffff)
1122 {
1123 result = bfd_get_64 (abfd, (bfd_byte *) buf + 4);
1124 *bytes_read_ptr = 12;
1125 }
1126 else
1127 *bytes_read_ptr = 4;
1128
1129 return result;
1130 }
1131
1132
1133 /* Pointer encoding helper functions. */
1134
1135 /* GCC supports exception handling based on DWARF2 CFI. However, for
1136 technical reasons, it encodes addresses in its FDE's in a different
1137 way. Several "pointer encodings" are supported. The encoding
1138 that's used for a particular FDE is determined by the 'R'
1139 augmentation in the associated CIE. The argument of this
1140 augmentation is a single byte.
1141
1142 The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a
1143 LEB128. This is encoded in bits 0, 1 and 2. Bit 3 encodes whether
1144 the address is signed or unsigned. Bits 4, 5 and 6 encode how the
1145 address should be interpreted (absolute, relative to the current
1146 position in the FDE, ...). Bit 7, indicates that the address
1147 should be dereferenced. */
1148
1149 static unsigned char
encoding_for_size(unsigned int size)1150 encoding_for_size (unsigned int size)
1151 {
1152 switch (size)
1153 {
1154 case 2:
1155 return DW_EH_PE_udata2;
1156 case 4:
1157 return DW_EH_PE_udata4;
1158 case 8:
1159 return DW_EH_PE_udata8;
1160 default:
1161 internal_error (__FILE__, __LINE__, _("Unsupported address size"));
1162 }
1163 }
1164
1165 static unsigned int
size_of_encoded_value(unsigned char encoding)1166 size_of_encoded_value (unsigned char encoding)
1167 {
1168 if (encoding == DW_EH_PE_omit)
1169 return 0;
1170
1171 switch (encoding & 0x07)
1172 {
1173 case DW_EH_PE_absptr:
1174 return TYPE_LENGTH (builtin_type_void_data_ptr);
1175 case DW_EH_PE_udata2:
1176 return 2;
1177 case DW_EH_PE_udata4:
1178 return 4;
1179 case DW_EH_PE_udata8:
1180 return 8;
1181 default:
1182 internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
1183 }
1184 }
1185
1186 static CORE_ADDR
read_encoded_value(struct comp_unit * unit,unsigned char encoding,unsigned char * buf,unsigned int * bytes_read_ptr)1187 read_encoded_value (struct comp_unit *unit, unsigned char encoding,
1188 unsigned char *buf, unsigned int *bytes_read_ptr)
1189 {
1190 int ptr_len = size_of_encoded_value (DW_EH_PE_absptr);
1191 ptrdiff_t offset;
1192 CORE_ADDR base;
1193
1194 /* GCC currently doesn't generate DW_EH_PE_indirect encodings for
1195 FDE's. */
1196 if (encoding & DW_EH_PE_indirect)
1197 internal_error (__FILE__, __LINE__,
1198 _("Unsupported encoding: DW_EH_PE_indirect"));
1199
1200 *bytes_read_ptr = 0;
1201
1202 switch (encoding & 0x70)
1203 {
1204 case DW_EH_PE_absptr:
1205 base = 0;
1206 break;
1207 case DW_EH_PE_pcrel:
1208 base = bfd_get_section_vma (unit->bfd, unit->dwarf_frame_section);
1209 base += ((char *) buf - unit->dwarf_frame_buffer);
1210 break;
1211 case DW_EH_PE_datarel:
1212 base = unit->dbase;
1213 break;
1214 case DW_EH_PE_textrel:
1215 base = unit->tbase;
1216 break;
1217 case DW_EH_PE_funcrel:
1218 /* FIXME: kettenis/20040501: For now just pretend
1219 DW_EH_PE_funcrel is equivalent to DW_EH_PE_absptr. For
1220 reading the initial location of an FDE it should be treated
1221 as such, and currently that's the only place where this code
1222 is used. */
1223 base = 0;
1224 break;
1225 case DW_EH_PE_aligned:
1226 base = 0;
1227 offset = (char *) buf - unit->dwarf_frame_buffer;
1228 if ((offset % ptr_len) != 0)
1229 {
1230 *bytes_read_ptr = ptr_len - (offset % ptr_len);
1231 buf += *bytes_read_ptr;
1232 }
1233 break;
1234 default:
1235 internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
1236 }
1237
1238 if ((encoding & 0x07) == 0x00)
1239 encoding |= encoding_for_size (ptr_len);
1240
1241 switch (encoding & 0x0f)
1242 {
1243 case DW_EH_PE_uleb128:
1244 {
1245 ULONGEST value;
1246 unsigned char *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1247 *bytes_read_ptr += read_uleb128 (buf, end_buf, &value) - buf;
1248 return base + value;
1249 }
1250 case DW_EH_PE_udata2:
1251 *bytes_read_ptr += 2;
1252 return (base + bfd_get_16 (unit->abfd, (bfd_byte *) buf));
1253 case DW_EH_PE_udata4:
1254 *bytes_read_ptr += 4;
1255 return (base + bfd_get_32 (unit->abfd, (bfd_byte *) buf));
1256 case DW_EH_PE_udata8:
1257 *bytes_read_ptr += 8;
1258 return (base + bfd_get_64 (unit->abfd, (bfd_byte *) buf));
1259 case DW_EH_PE_sleb128:
1260 {
1261 LONGEST value;
1262 char *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1263 *bytes_read_ptr += read_sleb128 (buf, end_buf, &value) - buf;
1264 return base + value;
1265 }
1266 case DW_EH_PE_sdata2:
1267 *bytes_read_ptr += 2;
1268 return (base + bfd_get_signed_16 (unit->abfd, (bfd_byte *) buf));
1269 case DW_EH_PE_sdata4:
1270 *bytes_read_ptr += 4;
1271 return (base + bfd_get_signed_32 (unit->abfd, (bfd_byte *) buf));
1272 case DW_EH_PE_sdata8:
1273 *bytes_read_ptr += 8;
1274 return (base + bfd_get_signed_64 (unit->abfd, (bfd_byte *) buf));
1275 default:
1276 internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
1277 }
1278 }
1279
1280
1281 /* GCC uses a single CIE for all FDEs in a .debug_frame section.
1282 That's why we use a simple linked list here. */
1283
1284 static struct dwarf2_cie *
find_cie(struct comp_unit * unit,ULONGEST cie_pointer)1285 find_cie (struct comp_unit *unit, ULONGEST cie_pointer)
1286 {
1287 struct dwarf2_cie *cie = unit->cie;
1288
1289 while (cie)
1290 {
1291 if (cie->cie_pointer == cie_pointer)
1292 return cie;
1293
1294 cie = cie->next;
1295 }
1296
1297 return NULL;
1298 }
1299
1300 static void
add_cie(struct comp_unit * unit,struct dwarf2_cie * cie)1301 add_cie (struct comp_unit *unit, struct dwarf2_cie *cie)
1302 {
1303 cie->next = unit->cie;
1304 unit->cie = cie;
1305 }
1306
1307 /* Find the FDE for *PC. Return a pointer to the FDE, and store the
1308 inital location associated with it into *PC. */
1309
1310 static struct dwarf2_fde *
dwarf2_frame_find_fde(CORE_ADDR * pc)1311 dwarf2_frame_find_fde (CORE_ADDR *pc)
1312 {
1313 struct objfile *objfile;
1314
1315 ALL_OBJFILES (objfile)
1316 {
1317 struct dwarf2_fde *fde;
1318 CORE_ADDR offset;
1319
1320 fde = objfile_data (objfile, dwarf2_frame_objfile_data);
1321 if (fde == NULL)
1322 continue;
1323
1324 gdb_assert (objfile->section_offsets);
1325 offset = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1326
1327 while (fde)
1328 {
1329 if (*pc >= fde->initial_location + offset
1330 && *pc < fde->initial_location + offset + fde->address_range)
1331 {
1332 *pc = fde->initial_location + offset;
1333 return fde;
1334 }
1335
1336 fde = fde->next;
1337 }
1338 }
1339
1340 return NULL;
1341 }
1342
1343 static void
add_fde(struct comp_unit * unit,struct dwarf2_fde * fde)1344 add_fde (struct comp_unit *unit, struct dwarf2_fde *fde)
1345 {
1346 fde->next = objfile_data (unit->objfile, dwarf2_frame_objfile_data);
1347 set_objfile_data (unit->objfile, dwarf2_frame_objfile_data, fde);
1348 }
1349
1350 #ifdef CC_HAS_LONG_LONG
1351 #define DW64_CIE_ID 0xffffffffffffffffULL
1352 #else
1353 #define DW64_CIE_ID ~0
1354 #endif
1355
1356 static char *decode_frame_entry (struct comp_unit *unit, char *start,
1357 int eh_frame_p);
1358
1359 /* Decode the next CIE or FDE. Return NULL if invalid input, otherwise
1360 the next byte to be processed. */
1361 static char *
decode_frame_entry_1(struct comp_unit * unit,char * start,int eh_frame_p)1362 decode_frame_entry_1 (struct comp_unit *unit, char *start, int eh_frame_p)
1363 {
1364 char *buf;
1365 LONGEST length;
1366 unsigned int bytes_read;
1367 int dwarf64_p;
1368 ULONGEST cie_id;
1369 ULONGEST cie_pointer;
1370 char *end;
1371
1372 buf = start;
1373 length = read_initial_length (unit->abfd, buf, &bytes_read);
1374 buf += bytes_read;
1375 end = buf + length;
1376
1377 /* Are we still within the section? */
1378 if (end > unit->dwarf_frame_buffer + unit->dwarf_frame_size)
1379 return NULL;
1380
1381 if (length == 0)
1382 return end;
1383
1384 /* Distinguish between 32 and 64-bit encoded frame info. */
1385 dwarf64_p = (bytes_read == 12);
1386
1387 /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs. */
1388 if (eh_frame_p)
1389 cie_id = 0;
1390 else if (dwarf64_p)
1391 cie_id = DW64_CIE_ID;
1392 else
1393 cie_id = DW_CIE_ID;
1394
1395 if (dwarf64_p)
1396 {
1397 cie_pointer = read_8_bytes (unit->abfd, buf);
1398 buf += 8;
1399 }
1400 else
1401 {
1402 cie_pointer = read_4_bytes (unit->abfd, buf);
1403 buf += 4;
1404 }
1405
1406 if (cie_pointer == cie_id)
1407 {
1408 /* This is a CIE. */
1409 struct dwarf2_cie *cie;
1410 char *augmentation;
1411 unsigned int cie_version;
1412
1413 /* Record the offset into the .debug_frame section of this CIE. */
1414 cie_pointer = start - unit->dwarf_frame_buffer;
1415
1416 /* Check whether we've already read it. */
1417 if (find_cie (unit, cie_pointer))
1418 return end;
1419
1420 cie = (struct dwarf2_cie *)
1421 obstack_alloc (&unit->objfile->objfile_obstack,
1422 sizeof (struct dwarf2_cie));
1423 cie->initial_instructions = NULL;
1424 cie->cie_pointer = cie_pointer;
1425
1426 /* The encoding for FDE's in a normal .debug_frame section
1427 depends on the target address size. */
1428 cie->encoding = DW_EH_PE_absptr;
1429
1430 /* Check version number. */
1431 cie_version = read_1_byte (unit->abfd, buf);
1432 if (cie_version != 1 && cie_version != 3)
1433 return NULL;
1434 buf += 1;
1435
1436 /* Interpret the interesting bits of the augmentation. */
1437 augmentation = buf;
1438 buf = augmentation + strlen (augmentation) + 1;
1439
1440 /* The GCC 2.x "eh" augmentation has a pointer immediately
1441 following the augmentation string, so it must be handled
1442 first. */
1443 if (augmentation[0] == 'e' && augmentation[1] == 'h')
1444 {
1445 /* Skip. */
1446 buf += TYPE_LENGTH (builtin_type_void_data_ptr);
1447 augmentation += 2;
1448 }
1449
1450 cie->code_alignment_factor =
1451 read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1452 buf += bytes_read;
1453
1454 cie->data_alignment_factor =
1455 read_signed_leb128 (unit->abfd, buf, &bytes_read);
1456 buf += bytes_read;
1457
1458 if (cie_version == 1)
1459 {
1460 cie->return_address_register = read_1_byte (unit->abfd, buf);
1461 bytes_read = 1;
1462 }
1463 else
1464 cie->return_address_register = read_unsigned_leb128 (unit->abfd, buf,
1465 &bytes_read);
1466 buf += bytes_read;
1467
1468 cie->saw_z_augmentation = (*augmentation == 'z');
1469 if (cie->saw_z_augmentation)
1470 {
1471 ULONGEST length;
1472
1473 length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1474 buf += bytes_read;
1475 if (buf > end)
1476 return NULL;
1477 cie->initial_instructions = buf + length;
1478 augmentation++;
1479 }
1480
1481 while (*augmentation)
1482 {
1483 /* "L" indicates a byte showing how the LSDA pointer is encoded. */
1484 if (*augmentation == 'L')
1485 {
1486 /* Skip. */
1487 buf++;
1488 augmentation++;
1489 }
1490
1491 /* "R" indicates a byte indicating how FDE addresses are encoded. */
1492 else if (*augmentation == 'R')
1493 {
1494 cie->encoding = *buf++;
1495 augmentation++;
1496 }
1497
1498 /* "P" indicates a personality routine in the CIE augmentation. */
1499 else if (*augmentation == 'P')
1500 {
1501 /* Skip. Avoid indirection since we throw away the result. */
1502 unsigned char encoding = (*buf++) & ~DW_EH_PE_indirect;
1503 read_encoded_value (unit, encoding, buf, &bytes_read);
1504 buf += bytes_read;
1505 augmentation++;
1506 }
1507
1508 /* Otherwise we have an unknown augmentation.
1509 Bail out unless we saw a 'z' prefix. */
1510 else
1511 {
1512 if (cie->initial_instructions == NULL)
1513 return end;
1514
1515 /* Skip unknown augmentations. */
1516 buf = cie->initial_instructions;
1517 break;
1518 }
1519 }
1520
1521 cie->initial_instructions = buf;
1522 cie->end = end;
1523
1524 add_cie (unit, cie);
1525 }
1526 else
1527 {
1528 /* This is a FDE. */
1529 struct dwarf2_fde *fde;
1530
1531 /* In an .eh_frame section, the CIE pointer is the delta between the
1532 address within the FDE where the CIE pointer is stored and the
1533 address of the CIE. Convert it to an offset into the .eh_frame
1534 section. */
1535 if (eh_frame_p)
1536 {
1537 cie_pointer = buf - unit->dwarf_frame_buffer - cie_pointer;
1538 cie_pointer -= (dwarf64_p ? 8 : 4);
1539 }
1540
1541 /* In either case, validate the result is still within the section. */
1542 if (cie_pointer >= unit->dwarf_frame_size)
1543 return NULL;
1544
1545 fde = (struct dwarf2_fde *)
1546 obstack_alloc (&unit->objfile->objfile_obstack,
1547 sizeof (struct dwarf2_fde));
1548 fde->cie = find_cie (unit, cie_pointer);
1549 if (fde->cie == NULL)
1550 {
1551 decode_frame_entry (unit, unit->dwarf_frame_buffer + cie_pointer,
1552 eh_frame_p);
1553 fde->cie = find_cie (unit, cie_pointer);
1554 }
1555
1556 gdb_assert (fde->cie != NULL);
1557
1558 fde->initial_location =
1559 read_encoded_value (unit, fde->cie->encoding, buf, &bytes_read);
1560 buf += bytes_read;
1561
1562 fde->address_range =
1563 read_encoded_value (unit, fde->cie->encoding & 0x0f, buf, &bytes_read);
1564 buf += bytes_read;
1565
1566 /* A 'z' augmentation in the CIE implies the presence of an
1567 augmentation field in the FDE as well. The only thing known
1568 to be in here at present is the LSDA entry for EH. So we
1569 can skip the whole thing. */
1570 if (fde->cie->saw_z_augmentation)
1571 {
1572 ULONGEST length;
1573
1574 length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1575 buf += bytes_read + length;
1576 if (buf > end)
1577 return NULL;
1578 }
1579
1580 fde->instructions = buf;
1581 fde->end = end;
1582
1583 add_fde (unit, fde);
1584 }
1585
1586 return end;
1587 }
1588
1589 /* Read a CIE or FDE in BUF and decode it. */
1590 static char *
decode_frame_entry(struct comp_unit * unit,char * start,int eh_frame_p)1591 decode_frame_entry (struct comp_unit *unit, char *start, int eh_frame_p)
1592 {
1593 enum { NONE, ALIGN4, ALIGN8, FAIL } workaround = NONE;
1594 char *ret;
1595 const char *msg;
1596 ptrdiff_t start_offset;
1597
1598 while (1)
1599 {
1600 ret = decode_frame_entry_1 (unit, start, eh_frame_p);
1601 if (ret != NULL)
1602 break;
1603
1604 /* We have corrupt input data of some form. */
1605
1606 /* ??? Try, weakly, to work around compiler/assembler/linker bugs
1607 and mismatches wrt padding and alignment of debug sections. */
1608 /* Note that there is no requirement in the standard for any
1609 alignment at all in the frame unwind sections. Testing for
1610 alignment before trying to interpret data would be incorrect.
1611
1612 However, GCC traditionally arranged for frame sections to be
1613 sized such that the FDE length and CIE fields happen to be
1614 aligned (in theory, for performance). This, unfortunately,
1615 was done with .align directives, which had the side effect of
1616 forcing the section to be aligned by the linker.
1617
1618 This becomes a problem when you have some other producer that
1619 creates frame sections that are not as strictly aligned. That
1620 produces a hole in the frame info that gets filled by the
1621 linker with zeros.
1622
1623 The GCC behaviour is arguably a bug, but it's effectively now
1624 part of the ABI, so we're now stuck with it, at least at the
1625 object file level. A smart linker may decide, in the process
1626 of compressing duplicate CIE information, that it can rewrite
1627 the entire output section without this extra padding. */
1628
1629 start_offset = start - unit->dwarf_frame_buffer;
1630 if (workaround < ALIGN4 && (start_offset & 3) != 0)
1631 {
1632 start += 4 - (start_offset & 3);
1633 workaround = ALIGN4;
1634 continue;
1635 }
1636 if (workaround < ALIGN8 && (start_offset & 7) != 0)
1637 {
1638 start += 8 - (start_offset & 7);
1639 workaround = ALIGN8;
1640 continue;
1641 }
1642
1643 /* Nothing left to try. Arrange to return as if we've consumed
1644 the entire input section. Hopefully we'll get valid info from
1645 the other of .debug_frame/.eh_frame. */
1646 workaround = FAIL;
1647 ret = unit->dwarf_frame_buffer + unit->dwarf_frame_size;
1648 break;
1649 }
1650
1651 switch (workaround)
1652 {
1653 case NONE:
1654 break;
1655
1656 case ALIGN4:
1657 complaint (&symfile_complaints,
1658 _("Corrupt data in %s:%s; align 4 workaround apparently succeeded"),
1659 unit->dwarf_frame_section->owner->filename,
1660 unit->dwarf_frame_section->name);
1661 break;
1662
1663 case ALIGN8:
1664 complaint (&symfile_complaints,
1665 _("Corrupt data in %s:%s; align 8 workaround apparently succeeded"),
1666 unit->dwarf_frame_section->owner->filename,
1667 unit->dwarf_frame_section->name);
1668 break;
1669
1670 default:
1671 complaint (&symfile_complaints,
1672 _("Corrupt data in %s:%s"),
1673 unit->dwarf_frame_section->owner->filename,
1674 unit->dwarf_frame_section->name);
1675 break;
1676 }
1677
1678 return ret;
1679 }
1680
1681
1682 /* FIXME: kettenis/20030504: This still needs to be integrated with
1683 dwarf2read.c in a better way. */
1684
1685 /* Imported from dwarf2read.c. */
1686 extern asection *dwarf_frame_section;
1687 extern asection *dwarf_eh_frame_section;
1688
1689 /* Imported from dwarf2read.c. */
1690 extern char *dwarf2_read_section (struct objfile *objfile, asection *sectp);
1691
1692 void
dwarf2_build_frame_info(struct objfile * objfile)1693 dwarf2_build_frame_info (struct objfile *objfile)
1694 {
1695 struct comp_unit unit;
1696 char *frame_ptr;
1697
1698 /* Build a minimal decoding of the DWARF2 compilation unit. */
1699 unit.abfd = objfile->obfd;
1700 unit.objfile = objfile;
1701 unit.dbase = 0;
1702 unit.tbase = 0;
1703
1704 /* First add the information from the .eh_frame section. That way,
1705 the FDEs from that section are searched last. */
1706 if (dwarf_eh_frame_section)
1707 {
1708 asection *got, *txt;
1709
1710 unit.cie = NULL;
1711 unit.dwarf_frame_buffer = dwarf2_read_section (objfile,
1712 dwarf_eh_frame_section);
1713
1714 unit.dwarf_frame_size = bfd_get_section_size (dwarf_eh_frame_section);
1715 unit.dwarf_frame_section = dwarf_eh_frame_section;
1716
1717 /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
1718 that is used for the i386/amd64 target, which currently is
1719 the only target in GCC that supports/uses the
1720 DW_EH_PE_datarel encoding. */
1721 got = bfd_get_section_by_name (unit.abfd, ".got");
1722 if (got)
1723 unit.dbase = got->vma;
1724
1725 /* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64
1726 so far. */
1727 txt = bfd_get_section_by_name (unit.abfd, ".text");
1728 if (txt)
1729 unit.tbase = txt->vma;
1730
1731 frame_ptr = unit.dwarf_frame_buffer;
1732 while (frame_ptr < unit.dwarf_frame_buffer + unit.dwarf_frame_size)
1733 frame_ptr = decode_frame_entry (&unit, frame_ptr, 1);
1734 }
1735
1736 if (dwarf_frame_section)
1737 {
1738 unit.cie = NULL;
1739 unit.dwarf_frame_buffer = dwarf2_read_section (objfile,
1740 dwarf_frame_section);
1741 unit.dwarf_frame_size = bfd_get_section_size (dwarf_frame_section);
1742 unit.dwarf_frame_section = dwarf_frame_section;
1743
1744 frame_ptr = unit.dwarf_frame_buffer;
1745 while (frame_ptr < unit.dwarf_frame_buffer + unit.dwarf_frame_size)
1746 frame_ptr = decode_frame_entry (&unit, frame_ptr, 0);
1747 }
1748 }
1749
1750 /* Provide a prototype to silence -Wmissing-prototypes. */
1751 void _initialize_dwarf2_frame (void);
1752
1753 void
_initialize_dwarf2_frame(void)1754 _initialize_dwarf2_frame (void)
1755 {
1756 dwarf2_frame_data = gdbarch_data_register_pre_init (dwarf2_frame_init);
1757 dwarf2_frame_objfile_data = register_objfile_data ();
1758 }
1759