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