projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
2003-01-13 Andrew Cagney <ac131313@redhat.com>
[deliverable/binutils-gdb.git] / gdb / dwarf2cfi.c
CommitLineData
b6af0555 1/* Stack unwinding code based on dwarf2 frame info for GDB, the GNU debugger.
1bac305b
AC		 2
3 Copyright 2001, 2002, 2003 Free Software Foundation, Inc.
4
b6af0555 5 Contributed by Jiri Smid, SuSE Labs.
7e336ba1 6 Based on code written by Daniel Berlin (dan@dberlin.org).
b6af0555
JS		 7
8 This file is part of GDB.
9
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 2 of the License, or
13 (at your option) any later version.
14
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.
19
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, USA. */
24
25#include "defs.h"
9b94f7bf 26#include "gdbcore.h"
b6af0555
JS		 27#include "symtab.h"
28#include "symfile.h"
29#include "objfiles.h"
30#include "target.h"
31#include "elf/dwarf2.h"
32#include "inferior.h"
33#include "regcache.h"
34#include "dwarf2cfi.h"
7c43edc1 35#include "gdb_assert.h"
b6af0555
JS		 36
37/* Common Information Entry - holds information that is shared among many
38 Frame Descriptors. */
39struct cie_unit
40{
7f0c12ed 41 /* Offset of this unit in .debug_frame or .eh_frame. */
b6af0555
JS		 42 ULONGEST offset;
43
44 /* A null-terminated string that identifies the augmentation to this CIE or
45 to the FDEs that use it. */
46 char *augmentation;
47
48 /* A constant that is factored out of all advance location instructions. */
49 unsigned int code_align;
50
51 /* A constant that is factored out of all offset instructions. */
52 int data_align;
53
54 /* A constant that indicates which regiter represents the return address
55 of a function. */
56 unsigned char ra;
57
58 /* Indicates how addresses are encoded. */
59 unsigned char addr_encoding;
60
61 /* Pointer and length of the cie program. */
62 char *data;
63 unsigned int data_length;
64
65 struct objfile *objfile;
66
67 /* Next in chain. */
68 struct cie_unit *next;
69};
70
71/* Frame Description Entry. */
72struct fde_unit
73{
74 /* Address of the first location associated with this entry. */
75 CORE_ADDR initial_location;
76
77 /* Length of program section described by this entry. */
78 CORE_ADDR address_range;
79
80 /* Pointer to asociated CIE. */
81 struct cie_unit *cie_ptr;
82
83 /* Pointer and length of the cie program. */
84 char *data;
85 unsigned int data_length;
86};
87
88struct fde_array
89{
90 struct fde_unit **array;
91 int elems;
92 int array_size;
93};
94
b6af0555
JS		 95struct frame_state_reg
96{
97 union
98 {
99 unsigned int reg;
100 long offset;
101 unsigned char *exp;
102 }
103 loc;
104 enum
105 {
106 REG_UNSAVED,
107 REG_SAVED_OFFSET,
108 REG_SAVED_REG,
109 REG_SAVED_EXP,
110 }
111 how;
112};
113
114struct frame_state
115{
116 /* Each register save state can be described in terms of a CFA slot,
117 another register, or a location expression. */
118 struct frame_state_regs
119 {
120 struct frame_state_reg *reg;
121
122 /* Used to implement DW_CFA_remember_state. */
123 struct frame_state_regs *prev;
124 }
125 regs;
126
127 /* The CFA can be described in terms of a reg+offset or a
128 location expression. */
129 long cfa_offset;
130 int cfa_reg;
131 unsigned char *cfa_exp;
132 enum
133 {
134 CFA_UNSET,
135 CFA_REG_OFFSET,
136 CFA_EXP,
137 }
138 cfa_how;
139
140 /* The PC described by the current frame state. */
141 CORE_ADDR pc;
142
143 /* The information we care about from the CIE/FDE. */
144 int data_align;
145 unsigned int code_align;
146 unsigned char retaddr_column;
147 unsigned char addr_encoding;
148
149 struct objfile *objfile;
150};
151
19d833a2
ML		 152enum ptr_encoding
153{
7f0c12ed
ML		 154 PE_absptr = DW_EH_PE_absptr,
155 PE_pcrel = DW_EH_PE_pcrel,
156 PE_textrel = DW_EH_PE_textrel,
157 PE_datarel = DW_EH_PE_datarel,
158 PE_funcrel = DW_EH_PE_funcrel
159};
160
2d75187b 161#define UNWIND_CONTEXT(fi) ((struct context *) (deprecated_get_frame_context (fi)))
b6af0555
JS		 162\f
163
164static struct cie_unit *cie_chunks;
165static struct fde_array fde_chunks;
166/* Obstack for allocating temporary storage used during unwind operations. */
167static struct obstack unwind_tmp_obstack;
168
169extern file_ptr dwarf_frame_offset;
170extern unsigned int dwarf_frame_size;
171extern file_ptr dwarf_eh_frame_offset;
172extern unsigned int dwarf_eh_frame_size;
b6af0555
JS		 173\f
174
175extern char *dwarf2_read_section (struct objfile *objfile, file_ptr offset,
176 unsigned int size);
177
178static struct fde_unit *fde_unit_alloc (void);
179static struct cie_unit *cie_unit_alloc (void);
180static void fde_chunks_need_space ();
181
23aa4c72 182static void unwind_tmp_obstack_init ();
b6af0555 183static void unwind_tmp_obstack_free ();
b6af0555 184
9f1549cc
MK		 185static unsigned int read_1u (bfd *abfd, char **p);
186static int read_1s (bfd *abfd, char **p);
187static unsigned int read_2u (bfd *abfd, char **p);
188static int read_2s (bfd *abfd, char **p);
189static unsigned int read_4u (bfd *abfd, char **p);
190static int read_4s (bfd *abfd, char **p);
191static ULONGEST read_8u (bfd *abfd, char **p);
192static LONGEST read_8s (bfd *abfd, char **p);
193
194static ULONGEST read_uleb128 (bfd *abfd, char **p);
195static LONGEST read_sleb128 (bfd *abfd, char **p);
196static CORE_ADDR read_pointer (bfd *abfd, char **p);
197static CORE_ADDR read_encoded_pointer (bfd *abfd, char **p,
b6af0555 198 unsigned char encoding);
7f0c12ed 199static enum ptr_encoding pointer_encoding (unsigned char encoding);
b6af0555 200
9f1549cc
MK		 201static LONGEST read_initial_length (bfd *abfd, char *buf, int *bytes_read);
202static ULONGEST read_length (bfd *abfd, char *buf, int *bytes_read,
b6af0555 203 int dwarf64);
b6af0555
JS		 204
205static int is_cie (ULONGEST cie_id, int dwarf64);
206static int compare_fde_unit (const void *a, const void *b);
207void dwarf2_build_frame_info (struct objfile *objfile);
208
209static void execute_cfa_program (struct objfile *objfile, char *insn_ptr,
210 char *insn_end, struct context *context,
211 struct frame_state *fs);
212static struct fde_unit *get_fde_for_addr (CORE_ADDR pc);
213static void frame_state_for (struct context *context, struct frame_state *fs);
214static void get_reg (char *reg, struct context *context, int regnum);
215static CORE_ADDR execute_stack_op (struct objfile *objfile,
216 char *op_ptr, char *op_end,
264d1763
ML		 217 struct context *context,
218 CORE_ADDR initial);
b6af0555
JS		 219static void update_context (struct context *context, struct frame_state *fs,
220 int chain);
b6af0555 221\f
264d1763 222
b6af0555
JS		 223/* Memory allocation functions. */
224static struct fde_unit *
225fde_unit_alloc (void)
226{
227 struct fde_unit *fde;
228
229 fde = (struct fde_unit *) xmalloc (sizeof (struct fde_unit));
230 memset (fde, 0, sizeof (struct fde_unit));
231 return fde;
232}
233
234static struct cie_unit *
235cie_unit_alloc (void)
236{
237 struct cie_unit *cie;
238
239 cie = (struct cie_unit *) xmalloc (sizeof (struct cie_unit));
240 memset (cie, 0, sizeof (struct cie_unit));
241 return cie;
242}
243
244static void
5ae5f592 245fde_chunks_need_space (void)
b6af0555
JS		 246{
247 if (fde_chunks.elems < fde_chunks.array_size)
248 return;
249 fde_chunks.array_size =
250 fde_chunks.array_size ? 2 * fde_chunks.array_size : 1024;
251 fde_chunks.array =
252 xrealloc (fde_chunks.array,
253 sizeof (struct fde_unit) * fde_chunks.array_size);
254}
255
256/* Alocate a new `struct context' on temporary obstack. */
baed091b 257struct context *
5ae5f592 258context_alloc (void)
b6af0555
JS		 259{
260 struct context *context;
4657573b 261
b6af0555
JS		 262 int regs_size = sizeof (struct context_reg) * NUM_REGS;
263
264 context = (struct context *) obstack_alloc (&unwind_tmp_obstack,
265 sizeof (struct context));
266 memset (context, 0, sizeof (struct context));
267 context->reg = (struct context_reg *) obstack_alloc (&unwind_tmp_obstack,
268 regs_size);
269 memset (context->reg, 0, regs_size);
270 return context;
271}
272
273/* Alocate a new `struct frame_state' on temporary obstack. */
baed091b 274struct frame_state *
5ae5f592 275frame_state_alloc (void)
b6af0555
JS		 276{
277 struct frame_state *fs;
4657573b 278
b6af0555
JS		 279 int regs_size = sizeof (struct frame_state_reg) * NUM_REGS;
280
281 fs = (struct frame_state *) obstack_alloc (&unwind_tmp_obstack,
282 sizeof (struct frame_state));
283 memset (fs, 0, sizeof (struct frame_state));
264d1763
ML		 284 fs->regs.reg =
285 (struct frame_state_reg *) obstack_alloc (&unwind_tmp_obstack, regs_size);
b6af0555
JS		 286 memset (fs->regs.reg, 0, regs_size);
287 return fs;
288}
289
23aa4c72 290static void
5ae5f592 291unwind_tmp_obstack_init (void)
23aa4c72
ML		 292{
293 obstack_init (&unwind_tmp_obstack);
294}
295
b6af0555 296static void
5ae5f592 297unwind_tmp_obstack_free (void)
b6af0555
JS		 298{
299 obstack_free (&unwind_tmp_obstack, NULL);
23aa4c72 300 unwind_tmp_obstack_init ();
b6af0555
JS		 301}
302
baed091b 303void
b6af0555
JS		 304context_cpy (struct context *dst, struct context *src)
305{
b6af0555 306 int regs_size = sizeof (struct context_reg) * NUM_REGS;
5d085aaf
ML		 307 struct context_reg *dreg;
308
9f1549cc
MK		 309 /* Since `struct context' contains a pointer to an array with
310 register values, make sure we end up with a copy of that array,
311 and not with a copy of the pointer to that array. */
5d085aaf 312 dreg = dst->reg;
b6af0555 313 *dst = *src;
5d085aaf 314 dst->reg = dreg;
b6af0555
JS		 315 memcpy (dst->reg, src->reg, regs_size);
316}
b6af0555
JS		 317
318static unsigned int
9f1549cc 319read_1u (bfd *abfd, char **p)
b6af0555
JS		 320{
321 unsigned ret;
322
264d1763
ML		 323 ret = bfd_get_8 (abfd, (bfd_byte *) * p);
324 (*p)++;
b6af0555
JS		 325 return ret;
326}
327
328static int
9f1549cc 329read_1s (bfd *abfd, char **p)
b6af0555
JS		 330{
331 int ret;
332
264d1763
ML		 333 ret = bfd_get_signed_8 (abfd, (bfd_byte *) * p);
334 (*p)++;
b6af0555
JS		 335 return ret;
336}
337
338static unsigned int
9f1549cc 339read_2u (bfd *abfd, char **p)
b6af0555
JS		 340{
341 unsigned ret;
342
264d1763
ML		 343 ret = bfd_get_16 (abfd, (bfd_byte *) * p);
344 (*p)++;
b6af0555
JS		 345 return ret;
346}
347
348static int
9f1549cc 349read_2s (bfd *abfd, char **p)
b6af0555
JS		 350{
351 int ret;
352
264d1763 353 ret = bfd_get_signed_16 (abfd, (bfd_byte *) * p);
b6af0555
JS		 354 (*p) += 2;
355 return ret;
356}
357
358static unsigned int
9f1549cc 359read_4u (bfd *abfd, char **p)
b6af0555
JS		 360{
361 unsigned int ret;
362
264d1763 363 ret = bfd_get_32 (abfd, (bfd_byte *) * p);
b6af0555
JS		 364 (*p) += 4;
365 return ret;
366}
367
368static int
9f1549cc 369read_4s (bfd *abfd, char **p)
b6af0555
JS		 370{
371 int ret;
372
264d1763 373 ret = bfd_get_signed_32 (abfd, (bfd_byte *) * p);
b6af0555
JS		 374 (*p) += 4;
375 return ret;
376}
377
378static ULONGEST
9f1549cc 379read_8u (bfd *abfd, char **p)
b6af0555
JS		 380{
381 ULONGEST ret;
382
264d1763 383 ret = bfd_get_64 (abfd, (bfd_byte *) * p);
b6af0555
JS		 384 (*p) += 8;
385 return ret;
386}
387
388static LONGEST
9f1549cc 389read_8s (bfd *abfd, char **p)
b6af0555
JS		 390{
391 LONGEST ret;
392
264d1763 393 ret = bfd_get_signed_64 (abfd, (bfd_byte *) * p);
b6af0555
JS		 394 (*p) += 8;
395 return ret;
396}
397
398static ULONGEST
9f1549cc 399read_uleb128 (bfd *abfd, char **p)
b6af0555
JS		 400{
401 ULONGEST ret;
402 int i, shift;
403 unsigned char byte;
404
405 ret = 0;
406 shift = 0;
407 i = 0;
408 while (1)
409 {
264d1763
ML		 410 byte = bfd_get_8 (abfd, (bfd_byte *) * p);
411 (*p)++;
b6af0555
JS		 412 ret |= ((unsigned long) (byte & 127) << shift);
413 if ((byte & 128) == 0)
414 {
415 break;
416 }
417 shift += 7;
418 }
419 return ret;
420}
421
422static LONGEST
9f1549cc 423read_sleb128 (bfd *abfd, char **p)
b6af0555
JS		 424{
425 LONGEST ret;
426 int i, shift, size, num_read;
427 unsigned char byte;
428
429 ret = 0;
430 shift = 0;
431 size = 32;
432 num_read = 0;
433 i = 0;
434 while (1)
435 {
264d1763
ML		 436 byte = bfd_get_8 (abfd, (bfd_byte *) * p);
437 (*p)++;
b6af0555
JS		 438 ret |= ((long) (byte & 127) << shift);
439 shift += 7;
440 if ((byte & 128) == 0)
441 {
442 break;
443 }
444 }
445 if ((shift < size) && (byte & 0x40))
446 {
447 ret |= -(1 << shift);
448 }
449 return ret;
450}
451
452static CORE_ADDR
9f1549cc 453read_pointer (bfd *abfd, char **p)
b6af0555
JS		 454{
455 switch (TARGET_ADDR_BIT / TARGET_CHAR_BIT)
456 {
457 case 4:
458 return read_4u (abfd, p);
459 case 8:
460 return read_8u (abfd, p);
461 default:
462 error ("dwarf cfi error: unsupported target address length.");
463 }
464}
465
9f1549cc
MK		 466/* Read the appropriate amount of data from *P and return the
467 resulting value based on ENCODING, which the calling function must
468 provide. */
b6af0555 469static CORE_ADDR
9f1549cc 470read_encoded_pointer (bfd *abfd, char **p, unsigned char encoding)
b6af0555
JS		 471{
472 CORE_ADDR ret;
473
474 switch (encoding & 0x0f)
475 {
476 case DW_EH_PE_absptr:
477 ret = read_pointer (abfd, p);
478 break;
479
480 case DW_EH_PE_uleb128:
481 ret = read_uleb128 (abfd, p);
482 break;
483 case DW_EH_PE_sleb128:
484 ret = read_sleb128 (abfd, p);
485 break;
486
487 case DW_EH_PE_udata2:
488 ret = read_2u (abfd, p);
489 break;
490 case DW_EH_PE_udata4:
491 ret = read_4u (abfd, p);
492 break;
493 case DW_EH_PE_udata8:
494 ret = read_8u (abfd, p);
495 break;
496
497 case DW_EH_PE_sdata2:
498 ret = read_2s (abfd, p);
499 break;
500 case DW_EH_PE_sdata4:
501 ret = read_4s (abfd, p);
502 break;
503 case DW_EH_PE_sdata8:
504 ret = read_8s (abfd, p);
505 break;
506
507 default:
508 internal_error (__FILE__, __LINE__,
509 "read_encoded_pointer: unknown pointer encoding");
510 }
511
7f0c12ed
ML		 512 return ret;
513}
514
9f1549cc
MK		 515/* The variable 'encoding' carries three different flags:
516 - encoding & 0x0f : size of the address (handled in read_encoded_pointer())
517 - encoding & 0x70 : type (absolute, relative, ...)
518 - encoding & 0x80 : indirect flag (DW_EH_PE_indirect == 0x80). */
7f0c12ed
ML		 519enum ptr_encoding
520pointer_encoding (unsigned char encoding)
521{
522 int ret;
b6af0555 523
7f0c12ed
ML		 524 if (encoding & DW_EH_PE_indirect)
525 warning ("CFI: Unsupported pointer encoding: DW_EH_PE_indirect");
19d833a2 526
7f0c12ed
ML		 527 switch (encoding & 0x70)
528 {
529 case DW_EH_PE_absptr:
530 case DW_EH_PE_pcrel:
531 case DW_EH_PE_textrel:
532 case DW_EH_PE_datarel:
533 case DW_EH_PE_funcrel:
534 ret = encoding & 0x70;
535 break;
536 default:
19d833a2 537 internal_error (__FILE__, __LINE__, "CFI: unknown pointer encoding");
7f0c12ed 538 }
b6af0555
JS		 539 return ret;
540}
541
542static LONGEST
9f1549cc 543read_initial_length (bfd *abfd, char *buf, int *bytes_read)
b6af0555
JS		 544{
545 LONGEST ret = 0;
546
547 ret = bfd_get_32 (abfd, (bfd_byte *) buf);
548
549 if (ret == 0xffffffff)
550 {
551 ret = bfd_get_64 (abfd, (bfd_byte *) buf + 4);
552 *bytes_read = 12;
553 }
554 else
555 {
556 *bytes_read = 4;
557 }
558
559 return ret;
560}
561
562static ULONGEST
9f1549cc 563read_length (bfd *abfd, char *buf, int *bytes_read, int dwarf64)
b6af0555
JS		 564{
565 if (dwarf64)
566 {
567 *bytes_read = 8;
568 return read_8u (abfd, &buf);
569 }
570 else
571 {
572 *bytes_read = 4;
573 return read_4u (abfd, &buf);
574 }
575}
576
577static void
264d1763
ML		 578execute_cfa_program (struct objfile *objfile, char *insn_ptr, char *insn_end,
579 struct context *context, struct frame_state *fs)
b6af0555
JS		 580{
581 struct frame_state_regs *unused_rs = NULL;
582
583 /* Don't allow remember/restore between CIE and FDE programs. */
584 fs->regs.prev = NULL;
585
586 while (insn_ptr < insn_end && fs->pc < context->ra)
587 {
588 unsigned char insn = *insn_ptr++;
589 ULONGEST reg, uoffset;
590 LONGEST offset;
b6af0555
JS		 591
592 if (insn & DW_CFA_advance_loc)
593 fs->pc += (insn & 0x3f) * fs->code_align;
594 else if (insn & DW_CFA_offset)
595 {
596 reg = insn & 0x3f;
597 uoffset = read_uleb128 (objfile->obfd, &insn_ptr);
264d1763 598 offset = (long) uoffset *fs->data_align;
b6af0555
JS		 599 fs->regs.reg[reg].how = REG_SAVED_OFFSET;
600 fs->regs.reg[reg].loc.offset = offset;
601 }
602 else if (insn & DW_CFA_restore)
603 {
604 reg = insn & 0x3f;
605 fs->regs.reg[reg].how = REG_UNSAVED;
606 }
607 else
608 switch (insn)
609 {
610 case DW_CFA_set_loc:
611 fs->pc = read_encoded_pointer (objfile->obfd, &insn_ptr,
612 fs->addr_encoding);
19d833a2 613
7f0c12ed 614 if (pointer_encoding (fs->addr_encoding) != PE_absptr)
19d833a2
ML		 615 warning ("CFI: DW_CFA_set_loc uses relative addressing");
616
b6af0555
JS		 617 break;
618
619 case DW_CFA_advance_loc1:
620 fs->pc += read_1u (objfile->obfd, &insn_ptr);
621 break;
622 case DW_CFA_advance_loc2:
623 fs->pc += read_2u (objfile->obfd, &insn_ptr);
624 break;
625 case DW_CFA_advance_loc4:
626 fs->pc += read_4u (objfile->obfd, &insn_ptr);
627 break;
628
629 case DW_CFA_offset_extended:
630 reg = read_uleb128 (objfile->obfd, &insn_ptr);
631 uoffset = read_uleb128 (objfile->obfd, &insn_ptr);
632 offset = (long) uoffset *fs->data_align;
633 fs->regs.reg[reg].how = REG_SAVED_OFFSET;
634 fs->regs.reg[reg].loc.offset = offset;
635 break;
636
637 case DW_CFA_restore_extended:
638 reg = read_uleb128 (objfile->obfd, &insn_ptr);
639 fs->regs.reg[reg].how = REG_UNSAVED;
640 break;
641
642 case DW_CFA_undefined:
643 case DW_CFA_same_value:
644 case DW_CFA_nop:
645 break;
646
647 case DW_CFA_register:
648 {
649 ULONGEST reg2;
650 reg = read_uleb128 (objfile->obfd, &insn_ptr);
651 reg2 = read_uleb128 (objfile->obfd, &insn_ptr);
652 fs->regs.reg[reg].how = REG_SAVED_REG;
653 fs->regs.reg[reg].loc.reg = reg2;
654 }
655 break;
656
657 case DW_CFA_remember_state:
658 {
659 struct frame_state_regs *new_rs;
660 if (unused_rs)
661 {
662 new_rs = unused_rs;
663 unused_rs = unused_rs->prev;
664 }
665 else
666 new_rs = xmalloc (sizeof (struct frame_state_regs));
667
668 *new_rs = fs->regs;
669 fs->regs.prev = new_rs;
670 }
671 break;
672
673 case DW_CFA_restore_state:
674 {
675 struct frame_state_regs *old_rs = fs->regs.prev;
676 fs->regs = *old_rs;
677 old_rs->prev = unused_rs;
678 unused_rs = old_rs;
679 }
680 break;
681
682 case DW_CFA_def_cfa:
683 reg = read_uleb128 (objfile->obfd, &insn_ptr);
684 uoffset = read_uleb128 (objfile->obfd, &insn_ptr);
685 fs->cfa_reg = reg;
686 fs->cfa_offset = uoffset;
687 fs->cfa_how = CFA_REG_OFFSET;
688 break;
689
690 case DW_CFA_def_cfa_register:
691 reg = read_uleb128 (objfile->obfd, &insn_ptr);
692 fs->cfa_reg = reg;
693 fs->cfa_how = CFA_REG_OFFSET;
694 break;
695
696 case DW_CFA_def_cfa_offset:
697 uoffset = read_uleb128 (objfile->obfd, &insn_ptr);
698 fs->cfa_offset = uoffset;
699 break;
700
701 case DW_CFA_def_cfa_expression:
702 uoffset = read_uleb128 (objfile->obfd, &insn_ptr);
703 fs->cfa_exp = insn_ptr;
704 fs->cfa_how = CFA_EXP;
705 insn_ptr += uoffset;
706 break;
707
708 case DW_CFA_expression:
709 reg = read_uleb128 (objfile->obfd, &insn_ptr);
710 uoffset = read_uleb128 (objfile->obfd, &insn_ptr);
711 fs->regs.reg[reg].how = REG_SAVED_EXP;
712 fs->regs.reg[reg].loc.exp = insn_ptr;
713 insn_ptr += uoffset;
714 break;
715
716 /* From the 2.1 draft. */
717 case DW_CFA_offset_extended_sf:
718 reg = read_uleb128 (objfile->obfd, &insn_ptr);
719 offset = read_sleb128 (objfile->obfd, &insn_ptr);
720 offset *= fs->data_align;
721 fs->regs.reg[reg].how = REG_SAVED_OFFSET;
722 fs->regs.reg[reg].loc.offset = offset;
723 break;
724
725 case DW_CFA_def_cfa_sf:
726 reg = read_uleb128 (objfile->obfd, &insn_ptr);
727 offset = read_sleb128 (objfile->obfd, &insn_ptr);
728 fs->cfa_offset = offset;
729 fs->cfa_reg = reg;
730 fs->cfa_how = CFA_REG_OFFSET;
731 break;
732
733 case DW_CFA_def_cfa_offset_sf:
734 uoffset = read_uleb128 (objfile->obfd, &insn_ptr);
735 fs->cfa_offset = uoffset;
736 /* cfa_how deliberately not set. */
737 break;
738
739 case DW_CFA_GNU_window_save:
740 /* ??? Hardcoded for SPARC register window configuration. */
741 for (reg = 16; reg < 32; ++reg)
742 {
743 fs->regs.reg[reg].how = REG_SAVED_OFFSET;
744 fs->regs.reg[reg].loc.offset = (reg - 16) * sizeof (void *);
745 }
746 break;
747
748 case DW_CFA_GNU_args_size:
749 uoffset = read_uleb128 (objfile->obfd, &insn_ptr);
750 context->args_size = uoffset;
751 break;
752
753 case DW_CFA_GNU_negative_offset_extended:
754 /* Obsoleted by DW_CFA_offset_extended_sf, but used by
755 older PowerPC code. */
756 reg = read_uleb128 (objfile->obfd, &insn_ptr);
757 uoffset = read_uleb128 (objfile->obfd, &insn_ptr);
758 offset = (long) uoffset *fs->data_align;
759 fs->regs.reg[reg].how = REG_SAVED_OFFSET;
760 fs->regs.reg[reg].loc.offset = -offset;
761 break;
762
763 default:
764 error ("dwarf cfi error: unknown cfa instruction %d.", insn);
765 }
766 }
767}
768
769static struct fde_unit *
770get_fde_for_addr (CORE_ADDR pc)
771{
772 size_t lo, hi;
773 struct fde_unit *fde = NULL;
774 lo = 0;
775 hi = fde_chunks.elems;
776
777 while (lo < hi)
778 {
779 size_t i = (lo + hi) / 2;
780 fde = fde_chunks.array[i];
781 if (pc < fde->initial_location)
782 hi = i;
783 else if (pc >= fde->initial_location + fde->address_range)
784 lo = i + 1;
785 else
786 return fde;
787 }
788 return 0;
789}
790
791static void
792frame_state_for (struct context *context, struct frame_state *fs)
793{
794 struct fde_unit *fde;
795 struct cie_unit *cie;
b6af0555
JS		 796
797 context->args_size = 0;
798 context->lsda = 0;
799
005ef3d2
ML		 800 fde = get_fde_for_addr (context->ra - 1);
801
802 if (fde == NULL)
803 return;
264d1763 804
005ef3d2 805 fs->pc = fde->initial_location;
b6af0555 806
7c43edc1
AC		 807 gdb_assert (fde->cie_ptr != NULL);
808
809 cie = fde->cie_ptr;
b64bbf8c 810
7c43edc1
AC		 811 fs->code_align = cie->code_align;
812 fs->data_align = cie->data_align;
813 fs->retaddr_column = cie->ra;
814 fs->addr_encoding = cie->addr_encoding;
815 fs->objfile = cie->objfile;
b64bbf8c 816
7c43edc1
AC		 817 execute_cfa_program (cie->objfile, cie->data,
818 cie->data + cie->data_length, context, fs);
819 execute_cfa_program (cie->objfile, fde->data,
820 fde->data + fde->data_length, context, fs);
b6af0555
JS		 821}
822
823static void
824get_reg (char *reg, struct context *context, int regnum)
825{
826 switch (context->reg[regnum].how)
827 {
828 case REG_CTX_UNSAVED:
4caf0990 829 deprecated_read_register_gen (regnum, reg);
b6af0555
JS		 830 break;
831 case REG_CTX_SAVED_OFFSET:
832 target_read_memory (context->cfa + context->reg[regnum].loc.offset,
833 reg, REGISTER_RAW_SIZE (regnum));
834 break;
835 case REG_CTX_SAVED_REG:
4caf0990 836 deprecated_read_register_gen (context->reg[regnum].loc.reg, reg);
b6af0555
JS		 837 break;
838 case REG_CTX_SAVED_ADDR:
839 target_read_memory (context->reg[regnum].loc.addr,
840 reg, REGISTER_RAW_SIZE (regnum));
841 break;
842 case REG_CTX_VALUE:
843 memcpy (reg, &context->reg[regnum].loc.addr,
844 REGISTER_RAW_SIZE (regnum));
845 break;
846 default:
264d1763 847 internal_error (__FILE__, __LINE__, "get_reg: unknown register rule");
b6af0555
JS		 848 }
849}
850
851/* Decode a DW_OP stack program. Return the top of stack. Push INITIAL
852 onto the stack to start. */
853static CORE_ADDR
854execute_stack_op (struct objfile *objfile,
855 char *op_ptr, char *op_end, struct context *context,
856 CORE_ADDR initial)
857{
858 CORE_ADDR stack[64]; /* ??? Assume this is enough. */
859 int stack_elt;
860
861 stack[0] = initial;
862 stack_elt = 1;
863
864 while (op_ptr < op_end)
865 {
866 enum dwarf_location_atom op = *op_ptr++;
6c3eb890
ML		 867 CORE_ADDR result;
868 ULONGEST reg;
b6af0555
JS		 869 LONGEST offset;
870
871 switch (op)
872 {
873 case DW_OP_lit0:
874 case DW_OP_lit1:
875 case DW_OP_lit2:
876 case DW_OP_lit3:
877 case DW_OP_lit4:
878 case DW_OP_lit5:
879 case DW_OP_lit6:
880 case DW_OP_lit7:
881 case DW_OP_lit8:
882 case DW_OP_lit9:
883 case DW_OP_lit10:
884 case DW_OP_lit11:
885 case DW_OP_lit12:
886 case DW_OP_lit13:
887 case DW_OP_lit14:
888 case DW_OP_lit15:
889 case DW_OP_lit16:
890 case DW_OP_lit17:
891 case DW_OP_lit18:
892 case DW_OP_lit19:
893 case DW_OP_lit20:
894 case DW_OP_lit21:
895 case DW_OP_lit22:
896 case DW_OP_lit23:
897 case DW_OP_lit24:
898 case DW_OP_lit25:
899 case DW_OP_lit26:
900 case DW_OP_lit27:
901 case DW_OP_lit28:
902 case DW_OP_lit29:
903 case DW_OP_lit30:
904 case DW_OP_lit31:
905 result = op - DW_OP_lit0;
906 break;
907
908 case DW_OP_addr:
909 result = read_pointer (objfile->obfd, &op_ptr);
910 break;
911
912 case DW_OP_const1u:
913 result = read_1u (objfile->obfd, &op_ptr);
914 break;
915 case DW_OP_const1s:
916 result = read_1s (objfile->obfd, &op_ptr);
917 break;
918 case DW_OP_const2u:
919 result = read_2u (objfile->obfd, &op_ptr);
920 break;
921 case DW_OP_const2s:
922 result = read_2s (objfile->obfd, &op_ptr);
923 break;
924 case DW_OP_const4u:
925 result = read_4u (objfile->obfd, &op_ptr);
926 break;
927 case DW_OP_const4s:
928 result = read_4s (objfile->obfd, &op_ptr);
929 break;
930 case DW_OP_const8u:
931 result = read_8u (objfile->obfd, &op_ptr);
932 break;
933 case DW_OP_const8s:
934 result = read_8s (objfile->obfd, &op_ptr);
935 break;
936 case DW_OP_constu:
937 result = read_uleb128 (objfile->obfd, &op_ptr);
938 break;
939 case DW_OP_consts:
940 result = read_sleb128 (objfile->obfd, &op_ptr);
941 break;
942
943 case DW_OP_reg0:
944 case DW_OP_reg1:
945 case DW_OP_reg2:
946 case DW_OP_reg3:
947 case DW_OP_reg4:
948 case DW_OP_reg5:
949 case DW_OP_reg6:
950 case DW_OP_reg7:
951 case DW_OP_reg8:
952 case DW_OP_reg9:
953 case DW_OP_reg10:
954 case DW_OP_reg11:
955 case DW_OP_reg12:
956 case DW_OP_reg13:
957 case DW_OP_reg14:
958 case DW_OP_reg15:
959 case DW_OP_reg16:
960 case DW_OP_reg17:
961 case DW_OP_reg18:
962 case DW_OP_reg19:
963 case DW_OP_reg20:
964 case DW_OP_reg21:
965 case DW_OP_reg22:
966 case DW_OP_reg23:
967 case DW_OP_reg24:
968 case DW_OP_reg25:
969 case DW_OP_reg26:
970 case DW_OP_reg27:
971 case DW_OP_reg28:
972 case DW_OP_reg29:
973 case DW_OP_reg30:
974 case DW_OP_reg31:
975 get_reg ((char *) &result, context, op - DW_OP_reg0);
976 break;
977 case DW_OP_regx:
978 reg = read_uleb128 (objfile->obfd, &op_ptr);
979 get_reg ((char *) &result, context, reg);
980 break;
981
982 case DW_OP_breg0:
983 case DW_OP_breg1:
984 case DW_OP_breg2:
985 case DW_OP_breg3:
986 case DW_OP_breg4:
987 case DW_OP_breg5:
988 case DW_OP_breg6:
989 case DW_OP_breg7:
990 case DW_OP_breg8:
991 case DW_OP_breg9:
992 case DW_OP_breg10:
993 case DW_OP_breg11:
994 case DW_OP_breg12:
995 case DW_OP_breg13:
996 case DW_OP_breg14:
997 case DW_OP_breg15:
998 case DW_OP_breg16:
999 case DW_OP_breg17:
1000 case DW_OP_breg18:
1001 case DW_OP_breg19:
1002 case DW_OP_breg20:
1003 case DW_OP_breg21:
1004 case DW_OP_breg22:
1005 case DW_OP_breg23:
1006 case DW_OP_breg24:
1007 case DW_OP_breg25:
1008 case DW_OP_breg26:
1009 case DW_OP_breg27:
1010 case DW_OP_breg28:
1011 case DW_OP_breg29:
1012 case DW_OP_breg30:
1013 case DW_OP_breg31:
1014 offset = read_sleb128 (objfile->obfd, &op_ptr);
1015 get_reg ((char *) &result, context, op - DW_OP_breg0);
1016 result += offset;
1017 break;
1018 case DW_OP_bregx:
1019 reg = read_uleb128 (objfile->obfd, &op_ptr);
1020 offset = read_sleb128 (objfile->obfd, &op_ptr);
1021 get_reg ((char *) &result, context, reg);
1022 result += offset;
1023 break;
1024
1025 case DW_OP_dup:
1026 if (stack_elt < 1)
1027 internal_error (__FILE__, __LINE__, "execute_stack_op error");
1028 result = stack[stack_elt - 1];
1029 break;
1030
1031 case DW_OP_drop:
1032 if (--stack_elt < 0)
1033 internal_error (__FILE__, __LINE__, "execute_stack_op error");
1034 goto no_push;
1035
1036 case DW_OP_pick:
1037 offset = *op_ptr++;
1038 if (offset >= stack_elt - 1)
1039 internal_error (__FILE__, __LINE__, "execute_stack_op error");
1040 result = stack[stack_elt - 1 - offset];
1041 break;
1042
1043 case DW_OP_over:
1044 if (stack_elt < 2)
1045 internal_error (__FILE__, __LINE__, "execute_stack_op error");
1046 result = stack[stack_elt - 2];
1047 break;
1048
1049 case DW_OP_rot:
1050 {
1051 CORE_ADDR t1, t2, t3;
1052
1053 if (stack_elt < 3)
1054 internal_error (__FILE__, __LINE__, "execute_stack_op error");
1055 t1 = stack[stack_elt - 1];
1056 t2 = stack[stack_elt - 2];
1057 t3 = stack[stack_elt - 3];
1058 stack[stack_elt - 1] = t2;
1059 stack[stack_elt - 2] = t3;
1060 stack[stack_elt - 3] = t1;
1061 goto no_push;
1062 }
1063
1064 case DW_OP_deref:
1065 case DW_OP_deref_size:
1066 case DW_OP_abs:
1067 case DW_OP_neg:
1068 case DW_OP_not:
1069 case DW_OP_plus_uconst:
1070 /* Unary operations. */
1071 if (--stack_elt < 0)
1072 internal_error (__FILE__, __LINE__, "execute_stack_op error");
1073 result = stack[stack_elt];
1074
1075 switch (op)
1076 {
1077 case DW_OP_deref:
1078 {
9b94f7bf
MK		 1079 int len = TARGET_ADDR_BIT / TARGET_CHAR_BIT;
1080 if (len != 4 && len != 8)
1081 internal_error (__FILE__, __LINE__,
1082 "execute_stack_op error");
1083 result = read_memory_unsigned_integer (result, len);
b6af0555
JS		 1084 }
1085 break;
1086
1087 case DW_OP_deref_size:
1088 {
9b94f7bf 1089 int len = *op_ptr++;
b64bbf8c 1090 if (len != 1 && len != 2 && len != 4 && len != 8)
9b94f7bf
MK		 1091 internal_error (__FILE__, __LINE__,
1092 "execute_stack_op error");
1093 result = read_memory_unsigned_integer (result, len);
b6af0555
JS		 1094 }
1095 break;
1096
1097 case DW_OP_abs:
1098 if (result < 0)
1099 result = -result;
1100 break;
1101 case DW_OP_neg:
1102 result = -result;
1103 break;
1104 case DW_OP_not:
1105 result = ~result;
1106 break;
1107 case DW_OP_plus_uconst:
1108 result += read_uleb128 (objfile->obfd, &op_ptr);
1109 break;
4657573b
ML		 1110 default:
1111 break;
b6af0555
JS		 1112 }
1113 break;
1114
1115 case DW_OP_and:
1116 case DW_OP_div:
1117 case DW_OP_minus:
1118 case DW_OP_mod:
1119 case DW_OP_mul:
1120 case DW_OP_or:
1121 case DW_OP_plus:
1122 case DW_OP_le:
1123 case DW_OP_ge:
1124 case DW_OP_eq:
1125 case DW_OP_lt:
1126 case DW_OP_gt:
1127 case DW_OP_ne:
1128 {
1129 /* Binary operations. */
1130 CORE_ADDR first, second;
1131 if ((stack_elt -= 2) < 0)
1132 internal_error (__FILE__, __LINE__, "execute_stack_op error");
1133 second = stack[stack_elt];
1134 first = stack[stack_elt + 1];
1135
1136 switch (op)
1137 {
1138 case DW_OP_and:
1139 result = second & first;
1140 break;
1141 case DW_OP_div:
1142 result = (LONGEST) second / (LONGEST) first;
1143 break;
1144 case DW_OP_minus:
1145 result = second - first;
1146 break;
1147 case DW_OP_mod:
1148 result = (LONGEST) second % (LONGEST) first;
1149 break;
1150 case DW_OP_mul:
1151 result = second * first;
1152 break;
1153 case DW_OP_or:
1154 result = second | first;
1155 break;
1156 case DW_OP_plus:
1157 result = second + first;
1158 break;
1159 case DW_OP_shl:
1160 result = second << first;
1161 break;
1162 case DW_OP_shr:
1163 result = second >> first;
1164 break;
1165 case DW_OP_shra:
1166 result = (LONGEST) second >> first;
1167 break;
1168 case DW_OP_xor:
1169 result = second ^ first;
1170 break;
1171 case DW_OP_le:
1172 result = (LONGEST) first <= (LONGEST) second;
1173 break;
1174 case DW_OP_ge:
1175 result = (LONGEST) first >= (LONGEST) second;
1176 break;
1177 case DW_OP_eq:
1178 result = (LONGEST) first == (LONGEST) second;
1179 break;
1180 case DW_OP_lt:
1181 result = (LONGEST) first < (LONGEST) second;
1182 break;
1183 case DW_OP_gt:
1184 result = (LONGEST) first > (LONGEST) second;
1185 break;
1186 case DW_OP_ne:
1187 result = (LONGEST) first != (LONGEST) second;
1188 break;
fb16b900
ML		 1189 default:
1190 error ("execute_stack_op: Unknown DW_OP_ value");
264d1763 1191 break;
b6af0555
JS		 1192 }
1193 }
1194 break;
1195
1196 case DW_OP_skip:
1197 offset = read_2s (objfile->obfd, &op_ptr);
1198 op_ptr += offset;
1199 goto no_push;
1200
1201 case DW_OP_bra:
1202 if (--stack_elt < 0)
1203 internal_error (__FILE__, __LINE__, "execute_stack_op error");
1204 offset = read_2s (objfile->obfd, &op_ptr);
1205 if (stack[stack_elt] != 0)
1206 op_ptr += offset;
1207 goto no_push;
1208
1209 case DW_OP_nop:
1210 goto no_push;
1211
1212 default:
1213 internal_error (__FILE__, __LINE__, "execute_stack_op error");
1214 }
1215
1216 /* Most things push a result value. */
1217 if ((size_t) stack_elt >= sizeof (stack) / sizeof (*stack))
1218 internal_error (__FILE__, __LINE__, "execute_stack_op error");
1219 stack[++stack_elt] = result;
1220 no_push:;
1221 }
1222
1223 /* We were executing this program to get a value. It should be
1224 at top of stack. */
1225 if (--stack_elt < 0)
1226 internal_error (__FILE__, __LINE__, "execute_stack_op error");
1227 return stack[stack_elt];
1228}
1229
1230static void
1231update_context (struct context *context, struct frame_state *fs, int chain)
1232{
1233 struct context *orig_context;
fb16b900 1234 CORE_ADDR cfa = 0;
b6af0555
JS		 1235 long i;
1236
23aa4c72
ML		 1237 unwind_tmp_obstack_init ();
1238
b6af0555
JS		 1239 orig_context = context_alloc ();
1240 context_cpy (orig_context, context);
23aa4c72 1241
b6af0555
JS		 1242 /* Compute this frame's CFA. */
1243 switch (fs->cfa_how)
1244 {
1245 case CFA_REG_OFFSET:
1246 get_reg ((char *) &cfa, context, fs->cfa_reg);
1247 cfa += fs->cfa_offset;
1248 break;
1249
1250 case CFA_EXP:
1251 /* ??? No way of knowing what register number is the stack pointer
264d1763
ML		 1252 to do the same sort of handling as above. Assume that if the
1253 CFA calculation is so complicated as to require a stack program
1254 that this will not be a problem. */
b6af0555
JS		 1255 {
1256 char *exp = fs->cfa_exp;
1257 ULONGEST len;
1258
1259 len = read_uleb128 (fs->objfile->obfd, &exp);
1260 cfa = (CORE_ADDR) execute_stack_op (fs->objfile, exp,
1261 exp + len, context, 0);
1262 break;
1263 }
4657573b
ML		 1264 default:
1265 break;
b6af0555
JS		 1266 }
1267 context->cfa = cfa;
1268
1269 if (!chain)
1270 orig_context->cfa = cfa;
1271
1272 /* Compute the addresses of all registers saved in this frame. */
1273 for (i = 0; i < NUM_REGS; ++i)
1274 switch (fs->regs.reg[i].how)
1275 {
1276 case REG_UNSAVED:
1277 if (i == SP_REGNUM)
1278 {
1279 context->reg[i].how = REG_CTX_VALUE;
1280 context->reg[i].loc.addr = cfa;
1281 }
1282 else
1283 context->reg[i].how = REG_CTX_UNSAVED;
1284 break;
1285 case REG_SAVED_OFFSET:
1286 context->reg[i].how = REG_CTX_SAVED_OFFSET;
1287 context->reg[i].loc.offset = fs->regs.reg[i].loc.offset;
1288 break;
1289 case REG_SAVED_REG:
1290 switch (orig_context->reg[fs->regs.reg[i].loc.reg].how)
1291 {
1292 case REG_CTX_UNSAVED:
1293 context->reg[i].how = REG_CTX_UNSAVED;
1294 break;
1295 case REG_CTX_SAVED_OFFSET:
1296 context->reg[i].how = REG_CTX_SAVED_OFFSET;
1297 context->reg[i].loc.offset = orig_context->cfa - context->cfa +
1298 orig_context->reg[fs->regs.reg[i].loc.reg].loc.offset;
1299 break;
1300 case REG_CTX_SAVED_REG:
1301 context->reg[i].how = REG_CTX_SAVED_REG;
1302 context->reg[i].loc.reg =
1303 orig_context->reg[fs->regs.reg[i].loc.reg].loc.reg;
1304 break;
1305 case REG_CTX_SAVED_ADDR:
1306 context->reg[i].how = REG_CTX_SAVED_ADDR;
1307 context->reg[i].loc.addr =
1308 orig_context->reg[fs->regs.reg[i].loc.reg].loc.addr;
7c43edc1 1309 break;
b6af0555 1310 default:
7c43edc1 1311 internal_error (__FILE__, __LINE__, "bad switch");
b6af0555
JS		 1312 }
1313 break;
1314 case REG_SAVED_EXP:
1315 {
1316 char *exp = fs->regs.reg[i].loc.exp;
1317 ULONGEST len;
1318 CORE_ADDR val;
1319
1320 len = read_uleb128 (fs->objfile->obfd, &exp);
1321 val = execute_stack_op (fs->objfile, exp, exp + len,
1322 orig_context, cfa);
1323 context->reg[i].how = REG_CTX_SAVED_ADDR;
1324 context->reg[i].loc.addr = val;
1325 }
1326 break;
1327 default:
7c43edc1 1328 internal_error (__FILE__, __LINE__, "bad switch");
b6af0555
JS		 1329 }
1330 get_reg ((char *) &context->ra, context, fs->retaddr_column);
1331 unwind_tmp_obstack_free ();
1332}
1333
1334static int
1335is_cie (ULONGEST cie_id, int dwarf64)
1336{
1337 return dwarf64 ? (cie_id == 0xffffffffffffffff) : (cie_id == 0xffffffff);
1338}
1339
1340static int
1341compare_fde_unit (const void *a, const void *b)
1342{
1343 struct fde_unit **first, **second;
1344 first = (struct fde_unit **) a;
1345 second = (struct fde_unit **) b;
1346 if ((*first)->initial_location > (*second)->initial_location)
1347 return 1;
1348 else if ((*first)->initial_location < (*second)->initial_location)
1349 return -1;
1350 else
1351 return 0;
1352}
1353
1354/* Build the cie_chunks and fde_chunks tables from informations
7f0c12ed
ML		 1355 found in .debug_frame and .eh_frame sections. */
1356/* We can handle both of these sections almost in the same way, however there
1357 are some exceptions:
1358 - CIE ID is -1 in debug_frame, but 0 in eh_frame
1359 - eh_frame may contain some more information that are used only by gcc
1360 (eg. personality pointer, LSDA pointer, ...). Most of them we can ignore.
1361 - In debug_frame FDE's item cie_id contains offset of it's parent CIE.
1362 In eh_frame FDE's item cie_id is a relative pointer to the parent CIE.
1363 Anyway we don't need to bother with this, because we are smart enough
1364 to keep the pointer to the parent CIE of oncomming FDEs in 'last_cie'.
1365 - Although debug_frame items can contain Augmentation as well as
1366 eh_frame ones, I have never seen them non-empty. Thus only in eh_frame
1367 we can encounter for example non-absolute pointers (Aug. 'R').
1368 -- mludvig */
1369static void
1370parse_frame_info (struct objfile *objfile, file_ptr frame_offset,
1371 unsigned int frame_size, int eh_frame)
b6af0555
JS		 1372{
1373 bfd *abfd = objfile->obfd;
7f0c12ed 1374 asection *curr_section_ptr;
b6af0555
JS		 1375 char *start = NULL;
1376 char *end = NULL;
7f0c12ed
ML		 1377 char *frame_buffer = NULL;
1378 char *curr_section_name, *aug_data;
1379 struct cie_unit *last_cie = NULL;
1380 int last_dup_fde = 0;
1381 int aug_len, i;
1382 CORE_ADDR curr_section_vma = 0;
b6af0555 1383
23aa4c72 1384 unwind_tmp_obstack_init ();
b6af0555 1385
7f0c12ed 1386 frame_buffer = dwarf2_read_section (objfile, frame_offset, frame_size);
b6af0555 1387
7f0c12ed
ML		 1388 start = frame_buffer;
1389 end = frame_buffer + frame_size;
b6af0555 1390
7f0c12ed
ML		 1391 curr_section_name = eh_frame ? ".eh_frame" : ".debug_frame";
1392 curr_section_ptr = bfd_get_section_by_name (abfd, curr_section_name);
1393 if (curr_section_ptr)
1394 curr_section_vma = curr_section_ptr->vma;
b6af0555
JS		 1395
1396 if (start)
1397 {
1398 while (start < end)
1399 {
1400 unsigned long length;
1401 ULONGEST cie_id;
7f0c12ed 1402 ULONGEST unit_offset = start - frame_buffer;
19d833a2 1403 int bytes_read, dwarf64;
b6af0555
JS		 1404 char *block_end;
1405
1406 length = read_initial_length (abfd, start, &bytes_read);
1407 start += bytes_read;
1408 dwarf64 = (bytes_read == 12);
1409 block_end = start + length;
1410
7f0c12ed
ML		 1411 if (length == 0)
1412 {
1413 start = block_end;
1414 continue;
1415 }
1416
b6af0555
JS		 1417 cie_id = read_length (abfd, start, &bytes_read, dwarf64);
1418 start += bytes_read;
1419
7f0c12ed 1420 if ((eh_frame && cie_id == 0) || is_cie (cie_id, dwarf64))
b6af0555
JS		 1421 {
1422 struct cie_unit *cie = cie_unit_alloc ();
1423 char *aug;
1424
1425 cie->objfile = objfile;
1426 cie->next = cie_chunks;
1427 cie_chunks = cie;
1428
1429 cie->objfile = objfile;
1430
1431 cie->offset = unit_offset;
1432
1433 start++; /* version */
1434
1435 cie->augmentation = aug = start;
7f0c12ed 1436 while (*start++); /* Skips last NULL as well */
b6af0555
JS		 1437
1438 cie->code_align = read_uleb128 (abfd, &start);
1439 cie->data_align = read_sleb128 (abfd, &start);
1440 cie->ra = read_1u (abfd, &start);
1441
7f0c12ed
ML		 1442 /* Augmentation:
1443 z Indicates that a uleb128 is present to size the
1444 augmentation section.
1445 L Indicates the encoding (and thus presence) of
1446 an LSDA pointer in the FDE augmentation.
1447 R Indicates a non-default pointer encoding for
1448 FDE code pointers.
1449 P Indicates the presence of an encoding + language
1450 personality routine in the CIE augmentation.
1451
1452 [This info comes from GCC's dwarf2out.c]
1453 */
b6af0555
JS		 1454 if (*aug == 'z')
1455 {
7f0c12ed
ML		 1456 aug_len = read_uleb128 (abfd, &start);
1457 aug_data = start;
1458 start += aug_len;
b6af0555
JS		 1459 ++aug;
1460 }
1461
7f0c12ed
ML		 1462 cie->data = start;
1463 cie->data_length = block_end - cie->data;
1464
b6af0555
JS		 1465 while (*aug != '\0')
1466 {
1467 if (aug[0] == 'e' && aug[1] == 'h')
1468 {
7f0c12ed
ML		 1469 aug_data += sizeof (void *);
1470 aug++;
b6af0555
JS		 1471 }
1472 else if (aug[0] == 'R')
7f0c12ed
ML		 1473 cie->addr_encoding = *aug_data++;
1474 else if (aug[0] == 'P')
b6af0555 1475 {
7f0c12ed
ML		 1476 CORE_ADDR pers_addr;
1477 int pers_addr_enc;
1478
1479 pers_addr_enc = *aug_data++;
1480 /* We don't need pers_addr value and so we
1481 don't care about it's encoding. */
1482 pers_addr = read_encoded_pointer (abfd, &aug_data,
1483 pers_addr_enc);
b6af0555 1484 }
7f0c12ed 1485 else if (aug[0] == 'L' && eh_frame)
b6af0555 1486 {
7f0c12ed
ML		 1487 int lsda_addr_enc;
1488
1489 /* Perhaps we should save this to CIE for later use?
1490 Do we need it for something in GDB? */
1491 lsda_addr_enc = *aug_data++;
b6af0555
JS		 1492 }
1493 else
7f0c12ed
ML		 1494 warning ("CFI warning: unknown augmentation \"%c\""
1495 " in \"%s\" of\n"
1496 "\t%s", aug[0], curr_section_name,
1497 objfile->name);
1498 aug++;
b6af0555
JS		 1499 }
1500
7f0c12ed 1501 last_cie = cie;
b6af0555
JS		 1502 }
1503 else
1504 {
1505 struct fde_unit *fde;
1506 struct cie_unit *cie;
7f0c12ed
ML		 1507 int dup = 0;
1508 CORE_ADDR init_loc;
1509
1510 /* We assume that debug_frame is in order
1511 CIE,FDE,CIE,FDE,FDE,... and thus the CIE for this FDE
1512 should be stored in last_cie pointer. If not, we'll
1513 try to find it by the older way. */
1514 if (last_cie)
1515 cie = last_cie;
1516 else
1517 {
1518 warning ("CFI: last_cie == NULL. "
1519 "Perhaps a malformed %s section in '%s'...?\n",
1520 curr_section_name, objfile->name);
b6af0555 1521
7f0c12ed
ML		 1522 cie = cie_chunks;
1523 while (cie)
1524 {
1525 if (cie->objfile == objfile)
1526 {
1527 if (eh_frame &&
1528 (cie->offset ==
1529 (unit_offset + bytes_read - cie_id)))
1530 break;
1531 if (!eh_frame && (cie->offset == cie_id))
1532 break;
1533 }
1534
1535 cie = cie->next;
1536 }
1537 if (!cie)
1538 error ("CFI: can't find CIE pointer");
1539 }
b6af0555 1540
7f0c12ed
ML		 1541 init_loc = read_encoded_pointer (abfd, &start,
1542 cie->addr_encoding);
264d1763 1543
7f0c12ed 1544 switch (pointer_encoding (cie->addr_encoding))
19d833a2 1545 {
7f0c12ed 1546 case PE_absptr:
19d833a2 1547 break;
7f0c12ed 1548 case PE_pcrel:
19d833a2
ML		 1549 /* start-frame_buffer gives offset from
1550 the beginning of actual section. */
1551 init_loc += curr_section_vma + start - frame_buffer;
1552 break;
7f0c12ed 1553 default:
19d833a2
ML		 1554 warning ("CFI: Unsupported pointer encoding\n");
1555 }
b6af0555 1556
7f0c12ed
ML		 1557 /* For relocatable objects we must add an offset telling
1558 where the section is actually mapped in the memory. */
1559 init_loc += ANOFFSET (objfile->section_offsets,
1560 SECT_OFF_TEXT (objfile));
1561
1562 /* If we have both .debug_frame and .eh_frame present in
1563 a file, we must eliminate duplicate FDEs. For now we'll
1564 run through all entries in fde_chunks and check it one
1565 by one. Perhaps in the future we can implement a faster
1566 searching algorithm. */
1567 /* eh_frame==2 indicates, that this file has an already
1568 parsed .debug_frame too. When eh_frame==1 it means, that no
1569 .debug_frame is present and thus we don't need to check for
1570 duplicities. eh_frame==0 means, that we parse .debug_frame
1571 and don't need to care about duplicate FDEs, because
1572 .debug_frame is parsed first. */
1573 if (eh_frame == 2)
19d833a2
ML		 1574 for (i = 0; eh_frame == 2 && i < fde_chunks.elems; i++)
1575 {
1576 /* We assume that FDEs in .debug_frame and .eh_frame
1577 have the same order (if they are present, of course).
1578 If we find a duplicate entry for one FDE and save
1579 it's index to last_dup_fde it's very likely, that
1580 we'll find an entry for the following FDE right after
1581 the previous one. Thus in many cases we'll run this
1582 loop only once. */
1583 last_dup_fde = (last_dup_fde + i) % fde_chunks.elems;
1584 if (fde_chunks.array[last_dup_fde]->initial_location
1585 == init_loc)
1586 {
1587 dup = 1;
1588 break;
1589 }
1590 }
005ef3d2 1591
7f0c12ed
ML		 1592 /* Allocate a new entry only if this FDE isn't a duplicate of
1593 something we have already seen. */
1594 if (!dup)
1595 {
1596 fde_chunks_need_space ();
1597 fde = fde_unit_alloc ();
1598
1599 fde_chunks.array[fde_chunks.elems++] = fde;
1600
1601 fde->initial_location = init_loc;
1602 fde->address_range = read_encoded_pointer (abfd, &start,
1603 cie->
1604 addr_encoding);
b6af0555 1605
7f0c12ed 1606 fde->cie_ptr = cie;
b6af0555 1607
7f0c12ed
ML		 1608 /* Here we intentionally ignore augmentation data
1609 from FDE, because we don't need them. */
1610 if (cie->augmentation[0] == 'z')
1611 start += read_uleb128 (abfd, &start);
1612
1613 fde->data = start;
1614 fde->data_length = block_end - start;
1615 }
b6af0555
JS		 1616 }
1617 start = block_end;
1618 }
1619 qsort (fde_chunks.array, fde_chunks.elems,
1620 sizeof (struct fde_unit *), compare_fde_unit);
1621 }
1622}
7f0c12ed
ML		 1623
1624/* We must parse both .debug_frame section and .eh_frame because
1625 * not all frames must be present in both of these sections. */
1626void
1627dwarf2_build_frame_info (struct objfile *objfile)
1628{
1629 int after_debug_frame = 0;
1630
1631 /* If we have .debug_frame then the parser is called with
1632 eh_frame==0 for .debug_frame and eh_frame==2 for .eh_frame,
1633 otherwise it's only called once for .eh_frame with argument
1634 eh_frame==1. */
1635
1636 if (dwarf_frame_offset)
19d833a2
ML		 1637 {
1638 parse_frame_info (objfile, dwarf_frame_offset,
1639 dwarf_frame_size, 0 /* = debug_frame */ );
1640 after_debug_frame = 1;
1641 }
7f0c12ed
ML		 1642
1643 if (dwarf_eh_frame_offset)
19d833a2
ML		 1644 parse_frame_info (objfile, dwarf_eh_frame_offset, dwarf_eh_frame_size,
1645 1 /* = eh_frame */ + after_debug_frame);
7f0c12ed 1646}
b6af0555
JS		 1647
1648/* Return the frame address. */
1649CORE_ADDR
5ae5f592 1650cfi_read_fp (void)
b6af0555
JS		 1651{
1652 struct context *context;
1653 struct frame_state *fs;
1654 CORE_ADDR cfa;
1655
23aa4c72
ML		 1656 unwind_tmp_obstack_init ();
1657
b6af0555
JS		 1658 context = context_alloc ();
1659 fs = frame_state_alloc ();
1660
1661 context->ra = read_pc () + 1;
1662
1663 frame_state_for (context, fs);
1664 update_context (context, fs, 0);
1665
1666 cfa = context->cfa;
264d1763 1667
b6af0555 1668 unwind_tmp_obstack_free ();
264d1763 1669
b6af0555
JS		 1670 return cfa;
1671}
1672
8227c0ff
AC		 1673/* Store the frame address. This function is not used. */
1674
b6af0555
JS		 1675void
1676cfi_write_fp (CORE_ADDR val)
1677{
1678 struct context *context;
1679 struct frame_state *fs;
1680
23aa4c72
ML		 1681 unwind_tmp_obstack_init ();
1682
b6af0555
JS		 1683 context = context_alloc ();
1684 fs = frame_state_alloc ();
1685
1686 context->ra = read_pc () + 1;
1687
1688 frame_state_for (context, fs);
1689
1690 if (fs->cfa_how == CFA_REG_OFFSET)
1691 {
1692 val -= fs->cfa_offset;
4caf0990 1693 deprecated_write_register_gen (fs->cfa_reg, (char *) &val);
b6af0555
JS		 1694 }
1695 else
1696 warning ("Can't write fp.");
1697
1698 unwind_tmp_obstack_free ();
1699}
1700
1701/* Restore the machine to the state it had before the current frame
1702 was created. */
1703void
1704cfi_pop_frame (struct frame_info *fi)
1705{
2404952e 1706 char *regbuf = alloca (MAX_REGISTER_RAW_SIZE);
b6af0555
JS		 1707 int regnum;
1708
b6af0555
JS		 1709 for (regnum = 0; regnum < NUM_REGS; regnum++)
1710 {
1711 get_reg (regbuf, UNWIND_CONTEXT (fi), regnum);
73937e03
AC		 1712 deprecated_write_register_bytes (REGISTER_BYTE (regnum), regbuf,
1713 REGISTER_RAW_SIZE (regnum));
b6af0555
JS		 1714 }
1715 write_register (PC_REGNUM, UNWIND_CONTEXT (fi)->ra);
1716
1717 flush_cached_frames ();
1718}
1719
1720/* Determine the address of the calling function's frame. */
1721CORE_ADDR
1722cfi_frame_chain (struct frame_info *fi)
1723{
1724 struct context *context;
1725 struct frame_state *fs;
1726 CORE_ADDR cfa;
1727
23aa4c72
ML		 1728 unwind_tmp_obstack_init ();
1729
b6af0555
JS		 1730 context = context_alloc ();
1731 fs = frame_state_alloc ();
1732 context_cpy (context, UNWIND_CONTEXT (fi));
1733
1734 /* outermost frame */
1735 if (context->ra == 0)
1736 {
1737 unwind_tmp_obstack_free ();
1738 return 0;
1739 }
1740
1741 frame_state_for (context, fs);
1742 update_context (context, fs, 1);
1743
1744 cfa = context->cfa;
1745 unwind_tmp_obstack_free ();
264d1763 1746
b6af0555
JS		 1747 return cfa;
1748}
1749
1750/* Sets the pc of the frame. */
97f46953 1751CORE_ADDR
b6af0555
JS		 1752cfi_init_frame_pc (int fromleaf, struct frame_info *fi)
1753{
97f46953
AC		 1754 if (get_next_frame (fi))
1755 {
1756 CORE_ADDR pc;
1757 /* FIXME: cagney/2002-12-04: This is straight wrong. It's
1758 assuming that the PC is CORE_ADDR (a host quantity) in size. */
408400e7 1759 get_reg ((void *)&pc, UNWIND_CONTEXT (get_next_frame (fi)), PC_REGNUM);
97f46953
AC		 1760 return pc;
1761 }
b6af0555 1762 else
97f46953 1763 return read_pc ();
b6af0555
JS		 1764}
1765
1766/* Initialize unwind context informations of the frame. */
1767void
1768cfi_init_extra_frame_info (int fromleaf, struct frame_info *fi)
1769{
1770 struct frame_state *fs;
1771
23aa4c72 1772 unwind_tmp_obstack_init ();
264d1763 1773
b6af0555 1774 fs = frame_state_alloc ();
479ab5a0 1775 deprecated_set_frame_context (fi, frame_obstack_zalloc (sizeof (struct context)));
b6af0555 1776 UNWIND_CONTEXT (fi)->reg =
479ab5a0 1777 frame_obstack_zalloc (sizeof (struct context_reg) * NUM_REGS);
b6af0555
JS		 1778 memset (UNWIND_CONTEXT (fi)->reg, 0,
1779 sizeof (struct context_reg) * NUM_REGS);
1780
11c02a10 1781 if (get_next_frame (fi))
b6af0555 1782 {
11c02a10 1783 context_cpy (UNWIND_CONTEXT (fi), UNWIND_CONTEXT (get_next_frame (fi)));
b6af0555
JS		 1784 frame_state_for (UNWIND_CONTEXT (fi), fs);
1785 update_context (UNWIND_CONTEXT (fi), fs, 1);
1786 }
1787 else
1788 {
50abf9e5 1789 UNWIND_CONTEXT (fi)->ra = get_frame_pc (fi) + 1;
b6af0555
JS		 1790 frame_state_for (UNWIND_CONTEXT (fi), fs);
1791 update_context (UNWIND_CONTEXT (fi), fs, 0);
1792 }
264d1763 1793
b6af0555
JS		 1794 unwind_tmp_obstack_free ();
1795}
1796
1797/* Obtain return address of the frame. */
1798CORE_ADDR
1799cfi_get_ra (struct frame_info *fi)
1800{
1801 return UNWIND_CONTEXT (fi)->ra;
1802}
1803
1804/* Find register number REGNUM relative to FRAME and put its
1805 (raw) contents in *RAW_BUFFER. Set *OPTIMIZED if the variable
1806 was optimized out (and thus can't be fetched). If the variable
1807 was fetched from memory, set *ADDRP to where it was fetched from,
1808 otherwise it was fetched from a register.
1809
1810 The argument RAW_BUFFER must point to aligned memory. */
1811void
1812cfi_get_saved_register (char *raw_buffer,
1813 int *optimized,
19d833a2 1814 CORE_ADDR *addrp,
b6af0555
JS		 1815 struct frame_info *frame,
1816 int regnum, enum lval_type *lval)
1817{
1818 if (!target_has_registers)
1819 error ("No registers.");
1820
1821 /* Normal systems don't optimize out things with register numbers. */
1822 if (optimized != NULL)
1823 *optimized = 0;
1824
1825 if (addrp) /* default assumption: not found in memory */
1826 *addrp = 0;
1827
11c02a10 1828 if (!get_next_frame (frame))
b6af0555 1829 {
4caf0990 1830 deprecated_read_register_gen (regnum, raw_buffer);
b6af0555
JS		 1831 if (lval != NULL)
1832 *lval = lval_register;
1833 if (addrp != NULL)
1834 *addrp = REGISTER_BYTE (regnum);
1835 }
1836 else
1837 {
11c02a10 1838 frame = get_next_frame (frame);
b6af0555
JS		 1839 switch (UNWIND_CONTEXT (frame)->reg[regnum].how)
1840 {
1841 case REG_CTX_UNSAVED:
4caf0990 1842 deprecated_read_register_gen (regnum, raw_buffer);
b6af0555
JS		 1843 if (lval != NULL)
1844 *lval = not_lval;
1845 if (optimized != NULL)
1846 *optimized = 1;
1847 break;
1848 case REG_CTX_SAVED_OFFSET:
1849 target_read_memory (UNWIND_CONTEXT (frame)->cfa +
1850 UNWIND_CONTEXT (frame)->reg[regnum].loc.offset,
1851 raw_buffer, REGISTER_RAW_SIZE (regnum));
1852 if (lval != NULL)
1853 *lval = lval_memory;
1854 if (addrp != NULL)
1855 *addrp =
1856 UNWIND_CONTEXT (frame)->cfa +
1857 UNWIND_CONTEXT (frame)->reg[regnum].loc.offset;
1858 break;
1859 case REG_CTX_SAVED_REG:
4caf0990
AC		 1860 deprecated_read_register_gen (UNWIND_CONTEXT (frame)->reg[regnum].loc.reg,
1861 raw_buffer);
b6af0555
JS		 1862 if (lval != NULL)
1863 *lval = lval_register;
1864 if (addrp != NULL)
1865 *addrp =
1866 REGISTER_BYTE (UNWIND_CONTEXT (frame)->reg[regnum].loc.reg);
1867 break;
1868 case REG_CTX_SAVED_ADDR:
1869 target_read_memory (UNWIND_CONTEXT (frame)->reg[regnum].loc.addr,
1870 raw_buffer, REGISTER_RAW_SIZE (regnum));
1871 if (lval != NULL)
1872 *lval = lval_memory;
1873 if (addrp != NULL)
1874 *addrp = UNWIND_CONTEXT (frame)->reg[regnum].loc.addr;
1875 break;
1876 case REG_CTX_VALUE:
1877 memcpy (raw_buffer, &UNWIND_CONTEXT (frame)->reg[regnum].loc.addr,
1878 REGISTER_RAW_SIZE (regnum));
1879 if (lval != NULL)
1880 *lval = not_lval;
1881 if (optimized != NULL)
1882 *optimized = 0;
1883 break;
1884 default:
1885 internal_error (__FILE__, __LINE__,
1886 "cfi_get_saved_register: unknown register rule");
1887 }
1888 }
1889}
1890
1891/* Return the register that the function uses for a frame pointer,
1892 plus any necessary offset to be applied to the register before
1893 any frame pointer offsets. */
1894void
1895cfi_virtual_frame_pointer (CORE_ADDR pc, int *frame_reg,
1896 LONGEST * frame_offset)
1897{
1898 struct context *context;
1899 struct frame_state *fs;
1900
23aa4c72
ML		 1901 unwind_tmp_obstack_init ();
1902
b6af0555
JS		 1903 context = context_alloc ();
1904 fs = frame_state_alloc ();
1905
1906 context->ra = read_pc () + 1;
1907
1908 frame_state_for (context, fs);
1909
1910 if (fs->cfa_how == CFA_REG_OFFSET)
1911 {
1912 *frame_reg = fs->cfa_reg;
1913 *frame_offset = fs->cfa_offset;
1914 }
1915 else
1916 error ("dwarf cfi error: CFA is not defined as CFA_REG_OFFSET");
1917
1918 unwind_tmp_obstack_free ();
1919}
GDB Binutils - Deliverables
This page took 0.281925 seconds and 4 git commands to generate.