1
2 /*--------------------------------------------------------------------*/
3 /*--- Read DWARF1/2/3/4 debug info. readdwarf.c ---*/
4 /*--------------------------------------------------------------------*/
5
6 /*
7 This file is part of Valgrind, a dynamic binary instrumentation
8 framework.
9
10 Copyright (C) 2000-2011 Julian Seward
11 jseward@acm.org
12
13 This program is free software; you can redistribute it and/or
14 modify it under the terms of the GNU General Public License as
15 published by the Free Software Foundation; either version 2 of the
16 License, or (at your option) any later version.
17
18 This program is distributed in the hope that it will be useful, but
19 WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 General Public License for more details.
22
23 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software
25 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
26 02111-1307, USA.
27
28 The GNU General Public License is contained in the file COPYING.
29 */
30
31 #if defined(VGO_linux) || defined(VGO_darwin)
32
33 #include "pub_core_basics.h"
34 #include "pub_core_debuginfo.h"
35 #include "pub_core_libcbase.h"
36 #include "pub_core_libcassert.h"
37 #include "pub_core_libcprint.h"
38 #include "pub_core_options.h"
39 #include "pub_core_xarray.h"
40 #include "pub_core_tooliface.h" /* VG_(needs) */
41 #include "priv_misc.h" /* dinfo_zalloc/free/strdup */
42 #include "priv_d3basics.h"
43 #include "priv_tytypes.h"
44 #include "priv_storage.h"
45 #include "priv_readdwarf.h" /* self */
46
47
48 /*------------------------------------------------------------*/
49 /*--- ---*/
50 /*--- Read line number and CFI info from DWARF1, DWARF2 ---*/
51 /*--- and to some extent DWARF3 sections. ---*/
52 /*--- ---*/
53 /*------------------------------------------------------------*/
54
55 /*------------------------------------------------------------*/
56 /*--- Expanding arrays of words, for holding file name and ---*/
57 /*--- directory name arrays. ---*/
58 /*------------------------------------------------------------*/
59
60 typedef
61 struct {
62 Word* tab;
63 UInt tab_size;
64 UInt tab_used;
65 }
66 WordArray;
67
init_WordArray(WordArray * wa)68 static void init_WordArray ( WordArray* wa )
69 {
70 wa->tab = NULL;
71 wa->tab_size = 0;
72 wa->tab_used = 0;
73 }
74
free_WordArray(WordArray * wa)75 static void free_WordArray ( WordArray* wa )
76 {
77 if (wa->tab) {
78 vg_assert(wa->tab_size > 0);
79 ML_(dinfo_free)(wa->tab);
80 }
81 init_WordArray(wa);
82 }
83
addto_WordArray(WordArray * wa,Word w)84 static void addto_WordArray ( WordArray* wa, Word w )
85 {
86 UInt new_size, i;
87 Word* new_tab;
88
89 if (0) VG_(printf)("<<ADD %p (new sz = %d) >>\n",
90 (HChar*)w, wa->tab_used+1);
91
92 if (wa->tab_used < wa->tab_size) {
93 /* fine */
94 } else {
95 /* expand array */
96 if (0) VG_(printf)("EXPAND ARRAY from %d\n", wa->tab_size);
97 vg_assert(wa->tab_used == wa->tab_size);
98 vg_assert( (wa->tab_size == 0 && wa->tab == NULL)
99 || (wa->tab_size != 0 && wa->tab != NULL) );
100 new_size = wa->tab_size == 0 ? 8 : 2 * wa->tab_size;
101 new_tab = ML_(dinfo_zalloc)("di.aWA.1", new_size * sizeof(Word));
102 vg_assert(new_tab != NULL);
103 for (i = 0; i < wa->tab_used; i++)
104 new_tab[i] = wa->tab[i];
105 wa->tab_size = new_size;
106 if (wa->tab)
107 ML_(dinfo_free)(wa->tab);
108 wa->tab = new_tab;
109 }
110
111 vg_assert(wa->tab_used < wa->tab_size);
112 vg_assert(wa->tab_size > 0);
113 wa->tab[wa->tab_used] = w;
114 wa->tab_used++;
115 }
116
index_WordArray(Bool * inRange,WordArray * wa,Int i)117 static Word index_WordArray ( /*OUT*/Bool* inRange, WordArray* wa, Int i )
118 {
119 vg_assert(inRange);
120 if (i >= 0 && i < wa->tab_used) {
121 *inRange = True;
122 return wa->tab[i];
123 } else {
124 *inRange = False;
125 return 0;
126 }
127 }
128
129
130 /*------------------------------------------------------------*/
131 /*--- Read DWARF2 format line number info. ---*/
132 /*------------------------------------------------------------*/
133
134 /* Structure holding info extracted from the a .debug_line
135 section. */
136 typedef struct
137 {
138 ULong li_length;
139 UShort li_version;
140 ULong li_header_length;
141 UChar li_min_insn_length;
142 UChar li_max_ops_per_insn;
143 UChar li_default_is_stmt;
144 Int li_line_base;
145 UChar li_line_range;
146 UChar li_opcode_base;
147 }
148 DebugLineInfo;
149
150 /* Structure holding additional infos found from a .debug_info
151 * compilation unit block */
152 typedef struct
153 {
154 /* Feel free to add more members here if you need ! */
155 Char* compdir; /* Compilation directory - points to .debug_info */
156 Char* name; /* Main file name - points to .debug_info */
157 ULong stmt_list; /* Offset in .debug_line */
158 Bool dw64; /* 64-bit Dwarf? */
159 }
160 UnitInfo;
161
162 /* Line number opcodes. */
163 enum dwarf_line_number_ops
164 {
165 DW_LNS_extended_op = 0,
166 DW_LNS_copy = 1,
167 DW_LNS_advance_pc = 2,
168 DW_LNS_advance_line = 3,
169 DW_LNS_set_file = 4,
170 DW_LNS_set_column = 5,
171 DW_LNS_negate_stmt = 6,
172 DW_LNS_set_basic_block = 7,
173 DW_LNS_const_add_pc = 8,
174 DW_LNS_fixed_advance_pc = 9,
175 /* DWARF 3. */
176 DW_LNS_set_prologue_end = 10,
177 DW_LNS_set_epilogue_begin = 11,
178 DW_LNS_set_isa = 12
179 };
180
181 /* Line number extended opcodes. */
182 enum dwarf_line_number_x_ops
183 {
184 DW_LNE_end_sequence = 1,
185 DW_LNE_set_address = 2,
186 DW_LNE_define_file = 3,
187 DW_LNE_set_discriminator = 4
188 };
189
190 typedef struct
191 {
192 /* Information for the last statement boundary.
193 * Needed to calculate statement lengths. */
194 Addr last_address;
195 UInt last_file;
196 UInt last_line;
197
198 Addr address;
199 UInt file;
200 UInt line;
201 UInt column;
202 Int is_stmt;
203 Int basic_block;
204 UChar end_sequence;
205 } LineSMR;
206
207
208 /* FIXME: duplicated in readdwarf3.c */
209 static
read_leb128(UChar * data,Int * length_return,Int sign)210 ULong read_leb128 ( UChar* data, Int* length_return, Int sign )
211 {
212 ULong result = 0;
213 UInt num_read = 0;
214 Int shift = 0;
215 UChar byte;
216
217 vg_assert(sign == 0 || sign == 1);
218
219 do
220 {
221 byte = * data ++;
222 num_read ++;
223
224 result |= ((ULong)(byte & 0x7f)) << shift;
225
226 shift += 7;
227
228 }
229 while (byte & 0x80);
230
231 if (length_return != NULL)
232 * length_return = num_read;
233
234 if (sign && (shift < 64) && (byte & 0x40))
235 result |= -(1ULL << shift);
236
237 return result;
238 }
239
240 /* Small helper functions easier to use
241 * value is returned and the given pointer is
242 * moved past end of leb128 data */
243 /* FIXME: duplicated in readdwarf3.c */
read_leb128U(UChar ** data)244 static ULong read_leb128U( UChar **data )
245 {
246 Int len;
247 ULong val = read_leb128( *data, &len, 0 );
248 *data += len;
249 return val;
250 }
251
252 /* Same for signed data */
253 /* FIXME: duplicated in readdwarf3.c */
read_leb128S(UChar ** data)254 static Long read_leb128S( UChar **data )
255 {
256 Int len;
257 ULong val = read_leb128( *data, &len, 1 );
258 *data += len;
259 return (Long)val;
260 }
261
262 /* Read what the DWARF3 spec calls an "initial length field". This
263 uses up either 4 or 12 bytes of the input and produces a 32-bit or
264 64-bit number respectively.
265
266 Read 32-bit value from p. If it is 0xFFFFFFFF, instead read a
267 64-bit bit value from p+4. This is used in 64-bit dwarf to encode
268 some table lengths.
269
270 XXX this is a hack: the endianness of the initial length field is
271 specified by the DWARF we're reading. This happens to work only
272 because we don't do cross-arch jitting, hence this code runs on a
273 platform of the same endianness as the DWARF it is reading. Same
274 applies for initial lengths for CIE/FDEs and probably in zillions
275 of other places -- to be precise, exactly the places where
276 binutils/dwarf.c calls byte_get().
277 */
read_initial_length_field(UChar * p_img,Bool * is64)278 static ULong read_initial_length_field ( UChar* p_img, /*OUT*/Bool* is64 )
279 {
280 UInt w32 = ML_(read_UInt)(p_img);
281 if (w32 == 0xFFFFFFFF) {
282 *is64 = True;
283 return ML_(read_ULong)(p_img+4);
284 } else {
285 *is64 = False;
286 return (ULong)w32;
287 }
288 }
289
290
291 static LineSMR state_machine_regs;
292
293 static
reset_state_machine(Int is_stmt)294 void reset_state_machine ( Int is_stmt )
295 {
296 if (0) VG_(printf)("smr.a := %p (reset)\n", NULL );
297 state_machine_regs.last_address = 0;
298 state_machine_regs.last_file = 1;
299 state_machine_regs.last_line = 1;
300 state_machine_regs.address = 0;
301 state_machine_regs.file = 1;
302 state_machine_regs.line = 1;
303 state_machine_regs.column = 0;
304 state_machine_regs.is_stmt = is_stmt;
305 state_machine_regs.basic_block = 0;
306 state_machine_regs.end_sequence = 0;
307 }
308
309 /* Look up a directory name, or return NULL if unknown. */
310 static
lookupDir(Int filename_index,WordArray * fnidx2dir,WordArray * dirnames)311 Char* lookupDir ( Int filename_index,
312 WordArray* fnidx2dir,
313 WordArray* dirnames )
314 {
315 Bool inRange;
316 Word diridx, dirname;
317
318 diridx = index_WordArray( &inRange, fnidx2dir, filename_index );
319 if (!inRange) goto bad;
320
321 dirname = index_WordArray( &inRange, dirnames, (Int)diridx );
322 if (!inRange) goto bad;
323
324 return (Char*)dirname;
325 bad:
326 return NULL;
327 }
328
329 ////////////////////////////////////////////////////////////////////
330 ////////////////////////////////////////////////////////////////////
331
332 /* Handled an extended line op starting at 'data'. Returns the number
333 of bytes that 'data' should be advanced by. */
334 static
process_extended_line_op(struct _DebugInfo * di,WordArray * filenames,WordArray * dirnames,WordArray * fnidx2dir,UChar * data,Int is_stmt)335 Word process_extended_line_op( struct _DebugInfo* di,
336 WordArray* filenames,
337 WordArray* dirnames,
338 WordArray* fnidx2dir,
339 UChar* data, Int is_stmt)
340 {
341 UChar op_code;
342 Int bytes_read;
343 UInt len;
344 UChar* name;
345 Addr adr;
346
347 len = read_leb128 (data, & bytes_read, 0);
348 data += bytes_read;
349
350 if (len == 0) {
351 VG_(message)(Vg_UserMsg,
352 "Warning: DWARF2 reader: "
353 "Badly formed extended line op encountered\n");
354 return (Word)bytes_read;
355 }
356
357 len += bytes_read;
358 op_code = * data ++;
359
360 if (0) VG_(printf)("dwarf2: ext OPC: %d\n", op_code);
361
362 switch (op_code) {
363 case DW_LNE_end_sequence:
364 if (0) VG_(printf)("1001: si->o %#lx, smr.a %#lx\n",
365 di->text_debug_bias, state_machine_regs.address );
366 /* JRS: added for compliance with spec; is pointless due to
367 reset_state_machine below */
368 state_machine_regs.end_sequence = 1;
369
370 if (state_machine_regs.is_stmt) {
371 if (state_machine_regs.last_address) {
372 Bool inRange = False;
373 Char* filename
374 = (Char*)index_WordArray( &inRange, filenames,
375 state_machine_regs.last_file);
376 if (!inRange || !filename)
377 filename = "???";
378 ML_(addLineInfo) (
379 di,
380 filename,
381 lookupDir( state_machine_regs.last_file,
382 fnidx2dir, dirnames ),
383 di->text_debug_bias + state_machine_regs.last_address,
384 di->text_debug_bias + state_machine_regs.address,
385 state_machine_regs.last_line, 0
386 );
387 }
388 }
389 reset_state_machine (is_stmt);
390 if (di->ddump_line)
391 VG_(printf)(" Extended opcode %d: End of Sequence\n\n",
392 (Int)op_code);
393 break;
394
395 case DW_LNE_set_address:
396 adr = ML_(read_Addr)(data);
397 state_machine_regs.address = adr;
398 if (di->ddump_line)
399 VG_(printf)(" Extended opcode %d: set Address to 0x%lx\n",
400 (Int)op_code, (Addr)adr);
401 break;
402
403 case DW_LNE_define_file:
404 name = data;
405 addto_WordArray( filenames, (Word)ML_(addStr)(di,name,-1) );
406 data += VG_(strlen) ((char *) data) + 1;
407 read_leb128 (data, & bytes_read, 0);
408 data += bytes_read;
409 read_leb128 (data, & bytes_read, 0);
410 data += bytes_read;
411 read_leb128 (data, & bytes_read, 0);
412 if (di->ddump_line)
413 VG_(printf)(" DWARF2-line: set_address\n");
414 break;
415
416 case DW_LNE_set_discriminator:
417 read_leb128 (data, & bytes_read, 0);
418 data += bytes_read;
419 break;
420
421 default:
422 if (di->ddump_line)
423 VG_(printf)("process_extended_line_op:default\n");
424 break;
425 }
426
427 return (Word)len;
428 }
429
430 ////////////////////////////////////////////////////////////////////
431 ////////////////////////////////////////////////////////////////////
432
433 /* read a .debug_line section block for a compilation unit
434 *
435 * Input: - theBlock must point to the start of the block
436 * for the given compilation unit
437 * - ui contains additional info like the compilation dir
438 * for this unit
439 *
440 * Output: - si debug info structures get updated
441 */
442 static
read_dwarf2_lineblock(struct _DebugInfo * di,UnitInfo * ui,UChar * theBlock,Int noLargerThan)443 void read_dwarf2_lineblock ( struct _DebugInfo* di,
444 UnitInfo* ui,
445 UChar* theBlock, /* IMAGE */
446 Int noLargerThan )
447 {
448 Int i;
449 DebugLineInfo info;
450 UChar* standard_opcodes;
451 UChar* end_of_sequence;
452 Bool is64;
453 WordArray filenames;
454 WordArray dirnames;
455 WordArray fnidx2dir;
456
457 UChar* external = theBlock;
458 UChar* data = theBlock;
459
460 /* filenames is an array of file names harvested from the DWARF2
461 info. Entry [0] is NULL and is never referred to by the state
462 machine.
463
464 Similarly, dirnames is an array of directory names. Entry [0]
465 is also NULL and denotes "we don't know what the path is", since
466 that is different from "the path is the empty string". Unlike
467 the file name table, the state machine does refer to entry [0],
468 which basically means "." ("the current directory of the
469 compilation", whatever that means, according to the DWARF3
470 spec.)
471
472 fnidx2dir is an array of indexes into the dirnames table.
473 (confused yet?) filenames[] and fnidx2dir[] are indexed
474 together. That is, for some index i in the filename table, then
475
476 the filename is filenames[i]
477 the directory is dirnames[ fnidx2dir[i] ] */
478
479 /* Fails due to gcc padding ...
480 vg_assert(sizeof(DWARF2_External_LineInfo)
481 == sizeof(DWARF2_Internal_LineInfo));
482 */
483
484 init_WordArray(&filenames);
485 init_WordArray(&dirnames);
486 init_WordArray(&fnidx2dir);
487
488 /* DWARF2 starts numbering filename entries at 1, so we need to
489 add a dummy zeroth entry to the table. The zeroth dirnames
490 entry denotes 'current directory of compilation' so we might
491 as well make the fnidx2dir zeroth entry denote that.
492 */
493 addto_WordArray( &filenames, (Word)NULL );
494
495 if (ui->compdir)
496 addto_WordArray( &dirnames, (Word)ML_(addStr)(di, ui->compdir, -1) );
497 else
498 addto_WordArray( &dirnames, (Word)ML_(addStr)(di, ".", -1) );
499
500 addto_WordArray( &fnidx2dir, (Word)0 ); /* compilation dir */
501
502 info.li_length = read_initial_length_field( external, &is64 );
503 external += is64 ? 12 : 4;
504 if (di->ddump_line)
505 VG_(printf)(" Length: %llu\n",
506 info.li_length);
507
508 /* Check the length of the block. */
509 if (info.li_length > noLargerThan) {
510 ML_(symerr)(di, True,
511 "DWARF line info appears to be corrupt "
512 "- the section is too small");
513 goto out;
514 }
515
516 /* Check its version number. */
517 info.li_version = ML_(read_UShort)(external);
518 external += 2;
519 if (di->ddump_line)
520 VG_(printf)(" DWARF Version: %d\n",
521 (Int)info.li_version);
522
523 if (info.li_version != 2 && info.li_version != 3 && info.li_version != 4) {
524 ML_(symerr)(di, True,
525 "Only DWARF version 2, 3 and 4 line info "
526 "is currently supported.");
527 goto out;
528 }
529
530 info.li_header_length = ui->dw64 ? ML_(read_ULong)(external)
531 : (ULong)(ML_(read_UInt)(external));
532 external += ui->dw64 ? 8 : 4;
533 if (di->ddump_line)
534 VG_(printf)(" Prologue Length: %llu\n",
535 info.li_header_length);
536
537 info.li_min_insn_length = * ((UChar *)external);
538 external += 1;
539 if (di->ddump_line)
540 VG_(printf)(" Minimum Instruction Length: %d\n",
541 (Int)info.li_min_insn_length);
542
543 /* We only support machines with one opcode per instruction
544 for now. If we ever want to support VLIW machines there is
545 code to handle multiple opcodes per instruction in the
546 patch attached to BZ#233595.
547 */
548 if (info.li_version >= 4) {
549 info.li_max_ops_per_insn = * ((UChar *)external);
550 if (info.li_max_ops_per_insn != 1) {
551 ML_(symerr)(di, True,
552 "Invalid Maximum Ops Per Insn in line info.");
553 goto out;
554 }
555 external += 1;
556 if (di->ddump_line)
557 VG_(printf)(" Maximum Ops Per Insn: %d\n",
558 (Int)info.li_max_ops_per_insn);
559 } else {
560 info.li_max_ops_per_insn = 1;
561 }
562
563 info.li_default_is_stmt = * ((UChar *)external);
564 external += 1;
565 if (di->ddump_line)
566 VG_(printf)(" Initial value of 'is_stmt': %d\n",
567 (Int)info.li_default_is_stmt);
568
569 /* Josef Weidendorfer (20021021) writes:
570
571 It seems to me that the Intel Fortran compiler generates bad
572 DWARF2 line info code: It sets "is_stmt" of the state machine in
573 the the line info reader to be always false. Thus, there is
574 never a statement boundary generated and therefore never a
575 instruction range/line number mapping generated for valgrind.
576
577 Please have a look at the DWARF2 specification, Ch. 6.2
578 (x86.ddj.com/ftp/manuals/tools/dwarf.pdf). Perhaps I understand
579 this wrong, but I don't think so.
580
581 I just had a look at the GDB DWARF2 reader... They completely
582 ignore "is_stmt" when recording line info ;-) That's the reason
583 "objdump -S" works on files from the the intel fortran compiler.
584
585 Therefore: */
586 info.li_default_is_stmt = True;
587
588 /* JRS: changed (UInt*) to (UChar*) */
589 info.li_line_base = * ((UChar *)external);
590 info.li_line_base = (Int)(signed char)info.li_line_base;
591 external += 1;
592 if (di->ddump_line)
593 VG_(printf)(" Line Base: %d\n",
594 info.li_line_base);
595
596 info.li_line_range = * ((UChar *)external);
597 external += 1;
598 if (di->ddump_line)
599 VG_(printf)(" Line Range: %d\n",
600 (Int)info.li_line_range);
601
602 info.li_opcode_base = * ((UChar *)external);
603 external += 1;
604 if (di->ddump_line)
605 VG_(printf)(" Opcode Base: %d\n\n",
606 info.li_opcode_base);
607
608 if (0) VG_(printf)("dwarf2: line base: %d, range %d, opc base: %d\n",
609 (Int)info.li_line_base,
610 (Int)info.li_line_range,
611 (Int)info.li_opcode_base);
612
613 end_of_sequence = data + info.li_length
614 + (is64 ? 12 : 4);
615
616 reset_state_machine (info.li_default_is_stmt);
617
618 /* Read the contents of the Opcodes table. */
619 standard_opcodes = external;
620 if (di->ddump_line) {
621 VG_(printf)(" Opcodes:\n");
622 for (i = 1; i < (Int)info.li_opcode_base; i++) {
623 VG_(printf)(" Opcode %d has %d args\n",
624 i, (Int)standard_opcodes[i-1]);
625 }
626 VG_(printf)("\n");
627 }
628
629 /* Read the contents of the Directory table. */
630 data = standard_opcodes + info.li_opcode_base - 1;
631
632 if (di->ddump_line)
633 VG_(printf)(" The Directory Table%s\n",
634 *data == 0 ? " is empty." : ":" );
635
636 while (* data != 0) {
637
638 # define NBUF 4096
639 static Char buf[NBUF];
640
641 if (di->ddump_line)
642 VG_(printf)(" %s\n", data);
643
644 /* If data[0] is '/', then 'data' is an absolute path and we
645 don't mess with it. Otherwise, if we can, construct the
646 'path ui->compdir' ++ "/" ++ 'data'. */
647
648 if (*data != '/'
649 /* not an absolute path */
650 && ui->compdir != NULL
651 /* actually got something sensible for compdir */
652 && VG_(strlen)(ui->compdir) + VG_(strlen)(data) + 5/*paranoia*/ < NBUF
653 /* it's short enough to concatenate */)
654 {
655 buf[0] = 0;
656 VG_(strcat)(buf, ui->compdir);
657 VG_(strcat)(buf, "/");
658 VG_(strcat)(buf, data);
659 vg_assert(VG_(strlen)(buf) < NBUF);
660 addto_WordArray( &dirnames, (Word)ML_(addStr)(di,buf,-1) );
661 if (0) VG_(printf)("rel path %s\n", buf);
662 } else {
663 /* just use 'data'. */
664 addto_WordArray( &dirnames, (Word)ML_(addStr)(di,data,-1) );
665 if (0) VG_(printf)("abs path %s\n", data);
666 }
667
668 data += VG_(strlen)(data) + 1;
669
670 # undef NBUF
671 }
672
673 if (di->ddump_line)
674 VG_(printf)("\n");
675
676 if (*data != 0) {
677 ML_(symerr)(di, True,
678 "can't find NUL at end of DWARF2 directory table");
679 goto out;
680 }
681 data ++;
682
683 /* Read the contents of the File Name table. This produces a bunch
684 of file names, and for each, an index to the corresponding
685 directory name entry. */
686 if (di->ddump_line) {
687 VG_(printf)(" The File Name Table:\n");
688 VG_(printf)(" Entry Dir Time Size Name\n");
689 }
690
691 i = 1;
692 while (* data != 0) {
693 UChar* name;
694 Int bytes_read, diridx;
695 Int uu_time, uu_size; /* unused, and a guess */
696 name = data;
697 data += VG_(strlen) ((Char *) data) + 1;
698
699 diridx = read_leb128 (data, & bytes_read, 0);
700 data += bytes_read;
701 uu_time = read_leb128 (data, & bytes_read, 0);
702 data += bytes_read;
703 uu_size = read_leb128 (data, & bytes_read, 0);
704 data += bytes_read;
705
706 addto_WordArray( &filenames, (Word)ML_(addStr)(di,name,-1) );
707 addto_WordArray( &fnidx2dir, (Word)diridx );
708 if (0) VG_(printf)("file %s diridx %d\n", name, diridx );
709 if (di->ddump_line)
710 VG_(printf)(" %d\t%d\t%d\t%d\t%s\n",
711 i, diridx, uu_time, uu_size, name);
712 i++;
713 }
714
715 if (di->ddump_line)
716 VG_(printf)("\n");
717
718 if (*data != 0) {
719 ML_(symerr)(di, True,
720 "can't find NUL at end of DWARF2 file name table");
721 goto out;
722 }
723 data ++;
724
725 if (di->ddump_line)
726 VG_(printf)(" Line Number Statements:\n");
727
728 /* Now display the statements. */
729
730 while (data < end_of_sequence) {
731
732 UChar op_code;
733 Int adv;
734 Int bytes_read;
735
736 op_code = * data ++;
737
738 if (0) VG_(printf)("dwarf2: OPC: %d\n", op_code);
739
740 if (op_code >= info.li_opcode_base) {
741
742 Int advAddr;
743 op_code -= info.li_opcode_base;
744 adv = (op_code / info.li_line_range)
745 * info.li_min_insn_length;
746 advAddr = adv;
747 state_machine_regs.address += adv;
748
749 if (0) VG_(printf)("smr.a += %#x\n", adv );
750 adv = (op_code % info.li_line_range) + info.li_line_base;
751 if (0) VG_(printf)("1002: di->o %#lx, smr.a %#lx\n",
752 di->text_debug_bias, state_machine_regs.address );
753 state_machine_regs.line += adv;
754
755 if (di->ddump_line)
756 VG_(printf)(" Special opcode %d: advance Address by %d "
757 "to 0x%lx and Line by %d to %d\n",
758 (Int)op_code, advAddr, state_machine_regs.address,
759 (Int)adv, (Int)state_machine_regs.line );
760
761 if (state_machine_regs.is_stmt) {
762 /* only add a statement if there was a previous boundary */
763 if (state_machine_regs.last_address) {
764 Bool inRange = False;
765 Char* filename
766 = (Char*)index_WordArray( &inRange, &filenames,
767 state_machine_regs.last_file);
768 if (!inRange || !filename)
769 filename = "???";
770 ML_(addLineInfo)(
771 di,
772 filename,
773 lookupDir( state_machine_regs.last_file,
774 &fnidx2dir, &dirnames ),
775 di->text_debug_bias + state_machine_regs.last_address,
776 di->text_debug_bias + state_machine_regs.address,
777 state_machine_regs.last_line,
778 0
779 );
780 }
781 state_machine_regs.last_address = state_machine_regs.address;
782 state_machine_regs.last_file = state_machine_regs.file;
783 state_machine_regs.last_line = state_machine_regs.line;
784 }
785
786 }
787
788 else { /* ! (op_code >= info.li_opcode_base) */
789
790 switch (op_code) {
791 case DW_LNS_extended_op:
792 data += process_extended_line_op (
793 di, &filenames, &dirnames, &fnidx2dir,
794 data, info.li_default_is_stmt);
795 break;
796
797 case DW_LNS_copy:
798 if (0) VG_(printf)("1002: di->o %#lx, smr.a %#lx\n",
799 di->text_debug_bias, state_machine_regs.address );
800 if (state_machine_regs.is_stmt) {
801 /* only add a statement if there was a previous boundary */
802 if (state_machine_regs.last_address) {
803 Bool inRange = False;
804 Char* filename
805 = (Char*)index_WordArray( &inRange, &filenames,
806 state_machine_regs.last_file );
807 if (!inRange || !filename)
808 filename = "???";
809 ML_(addLineInfo)(
810 di,
811 filename,
812 lookupDir( state_machine_regs.last_file,
813 &fnidx2dir, &dirnames ),
814 di->text_debug_bias + state_machine_regs.last_address,
815 di->text_debug_bias + state_machine_regs.address,
816 state_machine_regs.last_line,
817 0
818 );
819 }
820 state_machine_regs.last_address = state_machine_regs.address;
821 state_machine_regs.last_file = state_machine_regs.file;
822 state_machine_regs.last_line = state_machine_regs.line;
823 }
824 state_machine_regs.basic_block = 0; /* JRS added */
825 if (di->ddump_line)
826 VG_(printf)(" Copy\n");
827 break;
828
829 case DW_LNS_advance_pc:
830 adv = info.li_min_insn_length
831 * read_leb128 (data, & bytes_read, 0);
832 data += bytes_read;
833 state_machine_regs.address += adv;
834 if (0) VG_(printf)("smr.a += %#x\n", adv );
835 if (di->ddump_line)
836 VG_(printf)(" Advance PC by %d to 0x%lx\n",
837 (Int)adv, state_machine_regs.address);
838 break;
839
840 case DW_LNS_advance_line:
841 adv = read_leb128 (data, & bytes_read, 1);
842 data += bytes_read;
843 state_machine_regs.line += adv;
844 if (di->ddump_line)
845 VG_(printf)(" Advance Line by %d to %d\n",
846 (Int)adv, (Int)state_machine_regs.line);
847 break;
848
849 case DW_LNS_set_file:
850 adv = read_leb128 (data, & bytes_read, 0);
851 data += bytes_read;
852 state_machine_regs.file = adv;
853 if (di->ddump_line)
854 VG_(printf)(" Set File Name to entry %d in the File Name Table\n",
855 (Int)adv);
856 break;
857
858 case DW_LNS_set_column:
859 adv = read_leb128 (data, & bytes_read, 0);
860 data += bytes_read;
861 state_machine_regs.column = adv;
862 if (di->ddump_line)
863 VG_(printf)(" Set column to %d\n", (Int)adv);
864 break;
865
866 case DW_LNS_negate_stmt:
867 adv = state_machine_regs.is_stmt;
868 adv = ! adv;
869 state_machine_regs.is_stmt = adv;
870 if (di->ddump_line)
871 VG_(printf)(" DWARF2-line: negate_stmt\n");
872 break;
873
874 case DW_LNS_set_basic_block:
875 state_machine_regs.basic_block = 1;
876 if (di->ddump_line)
877 VG_(printf)(" DWARF2-line: set_basic_block\n");
878 break;
879
880 case DW_LNS_const_add_pc:
881 adv = (((255 - info.li_opcode_base) / info.li_line_range)
882 * info.li_min_insn_length);
883 state_machine_regs.address += adv;
884 if (0) VG_(printf)("smr.a += %#x\n", adv );
885 if (di->ddump_line)
886 VG_(printf)(" Advance PC by constant %d to 0x%lx\n",
887 (Int)adv, (Addr)state_machine_regs.address);
888 break;
889
890 case DW_LNS_fixed_advance_pc:
891 /* XXX: Need something to get 2 bytes */
892 adv = ML_(read_UShort)(data);
893 data += 2;
894 state_machine_regs.address += adv;
895 if (0) VG_(printf)("smr.a += %#x\n", adv );
896 if (di->ddump_line)
897 VG_(printf)(" DWARF2-line: fixed_advance_pc\n");
898 break;
899
900 case DW_LNS_set_prologue_end:
901 if (di->ddump_line)
902 VG_(printf)(" DWARF2-line: set_prologue_end\n");
903 break;
904
905 case DW_LNS_set_epilogue_begin:
906 if (di->ddump_line)
907 VG_(printf)(" DWARF2-line: set_epilogue_begin\n");
908 break;
909
910 case DW_LNS_set_isa:
911 /*adv =*/ read_leb128 (data, & bytes_read, 0);
912 data += bytes_read;
913 if (di->ddump_line)
914 VG_(printf)(" DWARF2-line: set_isa\n");
915 break;
916
917 default: {
918 Int j;
919 for (j = standard_opcodes[op_code - 1]; j > 0 ; --j) {
920 read_leb128 (data, &bytes_read, 0);
921 data += bytes_read;
922 }
923 if (di->ddump_line)
924 VG_(printf)(" Unknown opcode %d\n", (Int)op_code);
925 break;
926 }
927 } /* switch (op_code) */
928
929 } /* if (op_code >= info.li_opcode_base) */
930
931 } /* while (data < end_of_sequence) */
932
933 if (di->ddump_line)
934 VG_(printf)("\n");
935
936 out:
937 free_WordArray(&filenames);
938 free_WordArray(&dirnames);
939 free_WordArray(&fnidx2dir);
940 }
941
942 ////////////////////////////////////////////////////////////////////
943 ////////////////////////////////////////////////////////////////////
944
945 /* Return abbrev for given code
946 * Returned pointer points to the tag
947 * */
lookup_abbrev(UChar * p,UInt acode)948 static UChar* lookup_abbrev( UChar* p, UInt acode )
949 {
950 UInt code;
951 UInt name;
952 for( ; ; ) {
953 code = read_leb128U( &p );
954 if ( code == acode )
955 return p;
956 read_leb128U( &p ); /* skip tag */
957 p++; /* skip has_children flag */
958 do {
959 name = read_leb128U( &p ); /* name */
960 read_leb128U( &p ); /* form */
961 }
962 while( name != 0 ); /* until name == form == 0 */
963 }
964 return NULL;
965 }
966
967 /* Read general information for a particular compile unit block in
968 * the .debug_info section.
969 *
970 * Input: - unitblock is the start of a compilation
971 * unit block in .debuginfo section
972 * - debugabbrev is start of .debug_abbrev section
973 * - debugstr is start of .debug_str section
974 *
975 * Output: Fill members of ui pertaining to the compilation unit:
976 * - ui->name is the name of the compilation unit
977 * - ui->compdir is the compilation unit directory
978 * - ui->stmt_list is the offset in .debug_line section
979 * for the dbginfos of this compilation unit
980 *
981 * Note : the output strings are not allocated and point
982 * directly to the memory-mapped section.
983 */
984 static
read_unitinfo_dwarf2(UnitInfo * ui,UChar * unitblock_img,UChar * debugabbrev_img,UChar * debugstr_img)985 void read_unitinfo_dwarf2( /*OUT*/UnitInfo* ui,
986 UChar* unitblock_img,
987 UChar* debugabbrev_img,
988 UChar* debugstr_img )
989 {
990 UInt acode, abcode;
991 ULong atoffs, blklen;
992 Int level;
993 /* UShort ver; */
994
995 UChar addr_size;
996 UChar* p = unitblock_img;
997 UChar* end_img;
998 UChar* abbrev_img;
999
1000 VG_(memset)( ui, 0, sizeof( UnitInfo ) );
1001 ui->stmt_list = -1LL;
1002
1003 /* Read the compilation unit header in .debug_info section - See p 70 */
1004
1005 /* This block length */
1006 blklen = read_initial_length_field( p, &ui->dw64 );
1007 p += ui->dw64 ? 12 : 4;
1008
1009 /* version should be 2, 3 or 4 */
1010 /* ver = ML_(read_UShort)(p); */
1011 p += 2;
1012
1013 /* get offset in abbrev */
1014 atoffs = ui->dw64 ? ML_(read_ULong)(p) : (ULong)(ML_(read_UInt)(p));
1015 p += ui->dw64 ? 8 : 4;
1016
1017 /* Address size */
1018 addr_size = *p;
1019 p += 1;
1020
1021 end_img = unitblock_img
1022 + blklen + (ui->dw64 ? 12 : 4); /* End of this block */
1023 level = 0; /* Level in the abbrev tree */
1024 abbrev_img = debugabbrev_img
1025 + atoffs; /* Abbreviation data for this block */
1026
1027 /* Read the compilation unit entries */
1028 while ( p < end_img ) {
1029 Bool has_child;
1030 UInt tag;
1031
1032 acode = read_leb128U( &p ); /* abbreviation code */
1033 if ( acode == 0 ) {
1034 /* NULL entry used for padding - or last child for a sequence
1035 - see para 7.5.3 */
1036 level--;
1037 continue;
1038 }
1039
1040 /* Read abbreviation header */
1041 abcode = read_leb128U( &abbrev_img ); /* abbreviation code */
1042 if ( acode != abcode ) {
1043 /* We are in in children list, and must rewind to a
1044 * previously declared abbrev code. This code works but is
1045 * not triggered since we shortcut the parsing once we have
1046 * read the compile_unit block. This should only occur when
1047 * level > 0 */
1048 abbrev_img = lookup_abbrev( debugabbrev_img + atoffs, acode );
1049 }
1050
1051 tag = read_leb128U( &abbrev_img );
1052 has_child = *(abbrev_img++) == 1; /* DW_CHILDREN_yes */
1053
1054 if ( has_child )
1055 level++;
1056
1057 /* And loop on entries */
1058 for ( ; ; ) {
1059 /* Read entry definition */
1060 UInt name, form;
1061 ULong cval = -1LL; /* Constant value read */
1062 Char *sval = NULL; /* String value read */
1063 name = read_leb128U( &abbrev_img );
1064 form = read_leb128U( &abbrev_img );
1065 if ( name == 0 )
1066 break;
1067
1068 /* Read data */
1069 /* Attributes encoding explained p 71 */
1070 if ( form == 0x16 /* FORM_indirect */ )
1071 form = read_leb128U( &p );
1072 /* Decode form. For most kinds, Just skip the amount of data since
1073 we don't use it for now */
1074 /* JRS 9 Feb 06: This now handles 64-bit DWARF too. In
1075 64-bit DWARF, lineptr (and loclistptr,macptr,rangelistptr
1076 classes) use FORM_data8, not FORM_data4. Also,
1077 FORM_ref_addr and FORM_strp are 64-bit values, not 32-bit
1078 values. */
1079 /* TJH 27 Apr 10: in DWARF 4 lineptr (and loclistptr,macptr,
1080 rangelistptr classes) use FORM_sec_offset which is 64 bits
1081 in 64 bit DWARF and 32 bits in 32 bit DWARF. */
1082 /* JRS 20 Apr 11: LLVM-2.9 encodes DW_AT_stmt_list using
1083 FORM_addr rather than the FORM_data4 that GCC uses. Hence
1084 handle FORM_addr too. */
1085 switch( form ) {
1086 /* Those cases extract the data properly */
1087 case 0x05: /* FORM_data2 */ cval = ML_(read_UShort)(p); p +=2; break;
1088 case 0x06: /* FORM_data4 */ cval = ML_(read_UInt)(p); p +=4; break;
1089 case 0x0e: /* FORM_strp */ /* pointer in .debug_str */
1090 /* 2006-01-01: only generate a value if
1091 debugstr is non-NULL (which means that a
1092 debug_str section was found) */
1093 if (debugstr_img && !ui->dw64)
1094 sval = debugstr_img + ML_(read_UInt)(p);
1095 if (debugstr_img && ui->dw64)
1096 sval = debugstr_img + ML_(read_ULong)(p);
1097 p += ui->dw64 ? 8 : 4;
1098 break;
1099 case 0x08: /* FORM_string */ sval = (Char*)p;
1100 p += VG_(strlen)((Char*)p) + 1; break;
1101 case 0x0b: /* FORM_data1 */ cval = *p; p++; break;
1102 case 0x17: /* FORM_sec_offset */if (ui->dw64) {
1103 cval = ML_(read_ULong)(p); p += 8;
1104 } else {
1105 cval = ML_(read_UInt)(p); p += 4;
1106 }; break;
1107
1108 case 0x07: /* FORM_data8 */ if (ui->dw64) cval = ML_(read_ULong)(p);
1109 p += 8; break;
1110 /* perhaps should assign
1111 unconditionally to cval? */
1112
1113 /* TODO : Following ones just skip data - implement if you need */
1114 case 0x01: /* FORM_addr */ p += addr_size; break;
1115 case 0x03: /* FORM_block2 */ p += ML_(read_UShort)(p) + 2; break;
1116 case 0x04: /* FORM_block4 */ p += ML_(read_UInt)(p) + 4; break;
1117 case 0x09: /* FORM_block */ p += read_leb128U( &p ); break;
1118 case 0x0a: /* FORM_block1 */ p += *p + 1; break;
1119 case 0x0c: /* FORM_flag */ p++; break;
1120 case 0x0d: /* FORM_sdata */ read_leb128S( &p ); break;
1121 case 0x0f: /* FORM_udata */ read_leb128U( &p ); break;
1122 case 0x10: /* FORM_ref_addr */ p += ui->dw64 ? 8 : 4; break;
1123 case 0x11: /* FORM_ref1 */ p++; break;
1124 case 0x12: /* FORM_ref2 */ p += 2; break;
1125 case 0x13: /* FORM_ref4 */ p += 4; break;
1126 case 0x14: /* FORM_ref8 */ p += 8; break;
1127 case 0x15: /* FORM_ref_udata */ read_leb128U( &p ); break;
1128 case 0x18: /* FORM_exprloc */ p += read_leb128U( &p ); break;
1129 case 0x19: /* FORM_flag_present */break;
1130 case 0x20: /* FORM_ref_sig8 */ p += 8; break;
1131
1132 default:
1133 VG_(printf)( "### unhandled dwarf2 abbrev form code 0x%x\n", form );
1134 break;
1135 }
1136
1137 /* Now store the members we need in the UnitInfo structure */
1138 if ( tag == 0x0011 /*TAG_compile_unit*/ ) {
1139 if ( name == 0x03 ) ui->name = sval; /* DW_AT_name */
1140 else if ( name == 0x1b ) ui->compdir = sval; /* DW_AT_compdir */
1141 else if ( name == 0x10 ) ui->stmt_list = cval; /* DW_AT_stmt_list */
1142 }
1143 }
1144 /* Shortcut the parsing once we have read the compile_unit block
1145 * That's enough info for us, and we are not gdb ! */
1146 if ( tag == 0x0011 /*TAG_compile_unit*/ )
1147 break;
1148 } /* Loop on each sub block */
1149
1150 /* This test would be valid if we were not shortcutting the parsing
1151 if (level != 0)
1152 VG_(printf)( "#### Exiting debuginfo block at level %d !!!\n", level );
1153 */
1154 }
1155
1156
1157 ////////////////////////////////////////////////////////////////////
1158 ////////////////////////////////////////////////////////////////////
1159
1160 /* Collect the debug info from DWARF3 debugging sections
1161 * of a given module.
1162 *
1163 * Inputs: given .debug_xxx sections
1164 * Output: update di to contain all the DWARF3 debug infos
1165 */
ML_(read_debuginfo_dwarf3)1166 void ML_(read_debuginfo_dwarf3)
1167 ( struct _DebugInfo* di,
1168 UChar* debug_info_img, Word debug_info_sz, /* .debug_info */
1169 UChar* debug_abbv_img, Word debug_abbv_sz, /* .debug_abbrev */
1170 UChar* debug_line_img, Word debug_line_sz, /* .debug_line */
1171 UChar* debug_str_img, Word debug_str_sz ) /* .debug_str */
1172 {
1173 UnitInfo ui;
1174 UShort ver;
1175 UChar* block_img;
1176 UChar* end1_img;
1177 ULong blklen;
1178 Bool blklen_is_64;
1179 Int blklen_len;
1180
1181 end1_img = debug_info_img + debug_info_sz;
1182 blklen_len = 0;
1183
1184 /* Make sure we at least have a header for the first block */
1185 if (debug_info_sz < 4) {
1186 ML_(symerr)( di, True,
1187 "Last block truncated in .debug_info; ignoring" );
1188 return;
1189 }
1190
1191 /* Iterate on all the blocks we find in .debug_info */
1192 for ( block_img = debug_info_img;
1193 block_img < end1_img - 4;
1194 block_img += blklen + blklen_len ) {
1195
1196 /* Read the compilation unit header in .debug_info section - See
1197 p 70 */
1198 /* This block length */
1199 blklen = read_initial_length_field( block_img, &blklen_is_64 );
1200 blklen_len = blklen_is_64 ? 12 : 4;
1201 if ( block_img + blklen + blklen_len > end1_img ) {
1202 ML_(symerr)( di, True,
1203 "Last block truncated in .debug_info; ignoring" );
1204 return;
1205 }
1206
1207 /* version should be 2 */
1208 ver = ML_(read_UShort)( block_img + blklen_len );
1209 if ( ver != 2 && ver != 3 && ver != 4 ) {
1210 ML_(symerr)( di, True,
1211 "Ignoring non-Dwarf2/3/4 block in .debug_info" );
1212 continue;
1213 }
1214
1215 /* Fill ui with offset in .debug_line and compdir */
1216 if (0)
1217 VG_(printf)( "Reading UnitInfo at 0x%lx.....\n",
1218 block_img - debug_info_img + 0UL );
1219 read_unitinfo_dwarf2( &ui, block_img,
1220 debug_abbv_img, debug_str_img );
1221 if (0)
1222 VG_(printf)( " => LINES=0x%llx NAME=%s DIR=%s\n",
1223 ui.stmt_list, ui.name, ui.compdir );
1224
1225 /* Ignore blocks with no .debug_line associated block */
1226 if ( ui.stmt_list == -1LL )
1227 continue;
1228
1229 if (0)
1230 VG_(printf)("debug_line_sz %ld, ui.stmt_list %lld %s\n",
1231 debug_line_sz, ui.stmt_list, ui.name );
1232 /* Read the .debug_line block for this compile unit */
1233 read_dwarf2_lineblock(
1234 di, &ui, debug_line_img + ui.stmt_list,
1235 debug_line_sz - ui.stmt_list );
1236 }
1237 }
1238
1239
1240 ////////////////////////////////////////////////////////////////////
1241 ////////////////////////////////////////////////////////////////////
1242
1243 /*------------------------------------------------------------*/
1244 /*--- Read DWARF1 format line number info. ---*/
1245 /*------------------------------------------------------------*/
1246
1247 /* DWARF1 appears to be redundant, but nevertheless the Lahey Fortran
1248 compiler generates it.
1249 */
1250
1251 /* The following three enums (dwarf_tag, dwarf_form, dwarf_attribute)
1252 are taken from the file include/elf/dwarf.h in the GNU gdb-6.0
1253 sources, which are Copyright 1992, 1993, 1995, 1999 Free Software
1254 Foundation, Inc and naturally licensed under the GNU General Public
1255 License version 2 or later.
1256 */
1257
1258 /* Tag names and codes. */
1259
1260 enum dwarf_tag {
1261 TAG_padding = 0x0000,
1262 TAG_array_type = 0x0001,
1263 TAG_class_type = 0x0002,
1264 TAG_entry_point = 0x0003,
1265 TAG_enumeration_type = 0x0004,
1266 TAG_formal_parameter = 0x0005,
1267 TAG_global_subroutine = 0x0006,
1268 TAG_global_variable = 0x0007,
1269 /* 0x0008 -- reserved */
1270 /* 0x0009 -- reserved */
1271 TAG_label = 0x000a,
1272 TAG_lexical_block = 0x000b,
1273 TAG_local_variable = 0x000c,
1274 TAG_member = 0x000d,
1275 /* 0x000e -- reserved */
1276 TAG_pointer_type = 0x000f,
1277 TAG_reference_type = 0x0010,
1278 TAG_compile_unit = 0x0011,
1279 TAG_string_type = 0x0012,
1280 TAG_structure_type = 0x0013,
1281 TAG_subroutine = 0x0014,
1282 TAG_subroutine_type = 0x0015,
1283 TAG_typedef = 0x0016,
1284 TAG_union_type = 0x0017,
1285 TAG_unspecified_parameters = 0x0018,
1286 TAG_variant = 0x0019,
1287 TAG_common_block = 0x001a,
1288 TAG_common_inclusion = 0x001b,
1289 TAG_inheritance = 0x001c,
1290 TAG_inlined_subroutine = 0x001d,
1291 TAG_module = 0x001e,
1292 TAG_ptr_to_member_type = 0x001f,
1293 TAG_set_type = 0x0020,
1294 TAG_subrange_type = 0x0021,
1295 TAG_with_stmt = 0x0022,
1296
1297 /* GNU extensions */
1298
1299 TAG_format_label = 0x8000, /* for FORTRAN 77 and Fortran 90 */
1300 TAG_namelist = 0x8001, /* For Fortran 90 */
1301 TAG_function_template = 0x8002, /* for C++ */
1302 TAG_class_template = 0x8003 /* for C++ */
1303 };
1304
1305 /* Form names and codes. */
1306
1307 enum dwarf_form {
1308 FORM_ADDR = 0x1,
1309 FORM_REF = 0x2,
1310 FORM_BLOCK2 = 0x3,
1311 FORM_BLOCK4 = 0x4,
1312 FORM_DATA2 = 0x5,
1313 FORM_DATA4 = 0x6,
1314 FORM_DATA8 = 0x7,
1315 FORM_STRING = 0x8
1316 };
1317
1318 /* Attribute names and codes. */
1319
1320 enum dwarf_attribute {
1321 AT_sibling = (0x0010|FORM_REF),
1322 AT_location = (0x0020|FORM_BLOCK2),
1323 AT_name = (0x0030|FORM_STRING),
1324 AT_fund_type = (0x0050|FORM_DATA2),
1325 AT_mod_fund_type = (0x0060|FORM_BLOCK2),
1326 AT_user_def_type = (0x0070|FORM_REF),
1327 AT_mod_u_d_type = (0x0080|FORM_BLOCK2),
1328 AT_ordering = (0x0090|FORM_DATA2),
1329 AT_subscr_data = (0x00a0|FORM_BLOCK2),
1330 AT_byte_size = (0x00b0|FORM_DATA4),
1331 AT_bit_offset = (0x00c0|FORM_DATA2),
1332 AT_bit_size = (0x00d0|FORM_DATA4),
1333 /* (0x00e0|FORM_xxxx) -- reserved */
1334 AT_element_list = (0x00f0|FORM_BLOCK4),
1335 AT_stmt_list = (0x0100|FORM_DATA4),
1336 AT_low_pc = (0x0110|FORM_ADDR),
1337 AT_high_pc = (0x0120|FORM_ADDR),
1338 AT_language = (0x0130|FORM_DATA4),
1339 AT_member = (0x0140|FORM_REF),
1340 AT_discr = (0x0150|FORM_REF),
1341 AT_discr_value = (0x0160|FORM_BLOCK2),
1342 /* (0x0170|FORM_xxxx) -- reserved */
1343 /* (0x0180|FORM_xxxx) -- reserved */
1344 AT_string_length = (0x0190|FORM_BLOCK2),
1345 AT_common_reference = (0x01a0|FORM_REF),
1346 AT_comp_dir = (0x01b0|FORM_STRING),
1347 AT_const_value_string = (0x01c0|FORM_STRING),
1348 AT_const_value_data2 = (0x01c0|FORM_DATA2),
1349 AT_const_value_data4 = (0x01c0|FORM_DATA4),
1350 AT_const_value_data8 = (0x01c0|FORM_DATA8),
1351 AT_const_value_block2 = (0x01c0|FORM_BLOCK2),
1352 AT_const_value_block4 = (0x01c0|FORM_BLOCK4),
1353 AT_containing_type = (0x01d0|FORM_REF),
1354 AT_default_value_addr = (0x01e0|FORM_ADDR),
1355 AT_default_value_data2 = (0x01e0|FORM_DATA2),
1356 AT_default_value_data4 = (0x01e0|FORM_DATA4),
1357 AT_default_value_data8 = (0x01e0|FORM_DATA8),
1358 AT_default_value_string = (0x01e0|FORM_STRING),
1359 AT_friends = (0x01f0|FORM_BLOCK2),
1360 AT_inline = (0x0200|FORM_STRING),
1361 AT_is_optional = (0x0210|FORM_STRING),
1362 AT_lower_bound_ref = (0x0220|FORM_REF),
1363 AT_lower_bound_data2 = (0x0220|FORM_DATA2),
1364 AT_lower_bound_data4 = (0x0220|FORM_DATA4),
1365 AT_lower_bound_data8 = (0x0220|FORM_DATA8),
1366 AT_private = (0x0240|FORM_STRING),
1367 AT_producer = (0x0250|FORM_STRING),
1368 AT_program = (0x0230|FORM_STRING),
1369 AT_protected = (0x0260|FORM_STRING),
1370 AT_prototyped = (0x0270|FORM_STRING),
1371 AT_public = (0x0280|FORM_STRING),
1372 AT_pure_virtual = (0x0290|FORM_STRING),
1373 AT_return_addr = (0x02a0|FORM_BLOCK2),
1374 AT_abstract_origin = (0x02b0|FORM_REF),
1375 AT_start_scope = (0x02c0|FORM_DATA4),
1376 AT_stride_size = (0x02e0|FORM_DATA4),
1377 AT_upper_bound_ref = (0x02f0|FORM_REF),
1378 AT_upper_bound_data2 = (0x02f0|FORM_DATA2),
1379 AT_upper_bound_data4 = (0x02f0|FORM_DATA4),
1380 AT_upper_bound_data8 = (0x02f0|FORM_DATA8),
1381 AT_virtual = (0x0300|FORM_STRING),
1382
1383 /* GNU extensions. */
1384
1385 AT_sf_names = (0x8000|FORM_DATA4),
1386 AT_src_info = (0x8010|FORM_DATA4),
1387 AT_mac_info = (0x8020|FORM_DATA4),
1388 AT_src_coords = (0x8030|FORM_DATA4),
1389 AT_body_begin = (0x8040|FORM_ADDR),
1390 AT_body_end = (0x8050|FORM_ADDR)
1391 };
1392
1393 /* end of enums taken from gdb-6.0 sources */
1394
ML_(read_debuginfo_dwarf1)1395 void ML_(read_debuginfo_dwarf1) (
1396 struct _DebugInfo* di,
1397 UChar* dwarf1d, Int dwarf1d_sz,
1398 UChar* dwarf1l, Int dwarf1l_sz )
1399 {
1400 UInt stmt_list;
1401 Bool stmt_list_found;
1402 Int die_offset, die_szb, at_offset;
1403 UShort die_kind, at_kind;
1404 UChar* at_base;
1405 UChar* src_filename;
1406
1407 if (0)
1408 VG_(printf)("read_debuginfo_dwarf1 ( %p, %d, %p, %d )\n",
1409 dwarf1d, dwarf1d_sz, dwarf1l, dwarf1l_sz );
1410
1411 /* This loop scans the DIEs. */
1412 die_offset = 0;
1413 while (True) {
1414 if (die_offset >= dwarf1d_sz) break;
1415
1416 die_szb = ML_(read_Int)(dwarf1d + die_offset);
1417 die_kind = ML_(read_UShort)(dwarf1d + die_offset + 4);
1418
1419 /* We're only interested in compile_unit DIEs; ignore others. */
1420 if (die_kind != TAG_compile_unit) {
1421 die_offset += die_szb;
1422 continue;
1423 }
1424
1425 if (0)
1426 VG_(printf)("compile-unit DIE: offset %d, tag 0x%x, size %d\n",
1427 die_offset, (Int)die_kind, die_szb );
1428
1429 /* We've got a compile_unit DIE starting at (dwarf1d +
1430 die_offset+6). Try and find the AT_name and AT_stmt_list
1431 attributes. Then, finally, we can read the line number info
1432 for this source file. */
1433
1434 /* The next 3 are set as we find the relevant attrs. */
1435 src_filename = NULL;
1436 stmt_list_found = False;
1437 stmt_list = 0;
1438
1439 /* This loop scans the Attrs inside compile_unit DIEs. */
1440 at_base = dwarf1d + die_offset + 6;
1441 at_offset = 0;
1442 while (True) {
1443 if (at_offset >= die_szb-6) break;
1444
1445 at_kind = ML_(read_UShort)(at_base + at_offset);
1446 if (0) VG_(printf)("atoffset %d, attag 0x%x\n",
1447 at_offset, (Int)at_kind );
1448 at_offset += 2; /* step over the attribute itself */
1449 /* We have to examine the attribute to figure out its
1450 length. */
1451 switch (at_kind) {
1452 case AT_stmt_list:
1453 case AT_language:
1454 case AT_sibling:
1455 if (at_kind == AT_stmt_list) {
1456 stmt_list_found = True;
1457 stmt_list = ML_(read_Int)(at_base+at_offset);
1458 }
1459 at_offset += 4; break;
1460 case AT_high_pc:
1461 case AT_low_pc:
1462 at_offset += sizeof(void*); break;
1463 case AT_name:
1464 case AT_producer:
1465 case AT_comp_dir:
1466 /* Zero terminated string, step over it. */
1467 if (at_kind == AT_name)
1468 src_filename = at_base + at_offset;
1469 while (at_offset < die_szb-6 && at_base[at_offset] != 0)
1470 at_offset++;
1471 at_offset++;
1472 break;
1473 default:
1474 VG_(printf)("Unhandled DWARF-1 attribute 0x%x\n",
1475 (Int)at_kind );
1476 VG_(core_panic)("Unhandled DWARF-1 attribute");
1477 } /* switch (at_kind) */
1478 } /* looping over attributes */
1479
1480 /* So, did we find the required stuff for a line number table in
1481 this DIE? If yes, read it. */
1482 if (stmt_list_found /* there is a line number table */
1483 && src_filename != NULL /* we know the source filename */
1484 ) {
1485 /* Table starts:
1486 Length:
1487 4 bytes, includes the entire table
1488 Base address:
1489 unclear (4? 8?), assuming native pointer size here.
1490 Then a sequence of triples
1491 (source line number -- 32 bits
1492 source line column -- 16 bits
1493 address delta -- 32 bits)
1494 */
1495 Addr base;
1496 Int len;
1497 Char* curr_filenm;
1498 UChar* ptr;
1499 UInt prev_line, prev_delta;
1500
1501 curr_filenm = ML_(addStr) ( di, src_filename, -1 );
1502 prev_line = prev_delta = 0;
1503
1504 ptr = dwarf1l + stmt_list;
1505 len = ML_(read_Int)(ptr); ptr += sizeof(Int);
1506 base = ML_(read_Addr)(ptr); ptr += sizeof(void*);
1507 len -= (sizeof(Int) + sizeof(void*));
1508 while (len > 0) {
1509 UInt line;
1510 UShort col;
1511 UInt delta;
1512 line = ML_(read_UInt)(ptr); ptr += sizeof(UInt);
1513 col = ML_(read_UShort)(ptr); ptr += sizeof(UShort);
1514 delta = ML_(read_UInt)(ptr); ptr += sizeof(UInt);
1515 if (0) VG_(printf)("line %d, col %d, delta %d\n",
1516 line, (Int)col, delta );
1517 len -= (sizeof(UInt) + sizeof(UShort) + sizeof(UInt));
1518
1519 if (delta > 0 && prev_line > 0) {
1520 if (0) VG_(printf) (" %d %d-%d\n",
1521 prev_line, prev_delta, delta-1);
1522 ML_(addLineInfo) ( di, curr_filenm, NULL,
1523 base + prev_delta, base + delta,
1524 prev_line, 0 );
1525 }
1526 prev_line = line;
1527 prev_delta = delta;
1528 }
1529 }
1530
1531 /* Move on the the next DIE. */
1532 die_offset += die_szb;
1533
1534 } /* Looping over DIEs */
1535
1536 }
1537
1538
1539 /*------------------------------------------------------------*/
1540 /*--- Read call-frame info from an .eh_frame section ---*/
1541 /*------------------------------------------------------------*/
1542
1543 /* Sources of info:
1544
1545 The DWARF3 spec, available from http://www.dwarfstd.org/Download.php
1546
1547 This describes how to read CFA data from .debug_frame sections.
1548 So as to maximise everybody's annoyance and confusion, .eh_frame
1549 sections are almost the same as .debug_frame sections, but differ
1550 in a few subtle and ill documented but important aspects.
1551
1552 Generic ELF Specification, sections 7.5 (DWARF Extensions) and 7.6
1553 (Exception Frames), available from
1554
1555 http://www.linux-foundation.org/spec/book/ELF-generic/ELF-generic.html
1556
1557 This really does describe .eh_frame, at least the aspects that
1558 differ from standard DWARF3. It's better than guessing, and
1559 (marginally) more fun than reading the gdb source code.
1560 */
1561
1562 /* Useful info ..
1563
1564 In general:
1565 gdb-6.3/gdb/dwarf2-frame.c
1566
1567 gdb-6.3/gdb/i386-tdep.c:
1568
1569 DWARF2/GCC uses the stack address *before* the function call as a
1570 frame's CFA. [jrs: I presume this means %esp before the call as
1571 the CFA].
1572
1573 JRS: on amd64, the dwarf register numbering is, as per
1574 gdb-6.3/gdb/amd64-tdep.c and also amd64-abi-0.98.pdf:
1575
1576 0 1 2 3 4 5 6 7
1577 RAX RDX RCX RBX RSI RDI RBP RSP
1578
1579 8 ... 15
1580 R8 ... R15
1581
1582 16 is the return address (RIP)
1583 "The table defines Return Address to have a register number,
1584 even though the address is stored in 0(%rsp) and not in a
1585 physical register."
1586
1587 17 ... 24
1588 XMM0 ... XMM7
1589
1590 25 ... 32
1591 XMM8 ... XMM15
1592
1593 33 ... 40
1594 ST0 ... ST7
1595
1596 41 ... 48
1597 MM0 ... MM7
1598
1599 49 RFLAGS
1600 50,51,52,53,54,55 ES,CS,SS,DS,FS,GS
1601 58 FS.BASE (what's that?)
1602 59 GS.BASE (what's that?)
1603 62 TR (task register)
1604 63 LDTR (LDT register)
1605 64 MXCSR
1606 65 FCW (x87 control word)
1607 66 FSW (x86 status word)
1608
1609 On x86 I cannot find any documentation. It _appears_ to be the
1610 actual instruction encoding, viz:
1611
1612 0 1 2 3 4 5 6 7
1613 EAX ECX EDX EBX ESP EBP ESI EDI
1614
1615 8 is the return address (EIP) */
1616
1617
1618 /* Comments re DW_CFA_set_loc, 16 Nov 06.
1619
1620 JRS:
1621 Someone recently sent me a libcrypto.so.0.9.8 as distributed with
1622 Ubuntu of some flavour, compiled with gcc 4.1.2 on amd64. It
1623 causes V's CF reader to complain a lot:
1624
1625 >> --19976-- DWARF2 CFI reader: unhandled CFI instruction 0:24
1626 >> --19976-- DWARF2 CFI reader: unhandled CFI instruction 0:24
1627 >> --19976-- DWARF2 CFI reader: unhandled CFI instruction 0:24
1628 >> --19976-- DWARF2 CFI reader: unhandled CFI instruction 0:24
1629 >> --19976-- DWARF2 CFI reader: unhandled CFI instruction 0:48
1630 >> --19976-- DWARF2 CFI reader: unhandled CFI instruction 0:24
1631
1632 After chasing this around a bit it seems that the CF bytecode
1633 parser lost sync at a DW_CFA_set_loc, which has a single argument
1634 denoting an address.
1635
1636 As it stands that address is extracted by read_Addr(). On amd64
1637 that just fetches 8 bytes regardless of anything else.
1638
1639 read_encoded_Addr() is more sophisticated. This appears to take
1640 into account some kind of encoding flag. When I replace the uses
1641 of read_Addr by read_encoded_Addr for DW_CFA_set_loc, the
1642 complaints go away, there is no loss of sync, and the parsed CF
1643 instructions are the same as shown by readelf --debug-dump=frames.
1644
1645 So it seems a plausible fix. The problem is I looked in the DWARF3
1646 spec and completely failed to figure out whether or not the arg to
1647 DW_CFA_set_loc is supposed to be encoded in a way suitable for
1648 read_encoded_Addr, nor for that matter any description of what it
1649 is that read_encoded_Addr is really decoding.
1650
1651 TomH:
1652 The problem is that the encoding is not standard - the eh_frame
1653 section uses the same encoding as the dwarf_frame section except
1654 for a few small changes, and this is one of them. So this is not
1655 something the DWARF standard covers.
1656
1657 There is an augmentation string to indicate what is going on though
1658 so that programs can recognise it.
1659
1660 What we are doing seems to match what gdb 6.5 and libdwarf 20060614
1661 do though. I'm not sure about readelf though.
1662
1663 (later): Well dwarfdump barfs on it:
1664
1665 dwarfdump ERROR: dwarf_get_fde_info_for_reg:
1666 DW_DLE_DF_FRAME_DECODING_ERROR(193) (193)
1667
1668 I've looked at binutils as well now, and the code in readelf agrees
1669 with your patch - ie it treats set_loc as having an encoded address
1670 if there is a zR augmentation indicating an encoding.
1671
1672 Quite why gdb and libdwarf don't understand this is an interesting
1673 question...
1674
1675 Final outcome: all uses of read_Addr were replaced by
1676 read_encoded_Addr. A new type AddressDecodingInfo was added to
1677 make it relatively clean to plumb through the extra info needed by
1678 read_encoded_Addr.
1679 */
1680
1681 /* More badness re address encoding, 12 Jan 07.
1682
1683 Most gcc provided CIEs have a "zR" augmentation, which means they
1684 supply their own address encoding, and that works fine. However,
1685 some icc9 supplied CIEs have no augmentation, which means they use
1686 the default_Addr_encoding(). That says to use a machine-word sized
1687 value, literally unmodified.
1688
1689 Since .so's are, in general, relocated when loaded, having absolute
1690 addresses in the CFI data makes no sense when read_encoded_Addr is
1691 used to find the initial location for a FDE. The resulting saga:
1692
1693 TomH:
1694 > I'm chasing a stack backtrace failure for an amd64 .so which was
1695 > created I believe by icc 9.1. After a while I wound up looking at
1696 > this: (readdwarf.c)
1697 >
1698 > 5083 tom static UChar default_Addr_encoding ( void )
1699 > 3584 tom {
1700 > 3584 tom switch (sizeof(Addr)) {
1701 > 3584 tom case 4: return DW_EH_PE_udata4;
1702 > 3584 tom case 8: return DW_EH_PE_udata8;
1703 > 3584 tom default: vg_assert(0);
1704 > 3584 tom }
1705 > 3584 tom }
1706 >
1707 > If a CIE does not have an "augmentation string" (typically "zR") then
1708 > addresses are decoded as described by default_Addr_encoding. If there
1709 > is an 'R' in the augmentation string then the encoding to use
1710 > is specified by the CIE itself, which works fine with GCC compiled code
1711 > since that always appears to specify zR.
1712
1713 Correct.
1714
1715 > Problem is this .so has no augmentation string and so uses the
1716 > default encoding, viz DW_EH_PE_udata8. That appears to mean
1717 > "read a 64 bit number" and use that as-is (for the starting value
1718 > of the program counter when running the CFA program).
1719
1720 Strictly speaking the default is DW_EH_PE_absptr, but that amounts
1721 to either udata4 or udata8 depending on the platform's pointer size
1722 which is a shortcut I used.
1723
1724 > For this .so that gives nonsense (very small) PCs which are later
1725 > rejected by the sanity check which ensures PC ranges fall inside
1726 > the mapped text segment. It seems like the .so expects to have the
1727 > start VMA of the text segment added on. This would correspond to
1728 >
1729 > static UChar default_Addr_encoding ( void )
1730 > {
1731 > switch (sizeof(Addr)) {
1732 > case 4: return DW_EH_PE_textrel + DW_EH_PE_udata4;
1733 > case 8: return DW_EH_PE_textrel + DW_EH_PE_udata8;
1734 > default: vg_assert(0);
1735 > }
1736 > }
1737
1738 The problem you're seeing is that you have absolute pointers inside
1739 a shared library, which obviously makes little sense on the face of
1740 things as how would the linker know where the library will be
1741 loaded?
1742
1743 The answer of course is that it doesn't, so if it points absolute
1744 pointers in the frame unwind data is has to include relocations for
1745 them, and I'm betting that if you look at the relocations in the
1746 library you will there are some for that data.
1747
1748 That is fine of course when ld.so maps the library - it will
1749 relocate the eh_frame data as it maps it (or prelinking will
1750 already have done so) and when the g++ exception code kicks in and
1751 unwinds the stack it will see relocated data.
1752
1753 We of course are mapping the section from the ELF file ourselves
1754 and are not applying the relocations, hence the problem you are
1755 seeing.
1756
1757 Strictly speaking we should apply the relocations but the cheap
1758 solution is essentially to do what you've done - strictly speaking
1759 you should adjust by the difference between the address the library
1760 was linked for and the address it has been loaded at, but a shared
1761 library will normally be linked for address zero I believe. It's
1762 possible that prelinking might change that though?
1763
1764 JRS:
1765 That all syncs with what I am seeing.
1766
1767 So what I am inclined to do is:
1768
1769 - Leave default_Addr_encoding as it is
1770
1771 - Change read_encoded_Addr's handling of "case DW_EH_PE_absptr" so
1772 it sets base to, as you say, the difference between the address
1773 the library was linked for and the address it has been loaded at
1774 (== the SegInfo's text_bias)
1775
1776 Does that sound sane? I think it should even handle the prelinked
1777 case.
1778
1779 (JRS, later)
1780
1781 Hmm. Plausible as it sounds, it doesn't work. It now produces
1782 bogus backtraces for locations inside the (statically linked)
1783 memcheck executable.
1784
1785 Besides, there are a couple of other places where read_encoded_Addr
1786 is used -- one of which is used to establish the length of the
1787 address range covered by the current FDE:
1788
1789 fde_arange = read_encoded_Addr(&nbytes, &adi, data);
1790
1791 and it doesn't seem to make any sense for read_encoded_Addr to add
1792 on the text segment bias in that context. The DWARF3 spec says
1793 that both the initial_location and address_range (length) fields
1794 are encoded the same way ("target address"), so it is unclear at
1795 what stage in the process it would be appropriate to relocate the
1796 former but not the latter.
1797
1798 One unprincipled kludge that does work is the following: just
1799 before handing one of the address range fragments off to
1800 ML_(addDiCfSI) for permanent storage, check its start address. If
1801 that is very low (less than 2 M), and is far below the mapped text
1802 segment, and adding the text bias would move the fragment entirely
1803 inside the mapped text segment, then do so. A kind of kludged
1804 last-minute relocation, if you like.
1805
1806 12 Jan 07: committing said kludge (see kludge_then_addDiCfSI). If
1807 the situation clarifies, it can easily enough be backed out and
1808 replaced by a better fix.
1809 */
1810
1811 /* --------------- Decls --------------- */
1812
1813 #if defined(VGP_x86_linux)
1814 # define FP_REG 5
1815 # define SP_REG 4
1816 # define RA_REG_DEFAULT 8
1817 #elif defined(VGP_amd64_linux)
1818 # define FP_REG 6
1819 # define SP_REG 7
1820 # define RA_REG_DEFAULT 16
1821 #elif defined(VGP_ppc32_linux)
1822 # define FP_REG 1
1823 # define SP_REG 1
1824 # define RA_REG_DEFAULT 65
1825 #elif defined(VGP_ppc64_linux)
1826 # define FP_REG 1
1827 # define SP_REG 1
1828 # define RA_REG_DEFAULT 65
1829 #elif defined(VGP_arm_linux)
1830 # define FP_REG 12
1831 # define SP_REG 13
1832 # define RA_REG_DEFAULT 14 //???
1833 #elif defined(VGP_x86_darwin)
1834 # define FP_REG 5
1835 # define SP_REG 4
1836 # define RA_REG_DEFAULT 8
1837 #elif defined(VGP_amd64_darwin)
1838 # define FP_REG 6
1839 # define SP_REG 7
1840 # define RA_REG_DEFAULT 16
1841 #elif defined(VGP_s390x_linux)
1842 # define FP_REG 11 // sometimes s390 has a frame pointer in r11
1843 # define SP_REG 15 // stack is always r15
1844 # define RA_REG_DEFAULT 14 // the return address is in r14
1845 #else
1846 # error "Unknown platform"
1847 #endif
1848
1849 /* the number of regs we are prepared to unwind */
1850 #if defined(VGP_ppc32_linux) || defined(VGP_ppc64_linux)
1851 # define N_CFI_REGS 72
1852 #elif defined (VGP_arm_linux)
1853 /* 287 is the highest allocated DWARF register name as of 27.07.2011
1854 http://infocenter.arm.com/help/topic/com.arm.doc.ihi0040a/IHI0040A_aadwarf.pdf
1855 */
1856 # define N_CFI_REGS 287
1857 #else
1858 # define N_CFI_REGS 20
1859 #endif
1860
1861 /* Instructions for the automaton */
1862 enum dwarf_cfa_primary_ops
1863 {
1864 DW_CFA_use_secondary = 0,
1865 DW_CFA_advance_loc = 1,
1866 DW_CFA_offset = 2,
1867 DW_CFA_restore = 3
1868 };
1869
1870 enum dwarf_cfa_secondary_ops
1871 {
1872 DW_CFA_nop = 0x00,
1873 DW_CFA_set_loc = 0x01,
1874 DW_CFA_advance_loc1 = 0x02,
1875 DW_CFA_advance_loc2 = 0x03,
1876 DW_CFA_advance_loc4 = 0x04,
1877 DW_CFA_offset_extended = 0x05,
1878 DW_CFA_restore_extended = 0x06,
1879 DW_CFA_undefined = 0x07,
1880 DW_CFA_same_value = 0x08,
1881 DW_CFA_register = 0x09,
1882 DW_CFA_remember_state = 0x0a,
1883 DW_CFA_restore_state = 0x0b,
1884 DW_CFA_def_cfa = 0x0c,
1885 DW_CFA_def_cfa_register = 0x0d,
1886 DW_CFA_def_cfa_offset = 0x0e,
1887 DW_CFA_def_cfa_expression = 0x0f, /* DWARF3 only */
1888 DW_CFA_expression = 0x10, /* DWARF3 only */
1889 DW_CFA_offset_extended_sf = 0x11, /* DWARF3 only */
1890 DW_CFA_def_cfa_sf = 0x12, /* DWARF3 only */
1891 DW_CFA_def_cfa_offset_sf = 0x13, /* DWARF3 only */
1892 DW_CFA_val_offset = 0x14, /* DWARF3 only */
1893 DW_CFA_val_offset_sf = 0x15, /* DWARF3 only */
1894 DW_CFA_val_expression = 0x16, /* DWARF3 only */
1895 DW_CFA_lo_user = 0x1c,
1896 DW_CFA_GNU_window_save = 0x2d, /* GNU extension */
1897 DW_CFA_GNU_args_size = 0x2e, /* GNU extension */
1898 DW_CFA_GNU_negative_offset_extended = 0x2f, /* GNU extension */
1899 DW_CFA_hi_user = 0x3f
1900 };
1901
1902 #define DW_EH_PE_absptr 0x00
1903 #define DW_EH_PE_omit 0xff
1904
1905 #define DW_EH_PE_uleb128 0x01
1906 #define DW_EH_PE_udata2 0x02
1907 #define DW_EH_PE_udata4 0x03
1908 #define DW_EH_PE_udata8 0x04
1909 #define DW_EH_PE_sleb128 0x09
1910 #define DW_EH_PE_sdata2 0x0A
1911 #define DW_EH_PE_sdata4 0x0B
1912 #define DW_EH_PE_sdata8 0x0C
1913 #define DW_EH_PE_signed 0x08
1914
1915 #define DW_EH_PE_pcrel 0x10
1916 #define DW_EH_PE_textrel 0x20
1917 #define DW_EH_PE_datarel 0x30
1918 #define DW_EH_PE_funcrel 0x40
1919 #define DW_EH_PE_aligned 0x50
1920
1921 #define DW_EH_PE_indirect 0x80
1922
1923
1924 /* RegRule and UnwindContext are used temporarily to do the unwinding.
1925 The result is then summarised into a sequence of CfiSIs, if
1926 possible. UnwindContext effectively holds the state of the
1927 abstract machine whilst it is running.
1928
1929 The CFA can either be a signed offset from a register,
1930 or an expression:
1931
1932 CFA = cfa_reg + cfa_off when UnwindContext.cfa_is_regoff==True
1933 | [[ cfa_expr_id ]]
1934
1935 When .cfa_is_regoff == True, cfa_expr_id must be zero
1936 When .cfa_is_regoff == False, cfa_reg must be zero
1937 and cfa_off must be zero
1938
1939 RegRule describes, for each register, how to get its
1940 value in the previous frame, where 'cfa' denotes the cfa
1941 for the frame as a whole:
1942
1943 RegRule = RR_Undef -- undefined
1944 | RR_Same -- same as in previous frame
1945 | RR_CFAOff arg -- is at * ( cfa + arg )
1946 | RR_CFAValOff arg -- is ( cfa + arg )
1947 | RR_Reg arg -- is in register 'arg'
1948 | RR_Expr arg -- is at * [[ arg ]]
1949 | RR_ValExpr arg -- is [[ arg ]]
1950 | RR_Arch -- dunno
1951
1952 Note that RR_Expr is redundant since the same can be represented
1953 using RR_ValExpr with an explicit dereference (CfiExpr_Deref) at
1954 the outermost level.
1955
1956 All expressions are stored in exprs in the containing
1957 UnwindContext. Since the UnwindContext gets reinitialised for each
1958 new FDE, summarise_context needs to copy out any expressions it
1959 wants to keep into the cfsi_exprs field of the containing SegInfo.
1960 */
1961 typedef
1962 struct {
1963 enum { RR_Undef, RR_Same, RR_CFAOff, RR_CFAValOff,
1964 RR_Reg, /*RR_Expr,*/ RR_ValExpr, RR_Arch } tag;
1965 /* meaning: int offset for CFAoff/CFAValOff
1966 reg # for Reg
1967 expr index for Expr/ValExpr */
1968 Int arg;
1969 }
1970 RegRule;
1971
ppRegRule(XArray * exprs,RegRule * rrule)1972 static void ppRegRule ( XArray* exprs, RegRule* rrule )
1973 {
1974 vg_assert(exprs);
1975 switch (rrule->tag) {
1976 case RR_Undef: VG_(printf)("u "); break;
1977 case RR_Same: VG_(printf)("s "); break;
1978 case RR_CFAOff: VG_(printf)("c%d ", rrule->arg); break;
1979 case RR_CFAValOff: VG_(printf)("v%d ", rrule->arg); break;
1980 case RR_Reg: VG_(printf)("r%d ", rrule->arg); break;
1981 case RR_ValExpr: VG_(printf)("ve{");
1982 ML_(ppCfiExpr)( exprs, rrule->arg );
1983 VG_(printf)("} ");
1984 break;
1985 case RR_Arch: VG_(printf)("a "); break;
1986 default: VG_(core_panic)("ppRegRule");
1987 }
1988 }
1989
1990
1991 /* Size of the stack of register unwind rules. This is only
1992 exceedingly rarely used, so a stack of size 1 should actually work
1993 with almost all compiler-generated CFA. */
1994 #define N_RR_STACK 4
1995
1996 typedef
1997 struct {
1998 /* Read-only fields (set by the CIE) */
1999 Int code_a_f;
2000 Int data_a_f;
2001 Addr initloc;
2002 Int ra_reg;
2003 /* The rest of these fields can be modifed by
2004 run_CF_instruction. */
2005 /* The LOC entry */
2006 Addr loc;
2007 /* We need a stack of these in order to handle
2008 DW_CFA_{remember,restore}_state. */
2009 struct UnwindContextState {
2010 /* The CFA entry. This can be either reg+/-offset or an expr. */
2011 Bool cfa_is_regoff; /* True=>is reg+offset; False=>is expr */
2012 Int cfa_reg;
2013 Int cfa_off; /* in bytes */
2014 Int cfa_expr_ix; /* index into cfa_exprs */
2015 /* Register unwind rules. */
2016 RegRule reg[N_CFI_REGS];
2017 }
2018 state[N_RR_STACK];
2019 Int state_sp; /* 0 <= state_sp < N_RR_STACK; points at the
2020 currently-in-use rule set. */
2021 /* array of CfiExpr, shared by reg[] and cfa_expr_ix */
2022 XArray* exprs;
2023 }
2024 UnwindContext;
2025
ppUnwindContext(UnwindContext * ctx)2026 static void ppUnwindContext ( UnwindContext* ctx )
2027 {
2028 Int j, i;
2029 VG_(printf)("0x%llx: ", (ULong)ctx->loc);
2030 for (j = 0; j <= ctx->state_sp; j++) {
2031 struct UnwindContextState* ctxs = &ctx->state[j];
2032 VG_(printf)("%s[%d]={ ", j > 0 ? " " : "", j);
2033 if (ctxs->cfa_is_regoff) {
2034 VG_(printf)("%d(r%d) ", ctxs->cfa_off, ctxs->cfa_reg);
2035 } else {
2036 vg_assert(ctx->exprs);
2037 VG_(printf)("{");
2038 ML_(ppCfiExpr)( ctx->exprs, ctxs->cfa_expr_ix );
2039 VG_(printf)("} ");
2040 }
2041 VG_(printf)("{ ");
2042 for (i = 0; i < N_CFI_REGS; i++)
2043 ppRegRule(ctx->exprs, &ctxs->reg[i]);
2044 VG_(printf)("}");
2045 }
2046 VG_(printf)("\n");
2047 }
2048
initUnwindContext(UnwindContext * ctx)2049 static void initUnwindContext ( /*OUT*/UnwindContext* ctx )
2050 {
2051 Int j, i;
2052 VG_(memset)(ctx, 0, sizeof(*ctx));
2053 /* ctx->code_a_f = 0;
2054 ctx->data_a_f = 0;
2055 ctx->initloc = 0; */
2056 ctx->ra_reg = RA_REG_DEFAULT;
2057 /* ctx->loc = 0;
2058 ctx->exprs = NULL;
2059 ctx->state_sp = 0; */
2060 for (j = 0; j < N_RR_STACK; j++) {
2061 ctx->state[j].cfa_is_regoff = True;
2062 /* ctx->state[j].cfa_reg = 0;
2063 ctx->state[j].cfa_off = 0;
2064 ctx->state[j].cfa_expr_ix = 0; */
2065 for (i = 0; i < N_CFI_REGS; i++) {
2066 if (RR_Undef != 0)
2067 ctx->state[j].reg[i].tag = RR_Undef;
2068 /* ctx->state[j].reg[i].arg = 0; */
2069 }
2070 # if defined(VGA_arm)
2071 /* All callee-saved registers (or at least the ones we are
2072 summarising for) should start out as RR_Same, on ARM. */
2073 ctx->state[j].reg[11].tag = RR_Same;
2074 /* ctx->state[j].reg[13].tag = RR_Same; */
2075 ctx->state[j].reg[14].tag = RR_Same;
2076 ctx->state[j].reg[12].tag = RR_Same;
2077 ctx->state[j].reg[7].tag = RR_Same;
2078 /* this can't be right though: R12 (IP) isn't callee saved. */
2079 # endif
2080 }
2081 }
2082
2083
2084 /* A structure which holds information needed by read_encoded_Addr().
2085 */
2086 typedef
2087 struct {
2088 UChar encoding;
2089 UChar* ehframe_image;
2090 Addr ehframe_avma;
2091 Addr text_bias;
2092 }
2093 AddressDecodingInfo;
2094
2095
2096 /* ------------ Deal with summary-info records ------------ */
2097
initCfiSI(DiCfSI * si)2098 static void initCfiSI ( DiCfSI* si )
2099 {
2100 VG_(memset)(si, 0, sizeof(*si));
2101 }
2102
2103
2104 /* --------------- Summarisation --------------- */
2105
2106 /* Forward */
2107 static
2108 Int copy_convert_CfiExpr_tree ( XArray* dst,
2109 UnwindContext* srcuc,
2110 Int nd );
2111
2112 /* Summarise ctx into si, if possible. Returns True if successful.
2113 This is taken to be just after ctx's loc advances; hence the
2114 summary is up to but not including the current loc. This works
2115 on both x86 and amd64.
2116 */
summarise_context(DiCfSI * si,Addr loc_start,UnwindContext * ctx,struct _DebugInfo * debuginfo)2117 static Bool summarise_context( /*OUT*/DiCfSI* si,
2118 Addr loc_start,
2119 UnwindContext* ctx,
2120 struct _DebugInfo* debuginfo )
2121 {
2122 Int why = 0;
2123 struct UnwindContextState* ctxs;
2124 initCfiSI(si);
2125
2126 /* Guard against obviously stupid settings of the reg-rule stack
2127 pointer. */
2128 if (ctx->state_sp < 0) { why = 8; goto failed; }
2129 if (ctx->state_sp >= N_RR_STACK) { why = 9; goto failed; }
2130 ctxs = &ctx->state[ctx->state_sp];
2131
2132 /* First, summarise the method for generating the CFA */
2133 if (!ctxs->cfa_is_regoff) {
2134 /* it was set by DW_CFA_def_cfa_expression; try to convert */
2135 XArray *src, *dst;
2136 Int conv;
2137 src = ctx->exprs;
2138 dst = debuginfo->cfsi_exprs;
2139 if (src && (VG_(sizeXA)(src) > 0) && (!dst)) {
2140 dst = VG_(newXA)( ML_(dinfo_zalloc), "di.ccCt.1", ML_(dinfo_free),
2141 sizeof(CfiExpr) );
2142 vg_assert(dst);
2143 debuginfo->cfsi_exprs = dst;
2144 }
2145 conv = copy_convert_CfiExpr_tree
2146 ( dst, ctx, ctxs->cfa_expr_ix );
2147 vg_assert(conv >= -1);
2148 if (conv == -1) { why = 6; goto failed; }
2149 si->cfa_how = CFIC_EXPR;
2150 si->cfa_off = conv;
2151 if (0 && debuginfo->ddump_frames)
2152 ML_(ppCfiExpr)(dst, conv);
2153 }
2154 else
2155 if (ctxs->cfa_is_regoff && ctxs->cfa_reg == SP_REG) {
2156 si->cfa_off = ctxs->cfa_off;
2157 # if defined(VGA_x86) || defined(VGA_amd64) || defined(VGA_s390x)
2158 si->cfa_how = CFIC_IA_SPREL;
2159 # elif defined(VGA_arm)
2160 si->cfa_how = CFIC_ARM_R13REL;
2161 # else
2162 si->cfa_how = 0; /* invalid */
2163 # endif
2164 }
2165 else
2166 if (ctxs->cfa_is_regoff && ctxs->cfa_reg == FP_REG) {
2167 si->cfa_off = ctxs->cfa_off;
2168 # if defined(VGA_x86) || defined(VGA_amd64) || defined(VGA_s390x)
2169 si->cfa_how = CFIC_IA_BPREL;
2170 # elif defined(VGA_arm)
2171 si->cfa_how = CFIC_ARM_R12REL;
2172 # else
2173 si->cfa_how = 0; /* invalid */
2174 # endif
2175 }
2176 # if defined(VGA_arm)
2177 else
2178 if (ctxs->cfa_is_regoff && ctxs->cfa_reg == 11/*??_REG*/) {
2179 si->cfa_how = CFIC_ARM_R11REL;
2180 si->cfa_off = ctxs->cfa_off;
2181 }
2182 else
2183 if (ctxs->cfa_is_regoff && ctxs->cfa_reg == 7/*??_REG*/) {
2184 si->cfa_how = CFIC_ARM_R7REL;
2185 si->cfa_off = ctxs->cfa_off;
2186 }
2187 # endif
2188 else {
2189 why = 1;
2190 goto failed;
2191 }
2192
2193 # define SUMMARISE_HOW(_how, _off, _ctxreg) \
2194 switch (_ctxreg.tag) { \
2195 case RR_Undef: \
2196 _how = CFIR_UNKNOWN; _off = 0; break; \
2197 case RR_Same: \
2198 _how = CFIR_SAME; _off = 0; break; \
2199 case RR_CFAOff: \
2200 _how = CFIR_MEMCFAREL; _off = _ctxreg.arg; break; \
2201 case RR_CFAValOff: \
2202 _how = CFIR_CFAREL; _off = _ctxreg.arg; break; \
2203 case RR_ValExpr: { \
2204 XArray *src, *dst; \
2205 Int conv; \
2206 src = ctx->exprs; \
2207 dst = debuginfo->cfsi_exprs; \
2208 if (src && (VG_(sizeXA)(src) > 0) && (!dst)) { \
2209 dst = VG_(newXA)( ML_(dinfo_zalloc), \
2210 "di.ccCt.2", \
2211 ML_(dinfo_free), \
2212 sizeof(CfiExpr) ); \
2213 vg_assert(dst); \
2214 debuginfo->cfsi_exprs = dst; \
2215 } \
2216 conv = copy_convert_CfiExpr_tree \
2217 ( dst, ctx, _ctxreg.arg ); \
2218 vg_assert(conv >= -1); \
2219 if (conv == -1) { why = 7; goto failed; } \
2220 _how = CFIR_EXPR; \
2221 _off = conv; \
2222 if (0 && debuginfo->ddump_frames) \
2223 ML_(ppCfiExpr)(dst, conv); \
2224 break; \
2225 } \
2226 default: \
2227 why = 2; goto failed; /* otherwise give up */ \
2228 }
2229
2230 # if defined(VGA_x86) || defined(VGA_amd64)
2231
2232 /* --- entire tail of this fn specialised for x86/amd64 --- */
2233
2234 SUMMARISE_HOW(si->ra_how, si->ra_off,
2235 ctxs->reg[ctx->ra_reg] );
2236 SUMMARISE_HOW(si->bp_how, si->bp_off,
2237 ctxs->reg[FP_REG] );
2238
2239 /* on x86/amd64, it seems the old %{e,r}sp value before the call is
2240 always the same as the CFA. Therefore ... */
2241 si->sp_how = CFIR_CFAREL;
2242 si->sp_off = 0;
2243
2244 /* also, gcc says "Undef" for %{e,r}bp when it is unchanged. So
2245 .. */
2246 if (ctxs->reg[FP_REG].tag == RR_Undef)
2247 si->bp_how = CFIR_SAME;
2248
2249 /* knock out some obviously stupid cases */
2250 if (si->ra_how == CFIR_SAME)
2251 { why = 3; goto failed; }
2252
2253 /* bogus looking range? Note, we require that the difference is
2254 representable in 32 bits. */
2255 if (loc_start >= ctx->loc)
2256 { why = 4; goto failed; }
2257 if (ctx->loc - loc_start > 10000000 /* let's say */)
2258 { why = 5; goto failed; }
2259
2260 si->base = loc_start + ctx->initloc;
2261 si->len = (UInt)(ctx->loc - loc_start);
2262
2263 return True;
2264
2265 # elif defined(VGA_arm)
2266
2267 /* ---- entire tail of this fn specialised for arm ---- */
2268
2269 SUMMARISE_HOW(si->r14_how, si->r14_off,
2270 ctxs->reg[14] );
2271
2272 //SUMMARISE_HOW(si->r13_how, si->r13_off,
2273 // ctxs->reg[13] );
2274
2275 SUMMARISE_HOW(si->r12_how, si->r12_off,
2276 ctxs->reg[FP_REG] );
2277
2278 SUMMARISE_HOW(si->r11_how, si->r11_off,
2279 ctxs->reg[11/*FP_REG*/] );
2280
2281 SUMMARISE_HOW(si->r7_how, si->r7_off,
2282 ctxs->reg[7] );
2283
2284 if (ctxs->reg[14/*LR*/].tag == RR_Same
2285 && ctx->ra_reg == 14/*as we expect it always to be*/) {
2286 /* Generate a trivial CfiExpr, which merely says "r14". First
2287 ensure this DebugInfo has a cfsi_expr array in which to park
2288 it. */
2289 if (!debuginfo->cfsi_exprs)
2290 debuginfo->cfsi_exprs = VG_(newXA)( ML_(dinfo_zalloc),
2291 "di.ccCt.2a",
2292 ML_(dinfo_free),
2293 sizeof(CfiExpr) );
2294 si->ra_off = ML_(CfiExpr_CfiReg)( debuginfo->cfsi_exprs,
2295 Creg_ARM_R14);
2296 si->ra_how = CFIR_EXPR;
2297 } else {
2298 /* Just summarise it in the normal way */
2299 SUMMARISE_HOW(si->ra_how, si->ra_off,
2300 ctxs->reg[ctx->ra_reg] );
2301 }
2302
2303 /* on arm, it seems the old r13 (SP) value before the call is
2304 always the same as the CFA. Therefore ... */
2305 si->r13_how = CFIR_CFAREL;
2306 si->r13_off = 0;
2307
2308 /* bogus looking range? Note, we require that the difference is
2309 representable in 32 bits. */
2310 if (loc_start >= ctx->loc)
2311 { why = 4; goto failed; }
2312 if (ctx->loc - loc_start > 10000000 /* let's say */)
2313 { why = 5; goto failed; }
2314
2315 si->base = loc_start + ctx->initloc;
2316 si->len = (UInt)(ctx->loc - loc_start);
2317
2318 return True;
2319
2320
2321 # elif defined(VGA_s390x)
2322
2323 SUMMARISE_HOW(si->ra_how, si->ra_off,
2324 ctxs->reg[ctx->ra_reg] );
2325 SUMMARISE_HOW(si->fp_how, si->fp_off,
2326 ctxs->reg[FP_REG] );
2327 SUMMARISE_HOW(si->sp_how, si->sp_off,
2328 ctxs->reg[SP_REG] );
2329
2330 /* change some defaults to consumable values */
2331 if (si->sp_how == CFIR_UNKNOWN)
2332 si->sp_how = CFIR_SAME;
2333
2334 if (si->fp_how == CFIR_UNKNOWN)
2335 si->fp_how = CFIR_SAME;
2336
2337 if (si->cfa_how == CFIR_UNKNOWN) {
2338 si->cfa_how = CFIC_IA_SPREL;
2339 si->cfa_off = 160;
2340 }
2341 if (si->ra_how == CFIR_UNKNOWN) {
2342 if (!debuginfo->cfsi_exprs)
2343 debuginfo->cfsi_exprs = VG_(newXA)( ML_(dinfo_zalloc),
2344 "di.ccCt.2a",
2345 ML_(dinfo_free),
2346 sizeof(CfiExpr) );
2347 si->ra_how = CFIR_EXPR;
2348 si->ra_off = ML_(CfiExpr_CfiReg)( debuginfo->cfsi_exprs,
2349 Creg_S390_R14);
2350 }
2351
2352 /* knock out some obviously stupid cases */
2353 if (si->ra_how == CFIR_SAME)
2354 { why = 3; goto failed; }
2355
2356 /* bogus looking range? Note, we require that the difference is
2357 representable in 32 bits. */
2358 if (loc_start >= ctx->loc)
2359 { why = 4; goto failed; }
2360 if (ctx->loc - loc_start > 10000000 /* let's say */)
2361 { why = 5; goto failed; }
2362
2363 si->base = loc_start + ctx->initloc;
2364 si->len = (UInt)(ctx->loc - loc_start);
2365
2366 return True;
2367
2368
2369
2370 # elif defined(VGA_ppc32) || defined(VGA_ppc64)
2371 # else
2372 # error "Unknown arch"
2373 # endif
2374
2375 # undef SUMMARISE_HOW
2376
2377 failed:
2378 if (VG_(clo_verbosity) > 2 || debuginfo->trace_cfi) {
2379 VG_(message)(Vg_DebugMsg,
2380 "summarise_context(loc_start = %#lx)"
2381 ": cannot summarise(why=%d): \n", loc_start, why);
2382 ppUnwindContext(ctx);
2383 }
2384 return False;
2385 }
2386
2387 /* Copy the tree rooted at srcuc->exprs node srcix to dstxa, on the
2388 way converting any DwReg regs (regs numbered using the Dwarf scheme
2389 defined by each architecture's ABI) into CfiRegs, which are
2390 platform independent. If the conversion isn't possible because
2391 there is no equivalent register, return -1. This has the
2392 undesirable side effect of de-dagifying the input; oh well. */
copy_convert_CfiExpr_tree(XArray * dstxa,UnwindContext * srcuc,Int srcix)2393 static Int copy_convert_CfiExpr_tree ( XArray* dstxa,
2394 UnwindContext* srcuc,
2395 Int srcix )
2396 {
2397 CfiExpr* src;
2398 Int cpL, cpR, cpA;
2399 XArray* srcxa = srcuc->exprs;
2400 vg_assert(srcxa);
2401 vg_assert(dstxa);
2402 vg_assert(srcix >= 0 && srcix < VG_(sizeXA)(srcxa));
2403
2404 src = VG_(indexXA)( srcxa, srcix );
2405 switch (src->tag) {
2406 case Cex_Undef:
2407 return ML_(CfiExpr_Undef)( dstxa );
2408 case Cex_Deref:
2409 cpA = copy_convert_CfiExpr_tree( dstxa, srcuc, src->Cex.Deref.ixAddr );
2410 if (cpA == -1)
2411 return -1; /* propagate failure */
2412 return ML_(CfiExpr_Deref)( dstxa, cpA );
2413 case Cex_Const:
2414 return ML_(CfiExpr_Const)( dstxa, src->Cex.Const.con );
2415 case Cex_Binop:
2416 cpL = copy_convert_CfiExpr_tree( dstxa, srcuc, src->Cex.Binop.ixL );
2417 cpR = copy_convert_CfiExpr_tree( dstxa, srcuc, src->Cex.Binop.ixR );
2418 vg_assert(cpL >= -1 && cpR >= -1);
2419 if (cpL == -1 || cpR == -1)
2420 return -1; /* propagate failure */
2421 return ML_(CfiExpr_Binop)( dstxa, src->Cex.Binop.op, cpL, cpR );
2422 case Cex_CfiReg:
2423 /* should not see these in input (are created only by this
2424 conversion step!) */
2425 VG_(core_panic)("copy_convert_CfiExpr_tree: CfiReg in input");
2426 case Cex_DwReg: {
2427 /* This is the only place where the conversion can fail. */
2428 Int dwreg __attribute__((unused));
2429 dwreg = src->Cex.DwReg.reg;
2430 # if defined(VGA_x86) || defined(VGA_amd64)
2431 if (dwreg == SP_REG)
2432 return ML_(CfiExpr_CfiReg)( dstxa, Creg_IA_SP );
2433 if (dwreg == FP_REG)
2434 return ML_(CfiExpr_CfiReg)( dstxa, Creg_IA_BP );
2435 if (dwreg == srcuc->ra_reg)
2436 return ML_(CfiExpr_CfiReg)( dstxa, Creg_IA_IP ); /* correct? */
2437 # elif defined(VGA_arm)
2438 if (dwreg == SP_REG)
2439 return ML_(CfiExpr_CfiReg)( dstxa, Creg_ARM_R13 );
2440 if (dwreg == FP_REG)
2441 return ML_(CfiExpr_CfiReg)( dstxa, Creg_ARM_R12 );
2442 if (dwreg == srcuc->ra_reg)
2443 return ML_(CfiExpr_CfiReg)( dstxa, Creg_ARM_R15 ); /* correct? */
2444 # elif defined(VGA_s390x)
2445 if (dwreg == SP_REG)
2446 return ML_(CfiExpr_CfiReg)( dstxa, Creg_IA_SP );
2447 if (dwreg == FP_REG)
2448 return ML_(CfiExpr_CfiReg)( dstxa, Creg_IA_BP );
2449 if (dwreg == srcuc->ra_reg)
2450 return ML_(CfiExpr_CfiReg)( dstxa, Creg_IA_IP ); /* correct? */
2451 # elif defined(VGA_ppc32) || defined(VGA_ppc64)
2452 # else
2453 # error "Unknown arch"
2454 # endif
2455 /* else we must fail - can't represent the reg */
2456 return -1;
2457 }
2458 default:
2459 VG_(core_panic)("copy_convert_CfiExpr_tree: default");
2460 }
2461 }
2462
2463
ppUnwindContext_summary(UnwindContext * ctx)2464 static void ppUnwindContext_summary ( UnwindContext* ctx )
2465 {
2466 struct UnwindContextState* ctxs = &ctx->state[ctx->state_sp];
2467
2468 VG_(printf)("0x%llx-1: ", (ULong)ctx->loc);
2469
2470 if (ctxs->cfa_reg == SP_REG) {
2471 VG_(printf)("SP/CFA=%d+SP ", ctxs->cfa_off);
2472 } else
2473 if (ctxs->cfa_reg == FP_REG) {
2474 VG_(printf)("SP/CFA=%d+FP ", ctxs->cfa_off);
2475 } else {
2476 VG_(printf)("SP/CFA=unknown ");
2477 }
2478
2479 VG_(printf)("RA=");
2480 ppRegRule( ctx->exprs, &ctxs->reg[ctx->ra_reg] );
2481
2482 VG_(printf)("FP=");
2483 ppRegRule( ctx->exprs, &ctxs->reg[FP_REG] );
2484 VG_(printf)("\n");
2485 }
2486
2487
2488 /* ------------ Pick apart DWARF2 byte streams ------------ */
2489
read_le_u_encoded_literal(UChar * data,UInt size)2490 static ULong read_le_u_encoded_literal ( UChar* data, UInt size )
2491 {
2492 switch (size) {
2493 case 8: return (ULong)ML_(read_ULong)( data );
2494 case 4: return (ULong)ML_(read_UInt)( data );
2495 case 2: return (ULong)ML_(read_UShort)( data );
2496 case 1: return (ULong)ML_(read_UChar)( data );
2497 default: vg_assert(0); /*NOTREACHED*/ return 0;
2498 }
2499 }
2500
read_le_s_encoded_literal(UChar * data,UInt size)2501 static Long read_le_s_encoded_literal ( UChar* data, UInt size )
2502 {
2503 Long s64 = read_le_u_encoded_literal( data, size );
2504 switch (size) {
2505 case 8: break;
2506 case 4: s64 <<= 32; s64 >>= 32; break;
2507 case 2: s64 <<= 48; s64 >>= 48; break;
2508 case 1: s64 <<= 56; s64 >>= 56; break;
2509 default: vg_assert(0); /*NOTREACHED*/ return 0;
2510 }
2511 return s64;
2512 }
2513
default_Addr_encoding(void)2514 static UChar default_Addr_encoding ( void )
2515 {
2516 switch (sizeof(Addr)) {
2517 case 4: return DW_EH_PE_udata4;
2518 case 8: return DW_EH_PE_udata8;
2519 default: vg_assert(0);
2520 }
2521 }
2522
size_of_encoded_Addr(UChar encoding)2523 static UInt size_of_encoded_Addr ( UChar encoding )
2524 {
2525 if (encoding == DW_EH_PE_omit)
2526 return 0;
2527
2528 switch (encoding & 0x07) {
2529 case DW_EH_PE_absptr: return sizeof(Addr);
2530 case DW_EH_PE_udata2: return sizeof(UShort);
2531 case DW_EH_PE_udata4: return sizeof(UInt);
2532 case DW_EH_PE_udata8: return sizeof(ULong);
2533 default: vg_assert(0);
2534 }
2535 }
2536
read_encoded_Addr(Int * nbytes,AddressDecodingInfo * adi,UChar * data)2537 static Addr read_encoded_Addr ( /*OUT*/Int* nbytes,
2538 AddressDecodingInfo* adi,
2539 UChar* data )
2540 {
2541 /* Regarding the handling of DW_EH_PE_absptr. DWARF3 says this
2542 denotes an absolute address, hence you would think 'base' is
2543 zero. However, that is nonsensical (unless relocations are to
2544 be applied to the unwind data before reading it, which sounds
2545 unlikely). My interpretation is that DW_EH_PE_absptr indicates
2546 an address relative to where the object was loaded (technically,
2547 relative to its stated load VMA, hence the use of text_bias
2548 rather than text_avma). Hmm, should we use text_bias or
2549 text_avma here? Not sure.
2550
2551 This view appears to be supported by DWARF3 spec sec 7.3
2552 "Executable Objects and Shared Objects":
2553
2554 This requirement makes the debugging information for shared
2555 objects position independent. Virtual addresses in a shared
2556 object may be calculated by adding the offset to the base
2557 address at which the object was attached. This offset is
2558 available in the run-time linker's data structures.
2559 */
2560 Addr base;
2561 Word offset;
2562 UChar encoding = adi->encoding;
2563 UChar* ehframe_image = adi->ehframe_image;
2564 Addr ehframe_avma = adi->ehframe_avma;
2565
2566 vg_assert((encoding & DW_EH_PE_indirect) == 0);
2567
2568 *nbytes = 0;
2569
2570 switch (encoding & 0x70) {
2571 case DW_EH_PE_absptr:
2572 base = adi->text_bias;
2573 break;
2574 case DW_EH_PE_pcrel:
2575 base = ehframe_avma + ( data - ehframe_image );
2576 break;
2577 case DW_EH_PE_datarel:
2578 vg_assert(0);
2579 base = /* data base address */ 0;
2580 break;
2581 case DW_EH_PE_textrel:
2582 vg_assert(0);
2583 base = /* text base address */ 0;
2584 break;
2585 case DW_EH_PE_funcrel:
2586 base = 0;
2587 break;
2588 case DW_EH_PE_aligned:
2589 base = 0;
2590 offset = data - ehframe_image;
2591 if ((offset % sizeof(Addr)) != 0) {
2592 *nbytes = sizeof(Addr) - (offset % sizeof(Addr));
2593 data += *nbytes;
2594 }
2595 break;
2596 default:
2597 vg_assert(0);
2598 }
2599
2600 if ((encoding & 0x07) == 0x00)
2601 encoding |= default_Addr_encoding();
2602
2603 switch (encoding & 0x0f) {
2604 case DW_EH_PE_udata2:
2605 *nbytes += sizeof(UShort);
2606 return base + ML_(read_UShort)(data);
2607 case DW_EH_PE_udata4:
2608 *nbytes += sizeof(UInt);
2609 return base + ML_(read_UInt)(data);
2610 case DW_EH_PE_udata8:
2611 *nbytes += sizeof(ULong);
2612 return base + ML_(read_ULong)(data);
2613 case DW_EH_PE_sdata2:
2614 *nbytes += sizeof(Short);
2615 return base + ML_(read_Short)(data);
2616 case DW_EH_PE_sdata4:
2617 *nbytes += sizeof(Int);
2618 return base + ML_(read_Int)(data);
2619 case DW_EH_PE_sdata8:
2620 *nbytes += sizeof(Long);
2621 return base + ML_(read_Long)(data);
2622 default:
2623 vg_assert2(0, "read encoded address %d\n", encoding & 0x0f);
2624 }
2625 }
2626
2627
2628 /* ------------ Run/show DWARF3 expressions ---------- */
2629
2630 /* Convert the DWARF3 expression in expr[0 .. exprlen-1] into a dag
2631 (of CfiExprs) stored in ctx->exprs, and return the index in
2632 ctx->exprs of the root node. Or fail in which case return -1. */
2633 /* IMPORTANT: when adding expression forms here, also remember to
2634 add suitable evaluation code in evalCfiExpr in debuginfo.c. */
dwarfexpr_to_dag(UnwindContext * ctx,UChar * expr,Int exprlen,Bool push_cfa_at_start,Bool ddump_frames)2635 static Int dwarfexpr_to_dag ( UnwindContext* ctx,
2636 UChar* expr, Int exprlen,
2637 Bool push_cfa_at_start,
2638 Bool ddump_frames )
2639 {
2640 # define N_EXPR_STACK 20
2641
2642 # define PUSH(_arg) \
2643 do { \
2644 vg_assert(sp >= -1 && sp < N_EXPR_STACK); \
2645 if (sp == N_EXPR_STACK-1) \
2646 return -1; \
2647 sp++; \
2648 stack[sp] = (_arg); \
2649 } while (0)
2650
2651 # define POP(_lval) \
2652 do { \
2653 vg_assert(sp >= -1 && sp < N_EXPR_STACK); \
2654 if (sp == -1) \
2655 return -1; \
2656 _lval = stack[sp]; \
2657 sp--; \
2658 } while (0)
2659
2660 Int ix, ix2, reg;
2661 UChar opcode;
2662 Word sw;
2663 UWord uw;
2664 CfiOp op;
2665 HChar* opname;
2666
2667 Int sp; /* # of top element: valid is -1 .. N_EXPR_STACK-1 */
2668 Int stack[N_EXPR_STACK]; /* indices into ctx->exprs */
2669 struct UnwindContextState* ctxs = &ctx->state[ctx->state_sp];
2670
2671 XArray* dst = ctx->exprs;
2672 UChar* limit = expr + exprlen;
2673
2674 vg_assert(dst);
2675 vg_assert(exprlen >= 0);
2676
2677 sp = -1; /* empty */
2678
2679 /* Synthesise the CFA as a CfiExpr */
2680 if (push_cfa_at_start) {
2681 if (ctxs->cfa_is_regoff) {
2682 /* cfa is reg +/- offset */
2683 ix = ML_(CfiExpr_Binop)( dst,
2684 Cop_Add,
2685 ML_(CfiExpr_DwReg)( dst, ctxs->cfa_reg ),
2686 ML_(CfiExpr_Const)( dst, (UWord)(Word)ctxs->cfa_off )
2687 );
2688 PUSH(ix);
2689 } else {
2690 /* CFA is already an expr; use its root node */
2691 PUSH(ctxs->cfa_expr_ix);
2692 }
2693 }
2694
2695 while (True) {
2696
2697 vg_assert(sp >= -1 && sp < N_EXPR_STACK);
2698
2699 if (expr > limit)
2700 return -1; /* overrun - something's wrong */
2701
2702 if (expr == limit) {
2703 /* end of expr - return expr on the top of stack. */
2704 if (sp == -1)
2705 return -1; /* stack empty. Bad. */
2706 else
2707 break;
2708 }
2709
2710 op = 0; opname = NULL; /* excessively conservative */
2711
2712 opcode = *expr++;
2713 switch (opcode) {
2714
2715 case DW_OP_lit0 ... DW_OP_lit31:
2716 /* push: literal 0 .. 31 */
2717 sw = (Word)opcode - (Word)DW_OP_lit0;
2718 vg_assert(sw >= 0 && sw <= 31);
2719 PUSH( ML_(CfiExpr_Const)( dst, (UWord)sw ) );
2720 if (ddump_frames)
2721 VG_(printf)("DW_OP_lit%ld", sw);
2722 break;
2723
2724 case DW_OP_breg0 ... DW_OP_breg31:
2725 /* push: reg + sleb128 */
2726 reg = (Int)opcode - (Int)DW_OP_breg0;
2727 vg_assert(reg >= 0 && reg <= 31);
2728 sw = read_leb128S( &expr );
2729 ix = ML_(CfiExpr_Binop)( dst,
2730 Cop_Add,
2731 ML_(CfiExpr_DwReg)( dst, reg ),
2732 ML_(CfiExpr_Const)( dst, (UWord)sw )
2733 );
2734 PUSH(ix);
2735 if (ddump_frames)
2736 VG_(printf)("DW_OP_breg%d: %ld", reg, sw);
2737 break;
2738
2739 case DW_OP_reg0 ... DW_OP_reg31:
2740 /* push: reg */
2741 reg = (Int)opcode - (Int)DW_OP_reg0;
2742 vg_assert(reg >= 0 && reg <= 31);
2743 ix = ML_(CfiExpr_DwReg)( dst, reg );
2744 PUSH(ix);
2745 if (ddump_frames)
2746 VG_(printf)("DW_OP_reg%d", reg);
2747 break;
2748
2749 case DW_OP_plus_uconst:
2750 uw = read_leb128U( &expr );
2751 PUSH( ML_(CfiExpr_Const)( dst, uw ) );
2752 POP( ix );
2753 POP( ix2 );
2754 PUSH( ML_(CfiExpr_Binop)( dst, op, ix2, ix ) );
2755 if (ddump_frames)
2756 VG_(printf)("DW_OP_plus_uconst: %lu", uw);
2757 break;
2758
2759 case DW_OP_const4s:
2760 /* push: 32-bit signed immediate */
2761 sw = read_le_s_encoded_literal( expr, 4 );
2762 expr += 4;
2763 PUSH( ML_(CfiExpr_Const)( dst, (UWord)sw ) );
2764 if (ddump_frames)
2765 VG_(printf)("DW_OP_const4s: %ld", sw);
2766 break;
2767
2768 case DW_OP_const1s:
2769 /* push: 8-bit signed immediate */
2770 sw = read_le_s_encoded_literal( expr, 1 );
2771 expr += 1;
2772 PUSH( ML_(CfiExpr_Const)( dst, (UWord)sw ) );
2773 if (ddump_frames)
2774 VG_(printf)("DW_OP_const1s: %ld", sw);
2775 break;
2776
2777 case DW_OP_minus:
2778 op = Cop_Sub; opname = "minus"; goto binop;
2779 case DW_OP_plus:
2780 op = Cop_Add; opname = "plus"; goto binop;
2781 case DW_OP_and:
2782 op = Cop_And; opname = "and"; goto binop;
2783 case DW_OP_mul:
2784 op = Cop_Mul; opname = "mul"; goto binop;
2785 case DW_OP_shl:
2786 op = Cop_Shl; opname = "shl"; goto binop;
2787 case DW_OP_shr:
2788 op = Cop_Shr; opname = "shr"; goto binop;
2789 case DW_OP_eq:
2790 op = Cop_Eq; opname = "eq"; goto binop;
2791 case DW_OP_ge:
2792 op = Cop_Ge; opname = "ge"; goto binop;
2793 case DW_OP_gt:
2794 op = Cop_Gt; opname = "gt"; goto binop;
2795 case DW_OP_le:
2796 op = Cop_Le; opname = "le"; goto binop;
2797 case DW_OP_lt:
2798 op = Cop_Lt; opname = "lt"; goto binop;
2799 case DW_OP_ne:
2800 op = Cop_Ne; opname = "ne"; goto binop;
2801 binop:
2802 POP( ix );
2803 POP( ix2 );
2804 PUSH( ML_(CfiExpr_Binop)( dst, op, ix2, ix ) );
2805 if (ddump_frames)
2806 VG_(printf)("DW_OP_%s", opname);
2807 break;
2808
2809 case DW_OP_deref:
2810 POP( ix );
2811 PUSH( ML_(CfiExpr_Deref)( dst, ix ) );
2812 if (ddump_frames)
2813 VG_(printf)("DW_OP_deref");
2814 break;
2815
2816 default:
2817 if (!VG_(clo_xml))
2818 VG_(message)(Vg_DebugMsg,
2819 "Warning: DWARF2 CFI reader: unhandled DW_OP_ "
2820 "opcode 0x%x\n", (Int)opcode);
2821 return -1;
2822 }
2823
2824 if (expr < limit && ddump_frames)
2825 VG_(printf)("; ");
2826
2827 }
2828
2829 vg_assert(sp >= -1 && sp < N_EXPR_STACK);
2830 if (sp == -1)
2831 return -1;
2832
2833 if (0 && ddump_frames)
2834 ML_(ppCfiExpr)( dst, stack[sp] );
2835 return stack[sp];
2836
2837 # undef POP
2838 # undef PUSH
2839 # undef N_EXPR_STACK
2840 }
2841
2842
2843 /* ------------ Run/show CFI instructions ------------ */
2844
2845 /* Run a CFI instruction, and also return its length.
2846 Returns 0 if the instruction could not be executed.
2847 */
run_CF_instruction(UnwindContext * ctx,UChar * instr,UnwindContext * restore_ctx,AddressDecodingInfo * adi,struct _DebugInfo * di)2848 static Int run_CF_instruction ( /*MOD*/UnwindContext* ctx,
2849 UChar* instr,
2850 UnwindContext* restore_ctx,
2851 AddressDecodingInfo* adi,
2852 struct _DebugInfo* di )
2853 {
2854 Int off, reg, reg2, nleb, len;
2855 UInt delta;
2856 UChar* expr;
2857 Int j;
2858 Int i = 0;
2859 UChar hi2 = (instr[i] >> 6) & 3;
2860 UChar lo6 = instr[i] & 0x3F;
2861 Addr printing_bias = ((Addr)ctx->initloc) - ((Addr)di->text_bias);
2862 struct UnwindContextState* ctxs;
2863 i++;
2864
2865 if (ctx->state_sp < 0 || ctx->state_sp >= N_RR_STACK)
2866 return 0; /* bogus reg-rule stack pointer */
2867
2868 ctxs = &ctx->state[ctx->state_sp];
2869 if (hi2 == DW_CFA_advance_loc) {
2870 delta = (UInt)lo6;
2871 delta *= ctx->code_a_f;
2872 ctx->loc += delta;
2873 if (di->ddump_frames)
2874 VG_(printf)(" DW_CFA_advance_loc: %d to %08lx\n",
2875 (Int)delta, (Addr)ctx->loc + printing_bias);
2876 return i;
2877 }
2878
2879 if (hi2 == DW_CFA_offset) {
2880 /* Set rule for reg 'lo6' to CFAOff(off * data_af) */
2881 off = read_leb128( &instr[i], &nleb, 0 );
2882 i += nleb;
2883 reg = (Int)lo6;
2884 if (reg < 0 || reg >= N_CFI_REGS)
2885 return 0; /* fail */
2886 ctxs->reg[reg].tag = RR_CFAOff;
2887 ctxs->reg[reg].arg = off * ctx->data_a_f;
2888 if (di->ddump_frames)
2889 VG_(printf)(" DW_CFA_offset: r%d at cfa%s%d\n",
2890 (Int)reg,
2891 ctxs->reg[reg].arg < 0 ? "" : "+",
2892 (Int)ctxs->reg[reg].arg );
2893 return i;
2894 }
2895
2896 if (hi2 == DW_CFA_restore) {
2897 reg = (Int)lo6;
2898 if (reg < 0 || reg >= N_CFI_REGS)
2899 return 0; /* fail */
2900 if (restore_ctx == NULL)
2901 return 0; /* fail */
2902 ctxs->reg[reg] = restore_ctx->state[restore_ctx->state_sp].reg[reg];
2903 if (di->ddump_frames)
2904 VG_(printf)(" DW_CFA_restore: r%d\n", (Int)reg);
2905 return i;
2906 }
2907
2908 vg_assert(hi2 == DW_CFA_use_secondary);
2909
2910 switch (lo6) {
2911 case DW_CFA_nop:
2912 if (di->ddump_frames)
2913 VG_(printf)(" DW_CFA_nop\n");
2914 break;
2915 case DW_CFA_set_loc:
2916 /* WAS:
2917 ctx->loc = read_Addr(&instr[i]) - ctx->initloc; i+= sizeof(Addr);
2918 Was this ever right? */
2919 /* 2007 Feb 23: No. binutils/dwarf.c treats it as an encoded
2920 address and that appears to be in accordance with the
2921 DWARF3 spec. */
2922 ctx->loc = read_encoded_Addr(&len, adi, &instr[i]);
2923 i += len;
2924 if (di->ddump_frames)
2925 VG_(printf)(" rci:DW_CFA_set_loc\n");
2926 break;
2927 case DW_CFA_advance_loc1:
2928 delta = (UInt)ML_(read_UChar)(&instr[i]); i+= sizeof(UChar);
2929 delta *= ctx->code_a_f;
2930 ctx->loc += delta;
2931 if (di->ddump_frames)
2932 VG_(printf)(" DW_CFA_advance_loc1: %d to %08lx\n",
2933 (Int)delta, (Addr)ctx->loc + printing_bias);
2934 break;
2935 case DW_CFA_advance_loc2:
2936 delta = (UInt)ML_(read_UShort)(&instr[i]); i+= sizeof(UShort);
2937 delta *= ctx->code_a_f;
2938 ctx->loc += delta;
2939 if (di->ddump_frames)
2940 VG_(printf)(" DW_CFA_advance_loc2: %d to %08lx\n",
2941 (Int)delta, (Addr)ctx->loc + printing_bias);
2942 break;
2943 case DW_CFA_advance_loc4:
2944 delta = (UInt)ML_(read_UInt)(&instr[i]); i+= sizeof(UInt);
2945 delta *= ctx->code_a_f;
2946 ctx->loc += delta;
2947 if (di->ddump_frames)
2948 VG_(printf)(" DW_CFA_advance_loc4: %d to %08lx\n",
2949 (Int)delta, (Addr)ctx->loc + printing_bias);
2950 break;
2951
2952 case DW_CFA_def_cfa:
2953 reg = read_leb128( &instr[i], &nleb, 0 );
2954 i += nleb;
2955 off = read_leb128( &instr[i], &nleb, 0 );
2956 i += nleb;
2957 if (reg < 0 || reg >= N_CFI_REGS)
2958 return 0; /* fail */
2959 ctxs->cfa_is_regoff = True;
2960 ctxs->cfa_expr_ix = 0;
2961 ctxs->cfa_reg = reg;
2962 ctxs->cfa_off = off;
2963 if (di->ddump_frames)
2964 VG_(printf)(" DW_CFA_def_cfa: r%d ofs %d\n", (Int)reg, (Int)off);
2965 break;
2966
2967 case DW_CFA_def_cfa_sf:
2968 reg = read_leb128( &instr[i], &nleb, 0 );
2969 i += nleb;
2970 off = read_leb128( &instr[i], &nleb, 1 );
2971 i += nleb;
2972 if (reg < 0 || reg >= N_CFI_REGS)
2973 return 0; /* fail */
2974 ctxs->cfa_is_regoff = True;
2975 ctxs->cfa_expr_ix = 0;
2976 ctxs->cfa_reg = reg;
2977 ctxs->cfa_off = off * ctx->data_a_f;
2978 if (di->ddump_frames)
2979 VG_(printf)(" rci:DW_CFA_def_cfa_sf\n");
2980 break;
2981
2982 case DW_CFA_register:
2983 reg = read_leb128( &instr[i], &nleb, 0);
2984 i += nleb;
2985 reg2 = read_leb128( &instr[i], &nleb, 0);
2986 i += nleb;
2987 if (reg < 0 || reg >= N_CFI_REGS)
2988 return 0; /* fail */
2989 if (reg2 < 0 || reg2 >= N_CFI_REGS)
2990 return 0; /* fail */
2991 ctxs->reg[reg].tag = RR_Reg;
2992 ctxs->reg[reg].arg = reg2;
2993 if (di->ddump_frames)
2994 VG_(printf)(" DW_CFA_register: r%d in r%d\n",
2995 (Int)reg, (Int)reg2);
2996 break;
2997
2998 case DW_CFA_offset_extended:
2999 reg = read_leb128( &instr[i], &nleb, 0 );
3000 i += nleb;
3001 off = read_leb128( &instr[i], &nleb, 0 );
3002 i += nleb;
3003 if (reg < 0 || reg >= N_CFI_REGS)
3004 return 0; /* fail */
3005 ctxs->reg[reg].tag = RR_CFAOff;
3006 ctxs->reg[reg].arg = off * ctx->data_a_f;
3007 if (di->ddump_frames)
3008 VG_(printf)(" rci:DW_CFA_offset_extended\n");
3009 break;
3010
3011 case DW_CFA_offset_extended_sf:
3012 reg = read_leb128( &instr[i], &nleb, 0 );
3013 i += nleb;
3014 off = read_leb128( &instr[i], &nleb, 1 );
3015 i += nleb;
3016 if (reg < 0 || reg >= N_CFI_REGS)
3017 return 0; /* fail */
3018 ctxs->reg[reg].tag = RR_CFAOff;
3019 ctxs->reg[reg].arg = off * ctx->data_a_f;
3020 if (di->ddump_frames)
3021 VG_(printf)(" DW_CFA_offset_extended_sf: r%d at cfa%s%d\n",
3022 reg,
3023 ctxs->reg[reg].arg < 0 ? "" : "+",
3024 (Int)ctxs->reg[reg].arg);
3025 break;
3026
3027 case DW_CFA_GNU_negative_offset_extended:
3028 reg = read_leb128( &instr[i], &nleb, 0 );
3029 i += nleb;
3030 off = read_leb128( &instr[i], &nleb, 0 );
3031 i += nleb;
3032 if (reg < 0 || reg >= N_CFI_REGS)
3033 return 0; /* fail */
3034 ctxs->reg[reg].tag = RR_CFAOff;
3035 ctxs->reg[reg].arg = (-off) * ctx->data_a_f;
3036 if (di->ddump_frames)
3037 VG_(printf)(" rci:DW_CFA_GNU_negative_offset_extended\n");
3038 break;
3039
3040 case DW_CFA_restore_extended:
3041 reg = read_leb128( &instr[i], &nleb, 0 );
3042 i += nleb;
3043 if (reg < 0 || reg >= N_CFI_REGS)
3044 return 0; /* fail */
3045 if (restore_ctx == NULL)
3046 return 0; /* fail */
3047 ctxs->reg[reg] = restore_ctx->state[restore_ctx->state_sp].reg[reg];
3048 if (di->ddump_frames)
3049 VG_(printf)(" rci:DW_CFA_restore_extended\n");
3050 break;
3051
3052 case DW_CFA_val_offset:
3053 reg = read_leb128( &instr[i], &nleb, 0 );
3054 i += nleb;
3055 off = read_leb128( &instr[i], &nleb, 0 );
3056 i += nleb;
3057 if (reg < 0 || reg >= N_CFI_REGS)
3058 return 0; /* fail */
3059 ctxs->reg[reg].tag = RR_CFAValOff;
3060 ctxs->reg[reg].arg = off * ctx->data_a_f;
3061 if (di->ddump_frames)
3062 VG_(printf)(" rci:DW_CFA_val_offset\n");
3063 break;
3064
3065 case DW_CFA_val_offset_sf:
3066 reg = read_leb128( &instr[i], &nleb, 0 );
3067 i += nleb;
3068 off = read_leb128( &instr[i], &nleb, 1 );
3069 i += nleb;
3070 if (reg < 0 || reg >= N_CFI_REGS)
3071 return 0; /* fail */
3072 ctxs->reg[reg].tag = RR_CFAValOff;
3073 ctxs->reg[reg].arg = off * ctx->data_a_f;
3074 if (di->ddump_frames)
3075 VG_(printf)(" rci:DW_CFA_val_offset_sf\n");
3076 break;
3077
3078 case DW_CFA_def_cfa_register:
3079 reg = read_leb128( &instr[i], &nleb, 0);
3080 i += nleb;
3081 if (reg < 0 || reg >= N_CFI_REGS)
3082 return 0; /* fail */
3083 ctxs->cfa_is_regoff = True;
3084 ctxs->cfa_expr_ix = 0;
3085 ctxs->cfa_reg = reg;
3086 /* ->cfa_off unchanged */
3087 if (di->ddump_frames)
3088 VG_(printf)(" DW_CFA_def_cfa_register: r%d\n", (Int)reg );
3089 break;
3090
3091 case DW_CFA_def_cfa_offset:
3092 off = read_leb128( &instr[i], &nleb, 0);
3093 i += nleb;
3094 ctxs->cfa_is_regoff = True;
3095 ctxs->cfa_expr_ix = 0;
3096 /* ->reg is unchanged */
3097 ctxs->cfa_off = off;
3098 if (di->ddump_frames)
3099 VG_(printf)(" DW_CFA_def_cfa_offset: %d\n", (Int)off);
3100 break;
3101
3102 case DW_CFA_def_cfa_offset_sf:
3103 off = read_leb128( &instr[i], &nleb, 1);
3104 i += nleb;
3105 ctxs->cfa_is_regoff = True;
3106 ctxs->cfa_expr_ix = 0;
3107 /* ->reg is unchanged */
3108 ctxs->cfa_off = off * ctx->data_a_f;
3109 if (di->ddump_frames)
3110 VG_(printf)(" DW_CFA_def_cfa_offset_sf: %d\n", ctxs->cfa_off);
3111 break;
3112
3113 case DW_CFA_undefined:
3114 reg = read_leb128( &instr[i], &nleb, 0);
3115 i += nleb;
3116 if (reg < 0 || reg >= N_CFI_REGS)
3117 return 0; /* fail */
3118 ctxs->reg[reg].tag = RR_Undef;
3119 ctxs->reg[reg].arg = 0;
3120 if (di->ddump_frames)
3121 VG_(printf)(" rci:DW_CFA_undefined\n");
3122 break;
3123
3124 case DW_CFA_same_value:
3125 reg = read_leb128( &instr[i], &nleb, 0);
3126 i += nleb;
3127 if (reg < 0 || reg >= N_CFI_REGS)
3128 return 0; /* fail */
3129 ctxs->reg[reg].tag = RR_Same;
3130 ctxs->reg[reg].arg = 0;
3131 if (di->ddump_frames)
3132 VG_(printf)(" rci:DW_CFA_same_value\n");
3133 break;
3134
3135 case DW_CFA_GNU_args_size:
3136 /* No idea what is supposed to happen. gdb-6.3 simply
3137 ignores these. */
3138 /*off = */ read_leb128( &instr[i], &nleb, 0 );
3139 i += nleb;
3140 if (di->ddump_frames)
3141 VG_(printf)(" rci:DW_CFA_GNU_args_size (ignored)\n");
3142 break;
3143
3144 case DW_CFA_expression:
3145 /* Identical to DW_CFA_val_expression except that the value
3146 computed is an address and so needs one final
3147 dereference. */
3148 reg = read_leb128( &instr[i], &nleb, 0 );
3149 i += nleb;
3150 len = read_leb128( &instr[i], &nleb, 0 );
3151 i += nleb;
3152 expr = &instr[i];
3153 i += len;
3154 if (reg < 0 || reg >= N_CFI_REGS)
3155 return 0; /* fail */
3156 if (di->ddump_frames)
3157 VG_(printf)(" DW_CFA_expression: r%d (",
3158 (Int)reg);
3159 /* Convert the expression into a dag rooted at ctx->exprs index j,
3160 or fail. */
3161 j = dwarfexpr_to_dag ( ctx, expr, len, True/*push CFA at start*/,
3162 di->ddump_frames);
3163 if (di->ddump_frames)
3164 VG_(printf)(")\n");
3165 vg_assert(j >= -1);
3166 if (j >= 0) {
3167 vg_assert(ctx->exprs);
3168 vg_assert( j < VG_(sizeXA)(ctx->exprs) );
3169 }
3170 if (j == -1)
3171 return 0; /* fail */
3172 /* Add an extra dereference */
3173 j = ML_(CfiExpr_Deref)( ctx->exprs, j );
3174 ctxs->reg[reg].tag = RR_ValExpr;
3175 ctxs->reg[reg].arg = j;
3176 break;
3177
3178 case DW_CFA_val_expression:
3179 reg = read_leb128( &instr[i], &nleb, 0 );
3180 i += nleb;
3181 len = read_leb128( &instr[i], &nleb, 0 );
3182 i += nleb;
3183 expr = &instr[i];
3184 i += len;
3185 if (reg < 0 || reg >= N_CFI_REGS)
3186 return 0; /* fail */
3187 if (di->ddump_frames)
3188 VG_(printf)(" DW_CFA_val_expression: r%d (",
3189 (Int)reg);
3190 /* Convert the expression into a dag rooted at ctx->exprs index j,
3191 or fail. */
3192 j = dwarfexpr_to_dag ( ctx, expr, len, True/*push CFA at start*/,
3193 di->ddump_frames);
3194 if (di->ddump_frames)
3195 VG_(printf)(")\n");
3196 vg_assert(j >= -1);
3197 if (j >= 0) {
3198 vg_assert(ctx->exprs);
3199 vg_assert( j < VG_(sizeXA)(ctx->exprs) );
3200 }
3201 if (j == -1)
3202 return 0; /* fail */
3203 ctxs->reg[reg].tag = RR_ValExpr;
3204 ctxs->reg[reg].arg = j;
3205 break;
3206
3207 case DW_CFA_def_cfa_expression:
3208 len = read_leb128( &instr[i], &nleb, 0 );
3209 i += nleb;
3210 expr = &instr[i];
3211 i += len;
3212 if (di->ddump_frames)
3213 VG_(printf)(" DW_CFA_def_cfa_expression (");
3214 /* Convert the expression into a dag rooted at ctx->exprs index j,
3215 or fail. */
3216 j = dwarfexpr_to_dag ( ctx, expr, len, True/*push CFA at start*/,
3217 di->ddump_frames);
3218 if (di->ddump_frames)
3219 VG_(printf)(")\n");
3220 ctxs->cfa_is_regoff = False;
3221 ctxs->cfa_reg = 0;
3222 ctxs->cfa_off = 0;
3223 ctxs->cfa_expr_ix = j;
3224 break;
3225
3226 case DW_CFA_GNU_window_save:
3227 /* Ignored. This appears to be sparc-specific; quite why it
3228 turns up in SuSE-supplied x86 .so's beats me. */
3229 if (di->ddump_frames)
3230 VG_(printf)(" DW_CFA_GNU_window_save\n");
3231 break;
3232
3233 case DW_CFA_remember_state:
3234 if (di->ddump_frames)
3235 VG_(printf)(" DW_CFA_remember_state\n");
3236 /* we just checked this at entry, so: */
3237 vg_assert(ctx->state_sp >= 0 && ctx->state_sp < N_RR_STACK);
3238 ctx->state_sp++;
3239 if (ctx->state_sp == N_RR_STACK) {
3240 /* stack overflow. We're hosed. */
3241 VG_(message)(Vg_DebugMsg, "DWARF2 CFI reader: N_RR_STACK is "
3242 "too low; increase and recompile.");
3243 i = 0; /* indicate failure */
3244 } else {
3245 VG_(memcpy)(/*dst*/&ctx->state[ctx->state_sp],
3246 /*src*/&ctx->state[ctx->state_sp - 1],
3247 sizeof(ctx->state[ctx->state_sp]) );
3248 }
3249 break;
3250
3251 case DW_CFA_restore_state:
3252 if (di->ddump_frames)
3253 VG_(printf)(" DW_CFA_restore_state\n");
3254 /* we just checked this at entry, so: */
3255 vg_assert(ctx->state_sp >= 0 && ctx->state_sp < N_RR_STACK);
3256 if (ctx->state_sp == 0) {
3257 /* stack overflow. Give up. */
3258 i = 0; /* indicate failure */
3259 } else {
3260 /* simply fall back to previous entry */
3261 ctx->state_sp--;
3262 }
3263 break;
3264
3265 default:
3266 VG_(message)(Vg_DebugMsg, "DWARF2 CFI reader: unhandled CFI "
3267 "instruction 0:%d\n", (Int)lo6);
3268 if (di->ddump_frames)
3269 VG_(printf)(" rci:run_CF_instruction:default\n");
3270 i = 0;
3271 break;
3272 }
3273
3274 return i;
3275 }
3276
3277
3278 /* Show a CFI instruction, and also return its length. Show it as
3279 close as possible (preferably identical) to how GNU binutils
3280 readelf --debug-dump=frames would. */
3281
show_CF_instruction(UChar * instr,AddressDecodingInfo * adi,Int code_a_f,Int data_a_f)3282 static Int show_CF_instruction ( UChar* instr,
3283 AddressDecodingInfo* adi,
3284 Int code_a_f, Int data_a_f )
3285 {
3286 UInt delta;
3287 Int off, coff, reg, reg2, nleb, len;
3288 Addr loc;
3289 Int i = 0;
3290 UChar hi2 = (instr[i] >> 6) & 3;
3291 UChar lo6 = instr[i] & 0x3F;
3292 i++;
3293
3294 if (0) VG_(printf)("raw:%x/%x:%x:%x:%x:%x:%x:%x:%x:%x\n",
3295 hi2, lo6,
3296 instr[i+0], instr[i+1], instr[i+2], instr[i+3],
3297 instr[i+4], instr[i+5], instr[i+6], instr[i+7] );
3298
3299 if (hi2 == DW_CFA_advance_loc) {
3300 VG_(printf)(" sci:DW_CFA_advance_loc(%d)\n", (Int)lo6);
3301 return i;
3302 }
3303
3304 if (hi2 == DW_CFA_offset) {
3305 off = read_leb128( &instr[i], &nleb, 0 );
3306 i += nleb;
3307 coff = off * data_a_f;
3308 VG_(printf)(" DW_CFA_offset: r%d at cfa%s%d\n",
3309 (Int)lo6, coff < 0 ? "" : "+", (Int)coff );
3310 return i;
3311 }
3312
3313 if (hi2 == DW_CFA_restore) {
3314 VG_(printf)(" sci:DW_CFA_restore(r%d)\n", (Int)lo6);
3315 return i;
3316 }
3317
3318 vg_assert(hi2 == DW_CFA_use_secondary);
3319
3320 switch (lo6) {
3321
3322 case DW_CFA_nop:
3323 VG_(printf)(" DW_CFA_nop\n");
3324 break;
3325
3326 case DW_CFA_set_loc:
3327 /* WAS: loc = read_Addr(&instr[i]); i+= sizeof(Addr);
3328 (now known to be incorrect -- the address is encoded) */
3329 loc = read_encoded_Addr(&len, adi, &instr[i]);
3330 i += len;
3331 VG_(printf)(" sci:DW_CFA_set_loc(%#lx)\n", loc);
3332 break;
3333
3334 case DW_CFA_advance_loc1:
3335 delta = (UInt)ML_(read_UChar)(&instr[i]); i+= sizeof(UChar);
3336 VG_(printf)(" sci:DW_CFA_advance_loc1(%d)\n", delta);
3337 break;
3338
3339 case DW_CFA_advance_loc2:
3340 delta = (UInt)ML_(read_UShort)(&instr[i]); i+= sizeof(UShort);
3341 VG_(printf)(" sci:DW_CFA_advance_loc2(%d)\n", delta);
3342 break;
3343
3344 case DW_CFA_advance_loc4:
3345 delta = (UInt)ML_(read_UInt)(&instr[i]); i+= sizeof(UInt);
3346 VG_(printf)(" DW_CFA_advance_loc4(%d)\n", delta);
3347 break;
3348
3349 case DW_CFA_def_cfa:
3350 reg = read_leb128( &instr[i], &nleb, 0 );
3351 i += nleb;
3352 off = read_leb128( &instr[i], &nleb, 0 );
3353 i += nleb;
3354 VG_(printf)(" DW_CFA_def_cfa: r%d ofs %d\n", (Int)reg, (Int)off);
3355 break;
3356
3357 case DW_CFA_def_cfa_sf:
3358 reg = read_leb128( &instr[i], &nleb, 0 );
3359 i += nleb;
3360 off = read_leb128( &instr[i], &nleb, 1 );
3361 i += nleb;
3362 VG_(printf)(" DW_CFA_def_cfa_sf: r%d ofs %d\n",
3363 (Int)reg, (Int)(off * data_a_f));
3364 break;
3365
3366 case DW_CFA_register:
3367 reg = read_leb128( &instr[i], &nleb, 0);
3368 i += nleb;
3369 reg2 = read_leb128( &instr[i], &nleb, 0);
3370 i += nleb;
3371 VG_(printf)(" sci:DW_CFA_register(r%d, r%d)\n", reg, reg2);
3372 break;
3373
3374 case DW_CFA_def_cfa_register:
3375 reg = read_leb128( &instr[i], &nleb, 0);
3376 i += nleb;
3377 VG_(printf)(" sci:DW_CFA_def_cfa_register(r%d)\n", reg);
3378 break;
3379
3380 case DW_CFA_def_cfa_offset:
3381 off = read_leb128( &instr[i], &nleb, 0);
3382 i += nleb;
3383 VG_(printf)(" sci:DW_CFA_def_cfa_offset(%d)\n", off);
3384 break;
3385
3386 case DW_CFA_def_cfa_offset_sf:
3387 off = read_leb128( &instr[i], &nleb, 1);
3388 i += nleb;
3389 VG_(printf)(" sci:DW_CFA_def_cfa_offset_sf(%d)\n", off);
3390 break;
3391
3392 case DW_CFA_restore_extended:
3393 reg = read_leb128( &instr[i], &nleb, 0);
3394 i += nleb;
3395 VG_(printf)(" sci:DW_CFA_restore_extended(r%d)\n", reg);
3396 break;
3397
3398 case DW_CFA_undefined:
3399 reg = read_leb128( &instr[i], &nleb, 0);
3400 i += nleb;
3401 VG_(printf)(" sci:DW_CFA_undefined(r%d)\n", reg);
3402 break;
3403
3404 case DW_CFA_same_value:
3405 reg = read_leb128( &instr[i], &nleb, 0);
3406 i += nleb;
3407 VG_(printf)(" sci:DW_CFA_same_value(r%d)\n", reg);
3408 break;
3409
3410 case DW_CFA_remember_state:
3411 VG_(printf)(" sci:DW_CFA_remember_state\n");
3412 break;
3413
3414 case DW_CFA_restore_state:
3415 VG_(printf)(" sci:DW_CFA_restore_state\n");
3416 break;
3417
3418 case DW_CFA_GNU_args_size:
3419 off = read_leb128( &instr[i], &nleb, 0 );
3420 i += nleb;
3421 VG_(printf)(" sci:DW_CFA_GNU_args_size(%d)\n", off );
3422 break;
3423
3424 case DW_CFA_def_cfa_expression:
3425 len = read_leb128( &instr[i], &nleb, 0 );
3426 i += nleb;
3427 i += len;
3428 VG_(printf)(" sci:DW_CFA_def_cfa_expression(length %d)\n", len);
3429 break;
3430
3431 case DW_CFA_expression:
3432 reg = read_leb128( &instr[i], &nleb, 0 );
3433 i += nleb;
3434 len = read_leb128( &instr[i], &nleb, 0 );
3435 i += nleb;
3436 i += len;
3437 VG_(printf)(" sci:DW_CFA_expression(r%d, length %d)\n", reg, len);
3438 break;
3439
3440 case DW_CFA_val_expression:
3441 reg = read_leb128( &instr[i], &nleb, 0 );
3442 i += nleb;
3443 len = read_leb128( &instr[i], &nleb, 0 );
3444 i += nleb;
3445 i += len;
3446 VG_(printf)(" sci:DW_CFA_val_expression(r%d, length %d)\n", reg, len);
3447 break;
3448
3449 case DW_CFA_offset_extended:
3450 reg = read_leb128( &instr[i], &nleb, 0 );
3451 i += nleb;
3452 off = read_leb128( &instr[i], &nleb, 0 );
3453 i += nleb;
3454 VG_(printf)(" sci:DW_CFA_offset_extended(r%d, "
3455 "off %d x data_af)\n", reg, off);
3456 break;
3457
3458 case DW_CFA_offset_extended_sf:
3459 reg = read_leb128( &instr[i], &nleb, 0 );
3460 i += nleb;
3461 off = read_leb128( &instr[i], &nleb, 1 );
3462 i += nleb;
3463 coff = (Int)(off * data_a_f);
3464 VG_(printf)(" DW_CFA_offset_extended_sf: r%d at cfa%s%d\n",
3465 reg, coff < 0 ? "" : "+", coff);
3466 break;
3467
3468 case DW_CFA_GNU_negative_offset_extended:
3469 reg = read_leb128( &instr[i], &nleb, 0 );
3470 i += nleb;
3471 off = read_leb128( &instr[i], &nleb, 0 );
3472 i += nleb;
3473 VG_(printf)(" sci:DW_CFA_GNU_negative_offset_extended"
3474 "(r%d, off %d x data_af)\n", reg, -off);
3475 break;
3476
3477 case DW_CFA_val_offset:
3478 reg = read_leb128( &instr[i], &nleb, 0 );
3479 i += nleb;
3480 off = read_leb128( &instr[i], &nleb, 0 );
3481 i += nleb;
3482 VG_(printf)(" sci:DW_CFA_val_offset(r%d, off %d x data_af)\n",
3483 reg, off);
3484 break;
3485
3486 case DW_CFA_val_offset_sf:
3487 reg = read_leb128( &instr[i], &nleb, 0 );
3488 i += nleb;
3489 off = read_leb128( &instr[i], &nleb, 1 );
3490 i += nleb;
3491 VG_(printf)(" sci:DW_CFA_val_offset_sf(r%d, off %d x data_af)\n",
3492 reg, off);
3493 break;
3494
3495 case DW_CFA_GNU_window_save:
3496 VG_(printf)(" sci:DW_CFA_GNU_window_save\n");
3497 break;
3498
3499 default:
3500 VG_(printf)(" sci:0:%d\n", (Int)lo6);
3501 break;
3502 }
3503
3504 return i;
3505 }
3506
3507
3508 /* Show the instructions in instrs[0 .. ilen-1]. */
show_CF_instructions(UChar * instrs,Int ilen,AddressDecodingInfo * adi,Int code_a_f,Int data_a_f)3509 static void show_CF_instructions ( UChar* instrs, Int ilen,
3510 AddressDecodingInfo* adi,
3511 Int code_a_f, Int data_a_f )
3512 {
3513 Int i = 0;
3514 while (True) {
3515 if (i >= ilen) break;
3516 i += show_CF_instruction( &instrs[i], adi, code_a_f, data_a_f );
3517 }
3518 }
3519
3520
3521 /* Run the CF instructions in instrs[0 .. ilen-1], until the end is
3522 reached, or until there is a failure. Return True iff success.
3523 */
3524 static
run_CF_instructions(struct _DebugInfo * di,Bool record,UnwindContext * ctx,UChar * instrs,Int ilen,UWord fde_arange,UnwindContext * restore_ctx,AddressDecodingInfo * adi)3525 Bool run_CF_instructions ( struct _DebugInfo* di,
3526 Bool record,
3527 UnwindContext* ctx, UChar* instrs, Int ilen,
3528 UWord fde_arange,
3529 UnwindContext* restore_ctx,
3530 AddressDecodingInfo* adi )
3531 {
3532 DiCfSI cfsi;
3533 Bool summ_ok;
3534 Int j, i = 0;
3535 Addr loc_prev;
3536 if (0) ppUnwindContext(ctx);
3537 if (0) ppUnwindContext_summary(ctx);
3538 while (True) {
3539 loc_prev = ctx->loc;
3540 if (i >= ilen) break;
3541 if (0) (void)show_CF_instruction( &instrs[i], adi,
3542 ctx->code_a_f, ctx->data_a_f );
3543 j = run_CF_instruction( ctx, &instrs[i], restore_ctx, adi, di );
3544 if (j == 0)
3545 return False; /* execution failed */
3546 i += j;
3547 if (0) ppUnwindContext(ctx);
3548 if (record && loc_prev != ctx->loc) {
3549 summ_ok = summarise_context ( &cfsi, loc_prev, ctx, di );
3550 if (summ_ok) {
3551 ML_(addDiCfSI)(di, &cfsi);
3552 if (di->trace_cfi)
3553 ML_(ppDiCfSI)(di->cfsi_exprs, &cfsi);
3554 }
3555 }
3556 }
3557 if (ctx->loc < fde_arange) {
3558 loc_prev = ctx->loc;
3559 ctx->loc = fde_arange;
3560 if (record) {
3561 summ_ok = summarise_context ( &cfsi, loc_prev, ctx, di );
3562 if (summ_ok) {
3563 ML_(addDiCfSI)(di, &cfsi);
3564 if (di->trace_cfi)
3565 ML_(ppDiCfSI)(di->cfsi_exprs, &cfsi);
3566 }
3567 }
3568 }
3569 return True;
3570 }
3571
3572
3573 /* ------------ Main entry point for CFI reading ------------ */
3574
3575 typedef
3576 struct {
3577 /* This gives the CIE an identity to which FDEs will refer. */
3578 ULong offset;
3579 /* Code, data factors. */
3580 Int code_a_f;
3581 Int data_a_f;
3582 /* Return-address pseudo-register. */
3583 Int ra_reg;
3584 UChar address_encoding;
3585 /* Where are the instrs? Note, this are simply pointers back to
3586 the transiently-mapped-in section. */
3587 UChar* instrs;
3588 Int ilen;
3589 /* God knows .. don't ask */
3590 Bool saw_z_augmentation;
3591 }
3592 CIE;
3593
init_CIE(CIE * cie)3594 static void init_CIE ( CIE* cie )
3595 {
3596 cie->offset = 0;
3597 cie->code_a_f = 0;
3598 cie->data_a_f = 0;
3599 cie->ra_reg = 0;
3600 cie->address_encoding = 0;
3601 cie->instrs = NULL;
3602 cie->ilen = 0;
3603 cie->saw_z_augmentation = False;
3604 }
3605
3606 #ifdef VGP_arm_linux_android
3607 #define N_CIEs 8000
3608 #else
3609 #define N_CIEs 4000
3610 #endif
3611 static CIE the_CIEs[N_CIEs];
3612
3613
3614 /* Read, summarise and store CFA unwind info from .eh_frame and
3615 .debug_frame sections. is_ehframe tells us which kind we are
3616 dealing with -- they are slightly different. */
ML_(read_callframe_info_dwarf3)3617 void ML_(read_callframe_info_dwarf3)
3618 ( /*OUT*/struct _DebugInfo* di,
3619 UChar* frame_image, SizeT frame_size, Addr frame_avma,
3620 Bool is_ehframe )
3621 {
3622 Int nbytes;
3623 HChar* how = NULL;
3624 Int n_CIEs = 0;
3625 UChar* data = frame_image;
3626 UWord cfsi_used_orig;
3627
3628 /* If we're dealing with a .debug_frame, assume zero frame_avma. */
3629 if (!is_ehframe)
3630 vg_assert(frame_avma == 0);
3631
3632 # if defined(VGP_ppc32_linux) || defined(VGP_ppc64_linux)
3633 /* These targets don't use CFI-based stack unwinding. */
3634 return;
3635 # endif
3636
3637 /* If we read more than one .debug_frame or .eh_frame for this
3638 DebugInfo*, the second and subsequent reads should only add FDEs
3639 for address ranges not already covered by the FDEs already
3640 present. To be able to quickly check which address ranges are
3641 already present, any existing records (DiCFSIs) must be sorted,
3642 so we can binary-search them in the code below. We also record
3643 di->cfsi_used so that we know where the boundary is between
3644 existing and new records. */
3645 if (di->cfsi_used > 0) {
3646 ML_(canonicaliseCFI) ( di );
3647 }
3648 cfsi_used_orig = di->cfsi_used;
3649
3650 if (di->trace_cfi) {
3651 VG_(printf)("\n-----------------------------------------------\n");
3652 VG_(printf)("CFI info: szB %ld, _avma %#lx, _image %p\n",
3653 frame_size, frame_avma, frame_image );
3654 VG_(printf)("CFI info: name %s\n",
3655 di->fsm.filename );
3656 }
3657
3658 /* Loop over CIEs/FDEs */
3659
3660 /* Conceptually, the frame info is a sequence of FDEs, one for each
3661 function. Inside an FDE is a miniature program for a special
3662 state machine, which, when run, produces the stack-unwinding
3663 info for that function.
3664
3665 Because the FDEs typically have much in common, and because the
3666 DWARF designers appear to have been fanatical about space
3667 saving, the common parts are factored out into so-called CIEs.
3668 That means that what we traverse is a sequence of structs, each
3669 of which is either a FDE (usually) or a CIE (occasionally).
3670 Each FDE has a field indicating which CIE is the one pertaining
3671 to it.
3672
3673 The following loop traverses the sequence. FDEs are dealt with
3674 immediately; once we harvest the useful info in an FDE, it is
3675 then forgotten about. By contrast, CIEs are validated and
3676 dumped into an array, because later FDEs may refer to any
3677 previously-seen CIE.
3678 */
3679 while (True) {
3680 UChar* ciefde_start;
3681 ULong ciefde_len;
3682 ULong cie_pointer;
3683 Bool dw64;
3684
3685 /* Are we done? */
3686 if (data == frame_image + frame_size)
3687 return;
3688
3689 /* Overshot the end? Means something is wrong */
3690 if (data > frame_image + frame_size) {
3691 how = "overran the end of .eh_frame";
3692 goto bad;
3693 }
3694
3695 /* Ok, we must be looking at the start of a new CIE or FDE.
3696 Figure out which it is. */
3697
3698 ciefde_start = data;
3699 if (di->trace_cfi)
3700 VG_(printf)("\ncie/fde.start = %p (frame_image + 0x%lx)\n",
3701 ciefde_start,
3702 ciefde_start - frame_image + 0UL);
3703
3704 ciefde_len = (ULong)ML_(read_UInt)(data); data += sizeof(UInt);
3705 if (di->trace_cfi)
3706 VG_(printf)("cie/fde.length = %lld\n", ciefde_len);
3707
3708 /* Apparently, if the .length field is zero, we are at the end
3709 of the sequence. This is stated in the Generic Elf
3710 Specification (see comments far above here) and is one of the
3711 places where .eh_frame and .debug_frame data differ. */
3712 if (ciefde_len == 0) {
3713 if (di->ddump_frames)
3714 VG_(printf)("%08lx ZERO terminator\n\n",
3715 ((Addr)ciefde_start) - ((Addr)frame_image));
3716 return;
3717 }
3718
3719 /* If the .length field is 0xFFFFFFFF then we're dealing with
3720 64-bit DWARF, and the real length is stored as a 64-bit
3721 number immediately following it. */
3722 dw64 = False;
3723 if (ciefde_len == 0xFFFFFFFFUL) {
3724 dw64 = True;
3725 ciefde_len = ML_(read_ULong)(data); data += sizeof(ULong);
3726 }
3727
3728 /* Now get the CIE ID, whose size depends on the DWARF 32 vs
3729 64-ness. */
3730 if (dw64) {
3731 cie_pointer = ML_(read_ULong)(data);
3732 data += sizeof(ULong); /* XXX see XXX below */
3733 } else {
3734 cie_pointer = (ULong)ML_(read_UInt)(data);
3735 data += sizeof(UInt); /* XXX see XXX below */
3736 }
3737
3738 if (di->trace_cfi)
3739 VG_(printf)("cie.pointer = %lld\n", cie_pointer);
3740
3741 /* If cie_pointer is zero for .eh_frame or all ones for .debug_frame,
3742 we've got a CIE; else it's an FDE. */
3743 if (cie_pointer == (is_ehframe ? 0ULL
3744 : dw64 ? 0xFFFFFFFFFFFFFFFFULL : 0xFFFFFFFFULL)) {
3745
3746 Int this_CIE;
3747 UChar cie_version;
3748 UChar* cie_augmentation;
3749
3750 /* --------- CIE --------- */
3751 if (di->trace_cfi)
3752 VG_(printf)("------ new CIE (#%d of 0 .. %d) ------\n",
3753 n_CIEs, N_CIEs - 1);
3754
3755 /* Allocate a new CIE record. */
3756 vg_assert(n_CIEs >= 0 && n_CIEs <= N_CIEs);
3757 if (n_CIEs == N_CIEs) {
3758 how = "N_CIEs is too low. Increase and recompile.";
3759 goto bad;
3760 }
3761
3762 this_CIE = n_CIEs;
3763 n_CIEs++;
3764 init_CIE( &the_CIEs[this_CIE] );
3765
3766 /* Record its offset. This is how we will find it again
3767 later when looking at an FDE. */
3768 the_CIEs[this_CIE].offset = (ULong)(ciefde_start - frame_image);
3769
3770 if (di->ddump_frames)
3771 VG_(printf)("%08lx %08lx %08lx CIE\n",
3772 ((Addr)ciefde_start) - ((Addr)frame_image),
3773 (Addr)ciefde_len,
3774 (Addr)(UWord)cie_pointer );
3775
3776 cie_version = ML_(read_UChar)(data); data += sizeof(UChar);
3777 if (di->trace_cfi)
3778 VG_(printf)("cie.version = %d\n", (Int)cie_version);
3779 if (di->ddump_frames)
3780 VG_(printf)(" Version: %d\n", (Int)cie_version);
3781 if (cie_version != 1 && cie_version != 3 && cie_version != 4) {
3782 how = "unexpected CIE version (not 1 nor 3 nor 4)";
3783 goto bad;
3784 }
3785
3786 cie_augmentation = data;
3787 data += 1 + VG_(strlen)(cie_augmentation);
3788 if (di->trace_cfi)
3789 VG_(printf)("cie.augment = \"%s\"\n", cie_augmentation);
3790 if (di->ddump_frames)
3791 VG_(printf)(" Augmentation: \"%s\"\n", cie_augmentation);
3792
3793 if (cie_augmentation[0] == 'e' && cie_augmentation[1] == 'h') {
3794 data += sizeof(Addr);
3795 cie_augmentation += 2;
3796 }
3797
3798 if (cie_version >= 4) {
3799 if (ML_(read_UChar)(data) != sizeof(Addr)) {
3800 how = "unexpected address size";
3801 goto bad;
3802 }
3803 data += sizeof(UChar);
3804 if (ML_(read_UChar)(data) != 0) {
3805 how = "unexpected non-zero segment size";
3806 goto bad;
3807 }
3808 data += sizeof(UChar);
3809 }
3810
3811 the_CIEs[this_CIE].code_a_f = read_leb128( data, &nbytes, 0);
3812 data += nbytes;
3813 if (di->trace_cfi)
3814 VG_(printf)("cie.code_af = %d\n",
3815 the_CIEs[this_CIE].code_a_f);
3816 if (di->ddump_frames)
3817 VG_(printf)(" Code alignment factor: %d\n",
3818 (Int)the_CIEs[this_CIE].code_a_f);
3819
3820 the_CIEs[this_CIE].data_a_f = read_leb128( data, &nbytes, 1);
3821 data += nbytes;
3822 if (di->trace_cfi)
3823 VG_(printf)("cie.data_af = %d\n",
3824 the_CIEs[this_CIE].data_a_f);
3825 if (di->ddump_frames)
3826 VG_(printf)(" Data alignment factor: %d\n",
3827 (Int)the_CIEs[this_CIE].data_a_f);
3828
3829 if (cie_version == 1) {
3830 the_CIEs[this_CIE].ra_reg = (Int)ML_(read_UChar)(data);
3831 data += sizeof(UChar);
3832 } else {
3833 the_CIEs[this_CIE].ra_reg = read_leb128( data, &nbytes, 0);
3834 data += nbytes;
3835 }
3836 if (di->trace_cfi)
3837 VG_(printf)("cie.ra_reg = %d\n",
3838 the_CIEs[this_CIE].ra_reg);
3839 if (di->ddump_frames)
3840 VG_(printf)(" Return address column: %d\n",
3841 (Int)the_CIEs[this_CIE].ra_reg);
3842
3843 if (the_CIEs[this_CIE].ra_reg < 0
3844 || the_CIEs[this_CIE].ra_reg >= N_CFI_REGS) {
3845 how = "cie.ra_reg has implausible value";
3846 goto bad;
3847 }
3848
3849 the_CIEs[this_CIE].saw_z_augmentation
3850 = *cie_augmentation == 'z';
3851 if (the_CIEs[this_CIE].saw_z_augmentation) {
3852 UInt length = read_leb128( data, &nbytes, 0);
3853 data += nbytes;
3854 the_CIEs[this_CIE].instrs = data + length;
3855 cie_augmentation++;
3856 if (di->ddump_frames) {
3857 UInt i;
3858 VG_(printf)(" Augmentation data: ");
3859 for (i = 0; i < length; i++)
3860 VG_(printf)(" %02x", (UInt)data[i]);
3861 VG_(printf)("\n");
3862 }
3863 } else {
3864 the_CIEs[this_CIE].instrs = NULL;
3865 }
3866
3867 the_CIEs[this_CIE].address_encoding = default_Addr_encoding();
3868
3869 while (*cie_augmentation) {
3870 switch (*cie_augmentation) {
3871 case 'L':
3872 data++;
3873 cie_augmentation++;
3874 break;
3875 case 'R':
3876 the_CIEs[this_CIE].address_encoding
3877 = ML_(read_UChar)(data); data += sizeof(UChar);
3878 cie_augmentation++;
3879 break;
3880 case 'P':
3881 data += size_of_encoded_Addr( ML_(read_UChar)(data) );
3882 data++;
3883 cie_augmentation++;
3884 break;
3885 case 'S':
3886 cie_augmentation++;
3887 break;
3888 default:
3889 if (the_CIEs[this_CIE].instrs == NULL) {
3890 how = "unhandled cie.augmentation";
3891 goto bad;
3892 }
3893 data = the_CIEs[this_CIE].instrs;
3894 goto done_augmentation;
3895 }
3896 }
3897
3898 done_augmentation:
3899
3900 if (di->trace_cfi)
3901 VG_(printf)("cie.encoding = 0x%x\n",
3902 the_CIEs[this_CIE].address_encoding);
3903
3904 the_CIEs[this_CIE].instrs = data;
3905 the_CIEs[this_CIE].ilen
3906 = ciefde_start + ciefde_len + sizeof(UInt) - data;
3907 if (di->trace_cfi) {
3908 VG_(printf)("cie.instrs = %p\n", the_CIEs[this_CIE].instrs);
3909 VG_(printf)("cie.ilen = %d\n", the_CIEs[this_CIE].ilen);
3910 }
3911
3912 if (the_CIEs[this_CIE].ilen < 0
3913 || the_CIEs[this_CIE].ilen > frame_size) {
3914 how = "implausible # cie initial insns";
3915 goto bad;
3916 }
3917
3918 data += the_CIEs[this_CIE].ilen;
3919
3920 /* Show the CIE's instructions (the preamble for each FDE
3921 that uses this CIE). */
3922 if (di->ddump_frames)
3923 VG_(printf)("\n");
3924
3925 if (di->trace_cfi || di->ddump_frames) {
3926 AddressDecodingInfo adi;
3927 adi.encoding = the_CIEs[this_CIE].address_encoding;
3928 adi.ehframe_image = frame_image;
3929 adi.ehframe_avma = frame_avma;
3930 adi.text_bias = di->text_debug_bias;
3931 show_CF_instructions( the_CIEs[this_CIE].instrs,
3932 the_CIEs[this_CIE].ilen, &adi,
3933 the_CIEs[this_CIE].code_a_f,
3934 the_CIEs[this_CIE].data_a_f );
3935 }
3936
3937 if (di->ddump_frames)
3938 VG_(printf)("\n");
3939
3940 } else {
3941
3942 AddressDecodingInfo adi;
3943 UnwindContext ctx, restore_ctx;
3944 Int cie;
3945 ULong look_for;
3946 Bool ok;
3947 Addr fde_initloc;
3948 UWord fde_arange;
3949 UChar* fde_instrs;
3950 Int fde_ilen;
3951
3952 /* --------- FDE --------- */
3953
3954 /* Find the relevant CIE. The CIE we want is located
3955 cie_pointer bytes back from here. */
3956
3957 /* re sizeof(UInt) / sizeof(ULong), matches XXX above. */
3958 if (is_ehframe)
3959 look_for = (data - (dw64 ? sizeof(ULong) : sizeof(UInt))
3960 - frame_image)
3961 - cie_pointer;
3962 else
3963 look_for = cie_pointer;
3964
3965 for (cie = 0; cie < n_CIEs; cie++) {
3966 if (0) VG_(printf)("look for %lld %lld\n",
3967 look_for, the_CIEs[cie].offset );
3968 if (the_CIEs[cie].offset == look_for)
3969 break;
3970 }
3971 vg_assert(cie >= 0 && cie <= n_CIEs);
3972 if (cie == n_CIEs) {
3973 how = "FDE refers to not-findable CIE";
3974 goto bad;
3975 }
3976
3977 adi.encoding = the_CIEs[cie].address_encoding;
3978 adi.ehframe_image = frame_image;
3979 adi.ehframe_avma = frame_avma;
3980 adi.text_bias = di->text_debug_bias;
3981 fde_initloc = read_encoded_Addr(&nbytes, &adi, data);
3982 data += nbytes;
3983 if (di->trace_cfi)
3984 VG_(printf)("fde.initloc = %#lx\n", fde_initloc);
3985
3986 adi.encoding = the_CIEs[cie].address_encoding & 0xf;
3987 adi.ehframe_image = frame_image;
3988 adi.ehframe_avma = frame_avma;
3989 adi.text_bias = di->text_debug_bias;
3990
3991 /* WAS (incorrectly):
3992 fde_arange = read_encoded_Addr(&nbytes, &adi, data);
3993 data += nbytes;
3994 The following corresponds to what binutils/dwarf.c does:
3995 */
3996 { UInt ptr_size = size_of_encoded_Addr( adi.encoding );
3997 switch (ptr_size) {
3998 case 8: case 4: case 2: case 1:
3999 fde_arange
4000 = (UWord)read_le_u_encoded_literal(data, ptr_size);
4001 data += ptr_size;
4002 break;
4003 default:
4004 how = "unknown arange field encoding in FDE";
4005 goto bad;
4006 }
4007 }
4008
4009 if (di->trace_cfi)
4010 VG_(printf)("fde.arangec = %#lx\n", fde_arange);
4011
4012 if (di->ddump_frames)
4013 VG_(printf)("%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
4014 ((Addr)ciefde_start) - ((Addr)frame_image),
4015 (Addr)ciefde_len,
4016 (Addr)(UWord)cie_pointer,
4017 (Addr)look_for,
4018 ((Addr)fde_initloc) - di->text_debug_bias,
4019 ((Addr)fde_initloc) - di->text_debug_bias + fde_arange);
4020
4021 if (the_CIEs[cie].saw_z_augmentation) {
4022 UInt length = read_leb128( data, &nbytes, 0);
4023 data += nbytes;
4024 if (di->ddump_frames && (length > 0)) {
4025 UInt i;
4026 VG_(printf)(" Augmentation data: ");
4027 for (i = 0; i < length; i++)
4028 VG_(printf)(" %02x", (UInt)data[i]);
4029 VG_(printf)("\n\n");
4030 }
4031 data += length;
4032 }
4033
4034 fde_instrs = data;
4035 fde_ilen = ciefde_start + ciefde_len + sizeof(UInt) - data;
4036 if (di->trace_cfi) {
4037 VG_(printf)("fde.instrs = %p\n", fde_instrs);
4038 VG_(printf)("fde.ilen = %d\n", (Int)fde_ilen);
4039 }
4040
4041 if (fde_ilen < 0 || fde_ilen > frame_size) {
4042 how = "implausible # fde insns";
4043 goto bad;
4044 }
4045
4046 data += fde_ilen;
4047
4048 /* If this object's DebugInfo* had some DiCFSIs from a
4049 previous .eh_frame or .debug_frame read, we must check
4050 that we're not adding a duplicate. */
4051 if (cfsi_used_orig > 0) {
4052 Addr a_mid_lo, a_mid_hi;
4053 Word mid, size,
4054 lo = 0,
4055 hi = cfsi_used_orig-1;
4056 while (True) {
4057 /* current unsearched space is from lo to hi, inclusive. */
4058 if (lo > hi) break; /* not found */
4059 mid = (lo + hi) / 2;
4060 a_mid_lo = di->cfsi[mid].base;
4061 size = di->cfsi[mid].len;
4062 a_mid_hi = a_mid_lo + size - 1;
4063 vg_assert(a_mid_hi >= a_mid_lo);
4064 if (fde_initloc + fde_arange <= a_mid_lo) {
4065 hi = mid-1; continue;
4066 }
4067 if (fde_initloc > a_mid_hi) { lo = mid+1; continue; }
4068 break;
4069 }
4070
4071 /* The range this .debug_frame FDE covers has been already
4072 covered in .eh_frame section. Don't add it from .debug_frame
4073 section again. */
4074 if (lo <= hi)
4075 continue;
4076 }
4077
4078 adi.encoding = the_CIEs[cie].address_encoding;
4079 adi.ehframe_image = frame_image;
4080 adi.ehframe_avma = frame_avma;
4081 adi.text_bias = di->text_debug_bias;
4082
4083 if (di->trace_cfi)
4084 show_CF_instructions( fde_instrs, fde_ilen, &adi,
4085 the_CIEs[cie].code_a_f,
4086 the_CIEs[cie].data_a_f );
4087
4088 initUnwindContext(&ctx);
4089 ctx.code_a_f = the_CIEs[cie].code_a_f;
4090 ctx.data_a_f = the_CIEs[cie].data_a_f;
4091 ctx.initloc = fde_initloc;
4092 ctx.ra_reg = the_CIEs[cie].ra_reg;
4093 ctx.exprs = VG_(newXA)( ML_(dinfo_zalloc), "di.rcid.1",
4094 ML_(dinfo_free),
4095 sizeof(CfiExpr) );
4096 vg_assert(ctx.exprs);
4097
4098 /* Run the CIE's instructions. Ugly hack: if
4099 --debug-dump=frames is in effect, suppress output for
4100 these instructions since they will already have been shown
4101 at the time the CIE was first encountered. Note, not
4102 thread safe - if this reader is ever made threaded, should
4103 fix properly. */
4104 { Bool hack = di->ddump_frames;
4105 di->ddump_frames = False;
4106 initUnwindContext(&restore_ctx);
4107 ok = run_CF_instructions(
4108 di, False, &ctx, the_CIEs[cie].instrs,
4109 the_CIEs[cie].ilen, 0, NULL, &adi
4110 );
4111 di->ddump_frames = hack;
4112 }
4113 /* And now run the instructions for the FDE, starting from
4114 the state created by running the CIE preamble
4115 instructions. */
4116 if (ok) {
4117 restore_ctx = ctx;
4118 ok = run_CF_instructions(
4119 di, True, &ctx, fde_instrs, fde_ilen, fde_arange,
4120 &restore_ctx, &adi
4121 );
4122 if (di->ddump_frames)
4123 VG_(printf)("\n");
4124 }
4125
4126 VG_(deleteXA)( ctx.exprs );
4127 }
4128 }
4129
4130 return;
4131
4132 bad:
4133 if (!VG_(clo_xml) && VG_(clo_verbosity) > 1)
4134 VG_(message)(Vg_UserMsg,
4135 "Warning: %s in DWARF2 CFI reading\n", how);
4136 return;
4137 }
4138
4139 #endif // defined(VGO_linux) || defined(VGO_darwin)
4140
4141 /*--------------------------------------------------------------------*/
4142 /*--- end ---*/
4143 /*--------------------------------------------------------------------*/
4144