OpenCores
URL https://opencores.org/ocsvn/open8_urisc/open8_urisc/trunk

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [binutils/] [dwarf.c] - Blame information for rev 161

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 15 khays
/* dwarf.c -- display DWARF contents of a BFD binary file
2
   Copyright 2005, 2006, 2007, 2008, 2009, 2010, 2011
3
   Free Software Foundation, Inc.
4
 
5
   This file is part of GNU Binutils.
6
 
7
   This program is free software; you can redistribute it and/or modify
8
   it under the terms of the GNU General Public License as published by
9
   the Free Software Foundation; either version 3 of the License, or
10
   (at your option) any later version.
11
 
12
   This program is distributed in the hope that it will be useful,
13
   but WITHOUT ANY WARRANTY; without even the implied warranty of
14
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
   GNU General Public License for more details.
16
 
17
   You should have received a copy of the GNU General Public License
18
   along with this program; if not, write to the Free Software
19
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
20
   02110-1301, USA.  */
21
 
22
#include "sysdep.h"
23
#include "libiberty.h"
24
#include "bfd.h"
25
#include "bfd_stdint.h"
26
#include "bucomm.h"
27
#include "elfcomm.h"
28
#include "elf/common.h"
29
#include "dwarf2.h"
30
#include "dwarf.h"
31
 
32
static const char *regname (unsigned int regno, int row);
33
 
34
static int have_frame_base;
35
static int need_base_address;
36
 
37
static unsigned int last_pointer_size = 0;
38
static int warned_about_missing_comp_units = FALSE;
39
 
40
static unsigned int num_debug_info_entries = 0;
41
static debug_info *debug_information = NULL;
42
/* Special value for num_debug_info_entries to indicate
43
   that the .debug_info section could not be loaded/parsed.  */
44
#define DEBUG_INFO_UNAVAILABLE  (unsigned int) -1
45
 
46
int eh_addr_size;
47
 
48
int do_debug_info;
49
int do_debug_abbrevs;
50
int do_debug_lines;
51
int do_debug_pubnames;
52
int do_debug_pubtypes;
53
int do_debug_aranges;
54
int do_debug_ranges;
55
int do_debug_frames;
56
int do_debug_frames_interp;
57
int do_debug_macinfo;
58
int do_debug_str;
59
int do_debug_loc;
60
int do_gdb_index;
61
int do_trace_info;
62
int do_trace_abbrevs;
63
int do_trace_aranges;
64
int do_wide;
65
 
66
int dwarf_cutoff_level = -1;
67
unsigned long dwarf_start_die;
68
 
69
/* Values for do_debug_lines.  */
70
#define FLAG_DEBUG_LINES_RAW     1
71
#define FLAG_DEBUG_LINES_DECODED 2
72
 
73
static int
74
size_of_encoded_value (int encoding)
75
{
76
  switch (encoding & 0x7)
77
    {
78
    default:    /* ??? */
79
    case 0:      return eh_addr_size;
80
    case 2:     return 2;
81
    case 3:     return 4;
82
    case 4:     return 8;
83
    }
84
}
85
 
86
static dwarf_vma
87
get_encoded_value (unsigned char *data,
88
                   int encoding,
89
                   struct dwarf_section *section)
90
{
91
  int size = size_of_encoded_value (encoding);
92
  dwarf_vma val;
93
 
94
  if (encoding & DW_EH_PE_signed)
95
    val = byte_get_signed (data, size);
96
  else
97
    val = byte_get (data, size);
98
 
99
  if ((encoding & 0x70) == DW_EH_PE_pcrel)
100
    val += section->address + (data - section->start);
101
  return val;
102
}
103
 
104
/* Print a dwarf_vma value (typically an address, offset or length) in
105
   hexadecimal format, followed by a space.  The length of the value (and
106
   hence the precision displayed) is determined by the byte_size parameter.  */
107
 
108
static void
109
print_dwarf_vma (dwarf_vma val, unsigned byte_size)
110
{
111
  static char buff[18];
112
  int offset = 0;
113
 
114
  /* Printf does not have a way of specifiying a maximum field width for an
115
     integer value, so we print the full value into a buffer and then select
116
     the precision we need.  */
117
#if __STDC_VERSION__ >= 199901L || (defined(__GNUC__) && __GNUC__ >= 2)
118
#ifndef __MINGW32__
119
  snprintf (buff, sizeof (buff), "%16.16llx ", val);
120
#else
121
  snprintf (buff, sizeof (buff), "%016I64x ", val);
122
#endif
123
#else
124
  snprintf (buff, sizeof (buff), "%16.16lx ", val);
125
#endif
126
 
127
  if (byte_size != 0)
128
    {
129
      if (byte_size > 0 && byte_size <= 8)
130
        offset = 16 - 2 * byte_size;
131
      else
132
        error ("Wrong size in print_dwarf_vma");
133
    }
134
 
135
  fputs (buff + offset, stdout);
136
}
137
 
138
#if __STDC_VERSION__ >= 199901L || (defined(__GNUC__) && __GNUC__ >= 2)
139
#ifndef __MINGW32__
140
#define  DWARF_VMA_FMT "ll"
141
#else
142
#define  DWARF_VMA_FMT "I64"
143
#endif
144
#else
145
#define  DWARF_VMA_FMT "l"
146
#endif
147
 
148
static const char *
149
dwarf_vmatoa (const char *fmtch, dwarf_vma value)
150
{
151
  /* As dwarf_vmatoa is used more then once in a printf call
152
     for output, we are cycling through an fixed array of pointers
153
     for return address.  */
154
  static int buf_pos = 0;
155
  static struct dwarf_vmatoa_buf
156
  {
157
    char place[64];
158
  } buf[16];
159
  char fmt[32];
160
  char *ret;
161
 
162
  sprintf (fmt, "%%%s%s", DWARF_VMA_FMT, fmtch);
163
 
164
  ret = buf[buf_pos++].place;
165
  buf_pos %= ARRAY_SIZE (buf);
166
 
167
  snprintf (ret, sizeof (buf[0].place), fmt, value);
168
 
169
  return ret;
170
}
171
 
172
dwarf_vma
173
read_leb128 (unsigned char *data, unsigned int *length_return, int sign)
174
{
175
  dwarf_vma result = 0;
176
  unsigned int num_read = 0;
177
  unsigned int shift = 0;
178
  unsigned char byte;
179
 
180
  do
181
    {
182
      byte = *data++;
183
      num_read++;
184
 
185
      result |= ((dwarf_vma) (byte & 0x7f)) << shift;
186
 
187
      shift += 7;
188
 
189
    }
190
  while (byte & 0x80);
191
 
192
  if (length_return != NULL)
193
    *length_return = num_read;
194
 
195
  if (sign && (shift < 8 * sizeof (result)) && (byte & 0x40))
196
    result |= -1L << shift;
197
 
198
  return result;
199
}
200
 
201
/* Create a signed version to avoid painful typecasts.  */
202
static dwarf_signed_vma
203
read_sleb128 (unsigned char *data, unsigned int *length_return)
204
{
205
  return (dwarf_signed_vma) read_leb128 (data, length_return, 1);
206
}
207
 
208
typedef struct State_Machine_Registers
209
{
210
  dwarf_vma address;
211
  unsigned int file;
212
  unsigned int line;
213
  unsigned int column;
214
  int is_stmt;
215
  int basic_block;
216
  unsigned char op_index;
217
  unsigned char end_sequence;
218
/* This variable hold the number of the last entry seen
219
   in the File Table.  */
220
  unsigned int last_file_entry;
221
} SMR;
222
 
223
static SMR state_machine_regs;
224
 
225
static void
226
reset_state_machine (int is_stmt)
227
{
228
  state_machine_regs.address = 0;
229
  state_machine_regs.op_index = 0;
230
  state_machine_regs.file = 1;
231
  state_machine_regs.line = 1;
232
  state_machine_regs.column = 0;
233
  state_machine_regs.is_stmt = is_stmt;
234
  state_machine_regs.basic_block = 0;
235
  state_machine_regs.end_sequence = 0;
236
  state_machine_regs.last_file_entry = 0;
237
}
238
 
239
/* Handled an extend line op.
240
   Returns the number of bytes read.  */
241
 
242
static int
243
process_extended_line_op (unsigned char *data, int is_stmt)
244
{
245
  unsigned char op_code;
246
  unsigned int bytes_read;
247
  unsigned int len;
248
  unsigned char *name;
249
  dwarf_vma adr;
250
 
251
  len = read_leb128 (data, & bytes_read, 0);
252
  data += bytes_read;
253
 
254
  if (len == 0)
255
    {
256
      warn (_("badly formed extended line op encountered!\n"));
257
      return bytes_read;
258
    }
259
 
260
  len += bytes_read;
261
  op_code = *data++;
262
 
263
  printf (_("  Extended opcode %d: "), op_code);
264
 
265
  switch (op_code)
266
    {
267
    case DW_LNE_end_sequence:
268
      printf (_("End of Sequence\n\n"));
269
      reset_state_machine (is_stmt);
270
      break;
271
 
272
    case DW_LNE_set_address:
273
      adr = byte_get (data, len - bytes_read - 1);
274
      printf (_("set Address to 0x%s\n"), dwarf_vmatoa ("x", adr));
275
      state_machine_regs.address = adr;
276
      state_machine_regs.op_index = 0;
277
      break;
278
 
279
    case DW_LNE_define_file:
280
      printf (_("  define new File Table entry\n"));
281
      printf (_("  Entry\tDir\tTime\tSize\tName\n"));
282
 
283
      printf ("   %d\t", ++state_machine_regs.last_file_entry);
284
      name = data;
285
      data += strlen ((char *) data) + 1;
286
      printf ("%s\t", dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
287
      data += bytes_read;
288
      printf ("%s\t", dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
289
      data += bytes_read;
290
      printf ("%s\t", dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
291
      printf ("%s\n\n", name);
292
      break;
293
 
294
    case DW_LNE_set_discriminator:
295
      printf (_("set Discriminator to %s\n"),
296
              dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
297
      break;
298
 
299
    /* HP extensions.  */
300
    case DW_LNE_HP_negate_is_UV_update:
301
      printf ("DW_LNE_HP_negate_is_UV_update\n");
302
      break;
303
    case DW_LNE_HP_push_context:
304
      printf ("DW_LNE_HP_push_context\n");
305
      break;
306
    case DW_LNE_HP_pop_context:
307
      printf ("DW_LNE_HP_pop_context\n");
308
      break;
309
    case DW_LNE_HP_set_file_line_column:
310
      printf ("DW_LNE_HP_set_file_line_column\n");
311
      break;
312
    case DW_LNE_HP_set_routine_name:
313
      printf ("DW_LNE_HP_set_routine_name\n");
314
      break;
315
    case DW_LNE_HP_set_sequence:
316
      printf ("DW_LNE_HP_set_sequence\n");
317
      break;
318
    case DW_LNE_HP_negate_post_semantics:
319
      printf ("DW_LNE_HP_negate_post_semantics\n");
320
      break;
321
    case DW_LNE_HP_negate_function_exit:
322
      printf ("DW_LNE_HP_negate_function_exit\n");
323
      break;
324
    case DW_LNE_HP_negate_front_end_logical:
325
      printf ("DW_LNE_HP_negate_front_end_logical\n");
326
      break;
327
    case DW_LNE_HP_define_proc:
328
      printf ("DW_LNE_HP_define_proc\n");
329
      break;
330
    case DW_LNE_HP_source_file_correlation:
331
      {
332
        unsigned char *edata = data + len - bytes_read - 1;
333
 
334
        printf ("DW_LNE_HP_source_file_correlation\n");
335
 
336
        while (data < edata)
337
          {
338
            unsigned int opc;
339
 
340
            opc = read_leb128 (data, & bytes_read, 0);
341
            data += bytes_read;
342
 
343
            switch (opc)
344
              {
345
              case DW_LNE_HP_SFC_formfeed:
346
                printf ("    DW_LNE_HP_SFC_formfeed\n");
347
                break;
348
              case DW_LNE_HP_SFC_set_listing_line:
349
                printf ("    DW_LNE_HP_SFC_set_listing_line (%s)\n",
350
                        dwarf_vmatoa ("u",
351
                                      read_leb128 (data, & bytes_read, 0)));
352
                data += bytes_read;
353
                break;
354
              case DW_LNE_HP_SFC_associate:
355
                printf ("    DW_LNE_HP_SFC_associate ");
356
                printf (_("(%s"),
357
                        dwarf_vmatoa ("u",
358
                                      read_leb128 (data, & bytes_read, 0)));
359
                data += bytes_read;
360
                printf (_(",%s"),
361
                        dwarf_vmatoa ("u",
362
                                      read_leb128 (data, & bytes_read, 0)));
363
                data += bytes_read;
364
                printf (_(",%s)\n"),
365
                        dwarf_vmatoa ("u",
366
                                      read_leb128 (data, & bytes_read, 0)));
367
                data += bytes_read;
368
                break;
369
              default:
370
                printf ("    UNKNOW DW_LNE_HP_SFC opcode (%u)\n", opc);
371
                data = edata;
372
                break;
373
              }
374
          }
375
      }
376
      break;
377
 
378
    default:
379
      {
380
        unsigned int rlen = len - bytes_read - 1;
381
 
382
        if (op_code >= DW_LNE_lo_user
383
            /* The test against DW_LNW_hi_user is redundant due to
384
               the limited range of the unsigned char data type used
385
               for op_code.  */
386
            /*&& op_code <= DW_LNE_hi_user*/)
387
          printf (_("user defined: "));
388
        else
389
          printf (_("UNKNOWN: "));
390
        printf (_("length %d ["), rlen);
391
        for (; rlen; rlen--)
392
          printf (" %02x", *data++);
393
        printf ("]\n");
394
      }
395
      break;
396
    }
397
 
398
  return len;
399
}
400
 
401
static const char *
402
fetch_indirect_string (dwarf_vma offset)
403
{
404
  struct dwarf_section *section = &debug_displays [str].section;
405
 
406
  if (section->start == NULL)
407
    return _("<no .debug_str section>");
408
 
409
  /* DWARF sections under Mach-O have non-zero addresses.  */
410
  offset -= section->address;
411
  if (offset > section->size)
412
    {
413
      warn (_("DW_FORM_strp offset too big: %s\n"),
414
            dwarf_vmatoa ("x", offset));
415
      return _("<offset is too big>");
416
    }
417
 
418
  return (const char *) section->start + offset;
419
}
420
 
421
/* FIXME:  There are better and more efficient ways to handle
422
   these structures.  For now though, I just want something that
423
   is simple to implement.  */
424
typedef struct abbrev_attr
425
{
426
  unsigned long attribute;
427
  unsigned long form;
428
  struct abbrev_attr *next;
429
}
430
abbrev_attr;
431
 
432
typedef struct abbrev_entry
433
{
434
  unsigned long entry;
435
  unsigned long tag;
436
  int children;
437
  struct abbrev_attr *first_attr;
438
  struct abbrev_attr *last_attr;
439
  struct abbrev_entry *next;
440
}
441
abbrev_entry;
442
 
443
static abbrev_entry *first_abbrev = NULL;
444
static abbrev_entry *last_abbrev = NULL;
445
 
446
static void
447
free_abbrevs (void)
448
{
449
  abbrev_entry *abbrv;
450
 
451
  for (abbrv = first_abbrev; abbrv;)
452
    {
453
      abbrev_entry *next_abbrev = abbrv->next;
454
      abbrev_attr *attr;
455
 
456
      for (attr = abbrv->first_attr; attr;)
457
        {
458
          abbrev_attr *next_attr = attr->next;
459
 
460
          free (attr);
461
          attr = next_attr;
462
        }
463
 
464
      free (abbrv);
465
      abbrv = next_abbrev;
466
    }
467
 
468
  last_abbrev = first_abbrev = NULL;
469
}
470
 
471
static void
472
add_abbrev (unsigned long number, unsigned long tag, int children)
473
{
474
  abbrev_entry *entry;
475
 
476
  entry = (abbrev_entry *) malloc (sizeof (*entry));
477
  if (entry == NULL)
478
    /* ugg */
479
    return;
480
 
481
  entry->entry      = number;
482
  entry->tag        = tag;
483
  entry->children   = children;
484
  entry->first_attr = NULL;
485
  entry->last_attr  = NULL;
486
  entry->next       = NULL;
487
 
488
  if (first_abbrev == NULL)
489
    first_abbrev = entry;
490
  else
491
    last_abbrev->next = entry;
492
 
493
  last_abbrev = entry;
494
}
495
 
496
static void
497
add_abbrev_attr (unsigned long attribute, unsigned long form)
498
{
499
  abbrev_attr *attr;
500
 
501
  attr = (abbrev_attr *) malloc (sizeof (*attr));
502
  if (attr == NULL)
503
    /* ugg */
504
    return;
505
 
506
  attr->attribute = attribute;
507
  attr->form      = form;
508
  attr->next      = NULL;
509
 
510
  if (last_abbrev->first_attr == NULL)
511
    last_abbrev->first_attr = attr;
512
  else
513
    last_abbrev->last_attr->next = attr;
514
 
515
  last_abbrev->last_attr = attr;
516
}
517
 
518
/* Processes the (partial) contents of a .debug_abbrev section.
519
   Returns NULL if the end of the section was encountered.
520
   Returns the address after the last byte read if the end of
521
   an abbreviation set was found.  */
522
 
523
static unsigned char *
524
process_abbrev_section (unsigned char *start, unsigned char *end)
525
{
526
  if (first_abbrev != NULL)
527
    return NULL;
528
 
529
  while (start < end)
530
    {
531
      unsigned int bytes_read;
532
      unsigned long entry;
533
      unsigned long tag;
534
      unsigned long attribute;
535
      int children;
536
 
537
      entry = read_leb128 (start, & bytes_read, 0);
538
      start += bytes_read;
539
 
540
      /* A single zero is supposed to end the section according
541
         to the standard.  If there's more, then signal that to
542
         the caller.  */
543
      if (entry == 0)
544
        return start == end ? NULL : start;
545
 
546
      tag = read_leb128 (start, & bytes_read, 0);
547
      start += bytes_read;
548
 
549
      children = *start++;
550
 
551
      add_abbrev (entry, tag, children);
552
 
553
      do
554
        {
555
          unsigned long form;
556
 
557
          attribute = read_leb128 (start, & bytes_read, 0);
558
          start += bytes_read;
559
 
560
          form = read_leb128 (start, & bytes_read, 0);
561
          start += bytes_read;
562
 
563
          if (attribute != 0)
564
            add_abbrev_attr (attribute, form);
565
        }
566
      while (attribute != 0);
567
    }
568
 
569
  return NULL;
570
}
571
 
572
static char *
573
get_TAG_name (unsigned long tag)
574
{
575
  switch (tag)
576
    {
577
    case DW_TAG_padding:                return "DW_TAG_padding";
578
    case DW_TAG_array_type:             return "DW_TAG_array_type";
579
    case DW_TAG_class_type:             return "DW_TAG_class_type";
580
    case DW_TAG_entry_point:            return "DW_TAG_entry_point";
581
    case DW_TAG_enumeration_type:       return "DW_TAG_enumeration_type";
582
    case DW_TAG_formal_parameter:       return "DW_TAG_formal_parameter";
583
    case DW_TAG_imported_declaration:   return "DW_TAG_imported_declaration";
584
    case DW_TAG_label:                  return "DW_TAG_label";
585
    case DW_TAG_lexical_block:          return "DW_TAG_lexical_block";
586
    case DW_TAG_member:                 return "DW_TAG_member";
587
    case DW_TAG_pointer_type:           return "DW_TAG_pointer_type";
588
    case DW_TAG_reference_type:         return "DW_TAG_reference_type";
589
    case DW_TAG_compile_unit:           return "DW_TAG_compile_unit";
590
    case DW_TAG_string_type:            return "DW_TAG_string_type";
591
    case DW_TAG_structure_type:         return "DW_TAG_structure_type";
592
    case DW_TAG_subroutine_type:        return "DW_TAG_subroutine_type";
593
    case DW_TAG_typedef:                return "DW_TAG_typedef";
594
    case DW_TAG_union_type:             return "DW_TAG_union_type";
595
    case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
596
    case DW_TAG_variant:                return "DW_TAG_variant";
597
    case DW_TAG_common_block:           return "DW_TAG_common_block";
598
    case DW_TAG_common_inclusion:       return "DW_TAG_common_inclusion";
599
    case DW_TAG_inheritance:            return "DW_TAG_inheritance";
600
    case DW_TAG_inlined_subroutine:     return "DW_TAG_inlined_subroutine";
601
    case DW_TAG_module:                 return "DW_TAG_module";
602
    case DW_TAG_ptr_to_member_type:     return "DW_TAG_ptr_to_member_type";
603
    case DW_TAG_set_type:               return "DW_TAG_set_type";
604
    case DW_TAG_subrange_type:          return "DW_TAG_subrange_type";
605
    case DW_TAG_with_stmt:              return "DW_TAG_with_stmt";
606
    case DW_TAG_access_declaration:     return "DW_TAG_access_declaration";
607
    case DW_TAG_base_type:              return "DW_TAG_base_type";
608
    case DW_TAG_catch_block:            return "DW_TAG_catch_block";
609
    case DW_TAG_const_type:             return "DW_TAG_const_type";
610
    case DW_TAG_constant:               return "DW_TAG_constant";
611
    case DW_TAG_enumerator:             return "DW_TAG_enumerator";
612
    case DW_TAG_file_type:              return "DW_TAG_file_type";
613
    case DW_TAG_friend:                 return "DW_TAG_friend";
614
    case DW_TAG_namelist:               return "DW_TAG_namelist";
615
    case DW_TAG_namelist_item:          return "DW_TAG_namelist_item";
616
    case DW_TAG_packed_type:            return "DW_TAG_packed_type";
617
    case DW_TAG_subprogram:             return "DW_TAG_subprogram";
618
    case DW_TAG_template_type_param:    return "DW_TAG_template_type_param";
619
    case DW_TAG_template_value_param:   return "DW_TAG_template_value_param";
620
    case DW_TAG_thrown_type:            return "DW_TAG_thrown_type";
621
    case DW_TAG_try_block:              return "DW_TAG_try_block";
622
    case DW_TAG_variant_part:           return "DW_TAG_variant_part";
623
    case DW_TAG_variable:               return "DW_TAG_variable";
624
    case DW_TAG_volatile_type:          return "DW_TAG_volatile_type";
625
    case DW_TAG_MIPS_loop:              return "DW_TAG_MIPS_loop";
626
    case DW_TAG_format_label:           return "DW_TAG_format_label";
627
    case DW_TAG_function_template:      return "DW_TAG_function_template";
628
    case DW_TAG_class_template:         return "DW_TAG_class_template";
629
      /* DWARF 2.1 values.  */
630
    case DW_TAG_dwarf_procedure:        return "DW_TAG_dwarf_procedure";
631
    case DW_TAG_restrict_type:          return "DW_TAG_restrict_type";
632
    case DW_TAG_interface_type:         return "DW_TAG_interface_type";
633
    case DW_TAG_namespace:              return "DW_TAG_namespace";
634
    case DW_TAG_imported_module:        return "DW_TAG_imported_module";
635
    case DW_TAG_unspecified_type:       return "DW_TAG_unspecified_type";
636
    case DW_TAG_partial_unit:           return "DW_TAG_partial_unit";
637
    case DW_TAG_imported_unit:          return "DW_TAG_imported_unit";
638
    case DW_TAG_condition:              return "DW_TAG_condition";
639
    case DW_TAG_shared_type:            return "DW_TAG_shared_type";
640
      /* DWARF 4 values.  */
641
    case DW_TAG_type_unit:              return "DW_TAG_type_unit";
642
    case DW_TAG_rvalue_reference_type:  return "DW_TAG_rvalue_reference_type";
643
    case DW_TAG_template_alias:         return "DW_TAG_template_alias";
644
      /* UPC values.  */
645
    case DW_TAG_upc_shared_type:        return "DW_TAG_upc_shared_type";
646
    case DW_TAG_upc_strict_type:        return "DW_TAG_upc_strict_type";
647
    case DW_TAG_upc_relaxed_type:       return "DW_TAG_upc_relaxed_type";
648
      /* GNU values.  */
649
    case DW_TAG_GNU_call_site:          return "DW_TAG_GNU_call_site";
650
    case DW_TAG_GNU_call_site_parameter:return "DW_TAG_GNU_call_site_parameter";
651
    default:
652
      {
653
        static char buffer[100];
654
 
655
        snprintf (buffer, sizeof (buffer), _("Unknown TAG value: %lx"), tag);
656
        return buffer;
657
      }
658
    }
659
}
660
 
661
static char *
662
get_FORM_name (unsigned long form)
663
{
664
  switch (form)
665
    {
666
    case DW_FORM_addr:          return "DW_FORM_addr";
667
    case DW_FORM_block2:        return "DW_FORM_block2";
668
    case DW_FORM_block4:        return "DW_FORM_block4";
669
    case DW_FORM_data2:         return "DW_FORM_data2";
670
    case DW_FORM_data4:         return "DW_FORM_data4";
671
    case DW_FORM_data8:         return "DW_FORM_data8";
672
    case DW_FORM_string:        return "DW_FORM_string";
673
    case DW_FORM_block:         return "DW_FORM_block";
674
    case DW_FORM_block1:        return "DW_FORM_block1";
675
    case DW_FORM_data1:         return "DW_FORM_data1";
676
    case DW_FORM_flag:          return "DW_FORM_flag";
677
    case DW_FORM_sdata:         return "DW_FORM_sdata";
678
    case DW_FORM_strp:          return "DW_FORM_strp";
679
    case DW_FORM_udata:         return "DW_FORM_udata";
680
    case DW_FORM_ref_addr:      return "DW_FORM_ref_addr";
681
    case DW_FORM_ref1:          return "DW_FORM_ref1";
682
    case DW_FORM_ref2:          return "DW_FORM_ref2";
683
    case DW_FORM_ref4:          return "DW_FORM_ref4";
684
    case DW_FORM_ref8:          return "DW_FORM_ref8";
685
    case DW_FORM_ref_udata:     return "DW_FORM_ref_udata";
686
    case DW_FORM_indirect:      return "DW_FORM_indirect";
687
      /* DWARF 4 values.  */
688
    case DW_FORM_sec_offset:    return "DW_FORM_sec_offset";
689
    case DW_FORM_exprloc:       return "DW_FORM_exprloc";
690
    case DW_FORM_flag_present:  return "DW_FORM_flag_present";
691
    case DW_FORM_ref_sig8:      return "DW_FORM_ref_sig8";
692
    default:
693
      {
694
        static char buffer[100];
695
 
696
        snprintf (buffer, sizeof (buffer), _("Unknown FORM value: %lx"), form);
697
        return buffer;
698
      }
699
    }
700
}
701
 
702
static unsigned char *
703
display_block (unsigned char *data, dwarf_vma length)
704
{
705
  printf (_(" %s byte block: "), dwarf_vmatoa ("u", length));
706
 
707
  while (length --)
708
    printf ("%lx ", (unsigned long) byte_get (data++, 1));
709
 
710
  return data;
711
}
712
 
713
static int
714
decode_location_expression (unsigned char * data,
715
                            unsigned int pointer_size,
716
                            unsigned int offset_size,
717
                            int dwarf_version,
718
                            dwarf_vma length,
719
                            dwarf_vma cu_offset,
720
                            struct dwarf_section * section)
721
{
722
  unsigned op;
723
  unsigned int bytes_read;
724
  dwarf_vma uvalue;
725
  unsigned char *end = data + length;
726
  int need_frame_base = 0;
727
 
728
  while (data < end)
729
    {
730
      op = *data++;
731
 
732
      switch (op)
733
        {
734
        case DW_OP_addr:
735
         printf ("DW_OP_addr: %s",
736
                 dwarf_vmatoa ("x", byte_get (data, pointer_size)));
737
          data += pointer_size;
738
          break;
739
        case DW_OP_deref:
740
          printf ("DW_OP_deref");
741
          break;
742
        case DW_OP_const1u:
743
          printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data++, 1));
744
          break;
745
        case DW_OP_const1s:
746
          printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data++, 1));
747
          break;
748
        case DW_OP_const2u:
749
          printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
750
          data += 2;
751
          break;
752
        case DW_OP_const2s:
753
          printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data, 2));
754
          data += 2;
755
          break;
756
        case DW_OP_const4u:
757
          printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
758
          data += 4;
759
          break;
760
        case DW_OP_const4s:
761
          printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data, 4));
762
          data += 4;
763
          break;
764
        case DW_OP_const8u:
765
          printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
766
                  (unsigned long) byte_get (data + 4, 4));
767
          data += 8;
768
          break;
769
        case DW_OP_const8s:
770
          printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
771
                  (long) byte_get (data + 4, 4));
772
          data += 8;
773
          break;
774
        case DW_OP_constu:
775
          printf ("DW_OP_constu: %s",
776
                  dwarf_vmatoa ("u", read_leb128 (data, &bytes_read, 0)));
777
          data += bytes_read;
778
          break;
779
        case DW_OP_consts:
780
          printf ("DW_OP_consts: %s",
781
                  dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read)));
782
          data += bytes_read;
783
          break;
784
        case DW_OP_dup:
785
          printf ("DW_OP_dup");
786
          break;
787
        case DW_OP_drop:
788
          printf ("DW_OP_drop");
789
          break;
790
        case DW_OP_over:
791
          printf ("DW_OP_over");
792
          break;
793
        case DW_OP_pick:
794
          printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data++, 1));
795
          break;
796
        case DW_OP_swap:
797
          printf ("DW_OP_swap");
798
          break;
799
        case DW_OP_rot:
800
          printf ("DW_OP_rot");
801
          break;
802
        case DW_OP_xderef:
803
          printf ("DW_OP_xderef");
804
          break;
805
        case DW_OP_abs:
806
          printf ("DW_OP_abs");
807
          break;
808
        case DW_OP_and:
809
          printf ("DW_OP_and");
810
          break;
811
        case DW_OP_div:
812
          printf ("DW_OP_div");
813
          break;
814
        case DW_OP_minus:
815
          printf ("DW_OP_minus");
816
          break;
817
        case DW_OP_mod:
818
          printf ("DW_OP_mod");
819
          break;
820
        case DW_OP_mul:
821
          printf ("DW_OP_mul");
822
          break;
823
        case DW_OP_neg:
824
          printf ("DW_OP_neg");
825
          break;
826
        case DW_OP_not:
827
          printf ("DW_OP_not");
828
          break;
829
        case DW_OP_or:
830
          printf ("DW_OP_or");
831
          break;
832
        case DW_OP_plus:
833
          printf ("DW_OP_plus");
834
          break;
835
        case DW_OP_plus_uconst:
836
          printf ("DW_OP_plus_uconst: %s",
837
                  dwarf_vmatoa ("u", read_leb128 (data, &bytes_read, 0)));
838
          data += bytes_read;
839
          break;
840
        case DW_OP_shl:
841
          printf ("DW_OP_shl");
842
          break;
843
        case DW_OP_shr:
844
          printf ("DW_OP_shr");
845
          break;
846
        case DW_OP_shra:
847
          printf ("DW_OP_shra");
848
          break;
849
        case DW_OP_xor:
850
          printf ("DW_OP_xor");
851
          break;
852
        case DW_OP_bra:
853
          printf ("DW_OP_bra: %ld", (long) byte_get_signed (data, 2));
854
          data += 2;
855
          break;
856
        case DW_OP_eq:
857
          printf ("DW_OP_eq");
858
          break;
859
        case DW_OP_ge:
860
          printf ("DW_OP_ge");
861
          break;
862
        case DW_OP_gt:
863
          printf ("DW_OP_gt");
864
          break;
865
        case DW_OP_le:
866
          printf ("DW_OP_le");
867
          break;
868
        case DW_OP_lt:
869
          printf ("DW_OP_lt");
870
          break;
871
        case DW_OP_ne:
872
          printf ("DW_OP_ne");
873
          break;
874
        case DW_OP_skip:
875
          printf ("DW_OP_skip: %ld", (long) byte_get_signed (data, 2));
876
          data += 2;
877
          break;
878
 
879
        case DW_OP_lit0:
880
        case DW_OP_lit1:
881
        case DW_OP_lit2:
882
        case DW_OP_lit3:
883
        case DW_OP_lit4:
884
        case DW_OP_lit5:
885
        case DW_OP_lit6:
886
        case DW_OP_lit7:
887
        case DW_OP_lit8:
888
        case DW_OP_lit9:
889
        case DW_OP_lit10:
890
        case DW_OP_lit11:
891
        case DW_OP_lit12:
892
        case DW_OP_lit13:
893
        case DW_OP_lit14:
894
        case DW_OP_lit15:
895
        case DW_OP_lit16:
896
        case DW_OP_lit17:
897
        case DW_OP_lit18:
898
        case DW_OP_lit19:
899
        case DW_OP_lit20:
900
        case DW_OP_lit21:
901
        case DW_OP_lit22:
902
        case DW_OP_lit23:
903
        case DW_OP_lit24:
904
        case DW_OP_lit25:
905
        case DW_OP_lit26:
906
        case DW_OP_lit27:
907
        case DW_OP_lit28:
908
        case DW_OP_lit29:
909
        case DW_OP_lit30:
910
        case DW_OP_lit31:
911
          printf ("DW_OP_lit%d", op - DW_OP_lit0);
912
          break;
913
 
914
        case DW_OP_reg0:
915
        case DW_OP_reg1:
916
        case DW_OP_reg2:
917
        case DW_OP_reg3:
918
        case DW_OP_reg4:
919
        case DW_OP_reg5:
920
        case DW_OP_reg6:
921
        case DW_OP_reg7:
922
        case DW_OP_reg8:
923
        case DW_OP_reg9:
924
        case DW_OP_reg10:
925
        case DW_OP_reg11:
926
        case DW_OP_reg12:
927
        case DW_OP_reg13:
928
        case DW_OP_reg14:
929
        case DW_OP_reg15:
930
        case DW_OP_reg16:
931
        case DW_OP_reg17:
932
        case DW_OP_reg18:
933
        case DW_OP_reg19:
934
        case DW_OP_reg20:
935
        case DW_OP_reg21:
936
        case DW_OP_reg22:
937
        case DW_OP_reg23:
938
        case DW_OP_reg24:
939
        case DW_OP_reg25:
940
        case DW_OP_reg26:
941
        case DW_OP_reg27:
942
        case DW_OP_reg28:
943
        case DW_OP_reg29:
944
        case DW_OP_reg30:
945
        case DW_OP_reg31:
946
          printf ("DW_OP_reg%d (%s)", op - DW_OP_reg0,
947
                  regname (op - DW_OP_reg0, 1));
948
          break;
949
 
950
        case DW_OP_breg0:
951
        case DW_OP_breg1:
952
        case DW_OP_breg2:
953
        case DW_OP_breg3:
954
        case DW_OP_breg4:
955
        case DW_OP_breg5:
956
        case DW_OP_breg6:
957
        case DW_OP_breg7:
958
        case DW_OP_breg8:
959
        case DW_OP_breg9:
960
        case DW_OP_breg10:
961
        case DW_OP_breg11:
962
        case DW_OP_breg12:
963
        case DW_OP_breg13:
964
        case DW_OP_breg14:
965
        case DW_OP_breg15:
966
        case DW_OP_breg16:
967
        case DW_OP_breg17:
968
        case DW_OP_breg18:
969
        case DW_OP_breg19:
970
        case DW_OP_breg20:
971
        case DW_OP_breg21:
972
        case DW_OP_breg22:
973
        case DW_OP_breg23:
974
        case DW_OP_breg24:
975
        case DW_OP_breg25:
976
        case DW_OP_breg26:
977
        case DW_OP_breg27:
978
        case DW_OP_breg28:
979
        case DW_OP_breg29:
980
        case DW_OP_breg30:
981
        case DW_OP_breg31:
982
          printf ("DW_OP_breg%d (%s): %s",
983
                  op - DW_OP_breg0,
984
                  regname (op - DW_OP_breg0, 1),
985
                  dwarf_vmatoa ("d", (dwarf_signed_vma)
986
                    read_leb128 (data, &bytes_read, 1)));
987
          data += bytes_read;
988
          break;
989
 
990
        case DW_OP_regx:
991
          uvalue = read_leb128 (data, &bytes_read, 0);
992
          data += bytes_read;
993
          printf ("DW_OP_regx: %s (%s)",
994
                  dwarf_vmatoa ("u", uvalue), regname (uvalue, 1));
995
          break;
996
        case DW_OP_fbreg:
997
          need_frame_base = 1;
998
          printf ("DW_OP_fbreg: %s",
999
                  dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read)));
1000
          data += bytes_read;
1001
          break;
1002
        case DW_OP_bregx:
1003
          uvalue = read_leb128 (data, &bytes_read, 0);
1004
          data += bytes_read;
1005
          printf ("DW_OP_bregx: %s (%s) %s",
1006
                  dwarf_vmatoa ("u", uvalue), regname (uvalue, 1),
1007
                  dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read)));
1008
          data += bytes_read;
1009
          break;
1010
        case DW_OP_piece:
1011
          printf ("DW_OP_piece: %s",
1012
                  dwarf_vmatoa ("u", read_leb128 (data, &bytes_read, 0)));
1013
          data += bytes_read;
1014
          break;
1015
        case DW_OP_deref_size:
1016
          printf ("DW_OP_deref_size: %ld", (long) byte_get (data++, 1));
1017
          break;
1018
        case DW_OP_xderef_size:
1019
          printf ("DW_OP_xderef_size: %ld", (long) byte_get (data++, 1));
1020
          break;
1021
        case DW_OP_nop:
1022
          printf ("DW_OP_nop");
1023
          break;
1024
 
1025
          /* DWARF 3 extensions.  */
1026
        case DW_OP_push_object_address:
1027
          printf ("DW_OP_push_object_address");
1028
          break;
1029
        case DW_OP_call2:
1030
          /* XXX: Strictly speaking for 64-bit DWARF3 files
1031
             this ought to be an 8-byte wide computation.  */
1032
          printf ("DW_OP_call2: <0x%s>",
1033
                  dwarf_vmatoa ("x", (dwarf_signed_vma) byte_get (data, 2)
1034
                                     + cu_offset));
1035
          data += 2;
1036
          break;
1037
        case DW_OP_call4:
1038
          /* XXX: Strictly speaking for 64-bit DWARF3 files
1039
             this ought to be an 8-byte wide computation.  */
1040
          printf ("DW_OP_call4: <0x%s>",
1041
                  dwarf_vmatoa ("x", (dwarf_signed_vma) byte_get (data, 4)
1042
                                     + cu_offset));
1043
          data += 4;
1044
          break;
1045
        case DW_OP_call_ref:
1046
          /* XXX: Strictly speaking for 64-bit DWARF3 files
1047
             this ought to be an 8-byte wide computation.  */
1048
          if (dwarf_version == -1)
1049
            {
1050
              printf (_("(DW_OP_call_ref in frame info)"));
1051
              /* No way to tell where the next op is, so just bail.  */
1052
              return need_frame_base;
1053
            }
1054
          if (dwarf_version == 2)
1055
            {
1056
              printf ("DW_OP_call_ref: <0x%s>",
1057
                      dwarf_vmatoa ("x", byte_get (data, pointer_size)));
1058
              data += pointer_size;
1059
            }
1060
          else
1061
            {
1062
              printf ("DW_OP_call_ref: <0x%s>",
1063
                      dwarf_vmatoa ("x", byte_get (data, offset_size)));
1064
              data += offset_size;
1065
            }
1066
          break;
1067
        case DW_OP_form_tls_address:
1068
          printf ("DW_OP_form_tls_address");
1069
          break;
1070
        case DW_OP_call_frame_cfa:
1071
          printf ("DW_OP_call_frame_cfa");
1072
          break;
1073
        case DW_OP_bit_piece:
1074
          printf ("DW_OP_bit_piece: ");
1075
          printf ("size: %s ",
1076
                  dwarf_vmatoa ("u", read_leb128 (data, &bytes_read, 0)));
1077
          data += bytes_read;
1078
          printf ("offset: %s ",
1079
                  dwarf_vmatoa ("u", read_leb128 (data, &bytes_read, 0)));
1080
          data += bytes_read;
1081
          break;
1082
 
1083
          /* DWARF 4 extensions.  */
1084
        case DW_OP_stack_value:
1085
          printf ("DW_OP_stack_value");
1086
          break;
1087
 
1088
        case DW_OP_implicit_value:
1089
          printf ("DW_OP_implicit_value");
1090
          uvalue = read_leb128 (data, &bytes_read, 0);
1091
          data += bytes_read;
1092
          display_block (data, uvalue);
1093
          data += uvalue;
1094
          break;
1095
 
1096
          /* GNU extensions.  */
1097
        case DW_OP_GNU_push_tls_address:
1098
          printf ("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown");
1099
          break;
1100
        case DW_OP_GNU_uninit:
1101
          printf ("DW_OP_GNU_uninit");
1102
          /* FIXME: Is there data associated with this OP ?  */
1103
          break;
1104
        case DW_OP_GNU_encoded_addr:
1105
          {
1106
            int encoding;
1107
            dwarf_vma addr;
1108
 
1109
            encoding = *data++;
1110
            addr = get_encoded_value (data, encoding, section);
1111
            data += size_of_encoded_value (encoding);
1112
 
1113
            printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding);
1114
            print_dwarf_vma (addr, pointer_size);
1115
          }
1116
          break;
1117
        case DW_OP_GNU_implicit_pointer:
1118
          /* XXX: Strictly speaking for 64-bit DWARF3 files
1119
             this ought to be an 8-byte wide computation.  */
1120
          if (dwarf_version == -1)
1121
            {
1122
              printf (_("(DW_OP_GNU_implicit_pointer in frame info)"));
1123
              /* No way to tell where the next op is, so just bail.  */
1124
              return need_frame_base;
1125
            }
1126
          if (dwarf_version == 2)
1127
            {
1128
              printf ("DW_OP_GNU_implicit_pointer: <0x%s> %s",
1129
                      dwarf_vmatoa ("x", byte_get (data, pointer_size)),
1130
                      dwarf_vmatoa ("d", read_sleb128 (data + pointer_size,
1131
                                     &bytes_read)));
1132
              data += pointer_size + bytes_read;
1133
            }
1134
          else
1135
            {
1136
              printf ("DW_OP_GNU_implicit_pointer: <0x%s> %s",
1137
                      dwarf_vmatoa ("x", byte_get (data, offset_size)),
1138
                      dwarf_vmatoa ("d", read_sleb128 (data + offset_size,
1139
                                     &bytes_read)));
1140
              data += offset_size + bytes_read;
1141
            }
1142
          break;
1143
        case DW_OP_GNU_entry_value:
1144
          uvalue = read_leb128 (data, &bytes_read, 0);
1145
          data += bytes_read;
1146
          printf ("DW_OP_GNU_entry_value: (");
1147
          if (decode_location_expression (data, pointer_size, offset_size,
1148
                                          dwarf_version, uvalue,
1149
                                          cu_offset, section))
1150
            need_frame_base = 1;
1151
          putchar (')');
1152
          data += uvalue;
1153
          break;
1154
        case DW_OP_GNU_const_type:
1155
          uvalue = read_leb128 (data, &bytes_read, 0);
1156
          data += bytes_read;
1157
          printf ("DW_OP_GNU_const_type: <0x%s> ",
1158
                  dwarf_vmatoa ("x", cu_offset + uvalue));
1159
          uvalue = byte_get (data++, 1);
1160
          display_block (data, uvalue);
1161
          data += uvalue;
1162
          break;
1163
        case DW_OP_GNU_regval_type:
1164
          uvalue = read_leb128 (data, &bytes_read, 0);
1165
          data += bytes_read;
1166
          printf ("DW_OP_GNU_regval_type: %s (%s)",
1167
                  dwarf_vmatoa ("u", uvalue), regname (uvalue, 1));
1168
          uvalue = read_leb128 (data, &bytes_read, 0);
1169
          data += bytes_read;
1170
          printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset + uvalue));
1171
          break;
1172
        case DW_OP_GNU_deref_type:
1173
          printf ("DW_OP_GNU_deref_type: %ld", (long) byte_get (data++, 1));
1174
          uvalue = read_leb128 (data, &bytes_read, 0);
1175
          data += bytes_read;
1176
          printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset + uvalue));
1177
          break;
1178
        case DW_OP_GNU_convert:
1179
          uvalue = read_leb128 (data, &bytes_read, 0);
1180
          data += bytes_read;
1181
          printf ("DW_OP_GNU_convert <0x%s>",
1182 161 khays
                  dwarf_vmatoa ("x", uvalue ? cu_offset + uvalue : 0));
1183 15 khays
          break;
1184
        case DW_OP_GNU_reinterpret:
1185
          uvalue = read_leb128 (data, &bytes_read, 0);
1186
          data += bytes_read;
1187
          printf ("DW_OP_GNU_reinterpret <0x%s>",
1188 161 khays
                  dwarf_vmatoa ("x", uvalue ? cu_offset + uvalue : 0));
1189 15 khays
          break;
1190 161 khays
        case DW_OP_GNU_parameter_ref:
1191
          printf ("DW_OP_GNU_parameter_ref: <0x%s>",
1192
                  dwarf_vmatoa ("x", cu_offset + byte_get (data, 4)));
1193
          data += 4;
1194
          break;
1195 15 khays
 
1196
          /* HP extensions.  */
1197
        case DW_OP_HP_is_value:
1198
          printf ("DW_OP_HP_is_value");
1199
          /* FIXME: Is there data associated with this OP ?  */
1200
          break;
1201
        case DW_OP_HP_fltconst4:
1202
          printf ("DW_OP_HP_fltconst4");
1203
          /* FIXME: Is there data associated with this OP ?  */
1204
          break;
1205
        case DW_OP_HP_fltconst8:
1206
          printf ("DW_OP_HP_fltconst8");
1207
          /* FIXME: Is there data associated with this OP ?  */
1208
          break;
1209
        case DW_OP_HP_mod_range:
1210
          printf ("DW_OP_HP_mod_range");
1211
          /* FIXME: Is there data associated with this OP ?  */
1212
          break;
1213
        case DW_OP_HP_unmod_range:
1214
          printf ("DW_OP_HP_unmod_range");
1215
          /* FIXME: Is there data associated with this OP ?  */
1216
          break;
1217
        case DW_OP_HP_tls:
1218
          printf ("DW_OP_HP_tls");
1219
          /* FIXME: Is there data associated with this OP ?  */
1220
          break;
1221
 
1222
          /* PGI (STMicroelectronics) extensions.  */
1223
        case DW_OP_PGI_omp_thread_num:
1224
          /* Pushes the thread number for the current thread as it would be
1225
             returned by the standard OpenMP library function:
1226
             omp_get_thread_num().  The "current thread" is the thread for
1227
             which the expression is being evaluated.  */
1228
          printf ("DW_OP_PGI_omp_thread_num");
1229
          break;
1230
 
1231
        default:
1232
          if (op >= DW_OP_lo_user
1233
              && op <= DW_OP_hi_user)
1234
            printf (_("(User defined location op)"));
1235
          else
1236
            printf (_("(Unknown location op)"));
1237
          /* No way to tell where the next op is, so just bail.  */
1238
          return need_frame_base;
1239
        }
1240
 
1241
      /* Separate the ops.  */
1242
      if (data < end)
1243
        printf ("; ");
1244
    }
1245
 
1246
  return need_frame_base;
1247
}
1248
 
1249
static unsigned char *
1250
read_and_display_attr_value (unsigned long attribute,
1251
                             unsigned long form,
1252
                             unsigned char * data,
1253
                             dwarf_vma cu_offset,
1254
                             dwarf_vma pointer_size,
1255
                             dwarf_vma offset_size,
1256
                             int dwarf_version,
1257
                             debug_info * debug_info_p,
1258
                             int do_loc,
1259
                             struct dwarf_section * section)
1260
{
1261
  dwarf_vma uvalue = 0;
1262
  unsigned char *block_start = NULL;
1263
  unsigned char * orig_data = data;
1264
  unsigned int bytes_read;
1265
 
1266
  switch (form)
1267
    {
1268
    default:
1269
      break;
1270
 
1271
    case DW_FORM_ref_addr:
1272
      if (dwarf_version == 2)
1273
        {
1274
          uvalue = byte_get (data, pointer_size);
1275
          data += pointer_size;
1276
        }
1277
      else if (dwarf_version == 3 || dwarf_version == 4)
1278
        {
1279
          uvalue = byte_get (data, offset_size);
1280
          data += offset_size;
1281
        }
1282
      else
1283
        error (_("Internal error: DWARF version is not 2, 3 or 4.\n"));
1284
 
1285
      break;
1286
 
1287
    case DW_FORM_addr:
1288
      uvalue = byte_get (data, pointer_size);
1289
      data += pointer_size;
1290
      break;
1291
 
1292
    case DW_FORM_strp:
1293
    case DW_FORM_sec_offset:
1294
      uvalue = byte_get (data, offset_size);
1295
      data += offset_size;
1296
      break;
1297
 
1298
    case DW_FORM_flag_present:
1299
      uvalue = 1;
1300
      break;
1301
 
1302
    case DW_FORM_ref1:
1303
    case DW_FORM_flag:
1304
    case DW_FORM_data1:
1305
      uvalue = byte_get (data++, 1);
1306
      break;
1307
 
1308
    case DW_FORM_ref2:
1309
    case DW_FORM_data2:
1310
      uvalue = byte_get (data, 2);
1311
      data += 2;
1312
      break;
1313
 
1314
    case DW_FORM_ref4:
1315
    case DW_FORM_data4:
1316
      uvalue = byte_get (data, 4);
1317
      data += 4;
1318
      break;
1319
 
1320
    case DW_FORM_sdata:
1321
      uvalue = read_leb128 (data, & bytes_read, 1);
1322
      data += bytes_read;
1323
      break;
1324
 
1325
    case DW_FORM_ref_udata:
1326
    case DW_FORM_udata:
1327
      uvalue = read_leb128 (data, & bytes_read, 0);
1328
      data += bytes_read;
1329
      break;
1330
 
1331
    case DW_FORM_indirect:
1332
      form = read_leb128 (data, & bytes_read, 0);
1333
      data += bytes_read;
1334
      if (!do_loc)
1335
        printf (" %s", get_FORM_name (form));
1336
      return read_and_display_attr_value (attribute, form, data,
1337
                                          cu_offset, pointer_size,
1338
                                          offset_size, dwarf_version,
1339
                                          debug_info_p, do_loc,
1340
                                          section);
1341
    }
1342
 
1343
  switch (form)
1344
    {
1345
    case DW_FORM_ref_addr:
1346
      if (!do_loc)
1347
        printf (" <0x%s>", dwarf_vmatoa ("x",uvalue));
1348
      break;
1349
 
1350
    case DW_FORM_ref1:
1351
    case DW_FORM_ref2:
1352
    case DW_FORM_ref4:
1353
    case DW_FORM_ref_udata:
1354
      if (!do_loc)
1355
        printf (" <0x%s>", dwarf_vmatoa ("x", uvalue + cu_offset));
1356
      break;
1357
 
1358
    case DW_FORM_data4:
1359
    case DW_FORM_addr:
1360
    case DW_FORM_sec_offset:
1361
      if (!do_loc)
1362
        printf (" 0x%s", dwarf_vmatoa ("x", uvalue));
1363
      break;
1364
 
1365
    case DW_FORM_flag_present:
1366
    case DW_FORM_flag:
1367
    case DW_FORM_data1:
1368
    case DW_FORM_data2:
1369
    case DW_FORM_sdata:
1370
    case DW_FORM_udata:
1371
      if (!do_loc)
1372
        printf (" %s", dwarf_vmatoa ("d", uvalue));
1373
      break;
1374
 
1375
    case DW_FORM_ref8:
1376
    case DW_FORM_data8:
1377
      if (!do_loc)
1378
        {
1379
          uvalue = byte_get (data, 4);
1380
          printf (" 0x%s", dwarf_vmatoa ("x", uvalue));
1381
          printf (" 0x%lx", (unsigned long) byte_get (data + 4, 4));
1382
        }
1383
      if ((do_loc || do_debug_loc || do_debug_ranges)
1384
          && num_debug_info_entries == 0)
1385
        {
1386
          if (sizeof (uvalue) == 8)
1387
            uvalue = byte_get (data, 8);
1388
          else
1389
            error (_("DW_FORM_data8 is unsupported when sizeof (dwarf_vma) != 8\n"));
1390
        }
1391
      data += 8;
1392
      break;
1393
 
1394
    case DW_FORM_string:
1395
      if (!do_loc)
1396
        printf (" %s", data);
1397
      data += strlen ((char *) data) + 1;
1398
      break;
1399
 
1400
    case DW_FORM_block:
1401
    case DW_FORM_exprloc:
1402
      uvalue = read_leb128 (data, & bytes_read, 0);
1403
      block_start = data + bytes_read;
1404
      if (do_loc)
1405
        data = block_start + uvalue;
1406
      else
1407
        data = display_block (block_start, uvalue);
1408
      break;
1409
 
1410
    case DW_FORM_block1:
1411
      uvalue = byte_get (data, 1);
1412
      block_start = data + 1;
1413
      if (do_loc)
1414
        data = block_start + uvalue;
1415
      else
1416
        data = display_block (block_start, uvalue);
1417
      break;
1418
 
1419
    case DW_FORM_block2:
1420
      uvalue = byte_get (data, 2);
1421
      block_start = data + 2;
1422
      if (do_loc)
1423
        data = block_start + uvalue;
1424
      else
1425
        data = display_block (block_start, uvalue);
1426
      break;
1427
 
1428
    case DW_FORM_block4:
1429
      uvalue = byte_get (data, 4);
1430
      block_start = data + 4;
1431
      if (do_loc)
1432
        data = block_start + uvalue;
1433
      else
1434
        data = display_block (block_start, uvalue);
1435
      break;
1436
 
1437
    case DW_FORM_strp:
1438
      if (!do_loc)
1439
        printf (_(" (indirect string, offset: 0x%s): %s"),
1440
                dwarf_vmatoa ("x", uvalue),
1441
                fetch_indirect_string (uvalue));
1442
      break;
1443
 
1444
    case DW_FORM_indirect:
1445
      /* Handled above.  */
1446
      break;
1447
 
1448
    case DW_FORM_ref_sig8:
1449
      if (!do_loc)
1450
        {
1451
          int i;
1452
          printf (" signature: ");
1453
          for (i = 0; i < 8; i++)
1454
            {
1455
              printf ("%02x", (unsigned) byte_get (data, 1));
1456
              data += 1;
1457
            }
1458
        }
1459
      else
1460
        data += 8;
1461
      break;
1462
 
1463
    default:
1464
      warn (_("Unrecognized form: %lu\n"), form);
1465
      break;
1466
    }
1467
 
1468
  if ((do_loc || do_debug_loc || do_debug_ranges)
1469
      && num_debug_info_entries == 0
1470
      && debug_info_p != NULL)
1471
    {
1472
      switch (attribute)
1473
        {
1474
        case DW_AT_frame_base:
1475
          have_frame_base = 1;
1476
        case DW_AT_location:
1477
        case DW_AT_string_length:
1478
        case DW_AT_return_addr:
1479
        case DW_AT_data_member_location:
1480
        case DW_AT_vtable_elem_location:
1481
        case DW_AT_segment:
1482
        case DW_AT_static_link:
1483
        case DW_AT_use_location:
1484
        case DW_AT_GNU_call_site_value:
1485
        case DW_AT_GNU_call_site_data_value:
1486
        case DW_AT_GNU_call_site_target:
1487
        case DW_AT_GNU_call_site_target_clobbered:
1488 161 khays
          if ((dwarf_version < 4
1489
               && (form == DW_FORM_data4 || form == DW_FORM_data8))
1490 15 khays
              || form == DW_FORM_sec_offset)
1491
            {
1492
              /* Process location list.  */
1493
              unsigned int lmax = debug_info_p->max_loc_offsets;
1494
              unsigned int num = debug_info_p->num_loc_offsets;
1495
 
1496
              if (lmax == 0 || num >= lmax)
1497
                {
1498
                  lmax += 1024;
1499
                  debug_info_p->loc_offsets = (dwarf_vma *)
1500
                      xcrealloc (debug_info_p->loc_offsets,
1501
                                 lmax, sizeof (*debug_info_p->loc_offsets));
1502
                  debug_info_p->have_frame_base = (int *)
1503
                      xcrealloc (debug_info_p->have_frame_base,
1504
                                 lmax, sizeof (*debug_info_p->have_frame_base));
1505
                  debug_info_p->max_loc_offsets = lmax;
1506
                }
1507
              debug_info_p->loc_offsets [num] = uvalue;
1508
              debug_info_p->have_frame_base [num] = have_frame_base;
1509
              debug_info_p->num_loc_offsets++;
1510
            }
1511
          break;
1512
 
1513
        case DW_AT_low_pc:
1514
          if (need_base_address)
1515
            debug_info_p->base_address = uvalue;
1516
          break;
1517
 
1518
        case DW_AT_ranges:
1519 161 khays
          if ((dwarf_version < 4
1520
               && (form == DW_FORM_data4 || form == DW_FORM_data8))
1521 15 khays
              || form == DW_FORM_sec_offset)
1522
            {
1523
              /* Process range list.  */
1524
              unsigned int lmax = debug_info_p->max_range_lists;
1525
              unsigned int num = debug_info_p->num_range_lists;
1526
 
1527
              if (lmax == 0 || num >= lmax)
1528
                {
1529
                  lmax += 1024;
1530
                  debug_info_p->range_lists = (dwarf_vma *)
1531
                      xcrealloc (debug_info_p->range_lists,
1532
                                 lmax, sizeof (*debug_info_p->range_lists));
1533
                  debug_info_p->max_range_lists = lmax;
1534
                }
1535
              debug_info_p->range_lists [num] = uvalue;
1536
              debug_info_p->num_range_lists++;
1537
            }
1538
          break;
1539
 
1540
        default:
1541
          break;
1542
        }
1543
    }
1544
 
1545 161 khays
  if (do_loc || attribute == 0)
1546 15 khays
    return data;
1547
 
1548
  /* For some attributes we can display further information.  */
1549
  printf ("\t");
1550
 
1551
  switch (attribute)
1552
    {
1553
    case DW_AT_inline:
1554
      switch (uvalue)
1555
        {
1556
        case DW_INL_not_inlined:
1557
          printf (_("(not inlined)"));
1558
          break;
1559
        case DW_INL_inlined:
1560
          printf (_("(inlined)"));
1561
          break;
1562
        case DW_INL_declared_not_inlined:
1563
          printf (_("(declared as inline but ignored)"));
1564
          break;
1565
        case DW_INL_declared_inlined:
1566
          printf (_("(declared as inline and inlined)"));
1567
          break;
1568
        default:
1569
          printf (_("  (Unknown inline attribute value: %s)"),
1570
                  dwarf_vmatoa ("x", uvalue));
1571
          break;
1572
        }
1573
      break;
1574
 
1575
    case DW_AT_language:
1576
      switch (uvalue)
1577
        {
1578
          /* Ordered by the numeric value of these constants.  */
1579
        case DW_LANG_C89:               printf ("(ANSI C)"); break;
1580
        case DW_LANG_C:                 printf ("(non-ANSI C)"); break;
1581
        case DW_LANG_Ada83:             printf ("(Ada)"); break;
1582
        case DW_LANG_C_plus_plus:       printf ("(C++)"); break;
1583
        case DW_LANG_Cobol74:           printf ("(Cobol 74)"); break;
1584
        case DW_LANG_Cobol85:           printf ("(Cobol 85)"); break;
1585
        case DW_LANG_Fortran77:         printf ("(FORTRAN 77)"); break;
1586
        case DW_LANG_Fortran90:         printf ("(Fortran 90)"); break;
1587
        case DW_LANG_Pascal83:          printf ("(ANSI Pascal)"); break;
1588
        case DW_LANG_Modula2:           printf ("(Modula 2)"); break;
1589
          /* DWARF 2.1 values.  */
1590
        case DW_LANG_Java:              printf ("(Java)"); break;
1591
        case DW_LANG_C99:               printf ("(ANSI C99)"); break;
1592
        case DW_LANG_Ada95:             printf ("(ADA 95)"); break;
1593
        case DW_LANG_Fortran95:         printf ("(Fortran 95)"); break;
1594
          /* DWARF 3 values.  */
1595
        case DW_LANG_PLI:               printf ("(PLI)"); break;
1596
        case DW_LANG_ObjC:              printf ("(Objective C)"); break;
1597
        case DW_LANG_ObjC_plus_plus:    printf ("(Objective C++)"); break;
1598
        case DW_LANG_UPC:               printf ("(Unified Parallel C)"); break;
1599
        case DW_LANG_D:                 printf ("(D)"); break;
1600
          /* DWARF 4 values.  */
1601
        case DW_LANG_Python:            printf ("(Python)"); break;
1602
          /* MIPS extension.  */
1603
        case DW_LANG_Mips_Assembler:    printf ("(MIPS assembler)"); break;
1604
          /* UPC extension.  */
1605
        case DW_LANG_Upc:               printf ("(Unified Parallel C)"); break;
1606
        default:
1607
          if (uvalue >= DW_LANG_lo_user && uvalue <= DW_LANG_hi_user)
1608
            printf ("(implementation defined: %s)",
1609
                    dwarf_vmatoa ("x", uvalue));
1610
          else
1611
            printf ("(Unknown: %s)", dwarf_vmatoa ("x", uvalue));
1612
          break;
1613
        }
1614
      break;
1615
 
1616
    case DW_AT_encoding:
1617
      switch (uvalue)
1618
        {
1619
        case DW_ATE_void:               printf ("(void)"); break;
1620
        case DW_ATE_address:            printf ("(machine address)"); break;
1621
        case DW_ATE_boolean:            printf ("(boolean)"); break;
1622
        case DW_ATE_complex_float:      printf ("(complex float)"); break;
1623
        case DW_ATE_float:              printf ("(float)"); break;
1624
        case DW_ATE_signed:             printf ("(signed)"); break;
1625
        case DW_ATE_signed_char:        printf ("(signed char)"); break;
1626
        case DW_ATE_unsigned:           printf ("(unsigned)"); break;
1627
        case DW_ATE_unsigned_char:      printf ("(unsigned char)"); break;
1628
          /* DWARF 2.1 values:  */
1629
        case DW_ATE_imaginary_float:    printf ("(imaginary float)"); break;
1630
        case DW_ATE_decimal_float:      printf ("(decimal float)"); break;
1631
          /* DWARF 3 values:  */
1632
        case DW_ATE_packed_decimal:     printf ("(packed_decimal)"); break;
1633
        case DW_ATE_numeric_string:     printf ("(numeric_string)"); break;
1634
        case DW_ATE_edited:             printf ("(edited)"); break;
1635
        case DW_ATE_signed_fixed:       printf ("(signed_fixed)"); break;
1636
        case DW_ATE_unsigned_fixed:     printf ("(unsigned_fixed)"); break;
1637
          /* HP extensions:  */
1638
        case DW_ATE_HP_float80:         printf ("(HP_float80)"); break;
1639
        case DW_ATE_HP_complex_float80: printf ("(HP_complex_float80)"); break;
1640
        case DW_ATE_HP_float128:        printf ("(HP_float128)"); break;
1641
        case DW_ATE_HP_complex_float128:printf ("(HP_complex_float128)"); break;
1642
        case DW_ATE_HP_floathpintel:    printf ("(HP_floathpintel)"); break;
1643
        case DW_ATE_HP_imaginary_float80:       printf ("(HP_imaginary_float80)"); break;
1644
        case DW_ATE_HP_imaginary_float128:      printf ("(HP_imaginary_float128)"); break;
1645
 
1646
        default:
1647
          if (uvalue >= DW_ATE_lo_user
1648
              && uvalue <= DW_ATE_hi_user)
1649
            printf ("(user defined type)");
1650
          else
1651
            printf ("(unknown type)");
1652
          break;
1653
        }
1654
      break;
1655
 
1656
    case DW_AT_accessibility:
1657
      switch (uvalue)
1658
        {
1659
        case DW_ACCESS_public:          printf ("(public)"); break;
1660
        case DW_ACCESS_protected:       printf ("(protected)"); break;
1661
        case DW_ACCESS_private:         printf ("(private)"); break;
1662
        default:
1663
          printf ("(unknown accessibility)");
1664
          break;
1665
        }
1666
      break;
1667
 
1668
    case DW_AT_visibility:
1669
      switch (uvalue)
1670
        {
1671
        case DW_VIS_local:              printf ("(local)"); break;
1672
        case DW_VIS_exported:           printf ("(exported)"); break;
1673
        case DW_VIS_qualified:          printf ("(qualified)"); break;
1674
        default:                        printf ("(unknown visibility)"); break;
1675
        }
1676
      break;
1677
 
1678
    case DW_AT_virtuality:
1679
      switch (uvalue)
1680
        {
1681
        case DW_VIRTUALITY_none:        printf ("(none)"); break;
1682
        case DW_VIRTUALITY_virtual:     printf ("(virtual)"); break;
1683
        case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
1684
        default:                        printf ("(unknown virtuality)"); break;
1685
        }
1686
      break;
1687
 
1688
    case DW_AT_identifier_case:
1689
      switch (uvalue)
1690
        {
1691
        case DW_ID_case_sensitive:      printf ("(case_sensitive)"); break;
1692
        case DW_ID_up_case:             printf ("(up_case)"); break;
1693
        case DW_ID_down_case:           printf ("(down_case)"); break;
1694
        case DW_ID_case_insensitive:    printf ("(case_insensitive)"); break;
1695
        default:                        printf ("(unknown case)"); break;
1696
        }
1697
      break;
1698
 
1699
    case DW_AT_calling_convention:
1700
      switch (uvalue)
1701
        {
1702
        case DW_CC_normal:      printf ("(normal)"); break;
1703
        case DW_CC_program:     printf ("(program)"); break;
1704
        case DW_CC_nocall:      printf ("(nocall)"); break;
1705
        default:
1706
          if (uvalue >= DW_CC_lo_user
1707
              && uvalue <= DW_CC_hi_user)
1708
            printf ("(user defined)");
1709
          else
1710
            printf ("(unknown convention)");
1711
        }
1712
      break;
1713
 
1714
    case DW_AT_ordering:
1715
      switch (uvalue)
1716
        {
1717
        case -1: printf ("(undefined)"); break;
1718
        case 0:  printf ("(row major)"); break;
1719
        case 1:  printf ("(column major)"); break;
1720
        }
1721
      break;
1722
 
1723
    case DW_AT_frame_base:
1724
      have_frame_base = 1;
1725
    case DW_AT_location:
1726
    case DW_AT_string_length:
1727
    case DW_AT_return_addr:
1728
    case DW_AT_data_member_location:
1729
    case DW_AT_vtable_elem_location:
1730
    case DW_AT_segment:
1731
    case DW_AT_static_link:
1732
    case DW_AT_use_location:
1733
    case DW_AT_GNU_call_site_value:
1734
    case DW_AT_GNU_call_site_data_value:
1735
    case DW_AT_GNU_call_site_target:
1736
    case DW_AT_GNU_call_site_target_clobbered:
1737 161 khays
      if ((dwarf_version < 4
1738
           && (form == DW_FORM_data4 || form == DW_FORM_data8))
1739 15 khays
          || form == DW_FORM_sec_offset)
1740
        printf (_("(location list)"));
1741
      /* Fall through.  */
1742
    case DW_AT_allocated:
1743
    case DW_AT_associated:
1744
    case DW_AT_data_location:
1745
    case DW_AT_stride:
1746
    case DW_AT_upper_bound:
1747
    case DW_AT_lower_bound:
1748
      if (block_start)
1749
        {
1750
          int need_frame_base;
1751
 
1752
          printf ("(");
1753
          need_frame_base = decode_location_expression (block_start,
1754
                                                        pointer_size,
1755
                                                        offset_size,
1756
                                                        dwarf_version,
1757
                                                        uvalue,
1758
                                                        cu_offset, section);
1759
          printf (")");
1760
          if (need_frame_base && !have_frame_base)
1761
            printf (_(" [without DW_AT_frame_base]"));
1762
        }
1763
      break;
1764
 
1765
    case DW_AT_import:
1766
      {
1767
        if (form == DW_FORM_ref_sig8)
1768
          break;
1769
 
1770
        if (form == DW_FORM_ref1
1771
            || form == DW_FORM_ref2
1772
            || form == DW_FORM_ref4)
1773
          uvalue += cu_offset;
1774
 
1775
        if (uvalue >= section->size)
1776
          warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset %lx is too big.\n"),
1777
                dwarf_vmatoa ("x", uvalue),
1778
                (unsigned long) (orig_data - section->start));
1779
        else
1780
          {
1781
            unsigned long abbrev_number;
1782
            abbrev_entry * entry;
1783
 
1784
            abbrev_number = read_leb128 (section->start + uvalue, NULL, 0);
1785
 
1786
            printf ("[Abbrev Number: %ld", abbrev_number);
1787
            for (entry = first_abbrev; entry != NULL; entry = entry->next)
1788
              if (entry->entry == abbrev_number)
1789
                break;
1790
            if (entry != NULL)
1791
              printf (" (%s)", get_TAG_name (entry->tag));
1792
            printf ("]");
1793
          }
1794
      }
1795
      break;
1796
 
1797
    default:
1798
      break;
1799
    }
1800
 
1801
  return data;
1802
}
1803
 
1804
static char *
1805
get_AT_name (unsigned long attribute)
1806
{
1807
  switch (attribute)
1808
    {
1809
    case DW_AT_sibling:                 return "DW_AT_sibling";
1810
    case DW_AT_location:                return "DW_AT_location";
1811
    case DW_AT_name:                    return "DW_AT_name";
1812
    case DW_AT_ordering:                return "DW_AT_ordering";
1813
    case DW_AT_subscr_data:             return "DW_AT_subscr_data";
1814
    case DW_AT_byte_size:               return "DW_AT_byte_size";
1815
    case DW_AT_bit_offset:              return "DW_AT_bit_offset";
1816
    case DW_AT_bit_size:                return "DW_AT_bit_size";
1817
    case DW_AT_element_list:            return "DW_AT_element_list";
1818
    case DW_AT_stmt_list:               return "DW_AT_stmt_list";
1819
    case DW_AT_low_pc:                  return "DW_AT_low_pc";
1820
    case DW_AT_high_pc:                 return "DW_AT_high_pc";
1821
    case DW_AT_language:                return "DW_AT_language";
1822
    case DW_AT_member:                  return "DW_AT_member";
1823
    case DW_AT_discr:                   return "DW_AT_discr";
1824
    case DW_AT_discr_value:             return "DW_AT_discr_value";
1825
    case DW_AT_visibility:              return "DW_AT_visibility";
1826
    case DW_AT_import:                  return "DW_AT_import";
1827
    case DW_AT_string_length:           return "DW_AT_string_length";
1828
    case DW_AT_common_reference:        return "DW_AT_common_reference";
1829
    case DW_AT_comp_dir:                return "DW_AT_comp_dir";
1830
    case DW_AT_const_value:             return "DW_AT_const_value";
1831
    case DW_AT_containing_type:         return "DW_AT_containing_type";
1832
    case DW_AT_default_value:           return "DW_AT_default_value";
1833
    case DW_AT_inline:                  return "DW_AT_inline";
1834
    case DW_AT_is_optional:             return "DW_AT_is_optional";
1835
    case DW_AT_lower_bound:             return "DW_AT_lower_bound";
1836
    case DW_AT_producer:                return "DW_AT_producer";
1837
    case DW_AT_prototyped:              return "DW_AT_prototyped";
1838
    case DW_AT_return_addr:             return "DW_AT_return_addr";
1839
    case DW_AT_start_scope:             return "DW_AT_start_scope";
1840
    case DW_AT_stride_size:             return "DW_AT_stride_size";
1841
    case DW_AT_upper_bound:             return "DW_AT_upper_bound";
1842
    case DW_AT_abstract_origin:         return "DW_AT_abstract_origin";
1843
    case DW_AT_accessibility:           return "DW_AT_accessibility";
1844
    case DW_AT_address_class:           return "DW_AT_address_class";
1845
    case DW_AT_artificial:              return "DW_AT_artificial";
1846
    case DW_AT_base_types:              return "DW_AT_base_types";
1847
    case DW_AT_calling_convention:      return "DW_AT_calling_convention";
1848
    case DW_AT_count:                   return "DW_AT_count";
1849
    case DW_AT_data_member_location:    return "DW_AT_data_member_location";
1850
    case DW_AT_decl_column:             return "DW_AT_decl_column";
1851
    case DW_AT_decl_file:               return "DW_AT_decl_file";
1852
    case DW_AT_decl_line:               return "DW_AT_decl_line";
1853
    case DW_AT_declaration:             return "DW_AT_declaration";
1854
    case DW_AT_discr_list:              return "DW_AT_discr_list";
1855
    case DW_AT_encoding:                return "DW_AT_encoding";
1856
    case DW_AT_external:                return "DW_AT_external";
1857
    case DW_AT_frame_base:              return "DW_AT_frame_base";
1858
    case DW_AT_friend:                  return "DW_AT_friend";
1859
    case DW_AT_identifier_case:         return "DW_AT_identifier_case";
1860
    case DW_AT_macro_info:              return "DW_AT_macro_info";
1861
    case DW_AT_namelist_items:          return "DW_AT_namelist_items";
1862
    case DW_AT_priority:                return "DW_AT_priority";
1863
    case DW_AT_segment:                 return "DW_AT_segment";
1864
    case DW_AT_specification:           return "DW_AT_specification";
1865
    case DW_AT_static_link:             return "DW_AT_static_link";
1866
    case DW_AT_type:                    return "DW_AT_type";
1867
    case DW_AT_use_location:            return "DW_AT_use_location";
1868
    case DW_AT_variable_parameter:      return "DW_AT_variable_parameter";
1869
    case DW_AT_virtuality:              return "DW_AT_virtuality";
1870
    case DW_AT_vtable_elem_location:    return "DW_AT_vtable_elem_location";
1871
      /* DWARF 2.1 values.  */
1872
    case DW_AT_allocated:               return "DW_AT_allocated";
1873
    case DW_AT_associated:              return "DW_AT_associated";
1874
    case DW_AT_data_location:           return "DW_AT_data_location";
1875
    case DW_AT_stride:                  return "DW_AT_stride";
1876
    case DW_AT_entry_pc:                return "DW_AT_entry_pc";
1877
    case DW_AT_use_UTF8:                return "DW_AT_use_UTF8";
1878
    case DW_AT_extension:               return "DW_AT_extension";
1879
    case DW_AT_ranges:                  return "DW_AT_ranges";
1880
    case DW_AT_trampoline:              return "DW_AT_trampoline";
1881
    case DW_AT_call_column:             return "DW_AT_call_column";
1882
    case DW_AT_call_file:               return "DW_AT_call_file";
1883
    case DW_AT_call_line:               return "DW_AT_call_line";
1884
    case DW_AT_description:             return "DW_AT_description";
1885
    case DW_AT_binary_scale:            return "DW_AT_binary_scale";
1886
    case DW_AT_decimal_scale:           return "DW_AT_decimal_scale";
1887
    case DW_AT_small:                   return "DW_AT_small";
1888
    case DW_AT_decimal_sign:            return "DW_AT_decimal_sign";
1889
    case DW_AT_digit_count:             return "DW_AT_digit_count";
1890
    case DW_AT_picture_string:          return "DW_AT_picture_string";
1891
    case DW_AT_mutable:                 return "DW_AT_mutable";
1892
    case DW_AT_threads_scaled:          return "DW_AT_threads_scaled";
1893
    case DW_AT_explicit:                return "DW_AT_explicit";
1894
    case DW_AT_object_pointer:          return "DW_AT_object_pointer";
1895
    case DW_AT_endianity:               return "DW_AT_endianity";
1896
    case DW_AT_elemental:               return "DW_AT_elemental";
1897
    case DW_AT_pure:                    return "DW_AT_pure";
1898
    case DW_AT_recursive:               return "DW_AT_recursive";
1899
      /* DWARF 4 values.  */
1900
    case DW_AT_signature:               return "DW_AT_signature";
1901
    case DW_AT_main_subprogram:         return "DW_AT_main_subprogram";
1902
    case DW_AT_data_bit_offset:         return "DW_AT_data_bit_offset";
1903
    case DW_AT_const_expr:              return "DW_AT_const_expr";
1904
    case DW_AT_enum_class:              return "DW_AT_enum_class";
1905
    case DW_AT_linkage_name:            return "DW_AT_linkage_name";
1906
 
1907
      /* HP and SGI/MIPS extensions.  */
1908
    case DW_AT_MIPS_loop_begin:                 return "DW_AT_MIPS_loop_begin";
1909
    case DW_AT_MIPS_tail_loop_begin:            return "DW_AT_MIPS_tail_loop_begin";
1910
    case DW_AT_MIPS_epilog_begin:               return "DW_AT_MIPS_epilog_begin";
1911
    case DW_AT_MIPS_loop_unroll_factor:         return "DW_AT_MIPS_loop_unroll_factor";
1912
    case DW_AT_MIPS_software_pipeline_depth:    return "DW_AT_MIPS_software_pipeline_depth";
1913
    case DW_AT_MIPS_linkage_name:               return "DW_AT_MIPS_linkage_name";
1914
    case DW_AT_MIPS_stride:                     return "DW_AT_MIPS_stride";
1915
    case DW_AT_MIPS_abstract_name:              return "DW_AT_MIPS_abstract_name";
1916
    case DW_AT_MIPS_clone_origin:               return "DW_AT_MIPS_clone_origin";
1917
    case DW_AT_MIPS_has_inlines:                return "DW_AT_MIPS_has_inlines";
1918
 
1919
      /* HP Extensions.  */
1920
    case DW_AT_HP_block_index:                  return "DW_AT_HP_block_index";
1921
    case DW_AT_HP_actuals_stmt_list:            return "DW_AT_HP_actuals_stmt_list";
1922
    case DW_AT_HP_proc_per_section:             return "DW_AT_HP_proc_per_section";
1923
    case DW_AT_HP_raw_data_ptr:                 return "DW_AT_HP_raw_data_ptr";
1924
    case DW_AT_HP_pass_by_reference:            return "DW_AT_HP_pass_by_reference";
1925
    case DW_AT_HP_opt_level:                    return "DW_AT_HP_opt_level";
1926
    case DW_AT_HP_prof_version_id:              return "DW_AT_HP_prof_version_id";
1927
    case DW_AT_HP_opt_flags:                    return "DW_AT_HP_opt_flags";
1928
    case DW_AT_HP_cold_region_low_pc:           return "DW_AT_HP_cold_region_low_pc";
1929
    case DW_AT_HP_cold_region_high_pc:          return "DW_AT_HP_cold_region_high_pc";
1930
    case DW_AT_HP_all_variables_modifiable:     return "DW_AT_HP_all_variables_modifiable";
1931
    case DW_AT_HP_linkage_name:                 return "DW_AT_HP_linkage_name";
1932
    case DW_AT_HP_prof_flags:                   return "DW_AT_HP_prof_flags";
1933
 
1934
      /* One value is shared by the MIPS and HP extensions:  */
1935
    case DW_AT_MIPS_fde:                        return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
1936
 
1937
      /* GNU extensions.  */
1938
    case DW_AT_sf_names:                        return "DW_AT_sf_names";
1939
    case DW_AT_src_info:                        return "DW_AT_src_info";
1940
    case DW_AT_mac_info:                        return "DW_AT_mac_info";
1941
    case DW_AT_src_coords:                      return "DW_AT_src_coords";
1942
    case DW_AT_body_begin:                      return "DW_AT_body_begin";
1943
    case DW_AT_body_end:                        return "DW_AT_body_end";
1944
    case DW_AT_GNU_vector:                      return "DW_AT_GNU_vector";
1945
    case DW_AT_GNU_guarded_by:                  return "DW_AT_GNU_guarded_by";
1946
    case DW_AT_GNU_pt_guarded_by:               return "DW_AT_GNU_pt_guarded_by";
1947
    case DW_AT_GNU_guarded:                     return "DW_AT_GNU_guarded";
1948
    case DW_AT_GNU_pt_guarded:                  return "DW_AT_GNU_pt_guarded";
1949
    case DW_AT_GNU_locks_excluded:              return "DW_AT_GNU_locks_excluded";
1950
    case DW_AT_GNU_exclusive_locks_required:    return "DW_AT_GNU_exclusive_locks_required";
1951
    case DW_AT_GNU_shared_locks_required:       return "DW_AT_GNU_shared_locks_required";
1952
    case DW_AT_GNU_odr_signature:               return "DW_AT_GNU_odr_signature";
1953
    case DW_AT_use_GNAT_descriptive_type:       return "DW_AT_use_GNAT_descriptive_type";
1954
    case DW_AT_GNAT_descriptive_type:           return "DW_AT_GNAT_descriptive_type";
1955
    case DW_AT_GNU_call_site_value:             return "DW_AT_GNU_call_site_value";
1956
    case DW_AT_GNU_call_site_data_value:        return "DW_AT_GNU_call_site_data_value";
1957
    case DW_AT_GNU_call_site_target:            return "DW_AT_GNU_call_site_target";
1958
    case DW_AT_GNU_call_site_target_clobbered:  return "DW_AT_GNU_call_site_target_clobbered";
1959
    case DW_AT_GNU_tail_call:                   return "DW_AT_GNU_tail_call";
1960
    case DW_AT_GNU_all_tail_call_sites:         return "DW_AT_GNU_all_tail_call_sites";
1961
    case DW_AT_GNU_all_call_sites:              return "DW_AT_GNU_all_call_sites";
1962
    case DW_AT_GNU_all_source_call_sites:       return "DW_AT_GNU_all_source_call_sites";
1963 161 khays
    case DW_AT_GNU_macros:                      return "DW_AT_GNU_macros";
1964 15 khays
 
1965
      /* UPC extension.  */
1966
    case DW_AT_upc_threads_scaled:      return "DW_AT_upc_threads_scaled";
1967
 
1968
    /* PGI (STMicroelectronics) extensions.  */
1969
    case DW_AT_PGI_lbase:               return "DW_AT_PGI_lbase";
1970
    case DW_AT_PGI_soffset:             return "DW_AT_PGI_soffset";
1971
    case DW_AT_PGI_lstride:             return "DW_AT_PGI_lstride";
1972
 
1973
    default:
1974
      {
1975
        static char buffer[100];
1976
 
1977
        snprintf (buffer, sizeof (buffer), _("Unknown AT value: %lx"),
1978
                  attribute);
1979
        return buffer;
1980
      }
1981
    }
1982
}
1983
 
1984
static unsigned char *
1985
read_and_display_attr (unsigned long attribute,
1986
                       unsigned long form,
1987
                       unsigned char * data,
1988
                       dwarf_vma cu_offset,
1989
                       dwarf_vma pointer_size,
1990
                       dwarf_vma offset_size,
1991
                       int dwarf_version,
1992
                       debug_info * debug_info_p,
1993
                       int do_loc,
1994
                       struct dwarf_section * section)
1995
{
1996
  if (!do_loc)
1997
    printf ("   %-18s:", get_AT_name (attribute));
1998
  data = read_and_display_attr_value (attribute, form, data, cu_offset,
1999
                                      pointer_size, offset_size,
2000
                                      dwarf_version, debug_info_p,
2001
                                      do_loc, section);
2002
  if (!do_loc)
2003
    printf ("\n");
2004
  return data;
2005
}
2006
 
2007
 
2008
/* Process the contents of a .debug_info section.  If do_loc is non-zero
2009
   then we are scanning for location lists and we do not want to display
2010
   anything to the user.  If do_types is non-zero, we are processing
2011
   a .debug_types section instead of a .debug_info section.  */
2012
 
2013
static int
2014
process_debug_info (struct dwarf_section *section,
2015
                    void *file,
2016
                    enum dwarf_section_display_enum abbrev_sec,
2017
                    int do_loc,
2018
                    int do_types)
2019
{
2020
  unsigned char *start = section->start;
2021
  unsigned char *end = start + section->size;
2022
  unsigned char *section_begin;
2023
  unsigned int unit;
2024
  unsigned int num_units = 0;
2025
 
2026
  if ((do_loc || do_debug_loc || do_debug_ranges)
2027
      && num_debug_info_entries == 0
2028
      && ! do_types)
2029
    {
2030
      dwarf_vma length;
2031
 
2032
      /* First scan the section to get the number of comp units.  */
2033
      for (section_begin = start, num_units = 0; section_begin < end;
2034
           num_units ++)
2035
        {
2036
          /* Read the first 4 bytes.  For a 32-bit DWARF section, this
2037
             will be the length.  For a 64-bit DWARF section, it'll be
2038
             the escape code 0xffffffff followed by an 8 byte length.  */
2039
          length = byte_get (section_begin, 4);
2040
 
2041
          if (length == 0xffffffff)
2042
            {
2043
              length = byte_get (section_begin + 4, 8);
2044
              section_begin += length + 12;
2045
            }
2046
          else if (length >= 0xfffffff0 && length < 0xffffffff)
2047
            {
2048
              warn (_("Reserved length value (0x%s) found in section %s\n"),
2049
                    dwarf_vmatoa ("x", length), section->name);
2050
              return 0;
2051
            }
2052
          else
2053
            section_begin += length + 4;
2054
 
2055
          /* Negative values are illegal, they may even cause infinite
2056
             looping.  This can happen if we can't accurately apply
2057
             relocations to an object file.  */
2058
          if ((signed long) length <= 0)
2059
            {
2060
              warn (_("Corrupt unit length (0x%s) found in section %s\n"),
2061
                    dwarf_vmatoa ("x", length), section->name);
2062
              return 0;
2063
            }
2064
        }
2065
 
2066
      if (num_units == 0)
2067
        {
2068
          error (_("No comp units in %s section ?"), section->name);
2069
          return 0;
2070
        }
2071
 
2072
      /* Then allocate an array to hold the information.  */
2073
      debug_information = (debug_info *) cmalloc (num_units,
2074
                                                  sizeof (* debug_information));
2075
      if (debug_information == NULL)
2076
        {
2077
          error (_("Not enough memory for a debug info array of %u entries"),
2078
                 num_units);
2079
          return 0;
2080
        }
2081
    }
2082
 
2083
  if (!do_loc)
2084
    {
2085
      if (dwarf_start_die == 0)
2086
        printf (_("Contents of the %s section:\n\n"), section->name);
2087
 
2088
      load_debug_section (str, file);
2089
    }
2090
 
2091
  load_debug_section (abbrev_sec, file);
2092
  if (debug_displays [abbrev_sec].section.start == NULL)
2093
    {
2094
      warn (_("Unable to locate %s section!\n"),
2095
            debug_displays [abbrev_sec].section.name);
2096
      return 0;
2097
    }
2098
 
2099
  for (section_begin = start, unit = 0; start < end; unit++)
2100
    {
2101
      DWARF2_Internal_CompUnit compunit;
2102
      unsigned char *hdrptr;
2103
      unsigned char *tags;
2104
      int level, last_level, saved_level;
2105
      dwarf_vma cu_offset;
2106
      int offset_size;
2107
      int initial_length_size;
2108
      unsigned char signature[8] = { 0 };
2109
      dwarf_vma type_offset = 0;
2110
 
2111
      hdrptr = start;
2112
 
2113
      compunit.cu_length = byte_get (hdrptr, 4);
2114
      hdrptr += 4;
2115
 
2116
      if (compunit.cu_length == 0xffffffff)
2117
        {
2118
          compunit.cu_length = byte_get (hdrptr, 8);
2119
          hdrptr += 8;
2120
          offset_size = 8;
2121
          initial_length_size = 12;
2122
        }
2123
      else
2124
        {
2125
          offset_size = 4;
2126
          initial_length_size = 4;
2127
        }
2128
 
2129
      compunit.cu_version = byte_get (hdrptr, 2);
2130
      hdrptr += 2;
2131
 
2132
      cu_offset = start - section_begin;
2133
 
2134
      compunit.cu_abbrev_offset = byte_get (hdrptr, offset_size);
2135
      hdrptr += offset_size;
2136
 
2137
      compunit.cu_pointer_size = byte_get (hdrptr, 1);
2138
      hdrptr += 1;
2139
 
2140
      if (do_types)
2141
        {
2142
          int i;
2143
 
2144
          for (i = 0; i < 8; i++)
2145
            {
2146
              signature[i] = byte_get (hdrptr, 1);
2147
              hdrptr += 1;
2148
            }
2149
 
2150
          type_offset = byte_get (hdrptr, offset_size);
2151
          hdrptr += offset_size;
2152
        }
2153
 
2154
      if ((do_loc || do_debug_loc || do_debug_ranges)
2155
          && num_debug_info_entries == 0
2156
          && ! do_types)
2157
        {
2158
          debug_information [unit].cu_offset = cu_offset;
2159
          debug_information [unit].pointer_size
2160
            = compunit.cu_pointer_size;
2161
          debug_information [unit].offset_size = offset_size;
2162
          debug_information [unit].dwarf_version = compunit.cu_version;
2163
          debug_information [unit].base_address = 0;
2164
          debug_information [unit].loc_offsets = NULL;
2165
          debug_information [unit].have_frame_base = NULL;
2166
          debug_information [unit].max_loc_offsets = 0;
2167
          debug_information [unit].num_loc_offsets = 0;
2168
          debug_information [unit].range_lists = NULL;
2169
          debug_information [unit].max_range_lists= 0;
2170
          debug_information [unit].num_range_lists = 0;
2171
        }
2172
 
2173
      if (!do_loc && dwarf_start_die == 0)
2174
        {
2175
          printf (_("  Compilation Unit @ offset 0x%s:\n"),
2176
                  dwarf_vmatoa ("x", cu_offset));
2177
          printf (_("   Length:        0x%s (%s)\n"),
2178
                  dwarf_vmatoa ("x", compunit.cu_length),
2179
                  offset_size == 8 ? "64-bit" : "32-bit");
2180
          printf (_("   Version:       %d\n"), compunit.cu_version);
2181
          printf (_("   Abbrev Offset: %s\n"),
2182
                  dwarf_vmatoa ("d", compunit.cu_abbrev_offset));
2183
          printf (_("   Pointer Size:  %d\n"), compunit.cu_pointer_size);
2184
          if (do_types)
2185
            {
2186
              int i;
2187
              printf (_("   Signature:     "));
2188
              for (i = 0; i < 8; i++)
2189
                printf ("%02x", signature[i]);
2190
              printf ("\n");
2191
             printf (_("   Type Offset:   0x%s\n"),
2192
                     dwarf_vmatoa ("x", type_offset));
2193
            }
2194
        }
2195
 
2196
      if (cu_offset + compunit.cu_length + initial_length_size
2197
          > section->size)
2198
        {
2199
          warn (_("Debug info is corrupted, length of CU at %s"
2200
                  " extends beyond end of section (length = %s)\n"),
2201
                dwarf_vmatoa ("x", cu_offset),
2202
                dwarf_vmatoa ("x", compunit.cu_length));
2203
          break;
2204
        }
2205
      tags = hdrptr;
2206
      start += compunit.cu_length + initial_length_size;
2207
 
2208
      if (compunit.cu_version != 2
2209
          && compunit.cu_version != 3
2210
          && compunit.cu_version != 4)
2211
        {
2212
          warn (_("CU at offset %s contains corrupt or "
2213
                  "unsupported version number: %d.\n"),
2214
                dwarf_vmatoa ("x", cu_offset), compunit.cu_version);
2215
          continue;
2216
        }
2217
 
2218
      free_abbrevs ();
2219
 
2220
      /* Process the abbrevs used by this compilation unit. DWARF
2221
         sections under Mach-O have non-zero addresses.  */
2222
      if (compunit.cu_abbrev_offset >= debug_displays [abbrev_sec].section.size)
2223
        warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
2224
              (unsigned long) compunit.cu_abbrev_offset,
2225
              (unsigned long) debug_displays [abbrev_sec].section.size);
2226
      else
2227
        process_abbrev_section
2228
          ((unsigned char *) debug_displays [abbrev_sec].section.start
2229
           + compunit.cu_abbrev_offset,
2230
           (unsigned char *) debug_displays [abbrev_sec].section.start
2231
           + debug_displays [abbrev_sec].section.size);
2232
 
2233
      level = 0;
2234
      last_level = level;
2235
      saved_level = -1;
2236
      while (tags < start)
2237
        {
2238
          unsigned int bytes_read;
2239
          unsigned long abbrev_number;
2240
          unsigned long die_offset;
2241
          abbrev_entry *entry;
2242
          abbrev_attr *attr;
2243
          int do_printing = 1;
2244
 
2245
          die_offset = tags - section_begin;
2246
 
2247
          abbrev_number = read_leb128 (tags, & bytes_read, 0);
2248
          tags += bytes_read;
2249
 
2250
          /* A null DIE marks the end of a list of siblings or it may also be
2251
             a section padding.  */
2252
          if (abbrev_number == 0)
2253
            {
2254
              /* Check if it can be a section padding for the last CU.  */
2255
              if (level == 0 && start == end)
2256
                {
2257
                  unsigned char *chk;
2258
 
2259
                  for (chk = tags; chk < start; chk++)
2260
                    if (*chk != 0)
2261
                      break;
2262
                  if (chk == start)
2263
                    break;
2264
                }
2265
 
2266
              --level;
2267
              if (level < 0)
2268
                {
2269
                  static unsigned num_bogus_warns = 0;
2270
 
2271
                  if (num_bogus_warns < 3)
2272
                    {
2273
                      warn (_("Bogus end-of-siblings marker detected at offset %lx in .debug_info section\n"),
2274
                            die_offset);
2275
                      num_bogus_warns ++;
2276
                      if (num_bogus_warns == 3)
2277
                        warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
2278
                    }
2279
                }
2280
              if (dwarf_start_die != 0 && level < saved_level)
2281
                return 1;
2282
              continue;
2283
            }
2284
 
2285
          if (!do_loc)
2286
            {
2287
              if (dwarf_start_die != 0 && die_offset < dwarf_start_die)
2288
                do_printing = 0;
2289
              else
2290
                {
2291
                  if (dwarf_start_die != 0 && die_offset == dwarf_start_die)
2292
                    saved_level = level;
2293
                  do_printing = (dwarf_cutoff_level == -1
2294
                                 || level < dwarf_cutoff_level);
2295
                  if (do_printing)
2296
                    printf (_(" <%d><%lx>: Abbrev Number: %lu"),
2297
                            level, die_offset, abbrev_number);
2298
                  else if (dwarf_cutoff_level == -1
2299
                           || last_level < dwarf_cutoff_level)
2300
                    printf (_(" <%d><%lx>: ...\n"), level, die_offset);
2301
                  last_level = level;
2302
                }
2303
            }
2304
 
2305
          /* Scan through the abbreviation list until we reach the
2306
             correct entry.  */
2307
          for (entry = first_abbrev;
2308
               entry && entry->entry != abbrev_number;
2309
               entry = entry->next)
2310
            continue;
2311
 
2312
          if (entry == NULL)
2313
            {
2314
              if (!do_loc && do_printing)
2315
                {
2316
                  printf ("\n");
2317
                  fflush (stdout);
2318
                }
2319
              warn (_("DIE at offset %lx refers to abbreviation number %lu which does not exist\n"),
2320
                    die_offset, abbrev_number);
2321
              return 0;
2322
            }
2323
 
2324
          if (!do_loc && do_printing)
2325
            printf (" (%s)\n", get_TAG_name (entry->tag));
2326
 
2327
          switch (entry->tag)
2328
            {
2329
            default:
2330
              need_base_address = 0;
2331
              break;
2332
            case DW_TAG_compile_unit:
2333
              need_base_address = 1;
2334
              break;
2335
            case DW_TAG_entry_point:
2336
            case DW_TAG_subprogram:
2337
              need_base_address = 0;
2338
              /* Assuming that there is no DW_AT_frame_base.  */
2339
              have_frame_base = 0;
2340
              break;
2341
            }
2342
 
2343
          for (attr = entry->first_attr; attr; attr = attr->next)
2344
            {
2345
              debug_info *arg;
2346
 
2347
              if (! do_loc && do_printing)
2348
                /* Show the offset from where the tag was extracted.  */
2349
                printf ("    <%lx>", (unsigned long)(tags - section_begin));
2350
 
2351
              arg = debug_information;
2352
              if (debug_information)
2353
                arg += unit;
2354
 
2355
              tags = read_and_display_attr (attr->attribute,
2356
                                            attr->form,
2357
                                            tags, cu_offset,
2358
                                            compunit.cu_pointer_size,
2359
                                            offset_size,
2360
                                            compunit.cu_version,
2361
                                            arg,
2362
                                            do_loc || ! do_printing, section);
2363
            }
2364
 
2365
          if (entry->children)
2366
            ++level;
2367
        }
2368
    }
2369
 
2370
  /* Set num_debug_info_entries here so that it can be used to check if
2371
     we need to process .debug_loc and .debug_ranges sections.  */
2372
  if ((do_loc || do_debug_loc || do_debug_ranges)
2373
      && num_debug_info_entries == 0
2374
      && ! do_types)
2375
    num_debug_info_entries = num_units;
2376
 
2377
  if (!do_loc)
2378
    printf ("\n");
2379
 
2380
  return 1;
2381
}
2382
 
2383
/* Locate and scan the .debug_info section in the file and record the pointer
2384
   sizes and offsets for the compilation units in it.  Usually an executable
2385
   will have just one pointer size, but this is not guaranteed, and so we try
2386
   not to make any assumptions.  Returns zero upon failure, or the number of
2387
   compilation units upon success.  */
2388
 
2389
static unsigned int
2390
load_debug_info (void * file)
2391
{
2392
  /* Reset the last pointer size so that we can issue correct error
2393
     messages if we are displaying the contents of more than one section.  */
2394
  last_pointer_size = 0;
2395
  warned_about_missing_comp_units = FALSE;
2396
 
2397
  /* If we have already tried and failed to load the .debug_info
2398
     section then do not bother to repear the task.  */
2399
  if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
2400
    return 0;
2401
 
2402
  /* If we already have the information there is nothing else to do.  */
2403
  if (num_debug_info_entries > 0)
2404
    return num_debug_info_entries;
2405
 
2406
  if (load_debug_section (info, file)
2407
      && process_debug_info (&debug_displays [info].section, file, abbrev, 1, 0))
2408
    return num_debug_info_entries;
2409
 
2410
  num_debug_info_entries = DEBUG_INFO_UNAVAILABLE;
2411
  return 0;
2412
}
2413
 
2414
static int
2415
display_debug_lines_raw (struct dwarf_section *section,
2416
                         unsigned char *data,
2417
                         unsigned char *end)
2418
{
2419
  unsigned char *start = section->start;
2420
 
2421
  printf (_("Raw dump of debug contents of section %s:\n\n"),
2422
          section->name);
2423
 
2424
  while (data < end)
2425
    {
2426
      DWARF2_Internal_LineInfo linfo;
2427
      unsigned char *standard_opcodes;
2428
      unsigned char *end_of_sequence;
2429
      unsigned char *hdrptr;
2430
      unsigned long hdroff;
2431
      int initial_length_size;
2432
      int offset_size;
2433
      int i;
2434
 
2435
      hdrptr = data;
2436
      hdroff = hdrptr - start;
2437
 
2438
      /* Check the length of the block.  */
2439
      linfo.li_length = byte_get (hdrptr, 4);
2440
      hdrptr += 4;
2441
 
2442
      if (linfo.li_length == 0xffffffff)
2443
        {
2444
          /* This section is 64-bit DWARF 3.  */
2445
          linfo.li_length = byte_get (hdrptr, 8);
2446
          hdrptr += 8;
2447
          offset_size = 8;
2448
          initial_length_size = 12;
2449
        }
2450
      else
2451
        {
2452
          offset_size = 4;
2453
          initial_length_size = 4;
2454
        }
2455
 
2456
      if (linfo.li_length + initial_length_size > section->size)
2457
        {
2458
          warn
2459
            (_("The information in section %s appears to be corrupt - the section is too small\n"),
2460
             section->name);
2461
          return 0;
2462
        }
2463
 
2464
      /* Check its version number.  */
2465
      linfo.li_version = byte_get (hdrptr, 2);
2466
      hdrptr += 2;
2467
      if (linfo.li_version != 2
2468
          && linfo.li_version != 3
2469
          && linfo.li_version != 4)
2470
        {
2471
          warn (_("Only DWARF version 2, 3 and 4 line info is currently supported.\n"));
2472
          return 0;
2473
        }
2474
 
2475
      linfo.li_prologue_length = byte_get (hdrptr, offset_size);
2476
      hdrptr += offset_size;
2477
      linfo.li_min_insn_length = byte_get (hdrptr, 1);
2478
      hdrptr++;
2479
      if (linfo.li_version >= 4)
2480
        {
2481
          linfo.li_max_ops_per_insn = byte_get (hdrptr, 1);
2482
          hdrptr++;
2483
          if (linfo.li_max_ops_per_insn == 0)
2484
            {
2485
              warn (_("Invalid maximum operations per insn.\n"));
2486
              return 0;
2487
            }
2488
        }
2489
      else
2490
        linfo.li_max_ops_per_insn = 1;
2491
      linfo.li_default_is_stmt = byte_get (hdrptr, 1);
2492
      hdrptr++;
2493
      linfo.li_line_base = byte_get (hdrptr, 1);
2494
      hdrptr++;
2495
      linfo.li_line_range = byte_get (hdrptr, 1);
2496
      hdrptr++;
2497
      linfo.li_opcode_base = byte_get (hdrptr, 1);
2498
      hdrptr++;
2499
 
2500
      /* Sign extend the line base field.  */
2501
      linfo.li_line_base <<= 24;
2502
      linfo.li_line_base >>= 24;
2503
 
2504
      printf (_("  Offset:                      0x%lx\n"), hdroff);
2505
      printf (_("  Length:                      %ld\n"), (long) linfo.li_length);
2506
      printf (_("  DWARF Version:               %d\n"), linfo.li_version);
2507
      printf (_("  Prologue Length:             %d\n"), linfo.li_prologue_length);
2508
      printf (_("  Minimum Instruction Length:  %d\n"), linfo.li_min_insn_length);
2509
      if (linfo.li_version >= 4)
2510
        printf (_("  Maximum Ops per Instruction: %d\n"), linfo.li_max_ops_per_insn);
2511
      printf (_("  Initial value of 'is_stmt':  %d\n"), linfo.li_default_is_stmt);
2512
      printf (_("  Line Base:                   %d\n"), linfo.li_line_base);
2513
      printf (_("  Line Range:                  %d\n"), linfo.li_line_range);
2514
      printf (_("  Opcode Base:                 %d\n"), linfo.li_opcode_base);
2515
 
2516
      end_of_sequence = data + linfo.li_length + initial_length_size;
2517
 
2518
      reset_state_machine (linfo.li_default_is_stmt);
2519
 
2520
      /* Display the contents of the Opcodes table.  */
2521
      standard_opcodes = hdrptr;
2522
 
2523
      printf (_("\n Opcodes:\n"));
2524
 
2525
      for (i = 1; i < linfo.li_opcode_base; i++)
2526
        printf (_("  Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
2527
 
2528
      /* Display the contents of the Directory table.  */
2529
      data = standard_opcodes + linfo.li_opcode_base - 1;
2530
 
2531
      if (*data == 0)
2532
        printf (_("\n The Directory Table is empty.\n"));
2533
      else
2534
        {
2535
          printf (_("\n The Directory Table:\n"));
2536
 
2537
          while (*data != 0)
2538
            {
2539
              printf ("  %s\n", data);
2540
 
2541
              data += strlen ((char *) data) + 1;
2542
            }
2543
        }
2544
 
2545
      /* Skip the NUL at the end of the table.  */
2546
      data++;
2547
 
2548
      /* Display the contents of the File Name table.  */
2549
      if (*data == 0)
2550
        printf (_("\n The File Name Table is empty.\n"));
2551
      else
2552
        {
2553
          printf (_("\n The File Name Table:\n"));
2554
          printf (_("  Entry\tDir\tTime\tSize\tName\n"));
2555
 
2556
          while (*data != 0)
2557
            {
2558
              unsigned char *name;
2559
              unsigned int bytes_read;
2560
 
2561
              printf ("  %d\t", ++state_machine_regs.last_file_entry);
2562
              name = data;
2563
 
2564
              data += strlen ((char *) data) + 1;
2565
 
2566
              printf ("%s\t",
2567
                      dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
2568
              data += bytes_read;
2569
              printf ("%s\t",
2570
                      dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
2571
              data += bytes_read;
2572
              printf ("%s\t",
2573
                      dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
2574
              data += bytes_read;
2575
              printf ("%s\n", name);
2576
            }
2577
        }
2578
 
2579
      /* Skip the NUL at the end of the table.  */
2580
      data++;
2581
 
2582
      /* Now display the statements.  */
2583
      printf (_("\n Line Number Statements:\n"));
2584
 
2585
      while (data < end_of_sequence)
2586
        {
2587
          unsigned char op_code;
2588
          dwarf_signed_vma adv;
2589
          dwarf_vma uladv;
2590
          unsigned int bytes_read;
2591
 
2592
          op_code = *data++;
2593
 
2594
          if (op_code >= linfo.li_opcode_base)
2595
            {
2596
              op_code -= linfo.li_opcode_base;
2597
              uladv = (op_code / linfo.li_line_range);
2598
              if (linfo.li_max_ops_per_insn == 1)
2599
                {
2600
                  uladv *= linfo.li_min_insn_length;
2601
                  state_machine_regs.address += uladv;
2602
                  printf (_("  Special opcode %d: "
2603
                            "advance Address by %s to 0x%s"),
2604
                          op_code, dwarf_vmatoa ("u", uladv),
2605
                          dwarf_vmatoa ("x", state_machine_regs.address));
2606
                }
2607
              else
2608
                {
2609
                  state_machine_regs.address
2610
                    += ((state_machine_regs.op_index + uladv)
2611
                        / linfo.li_max_ops_per_insn)
2612
                       * linfo.li_min_insn_length;
2613
                  state_machine_regs.op_index
2614
                    = (state_machine_regs.op_index + uladv)
2615
                      % linfo.li_max_ops_per_insn;
2616
                  printf (_("  Special opcode %d: "
2617
                            "advance Address by %s to 0x%s[%d]"),
2618
                          op_code, dwarf_vmatoa ("u", uladv),
2619
                          dwarf_vmatoa ("x", state_machine_regs.address),
2620
                          state_machine_regs.op_index);
2621
                }
2622
              adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
2623
              state_machine_regs.line += adv;
2624
              printf (_(" and Line by %s to %d\n"),
2625
                      dwarf_vmatoa ("d", adv), state_machine_regs.line);
2626
            }
2627
          else switch (op_code)
2628
            {
2629
            case DW_LNS_extended_op:
2630
              data += process_extended_line_op (data, linfo.li_default_is_stmt);
2631
              break;
2632
 
2633
            case DW_LNS_copy:
2634
              printf (_("  Copy\n"));
2635
              break;
2636
 
2637
            case DW_LNS_advance_pc:
2638
              uladv = read_leb128 (data, & bytes_read, 0);
2639
              data += bytes_read;
2640
              if (linfo.li_max_ops_per_insn == 1)
2641
                {
2642
                  uladv *= linfo.li_min_insn_length;
2643
                  state_machine_regs.address += uladv;
2644
                  printf (_("  Advance PC by %s to 0x%s\n"),
2645
                          dwarf_vmatoa ("u", uladv),
2646
                          dwarf_vmatoa ("x", state_machine_regs.address));
2647
                }
2648
              else
2649
                {
2650
                  state_machine_regs.address
2651
                    += ((state_machine_regs.op_index + uladv)
2652
                        / linfo.li_max_ops_per_insn)
2653
                       * linfo.li_min_insn_length;
2654
                  state_machine_regs.op_index
2655
                    = (state_machine_regs.op_index + uladv)
2656
                      % linfo.li_max_ops_per_insn;
2657
                  printf (_("  Advance PC by %s to 0x%s[%d]\n"),
2658
                          dwarf_vmatoa ("u", uladv),
2659
                          dwarf_vmatoa ("x", state_machine_regs.address),
2660
                          state_machine_regs.op_index);
2661
                }
2662
              break;
2663
 
2664
            case DW_LNS_advance_line:
2665
              adv = read_sleb128 (data, & bytes_read);
2666
              data += bytes_read;
2667
              state_machine_regs.line += adv;
2668
              printf (_("  Advance Line by %s to %d\n"),
2669
                        dwarf_vmatoa ("d", adv),
2670
                        state_machine_regs.line);
2671
              break;
2672
 
2673
            case DW_LNS_set_file:
2674
              adv = read_leb128 (data, & bytes_read, 0);
2675
              data += bytes_read;
2676
              printf (_("  Set File Name to entry %s in the File Name Table\n"),
2677
                      dwarf_vmatoa ("d", adv));
2678
              state_machine_regs.file = adv;
2679
              break;
2680
 
2681
            case DW_LNS_set_column:
2682
              uladv = read_leb128 (data, & bytes_read, 0);
2683
              data += bytes_read;
2684
              printf (_("  Set column to %s\n"),
2685
                      dwarf_vmatoa ("u", uladv));
2686
              state_machine_regs.column = uladv;
2687
              break;
2688
 
2689
            case DW_LNS_negate_stmt:
2690
              adv = state_machine_regs.is_stmt;
2691
              adv = ! adv;
2692
              printf (_("  Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv));
2693
              state_machine_regs.is_stmt = adv;
2694
              break;
2695
 
2696
            case DW_LNS_set_basic_block:
2697
              printf (_("  Set basic block\n"));
2698
              state_machine_regs.basic_block = 1;
2699
              break;
2700
 
2701
            case DW_LNS_const_add_pc:
2702
              uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
2703
              if (linfo.li_max_ops_per_insn)
2704
                {
2705
                  uladv *= linfo.li_min_insn_length;
2706
                  state_machine_regs.address += uladv;
2707
                  printf (_("  Advance PC by constant %s to 0x%s\n"),
2708
                          dwarf_vmatoa ("u", uladv),
2709
                          dwarf_vmatoa ("x", state_machine_regs.address));
2710
                }
2711
              else
2712
                {
2713
                  state_machine_regs.address
2714
                    += ((state_machine_regs.op_index + uladv)
2715
                        / linfo.li_max_ops_per_insn)
2716
                       * linfo.li_min_insn_length;
2717
                  state_machine_regs.op_index
2718
                    = (state_machine_regs.op_index + uladv)
2719
                      % linfo.li_max_ops_per_insn;
2720
                  printf (_("  Advance PC by constant %s to 0x%s[%d]\n"),
2721
                          dwarf_vmatoa ("u", uladv),
2722
                          dwarf_vmatoa ("x", state_machine_regs.address),
2723
                          state_machine_regs.op_index);
2724
                }
2725
              break;
2726
 
2727
            case DW_LNS_fixed_advance_pc:
2728
              uladv = byte_get (data, 2);
2729
              data += 2;
2730
              state_machine_regs.address += uladv;
2731
              state_machine_regs.op_index = 0;
2732
              printf (_("  Advance PC by fixed size amount %s to 0x%s\n"),
2733
                      dwarf_vmatoa ("u", uladv),
2734
                      dwarf_vmatoa ("x", state_machine_regs.address));
2735
              break;
2736
 
2737
            case DW_LNS_set_prologue_end:
2738
              printf (_("  Set prologue_end to true\n"));
2739
              break;
2740
 
2741
            case DW_LNS_set_epilogue_begin:
2742
              printf (_("  Set epilogue_begin to true\n"));
2743
              break;
2744
 
2745
            case DW_LNS_set_isa:
2746
              uladv = read_leb128 (data, & bytes_read, 0);
2747
              data += bytes_read;
2748
              printf (_("  Set ISA to %s\n"), dwarf_vmatoa ("u", uladv));
2749
              break;
2750
 
2751
            default:
2752
              printf (_("  Unknown opcode %d with operands: "), op_code);
2753
 
2754
              for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
2755
                {
2756
                  printf ("0x%s%s", dwarf_vmatoa ("x", read_leb128 (data,
2757
                                                         &bytes_read, 0)),
2758
                          i == 1 ? "" : ", ");
2759
                  data += bytes_read;
2760
                }
2761
              putchar ('\n');
2762
              break;
2763
            }
2764
        }
2765
      putchar ('\n');
2766
    }
2767
 
2768
  return 1;
2769
}
2770
 
2771
typedef struct
2772
{
2773
  unsigned char *name;
2774
  unsigned int directory_index;
2775
  unsigned int modification_date;
2776
  unsigned int length;
2777
} File_Entry;
2778
 
2779
/* Output a decoded representation of the .debug_line section.  */
2780
 
2781
static int
2782
display_debug_lines_decoded (struct dwarf_section *section,
2783
                             unsigned char *data,
2784
                             unsigned char *end)
2785
{
2786
  printf (_("Decoded dump of debug contents of section %s:\n\n"),
2787
          section->name);
2788
 
2789
  while (data < end)
2790
    {
2791
      /* This loop amounts to one iteration per compilation unit.  */
2792
      DWARF2_Internal_LineInfo linfo;
2793
      unsigned char *standard_opcodes;
2794
      unsigned char *end_of_sequence;
2795
      unsigned char *hdrptr;
2796
      int initial_length_size;
2797
      int offset_size;
2798
      int i;
2799
      File_Entry *file_table = NULL;
2800
      unsigned char **directory_table = NULL;
2801
 
2802
      hdrptr = data;
2803
 
2804
      /* Extract information from the Line Number Program Header.
2805
        (section 6.2.4 in the Dwarf3 doc).  */
2806
 
2807
      /* Get the length of this CU's line number information block.  */
2808
      linfo.li_length = byte_get (hdrptr, 4);
2809
      hdrptr += 4;
2810
 
2811
      if (linfo.li_length == 0xffffffff)
2812
        {
2813
          /* This section is 64-bit DWARF 3.  */
2814
          linfo.li_length = byte_get (hdrptr, 8);
2815
          hdrptr += 8;
2816
          offset_size = 8;
2817
          initial_length_size = 12;
2818
        }
2819
      else
2820
        {
2821
          offset_size = 4;
2822
          initial_length_size = 4;
2823
        }
2824
 
2825
      if (linfo.li_length + initial_length_size > section->size)
2826
        {
2827
          warn (_("The line info appears to be corrupt - "
2828
                  "the section is too small\n"));
2829
          return 0;
2830
        }
2831
 
2832
      /* Get this CU's Line Number Block version number.  */
2833
      linfo.li_version = byte_get (hdrptr, 2);
2834
      hdrptr += 2;
2835
      if (linfo.li_version != 2
2836
          && linfo.li_version != 3
2837
          && linfo.li_version != 4)
2838
        {
2839
          warn (_("Only DWARF version 2, 3 and 4 line info is currently "
2840
                "supported.\n"));
2841
          return 0;
2842
        }
2843
 
2844
      linfo.li_prologue_length = byte_get (hdrptr, offset_size);
2845
      hdrptr += offset_size;
2846
      linfo.li_min_insn_length = byte_get (hdrptr, 1);
2847
      hdrptr++;
2848
      if (linfo.li_version >= 4)
2849
        {
2850
          linfo.li_max_ops_per_insn = byte_get (hdrptr, 1);
2851
          hdrptr++;
2852
          if (linfo.li_max_ops_per_insn == 0)
2853
            {
2854
              warn (_("Invalid maximum operations per insn.\n"));
2855
              return 0;
2856
            }
2857
        }
2858
      else
2859
        linfo.li_max_ops_per_insn = 1;
2860
      linfo.li_default_is_stmt = byte_get (hdrptr, 1);
2861
      hdrptr++;
2862
      linfo.li_line_base = byte_get (hdrptr, 1);
2863
      hdrptr++;
2864
      linfo.li_line_range = byte_get (hdrptr, 1);
2865
      hdrptr++;
2866
      linfo.li_opcode_base = byte_get (hdrptr, 1);
2867
      hdrptr++;
2868
 
2869
      /* Sign extend the line base field.  */
2870
      linfo.li_line_base <<= 24;
2871
      linfo.li_line_base >>= 24;
2872
 
2873
      /* Find the end of this CU's Line Number Information Block.  */
2874
      end_of_sequence = data + linfo.li_length + initial_length_size;
2875
 
2876
      reset_state_machine (linfo.li_default_is_stmt);
2877
 
2878
      /* Save a pointer to the contents of the Opcodes table.  */
2879
      standard_opcodes = hdrptr;
2880
 
2881
      /* Traverse the Directory table just to count entries.  */
2882
      data = standard_opcodes + linfo.li_opcode_base - 1;
2883
      if (*data != 0)
2884
        {
2885
          unsigned int n_directories = 0;
2886
          unsigned char *ptr_directory_table = data;
2887
 
2888
          while (*data != 0)
2889
            {
2890
              data += strlen ((char *) data) + 1;
2891
              n_directories++;
2892
            }
2893
 
2894
          /* Go through the directory table again to save the directories.  */
2895
          directory_table = (unsigned char **)
2896
              xmalloc (n_directories * sizeof (unsigned char *));
2897
 
2898
          i = 0;
2899
          while (*ptr_directory_table != 0)
2900
            {
2901
              directory_table[i] = ptr_directory_table;
2902
              ptr_directory_table += strlen ((char *) ptr_directory_table) + 1;
2903
              i++;
2904
            }
2905
        }
2906
      /* Skip the NUL at the end of the table.  */
2907
      data++;
2908
 
2909
      /* Traverse the File Name table just to count the entries.  */
2910
      if (*data != 0)
2911
        {
2912
          unsigned int n_files = 0;
2913
          unsigned char *ptr_file_name_table = data;
2914
 
2915
          while (*data != 0)
2916
            {
2917
              unsigned int bytes_read;
2918
 
2919
              /* Skip Name, directory index, last modification time and length
2920
                 of file.  */
2921
              data += strlen ((char *) data) + 1;
2922
              read_leb128 (data, & bytes_read, 0);
2923
              data += bytes_read;
2924
              read_leb128 (data, & bytes_read, 0);
2925
              data += bytes_read;
2926
              read_leb128 (data, & bytes_read, 0);
2927
              data += bytes_read;
2928
 
2929
              n_files++;
2930
            }
2931
 
2932
          /* Go through the file table again to save the strings.  */
2933
          file_table = (File_Entry *) xmalloc (n_files * sizeof (File_Entry));
2934
 
2935
          i = 0;
2936
          while (*ptr_file_name_table != 0)
2937
            {
2938
              unsigned int bytes_read;
2939
 
2940
              file_table[i].name = ptr_file_name_table;
2941
              ptr_file_name_table += strlen ((char *) ptr_file_name_table) + 1;
2942
 
2943
              /* We are not interested in directory, time or size.  */
2944
              file_table[i].directory_index = read_leb128 (ptr_file_name_table,
2945
                                                           & bytes_read, 0);
2946
              ptr_file_name_table += bytes_read;
2947
              file_table[i].modification_date = read_leb128 (ptr_file_name_table,
2948
                                                             & bytes_read, 0);
2949
              ptr_file_name_table += bytes_read;
2950
              file_table[i].length = read_leb128 (ptr_file_name_table, & bytes_read, 0);
2951
              ptr_file_name_table += bytes_read;
2952
              i++;
2953
            }
2954
          i = 0;
2955
 
2956
          /* Print the Compilation Unit's name and a header.  */
2957
          if (directory_table == NULL)
2958
            {
2959
              printf (_("CU: %s:\n"), file_table[0].name);
2960
              printf (_("File name                            Line number    Starting address\n"));
2961
            }
2962
          else
2963
            {
2964
              if (do_wide || strlen ((char *) directory_table[0]) < 76)
2965
                printf (_("CU: %s/%s:\n"), directory_table[0],
2966
                        file_table[0].name);
2967
              else
2968
                printf ("%s:\n", file_table[0].name);
2969
 
2970
              printf (_("File name                            Line number    Starting address\n"));
2971
            }
2972
        }
2973
 
2974
      /* Skip the NUL at the end of the table.  */
2975
      data++;
2976
 
2977
      /* This loop iterates through the Dwarf Line Number Program.  */
2978
      while (data < end_of_sequence)
2979
        {
2980
          unsigned char op_code;
2981
          int adv;
2982
          unsigned long int uladv;
2983
          unsigned int bytes_read;
2984
          int is_special_opcode = 0;
2985
 
2986
          op_code = *data++;
2987
 
2988
          if (op_code >= linfo.li_opcode_base)
2989
            {
2990
              op_code -= linfo.li_opcode_base;
2991
              uladv = (op_code / linfo.li_line_range);
2992
              if (linfo.li_max_ops_per_insn == 1)
2993
                {
2994
                  uladv *= linfo.li_min_insn_length;
2995
                  state_machine_regs.address += uladv;
2996
                }
2997
              else
2998
                {
2999
                  state_machine_regs.address
3000
                    += ((state_machine_regs.op_index + uladv)
3001
                        / linfo.li_max_ops_per_insn)
3002
                       * linfo.li_min_insn_length;
3003
                  state_machine_regs.op_index
3004
                    = (state_machine_regs.op_index + uladv)
3005
                      % linfo.li_max_ops_per_insn;
3006
                }
3007
 
3008
              adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
3009
              state_machine_regs.line += adv;
3010
              is_special_opcode = 1;
3011
            }
3012
          else switch (op_code)
3013
            {
3014
            case DW_LNS_extended_op:
3015
              {
3016
                unsigned int ext_op_code_len;
3017
                unsigned char ext_op_code;
3018
                unsigned char *op_code_data = data;
3019
 
3020
                ext_op_code_len = read_leb128 (op_code_data, &bytes_read, 0);
3021
                op_code_data += bytes_read;
3022
 
3023
                if (ext_op_code_len == 0)
3024
                  {
3025
                    warn (_("badly formed extended line op encountered!\n"));
3026
                    break;
3027
                  }
3028
                ext_op_code_len += bytes_read;
3029
                ext_op_code = *op_code_data++;
3030
 
3031
                switch (ext_op_code)
3032
                  {
3033
                  case DW_LNE_end_sequence:
3034
                    reset_state_machine (linfo.li_default_is_stmt);
3035
                    break;
3036
                  case DW_LNE_set_address:
3037
                    state_machine_regs.address =
3038
                    byte_get (op_code_data, ext_op_code_len - bytes_read - 1);
3039
                    state_machine_regs.op_index = 0;
3040
                    break;
3041
                  case DW_LNE_define_file:
3042
                    {
3043
                      unsigned int dir_index = 0;
3044
 
3045
                      ++state_machine_regs.last_file_entry;
3046
                      op_code_data += strlen ((char *) op_code_data) + 1;
3047
                      dir_index = read_leb128 (op_code_data, & bytes_read, 0);
3048
                      op_code_data += bytes_read;
3049
                      read_leb128 (op_code_data, & bytes_read, 0);
3050
                      op_code_data += bytes_read;
3051
                      read_leb128 (op_code_data, & bytes_read, 0);
3052
 
3053
                      printf ("%s:\n", directory_table[dir_index]);
3054
                      break;
3055
                    }
3056
                  default:
3057
                    printf (_("UNKNOWN: length %d\n"), ext_op_code_len - bytes_read);
3058
                    break;
3059
                  }
3060
                data += ext_op_code_len;
3061
                break;
3062
              }
3063
            case DW_LNS_copy:
3064
              break;
3065
 
3066
            case DW_LNS_advance_pc:
3067
              uladv = read_leb128 (data, & bytes_read, 0);
3068
              data += bytes_read;
3069
              if (linfo.li_max_ops_per_insn == 1)
3070
                {
3071
                  uladv *= linfo.li_min_insn_length;
3072
                  state_machine_regs.address += uladv;
3073
                }
3074
              else
3075
                {
3076
                  state_machine_regs.address
3077
                    += ((state_machine_regs.op_index + uladv)
3078
                        / linfo.li_max_ops_per_insn)
3079
                       * linfo.li_min_insn_length;
3080
                  state_machine_regs.op_index
3081
                    = (state_machine_regs.op_index + uladv)
3082
                      % linfo.li_max_ops_per_insn;
3083
                }
3084
              break;
3085
 
3086
            case DW_LNS_advance_line:
3087
              adv = read_sleb128 (data, & bytes_read);
3088
              data += bytes_read;
3089
              state_machine_regs.line += adv;
3090
              break;
3091
 
3092
            case DW_LNS_set_file:
3093
              adv = read_leb128 (data, & bytes_read, 0);
3094
              data += bytes_read;
3095
              state_machine_regs.file = adv;
3096
              if (file_table[state_machine_regs.file - 1].directory_index == 0)
3097
                {
3098
                  /* If directory index is 0, that means current directory.  */
3099
                  printf ("\n./%s:[++]\n",
3100
                          file_table[state_machine_regs.file - 1].name);
3101
                }
3102
              else
3103
                {
3104
                  /* The directory index starts counting at 1.  */
3105
                  printf ("\n%s/%s:\n",
3106
                          directory_table[file_table[state_machine_regs.file - 1].directory_index - 1],
3107
                          file_table[state_machine_regs.file - 1].name);
3108
                }
3109
              break;
3110
 
3111
            case DW_LNS_set_column:
3112
              uladv = read_leb128 (data, & bytes_read, 0);
3113
              data += bytes_read;
3114
              state_machine_regs.column = uladv;
3115
              break;
3116
 
3117
            case DW_LNS_negate_stmt:
3118
              adv = state_machine_regs.is_stmt;
3119
              adv = ! adv;
3120
              state_machine_regs.is_stmt = adv;
3121
              break;
3122
 
3123
            case DW_LNS_set_basic_block:
3124
              state_machine_regs.basic_block = 1;
3125
              break;
3126
 
3127
            case DW_LNS_const_add_pc:
3128
              uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
3129
              if (linfo.li_max_ops_per_insn == 1)
3130
                {
3131
                  uladv *= linfo.li_min_insn_length;
3132
                  state_machine_regs.address += uladv;
3133
                }
3134
              else
3135
                {
3136
                  state_machine_regs.address
3137
                    += ((state_machine_regs.op_index + uladv)
3138
                        / linfo.li_max_ops_per_insn)
3139
                       * linfo.li_min_insn_length;
3140
                  state_machine_regs.op_index
3141
                    = (state_machine_regs.op_index + uladv)
3142
                      % linfo.li_max_ops_per_insn;
3143
                }
3144
              break;
3145
 
3146
            case DW_LNS_fixed_advance_pc:
3147
              uladv = byte_get (data, 2);
3148
              data += 2;
3149
              state_machine_regs.address += uladv;
3150
              state_machine_regs.op_index = 0;
3151
              break;
3152
 
3153
            case DW_LNS_set_prologue_end:
3154
              break;
3155
 
3156
            case DW_LNS_set_epilogue_begin:
3157
              break;
3158
 
3159
            case DW_LNS_set_isa:
3160
              uladv = read_leb128 (data, & bytes_read, 0);
3161
              data += bytes_read;
3162
              printf (_("  Set ISA to %lu\n"), uladv);
3163
              break;
3164
 
3165
            default:
3166
              printf (_("  Unknown opcode %d with operands: "), op_code);
3167
 
3168
              for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
3169
                {
3170
                  printf ("0x%s%s", dwarf_vmatoa ("x", read_leb128 (data,
3171
                                                         &bytes_read, 0)),
3172
                          i == 1 ? "" : ", ");
3173
                  data += bytes_read;
3174
                }
3175
              putchar ('\n');
3176
              break;
3177
            }
3178
 
3179
          /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
3180
             to the DWARF address/line matrix.  */
3181
          if ((is_special_opcode) || (op_code == DW_LNE_end_sequence)
3182
              || (op_code == DW_LNS_copy))
3183
            {
3184
              const unsigned int MAX_FILENAME_LENGTH = 35;
3185
              char *fileName = (char *)file_table[state_machine_regs.file - 1].name;
3186
              char *newFileName = NULL;
3187
              size_t fileNameLength = strlen (fileName);
3188
 
3189
              if ((fileNameLength > MAX_FILENAME_LENGTH) && (!do_wide))
3190
                {
3191
                  newFileName = (char *) xmalloc (MAX_FILENAME_LENGTH + 1);
3192
                  /* Truncate file name */
3193
                  strncpy (newFileName,
3194
                           fileName + fileNameLength - MAX_FILENAME_LENGTH,
3195
                           MAX_FILENAME_LENGTH + 1);
3196
                }
3197
              else
3198
                {
3199
                  newFileName = (char *) xmalloc (fileNameLength + 1);
3200
                  strncpy (newFileName, fileName, fileNameLength + 1);
3201
                }
3202
 
3203
              if (!do_wide || (fileNameLength <= MAX_FILENAME_LENGTH))
3204
                {
3205
                  if (linfo.li_max_ops_per_insn == 1)
3206
                    printf ("%-35s  %11d  %#18" DWARF_VMA_FMT "x\n",
3207
                            newFileName, state_machine_regs.line,
3208
                            state_machine_regs.address);
3209
                  else
3210
                    printf ("%-35s  %11d  %#18" DWARF_VMA_FMT "x[%d]\n",
3211
                            newFileName, state_machine_regs.line,
3212
                            state_machine_regs.address,
3213
                            state_machine_regs.op_index);
3214
                }
3215
              else
3216
                {
3217
                  if (linfo.li_max_ops_per_insn == 1)
3218
                    printf ("%s  %11d  %#18" DWARF_VMA_FMT "x\n",
3219
                            newFileName, state_machine_regs.line,
3220
                            state_machine_regs.address);
3221
                  else
3222
                    printf ("%s  %11d  %#18" DWARF_VMA_FMT "x[%d]\n",
3223
                            newFileName, state_machine_regs.line,
3224
                            state_machine_regs.address,
3225
                            state_machine_regs.op_index);
3226
                }
3227
 
3228
              if (op_code == DW_LNE_end_sequence)
3229
                printf ("\n");
3230
 
3231
              free (newFileName);
3232
            }
3233
        }
3234
      free (file_table);
3235
      file_table = NULL;
3236
      free (directory_table);
3237
      directory_table = NULL;
3238
      putchar ('\n');
3239
    }
3240
 
3241
  return 1;
3242
}
3243
 
3244
static int
3245
display_debug_lines (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED)
3246
{
3247
  unsigned char *data = section->start;
3248
  unsigned char *end = data + section->size;
3249
  int retValRaw = 1;
3250
  int retValDecoded = 1;
3251
 
3252
  if (do_debug_lines == 0)
3253
    do_debug_lines |= FLAG_DEBUG_LINES_RAW;
3254
 
3255
  if (do_debug_lines & FLAG_DEBUG_LINES_RAW)
3256
    retValRaw = display_debug_lines_raw (section, data, end);
3257
 
3258
  if (do_debug_lines & FLAG_DEBUG_LINES_DECODED)
3259
    retValDecoded = display_debug_lines_decoded (section, data, end);
3260
 
3261
  if (!retValRaw || !retValDecoded)
3262
    return 0;
3263
 
3264
  return 1;
3265
}
3266
 
3267
static debug_info *
3268
find_debug_info_for_offset (unsigned long offset)
3269
{
3270
  unsigned int i;
3271
 
3272
  if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
3273
    return NULL;
3274
 
3275
  for (i = 0; i < num_debug_info_entries; i++)
3276
    if (debug_information[i].cu_offset == offset)
3277
      return debug_information + i;
3278
 
3279
  return NULL;
3280
}
3281
 
3282
static int
3283
display_debug_pubnames (struct dwarf_section *section,
3284
                        void *file ATTRIBUTE_UNUSED)
3285
{
3286
  DWARF2_Internal_PubNames names;
3287
  unsigned char *start = section->start;
3288
  unsigned char *end = start + section->size;
3289
 
3290
  /* It does not matter if this load fails,
3291
     we test for that later on.  */
3292
  load_debug_info (file);
3293
 
3294
  printf (_("Contents of the %s section:\n\n"), section->name);
3295
 
3296
  while (start < end)
3297
    {
3298
      unsigned char *data;
3299
      unsigned long offset;
3300
      int offset_size, initial_length_size;
3301
 
3302
      data = start;
3303
 
3304
      names.pn_length = byte_get (data, 4);
3305
      data += 4;
3306
      if (names.pn_length == 0xffffffff)
3307
        {
3308
          names.pn_length = byte_get (data, 8);
3309
          data += 8;
3310
          offset_size = 8;
3311
          initial_length_size = 12;
3312
        }
3313
      else
3314
        {
3315
          offset_size = 4;
3316
          initial_length_size = 4;
3317
        }
3318
 
3319
      names.pn_version = byte_get (data, 2);
3320
      data += 2;
3321
 
3322
      names.pn_offset = byte_get (data, offset_size);
3323
      data += offset_size;
3324
 
3325
      if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
3326
          && num_debug_info_entries > 0
3327
          && find_debug_info_for_offset (names.pn_offset) == NULL)
3328
        warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3329
              (unsigned long) names.pn_offset, section->name);
3330
 
3331
      names.pn_size = byte_get (data, offset_size);
3332
      data += offset_size;
3333
 
3334
      start += names.pn_length + initial_length_size;
3335
 
3336
      if (names.pn_version != 2 && names.pn_version != 3)
3337
        {
3338
          static int warned = 0;
3339
 
3340
          if (! warned)
3341
            {
3342
              warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
3343
              warned = 1;
3344
            }
3345
 
3346
          continue;
3347
        }
3348
 
3349
      printf (_("  Length:                              %ld\n"),
3350
              (long) names.pn_length);
3351
      printf (_("  Version:                             %d\n"),
3352
              names.pn_version);
3353
      printf (_("  Offset into .debug_info section:     0x%lx\n"),
3354
              (unsigned long) names.pn_offset);
3355
      printf (_("  Size of area in .debug_info section: %ld\n"),
3356
              (long) names.pn_size);
3357
 
3358
      printf (_("\n    Offset\tName\n"));
3359
 
3360
      do
3361
        {
3362
          offset = byte_get (data, offset_size);
3363
 
3364
          if (offset != 0)
3365
            {
3366
              data += offset_size;
3367
              printf ("    %-6lx\t%s\n", offset, data);
3368
              data += strlen ((char *) data) + 1;
3369
            }
3370
        }
3371
      while (offset != 0);
3372
    }
3373
 
3374
  printf ("\n");
3375
  return 1;
3376
}
3377
 
3378
static int
3379
display_debug_macinfo (struct dwarf_section *section,
3380
                       void *file ATTRIBUTE_UNUSED)
3381
{
3382
  unsigned char *start = section->start;
3383
  unsigned char *end = start + section->size;
3384
  unsigned char *curr = start;
3385
  unsigned int bytes_read;
3386
  enum dwarf_macinfo_record_type op;
3387
 
3388
  printf (_("Contents of the %s section:\n\n"), section->name);
3389
 
3390
  while (curr < end)
3391
    {
3392
      unsigned int lineno;
3393
      const char *string;
3394
 
3395
      op = (enum dwarf_macinfo_record_type) *curr;
3396
      curr++;
3397
 
3398
      switch (op)
3399
        {
3400
        case DW_MACINFO_start_file:
3401
          {
3402
            unsigned int filenum;
3403
 
3404
            lineno = read_leb128 (curr, & bytes_read, 0);
3405
            curr += bytes_read;
3406
            filenum = read_leb128 (curr, & bytes_read, 0);
3407
            curr += bytes_read;
3408
 
3409
            printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
3410
                    lineno, filenum);
3411
          }
3412
          break;
3413
 
3414
        case DW_MACINFO_end_file:
3415
          printf (_(" DW_MACINFO_end_file\n"));
3416
          break;
3417
 
3418
        case DW_MACINFO_define:
3419
          lineno = read_leb128 (curr, & bytes_read, 0);
3420
          curr += bytes_read;
3421
          string = (char *) curr;
3422
          curr += strlen (string) + 1;
3423
          printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
3424
                  lineno, string);
3425
          break;
3426
 
3427
        case DW_MACINFO_undef:
3428
          lineno = read_leb128 (curr, & bytes_read, 0);
3429
          curr += bytes_read;
3430
          string = (char *) curr;
3431
          curr += strlen (string) + 1;
3432
          printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
3433
                  lineno, string);
3434
          break;
3435
 
3436
        case DW_MACINFO_vendor_ext:
3437
          {
3438
            unsigned int constant;
3439
 
3440
            constant = read_leb128 (curr, & bytes_read, 0);
3441
            curr += bytes_read;
3442
            string = (char *) curr;
3443
            curr += strlen (string) + 1;
3444
            printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
3445
                    constant, string);
3446
          }
3447
          break;
3448
        }
3449
    }
3450
 
3451
  return 1;
3452
}
3453
 
3454 161 khays
/* Given LINE_OFFSET into the .debug_line section, attempt to return
3455
   filename and dirname corresponding to file name table entry with index
3456
   FILEIDX.  Return NULL on failure.  */
3457
 
3458
static unsigned char *
3459
get_line_filename_and_dirname (dwarf_vma line_offset, dwarf_vma fileidx,
3460
                               unsigned char **dir_name)
3461
{
3462
  struct dwarf_section *section = &debug_displays [line].section;
3463
  unsigned char *hdrptr, *dirtable, *file_name;
3464
  unsigned int offset_size, initial_length_size;
3465
  unsigned int version, opcode_base, bytes_read;
3466
  dwarf_vma length, diridx;
3467
 
3468
  *dir_name = NULL;
3469
  if (section->start == NULL
3470
      || line_offset >= section->size
3471
      || fileidx == 0)
3472
    return NULL;
3473
 
3474
  hdrptr = section->start + line_offset;
3475
  length = byte_get (hdrptr, 4);
3476
  hdrptr += 4;
3477
  if (length == 0xffffffff)
3478
    {
3479
      /* This section is 64-bit DWARF 3.  */
3480
      length = byte_get (hdrptr, 8);
3481
      hdrptr += 8;
3482
      offset_size = 8;
3483
      initial_length_size = 12;
3484
    }
3485
  else
3486
    {
3487
      offset_size = 4;
3488
      initial_length_size = 4;
3489
    }
3490
  if (length + initial_length_size > section->size)
3491
    return NULL;
3492
  version = byte_get (hdrptr, 2);
3493
  hdrptr += 2;
3494
  if (version != 2 && version != 3 && version != 4)
3495
    return NULL;
3496
  hdrptr += offset_size + 1;/* Skip prologue_length and min_insn_length.  */
3497
  if (version >= 4)
3498
    hdrptr++;               /* Skip max_ops_per_insn.  */
3499
  hdrptr += 3;              /* Skip default_is_stmt, line_base, line_range.  */
3500
  opcode_base = byte_get (hdrptr, 1);
3501
  if (opcode_base == 0)
3502
    return NULL;
3503
  hdrptr++;
3504
  hdrptr += opcode_base - 1;
3505
  dirtable = hdrptr;
3506
  /* Skip over dirname table.  */
3507
  while (*hdrptr != '\0')
3508
    hdrptr += strlen ((char *) hdrptr) + 1;
3509
  hdrptr++;                 /* Skip the NUL at the end of the table.  */
3510
  /* Now skip over preceding filename table entries.  */
3511
  for (; *hdrptr != '\0' && fileidx > 1; fileidx--)
3512
    {
3513
      hdrptr += strlen ((char *) hdrptr) + 1;
3514
      read_leb128 (hdrptr, &bytes_read, 0);
3515
      hdrptr += bytes_read;
3516
      read_leb128 (hdrptr, &bytes_read, 0);
3517
      hdrptr += bytes_read;
3518
      read_leb128 (hdrptr, &bytes_read, 0);
3519
      hdrptr += bytes_read;
3520
    }
3521
  if (*hdrptr == '\0')
3522
    return NULL;
3523
  file_name = hdrptr;
3524
  hdrptr += strlen ((char *) hdrptr) + 1;
3525
  diridx = read_leb128 (hdrptr, &bytes_read, 0);
3526
  if (diridx == 0)
3527
    return file_name;
3528
  for (; *dirtable != '\0' && diridx > 1; diridx--)
3529
    dirtable += strlen ((char *) dirtable) + 1;
3530
  if (*dirtable == '\0')
3531
    return NULL;
3532
  *dir_name = dirtable;
3533
  return file_name;
3534
}
3535
 
3536 15 khays
static int
3537 161 khays
display_debug_macro (struct dwarf_section *section,
3538
                     void *file)
3539
{
3540
  unsigned char *start = section->start;
3541
  unsigned char *end = start + section->size;
3542
  unsigned char *curr = start;
3543
  unsigned char *extended_op_buf[256];
3544
  unsigned int bytes_read;
3545
 
3546
  load_debug_section (str, file);
3547
  load_debug_section (line, file);
3548
 
3549
  printf (_("Contents of the %s section:\n\n"), section->name);
3550
 
3551
  while (curr < end)
3552
    {
3553
      unsigned int lineno, version, flags;
3554
      unsigned int offset_size = 4;
3555
      const char *string;
3556
      dwarf_vma line_offset = 0, sec_offset = curr - start, offset;
3557
      unsigned char **extended_ops = NULL;
3558
 
3559
      version = byte_get (curr, 2);
3560
      curr += 2;
3561
 
3562
      if (version != 4)
3563
        {
3564
          error (_("Only GNU extension to DWARF 4 of %s is currently supported.\n"),
3565
                 section->name);
3566
          return 0;
3567
        }
3568
 
3569
      flags = byte_get (curr++, 1);
3570
      if (flags & 1)
3571
        offset_size = 8;
3572
      printf (_("  Offset:                      0x%lx\n"),
3573
              (unsigned long) sec_offset);
3574
      printf (_("  Version:                     %d\n"), version);
3575
      printf (_("  Offset size:                 %d\n"), offset_size);
3576
      if (flags & 2)
3577
        {
3578
          line_offset = byte_get (curr, offset_size);
3579
          curr += offset_size;
3580
          printf (_("  Offset into .debug_line:     0x%lx\n"),
3581
                  (unsigned long) line_offset);
3582
        }
3583
      if (flags & 4)
3584
        {
3585
          unsigned int i, count = byte_get (curr++, 1), op;
3586
          dwarf_vma nargs, n;
3587
          memset (extended_op_buf, 0, sizeof (extended_op_buf));
3588
          extended_ops = extended_op_buf;
3589
          if (count)
3590
            {
3591
              printf (_("  Extension opcode arguments:\n"));
3592
              for (i = 0; i < count; i++)
3593
                {
3594
                  op = byte_get (curr++, 1);
3595
                  extended_ops[op] = curr;
3596
                  nargs = read_leb128 (curr, &bytes_read, 0);
3597
                  curr += bytes_read;
3598
                  if (nargs == 0)
3599
                    printf (_("    DW_MACRO_GNU_%02x has no arguments\n"), op);
3600
                  else
3601
                    {
3602
                      printf (_("    DW_MACRO_GNU_%02x arguments: "), op);
3603
                      for (n = 0; n < nargs; n++)
3604
                        {
3605
                          unsigned int form = byte_get (curr++, 1);
3606
                          printf ("%s%s", get_FORM_name (form),
3607
                                  n == nargs - 1 ? "\n" : ", ");
3608
                          switch (form)
3609
                            {
3610
                            case DW_FORM_data1:
3611
                            case DW_FORM_data2:
3612
                            case DW_FORM_data4:
3613
                            case DW_FORM_data8:
3614
                            case DW_FORM_sdata:
3615
                            case DW_FORM_udata:
3616
                            case DW_FORM_block:
3617
                            case DW_FORM_block1:
3618
                            case DW_FORM_block2:
3619
                            case DW_FORM_block4:
3620
                            case DW_FORM_flag:
3621
                            case DW_FORM_string:
3622
                            case DW_FORM_strp:
3623
                            case DW_FORM_sec_offset:
3624
                              break;
3625
                            default:
3626
                              error (_("Invalid extension opcode form %s\n"),
3627
                                     get_FORM_name (form));
3628
                              return 0;
3629
                            }
3630
                        }
3631
                    }
3632
                }
3633
            }
3634
        }
3635
      printf ("\n");
3636
 
3637
      while (1)
3638
        {
3639
          unsigned int op;
3640
 
3641
          if (curr >= end)
3642
            {
3643
              error (_(".debug_macro section not zero terminated\n"));
3644
              return 0;
3645
            }
3646
 
3647
          op = byte_get (curr++, 1);
3648
          if (op == 0)
3649
            break;
3650
 
3651
          switch (op)
3652
            {
3653
            case DW_MACRO_GNU_start_file:
3654
              {
3655
                unsigned int filenum;
3656
                unsigned char *file_name = NULL, *dir_name = NULL;
3657
 
3658
                lineno = read_leb128 (curr, &bytes_read, 0);
3659
                curr += bytes_read;
3660
                filenum = read_leb128 (curr, &bytes_read, 0);
3661
                curr += bytes_read;
3662
 
3663
                if ((flags & 2) == 0)
3664
                  error (_("DW_MACRO_GNU_start_file used, but no .debug_line offset provided.\n"));
3665
                else
3666
                  file_name
3667
                    = get_line_filename_and_dirname (line_offset, filenum,
3668
                                                     &dir_name);
3669
                if (file_name == NULL)
3670
                  printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d\n"),
3671
                          lineno, filenum);
3672
                else
3673
                  printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
3674
                          lineno, filenum,
3675
                          dir_name != NULL ? (const char *) dir_name : "",
3676
                          dir_name != NULL ? "/" : "", file_name);
3677
              }
3678
              break;
3679
 
3680
            case DW_MACRO_GNU_end_file:
3681
              printf (_(" DW_MACRO_GNU_end_file\n"));
3682
              break;
3683
 
3684
            case DW_MACRO_GNU_define:
3685
              lineno = read_leb128 (curr, &bytes_read, 0);
3686
              curr += bytes_read;
3687
              string = (char *) curr;
3688
              curr += strlen (string) + 1;
3689
              printf (_(" DW_MACRO_GNU_define - lineno : %d macro : %s\n"),
3690
                      lineno, string);
3691
              break;
3692
 
3693
            case DW_MACRO_GNU_undef:
3694
              lineno = read_leb128 (curr, &bytes_read, 0);
3695
              curr += bytes_read;
3696
              string = (char *) curr;
3697
              curr += strlen (string) + 1;
3698
              printf (_(" DW_MACRO_GNU_undef - lineno : %d macro : %s\n"),
3699
                      lineno, string);
3700
              break;
3701
 
3702
            case DW_MACRO_GNU_define_indirect:
3703
              lineno = read_leb128 (curr, &bytes_read, 0);
3704
              curr += bytes_read;
3705
              offset = byte_get (curr, offset_size);
3706
              curr += offset_size;
3707
              string = fetch_indirect_string (offset);
3708
              printf (_(" DW_MACRO_GNU_define_indirect - lineno : %d macro : %s\n"),
3709
                      lineno, string);
3710
              break;
3711
 
3712
            case DW_MACRO_GNU_undef_indirect:
3713
              lineno = read_leb128 (curr, &bytes_read, 0);
3714
              curr += bytes_read;
3715
              offset = byte_get (curr, offset_size);
3716
              curr += offset_size;
3717
              string = fetch_indirect_string (offset);
3718
              printf (_(" DW_MACRO_GNU_undef_indirect - lineno : %d macro : %s\n"),
3719
                      lineno, string);
3720
              break;
3721
 
3722
            case DW_MACRO_GNU_transparent_include:
3723
              offset = byte_get (curr, offset_size);
3724
              curr += offset_size;
3725
              printf (_(" DW_MACRO_GNU_transparent_include - offset : 0x%lx\n"),
3726
                      (unsigned long) offset);
3727
              break;
3728
 
3729
            default:
3730
              if (extended_ops == NULL || extended_ops[op] == NULL)
3731
                {
3732
                  error (_(" Unknown macro opcode %02x seen\n"), op);
3733
                  return 0;
3734
                }
3735
              else
3736
                {
3737
                  /* Skip over unhandled opcodes.  */
3738
                  dwarf_vma nargs, n;
3739
                  unsigned char *desc = extended_ops[op];
3740
                  nargs = read_leb128 (desc, &bytes_read, 0);
3741
                  desc += bytes_read;
3742
                  if (nargs == 0)
3743
                    {
3744
                      printf (_(" DW_MACRO_GNU_%02x\n"), op);
3745
                      break;
3746
                    }
3747
                  printf (_(" DW_MACRO_GNU_%02x -"), op);
3748
                  for (n = 0; n < nargs; n++)
3749
                    {
3750
                      curr
3751
                        = read_and_display_attr_value (0, byte_get (desc++, 1),
3752
                                                       curr, 0, 0, offset_size,
3753
                                                       version, NULL, 0, NULL);
3754
                      if (n != nargs - 1)
3755
                        printf (",");
3756
                    }
3757
                  printf ("\n");
3758
                }
3759
              break;
3760
            }
3761
        }
3762
 
3763
      printf ("\n");
3764
    }
3765
 
3766
  return 1;
3767
}
3768
 
3769
static int
3770 15 khays
display_debug_abbrev (struct dwarf_section *section,
3771
                      void *file ATTRIBUTE_UNUSED)
3772
{
3773
  abbrev_entry *entry;
3774
  unsigned char *start = section->start;
3775
  unsigned char *end = start + section->size;
3776
 
3777
  printf (_("Contents of the %s section:\n\n"), section->name);
3778
 
3779
  do
3780
    {
3781
      free_abbrevs ();
3782
 
3783
      start = process_abbrev_section (start, end);
3784
 
3785
      if (first_abbrev == NULL)
3786
        continue;
3787
 
3788
      printf (_("  Number TAG\n"));
3789
 
3790
      for (entry = first_abbrev; entry; entry = entry->next)
3791
        {
3792
          abbrev_attr *attr;
3793
 
3794
          printf ("   %ld      %s    [%s]\n",
3795
                  entry->entry,
3796
                  get_TAG_name (entry->tag),
3797
                  entry->children ? _("has children") : _("no children"));
3798
 
3799
          for (attr = entry->first_attr; attr; attr = attr->next)
3800
            printf ("    %-18s %s\n",
3801
                    get_AT_name (attr->attribute),
3802
                    get_FORM_name (attr->form));
3803
        }
3804
    }
3805
  while (start);
3806
 
3807
  printf ("\n");
3808
 
3809
  return 1;
3810
}
3811
 
3812
/* Sort array of indexes in ascending order of loc_offsets[idx].  */
3813
 
3814
static dwarf_vma *loc_offsets;
3815
 
3816
static int
3817
loc_offsets_compar (const void *ap, const void *bp)
3818
{
3819
  dwarf_vma a = loc_offsets[*(const unsigned int *) ap];
3820
  dwarf_vma b = loc_offsets[*(const unsigned int *) bp];
3821
 
3822
  return (a > b) - (b > a);
3823
}
3824
 
3825
static int
3826
display_debug_loc (struct dwarf_section *section, void *file)
3827
{
3828
  unsigned char *start = section->start;
3829
  unsigned char *section_end;
3830
  unsigned long bytes;
3831
  unsigned char *section_begin = start;
3832
  unsigned int num_loc_list = 0;
3833
  unsigned long last_offset = 0;
3834
  unsigned int first = 0;
3835
  unsigned int i;
3836
  unsigned int j;
3837
  unsigned int k;
3838
  int seen_first_offset = 0;
3839
  int locs_sorted = 1;
3840
  unsigned char *next;
3841
  unsigned int *array = NULL;
3842
 
3843
  bytes = section->size;
3844
  section_end = start + bytes;
3845
 
3846
  if (bytes == 0)
3847
    {
3848
      printf (_("\nThe %s section is empty.\n"), section->name);
3849
      return 0;
3850
    }
3851
 
3852
  if (load_debug_info (file) == 0)
3853
    {
3854
      warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
3855
            section->name);
3856
      return 0;
3857
    }
3858
 
3859
  /* Check the order of location list in .debug_info section. If
3860
     offsets of location lists are in the ascending order, we can
3861
     use `debug_information' directly.  */
3862
  for (i = 0; i < num_debug_info_entries; i++)
3863
    {
3864
      unsigned int num;
3865
 
3866
      num = debug_information [i].num_loc_offsets;
3867
      if (num > num_loc_list)
3868
        num_loc_list = num;
3869
 
3870
      /* Check if we can use `debug_information' directly.  */
3871
      if (locs_sorted && num != 0)
3872
        {
3873
          if (!seen_first_offset)
3874
            {
3875
              /* This is the first location list.  */
3876
              last_offset = debug_information [i].loc_offsets [0];
3877
              first = i;
3878
              seen_first_offset = 1;
3879
              j = 1;
3880
            }
3881
          else
3882
            j = 0;
3883
 
3884
          for (; j < num; j++)
3885
            {
3886
              if (last_offset >
3887
                  debug_information [i].loc_offsets [j])
3888
                {
3889
                  locs_sorted = 0;
3890
                  break;
3891
                }
3892
              last_offset = debug_information [i].loc_offsets [j];
3893
            }
3894
        }
3895
    }
3896
 
3897
  if (!seen_first_offset)
3898
    error (_("No location lists in .debug_info section!\n"));
3899
 
3900
  /* DWARF sections under Mach-O have non-zero addresses.  */
3901
  if (debug_information [first].num_loc_offsets > 0
3902
      && debug_information [first].loc_offsets [0] != section->address)
3903
    warn (_("Location lists in %s section start at 0x%s\n"),
3904
          section->name,
3905
          dwarf_vmatoa ("x", debug_information [first].loc_offsets [0]));
3906
 
3907
  if (!locs_sorted)
3908
    array = (unsigned int *) xcmalloc (num_loc_list, sizeof (unsigned int));
3909
  printf (_("Contents of the %s section:\n\n"), section->name);
3910
  printf (_("    Offset   Begin    End      Expression\n"));
3911
 
3912
  seen_first_offset = 0;
3913
  for (i = first; i < num_debug_info_entries; i++)
3914
    {
3915
      dwarf_vma begin;
3916
      dwarf_vma end;
3917
      unsigned short length;
3918
      unsigned long offset;
3919
      unsigned int pointer_size;
3920
      unsigned int offset_size;
3921
      int dwarf_version;
3922
      unsigned long cu_offset;
3923
      unsigned long base_address;
3924
      int need_frame_base;
3925
      int has_frame_base;
3926
 
3927
      pointer_size = debug_information [i].pointer_size;
3928
      cu_offset = debug_information [i].cu_offset;
3929
      offset_size = debug_information [i].offset_size;
3930
      dwarf_version = debug_information [i].dwarf_version;
3931
      if (!locs_sorted)
3932
        {
3933
          for (k = 0; k < debug_information [i].num_loc_offsets; k++)
3934
            array[k] = k;
3935
          loc_offsets = debug_information [i].loc_offsets;
3936
          qsort (array, debug_information [i].num_loc_offsets,
3937
                 sizeof (*array), loc_offsets_compar);
3938
        }
3939
 
3940
      for (k = 0; k < debug_information [i].num_loc_offsets; k++)
3941
        {
3942
          j = locs_sorted ? k : array[k];
3943
          if (k
3944
              && debug_information [i].loc_offsets [locs_sorted
3945
                                                    ? k - 1 : array [k - 1]]
3946
                 == debug_information [i].loc_offsets [j])
3947
            continue;
3948
          has_frame_base = debug_information [i].have_frame_base [j];
3949
          /* DWARF sections under Mach-O have non-zero addresses.  */
3950
          offset = debug_information [i].loc_offsets [j] - section->address;
3951
          next = section_begin + offset;
3952
          base_address = debug_information [i].base_address;
3953
 
3954
          if (!seen_first_offset)
3955
            seen_first_offset = 1;
3956
          else
3957
            {
3958
              if (start < next)
3959
                warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
3960
                      (unsigned long) (start - section_begin),
3961
                      (unsigned long) (next - section_begin));
3962
              else if (start > next)
3963
                warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
3964
                      (unsigned long) (start - section_begin),
3965
                      (unsigned long) (next - section_begin));
3966
            }
3967
          start = next;
3968
 
3969
          if (offset >= bytes)
3970
            {
3971
              warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
3972
                    offset);
3973
              continue;
3974
            }
3975
 
3976
          while (1)
3977
            {
3978
              if (start + 2 * pointer_size > section_end)
3979
                {
3980
                  warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
3981
                        offset);
3982
                  break;
3983
                }
3984
 
3985
              /* Note: we use sign extension here in order to be sure that
3986
                 we can detect the -1 escape value.  Sign extension into the
3987
                 top 32 bits of a 32-bit address will not affect the values
3988
                 that we display since we always show hex values, and always
3989
                 the bottom 32-bits.  */
3990
              begin = byte_get_signed (start, pointer_size);
3991
              start += pointer_size;
3992
              end = byte_get_signed (start, pointer_size);
3993
              start += pointer_size;
3994
 
3995
              printf ("    %8.8lx ", offset);
3996
 
3997
              if (begin == 0 && end == 0)
3998
                {
3999
                  printf (_("<End of list>\n"));
4000
                  break;
4001
                }
4002
 
4003
              /* Check base address specifiers.  */
4004
              if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
4005
                {
4006
                  base_address = end;
4007
                  print_dwarf_vma (begin, pointer_size);
4008
                  print_dwarf_vma (end, pointer_size);
4009
                  printf (_("(base address)\n"));
4010
                  continue;
4011
                }
4012
 
4013
              if (start + 2 > section_end)
4014
                {
4015
                  warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4016
                        offset);
4017
                  break;
4018
                }
4019
 
4020
              length = byte_get (start, 2);
4021
              start += 2;
4022
 
4023
              if (start + length > section_end)
4024
                {
4025
                  warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4026
                        offset);
4027
                  break;
4028
                }
4029
 
4030
              print_dwarf_vma (begin + base_address, pointer_size);
4031
              print_dwarf_vma (end + base_address, pointer_size);
4032
 
4033
              putchar ('(');
4034
              need_frame_base = decode_location_expression (start,
4035
                                                            pointer_size,
4036
                                                            offset_size,
4037
                                                            dwarf_version,
4038
                                                            length,
4039
                                                            cu_offset, section);
4040
              putchar (')');
4041
 
4042
              if (need_frame_base && !has_frame_base)
4043
                printf (_(" [without DW_AT_frame_base]"));
4044
 
4045
              if (begin == end)
4046
                fputs (_(" (start == end)"), stdout);
4047
              else if (begin > end)
4048
                fputs (_(" (start > end)"), stdout);
4049
 
4050
              putchar ('\n');
4051
 
4052
              start += length;
4053
            }
4054
        }
4055
    }
4056
 
4057
  if (start < section_end)
4058
    warn (_("There are %ld unused bytes at the end of section %s\n"),
4059
          (long) (section_end - start), section->name);
4060
  putchar ('\n');
4061
  free (array);
4062
  return 1;
4063
}
4064
 
4065
static int
4066
display_debug_str (struct dwarf_section *section,
4067
                   void *file ATTRIBUTE_UNUSED)
4068
{
4069
  unsigned char *start = section->start;
4070
  unsigned long bytes = section->size;
4071
  dwarf_vma addr = section->address;
4072
 
4073
  if (bytes == 0)
4074
    {
4075
      printf (_("\nThe %s section is empty.\n"), section->name);
4076
      return 0;
4077
    }
4078
 
4079
  printf (_("Contents of the %s section:\n\n"), section->name);
4080
 
4081
  while (bytes)
4082
    {
4083
      int j;
4084
      int k;
4085
      int lbytes;
4086
 
4087
      lbytes = (bytes > 16 ? 16 : bytes);
4088
 
4089
      printf ("  0x%8.8lx ", (unsigned long) addr);
4090
 
4091
      for (j = 0; j < 16; j++)
4092
        {
4093
          if (j < lbytes)
4094
            printf ("%2.2x", start[j]);
4095
          else
4096
            printf ("  ");
4097
 
4098
          if ((j & 3) == 3)
4099
            printf (" ");
4100
        }
4101
 
4102
      for (j = 0; j < lbytes; j++)
4103
        {
4104
          k = start[j];
4105
          if (k >= ' ' && k < 0x80)
4106
            printf ("%c", k);
4107
          else
4108
            printf (".");
4109
        }
4110
 
4111
      putchar ('\n');
4112
 
4113
      start += lbytes;
4114
      addr  += lbytes;
4115
      bytes -= lbytes;
4116
    }
4117
 
4118
  putchar ('\n');
4119
 
4120
  return 1;
4121
}
4122
 
4123
static int
4124
display_debug_info (struct dwarf_section *section, void *file)
4125
{
4126
  return process_debug_info (section, file, abbrev, 0, 0);
4127
}
4128
 
4129
static int
4130
display_debug_types (struct dwarf_section *section, void *file)
4131
{
4132
  return process_debug_info (section, file, abbrev, 0, 1);
4133
}
4134
 
4135
static int
4136
display_trace_info (struct dwarf_section *section, void *file)
4137
{
4138
  return process_debug_info (section, file, trace_abbrev, 0, 0);
4139
}
4140
 
4141
static int
4142
display_debug_aranges (struct dwarf_section *section,
4143
                       void *file ATTRIBUTE_UNUSED)
4144
{
4145
  unsigned char *start = section->start;
4146
  unsigned char *end = start + section->size;
4147
 
4148
  printf (_("Contents of the %s section:\n\n"), section->name);
4149
 
4150
  /* It does not matter if this load fails,
4151
     we test for that later on.  */
4152
  load_debug_info (file);
4153
 
4154
  while (start < end)
4155
    {
4156
      unsigned char *hdrptr;
4157
      DWARF2_Internal_ARange arange;
4158
      unsigned char *addr_ranges;
4159
      dwarf_vma length;
4160
      dwarf_vma address;
4161
      unsigned char address_size;
4162
      int excess;
4163
      int offset_size;
4164
      int initial_length_size;
4165
 
4166
      hdrptr = start;
4167
 
4168
      arange.ar_length = byte_get (hdrptr, 4);
4169
      hdrptr += 4;
4170
 
4171
      if (arange.ar_length == 0xffffffff)
4172
        {
4173
          arange.ar_length = byte_get (hdrptr, 8);
4174
          hdrptr += 8;
4175
          offset_size = 8;
4176
          initial_length_size = 12;
4177
        }
4178
      else
4179
        {
4180
          offset_size = 4;
4181
          initial_length_size = 4;
4182
        }
4183
 
4184
      arange.ar_version = byte_get (hdrptr, 2);
4185
      hdrptr += 2;
4186
 
4187
      arange.ar_info_offset = byte_get (hdrptr, offset_size);
4188
      hdrptr += offset_size;
4189
 
4190
      if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
4191
          && num_debug_info_entries > 0
4192
          && find_debug_info_for_offset (arange.ar_info_offset) == NULL)
4193
        warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
4194
              (unsigned long) arange.ar_info_offset, section->name);
4195
 
4196
      arange.ar_pointer_size = byte_get (hdrptr, 1);
4197
      hdrptr += 1;
4198
 
4199
      arange.ar_segment_size = byte_get (hdrptr, 1);
4200
      hdrptr += 1;
4201
 
4202
      if (arange.ar_version != 2 && arange.ar_version != 3)
4203
        {
4204
          warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
4205
          break;
4206
        }
4207
 
4208
      printf (_("  Length:                   %ld\n"),
4209
              (long) arange.ar_length);
4210
      printf (_("  Version:                  %d\n"), arange.ar_version);
4211
      printf (_("  Offset into .debug_info:  0x%lx\n"),
4212
              (unsigned long) arange.ar_info_offset);
4213
      printf (_("  Pointer Size:             %d\n"), arange.ar_pointer_size);
4214
      printf (_("  Segment Size:             %d\n"), arange.ar_segment_size);
4215
 
4216
      address_size = arange.ar_pointer_size + arange.ar_segment_size;
4217
 
4218
      /* The DWARF spec does not require that the address size be a power
4219
         of two, but we do.  This will have to change if we ever encounter
4220
         an uneven architecture.  */
4221
      if ((address_size & (address_size - 1)) != 0)
4222
        {
4223
          warn (_("Pointer size + Segment size is not a power of two.\n"));
4224
          break;
4225
        }
4226
 
4227
      if (address_size > 4)
4228
        printf (_("\n    Address            Length\n"));
4229
      else
4230
        printf (_("\n    Address    Length\n"));
4231
 
4232
      addr_ranges = hdrptr;
4233
 
4234
      /* Must pad to an alignment boundary that is twice the address size.  */
4235
      excess = (hdrptr - start) % (2 * address_size);
4236
      if (excess)
4237
        addr_ranges += (2 * address_size) - excess;
4238
 
4239
      start += arange.ar_length + initial_length_size;
4240
 
4241
      while (addr_ranges + 2 * address_size <= start)
4242
        {
4243
          address = byte_get (addr_ranges, address_size);
4244
 
4245
          addr_ranges += address_size;
4246
 
4247
          length  = byte_get (addr_ranges, address_size);
4248
 
4249
          addr_ranges += address_size;
4250
 
4251
          printf ("    ");
4252
          print_dwarf_vma (address, address_size);
4253
          print_dwarf_vma (length, address_size);
4254
          putchar ('\n');
4255
        }
4256
    }
4257
 
4258
  printf ("\n");
4259
 
4260
  return 1;
4261
}
4262
 
4263
/* Each debug_information[x].range_lists[y] gets this representation for
4264
   sorting purposes.  */
4265
 
4266
struct range_entry
4267
{
4268
  /* The debug_information[x].range_lists[y] value.  */
4269
  unsigned long ranges_offset;
4270
 
4271
  /* Original debug_information to find parameters of the data.  */
4272
  debug_info *debug_info_p;
4273
};
4274
 
4275
/* Sort struct range_entry in ascending order of its RANGES_OFFSET.  */
4276
 
4277
static int
4278
range_entry_compar (const void *ap, const void *bp)
4279
{
4280
  const struct range_entry *a_re = (const struct range_entry *) ap;
4281
  const struct range_entry *b_re = (const struct range_entry *) bp;
4282
  const unsigned long a = a_re->ranges_offset;
4283
  const unsigned long b = b_re->ranges_offset;
4284
 
4285
  return (a > b) - (b > a);
4286
}
4287
 
4288
static int
4289
display_debug_ranges (struct dwarf_section *section,
4290
                      void *file ATTRIBUTE_UNUSED)
4291
{
4292
  unsigned char *start = section->start;
4293
  unsigned long bytes;
4294
  unsigned char *section_begin = start;
4295
  unsigned int num_range_list, i;
4296
  struct range_entry *range_entries, *range_entry_fill;
4297
 
4298
  bytes = section->size;
4299
 
4300
  if (bytes == 0)
4301
    {
4302
      printf (_("\nThe %s section is empty.\n"), section->name);
4303
      return 0;
4304
    }
4305
 
4306
  if (load_debug_info (file) == 0)
4307
    {
4308
      warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4309
            section->name);
4310
      return 0;
4311
    }
4312
 
4313
  num_range_list = 0;
4314
  for (i = 0; i < num_debug_info_entries; i++)
4315
    num_range_list += debug_information [i].num_range_lists;
4316
 
4317
  if (num_range_list == 0)
4318
    error (_("No range lists in .debug_info section!\n"));
4319
 
4320
  range_entries = (struct range_entry *)
4321
      xmalloc (sizeof (*range_entries) * num_range_list);
4322
  range_entry_fill = range_entries;
4323
 
4324
  for (i = 0; i < num_debug_info_entries; i++)
4325
    {
4326
      debug_info *debug_info_p = &debug_information[i];
4327
      unsigned int j;
4328
 
4329
      for (j = 0; j < debug_info_p->num_range_lists; j++)
4330
        {
4331
          range_entry_fill->ranges_offset = debug_info_p->range_lists[j];
4332
          range_entry_fill->debug_info_p = debug_info_p;
4333
          range_entry_fill++;
4334
        }
4335
    }
4336
 
4337
  qsort (range_entries, num_range_list, sizeof (*range_entries),
4338
         range_entry_compar);
4339
 
4340
  /* DWARF sections under Mach-O have non-zero addresses.  */
4341
  if (range_entries[0].ranges_offset != section->address)
4342
    warn (_("Range lists in %s section start at 0x%lx\n"),
4343
          section->name, range_entries[0].ranges_offset);
4344
 
4345
  printf (_("Contents of the %s section:\n\n"), section->name);
4346
  printf (_("    Offset   Begin    End\n"));
4347
 
4348
  for (i = 0; i < num_range_list; i++)
4349
    {
4350
      struct range_entry *range_entry = &range_entries[i];
4351
      debug_info *debug_info_p = range_entry->debug_info_p;
4352
      unsigned int pointer_size;
4353
      unsigned long offset;
4354
      unsigned char *next;
4355
      unsigned long base_address;
4356
 
4357
      pointer_size = debug_info_p->pointer_size;
4358
 
4359
      /* DWARF sections under Mach-O have non-zero addresses.  */
4360
      offset = range_entry->ranges_offset - section->address;
4361
      next = section_begin + offset;
4362
      base_address = debug_info_p->base_address;
4363
 
4364
      if (i > 0)
4365
        {
4366
          if (start < next)
4367
            warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
4368
                  (unsigned long) (start - section_begin),
4369
                  (unsigned long) (next - section_begin), section->name);
4370
          else if (start > next)
4371
            warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
4372
                  (unsigned long) (start - section_begin),
4373
                  (unsigned long) (next - section_begin), section->name);
4374
        }
4375
      start = next;
4376
 
4377
      while (1)
4378
        {
4379
          dwarf_vma begin;
4380
          dwarf_vma end;
4381
 
4382
          /* Note: we use sign extension here in order to be sure that
4383
             we can detect the -1 escape value.  Sign extension into the
4384
             top 32 bits of a 32-bit address will not affect the values
4385
             that we display since we always show hex values, and always
4386
             the bottom 32-bits.  */
4387
          begin = byte_get_signed (start, pointer_size);
4388
          start += pointer_size;
4389
          end = byte_get_signed (start, pointer_size);
4390
          start += pointer_size;
4391
 
4392
          printf ("    %8.8lx ", offset);
4393
 
4394
          if (begin == 0 && end == 0)
4395
            {
4396
              printf (_("<End of list>\n"));
4397
              break;
4398
            }
4399
 
4400
          /* Check base address specifiers.  */
4401
          if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
4402
            {
4403
              base_address = end;
4404
              print_dwarf_vma (begin, pointer_size);
4405
              print_dwarf_vma (end, pointer_size);
4406
              printf ("(base address)\n");
4407
              continue;
4408
            }
4409
 
4410
          print_dwarf_vma (begin + base_address, pointer_size);
4411
          print_dwarf_vma (end + base_address, pointer_size);
4412
 
4413
          if (begin == end)
4414
            fputs (_("(start == end)"), stdout);
4415
          else if (begin > end)
4416
            fputs (_("(start > end)"), stdout);
4417
 
4418
          putchar ('\n');
4419
        }
4420
    }
4421
  putchar ('\n');
4422
 
4423
  free (range_entries);
4424
 
4425
  return 1;
4426
}
4427
 
4428
typedef struct Frame_Chunk
4429
{
4430
  struct Frame_Chunk *next;
4431
  unsigned char *chunk_start;
4432
  int ncols;
4433
  /* DW_CFA_{undefined,same_value,offset,register,unreferenced}  */
4434
  short int *col_type;
4435
  int *col_offset;
4436
  char *augmentation;
4437
  unsigned int code_factor;
4438
  int data_factor;
4439
  unsigned long pc_begin;
4440
  unsigned long pc_range;
4441
  int cfa_reg;
4442
  int cfa_offset;
4443
  int ra;
4444
  unsigned char fde_encoding;
4445
  unsigned char cfa_exp;
4446
  unsigned char ptr_size;
4447
  unsigned char segment_size;
4448
}
4449
Frame_Chunk;
4450
 
4451
static const char *const *dwarf_regnames;
4452
static unsigned int dwarf_regnames_count;
4453
 
4454
/* A marker for a col_type that means this column was never referenced
4455
   in the frame info.  */
4456
#define DW_CFA_unreferenced (-1)
4457
 
4458
/* Return 0 if not more space is needed, 1 if more space is needed,
4459
   -1 for invalid reg.  */
4460
 
4461
static int
4462
frame_need_space (Frame_Chunk *fc, unsigned int reg)
4463
{
4464
  int prev = fc->ncols;
4465
 
4466
  if (reg < (unsigned int) fc->ncols)
4467
    return 0;
4468
 
4469
  if (dwarf_regnames_count
4470
      && reg > dwarf_regnames_count)
4471
    return -1;
4472
 
4473
  fc->ncols = reg + 1;
4474
  fc->col_type = (short int *) xcrealloc (fc->col_type, fc->ncols,
4475
                                          sizeof (short int));
4476
  fc->col_offset = (int *) xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
4477
 
4478
  while (prev < fc->ncols)
4479
    {
4480
      fc->col_type[prev] = DW_CFA_unreferenced;
4481
      fc->col_offset[prev] = 0;
4482
      prev++;
4483
    }
4484
  return 1;
4485
}
4486
 
4487
static const char *const dwarf_regnames_i386[] =
4488
{
4489
  "eax", "ecx", "edx", "ebx",
4490
  "esp", "ebp", "esi", "edi",
4491
  "eip", "eflags", NULL,
4492
  "st0", "st1", "st2", "st3",
4493
  "st4", "st5", "st6", "st7",
4494
  NULL, NULL,
4495
  "xmm0", "xmm1", "xmm2", "xmm3",
4496
  "xmm4", "xmm5", "xmm6", "xmm7",
4497
  "mm0", "mm1", "mm2", "mm3",
4498
  "mm4", "mm5", "mm6", "mm7",
4499
  "fcw", "fsw", "mxcsr",
4500
  "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
4501
  "tr", "ldtr"
4502
};
4503
 
4504
void
4505
init_dwarf_regnames_i386 (void)
4506
{
4507
  dwarf_regnames = dwarf_regnames_i386;
4508
  dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_i386);
4509
}
4510
 
4511
static const char *const dwarf_regnames_x86_64[] =
4512
{
4513
  "rax", "rdx", "rcx", "rbx",
4514
  "rsi", "rdi", "rbp", "rsp",
4515
  "r8",  "r9",  "r10", "r11",
4516
  "r12", "r13", "r14", "r15",
4517
  "rip",
4518
  "xmm0",  "xmm1",  "xmm2",  "xmm3",
4519
  "xmm4",  "xmm5",  "xmm6",  "xmm7",
4520
  "xmm8",  "xmm9",  "xmm10", "xmm11",
4521
  "xmm12", "xmm13", "xmm14", "xmm15",
4522
  "st0", "st1", "st2", "st3",
4523
  "st4", "st5", "st6", "st7",
4524
  "mm0", "mm1", "mm2", "mm3",
4525
  "mm4", "mm5", "mm6", "mm7",
4526
  "rflags",
4527
  "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
4528
  "fs.base", "gs.base", NULL, NULL,
4529
  "tr", "ldtr",
4530
  "mxcsr", "fcw", "fsw"
4531
};
4532
 
4533
void
4534
init_dwarf_regnames_x86_64 (void)
4535
{
4536
  dwarf_regnames = dwarf_regnames_x86_64;
4537
  dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_x86_64);
4538
}
4539
 
4540
void
4541
init_dwarf_regnames (unsigned int e_machine)
4542
{
4543
  switch (e_machine)
4544
    {
4545
    case EM_386:
4546
    case EM_486:
4547
      init_dwarf_regnames_i386 ();
4548
      break;
4549
 
4550
    case EM_X86_64:
4551
    case EM_L1OM:
4552 161 khays
    case EM_K1OM:
4553 15 khays
      init_dwarf_regnames_x86_64 ();
4554
      break;
4555
 
4556
    default:
4557
      break;
4558
    }
4559
}
4560
 
4561
static const char *
4562
regname (unsigned int regno, int row)
4563
{
4564
  static char reg[64];
4565
  if (dwarf_regnames
4566
      && regno < dwarf_regnames_count
4567
      && dwarf_regnames [regno] != NULL)
4568
    {
4569
      if (row)
4570
        return dwarf_regnames [regno];
4571
      snprintf (reg, sizeof (reg), "r%d (%s)", regno,
4572
                dwarf_regnames [regno]);
4573
    }
4574
  else
4575
    snprintf (reg, sizeof (reg), "r%d", regno);
4576
  return reg;
4577
}
4578
 
4579
static void
4580
frame_display_row (Frame_Chunk *fc, int *need_col_headers, int *max_regs)
4581
{
4582
  int r;
4583
  char tmp[100];
4584
 
4585
  if (*max_regs < fc->ncols)
4586
    *max_regs = fc->ncols;
4587
 
4588
  if (*need_col_headers)
4589
    {
4590
      static const char *sloc = "   LOC";
4591
 
4592
      *need_col_headers = 0;
4593
 
4594
      printf ("%-*s CFA      ", eh_addr_size * 2, sloc);
4595
 
4596
      for (r = 0; r < *max_regs; r++)
4597
        if (fc->col_type[r] != DW_CFA_unreferenced)
4598
          {
4599
            if (r == fc->ra)
4600
              printf ("ra      ");
4601
            else
4602
              printf ("%-5s ", regname (r, 1));
4603
          }
4604
 
4605
      printf ("\n");
4606
    }
4607
 
4608
  printf ("%0*lx ", eh_addr_size * 2, fc->pc_begin);
4609
  if (fc->cfa_exp)
4610
    strcpy (tmp, "exp");
4611
  else
4612
    sprintf (tmp, "%s%+d", regname (fc->cfa_reg, 1), fc->cfa_offset);
4613
  printf ("%-8s ", tmp);
4614
 
4615
  for (r = 0; r < fc->ncols; r++)
4616
    {
4617
      if (fc->col_type[r] != DW_CFA_unreferenced)
4618
        {
4619
          switch (fc->col_type[r])
4620
            {
4621
            case DW_CFA_undefined:
4622
              strcpy (tmp, "u");
4623
              break;
4624
            case DW_CFA_same_value:
4625
              strcpy (tmp, "s");
4626
              break;
4627
            case DW_CFA_offset:
4628
              sprintf (tmp, "c%+d", fc->col_offset[r]);
4629
              break;
4630
            case DW_CFA_val_offset:
4631
              sprintf (tmp, "v%+d", fc->col_offset[r]);
4632
              break;
4633
            case DW_CFA_register:
4634
              sprintf (tmp, "%s", regname (fc->col_offset[r], 0));
4635
              break;
4636
            case DW_CFA_expression:
4637
              strcpy (tmp, "exp");
4638
              break;
4639
            case DW_CFA_val_expression:
4640
              strcpy (tmp, "vexp");
4641
              break;
4642
            default:
4643
              strcpy (tmp, "n/a");
4644
              break;
4645
            }
4646
          printf ("%-5s ", tmp);
4647
        }
4648
    }
4649
  printf ("\n");
4650
}
4651
 
4652
#define GET(N)  byte_get (start, N); start += N
4653
#define LEB()   read_leb128 (start, & length_return, 0); start += length_return
4654
#define SLEB()  read_sleb128 (start, & length_return); start += length_return
4655
 
4656
static int
4657
display_debug_frames (struct dwarf_section *section,
4658
                      void *file ATTRIBUTE_UNUSED)
4659
{
4660
  unsigned char *start = section->start;
4661
  unsigned char *end = start + section->size;
4662
  unsigned char *section_start = start;
4663
  Frame_Chunk *chunks = 0;
4664
  Frame_Chunk *remembered_state = 0;
4665
  Frame_Chunk *rs;
4666
  int is_eh = strcmp (section->name, ".eh_frame") == 0;
4667
  unsigned int length_return;
4668
  int max_regs = 0;
4669
  const char *bad_reg = _("bad register: ");
4670
  int saved_eh_addr_size = eh_addr_size;
4671
 
4672
  printf (_("Contents of the %s section:\n"), section->name);
4673
 
4674
  while (start < end)
4675
    {
4676
      unsigned char *saved_start;
4677
      unsigned char *block_end;
4678
      unsigned long length;
4679
      unsigned long cie_id;
4680
      Frame_Chunk *fc;
4681
      Frame_Chunk *cie;
4682
      int need_col_headers = 1;
4683
      unsigned char *augmentation_data = NULL;
4684
      unsigned long augmentation_data_len = 0;
4685
      int encoded_ptr_size = saved_eh_addr_size;
4686
      int offset_size;
4687
      int initial_length_size;
4688
 
4689
      saved_start = start;
4690
      length = byte_get (start, 4); start += 4;
4691
 
4692
      if (length == 0)
4693
        {
4694
          printf ("\n%08lx ZERO terminator\n\n",
4695
                    (unsigned long)(saved_start - section_start));
4696
          continue;
4697
        }
4698
 
4699
      if (length == 0xffffffff)
4700
        {
4701
          length = byte_get (start, 8);
4702
          start += 8;
4703
          offset_size = 8;
4704
          initial_length_size = 12;
4705
        }
4706
      else
4707
        {
4708
          offset_size = 4;
4709
          initial_length_size = 4;
4710
        }
4711
 
4712
      block_end = saved_start + length + initial_length_size;
4713
      if (block_end > end)
4714
        {
4715
          warn ("Invalid length %#08lx in FDE at %#08lx\n",
4716
                length, (unsigned long)(saved_start - section_start));
4717
          block_end = end;
4718
        }
4719
      cie_id = byte_get (start, offset_size); start += offset_size;
4720
 
4721
      if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
4722
        {
4723
          int version;
4724
 
4725
          fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
4726
          memset (fc, 0, sizeof (Frame_Chunk));
4727
 
4728
          fc->next = chunks;
4729
          chunks = fc;
4730
          fc->chunk_start = saved_start;
4731
          fc->ncols = 0;
4732
          fc->col_type = (short int *) xmalloc (sizeof (short int));
4733
          fc->col_offset = (int *) xmalloc (sizeof (int));
4734
          frame_need_space (fc, max_regs - 1);
4735
 
4736
          version = *start++;
4737
 
4738
          fc->augmentation = (char *) start;
4739
          start = (unsigned char *) strchr ((char *) start, '\0') + 1;
4740
 
4741
          if (strcmp (fc->augmentation, "eh") == 0)
4742
            start += eh_addr_size;
4743
 
4744
          if (version >= 4)
4745
            {
4746
              fc->ptr_size = GET (1);
4747
              fc->segment_size = GET (1);
4748
              eh_addr_size = fc->ptr_size;
4749
            }
4750
          else
4751
            {
4752
              fc->ptr_size = eh_addr_size;
4753
              fc->segment_size = 0;
4754
            }
4755
          fc->code_factor = LEB ();
4756
          fc->data_factor = SLEB ();
4757
          if (version == 1)
4758
            {
4759
              fc->ra = GET (1);
4760
            }
4761
          else
4762
            {
4763
              fc->ra = LEB ();
4764
            }
4765
 
4766
          if (fc->augmentation[0] == 'z')
4767
            {
4768
              augmentation_data_len = LEB ();
4769
              augmentation_data = start;
4770
              start += augmentation_data_len;
4771
            }
4772
          cie = fc;
4773
 
4774
          if (do_debug_frames_interp)
4775
            printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
4776
                    (unsigned long)(saved_start - section_start), length, cie_id,
4777
                    fc->augmentation, fc->code_factor, fc->data_factor,
4778
                    fc->ra);
4779
          else
4780
            {
4781
              printf ("\n%08lx %08lx %08lx CIE\n",
4782
                      (unsigned long)(saved_start - section_start), length, cie_id);
4783
              printf ("  Version:               %d\n", version);
4784
              printf ("  Augmentation:          \"%s\"\n", fc->augmentation);
4785
              if (version >= 4)
4786
                {
4787
                  printf ("  Pointer Size:          %u\n", fc->ptr_size);
4788
                  printf ("  Segment Size:          %u\n", fc->segment_size);
4789
                }
4790
              printf ("  Code alignment factor: %u\n", fc->code_factor);
4791
              printf ("  Data alignment factor: %d\n", fc->data_factor);
4792
              printf ("  Return address column: %d\n", fc->ra);
4793
 
4794
              if (augmentation_data_len)
4795
                {
4796
                  unsigned long i;
4797
                  printf ("  Augmentation data:    ");
4798
                  for (i = 0; i < augmentation_data_len; ++i)
4799
                    printf (" %02x", augmentation_data[i]);
4800
                  putchar ('\n');
4801
                }
4802
              putchar ('\n');
4803
            }
4804
 
4805
          if (augmentation_data_len)
4806
            {
4807
              unsigned char *p, *q;
4808
              p = (unsigned char *) fc->augmentation + 1;
4809
              q = augmentation_data;
4810
 
4811
              while (1)
4812
                {
4813
                  if (*p == 'L')
4814
                    q++;
4815
                  else if (*p == 'P')
4816
                    q += 1 + size_of_encoded_value (*q);
4817
                  else if (*p == 'R')
4818
                    fc->fde_encoding = *q++;
4819
                  else if (*p == 'S')
4820
                    ;
4821
                  else
4822
                    break;
4823
                  p++;
4824
                }
4825
 
4826
              if (fc->fde_encoding)
4827
                encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
4828
            }
4829
 
4830
          frame_need_space (fc, fc->ra);
4831
        }
4832
      else
4833
        {
4834
          unsigned char *look_for;
4835
          static Frame_Chunk fde_fc;
4836
          unsigned long segment_selector;
4837
 
4838
          fc = & fde_fc;
4839
          memset (fc, 0, sizeof (Frame_Chunk));
4840
 
4841
          look_for = is_eh ? start - 4 - cie_id : section_start + cie_id;
4842
 
4843
          for (cie = chunks; cie ; cie = cie->next)
4844
            if (cie->chunk_start == look_for)
4845
              break;
4846
 
4847
          if (!cie)
4848
            {
4849
              warn ("Invalid CIE pointer %#08lx in FDE at %#08lx\n",
4850
                    cie_id, (unsigned long)(saved_start - section_start));
4851
              fc->ncols = 0;
4852
              fc->col_type = (short int *) xmalloc (sizeof (short int));
4853
              fc->col_offset = (int *) xmalloc (sizeof (int));
4854
              frame_need_space (fc, max_regs - 1);
4855
              cie = fc;
4856
              fc->augmentation = "";
4857
              fc->fde_encoding = 0;
4858
              fc->ptr_size = eh_addr_size;
4859
              fc->segment_size = 0;
4860
            }
4861
          else
4862
            {
4863
              fc->ncols = cie->ncols;
4864
              fc->col_type = (short int *) xcmalloc (fc->ncols, sizeof (short int));
4865
              fc->col_offset =  (int *) xcmalloc (fc->ncols, sizeof (int));
4866
              memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
4867
              memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
4868
              fc->augmentation = cie->augmentation;
4869
              fc->ptr_size = cie->ptr_size;
4870
              eh_addr_size = cie->ptr_size;
4871
              fc->segment_size = cie->segment_size;
4872
              fc->code_factor = cie->code_factor;
4873
              fc->data_factor = cie->data_factor;
4874
              fc->cfa_reg = cie->cfa_reg;
4875
              fc->cfa_offset = cie->cfa_offset;
4876
              fc->ra = cie->ra;
4877
              frame_need_space (fc, max_regs - 1);
4878
              fc->fde_encoding = cie->fde_encoding;
4879
            }
4880
 
4881
          if (fc->fde_encoding)
4882
            encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
4883
 
4884
          segment_selector = 0;
4885
          if (fc->segment_size)
4886
            {
4887
              segment_selector = byte_get (start, fc->segment_size);
4888
              start += fc->segment_size;
4889
            }
4890
          fc->pc_begin = get_encoded_value (start, fc->fde_encoding, section);
4891
          start += encoded_ptr_size;
4892
          fc->pc_range = byte_get (start, encoded_ptr_size);
4893
          start += encoded_ptr_size;
4894
 
4895
          if (cie->augmentation[0] == 'z')
4896
            {
4897
              augmentation_data_len = LEB ();
4898
              augmentation_data = start;
4899
              start += augmentation_data_len;
4900
            }
4901
 
4902
          printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=",
4903
                  (unsigned long)(saved_start - section_start), length, cie_id,
4904
                  (unsigned long)(cie->chunk_start - section_start));
4905
          if (fc->segment_size)
4906
            printf ("%04lx:", segment_selector);
4907
          printf ("%08lx..%08lx\n", fc->pc_begin, fc->pc_begin + fc->pc_range);
4908
          if (! do_debug_frames_interp && augmentation_data_len)
4909
            {
4910
              unsigned long i;
4911
 
4912
              printf ("  Augmentation data:    ");
4913
              for (i = 0; i < augmentation_data_len; ++i)
4914
                printf (" %02x", augmentation_data[i]);
4915
              putchar ('\n');
4916
              putchar ('\n');
4917
            }
4918
        }
4919
 
4920
      /* At this point, fc is the current chunk, cie (if any) is set, and
4921
         we're about to interpret instructions for the chunk.  */
4922
      /* ??? At present we need to do this always, since this sizes the
4923
         fc->col_type and fc->col_offset arrays, which we write into always.
4924
         We should probably split the interpreted and non-interpreted bits
4925
         into two different routines, since there's so much that doesn't
4926
         really overlap between them.  */
4927
      if (1 || do_debug_frames_interp)
4928
        {
4929
          /* Start by making a pass over the chunk, allocating storage
4930
             and taking note of what registers are used.  */
4931
          unsigned char *tmp = start;
4932
 
4933
          while (start < block_end)
4934
            {
4935
              unsigned op, opa;
4936
              unsigned long reg, temp;
4937
 
4938
              op = *start++;
4939
              opa = op & 0x3f;
4940
              if (op & 0xc0)
4941
                op &= 0xc0;
4942
 
4943
              /* Warning: if you add any more cases to this switch, be
4944
                 sure to add them to the corresponding switch below.  */
4945
              switch (op)
4946
                {
4947
                case DW_CFA_advance_loc:
4948
                  break;
4949
                case DW_CFA_offset:
4950
                  LEB ();
4951
                  if (frame_need_space (fc, opa) >= 0)
4952
                    fc->col_type[opa] = DW_CFA_undefined;
4953
                  break;
4954
                case DW_CFA_restore:
4955
                  if (frame_need_space (fc, opa) >= 0)
4956
                    fc->col_type[opa] = DW_CFA_undefined;
4957
                  break;
4958
                case DW_CFA_set_loc:
4959
                  start += encoded_ptr_size;
4960
                  break;
4961
                case DW_CFA_advance_loc1:
4962
                  start += 1;
4963
                  break;
4964
                case DW_CFA_advance_loc2:
4965
                  start += 2;
4966
                  break;
4967
                case DW_CFA_advance_loc4:
4968
                  start += 4;
4969
                  break;
4970
                case DW_CFA_offset_extended:
4971
                case DW_CFA_val_offset:
4972
                  reg = LEB (); LEB ();
4973
                  if (frame_need_space (fc, reg) >= 0)
4974
                    fc->col_type[reg] = DW_CFA_undefined;
4975
                  break;
4976
                case DW_CFA_restore_extended:
4977
                  reg = LEB ();
4978
                  frame_need_space (fc, reg);
4979
                  if (frame_need_space (fc, reg) >= 0)
4980
                    fc->col_type[reg] = DW_CFA_undefined;
4981
                  break;
4982
                case DW_CFA_undefined:
4983
                  reg = LEB ();
4984
                  if (frame_need_space (fc, reg) >= 0)
4985
                    fc->col_type[reg] = DW_CFA_undefined;
4986
                  break;
4987
                case DW_CFA_same_value:
4988
                  reg = LEB ();
4989
                  if (frame_need_space (fc, reg) >= 0)
4990
                    fc->col_type[reg] = DW_CFA_undefined;
4991
                  break;
4992
                case DW_CFA_register:
4993
                  reg = LEB (); LEB ();
4994
                  if (frame_need_space (fc, reg) >= 0)
4995
                    fc->col_type[reg] = DW_CFA_undefined;
4996
                  break;
4997
                case DW_CFA_def_cfa:
4998
                  LEB (); LEB ();
4999
                  break;
5000
                case DW_CFA_def_cfa_register:
5001
                  LEB ();
5002
                  break;
5003
                case DW_CFA_def_cfa_offset:
5004
                  LEB ();
5005
                  break;
5006
                case DW_CFA_def_cfa_expression:
5007
                  temp = LEB ();
5008
                  start += temp;
5009
                  break;
5010
                case DW_CFA_expression:
5011
                case DW_CFA_val_expression:
5012
                  reg = LEB ();
5013
                  temp = LEB ();
5014
                  start += temp;
5015
                  if (frame_need_space (fc, reg) >= 0)
5016
                    fc->col_type[reg] = DW_CFA_undefined;
5017
                  break;
5018
                case DW_CFA_offset_extended_sf:
5019
                case DW_CFA_val_offset_sf:
5020
                  reg = LEB (); SLEB ();
5021
                  if (frame_need_space (fc, reg) >= 0)
5022
                    fc->col_type[reg] = DW_CFA_undefined;
5023
                  break;
5024
                case DW_CFA_def_cfa_sf:
5025
                  LEB (); SLEB ();
5026
                  break;
5027
                case DW_CFA_def_cfa_offset_sf:
5028
                  SLEB ();
5029
                  break;
5030
                case DW_CFA_MIPS_advance_loc8:
5031
                  start += 8;
5032
                  break;
5033
                case DW_CFA_GNU_args_size:
5034
                  LEB ();
5035
                  break;
5036
                case DW_CFA_GNU_negative_offset_extended:
5037
                  reg = LEB (); LEB ();
5038
                  if (frame_need_space (fc, reg) >= 0)
5039
                    fc->col_type[reg] = DW_CFA_undefined;
5040
                  break;
5041
                default:
5042
                  break;
5043
                }
5044
            }
5045
          start = tmp;
5046
        }
5047
 
5048
      /* Now we know what registers are used, make a second pass over
5049
         the chunk, this time actually printing out the info.  */
5050
 
5051
      while (start < block_end)
5052
        {
5053
          unsigned op, opa;
5054
          unsigned long ul, reg, roffs;
5055
          long l, ofs;
5056
          dwarf_vma vma;
5057
          const char *reg_prefix = "";
5058
 
5059
          op = *start++;
5060
          opa = op & 0x3f;
5061
          if (op & 0xc0)
5062
            op &= 0xc0;
5063
 
5064
          /* Warning: if you add any more cases to this switch, be
5065
             sure to add them to the corresponding switch above.  */
5066
          switch (op)
5067
            {
5068
            case DW_CFA_advance_loc:
5069
              if (do_debug_frames_interp)
5070
                frame_display_row (fc, &need_col_headers, &max_regs);
5071
              else
5072
                printf ("  DW_CFA_advance_loc: %d to %08lx\n",
5073
                        opa * fc->code_factor,
5074
                        fc->pc_begin + opa * fc->code_factor);
5075
              fc->pc_begin += opa * fc->code_factor;
5076
              break;
5077
 
5078
            case DW_CFA_offset:
5079
              roffs = LEB ();
5080
              if (opa >= (unsigned int) fc->ncols)
5081
                reg_prefix = bad_reg;
5082
              if (! do_debug_frames_interp || *reg_prefix != '\0')
5083
                printf ("  DW_CFA_offset: %s%s at cfa%+ld\n",
5084
                        reg_prefix, regname (opa, 0),
5085
                        roffs * fc->data_factor);
5086
              if (*reg_prefix == '\0')
5087
                {
5088
                  fc->col_type[opa] = DW_CFA_offset;
5089
                  fc->col_offset[opa] = roffs * fc->data_factor;
5090
                }
5091
              break;
5092
 
5093
            case DW_CFA_restore:
5094
              if (opa >= (unsigned int) cie->ncols
5095
                  || opa >= (unsigned int) fc->ncols)
5096
                reg_prefix = bad_reg;
5097
              if (! do_debug_frames_interp || *reg_prefix != '\0')
5098
                printf ("  DW_CFA_restore: %s%s\n",
5099
                        reg_prefix, regname (opa, 0));
5100
              if (*reg_prefix == '\0')
5101
                {
5102
                  fc->col_type[opa] = cie->col_type[opa];
5103
                  fc->col_offset[opa] = cie->col_offset[opa];
5104
                }
5105
              break;
5106
 
5107
            case DW_CFA_set_loc:
5108
              vma = get_encoded_value (start, fc->fde_encoding, section);
5109
              start += encoded_ptr_size;
5110
              if (do_debug_frames_interp)
5111
                frame_display_row (fc, &need_col_headers, &max_regs);
5112
              else
5113
                printf ("  DW_CFA_set_loc: %08lx\n", (unsigned long)vma);
5114
              fc->pc_begin = vma;
5115
              break;
5116
 
5117
            case DW_CFA_advance_loc1:
5118
              ofs = byte_get (start, 1); start += 1;
5119
              if (do_debug_frames_interp)
5120
                frame_display_row (fc, &need_col_headers, &max_regs);
5121
              else
5122
                printf ("  DW_CFA_advance_loc1: %ld to %08lx\n",
5123
                        ofs * fc->code_factor,
5124
                        fc->pc_begin + ofs * fc->code_factor);
5125
              fc->pc_begin += ofs * fc->code_factor;
5126
              break;
5127
 
5128
            case DW_CFA_advance_loc2:
5129
              ofs = byte_get (start, 2); start += 2;
5130
              if (do_debug_frames_interp)
5131
                frame_display_row (fc, &need_col_headers, &max_regs);
5132
              else
5133
                printf ("  DW_CFA_advance_loc2: %ld to %08lx\n",
5134
                        ofs * fc->code_factor,
5135
                        fc->pc_begin + ofs * fc->code_factor);
5136
              fc->pc_begin += ofs * fc->code_factor;
5137
              break;
5138
 
5139
            case DW_CFA_advance_loc4:
5140
              ofs = byte_get (start, 4); start += 4;
5141
              if (do_debug_frames_interp)
5142
                frame_display_row (fc, &need_col_headers, &max_regs);
5143
              else
5144
                printf ("  DW_CFA_advance_loc4: %ld to %08lx\n",
5145
                        ofs * fc->code_factor,
5146
                        fc->pc_begin + ofs * fc->code_factor);
5147
              fc->pc_begin += ofs * fc->code_factor;
5148
              break;
5149
 
5150
            case DW_CFA_offset_extended:
5151
              reg = LEB ();
5152
              roffs = LEB ();
5153
              if (reg >= (unsigned int) fc->ncols)
5154
                reg_prefix = bad_reg;
5155
              if (! do_debug_frames_interp || *reg_prefix != '\0')
5156
                printf ("  DW_CFA_offset_extended: %s%s at cfa%+ld\n",
5157
                        reg_prefix, regname (reg, 0),
5158
                        roffs * fc->data_factor);
5159
              if (*reg_prefix == '\0')
5160
                {
5161
                  fc->col_type[reg] = DW_CFA_offset;
5162
                  fc->col_offset[reg] = roffs * fc->data_factor;
5163
                }
5164
              break;
5165
 
5166
            case DW_CFA_val_offset:
5167
              reg = LEB ();
5168
              roffs = LEB ();
5169
              if (reg >= (unsigned int) fc->ncols)
5170
                reg_prefix = bad_reg;
5171
              if (! do_debug_frames_interp || *reg_prefix != '\0')
5172
                printf ("  DW_CFA_val_offset: %s%s at cfa%+ld\n",
5173
                        reg_prefix, regname (reg, 0),
5174
                        roffs * fc->data_factor);
5175
              if (*reg_prefix == '\0')
5176
                {
5177
                  fc->col_type[reg] = DW_CFA_val_offset;
5178
                  fc->col_offset[reg] = roffs * fc->data_factor;
5179
                }
5180
              break;
5181
 
5182
            case DW_CFA_restore_extended:
5183
              reg = LEB ();
5184
              if (reg >= (unsigned int) cie->ncols
5185
                  || reg >= (unsigned int) fc->ncols)
5186
                reg_prefix = bad_reg;
5187
              if (! do_debug_frames_interp || *reg_prefix != '\0')
5188
                printf ("  DW_CFA_restore_extended: %s%s\n",
5189
                        reg_prefix, regname (reg, 0));
5190
              if (*reg_prefix == '\0')
5191
                {
5192
                  fc->col_type[reg] = cie->col_type[reg];
5193
                  fc->col_offset[reg] = cie->col_offset[reg];
5194
                }
5195
              break;
5196
 
5197
            case DW_CFA_undefined:
5198
              reg = LEB ();
5199
              if (reg >= (unsigned int) fc->ncols)
5200
                reg_prefix = bad_reg;
5201
              if (! do_debug_frames_interp || *reg_prefix != '\0')
5202
                printf ("  DW_CFA_undefined: %s%s\n",
5203
                        reg_prefix, regname (reg, 0));
5204
              if (*reg_prefix == '\0')
5205
                {
5206
                  fc->col_type[reg] = DW_CFA_undefined;
5207
                  fc->col_offset[reg] = 0;
5208
                }
5209
              break;
5210
 
5211
            case DW_CFA_same_value:
5212
              reg = LEB ();
5213
              if (reg >= (unsigned int) fc->ncols)
5214
                reg_prefix = bad_reg;
5215
              if (! do_debug_frames_interp || *reg_prefix != '\0')
5216
                printf ("  DW_CFA_same_value: %s%s\n",
5217
                        reg_prefix, regname (reg, 0));
5218
              if (*reg_prefix == '\0')
5219
                {
5220
                  fc->col_type[reg] = DW_CFA_same_value;
5221
                  fc->col_offset[reg] = 0;
5222
                }
5223
              break;
5224
 
5225
            case DW_CFA_register:
5226
              reg = LEB ();
5227
              roffs = LEB ();
5228
              if (reg >= (unsigned int) fc->ncols)
5229
                reg_prefix = bad_reg;
5230
              if (! do_debug_frames_interp || *reg_prefix != '\0')
5231
                {
5232
                  printf ("  DW_CFA_register: %s%s in ",
5233
                          reg_prefix, regname (reg, 0));
5234
                  puts (regname (roffs, 0));
5235
                }
5236
              if (*reg_prefix == '\0')
5237
                {
5238
                  fc->col_type[reg] = DW_CFA_register;
5239
                  fc->col_offset[reg] = roffs;
5240
                }
5241
              break;
5242
 
5243
            case DW_CFA_remember_state:
5244
              if (! do_debug_frames_interp)
5245
                printf ("  DW_CFA_remember_state\n");
5246
              rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
5247
              rs->ncols = fc->ncols;
5248
              rs->col_type = (short int *) xcmalloc (rs->ncols,
5249
                                                     sizeof (short int));
5250
              rs->col_offset = (int *) xcmalloc (rs->ncols, sizeof (int));
5251
              memcpy (rs->col_type, fc->col_type, rs->ncols);
5252
              memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
5253
              rs->next = remembered_state;
5254
              remembered_state = rs;
5255
              break;
5256
 
5257
            case DW_CFA_restore_state:
5258
              if (! do_debug_frames_interp)
5259
                printf ("  DW_CFA_restore_state\n");
5260
              rs = remembered_state;
5261
              if (rs)
5262
                {
5263
                  remembered_state = rs->next;
5264
                  frame_need_space (fc, rs->ncols - 1);
5265
                  memcpy (fc->col_type, rs->col_type, rs->ncols);
5266
                  memcpy (fc->col_offset, rs->col_offset,
5267
                          rs->ncols * sizeof (int));
5268
                  free (rs->col_type);
5269
                  free (rs->col_offset);
5270
                  free (rs);
5271
                }
5272
              else if (do_debug_frames_interp)
5273
                printf ("Mismatched DW_CFA_restore_state\n");
5274
              break;
5275
 
5276
            case DW_CFA_def_cfa:
5277
              fc->cfa_reg = LEB ();
5278
              fc->cfa_offset = LEB ();
5279
              fc->cfa_exp = 0;
5280
              if (! do_debug_frames_interp)
5281
                printf ("  DW_CFA_def_cfa: %s ofs %d\n",
5282
                        regname (fc->cfa_reg, 0), fc->cfa_offset);
5283
              break;
5284
 
5285
            case DW_CFA_def_cfa_register:
5286
              fc->cfa_reg = LEB ();
5287
              fc->cfa_exp = 0;
5288
              if (! do_debug_frames_interp)
5289
                printf ("  DW_CFA_def_cfa_register: %s\n",
5290
                        regname (fc->cfa_reg, 0));
5291
              break;
5292
 
5293
            case DW_CFA_def_cfa_offset:
5294
              fc->cfa_offset = LEB ();
5295
              if (! do_debug_frames_interp)
5296
                printf ("  DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
5297
              break;
5298
 
5299
            case DW_CFA_nop:
5300
              if (! do_debug_frames_interp)
5301
                printf ("  DW_CFA_nop\n");
5302
              break;
5303
 
5304
            case DW_CFA_def_cfa_expression:
5305
              ul = LEB ();
5306
              if (! do_debug_frames_interp)
5307
                {
5308
                  printf ("  DW_CFA_def_cfa_expression (");
5309
                  decode_location_expression (start, eh_addr_size, 0, -1,
5310
                                              ul, 0, section);
5311
                  printf (")\n");
5312
                }
5313
              fc->cfa_exp = 1;
5314
              start += ul;
5315
              break;
5316
 
5317
            case DW_CFA_expression:
5318
              reg = LEB ();
5319
              ul = LEB ();
5320
              if (reg >= (unsigned int) fc->ncols)
5321
                reg_prefix = bad_reg;
5322
              if (! do_debug_frames_interp || *reg_prefix != '\0')
5323
                {
5324
                  printf ("  DW_CFA_expression: %s%s (",
5325
                          reg_prefix, regname (reg, 0));
5326
                  decode_location_expression (start, eh_addr_size, 0, -1,
5327
                                              ul, 0, section);
5328
                  printf (")\n");
5329
                }
5330
              if (*reg_prefix == '\0')
5331
                fc->col_type[reg] = DW_CFA_expression;
5332
              start += ul;
5333
              break;
5334
 
5335
            case DW_CFA_val_expression:
5336
              reg = LEB ();
5337
              ul = LEB ();
5338
              if (reg >= (unsigned int) fc->ncols)
5339
                reg_prefix = bad_reg;
5340
              if (! do_debug_frames_interp || *reg_prefix != '\0')
5341
                {
5342
                  printf ("  DW_CFA_val_expression: %s%s (",
5343
                          reg_prefix, regname (reg, 0));
5344
                  decode_location_expression (start, eh_addr_size, 0, -1,
5345
                                              ul, 0, section);
5346
                  printf (")\n");
5347
                }
5348
              if (*reg_prefix == '\0')
5349
                fc->col_type[reg] = DW_CFA_val_expression;
5350
              start += ul;
5351
              break;
5352
 
5353
            case DW_CFA_offset_extended_sf:
5354
              reg = LEB ();
5355
              l = SLEB ();
5356
              if (frame_need_space (fc, reg) < 0)
5357
                reg_prefix = bad_reg;
5358
              if (! do_debug_frames_interp || *reg_prefix != '\0')
5359
                printf ("  DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
5360
                        reg_prefix, regname (reg, 0),
5361
                        l * fc->data_factor);
5362
              if (*reg_prefix == '\0')
5363
                {
5364
                  fc->col_type[reg] = DW_CFA_offset;
5365
                  fc->col_offset[reg] = l * fc->data_factor;
5366
                }
5367
              break;
5368
 
5369
            case DW_CFA_val_offset_sf:
5370
              reg = LEB ();
5371
              l = SLEB ();
5372
              if (frame_need_space (fc, reg) < 0)
5373
                reg_prefix = bad_reg;
5374
              if (! do_debug_frames_interp || *reg_prefix != '\0')
5375
                printf ("  DW_CFA_val_offset_sf: %s%s at cfa%+ld\n",
5376
                        reg_prefix, regname (reg, 0),
5377
                        l * fc->data_factor);
5378
              if (*reg_prefix == '\0')
5379
                {
5380
                  fc->col_type[reg] = DW_CFA_val_offset;
5381
                  fc->col_offset[reg] = l * fc->data_factor;
5382
                }
5383
              break;
5384
 
5385
            case DW_CFA_def_cfa_sf:
5386
              fc->cfa_reg = LEB ();
5387
              fc->cfa_offset = SLEB ();
5388
              fc->cfa_offset = fc->cfa_offset * fc->data_factor;
5389
              fc->cfa_exp = 0;
5390
              if (! do_debug_frames_interp)
5391
                printf ("  DW_CFA_def_cfa_sf: %s ofs %d\n",
5392
                        regname (fc->cfa_reg, 0), fc->cfa_offset);
5393
              break;
5394
 
5395
            case DW_CFA_def_cfa_offset_sf:
5396
              fc->cfa_offset = SLEB ();
5397
              fc->cfa_offset = fc->cfa_offset * fc->data_factor;
5398
              if (! do_debug_frames_interp)
5399
                printf ("  DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset);
5400
              break;
5401
 
5402
            case DW_CFA_MIPS_advance_loc8:
5403
              ofs = byte_get (start, 8); start += 8;
5404
              if (do_debug_frames_interp)
5405
                frame_display_row (fc, &need_col_headers, &max_regs);
5406
              else
5407
                printf ("  DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
5408
                        ofs * fc->code_factor,
5409
                        fc->pc_begin + ofs * fc->code_factor);
5410
              fc->pc_begin += ofs * fc->code_factor;
5411
              break;
5412
 
5413
            case DW_CFA_GNU_window_save:
5414
              if (! do_debug_frames_interp)
5415
                printf ("  DW_CFA_GNU_window_save\n");
5416
              break;
5417
 
5418
            case DW_CFA_GNU_args_size:
5419
              ul = LEB ();
5420
              if (! do_debug_frames_interp)
5421
                printf ("  DW_CFA_GNU_args_size: %ld\n", ul);
5422
              break;
5423
 
5424
            case DW_CFA_GNU_negative_offset_extended:
5425
              reg = LEB ();
5426
              l = - LEB ();
5427
              if (frame_need_space (fc, reg) < 0)
5428
                reg_prefix = bad_reg;
5429
              if (! do_debug_frames_interp || *reg_prefix != '\0')
5430
                printf ("  DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
5431
                        reg_prefix, regname (reg, 0),
5432
                        l * fc->data_factor);
5433
              if (*reg_prefix == '\0')
5434
                {
5435
                  fc->col_type[reg] = DW_CFA_offset;
5436
                  fc->col_offset[reg] = l * fc->data_factor;
5437
                }
5438
              break;
5439
 
5440
            default:
5441
              if (op >= DW_CFA_lo_user && op <= DW_CFA_hi_user)
5442
                printf (_("  DW_CFA_??? (User defined call frame op: %#x)\n"), op);
5443
              else
5444
                warn (_("unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op);
5445
              start = block_end;
5446
            }
5447
        }
5448
 
5449
      if (do_debug_frames_interp)
5450
        frame_display_row (fc, &need_col_headers, &max_regs);
5451
 
5452
      start = block_end;
5453
      eh_addr_size = saved_eh_addr_size;
5454
    }
5455
 
5456
  printf ("\n");
5457
 
5458
  return 1;
5459
}
5460
 
5461
#undef GET
5462
#undef LEB
5463
#undef SLEB
5464
 
5465
static int
5466
display_gdb_index (struct dwarf_section *section,
5467
                   void *file ATTRIBUTE_UNUSED)
5468
{
5469
  unsigned char *start = section->start;
5470
  uint32_t version;
5471
  uint32_t cu_list_offset, tu_list_offset;
5472
  uint32_t address_table_offset, symbol_table_offset, constant_pool_offset;
5473
  unsigned int cu_list_elements, tu_list_elements;
5474
  unsigned int address_table_size, symbol_table_slots;
5475
  unsigned char *cu_list, *tu_list;
5476
  unsigned char *address_table, *symbol_table, *constant_pool;
5477
  unsigned int i;
5478
 
5479
  /* The documentation for the format of this file is in gdb/dwarf2read.c.  */
5480
 
5481
  printf (_("Contents of the %s section:\n"), section->name);
5482
 
5483
  if (section->size < 6 * sizeof (uint32_t))
5484
    {
5485
      warn (_("Truncated header in the %s section.\n"), section->name);
5486
      return 0;
5487
    }
5488
 
5489
  version = byte_get_little_endian (start, 4);
5490
  printf (_("Version %ld\n"), (long) version);
5491
 
5492
  /* Prior versions are obsolete, and future versions may not be
5493
     backwards compatible.  */
5494
  switch (version)
5495
    {
5496
    case 3:
5497
      warn (_("The address table data in version 3 may be wrong.\n"));
5498
      break;
5499
    case 4:
5500
      warn (_("Version 4 does not support case insensitive lookups.\n"));
5501
      break;
5502
    case 5:
5503
      break;
5504
    default:
5505
      warn (_("Unsupported version %lu.\n"), (unsigned long) version);
5506
      return 0;
5507
    }
5508
 
5509
  cu_list_offset = byte_get_little_endian (start + 4, 4);
5510
  tu_list_offset = byte_get_little_endian (start + 8, 4);
5511
  address_table_offset = byte_get_little_endian (start + 12, 4);
5512
  symbol_table_offset = byte_get_little_endian (start + 16, 4);
5513
  constant_pool_offset = byte_get_little_endian (start + 20, 4);
5514
 
5515
  if (cu_list_offset > section->size
5516
      || tu_list_offset > section->size
5517
      || address_table_offset > section->size
5518
      || symbol_table_offset > section->size
5519
      || constant_pool_offset > section->size)
5520
    {
5521
      warn (_("Corrupt header in the %s section.\n"), section->name);
5522
      return 0;
5523
    }
5524
 
5525
  cu_list_elements = (tu_list_offset - cu_list_offset) / 8;
5526
  tu_list_elements = (address_table_offset - tu_list_offset) / 8;
5527
  address_table_size = symbol_table_offset - address_table_offset;
5528
  symbol_table_slots = (constant_pool_offset - symbol_table_offset) / 8;
5529
 
5530
  cu_list = start + cu_list_offset;
5531
  tu_list = start + tu_list_offset;
5532
  address_table = start + address_table_offset;
5533
  symbol_table = start + symbol_table_offset;
5534
  constant_pool = start + constant_pool_offset;
5535
 
5536
  printf (_("\nCU table:\n"));
5537
  for (i = 0; i < cu_list_elements; i += 2)
5538
    {
5539
      uint64_t cu_offset = byte_get_little_endian (cu_list + i * 8, 8);
5540
      uint64_t cu_length = byte_get_little_endian (cu_list + i * 8 + 8, 8);
5541
 
5542
      printf (_("[%3u] 0x%lx - 0x%lx\n"), i / 2,
5543
              (unsigned long) cu_offset,
5544
              (unsigned long) (cu_offset + cu_length - 1));
5545
    }
5546
 
5547
  printf (_("\nTU table:\n"));
5548
  for (i = 0; i < tu_list_elements; i += 3)
5549
    {
5550
      uint64_t tu_offset = byte_get_little_endian (tu_list + i * 8, 8);
5551
      uint64_t type_offset = byte_get_little_endian (tu_list + i * 8 + 8, 8);
5552
      uint64_t signature = byte_get_little_endian (tu_list + i * 8 + 16, 8);
5553
 
5554
      printf (_("[%3u] 0x%lx 0x%lx "), i / 3,
5555
              (unsigned long) tu_offset,
5556
              (unsigned long) type_offset);
5557
      print_dwarf_vma (signature, 8);
5558
      printf ("\n");
5559
    }
5560
 
5561
  printf (_("\nAddress table:\n"));
5562
  for (i = 0; i < address_table_size; i += 2 * 8 + 4)
5563
    {
5564
      uint64_t low = byte_get_little_endian (address_table + i, 8);
5565
      uint64_t high = byte_get_little_endian (address_table + i + 8, 8);
5566
      uint32_t cu_index = byte_get_little_endian (address_table + i + 16, 4);
5567
 
5568
      print_dwarf_vma (low, 8);
5569
      print_dwarf_vma (high, 8);
5570
      printf (_("%lu\n"), (unsigned long) cu_index);
5571
    }
5572
 
5573
  printf (_("\nSymbol table:\n"));
5574
  for (i = 0; i < symbol_table_slots; ++i)
5575
    {
5576
      uint32_t name_offset = byte_get_little_endian (symbol_table + i * 8, 4);
5577
      uint32_t cu_vector_offset = byte_get_little_endian (symbol_table + i * 8 + 4, 4);
5578
      uint32_t num_cus, cu;
5579
 
5580
      if (name_offset != 0
5581
          || cu_vector_offset != 0)
5582
        {
5583
          unsigned int j;
5584
 
5585
          printf ("[%3u] %s:", i, constant_pool + name_offset);
5586
          num_cus = byte_get_little_endian (constant_pool + cu_vector_offset, 4);
5587
          for (j = 0; j < num_cus; ++j)
5588
            {
5589
              cu = byte_get_little_endian (constant_pool + cu_vector_offset + 4 + j * 4, 4);
5590
              /* Convert to TU number if it's for a type unit.  */
5591 148 khays
              if (cu >= cu_list_elements / 2)
5592
                printf (" T%lu", (unsigned long) (cu - cu_list_elements / 2));
5593 15 khays
              else
5594
                printf (" %lu", (unsigned long) cu);
5595
            }
5596
          printf ("\n");
5597
        }
5598
    }
5599
 
5600
  return 1;
5601
}
5602
 
5603
static int
5604
display_debug_not_supported (struct dwarf_section *section,
5605
                             void *file ATTRIBUTE_UNUSED)
5606
{
5607
  printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
5608
            section->name);
5609
 
5610
  return 1;
5611
}
5612
 
5613
void *
5614
cmalloc (size_t nmemb, size_t size)
5615
{
5616
  /* Check for overflow.  */
5617
  if (nmemb >= ~(size_t) 0 / size)
5618
    return NULL;
5619
  else
5620
    return malloc (nmemb * size);
5621
}
5622
 
5623
void *
5624
xcmalloc (size_t nmemb, size_t size)
5625
{
5626
  /* Check for overflow.  */
5627
  if (nmemb >= ~(size_t) 0 / size)
5628
    return NULL;
5629
  else
5630
    return xmalloc (nmemb * size);
5631
}
5632
 
5633
void *
5634
xcrealloc (void *ptr, size_t nmemb, size_t size)
5635
{
5636
  /* Check for overflow.  */
5637
  if (nmemb >= ~(size_t) 0 / size)
5638
    return NULL;
5639
  else
5640
    return xrealloc (ptr, nmemb * size);
5641
}
5642
 
5643
void
5644
free_debug_memory (void)
5645
{
5646
  unsigned int i;
5647
 
5648
  free_abbrevs ();
5649
 
5650
  for (i = 0; i < max; i++)
5651
    free_debug_section ((enum dwarf_section_display_enum) i);
5652
 
5653
  if (debug_information != NULL)
5654
    {
5655
      if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE)
5656
        {
5657
          for (i = 0; i < num_debug_info_entries; i++)
5658
            {
5659
              if (!debug_information [i].max_loc_offsets)
5660
                {
5661
                  free (debug_information [i].loc_offsets);
5662
                  free (debug_information [i].have_frame_base);
5663
                }
5664
              if (!debug_information [i].max_range_lists)
5665
                free (debug_information [i].range_lists);
5666
            }
5667
        }
5668
 
5669
      free (debug_information);
5670
      debug_information = NULL;
5671
      num_debug_info_entries = 0;
5672
    }
5673
}
5674
 
5675
void
5676
dwarf_select_sections_by_names (const char *names)
5677
{
5678
  typedef struct
5679
  {
5680
    const char * option;
5681
    int *        variable;
5682
    int          val;
5683
  }
5684
  debug_dump_long_opts;
5685
 
5686
  static const debug_dump_long_opts opts_table [] =
5687
    {
5688
      /* Please keep this table alpha- sorted.  */
5689
      { "Ranges", & do_debug_ranges, 1 },
5690
      { "abbrev", & do_debug_abbrevs, 1 },
5691
      { "aranges", & do_debug_aranges, 1 },
5692
      { "frames", & do_debug_frames, 1 },
5693
      { "frames-interp", & do_debug_frames_interp, 1 },
5694
      { "info", & do_debug_info, 1 },
5695
      { "line", & do_debug_lines, FLAG_DEBUG_LINES_RAW }, /* For backwards compatibility.  */
5696
      { "rawline", & do_debug_lines, FLAG_DEBUG_LINES_RAW },
5697
      { "decodedline", & do_debug_lines, FLAG_DEBUG_LINES_DECODED },
5698
      { "loc",  & do_debug_loc, 1 },
5699
      { "macro", & do_debug_macinfo, 1 },
5700
      { "pubnames", & do_debug_pubnames, 1 },
5701
      { "pubtypes", & do_debug_pubtypes, 1 },
5702
      /* This entry is for compatability
5703
         with earlier versions of readelf.  */
5704
      { "ranges", & do_debug_aranges, 1 },
5705
      { "str", & do_debug_str, 1 },
5706
      /* The special .gdb_index section.  */
5707
      { "gdb_index", & do_gdb_index, 1 },
5708
      /* These trace_* sections are used by Itanium VMS.  */
5709
      { "trace_abbrev", & do_trace_abbrevs, 1 },
5710
      { "trace_aranges", & do_trace_aranges, 1 },
5711
      { "trace_info", & do_trace_info, 1 },
5712
      { NULL, NULL, 0 }
5713
    };
5714
 
5715
  const char *p;
5716
 
5717
  p = names;
5718
  while (*p)
5719
    {
5720
      const debug_dump_long_opts * entry;
5721
 
5722
      for (entry = opts_table; entry->option; entry++)
5723
        {
5724
          size_t len = strlen (entry->option);
5725
 
5726
          if (strncmp (p, entry->option, len) == 0
5727
              && (p[len] == ',' || p[len] == '\0'))
5728
            {
5729
              * entry->variable |= entry->val;
5730
 
5731
              /* The --debug-dump=frames-interp option also
5732
                 enables the --debug-dump=frames option.  */
5733
              if (do_debug_frames_interp)
5734
                do_debug_frames = 1;
5735
 
5736
              p += len;
5737
              break;
5738
            }
5739
        }
5740
 
5741
      if (entry->option == NULL)
5742
        {
5743
          warn (_("Unrecognized debug option '%s'\n"), p);
5744
          p = strchr (p, ',');
5745
          if (p == NULL)
5746
            break;
5747
        }
5748
 
5749
      if (*p == ',')
5750
        p++;
5751
    }
5752
}
5753
 
5754
void
5755
dwarf_select_sections_by_letters (const char *letters)
5756
{
5757
  unsigned int lindex = 0;
5758
 
5759
  while (letters[lindex])
5760
    switch (letters[lindex++])
5761
      {
5762
      case 'i':
5763
        do_debug_info = 1;
5764
        break;
5765
 
5766
      case 'a':
5767
        do_debug_abbrevs = 1;
5768
        break;
5769
 
5770
      case 'l':
5771
        do_debug_lines |= FLAG_DEBUG_LINES_RAW;
5772
        break;
5773
 
5774
      case 'L':
5775
        do_debug_lines |= FLAG_DEBUG_LINES_DECODED;
5776
        break;
5777
 
5778
      case 'p':
5779
        do_debug_pubnames = 1;
5780
        break;
5781
 
5782
      case 't':
5783
        do_debug_pubtypes = 1;
5784
        break;
5785
 
5786
      case 'r':
5787
        do_debug_aranges = 1;
5788
        break;
5789
 
5790
      case 'R':
5791
        do_debug_ranges = 1;
5792
        break;
5793
 
5794
      case 'F':
5795
        do_debug_frames_interp = 1;
5796
      case 'f':
5797
        do_debug_frames = 1;
5798
        break;
5799
 
5800
      case 'm':
5801
        do_debug_macinfo = 1;
5802
        break;
5803
 
5804
      case 's':
5805
        do_debug_str = 1;
5806
        break;
5807
 
5808
      case 'o':
5809
        do_debug_loc = 1;
5810
        break;
5811
 
5812
      default:
5813
        warn (_("Unrecognized debug option '%s'\n"), optarg);
5814
        break;
5815
      }
5816
}
5817
 
5818
void
5819
dwarf_select_sections_all (void)
5820
{
5821
  do_debug_info = 1;
5822
  do_debug_abbrevs = 1;
5823
  do_debug_lines = FLAG_DEBUG_LINES_RAW;
5824
  do_debug_pubnames = 1;
5825
  do_debug_pubtypes = 1;
5826
  do_debug_aranges = 1;
5827
  do_debug_ranges = 1;
5828
  do_debug_frames = 1;
5829
  do_debug_macinfo = 1;
5830
  do_debug_str = 1;
5831
  do_debug_loc = 1;
5832
  do_gdb_index = 1;
5833
  do_trace_info = 1;
5834
  do_trace_abbrevs = 1;
5835
  do_trace_aranges = 1;
5836
}
5837
 
5838
struct dwarf_section_display debug_displays[] =
5839
{
5840
  { { ".debug_abbrev",          ".zdebug_abbrev",       NULL, NULL, 0, 0 },
5841
    display_debug_abbrev,               &do_debug_abbrevs,      0 },
5842
  { { ".debug_aranges",         ".zdebug_aranges",      NULL, NULL, 0, 0 },
5843
    display_debug_aranges,              &do_debug_aranges,      1 },
5844
  { { ".debug_frame",           ".zdebug_frame",        NULL, NULL, 0, 0 },
5845
    display_debug_frames,               &do_debug_frames,       1 },
5846
  { { ".debug_info",            ".zdebug_info",         NULL, NULL, 0, 0 },
5847
    display_debug_info,                 &do_debug_info,         1 },
5848
  { { ".debug_line",            ".zdebug_line",         NULL, NULL, 0, 0 },
5849
    display_debug_lines,                &do_debug_lines,        1 },
5850
  { { ".debug_pubnames",        ".zdebug_pubnames",     NULL, NULL, 0, 0 },
5851
    display_debug_pubnames,             &do_debug_pubnames,     0 },
5852
  { { ".eh_frame",              "",                     NULL, NULL, 0, 0 },
5853
    display_debug_frames,               &do_debug_frames,       1 },
5854
  { { ".debug_macinfo",         ".zdebug_macinfo",      NULL, NULL, 0, 0 },
5855
    display_debug_macinfo,              &do_debug_macinfo,      0 },
5856 161 khays
  { { ".debug_macro",           ".zdebug_macro",        NULL, NULL, 0, 0 },
5857
    display_debug_macro,                &do_debug_macinfo,      1 },
5858 15 khays
  { { ".debug_str",             ".zdebug_str",          NULL, NULL, 0, 0 },
5859
    display_debug_str,                  &do_debug_str,          0 },
5860
  { { ".debug_loc",             ".zdebug_loc",          NULL, NULL, 0, 0 },
5861
    display_debug_loc,                  &do_debug_loc,          1 },
5862
  { { ".debug_pubtypes",        ".zdebug_pubtypes",     NULL, NULL, 0, 0 },
5863
    display_debug_pubnames,             &do_debug_pubtypes,     0 },
5864
  { { ".debug_ranges",          ".zdebug_ranges",       NULL, NULL, 0, 0 },
5865
    display_debug_ranges,               &do_debug_ranges,       1 },
5866
  { { ".debug_static_func",     ".zdebug_static_func",  NULL, NULL, 0, 0 },
5867
    display_debug_not_supported,        NULL,                   0 },
5868
  { { ".debug_static_vars",     ".zdebug_static_vars",  NULL, NULL, 0, 0 },
5869
    display_debug_not_supported,        NULL,                   0 },
5870
  { { ".debug_types",           ".zdebug_types",        NULL, NULL, 0, 0 },
5871
    display_debug_types,                &do_debug_info,         1 },
5872
  { { ".debug_weaknames",       ".zdebug_weaknames",    NULL, NULL, 0, 0 },
5873
    display_debug_not_supported,        NULL,                   0 },
5874
  { { ".gdb_index",             "",                     NULL, NULL, 0, 0 },
5875
    display_gdb_index,                  &do_gdb_index,          0 },
5876
  { { ".trace_info",            "",                     NULL, NULL, 0, 0 },
5877
    display_trace_info,                 &do_trace_info,         1 },
5878
  { { ".trace_abbrev",          "",                     NULL, NULL, 0, 0 },
5879
    display_debug_abbrev,               &do_trace_abbrevs,      0 },
5880
  { { ".trace_aranges",         "",                     NULL, NULL, 0, 0 },
5881
    display_debug_aranges,              &do_trace_aranges,      0 }
5882
};

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.