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