projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* config/alpha/tm-fbsd.h (FRAME_CHAIN_VALID): Remove.
[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 ();
204static void unwind_tmp_obstack_free ();
205static void context_cpy (struct context *dst, struct context *src);
206
207static unsigned int read_1u (bfd *abfd, char **p);
208static int read_1s (bfd *abfd, char **p);
209static unsigned int read_2u (bfd *abfd, char **p);
210static int read_2s (bfd *abfd, char **p);
211static unsigned int read_4u (bfd *abfd, char **p);
212static int read_4s (bfd *abfd, char **p);
213static ULONGEST read_8u (bfd *abfd, char **p);
214static LONGEST read_8s (bfd *abfd, char **p);
215
216static ULONGEST read_uleb128 (bfd *abfd, char **p);
217static LONGEST read_sleb128 (bfd *abfd, char **p);
218static CORE_ADDR read_pointer (bfd *abfd, char **p);
219static CORE_ADDR read_encoded_pointer (bfd *abfd, char **p,
220 unsigned char encoding);
221
222static LONGEST read_initial_length (bfd *abfd, char *buf, int *bytes_read);
223static ULONGEST read_length (bfd *abfd, char *buf, int *bytes_read,
224 int dwarf64);
225static ULONGEST read_address (bfd *abfd, char **p);
226
227
228static int is_cie (ULONGEST cie_id, int dwarf64);
229static int compare_fde_unit (const void *a, const void *b);
230void dwarf2_build_frame_info (struct objfile *objfile);
231
232static void execute_cfa_program (struct objfile *objfile, char *insn_ptr,
233 char *insn_end, struct context *context,
234 struct frame_state *fs);
235static struct fde_unit *get_fde_for_addr (CORE_ADDR pc);
236static void frame_state_for (struct context *context, struct frame_state *fs);
237static void get_reg (char *reg, struct context *context, int regnum);
238static CORE_ADDR execute_stack_op (struct objfile *objfile,
239 char *op_ptr, char *op_end,
240 struct context *context, CORE_ADDR initial);
241static void update_context (struct context *context, struct frame_state *fs,
242 int chain);
243
244\f
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;
283 struct context_reg *reg;
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;
300 struct frame_state_reg *reg;
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));
306 fs->regs.reg = (struct frame_state_reg *) obstack_alloc (&unwind_tmp_obstack,
307 regs_size);
308 memset (fs->regs.reg, 0, regs_size);
309 return fs;
310}
311
312static void
313unwind_tmp_obstack_free ()
314{
315 obstack_free (&unwind_tmp_obstack, NULL);
316 obstack_init (&unwind_tmp_obstack);
317}
318
319static void
320context_cpy (struct context *dst, struct context *src)
321{
322 struct context_reg *reg = dst->reg;
323 int regs_size = sizeof (struct context_reg) * NUM_REGS;
324
325 *dst = *src;
326 memcpy (dst->reg, src->reg, regs_size);
327}
328\f
329
330static unsigned int
331read_1u (bfd *abfd, char **p)
332{
333 unsigned ret;
334
335 ret= bfd_get_8 (abfd, (bfd_byte *) *p);
336 (*p) ++;
337 return ret;
338}
339
340static int
341read_1s (bfd *abfd, char **p)
342{
343 int ret;
344
345 ret= bfd_get_signed_8 (abfd, (bfd_byte *) *p);
346 (*p) ++;
347 return ret;
348}
349
350static unsigned int
351read_2u (bfd *abfd, char **p)
352{
353 unsigned ret;
354
355 ret= bfd_get_16 (abfd, (bfd_byte *) *p);
356 (*p) ++;
357 return ret;
358}
359
360static int
361read_2s (bfd *abfd, char **p)
362{
363 int ret;
364
365 ret= bfd_get_signed_16 (abfd, (bfd_byte *) *p);
366 (*p) += 2;
367 return ret;
368}
369
370static unsigned int
371read_4u (bfd *abfd, char **p)
372{
373 unsigned int ret;
374
375 ret= bfd_get_32 (abfd, (bfd_byte *) *p);
376 (*p) += 4;
377 return ret;
378}
379
380static int
381read_4s (bfd *abfd, char **p)
382{
383 int ret;
384
385 ret= bfd_get_signed_32 (abfd, (bfd_byte *) *p);
386 (*p) += 4;
387 return ret;
388}
389
390static ULONGEST
391read_8u (bfd *abfd, char **p)
392{
393 ULONGEST ret;
394
395 ret = bfd_get_64 (abfd, (bfd_byte *) *p);
396 (*p) += 8;
397 return ret;
398}
399
400static LONGEST
401read_8s (bfd *abfd, char **p)
402{
403 LONGEST ret;
404
405 ret = bfd_get_signed_64 (abfd, (bfd_byte *) *p);
406 (*p) += 8;
407 return ret;
408}
409
410static ULONGEST
411read_uleb128 (bfd *abfd, char **p)
412{
413 ULONGEST ret;
414 int i, shift;
415 unsigned char byte;
416
417 ret = 0;
418 shift = 0;
419 i = 0;
420 while (1)
421 {
422 byte = bfd_get_8 (abfd, (bfd_byte *) *p);
423 (*p) ++;
424 ret |= ((unsigned long) (byte & 127) << shift);
425 if ((byte & 128) == 0)
426 {
427 break;
428 }
429 shift += 7;
430 }
431 return ret;
432}
433
434static LONGEST
435read_sleb128 (bfd *abfd, char **p)
436{
437 LONGEST ret;
438 int i, shift, size, num_read;
439 unsigned char byte;
440
441 ret = 0;
442 shift = 0;
443 size = 32;
444 num_read = 0;
445 i = 0;
446 while (1)
447 {
448 byte = bfd_get_8 (abfd, (bfd_byte *) *p);
449 (*p) ++;
450 ret |= ((long) (byte & 127) << shift);
451 shift += 7;
452 if ((byte & 128) == 0)
453 {
454 break;
455 }
456 }
457 if ((shift < size) && (byte & 0x40))
458 {
459 ret |= -(1 << shift);
460 }
461 return ret;
462}
463
464static CORE_ADDR
465read_pointer (bfd *abfd, char **p)
466{
467 switch (TARGET_ADDR_BIT / TARGET_CHAR_BIT)
468 {
469 case 4:
470 return read_4u (abfd, p);
471 case 8:
472 return read_8u (abfd, p);
473 default:
474 error ("dwarf cfi error: unsupported target address length.");
475 }
476}
477
478static CORE_ADDR
479read_encoded_pointer (bfd *abfd, char **p, unsigned char encoding)
480{
481 CORE_ADDR ret;
482
483 switch (encoding & 0x0f)
484 {
485 case DW_EH_PE_absptr:
486 ret = read_pointer (abfd, p);
487 break;
488
489 case DW_EH_PE_uleb128:
490 ret = read_uleb128 (abfd, p);
491 break;
492 case DW_EH_PE_sleb128:
493 ret = read_sleb128 (abfd, p);
494 break;
495
496 case DW_EH_PE_udata2:
497 ret = read_2u (abfd, p);
498 break;
499 case DW_EH_PE_udata4:
500 ret = read_4u (abfd, p);
501 break;
502 case DW_EH_PE_udata8:
503 ret = read_8u (abfd, p);
504 break;
505
506 case DW_EH_PE_sdata2:
507 ret = read_2s (abfd, p);
508 break;
509 case DW_EH_PE_sdata4:
510 ret = read_4s (abfd, p);
511 break;
512 case DW_EH_PE_sdata8:
513 ret = read_8s (abfd, p);
514 break;
515
516 default:
517 internal_error (__FILE__, __LINE__,
518 "read_encoded_pointer: unknown pointer encoding");
519 }
520
521 if (ret != 0)
522 switch (encoding & 0xf0)
523 {
524 case DW_EH_PE_absptr:
525 break;
526 case DW_EH_PE_pcrel:
527 ret += (CORE_ADDR) *p;
528 break;
529 case DW_EH_PE_textrel:
530 case DW_EH_PE_datarel:
531 case DW_EH_PE_funcrel:
532 default:
533 internal_error (__FILE__, __LINE__,
534 "read_encoded_pointer: unknown pointer encoding");
535 }
536
537 return ret;
538}
539
540static LONGEST
541read_initial_length (bfd * abfd, char *buf, int *bytes_read)
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
561read_length (bfd * abfd, char *buf, int *bytes_read, int dwarf64)
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
576execute_cfa_program ( struct objfile *objfile, char *insn_ptr, char *insn_end,
577 struct context *context, struct frame_state *fs)
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;
589 int bytes_read;
590
591 if (insn & DW_CFA_advance_loc)
592 fs->pc += (insn & 0x3f) * fs->code_align;
593 else if (insn & DW_CFA_offset)
594 {
595 reg = insn & 0x3f;
596 uoffset = read_uleb128 (objfile->obfd, &insn_ptr);
597 offset = (long) uoffset * fs->data_align;
598 fs->regs.reg[reg].how = REG_SAVED_OFFSET;
599 fs->regs.reg[reg].loc.offset = offset;
600 }
601 else if (insn & DW_CFA_restore)
602 {
603 reg = insn & 0x3f;
604 fs->regs.reg[reg].how = REG_UNSAVED;
605 }
606 else
607 switch (insn)
608 {
609 case DW_CFA_set_loc:
610 fs->pc = read_encoded_pointer (objfile->obfd, &insn_ptr,
611 fs->addr_encoding);
612 break;
613
614 case DW_CFA_advance_loc1:
615 fs->pc += read_1u (objfile->obfd, &insn_ptr);
616 break;
617 case DW_CFA_advance_loc2:
618 fs->pc += read_2u (objfile->obfd, &insn_ptr);
619 break;
620 case DW_CFA_advance_loc4:
621 fs->pc += read_4u (objfile->obfd, &insn_ptr);
622 break;
623
624 case DW_CFA_offset_extended:
625 reg = read_uleb128 (objfile->obfd, &insn_ptr);
626 uoffset = read_uleb128 (objfile->obfd, &insn_ptr);
627 offset = (long) uoffset *fs->data_align;
628 fs->regs.reg[reg].how = REG_SAVED_OFFSET;
629 fs->regs.reg[reg].loc.offset = offset;
630 break;
631
632 case DW_CFA_restore_extended:
633 reg = read_uleb128 (objfile->obfd, &insn_ptr);
634 fs->regs.reg[reg].how = REG_UNSAVED;
635 break;
636
637 case DW_CFA_undefined:
638 case DW_CFA_same_value:
639 case DW_CFA_nop:
640 break;
641
642 case DW_CFA_register:
643 {
644 ULONGEST reg2;
645 reg = read_uleb128 (objfile->obfd, &insn_ptr);
646 reg2 = read_uleb128 (objfile->obfd, &insn_ptr);
647 fs->regs.reg[reg].how = REG_SAVED_REG;
648 fs->regs.reg[reg].loc.reg = reg2;
649 }
650 break;
651
652 case DW_CFA_remember_state:
653 {
654 struct frame_state_regs *new_rs;
655 if (unused_rs)
656 {
657 new_rs = unused_rs;
658 unused_rs = unused_rs->prev;
659 }
660 else
661 new_rs = xmalloc (sizeof (struct frame_state_regs));
662
663 *new_rs = fs->regs;
664 fs->regs.prev = new_rs;
665 }
666 break;
667
668 case DW_CFA_restore_state:
669 {
670 struct frame_state_regs *old_rs = fs->regs.prev;
671 fs->regs = *old_rs;
672 old_rs->prev = unused_rs;
673 unused_rs = old_rs;
674 }
675 break;
676
677 case DW_CFA_def_cfa:
678 reg = read_uleb128 (objfile->obfd, &insn_ptr);
679 uoffset = read_uleb128 (objfile->obfd, &insn_ptr);
680 fs->cfa_reg = reg;
681 fs->cfa_offset = uoffset;
682 fs->cfa_how = CFA_REG_OFFSET;
683 break;
684
685 case DW_CFA_def_cfa_register:
686 reg = read_uleb128 (objfile->obfd, &insn_ptr);
687 fs->cfa_reg = reg;
688 fs->cfa_how = CFA_REG_OFFSET;
689 break;
690
691 case DW_CFA_def_cfa_offset:
692 uoffset = read_uleb128 (objfile->obfd, &insn_ptr);
693 fs->cfa_offset = uoffset;
694 break;
695
696 case DW_CFA_def_cfa_expression:
697 uoffset = read_uleb128 (objfile->obfd, &insn_ptr);
698 fs->cfa_exp = insn_ptr;
699 fs->cfa_how = CFA_EXP;
700 insn_ptr += uoffset;
701 break;
702
703 case DW_CFA_expression:
704 reg = read_uleb128 (objfile->obfd, &insn_ptr);
705 uoffset = read_uleb128 (objfile->obfd, &insn_ptr);
706 fs->regs.reg[reg].how = REG_SAVED_EXP;
707 fs->regs.reg[reg].loc.exp = insn_ptr;
708 insn_ptr += uoffset;
709 break;
710
711 /* From the 2.1 draft. */
712 case DW_CFA_offset_extended_sf:
713 reg = read_uleb128 (objfile->obfd, &insn_ptr);
714 offset = read_sleb128 (objfile->obfd, &insn_ptr);
715 offset *= fs->data_align;
716 fs->regs.reg[reg].how = REG_SAVED_OFFSET;
717 fs->regs.reg[reg].loc.offset = offset;
718 break;
719
720 case DW_CFA_def_cfa_sf:
721 reg = read_uleb128 (objfile->obfd, &insn_ptr);
722 offset = read_sleb128 (objfile->obfd, &insn_ptr);
723 fs->cfa_offset = offset;
724 fs->cfa_reg = reg;
725 fs->cfa_how = CFA_REG_OFFSET;
726 break;
727
728 case DW_CFA_def_cfa_offset_sf:
729 uoffset = read_uleb128 (objfile->obfd, &insn_ptr);
730 fs->cfa_offset = uoffset;
731 /* cfa_how deliberately not set. */
732 break;
733
734 case DW_CFA_GNU_window_save:
735 /* ??? Hardcoded for SPARC register window configuration. */
736 for (reg = 16; reg < 32; ++reg)
737 {
738 fs->regs.reg[reg].how = REG_SAVED_OFFSET;
739 fs->regs.reg[reg].loc.offset = (reg - 16) * sizeof (void *);
740 }
741 break;
742
743 case DW_CFA_GNU_args_size:
744 uoffset = read_uleb128 (objfile->obfd, &insn_ptr);
745 context->args_size = uoffset;
746 break;
747
748 case DW_CFA_GNU_negative_offset_extended:
749 /* Obsoleted by DW_CFA_offset_extended_sf, but used by
750 older PowerPC code. */
751 reg = read_uleb128 (objfile->obfd, &insn_ptr);
752 uoffset = read_uleb128 (objfile->obfd, &insn_ptr);
753 offset = (long) uoffset *fs->data_align;
754 fs->regs.reg[reg].how = REG_SAVED_OFFSET;
755 fs->regs.reg[reg].loc.offset = -offset;
756 break;
757
758 default:
759 error ("dwarf cfi error: unknown cfa instruction %d.", insn);
760 }
761 }
762}
763
764static struct fde_unit *
765get_fde_for_addr (CORE_ADDR pc)
766{
767 size_t lo, hi;
768 struct fde_unit *fde = NULL;
769 lo = 0;
770 hi = fde_chunks.elems;
771
772 while (lo < hi)
773 {
774 size_t i = (lo + hi) / 2;
775 fde = fde_chunks.array[i];
776 if (pc < fde->initial_location)
777 hi = i;
778 else if (pc >= fde->initial_location + fde->address_range)
779 lo = i + 1;
780 else
781 return fde;
782 }
783 return 0;
784}
785
786static void
787frame_state_for (struct context *context, struct frame_state *fs)
788{
789 struct fde_unit *fde;
790 struct cie_unit *cie;
791 unsigned char *aug, *insn, *end;
792
793 context->args_size = 0;
794 context->lsda = 0;
795
796 if ((fde = get_fde_for_addr (context->ra - 1)) != NULL)
797 {
798 fs->pc = fde->initial_location;
799
800 cie = fde->cie_ptr;
801 fs->code_align = cie->code_align;
802 fs->data_align = cie->data_align;
803 fs->retaddr_column = cie->ra;
804 fs->addr_encoding = cie->addr_encoding;
805 fs->objfile = cie->objfile;
806
807 execute_cfa_program (cie->objfile, cie->data,
808 cie->data + cie->data_length, context, fs);
809 execute_cfa_program (cie->objfile, fde->data,
810 fde->data + fde->data_length, context, fs);
811 }
812}
813
814static void
815get_reg (char *reg, struct context *context, int regnum)
816{
817 switch (context->reg[regnum].how)
818 {
819 case REG_CTX_UNSAVED:
820 read_register_gen (regnum, reg);
821 break;
822 case REG_CTX_SAVED_OFFSET:
823 target_read_memory (context->cfa + context->reg[regnum].loc.offset,
824 reg, REGISTER_RAW_SIZE (regnum));
825 break;
826 case REG_CTX_SAVED_REG:
827 read_register_gen (context->reg[regnum].loc.reg, reg);
828 break;
829 case REG_CTX_SAVED_ADDR:
830 target_read_memory (context->reg[regnum].loc.addr,
831 reg, REGISTER_RAW_SIZE (regnum));
832 break;
833 case REG_CTX_VALUE:
834 memcpy (reg, &context->reg[regnum].loc.addr,
835 REGISTER_RAW_SIZE (regnum));
836 break;
837 default:
838 internal_error (__FILE__, __LINE__,
839 "get_reg: unknown register rule");
840 }
841}
842
843/* Decode a DW_OP stack program. Return the top of stack. Push INITIAL
844 onto the stack to start. */
845static CORE_ADDR
846execute_stack_op (struct objfile *objfile,
847 char *op_ptr, char *op_end, struct context *context,
848 CORE_ADDR initial)
849{
850 CORE_ADDR stack[64]; /* ??? Assume this is enough. */
851 int stack_elt;
852
853 stack[0] = initial;
854 stack_elt = 1;
855
856 while (op_ptr < op_end)
857 {
858 enum dwarf_location_atom op = *op_ptr++;
859 ULONGEST result, reg;
860 LONGEST offset;
861
862 switch (op)
863 {
864 case DW_OP_lit0:
865 case DW_OP_lit1:
866 case DW_OP_lit2:
867 case DW_OP_lit3:
868 case DW_OP_lit4:
869 case DW_OP_lit5:
870 case DW_OP_lit6:
871 case DW_OP_lit7:
872 case DW_OP_lit8:
873 case DW_OP_lit9:
874 case DW_OP_lit10:
875 case DW_OP_lit11:
876 case DW_OP_lit12:
877 case DW_OP_lit13:
878 case DW_OP_lit14:
879 case DW_OP_lit15:
880 case DW_OP_lit16:
881 case DW_OP_lit17:
882 case DW_OP_lit18:
883 case DW_OP_lit19:
884 case DW_OP_lit20:
885 case DW_OP_lit21:
886 case DW_OP_lit22:
887 case DW_OP_lit23:
888 case DW_OP_lit24:
889 case DW_OP_lit25:
890 case DW_OP_lit26:
891 case DW_OP_lit27:
892 case DW_OP_lit28:
893 case DW_OP_lit29:
894 case DW_OP_lit30:
895 case DW_OP_lit31:
896 result = op - DW_OP_lit0;
897 break;
898
899 case DW_OP_addr:
900 result = read_pointer (objfile->obfd, &op_ptr);
901 break;
902
903 case DW_OP_const1u:
904 result = read_1u (objfile->obfd, &op_ptr);
905 break;
906 case DW_OP_const1s:
907 result = read_1s (objfile->obfd, &op_ptr);
908 break;
909 case DW_OP_const2u:
910 result = read_2u (objfile->obfd, &op_ptr);
911 break;
912 case DW_OP_const2s:
913 result = read_2s (objfile->obfd, &op_ptr);
914 break;
915 case DW_OP_const4u:
916 result = read_4u (objfile->obfd, &op_ptr);
917 break;
918 case DW_OP_const4s:
919 result = read_4s (objfile->obfd, &op_ptr);
920 break;
921 case DW_OP_const8u:
922 result = read_8u (objfile->obfd, &op_ptr);
923 break;
924 case DW_OP_const8s:
925 result = read_8s (objfile->obfd, &op_ptr);
926 break;
927 case DW_OP_constu:
928 result = read_uleb128 (objfile->obfd, &op_ptr);
929 break;
930 case DW_OP_consts:
931 result = read_sleb128 (objfile->obfd, &op_ptr);
932 break;
933
934 case DW_OP_reg0:
935 case DW_OP_reg1:
936 case DW_OP_reg2:
937 case DW_OP_reg3:
938 case DW_OP_reg4:
939 case DW_OP_reg5:
940 case DW_OP_reg6:
941 case DW_OP_reg7:
942 case DW_OP_reg8:
943 case DW_OP_reg9:
944 case DW_OP_reg10:
945 case DW_OP_reg11:
946 case DW_OP_reg12:
947 case DW_OP_reg13:
948 case DW_OP_reg14:
949 case DW_OP_reg15:
950 case DW_OP_reg16:
951 case DW_OP_reg17:
952 case DW_OP_reg18:
953 case DW_OP_reg19:
954 case DW_OP_reg20:
955 case DW_OP_reg21:
956 case DW_OP_reg22:
957 case DW_OP_reg23:
958 case DW_OP_reg24:
959 case DW_OP_reg25:
960 case DW_OP_reg26:
961 case DW_OP_reg27:
962 case DW_OP_reg28:
963 case DW_OP_reg29:
964 case DW_OP_reg30:
965 case DW_OP_reg31:
966 get_reg ((char *) &result, context, op - DW_OP_reg0);
967 break;
968 case DW_OP_regx:
969 reg = read_uleb128 (objfile->obfd, &op_ptr);
970 get_reg ((char *) &result, context, reg);
971 break;
972
973 case DW_OP_breg0:
974 case DW_OP_breg1:
975 case DW_OP_breg2:
976 case DW_OP_breg3:
977 case DW_OP_breg4:
978 case DW_OP_breg5:
979 case DW_OP_breg6:
980 case DW_OP_breg7:
981 case DW_OP_breg8:
982 case DW_OP_breg9:
983 case DW_OP_breg10:
984 case DW_OP_breg11:
985 case DW_OP_breg12:
986 case DW_OP_breg13:
987 case DW_OP_breg14:
988 case DW_OP_breg15:
989 case DW_OP_breg16:
990 case DW_OP_breg17:
991 case DW_OP_breg18:
992 case DW_OP_breg19:
993 case DW_OP_breg20:
994 case DW_OP_breg21:
995 case DW_OP_breg22:
996 case DW_OP_breg23:
997 case DW_OP_breg24:
998 case DW_OP_breg25:
999 case DW_OP_breg26:
1000 case DW_OP_breg27:
1001 case DW_OP_breg28:
1002 case DW_OP_breg29:
1003 case DW_OP_breg30:
1004 case DW_OP_breg31:
1005 offset = read_sleb128 (objfile->obfd, &op_ptr);
1006 get_reg ((char *) &result, context, op - DW_OP_breg0);
1007 result += offset;
1008 break;
1009 case DW_OP_bregx:
1010 reg = read_uleb128 (objfile->obfd, &op_ptr);
1011 offset = read_sleb128 (objfile->obfd, &op_ptr);
1012 get_reg ((char *) &result, context, reg);
1013 result += offset;
1014 break;
1015
1016 case DW_OP_dup:
1017 if (stack_elt < 1)
1018 internal_error (__FILE__, __LINE__, "execute_stack_op error");
1019 result = stack[stack_elt - 1];
1020 break;
1021
1022 case DW_OP_drop:
1023 if (--stack_elt < 0)
1024 internal_error (__FILE__, __LINE__, "execute_stack_op error");
1025 goto no_push;
1026
1027 case DW_OP_pick:
1028 offset = *op_ptr++;
1029 if (offset >= stack_elt - 1)
1030 internal_error (__FILE__, __LINE__, "execute_stack_op error");
1031 result = stack[stack_elt - 1 - offset];
1032 break;
1033
1034 case DW_OP_over:
1035 if (stack_elt < 2)
1036 internal_error (__FILE__, __LINE__, "execute_stack_op error");
1037 result = stack[stack_elt - 2];
1038 break;
1039
1040 case DW_OP_rot:
1041 {
1042 CORE_ADDR t1, t2, t3;
1043
1044 if (stack_elt < 3)
1045 internal_error (__FILE__, __LINE__, "execute_stack_op error");
1046 t1 = stack[stack_elt - 1];
1047 t2 = stack[stack_elt - 2];
1048 t3 = stack[stack_elt - 3];
1049 stack[stack_elt - 1] = t2;
1050 stack[stack_elt - 2] = t3;
1051 stack[stack_elt - 3] = t1;
1052 goto no_push;
1053 }
1054
1055 case DW_OP_deref:
1056 case DW_OP_deref_size:
1057 case DW_OP_abs:
1058 case DW_OP_neg:
1059 case DW_OP_not:
1060 case DW_OP_plus_uconst:
1061 /* Unary operations. */
1062 if (--stack_elt < 0)
1063 internal_error (__FILE__, __LINE__, "execute_stack_op error");
1064 result = stack[stack_elt];
1065
1066 switch (op)
1067 {
1068 case DW_OP_deref:
1069 {
1070 char *ptr = (char *) result;
1071 result = read_pointer (objfile->obfd, &ptr);
1072 }
1073 break;
1074
1075 case DW_OP_deref_size:
1076 {
1077 char *ptr = (char *) result;
1078 switch (*op_ptr++)
1079 {
1080 case 1:
1081 result = read_1u (objfile->obfd, &ptr);
1082 break;
1083 case 2:
1084 result = read_2u (objfile->obfd, &ptr);
1085 break;
1086 case 4:
1087 result = read_4u (objfile->obfd, &ptr);
1088 break;
1089 case 8:
1090 result = read_8u (objfile->obfd, &ptr);
1091 break;
1092 default:
1093 internal_error (__FILE__, __LINE__,
1094 "execute_stack_op error");
1095 }
1096 }
1097 break;
1098
1099 case DW_OP_abs:
1100 if (result < 0)
1101 result = -result;
1102 break;
1103 case DW_OP_neg:
1104 result = -result;
1105 break;
1106 case DW_OP_not:
1107 result = ~result;
1108 break;
1109 case DW_OP_plus_uconst:
1110 result += read_uleb128 (objfile->obfd, &op_ptr);
1111 break;
1112 }
1113 break;
1114
1115 case DW_OP_and:
1116 case DW_OP_div:
1117 case DW_OP_minus:
1118 case DW_OP_mod:
1119 case DW_OP_mul:
1120 case DW_OP_or:
1121 case DW_OP_plus:
1122 case DW_OP_le:
1123 case DW_OP_ge:
1124 case DW_OP_eq:
1125 case DW_OP_lt:
1126 case DW_OP_gt:
1127 case DW_OP_ne:
1128 {
1129 /* Binary operations. */
1130 CORE_ADDR first, second;
1131 if ((stack_elt -= 2) < 0)
1132 internal_error (__FILE__, __LINE__, "execute_stack_op error");
1133 second = stack[stack_elt];
1134 first = stack[stack_elt + 1];
1135
1136 switch (op)
1137 {
1138 case DW_OP_and:
1139 result = second & first;
1140 break;
1141 case DW_OP_div:
1142 result = (LONGEST) second / (LONGEST) first;
1143 break;
1144 case DW_OP_minus:
1145 result = second - first;
1146 break;
1147 case DW_OP_mod:
1148 result = (LONGEST) second % (LONGEST) first;
1149 break;
1150 case DW_OP_mul:
1151 result = second * first;
1152 break;
1153 case DW_OP_or:
1154 result = second | first;
1155 break;
1156 case DW_OP_plus:
1157 result = second + first;
1158 break;
1159 case DW_OP_shl:
1160 result = second << first;
1161 break;
1162 case DW_OP_shr:
1163 result = second >> first;
1164 break;
1165 case DW_OP_shra:
1166 result = (LONGEST) second >> first;
1167 break;
1168 case DW_OP_xor:
1169 result = second ^ first;
1170 break;
1171 case DW_OP_le:
1172 result = (LONGEST) first <= (LONGEST) second;
1173 break;
1174 case DW_OP_ge:
1175 result = (LONGEST) first >= (LONGEST) second;
1176 break;
1177 case DW_OP_eq:
1178 result = (LONGEST) first == (LONGEST) second;
1179 break;
1180 case DW_OP_lt:
1181 result = (LONGEST) first < (LONGEST) second;
1182 break;
1183 case DW_OP_gt:
1184 result = (LONGEST) first > (LONGEST) second;
1185 break;
1186 case DW_OP_ne:
1187 result = (LONGEST) first != (LONGEST) second;
1188 break;
1189 }
1190 }
1191 break;
1192
1193 case DW_OP_skip:
1194 offset = read_2s (objfile->obfd, &op_ptr);
1195 op_ptr += offset;
1196 goto no_push;
1197
1198 case DW_OP_bra:
1199 if (--stack_elt < 0)
1200 internal_error (__FILE__, __LINE__, "execute_stack_op error");
1201 offset = read_2s (objfile->obfd, &op_ptr);
1202 if (stack[stack_elt] != 0)
1203 op_ptr += offset;
1204 goto no_push;
1205
1206 case DW_OP_nop:
1207 goto no_push;
1208
1209 default:
1210 internal_error (__FILE__, __LINE__, "execute_stack_op error");
1211 }
1212
1213 /* Most things push a result value. */
1214 if ((size_t) stack_elt >= sizeof (stack) / sizeof (*stack))
1215 internal_error (__FILE__, __LINE__, "execute_stack_op error");
1216 stack[++stack_elt] = result;
1217 no_push:;
1218 }
1219
1220 /* We were executing this program to get a value. It should be
1221 at top of stack. */
1222 if (--stack_elt < 0)
1223 internal_error (__FILE__, __LINE__, "execute_stack_op error");
1224 return stack[stack_elt];
1225}
1226
1227static void
1228update_context (struct context *context, struct frame_state *fs, int chain)
1229{
1230 struct context *orig_context;
1231 CORE_ADDR cfa;
1232 long i;
1233
1234 orig_context = context_alloc ();
1235 context_cpy (orig_context, context);
1236 /* Compute this frame's CFA. */
1237 switch (fs->cfa_how)
1238 {
1239 case CFA_REG_OFFSET:
1240 get_reg ((char *) &cfa, context, fs->cfa_reg);
1241 cfa += fs->cfa_offset;
1242 break;
1243
1244 case CFA_EXP:
1245 /* ??? No way of knowing what register number is the stack pointer
1246 to do the same sort of handling as above. Assume that if the
1247 CFA calculation is so complicated as to require a stack program
1248 that this will not be a problem. */
1249 {
1250 char *exp = fs->cfa_exp;
1251 ULONGEST len;
1252
1253 len = read_uleb128 (fs->objfile->obfd, &exp);
1254 cfa = (CORE_ADDR) execute_stack_op (fs->objfile, exp,
1255 exp + len, context, 0);
1256 break;
1257 }
1258 }
1259 context->cfa = cfa;
1260
1261 if (!chain)
1262 orig_context->cfa = cfa;
1263
1264 /* Compute the addresses of all registers saved in this frame. */
1265 for (i = 0; i < NUM_REGS; ++i)
1266 switch (fs->regs.reg[i].how)
1267 {
1268 case REG_UNSAVED:
1269 if (i == SP_REGNUM)
1270 {
1271 context->reg[i].how = REG_CTX_VALUE;
1272 context->reg[i].loc.addr = cfa;
1273 }
1274 else
1275 context->reg[i].how = REG_CTX_UNSAVED;
1276 break;
1277 case REG_SAVED_OFFSET:
1278 context->reg[i].how = REG_CTX_SAVED_OFFSET;
1279 context->reg[i].loc.offset = fs->regs.reg[i].loc.offset;
1280 break;
1281 case REG_SAVED_REG:
1282 switch (orig_context->reg[fs->regs.reg[i].loc.reg].how)
1283 {
1284 case REG_CTX_UNSAVED:
1285 context->reg[i].how = REG_CTX_UNSAVED;
1286 break;
1287 case REG_CTX_SAVED_OFFSET:
1288 context->reg[i].how = REG_CTX_SAVED_OFFSET;
1289 context->reg[i].loc.offset = orig_context->cfa - context->cfa +
1290 orig_context->reg[fs->regs.reg[i].loc.reg].loc.offset;
1291 break;
1292 case REG_CTX_SAVED_REG:
1293 context->reg[i].how = REG_CTX_SAVED_REG;
1294 context->reg[i].loc.reg =
1295 orig_context->reg[fs->regs.reg[i].loc.reg].loc.reg;
1296 break;
1297 case REG_CTX_SAVED_ADDR:
1298 context->reg[i].how = REG_CTX_SAVED_ADDR;
1299 context->reg[i].loc.addr =
1300 orig_context->reg[fs->regs.reg[i].loc.reg].loc.addr;
1301 default:
1302 internal_error (__FILE__, __LINE__,
1303 "cfi_update_context: unknown register rule");
1304 }
1305 break;
1306 case REG_SAVED_EXP:
1307 {
1308 char *exp = fs->regs.reg[i].loc.exp;
1309 ULONGEST len;
1310 CORE_ADDR val;
1311
1312 len = read_uleb128 (fs->objfile->obfd, &exp);
1313 val = execute_stack_op (fs->objfile, exp, exp + len,
1314 orig_context, cfa);
1315 context->reg[i].how = REG_CTX_SAVED_ADDR;
1316 context->reg[i].loc.addr = val;
1317 }
1318 break;
1319 default:
1320 internal_error (__FILE__, __LINE__,
1321 "cfi_update_context: unknown register rule");
1322
1323 }
1324 get_reg ((char *) &context->ra, context, fs->retaddr_column);
1325 unwind_tmp_obstack_free ();
1326}
1327
1328static int
1329is_cie (ULONGEST cie_id, int dwarf64)
1330{
1331 return dwarf64 ? (cie_id == 0xffffffffffffffff) : (cie_id == 0xffffffff);
1332}
1333
1334static int
1335compare_fde_unit (const void *a, const void *b)
1336{
1337 struct fde_unit **first, **second;
1338 first = (struct fde_unit **) a;
1339 second = (struct fde_unit **) b;
1340 if ((*first)->initial_location > (*second)->initial_location)
1341 return 1;
1342 else if ((*first)->initial_location < (*second)->initial_location)
1343 return -1;
1344 else
1345 return 0;
1346}
1347
1348/* Build the cie_chunks and fde_chunks tables from informations
1349 in .debug.frame section. */
1350void
1351dwarf2_build_frame_info (struct objfile *objfile)
1352{
1353 bfd *abfd = objfile->obfd;
1354 char *start = NULL;
1355 char *end = NULL;
1356
1357 obstack_init (&unwind_tmp_obstack);
1358
1359 dwarf_frame_buffer = 0;
1360
1361 if (dwarf_frame_offset)
1362 {
1363 dwarf_frame_buffer = dwarf2_read_section (objfile,
1364 dwarf_frame_offset,
1365 dwarf_frame_size);
1366
1367 start = dwarf_frame_buffer;
1368 end = dwarf_frame_buffer + dwarf_frame_size;
1369 }
1370 else if (dwarf_eh_frame_offset)
1371 {
1372 dwarf_frame_buffer = dwarf2_read_section (objfile,
1373 dwarf_eh_frame_offset,
1374 dwarf_eh_frame_size);
1375
1376 start = dwarf_frame_buffer;
1377 end = dwarf_frame_buffer + dwarf_eh_frame_size;
1378 }
1379
1380 if (start)
1381 {
1382 while (start < end)
1383 {
1384 unsigned long length;
1385 ULONGEST cie_id;
1386 ULONGEST unit_offset = start - dwarf_frame_buffer;
1387 int bytes_read;
1388 int dwarf64;
1389 char *block_end;
1390
1391 length = read_initial_length (abfd, start, &bytes_read);
1392 start += bytes_read;
1393 dwarf64 = (bytes_read == 12);
1394 block_end = start + length;
1395
1396 cie_id = read_length (abfd, start, &bytes_read, dwarf64);
1397 start += bytes_read;
1398
1399 if (is_cie (cie_id, dwarf64))
1400 {
1401 struct cie_unit *cie = cie_unit_alloc ();
1402 char *aug;
1403
1404 cie->objfile = objfile;
1405 cie->next = cie_chunks;
1406 cie_chunks = cie;
1407
1408 cie->objfile = objfile;
1409
1410 cie->offset = unit_offset;
1411
1412 start++; /* version */
1413
1414 cie->augmentation = aug = start;
1415 while (*start)
1416 start++;
1417 start++; /* skip past NUL */
1418
1419 cie->code_align = read_uleb128 (abfd, &start);
1420 cie->data_align = read_sleb128 (abfd, &start);
1421 cie->ra = read_1u (abfd, &start);
1422
1423 if (*aug == 'z')
1424 {
1425 int xtra = read_uleb128 (abfd, &start);
1426 start += xtra;
1427 ++aug;
1428 }
1429
1430 while (*aug != '\0')
1431 {
1432 if (aug[0] == 'e' && aug[1] == 'h')
1433 {
1434 start += sizeof (void *);
1435 aug += 2;
1436 }
1437 else if (aug[0] == 'R')
1438 {
1439 cie->addr_encoding = *start++;
1440 aug += 1;
1441 }
1442 else if (aug[0] == 'P')
1443 {
1444 CORE_ADDR ptr;
1445 ptr = read_encoded_pointer (abfd, &start,
1446 cie->addr_encoding);
1447 aug += 1;
1448 }
1449 else
1450 warning ("unknown augmentation");
1451 }
1452
1453 cie->data = start;
1454 cie->data_length = block_end - start;
1455 }
1456 else
1457 {
1458 struct fde_unit *fde;
1459 struct cie_unit *cie;
1460
1461 fde_chunks_need_space ();
1462 fde = fde_unit_alloc ();
1463
1464 fde_chunks.array[fde_chunks.elems++] = fde;
1465 fde->initial_location = read_pointer (abfd, &start);
1466 fde->address_range = read_pointer (abfd, &start);
1467
1468 for (cie = cie_chunks;
1469 cie && (cie->offset != cie_id); cie = cie->next);
1470 if (!cie)
1471 error ("dwarf cfi error: can't find CIE pointer");
1472 fde->cie_ptr = cie;
1473
1474 if (cie->augmentation[0] == 'z')
1475 read_uleb128 (abfd, &start);
1476
1477 fde->data = start;
1478 fde->data_length = block_end - start;
1479 }
1480 start = block_end;
1481 }
1482 qsort (fde_chunks.array, fde_chunks.elems,
1483 sizeof (struct fde_unit *), compare_fde_unit);
1484 }
1485}
1486\f
1487
1488/* Return the frame address. */
1489CORE_ADDR
1490cfi_read_fp ()
1491{
1492 struct context *context;
1493 struct frame_state *fs;
1494 CORE_ADDR cfa;
1495
1496 context = context_alloc ();
1497 fs = frame_state_alloc ();
1498
1499 context->ra = read_pc () + 1;
1500
1501 frame_state_for (context, fs);
1502 update_context (context, fs, 0);
1503
1504 cfa = context->cfa;
1505 unwind_tmp_obstack_free ();
1506 return cfa;
1507}
1508
8227c0ff
AC		 1509/* Store the frame address. This function is not used. */
1510
b6af0555
JS		 1511void
1512cfi_write_fp (CORE_ADDR val)
1513{
1514 struct context *context;
1515 struct frame_state *fs;
1516
1517 context = context_alloc ();
1518 fs = frame_state_alloc ();
1519
1520 context->ra = read_pc () + 1;
1521
1522 frame_state_for (context, fs);
1523
1524 if (fs->cfa_how == CFA_REG_OFFSET)
1525 {
1526 val -= fs->cfa_offset;
1527 write_register_gen (fs->cfa_reg, (char *) &val);
1528 }
1529 else
1530 warning ("Can't write fp.");
1531
1532 unwind_tmp_obstack_free ();
1533}
1534
1535/* Restore the machine to the state it had before the current frame
1536 was created. */
1537void
1538cfi_pop_frame (struct frame_info *fi)
1539{
1540 char regbuf[MAX_REGISTER_RAW_SIZE];
1541 int regnum;
1542
1543 fi = get_current_frame ();
1544
1545 for (regnum = 0; regnum < NUM_REGS; regnum++)
1546 {
1547 get_reg (regbuf, UNWIND_CONTEXT (fi), regnum);
1548 write_register_bytes (REGISTER_BYTE (regnum), regbuf,
1549 REGISTER_RAW_SIZE (regnum));
1550 }
1551 write_register (PC_REGNUM, UNWIND_CONTEXT (fi)->ra);
1552
1553 flush_cached_frames ();
1554}
1555
1556/* Determine the address of the calling function's frame. */
1557CORE_ADDR
1558cfi_frame_chain (struct frame_info *fi)
1559{
1560 struct context *context;
1561 struct frame_state *fs;
1562 CORE_ADDR cfa;
1563
1564 context = context_alloc ();
1565 fs = frame_state_alloc ();
1566 context_cpy (context, UNWIND_CONTEXT (fi));
1567
1568 /* outermost frame */
1569 if (context->ra == 0)
1570 {
1571 unwind_tmp_obstack_free ();
1572 return 0;
1573 }
1574
1575 frame_state_for (context, fs);
1576 update_context (context, fs, 1);
1577
1578 cfa = context->cfa;
1579 unwind_tmp_obstack_free ();
1580 return cfa;
1581}
1582
1583/* Sets the pc of the frame. */
1584void
1585cfi_init_frame_pc (int fromleaf, struct frame_info *fi)
1586{
1587 if (fi->next)
1588 get_reg ((char *) &(fi->pc), UNWIND_CONTEXT (fi->next), PC_REGNUM);
1589 else
1590 fi->pc = read_pc ();
1591}
1592
1593/* Initialize unwind context informations of the frame. */
1594void
1595cfi_init_extra_frame_info (int fromleaf, struct frame_info *fi)
1596{
1597 struct frame_state *fs;
1598
1599 fs = frame_state_alloc ();
1600 fi->context = frame_obstack_alloc (sizeof (struct context));
1601 UNWIND_CONTEXT (fi)->reg =
1602 frame_obstack_alloc (sizeof (struct context_reg) * NUM_REGS);
1603 memset (UNWIND_CONTEXT (fi)->reg, 0,
1604 sizeof (struct context_reg) * NUM_REGS);
1605
1606 if (fi->next)
1607 {
1608 context_cpy (UNWIND_CONTEXT (fi), UNWIND_CONTEXT (fi->next));
1609 frame_state_for (UNWIND_CONTEXT (fi), fs);
1610 update_context (UNWIND_CONTEXT (fi), fs, 1);
1611 }
1612 else
1613 {
1614 UNWIND_CONTEXT (fi)->ra = fi->pc + 1;
1615 frame_state_for (UNWIND_CONTEXT (fi), fs);
1616 update_context (UNWIND_CONTEXT (fi), fs, 0);
1617 }
1618 unwind_tmp_obstack_free ();
1619}
1620
1621/* Obtain return address of the frame. */
1622CORE_ADDR
1623cfi_get_ra (struct frame_info *fi)
1624{
1625 return UNWIND_CONTEXT (fi)->ra;
1626}
1627
1628/* Find register number REGNUM relative to FRAME and put its
1629 (raw) contents in *RAW_BUFFER. Set *OPTIMIZED if the variable
1630 was optimized out (and thus can't be fetched). If the variable
1631 was fetched from memory, set *ADDRP to where it was fetched from,
1632 otherwise it was fetched from a register.
1633
1634 The argument RAW_BUFFER must point to aligned memory. */
1635void
1636cfi_get_saved_register (char *raw_buffer,
1637 int *optimized,
1638 CORE_ADDR * addrp,
1639 struct frame_info *frame,
1640 int regnum, enum lval_type *lval)
1641{
1642 if (!target_has_registers)
1643 error ("No registers.");
1644
1645 /* Normal systems don't optimize out things with register numbers. */
1646 if (optimized != NULL)
1647 *optimized = 0;
1648
1649 if (addrp) /* default assumption: not found in memory */
1650 *addrp = 0;
1651
1652 if (!frame->next)
1653 {
1654 read_register_gen (regnum, raw_buffer);
1655 if (lval != NULL)
1656 *lval = lval_register;
1657 if (addrp != NULL)
1658 *addrp = REGISTER_BYTE (regnum);
1659 }
1660 else
1661 {
1662 frame = frame->next;
1663 switch (UNWIND_CONTEXT (frame)->reg[regnum].how)
1664 {
1665 case REG_CTX_UNSAVED:
1666 read_register_gen (regnum, raw_buffer);
1667 if (lval != NULL)
1668 *lval = not_lval;
1669 if (optimized != NULL)
1670 *optimized = 1;
1671 break;
1672 case REG_CTX_SAVED_OFFSET:
1673 target_read_memory (UNWIND_CONTEXT (frame)->cfa +
1674 UNWIND_CONTEXT (frame)->reg[regnum].loc.offset,
1675 raw_buffer, REGISTER_RAW_SIZE (regnum));
1676 if (lval != NULL)
1677 *lval = lval_memory;
1678 if (addrp != NULL)
1679 *addrp =
1680 UNWIND_CONTEXT (frame)->cfa +
1681 UNWIND_CONTEXT (frame)->reg[regnum].loc.offset;
1682 break;
1683 case REG_CTX_SAVED_REG:
1684 read_register_gen (UNWIND_CONTEXT (frame)->reg[regnum].loc.reg,
1685 raw_buffer);
1686 if (lval != NULL)
1687 *lval = lval_register;
1688 if (addrp != NULL)
1689 *addrp =
1690 REGISTER_BYTE (UNWIND_CONTEXT (frame)->reg[regnum].loc.reg);
1691 break;
1692 case REG_CTX_SAVED_ADDR:
1693 target_read_memory (UNWIND_CONTEXT (frame)->reg[regnum].loc.addr,
1694 raw_buffer, REGISTER_RAW_SIZE (regnum));
1695 if (lval != NULL)
1696 *lval = lval_memory;
1697 if (addrp != NULL)
1698 *addrp = UNWIND_CONTEXT (frame)->reg[regnum].loc.addr;
1699 break;
1700 case REG_CTX_VALUE:
1701 memcpy (raw_buffer, &UNWIND_CONTEXT (frame)->reg[regnum].loc.addr,
1702 REGISTER_RAW_SIZE (regnum));
1703 if (lval != NULL)
1704 *lval = not_lval;
1705 if (optimized != NULL)
1706 *optimized = 0;
1707 break;
1708 default:
1709 internal_error (__FILE__, __LINE__,
1710 "cfi_get_saved_register: unknown register rule");
1711 }
1712 }
1713}
1714
1715/* Return the register that the function uses for a frame pointer,
1716 plus any necessary offset to be applied to the register before
1717 any frame pointer offsets. */
1718void
1719cfi_virtual_frame_pointer (CORE_ADDR pc, int *frame_reg,
1720 LONGEST * frame_offset)
1721{
1722 struct context *context;
1723 struct frame_state *fs;
1724
1725 context = context_alloc ();
1726 fs = frame_state_alloc ();
1727
1728 context->ra = read_pc () + 1;
1729
1730 frame_state_for (context, fs);
1731
1732 if (fs->cfa_how == CFA_REG_OFFSET)
1733 {
1734 *frame_reg = fs->cfa_reg;
1735 *frame_offset = fs->cfa_offset;
1736 }
1737 else
1738 error ("dwarf cfi error: CFA is not defined as CFA_REG_OFFSET");
1739
1740 unwind_tmp_obstack_free ();
1741}
GDB Binutils - Deliverables
This page took 0.116545 seconds and 4 git commands to generate.