File: | src/gnu/usr.bin/binutils/gdb/dwarf2-frame.c |
Warning: | line 1306, column 33 Access to field 'initial_instructions' results in a dereference of a null pointer (loaded from variable 'cie') |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* Frame unwinder for frames with DWARF Call Frame Information. | ||||
2 | |||||
3 | Copyright 2003, 2004 Free Software Foundation, Inc. | ||||
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 | ||||
11 | the Free Software Foundation; either version 2 of the License, or | ||||
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 | ||||
20 | along with this program; if not, write to the Free Software | ||||
21 | Foundation, Inc., 59 Temple Place - Suite 330, | ||||
22 | Boston, MA 02111-1307, USA. */ | ||||
23 | |||||
24 | #include "defs.h" | ||||
25 | #include "dwarf2expr.h" | ||||
26 | #include "elf/dwarf2.h" | ||||
27 | #include "frame.h" | ||||
28 | #include "frame-base.h" | ||||
29 | #include "frame-unwind.h" | ||||
30 | #include "gdbcore.h" | ||||
31 | #include "gdbtypes.h" | ||||
32 | #include "symtab.h" | ||||
33 | #include "objfiles.h" | ||||
34 | #include "regcache.h" | ||||
35 | |||||
36 | #include "gdb_assert.h" | ||||
37 | #include "gdb_string.h" | ||||
38 | |||||
39 | #include "complaints.h" | ||||
40 | #include "dwarf2-frame.h" | ||||
41 | |||||
42 | /* Call Frame Information (CFI). */ | ||||
43 | |||||
44 | /* Common Information Entry (CIE). */ | ||||
45 | |||||
46 | struct dwarf2_cie | ||||
47 | { | ||||
48 | /* Offset into the .debug_frame section where this CIE was found. | ||||
49 | Used to identify this CIE. */ | ||||
50 | ULONGESTunsigned long cie_pointer; | ||||
51 | |||||
52 | /* Constant that is factored out of all advance location | ||||
53 | instructions. */ | ||||
54 | ULONGESTunsigned long code_alignment_factor; | ||||
55 | |||||
56 | /* Constants that is factored out of all offset instructions. */ | ||||
57 | LONGESTlong data_alignment_factor; | ||||
58 | |||||
59 | /* Return address column. */ | ||||
60 | ULONGESTunsigned long return_address_register; | ||||
61 | |||||
62 | /* Instruction sequence to initialize a register set. */ | ||||
63 | unsigned char *initial_instructions; | ||||
64 | unsigned char *end; | ||||
65 | |||||
66 | /* Encoding of addresses. */ | ||||
67 | unsigned char encoding; | ||||
68 | |||||
69 | /* True if a 'z' augmentation existed. */ | ||||
70 | unsigned char saw_z_augmentation; | ||||
71 | |||||
72 | struct dwarf2_cie *next; | ||||
73 | }; | ||||
74 | |||||
75 | /* Frame Description Entry (FDE). */ | ||||
76 | |||||
77 | struct dwarf2_fde | ||||
78 | { | ||||
79 | /* CIE for this FDE. */ | ||||
80 | struct dwarf2_cie *cie; | ||||
81 | |||||
82 | /* First location associated with this FDE. */ | ||||
83 | CORE_ADDR initial_location; | ||||
84 | |||||
85 | /* Number of bytes of program instructions described by this FDE. */ | ||||
86 | CORE_ADDR address_range; | ||||
87 | |||||
88 | /* Instruction sequence. */ | ||||
89 | unsigned char *instructions; | ||||
90 | unsigned char *end; | ||||
91 | |||||
92 | struct dwarf2_fde *next; | ||||
93 | }; | ||||
94 | |||||
95 | static struct dwarf2_fde *dwarf2_frame_find_fde (CORE_ADDR *pc); | ||||
96 | |||||
97 | |||||
98 | /* Structure describing a frame state. */ | ||||
99 | |||||
100 | struct dwarf2_frame_state | ||||
101 | { | ||||
102 | /* Each register save state can be described in terms of a CFA slot, | ||||
103 | another register, or a location expression. */ | ||||
104 | struct dwarf2_frame_state_reg_info | ||||
105 | { | ||||
106 | struct dwarf2_frame_state_reg *reg; | ||||
107 | int num_regs; | ||||
108 | |||||
109 | /* Used to implement DW_CFA_remember_state. */ | ||||
110 | struct dwarf2_frame_state_reg_info *prev; | ||||
111 | } regs; | ||||
112 | |||||
113 | LONGESTlong cfa_offset; | ||||
114 | ULONGESTunsigned long cfa_reg; | ||||
115 | unsigned char *cfa_exp; | ||||
116 | enum { | ||||
117 | CFA_UNSET, | ||||
118 | CFA_REG_OFFSET, | ||||
119 | CFA_EXP | ||||
120 | } cfa_how; | ||||
121 | |||||
122 | /* The PC described by the current frame state. */ | ||||
123 | CORE_ADDR pc; | ||||
124 | |||||
125 | /* Initial register set from the CIE. | ||||
126 | Used to implement DW_CFA_restore. */ | ||||
127 | struct dwarf2_frame_state_reg_info initial; | ||||
128 | |||||
129 | /* The information we care about from the CIE. */ | ||||
130 | LONGESTlong data_align; | ||||
131 | ULONGESTunsigned long code_align; | ||||
132 | ULONGESTunsigned long retaddr_column; | ||||
133 | }; | ||||
134 | |||||
135 | /* Store the length the expression for the CFA in the `cfa_reg' field, | ||||
136 | which is unused in that case. */ | ||||
137 | #define cfa_exp_lencfa_reg cfa_reg | ||||
138 | |||||
139 | /* Assert that the register set RS is large enough to store NUM_REGS | ||||
140 | columns. If necessary, enlarge the register set. */ | ||||
141 | |||||
142 | static void | ||||
143 | dwarf2_frame_state_alloc_regs (struct dwarf2_frame_state_reg_info *rs, | ||||
144 | int num_regs) | ||||
145 | { | ||||
146 | size_t size = sizeof (struct dwarf2_frame_state_reg); | ||||
147 | |||||
148 | if (num_regs <= rs->num_regs) | ||||
149 | return; | ||||
150 | |||||
151 | rs->reg = (struct dwarf2_frame_state_reg *) | ||||
152 | xrealloc (rs->reg, num_regs * size); | ||||
153 | |||||
154 | /* Initialize newly allocated registers. */ | ||||
155 | memset (rs->reg + rs->num_regs, 0, (num_regs - rs->num_regs) * size); | ||||
156 | rs->num_regs = num_regs; | ||||
157 | } | ||||
158 | |||||
159 | /* Copy the register columns in register set RS into newly allocated | ||||
160 | memory and return a pointer to this newly created copy. */ | ||||
161 | |||||
162 | static struct dwarf2_frame_state_reg * | ||||
163 | dwarf2_frame_state_copy_regs (struct dwarf2_frame_state_reg_info *rs) | ||||
164 | { | ||||
165 | size_t size = rs->num_regs * sizeof (struct dwarf2_frame_state_reg_info); | ||||
166 | struct dwarf2_frame_state_reg *reg; | ||||
167 | |||||
168 | reg = (struct dwarf2_frame_state_reg *) xmalloc (size); | ||||
169 | memcpy (reg, rs->reg, size); | ||||
170 | |||||
171 | return reg; | ||||
172 | } | ||||
173 | |||||
174 | /* Release the memory allocated to register set RS. */ | ||||
175 | |||||
176 | static void | ||||
177 | dwarf2_frame_state_free_regs (struct dwarf2_frame_state_reg_info *rs) | ||||
178 | { | ||||
179 | if (rs) | ||||
180 | { | ||||
181 | dwarf2_frame_state_free_regs (rs->prev); | ||||
182 | |||||
183 | xfree (rs->reg); | ||||
184 | xfree (rs); | ||||
185 | } | ||||
186 | } | ||||
187 | |||||
188 | /* Release the memory allocated to the frame state FS. */ | ||||
189 | |||||
190 | static void | ||||
191 | dwarf2_frame_state_free (void *p) | ||||
192 | { | ||||
193 | struct dwarf2_frame_state *fs = p; | ||||
194 | |||||
195 | dwarf2_frame_state_free_regs (fs->initial.prev); | ||||
196 | dwarf2_frame_state_free_regs (fs->regs.prev); | ||||
197 | xfree (fs->initial.reg); | ||||
198 | xfree (fs->regs.reg); | ||||
199 | xfree (fs); | ||||
200 | } | ||||
201 | |||||
202 | |||||
203 | /* Helper functions for execute_stack_op. */ | ||||
204 | |||||
205 | static CORE_ADDR | ||||
206 | read_reg (void *baton, int reg) | ||||
207 | { | ||||
208 | struct frame_info *next_frame = (struct frame_info *) baton; | ||||
209 | struct gdbarch *gdbarch = get_frame_arch (next_frame); | ||||
210 | int regnum; | ||||
211 | char *buf; | ||||
212 | |||||
213 | regnum = DWARF2_REG_TO_REGNUM (reg)(gdbarch_dwarf2_reg_to_regnum (current_gdbarch, reg)); | ||||
214 | |||||
215 | buf = (char *) alloca (register_size (gdbarch, regnum))__builtin_alloca(register_size (gdbarch, regnum)); | ||||
216 | frame_unwind_register (next_frame, regnum, buf); | ||||
217 | return extract_typed_address (buf, builtin_type_void_data_ptr); | ||||
218 | } | ||||
219 | |||||
220 | static void | ||||
221 | read_mem (void *baton, char *buf, CORE_ADDR addr, size_t len) | ||||
222 | { | ||||
223 | read_memory (addr, buf, len); | ||||
224 | } | ||||
225 | |||||
226 | static void | ||||
227 | no_get_frame_base (void *baton, unsigned char **start, size_t *length) | ||||
228 | { | ||||
229 | internal_error (__FILE__"/usr/src/gnu/usr.bin/binutils/gdb/dwarf2-frame.c", __LINE__229, | ||||
230 | "Support for DW_OP_fbreg is unimplemented"); | ||||
231 | } | ||||
232 | |||||
233 | static CORE_ADDR | ||||
234 | no_get_tls_address (void *baton, CORE_ADDR offset) | ||||
235 | { | ||||
236 | internal_error (__FILE__"/usr/src/gnu/usr.bin/binutils/gdb/dwarf2-frame.c", __LINE__236, | ||||
237 | "Support for DW_OP_GNU_push_tls_address is unimplemented"); | ||||
238 | } | ||||
239 | |||||
240 | static CORE_ADDR | ||||
241 | execute_stack_op (unsigned char *exp, ULONGESTunsigned long len, | ||||
242 | struct frame_info *next_frame, CORE_ADDR initial) | ||||
243 | { | ||||
244 | struct dwarf_expr_context *ctx; | ||||
245 | CORE_ADDR result; | ||||
246 | |||||
247 | ctx = new_dwarf_expr_context (); | ||||
248 | ctx->baton = next_frame; | ||||
249 | ctx->read_reg = read_reg; | ||||
250 | ctx->read_mem = read_mem; | ||||
251 | ctx->get_frame_base = no_get_frame_base; | ||||
252 | ctx->get_tls_address = no_get_tls_address; | ||||
253 | |||||
254 | dwarf_expr_push (ctx, initial); | ||||
255 | dwarf_expr_eval (ctx, exp, len); | ||||
256 | result = dwarf_expr_fetch (ctx, 0); | ||||
257 | |||||
258 | if (ctx->in_reg) | ||||
259 | result = read_reg (next_frame, result); | ||||
260 | |||||
261 | free_dwarf_expr_context (ctx); | ||||
262 | |||||
263 | return result; | ||||
264 | } | ||||
265 | |||||
266 | |||||
267 | static void | ||||
268 | execute_cfa_program (unsigned char *insn_ptr, unsigned char *insn_end, | ||||
269 | struct frame_info *next_frame, | ||||
270 | struct dwarf2_frame_state *fs) | ||||
271 | { | ||||
272 | CORE_ADDR pc = frame_pc_unwind (next_frame); | ||||
273 | int bytes_read; | ||||
274 | |||||
275 | while (insn_ptr < insn_end && fs->pc <= pc) | ||||
276 | { | ||||
277 | unsigned char insn = *insn_ptr++; | ||||
278 | ULONGESTunsigned long utmp, reg; | ||||
279 | LONGESTlong offset; | ||||
280 | |||||
281 | if ((insn & 0xc0) == DW_CFA_advance_loc) | ||||
282 | fs->pc += (insn & 0x3f) * fs->code_align; | ||||
283 | else if ((insn & 0xc0) == DW_CFA_offset) | ||||
284 | { | ||||
285 | reg = insn & 0x3f; | ||||
286 | insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp); | ||||
287 | offset = utmp * fs->data_align; | ||||
288 | dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1); | ||||
289 | fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET; | ||||
290 | fs->regs.reg[reg].loc.offset = offset; | ||||
291 | } | ||||
292 | else if ((insn & 0xc0) == DW_CFA_restore) | ||||
293 | { | ||||
294 | gdb_assert (fs->initial.reg)((void) ((fs->initial.reg) ? 0 : (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/dwarf2-frame.c" , 294, "%s: Assertion `%s' failed.", __PRETTY_FUNCTION__, "fs->initial.reg" ), 0))); | ||||
295 | reg = insn & 0x3f; | ||||
296 | dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1); | ||||
297 | fs->regs.reg[reg] = fs->initial.reg[reg]; | ||||
298 | } | ||||
299 | else | ||||
300 | { | ||||
301 | switch (insn) | ||||
302 | { | ||||
303 | case DW_CFA_set_loc: | ||||
304 | fs->pc = dwarf2_read_address (insn_ptr, insn_end, &bytes_read); | ||||
305 | insn_ptr += bytes_read; | ||||
306 | break; | ||||
307 | |||||
308 | case DW_CFA_advance_loc1: | ||||
309 | utmp = extract_unsigned_integer (insn_ptr, 1); | ||||
310 | fs->pc += utmp * fs->code_align; | ||||
311 | insn_ptr++; | ||||
312 | break; | ||||
313 | case DW_CFA_advance_loc2: | ||||
314 | utmp = extract_unsigned_integer (insn_ptr, 2); | ||||
315 | fs->pc += utmp * fs->code_align; | ||||
316 | insn_ptr += 2; | ||||
317 | break; | ||||
318 | case DW_CFA_advance_loc4: | ||||
319 | utmp = extract_unsigned_integer (insn_ptr, 4); | ||||
320 | fs->pc += utmp * fs->code_align; | ||||
321 | insn_ptr += 4; | ||||
322 | break; | ||||
323 | |||||
324 | case DW_CFA_offset_extended: | ||||
325 | insn_ptr = read_uleb128 (insn_ptr, insn_end, ®); | ||||
326 | insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp); | ||||
327 | offset = utmp * fs->data_align; | ||||
328 | dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1); | ||||
329 | fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET; | ||||
330 | fs->regs.reg[reg].loc.offset = offset; | ||||
331 | break; | ||||
332 | |||||
333 | case DW_CFA_restore_extended: | ||||
334 | gdb_assert (fs->initial.reg)((void) ((fs->initial.reg) ? 0 : (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/dwarf2-frame.c" , 334, "%s: Assertion `%s' failed.", __PRETTY_FUNCTION__, "fs->initial.reg" ), 0))); | ||||
335 | insn_ptr = read_uleb128 (insn_ptr, insn_end, ®); | ||||
336 | dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1); | ||||
337 | fs->regs.reg[reg] = fs->initial.reg[reg]; | ||||
338 | break; | ||||
339 | |||||
340 | case DW_CFA_undefined: | ||||
341 | insn_ptr = read_uleb128 (insn_ptr, insn_end, ®); | ||||
342 | dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1); | ||||
343 | fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNDEFINED; | ||||
344 | break; | ||||
345 | |||||
346 | case DW_CFA_same_value: | ||||
347 | insn_ptr = read_uleb128 (insn_ptr, insn_end, ®); | ||||
348 | dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1); | ||||
349 | fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAME_VALUE; | ||||
350 | break; | ||||
351 | |||||
352 | case DW_CFA_register: | ||||
353 | insn_ptr = read_uleb128 (insn_ptr, insn_end, ®); | ||||
354 | insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp); | ||||
355 | dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1); | ||||
356 | fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG; | ||||
357 | fs->regs.reg[reg].loc.reg = utmp; | ||||
358 | break; | ||||
359 | |||||
360 | case DW_CFA_remember_state: | ||||
361 | { | ||||
362 | struct dwarf2_frame_state_reg_info *new_rs; | ||||
363 | |||||
364 | new_rs = XMALLOC (struct dwarf2_frame_state_reg_info)((struct dwarf2_frame_state_reg_info*) xmalloc (sizeof (struct dwarf2_frame_state_reg_info))); | ||||
365 | *new_rs = fs->regs; | ||||
366 | fs->regs.reg = dwarf2_frame_state_copy_regs (&fs->regs); | ||||
367 | fs->regs.prev = new_rs; | ||||
368 | } | ||||
369 | break; | ||||
370 | |||||
371 | case DW_CFA_restore_state: | ||||
372 | { | ||||
373 | struct dwarf2_frame_state_reg_info *old_rs = fs->regs.prev; | ||||
374 | |||||
375 | if (old_rs == NULL((void*)0)) | ||||
376 | { | ||||
377 | complaint (&symfile_complaints, "\ | ||||
378 | bad CFI data; mismatched DW_CFA_restore_state at 0x%s", paddr (fs->pc)); | ||||
379 | } | ||||
380 | else | ||||
381 | { | ||||
382 | xfree (fs->regs.reg); | ||||
383 | fs->regs = *old_rs; | ||||
384 | xfree (old_rs); | ||||
385 | } | ||||
386 | } | ||||
387 | break; | ||||
388 | |||||
389 | case DW_CFA_def_cfa: | ||||
390 | insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_reg); | ||||
391 | insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp); | ||||
392 | fs->cfa_offset = utmp; | ||||
393 | fs->cfa_how = CFA_REG_OFFSET; | ||||
394 | break; | ||||
395 | |||||
396 | case DW_CFA_def_cfa_register: | ||||
397 | insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_reg); | ||||
398 | fs->cfa_how = CFA_REG_OFFSET; | ||||
399 | break; | ||||
400 | |||||
401 | case DW_CFA_def_cfa_offset: | ||||
402 | insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_offset); | ||||
403 | /* cfa_how deliberately not set. */ | ||||
404 | break; | ||||
405 | |||||
406 | case DW_CFA_nop: | ||||
407 | break; | ||||
408 | |||||
409 | case DW_CFA_def_cfa_expression: | ||||
410 | insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_exp_lencfa_reg); | ||||
411 | fs->cfa_exp = insn_ptr; | ||||
412 | fs->cfa_how = CFA_EXP; | ||||
413 | insn_ptr += fs->cfa_exp_lencfa_reg; | ||||
414 | break; | ||||
415 | |||||
416 | case DW_CFA_expression: | ||||
417 | insn_ptr = read_uleb128 (insn_ptr, insn_end, ®); | ||||
418 | dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1); | ||||
419 | insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp); | ||||
420 | fs->regs.reg[reg].loc.exp = insn_ptr; | ||||
421 | fs->regs.reg[reg].exp_len = utmp; | ||||
422 | fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_EXP; | ||||
423 | insn_ptr += utmp; | ||||
424 | break; | ||||
425 | |||||
426 | case DW_CFA_offset_extended_sf: | ||||
427 | insn_ptr = read_uleb128 (insn_ptr, insn_end, ®); | ||||
428 | insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset); | ||||
429 | offset *= fs->data_align; | ||||
430 | dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1); | ||||
431 | fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET; | ||||
432 | fs->regs.reg[reg].loc.offset = offset; | ||||
433 | break; | ||||
434 | |||||
435 | case DW_CFA_def_cfa_sf: | ||||
436 | insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_reg); | ||||
437 | insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset); | ||||
438 | fs->cfa_offset = offset * fs->data_align; | ||||
439 | fs->cfa_how = CFA_REG_OFFSET; | ||||
440 | break; | ||||
441 | |||||
442 | case DW_CFA_def_cfa_offset_sf: | ||||
443 | insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset); | ||||
444 | fs->cfa_offset = offset * fs->data_align; | ||||
445 | /* cfa_how deliberately not set. */ | ||||
446 | break; | ||||
447 | |||||
448 | case DW_CFA_val_expression: | ||||
449 | insn_ptr = read_uleb128 (insn_ptr, insn_end, ®); | ||||
450 | dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1); | ||||
451 | insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp); | ||||
452 | fs->regs.reg[reg].loc.exp = insn_ptr; | ||||
453 | fs->regs.reg[reg].exp_len = utmp; | ||||
454 | fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_EXP; | ||||
455 | insn_ptr += utmp; | ||||
456 | break; | ||||
457 | |||||
458 | case DW_CFA_GNU_args_size: | ||||
459 | /* Ignored. */ | ||||
460 | insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp); | ||||
461 | break; | ||||
462 | |||||
463 | default: | ||||
464 | internal_error (__FILE__"/usr/src/gnu/usr.bin/binutils/gdb/dwarf2-frame.c", __LINE__464, "Unknown CFI encountered."); | ||||
465 | } | ||||
466 | } | ||||
467 | } | ||||
468 | |||||
469 | /* Don't allow remember/restore between CIE and FDE programs. */ | ||||
470 | dwarf2_frame_state_free_regs (fs->regs.prev); | ||||
471 | fs->regs.prev = NULL((void*)0); | ||||
472 | } | ||||
473 | |||||
474 | |||||
475 | /* Architecture-specific operations. */ | ||||
476 | |||||
477 | /* Per-architecture data key. */ | ||||
478 | static struct gdbarch_data *dwarf2_frame_data; | ||||
479 | |||||
480 | struct dwarf2_frame_ops | ||||
481 | { | ||||
482 | /* Pre-initialize the register state REG for register REGNUM. */ | ||||
483 | void (*init_reg) (struct gdbarch *, int, struct dwarf2_frame_state_reg *); | ||||
484 | }; | ||||
485 | |||||
486 | /* Default architecture-specific register state initialization | ||||
487 | function. */ | ||||
488 | |||||
489 | static void | ||||
490 | dwarf2_frame_default_init_reg (struct gdbarch *gdbarch, int regnum, | ||||
491 | struct dwarf2_frame_state_reg *reg) | ||||
492 | { | ||||
493 | /* If we have a register that acts as a program counter, mark it as | ||||
494 | a destination for the return address. If we have a register that | ||||
495 | serves as the stack pointer, arrange for it to be filled with the | ||||
496 | call frame address (CFA). The other registers are marked as | ||||
497 | unspecified. | ||||
498 | |||||
499 | We copy the return address to the program counter, since many | ||||
500 | parts in GDB assume that it is possible to get the return address | ||||
501 | by unwinding the program counter register. However, on ISA's | ||||
502 | with a dedicated return address register, the CFI usually only | ||||
503 | contains information to unwind that return address register. | ||||
504 | |||||
505 | The reason we're treating the stack pointer special here is | ||||
506 | because in many cases GCC doesn't emit CFI for the stack pointer | ||||
507 | and implicitly assumes that it is equal to the CFA. This makes | ||||
508 | some sense since the DWARF specification (version 3, draft 8, | ||||
509 | p. 102) says that: | ||||
510 | |||||
511 | "Typically, the CFA is defined to be the value of the stack | ||||
512 | pointer at the call site in the previous frame (which may be | ||||
513 | different from its value on entry to the current frame)." | ||||
514 | |||||
515 | However, this isn't true for all platforms supported by GCC | ||||
516 | (e.g. IBM S/390 and zSeries). Those architectures should provide | ||||
517 | their own architecture-specific initialization function. */ | ||||
518 | |||||
519 | if (regnum == PC_REGNUM(gdbarch_pc_regnum (current_gdbarch))) | ||||
520 | reg->how = DWARF2_FRAME_REG_RA; | ||||
521 | else if (regnum == SP_REGNUM(gdbarch_sp_regnum (current_gdbarch))) | ||||
522 | reg->how = DWARF2_FRAME_REG_CFA; | ||||
523 | } | ||||
524 | |||||
525 | /* Return a default for the architecture-specific operations. */ | ||||
526 | |||||
527 | static void * | ||||
528 | dwarf2_frame_init (struct obstack *obstack) | ||||
529 | { | ||||
530 | struct dwarf2_frame_ops *ops; | ||||
531 | |||||
532 | ops = OBSTACK_ZALLOC (obstack, struct dwarf2_frame_ops)(memset (__extension__ ({ struct obstack *__h = ((obstack)); __extension__ ({ struct obstack *__o = (__h); int __len = ((sizeof (struct dwarf2_frame_ops))); if (__o->chunk_limit - __o->next_free < __len) _obstack_newchunk (__o, __len); ((__o)->next_free += (__len)); (void) 0; }); __extension__ ({ struct obstack * __o1 = (__h); void *value; value = (void *) __o1->object_base ; if (__o1->next_free == value) __o1->maybe_empty_object = 1; __o1->next_free = (((((__o1->next_free) - (char * ) 0)+__o1->alignment_mask) & ~ (__o1->alignment_mask )) + (char *) 0); if (__o1->next_free - (char *)__o1->chunk > __o1->chunk_limit - (char *)__o1->chunk) __o1-> next_free = __o1->chunk_limit; __o1->object_base = __o1 ->next_free; value; }); }), 0, sizeof (struct dwarf2_frame_ops ))); | ||||
533 | ops->init_reg = dwarf2_frame_default_init_reg; | ||||
534 | return ops; | ||||
535 | } | ||||
536 | |||||
537 | /* Set the architecture-specific register state initialization | ||||
538 | function for GDBARCH to INIT_REG. */ | ||||
539 | |||||
540 | void | ||||
541 | dwarf2_frame_set_init_reg (struct gdbarch *gdbarch, | ||||
542 | void (*init_reg) (struct gdbarch *, int, | ||||
543 | struct dwarf2_frame_state_reg *)) | ||||
544 | { | ||||
545 | struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data); | ||||
546 | |||||
547 | ops->init_reg = init_reg; | ||||
548 | } | ||||
549 | |||||
550 | /* Pre-initialize the register state REG for register REGNUM. */ | ||||
551 | |||||
552 | static void | ||||
553 | dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum, | ||||
554 | struct dwarf2_frame_state_reg *reg) | ||||
555 | { | ||||
556 | struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data); | ||||
557 | |||||
558 | ops->init_reg (gdbarch, regnum, reg); | ||||
559 | } | ||||
560 | |||||
561 | |||||
562 | struct dwarf2_frame_cache | ||||
563 | { | ||||
564 | /* DWARF Call Frame Address. */ | ||||
565 | CORE_ADDR cfa; | ||||
566 | |||||
567 | /* Saved registers, indexed by GDB register number, not by DWARF | ||||
568 | register number. */ | ||||
569 | struct dwarf2_frame_state_reg *reg; | ||||
570 | }; | ||||
571 | |||||
572 | static struct dwarf2_frame_cache * | ||||
573 | dwarf2_frame_cache (struct frame_info *next_frame, void **this_cache) | ||||
574 | { | ||||
575 | struct cleanup *old_chain; | ||||
576 | struct gdbarch *gdbarch = get_frame_arch (next_frame); | ||||
577 | const int num_regs = NUM_REGS(gdbarch_num_regs (current_gdbarch)) + NUM_PSEUDO_REGS(gdbarch_num_pseudo_regs (current_gdbarch)); | ||||
578 | struct dwarf2_frame_cache *cache; | ||||
579 | struct dwarf2_frame_state *fs; | ||||
580 | struct dwarf2_fde *fde; | ||||
581 | |||||
582 | if (*this_cache) | ||||
583 | return *this_cache; | ||||
584 | |||||
585 | /* Allocate a new cache. */ | ||||
586 | cache = FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache)((struct dwarf2_frame_cache *) frame_obstack_zalloc (sizeof ( struct dwarf2_frame_cache))); | ||||
587 | cache->reg = FRAME_OBSTACK_CALLOC (num_regs, struct dwarf2_frame_state_reg)((struct dwarf2_frame_state_reg *) frame_obstack_zalloc ((num_regs ) * sizeof (struct dwarf2_frame_state_reg))); | ||||
588 | |||||
589 | /* Allocate and initialize the frame state. */ | ||||
590 | fs = XMALLOC (struct dwarf2_frame_state)((struct dwarf2_frame_state*) xmalloc (sizeof (struct dwarf2_frame_state ))); | ||||
591 | memset (fs, 0, sizeof (struct dwarf2_frame_state)); | ||||
592 | old_chain = make_cleanup (dwarf2_frame_state_free, fs); | ||||
593 | |||||
594 | /* Unwind the PC. | ||||
595 | |||||
596 | Note that if NEXT_FRAME is never supposed to return (i.e. a call | ||||
597 | to abort), the compiler might optimize away the instruction at | ||||
598 | NEXT_FRAME's return address. As a result the return address will | ||||
599 | point at some random instruction, and the CFI for that | ||||
600 | instruction is probably worthless to us. GCC's unwinder solves | ||||
601 | this problem by substracting 1 from the return address to get an | ||||
602 | address in the middle of a presumed call instruction (or the | ||||
603 | instruction in the associated delay slot). This should only be | ||||
604 | done for "normal" frames and not for resume-type frames (signal | ||||
605 | handlers, sentinel frames, dummy frames). The function | ||||
606 | frame_unwind_address_in_block does just this. It's not clear how | ||||
607 | reliable the method is though; there is the potential for the | ||||
608 | register state pre-call being different to that on return. */ | ||||
609 | fs->pc = frame_unwind_address_in_block (next_frame); | ||||
610 | |||||
611 | /* Find the correct FDE. */ | ||||
612 | fde = dwarf2_frame_find_fde (&fs->pc); | ||||
613 | gdb_assert (fde != NULL)((void) ((fde != ((void*)0)) ? 0 : (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/dwarf2-frame.c" , 613, "%s: Assertion `%s' failed.", __PRETTY_FUNCTION__, "fde != NULL" ), 0))); | ||||
614 | |||||
615 | /* Extract any interesting information from the CIE. */ | ||||
616 | fs->data_align = fde->cie->data_alignment_factor; | ||||
617 | fs->code_align = fde->cie->code_alignment_factor; | ||||
618 | fs->retaddr_column = fde->cie->return_address_register; | ||||
619 | |||||
620 | /* First decode all the insns in the CIE. */ | ||||
621 | execute_cfa_program (fde->cie->initial_instructions, | ||||
622 | fde->cie->end, next_frame, fs); | ||||
623 | |||||
624 | /* Save the initialized register set. */ | ||||
625 | fs->initial = fs->regs; | ||||
626 | fs->initial.reg = dwarf2_frame_state_copy_regs (&fs->regs); | ||||
627 | |||||
628 | /* Then decode the insns in the FDE up to our target PC. */ | ||||
629 | execute_cfa_program (fde->instructions, fde->end, next_frame, fs); | ||||
630 | |||||
631 | /* Caclulate the CFA. */ | ||||
632 | switch (fs->cfa_how) | ||||
633 | { | ||||
634 | case CFA_REG_OFFSET: | ||||
635 | cache->cfa = read_reg (next_frame, fs->cfa_reg); | ||||
636 | cache->cfa += fs->cfa_offset; | ||||
637 | break; | ||||
638 | |||||
639 | case CFA_EXP: | ||||
640 | cache->cfa = | ||||
641 | execute_stack_op (fs->cfa_exp, fs->cfa_exp_lencfa_reg, next_frame, 0); | ||||
642 | break; | ||||
643 | |||||
644 | default: | ||||
645 | internal_error (__FILE__"/usr/src/gnu/usr.bin/binutils/gdb/dwarf2-frame.c", __LINE__645, "Unknown CFA rule."); | ||||
646 | } | ||||
647 | |||||
648 | /* Initialize the register state. */ | ||||
649 | { | ||||
650 | int regnum; | ||||
651 | |||||
652 | for (regnum = 0; regnum < num_regs; regnum++) | ||||
653 | dwarf2_frame_init_reg (gdbarch, regnum, &cache->reg[regnum]); | ||||
654 | } | ||||
655 | |||||
656 | /* Go through the DWARF2 CFI generated table and save its register | ||||
657 | location information in the cache. Note that we don't skip the | ||||
658 | return address column; it's perfectly all right for it to | ||||
659 | correspond to a real register. If it doesn't correspond to a | ||||
660 | real register, or if we shouldn't treat it as such, | ||||
661 | DWARF2_REG_TO_REGNUM should be defined to return a number outside | ||||
662 | the range [0, NUM_REGS). */ | ||||
663 | { | ||||
664 | int column; /* CFI speak for "register number". */ | ||||
665 | |||||
666 | for (column = 0; column < fs->regs.num_regs; column++) | ||||
667 | { | ||||
668 | /* Use the GDB register number as the destination index. */ | ||||
669 | int regnum = DWARF2_REG_TO_REGNUM (column)(gdbarch_dwarf2_reg_to_regnum (current_gdbarch, column)); | ||||
670 | |||||
671 | /* If there's no corresponding GDB register, ignore it. */ | ||||
672 | if (regnum < 0 || regnum >= num_regs) | ||||
673 | continue; | ||||
674 | |||||
675 | /* NOTE: cagney/2003-09-05: CFI should specify the disposition | ||||
676 | of all debug info registers. If it doesn't, complain (but | ||||
677 | not too loudly). It turns out that GCC assumes that an | ||||
678 | unspecified register implies "same value" when CFI (draft | ||||
679 | 7) specifies nothing at all. Such a register could equally | ||||
680 | be interpreted as "undefined". Also note that this check | ||||
681 | isn't sufficient; it only checks that all registers in the | ||||
682 | range [0 .. max column] are specified, and won't detect | ||||
683 | problems when a debug info register falls outside of the | ||||
684 | table. We need a way of iterating through all the valid | ||||
685 | DWARF2 register numbers. */ | ||||
686 | if (fs->regs.reg[column].how == DWARF2_FRAME_REG_UNSPECIFIED) | ||||
687 | complaint (&symfile_complaints, | ||||
688 | "Incomplete CFI data; unspecified registers at 0x%s", | ||||
689 | paddr (fs->pc)); | ||||
690 | else | ||||
691 | cache->reg[regnum] = fs->regs.reg[column]; | ||||
692 | } | ||||
693 | } | ||||
694 | |||||
695 | /* Eliminate any DWARF2_FRAME_REG_RA rules. */ | ||||
696 | { | ||||
697 | int regnum; | ||||
698 | |||||
699 | for (regnum = 0; regnum < num_regs; regnum++) | ||||
700 | { | ||||
701 | if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA) | ||||
702 | { | ||||
703 | struct dwarf2_frame_state_reg *retaddr_reg = | ||||
704 | &fs->regs.reg[fs->retaddr_column]; | ||||
705 | |||||
706 | /* It seems rather bizarre to specify an "empty" column as | ||||
707 | the return adress column. However, this is exactly | ||||
708 | what GCC does on some targets. It turns out that GCC | ||||
709 | assumes that the return address can be found in the | ||||
710 | register corresponding to the return address column. | ||||
711 | Incidentally, that's how should treat a return address | ||||
712 | column specifying "same value" too. */ | ||||
713 | if (fs->retaddr_column < fs->regs.num_regs | ||||
714 | && retaddr_reg->how != DWARF2_FRAME_REG_UNSPECIFIED | ||||
715 | && retaddr_reg->how != DWARF2_FRAME_REG_SAME_VALUE) | ||||
716 | cache->reg[regnum] = *retaddr_reg; | ||||
717 | else | ||||
718 | { | ||||
719 | cache->reg[regnum].loc.reg = fs->retaddr_column; | ||||
720 | cache->reg[regnum].how = DWARF2_FRAME_REG_SAVED_REG; | ||||
721 | } | ||||
722 | } | ||||
723 | } | ||||
724 | } | ||||
725 | |||||
726 | do_cleanups (old_chain); | ||||
727 | |||||
728 | *this_cache = cache; | ||||
729 | return cache; | ||||
730 | } | ||||
731 | |||||
732 | static void | ||||
733 | dwarf2_frame_this_id (struct frame_info *next_frame, void **this_cache, | ||||
734 | struct frame_id *this_id) | ||||
735 | { | ||||
736 | struct dwarf2_frame_cache *cache = | ||||
737 | dwarf2_frame_cache (next_frame, this_cache); | ||||
738 | |||||
739 | (*this_id) = frame_id_build (cache->cfa, frame_func_unwind (next_frame)); | ||||
740 | } | ||||
741 | |||||
742 | static void | ||||
743 | dwarf2_frame_prev_register (struct frame_info *next_frame, void **this_cache, | ||||
744 | int regnum, int *optimizedp, | ||||
745 | enum lval_type *lvalp, CORE_ADDR *addrp, | ||||
746 | int *realnump, void *valuep) | ||||
747 | { | ||||
748 | struct gdbarch *gdbarch = get_frame_arch (next_frame); | ||||
749 | struct dwarf2_frame_cache *cache = | ||||
750 | dwarf2_frame_cache (next_frame, this_cache); | ||||
751 | CORE_ADDR value; | ||||
752 | |||||
753 | switch (cache->reg[regnum].how) | ||||
754 | { | ||||
755 | case DWARF2_FRAME_REG_UNDEFINED: | ||||
756 | /* If CFI explicitly specified that the value isn't defined, | ||||
757 | mark it as optimized away; the value isn't available. */ | ||||
758 | *optimizedp = 1; | ||||
759 | *lvalp = not_lval; | ||||
760 | *addrp = 0; | ||||
761 | *realnump = -1; | ||||
762 | if (valuep) | ||||
763 | { | ||||
764 | /* In some cases, for example %eflags on the i386, we have | ||||
765 | to provide a sane value, even though this register wasn't | ||||
766 | saved. Assume we can get it from NEXT_FRAME. */ | ||||
767 | frame_unwind_register (next_frame, regnum, valuep); | ||||
768 | } | ||||
769 | break; | ||||
770 | |||||
771 | case DWARF2_FRAME_REG_SAVED_OFFSET: | ||||
772 | *optimizedp = 0; | ||||
773 | *lvalp = lval_memory; | ||||
774 | *addrp = cache->cfa + cache->reg[regnum].loc.offset; | ||||
775 | *realnump = -1; | ||||
776 | if (valuep) | ||||
777 | { | ||||
778 | /* Read the value in from memory. */ | ||||
779 | read_memory (*addrp, valuep, register_size (gdbarch, regnum)); | ||||
780 | } | ||||
781 | break; | ||||
782 | |||||
783 | case DWARF2_FRAME_REG_SAVED_REG: | ||||
784 | regnum = DWARF2_REG_TO_REGNUM (cache->reg[regnum].loc.reg)(gdbarch_dwarf2_reg_to_regnum (current_gdbarch, cache->reg [regnum].loc.reg)); | ||||
785 | frame_register_unwind (next_frame, regnum, | ||||
786 | optimizedp, lvalp, addrp, realnump, valuep); | ||||
787 | break; | ||||
788 | |||||
789 | case DWARF2_FRAME_REG_SAVED_EXP: | ||||
790 | *optimizedp = 0; | ||||
791 | *lvalp = lval_memory; | ||||
792 | *addrp = execute_stack_op (cache->reg[regnum].loc.exp, | ||||
793 | cache->reg[regnum].exp_len, | ||||
794 | next_frame, cache->cfa); | ||||
795 | *realnump = -1; | ||||
796 | if (valuep) | ||||
797 | { | ||||
798 | /* Read the value in from memory. */ | ||||
799 | read_memory (*addrp, valuep, register_size (gdbarch, regnum)); | ||||
800 | } | ||||
801 | break; | ||||
802 | |||||
803 | case DWARF2_FRAME_REG_SAVED_VAL_EXP: | ||||
804 | *optimizedp = 0; | ||||
805 | *lvalp = not_lval; | ||||
806 | *addrp = 0; | ||||
807 | value = execute_stack_op (cache->reg[regnum].loc.exp, | ||||
808 | cache->reg[regnum].exp_len, | ||||
809 | next_frame, cache->cfa); | ||||
810 | *realnump = -1; | ||||
811 | if (valuep) | ||||
812 | { | ||||
813 | /* Store the value. */ | ||||
814 | store_typed_address (valuep, builtin_type_void_data_ptr, value); | ||||
815 | } | ||||
816 | break; | ||||
817 | |||||
818 | case DWARF2_FRAME_REG_UNSPECIFIED: | ||||
819 | /* GCC, in its infinite wisdom decided to not provide unwind | ||||
820 | information for registers that are "same value". Since | ||||
821 | DWARF2 (3 draft 7) doesn't define such behavior, said | ||||
822 | registers are actually undefined (which is different to CFI | ||||
823 | "undefined"). Code above issues a complaint about this. | ||||
824 | Here just fudge the books, assume GCC, and that the value is | ||||
825 | more inner on the stack. */ | ||||
826 | frame_register_unwind (next_frame, regnum, | ||||
827 | optimizedp, lvalp, addrp, realnump, valuep); | ||||
828 | break; | ||||
829 | |||||
830 | case DWARF2_FRAME_REG_SAME_VALUE: | ||||
831 | frame_register_unwind (next_frame, regnum, | ||||
832 | optimizedp, lvalp, addrp, realnump, valuep); | ||||
833 | break; | ||||
834 | |||||
835 | case DWARF2_FRAME_REG_CFA: | ||||
836 | *optimizedp = 0; | ||||
837 | *lvalp = not_lval; | ||||
838 | *addrp = 0; | ||||
839 | *realnump = -1; | ||||
840 | if (valuep) | ||||
841 | { | ||||
842 | /* Store the value. */ | ||||
843 | store_typed_address (valuep, builtin_type_void_data_ptr, cache->cfa); | ||||
844 | } | ||||
845 | break; | ||||
846 | |||||
847 | default: | ||||
848 | internal_error (__FILE__"/usr/src/gnu/usr.bin/binutils/gdb/dwarf2-frame.c", __LINE__848, "Unknown register rule."); | ||||
849 | } | ||||
850 | } | ||||
851 | |||||
852 | static const struct frame_unwind dwarf2_frame_unwind = | ||||
853 | { | ||||
854 | NORMAL_FRAME, | ||||
855 | dwarf2_frame_this_id, | ||||
856 | dwarf2_frame_prev_register | ||||
857 | }; | ||||
858 | |||||
859 | const struct frame_unwind * | ||||
860 | dwarf2_frame_sniffer (struct frame_info *next_frame) | ||||
861 | { | ||||
862 | /* Grab an address that is guarenteed to reside somewhere within the | ||||
863 | function. frame_pc_unwind(), for a no-return next function, can | ||||
864 | end up returning something past the end of this function's body. */ | ||||
865 | CORE_ADDR block_addr = frame_unwind_address_in_block (next_frame); | ||||
866 | if (dwarf2_frame_find_fde (&block_addr)) | ||||
867 | return &dwarf2_frame_unwind; | ||||
868 | |||||
869 | return NULL((void*)0); | ||||
870 | } | ||||
871 | |||||
872 | |||||
873 | /* There is no explicitly defined relationship between the CFA and the | ||||
874 | location of frame's local variables and arguments/parameters. | ||||
875 | Therefore, frame base methods on this page should probably only be | ||||
876 | used as a last resort, just to avoid printing total garbage as a | ||||
877 | response to the "info frame" command. */ | ||||
878 | |||||
879 | static CORE_ADDR | ||||
880 | dwarf2_frame_base_address (struct frame_info *next_frame, void **this_cache) | ||||
881 | { | ||||
882 | struct dwarf2_frame_cache *cache = | ||||
883 | dwarf2_frame_cache (next_frame, this_cache); | ||||
884 | |||||
885 | return cache->cfa; | ||||
886 | } | ||||
887 | |||||
888 | static const struct frame_base dwarf2_frame_base = | ||||
889 | { | ||||
890 | &dwarf2_frame_unwind, | ||||
891 | dwarf2_frame_base_address, | ||||
892 | dwarf2_frame_base_address, | ||||
893 | dwarf2_frame_base_address | ||||
894 | }; | ||||
895 | |||||
896 | const struct frame_base * | ||||
897 | dwarf2_frame_base_sniffer (struct frame_info *next_frame) | ||||
898 | { | ||||
899 | CORE_ADDR pc = frame_pc_unwind (next_frame); | ||||
900 | if (dwarf2_frame_find_fde (&pc)) | ||||
901 | return &dwarf2_frame_base; | ||||
902 | |||||
903 | return NULL((void*)0); | ||||
904 | } | ||||
905 | |||||
906 | /* A minimal decoding of DWARF2 compilation units. We only decode | ||||
907 | what's needed to get to the call frame information. */ | ||||
908 | |||||
909 | struct comp_unit | ||||
910 | { | ||||
911 | /* Keep the bfd convenient. */ | ||||
912 | bfd *abfd; | ||||
913 | |||||
914 | struct objfile *objfile; | ||||
915 | |||||
916 | /* Linked list of CIEs for this object. */ | ||||
917 | struct dwarf2_cie *cie; | ||||
918 | |||||
919 | /* Pointer to the .debug_frame section loaded into memory. */ | ||||
920 | char *dwarf_frame_buffer; | ||||
921 | |||||
922 | /* Length of the loaded .debug_frame section. */ | ||||
923 | unsigned long dwarf_frame_size; | ||||
924 | |||||
925 | /* Pointer to the .debug_frame section. */ | ||||
926 | asection *dwarf_frame_section; | ||||
927 | |||||
928 | /* Base for DW_EH_PE_datarel encodings. */ | ||||
929 | bfd_vma dbase; | ||||
930 | |||||
931 | /* Base for DW_EH_PE_textrel encodings. */ | ||||
932 | bfd_vma tbase; | ||||
933 | }; | ||||
934 | |||||
935 | const struct objfile_data *dwarf2_frame_objfile_data; | ||||
936 | |||||
937 | static unsigned int | ||||
938 | read_1_byte (bfd *bfd, char *buf) | ||||
939 | { | ||||
940 | return bfd_get_8 (abfd, (bfd_byte *) buf)(*(unsigned char *) ((bfd_byte *) buf) & 0xff); | ||||
941 | } | ||||
942 | |||||
943 | static unsigned int | ||||
944 | read_4_bytes (bfd *abfd, char *buf) | ||||
945 | { | ||||
946 | return bfd_get_32 (abfd, (bfd_byte *) buf)((*((abfd)->xvec->bfd_getx32)) ((bfd_byte *) buf)); | ||||
947 | } | ||||
948 | |||||
949 | static ULONGESTunsigned long | ||||
950 | read_8_bytes (bfd *abfd, char *buf) | ||||
951 | { | ||||
952 | return bfd_get_64 (abfd, (bfd_byte *) buf)((*((abfd)->xvec->bfd_getx64)) ((bfd_byte *) buf)); | ||||
953 | } | ||||
954 | |||||
955 | static ULONGESTunsigned long | ||||
956 | read_unsigned_leb128 (bfd *abfd, char *buf, unsigned int *bytes_read_ptr) | ||||
957 | { | ||||
958 | ULONGESTunsigned long result; | ||||
959 | unsigned int num_read; | ||||
960 | int shift; | ||||
961 | unsigned char byte; | ||||
962 | |||||
963 | result = 0; | ||||
964 | shift = 0; | ||||
965 | num_read = 0; | ||||
966 | |||||
967 | do | ||||
968 | { | ||||
969 | byte = bfd_get_8 (abfd, (bfd_byte *) buf)(*(unsigned char *) ((bfd_byte *) buf) & 0xff); | ||||
970 | buf++; | ||||
971 | num_read++; | ||||
972 | result |= ((byte & 0x7f) << shift); | ||||
973 | shift += 7; | ||||
974 | } | ||||
975 | while (byte & 0x80); | ||||
976 | |||||
977 | *bytes_read_ptr = num_read; | ||||
978 | |||||
979 | return result; | ||||
980 | } | ||||
981 | |||||
982 | static LONGESTlong | ||||
983 | read_signed_leb128 (bfd *abfd, char *buf, unsigned int *bytes_read_ptr) | ||||
984 | { | ||||
985 | LONGESTlong result; | ||||
986 | int shift; | ||||
987 | unsigned int num_read; | ||||
988 | unsigned char byte; | ||||
989 | |||||
990 | result = 0; | ||||
991 | shift = 0; | ||||
992 | num_read = 0; | ||||
993 | |||||
994 | do | ||||
995 | { | ||||
996 | byte = bfd_get_8 (abfd, (bfd_byte *) buf)(*(unsigned char *) ((bfd_byte *) buf) & 0xff); | ||||
997 | buf++; | ||||
998 | num_read++; | ||||
999 | result |= ((byte & 0x7f) << shift); | ||||
1000 | shift += 7; | ||||
1001 | } | ||||
1002 | while (byte & 0x80); | ||||
1003 | |||||
1004 | if ((shift < 32) && (byte & 0x40)) | ||||
1005 | result |= -(1 << shift); | ||||
1006 | |||||
1007 | *bytes_read_ptr = num_read; | ||||
1008 | |||||
1009 | return result; | ||||
1010 | } | ||||
1011 | |||||
1012 | static ULONGESTunsigned long | ||||
1013 | read_initial_length (bfd *abfd, char *buf, unsigned int *bytes_read_ptr) | ||||
1014 | { | ||||
1015 | LONGESTlong result; | ||||
1016 | |||||
1017 | result = bfd_get_32 (abfd, (bfd_byte *) buf)((*((abfd)->xvec->bfd_getx32)) ((bfd_byte *) buf)); | ||||
1018 | if (result == 0xffffffff) | ||||
1019 | { | ||||
1020 | result = bfd_get_64 (abfd, (bfd_byte *) buf + 4)((*((abfd)->xvec->bfd_getx64)) ((bfd_byte *) buf + 4)); | ||||
1021 | *bytes_read_ptr = 12; | ||||
1022 | } | ||||
1023 | else | ||||
1024 | *bytes_read_ptr = 4; | ||||
1025 | |||||
1026 | return result; | ||||
1027 | } | ||||
1028 | |||||
1029 | |||||
1030 | /* Pointer encoding helper functions. */ | ||||
1031 | |||||
1032 | /* GCC supports exception handling based on DWARF2 CFI. However, for | ||||
1033 | technical reasons, it encodes addresses in its FDE's in a different | ||||
1034 | way. Several "pointer encodings" are supported. The encoding | ||||
1035 | that's used for a particular FDE is determined by the 'R' | ||||
1036 | augmentation in the associated CIE. The argument of this | ||||
1037 | augmentation is a single byte. | ||||
1038 | |||||
1039 | The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a | ||||
1040 | LEB128. This is encoded in bits 0, 1 and 2. Bit 3 encodes whether | ||||
1041 | the address is signed or unsigned. Bits 4, 5 and 6 encode how the | ||||
1042 | address should be interpreted (absolute, relative to the current | ||||
1043 | position in the FDE, ...). Bit 7, indicates that the address | ||||
1044 | should be dereferenced. */ | ||||
1045 | |||||
1046 | static unsigned char | ||||
1047 | encoding_for_size (unsigned int size) | ||||
1048 | { | ||||
1049 | switch (size) | ||||
1050 | { | ||||
1051 | case 2: | ||||
1052 | return DW_EH_PE_udata20x02; | ||||
1053 | case 4: | ||||
1054 | return DW_EH_PE_udata40x03; | ||||
1055 | case 8: | ||||
1056 | return DW_EH_PE_udata80x04; | ||||
1057 | default: | ||||
1058 | internal_error (__FILE__"/usr/src/gnu/usr.bin/binutils/gdb/dwarf2-frame.c", __LINE__1058, "Unsupported address size"); | ||||
1059 | } | ||||
1060 | } | ||||
1061 | |||||
1062 | static unsigned int | ||||
1063 | size_of_encoded_value (unsigned char encoding) | ||||
1064 | { | ||||
1065 | if (encoding == DW_EH_PE_omit0xff) | ||||
1066 | return 0; | ||||
1067 | |||||
1068 | switch (encoding & 0x07) | ||||
1069 | { | ||||
1070 | case DW_EH_PE_absptr0x00: | ||||
1071 | return TYPE_LENGTH (builtin_type_void_data_ptr)(builtin_type_void_data_ptr)->length; | ||||
1072 | case DW_EH_PE_udata20x02: | ||||
1073 | return 2; | ||||
1074 | case DW_EH_PE_udata40x03: | ||||
1075 | return 4; | ||||
1076 | case DW_EH_PE_udata80x04: | ||||
1077 | return 8; | ||||
1078 | default: | ||||
1079 | internal_error (__FILE__"/usr/src/gnu/usr.bin/binutils/gdb/dwarf2-frame.c", __LINE__1079, "Invalid or unsupported encoding"); | ||||
1080 | } | ||||
1081 | } | ||||
1082 | |||||
1083 | static CORE_ADDR | ||||
1084 | read_encoded_value (struct comp_unit *unit, unsigned char encoding, | ||||
1085 | char *buf, unsigned int *bytes_read_ptr) | ||||
1086 | { | ||||
1087 | int ptr_len = size_of_encoded_value (DW_EH_PE_absptr0x00); | ||||
1088 | ptrdiff_t offset; | ||||
1089 | CORE_ADDR base; | ||||
1090 | |||||
1091 | /* GCC currently doesn't generate DW_EH_PE_indirect encodings for | ||||
1092 | FDE's. */ | ||||
1093 | if (encoding & DW_EH_PE_indirect0x80) | ||||
1094 | internal_error (__FILE__"/usr/src/gnu/usr.bin/binutils/gdb/dwarf2-frame.c", __LINE__1094, | ||||
1095 | "Unsupported encoding: DW_EH_PE_indirect"); | ||||
1096 | |||||
1097 | *bytes_read_ptr = 0; | ||||
1098 | |||||
1099 | switch (encoding & 0x70) | ||||
1100 | { | ||||
1101 | case DW_EH_PE_absptr0x00: | ||||
1102 | base = 0; | ||||
1103 | break; | ||||
1104 | case DW_EH_PE_pcrel0x10: | ||||
1105 | base = bfd_get_section_vma (unit->bfd, unit->dwarf_frame_section)((unit->dwarf_frame_section)->vma + 0); | ||||
1106 | base += (buf - unit->dwarf_frame_buffer); | ||||
1107 | break; | ||||
1108 | case DW_EH_PE_datarel0x30: | ||||
1109 | base = unit->dbase; | ||||
1110 | break; | ||||
1111 | case DW_EH_PE_textrel0x20: | ||||
1112 | base = unit->tbase; | ||||
1113 | break; | ||||
1114 | case DW_EH_PE_funcrel0x40: | ||||
1115 | /* FIXME: kettenis/20040501: For now just pretend | ||||
1116 | DW_EH_PE_funcrel is equivalent to DW_EH_PE_absptr. For | ||||
1117 | reading the initial location of an FDE it should be treated | ||||
1118 | as such, and currently that's the only place where this code | ||||
1119 | is used. */ | ||||
1120 | base = 0; | ||||
1121 | break; | ||||
1122 | case DW_EH_PE_aligned0x50: | ||||
1123 | base = 0; | ||||
1124 | offset = buf - unit->dwarf_frame_buffer; | ||||
1125 | if ((offset % ptr_len) != 0) | ||||
1126 | { | ||||
1127 | *bytes_read_ptr = ptr_len - (offset % ptr_len); | ||||
1128 | buf += *bytes_read_ptr; | ||||
1129 | } | ||||
1130 | break; | ||||
1131 | default: | ||||
1132 | internal_error (__FILE__"/usr/src/gnu/usr.bin/binutils/gdb/dwarf2-frame.c", __LINE__1132, "Invalid or unsupported encoding"); | ||||
1133 | } | ||||
1134 | |||||
1135 | if ((encoding & 0x07) == 0x00) | ||||
1136 | encoding |= encoding_for_size (ptr_len); | ||||
1137 | |||||
1138 | switch (encoding & 0x0f) | ||||
1139 | { | ||||
1140 | case DW_EH_PE_udata20x02: | ||||
1141 | *bytes_read_ptr += 2; | ||||
1142 | return (base + bfd_get_16 (unit->abfd, (bfd_byte *) buf)((*((unit->abfd)->xvec->bfd_getx16)) ((bfd_byte *) buf ))); | ||||
1143 | case DW_EH_PE_udata40x03: | ||||
1144 | *bytes_read_ptr += 4; | ||||
1145 | return (base + bfd_get_32 (unit->abfd, (bfd_byte *) buf)((*((unit->abfd)->xvec->bfd_getx32)) ((bfd_byte *) buf ))); | ||||
1146 | case DW_EH_PE_udata80x04: | ||||
1147 | *bytes_read_ptr += 8; | ||||
1148 | return (base + bfd_get_64 (unit->abfd, (bfd_byte *) buf)((*((unit->abfd)->xvec->bfd_getx64)) ((bfd_byte *) buf ))); | ||||
1149 | case DW_EH_PE_sdata20x0A: | ||||
1150 | *bytes_read_ptr += 2; | ||||
1151 | return (base + bfd_get_signed_16 (unit->abfd, (bfd_byte *) buf)((*((unit->abfd)->xvec->bfd_getx_signed_16)) ((bfd_byte *) buf))); | ||||
1152 | case DW_EH_PE_sdata40x0B: | ||||
1153 | *bytes_read_ptr += 4; | ||||
1154 | return (base + bfd_get_signed_32 (unit->abfd, (bfd_byte *) buf)((*((unit->abfd)->xvec->bfd_getx_signed_32)) ((bfd_byte *) buf))); | ||||
1155 | case DW_EH_PE_sdata80x0C: | ||||
1156 | *bytes_read_ptr += 8; | ||||
1157 | return (base + bfd_get_signed_64 (unit->abfd, (bfd_byte *) buf)((*((unit->abfd)->xvec->bfd_getx_signed_64)) ((bfd_byte *) buf))); | ||||
1158 | default: | ||||
1159 | internal_error (__FILE__"/usr/src/gnu/usr.bin/binutils/gdb/dwarf2-frame.c", __LINE__1159, "Invalid or unsupported encoding"); | ||||
1160 | } | ||||
1161 | } | ||||
1162 | |||||
1163 | |||||
1164 | /* GCC uses a single CIE for all FDEs in a .debug_frame section. | ||||
1165 | That's why we use a simple linked list here. */ | ||||
1166 | |||||
1167 | static struct dwarf2_cie * | ||||
1168 | find_cie (struct comp_unit *unit, ULONGESTunsigned long cie_pointer) | ||||
1169 | { | ||||
1170 | struct dwarf2_cie *cie = unit->cie; | ||||
1171 | |||||
1172 | while (cie) | ||||
1173 | { | ||||
1174 | if (cie->cie_pointer == cie_pointer) | ||||
1175 | return cie; | ||||
1176 | |||||
1177 | cie = cie->next; | ||||
1178 | } | ||||
1179 | |||||
1180 | return NULL((void*)0); | ||||
1181 | } | ||||
1182 | |||||
1183 | static void | ||||
1184 | add_cie (struct comp_unit *unit, struct dwarf2_cie *cie) | ||||
1185 | { | ||||
1186 | cie->next = unit->cie; | ||||
1187 | unit->cie = cie; | ||||
1188 | } | ||||
1189 | |||||
1190 | /* Find the FDE for *PC. Return a pointer to the FDE, and store the | ||||
1191 | inital location associated with it into *PC. */ | ||||
1192 | |||||
1193 | static struct dwarf2_fde * | ||||
1194 | dwarf2_frame_find_fde (CORE_ADDR *pc) | ||||
1195 | { | ||||
1196 | struct objfile *objfile; | ||||
1197 | |||||
1198 | ALL_OBJFILES (objfile)for ((objfile) = object_files; (objfile) != ((void*)0); (objfile ) = (objfile)->next) | ||||
1199 | { | ||||
1200 | struct dwarf2_fde *fde; | ||||
1201 | CORE_ADDR offset; | ||||
1202 | |||||
1203 | fde = objfile_data (objfile, dwarf2_frame_objfile_data); | ||||
1204 | if (fde == NULL((void*)0)) | ||||
1205 | continue; | ||||
1206 | |||||
1207 | gdb_assert (objfile->section_offsets)((void) ((objfile->section_offsets) ? 0 : (internal_error ( "/usr/src/gnu/usr.bin/binutils/gdb/dwarf2-frame.c", 1207, "%s: Assertion `%s' failed." , __PRETTY_FUNCTION__, "objfile->section_offsets"), 0))); | ||||
1208 | offset = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile))((((objfile->sect_index_text == -1) ? (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/dwarf2-frame.c" , 1208, "sect_index_text not initialized"), -1) : objfile-> sect_index_text) == -1) ? (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/dwarf2-frame.c" , 1208, "Section index is uninitialized"), -1) : objfile-> section_offsets->offsets[((objfile->sect_index_text == - 1) ? (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/dwarf2-frame.c" , 1208, "sect_index_text not initialized"), -1) : objfile-> sect_index_text)]); | ||||
1209 | |||||
1210 | while (fde) | ||||
1211 | { | ||||
1212 | if (*pc >= fde->initial_location + offset | ||||
1213 | && *pc < fde->initial_location + offset + fde->address_range) | ||||
1214 | { | ||||
1215 | *pc = fde->initial_location + offset; | ||||
1216 | return fde; | ||||
1217 | } | ||||
1218 | |||||
1219 | fde = fde->next; | ||||
1220 | } | ||||
1221 | } | ||||
1222 | |||||
1223 | return NULL((void*)0); | ||||
1224 | } | ||||
1225 | |||||
1226 | static void | ||||
1227 | add_fde (struct comp_unit *unit, struct dwarf2_fde *fde) | ||||
1228 | { | ||||
1229 | fde->next = objfile_data (unit->objfile, dwarf2_frame_objfile_data); | ||||
1230 | set_objfile_data (unit->objfile, dwarf2_frame_objfile_data, fde); | ||||
1231 | } | ||||
1232 | |||||
1233 | #ifdef CC_HAS_LONG_LONG1 | ||||
1234 | #define DW64_CIE_ID0xffffffffffffffffULL 0xffffffffffffffffULL | ||||
1235 | #else | ||||
1236 | #define DW64_CIE_ID0xffffffffffffffffULL ~0 | ||||
1237 | #endif | ||||
1238 | |||||
1239 | static char *decode_frame_entry (struct comp_unit *unit, char *start, | ||||
1240 | int eh_frame_p); | ||||
1241 | |||||
1242 | /* Decode the next CIE or FDE. Return NULL if invalid input, otherwise | ||||
1243 | the next byte to be processed. */ | ||||
1244 | static char * | ||||
1245 | decode_frame_entry_1 (struct comp_unit *unit, char *start, int eh_frame_p) | ||||
1246 | { | ||||
1247 | char *buf; | ||||
1248 | LONGESTlong length; | ||||
1249 | unsigned int bytes_read; | ||||
1250 | int dwarf64_p; | ||||
1251 | ULONGESTunsigned long cie_id; | ||||
1252 | ULONGESTunsigned long cie_pointer; | ||||
1253 | char *end; | ||||
1254 | |||||
1255 | buf = start; | ||||
1256 | length = read_initial_length (unit->abfd, buf, &bytes_read); | ||||
1257 | buf += bytes_read; | ||||
1258 | end = buf + length; | ||||
1259 | |||||
1260 | /* Are we still within the section? */ | ||||
1261 | if (end > unit->dwarf_frame_buffer + unit->dwarf_frame_size) | ||||
1262 | return NULL((void*)0); | ||||
1263 | |||||
1264 | if (length == 0) | ||||
1265 | return end; | ||||
1266 | |||||
1267 | /* Distinguish between 32 and 64-bit encoded frame info. */ | ||||
1268 | dwarf64_p = (bytes_read == 12); | ||||
1269 | |||||
1270 | /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs. */ | ||||
1271 | if (eh_frame_p
| ||||
1272 | cie_id = 0; | ||||
1273 | else if (dwarf64_p
| ||||
1274 | cie_id = DW64_CIE_ID0xffffffffffffffffULL; | ||||
1275 | else | ||||
1276 | cie_id = DW_CIE_ID0xffffffff; | ||||
1277 | |||||
1278 | if (dwarf64_p
| ||||
1279 | { | ||||
1280 | cie_pointer = read_8_bytes (unit->abfd, buf); | ||||
1281 | buf += 8; | ||||
1282 | } | ||||
1283 | else | ||||
1284 | { | ||||
1285 | cie_pointer = read_4_bytes (unit->abfd, buf); | ||||
1286 | buf += 4; | ||||
1287 | } | ||||
1288 | |||||
1289 | if (cie_pointer == cie_id) | ||||
1290 | { | ||||
1291 | /* This is a CIE. */ | ||||
1292 | struct dwarf2_cie *cie; | ||||
1293 | char *augmentation; | ||||
1294 | unsigned int cie_version; | ||||
1295 | |||||
1296 | /* Record the offset into the .debug_frame section of this CIE. */ | ||||
1297 | cie_pointer = start - unit->dwarf_frame_buffer; | ||||
1298 | |||||
1299 | /* Check whether we've already read it. */ | ||||
1300 | if (find_cie (unit, cie_pointer)) | ||||
1301 | return end; | ||||
1302 | |||||
1303 | cie = (struct dwarf2_cie *) | ||||
1304 | obstack_alloc (&unit->objfile->objfile_obstack,__extension__ ({ struct obstack *__h = (&unit->objfile ->objfile_obstack); __extension__ ({ struct obstack *__o = (__h); int __len = ((sizeof (struct dwarf2_cie))); if (__o-> chunk_limit - __o->next_free < __len) _obstack_newchunk (__o, __len); ((__o)->next_free += (__len)); (void) 0; }) ; __extension__ ({ struct obstack *__o1 = (__h); void *value; value = (void *) __o1->object_base; if (__o1->next_free == value) __o1->maybe_empty_object = 1; __o1->next_free = (((((__o1->next_free) - (char *) 0)+__o1->alignment_mask ) & ~ (__o1->alignment_mask)) + (char *) 0); if (__o1-> next_free - (char *)__o1->chunk > __o1->chunk_limit - (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit ; __o1->object_base = __o1->next_free; value; }); }) | ||||
1305 | sizeof (struct dwarf2_cie))__extension__ ({ struct obstack *__h = (&unit->objfile ->objfile_obstack); __extension__ ({ struct obstack *__o = (__h); int __len = ((sizeof (struct dwarf2_cie))); if (__o-> chunk_limit - __o->next_free < __len) _obstack_newchunk (__o, __len); ((__o)->next_free += (__len)); (void) 0; }) ; __extension__ ({ struct obstack *__o1 = (__h); void *value; value = (void *) __o1->object_base; if (__o1->next_free == value) __o1->maybe_empty_object = 1; __o1->next_free = (((((__o1->next_free) - (char *) 0)+__o1->alignment_mask ) & ~ (__o1->alignment_mask)) + (char *) 0); if (__o1-> next_free - (char *)__o1->chunk > __o1->chunk_limit - (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit ; __o1->object_base = __o1->next_free; value; }); }); | ||||
1306 | cie->initial_instructions = NULL((void*)0); | ||||
| |||||
1307 | cie->cie_pointer = cie_pointer; | ||||
1308 | |||||
1309 | /* The encoding for FDE's in a normal .debug_frame section | ||||
1310 | depends on the target address size. */ | ||||
1311 | cie->encoding = DW_EH_PE_absptr0x00; | ||||
1312 | |||||
1313 | /* Check version number. */ | ||||
1314 | cie_version = read_1_byte (unit->abfd, buf); | ||||
1315 | if (cie_version != 1 && cie_version != 3) | ||||
1316 | return NULL((void*)0); | ||||
1317 | buf += 1; | ||||
1318 | |||||
1319 | /* Interpret the interesting bits of the augmentation. */ | ||||
1320 | augmentation = buf; | ||||
1321 | buf = augmentation + strlen (augmentation) + 1; | ||||
1322 | |||||
1323 | /* The GCC 2.x "eh" augmentation has a pointer immediately | ||||
1324 | following the augmentation string, so it must be handled | ||||
1325 | first. */ | ||||
1326 | if (augmentation[0] == 'e' && augmentation[1] == 'h') | ||||
1327 | { | ||||
1328 | /* Skip. */ | ||||
1329 | buf += TYPE_LENGTH (builtin_type_void_data_ptr)(builtin_type_void_data_ptr)->length; | ||||
1330 | augmentation += 2; | ||||
1331 | } | ||||
1332 | |||||
1333 | cie->code_alignment_factor = | ||||
1334 | read_unsigned_leb128 (unit->abfd, buf, &bytes_read); | ||||
1335 | buf += bytes_read; | ||||
1336 | |||||
1337 | cie->data_alignment_factor = | ||||
1338 | read_signed_leb128 (unit->abfd, buf, &bytes_read); | ||||
1339 | buf += bytes_read; | ||||
1340 | |||||
1341 | if (cie_version
| ||||
1342 | { | ||||
1343 | cie->return_address_register = read_1_byte (unit->abfd, buf); | ||||
1344 | bytes_read = 1; | ||||
1345 | } | ||||
1346 | else | ||||
1347 | cie->return_address_register = read_unsigned_leb128 (unit->abfd, buf, | ||||
1348 | &bytes_read); | ||||
1349 | buf += bytes_read; | ||||
1350 | |||||
1351 | cie->saw_z_augmentation = (*augmentation == 'z'); | ||||
1352 | if (cie->saw_z_augmentation
| ||||
1353 | { | ||||
1354 | ULONGESTunsigned long length; | ||||
1355 | |||||
1356 | length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read); | ||||
1357 | buf += bytes_read; | ||||
1358 | if (buf > end) | ||||
1359 | return NULL((void*)0); | ||||
1360 | cie->initial_instructions = buf + length; | ||||
1361 | augmentation++; | ||||
1362 | } | ||||
1363 | |||||
1364 | while (*augmentation) | ||||
1365 | { | ||||
1366 | /* "L" indicates a byte showing how the LSDA pointer is encoded. */ | ||||
1367 | if (*augmentation == 'L') | ||||
1368 | { | ||||
1369 | /* Skip. */ | ||||
1370 | buf++; | ||||
1371 | augmentation++; | ||||
1372 | } | ||||
1373 | |||||
1374 | /* "R" indicates a byte indicating how FDE addresses are encoded. */ | ||||
1375 | else if (*augmentation == 'R') | ||||
1376 | { | ||||
1377 | cie->encoding = *buf++; | ||||
1378 | augmentation++; | ||||
1379 | } | ||||
1380 | |||||
1381 | /* "P" indicates a personality routine in the CIE augmentation. */ | ||||
1382 | else if (*augmentation == 'P') | ||||
1383 | { | ||||
1384 | /* Skip. */ | ||||
1385 | buf += size_of_encoded_value (*buf++); | ||||
1386 | augmentation++; | ||||
1387 | } | ||||
1388 | |||||
1389 | /* Otherwise we have an unknown augmentation. | ||||
1390 | Bail out unless we saw a 'z' prefix. */ | ||||
1391 | else | ||||
1392 | { | ||||
1393 | if (cie->initial_instructions == NULL((void*)0)) | ||||
1394 | return end; | ||||
1395 | |||||
1396 | /* Skip unknown augmentations. */ | ||||
1397 | buf = cie->initial_instructions; | ||||
1398 | break; | ||||
1399 | } | ||||
1400 | } | ||||
1401 | |||||
1402 | cie->initial_instructions = buf; | ||||
1403 | cie->end = end; | ||||
1404 | |||||
1405 | add_cie (unit, cie); | ||||
1406 | } | ||||
1407 | else | ||||
1408 | { | ||||
1409 | /* This is a FDE. */ | ||||
1410 | struct dwarf2_fde *fde; | ||||
1411 | |||||
1412 | /* In an .eh_frame section, the CIE pointer is the delta between the | ||||
1413 | address within the FDE where the CIE pointer is stored and the | ||||
1414 | address of the CIE. Convert it to an offset into the .eh_frame | ||||
1415 | section. */ | ||||
1416 | if (eh_frame_p) | ||||
1417 | { | ||||
1418 | cie_pointer = buf - unit->dwarf_frame_buffer - cie_pointer; | ||||
1419 | cie_pointer -= (dwarf64_p ? 8 : 4); | ||||
1420 | } | ||||
1421 | |||||
1422 | /* In either case, validate the result is still within the section. */ | ||||
1423 | if (cie_pointer >= unit->dwarf_frame_size) | ||||
1424 | return NULL((void*)0); | ||||
1425 | |||||
1426 | fde = (struct dwarf2_fde *) | ||||
1427 | obstack_alloc (&unit->objfile->objfile_obstack,__extension__ ({ struct obstack *__h = (&unit->objfile ->objfile_obstack); __extension__ ({ struct obstack *__o = (__h); int __len = ((sizeof (struct dwarf2_fde))); if (__o-> chunk_limit - __o->next_free < __len) _obstack_newchunk (__o, __len); ((__o)->next_free += (__len)); (void) 0; }) ; __extension__ ({ struct obstack *__o1 = (__h); void *value; value = (void *) __o1->object_base; if (__o1->next_free == value) __o1->maybe_empty_object = 1; __o1->next_free = (((((__o1->next_free) - (char *) 0)+__o1->alignment_mask ) & ~ (__o1->alignment_mask)) + (char *) 0); if (__o1-> next_free - (char *)__o1->chunk > __o1->chunk_limit - (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit ; __o1->object_base = __o1->next_free; value; }); }) | ||||
1428 | sizeof (struct dwarf2_fde))__extension__ ({ struct obstack *__h = (&unit->objfile ->objfile_obstack); __extension__ ({ struct obstack *__o = (__h); int __len = ((sizeof (struct dwarf2_fde))); if (__o-> chunk_limit - __o->next_free < __len) _obstack_newchunk (__o, __len); ((__o)->next_free += (__len)); (void) 0; }) ; __extension__ ({ struct obstack *__o1 = (__h); void *value; value = (void *) __o1->object_base; if (__o1->next_free == value) __o1->maybe_empty_object = 1; __o1->next_free = (((((__o1->next_free) - (char *) 0)+__o1->alignment_mask ) & ~ (__o1->alignment_mask)) + (char *) 0); if (__o1-> next_free - (char *)__o1->chunk > __o1->chunk_limit - (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit ; __o1->object_base = __o1->next_free; value; }); }); | ||||
1429 | fde->cie = find_cie (unit, cie_pointer); | ||||
1430 | if (fde->cie == NULL((void*)0)) | ||||
1431 | { | ||||
1432 | decode_frame_entry (unit, unit->dwarf_frame_buffer + cie_pointer, | ||||
1433 | eh_frame_p); | ||||
1434 | fde->cie = find_cie (unit, cie_pointer); | ||||
1435 | } | ||||
1436 | |||||
1437 | gdb_assert (fde->cie != NULL)((void) ((fde->cie != ((void*)0)) ? 0 : (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/dwarf2-frame.c" , 1437, "%s: Assertion `%s' failed.", __PRETTY_FUNCTION__, "fde->cie != NULL" ), 0))); | ||||
1438 | |||||
1439 | fde->initial_location = | ||||
1440 | read_encoded_value (unit, fde->cie->encoding, buf, &bytes_read); | ||||
1441 | buf += bytes_read; | ||||
1442 | |||||
1443 | fde->address_range = | ||||
1444 | read_encoded_value (unit, fde->cie->encoding & 0x0f, buf, &bytes_read); | ||||
1445 | buf += bytes_read; | ||||
1446 | |||||
1447 | /* A 'z' augmentation in the CIE implies the presence of an | ||||
1448 | augmentation field in the FDE as well. The only thing known | ||||
1449 | to be in here at present is the LSDA entry for EH. So we | ||||
1450 | can skip the whole thing. */ | ||||
1451 | if (fde->cie->saw_z_augmentation) | ||||
1452 | { | ||||
1453 | ULONGESTunsigned long length; | ||||
1454 | |||||
1455 | length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read); | ||||
1456 | buf += bytes_read + length; | ||||
1457 | if (buf > end) | ||||
1458 | return NULL((void*)0); | ||||
1459 | } | ||||
1460 | |||||
1461 | fde->instructions = buf; | ||||
1462 | fde->end = end; | ||||
1463 | |||||
1464 | add_fde (unit, fde); | ||||
1465 | } | ||||
1466 | |||||
1467 | return end; | ||||
1468 | } | ||||
1469 | |||||
1470 | /* Read a CIE or FDE in BUF and decode it. */ | ||||
1471 | static char * | ||||
1472 | decode_frame_entry (struct comp_unit *unit, char *start, int eh_frame_p) | ||||
1473 | { | ||||
1474 | enum { NONE, ALIGN4, ALIGN8, FAIL } workaround = NONE; | ||||
1475 | char *ret; | ||||
1476 | const char *msg; | ||||
1477 | ptrdiff_t start_offset; | ||||
1478 | |||||
1479 | while (1) | ||||
1480 | { | ||||
1481 | ret = decode_frame_entry_1 (unit, start, eh_frame_p); | ||||
1482 | if (ret
| ||||
1483 | break; | ||||
1484 | |||||
1485 | /* We have corrupt input data of some form. */ | ||||
1486 | |||||
1487 | /* ??? Try, weakly, to work around compiler/assembler/linker bugs | ||||
1488 | and mismatches wrt padding and alignment of debug sections. */ | ||||
1489 | /* Note that there is no requirement in the standard for any | ||||
1490 | alignment at all in the frame unwind sections. Testing for | ||||
1491 | alignment before trying to interpret data would be incorrect. | ||||
1492 | |||||
1493 | However, GCC traditionally arranged for frame sections to be | ||||
1494 | sized such that the FDE length and CIE fields happen to be | ||||
1495 | aligned (in theory, for performance). This, unfortunately, | ||||
1496 | was done with .align directives, which had the side effect of | ||||
1497 | forcing the section to be aligned by the linker. | ||||
1498 | |||||
1499 | This becomes a problem when you have some other producer that | ||||
1500 | creates frame sections that are not as strictly aligned. That | ||||
1501 | produces a hole in the frame info that gets filled by the | ||||
1502 | linker with zeros. | ||||
1503 | |||||
1504 | The GCC behaviour is arguably a bug, but it's effectively now | ||||
1505 | part of the ABI, so we're now stuck with it, at least at the | ||||
1506 | object file level. A smart linker may decide, in the process | ||||
1507 | of compressing duplicate CIE information, that it can rewrite | ||||
1508 | the entire output section without this extra padding. */ | ||||
1509 | |||||
1510 | start_offset = start - unit->dwarf_frame_buffer; | ||||
1511 | if (workaround < ALIGN4 && (start_offset & 3) != 0) | ||||
1512 | { | ||||
1513 | start += 4 - (start_offset & 3); | ||||
1514 | workaround = ALIGN4; | ||||
1515 | continue; | ||||
1516 | } | ||||
1517 | if (workaround < ALIGN8 && (start_offset & 7) != 0) | ||||
1518 | { | ||||
1519 | start += 8 - (start_offset & 7); | ||||
1520 | workaround = ALIGN8; | ||||
1521 | continue; | ||||
1522 | } | ||||
1523 | |||||
1524 | /* Nothing left to try. Arrange to return as if we've consumed | ||||
1525 | the entire input section. Hopefully we'll get valid info from | ||||
1526 | the other of .debug_frame/.eh_frame. */ | ||||
1527 | workaround = FAIL; | ||||
1528 | ret = unit->dwarf_frame_buffer + unit->dwarf_frame_size; | ||||
1529 | break; | ||||
1530 | } | ||||
1531 | |||||
1532 | switch (workaround) | ||||
1533 | { | ||||
1534 | case NONE: | ||||
1535 | break; | ||||
1536 | |||||
1537 | case ALIGN4: | ||||
1538 | complaint (&symfile_complaints, | ||||
1539 | "Corrupt data in %s:%s; align 4 workaround apparently succeeded", | ||||
1540 | unit->dwarf_frame_section->owner->filename, | ||||
1541 | unit->dwarf_frame_section->name); | ||||
1542 | break; | ||||
1543 | |||||
1544 | case ALIGN8: | ||||
1545 | complaint (&symfile_complaints, | ||||
1546 | "Corrupt data in %s:%s; align 8 workaround apparently succeeded", | ||||
1547 | unit->dwarf_frame_section->owner->filename, | ||||
1548 | unit->dwarf_frame_section->name); | ||||
1549 | break; | ||||
1550 | |||||
1551 | default: | ||||
1552 | complaint (&symfile_complaints, | ||||
1553 | "Corrupt data in %s:%s", | ||||
1554 | unit->dwarf_frame_section->owner->filename, | ||||
1555 | unit->dwarf_frame_section->name); | ||||
1556 | break; | ||||
1557 | } | ||||
1558 | |||||
1559 | return ret; | ||||
1560 | } | ||||
1561 | |||||
1562 | |||||
1563 | /* FIXME: kettenis/20030504: This still needs to be integrated with | ||||
1564 | dwarf2read.c in a better way. */ | ||||
1565 | |||||
1566 | /* Imported from dwarf2read.c. */ | ||||
1567 | extern asection *dwarf_frame_section; | ||||
1568 | extern asection *dwarf_eh_frame_section; | ||||
1569 | |||||
1570 | /* Imported from dwarf2read.c. */ | ||||
1571 | extern char *dwarf2_read_section (struct objfile *objfile, asection *sectp); | ||||
1572 | |||||
1573 | void | ||||
1574 | dwarf2_build_frame_info (struct objfile *objfile) | ||||
1575 | { | ||||
1576 | struct comp_unit unit; | ||||
1577 | char *frame_ptr; | ||||
1578 | |||||
1579 | /* Build a minimal decoding of the DWARF2 compilation unit. */ | ||||
1580 | unit.abfd = objfile->obfd; | ||||
1581 | unit.objfile = objfile; | ||||
1582 | unit.dbase = 0; | ||||
1583 | unit.tbase = 0; | ||||
1584 | |||||
1585 | /* First add the information from the .eh_frame section. That way, | ||||
1586 | the FDEs from that section are searched last. */ | ||||
1587 | if (dwarf_eh_frame_section) | ||||
| |||||
1588 | { | ||||
1589 | asection *got, *txt; | ||||
1590 | |||||
1591 | unit.cie = NULL((void*)0); | ||||
1592 | unit.dwarf_frame_buffer = dwarf2_read_section (objfile, | ||||
1593 | dwarf_eh_frame_section); | ||||
1594 | |||||
1595 | unit.dwarf_frame_size = bfd_get_section_size (dwarf_eh_frame_section)((dwarf_eh_frame_section)->_raw_size); | ||||
1596 | unit.dwarf_frame_section = dwarf_eh_frame_section; | ||||
1597 | |||||
1598 | /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base | ||||
1599 | that is used for the i386/amd64 target, which currently is | ||||
1600 | the only target in GCC that supports/uses the | ||||
1601 | DW_EH_PE_datarel encoding. */ | ||||
1602 | got = bfd_get_section_by_name (unit.abfd, ".got"); | ||||
1603 | if (got) | ||||
1604 | unit.dbase = got->vma; | ||||
1605 | |||||
1606 | /* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64 | ||||
1607 | so far. */ | ||||
1608 | txt = bfd_get_section_by_name (unit.abfd, ".text"); | ||||
1609 | if (txt) | ||||
1610 | unit.tbase = txt->vma; | ||||
1611 | |||||
1612 | frame_ptr = unit.dwarf_frame_buffer; | ||||
1613 | while (frame_ptr < unit.dwarf_frame_buffer + unit.dwarf_frame_size) | ||||
1614 | frame_ptr = decode_frame_entry (&unit, frame_ptr, 1); | ||||
1615 | } | ||||
1616 | |||||
1617 | if (dwarf_frame_section) | ||||
1618 | { | ||||
1619 | unit.cie = NULL((void*)0); | ||||
1620 | unit.dwarf_frame_buffer = dwarf2_read_section (objfile, | ||||
1621 | dwarf_frame_section); | ||||
1622 | unit.dwarf_frame_size = bfd_get_section_size (dwarf_frame_section)((dwarf_frame_section)->_raw_size); | ||||
1623 | unit.dwarf_frame_section = dwarf_frame_section; | ||||
1624 | |||||
1625 | frame_ptr = unit.dwarf_frame_buffer; | ||||
1626 | while (frame_ptr < unit.dwarf_frame_buffer + unit.dwarf_frame_size) | ||||
1627 | frame_ptr = decode_frame_entry (&unit, frame_ptr, 0); | ||||
1628 | } | ||||
1629 | } | ||||
1630 | |||||
1631 | /* Provide a prototype to silence -Wmissing-prototypes. */ | ||||
1632 | void _initialize_dwarf2_frame (void); | ||||
1633 | |||||
1634 | void | ||||
1635 | _initialize_dwarf2_frame (void) | ||||
1636 | { | ||||
1637 | dwarf2_frame_data = gdbarch_data_register_pre_init (dwarf2_frame_init); | ||||
1638 | dwarf2_frame_objfile_data = register_objfile_data (); | ||||
1639 | } |