X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=binutils%2Freadelf.c;h=5e8fe824b3e4f395015c867ffc21fb80308a81f1;hb=92434a14b97bf07546701613a16aaf4d8a3b3eca;hp=54d165e60993c6b9bb6c431505e88d574a0430e1;hpb=8d18bf796bf70d71eb23f4247e29a1fab5f3c5c7;p=deliverable%2Fbinutils-gdb.git diff --git a/binutils/readelf.c b/binutils/readelf.c index 54d165e609..5e8fe824b3 100644 --- a/binutils/readelf.c +++ b/binutils/readelf.c @@ -60,6 +60,7 @@ #include "bucomm.h" #include "elfcomm.h" #include "dwarf.h" +#include "ctf-api.h" #include "elf/common.h" #include "elf/external.h" @@ -102,6 +103,7 @@ #include "elf/d10v.h" #include "elf/d30v.h" #include "elf/dlx.h" +#include "elf/bpf.h" #include "elf/epiphany.h" #include "elf/fr30.h" #include "elf/frv.h" @@ -182,6 +184,7 @@ typedef struct elf_section_list #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */ #define STRING_DUMP (1 << 3) /* The -p command line switch. */ #define RELOC_DUMP (1 << 4) /* The -R command line switch. */ +#define CTF_DUMP (1 << 5) /* The --ctf command line switch. */ typedef unsigned char dump_type; @@ -248,12 +251,17 @@ static bfd_boolean do_dump = FALSE; static bfd_boolean do_version = FALSE; static bfd_boolean do_histogram = FALSE; static bfd_boolean do_debugging = FALSE; +static bfd_boolean do_ctf = FALSE; static bfd_boolean do_arch = FALSE; static bfd_boolean do_notes = FALSE; static bfd_boolean do_archive_index = FALSE; static bfd_boolean is_32bit_elf = FALSE; static bfd_boolean decompress_dumps = FALSE; +static char *dump_ctf_parent_name; +static char *dump_ctf_symtab_name; +static char *dump_ctf_strtab_name; + struct group_list { struct group_list * next; @@ -781,6 +789,7 @@ guess_is_rela (unsigned int e_machine) case EM_SCORE: case EM_XGATE: case EM_NFP: + case EM_BPF: return FALSE; /* Targets that use RELA relocations. */ @@ -1482,6 +1491,10 @@ dump_relocations (Filedata * filedata, rtype = elf_visium_reloc_type (type); break; + case EM_BPF: + rtype = elf_bpf_reloc_type (type); + break; + case EM_ADAPTEVA_EPIPHANY: rtype = elf_epiphany_reloc_type (type); break; @@ -1797,6 +1810,19 @@ dump_relocations (Filedata * filedata, return res; } +static const char * +get_aarch64_dynamic_type (unsigned long type) +{ + switch (type) + { + case DT_AARCH64_BTI_PLT: return "AARCH64_BTI_PLT"; + case DT_AARCH64_PAC_PLT: return "AARCH64_PAC_PLT"; + case DT_AARCH64_VARIANT_PCS: return "AARCH64_VARIANT_PCS"; + default: + return NULL; + } +} + static const char * get_mips_dynamic_type (unsigned long type) { @@ -2170,6 +2196,9 @@ get_dynamic_type (Filedata * filedata, unsigned long type) switch (filedata->file_header.e_machine) { + case EM_AARCH64: + result = get_aarch64_dynamic_type (type); + break; case EM_MIPS: case EM_MIPS_RS3_LE: result = get_mips_dynamic_type (type); @@ -2383,7 +2412,7 @@ get_machine_name (unsigned e_machine) case EM_TPC: return "Tenor Network TPC processor"; case EM_SNP1K: return "Trebia SNP 1000 processor"; /* 100 */ - case EM_ST200: return "STMicroelectronics ST200 microcontroller"; + case EM_ST200: return "STMicroelectronics ST200 microcontroller"; case EM_IP2K_OLD: case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers"; case EM_MAX: return "MAX Processor"; @@ -2499,7 +2528,7 @@ get_machine_name (unsigned e_machine) case EM_MT: return "Morpho Techologies MT processor"; case EM_ALPHA: return "Alpha"; case EM_WEBASSEMBLY: return "Web Assembly"; - case EM_DLX: return "OpenDLX"; + case EM_DLX: return "OpenDLX"; case EM_XSTORMY16: return "Sanyo XStormy16 CPU core"; case EM_IQ2000: return "Vitesse IQ2000"; case EM_M32C_OLD: @@ -4372,6 +4401,10 @@ get_section_type_name (Filedata * filedata, unsigned int sh_type) #define OPTION_DWARF_DEPTH 514 #define OPTION_DWARF_START 515 #define OPTION_DWARF_CHECK 516 +#define OPTION_CTF_DUMP 517 +#define OPTION_CTF_PARENT 518 +#define OPTION_CTF_SYMBOLS 519 +#define OPTION_CTF_STRINGS 520 static struct option options[] = { @@ -4410,6 +4443,12 @@ static struct option options[] = {"dwarf-start", required_argument, 0, OPTION_DWARF_START}, {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK}, + {"ctf", required_argument, 0, OPTION_CTF_DUMP}, + + {"ctf-symbols", required_argument, 0, OPTION_CTF_SYMBOLS}, + {"ctf-strings", required_argument, 0, OPTION_CTF_STRINGS}, + {"ctf-parent", required_argument, 0, OPTION_CTF_PARENT}, + {"version", no_argument, 0, 'v'}, {"wide", no_argument, 0, 'W'}, {"help", no_argument, 0, 'H'}, @@ -4459,6 +4498,15 @@ usage (FILE * stream) --dwarf-depth=N Do not display DIEs at depth N or greater\n\ --dwarf-start=N Display DIEs starting with N, at the same depth\n\ or deeper\n")); + fprintf (stream, _("\ + --ctf= Display CTF info from section \n\ + --ctf-parent=\n\ + Use section as the CTF parent\n\n\ + --ctf-symbols=\n\ + Use section as the CTF external symtab\n\n\ + --ctf-strings=\n\ + Use section as the CTF external strtab\n\n")); + #ifdef SUPPORT_DISASSEMBLY fprintf (stream, _("\ -i --instruction-dump=\n\ @@ -4686,6 +4734,19 @@ parse_args (Filedata * filedata, int argc, char ** argv) case OPTION_DWARF_CHECK: dwarf_check = TRUE; break; + case OPTION_CTF_DUMP: + do_ctf = TRUE; + request_dump (filedata, CTF_DUMP); + break; + case OPTION_CTF_SYMBOLS: + dump_ctf_symtab_name = strdup (optarg); + break; + case OPTION_CTF_STRINGS: + dump_ctf_strtab_name = strdup (optarg); + break; + case OPTION_CTF_PARENT: + dump_ctf_parent_name = strdup (optarg); + break; case OPTION_DYN_SYMS: do_dyn_syms = TRUE; break; @@ -6853,7 +6914,7 @@ process_section_groups (Filedata * filedata) printable_section_name (filedata, section), (unsigned long) section->sh_entsize, (unsigned long) section->sh_size); - break; + continue; } start = (unsigned char *) get_data (NULL, filedata, section->sh_offset, @@ -8968,6 +9029,11 @@ decode_arm_unwind (Filedata * filedata, remaining = 4; } + else + { + addr.section = SHN_UNDEF; + addr.offset = 0; + } if ((word & 0x80000000) == 0) { @@ -9344,6 +9410,21 @@ process_unwind (Filedata * filedata) return TRUE; } +static void +dynamic_section_aarch64_val (Elf_Internal_Dyn * entry) +{ + switch (entry->d_tag) + { + case DT_AARCH64_BTI_PLT: + case DT_AARCH64_PAC_PLT: + break; + default: + print_vma (entry->d_un.d_ptr, PREFIX_HEX); + break; + } + putchar ('\n'); +} + static void dynamic_section_mips_val (Elf_Internal_Dyn * entry) { @@ -10358,6 +10439,9 @@ process_dynamic_section (Filedata * filedata) { switch (filedata->file_header.e_machine) { + case EM_AARCH64: + dynamic_section_aarch64_val (entry); + break; case EM_MIPS: case EM_MIPS_RS3_LE: dynamic_section_mips_val (entry); @@ -10455,7 +10539,7 @@ process_version_sections (Filedata * filedata) printable_section_name (filedata, section), section->sh_info); - printf (_(" Addr: 0x")); + printf (_(" Addr: 0x")); printf_vma (section->sh_addr); printf (_(" Offset: %#08lx Link: %u (%s)\n"), (unsigned long) section->sh_offset, section->sh_link, @@ -10747,7 +10831,7 @@ process_version_sections (Filedata * filedata) total), printable_section_name (filedata, section), (unsigned long) total); - printf (_(" Addr: ")); + printf (_(" Addr: 0x")); printf_vma (section->sh_addr); printf (_(" Offset: %#08lx Link: %u (%s)\n"), (unsigned long) section->sh_offset, section->sh_link, @@ -11050,6 +11134,19 @@ get_symbol_visibility (unsigned int visibility) } } +static const char * +get_alpha_symbol_other (unsigned int other) +{ + switch (other) + { + case STO_ALPHA_NOPV: return "NOPV"; + case STO_ALPHA_STD_GPLOAD: return "STD GPLOAD"; + default: + error (_("Unrecognized alpah specific other value: %u"), other); + return _(""); + } +} + static const char * get_solaris_symbol_visibility (unsigned int visibility) { @@ -11062,6 +11159,22 @@ get_solaris_symbol_visibility (unsigned int visibility) } } +static const char * +get_aarch64_symbol_other (unsigned int other) +{ + static char buf[32]; + + if (other & STO_AARCH64_VARIANT_PCS) + { + other &= ~STO_AARCH64_VARIANT_PCS; + if (other == 0) + return "VARIANT_PCS"; + snprintf (buf, sizeof buf, "VARIANT_PCS | %x", other); + return buf; + } + return NULL; +} + static const char * get_mips_symbol_other (unsigned int other) { @@ -11173,6 +11286,12 @@ get_symbol_other (Filedata * filedata, unsigned int other) switch (filedata->file_header.e_machine) { + case EM_ALPHA: + result = get_alpha_symbol_other (other); + break; + case EM_AARCH64: + result = get_aarch64_symbol_other (other); + break; case EM_MIPS: result = get_mips_symbol_other (other); break; @@ -11430,7 +11549,7 @@ get_symbol_version_string (Filedata * filedata, if (ivd.vd_ndx == (vers_data & VERSYM_VERSION)) { - if (ivd.vd_ndx == 1 && ivd.vd_flags == VER_FLG_BASE) + if (ivd.vd_ndx == 1 && ivd.vd_flags == VER_FLG_BASE) return NULL; off -= ivd.vd_next; @@ -12377,6 +12496,8 @@ is_32bit_abs_reloc (Filedata * filedata, unsigned int reloc_type) case EM_AARCH64: return (reloc_type == 258 || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */ + case EM_BPF: + return reloc_type == 11; /* R_BPF_DATA_32 */ case EM_ADAPTEVA_EPIPHANY: return reloc_type == 3; case EM_ALPHA: @@ -12477,7 +12598,7 @@ is_32bit_abs_reloc (Filedata * filedata, unsigned int reloc_type) case EM_OR1K: return reloc_type == 1; /* R_OR1K_32. */ case EM_PARISC: - return (reloc_type == 1 /* R_PARISC_DIR32. */ + return (reloc_type == 1 /* R_PARISC_DIR32. */ || reloc_type == 2 /* R_PARISC_DIR21L. */ || reloc_type == 41); /* R_PARISC_SECREL32. */ case EM_PJ: @@ -12617,6 +12738,8 @@ is_32bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type) case EM_L1OM: case EM_K1OM: return reloc_type == 2; /* R_X86_64_PC32. */ + case EM_VAX: + return reloc_type == 4; /* R_VAX_PCREL32. */ case EM_XTENSA_OLD: case EM_XTENSA: return reloc_type == 14; /* R_XTENSA_32_PCREL. */ @@ -13708,6 +13831,160 @@ dump_section_as_bytes (Elf_Internal_Shdr * section, return TRUE; } +static ctf_sect_t * +shdr_to_ctf_sect (ctf_sect_t *buf, Elf_Internal_Shdr *shdr, Filedata *filedata) +{ + buf->cts_name = SECTION_NAME (shdr); + buf->cts_size = shdr->sh_size; + buf->cts_entsize = shdr->sh_entsize; + + return buf; +} + +/* Formatting callback function passed to ctf_dump. Returns either the pointer + it is passed, or a pointer to newly-allocated storage, in which case + dump_ctf() will free it when it no longer needs it. */ + +static char *dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED, + char *s, void *arg) +{ + const char *blanks = arg; + char *new_s; + + if (asprintf (&new_s, "%s%s", blanks, s) < 0) + return s; + return new_s; +} + +static bfd_boolean +dump_section_as_ctf (Elf_Internal_Shdr * section, Filedata * filedata) +{ + Elf_Internal_Shdr * parent_sec = NULL; + Elf_Internal_Shdr * symtab_sec = NULL; + Elf_Internal_Shdr * strtab_sec = NULL; + void * data = NULL; + void * symdata = NULL; + void * strdata = NULL; + void * parentdata = NULL; + ctf_sect_t ctfsect, symsect, strsect, parentsect; + ctf_sect_t * symsectp = NULL; + ctf_sect_t * strsectp = NULL; + ctf_file_t * ctf = NULL; + ctf_file_t * parent = NULL; + + const char *things[] = {"Labels", "Data objects", "Function objects", + "Variables", "Types", "Strings", ""}; + const char **thing; + int err; + bfd_boolean ret = FALSE; + size_t i; + + shdr_to_ctf_sect (&ctfsect, section, filedata); + data = get_section_contents (section, filedata); + ctfsect.cts_data = data; + + if (dump_ctf_symtab_name) + { + if ((symtab_sec = find_section (filedata, dump_ctf_symtab_name)) == NULL) + { + error (_("No symbol section named %s\n"), dump_ctf_symtab_name); + goto fail; + } + if ((symdata = (void *) get_data (NULL, filedata, + symtab_sec->sh_offset, 1, + symtab_sec->sh_size, + _("symbols"))) == NULL) + goto fail; + symsectp = shdr_to_ctf_sect (&symsect, symtab_sec, filedata); + symsect.cts_data = symdata; + } + if (dump_ctf_strtab_name) + { + if ((strtab_sec = find_section (filedata, dump_ctf_strtab_name)) == NULL) + { + error (_("No string table section named %s\n"), + dump_ctf_strtab_name); + goto fail; + } + if ((strdata = (void *) get_data (NULL, filedata, + strtab_sec->sh_offset, 1, + strtab_sec->sh_size, + _("strings"))) == NULL) + goto fail; + strsectp = shdr_to_ctf_sect (&strsect, strtab_sec, filedata); + strsect.cts_data = strdata; + } + if (dump_ctf_parent_name) + { + if ((parent_sec = find_section (filedata, dump_ctf_parent_name)) == NULL) + { + error (_("No CTF parent section named %s\n"), dump_ctf_parent_name); + goto fail; + } + if ((parentdata = (void *) get_data (NULL, filedata, + parent_sec->sh_offset, 1, + parent_sec->sh_size, + _("CTF parent"))) == NULL) + goto fail; + shdr_to_ctf_sect (&parentsect, parent_sec, filedata); + parentsect.cts_data = parentdata; + } + + /* Load the CTF file and dump it. */ + + if ((ctf = ctf_bufopen (&ctfsect, symsectp, strsectp, &err)) == NULL) + { + error (_("CTF open failure: %s\n"), ctf_errmsg (err)); + goto fail; + } + + if (parentdata) + { + if ((parent = ctf_bufopen (&parentsect, symsectp, strsectp, &err)) == NULL) + { + error (_("CTF open failure: %s\n"), ctf_errmsg (err)); + goto fail; + } + + ctf_import (ctf, parent); + } + + ret = TRUE; + + printf (_("\nDump of CTF section '%s':\n"), + printable_section_name (filedata, section)); + + for (i = 1, thing = things; *thing[0]; thing++, i++) + { + ctf_dump_state_t *s = NULL; + char *item; + + printf ("\n %s:\n", *thing); + while ((item = ctf_dump (ctf, &s, i, dump_ctf_indent_lines, + (void *) " ")) != NULL) + { + printf ("%s\n", item); + free (item); + } + + if (ctf_errno (ctf)) + { + error (_("Iteration failed: %s, %s\n"), *thing, + ctf_errmsg (ctf_errno (ctf))); + ret = FALSE; + } + } + + fail: + ctf_file_close (ctf); + ctf_file_close (parent); + free (parentdata); + free (data); + free (symdata); + free (strdata); + return ret; +} + static bfd_boolean load_specific_debug_section (enum dwarf_section_display_enum debug, const Elf_Internal_Shdr * sec, @@ -13716,7 +13993,7 @@ load_specific_debug_section (enum dwarf_section_display_enum debug, struct dwarf_section * section = &debug_displays [debug].section; char buf [64]; Filedata * filedata = (Filedata *) data; - + if (section->start != NULL) { /* If it is already loaded, do nothing. */ @@ -14045,6 +14322,12 @@ process_section_contents (Filedata * filedata) if (! display_debug_section (i, section, filedata)) res = FALSE; } + + if (dump & CTF_DUMP) + { + if (! dump_section_as_ctf (section, filedata)) + res = FALSE; + } } /* Check to see if the user requested a @@ -14337,7 +14620,7 @@ typedef struct static const char * arm_attr_tag_CPU_arch[] = {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2", "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline", - "v8-M.mainline"}; + "v8-M.mainline", "", "", "", "v8.1-M.mainline"}; static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"}; static const char * arm_attr_tag_THUMB_ISA_use[] = {"No", "Thumb-1", "Thumb-2", "Yes"}; @@ -14401,6 +14684,9 @@ static const char * arm_attr_tag_Virtualization_use[] = static const char * arm_attr_tag_MPextension_use_legacy[] = {"Not Allowed", "Allowed"}; +static const char * arm_attr_tag_MVE_arch[] = + {"No MVE", "MVE Integer only", "MVE Integer and FP"}; + #define LOOKUP(id, name) \ {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name} static arm_attr_public_tag arm_attr_public_tags[] = @@ -14440,6 +14726,7 @@ static arm_attr_public_tag arm_attr_public_tags[] = LOOKUP(42, MPextension_use), LOOKUP(44, DIV_use), LOOKUP(46, DSP_extension), + LOOKUP(48, MVE_arch), {64, "nodefaults", 0, NULL}, {65, "also_compatible_with", 0, NULL}, LOOKUP(66, T2EE_use), @@ -16187,6 +16474,12 @@ process_mips_specific (Filedata * filedata) error (_("No MIPS_OPTIONS header found\n")); return FALSE; } + /* PR 24243 */ + if (sect->sh_size < sizeof (* eopt)) + { + error (_("The MIPS options section is too small.\n")); + return FALSE; + } eopt = (Elf_External_Options *) get_data (NULL, filedata, options_offset, 1, sect->sh_size, _("options")); @@ -17240,6 +17533,9 @@ decode_x86_isa (unsigned int bitmask) case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI: printf ("AVX512_VNNI"); break; + case GNU_PROPERTY_X86_ISA_1_AVX512_BF16: + printf ("AVX512_BF16"); + break; default: printf (_(""), bit); break; @@ -17335,6 +17631,33 @@ decode_x86_feature_2 (unsigned int bitmask) } } +static void +decode_aarch64_feature_1_and (unsigned int bitmask) +{ + while (bitmask) + { + unsigned int bit = bitmask & (- bitmask); + + bitmask &= ~ bit; + switch (bit) + { + case GNU_PROPERTY_AARCH64_FEATURE_1_BTI: + printf ("BTI"); + break; + + case GNU_PROPERTY_AARCH64_FEATURE_1_PAC: + printf ("PAC"); + break; + + default: + printf (_(""), bit); + break; + } + if (bitmask) + printf (", "); + } +} + static void print_gnu_property_note (Filedata * filedata, Elf_Internal_Note * pnote) { @@ -17469,6 +17792,18 @@ print_gnu_property_note (Filedata * filedata, Elf_Internal_Note * pnote) break; } } + else if (filedata->file_header.e_machine == EM_AARCH64) + { + if (type == GNU_PROPERTY_AARCH64_FEATURE_1_AND) + { + printf ("AArch64 feature: "); + if (datasz != 4) + printf (_(" "), datasz); + else + decode_aarch64_feature_1_and (byte_get (ptr, 4)); + goto next; + } + } } else { @@ -17620,7 +17955,7 @@ print_gnu_note (Filedata * filedata, Elf_Internal_Note *pnote) case NT_GNU_PROPERTY_TYPE_0: print_gnu_property_note (filedata, pnote); break; - + default: /* Handle unrecognised types. An error message should have already been created by get_gnu_elf_note_type(), so all that we need to do is to @@ -17740,10 +18075,23 @@ process_netbsd_elf_note (Elf_Internal_Note * pnote) return TRUE; case NT_NETBSD_MARCH: - printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz, + printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote->descsz, pnote->descdata); return TRUE; +#ifdef NT_NETBSD_PAX + case NT_NETBSD_PAX: + version = byte_get ((unsigned char *) pnote->descdata, sizeof (version)); + printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote->descsz, + ((version & NT_NETBSD_PAX_MPROTECT) ? "+mprotect" : ""), + ((version & NT_NETBSD_PAX_NOMPROTECT) ? "-mprotect" : ""), + ((version & NT_NETBSD_PAX_GUARD) ? "+guard" : ""), + ((version & NT_NETBSD_PAX_NOGUARD) ? "-guard" : ""), + ((version & NT_NETBSD_PAX_ASLR) ? "+ASLR" : ""), + ((version & NT_NETBSD_PAX_NOASLR) ? "-ASLR" : "")); + return TRUE; +#endif + default: printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz, pnote->type); @@ -17787,18 +18135,29 @@ get_netbsd_elfcore_note_type (Filedata * filedata, unsigned e_type) { static char buff[64]; - if (e_type == NT_NETBSDCORE_PROCINFO) - return _("NetBSD procinfo structure"); + switch (e_type) + { + case NT_NETBSDCORE_PROCINFO: + /* NetBSD core "procinfo" structure. */ + return _("NetBSD procinfo structure"); - /* As of Jan 2002 there are no other machine-independent notes - defined for NetBSD core files. If the note type is less - than the start of the machine-dependent note types, we don't - understand it. */ +#ifdef NT_NETBSDCORE_AUXV + case NT_NETBSDCORE_AUXV: + return _("NetBSD ELF auxiliary vector data"); +#endif - if (e_type < NT_NETBSDCORE_FIRSTMACH) - { - snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type); - return buff; + default: + /* As of Jan 2002 there are no other machine-independent notes + defined for NetBSD core files. If the note type is less + than the start of the machine-dependent note types, we don't + understand it. */ + + if (e_type < NT_NETBSDCORE_FIRSTMACH) + { + snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type); + return buff; + } + break; } switch (filedata->file_header.e_machine) @@ -17822,6 +18181,23 @@ get_netbsd_elfcore_note_type (Filedata * filedata, unsigned e_type) } break; + /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5. + There's also old PT___GETREGS40 == mach + 1 for old reg + structure which lacks GBR. */ + case EM_SH: + switch (e_type) + { + case NT_NETBSDCORE_FIRSTMACH + 1: + return _("PT___GETREGS40 (old reg structure)"); + case NT_NETBSDCORE_FIRSTMACH + 3: + return _("PT_GETREGS (reg structure)"); + case NT_NETBSDCORE_FIRSTMACH + 5: + return _("PT_GETFPREGS (fpreg structure)"); + default: + break; + } + break; + /* On all other arch's, PT_GETREGS == mach+1 and PT_GETFPREGS == mach+3. */ default: @@ -17862,25 +18238,60 @@ get_stapsdt_note_type (unsigned e_type) static bfd_boolean print_stapsdt_note (Elf_Internal_Note *pnote) { - int addr_size = is_32bit_elf ? 4 : 8; + size_t len, maxlen; + unsigned long addr_size = is_32bit_elf ? 4 : 8; char *data = pnote->descdata; char *data_end = pnote->descdata + pnote->descsz; bfd_vma pc, base_addr, semaphore; char *provider, *probe, *arg_fmt; + if (pnote->descsz < (addr_size * 3)) + goto stapdt_note_too_small; + pc = byte_get ((unsigned char *) data, addr_size); data += addr_size; + base_addr = byte_get ((unsigned char *) data, addr_size); data += addr_size; + semaphore = byte_get ((unsigned char *) data, addr_size); data += addr_size; - provider = data; - data += strlen (data) + 1; - probe = data; - data += strlen (data) + 1; - arg_fmt = data; - data += strlen (data) + 1; + if (data >= data_end) + goto stapdt_note_too_small; + maxlen = data_end - data; + len = strnlen (data, maxlen); + if (len < maxlen) + { + provider = data; + data += len + 1; + } + else + goto stapdt_note_too_small; + + if (data >= data_end) + goto stapdt_note_too_small; + maxlen = data_end - data; + len = strnlen (data, maxlen); + if (len < maxlen) + { + probe = data; + data += len + 1; + } + else + goto stapdt_note_too_small; + + if (data >= data_end) + goto stapdt_note_too_small; + maxlen = data_end - data; + len = strnlen (data, maxlen); + if (len < maxlen) + { + arg_fmt = data; + data += len + 1; + } + else + goto stapdt_note_too_small; printf (_(" Provider: %s\n"), provider); printf (_(" Name: %s\n"), probe); @@ -17894,6 +18305,11 @@ print_stapsdt_note (Elf_Internal_Note *pnote) printf (_(" Arguments: %s\n"), arg_fmt); return data == data_end; + + stapdt_note_too_small: + printf (_(" \n")); + error (_("corrupt stapdt note - the data size is too small\n")); + return FALSE; } static const char * @@ -18191,7 +18607,7 @@ same_section (Filedata * filedata, unsigned long addr1, unsigned long addr2) a1 = find_section_by_address (filedata, addr1); a2 = find_section_by_address (filedata, addr2); - + return a1 == a2 && a1 != NULL; } @@ -18255,7 +18671,7 @@ print_gnu_build_attribute_description (Elf_Internal_Note * pnote, start = byte_get ((unsigned char *) pnote->descdata, 8); end = byte_get ((unsigned char *) pnote->descdata + 8, 8); break; - + default: error (_(" \n"), pnote->descsz); printf (_(" ")); @@ -18550,7 +18966,7 @@ print_gnu_build_attribute_name (Elf_Internal_Note * pnote) if (do_wide && left > 0) printf ("%-*s", left, " "); - + return TRUE; } @@ -18588,6 +19004,10 @@ process_note (Elf_Internal_Note * pnote, /* NetBSD-specific core file notes. */ return process_netbsd_elf_note (pnote); + else if (const_strneq (pnote->namedata, "PaX")) + /* NetBSD-specific core file notes. */ + return process_netbsd_elf_note (pnote); + else if (strneq (pnote->namedata, "SPU/", 4)) { /* SPU-specific core file notes. */ @@ -19256,7 +19676,7 @@ open_debug_file (const char * pathname) static bfd_boolean process_object (Filedata * filedata) { - Filedata * separates; + bfd_boolean have_separate_files; unsigned int i; bfd_boolean res = TRUE; @@ -19333,19 +19753,26 @@ process_object (Filedata * filedata) res = FALSE; if (filedata->file_header.e_shstrndx != SHN_UNDEF) - separates = load_separate_debug_file (filedata, filedata->file_name); + have_separate_files = load_separate_debug_files (filedata, filedata->file_name); else - separates = NULL; + have_separate_files = FALSE; if (! process_section_contents (filedata)) res = FALSE; - if (separates) + if (have_separate_files) { - if (! process_section_headers (separates)) - res = FALSE; - else if (! process_section_contents (separates)) - res = FALSE; + separate_info * d; + + for (d = first_separate_info; d != NULL; d = d->next) + { + if (! process_section_headers (d->handle)) + res = FALSE; + else if (! process_section_contents (d->handle)) + res = FALSE; + } + + /* The file handles are closed by the call to free_debug_memory() below. */ } if (! process_notes (filedata)) @@ -19564,7 +19991,7 @@ process_archive (Filedata * filedata, bfd_boolean is_thin_archive) /* PR 24049 - we cannot use filedata->file_name as this will have already been freed. */ error (_("%s: failed to read archive header\n"), arch.file_name); - + ret = FALSE; break; } @@ -19658,7 +20085,7 @@ process_archive (Filedata * filedata, bfd_boolean is_thin_archive) thin_filedata.handle = nested_arch.file; thin_filedata.file_name = qualified_name; - + if (! process_object (& thin_filedata)) ret = FALSE; } @@ -19825,5 +20252,9 @@ main (int argc, char ** argv) if (cmdline.dump_sects != NULL) free (cmdline.dump_sects); + free (dump_ctf_symtab_name); + free (dump_ctf_strtab_name); + free (dump_ctf_parent_name); + return err ? EXIT_FAILURE : EXIT_SUCCESS; }