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