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