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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.20.1/] [binutils/] [dwarf.c] - Blame information for rev 281

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

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

powered by: WebSVN 2.1.0

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