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