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