/* Forward declarations for dumb compilers. */
static void print_vma PARAMS ((bfd_vma, print_mode));
-static void print_symbol PARAMS ((int, char *));
+static void print_symbol PARAMS ((int, const char *));
static bfd_vma (* byte_get) PARAMS ((unsigned char *, int));
static bfd_vma byte_get_little_endian PARAMS ((unsigned char *, int));
static bfd_vma byte_get_big_endian PARAMS ((unsigned char *, int));
case 8:
/* We want to extract data from an 8 byte wide field and
place it into a 4 byte wide field. Since this is a little
- endian source we can juts use the 4 byte extraction code. */
+ endian source we can just use the 4 byte extraction code. */
/* Fall through. */
#endif
case 4:
static void
print_symbol (width, symbol)
int width;
- char * symbol;
+ const char * symbol;
{
if (do_wide)
- printf (symbol);
+ printf ("%s", symbol);
else if (width < 0)
printf ("%-*.*s", width, width, symbol);
else
printf (is_32bit_elf ? " " : " ");
if (psym->st_name == 0)
- print_symbol (22, SECTION_NAME (section_headers + psym->st_shndx));
+ {
+ const char *sec_name = "<null>";
+ char name_buf[40];
+
+ if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
+ {
+ bfd_vma sec_index = (bfd_vma) -1;
+
+ if (psym->st_shndx < SHN_LORESERVE)
+ sec_index = psym->st_shndx;
+ else if (psym->st_shndx > SHN_LORESERVE)
+ sec_index = psym->st_shndx - (SHN_HIRESERVE + 1
+ - SHN_LORESERVE);
+
+ if (sec_index != (bfd_vma) -1)
+ sec_name = SECTION_NAME (section_headers + sec_index);
+ else if (psym->st_shndx == SHN_ABS)
+ sec_name = "ABS";
+ else if (psym->st_shndx == SHN_COMMON)
+ sec_name = "COMMON";
+ else
+ {
+ sprintf (name_buf, "<section 0x%x>",
+ (unsigned int) psym->st_shndx);
+ sec_name = name_buf;
+ }
+ }
+ print_symbol (22, sec_name);
+ }
else if (strtab == NULL)
printf (_("<string table index %3ld>"), psym->st_name);
else
case E_V850E_ARCH:
strcat (buf, ", v850e");
break;
- case E_V850EA_ARCH:
- strcat (buf, ", v850ea");
- break;
case E_V850_ARCH:
strcat (buf, ", v850");
break;
case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
- case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
+ case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
+ case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
+ case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
+ case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
case 0:
/* We simply ignore the field in this case to avoid confusion:
do_debugging = 1;
else
{
- const char *debug_dump_opt[]
+ static const char *debug_dump_opt[]
= { "line", "info", "abbrev", "pubnames", "ranges",
"macro", "frames", "frames-interp", "str", "loc", NULL };
unsigned int index;
return 1;
}
+/* Returns 1 if the program headers were loaded. */
+
static int
process_program_headers (file)
FILE * file;
{
if (do_segments)
printf (_("\nThere are no program headers in this file.\n"));
- return 1;
+ return 0;
}
if (do_segments && !do_header)
dynamic_symbols = NULL;
dynamic_strings = NULL;
dynamic_syminfo = NULL;
+ symtab_shndx_hdr = NULL;
for (i = 0, section = section_headers;
i < elf_header.e_shnum;
putchar ('\n');
}
}
- else
- putchar ('\n');
break;
}
}
get_symbol_index_type (type)
unsigned int type;
{
+ static char buff [32];
+
switch (type)
{
case SHN_UNDEF: return "UND";
case SHN_COMMON: return "COM";
default:
if (type >= SHN_LOPROC && type <= SHN_HIPROC)
- return "PRC";
+ sprintf (buff, "PRC[0x%04x]", type);
else if (type >= SHN_LOOS && type <= SHN_HIOS)
- return "OS ";
+ sprintf (buff, "OS [0x%04x]", type);
else if (type >= SHN_LORESERVE && type <= SHN_HIRESERVE)
- return "RSV";
+ sprintf (buff, "RSV[0x%04x]", type);
else
- {
- static char buff [32];
-
- sprintf (buff, "%3d", type);
- return buff;
- }
+ sprintf (buff, "%3d", type);
+ break;
}
+
+ return buff;
}
static int *
printf ("DW_OP_nop");
break;
- /* DWARF 2.1 extensions. */
+ /* DWARF 3 extensions. */
case DW_OP_push_object_address:
printf ("DW_OP_push_object_address");
break;
printf ("DW_OP_call4: <%lx>", (long) byte_get (data, 4));
data += 4;
break;
- case DW_OP_calli:
- printf ("DW_OP_calli");
+ case DW_OP_call_ref:
+ printf ("DW_OP_call_ref");
+ break;
+
+ /* GNU extensions. */
+ case DW_OP_GNU_push_tls_address:
+ printf ("DW_OP_GNU_push_tls_address");
break;
default:
addr = section->sh_addr;
bytes = section->sh_size;
section_end = start + bytes;
+
if (bytes == 0)
{
printf (_("\nThe .debug_loc section is empty.\n"));
return 0;
}
+
printf (_("Contents of the .debug_loc section:\n\n"));
printf (_("\n Offset Begin End Expression\n"));
+
while (start < section_end)
{
unsigned long begin;
return debug_str_contents + offset;
}
-
static int
display_debug_str (section, start, file)
Elf32_Internal_Shdr * section;
return 1;
}
-
static unsigned char *
read_and_display_attr_value (attribute, form, data, cu_offset, pointer_size)
unsigned long attribute;
break;
case DW_FORM_strp:
- printf (_(" (indirect string, offset: 0x%lx): "), uvalue);
- printf (fetch_indirect_string (uvalue));
+ printf (_(" (indirect string, offset: 0x%lx): %s"),
+ uvalue, fetch_indirect_string (uvalue));
break;
case DW_FORM_indirect:
break;
}
- /* Check for RELA relocations in the abbrev_offset address, and
- apply them. */
+ /* Check for RELA relocations in the
+ abbrev_offset address, and apply them. */
for (relsec = section_headers;
relsec < section_headers + elf_header.e_shnum;
++relsec)
Elf_Internal_Sym *sym;
if (relsec->sh_type != SHT_RELA
- || SECTION_HEADER (relsec->sh_info) != section)
+ || SECTION_HEADER (relsec->sh_info) != section
+ || relsec->sh_size == 0)
continue;
if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
{
sym = symtab + ELF32_R_SYM (rp->r_info);
- if (ELF32_ST_TYPE (sym->st_info) != STT_SECTION)
+ if (ELF32_R_SYM (rp->r_info) != 0
+ && ELF32_ST_TYPE (sym->st_info) != STT_SECTION)
{
warn (_("Skipping unexpected symbol type %u\n"),
ELF32_ST_TYPE (sym->st_info));
{
sym = symtab + ELF64_R_SYM (rp->r_info);
- if (ELF64_ST_TYPE (sym->st_info) != STT_SECTION)
+ if (ELF64_R_SYM (rp->r_info) != 0
+ && ELF64_ST_TYPE (sym->st_info) != STT_SECTION)
{
warn (_("Skipping unexpected symbol type %u\n"),
ELF64_ST_TYPE (sym->st_info));
}
}
- compunit.cu_abbrev_offset += rp->r_addend;
+ compunit.cu_abbrev_offset = rp->r_addend;
break;
}
free_abbrevs ();
/* Read in the abbrevs used by this compilation unit. */
-
{
Elf32_Internal_Shdr * sec;
unsigned char * begin;
length = byte_get (start, 4); start += 4;
if (length == 0)
- return 1;
+ {
+ printf ("\n%08lx ZERO terminator\n\n",
+ (unsigned long)(saved_start - section_start));
+ return 1;
+ }
if (length == 0xffffffff)
{
encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
fc->pc_begin = byte_get (start, encoded_ptr_size);
+ if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel)
+ fc->pc_begin += section->sh_addr + (start - section_start);
start += encoded_ptr_size;
fc->pc_range = byte_get (start, encoded_ptr_size);
start += encoded_ptr_size;
case DW_CFA_set_loc:
vma = byte_get (start, encoded_ptr_size);
+ if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel)
+ vma += section->sh_addr + (start - section_start);
start += encoded_ptr_size;
if (do_debug_frames_interp)
frame_display_row (fc, &need_col_headers, &max_regs);
return 1;
}
- process_section_headers (file);
+ if (! process_section_headers (file))
+ {
+ /* Without loaded section headers we
+ cannot process lots of things. */
+ do_unwind = do_version = do_dump = do_arch = 0;
- process_program_headers (file);
+ if (! do_using_dynamic)
+ do_syms = do_reloc = 0;
+ }
- process_dynamic_segment (file);
+ if (process_program_headers (file))
+ process_dynamic_segment (file);
process_relocs (file);