projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
gdb/
[deliverable/binutils-gdb.git] / gdb / dwarf2-frame.c
CommitLineData
cfc14b3a
MK		 1/* Frame unwinder for frames with DWARF Call Frame Information.
2
7b6bb8da 3 Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011
0fb0cc75 4 Free Software Foundation, Inc.
cfc14b3a
MK		 5
6 Contributed by Mark Kettenis.
7
8 This file is part of GDB.
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
a9762ec7 12 the Free Software Foundation; either version 3 of the License, or
cfc14b3a
MK		 13 (at your option) any later version.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
a9762ec7 21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
cfc14b3a
MK		 22
23#include "defs.h"
24#include "dwarf2expr.h"
fa8f86ff 25#include "dwarf2.h"
cfc14b3a
MK		 26#include "frame.h"
27#include "frame-base.h"
28#include "frame-unwind.h"
29#include "gdbcore.h"
30#include "gdbtypes.h"
31#include "symtab.h"
32#include "objfiles.h"
33#include "regcache.h"
f2da6b3a 34#include "value.h"
cfc14b3a
MK		 35
36#include "gdb_assert.h"
37#include "gdb_string.h"
38
6896c0c7 39#include "complaints.h"
cfc14b3a 40#include "dwarf2-frame.h"
9f6f94ff
TT		 41#include "ax.h"
42#include "dwarf2loc.h"
8fbca658 43#include "exceptions.h"
cfc14b3a 44
ae0d2f24
UW		 45struct comp_unit;
46
cfc14b3a
MK		 47/* Call Frame Information (CFI). */
48
49/* Common Information Entry (CIE). */
50
51struct dwarf2_cie
52{
ae0d2f24
UW		 53 /* Computation Unit for this CIE. */
54 struct comp_unit *unit;
55
cfc14b3a
MK		 56 /* Offset into the .debug_frame section where this CIE was found.
57 Used to identify this CIE. */
58 ULONGEST cie_pointer;
59
60 /* Constant that is factored out of all advance location
61 instructions. */
62 ULONGEST code_alignment_factor;
63
64 /* Constants that is factored out of all offset instructions. */
65 LONGEST data_alignment_factor;
66
67 /* Return address column. */
68 ULONGEST return_address_register;
69
70 /* Instruction sequence to initialize a register set. */
852483bc
MK		 71 gdb_byte *initial_instructions;
72 gdb_byte *end;
cfc14b3a 73
303b6f5d
DJ		 74 /* Saved augmentation, in case it's needed later. */
75 char *augmentation;
76
cfc14b3a 77 /* Encoding of addresses. */
852483bc 78 gdb_byte encoding;
cfc14b3a 79
ae0d2f24
UW		 80 /* Target address size in bytes. */
81 int addr_size;
82
0963b4bd 83 /* Target pointer size in bytes. */
8da614df
CV		 84 int ptr_size;
85
7131cb6e
RH		 86 /* True if a 'z' augmentation existed. */
87 unsigned char saw_z_augmentation;
88
56c987f6
AO		 89 /* True if an 'S' augmentation existed. */
90 unsigned char signal_frame;
91
303b6f5d
DJ		 92 /* The version recorded in the CIE. */
93 unsigned char version;
2dc7f7b3
TT		 94
95 /* The segment size. */
96 unsigned char segment_size;
b01c8410 97};
303b6f5d 98
b01c8410
PP		 99struct dwarf2_cie_table
100{
101 int num_entries;
102 struct dwarf2_cie **entries;
cfc14b3a
MK		 103};
104
105/* Frame Description Entry (FDE). */
106
107struct dwarf2_fde
108{
109 /* CIE for this FDE. */
110 struct dwarf2_cie *cie;
111
112 /* First location associated with this FDE. */
113 CORE_ADDR initial_location;
114
115 /* Number of bytes of program instructions described by this FDE. */
116 CORE_ADDR address_range;
117
118 /* Instruction sequence. */
852483bc
MK		 119 gdb_byte *instructions;
120 gdb_byte *end;
cfc14b3a 121
4bf8967c
AS		 122 /* True if this FDE is read from a .eh_frame instead of a .debug_frame
123 section. */
124 unsigned char eh_frame_p;
b01c8410 125};
4bf8967c 126
b01c8410
PP		 127struct dwarf2_fde_table
128{
129 int num_entries;
130 struct dwarf2_fde **entries;
cfc14b3a
MK		 131};
132
ae0d2f24
UW		 133/* A minimal decoding of DWARF2 compilation units. We only decode
134 what's needed to get to the call frame information. */
135
136struct comp_unit
137{
138 /* Keep the bfd convenient. */
139 bfd *abfd;
140
141 struct objfile *objfile;
142
ae0d2f24
UW		 143 /* Pointer to the .debug_frame section loaded into memory. */
144 gdb_byte *dwarf_frame_buffer;
145
146 /* Length of the loaded .debug_frame section. */
c098b58b 147 bfd_size_type dwarf_frame_size;
ae0d2f24
UW		 148
149 /* Pointer to the .debug_frame section. */
150 asection *dwarf_frame_section;
151
152 /* Base for DW_EH_PE_datarel encodings. */
153 bfd_vma dbase;
154
155 /* Base for DW_EH_PE_textrel encodings. */
156 bfd_vma tbase;
157};
158
ac56253d
TT		 159static struct dwarf2_fde *dwarf2_frame_find_fde (CORE_ADDR *pc,
160 CORE_ADDR *out_offset);
4fc771b8
DJ		 161
162static int dwarf2_frame_adjust_regnum (struct gdbarch *gdbarch, int regnum,
163 int eh_frame_p);
ae0d2f24
UW		 164
165static CORE_ADDR read_encoded_value (struct comp_unit *unit, gdb_byte encoding,
0d45f56e 166 int ptr_len, const gdb_byte *buf,
ae0d2f24
UW		 167 unsigned int *bytes_read_ptr,
168 CORE_ADDR func_base);
cfc14b3a
MK		 169\f
170
171/* Structure describing a frame state. */
172
173struct dwarf2_frame_state
174{
175 /* Each register save state can be described in terms of a CFA slot,
176 another register, or a location expression. */
177 struct dwarf2_frame_state_reg_info
178 {
05cbe71a 179 struct dwarf2_frame_state_reg *reg;
cfc14b3a
MK		 180 int num_regs;
181
2fd481e1
PP		 182 LONGEST cfa_offset;
183 ULONGEST cfa_reg;
184 enum {
185 CFA_UNSET,
186 CFA_REG_OFFSET,
187 CFA_EXP
188 } cfa_how;
0d45f56e 189 const gdb_byte *cfa_exp;
2fd481e1 190
cfc14b3a
MK		 191 /* Used to implement DW_CFA_remember_state. */
192 struct dwarf2_frame_state_reg_info *prev;
193 } regs;
194
cfc14b3a
MK		 195 /* The PC described by the current frame state. */
196 CORE_ADDR pc;
197
198 /* Initial register set from the CIE.
199 Used to implement DW_CFA_restore. */
200 struct dwarf2_frame_state_reg_info initial;
201
202 /* The information we care about from the CIE. */
203 LONGEST data_align;
204 ULONGEST code_align;
205 ULONGEST retaddr_column;
303b6f5d
DJ		 206
207 /* Flags for known producer quirks. */
208
209 /* The ARM compilers, in DWARF2 mode, assume that DW_CFA_def_cfa
210 and DW_CFA_def_cfa_offset takes a factored offset. */
211 int armcc_cfa_offsets_sf;
212
213 /* The ARM compilers, in DWARF2 or DWARF3 mode, may assume that
214 the CFA is defined as REG - OFFSET rather than REG + OFFSET. */
215 int armcc_cfa_offsets_reversed;
cfc14b3a
MK		 216};
217
218/* Store the length the expression for the CFA in the `cfa_reg' field,
219 which is unused in that case. */
220#define cfa_exp_len cfa_reg
221
f57d151a 222/* Assert that the register set RS is large enough to store gdbarch_num_regs
cfc14b3a
MK		 223 columns. If necessary, enlarge the register set. */
224
225static void
226dwarf2_frame_state_alloc_regs (struct dwarf2_frame_state_reg_info *rs,
227 int num_regs)
228{
229 size_t size = sizeof (struct dwarf2_frame_state_reg);
230
231 if (num_regs <= rs->num_regs)
232 return;
233
234 rs->reg = (struct dwarf2_frame_state_reg *)
235 xrealloc (rs->reg, num_regs * size);
236
237 /* Initialize newly allocated registers. */
2473a4a9 238 memset (rs->reg + rs->num_regs, 0, (num_regs - rs->num_regs) * size);
cfc14b3a
MK		 239 rs->num_regs = num_regs;
240}
241
242/* Copy the register columns in register set RS into newly allocated
243 memory and return a pointer to this newly created copy. */
244
245static struct dwarf2_frame_state_reg *
246dwarf2_frame_state_copy_regs (struct dwarf2_frame_state_reg_info *rs)
247{
d10891d4 248 size_t size = rs->num_regs * sizeof (struct dwarf2_frame_state_reg);
cfc14b3a
MK		 249 struct dwarf2_frame_state_reg *reg;
250
251 reg = (struct dwarf2_frame_state_reg *) xmalloc (size);
252 memcpy (reg, rs->reg, size);
253
254 return reg;
255}
256
257/* Release the memory allocated to register set RS. */
258
259static void
260dwarf2_frame_state_free_regs (struct dwarf2_frame_state_reg_info *rs)
261{
262 if (rs)
263 {
264 dwarf2_frame_state_free_regs (rs->prev);
265
266 xfree (rs->reg);
267 xfree (rs);
268 }
269}
270
271/* Release the memory allocated to the frame state FS. */
272
273static void
274dwarf2_frame_state_free (void *p)
275{
276 struct dwarf2_frame_state *fs = p;
277
278 dwarf2_frame_state_free_regs (fs->initial.prev);
279 dwarf2_frame_state_free_regs (fs->regs.prev);
280 xfree (fs->initial.reg);
281 xfree (fs->regs.reg);
282 xfree (fs);
283}
284\f
285
286/* Helper functions for execute_stack_op. */
287
288static CORE_ADDR
289read_reg (void *baton, int reg)
290{
4a4e5149
DJ		 291 struct frame_info *this_frame = (struct frame_info *) baton;
292 struct gdbarch *gdbarch = get_frame_arch (this_frame);
cfc14b3a 293 int regnum;
852483bc 294 gdb_byte *buf;
cfc14b3a 295
ad010def 296 regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, reg);
cfc14b3a 297
852483bc 298 buf = alloca (register_size (gdbarch, regnum));
4a4e5149 299 get_frame_register (this_frame, regnum, buf);
f2da6b3a
DJ		 300
301 /* Convert the register to an integer. This returns a LONGEST
302 rather than a CORE_ADDR, but unpack_pointer does the same thing
303 under the covers, and this makes more sense for non-pointer
304 registers. Maybe read_reg and the associated interfaces should
305 deal with "struct value" instead of CORE_ADDR. */
306 return unpack_long (register_type (gdbarch, regnum), buf);
cfc14b3a
MK		 307}
308
309static void
852483bc 310read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
cfc14b3a
MK		 311{
312 read_memory (addr, buf, len);
313}
314
315static void
0d45f56e 316no_get_frame_base (void *baton, const gdb_byte **start, size_t *length)
cfc14b3a
MK		 317{
318 internal_error (__FILE__, __LINE__,
e2e0b3e5 319 _("Support for DW_OP_fbreg is unimplemented"));
cfc14b3a
MK		 320}
321
e7802207
TT		 322/* Helper function for execute_stack_op. */
323
324static CORE_ADDR
325no_get_frame_cfa (void *baton)
326{
327 internal_error (__FILE__, __LINE__,
328 _("Support for DW_OP_call_frame_cfa is unimplemented"));
329}
330
8cf6f0b1
TT		 331/* Helper function for execute_stack_op. */
332
333static CORE_ADDR
334no_get_frame_pc (void *baton)
335{
3e43a32a
MS		 336 internal_error (__FILE__, __LINE__, _("\
337Support for DW_OP_GNU_implicit_pointer is unimplemented"));
8cf6f0b1
TT		 338}
339
cfc14b3a
MK		 340static CORE_ADDR
341no_get_tls_address (void *baton, CORE_ADDR offset)
342{
3e43a32a
MS		 343 internal_error (__FILE__, __LINE__, _("\
344Support for DW_OP_GNU_push_tls_address is unimplemented"));
cfc14b3a
MK		 345}
346
5c631832
JK		 347/* Helper function for execute_stack_op. */
348
349static void
350no_dwarf_call (struct dwarf_expr_context *ctx, size_t die_offset)
351{
352 internal_error (__FILE__, __LINE__,
353 _("Support for DW_OP_call* is invalid in CFI"));
354}
355
8a9b8146
TT		 356/* Helper function for execute_stack_op. */
357
358static struct type *
359no_base_type (struct dwarf_expr_context *ctx, size_t die)
360{
361 error (_("Support for typed DWARF is not supported in CFI"));
362}
363
a6a5a945
LM		 364/* Execute the required actions for both the DW_CFA_restore and
365DW_CFA_restore_extended instructions. */
366static void
367dwarf2_restore_rule (struct gdbarch *gdbarch, ULONGEST reg_num,
368 struct dwarf2_frame_state *fs, int eh_frame_p)
369{
370 ULONGEST reg;
371
372 gdb_assert (fs->initial.reg);
373 reg = dwarf2_frame_adjust_regnum (gdbarch, reg_num, eh_frame_p);
374 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
375
376 /* Check if this register was explicitly initialized in the
377 CIE initial instructions. If not, default the rule to
378 UNSPECIFIED. */
379 if (reg < fs->initial.num_regs)
380 fs->regs.reg[reg] = fs->initial.reg[reg];
381 else
382 fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNSPECIFIED;
383
384 if (fs->regs.reg[reg].how == DWARF2_FRAME_REG_UNSPECIFIED)
385 complaint (&symfile_complaints, _("\
386incomplete CFI data; DW_CFA_restore unspecified\n\
5af949e3 387register %s (#%d) at %s"),
a6a5a945
LM		 388 gdbarch_register_name
389 (gdbarch, gdbarch_dwarf2_reg_to_regnum (gdbarch, reg)),
390 gdbarch_dwarf2_reg_to_regnum (gdbarch, reg),
5af949e3 391 paddress (gdbarch, fs->pc));
a6a5a945
LM		 392}
393
cfc14b3a 394static CORE_ADDR
0d45f56e 395execute_stack_op (const gdb_byte *exp, ULONGEST len, int addr_size,
ac56253d
TT		 396 CORE_ADDR offset, struct frame_info *this_frame,
397 CORE_ADDR initial, int initial_in_stack_memory)
cfc14b3a
MK		 398{
399 struct dwarf_expr_context *ctx;
400 CORE_ADDR result;
4a227398 401 struct cleanup *old_chain;
cfc14b3a
MK		 402
403 ctx = new_dwarf_expr_context ();
4a227398 404 old_chain = make_cleanup_free_dwarf_expr_context (ctx);
72fc29ff 405 make_cleanup_value_free_to_mark (value_mark ());
4a227398 406
f7fd4728 407 ctx->gdbarch = get_frame_arch (this_frame);
ae0d2f24 408 ctx->addr_size = addr_size;
ac56253d 409 ctx->offset = offset;
4a4e5149 410 ctx->baton = this_frame;
cfc14b3a
MK		 411 ctx->read_reg = read_reg;
412 ctx->read_mem = read_mem;
413 ctx->get_frame_base = no_get_frame_base;
e7802207 414 ctx->get_frame_cfa = no_get_frame_cfa;
8cf6f0b1 415 ctx->get_frame_pc = no_get_frame_pc;
cfc14b3a 416 ctx->get_tls_address = no_get_tls_address;
5c631832 417 ctx->dwarf_call = no_dwarf_call;
8a9b8146 418 ctx->get_base_type = no_base_type;
cfc14b3a 419
8a9b8146 420 dwarf_expr_push_address (ctx, initial, initial_in_stack_memory);
cfc14b3a 421 dwarf_expr_eval (ctx, exp, len);
cfc14b3a 422
f2c7657e
UW		 423 if (ctx->location == DWARF_VALUE_MEMORY)
424 result = dwarf_expr_fetch_address (ctx, 0);
425 else if (ctx->location == DWARF_VALUE_REGISTER)
8a9b8146 426 result = read_reg (this_frame, value_as_long (dwarf_expr_fetch (ctx, 0)));
f2c7657e 427 else
cec03d70
TT		 428 {
429 /* This is actually invalid DWARF, but if we ever do run across
430 it somehow, we might as well support it. So, instead, report
431 it as unimplemented. */
3e43a32a
MS		 432 error (_("\
433Not implemented: computing unwound register using explicit value operator"));
cec03d70 434 }
cfc14b3a 435
4a227398 436 do_cleanups (old_chain);
cfc14b3a
MK		 437
438 return result;
439}
440\f
441
442static void
0d45f56e 443execute_cfa_program (struct dwarf2_fde *fde, const gdb_byte *insn_ptr,
9f6f94ff
TT		 444 const gdb_byte *insn_end, struct gdbarch *gdbarch,
445 CORE_ADDR pc, struct dwarf2_frame_state *fs)
cfc14b3a 446{
ae0d2f24 447 int eh_frame_p = fde->eh_frame_p;
cfc14b3a 448 int bytes_read;
e17a4113 449 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
cfc14b3a
MK		 450
451 while (insn_ptr < insn_end && fs->pc <= pc)
452 {
852483bc 453 gdb_byte insn = *insn_ptr++;
cfc14b3a
MK		 454 ULONGEST utmp, reg;
455 LONGEST offset;
456
457 if ((insn & 0xc0) == DW_CFA_advance_loc)
458 fs->pc += (insn & 0x3f) * fs->code_align;
459 else if ((insn & 0xc0) == DW_CFA_offset)
460 {
461 reg = insn & 0x3f;
4fc771b8 462 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
cfc14b3a
MK		 463 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
464 offset = utmp * fs->data_align;
465 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
05cbe71a 466 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
cfc14b3a
MK		 467 fs->regs.reg[reg].loc.offset = offset;
468 }
469 else if ((insn & 0xc0) == DW_CFA_restore)
470 {
cfc14b3a 471 reg = insn & 0x3f;
a6a5a945 472 dwarf2_restore_rule (gdbarch, reg, fs, eh_frame_p);
cfc14b3a
MK		 473 }
474 else
475 {
476 switch (insn)
477 {
478 case DW_CFA_set_loc:
ae0d2f24 479 fs->pc = read_encoded_value (fde->cie->unit, fde->cie->encoding,
8da614df 480 fde->cie->ptr_size, insn_ptr,
ae0d2f24
UW		 481 &bytes_read, fde->initial_location);
482 /* Apply the objfile offset for relocatable objects. */
483 fs->pc += ANOFFSET (fde->cie->unit->objfile->section_offsets,
484 SECT_OFF_TEXT (fde->cie->unit->objfile));
cfc14b3a
MK		 485 insn_ptr += bytes_read;
486 break;
487
488 case DW_CFA_advance_loc1:
e17a4113 489 utmp = extract_unsigned_integer (insn_ptr, 1, byte_order);
cfc14b3a
MK		 490 fs->pc += utmp * fs->code_align;
491 insn_ptr++;
492 break;
493 case DW_CFA_advance_loc2:
e17a4113 494 utmp = extract_unsigned_integer (insn_ptr, 2, byte_order);
cfc14b3a
MK		 495 fs->pc += utmp * fs->code_align;
496 insn_ptr += 2;
497 break;
498 case DW_CFA_advance_loc4:
e17a4113 499 utmp = extract_unsigned_integer (insn_ptr, 4, byte_order);
cfc14b3a
MK		 500 fs->pc += utmp * fs->code_align;
501 insn_ptr += 4;
502 break;
503
504 case DW_CFA_offset_extended:
505 insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
4fc771b8 506 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
cfc14b3a
MK		 507 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
508 offset = utmp * fs->data_align;
509 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
05cbe71a 510 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
cfc14b3a
MK		 511 fs->regs.reg[reg].loc.offset = offset;
512 break;
513
514 case DW_CFA_restore_extended:
cfc14b3a 515 insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
a6a5a945 516 dwarf2_restore_rule (gdbarch, reg, fs, eh_frame_p);
cfc14b3a
MK		 517 break;
518
519 case DW_CFA_undefined:
520 insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
4fc771b8 521 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
cfc14b3a 522 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
05cbe71a 523 fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNDEFINED;
cfc14b3a
MK		 524 break;
525
526 case DW_CFA_same_value:
527 insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
4fc771b8 528 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
cfc14b3a 529 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
05cbe71a 530 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAME_VALUE;
cfc14b3a
MK		 531 break;
532
533 case DW_CFA_register:
534 insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
4fc771b8 535 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
cfc14b3a 536 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
4fc771b8 537 utmp = dwarf2_frame_adjust_regnum (gdbarch, utmp, eh_frame_p);
cfc14b3a 538 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
05cbe71a 539 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
cfc14b3a
MK		 540 fs->regs.reg[reg].loc.reg = utmp;
541 break;
542
543 case DW_CFA_remember_state:
544 {
545 struct dwarf2_frame_state_reg_info *new_rs;
546
547 new_rs = XMALLOC (struct dwarf2_frame_state_reg_info);
548 *new_rs = fs->regs;
549 fs->regs.reg = dwarf2_frame_state_copy_regs (&fs->regs);
550 fs->regs.prev = new_rs;
551 }
552 break;
553
554 case DW_CFA_restore_state:
555 {
556 struct dwarf2_frame_state_reg_info *old_rs = fs->regs.prev;
557
50ea7769
MK		 558 if (old_rs == NULL)
559 {
e2e0b3e5 560 complaint (&symfile_complaints, _("\
5af949e3
UW		 561bad CFI data; mismatched DW_CFA_restore_state at %s"),
562 paddress (gdbarch, fs->pc));
50ea7769
MK		 563 }
564 else
565 {
566 xfree (fs->regs.reg);
567 fs->regs = *old_rs;
568 xfree (old_rs);
569 }
cfc14b3a
MK		 570 }
571 break;
572
573 case DW_CFA_def_cfa:
2fd481e1 574 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->regs.cfa_reg);
cfc14b3a 575 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
303b6f5d
DJ		 576
577 if (fs->armcc_cfa_offsets_sf)
578 utmp *= fs->data_align;
579
2fd481e1
PP		 580 fs->regs.cfa_offset = utmp;
581 fs->regs.cfa_how = CFA_REG_OFFSET;
cfc14b3a
MK		 582 break;
583
584 case DW_CFA_def_cfa_register:
2fd481e1
PP		 585 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->regs.cfa_reg);
586 fs->regs.cfa_reg = dwarf2_frame_adjust_regnum (gdbarch,
587 fs->regs.cfa_reg,
588 eh_frame_p);
589 fs->regs.cfa_how = CFA_REG_OFFSET;
cfc14b3a
MK		 590 break;
591
592 case DW_CFA_def_cfa_offset:
852483bc 593 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
303b6f5d
DJ		 594
595 if (fs->armcc_cfa_offsets_sf)
596 utmp *= fs->data_align;
597
2fd481e1 598 fs->regs.cfa_offset = utmp;
cfc14b3a
MK		 599 /* cfa_how deliberately not set. */
600 break;
601
a8504492
MK		 602 case DW_CFA_nop:
603 break;
604
cfc14b3a 605 case DW_CFA_def_cfa_expression:
2fd481e1
PP		 606 insn_ptr = read_uleb128 (insn_ptr, insn_end,
607 &fs->regs.cfa_exp_len);
608 fs->regs.cfa_exp = insn_ptr;
609 fs->regs.cfa_how = CFA_EXP;
610 insn_ptr += fs->regs.cfa_exp_len;
cfc14b3a
MK		 611 break;
612
613 case DW_CFA_expression:
614 insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
4fc771b8 615 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
cfc14b3a
MK		 616 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
617 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
618 fs->regs.reg[reg].loc.exp = insn_ptr;
619 fs->regs.reg[reg].exp_len = utmp;
05cbe71a 620 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_EXP;
cfc14b3a
MK		 621 insn_ptr += utmp;
622 break;
623
a8504492
MK		 624 case DW_CFA_offset_extended_sf:
625 insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
4fc771b8 626 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
a8504492 627 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
f6da8dd8 628 offset *= fs->data_align;
a8504492 629 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
05cbe71a 630 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
a8504492
MK		 631 fs->regs.reg[reg].loc.offset = offset;
632 break;
633
46ea248b
AO		 634 case DW_CFA_val_offset:
635 insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
636 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
637 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
638 offset = utmp * fs->data_align;
639 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_OFFSET;
640 fs->regs.reg[reg].loc.offset = offset;
641 break;
642
643 case DW_CFA_val_offset_sf:
644 insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
645 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
646 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
647 offset *= fs->data_align;
648 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_OFFSET;
649 fs->regs.reg[reg].loc.offset = offset;
650 break;
651
652 case DW_CFA_val_expression:
653 insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
654 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
655 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
656 fs->regs.reg[reg].loc.exp = insn_ptr;
657 fs->regs.reg[reg].exp_len = utmp;
658 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_EXP;
659 insn_ptr += utmp;
660 break;
661
a8504492 662 case DW_CFA_def_cfa_sf:
2fd481e1
PP		 663 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->regs.cfa_reg);
664 fs->regs.cfa_reg = dwarf2_frame_adjust_regnum (gdbarch,
665 fs->regs.cfa_reg,
666 eh_frame_p);
a8504492 667 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
2fd481e1
PP		 668 fs->regs.cfa_offset = offset * fs->data_align;
669 fs->regs.cfa_how = CFA_REG_OFFSET;
a8504492
MK		 670 break;
671
672 case DW_CFA_def_cfa_offset_sf:
673 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
2fd481e1 674 fs->regs.cfa_offset = offset * fs->data_align;
a8504492 675 /* cfa_how deliberately not set. */
cfc14b3a
MK		 676 break;
677
a77f4086
MK		 678 case DW_CFA_GNU_window_save:
679 /* This is SPARC-specific code, and contains hard-coded
680 constants for the register numbering scheme used by
681 GCC. Rather than having a architecture-specific
682 operation that's only ever used by a single
683 architecture, we provide the implementation here.
684 Incidentally that's what GCC does too in its
685 unwinder. */
686 {
4a4e5149 687 int size = register_size (gdbarch, 0);
9a619af0 688
a77f4086
MK		 689 dwarf2_frame_state_alloc_regs (&fs->regs, 32);
690 for (reg = 8; reg < 16; reg++)
691 {
692 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
693 fs->regs.reg[reg].loc.reg = reg + 16;
694 }
695 for (reg = 16; reg < 32; reg++)
696 {
697 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
698 fs->regs.reg[reg].loc.offset = (reg - 16) * size;
699 }
700 }
701 break;
702
cfc14b3a
MK		 703 case DW_CFA_GNU_args_size:
704 /* Ignored. */
705 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
706 break;
707
58894217
JK		 708 case DW_CFA_GNU_negative_offset_extended:
709 insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
4fc771b8 710 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
58894217
JK		 711 insn_ptr = read_uleb128 (insn_ptr, insn_end, &offset);
712 offset *= fs->data_align;
713 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
714 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
715 fs->regs.reg[reg].loc.offset = -offset;
716 break;
717
cfc14b3a 718 default:
3e43a32a
MS		 719 internal_error (__FILE__, __LINE__,
720 _("Unknown CFI encountered."));
cfc14b3a
MK		 721 }
722 }
723 }
724
725 /* Don't allow remember/restore between CIE and FDE programs. */
726 dwarf2_frame_state_free_regs (fs->regs.prev);
727 fs->regs.prev = NULL;
728}
8f22cb90 729\f
cfc14b3a 730
8f22cb90 731/* Architecture-specific operations. */
cfc14b3a 732
8f22cb90
MK		 733/* Per-architecture data key. */
734static struct gdbarch_data *dwarf2_frame_data;
735
736struct dwarf2_frame_ops
737{
738 /* Pre-initialize the register state REG for register REGNUM. */
aff37fc1
DM		 739 void (*init_reg) (struct gdbarch *, int, struct dwarf2_frame_state_reg *,
740 struct frame_info *);
3ed09a32 741
4a4e5149 742 /* Check whether the THIS_FRAME is a signal trampoline. */
3ed09a32 743 int (*signal_frame_p) (struct gdbarch *, struct frame_info *);
4bf8967c 744
4fc771b8
DJ		 745 /* Convert .eh_frame register number to DWARF register number, or
746 adjust .debug_frame register number. */
747 int (*adjust_regnum) (struct gdbarch *, int, int);
cfc14b3a
MK		 748};
749
8f22cb90
MK		 750/* Default architecture-specific register state initialization
751 function. */
752
753static void
754dwarf2_frame_default_init_reg (struct gdbarch *gdbarch, int regnum,
aff37fc1 755 struct dwarf2_frame_state_reg *reg,
4a4e5149 756 struct frame_info *this_frame)
8f22cb90
MK		 757{
758 /* If we have a register that acts as a program counter, mark it as
759 a destination for the return address. If we have a register that
760 serves as the stack pointer, arrange for it to be filled with the
761 call frame address (CFA). The other registers are marked as
762 unspecified.
763
764 We copy the return address to the program counter, since many
765 parts in GDB assume that it is possible to get the return address
766 by unwinding the program counter register. However, on ISA's
767 with a dedicated return address register, the CFI usually only
768 contains information to unwind that return address register.
769
770 The reason we're treating the stack pointer special here is
771 because in many cases GCC doesn't emit CFI for the stack pointer
772 and implicitly assumes that it is equal to the CFA. This makes
773 some sense since the DWARF specification (version 3, draft 8,
774 p. 102) says that:
775
776 "Typically, the CFA is defined to be the value of the stack
777 pointer at the call site in the previous frame (which may be
778 different from its value on entry to the current frame)."
779
780 However, this isn't true for all platforms supported by GCC
781 (e.g. IBM S/390 and zSeries). Those architectures should provide
782 their own architecture-specific initialization function. */
05cbe71a 783
ad010def 784 if (regnum == gdbarch_pc_regnum (gdbarch))
8f22cb90 785 reg->how = DWARF2_FRAME_REG_RA;
ad010def 786 else if (regnum == gdbarch_sp_regnum (gdbarch))
8f22cb90
MK		 787 reg->how = DWARF2_FRAME_REG_CFA;
788}
05cbe71a 789
8f22cb90 790/* Return a default for the architecture-specific operations. */
05cbe71a 791
8f22cb90 792static void *
030f20e1 793dwarf2_frame_init (struct obstack *obstack)
8f22cb90
MK		 794{
795 struct dwarf2_frame_ops *ops;
796
030f20e1 797 ops = OBSTACK_ZALLOC (obstack, struct dwarf2_frame_ops);
8f22cb90
MK		 798 ops->init_reg = dwarf2_frame_default_init_reg;
799 return ops;
800}
05cbe71a 801
8f22cb90
MK		 802/* Set the architecture-specific register state initialization
803 function for GDBARCH to INIT_REG. */
804
805void
806dwarf2_frame_set_init_reg (struct gdbarch *gdbarch,
807 void (*init_reg) (struct gdbarch *, int,
aff37fc1
DM		 808 struct dwarf2_frame_state_reg *,
809 struct frame_info *))
8f22cb90 810{
030f20e1 811 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
8f22cb90 812
8f22cb90
MK		 813 ops->init_reg = init_reg;
814}
815
816/* Pre-initialize the register state REG for register REGNUM. */
05cbe71a
MK		 817
818static void
819dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
aff37fc1 820 struct dwarf2_frame_state_reg *reg,
4a4e5149 821 struct frame_info *this_frame)
05cbe71a 822{
030f20e1 823 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
8f22cb90 824
4a4e5149 825 ops->init_reg (gdbarch, regnum, reg, this_frame);
05cbe71a 826}
3ed09a32
DJ		 827
828/* Set the architecture-specific signal trampoline recognition
829 function for GDBARCH to SIGNAL_FRAME_P. */
830
831void
832dwarf2_frame_set_signal_frame_p (struct gdbarch *gdbarch,
833 int (*signal_frame_p) (struct gdbarch *,
834 struct frame_info *))
835{
836 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
837
838 ops->signal_frame_p = signal_frame_p;
839}
840
841/* Query the architecture-specific signal frame recognizer for
4a4e5149 842 THIS_FRAME. */
3ed09a32
DJ		 843
844static int
845dwarf2_frame_signal_frame_p (struct gdbarch *gdbarch,
4a4e5149 846 struct frame_info *this_frame)
3ed09a32
DJ		 847{
848 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
849
850 if (ops->signal_frame_p == NULL)
851 return 0;
4a4e5149 852 return ops->signal_frame_p (gdbarch, this_frame);
3ed09a32 853}
4bf8967c 854
4fc771b8
DJ		 855/* Set the architecture-specific adjustment of .eh_frame and .debug_frame
856 register numbers. */
4bf8967c
AS		 857
858void
4fc771b8
DJ		 859dwarf2_frame_set_adjust_regnum (struct gdbarch *gdbarch,
860 int (*adjust_regnum) (struct gdbarch *,
861 int, int))
4bf8967c
AS		 862{
863 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
864
4fc771b8 865 ops->adjust_regnum = adjust_regnum;
4bf8967c
AS		 866}
867
4fc771b8
DJ		 868/* Translate a .eh_frame register to DWARF register, or adjust a .debug_frame
869 register. */
4bf8967c 870
4fc771b8 871static int
3e43a32a
MS		 872dwarf2_frame_adjust_regnum (struct gdbarch *gdbarch,
873 int regnum, int eh_frame_p)
4bf8967c
AS		 874{
875 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
876
4fc771b8 877 if (ops->adjust_regnum == NULL)
4bf8967c 878 return regnum;
4fc771b8 879 return ops->adjust_regnum (gdbarch, regnum, eh_frame_p);
4bf8967c 880}
303b6f5d
DJ		 881
882static void
883dwarf2_frame_find_quirks (struct dwarf2_frame_state *fs,
884 struct dwarf2_fde *fde)
885{
303b6f5d
DJ		 886 struct symtab *s;
887
888 s = find_pc_symtab (fs->pc);
a6c727b2 889 if (s == NULL)
303b6f5d
DJ		 890 return;
891
a6c727b2
DJ		 892 if (producer_is_realview (s->producer))
893 {
894 if (fde->cie->version == 1)
895 fs->armcc_cfa_offsets_sf = 1;
896
897 if (fde->cie->version == 1)
898 fs->armcc_cfa_offsets_reversed = 1;
899
900 /* The reversed offset problem is present in some compilers
901 using DWARF3, but it was eventually fixed. Check the ARM
902 defined augmentations, which are in the format "armcc" followed
903 by a list of one-character options. The "+" option means
904 this problem is fixed (no quirk needed). If the armcc
905 augmentation is missing, the quirk is needed. */
906 if (fde->cie->version == 3
907 && (strncmp (fde->cie->augmentation, "armcc", 5) != 0
908 || strchr (fde->cie->augmentation + 5, '+') == NULL))
909 fs->armcc_cfa_offsets_reversed = 1;
910
911 return;
912 }
303b6f5d 913}
8f22cb90
MK		 914\f
915
9f6f94ff
TT		 916void
917dwarf2_compile_cfa_to_ax (struct agent_expr *expr, struct axs_value *loc,
918 struct gdbarch *gdbarch,
919 CORE_ADDR pc,
920 struct dwarf2_per_cu_data *data)
921{
922 const int num_regs = gdbarch_num_regs (gdbarch)
923 + gdbarch_num_pseudo_regs (gdbarch);
924 struct dwarf2_fde *fde;
925 CORE_ADDR text_offset, cfa;
926 struct dwarf2_frame_state fs;
927 int addr_size;
928
929 memset (&fs, 0, sizeof (struct dwarf2_frame_state));
930
931 fs.pc = pc;
932
933 /* Find the correct FDE. */
934 fde = dwarf2_frame_find_fde (&fs.pc, &text_offset);
935 if (fde == NULL)
936 error (_("Could not compute CFA; needed to translate this expression"));
937
938 /* Extract any interesting information from the CIE. */
939 fs.data_align = fde->cie->data_alignment_factor;
940 fs.code_align = fde->cie->code_alignment_factor;
941 fs.retaddr_column = fde->cie->return_address_register;
942 addr_size = fde->cie->addr_size;
943
944 /* Check for "quirks" - known bugs in producers. */
945 dwarf2_frame_find_quirks (&fs, fde);
946
947 /* First decode all the insns in the CIE. */
948 execute_cfa_program (fde, fde->cie->initial_instructions,
949 fde->cie->end, gdbarch, pc, &fs);
950
951 /* Save the initialized register set. */
952 fs.initial = fs.regs;
953 fs.initial.reg = dwarf2_frame_state_copy_regs (&fs.regs);
954
955 /* Then decode the insns in the FDE up to our target PC. */
956 execute_cfa_program (fde, fde->instructions, fde->end, gdbarch, pc, &fs);
957
958 /* Calculate the CFA. */
959 switch (fs.regs.cfa_how)
960 {
961 case CFA_REG_OFFSET:
962 {
963 int regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, fs.regs.cfa_reg);
964
965 if (regnum == -1)
966 error (_("Unable to access DWARF register number %d"),
967 (int) fs.regs.cfa_reg); /* FIXME */
968 ax_reg (expr, regnum);
969
970 if (fs.regs.cfa_offset != 0)
971 {
972 if (fs.armcc_cfa_offsets_reversed)
973 ax_const_l (expr, -fs.regs.cfa_offset);
974 else
975 ax_const_l (expr, fs.regs.cfa_offset);
976 ax_simple (expr, aop_add);
977 }
978 }
979 break;
980
981 case CFA_EXP:
982 ax_const_l (expr, text_offset);
983 dwarf2_compile_expr_to_ax (expr, loc, gdbarch, addr_size,
984 fs.regs.cfa_exp,
985 fs.regs.cfa_exp + fs.regs.cfa_exp_len,
986 data);
987 break;
988
989 default:
990 internal_error (__FILE__, __LINE__, _("Unknown CFA rule."));
991 }
992}
993
994\f
8f22cb90
MK		 995struct dwarf2_frame_cache
996{
997 /* DWARF Call Frame Address. */
998 CORE_ADDR cfa;
999
8fbca658
PA		 1000 /* Set if the return address column was marked as unavailable
1001 (required non-collected memory or registers to compute). */
1002 int unavailable_retaddr;
1003
0228dfb9
DJ		 1004 /* Set if the return address column was marked as undefined. */
1005 int undefined_retaddr;
1006
8f22cb90
MK		 1007 /* Saved registers, indexed by GDB register number, not by DWARF
1008 register number. */
1009 struct dwarf2_frame_state_reg *reg;
8d5a9abc
MK		 1010
1011 /* Return address register. */
1012 struct dwarf2_frame_state_reg retaddr_reg;
ae0d2f24
UW		 1013
1014 /* Target address size in bytes. */
1015 int addr_size;
ac56253d
TT		 1016
1017 /* The .text offset. */
1018 CORE_ADDR text_offset;
8f22cb90 1019};
05cbe71a 1020
b9362cc7 1021static struct dwarf2_frame_cache *
4a4e5149 1022dwarf2_frame_cache (struct frame_info *this_frame, void **this_cache)
cfc14b3a
MK		 1023{
1024 struct cleanup *old_chain;
4a4e5149 1025 struct gdbarch *gdbarch = get_frame_arch (this_frame);
ad010def
UW		 1026 const int num_regs = gdbarch_num_regs (gdbarch)
1027 + gdbarch_num_pseudo_regs (gdbarch);
cfc14b3a
MK		 1028 struct dwarf2_frame_cache *cache;
1029 struct dwarf2_frame_state *fs;
1030 struct dwarf2_fde *fde;
8fbca658 1031 volatile struct gdb_exception ex;
cfc14b3a
MK		 1032
1033 if (*this_cache)
1034 return *this_cache;
1035
1036 /* Allocate a new cache. */
1037 cache = FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache);
1038 cache->reg = FRAME_OBSTACK_CALLOC (num_regs, struct dwarf2_frame_state_reg);
8fbca658 1039 *this_cache = cache;
cfc14b3a
MK		 1040
1041 /* Allocate and initialize the frame state. */
8fbca658 1042 fs = XZALLOC (struct dwarf2_frame_state);
cfc14b3a
MK		 1043 old_chain = make_cleanup (dwarf2_frame_state_free, fs);
1044
1045 /* Unwind the PC.
1046
4a4e5149 1047 Note that if the next frame is never supposed to return (i.e. a call
cfc14b3a 1048 to abort), the compiler might optimize away the instruction at
4a4e5149 1049 its return address. As a result the return address will
cfc14b3a 1050 point at some random instruction, and the CFI for that
e4e9607c 1051 instruction is probably worthless to us. GCC's unwinder solves
cfc14b3a
MK		 1052 this problem by substracting 1 from the return address to get an
1053 address in the middle of a presumed call instruction (or the
1054 instruction in the associated delay slot). This should only be
1055 done for "normal" frames and not for resume-type frames (signal
e4e9607c 1056 handlers, sentinel frames, dummy frames). The function
ad1193e7 1057 get_frame_address_in_block does just this. It's not clear how
e4e9607c
MK		 1058 reliable the method is though; there is the potential for the
1059 register state pre-call being different to that on return. */
4a4e5149 1060 fs->pc = get_frame_address_in_block (this_frame);
cfc14b3a
MK		 1061
1062 /* Find the correct FDE. */
ac56253d 1063 fde = dwarf2_frame_find_fde (&fs->pc, &cache->text_offset);
cfc14b3a
MK		 1064 gdb_assert (fde != NULL);
1065
1066 /* Extract any interesting information from the CIE. */
1067 fs->data_align = fde->cie->data_alignment_factor;
1068 fs->code_align = fde->cie->code_alignment_factor;
1069 fs->retaddr_column = fde->cie->return_address_register;
ae0d2f24 1070 cache->addr_size = fde->cie->addr_size;
cfc14b3a 1071
303b6f5d
DJ		 1072 /* Check for "quirks" - known bugs in producers. */
1073 dwarf2_frame_find_quirks (fs, fde);
1074
cfc14b3a 1075 /* First decode all the insns in the CIE. */
ae0d2f24 1076 execute_cfa_program (fde, fde->cie->initial_instructions,
9f6f94ff 1077 fde->cie->end, gdbarch, get_frame_pc (this_frame), fs);
cfc14b3a
MK		 1078
1079 /* Save the initialized register set. */
1080 fs->initial = fs->regs;
1081 fs->initial.reg = dwarf2_frame_state_copy_regs (&fs->regs);
1082
1083 /* Then decode the insns in the FDE up to our target PC. */
9f6f94ff
TT		 1084 execute_cfa_program (fde, fde->instructions, fde->end, gdbarch,
1085 get_frame_pc (this_frame), fs);
cfc14b3a 1086
8fbca658 1087 TRY_CATCH (ex, RETURN_MASK_ERROR)
cfc14b3a 1088 {
8fbca658
PA		 1089 /* Calculate the CFA. */
1090 switch (fs->regs.cfa_how)
1091 {
1092 case CFA_REG_OFFSET:
1093 cache->cfa = read_reg (this_frame, fs->regs.cfa_reg);
1094 if (fs->armcc_cfa_offsets_reversed)
1095 cache->cfa -= fs->regs.cfa_offset;
1096 else
1097 cache->cfa += fs->regs.cfa_offset;
1098 break;
1099
1100 case CFA_EXP:
1101 cache->cfa =
1102 execute_stack_op (fs->regs.cfa_exp, fs->regs.cfa_exp_len,
1103 cache->addr_size, cache->text_offset,
1104 this_frame, 0, 0);
1105 break;
1106
1107 default:
1108 internal_error (__FILE__, __LINE__, _("Unknown CFA rule."));
1109 }
1110 }
1111 if (ex.reason < 0)
1112 {
1113 if (ex.error == NOT_AVAILABLE_ERROR)
1114 {
1115 cache->unavailable_retaddr = 1;
1116 return cache;
1117 }
cfc14b3a 1118
8fbca658 1119 throw_exception (ex);
cfc14b3a
MK		 1120 }
1121
05cbe71a 1122 /* Initialize the register state. */
3e2c4033
AC		 1123 {
1124 int regnum;
e4e9607c 1125
3e2c4033 1126 for (regnum = 0; regnum < num_regs; regnum++)
4a4e5149 1127 dwarf2_frame_init_reg (gdbarch, regnum, &cache->reg[regnum], this_frame);
3e2c4033
AC		 1128 }
1129
1130 /* Go through the DWARF2 CFI generated table and save its register
79c4cb80
MK		 1131 location information in the cache. Note that we don't skip the
1132 return address column; it's perfectly all right for it to
1133 correspond to a real register. If it doesn't correspond to a
1134 real register, or if we shouldn't treat it as such,
055d23b8 1135 gdbarch_dwarf2_reg_to_regnum should be defined to return a number outside
f57d151a 1136 the range [0, gdbarch_num_regs). */
3e2c4033
AC		 1137 {
1138 int column; /* CFI speak for "register number". */
e4e9607c 1139
3e2c4033
AC		 1140 for (column = 0; column < fs->regs.num_regs; column++)
1141 {
3e2c4033 1142 /* Use the GDB register number as the destination index. */
ad010def 1143 int regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, column);
3e2c4033
AC		 1144
1145 /* If there's no corresponding GDB register, ignore it. */
1146 if (regnum < 0 || regnum >= num_regs)
1147 continue;
1148
1149 /* NOTE: cagney/2003-09-05: CFI should specify the disposition
e4e9607c
MK		 1150 of all debug info registers. If it doesn't, complain (but
1151 not too loudly). It turns out that GCC assumes that an
3e2c4033
AC		 1152 unspecified register implies "same value" when CFI (draft
1153 7) specifies nothing at all. Such a register could equally
1154 be interpreted as "undefined". Also note that this check
e4e9607c
MK		 1155 isn't sufficient; it only checks that all registers in the
1156 range [0 .. max column] are specified, and won't detect
3e2c4033 1157 problems when a debug info register falls outside of the
e4e9607c 1158 table. We need a way of iterating through all the valid
3e2c4033 1159 DWARF2 register numbers. */
05cbe71a 1160 if (fs->regs.reg[column].how == DWARF2_FRAME_REG_UNSPECIFIED)
f059bf6f
AC		 1161 {
1162 if (cache->reg[regnum].how == DWARF2_FRAME_REG_UNSPECIFIED)
e2e0b3e5 1163 complaint (&symfile_complaints, _("\
5af949e3 1164incomplete CFI data; unspecified registers (e.g., %s) at %s"),
f059bf6f 1165 gdbarch_register_name (gdbarch, regnum),
5af949e3 1166 paddress (gdbarch, fs->pc));
f059bf6f 1167 }
35889917
MK		 1168 else
1169 cache->reg[regnum] = fs->regs.reg[column];
3e2c4033
AC		 1170 }
1171 }
cfc14b3a 1172
8d5a9abc
MK		 1173 /* Eliminate any DWARF2_FRAME_REG_RA rules, and save the information
1174 we need for evaluating DWARF2_FRAME_REG_RA_OFFSET rules. */
35889917
MK		 1175 {
1176 int regnum;
1177
1178 for (regnum = 0; regnum < num_regs; regnum++)
1179 {
8d5a9abc
MK		 1180 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA
1181 || cache->reg[regnum].how == DWARF2_FRAME_REG_RA_OFFSET)
35889917 1182 {
05cbe71a
MK		 1183 struct dwarf2_frame_state_reg *retaddr_reg =
1184 &fs->regs.reg[fs->retaddr_column];
1185
d4f10bf2
MK		 1186 /* It seems rather bizarre to specify an "empty" column as
1187 the return adress column. However, this is exactly
1188 what GCC does on some targets. It turns out that GCC
1189 assumes that the return address can be found in the
1190 register corresponding to the return address column.
8d5a9abc
MK		 1191 Incidentally, that's how we should treat a return
1192 address column specifying "same value" too. */
d4f10bf2 1193 if (fs->retaddr_column < fs->regs.num_regs
05cbe71a
MK		 1194 && retaddr_reg->how != DWARF2_FRAME_REG_UNSPECIFIED
1195 && retaddr_reg->how != DWARF2_FRAME_REG_SAME_VALUE)
8d5a9abc
MK		 1196 {
1197 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
1198 cache->reg[regnum] = *retaddr_reg;
1199 else
1200 cache->retaddr_reg = *retaddr_reg;
1201 }
35889917
MK		 1202 else
1203 {
8d5a9abc
MK		 1204 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
1205 {
1206 cache->reg[regnum].loc.reg = fs->retaddr_column;
1207 cache->reg[regnum].how = DWARF2_FRAME_REG_SAVED_REG;
1208 }
1209 else
1210 {
1211 cache->retaddr_reg.loc.reg = fs->retaddr_column;
1212 cache->retaddr_reg.how = DWARF2_FRAME_REG_SAVED_REG;
1213 }
35889917
MK		 1214 }
1215 }
1216 }
1217 }
cfc14b3a 1218
0228dfb9
DJ		 1219 if (fs->retaddr_column < fs->regs.num_regs
1220 && fs->regs.reg[fs->retaddr_column].how == DWARF2_FRAME_REG_UNDEFINED)
1221 cache->undefined_retaddr = 1;
1222
cfc14b3a
MK		 1223 do_cleanups (old_chain);
1224
cfc14b3a
MK		 1225 return cache;
1226}
1227
8fbca658
PA		 1228static enum unwind_stop_reason
1229dwarf2_frame_unwind_stop_reason (struct frame_info *this_frame,
1230 void **this_cache)
1231{
1232 struct dwarf2_frame_cache *cache
1233 = dwarf2_frame_cache (this_frame, this_cache);
1234
1235 if (cache->unavailable_retaddr)
1236 return UNWIND_UNAVAILABLE;
1237
1238 if (cache->undefined_retaddr)
1239 return UNWIND_OUTERMOST;
1240
1241 return UNWIND_NO_REASON;
1242}
1243
cfc14b3a 1244static void
4a4e5149 1245dwarf2_frame_this_id (struct frame_info *this_frame, void **this_cache,
cfc14b3a
MK		 1246 struct frame_id *this_id)
1247{
1248 struct dwarf2_frame_cache *cache =
4a4e5149 1249 dwarf2_frame_cache (this_frame, this_cache);
cfc14b3a 1250
8fbca658
PA		 1251 if (cache->unavailable_retaddr)
1252 return;
1253
0228dfb9
DJ		 1254 if (cache->undefined_retaddr)
1255 return;
1256
4a4e5149 1257 (*this_id) = frame_id_build (cache->cfa, get_frame_func (this_frame));
93d42b30
DJ		 1258}
1259
4a4e5149
DJ		 1260static struct value *
1261dwarf2_frame_prev_register (struct frame_info *this_frame, void **this_cache,
1262 int regnum)
93d42b30 1263{
4a4e5149 1264 struct gdbarch *gdbarch = get_frame_arch (this_frame);
93d42b30 1265 struct dwarf2_frame_cache *cache =
4a4e5149
DJ		 1266 dwarf2_frame_cache (this_frame, this_cache);
1267 CORE_ADDR addr;
1268 int realnum;
cfc14b3a
MK		 1269
1270 switch (cache->reg[regnum].how)
1271 {
05cbe71a 1272 case DWARF2_FRAME_REG_UNDEFINED:
3e2c4033 1273 /* If CFI explicitly specified that the value isn't defined,
e4e9607c 1274 mark it as optimized away; the value isn't available. */
4a4e5149 1275 return frame_unwind_got_optimized (this_frame, regnum);
cfc14b3a 1276
05cbe71a 1277 case DWARF2_FRAME_REG_SAVED_OFFSET:
4a4e5149
DJ		 1278 addr = cache->cfa + cache->reg[regnum].loc.offset;
1279 return frame_unwind_got_memory (this_frame, regnum, addr);
cfc14b3a 1280
05cbe71a 1281 case DWARF2_FRAME_REG_SAVED_REG:
4a4e5149
DJ		 1282 realnum
1283 = gdbarch_dwarf2_reg_to_regnum (gdbarch, cache->reg[regnum].loc.reg);
1284 return frame_unwind_got_register (this_frame, regnum, realnum);
cfc14b3a 1285
05cbe71a 1286 case DWARF2_FRAME_REG_SAVED_EXP:
4a4e5149
DJ		 1287 addr = execute_stack_op (cache->reg[regnum].loc.exp,
1288 cache->reg[regnum].exp_len,
ac56253d
TT		 1289 cache->addr_size, cache->text_offset,
1290 this_frame, cache->cfa, 1);
4a4e5149 1291 return frame_unwind_got_memory (this_frame, regnum, addr);
cfc14b3a 1292
46ea248b 1293 case DWARF2_FRAME_REG_SAVED_VAL_OFFSET:
4a4e5149
DJ		 1294 addr = cache->cfa + cache->reg[regnum].loc.offset;
1295 return frame_unwind_got_constant (this_frame, regnum, addr);
46ea248b
AO		 1296
1297 case DWARF2_FRAME_REG_SAVED_VAL_EXP:
4a4e5149
DJ		 1298 addr = execute_stack_op (cache->reg[regnum].loc.exp,
1299 cache->reg[regnum].exp_len,
ac56253d
TT		 1300 cache->addr_size, cache->text_offset,
1301 this_frame, cache->cfa, 1);
4a4e5149 1302 return frame_unwind_got_constant (this_frame, regnum, addr);
46ea248b 1303
05cbe71a 1304 case DWARF2_FRAME_REG_UNSPECIFIED:
3e2c4033
AC		 1305 /* GCC, in its infinite wisdom decided to not provide unwind
1306 information for registers that are "same value". Since
1307 DWARF2 (3 draft 7) doesn't define such behavior, said
1308 registers are actually undefined (which is different to CFI
1309 "undefined"). Code above issues a complaint about this.
1310 Here just fudge the books, assume GCC, and that the value is
1311 more inner on the stack. */
4a4e5149 1312 return frame_unwind_got_register (this_frame, regnum, regnum);
3e2c4033 1313
05cbe71a 1314 case DWARF2_FRAME_REG_SAME_VALUE:
4a4e5149 1315 return frame_unwind_got_register (this_frame, regnum, regnum);
cfc14b3a 1316
05cbe71a 1317 case DWARF2_FRAME_REG_CFA:
4a4e5149 1318 return frame_unwind_got_address (this_frame, regnum, cache->cfa);
35889917 1319
ea7963f0 1320 case DWARF2_FRAME_REG_CFA_OFFSET:
4a4e5149
DJ		 1321 addr = cache->cfa + cache->reg[regnum].loc.offset;
1322 return frame_unwind_got_address (this_frame, regnum, addr);
ea7963f0 1323
8d5a9abc 1324 case DWARF2_FRAME_REG_RA_OFFSET:
4a4e5149
DJ		 1325 addr = cache->reg[regnum].loc.offset;
1326 regnum = gdbarch_dwarf2_reg_to_regnum
1327 (gdbarch, cache->retaddr_reg.loc.reg);
1328 addr += get_frame_register_unsigned (this_frame, regnum);
1329 return frame_unwind_got_address (this_frame, regnum, addr);
8d5a9abc 1330
b39cc962
DJ		 1331 case DWARF2_FRAME_REG_FN:
1332 return cache->reg[regnum].loc.fn (this_frame, this_cache, regnum);
1333
cfc14b3a 1334 default:
e2e0b3e5 1335 internal_error (__FILE__, __LINE__, _("Unknown register rule."));
cfc14b3a
MK		 1336 }
1337}
1338
4a4e5149
DJ		 1339static int
1340dwarf2_frame_sniffer (const struct frame_unwind *self,
1341 struct frame_info *this_frame, void **this_cache)
cfc14b3a 1342{
1ce5d6dd 1343 /* Grab an address that is guarenteed to reside somewhere within the
4a4e5149 1344 function. get_frame_pc(), with a no-return next function, can
93d42b30
DJ		 1345 end up returning something past the end of this function's body.
1346 If the frame we're sniffing for is a signal frame whose start
1347 address is placed on the stack by the OS, its FDE must
4a4e5149
DJ		 1348 extend one byte before its start address or we could potentially
1349 select the FDE of the previous function. */
1350 CORE_ADDR block_addr = get_frame_address_in_block (this_frame);
ac56253d 1351 struct dwarf2_fde *fde = dwarf2_frame_find_fde (&block_addr, NULL);
9a619af0 1352
56c987f6 1353 if (!fde)
4a4e5149 1354 return 0;
3ed09a32
DJ		 1355
1356 /* On some targets, signal trampolines may have unwind information.
1357 We need to recognize them so that we set the frame type
1358 correctly. */
1359
56c987f6 1360 if (fde->cie->signal_frame
4a4e5149
DJ		 1361 || dwarf2_frame_signal_frame_p (get_frame_arch (this_frame),
1362 this_frame))
1363 return self->type == SIGTRAMP_FRAME;
1364
1365 return self->type != SIGTRAMP_FRAME;
1366}
1367
1368static const struct frame_unwind dwarf2_frame_unwind =
1369{
1370 NORMAL_FRAME,
8fbca658 1371 dwarf2_frame_unwind_stop_reason,
4a4e5149
DJ		 1372 dwarf2_frame_this_id,
1373 dwarf2_frame_prev_register,
1374 NULL,
1375 dwarf2_frame_sniffer
1376};
1377
1378static const struct frame_unwind dwarf2_signal_frame_unwind =
1379{
1380 SIGTRAMP_FRAME,
8fbca658 1381 dwarf2_frame_unwind_stop_reason,
4a4e5149
DJ		 1382 dwarf2_frame_this_id,
1383 dwarf2_frame_prev_register,
1384 NULL,
1385 dwarf2_frame_sniffer
1386};
cfc14b3a 1387
4a4e5149
DJ		 1388/* Append the DWARF-2 frame unwinders to GDBARCH's list. */
1389
1390void
1391dwarf2_append_unwinders (struct gdbarch *gdbarch)
1392{
1393 frame_unwind_append_unwinder (gdbarch, &dwarf2_frame_unwind);
1394 frame_unwind_append_unwinder (gdbarch, &dwarf2_signal_frame_unwind);
cfc14b3a
MK		 1395}
1396\f
1397
1398/* There is no explicitly defined relationship between the CFA and the
1399 location of frame's local variables and arguments/parameters.
1400 Therefore, frame base methods on this page should probably only be
1401 used as a last resort, just to avoid printing total garbage as a
1402 response to the "info frame" command. */
1403
1404static CORE_ADDR
4a4e5149 1405dwarf2_frame_base_address (struct frame_info *this_frame, void **this_cache)
cfc14b3a
MK		 1406{
1407 struct dwarf2_frame_cache *cache =
4a4e5149 1408 dwarf2_frame_cache (this_frame, this_cache);
cfc14b3a
MK		 1409
1410 return cache->cfa;
1411}
1412
1413static const struct frame_base dwarf2_frame_base =
1414{
1415 &dwarf2_frame_unwind,
1416 dwarf2_frame_base_address,
1417 dwarf2_frame_base_address,
1418 dwarf2_frame_base_address
1419};
1420
1421const struct frame_base *
4a4e5149 1422dwarf2_frame_base_sniffer (struct frame_info *this_frame)
cfc14b3a 1423{
4a4e5149 1424 CORE_ADDR block_addr = get_frame_address_in_block (this_frame);
9a619af0 1425
ac56253d 1426 if (dwarf2_frame_find_fde (&block_addr, NULL))
cfc14b3a
MK		 1427 return &dwarf2_frame_base;
1428
1429 return NULL;
1430}
e7802207
TT		 1431
1432/* Compute the CFA for THIS_FRAME, but only if THIS_FRAME came from
1433 the DWARF unwinder. This is used to implement
1434 DW_OP_call_frame_cfa. */
1435
1436CORE_ADDR
1437dwarf2_frame_cfa (struct frame_info *this_frame)
1438{
1439 while (get_frame_type (this_frame) == INLINE_FRAME)
1440 this_frame = get_prev_frame (this_frame);
1441 /* This restriction could be lifted if other unwinders are known to
1442 compute the frame base in a way compatible with the DWARF
1443 unwinder. */
1444 if (! frame_unwinder_is (this_frame, &dwarf2_frame_unwind))
1445 error (_("can't compute CFA for this frame"));
1446 return get_frame_base (this_frame);
1447}
cfc14b3a 1448\f
8f22cb90 1449const struct objfile_data *dwarf2_frame_objfile_data;
0d0e1a63 1450
cfc14b3a 1451static unsigned int
852483bc 1452read_1_byte (bfd *abfd, gdb_byte *buf)
cfc14b3a 1453{
852483bc 1454 return bfd_get_8 (abfd, buf);
cfc14b3a
MK		 1455}
1456
1457static unsigned int
852483bc 1458read_4_bytes (bfd *abfd, gdb_byte *buf)
cfc14b3a 1459{
852483bc 1460 return bfd_get_32 (abfd, buf);
cfc14b3a
MK		 1461}
1462
1463static ULONGEST
852483bc 1464read_8_bytes (bfd *abfd, gdb_byte *buf)
cfc14b3a 1465{
852483bc 1466 return bfd_get_64 (abfd, buf);
cfc14b3a
MK		 1467}
1468
1469static ULONGEST
852483bc 1470read_unsigned_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
cfc14b3a
MK		 1471{
1472 ULONGEST result;
1473 unsigned int num_read;
1474 int shift;
852483bc 1475 gdb_byte byte;
cfc14b3a
MK		 1476
1477 result = 0;
1478 shift = 0;
1479 num_read = 0;
1480
1481 do
1482 {
1483 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
1484 buf++;
1485 num_read++;
1486 result |= ((byte & 0x7f) << shift);
1487 shift += 7;
1488 }
1489 while (byte & 0x80);
1490
1491 *bytes_read_ptr = num_read;
1492
1493 return result;
1494}
1495
1496static LONGEST
852483bc 1497read_signed_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
cfc14b3a
MK		 1498{
1499 LONGEST result;
1500 int shift;
1501 unsigned int num_read;
852483bc 1502 gdb_byte byte;
cfc14b3a
MK		 1503
1504 result = 0;
1505 shift = 0;
1506 num_read = 0;
1507
1508 do
1509 {
1510 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
1511 buf++;
1512 num_read++;
1513 result |= ((byte & 0x7f) << shift);
1514 shift += 7;
1515 }
1516 while (byte & 0x80);
1517
77e0b926
DJ		 1518 if (shift < 8 * sizeof (result) && (byte & 0x40))
1519 result |= -(((LONGEST)1) << shift);
cfc14b3a
MK		 1520
1521 *bytes_read_ptr = num_read;
1522
1523 return result;
1524}
1525
1526static ULONGEST
852483bc 1527read_initial_length (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
cfc14b3a
MK		 1528{
1529 LONGEST result;
1530
852483bc 1531 result = bfd_get_32 (abfd, buf);
cfc14b3a
MK		 1532 if (result == 0xffffffff)
1533 {
852483bc 1534 result = bfd_get_64 (abfd, buf + 4);
cfc14b3a
MK		 1535 *bytes_read_ptr = 12;
1536 }
1537 else
1538 *bytes_read_ptr = 4;
1539
1540 return result;
1541}
1542\f
1543
1544/* Pointer encoding helper functions. */
1545
1546/* GCC supports exception handling based on DWARF2 CFI. However, for
1547 technical reasons, it encodes addresses in its FDE's in a different
1548 way. Several "pointer encodings" are supported. The encoding
1549 that's used for a particular FDE is determined by the 'R'
1550 augmentation in the associated CIE. The argument of this
1551 augmentation is a single byte.
1552
1553 The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a
1554 LEB128. This is encoded in bits 0, 1 and 2. Bit 3 encodes whether
1555 the address is signed or unsigned. Bits 4, 5 and 6 encode how the
1556 address should be interpreted (absolute, relative to the current
1557 position in the FDE, ...). Bit 7, indicates that the address
1558 should be dereferenced. */
1559
852483bc 1560static gdb_byte
cfc14b3a
MK		 1561encoding_for_size (unsigned int size)
1562{
1563 switch (size)
1564 {
1565 case 2:
1566 return DW_EH_PE_udata2;
1567 case 4:
1568 return DW_EH_PE_udata4;
1569 case 8:
1570 return DW_EH_PE_udata8;
1571 default:
e2e0b3e5 1572 internal_error (__FILE__, __LINE__, _("Unsupported address size"));
cfc14b3a
MK		 1573 }
1574}
1575
cfc14b3a 1576static CORE_ADDR
852483bc 1577read_encoded_value (struct comp_unit *unit, gdb_byte encoding,
0d45f56e
TT		 1578 int ptr_len, const gdb_byte *buf,
1579 unsigned int *bytes_read_ptr,
ae0d2f24 1580 CORE_ADDR func_base)
cfc14b3a 1581{
68f6cf99 1582 ptrdiff_t offset;
cfc14b3a
MK		 1583 CORE_ADDR base;
1584
1585 /* GCC currently doesn't generate DW_EH_PE_indirect encodings for
1586 FDE's. */
1587 if (encoding & DW_EH_PE_indirect)
1588 internal_error (__FILE__, __LINE__,
e2e0b3e5 1589 _("Unsupported encoding: DW_EH_PE_indirect"));
cfc14b3a 1590
68f6cf99
MK		 1591 *bytes_read_ptr = 0;
1592
cfc14b3a
MK		 1593 switch (encoding & 0x70)
1594 {
1595 case DW_EH_PE_absptr:
1596 base = 0;
1597 break;
1598 case DW_EH_PE_pcrel:
f2fec864 1599 base = bfd_get_section_vma (unit->abfd, unit->dwarf_frame_section);
852483bc 1600 base += (buf - unit->dwarf_frame_buffer);
cfc14b3a 1601 break;
0912c7f2
MK		 1602 case DW_EH_PE_datarel:
1603 base = unit->dbase;
1604 break;
0fd85043
CV		 1605 case DW_EH_PE_textrel:
1606 base = unit->tbase;
1607 break;
03ac2a74 1608 case DW_EH_PE_funcrel:
ae0d2f24 1609 base = func_base;
03ac2a74 1610 break;
68f6cf99
MK		 1611 case DW_EH_PE_aligned:
1612 base = 0;
852483bc 1613 offset = buf - unit->dwarf_frame_buffer;
68f6cf99
MK		 1614 if ((offset % ptr_len) != 0)
1615 {
1616 *bytes_read_ptr = ptr_len - (offset % ptr_len);
1617 buf += *bytes_read_ptr;
1618 }
1619 break;
cfc14b3a 1620 default:
3e43a32a
MS		 1621 internal_error (__FILE__, __LINE__,
1622 _("Invalid or unsupported encoding"));
cfc14b3a
MK		 1623 }
1624
b04de778 1625 if ((encoding & 0x07) == 0x00)
f2fec864
DJ		 1626 {
1627 encoding |= encoding_for_size (ptr_len);
1628 if (bfd_get_sign_extend_vma (unit->abfd))
1629 encoding |= DW_EH_PE_signed;
1630 }
cfc14b3a
MK		 1631
1632 switch (encoding & 0x0f)
1633 {
a81b10ae
MK		 1634 case DW_EH_PE_uleb128:
1635 {
1636 ULONGEST value;
0d45f56e 1637 const gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
9a619af0 1638
a7289609 1639 *bytes_read_ptr += read_uleb128 (buf, end_buf, &value) - buf;
a81b10ae
MK		 1640 return base + value;
1641 }
cfc14b3a 1642 case DW_EH_PE_udata2:
68f6cf99 1643 *bytes_read_ptr += 2;
cfc14b3a
MK		 1644 return (base + bfd_get_16 (unit->abfd, (bfd_byte *) buf));
1645 case DW_EH_PE_udata4:
68f6cf99 1646 *bytes_read_ptr += 4;
cfc14b3a
MK		 1647 return (base + bfd_get_32 (unit->abfd, (bfd_byte *) buf));
1648 case DW_EH_PE_udata8:
68f6cf99 1649 *bytes_read_ptr += 8;
cfc14b3a 1650 return (base + bfd_get_64 (unit->abfd, (bfd_byte *) buf));
a81b10ae
MK		 1651 case DW_EH_PE_sleb128:
1652 {
1653 LONGEST value;
0d45f56e 1654 const gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
9a619af0 1655
a7289609 1656 *bytes_read_ptr += read_sleb128 (buf, end_buf, &value) - buf;
a81b10ae
MK		 1657 return base + value;
1658 }
cfc14b3a 1659 case DW_EH_PE_sdata2:
68f6cf99 1660 *bytes_read_ptr += 2;
cfc14b3a
MK		 1661 return (base + bfd_get_signed_16 (unit->abfd, (bfd_byte *) buf));
1662 case DW_EH_PE_sdata4:
68f6cf99 1663 *bytes_read_ptr += 4;
cfc14b3a
MK		 1664 return (base + bfd_get_signed_32 (unit->abfd, (bfd_byte *) buf));
1665 case DW_EH_PE_sdata8:
68f6cf99 1666 *bytes_read_ptr += 8;
cfc14b3a
MK		 1667 return (base + bfd_get_signed_64 (unit->abfd, (bfd_byte *) buf));
1668 default:
3e43a32a
MS		 1669 internal_error (__FILE__, __LINE__,
1670 _("Invalid or unsupported encoding"));
cfc14b3a
MK		 1671 }
1672}
1673\f
1674
b01c8410
PP		 1675static int
1676bsearch_cie_cmp (const void *key, const void *element)
cfc14b3a 1677{
b01c8410
PP		 1678 ULONGEST cie_pointer = *(ULONGEST *) key;
1679 struct dwarf2_cie *cie = *(struct dwarf2_cie **) element;
cfc14b3a 1680
b01c8410
PP		 1681 if (cie_pointer == cie->cie_pointer)
1682 return 0;
cfc14b3a 1683
b01c8410
PP		 1684 return (cie_pointer < cie->cie_pointer) ? -1 : 1;
1685}
1686
1687/* Find CIE with the given CIE_POINTER in CIE_TABLE. */
1688static struct dwarf2_cie *
1689find_cie (struct dwarf2_cie_table *cie_table, ULONGEST cie_pointer)
1690{
1691 struct dwarf2_cie **p_cie;
cfc14b3a 1692
65a97ab3
PP		 1693 /* The C standard (ISO/IEC 9899:TC2) requires the BASE argument to
1694 bsearch be non-NULL. */
1695 if (cie_table->entries == NULL)
1696 {
1697 gdb_assert (cie_table->num_entries == 0);
1698 return NULL;
1699 }
1700
b01c8410
PP		 1701 p_cie = bsearch (&cie_pointer, cie_table->entries, cie_table->num_entries,
1702 sizeof (cie_table->entries[0]), bsearch_cie_cmp);
1703 if (p_cie != NULL)
1704 return *p_cie;
cfc14b3a
MK		 1705 return NULL;
1706}
1707
b01c8410 1708/* Add a pointer to new CIE to the CIE_TABLE, allocating space for it. */
cfc14b3a 1709static void
b01c8410 1710add_cie (struct dwarf2_cie_table *cie_table, struct dwarf2_cie *cie)
cfc14b3a 1711{
b01c8410
PP		 1712 const int n = cie_table->num_entries;
1713
1714 gdb_assert (n < 1
1715 || cie_table->entries[n - 1]->cie_pointer < cie->cie_pointer);
1716
1717 cie_table->entries =
1718 xrealloc (cie_table->entries, (n + 1) * sizeof (cie_table->entries[0]));
1719 cie_table->entries[n] = cie;
1720 cie_table->num_entries = n + 1;
1721}
1722
1723static int
1724bsearch_fde_cmp (const void *key, const void *element)
1725{
1726 CORE_ADDR seek_pc = *(CORE_ADDR *) key;
1727 struct dwarf2_fde *fde = *(struct dwarf2_fde **) element;
9a619af0 1728
b01c8410
PP		 1729 if (seek_pc < fde->initial_location)
1730 return -1;
1731 if (seek_pc < fde->initial_location + fde->address_range)
1732 return 0;
1733 return 1;
cfc14b3a
MK		 1734}
1735
1736/* Find the FDE for *PC. Return a pointer to the FDE, and store the
1737 inital location associated with it into *PC. */
1738
1739static struct dwarf2_fde *
ac56253d 1740dwarf2_frame_find_fde (CORE_ADDR *pc, CORE_ADDR *out_offset)
cfc14b3a
MK		 1741{
1742 struct objfile *objfile;
1743
1744 ALL_OBJFILES (objfile)
1745 {
b01c8410
PP		 1746 struct dwarf2_fde_table *fde_table;
1747 struct dwarf2_fde **p_fde;
cfc14b3a 1748 CORE_ADDR offset;
b01c8410 1749 CORE_ADDR seek_pc;
cfc14b3a 1750
b01c8410
PP		 1751 fde_table = objfile_data (objfile, dwarf2_frame_objfile_data);
1752 if (fde_table == NULL)
be391dca
TT		 1753 {
1754 dwarf2_build_frame_info (objfile);
1755 fde_table = objfile_data (objfile, dwarf2_frame_objfile_data);
1756 }
1757 gdb_assert (fde_table != NULL);
1758
1759 if (fde_table->num_entries == 0)
4ae9ee8e
DJ		 1760 continue;
1761
1762 gdb_assert (objfile->section_offsets);
1763 offset = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1764
b01c8410
PP		 1765 gdb_assert (fde_table->num_entries > 0);
1766 if (*pc < offset + fde_table->entries[0]->initial_location)
1767 continue;
1768
1769 seek_pc = *pc - offset;
1770 p_fde = bsearch (&seek_pc, fde_table->entries, fde_table->num_entries,
1771 sizeof (fde_table->entries[0]), bsearch_fde_cmp);
1772 if (p_fde != NULL)
1773 {
1774 *pc = (*p_fde)->initial_location + offset;
ac56253d
TT		 1775 if (out_offset)
1776 *out_offset = offset;
b01c8410
PP		 1777 return *p_fde;
1778 }
cfc14b3a 1779 }
cfc14b3a
MK		 1780 return NULL;
1781}
1782
b01c8410 1783/* Add a pointer to new FDE to the FDE_TABLE, allocating space for it. */
cfc14b3a 1784static void
b01c8410 1785add_fde (struct dwarf2_fde_table *fde_table, struct dwarf2_fde *fde)
cfc14b3a 1786{
b01c8410
PP		 1787 if (fde->address_range == 0)
1788 /* Discard useless FDEs. */
1789 return;
1790
1791 fde_table->num_entries += 1;
1792 fde_table->entries =
1793 xrealloc (fde_table->entries,
1794 fde_table->num_entries * sizeof (fde_table->entries[0]));
1795 fde_table->entries[fde_table->num_entries - 1] = fde;
cfc14b3a
MK		 1796}
1797
1798#ifdef CC_HAS_LONG_LONG
1799#define DW64_CIE_ID 0xffffffffffffffffULL
1800#else
1801#define DW64_CIE_ID ~0
1802#endif
1803
852483bc 1804static gdb_byte *decode_frame_entry (struct comp_unit *unit, gdb_byte *start,
b01c8410
PP		 1805 int eh_frame_p,
1806 struct dwarf2_cie_table *cie_table,
1807 struct dwarf2_fde_table *fde_table);
cfc14b3a 1808
6896c0c7
RH		 1809/* Decode the next CIE or FDE. Return NULL if invalid input, otherwise
1810 the next byte to be processed. */
852483bc 1811static gdb_byte *
b01c8410
PP		 1812decode_frame_entry_1 (struct comp_unit *unit, gdb_byte *start, int eh_frame_p,
1813 struct dwarf2_cie_table *cie_table,
1814 struct dwarf2_fde_table *fde_table)
cfc14b3a 1815{
5e2b427d 1816 struct gdbarch *gdbarch = get_objfile_arch (unit->objfile);
852483bc 1817 gdb_byte *buf, *end;
cfc14b3a
MK		 1818 LONGEST length;
1819 unsigned int bytes_read;
6896c0c7
RH		 1820 int dwarf64_p;
1821 ULONGEST cie_id;
cfc14b3a 1822 ULONGEST cie_pointer;
cfc14b3a 1823
6896c0c7 1824 buf = start;
cfc14b3a
MK		 1825 length = read_initial_length (unit->abfd, buf, &bytes_read);
1826 buf += bytes_read;
1827 end = buf + length;
1828
0963b4bd 1829 /* Are we still within the section? */
6896c0c7
RH		 1830 if (end > unit->dwarf_frame_buffer + unit->dwarf_frame_size)
1831 return NULL;
1832
cfc14b3a
MK		 1833 if (length == 0)
1834 return end;
1835
6896c0c7
RH		 1836 /* Distinguish between 32 and 64-bit encoded frame info. */
1837 dwarf64_p = (bytes_read == 12);
cfc14b3a 1838
6896c0c7 1839 /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs. */
cfc14b3a
MK		 1840 if (eh_frame_p)
1841 cie_id = 0;
1842 else if (dwarf64_p)
1843 cie_id = DW64_CIE_ID;
6896c0c7
RH		 1844 else
1845 cie_id = DW_CIE_ID;
cfc14b3a
MK		 1846
1847 if (dwarf64_p)
1848 {
1849 cie_pointer = read_8_bytes (unit->abfd, buf);
1850 buf += 8;
1851 }
1852 else
1853 {
1854 cie_pointer = read_4_bytes (unit->abfd, buf);
1855 buf += 4;
1856 }
1857
1858 if (cie_pointer == cie_id)
1859 {
1860 /* This is a CIE. */
1861 struct dwarf2_cie *cie;
1862 char *augmentation;
28ba0b33 1863 unsigned int cie_version;
cfc14b3a
MK		 1864
1865 /* Record the offset into the .debug_frame section of this CIE. */
1866 cie_pointer = start - unit->dwarf_frame_buffer;
1867
1868 /* Check whether we've already read it. */
b01c8410 1869 if (find_cie (cie_table, cie_pointer))
cfc14b3a
MK		 1870 return end;
1871
1872 cie = (struct dwarf2_cie *)
8b92e4d5 1873 obstack_alloc (&unit->objfile->objfile_obstack,
cfc14b3a
MK		 1874 sizeof (struct dwarf2_cie));
1875 cie->initial_instructions = NULL;
1876 cie->cie_pointer = cie_pointer;
1877
1878 /* The encoding for FDE's in a normal .debug_frame section
32b05c07
MK		 1879 depends on the target address size. */
1880 cie->encoding = DW_EH_PE_absptr;
cfc14b3a 1881
56c987f6
AO		 1882 /* We'll determine the final value later, but we need to
1883 initialize it conservatively. */
1884 cie->signal_frame = 0;
1885
cfc14b3a 1886 /* Check version number. */
28ba0b33 1887 cie_version = read_1_byte (unit->abfd, buf);
2dc7f7b3 1888 if (cie_version != 1 && cie_version != 3 && cie_version != 4)
6896c0c7 1889 return NULL;
303b6f5d 1890 cie->version = cie_version;
cfc14b3a
MK		 1891 buf += 1;
1892
1893 /* Interpret the interesting bits of the augmentation. */
303b6f5d 1894 cie->augmentation = augmentation = (char *) buf;
852483bc 1895 buf += (strlen (augmentation) + 1);
cfc14b3a 1896
303b6f5d
DJ		 1897 /* Ignore armcc augmentations. We only use them for quirks,
1898 and that doesn't happen until later. */
1899 if (strncmp (augmentation, "armcc", 5) == 0)
1900 augmentation += strlen (augmentation);
1901
cfc14b3a
MK		 1902 /* The GCC 2.x "eh" augmentation has a pointer immediately
1903 following the augmentation string, so it must be handled
1904 first. */
1905 if (augmentation[0] == 'e' && augmentation[1] == 'h')
1906 {
1907 /* Skip. */
5e2b427d 1908 buf += gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
cfc14b3a
MK		 1909 augmentation += 2;
1910 }
1911
2dc7f7b3
TT		 1912 if (cie->version >= 4)
1913 {
1914 /* FIXME: check that this is the same as from the CU header. */
1915 cie->addr_size = read_1_byte (unit->abfd, buf);
1916 ++buf;
1917 cie->segment_size = read_1_byte (unit->abfd, buf);
1918 ++buf;
1919 }
1920 else
1921 {
8da614df 1922 cie->addr_size = gdbarch_dwarf2_addr_size (gdbarch);
2dc7f7b3
TT		 1923 cie->segment_size = 0;
1924 }
8da614df
CV		 1925 /* Address values in .eh_frame sections are defined to have the
1926 target's pointer size. Watchout: This breaks frame info for
1927 targets with pointer size < address size, unless a .debug_frame
0963b4bd 1928 section exists as well. */
8da614df
CV		 1929 if (eh_frame_p)
1930 cie->ptr_size = gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
1931 else
1932 cie->ptr_size = cie->addr_size;
2dc7f7b3 1933
cfc14b3a
MK		 1934 cie->code_alignment_factor =
1935 read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1936 buf += bytes_read;
1937
1938 cie->data_alignment_factor =
1939 read_signed_leb128 (unit->abfd, buf, &bytes_read);
1940 buf += bytes_read;
1941
28ba0b33
PB		 1942 if (cie_version == 1)
1943 {
1944 cie->return_address_register = read_1_byte (unit->abfd, buf);
1945 bytes_read = 1;
1946 }
1947 else
1948 cie->return_address_register = read_unsigned_leb128 (unit->abfd, buf,
1949 &bytes_read);
4fc771b8 1950 cie->return_address_register
5e2b427d 1951 = dwarf2_frame_adjust_regnum (gdbarch,
4fc771b8
DJ		 1952 cie->return_address_register,
1953 eh_frame_p);
4bf8967c 1954
28ba0b33 1955 buf += bytes_read;
cfc14b3a 1956
7131cb6e
RH		 1957 cie->saw_z_augmentation = (*augmentation == 'z');
1958 if (cie->saw_z_augmentation)
cfc14b3a
MK		 1959 {
1960 ULONGEST length;
1961
1962 length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1963 buf += bytes_read;
6896c0c7
RH		 1964 if (buf > end)
1965 return NULL;
cfc14b3a
MK		 1966 cie->initial_instructions = buf + length;
1967 augmentation++;
1968 }
1969
1970 while (*augmentation)
1971 {
1972 /* "L" indicates a byte showing how the LSDA pointer is encoded. */
1973 if (*augmentation == 'L')
1974 {
1975 /* Skip. */
1976 buf++;
1977 augmentation++;
1978 }
1979
1980 /* "R" indicates a byte indicating how FDE addresses are encoded. */
1981 else if (*augmentation == 'R')
1982 {
1983 cie->encoding = *buf++;
1984 augmentation++;
1985 }
1986
1987 /* "P" indicates a personality routine in the CIE augmentation. */
1988 else if (*augmentation == 'P')
1989 {
1234d960 1990 /* Skip. Avoid indirection since we throw away the result. */
852483bc 1991 gdb_byte encoding = (*buf++) & ~DW_EH_PE_indirect;
8da614df 1992 read_encoded_value (unit, encoding, cie->ptr_size,
ae0d2f24 1993 buf, &bytes_read, 0);
f724bf08 1994 buf += bytes_read;
cfc14b3a
MK		 1995 augmentation++;
1996 }
1997
56c987f6
AO		 1998 /* "S" indicates a signal frame, such that the return
1999 address must not be decremented to locate the call frame
2000 info for the previous frame; it might even be the first
2001 instruction of a function, so decrementing it would take
2002 us to a different function. */
2003 else if (*augmentation == 'S')
2004 {
2005 cie->signal_frame = 1;
2006 augmentation++;
2007 }
2008
3e9a2e52
DJ		 2009 /* Otherwise we have an unknown augmentation. Assume that either
2010 there is no augmentation data, or we saw a 'z' prefix. */
cfc14b3a
MK		 2011 else
2012 {
3e9a2e52
DJ		 2013 if (cie->initial_instructions)
2014 buf = cie->initial_instructions;
cfc14b3a
MK		 2015 break;
2016 }
2017 }
2018
2019 cie->initial_instructions = buf;
2020 cie->end = end;
b01c8410 2021 cie->unit = unit;
cfc14b3a 2022
b01c8410 2023 add_cie (cie_table, cie);
cfc14b3a
MK		 2024 }
2025 else
2026 {
2027 /* This is a FDE. */
2028 struct dwarf2_fde *fde;
2029
6896c0c7
RH		 2030 /* In an .eh_frame section, the CIE pointer is the delta between the
2031 address within the FDE where the CIE pointer is stored and the
2032 address of the CIE. Convert it to an offset into the .eh_frame
2033 section. */
cfc14b3a
MK		 2034 if (eh_frame_p)
2035 {
cfc14b3a
MK		 2036 cie_pointer = buf - unit->dwarf_frame_buffer - cie_pointer;
2037 cie_pointer -= (dwarf64_p ? 8 : 4);
2038 }
2039
6896c0c7
RH		 2040 /* In either case, validate the result is still within the section. */
2041 if (cie_pointer >= unit->dwarf_frame_size)
2042 return NULL;
2043
cfc14b3a 2044 fde = (struct dwarf2_fde *)
8b92e4d5 2045 obstack_alloc (&unit->objfile->objfile_obstack,
cfc14b3a 2046 sizeof (struct dwarf2_fde));
b01c8410 2047 fde->cie = find_cie (cie_table, cie_pointer);
cfc14b3a
MK		 2048 if (fde->cie == NULL)
2049 {
2050 decode_frame_entry (unit, unit->dwarf_frame_buffer + cie_pointer,
b01c8410
PP		 2051 eh_frame_p, cie_table, fde_table);
2052 fde->cie = find_cie (cie_table, cie_pointer);
cfc14b3a
MK		 2053 }
2054
2055 gdb_assert (fde->cie != NULL);
2056
2057 fde->initial_location =
8da614df 2058 read_encoded_value (unit, fde->cie->encoding, fde->cie->ptr_size,
ae0d2f24 2059 buf, &bytes_read, 0);
cfc14b3a
MK		 2060 buf += bytes_read;
2061
2062 fde->address_range =
ae0d2f24 2063 read_encoded_value (unit, fde->cie->encoding & 0x0f,
8da614df 2064 fde->cie->ptr_size, buf, &bytes_read, 0);
cfc14b3a
MK		 2065 buf += bytes_read;
2066
7131cb6e
RH		 2067 /* A 'z' augmentation in the CIE implies the presence of an
2068 augmentation field in the FDE as well. The only thing known
2069 to be in here at present is the LSDA entry for EH. So we
2070 can skip the whole thing. */
2071 if (fde->cie->saw_z_augmentation)
2072 {
2073 ULONGEST length;
2074
2075 length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
2076 buf += bytes_read + length;
6896c0c7
RH		 2077 if (buf > end)
2078 return NULL;
7131cb6e
RH		 2079 }
2080
cfc14b3a
MK		 2081 fde->instructions = buf;
2082 fde->end = end;
2083
4bf8967c
AS		 2084 fde->eh_frame_p = eh_frame_p;
2085
b01c8410 2086 add_fde (fde_table, fde);
cfc14b3a
MK		 2087 }
2088
2089 return end;
2090}
6896c0c7
RH		 2091
2092/* Read a CIE or FDE in BUF and decode it. */
852483bc 2093static gdb_byte *
b01c8410
PP		 2094decode_frame_entry (struct comp_unit *unit, gdb_byte *start, int eh_frame_p,
2095 struct dwarf2_cie_table *cie_table,
2096 struct dwarf2_fde_table *fde_table)
6896c0c7
RH		 2097{
2098 enum { NONE, ALIGN4, ALIGN8, FAIL } workaround = NONE;
852483bc 2099 gdb_byte *ret;
6896c0c7
RH		 2100 ptrdiff_t start_offset;
2101
2102 while (1)
2103 {
b01c8410
PP		 2104 ret = decode_frame_entry_1 (unit, start, eh_frame_p,
2105 cie_table, fde_table);
6896c0c7
RH		 2106 if (ret != NULL)
2107 break;
2108
2109 /* We have corrupt input data of some form. */
2110
2111 /* ??? Try, weakly, to work around compiler/assembler/linker bugs
2112 and mismatches wrt padding and alignment of debug sections. */
2113 /* Note that there is no requirement in the standard for any
2114 alignment at all in the frame unwind sections. Testing for
2115 alignment before trying to interpret data would be incorrect.
2116
2117 However, GCC traditionally arranged for frame sections to be
2118 sized such that the FDE length and CIE fields happen to be
2119 aligned (in theory, for performance). This, unfortunately,
2120 was done with .align directives, which had the side effect of
2121 forcing the section to be aligned by the linker.
2122
2123 This becomes a problem when you have some other producer that
2124 creates frame sections that are not as strictly aligned. That
2125 produces a hole in the frame info that gets filled by the
2126 linker with zeros.
2127
2128 The GCC behaviour is arguably a bug, but it's effectively now
2129 part of the ABI, so we're now stuck with it, at least at the
2130 object file level. A smart linker may decide, in the process
2131 of compressing duplicate CIE information, that it can rewrite
2132 the entire output section without this extra padding. */
2133
2134 start_offset = start - unit->dwarf_frame_buffer;
2135 if (workaround < ALIGN4 && (start_offset & 3) != 0)
2136 {
2137 start += 4 - (start_offset & 3);
2138 workaround = ALIGN4;
2139 continue;
2140 }
2141 if (workaround < ALIGN8 && (start_offset & 7) != 0)
2142 {
2143 start += 8 - (start_offset & 7);
2144 workaround = ALIGN8;
2145 continue;
2146 }
2147
2148 /* Nothing left to try. Arrange to return as if we've consumed
2149 the entire input section. Hopefully we'll get valid info from
2150 the other of .debug_frame/.eh_frame. */
2151 workaround = FAIL;
2152 ret = unit->dwarf_frame_buffer + unit->dwarf_frame_size;
2153 break;
2154 }
2155
2156 switch (workaround)
2157 {
2158 case NONE:
2159 break;
2160
2161 case ALIGN4:
3e43a32a
MS		 2162 complaint (&symfile_complaints, _("\
2163Corrupt data in %s:%s; align 4 workaround apparently succeeded"),
6896c0c7
RH		 2164 unit->dwarf_frame_section->owner->filename,
2165 unit->dwarf_frame_section->name);
2166 break;
2167
2168 case ALIGN8:
3e43a32a
MS		 2169 complaint (&symfile_complaints, _("\
2170Corrupt data in %s:%s; align 8 workaround apparently succeeded"),
6896c0c7
RH		 2171 unit->dwarf_frame_section->owner->filename,
2172 unit->dwarf_frame_section->name);
2173 break;
2174
2175 default:
2176 complaint (&symfile_complaints,
e2e0b3e5 2177 _("Corrupt data in %s:%s"),
6896c0c7
RH		 2178 unit->dwarf_frame_section->owner->filename,
2179 unit->dwarf_frame_section->name);
2180 break;
2181 }
2182
2183 return ret;
2184}
cfc14b3a 2185\f
b01c8410
PP		 2186static int
2187qsort_fde_cmp (const void *a, const void *b)
2188{
2189 struct dwarf2_fde *aa = *(struct dwarf2_fde **)a;
2190 struct dwarf2_fde *bb = *(struct dwarf2_fde **)b;
e5af178f 2191
b01c8410 2192 if (aa->initial_location == bb->initial_location)
e5af178f
PP		 2193 {
2194 if (aa->address_range != bb->address_range
2195 && aa->eh_frame_p == 0 && bb->eh_frame_p == 0)
2196 /* Linker bug, e.g. gold/10400.
2197 Work around it by keeping stable sort order. */
2198 return (a < b) ? -1 : 1;
2199 else
2200 /* Put eh_frame entries after debug_frame ones. */
2201 return aa->eh_frame_p - bb->eh_frame_p;
2202 }
b01c8410
PP		 2203
2204 return (aa->initial_location < bb->initial_location) ? -1 : 1;
2205}
2206
cfc14b3a
MK		 2207void
2208dwarf2_build_frame_info (struct objfile *objfile)
2209{
ae0d2f24 2210 struct comp_unit *unit;
852483bc 2211 gdb_byte *frame_ptr;
b01c8410
PP		 2212 struct dwarf2_cie_table cie_table;
2213 struct dwarf2_fde_table fde_table;
be391dca 2214 struct dwarf2_fde_table *fde_table2;
b01c8410
PP		 2215
2216 cie_table.num_entries = 0;
2217 cie_table.entries = NULL;
2218
2219 fde_table.num_entries = 0;
2220 fde_table.entries = NULL;
cfc14b3a
MK		 2221
2222 /* Build a minimal decoding of the DWARF2 compilation unit. */
ae0d2f24
UW		 2223 unit = (struct comp_unit *) obstack_alloc (&objfile->objfile_obstack,
2224 sizeof (struct comp_unit));
2225 unit->abfd = objfile->obfd;
2226 unit->objfile = objfile;
2227 unit->dbase = 0;
2228 unit->tbase = 0;
cfc14b3a 2229
3017a003 2230 dwarf2_get_section_info (objfile, DWARF2_EH_FRAME,
dce234bc
PP		 2231 &unit->dwarf_frame_section,
2232 &unit->dwarf_frame_buffer,
2233 &unit->dwarf_frame_size);
2234 if (unit->dwarf_frame_size)
cfc14b3a 2235 {
0fd85043 2236 asection *got, *txt;
0912c7f2 2237
0912c7f2 2238 /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
37b517aa
MK		 2239 that is used for the i386/amd64 target, which currently is
2240 the only target in GCC that supports/uses the
2241 DW_EH_PE_datarel encoding. */
ae0d2f24 2242 got = bfd_get_section_by_name (unit->abfd, ".got");
0912c7f2 2243 if (got)
ae0d2f24 2244 unit->dbase = got->vma;
0912c7f2 2245
22c7ba1a
MK		 2246 /* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64
2247 so far. */
ae0d2f24 2248 txt = bfd_get_section_by_name (unit->abfd, ".text");
0fd85043 2249 if (txt)
ae0d2f24 2250 unit->tbase = txt->vma;
0fd85043 2251
ae0d2f24
UW		 2252 frame_ptr = unit->dwarf_frame_buffer;
2253 while (frame_ptr < unit->dwarf_frame_buffer + unit->dwarf_frame_size)
b01c8410
PP		 2254 frame_ptr = decode_frame_entry (unit, frame_ptr, 1,
2255 &cie_table, &fde_table);
2256
2257 if (cie_table.num_entries != 0)
2258 {
2259 /* Reinit cie_table: debug_frame has different CIEs. */
2260 xfree (cie_table.entries);
2261 cie_table.num_entries = 0;
2262 cie_table.entries = NULL;
2263 }
cfc14b3a
MK		 2264 }
2265
3017a003 2266 dwarf2_get_section_info (objfile, DWARF2_DEBUG_FRAME,
dce234bc
PP		 2267 &unit->dwarf_frame_section,
2268 &unit->dwarf_frame_buffer,
2269 &unit->dwarf_frame_size);
2270 if (unit->dwarf_frame_size)
cfc14b3a 2271 {
ae0d2f24
UW		 2272 frame_ptr = unit->dwarf_frame_buffer;
2273 while (frame_ptr < unit->dwarf_frame_buffer + unit->dwarf_frame_size)
b01c8410
PP		 2274 frame_ptr = decode_frame_entry (unit, frame_ptr, 0,
2275 &cie_table, &fde_table);
2276 }
2277
2278 /* Discard the cie_table, it is no longer needed. */
2279 if (cie_table.num_entries != 0)
2280 {
2281 xfree (cie_table.entries);
2282 cie_table.entries = NULL; /* Paranoia. */
2283 cie_table.num_entries = 0; /* Paranoia. */
2284 }
2285
be391dca
TT		 2286 /* Copy fde_table to obstack: it is needed at runtime. */
2287 fde_table2 = (struct dwarf2_fde_table *)
2288 obstack_alloc (&objfile->objfile_obstack, sizeof (*fde_table2));
2289
2290 if (fde_table.num_entries == 0)
2291 {
2292 fde_table2->entries = NULL;
2293 fde_table2->num_entries = 0;
2294 }
2295 else
b01c8410 2296 {
875cdfbb
PA		 2297 struct dwarf2_fde *fde_prev = NULL;
2298 struct dwarf2_fde *first_non_zero_fde = NULL;
2299 int i;
b01c8410
PP		 2300
2301 /* Prepare FDE table for lookups. */
2302 qsort (fde_table.entries, fde_table.num_entries,
2303 sizeof (fde_table.entries[0]), qsort_fde_cmp);
2304
875cdfbb
PA		 2305 /* Check for leftovers from --gc-sections. The GNU linker sets
2306 the relevant symbols to zero, but doesn't zero the FDE *end*
2307 ranges because there's no relocation there. It's (offset,
2308 length), not (start, end). On targets where address zero is
2309 just another valid address this can be a problem, since the
2310 FDEs appear to be non-empty in the output --- we could pick
2311 out the wrong FDE. To work around this, when overlaps are
2312 detected, we prefer FDEs that do not start at zero.
2313
2314 Start by finding the first FDE with non-zero start. Below
2315 we'll discard all FDEs that start at zero and overlap this
2316 one. */
2317 for (i = 0; i < fde_table.num_entries; i++)
2318 {
2319 struct dwarf2_fde *fde = fde_table.entries[i];
b01c8410 2320
875cdfbb
PA		 2321 if (fde->initial_location != 0)
2322 {
2323 first_non_zero_fde = fde;
2324 break;
2325 }
2326 }
2327
2328 /* Since we'll be doing bsearch, squeeze out identical (except
2329 for eh_frame_p) fde entries so bsearch result is predictable.
2330 Also discard leftovers from --gc-sections. */
be391dca 2331 fde_table2->num_entries = 0;
875cdfbb
PA		 2332 for (i = 0; i < fde_table.num_entries; i++)
2333 {
2334 struct dwarf2_fde *fde = fde_table.entries[i];
2335
2336 if (fde->initial_location == 0
2337 && first_non_zero_fde != NULL
2338 && (first_non_zero_fde->initial_location
2339 < fde->initial_location + fde->address_range))
2340 continue;
2341
2342 if (fde_prev != NULL
2343 && fde_prev->initial_location == fde->initial_location)
2344 continue;
2345
2346 obstack_grow (&objfile->objfile_obstack, &fde_table.entries[i],
2347 sizeof (fde_table.entries[0]));
2348 ++fde_table2->num_entries;
2349 fde_prev = fde;
2350 }
b01c8410 2351 fde_table2->entries = obstack_finish (&objfile->objfile_obstack);
b01c8410
PP		 2352
2353 /* Discard the original fde_table. */
2354 xfree (fde_table.entries);
cfc14b3a 2355 }
be391dca
TT		 2356
2357 set_objfile_data (objfile, dwarf2_frame_objfile_data, fde_table2);
cfc14b3a 2358}
0d0e1a63
MK		 2359
2360/* Provide a prototype to silence -Wmissing-prototypes. */
2361void _initialize_dwarf2_frame (void);
2362
2363void
2364_initialize_dwarf2_frame (void)
2365{
030f20e1 2366 dwarf2_frame_data = gdbarch_data_register_pre_init (dwarf2_frame_init);
8f22cb90 2367 dwarf2_frame_objfile_data = register_objfile_data ();
0d0e1a63 2368}
GDB Binutils - Deliverables
This page took 0.783145 seconds and 4 git commands to generate.