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