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