Index: vendor/elftoolchain/dist/addr2line/addr2line.c =================================================================== --- vendor/elftoolchain/dist/addr2line/addr2line.c (revision 300227) +++ vendor/elftoolchain/dist/addr2line/addr2line.c (revision 300228) @@ -1,734 +1,734 @@ /*- * Copyright (c) 2009 Kai Wang * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #include #include #include #include #include #include #include #include #include #include #include #include "uthash.h" #include "_elftc.h" -ELFTC_VCSID("$Id: addr2line.c 3273 2015-12-11 21:38:57Z kaiwang27 $"); +ELFTC_VCSID("$Id: addr2line.c 3446 2016-05-03 01:31:17Z emaste $"); struct Func { char *name; Dwarf_Unsigned lopc; Dwarf_Unsigned hipc; Dwarf_Unsigned call_file; Dwarf_Unsigned call_line; Dwarf_Ranges *ranges; Dwarf_Signed ranges_cnt; struct Func *inlined_caller; STAILQ_ENTRY(Func) next; }; struct CU { Dwarf_Off off; Dwarf_Unsigned lopc; Dwarf_Unsigned hipc; char **srcfiles; Dwarf_Signed nsrcfiles; STAILQ_HEAD(, Func) funclist; UT_hash_handle hh; }; static struct option longopts[] = { {"addresses", no_argument, NULL, 'a'}, {"target" , required_argument, NULL, 'b'}, {"demangle", no_argument, NULL, 'C'}, {"exe", required_argument, NULL, 'e'}, {"functions", no_argument, NULL, 'f'}, {"inlines", no_argument, NULL, 'i'}, {"section", required_argument, NULL, 'j'}, {"pretty-print", no_argument, NULL, 'p'}, {"basename", no_argument, NULL, 's'}, {"help", no_argument, NULL, 'H'}, {"version", no_argument, NULL, 'V'}, {NULL, 0, NULL, 0} }; static int demangle, func, base, inlines, print_addr, pretty_print; static char unknown[] = { '?', '?', '\0' }; static Dwarf_Addr section_base; static struct CU *culist; #define USAGE_MESSAGE "\ Usage: %s [options] hexaddress...\n\ Map program addresses to source file names and line numbers.\n\n\ Options:\n\ -a | --addresses Display address prior to line number info.\n\ -b TGT | --target=TGT (Accepted but ignored).\n\ -e EXE | --exe=EXE Use program \"EXE\" to translate addresses.\n\ -f | --functions Display function names.\n\ -i | --inlines Display caller info for inlined functions.\n\ -j NAME | --section=NAME Values are offsets into section \"NAME\".\n\ -p | --pretty-print Display line number info and function name\n\ in human readable manner.\n\ -s | --basename Only show the base name for each file name.\n\ -C | --demangle Demangle C++ names.\n\ -H | --help Print a help message.\n\ -V | --version Print a version identifier and exit.\n" static void usage(void) { (void) fprintf(stderr, USAGE_MESSAGE, ELFTC_GETPROGNAME()); exit(1); } static void version(void) { fprintf(stderr, "%s (%s)\n", ELFTC_GETPROGNAME(), elftc_version()); exit(0); } /* * Handle DWARF 4 'offset from' DW_AT_high_pc. Although we don't * fully support DWARF 4, some compilers (like FreeBSD Clang 3.5.1) * generate DW_AT_high_pc as an offset from DW_AT_low_pc. * * "If the value of the DW_AT_high_pc is of class address, it is the * relocated address of the first location past the last instruction * associated with the entity; if it is of class constant, the value * is an unsigned integer offset which when added to the low PC gives * the address of the first location past the last instruction * associated with the entity." * * DWARF4 spec, section 2.17.2. */ static int handle_high_pc(Dwarf_Die die, Dwarf_Unsigned lopc, Dwarf_Unsigned *hipc) { Dwarf_Error de; Dwarf_Half form; Dwarf_Attribute at; int ret; ret = dwarf_attr(die, DW_AT_high_pc, &at, &de); if (ret == DW_DLV_ERROR) { warnx("dwarf_attr failed: %s", dwarf_errmsg(de)); return (ret); } ret = dwarf_whatform(at, &form, &de); if (ret == DW_DLV_ERROR) { warnx("dwarf_whatform failed: %s", dwarf_errmsg(de)); return (ret); } if (dwarf_get_form_class(2, 0, 0, form) == DW_FORM_CLASS_CONSTANT) *hipc += lopc; return (DW_DLV_OK); } static struct Func * search_func(struct CU *cu, Dwarf_Unsigned addr) { struct Func *f, *f0; Dwarf_Unsigned lopc, hipc, addr_base; int i; f0 = NULL; STAILQ_FOREACH(f, &cu->funclist, next) { if (f->ranges != NULL) { addr_base = 0; for (i = 0; i < f->ranges_cnt; i++) { if (f->ranges[i].dwr_type == DW_RANGES_END) break; if (f->ranges[i].dwr_type == DW_RANGES_ADDRESS_SELECTION) { addr_base = f->ranges[i].dwr_addr2; continue; } /* DW_RANGES_ENTRY */ lopc = f->ranges[i].dwr_addr1 + addr_base; hipc = f->ranges[i].dwr_addr2 + addr_base; if (addr >= lopc && addr < hipc) { if (f0 == NULL || (lopc >= f0->lopc && hipc <= f0->hipc)) { f0 = f; f0->lopc = lopc; f0->hipc = hipc; break; } } } } else if (addr >= f->lopc && addr < f->hipc) { if (f0 == NULL || (f->lopc >= f0->lopc && f->hipc <= f0->hipc)) f0 = f; } } return (f0); } static void collect_func(Dwarf_Debug dbg, Dwarf_Die die, struct Func *parent, struct CU *cu) { Dwarf_Die ret_die, abst_die, spec_die; Dwarf_Error de; Dwarf_Half tag; Dwarf_Unsigned lopc, hipc, ranges_off; Dwarf_Signed ranges_cnt; Dwarf_Off ref; Dwarf_Attribute abst_at, spec_at; Dwarf_Ranges *ranges; const char *funcname; struct Func *f; int found_ranges, ret; f = NULL; abst_die = spec_die = NULL; if (dwarf_tag(die, &tag, &de)) { warnx("dwarf_tag: %s", dwarf_errmsg(de)); goto cont_search; } if (tag == DW_TAG_subprogram || tag == DW_TAG_entry_point || tag == DW_TAG_inlined_subroutine) { /* * Function address range can be specified by either * a DW_AT_ranges attribute which points to a range list or * by a pair of DW_AT_low_pc and DW_AT_high_pc attributes. */ ranges = NULL; ranges_cnt = 0; found_ranges = 0; if (dwarf_attrval_unsigned(die, DW_AT_ranges, &ranges_off, &de) == DW_DLV_OK && dwarf_get_ranges(dbg, (Dwarf_Off) ranges_off, &ranges, &ranges_cnt, NULL, &de) == DW_DLV_OK) { if (ranges != NULL && ranges_cnt > 0) { found_ranges = 1; goto get_func_name; } } /* * Search for DW_AT_low_pc/DW_AT_high_pc if ranges pointer * not found. */ if (dwarf_attrval_unsigned(die, DW_AT_low_pc, &lopc, &de) || dwarf_attrval_unsigned(die, DW_AT_high_pc, &hipc, &de)) goto cont_search; if (handle_high_pc(die, lopc, &hipc) != DW_DLV_OK) goto cont_search; get_func_name: /* * Most common case the function name is stored in DW_AT_name * attribute. */ if (dwarf_attrval_string(die, DW_AT_name, &funcname, &de) == DW_DLV_OK) goto add_func; /* * For inlined function, the actual name is probably in the DIE * referenced by DW_AT_abstract_origin. (if present) */ if (dwarf_attr(die, DW_AT_abstract_origin, &abst_at, &de) == DW_DLV_OK && dwarf_global_formref(abst_at, &ref, &de) == DW_DLV_OK && dwarf_offdie(dbg, ref, &abst_die, &de) == DW_DLV_OK && dwarf_attrval_string(abst_die, DW_AT_name, &funcname, &de) == DW_DLV_OK) goto add_func; /* * If DW_AT_name is not present, but DW_AT_specification is * present, then probably the actual name is in the DIE * referenced by DW_AT_specification. */ if (dwarf_attr(die, DW_AT_specification, &spec_at, &de) == DW_DLV_OK && dwarf_global_formref(spec_at, &ref, &de) == DW_DLV_OK && dwarf_offdie(dbg, ref, &spec_die, &de) == DW_DLV_OK && dwarf_attrval_string(spec_die, DW_AT_name, &funcname, &de) == DW_DLV_OK) goto add_func; - /* Skip if no name assoicated with this DIE. */ + /* Skip if no name associated with this DIE. */ goto cont_search; add_func: if ((f = calloc(1, sizeof(*f))) == NULL) err(EXIT_FAILURE, "calloc"); if ((f->name = strdup(funcname)) == NULL) err(EXIT_FAILURE, "strdup"); if (found_ranges) { f->ranges = ranges; f->ranges_cnt = ranges_cnt; } else { f->lopc = lopc; f->hipc = hipc; } if (tag == DW_TAG_inlined_subroutine) { f->inlined_caller = parent; dwarf_attrval_unsigned(die, DW_AT_call_file, &f->call_file, &de); dwarf_attrval_unsigned(die, DW_AT_call_line, &f->call_line, &de); } STAILQ_INSERT_TAIL(&cu->funclist, f, next); } cont_search: /* Search children. */ ret = dwarf_child(die, &ret_die, &de); if (ret == DW_DLV_ERROR) warnx("dwarf_child: %s", dwarf_errmsg(de)); else if (ret == DW_DLV_OK) { if (f != NULL) collect_func(dbg, ret_die, f, cu); else collect_func(dbg, ret_die, parent, cu); } /* Search sibling. */ ret = dwarf_siblingof(dbg, die, &ret_die, &de); if (ret == DW_DLV_ERROR) warnx("dwarf_siblingof: %s", dwarf_errmsg(de)); else if (ret == DW_DLV_OK) collect_func(dbg, ret_die, parent, cu); /* Cleanup */ dwarf_dealloc(dbg, die, DW_DLA_DIE); if (abst_die != NULL) dwarf_dealloc(dbg, abst_die, DW_DLA_DIE); if (spec_die != NULL) dwarf_dealloc(dbg, spec_die, DW_DLA_DIE); } static void print_inlines(struct CU *cu, struct Func *f, Dwarf_Unsigned call_file, Dwarf_Unsigned call_line) { char demangled[1024]; char *file; if (call_file > 0 && (Dwarf_Signed) call_file <= cu->nsrcfiles) file = cu->srcfiles[call_file - 1]; else file = unknown; if (pretty_print) printf(" (inlined by) "); if (func) { if (demangle && !elftc_demangle(f->name, demangled, sizeof(demangled), 0)) { if (pretty_print) printf("%s at ", demangled); else printf("%s\n", demangled); } else { if (pretty_print) printf("%s at ", f->name); else printf("%s\n", f->name); } } (void) printf("%s:%ju\n", base ? basename(file) : file, (uintmax_t) call_line); if (f->inlined_caller != NULL) print_inlines(cu, f->inlined_caller, f->call_file, f->call_line); } static void translate(Dwarf_Debug dbg, Elf *e, const char* addrstr) { Dwarf_Die die, ret_die; Dwarf_Line *lbuf; Dwarf_Error de; Dwarf_Half tag; Dwarf_Unsigned lopc, hipc, addr, lineno, plineno; Dwarf_Signed lcount; Dwarf_Addr lineaddr, plineaddr; Dwarf_Off off; struct CU *cu; struct Func *f; const char *funcname; char *file, *file0, *pfile; char demangled[1024]; int ec, i, ret; addr = strtoull(addrstr, NULL, 16); addr += section_base; lineno = 0; file = unknown; cu = NULL; die = NULL; while ((ret = dwarf_next_cu_header(dbg, NULL, NULL, NULL, NULL, NULL, &de)) == DW_DLV_OK) { die = NULL; while (dwarf_siblingof(dbg, die, &ret_die, &de) == DW_DLV_OK) { if (die != NULL) dwarf_dealloc(dbg, die, DW_DLA_DIE); die = ret_die; if (dwarf_tag(die, &tag, &de) != DW_DLV_OK) { warnx("dwarf_tag failed: %s", dwarf_errmsg(de)); goto next_cu; } /* XXX: What about DW_TAG_partial_unit? */ if (tag == DW_TAG_compile_unit) break; } if (ret_die == NULL) { warnx("could not find DW_TAG_compile_unit die"); goto next_cu; } if (dwarf_attrval_unsigned(die, DW_AT_low_pc, &lopc, &de) == DW_DLV_OK) { if (dwarf_attrval_unsigned(die, DW_AT_high_pc, &hipc, &de) == DW_DLV_OK) { /* * Check if the address falls into the PC * range of this CU. */ if (handle_high_pc(die, lopc, &hipc) != DW_DLV_OK) goto out; } else { /* Assume ~0ULL if DW_AT_high_pc not present */ hipc = ~0ULL; } /* * Record the CU in the hash table for faster lookup * later. */ if (dwarf_dieoffset(die, &off, &de) != DW_DLV_OK) { warnx("dwarf_dieoffset failed: %s", dwarf_errmsg(de)); goto out; } HASH_FIND(hh, culist, &off, sizeof(off), cu); if (cu == NULL) { if ((cu = calloc(1, sizeof(*cu))) == NULL) err(EXIT_FAILURE, "calloc"); cu->off = off; cu->lopc = lopc; cu->hipc = hipc; STAILQ_INIT(&cu->funclist); HASH_ADD(hh, culist, off, sizeof(off), cu); } if (addr >= lopc && addr < hipc) break; } next_cu: if (die != NULL) { dwarf_dealloc(dbg, die, DW_DLA_DIE); die = NULL; } } if (ret != DW_DLV_OK || die == NULL) goto out; switch (dwarf_srclines(die, &lbuf, &lcount, &de)) { case DW_DLV_OK: break; case DW_DLV_NO_ENTRY: /* If a CU lacks debug info, just skip it. */ goto out; default: warnx("dwarf_srclines: %s", dwarf_errmsg(de)); goto out; } plineaddr = ~0ULL; plineno = 0; pfile = unknown; for (i = 0; i < lcount; i++) { if (dwarf_lineaddr(lbuf[i], &lineaddr, &de)) { warnx("dwarf_lineaddr: %s", dwarf_errmsg(de)); goto out; } if (dwarf_lineno(lbuf[i], &lineno, &de)) { warnx("dwarf_lineno: %s", dwarf_errmsg(de)); goto out; } if (dwarf_linesrc(lbuf[i], &file0, &de)) { warnx("dwarf_linesrc: %s", dwarf_errmsg(de)); } else file = file0; if (addr == lineaddr) goto out; else if (addr < lineaddr && addr > plineaddr) { lineno = plineno; file = pfile; goto out; } plineaddr = lineaddr; plineno = lineno; pfile = file; } out: f = NULL; funcname = NULL; if (ret == DW_DLV_OK && (func || inlines) && cu != NULL) { if (cu->srcfiles == NULL) if (dwarf_srcfiles(die, &cu->srcfiles, &cu->nsrcfiles, &de)) warnx("dwarf_srcfiles: %s", dwarf_errmsg(de)); if (STAILQ_EMPTY(&cu->funclist)) { collect_func(dbg, die, NULL, cu); die = NULL; } f = search_func(cu, addr); if (f != NULL) funcname = f->name; } if (print_addr) { if ((ec = gelf_getclass(e)) == ELFCLASSNONE) { warnx("gelf_getclass failed: %s", elf_errmsg(-1)); ec = ELFCLASS64; } if (ec == ELFCLASS32) { if (pretty_print) printf("0x%08jx: ", (uintmax_t) addr); else printf("0x%08jx\n", (uintmax_t) addr); } else { if (pretty_print) printf("0x%016jx: ", (uintmax_t) addr); else printf("0x%016jx\n", (uintmax_t) addr); } } if (func) { if (funcname == NULL) funcname = unknown; if (demangle && !elftc_demangle(funcname, demangled, sizeof(demangled), 0)) { if (pretty_print) printf("%s at ", demangled); else printf("%s\n", demangled); } else { if (pretty_print) printf("%s at ", funcname); else printf("%s\n", funcname); } } (void) printf("%s:%ju\n", base ? basename(file) : file, (uintmax_t) lineno); if (ret == DW_DLV_OK && inlines && cu != NULL && cu->srcfiles != NULL && f != NULL && f->inlined_caller != NULL) print_inlines(cu, f->inlined_caller, f->call_file, f->call_line); if (die != NULL) dwarf_dealloc(dbg, die, DW_DLA_DIE); /* * Reset internal CU pointer, so we will start from the first CU * next round. */ while (ret != DW_DLV_NO_ENTRY) { if (ret == DW_DLV_ERROR) errx(EXIT_FAILURE, "dwarf_next_cu_header: %s", dwarf_errmsg(de)); ret = dwarf_next_cu_header(dbg, NULL, NULL, NULL, NULL, NULL, &de); } } static void find_section_base(const char *exe, Elf *e, const char *section) { Dwarf_Addr off; Elf_Scn *scn; GElf_Ehdr eh; GElf_Shdr sh; size_t shstrndx; int elferr; const char *name; if (gelf_getehdr(e, &eh) != &eh) { warnx("gelf_getehdr failed: %s", elf_errmsg(-1)); return; } if (!elf_getshstrndx(e, &shstrndx)) { warnx("elf_getshstrndx failed: %s", elf_errmsg(-1)); return; } (void) elf_errno(); off = 0; scn = NULL; while ((scn = elf_nextscn(e, scn)) != NULL) { if (gelf_getshdr(scn, &sh) == NULL) { warnx("gelf_getshdr failed: %s", elf_errmsg(-1)); continue; } if ((name = elf_strptr(e, shstrndx, sh.sh_name)) == NULL) goto next; if (!strcmp(section, name)) { if (eh.e_type == ET_EXEC || eh.e_type == ET_DYN) { /* * For executables, section base is the virtual * address of the specified section. */ section_base = sh.sh_addr; } else if (eh.e_type == ET_REL) { /* * For relocatables, section base is the * relative offset of the specified section * to the start of the first section. */ section_base = off; } else warnx("unknown e_type %u", eh.e_type); return; } next: off += sh.sh_size; } elferr = elf_errno(); if (elferr != 0) warnx("elf_nextscn failed: %s", elf_errmsg(elferr)); errx(EXIT_FAILURE, "%s: cannot find section %s", exe, section); } int main(int argc, char **argv) { Elf *e; Dwarf_Debug dbg; Dwarf_Error de; const char *exe, *section; char line[1024]; int fd, i, opt; exe = NULL; section = NULL; while ((opt = getopt_long(argc, argv, "ab:Ce:fij:psHV", longopts, NULL)) != -1) { switch (opt) { case 'a': print_addr = 1; break; case 'b': /* ignored */ break; case 'C': demangle = 1; break; case 'e': exe = optarg; break; case 'f': func = 1; break; case 'i': inlines = 1; break; case 'j': section = optarg; break; case 'p': pretty_print = 1; break; case 's': base = 1; break; case 'H': usage(); case 'V': version(); default: usage(); } } argv += optind; argc -= optind; if (exe == NULL) exe = "a.out"; if ((fd = open(exe, O_RDONLY)) < 0) err(EXIT_FAILURE, "%s", exe); if (dwarf_init(fd, DW_DLC_READ, NULL, NULL, &dbg, &de)) errx(EXIT_FAILURE, "dwarf_init: %s", dwarf_errmsg(de)); if (dwarf_get_elf(dbg, &e, &de) != DW_DLV_OK) errx(EXIT_FAILURE, "dwarf_get_elf: %s", dwarf_errmsg(de)); if (section) find_section_base(exe, e, section); else section_base = 0; if (argc > 0) for (i = 0; i < argc; i++) translate(dbg, e, argv[i]); else while (fgets(line, sizeof(line), stdin) != NULL) { translate(dbg, e, line); fflush(stdout); } dwarf_finish(dbg, &de); (void) elf_end(e); exit(0); } Index: vendor/elftoolchain/dist/brandelf/brandelf.c =================================================================== --- vendor/elftoolchain/dist/brandelf/brandelf.c (revision 300227) +++ vendor/elftoolchain/dist/brandelf/brandelf.c (revision 300228) @@ -1,311 +1,312 @@ /*- * Copyright (c) 2008 Hyogeol Lee * Copyright (c) 2000, 2001 David O'Brien * Copyright (c) 1996 Søren Schmidt * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer * in this position and unchanged. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. The name of the author may not be used to endorse or promote products * derived from this software without specific prior written permission * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include "_elftc.h" -ELFTC_VCSID("$Id: brandelf.c 3354 2016-01-18 21:50:15Z jkoshy $"); +ELFTC_VCSID("$Id: brandelf.c 3440 2016-04-07 14:51:47Z emaste $"); static int elftype(const char *); static const char *iselftype(int); static void printelftypes(void); static void printversion(void); static void usage(void); struct ELFtypes { const char *str; int value; }; /* XXX - any more types? */ static struct ELFtypes elftypes[] = { { "86Open", ELFOSABI_86OPEN }, { "AIX", ELFOSABI_AIX }, { "ARM", ELFOSABI_ARM }, { "AROS", ELFOSABI_AROS }, + { "CloudABI", ELFOSABI_CLOUDABI }, { "FreeBSD", ELFOSABI_FREEBSD }, { "GNU", ELFOSABI_GNU }, { "HP/UX", ELFOSABI_HPUX}, { "Hurd", ELFOSABI_HURD }, { "IRIX", ELFOSABI_IRIX }, { "Linux", ELFOSABI_GNU }, { "Modesto", ELFOSABI_MODESTO }, { "NSK", ELFOSABI_NSK }, { "NetBSD", ELFOSABI_NETBSD}, { "None", ELFOSABI_NONE}, { "OpenBSD", ELFOSABI_OPENBSD }, { "OpenVMS", ELFOSABI_OPENVMS }, { "Standalone", ELFOSABI_STANDALONE }, { "SVR4", ELFOSABI_NONE }, { "Solaris", ELFOSABI_SOLARIS }, { "Tru64", ELFOSABI_TRU64 } }; static struct option brandelf_longopts[] = { { "help", no_argument, NULL, 'h' }, { "version", no_argument, NULL, 'V' }, { NULL, 0, NULL, 0 } }; int main(int argc, char **argv) { GElf_Ehdr ehdr; Elf *elf; Elf_Kind kind; int type = ELFOSABI_NONE; int retval = 0; int ch, change = 0, force = 0, listed = 0; if (elf_version(EV_CURRENT) == EV_NONE) errx(EXIT_FAILURE, "elf_version error"); while ((ch = getopt_long(argc, argv, "Vf:hlt:v", brandelf_longopts, NULL)) != -1) switch (ch) { case 'f': if (change) errx(EXIT_FAILURE, "ERROR: the -f option is " "incompatible with the -t option."); force = 1; type = atoi(optarg); if (errno == ERANGE || type < 0 || type > 255) { warnx("ERROR: invalid argument to option " "-f: %s", optarg); usage(); } break; case 'h': usage(); break; case 'l': printelftypes(); listed = 1; break; case 'v': /* This flag is ignored. */ break; case 't': if (force) errx(EXIT_FAILURE, "the -t option is " "incompatible with the -f option."); if ((type = elftype(optarg)) == -1) { warnx("ERROR: invalid ELF type '%s'", optarg); usage(); } change = 1; break; case 'V': printversion(); break; default: usage(); } argc -= optind; argv += optind; if (!argc) { if (listed) exit(0); else { warnx("no file(s) specified"); usage(); } } while (argc) { int fd; elf = NULL; if ((fd = open(argv[0], (change || force) ? O_RDWR : O_RDONLY, 0)) < 0) { warn("error opening file %s", argv[0]); retval = 1; goto fail; } if ((elf = elf_begin(fd, (change || force) ? ELF_C_RDWR : ELF_C_READ, NULL)) == NULL) { warnx("elf_begin failed: %s", elf_errmsg(-1)); retval = 1; goto fail; } if ((kind = elf_kind(elf)) != ELF_K_ELF) { if (kind == ELF_K_AR) warnx("file '%s' is an archive.", argv[0]); else warnx("file '%s' is not an ELF file.", argv[0]); retval = 1; goto fail; } if (gelf_getehdr(elf, &ehdr) == NULL) { warnx("gelf_getehdr: %s", elf_errmsg(-1)); retval = 1; goto fail; } if (!change && !force) { fprintf(stdout, "File '%s' is of brand '%s' (%u).\n", argv[0], iselftype(ehdr.e_ident[EI_OSABI]), ehdr.e_ident[EI_OSABI]); if (!iselftype(type)) { warnx("ELF ABI Brand '%u' is unknown", type); printelftypes(); } } else { /* * Keep the existing layout of the ELF object. */ if (elf_flagelf(elf, ELF_C_SET, ELF_F_LAYOUT) == 0) { warnx("elf_flagelf failed: %s", elf_errmsg(-1)); retval = 1; goto fail; } /* * Update the ABI type. */ ehdr.e_ident[EI_OSABI] = (unsigned char) type; if (gelf_update_ehdr(elf, &ehdr) == 0) { warnx("gelf_update_ehdr error: %s", elf_errmsg(-1)); retval = 1; goto fail; } /* * Write back changes. */ if (elf_update(elf, ELF_C_WRITE) == -1) { warnx("elf_update error: %s", elf_errmsg(-1)); retval = 1; goto fail; } } fail: if (elf) elf_end(elf); if (fd >= 0 && close(fd) == -1) { warnx("%s: close error", argv[0]); retval = 1; } argc--; argv++; } return (retval); } #define USAGE_MESSAGE "\ Usage: %s [options] file...\n\ Set or display the ABI field for an ELF object.\n\n\ Supported options are:\n\ -f NUM Set the ELF ABI to the number 'NUM'.\n\ -h | --help Print a usage message and exit.\n\ -l List known ELF ABI names.\n\ -t ABI Set the ELF ABI to the value named by \"ABI\".\n\ -V | --version Print a version identifier and exit.\n" static void usage(void) { (void) fprintf(stderr, USAGE_MESSAGE, ELFTC_GETPROGNAME()); exit(1); } static void printversion(void) { (void) printf("%s (%s)\n", ELFTC_GETPROGNAME(), elftc_version()); exit(0); } static const char * iselftype(int etype) { size_t elfwalk; for (elfwalk = 0; elfwalk < sizeof(elftypes)/sizeof(elftypes[0]); elfwalk++) if (etype == elftypes[elfwalk].value) return (elftypes[elfwalk].str); return (0); } static int elftype(const char *elfstrtype) { size_t elfwalk; for (elfwalk = 0; elfwalk < sizeof(elftypes)/sizeof(elftypes[0]); elfwalk++) if (strcasecmp(elfstrtype, elftypes[elfwalk].str) == 0) return (elftypes[elfwalk].value); return (-1); } static void printelftypes(void) { size_t elfwalk; (void) printf("Known ELF types are: "); for (elfwalk = 0; elfwalk < sizeof(elftypes)/sizeof(elftypes[0]); elfwalk++) (void) printf("%s(%u) ", elftypes[elfwalk].str, elftypes[elfwalk].value); (void) printf("\n"); } Index: vendor/elftoolchain/dist/common/_elftc.h =================================================================== --- vendor/elftoolchain/dist/common/_elftc.h (revision 300227) +++ vendor/elftoolchain/dist/common/_elftc.h (revision 300228) @@ -1,484 +1,484 @@ /*- * Copyright (c) 2009 Joseph Koshy * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: _elftc.h 3244 2015-08-31 19:53:08Z emaste $ + * $Id: _elftc.h 3446 2016-05-03 01:31:17Z emaste $ */ /** - ** Miscellanous definitions needed by multiple components. + ** Miscellaneous definitions needed by multiple components. **/ #ifndef _ELFTC_H #define _ELFTC_H #ifndef NULL #define NULL ((void *) 0) #endif #ifndef offsetof #define offsetof(T, M) ((int) &((T*) 0) -> M) #endif /* --QUEUE-MACROS-- [[ */ /* * Supply macros missing from */ /* * Copyright (c) 1991, 1993 * The Regents of the University of California. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #ifndef LIST_FOREACH_SAFE #define LIST_FOREACH_SAFE(var, head, field, tvar) \ for ((var) = LIST_FIRST((head)); \ (var) && ((tvar) = LIST_NEXT((var), field), 1); \ (var) = (tvar)) #endif #ifndef SLIST_FOREACH_SAFE #define SLIST_FOREACH_SAFE(var, head, field, tvar) \ for ((var) = SLIST_FIRST((head)); \ (var) && ((tvar) = SLIST_NEXT((var), field), 1); \ (var) = (tvar)) #endif #ifndef STAILQ_CONCAT #define STAILQ_CONCAT(head1, head2) do { \ if (!STAILQ_EMPTY((head2))) { \ *(head1)->stqh_last = (head2)->stqh_first; \ (head1)->stqh_last = (head2)->stqh_last; \ STAILQ_INIT((head2)); \ } \ } while (/*CONSTCOND*/0) #endif #ifndef STAILQ_EMPTY #define STAILQ_EMPTY(head) ((head)->stqh_first == NULL) #endif #ifndef STAILQ_ENTRY #define STAILQ_ENTRY(type) \ struct { \ struct type *stqe_next; /* next element */ \ } #endif #ifndef STAILQ_FIRST #define STAILQ_FIRST(head) ((head)->stqh_first) #endif #ifndef STAILQ_HEAD #define STAILQ_HEAD(name, type) \ struct name { \ struct type *stqh_first; /* first element */ \ struct type **stqh_last; /* addr of last next element */ \ } #endif #ifndef STAILQ_HEAD_INITIALIZER #define STAILQ_HEAD_INITIALIZER(head) \ { NULL, &(head).stqh_first } #endif #ifndef STAILQ_FOREACH #define STAILQ_FOREACH(var, head, field) \ for ((var) = ((head)->stqh_first); \ (var); \ (var) = ((var)->field.stqe_next)) #endif #ifndef STAILQ_FOREACH_SAFE #define STAILQ_FOREACH_SAFE(var, head, field, tvar) \ for ((var) = STAILQ_FIRST((head)); \ (var) && ((tvar) = STAILQ_NEXT((var), field), 1); \ (var) = (tvar)) #endif #ifndef STAILQ_INIT #define STAILQ_INIT(head) do { \ (head)->stqh_first = NULL; \ (head)->stqh_last = &(head)->stqh_first; \ } while (/*CONSTCOND*/0) #endif #ifndef STAILQ_INSERT_HEAD #define STAILQ_INSERT_HEAD(head, elm, field) do { \ if (((elm)->field.stqe_next = (head)->stqh_first) == NULL) \ (head)->stqh_last = &(elm)->field.stqe_next; \ (head)->stqh_first = (elm); \ } while (/*CONSTCOND*/0) #endif #ifndef STAILQ_INSERT_TAIL #define STAILQ_INSERT_TAIL(head, elm, field) do { \ (elm)->field.stqe_next = NULL; \ *(head)->stqh_last = (elm); \ (head)->stqh_last = &(elm)->field.stqe_next; \ } while (/*CONSTCOND*/0) #endif #ifndef STAILQ_INSERT_AFTER #define STAILQ_INSERT_AFTER(head, listelm, elm, field) do { \ if (((elm)->field.stqe_next = (listelm)->field.stqe_next) == NULL)\ (head)->stqh_last = &(elm)->field.stqe_next; \ (listelm)->field.stqe_next = (elm); \ } while (/*CONSTCOND*/0) #endif #ifndef STAILQ_LAST #define STAILQ_LAST(head, type, field) \ (STAILQ_EMPTY((head)) ? \ NULL : ((struct type *)(void *) \ ((char *)((head)->stqh_last) - offsetof(struct type, field)))) #endif #ifndef STAILQ_NEXT #define STAILQ_NEXT(elm, field) ((elm)->field.stqe_next) #endif #ifndef STAILQ_REMOVE #define STAILQ_REMOVE(head, elm, type, field) do { \ if ((head)->stqh_first == (elm)) { \ STAILQ_REMOVE_HEAD((head), field); \ } else { \ struct type *curelm = (head)->stqh_first; \ while (curelm->field.stqe_next != (elm)) \ curelm = curelm->field.stqe_next; \ if ((curelm->field.stqe_next = \ curelm->field.stqe_next->field.stqe_next) == NULL) \ (head)->stqh_last = &(curelm)->field.stqe_next; \ } \ } while (/*CONSTCOND*/0) #endif #ifndef STAILQ_REMOVE_HEAD #define STAILQ_REMOVE_HEAD(head, field) do { \ if (((head)->stqh_first = (head)->stqh_first->field.stqe_next) == \ NULL) \ (head)->stqh_last = &(head)->stqh_first; \ } while (/*CONSTCOND*/0) #endif /* * The STAILQ_SORT macro is adapted from Simon Tatham's O(n*log(n)) * mergesort algorithm. */ #ifndef STAILQ_SORT #define STAILQ_SORT(head, type, field, cmp) do { \ STAILQ_HEAD(, type) _la, _lb; \ struct type *_p, *_q, *_e; \ int _i, _sz, _nmerges, _psz, _qsz; \ \ _sz = 1; \ do { \ _nmerges = 0; \ STAILQ_INIT(&_lb); \ while (!STAILQ_EMPTY((head))) { \ _nmerges++; \ STAILQ_INIT(&_la); \ _psz = 0; \ for (_i = 0; _i < _sz && !STAILQ_EMPTY((head)); \ _i++) { \ _e = STAILQ_FIRST((head)); \ if (_e == NULL) \ break; \ _psz++; \ STAILQ_REMOVE_HEAD((head), field); \ STAILQ_INSERT_TAIL(&_la, _e, field); \ } \ _p = STAILQ_FIRST(&_la); \ _qsz = _sz; \ _q = STAILQ_FIRST((head)); \ while (_psz > 0 || (_qsz > 0 && _q != NULL)) { \ if (_psz == 0) { \ _e = _q; \ _q = STAILQ_NEXT(_q, field); \ STAILQ_REMOVE_HEAD((head), \ field); \ _qsz--; \ } else if (_qsz == 0 || _q == NULL) { \ _e = _p; \ _p = STAILQ_NEXT(_p, field); \ STAILQ_REMOVE_HEAD(&_la, field);\ _psz--; \ } else if (cmp(_p, _q) <= 0) { \ _e = _p; \ _p = STAILQ_NEXT(_p, field); \ STAILQ_REMOVE_HEAD(&_la, field);\ _psz--; \ } else { \ _e = _q; \ _q = STAILQ_NEXT(_q, field); \ STAILQ_REMOVE_HEAD((head), \ field); \ _qsz--; \ } \ STAILQ_INSERT_TAIL(&_lb, _e, field); \ } \ } \ (head)->stqh_first = _lb.stqh_first; \ (head)->stqh_last = _lb.stqh_last; \ _sz *= 2; \ } while (_nmerges > 1); \ } while (/*CONSTCOND*/0) #endif #ifndef TAILQ_FOREACH_SAFE #define TAILQ_FOREACH_SAFE(var, head, field, tvar) \ for ((var) = TAILQ_FIRST((head)); \ (var) && ((tvar) = TAILQ_NEXT((var), field), 1); \ (var) = (tvar)) #endif /* ]] --QUEUE-MACROS-- */ /* * VCS Ids. */ #ifndef ELFTC_VCSID #if defined(__DragonFly__) #define ELFTC_VCSID(ID) __RCSID(ID) #endif #if defined(__FreeBSD__) #define ELFTC_VCSID(ID) __FBSDID(ID) #endif #if defined(__APPLE__) || defined(__GLIBC__) || defined(__GNU__) || \ defined(__linux__) #if defined(__GNUC__) #define ELFTC_VCSID(ID) __asm__(".ident\t\"" ID "\"") #else #define ELFTC_VCSID(ID) /**/ #endif #endif #if defined(__minix) #if defined(__GNUC__) #define ELFTC_VCSID(ID) __asm__(".ident\t\"" ID "\"") #else #define ELFTC_VCSID(ID) /**/ #endif /* __GNU__ */ #endif #if defined(__NetBSD__) #define ELFTC_VCSID(ID) __RCSID(ID) #endif #if defined(__OpenBSD__) #if defined(__GNUC__) #define ELFTC_VCSID(ID) __asm__(".ident\t\"" ID "\"") #else #define ELFTC_VCSID(ID) /**/ #endif /* __GNUC__ */ #endif #endif /* ELFTC_VCSID */ /* * Provide an equivalent for getprogname(3). */ #ifndef ELFTC_GETPROGNAME #if defined(__APPLE__) || defined(__DragonFly__) || defined(__FreeBSD__) || \ defined(__minix) || defined(__NetBSD__) #include #define ELFTC_GETPROGNAME() getprogname() #endif /* __DragonFly__ || __FreeBSD__ || __minix || __NetBSD__ */ #if defined(__GLIBC__) || defined(__linux__) #ifndef _GNU_SOURCE /* * GLIBC based systems have a global 'char *' pointer referencing * the executable's name. */ extern const char *program_invocation_short_name; #endif /* !_GNU_SOURCE */ #define ELFTC_GETPROGNAME() program_invocation_short_name #endif /* __GLIBC__ || __linux__ */ #if defined(__OpenBSD__) extern const char *__progname; #define ELFTC_GETPROGNAME() __progname #endif /* __OpenBSD__ */ #endif /* ELFTC_GETPROGNAME */ /** ** Per-OS configuration. **/ #if defined(__APPLE__) #include #define htobe32(x) OSSwapHostToBigInt32(x) #define roundup2 roundup #define ELFTC_BYTE_ORDER _BYTE_ORDER #define ELFTC_BYTE_ORDER_LITTLE_ENDIAN _LITTLE_ENDIAN #define ELFTC_BYTE_ORDER_BIG_ENDIAN _BIG_ENDIAN #define ELFTC_HAVE_MMAP 1 #define ELFTC_HAVE_STRMODE 1 #define ELFTC_NEED_BYTEORDER_EXTENSIONS 1 #endif /* __APPLE__ */ #if defined(__DragonFly__) #include #include #define ELFTC_BYTE_ORDER _BYTE_ORDER #define ELFTC_BYTE_ORDER_LITTLE_ENDIAN _LITTLE_ENDIAN #define ELFTC_BYTE_ORDER_BIG_ENDIAN _BIG_ENDIAN #define ELFTC_HAVE_MMAP 1 #endif #if defined(__GLIBC__) || defined(__linux__) #include #define ELFTC_BYTE_ORDER __BYTE_ORDER #define ELFTC_BYTE_ORDER_LITTLE_ENDIAN __LITTLE_ENDIAN #define ELFTC_BYTE_ORDER_BIG_ENDIAN __BIG_ENDIAN #define ELFTC_HAVE_MMAP 1 /* * Debian GNU/Linux and Debian GNU/kFreeBSD do not have strmode(3). */ #define ELFTC_HAVE_STRMODE 0 /* Whether we need to supply {be,le}32dec. */ #define ELFTC_NEED_BYTEORDER_EXTENSIONS 1 #define roundup2 roundup #endif /* __GLIBC__ || __linux__ */ #if defined(__FreeBSD__) #include #include #define ELFTC_BYTE_ORDER _BYTE_ORDER #define ELFTC_BYTE_ORDER_LITTLE_ENDIAN _LITTLE_ENDIAN #define ELFTC_BYTE_ORDER_BIG_ENDIAN _BIG_ENDIAN #define ELFTC_HAVE_MMAP 1 #define ELFTC_HAVE_STRMODE 1 #if __FreeBSD_version <= 900000 #define ELFTC_BROKEN_YY_NO_INPUT 1 #endif #endif /* __FreeBSD__ */ #if defined(__minix) #define ELFTC_HAVE_MMAP 0 #endif /* __minix */ #if defined(__NetBSD__) #include #include #define ELFTC_BYTE_ORDER _BYTE_ORDER #define ELFTC_BYTE_ORDER_LITTLE_ENDIAN _LITTLE_ENDIAN #define ELFTC_BYTE_ORDER_BIG_ENDIAN _BIG_ENDIAN #define ELFTC_HAVE_MMAP 1 #define ELFTC_HAVE_STRMODE 1 #if __NetBSD_Version__ <= 599002100 /* from src/doc/CHANGES: flex(1): Import flex-2.5.35 [christos 20091025] */ /* and 5.99.21 was from Wed Oct 21 21:28:36 2009 UTC */ # define ELFTC_BROKEN_YY_NO_INPUT 1 #endif #endif /* __NetBSD __ */ #if defined(__OpenBSD__) #include #include #define ELFTC_BYTE_ORDER _BYTE_ORDER #define ELFTC_BYTE_ORDER_LITTLE_ENDIAN _LITTLE_ENDIAN #define ELFTC_BYTE_ORDER_BIG_ENDIAN _BIG_ENDIAN #define ELFTC_HAVE_MMAP 1 #define ELFTC_HAVE_STRMODE 1 #define ELFTC_NEED_BYTEORDER_EXTENSIONS 1 #define roundup2 roundup #endif /* __OpenBSD__ */ #endif /* _ELFTC_H */ Index: vendor/elftoolchain/dist/common/elfdefinitions.h =================================================================== --- vendor/elftoolchain/dist/common/elfdefinitions.h (revision 300227) +++ vendor/elftoolchain/dist/common/elfdefinitions.h (revision 300228) @@ -1,2820 +1,2889 @@ /*- * Copyright (c) 2010 Joseph Koshy * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: elfdefinitions.h 3392 2016-02-05 19:51:22Z emaste $ + * $Id: elfdefinitions.h 3455 2016-05-09 13:47:29Z emaste $ */ /* * These definitions are based on: * - The public specification of the ELF format as defined in the * October 2009 draft of System V ABI. * See: http://www.sco.com/developers/gabi/latest/ch4.intro.html * - The May 1998 (version 1.5) draft of "The ELF-64 object format". * - Processor-specific ELF ABI definitions for sparc, i386, amd64, mips, * ia64, and powerpc processors. * - The "Linkers and Libraries Guide", from Sun Microsystems. */ #ifndef _ELFDEFINITIONS_H_ #define _ELFDEFINITIONS_H_ #include /* * Types of capabilities. */ #define _ELF_DEFINE_CAPABILITIES() \ _ELF_DEFINE_CA(CA_SUNW_NULL, 0, "ignored") \ _ELF_DEFINE_CA(CA_SUNW_HW_1, 1, "hardware capability") \ _ELF_DEFINE_CA(CA_SUNW_SW_1, 2, "software capability") #undef _ELF_DEFINE_CA #define _ELF_DEFINE_CA(N, V, DESCR) N = V , enum { _ELF_DEFINE_CAPABILITIES() CA__LAST__ }; /* * Flags used with dynamic linking entries. */ #define _ELF_DEFINE_DYN_FLAGS() \ _ELF_DEFINE_DF(DF_ORIGIN, 0x1, \ "object being loaded may refer to $ORIGIN") \ _ELF_DEFINE_DF(DF_SYMBOLIC, 0x2, \ "search library for references before executable") \ _ELF_DEFINE_DF(DF_TEXTREL, 0x4, \ "relocation entries may modify text segment") \ _ELF_DEFINE_DF(DF_BIND_NOW, 0x8, \ "process relocation entries at load time") \ _ELF_DEFINE_DF(DF_STATIC_TLS, 0x10, \ "uses static thread-local storage") #undef _ELF_DEFINE_DF #define _ELF_DEFINE_DF(N, V, DESCR) N = V , enum { _ELF_DEFINE_DYN_FLAGS() DF__LAST__ }; /* * Dynamic linking entry types. */ #define _ELF_DEFINE_DYN_TYPES() \ _ELF_DEFINE_DT(DT_NULL, 0, "end of array") \ _ELF_DEFINE_DT(DT_NEEDED, 1, "names a needed library") \ _ELF_DEFINE_DT(DT_PLTRELSZ, 2, \ "size in bytes of associated relocation entries") \ _ELF_DEFINE_DT(DT_PLTGOT, 3, \ "address associated with the procedure linkage table") \ _ELF_DEFINE_DT(DT_HASH, 4, \ "address of the symbol hash table") \ _ELF_DEFINE_DT(DT_STRTAB, 5, \ "address of the string table") \ _ELF_DEFINE_DT(DT_SYMTAB, 6, \ "address of the symbol table") \ _ELF_DEFINE_DT(DT_RELA, 7, \ "address of the relocation table") \ _ELF_DEFINE_DT(DT_RELASZ, 8, "size of the DT_RELA table") \ _ELF_DEFINE_DT(DT_RELAENT, 9, "size of each DT_RELA entry") \ _ELF_DEFINE_DT(DT_STRSZ, 10, "size of the string table") \ _ELF_DEFINE_DT(DT_SYMENT, 11, \ "size of a symbol table entry") \ _ELF_DEFINE_DT(DT_INIT, 12, \ "address of the initialization function") \ _ELF_DEFINE_DT(DT_FINI, 13, \ "address of the finalization function") \ _ELF_DEFINE_DT(DT_SONAME, 14, "names the shared object") \ _ELF_DEFINE_DT(DT_RPATH, 15, \ "runtime library search path") \ _ELF_DEFINE_DT(DT_SYMBOLIC, 16, \ "alter symbol resolution algorithm") \ _ELF_DEFINE_DT(DT_REL, 17, \ "address of the DT_REL table") \ _ELF_DEFINE_DT(DT_RELSZ, 18, "size of the DT_REL table") \ _ELF_DEFINE_DT(DT_RELENT, 19, "size of each DT_REL entry") \ _ELF_DEFINE_DT(DT_PLTREL, 20, \ "type of relocation entry in the procedure linkage table") \ _ELF_DEFINE_DT(DT_DEBUG, 21, "used for debugging") \ _ELF_DEFINE_DT(DT_TEXTREL, 22, \ "text segment may be written to during relocation") \ _ELF_DEFINE_DT(DT_JMPREL, 23, \ "address of relocation entries associated with the procedure linkage table") \ _ELF_DEFINE_DT(DT_BIND_NOW, 24, \ "bind symbols at loading time") \ _ELF_DEFINE_DT(DT_INIT_ARRAY, 25, \ "pointers to initialization functions") \ _ELF_DEFINE_DT(DT_FINI_ARRAY, 26, \ "pointers to termination functions") \ _ELF_DEFINE_DT(DT_INIT_ARRAYSZ, 27, "size of the DT_INIT_ARRAY") \ _ELF_DEFINE_DT(DT_FINI_ARRAYSZ, 28, "size of the DT_FINI_ARRAY") \ _ELF_DEFINE_DT(DT_RUNPATH, 29, \ "index of library search path string") \ _ELF_DEFINE_DT(DT_FLAGS, 30, \ "flags specific to the object being loaded") \ _ELF_DEFINE_DT(DT_ENCODING, 32, "standard semantics") \ _ELF_DEFINE_DT(DT_PREINIT_ARRAY, 32, \ "pointers to pre-initialization functions") \ _ELF_DEFINE_DT(DT_PREINIT_ARRAYSZ, 33, \ "size of pre-initialization array") \ _ELF_DEFINE_DT(DT_MAXPOSTAGS, 34, \ "the number of positive tags") \ _ELF_DEFINE_DT(DT_LOOS, 0x6000000DUL, \ "start of OS-specific types") \ _ELF_DEFINE_DT(DT_SUNW_AUXILIARY, 0x6000000DUL, \ "offset of string naming auxiliary filtees") \ _ELF_DEFINE_DT(DT_SUNW_RTLDINF, 0x6000000EUL, "rtld internal use") \ _ELF_DEFINE_DT(DT_SUNW_FILTER, 0x6000000FUL, \ "offset of string naming standard filtees") \ _ELF_DEFINE_DT(DT_SUNW_CAP, 0x60000010UL, \ "address of hardware capabilities section") \ _ELF_DEFINE_DT(DT_HIOS, 0x6FFFF000UL, \ "end of OS-specific types") \ _ELF_DEFINE_DT(DT_VALRNGLO, 0x6FFFFD00UL, \ "start of range using the d_val field") \ _ELF_DEFINE_DT(DT_GNU_PRELINKED, 0x6FFFFDF5UL, \ "prelinking timestamp") \ _ELF_DEFINE_DT(DT_GNU_CONFLICTSZ, 0x6FFFFDF6UL, \ "size of conflict section") \ _ELF_DEFINE_DT(DT_GNU_LIBLISTSZ, 0x6FFFFDF7UL, \ "size of library list") \ _ELF_DEFINE_DT(DT_CHECKSUM, 0x6FFFFDF8UL, \ "checksum for the object") \ _ELF_DEFINE_DT(DT_PLTPADSZ, 0x6FFFFDF9UL, \ "size of PLT padding") \ _ELF_DEFINE_DT(DT_MOVEENT, 0x6FFFFDFAUL, \ "size of DT_MOVETAB entries") \ _ELF_DEFINE_DT(DT_MOVESZ, 0x6FFFFDFBUL, \ "total size of the MOVETAB table") \ _ELF_DEFINE_DT(DT_FEATURE, 0x6FFFFDFCUL, "feature values") \ _ELF_DEFINE_DT(DT_POSFLAG_1, 0x6FFFFDFDUL, \ "dynamic position flags") \ _ELF_DEFINE_DT(DT_SYMINSZ, 0x6FFFFDFEUL, \ "size of the DT_SYMINFO table") \ _ELF_DEFINE_DT(DT_SYMINENT, 0x6FFFFDFFUL, \ "size of a DT_SYMINFO entry") \ _ELF_DEFINE_DT(DT_VALRNGHI, 0x6FFFFDFFUL, \ "end of range using the d_val field") \ _ELF_DEFINE_DT(DT_ADDRRNGLO, 0x6FFFFE00UL, \ "start of range using the d_ptr field") \ _ELF_DEFINE_DT(DT_GNU_HASH, 0x6FFFFEF5UL, \ "GNU style hash tables") \ +_ELF_DEFINE_DT(DT_TLSDESC_PLT, 0x6FFFFEF6UL, \ + "location of PLT entry for TLS descriptor resolver calls") \ +_ELF_DEFINE_DT(DT_TLSDESC_GOT, 0x6FFFFEF7UL, \ + "location of GOT entry used by TLS descriptor resolver PLT entry") \ _ELF_DEFINE_DT(DT_GNU_CONFLICT, 0x6FFFFEF8UL, \ "address of conflict section") \ _ELF_DEFINE_DT(DT_GNU_LIBLIST, 0x6FFFFEF9UL, \ "address of conflict section") \ _ELF_DEFINE_DT(DT_CONFIG, 0x6FFFFEFAUL, \ "configuration file") \ _ELF_DEFINE_DT(DT_DEPAUDIT, 0x6FFFFEFBUL, \ "string defining audit libraries") \ _ELF_DEFINE_DT(DT_AUDIT, 0x6FFFFEFCUL, \ "string defining audit libraries") \ _ELF_DEFINE_DT(DT_PLTPAD, 0x6FFFFEFDUL, "PLT padding") \ _ELF_DEFINE_DT(DT_MOVETAB, 0x6FFFFEFEUL, \ "address of a move table") \ _ELF_DEFINE_DT(DT_SYMINFO, 0x6FFFFEFFUL, \ "address of the symbol information table") \ _ELF_DEFINE_DT(DT_ADDRRNGHI, 0x6FFFFEFFUL, \ "end of range using the d_ptr field") \ _ELF_DEFINE_DT(DT_VERSYM, 0x6FFFFFF0UL, \ "address of the version section") \ _ELF_DEFINE_DT(DT_RELACOUNT, 0x6FFFFFF9UL, \ "count of RELA relocations") \ _ELF_DEFINE_DT(DT_RELCOUNT, 0x6FFFFFFAUL, \ "count of REL relocations") \ _ELF_DEFINE_DT(DT_FLAGS_1, 0x6FFFFFFBUL, "flag values") \ _ELF_DEFINE_DT(DT_VERDEF, 0x6FFFFFFCUL, \ "address of the version definition segment") \ _ELF_DEFINE_DT(DT_VERDEFNUM, 0x6FFFFFFDUL, \ "the number of version definition entries") \ _ELF_DEFINE_DT(DT_VERNEED, 0x6FFFFFFEUL, \ "address of section with needed versions") \ _ELF_DEFINE_DT(DT_VERNEEDNUM, 0x6FFFFFFFUL, \ "the number of version needed entries") \ _ELF_DEFINE_DT(DT_LOPROC, 0x70000000UL, \ "start of processor-specific types") \ _ELF_DEFINE_DT(DT_ARM_SYMTABSZ, 0x70000001UL, \ "number of entries in the dynamic symbol table") \ _ELF_DEFINE_DT(DT_SPARC_REGISTER, 0x70000001UL, \ "index of an STT_SPARC_REGISTER symbol") \ _ELF_DEFINE_DT(DT_ARM_PREEMPTMAP, 0x70000002UL, \ "address of the preemption map") \ _ELF_DEFINE_DT(DT_MIPS_RLD_VERSION, 0x70000001UL, \ "version ID for runtime linker interface") \ _ELF_DEFINE_DT(DT_MIPS_TIME_STAMP, 0x70000002UL, \ "timestamp") \ _ELF_DEFINE_DT(DT_MIPS_ICHECKSUM, 0x70000003UL, \ "checksum of all external strings and common sizes") \ _ELF_DEFINE_DT(DT_MIPS_IVERSION, 0x70000004UL, \ "string table index of a version string") \ _ELF_DEFINE_DT(DT_MIPS_FLAGS, 0x70000005UL, \ "MIPS-specific flags") \ _ELF_DEFINE_DT(DT_MIPS_BASE_ADDRESS, 0x70000006UL, \ "base address for the executable/DSO") \ _ELF_DEFINE_DT(DT_MIPS_CONFLICT, 0x70000008UL, \ "address of .conflict section") \ _ELF_DEFINE_DT(DT_MIPS_LIBLIST, 0x70000009UL, \ "address of .liblist section") \ _ELF_DEFINE_DT(DT_MIPS_LOCAL_GOTNO, 0x7000000AUL, \ "number of local GOT entries") \ _ELF_DEFINE_DT(DT_MIPS_CONFLICTNO, 0x7000000BUL, \ "number of entries in the .conflict section") \ _ELF_DEFINE_DT(DT_MIPS_LIBLISTNO, 0x70000010UL, \ "number of entries in the .liblist section") \ _ELF_DEFINE_DT(DT_MIPS_SYMTABNO, 0x70000011UL, \ "number of entries in the .dynsym section") \ _ELF_DEFINE_DT(DT_MIPS_UNREFEXTNO, 0x70000012UL, \ "index of first external dynamic symbol not ref'ed locally") \ _ELF_DEFINE_DT(DT_MIPS_GOTSYM, 0x70000013UL, \ "index of first dynamic symbol corresponds to a GOT entry") \ _ELF_DEFINE_DT(DT_MIPS_HIPAGENO, 0x70000014UL, \ "number of page table entries in GOT") \ _ELF_DEFINE_DT(DT_MIPS_RLD_MAP, 0x70000016UL, \ "address of runtime linker map") \ _ELF_DEFINE_DT(DT_MIPS_DELTA_CLASS, 0x70000017UL, \ "Delta C++ class definition") \ _ELF_DEFINE_DT(DT_MIPS_DELTA_CLASS_NO, 0x70000018UL, \ "number of entries in DT_MIPS_DELTA_CLASS") \ _ELF_DEFINE_DT(DT_MIPS_DELTA_INSTANCE, 0x70000019UL, \ "Delta C++ class instances") \ _ELF_DEFINE_DT(DT_MIPS_DELTA_INSTANCE_NO, 0x7000001AUL, \ "number of entries in DT_MIPS_DELTA_INSTANCE") \ _ELF_DEFINE_DT(DT_MIPS_DELTA_RELOC, 0x7000001BUL, \ "Delta relocations") \ _ELF_DEFINE_DT(DT_MIPS_DELTA_RELOC_NO, 0x7000001CUL, \ "number of entries in DT_MIPS_DELTA_RELOC") \ _ELF_DEFINE_DT(DT_MIPS_DELTA_SYM, 0x7000001DUL, \ - "Delta symbols refered by Delta relocations") \ + "Delta symbols referred by Delta relocations") \ _ELF_DEFINE_DT(DT_MIPS_DELTA_SYM_NO, 0x7000001EUL, \ "number of entries in DT_MIPS_DELTA_SYM") \ _ELF_DEFINE_DT(DT_MIPS_DELTA_CLASSSYM, 0x70000020UL, \ "Delta symbols for class declarations") \ _ELF_DEFINE_DT(DT_MIPS_DELTA_CLASSSYM_NO, 0x70000021UL, \ "number of entries in DT_MIPS_DELTA_CLASSSYM") \ _ELF_DEFINE_DT(DT_MIPS_CXX_FLAGS, 0x70000022UL, \ "C++ flavor flags") \ _ELF_DEFINE_DT(DT_MIPS_PIXIE_INIT, 0x70000023UL, \ "address of an initialization routine created by pixie") \ _ELF_DEFINE_DT(DT_MIPS_SYMBOL_LIB, 0x70000024UL, \ "address of .MIPS.symlib section") \ _ELF_DEFINE_DT(DT_MIPS_LOCALPAGE_GOTIDX, 0x70000025UL, \ "GOT index of first page table entry for a segment") \ _ELF_DEFINE_DT(DT_MIPS_LOCAL_GOTIDX, 0x70000026UL, \ "GOT index of first page table entry for a local symbol") \ _ELF_DEFINE_DT(DT_MIPS_HIDDEN_GOTIDX, 0x70000027UL, \ "GOT index of first page table entry for a hidden symbol") \ _ELF_DEFINE_DT(DT_MIPS_PROTECTED_GOTIDX, 0x70000028UL, \ "GOT index of first page table entry for a protected symbol") \ _ELF_DEFINE_DT(DT_MIPS_OPTIONS, 0x70000029UL, \ "address of .MIPS.options section") \ _ELF_DEFINE_DT(DT_MIPS_INTERFACE, 0x7000002AUL, \ "address of .MIPS.interface section") \ _ELF_DEFINE_DT(DT_MIPS_DYNSTR_ALIGN, 0x7000002BUL, "???") \ _ELF_DEFINE_DT(DT_MIPS_INTERFACE_SIZE, 0x7000002CUL, \ "size of .MIPS.interface section") \ _ELF_DEFINE_DT(DT_MIPS_RLD_TEXT_RESOLVE_ADDR, 0x7000002DUL, \ "address of _rld_text_resolve in GOT") \ _ELF_DEFINE_DT(DT_MIPS_PERF_SUFFIX, 0x7000002EUL, \ "default suffix of DSO to be appended by dlopen") \ _ELF_DEFINE_DT(DT_MIPS_COMPACT_SIZE, 0x7000002FUL, \ "size of a ucode compact relocation record (o32)") \ _ELF_DEFINE_DT(DT_MIPS_GP_VALUE, 0x70000030UL, \ "GP value of a specified GP relative range") \ _ELF_DEFINE_DT(DT_MIPS_AUX_DYNAMIC, 0x70000031UL, \ "address of an auxiliary dynamic table") \ _ELF_DEFINE_DT(DT_MIPS_PLTGOT, 0x70000032UL, \ "address of the PLTGOT") \ _ELF_DEFINE_DT(DT_MIPS_RLD_OBJ_UPDATE, 0x70000033UL, \ "object list update callback") \ _ELF_DEFINE_DT(DT_MIPS_RWPLT, 0x70000034UL, \ "address of a writable PLT") \ _ELF_DEFINE_DT(DT_PPC_GOT, 0x70000000UL, \ "value of _GLOBAL_OFFSET_TABLE_") \ _ELF_DEFINE_DT(DT_PPC_TLSOPT, 0x70000001UL, \ "TLS descriptor should be optimized") \ _ELF_DEFINE_DT(DT_PPC64_GLINK, 0x70000000UL, \ "address of .glink section") \ _ELF_DEFINE_DT(DT_PPC64_OPD, 0x70000001UL, \ "address of .opd section") \ _ELF_DEFINE_DT(DT_PPC64_OPDSZ, 0x70000002UL, \ "size of .opd section") \ _ELF_DEFINE_DT(DT_PPC64_TLSOPT, 0x70000003UL, \ "TLS descriptor should be optimized") \ _ELF_DEFINE_DT(DT_AUXILIARY, 0x7FFFFFFDUL, \ "offset of string naming auxiliary filtees") \ _ELF_DEFINE_DT(DT_USED, 0x7FFFFFFEUL, "ignored") \ _ELF_DEFINE_DT(DT_FILTER, 0x7FFFFFFFUL, \ "index of string naming filtees") \ _ELF_DEFINE_DT(DT_HIPROC, 0x7FFFFFFFUL, \ "end of processor-specific types") #undef _ELF_DEFINE_DT #define _ELF_DEFINE_DT(N, V, DESCR) N = V , enum { _ELF_DEFINE_DYN_TYPES() DT__LAST__ = DT_HIPROC }; #define DT_DEPRECATED_SPARC_REGISTER DT_SPARC_REGISTER /* * Flags used in the executable header (field: e_flags). */ #define _ELF_DEFINE_EHDR_FLAGS() \ _ELF_DEFINE_EF(EF_ARM_RELEXEC, 0x00000001UL, \ "dynamic segment describes only how to relocate segments") \ _ELF_DEFINE_EF(EF_ARM_HASENTRY, 0x00000002UL, \ "e_entry contains a program entry point") \ _ELF_DEFINE_EF(EF_ARM_SYMSARESORTED, 0x00000004UL, \ "subsection of symbol table is sorted by symbol value") \ _ELF_DEFINE_EF(EF_ARM_DYNSYMSUSESEGIDX, 0x00000008UL, \ "dynamic symbol st_shndx = containing segment index + 1") \ _ELF_DEFINE_EF(EF_ARM_MAPSYMSFIRST, 0x00000010UL, \ "mapping symbols precede other local symbols in symtab") \ _ELF_DEFINE_EF(EF_ARM_BE8, 0x00800000UL, \ "file contains BE-8 code") \ _ELF_DEFINE_EF(EF_ARM_LE8, 0x00400000UL, \ "file contains LE-8 code") \ _ELF_DEFINE_EF(EF_ARM_EABIMASK, 0xFF000000UL, \ "mask for ARM EABI version number (0 denotes GNU or unknown)") \ _ELF_DEFINE_EF(EF_ARM_EABI_UNKNOWN, 0x00000000UL, \ "Unknown or GNU ARM EABI version number") \ _ELF_DEFINE_EF(EF_ARM_EABI_VER1, 0x01000000UL, \ "ARM EABI version 1") \ _ELF_DEFINE_EF(EF_ARM_EABI_VER2, 0x02000000UL, \ "ARM EABI version 2") \ _ELF_DEFINE_EF(EF_ARM_EABI_VER3, 0x03000000UL, \ "ARM EABI version 3") \ _ELF_DEFINE_EF(EF_ARM_EABI_VER4, 0x04000000UL, \ "ARM EABI version 4") \ _ELF_DEFINE_EF(EF_ARM_EABI_VER5, 0x05000000UL, \ "ARM EABI version 5") \ _ELF_DEFINE_EF(EF_ARM_INTERWORK, 0x00000004UL, \ "GNU EABI extension") \ _ELF_DEFINE_EF(EF_ARM_APCS_26, 0x00000008UL, \ "GNU EABI extension") \ _ELF_DEFINE_EF(EF_ARM_APCS_FLOAT, 0x00000010UL, \ "GNU EABI extension") \ _ELF_DEFINE_EF(EF_ARM_PIC, 0x00000020UL, \ "GNU EABI extension") \ _ELF_DEFINE_EF(EF_ARM_ALIGN8, 0x00000040UL, \ "GNU EABI extension") \ _ELF_DEFINE_EF(EF_ARM_NEW_ABI, 0x00000080UL, \ "GNU EABI extension") \ _ELF_DEFINE_EF(EF_ARM_OLD_ABI, 0x00000100UL, \ "GNU EABI extension") \ _ELF_DEFINE_EF(EF_ARM_SOFT_FLOAT, 0x00000200UL, \ "GNU EABI extension") \ _ELF_DEFINE_EF(EF_ARM_VFP_FLOAT, 0x00000400UL, \ "GNU EABI extension") \ _ELF_DEFINE_EF(EF_ARM_MAVERICK_FLOAT, 0x00000800UL, \ "GNU EABI extension") \ _ELF_DEFINE_EF(EF_MIPS_NOREORDER, 0x00000001UL, \ "at least one .noreorder directive appeared in the source") \ _ELF_DEFINE_EF(EF_MIPS_PIC, 0x00000002UL, \ "file contains position independent code") \ _ELF_DEFINE_EF(EF_MIPS_CPIC, 0x00000004UL, \ "file's code uses standard conventions for calling PIC") \ _ELF_DEFINE_EF(EF_MIPS_UCODE, 0x00000010UL, \ "file contains UCODE (obsolete)") \ _ELF_DEFINE_EF(EF_MIPS_ABI2, 0x00000020UL, \ "file follows MIPS III 32-bit ABI") \ _ELF_DEFINE_EF(EF_MIPS_OPTIONS_FIRST, 0x00000080UL, \ "ld(1) should process .MIPS.options section first") \ _ELF_DEFINE_EF(EF_MIPS_ARCH_ASE, 0x0F000000UL, \ "file uses application-specific architectural extensions") \ _ELF_DEFINE_EF(EF_MIPS_ARCH_ASE_MDMX, 0x08000000UL, \ "file uses MDMX multimedia extensions") \ _ELF_DEFINE_EF(EF_MIPS_ARCH_ASE_M16, 0x04000000UL, \ "file uses MIPS-16 ISA extensions") \ _ELF_DEFINE_EF(EF_MIPS_ARCH, 0xF0000000UL, \ "4-bit MIPS architecture field") \ _ELF_DEFINE_EF(EF_PPC_EMB, 0x80000000UL, \ "Embedded PowerPC flag") \ _ELF_DEFINE_EF(EF_PPC_RELOCATABLE, 0x00010000UL, \ "-mrelocatable flag") \ _ELF_DEFINE_EF(EF_PPC_RELOCATABLE_LIB, 0x00008000UL, \ "-mrelocatable-lib flag") \ _ELF_DEFINE_EF(EF_SPARC_EXT_MASK, 0x00ffff00UL, \ "Vendor Extension mask") \ _ELF_DEFINE_EF(EF_SPARC_32PLUS, 0x00000100UL, \ "Generic V8+ features") \ _ELF_DEFINE_EF(EF_SPARC_SUN_US1, 0x00000200UL, \ "Sun UltraSPARCTM 1 Extensions") \ _ELF_DEFINE_EF(EF_SPARC_HAL_R1, 0x00000400UL, "HAL R1 Extensions") \ _ELF_DEFINE_EF(EF_SPARC_SUN_US3, 0x00000800UL, \ "Sun UltraSPARC 3 Extensions") \ _ELF_DEFINE_EF(EF_SPARCV9_MM, 0x00000003UL, \ "Mask for Memory Model") \ _ELF_DEFINE_EF(EF_SPARCV9_TSO, 0x00000000UL, \ "Total Store Ordering") \ _ELF_DEFINE_EF(EF_SPARCV9_PSO, 0x00000001UL, \ "Partial Store Ordering") \ _ELF_DEFINE_EF(EF_SPARCV9_RMO, 0x00000002UL, \ "Relaxed Memory Ordering") #undef _ELF_DEFINE_EF #define _ELF_DEFINE_EF(N, V, DESCR) N = V , enum { _ELF_DEFINE_EHDR_FLAGS() EF__LAST__ }; /* * Offsets in the `ei_ident[]` field of an ELF executable header. */ #define _ELF_DEFINE_EI_OFFSETS() \ _ELF_DEFINE_EI(EI_MAG0, 0, "magic number") \ _ELF_DEFINE_EI(EI_MAG1, 1, "magic number") \ _ELF_DEFINE_EI(EI_MAG2, 2, "magic number") \ _ELF_DEFINE_EI(EI_MAG3, 3, "magic number") \ _ELF_DEFINE_EI(EI_CLASS, 4, "file class") \ _ELF_DEFINE_EI(EI_DATA, 5, "data encoding") \ _ELF_DEFINE_EI(EI_VERSION, 6, "file version") \ _ELF_DEFINE_EI(EI_OSABI, 7, "OS ABI kind") \ _ELF_DEFINE_EI(EI_ABIVERSION, 8, "OS ABI version") \ _ELF_DEFINE_EI(EI_PAD, 9, "padding start") \ _ELF_DEFINE_EI(EI_NIDENT, 16, "total size") #undef _ELF_DEFINE_EI #define _ELF_DEFINE_EI(N, V, DESCR) N = V , enum { _ELF_DEFINE_EI_OFFSETS() EI__LAST__ }; /* * The ELF class of an object. */ #define _ELF_DEFINE_ELFCLASS() \ _ELF_DEFINE_EC(ELFCLASSNONE, 0, "Unknown ELF class") \ _ELF_DEFINE_EC(ELFCLASS32, 1, "32 bit objects") \ _ELF_DEFINE_EC(ELFCLASS64, 2, "64 bit objects") #undef _ELF_DEFINE_EC #define _ELF_DEFINE_EC(N, V, DESCR) N = V , enum { _ELF_DEFINE_ELFCLASS() EC__LAST__ }; /* * Endianness of data in an ELF object. */ #define _ELF_DEFINE_ELF_DATA_ENDIANNESS() \ _ELF_DEFINE_ED(ELFDATANONE, 0, "Unknown data endianness") \ _ELF_DEFINE_ED(ELFDATA2LSB, 1, "little endian") \ _ELF_DEFINE_ED(ELFDATA2MSB, 2, "big endian") #undef _ELF_DEFINE_ED #define _ELF_DEFINE_ED(N, V, DESCR) N = V , enum { _ELF_DEFINE_ELF_DATA_ENDIANNESS() ED__LAST__ }; /* * Values of the magic numbers used in identification array. */ #define _ELF_DEFINE_ELF_MAGIC() \ _ELF_DEFINE_EMAG(ELFMAG0, 0x7FU) \ _ELF_DEFINE_EMAG(ELFMAG1, 'E') \ _ELF_DEFINE_EMAG(ELFMAG2, 'L') \ _ELF_DEFINE_EMAG(ELFMAG3, 'F') #undef _ELF_DEFINE_EMAG #define _ELF_DEFINE_EMAG(N, V) N = V , enum { _ELF_DEFINE_ELF_MAGIC() ELFMAG__LAST__ }; /* * ELF OS ABI field. */ #define _ELF_DEFINE_ELF_OSABI() \ _ELF_DEFINE_EABI(ELFOSABI_NONE, 0, \ "No extensions or unspecified") \ _ELF_DEFINE_EABI(ELFOSABI_SYSV, 0, "SYSV") \ _ELF_DEFINE_EABI(ELFOSABI_HPUX, 1, "Hewlett-Packard HP-UX") \ _ELF_DEFINE_EABI(ELFOSABI_NETBSD, 2, "NetBSD") \ _ELF_DEFINE_EABI(ELFOSABI_GNU, 3, "GNU") \ _ELF_DEFINE_EABI(ELFOSABI_HURD, 4, "GNU/HURD") \ _ELF_DEFINE_EABI(ELFOSABI_86OPEN, 5, "86Open Common ABI") \ _ELF_DEFINE_EABI(ELFOSABI_SOLARIS, 6, "Sun Solaris") \ _ELF_DEFINE_EABI(ELFOSABI_AIX, 7, "AIX") \ _ELF_DEFINE_EABI(ELFOSABI_IRIX, 8, "IRIX") \ _ELF_DEFINE_EABI(ELFOSABI_FREEBSD, 9, "FreeBSD") \ _ELF_DEFINE_EABI(ELFOSABI_TRU64, 10, "Compaq TRU64 UNIX") \ _ELF_DEFINE_EABI(ELFOSABI_MODESTO, 11, "Novell Modesto") \ _ELF_DEFINE_EABI(ELFOSABI_OPENBSD, 12, "Open BSD") \ _ELF_DEFINE_EABI(ELFOSABI_OPENVMS, 13, "Open VMS") \ _ELF_DEFINE_EABI(ELFOSABI_NSK, 14, \ "Hewlett-Packard Non-Stop Kernel") \ _ELF_DEFINE_EABI(ELFOSABI_AROS, 15, "Amiga Research OS") \ _ELF_DEFINE_EABI(ELFOSABI_FENIXOS, 16, \ "The FenixOS highly scalable multi-core OS") \ +_ELF_DEFINE_EABI(ELFOSABI_CLOUDABI, 17, "Nuxi CloudABI") \ _ELF_DEFINE_EABI(ELFOSABI_ARM_AEABI, 64, \ "ARM specific symbol versioning extensions") \ _ELF_DEFINE_EABI(ELFOSABI_ARM, 97, "ARM ABI") \ _ELF_DEFINE_EABI(ELFOSABI_STANDALONE, 255, \ "Standalone (embedded) application") #undef _ELF_DEFINE_EABI #define _ELF_DEFINE_EABI(N, V, DESCR) N = V , enum { _ELF_DEFINE_ELF_OSABI() ELFOSABI__LAST__ }; #define ELFOSABI_LINUX ELFOSABI_GNU /* * ELF Machine types: (EM_*). */ #define _ELF_DEFINE_ELF_MACHINES() \ _ELF_DEFINE_EM(EM_NONE, 0, "No machine") \ _ELF_DEFINE_EM(EM_M32, 1, "AT&T WE 32100") \ _ELF_DEFINE_EM(EM_SPARC, 2, "SPARC") \ _ELF_DEFINE_EM(EM_386, 3, "Intel 80386") \ _ELF_DEFINE_EM(EM_68K, 4, "Motorola 68000") \ _ELF_DEFINE_EM(EM_88K, 5, "Motorola 88000") \ _ELF_DEFINE_EM(EM_IAMCU, 6, "Intel MCU") \ _ELF_DEFINE_EM(EM_860, 7, "Intel 80860") \ _ELF_DEFINE_EM(EM_MIPS, 8, "MIPS I Architecture") \ _ELF_DEFINE_EM(EM_S370, 9, "IBM System/370 Processor") \ _ELF_DEFINE_EM(EM_MIPS_RS3_LE, 10, "MIPS RS3000 Little-endian") \ _ELF_DEFINE_EM(EM_PARISC, 15, "Hewlett-Packard PA-RISC") \ _ELF_DEFINE_EM(EM_VPP500, 17, "Fujitsu VPP500") \ _ELF_DEFINE_EM(EM_SPARC32PLUS, 18, \ "Enhanced instruction set SPARC") \ _ELF_DEFINE_EM(EM_960, 19, "Intel 80960") \ _ELF_DEFINE_EM(EM_PPC, 20, "PowerPC") \ _ELF_DEFINE_EM(EM_PPC64, 21, "64-bit PowerPC") \ _ELF_DEFINE_EM(EM_S390, 22, "IBM System/390 Processor") \ _ELF_DEFINE_EM(EM_SPU, 23, "IBM SPU/SPC") \ _ELF_DEFINE_EM(EM_V800, 36, "NEC V800") \ _ELF_DEFINE_EM(EM_FR20, 37, "Fujitsu FR20") \ _ELF_DEFINE_EM(EM_RH32, 38, "TRW RH-32") \ _ELF_DEFINE_EM(EM_RCE, 39, "Motorola RCE") \ _ELF_DEFINE_EM(EM_ARM, 40, "Advanced RISC Machines ARM") \ _ELF_DEFINE_EM(EM_ALPHA, 41, "Digital Alpha") \ _ELF_DEFINE_EM(EM_SH, 42, "Hitachi SH") \ _ELF_DEFINE_EM(EM_SPARCV9, 43, "SPARC Version 9") \ _ELF_DEFINE_EM(EM_TRICORE, 44, \ "Siemens TriCore embedded processor") \ _ELF_DEFINE_EM(EM_ARC, 45, \ "Argonaut RISC Core, Argonaut Technologies Inc.") \ _ELF_DEFINE_EM(EM_H8_300, 46, "Hitachi H8/300") \ _ELF_DEFINE_EM(EM_H8_300H, 47, "Hitachi H8/300H") \ _ELF_DEFINE_EM(EM_H8S, 48, "Hitachi H8S") \ _ELF_DEFINE_EM(EM_H8_500, 49, "Hitachi H8/500") \ _ELF_DEFINE_EM(EM_IA_64, 50, \ "Intel IA-64 processor architecture") \ _ELF_DEFINE_EM(EM_MIPS_X, 51, "Stanford MIPS-X") \ _ELF_DEFINE_EM(EM_COLDFIRE, 52, "Motorola ColdFire") \ _ELF_DEFINE_EM(EM_68HC12, 53, "Motorola M68HC12") \ _ELF_DEFINE_EM(EM_MMA, 54, \ "Fujitsu MMA Multimedia Accelerator") \ _ELF_DEFINE_EM(EM_PCP, 55, "Siemens PCP") \ _ELF_DEFINE_EM(EM_NCPU, 56, \ "Sony nCPU embedded RISC processor") \ _ELF_DEFINE_EM(EM_NDR1, 57, "Denso NDR1 microprocessor") \ _ELF_DEFINE_EM(EM_STARCORE, 58, "Motorola Star*Core processor") \ _ELF_DEFINE_EM(EM_ME16, 59, "Toyota ME16 processor") \ _ELF_DEFINE_EM(EM_ST100, 60, \ "STMicroelectronics ST100 processor") \ _ELF_DEFINE_EM(EM_TINYJ, 61, \ "Advanced Logic Corp. TinyJ embedded processor family") \ _ELF_DEFINE_EM(EM_X86_64, 62, "AMD x86-64 architecture") \ _ELF_DEFINE_EM(EM_PDSP, 63, "Sony DSP Processor") \ _ELF_DEFINE_EM(EM_PDP10, 64, \ "Digital Equipment Corp. PDP-10") \ _ELF_DEFINE_EM(EM_PDP11, 65, \ "Digital Equipment Corp. PDP-11") \ _ELF_DEFINE_EM(EM_FX66, 66, "Siemens FX66 microcontroller") \ _ELF_DEFINE_EM(EM_ST9PLUS, 67, \ "STMicroelectronics ST9+ 8/16 bit microcontroller") \ _ELF_DEFINE_EM(EM_ST7, 68, \ "STMicroelectronics ST7 8-bit microcontroller") \ _ELF_DEFINE_EM(EM_68HC16, 69, \ "Motorola MC68HC16 Microcontroller") \ _ELF_DEFINE_EM(EM_68HC11, 70, \ "Motorola MC68HC11 Microcontroller") \ _ELF_DEFINE_EM(EM_68HC08, 71, \ "Motorola MC68HC08 Microcontroller") \ _ELF_DEFINE_EM(EM_68HC05, 72, \ "Motorola MC68HC05 Microcontroller") \ _ELF_DEFINE_EM(EM_SVX, 73, "Silicon Graphics SVx") \ _ELF_DEFINE_EM(EM_ST19, 74, \ "STMicroelectronics ST19 8-bit microcontroller") \ _ELF_DEFINE_EM(EM_VAX, 75, "Digital VAX") \ _ELF_DEFINE_EM(EM_CRIS, 76, \ "Axis Communications 32-bit embedded processor") \ _ELF_DEFINE_EM(EM_JAVELIN, 77, \ "Infineon Technologies 32-bit embedded processor") \ _ELF_DEFINE_EM(EM_FIREPATH, 78, \ "Element 14 64-bit DSP Processor") \ _ELF_DEFINE_EM(EM_ZSP, 79, \ "LSI Logic 16-bit DSP Processor") \ _ELF_DEFINE_EM(EM_MMIX, 80, \ "Donald Knuth's educational 64-bit processor") \ _ELF_DEFINE_EM(EM_HUANY, 81, \ "Harvard University machine-independent object files") \ _ELF_DEFINE_EM(EM_PRISM, 82, "SiTera Prism") \ _ELF_DEFINE_EM(EM_AVR, 83, \ "Atmel AVR 8-bit microcontroller") \ _ELF_DEFINE_EM(EM_FR30, 84, "Fujitsu FR30") \ _ELF_DEFINE_EM(EM_D10V, 85, "Mitsubishi D10V") \ _ELF_DEFINE_EM(EM_D30V, 86, "Mitsubishi D30V") \ _ELF_DEFINE_EM(EM_V850, 87, "NEC v850") \ _ELF_DEFINE_EM(EM_M32R, 88, "Mitsubishi M32R") \ _ELF_DEFINE_EM(EM_MN10300, 89, "Matsushita MN10300") \ _ELF_DEFINE_EM(EM_MN10200, 90, "Matsushita MN10200") \ _ELF_DEFINE_EM(EM_PJ, 91, "picoJava") \ _ELF_DEFINE_EM(EM_OPENRISC, 92, \ "OpenRISC 32-bit embedded processor") \ _ELF_DEFINE_EM(EM_ARC_COMPACT, 93, \ "ARC International ARCompact processor") \ _ELF_DEFINE_EM(EM_XTENSA, 94, \ "Tensilica Xtensa Architecture") \ _ELF_DEFINE_EM(EM_VIDEOCORE, 95, \ "Alphamosaic VideoCore processor") \ _ELF_DEFINE_EM(EM_TMM_GPP, 96, \ "Thompson Multimedia General Purpose Processor") \ _ELF_DEFINE_EM(EM_NS32K, 97, \ "National Semiconductor 32000 series") \ _ELF_DEFINE_EM(EM_TPC, 98, "Tenor Network TPC processor") \ _ELF_DEFINE_EM(EM_SNP1K, 99, "Trebia SNP 1000 processor") \ _ELF_DEFINE_EM(EM_ST200, 100, \ "STMicroelectronics (www.st.com) ST200 microcontroller") \ _ELF_DEFINE_EM(EM_IP2K, 101, \ "Ubicom IP2xxx microcontroller family") \ _ELF_DEFINE_EM(EM_MAX, 102, "MAX Processor") \ _ELF_DEFINE_EM(EM_CR, 103, \ "National Semiconductor CompactRISC microprocessor") \ _ELF_DEFINE_EM(EM_F2MC16, 104, "Fujitsu F2MC16") \ _ELF_DEFINE_EM(EM_MSP430, 105, \ "Texas Instruments embedded microcontroller msp430") \ _ELF_DEFINE_EM(EM_BLACKFIN, 106, \ "Analog Devices Blackfin (DSP) processor") \ _ELF_DEFINE_EM(EM_SE_C33, 107, \ "S1C33 Family of Seiko Epson processors") \ _ELF_DEFINE_EM(EM_SEP, 108, \ "Sharp embedded microprocessor") \ _ELF_DEFINE_EM(EM_ARCA, 109, "Arca RISC Microprocessor") \ _ELF_DEFINE_EM(EM_UNICORE, 110, \ "Microprocessor series from PKU-Unity Ltd. and MPRC of Peking University") \ _ELF_DEFINE_EM(EM_EXCESS, 111, \ "eXcess: 16/32/64-bit configurable embedded CPU") \ _ELF_DEFINE_EM(EM_DXP, 112, \ "Icera Semiconductor Inc. Deep Execution Processor") \ _ELF_DEFINE_EM(EM_ALTERA_NIOS2, 113, \ "Altera Nios II soft-core processor") \ _ELF_DEFINE_EM(EM_CRX, 114, \ "National Semiconductor CompactRISC CRX microprocessor") \ _ELF_DEFINE_EM(EM_XGATE, 115, \ "Motorola XGATE embedded processor") \ _ELF_DEFINE_EM(EM_C166, 116, \ "Infineon C16x/XC16x processor") \ _ELF_DEFINE_EM(EM_M16C, 117, \ "Renesas M16C series microprocessors") \ _ELF_DEFINE_EM(EM_DSPIC30F, 118, \ "Microchip Technology dsPIC30F Digital Signal Controller") \ _ELF_DEFINE_EM(EM_CE, 119, \ "Freescale Communication Engine RISC core") \ _ELF_DEFINE_EM(EM_M32C, 120, \ "Renesas M32C series microprocessors") \ _ELF_DEFINE_EM(EM_TSK3000, 131, "Altium TSK3000 core") \ _ELF_DEFINE_EM(EM_RS08, 132, \ "Freescale RS08 embedded processor") \ _ELF_DEFINE_EM(EM_SHARC, 133, \ "Analog Devices SHARC family of 32-bit DSP processors") \ _ELF_DEFINE_EM(EM_ECOG2, 134, \ "Cyan Technology eCOG2 microprocessor") \ _ELF_DEFINE_EM(EM_SCORE7, 135, \ "Sunplus S+core7 RISC processor") \ _ELF_DEFINE_EM(EM_DSP24, 136, \ "New Japan Radio (NJR) 24-bit DSP Processor") \ _ELF_DEFINE_EM(EM_VIDEOCORE3, 137, \ "Broadcom VideoCore III processor") \ _ELF_DEFINE_EM(EM_LATTICEMICO32, 138, \ "RISC processor for Lattice FPGA architecture") \ _ELF_DEFINE_EM(EM_SE_C17, 139, "Seiko Epson C17 family") \ _ELF_DEFINE_EM(EM_TI_C6000, 140, \ "The Texas Instruments TMS320C6000 DSP family") \ _ELF_DEFINE_EM(EM_TI_C2000, 141, \ "The Texas Instruments TMS320C2000 DSP family") \ _ELF_DEFINE_EM(EM_TI_C5500, 142, \ "The Texas Instruments TMS320C55x DSP family") \ _ELF_DEFINE_EM(EM_MMDSP_PLUS, 160, \ "STMicroelectronics 64bit VLIW Data Signal Processor") \ _ELF_DEFINE_EM(EM_CYPRESS_M8C, 161, "Cypress M8C microprocessor") \ _ELF_DEFINE_EM(EM_R32C, 162, \ "Renesas R32C series microprocessors") \ _ELF_DEFINE_EM(EM_TRIMEDIA, 163, \ "NXP Semiconductors TriMedia architecture family") \ _ELF_DEFINE_EM(EM_QDSP6, 164, "QUALCOMM DSP6 Processor") \ _ELF_DEFINE_EM(EM_8051, 165, "Intel 8051 and variants") \ _ELF_DEFINE_EM(EM_STXP7X, 166, \ "STMicroelectronics STxP7x family of configurable and extensible RISC processors") \ _ELF_DEFINE_EM(EM_NDS32, 167, \ "Andes Technology compact code size embedded RISC processor family") \ _ELF_DEFINE_EM(EM_ECOG1, 168, \ "Cyan Technology eCOG1X family") \ _ELF_DEFINE_EM(EM_ECOG1X, 168, \ "Cyan Technology eCOG1X family") \ _ELF_DEFINE_EM(EM_MAXQ30, 169, \ "Dallas Semiconductor MAXQ30 Core Micro-controllers") \ _ELF_DEFINE_EM(EM_XIMO16, 170, \ "New Japan Radio (NJR) 16-bit DSP Processor") \ _ELF_DEFINE_EM(EM_MANIK, 171, \ "M2000 Reconfigurable RISC Microprocessor") \ _ELF_DEFINE_EM(EM_CRAYNV2, 172, \ "Cray Inc. NV2 vector architecture") \ _ELF_DEFINE_EM(EM_RX, 173, "Renesas RX family") \ _ELF_DEFINE_EM(EM_METAG, 174, \ "Imagination Technologies META processor architecture") \ _ELF_DEFINE_EM(EM_MCST_ELBRUS, 175, \ "MCST Elbrus general purpose hardware architecture") \ _ELF_DEFINE_EM(EM_ECOG16, 176, \ "Cyan Technology eCOG16 family") \ _ELF_DEFINE_EM(EM_CR16, 177, \ "National Semiconductor CompactRISC CR16 16-bit microprocessor") \ _ELF_DEFINE_EM(EM_ETPU, 178, \ "Freescale Extended Time Processing Unit") \ _ELF_DEFINE_EM(EM_SLE9X, 179, \ "Infineon Technologies SLE9X core") \ _ELF_DEFINE_EM(EM_AARCH64, 183, \ "AArch64 (64-bit ARM)") \ _ELF_DEFINE_EM(EM_AVR32, 185, \ "Atmel Corporation 32-bit microprocessor family") \ _ELF_DEFINE_EM(EM_STM8, 186, \ "STMicroeletronics STM8 8-bit microcontroller") \ _ELF_DEFINE_EM(EM_TILE64, 187, \ "Tilera TILE64 multicore architecture family") \ _ELF_DEFINE_EM(EM_TILEPRO, 188, \ "Tilera TILEPro multicore architecture family") \ _ELF_DEFINE_EM(EM_MICROBLAZE, 189, \ "Xilinx MicroBlaze 32-bit RISC soft processor core") \ _ELF_DEFINE_EM(EM_CUDA, 190, "NVIDIA CUDA architecture") \ _ELF_DEFINE_EM(EM_TILEGX, 191, \ "Tilera TILE-Gx multicore architecture family") \ _ELF_DEFINE_EM(EM_CLOUDSHIELD, 192, \ "CloudShield architecture family") \ _ELF_DEFINE_EM(EM_COREA_1ST, 193, \ "KIPO-KAIST Core-A 1st generation processor family") \ _ELF_DEFINE_EM(EM_COREA_2ND, 194, \ "KIPO-KAIST Core-A 2nd generation processor family") \ _ELF_DEFINE_EM(EM_ARC_COMPACT2, 195, "Synopsys ARCompact V2") \ _ELF_DEFINE_EM(EM_OPEN8, 196, \ "Open8 8-bit RISC soft processor core") \ _ELF_DEFINE_EM(EM_RL78, 197, "Renesas RL78 family") \ _ELF_DEFINE_EM(EM_VIDEOCORE5, 198, "Broadcom VideoCore V processor") \ _ELF_DEFINE_EM(EM_78KOR, 199, "Renesas 78KOR family") \ _ELF_DEFINE_EM(EM_56800EX, 200, \ "Freescale 56800EX Digital Signal Controller") \ _ELF_DEFINE_EM(EM_BA1, 201, "Beyond BA1 CPU architecture") \ _ELF_DEFINE_EM(EM_BA2, 202, "Beyond BA2 CPU architecture") \ _ELF_DEFINE_EM(EM_XCORE, 203, "XMOS xCORE processor family") \ _ELF_DEFINE_EM(EM_MCHP_PIC, 204, "Microchip 8-bit PIC(r) family") \ _ELF_DEFINE_EM(EM_INTEL205, 205, "Reserved by Intel") \ _ELF_DEFINE_EM(EM_INTEL206, 206, "Reserved by Intel") \ _ELF_DEFINE_EM(EM_INTEL207, 207, "Reserved by Intel") \ _ELF_DEFINE_EM(EM_INTEL208, 208, "Reserved by Intel") \ _ELF_DEFINE_EM(EM_INTEL209, 209, "Reserved by Intel") \ _ELF_DEFINE_EM(EM_KM32, 210, "KM211 KM32 32-bit processor") \ _ELF_DEFINE_EM(EM_KMX32, 211, "KM211 KMX32 32-bit processor") \ _ELF_DEFINE_EM(EM_KMX16, 212, "KM211 KMX16 16-bit processor") \ _ELF_DEFINE_EM(EM_KMX8, 213, "KM211 KMX8 8-bit processor") \ _ELF_DEFINE_EM(EM_KVARC, 214, "KM211 KMX32 KVARC processor") \ _ELF_DEFINE_EM(EM_RISCV, 243, "RISC-V") #undef _ELF_DEFINE_EM #define _ELF_DEFINE_EM(N, V, DESCR) N = V , enum { _ELF_DEFINE_ELF_MACHINES() EM__LAST__ }; /* Other synonyms. */ #define EM_AMD64 EM_X86_64 #define EM_ARC_A5 EM_ARC_COMPACT /* * ELF file types: (ET_*). */ #define _ELF_DEFINE_ELF_TYPES() \ _ELF_DEFINE_ET(ET_NONE, 0, "No file type") \ _ELF_DEFINE_ET(ET_REL, 1, "Relocatable object") \ _ELF_DEFINE_ET(ET_EXEC, 2, "Executable") \ _ELF_DEFINE_ET(ET_DYN, 3, "Shared object") \ _ELF_DEFINE_ET(ET_CORE, 4, "Core file") \ _ELF_DEFINE_ET(ET_LOOS, 0xFE00U, "Begin OS-specific range") \ _ELF_DEFINE_ET(ET_HIOS, 0xFEFFU, "End OS-specific range") \ _ELF_DEFINE_ET(ET_LOPROC, 0xFF00U, "Begin processor-specific range") \ _ELF_DEFINE_ET(ET_HIPROC, 0xFFFFU, "End processor-specific range") #undef _ELF_DEFINE_ET #define _ELF_DEFINE_ET(N, V, DESCR) N = V , enum { _ELF_DEFINE_ELF_TYPES() ET__LAST__ }; /* ELF file format version numbers. */ #define EV_NONE 0 #define EV_CURRENT 1 /* * Flags for section groups. */ #define GRP_COMDAT 0x1 /* COMDAT semantics */ #define GRP_MASKOS 0x0ff00000 /* OS-specific flags */ #define GRP_MASKPROC 0xf0000000 /* processor-specific flags */ /* * Flags / mask for .gnu.versym sections. */ #define VERSYM_VERSION 0x7fff #define VERSYM_HIDDEN 0x8000 /* * Flags used by program header table entries. */ #define _ELF_DEFINE_PHDR_FLAGS() \ _ELF_DEFINE_PF(PF_X, 0x1, "Execute") \ _ELF_DEFINE_PF(PF_W, 0x2, "Write") \ _ELF_DEFINE_PF(PF_R, 0x4, "Read") \ _ELF_DEFINE_PF(PF_MASKOS, 0x0ff00000, "OS-specific flags") \ _ELF_DEFINE_PF(PF_MASKPROC, 0xf0000000, "Processor-specific flags") \ _ELF_DEFINE_PF(PF_ARM_SB, 0x10000000, \ "segment contains the location addressed by the static base") \ _ELF_DEFINE_PF(PF_ARM_PI, 0x20000000, \ "segment is position-independent") \ _ELF_DEFINE_PF(PF_ARM_ABS, 0x40000000, \ "segment must be loaded at its base address") #undef _ELF_DEFINE_PF #define _ELF_DEFINE_PF(N, V, DESCR) N = V , enum { _ELF_DEFINE_PHDR_FLAGS() PF__LAST__ }; /* * Types of program header table entries. */ #define _ELF_DEFINE_PHDR_TYPES() \ _ELF_DEFINE_PT(PT_NULL, 0, "ignored entry") \ _ELF_DEFINE_PT(PT_LOAD, 1, "loadable segment") \ _ELF_DEFINE_PT(PT_DYNAMIC, 2, \ "contains dynamic linking information") \ _ELF_DEFINE_PT(PT_INTERP, 3, "names an interpreter") \ _ELF_DEFINE_PT(PT_NOTE, 4, "auxiliary information") \ _ELF_DEFINE_PT(PT_SHLIB, 5, "reserved") \ _ELF_DEFINE_PT(PT_PHDR, 6, \ "describes the program header itself") \ _ELF_DEFINE_PT(PT_TLS, 7, "thread local storage") \ _ELF_DEFINE_PT(PT_LOOS, 0x60000000UL, \ "start of OS-specific range") \ _ELF_DEFINE_PT(PT_SUNW_UNWIND, 0x6464E550UL, \ "Solaris/amd64 stack unwind tables") \ _ELF_DEFINE_PT(PT_GNU_EH_FRAME, 0x6474E550UL, \ "GCC generated .eh_frame_hdr segment") \ _ELF_DEFINE_PT(PT_GNU_STACK, 0x6474E551UL, \ "Stack flags") \ _ELF_DEFINE_PT(PT_GNU_RELRO, 0x6474E552UL, \ "Segment becomes read-only after relocation") \ _ELF_DEFINE_PT(PT_SUNWBSS, 0x6FFFFFFAUL, \ "A Solaris .SUNW_bss section") \ _ELF_DEFINE_PT(PT_SUNWSTACK, 0x6FFFFFFBUL, \ "A Solaris process stack") \ _ELF_DEFINE_PT(PT_SUNWDTRACE, 0x6FFFFFFCUL, \ "Used by dtrace(1)") \ _ELF_DEFINE_PT(PT_SUNWCAP, 0x6FFFFFFDUL, \ "Special hardware capability requirements") \ _ELF_DEFINE_PT(PT_HIOS, 0x6FFFFFFFUL, \ "end of OS-specific range") \ _ELF_DEFINE_PT(PT_LOPROC, 0x70000000UL, \ "start of processor-specific range") \ _ELF_DEFINE_PT(PT_ARM_ARCHEXT, 0x70000000UL, \ "platform architecture compatibility information") \ _ELF_DEFINE_PT(PT_ARM_EXIDX, 0x70000001UL, \ "exception unwind tables") \ _ELF_DEFINE_PT(PT_MIPS_REGINFO, 0x70000000UL, \ "register usage information") \ _ELF_DEFINE_PT(PT_MIPS_RTPROC, 0x70000001UL, \ "runtime procedure table") \ _ELF_DEFINE_PT(PT_MIPS_OPTIONS, 0x70000002UL, \ "options segment") \ _ELF_DEFINE_PT(PT_HIPROC, 0x7FFFFFFFUL, \ "end of processor-specific range") #undef _ELF_DEFINE_PT #define _ELF_DEFINE_PT(N, V, DESCR) N = V , enum { _ELF_DEFINE_PHDR_TYPES() PT__LAST__ = PT_HIPROC }; /* synonyms. */ #define PT_ARM_UNWIND PT_ARM_EXIDX #define PT_HISUNW PT_HIOS #define PT_LOSUNW PT_SUNWBSS /* * Section flags. */ #define _ELF_DEFINE_SECTION_FLAGS() \ _ELF_DEFINE_SHF(SHF_WRITE, 0x1, \ "writable during program execution") \ _ELF_DEFINE_SHF(SHF_ALLOC, 0x2, \ "occupies memory during program execution") \ _ELF_DEFINE_SHF(SHF_EXECINSTR, 0x4, "executable instructions") \ _ELF_DEFINE_SHF(SHF_MERGE, 0x10, \ "may be merged to prevent duplication") \ _ELF_DEFINE_SHF(SHF_STRINGS, 0x20, \ "NUL-terminated character strings") \ _ELF_DEFINE_SHF(SHF_INFO_LINK, 0x40, \ "the sh_info field holds a link") \ _ELF_DEFINE_SHF(SHF_LINK_ORDER, 0x80, \ "special ordering requirements during linking") \ _ELF_DEFINE_SHF(SHF_OS_NONCONFORMING, 0x100, \ "requires OS-specific processing during linking") \ _ELF_DEFINE_SHF(SHF_GROUP, 0x200, \ "member of a section group") \ _ELF_DEFINE_SHF(SHF_TLS, 0x400, \ "holds thread-local storage") \ _ELF_DEFINE_SHF(SHF_COMPRESSED, 0x800, \ "holds compressed data") \ _ELF_DEFINE_SHF(SHF_MASKOS, 0x0FF00000UL, \ "bits reserved for OS-specific semantics") \ _ELF_DEFINE_SHF(SHF_AMD64_LARGE, 0x10000000UL, \ "section uses large code model") \ _ELF_DEFINE_SHF(SHF_ENTRYSECT, 0x10000000UL, \ "section contains an entry point (ARM)") \ _ELF_DEFINE_SHF(SHF_COMDEF, 0x80000000UL, \ "section may be multiply defined in input to link step (ARM)") \ _ELF_DEFINE_SHF(SHF_MIPS_GPREL, 0x10000000UL, \ "section must be part of global data area") \ _ELF_DEFINE_SHF(SHF_MIPS_MERGE, 0x20000000UL, \ "section data should be merged to eliminate duplication") \ _ELF_DEFINE_SHF(SHF_MIPS_ADDR, 0x40000000UL, \ "section data is addressed by default") \ _ELF_DEFINE_SHF(SHF_MIPS_STRING, 0x80000000UL, \ "section data is string data by default") \ _ELF_DEFINE_SHF(SHF_MIPS_NOSTRIP, 0x08000000UL, \ "section data may not be stripped") \ _ELF_DEFINE_SHF(SHF_MIPS_LOCAL, 0x04000000UL, \ "section data local to process") \ _ELF_DEFINE_SHF(SHF_MIPS_NAMES, 0x02000000UL, \ "linker must generate implicit hidden weak names") \ _ELF_DEFINE_SHF(SHF_MIPS_NODUPE, 0x01000000UL, \ "linker must retain only one copy") \ _ELF_DEFINE_SHF(SHF_ORDERED, 0x40000000UL, \ "section is ordered with respect to other sections") \ _ELF_DEFINE_SHF(SHF_EXCLUDE, 0x80000000UL, \ "section is excluded from executables and shared objects") \ _ELF_DEFINE_SHF(SHF_MASKPROC, 0xF0000000UL, \ "bits reserved for processor-specific semantics") #undef _ELF_DEFINE_SHF #define _ELF_DEFINE_SHF(N, V, DESCR) N = V , enum { _ELF_DEFINE_SECTION_FLAGS() SHF__LAST__ }; /* * Special section indices. */ #define _ELF_DEFINE_SECTION_INDICES() \ _ELF_DEFINE_SHN(SHN_UNDEF, 0, "undefined section") \ _ELF_DEFINE_SHN(SHN_LORESERVE, 0xFF00U, "start of reserved area") \ _ELF_DEFINE_SHN(SHN_LOPROC, 0xFF00U, \ "start of processor-specific range") \ _ELF_DEFINE_SHN(SHN_BEFORE, 0xFF00U, "used for section ordering") \ _ELF_DEFINE_SHN(SHN_AFTER, 0xFF01U, "used for section ordering") \ _ELF_DEFINE_SHN(SHN_AMD64_LCOMMON, 0xFF02U, "large common block label") \ _ELF_DEFINE_SHN(SHN_MIPS_ACOMMON, 0xFF00U, \ "allocated common symbols in a DSO") \ _ELF_DEFINE_SHN(SHN_MIPS_TEXT, 0xFF01U, "Reserved (obsolete)") \ _ELF_DEFINE_SHN(SHN_MIPS_DATA, 0xFF02U, "Reserved (obsolete)") \ _ELF_DEFINE_SHN(SHN_MIPS_SCOMMON, 0xFF03U, \ "gp-addressable common symbols") \ _ELF_DEFINE_SHN(SHN_MIPS_SUNDEFINED, 0xFF04U, \ "gp-addressable undefined symbols") \ _ELF_DEFINE_SHN(SHN_MIPS_LCOMMON, 0xFF05U, "local common symbols") \ _ELF_DEFINE_SHN(SHN_MIPS_LUNDEFINED, 0xFF06U, \ "local undefined symbols") \ _ELF_DEFINE_SHN(SHN_HIPROC, 0xFF1FU, \ "end of processor-specific range") \ _ELF_DEFINE_SHN(SHN_LOOS, 0xFF20U, \ "start of OS-specific range") \ _ELF_DEFINE_SHN(SHN_SUNW_IGNORE, 0xFF3FU, "used by dtrace") \ _ELF_DEFINE_SHN(SHN_HIOS, 0xFF3FU, \ "end of OS-specific range") \ _ELF_DEFINE_SHN(SHN_ABS, 0xFFF1U, "absolute references") \ _ELF_DEFINE_SHN(SHN_COMMON, 0xFFF2U, "references to COMMON areas") \ _ELF_DEFINE_SHN(SHN_XINDEX, 0xFFFFU, "extended index") \ _ELF_DEFINE_SHN(SHN_HIRESERVE, 0xFFFFU, "end of reserved area") #undef _ELF_DEFINE_SHN #define _ELF_DEFINE_SHN(N, V, DESCR) N = V , enum { _ELF_DEFINE_SECTION_INDICES() SHN__LAST__ }; /* * Section types. */ #define _ELF_DEFINE_SECTION_TYPES() \ _ELF_DEFINE_SHT(SHT_NULL, 0, "inactive header") \ _ELF_DEFINE_SHT(SHT_PROGBITS, 1, "program defined information") \ _ELF_DEFINE_SHT(SHT_SYMTAB, 2, "symbol table") \ _ELF_DEFINE_SHT(SHT_STRTAB, 3, "string table") \ _ELF_DEFINE_SHT(SHT_RELA, 4, \ "relocation entries with addends") \ _ELF_DEFINE_SHT(SHT_HASH, 5, "symbol hash table") \ _ELF_DEFINE_SHT(SHT_DYNAMIC, 6, \ "information for dynamic linking") \ _ELF_DEFINE_SHT(SHT_NOTE, 7, "additional notes") \ _ELF_DEFINE_SHT(SHT_NOBITS, 8, "section occupying no space") \ _ELF_DEFINE_SHT(SHT_REL, 9, \ "relocation entries without addends") \ _ELF_DEFINE_SHT(SHT_SHLIB, 10, "reserved") \ _ELF_DEFINE_SHT(SHT_DYNSYM, 11, "symbol table") \ _ELF_DEFINE_SHT(SHT_INIT_ARRAY, 14, \ "pointers to initialization functions") \ _ELF_DEFINE_SHT(SHT_FINI_ARRAY, 15, \ "pointers to termination functions") \ _ELF_DEFINE_SHT(SHT_PREINIT_ARRAY, 16, \ "pointers to functions called before initialization") \ _ELF_DEFINE_SHT(SHT_GROUP, 17, "defines a section group") \ _ELF_DEFINE_SHT(SHT_SYMTAB_SHNDX, 18, \ "used for extended section numbering") \ _ELF_DEFINE_SHT(SHT_LOOS, 0x60000000UL, \ "start of OS-specific range") \ _ELF_DEFINE_SHT(SHT_SUNW_dof, 0x6FFFFFF4UL, \ "used by dtrace") \ _ELF_DEFINE_SHT(SHT_SUNW_cap, 0x6FFFFFF5UL, \ "capability requirements") \ _ELF_DEFINE_SHT(SHT_GNU_ATTRIBUTES, 0x6FFFFFF5UL, \ "object attributes") \ _ELF_DEFINE_SHT(SHT_SUNW_SIGNATURE, 0x6FFFFFF6UL, \ "module verification signature") \ _ELF_DEFINE_SHT(SHT_GNU_HASH, 0x6FFFFFF6UL, \ "GNU Hash sections") \ _ELF_DEFINE_SHT(SHT_GNU_LIBLIST, 0x6FFFFFF7UL, \ "List of libraries to be prelinked") \ _ELF_DEFINE_SHT(SHT_SUNW_ANNOTATE, 0x6FFFFFF7UL, \ "special section where unresolved references are allowed") \ _ELF_DEFINE_SHT(SHT_SUNW_DEBUGSTR, 0x6FFFFFF8UL, \ "debugging information") \ _ELF_DEFINE_SHT(SHT_CHECKSUM, 0x6FFFFFF8UL, \ "checksum for dynamic shared objects") \ _ELF_DEFINE_SHT(SHT_SUNW_DEBUG, 0x6FFFFFF9UL, \ "debugging information") \ _ELF_DEFINE_SHT(SHT_SUNW_move, 0x6FFFFFFAUL, \ "information to handle partially initialized symbols") \ _ELF_DEFINE_SHT(SHT_SUNW_COMDAT, 0x6FFFFFFBUL, \ "section supporting merging of multiple copies of data") \ _ELF_DEFINE_SHT(SHT_SUNW_syminfo, 0x6FFFFFFCUL, \ "additional symbol information") \ _ELF_DEFINE_SHT(SHT_SUNW_verdef, 0x6FFFFFFDUL, \ "symbol versioning information") \ _ELF_DEFINE_SHT(SHT_SUNW_verneed, 0x6FFFFFFEUL, \ "symbol versioning requirements") \ _ELF_DEFINE_SHT(SHT_SUNW_versym, 0x6FFFFFFFUL, \ "symbol versioning table") \ _ELF_DEFINE_SHT(SHT_HIOS, 0x6FFFFFFFUL, \ "end of OS-specific range") \ _ELF_DEFINE_SHT(SHT_LOPROC, 0x70000000UL, \ "start of processor-specific range") \ _ELF_DEFINE_SHT(SHT_ARM_EXIDX, 0x70000001UL, \ "exception index table") \ _ELF_DEFINE_SHT(SHT_ARM_PREEMPTMAP, 0x70000002UL, \ "BPABI DLL dynamic linking preemption map") \ _ELF_DEFINE_SHT(SHT_ARM_ATTRIBUTES, 0x70000003UL, \ "object file compatibility attributes") \ _ELF_DEFINE_SHT(SHT_ARM_DEBUGOVERLAY, 0x70000004UL, \ "overlay debug information") \ _ELF_DEFINE_SHT(SHT_ARM_OVERLAYSECTION, 0x70000005UL, \ "overlay debug information") \ _ELF_DEFINE_SHT(SHT_MIPS_LIBLIST, 0x70000000UL, \ "DSO library information used in link") \ _ELF_DEFINE_SHT(SHT_MIPS_MSYM, 0x70000001UL, \ "MIPS symbol table extension") \ _ELF_DEFINE_SHT(SHT_MIPS_CONFLICT, 0x70000002UL, \ "symbol conflicting with DSO-defined symbols ") \ _ELF_DEFINE_SHT(SHT_MIPS_GPTAB, 0x70000003UL, \ "global pointer table") \ _ELF_DEFINE_SHT(SHT_MIPS_UCODE, 0x70000004UL, \ "reserved") \ _ELF_DEFINE_SHT(SHT_MIPS_DEBUG, 0x70000005UL, \ "reserved (obsolete debug information)") \ _ELF_DEFINE_SHT(SHT_MIPS_REGINFO, 0x70000006UL, \ "register usage information") \ _ELF_DEFINE_SHT(SHT_MIPS_PACKAGE, 0x70000007UL, \ "OSF reserved") \ _ELF_DEFINE_SHT(SHT_MIPS_PACKSYM, 0x70000008UL, \ "OSF reserved") \ _ELF_DEFINE_SHT(SHT_MIPS_RELD, 0x70000009UL, \ "dynamic relocation") \ _ELF_DEFINE_SHT(SHT_MIPS_IFACE, 0x7000000BUL, \ "subprogram interface information") \ _ELF_DEFINE_SHT(SHT_MIPS_CONTENT, 0x7000000CUL, \ "section content classification") \ _ELF_DEFINE_SHT(SHT_MIPS_OPTIONS, 0x7000000DUL, \ "general options") \ _ELF_DEFINE_SHT(SHT_MIPS_DELTASYM, 0x7000001BUL, \ "Delta C++: symbol table") \ _ELF_DEFINE_SHT(SHT_MIPS_DELTAINST, 0x7000001CUL, \ "Delta C++: instance table") \ _ELF_DEFINE_SHT(SHT_MIPS_DELTACLASS, 0x7000001DUL, \ "Delta C++: class table") \ _ELF_DEFINE_SHT(SHT_MIPS_DWARF, 0x7000001EUL, \ "DWARF debug information") \ _ELF_DEFINE_SHT(SHT_MIPS_DELTADECL, 0x7000001FUL, \ "Delta C++: declarations") \ _ELF_DEFINE_SHT(SHT_MIPS_SYMBOL_LIB, 0x70000020UL, \ "symbol-to-library mapping") \ _ELF_DEFINE_SHT(SHT_MIPS_EVENTS, 0x70000021UL, \ "event locations") \ _ELF_DEFINE_SHT(SHT_MIPS_TRANSLATE, 0x70000022UL, \ "???") \ _ELF_DEFINE_SHT(SHT_MIPS_PIXIE, 0x70000023UL, \ "special pixie sections") \ _ELF_DEFINE_SHT(SHT_MIPS_XLATE, 0x70000024UL, \ "address translation table") \ _ELF_DEFINE_SHT(SHT_MIPS_XLATE_DEBUG, 0x70000025UL, \ "SGI internal address translation table") \ _ELF_DEFINE_SHT(SHT_MIPS_WHIRL, 0x70000026UL, \ "intermediate code") \ _ELF_DEFINE_SHT(SHT_MIPS_EH_REGION, 0x70000027UL, \ "C++ exception handling region info") \ _ELF_DEFINE_SHT(SHT_MIPS_XLATE_OLD, 0x70000028UL, \ "obsolete") \ _ELF_DEFINE_SHT(SHT_MIPS_PDR_EXCEPTION, 0x70000029UL, \ "runtime procedure descriptor table exception information") \ _ELF_DEFINE_SHT(SHT_MIPS_ABIFLAGS, 0x7000002AUL, \ "ABI flags") \ _ELF_DEFINE_SHT(SHT_SPARC_GOTDATA, 0x70000000UL, \ "SPARC-specific data") \ -_ELF_DEFINE_SHT(SHT_AMD64_UNWIND, 0x70000001UL, \ +_ELF_DEFINE_SHT(SHT_X86_64_UNWIND, 0x70000001UL, \ "unwind tables for the AMD64") \ _ELF_DEFINE_SHT(SHT_ORDERED, 0x7FFFFFFFUL, \ "sort entries in the section") \ _ELF_DEFINE_SHT(SHT_HIPROC, 0x7FFFFFFFUL, \ "end of processor-specific range") \ _ELF_DEFINE_SHT(SHT_LOUSER, 0x80000000UL, \ "start of application-specific range") \ _ELF_DEFINE_SHT(SHT_HIUSER, 0xFFFFFFFFUL, \ "end of application-specific range") #undef _ELF_DEFINE_SHT #define _ELF_DEFINE_SHT(N, V, DESCR) N = V , enum { _ELF_DEFINE_SECTION_TYPES() SHT__LAST__ = SHT_HIUSER }; /* Aliases for section types. */ +#define SHT_AMD64_UNWIND SHT_X86_64_UNWIND #define SHT_GNU_verdef SHT_SUNW_verdef #define SHT_GNU_verneed SHT_SUNW_verneed #define SHT_GNU_versym SHT_SUNW_versym /* * Symbol binding information. */ #define _ELF_DEFINE_SYMBOL_BINDING() \ _ELF_DEFINE_STB(STB_LOCAL, 0, \ "not visible outside defining object file") \ _ELF_DEFINE_STB(STB_GLOBAL, 1, \ "visible across all object files being combined") \ _ELF_DEFINE_STB(STB_WEAK, 2, \ "visible across all object files but with low precedence") \ _ELF_DEFINE_STB(STB_LOOS, 10, "start of OS-specific range") \ _ELF_DEFINE_STB(STB_GNU_UNIQUE, 10, "unique symbol (GNU)") \ _ELF_DEFINE_STB(STB_HIOS, 12, "end of OS-specific range") \ _ELF_DEFINE_STB(STB_LOPROC, 13, \ "start of processor-specific range") \ _ELF_DEFINE_STB(STB_HIPROC, 15, \ "end of processor-specific range") #undef _ELF_DEFINE_STB #define _ELF_DEFINE_STB(N, V, DESCR) N = V , enum { _ELF_DEFINE_SYMBOL_BINDING() STB__LAST__ }; /* * Symbol types */ #define _ELF_DEFINE_SYMBOL_TYPES() \ _ELF_DEFINE_STT(STT_NOTYPE, 0, "unspecified type") \ _ELF_DEFINE_STT(STT_OBJECT, 1, "data object") \ _ELF_DEFINE_STT(STT_FUNC, 2, "executable code") \ _ELF_DEFINE_STT(STT_SECTION, 3, "section") \ _ELF_DEFINE_STT(STT_FILE, 4, "source file") \ _ELF_DEFINE_STT(STT_COMMON, 5, "uninitialized common block") \ _ELF_DEFINE_STT(STT_TLS, 6, "thread local storage") \ _ELF_DEFINE_STT(STT_LOOS, 10, "start of OS-specific types") \ +_ELF_DEFINE_STT(STT_GNU_IFUNC, 10, "indirect function") \ _ELF_DEFINE_STT(STT_HIOS, 12, "end of OS-specific types") \ _ELF_DEFINE_STT(STT_LOPROC, 13, \ "start of processor-specific types") \ _ELF_DEFINE_STT(STT_ARM_TFUNC, 13, "Thumb function (GNU)") \ _ELF_DEFINE_STT(STT_ARM_16BIT, 15, "Thumb label (GNU)") \ _ELF_DEFINE_STT(STT_SPARC_REGISTER, 13, "SPARC register information") \ _ELF_DEFINE_STT(STT_HIPROC, 15, \ "end of processor-specific types") #undef _ELF_DEFINE_STT #define _ELF_DEFINE_STT(N, V, DESCR) N = V , enum { _ELF_DEFINE_SYMBOL_TYPES() STT__LAST__ }; /* * Symbol binding. */ #define _ELF_DEFINE_SYMBOL_BINDING_KINDS() \ _ELF_DEFINE_SYB(SYMINFO_BT_SELF, 0xFFFFU, \ "bound to self") \ _ELF_DEFINE_SYB(SYMINFO_BT_PARENT, 0xFFFEU, \ "bound to parent") \ _ELF_DEFINE_SYB(SYMINFO_BT_NONE, 0xFFFDU, \ "no special binding") #undef _ELF_DEFINE_SYB #define _ELF_DEFINE_SYB(N, V, DESCR) N = V , enum { _ELF_DEFINE_SYMBOL_BINDING_KINDS() SYMINFO__LAST__ }; /* * Symbol visibility. */ #define _ELF_DEFINE_SYMBOL_VISIBILITY() \ _ELF_DEFINE_STV(STV_DEFAULT, 0, \ "as specified by symbol type") \ _ELF_DEFINE_STV(STV_INTERNAL, 1, \ "as defined by processor semantics") \ _ELF_DEFINE_STV(STV_HIDDEN, 2, \ "hidden from other components") \ _ELF_DEFINE_STV(STV_PROTECTED, 3, \ "local references are not preemptable") #undef _ELF_DEFINE_STV #define _ELF_DEFINE_STV(N, V, DESCR) N = V , enum { _ELF_DEFINE_SYMBOL_VISIBILITY() STV__LAST__ }; /* * Symbol flags. */ #define _ELF_DEFINE_SYMBOL_FLAGS() \ _ELF_DEFINE_SYF(SYMINFO_FLG_DIRECT, 0x01, \ "directly assocated reference") \ _ELF_DEFINE_SYF(SYMINFO_FLG_COPY, 0x04, \ "definition by copy-relocation") \ _ELF_DEFINE_SYF(SYMINFO_FLG_LAZYLOAD, 0x08, \ "object should be lazily loaded") \ _ELF_DEFINE_SYF(SYMINFO_FLG_DIRECTBIND, 0x10, \ "reference should be directly bound") \ _ELF_DEFINE_SYF(SYMINFO_FLG_NOEXTDIRECT, 0x20, \ "external references not allowed to bind to definition") #undef _ELF_DEFINE_SYF #define _ELF_DEFINE_SYF(N, V, DESCR) N = V , enum { _ELF_DEFINE_SYMBOL_FLAGS() SYMINFO_FLG__LAST__ }; /* * Version dependencies. */ #define _ELF_DEFINE_VERSIONING_DEPENDENCIES() \ _ELF_DEFINE_VERD(VER_NDX_LOCAL, 0, "local scope") \ _ELF_DEFINE_VERD(VER_NDX_GLOBAL, 1, "global scope") #undef _ELF_DEFINE_VERD #define _ELF_DEFINE_VERD(N, V, DESCR) N = V , enum { _ELF_DEFINE_VERSIONING_DEPENDENCIES() VER_NDX__LAST__ }; /* * Version flags. */ #define _ELF_DEFINE_VERSIONING_FLAGS() \ _ELF_DEFINE_VERF(VER_FLG_BASE, 0x1, "file version") \ _ELF_DEFINE_VERF(VER_FLG_WEAK, 0x2, "weak version") #undef _ELF_DEFINE_VERF #define _ELF_DEFINE_VERF(N, V, DESCR) N = V , enum { _ELF_DEFINE_VERSIONING_FLAGS() VER_FLG__LAST__ }; /* * Version needs */ #define _ELF_DEFINE_VERSIONING_NEEDS() \ _ELF_DEFINE_VRN(VER_NEED_NONE, 0, "invalid version") \ _ELF_DEFINE_VRN(VER_NEED_CURRENT, 1, "current version") #undef _ELF_DEFINE_VRN #define _ELF_DEFINE_VRN(N, V, DESCR) N = V , enum { _ELF_DEFINE_VERSIONING_NEEDS() VER_NEED__LAST__ }; /* * Version numbers. */ #define _ELF_DEFINE_VERSIONING_NUMBERS() \ _ELF_DEFINE_VRNU(VER_DEF_NONE, 0, "invalid version") \ _ELF_DEFINE_VRNU(VER_DEF_CURRENT, 1, "current version") #undef _ELF_DEFINE_VRNU #define _ELF_DEFINE_VRNU(N, V, DESCR) N = V , enum { _ELF_DEFINE_VERSIONING_NUMBERS() VER_DEF__LAST__ }; /** ** Relocation types. **/ #define _ELF_DEFINE_386_RELOCATIONS() \ _ELF_DEFINE_RELOC(R_386_NONE, 0) \ _ELF_DEFINE_RELOC(R_386_32, 1) \ _ELF_DEFINE_RELOC(R_386_PC32, 2) \ _ELF_DEFINE_RELOC(R_386_GOT32, 3) \ _ELF_DEFINE_RELOC(R_386_PLT32, 4) \ _ELF_DEFINE_RELOC(R_386_COPY, 5) \ _ELF_DEFINE_RELOC(R_386_GLOB_DAT, 6) \ _ELF_DEFINE_RELOC(R_386_JUMP_SLOT, 7) \ _ELF_DEFINE_RELOC(R_386_RELATIVE, 8) \ _ELF_DEFINE_RELOC(R_386_GOTOFF, 9) \ _ELF_DEFINE_RELOC(R_386_GOTPC, 10) \ _ELF_DEFINE_RELOC(R_386_32PLT, 11) \ +_ELF_DEFINE_RELOC(R_386_TLS_TPOFF, 14) \ +_ELF_DEFINE_RELOC(R_386_TLS_IE, 15) \ +_ELF_DEFINE_RELOC(R_386_TLS_GOTIE, 16) \ +_ELF_DEFINE_RELOC(R_386_TLS_LE, 17) \ +_ELF_DEFINE_RELOC(R_386_TLS_GD, 18) \ +_ELF_DEFINE_RELOC(R_386_TLS_LDM, 19) \ _ELF_DEFINE_RELOC(R_386_16, 20) \ _ELF_DEFINE_RELOC(R_386_PC16, 21) \ _ELF_DEFINE_RELOC(R_386_8, 22) \ -_ELF_DEFINE_RELOC(R_386_PC8, 23) +_ELF_DEFINE_RELOC(R_386_PC8, 23) \ +_ELF_DEFINE_RELOC(R_386_TLS_GD_32, 24) \ +_ELF_DEFINE_RELOC(R_386_TLS_GD_PUSH, 25) \ +_ELF_DEFINE_RELOC(R_386_TLS_GD_CALL, 26) \ +_ELF_DEFINE_RELOC(R_386_TLS_GD_POP, 27) \ +_ELF_DEFINE_RELOC(R_386_TLS_LDM_32, 28) \ +_ELF_DEFINE_RELOC(R_386_TLS_LDM_PUSH, 29) \ +_ELF_DEFINE_RELOC(R_386_TLS_LDM_CALL, 30) \ +_ELF_DEFINE_RELOC(R_386_TLS_LDM_POP, 31) \ +_ELF_DEFINE_RELOC(R_386_TLS_LDO_32, 32) \ +_ELF_DEFINE_RELOC(R_386_TLS_IE_32, 33) \ +_ELF_DEFINE_RELOC(R_386_TLS_LE_32, 34) \ +_ELF_DEFINE_RELOC(R_386_TLS_DTPMOD32, 35) \ +_ELF_DEFINE_RELOC(R_386_TLS_DTPOFF32, 36) \ +_ELF_DEFINE_RELOC(R_386_TLS_TPOFF32, 37) \ +_ELF_DEFINE_RELOC(R_386_SIZE32, 38) \ +_ELF_DEFINE_RELOC(R_386_TLS_GOTDESC, 39) \ +_ELF_DEFINE_RELOC(R_386_TLS_DESC_CALL, 40) \ +_ELF_DEFINE_RELOC(R_386_TLS_DESC, 41) \ +_ELF_DEFINE_RELOC(R_386_IRELATIVE, 42) \ +_ELF_DEFINE_RELOC(R_386_GOT32X, 43) + /* */ #define _ELF_DEFINE_AARCH64_RELOCATIONS() \ _ELF_DEFINE_RELOC(R_AARCH64_NONE, 0) \ _ELF_DEFINE_RELOC(R_AARCH64_ABS64, 257) \ _ELF_DEFINE_RELOC(R_AARCH64_ABS32, 258) \ _ELF_DEFINE_RELOC(R_AARCH64_ABS16, 259) \ _ELF_DEFINE_RELOC(R_AARCH64_PREL64, 260) \ _ELF_DEFINE_RELOC(R_AARCH64_PREL32, 261) \ _ELF_DEFINE_RELOC(R_AARCH64_PREL16, 262) \ _ELF_DEFINE_RELOC(R_AARCH64_MOVW_UABS_G0, 263) \ _ELF_DEFINE_RELOC(R_AARCH64_MOVW_UABS_G0_NC, 264) \ _ELF_DEFINE_RELOC(R_AARCH64_MOVW_UABS_G1, 265) \ _ELF_DEFINE_RELOC(R_AARCH64_MOVW_UABS_G1_NC, 266) \ _ELF_DEFINE_RELOC(R_AARCH64_MOVW_UABS_G2, 267) \ _ELF_DEFINE_RELOC(R_AARCH64_MOVW_UABS_G2_NC, 268) \ _ELF_DEFINE_RELOC(R_AARCH64_MOVW_UABS_G3, 269) \ _ELF_DEFINE_RELOC(R_AARCH64_MOVW_SABS_G0, 270) \ _ELF_DEFINE_RELOC(R_AARCH64_MOVW_SABS_G1, 271) \ _ELF_DEFINE_RELOC(R_AARCH64_MOVW_SABS_G2, 272) \ _ELF_DEFINE_RELOC(R_AARCH64_LD_PREL_LO19, 273) \ _ELF_DEFINE_RELOC(R_AARCH64_ADR_PREL_LO21, 274) \ _ELF_DEFINE_RELOC(R_AARCH64_ADR_PREL_PG_HI21, 275) \ _ELF_DEFINE_RELOC(R_AARCH64_ADR_PREL_PG_HI21_NC, 276) \ _ELF_DEFINE_RELOC(R_AARCH64_ADD_ABS_LO12_NC, 277) \ _ELF_DEFINE_RELOC(R_AARCH64_LDST8_ABS_LO12_NC, 278) \ _ELF_DEFINE_RELOC(R_AARCH64_TSTBR14, 279) \ _ELF_DEFINE_RELOC(R_AARCH64_CONDBR19, 280) \ _ELF_DEFINE_RELOC(R_AARCH64_JUMP26, 282) \ _ELF_DEFINE_RELOC(R_AARCH64_CALL26, 283) \ _ELF_DEFINE_RELOC(R_AARCH64_LDST16_ABS_LO12_NC, 284) \ _ELF_DEFINE_RELOC(R_AARCH64_LDST32_ABS_LO12_NC, 285) \ _ELF_DEFINE_RELOC(R_AARCH64_LDST64_ABS_LO12_NC, 286) \ _ELF_DEFINE_RELOC(R_AARCH64_MOVW_PREL_G0, 287) \ _ELF_DEFINE_RELOC(R_AARCH64_MOVW_PREL_G0_NC, 288) \ _ELF_DEFINE_RELOC(R_AARCH64_MOVW_PREL_G1, 289) \ _ELF_DEFINE_RELOC(R_AARCH64_MOVW_PREL_G1_NC, 290) \ _ELF_DEFINE_RELOC(R_AARCH64_MOVW_PREL_G2, 291) \ _ELF_DEFINE_RELOC(R_AARCH64_MOVW_PREL_G2_NC, 292) \ _ELF_DEFINE_RELOC(R_AARCH64_MOVW_PREL_G3, 293) \ _ELF_DEFINE_RELOC(R_AARCH64_LDST128_ABS_LO12_NC, 299) \ _ELF_DEFINE_RELOC(R_AARCH64_MOVW_GOTOFF_G0, 300) \ _ELF_DEFINE_RELOC(R_AARCH64_MOVW_GOTOFF_G0_NC, 301) \ _ELF_DEFINE_RELOC(R_AARCH64_MOVW_GOTOFF_G1, 302) \ _ELF_DEFINE_RELOC(R_AARCH64_MOVW_GOTOFF_G1_NC, 303) \ _ELF_DEFINE_RELOC(R_AARCH64_MOVW_GOTOFF_G2, 304) \ _ELF_DEFINE_RELOC(R_AARCH64_MOVW_GOTOFF_G2_NC, 305) \ _ELF_DEFINE_RELOC(R_AARCH64_MOVW_GOTOFF_G3, 306) \ _ELF_DEFINE_RELOC(R_AARCH64_GOTREL64, 307) \ _ELF_DEFINE_RELOC(R_AARCH64_GOTREL32, 308) \ _ELF_DEFINE_RELOC(R_AARCH64_GOT_LD_PREL19, 309) \ _ELF_DEFINE_RELOC(R_AARCH64_LD64_GOTOFF_LO15, 310) \ _ELF_DEFINE_RELOC(R_AARCH64_ADR_GOT_PAGE, 311) \ _ELF_DEFINE_RELOC(R_AARCH64_LD64_GOT_LO12_NC, 312) \ _ELF_DEFINE_RELOC(R_AARCH64_LD64_GOTPAGE_LO15, 313) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSGD_ADR_PREL21, 512) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSGD_ADR_PAGE21, 513) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSGD_ADD_LO12_NC, 514) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSGD_MOVW_G1, 515) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSGD_MOVW_G0_NC, 516) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSLD_ADR_PREL21, 517) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSLD_ADR_PAGE21, 518) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSLD_ADD_LO12_NC, 519) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSLD_MOVW_G1, 520) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSLD_MOVW_G0_NC, 521) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSLD_LD_PREL19, 522) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSLD_MOVW_DTPREL_G2, 523) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSLD_MOVW_DTPREL_G1, 524) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSLD_MOVW_DTPREL_G1_NC, 525) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSLD_MOVW_DTPREL_G0, 526) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSLD_MOVW_DTPREL_G0_NC, 527) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSLD_ADD_DTPREL_HI12, 529) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSLD_ADD_DTPREL_LO12_NC, 530) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSLD_LDST8_DTPREL_LO12, 531) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSLD_LDST8_DTPREL_LO12_NC, 532) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSLD_LDST16_DTPREL_LO12, 533) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSLD_LDST16_DTPREL_LO12_NC, 534) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSLD_LDST32_DTPREL_LO12, 535) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSLD_LDST32_DTPREL_LO12_NC, 536) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSLD_LDST64_DTPREL_LO12, 537) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSLD_LDST64_DTPREL_LO12_NC, 538) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSIE_MOVW_GOTTPREL_G1, 539) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC, 540) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21, 541) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC, 542) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSIE_LD_GOTTPREL_PREL19, 543) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSLE_MOVW_TPREL_G2, 544) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSLE_MOVW_TPREL_G1, 545) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSLE_MOVW_TPREL_G1_NC, 546) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSLE_MOVW_TPREL_G0, 547) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSLE_MOVW_TPREL_G0_NC, 548) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSLE_ADD_TPREL_HI12, 549) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSLE_ADD_TPREL_LO12, 550) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSLE_ADD_TPREL_LO12_NC, 551) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSLE_LDST8_TPREL_LO12, 552) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSLE_LDST8_TPREL_LO12_NC, 553) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSLE_LDST16_TPREL_LO12, 554) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSLE_LDST16_TPREL_LO12_NC, 555) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSLE_LDST32_TPREL_LO12, 556) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSLE_LDST32_TPREL_LO12_NC, 557) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSLE_LDST64_TPREL_LO12, 558) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSLE_LDST64_TPREL_LO12_NC, 559) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSDESC_LD_PREL19, 560) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSDESC_ADR_PREL21, 561) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSDESC_ADR_PAGE21, 562) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSDESC_LD64_LO12, 563) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSDESC_ADD_LO12, 564) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSDESC_OFF_G1, 565) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSDESC_OFF_G0_NC, 566) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSDESC_LDR, 567) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSDESC_ADD, 568) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSDESC_CALL, 569) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSLE_LDST128_TPREL_LO12, 570) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSLE_LDST128_TPREL_LO12_NC, 571) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSLD_LDST128_DTPREL_LO12, 572) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSLD_LDST128_DTPREL_LO12_NC, 573) \ _ELF_DEFINE_RELOC(R_AARCH64_COPY, 1024) \ _ELF_DEFINE_RELOC(R_AARCH64_GLOB_DAT, 1025) \ _ELF_DEFINE_RELOC(R_AARCH64_JUMP_SLOT, 1026) \ _ELF_DEFINE_RELOC(R_AARCH64_RELATIVE, 1027) \ _ELF_DEFINE_RELOC(R_AARCH64_TLS_DTPREL64, 1028) \ _ELF_DEFINE_RELOC(R_AARCH64_TLS_DTPMOD64, 1029) \ _ELF_DEFINE_RELOC(R_AARCH64_TLS_TPREL64, 1030) \ _ELF_DEFINE_RELOC(R_AARCH64_TLSDESC, 1031) \ _ELF_DEFINE_RELOC(R_AARCH64_IRELATIVE, 1032) /* * These are the symbols used in the Sun ``Linkers and Loaders * Guide'', Document No: 817-1984-17. See the X86_64 relocations list * below for the spellings used in the ELF specification. */ #define _ELF_DEFINE_AMD64_RELOCATIONS() \ _ELF_DEFINE_RELOC(R_AMD64_NONE, 0) \ _ELF_DEFINE_RELOC(R_AMD64_64, 1) \ _ELF_DEFINE_RELOC(R_AMD64_PC32, 2) \ _ELF_DEFINE_RELOC(R_AMD64_GOT32, 3) \ _ELF_DEFINE_RELOC(R_AMD64_PLT32, 4) \ _ELF_DEFINE_RELOC(R_AMD64_COPY, 5) \ _ELF_DEFINE_RELOC(R_AMD64_GLOB_DAT, 6) \ _ELF_DEFINE_RELOC(R_AMD64_JUMP_SLOT, 7) \ _ELF_DEFINE_RELOC(R_AMD64_RELATIVE, 8) \ _ELF_DEFINE_RELOC(R_AMD64_GOTPCREL, 9) \ _ELF_DEFINE_RELOC(R_AMD64_32, 10) \ _ELF_DEFINE_RELOC(R_AMD64_32S, 11) \ _ELF_DEFINE_RELOC(R_AMD64_16, 12) \ _ELF_DEFINE_RELOC(R_AMD64_PC16, 13) \ _ELF_DEFINE_RELOC(R_AMD64_8, 14) \ _ELF_DEFINE_RELOC(R_AMD64_PC8, 15) \ _ELF_DEFINE_RELOC(R_AMD64_PC64, 24) \ _ELF_DEFINE_RELOC(R_AMD64_GOTOFF64, 25) \ _ELF_DEFINE_RELOC(R_AMD64_GOTPC32, 26) /* * Relocation definitions from the ARM ELF ABI, version "ARM IHI * 0044E" released on 30th November 2012. */ #define _ELF_DEFINE_ARM_RELOCATIONS() \ _ELF_DEFINE_RELOC(R_ARM_NONE, 0) \ _ELF_DEFINE_RELOC(R_ARM_PC24, 1) \ _ELF_DEFINE_RELOC(R_ARM_ABS32, 2) \ _ELF_DEFINE_RELOC(R_ARM_REL32, 3) \ _ELF_DEFINE_RELOC(R_ARM_LDR_PC_G0, 4) \ _ELF_DEFINE_RELOC(R_ARM_ABS16, 5) \ _ELF_DEFINE_RELOC(R_ARM_ABS12, 6) \ _ELF_DEFINE_RELOC(R_ARM_THM_ABS5, 7) \ _ELF_DEFINE_RELOC(R_ARM_ABS8, 8) \ _ELF_DEFINE_RELOC(R_ARM_SBREL32, 9) \ _ELF_DEFINE_RELOC(R_ARM_THM_CALL, 10) \ _ELF_DEFINE_RELOC(R_ARM_THM_PC8, 11) \ _ELF_DEFINE_RELOC(R_ARM_BREL_ADJ, 12) \ _ELF_DEFINE_RELOC(R_ARM_SWI24, 13) \ _ELF_DEFINE_RELOC(R_ARM_TLS_DESC, 13) \ _ELF_DEFINE_RELOC(R_ARM_THM_SWI8, 14) \ _ELF_DEFINE_RELOC(R_ARM_XPC25, 15) \ _ELF_DEFINE_RELOC(R_ARM_THM_XPC22, 16) \ _ELF_DEFINE_RELOC(R_ARM_TLS_DTPMOD32, 17) \ _ELF_DEFINE_RELOC(R_ARM_TLS_DTPOFF32, 18) \ _ELF_DEFINE_RELOC(R_ARM_TLS_TPOFF32, 19) \ _ELF_DEFINE_RELOC(R_ARM_COPY, 20) \ _ELF_DEFINE_RELOC(R_ARM_GLOB_DAT, 21) \ _ELF_DEFINE_RELOC(R_ARM_JUMP_SLOT, 22) \ _ELF_DEFINE_RELOC(R_ARM_RELATIVE, 23) \ _ELF_DEFINE_RELOC(R_ARM_GOTOFF32, 24) \ _ELF_DEFINE_RELOC(R_ARM_BASE_PREL, 25) \ _ELF_DEFINE_RELOC(R_ARM_GOT_BREL, 26) \ _ELF_DEFINE_RELOC(R_ARM_PLT32, 27) \ _ELF_DEFINE_RELOC(R_ARM_CALL, 28) \ _ELF_DEFINE_RELOC(R_ARM_JUMP24, 29) \ _ELF_DEFINE_RELOC(R_ARM_THM_JUMP24, 30) \ _ELF_DEFINE_RELOC(R_ARM_BASE_ABS, 31) \ _ELF_DEFINE_RELOC(R_ARM_ALU_PCREL_7_0, 32) \ _ELF_DEFINE_RELOC(R_ARM_ALU_PCREL_15_8, 33) \ _ELF_DEFINE_RELOC(R_ARM_ALU_PCREL_23_15, 34) \ _ELF_DEFINE_RELOC(R_ARM_LDR_SBREL_11_0_NC, 35) \ _ELF_DEFINE_RELOC(R_ARM_ALU_SBREL_19_12_NC, 36) \ _ELF_DEFINE_RELOC(R_ARM_ALU_SBREL_27_20_CK, 37) \ _ELF_DEFINE_RELOC(R_ARM_TARGET1, 38) \ _ELF_DEFINE_RELOC(R_ARM_SBREL31, 39) \ _ELF_DEFINE_RELOC(R_ARM_V4BX, 40) \ _ELF_DEFINE_RELOC(R_ARM_TARGET2, 41) \ _ELF_DEFINE_RELOC(R_ARM_PREL31, 42) \ _ELF_DEFINE_RELOC(R_ARM_MOVW_ABS_NC, 43) \ _ELF_DEFINE_RELOC(R_ARM_MOVT_ABS, 44) \ _ELF_DEFINE_RELOC(R_ARM_MOVW_PREL_NC, 45) \ _ELF_DEFINE_RELOC(R_ARM_MOVT_PREL, 46) \ _ELF_DEFINE_RELOC(R_ARM_THM_MOVW_ABS_NC, 47) \ _ELF_DEFINE_RELOC(R_ARM_THM_MOVT_ABS, 48) \ _ELF_DEFINE_RELOC(R_ARM_THM_MOVW_PREL_NC, 49) \ _ELF_DEFINE_RELOC(R_ARM_THM_MOVT_PREL, 50) \ _ELF_DEFINE_RELOC(R_ARM_THM_JUMP19, 51) \ _ELF_DEFINE_RELOC(R_ARM_THM_JUMP6, 52) \ _ELF_DEFINE_RELOC(R_ARM_THM_ALU_PREL_11_0, 53) \ _ELF_DEFINE_RELOC(R_ARM_THM_PC12, 54) \ _ELF_DEFINE_RELOC(R_ARM_ABS32_NOI, 55) \ _ELF_DEFINE_RELOC(R_ARM_REL32_NOI, 56) \ _ELF_DEFINE_RELOC(R_ARM_ALU_PC_G0_NC, 57) \ _ELF_DEFINE_RELOC(R_ARM_ALU_PC_G0, 58) \ _ELF_DEFINE_RELOC(R_ARM_ALU_PC_G1_NC, 59) \ _ELF_DEFINE_RELOC(R_ARM_ALU_PC_G1, 60) \ _ELF_DEFINE_RELOC(R_ARM_ALU_PC_G2, 61) \ _ELF_DEFINE_RELOC(R_ARM_LDR_PC_G1, 62) \ _ELF_DEFINE_RELOC(R_ARM_LDR_PC_G2, 63) \ _ELF_DEFINE_RELOC(R_ARM_LDRS_PC_G0, 64) \ _ELF_DEFINE_RELOC(R_ARM_LDRS_PC_G1, 65) \ _ELF_DEFINE_RELOC(R_ARM_LDRS_PC_G2, 66) \ _ELF_DEFINE_RELOC(R_ARM_LDC_PC_G0, 67) \ _ELF_DEFINE_RELOC(R_ARM_LDC_PC_G1, 68) \ _ELF_DEFINE_RELOC(R_ARM_LDC_PC_G2, 69) \ _ELF_DEFINE_RELOC(R_ARM_ALU_SB_G0_NC, 70) \ _ELF_DEFINE_RELOC(R_ARM_ALU_SB_G0, 71) \ _ELF_DEFINE_RELOC(R_ARM_ALU_SB_G1_NC, 72) \ _ELF_DEFINE_RELOC(R_ARM_ALU_SB_G1, 73) \ _ELF_DEFINE_RELOC(R_ARM_ALU_SB_G2, 74) \ _ELF_DEFINE_RELOC(R_ARM_LDR_SB_G0, 75) \ _ELF_DEFINE_RELOC(R_ARM_LDR_SB_G1, 76) \ _ELF_DEFINE_RELOC(R_ARM_LDR_SB_G2, 77) \ _ELF_DEFINE_RELOC(R_ARM_LDRS_SB_G0, 78) \ _ELF_DEFINE_RELOC(R_ARM_LDRS_SB_G1, 79) \ _ELF_DEFINE_RELOC(R_ARM_LDRS_SB_G2, 80) \ _ELF_DEFINE_RELOC(R_ARM_LDC_SB_G0, 81) \ _ELF_DEFINE_RELOC(R_ARM_LDC_SB_G1, 82) \ _ELF_DEFINE_RELOC(R_ARM_LDC_SB_G2, 83) \ _ELF_DEFINE_RELOC(R_ARM_MOVW_BREL_NC, 84) \ _ELF_DEFINE_RELOC(R_ARM_MOVT_BREL, 85) \ _ELF_DEFINE_RELOC(R_ARM_MOVW_BREL, 86) \ _ELF_DEFINE_RELOC(R_ARM_THM_MOVW_BREL_NC, 87) \ _ELF_DEFINE_RELOC(R_ARM_THM_MOVT_BREL, 88) \ _ELF_DEFINE_RELOC(R_ARM_THM_MOVW_BREL, 89) \ _ELF_DEFINE_RELOC(R_ARM_TLS_GOTDESC, 90) \ _ELF_DEFINE_RELOC(R_ARM_TLS_CALL, 91) \ _ELF_DEFINE_RELOC(R_ARM_TLS_DESCSEQ, 92) \ _ELF_DEFINE_RELOC(R_ARM_THM_TLS_CALL, 93) \ _ELF_DEFINE_RELOC(R_ARM_PLT32_ABS, 94) \ _ELF_DEFINE_RELOC(R_ARM_GOT_ABS, 95) \ _ELF_DEFINE_RELOC(R_ARM_GOT_PREL, 96) \ _ELF_DEFINE_RELOC(R_ARM_GOT_BREL12, 97) \ _ELF_DEFINE_RELOC(R_ARM_GOTOFF12, 98) \ _ELF_DEFINE_RELOC(R_ARM_GOTRELAX, 99) \ _ELF_DEFINE_RELOC(R_ARM_GNU_VTENTRY, 100) \ _ELF_DEFINE_RELOC(R_ARM_GNU_VTINHERIT, 101) \ _ELF_DEFINE_RELOC(R_ARM_THM_JUMP11, 102) \ _ELF_DEFINE_RELOC(R_ARM_THM_JUMP8, 103) \ _ELF_DEFINE_RELOC(R_ARM_TLS_GD32, 104) \ _ELF_DEFINE_RELOC(R_ARM_TLS_LDM32, 105) \ _ELF_DEFINE_RELOC(R_ARM_TLS_LDO32, 106) \ _ELF_DEFINE_RELOC(R_ARM_TLS_IE32, 107) \ _ELF_DEFINE_RELOC(R_ARM_TLS_LE32, 108) \ _ELF_DEFINE_RELOC(R_ARM_TLS_LDO12, 109) \ _ELF_DEFINE_RELOC(R_ARM_TLS_LE12, 110) \ _ELF_DEFINE_RELOC(R_ARM_TLS_IE12GP, 111) \ _ELF_DEFINE_RELOC(R_ARM_PRIVATE_0, 112) \ _ELF_DEFINE_RELOC(R_ARM_PRIVATE_1, 113) \ _ELF_DEFINE_RELOC(R_ARM_PRIVATE_2, 114) \ _ELF_DEFINE_RELOC(R_ARM_PRIVATE_3, 115) \ _ELF_DEFINE_RELOC(R_ARM_PRIVATE_4, 116) \ _ELF_DEFINE_RELOC(R_ARM_PRIVATE_5, 117) \ _ELF_DEFINE_RELOC(R_ARM_PRIVATE_6, 118) \ _ELF_DEFINE_RELOC(R_ARM_PRIVATE_7, 119) \ _ELF_DEFINE_RELOC(R_ARM_PRIVATE_8, 120) \ _ELF_DEFINE_RELOC(R_ARM_PRIVATE_9, 121) \ _ELF_DEFINE_RELOC(R_ARM_PRIVATE_10, 122) \ _ELF_DEFINE_RELOC(R_ARM_PRIVATE_11, 123) \ _ELF_DEFINE_RELOC(R_ARM_PRIVATE_12, 124) \ _ELF_DEFINE_RELOC(R_ARM_PRIVATE_13, 125) \ _ELF_DEFINE_RELOC(R_ARM_PRIVATE_14, 126) \ _ELF_DEFINE_RELOC(R_ARM_PRIVATE_15, 127) \ _ELF_DEFINE_RELOC(R_ARM_ME_TOO, 128) \ _ELF_DEFINE_RELOC(R_ARM_THM_TLS_DESCSEQ16, 129) \ _ELF_DEFINE_RELOC(R_ARM_THM_TLS_DESCSEQ32, 130) \ _ELF_DEFINE_RELOC(R_ARM_THM_GOT_BREL12, 131) \ _ELF_DEFINE_RELOC(R_ARM_IRELATIVE, 140) #define _ELF_DEFINE_IA64_RELOCATIONS() \ _ELF_DEFINE_RELOC(R_IA_64_NONE, 0) \ _ELF_DEFINE_RELOC(R_IA_64_IMM14, 0x21) \ _ELF_DEFINE_RELOC(R_IA_64_IMM22, 0x22) \ _ELF_DEFINE_RELOC(R_IA_64_IMM64, 0x23) \ _ELF_DEFINE_RELOC(R_IA_64_DIR32MSB, 0x24) \ _ELF_DEFINE_RELOC(R_IA_64_DIR32LSB, 0x25) \ _ELF_DEFINE_RELOC(R_IA_64_DIR64MSB, 0x26) \ _ELF_DEFINE_RELOC(R_IA_64_DIR64LSB, 0x27) \ _ELF_DEFINE_RELOC(R_IA_64_GPREL22, 0x2a) \ _ELF_DEFINE_RELOC(R_IA_64_GPREL64I, 0x2b) \ _ELF_DEFINE_RELOC(R_IA_64_GPREL32MSB, 0x2c) \ _ELF_DEFINE_RELOC(R_IA_64_GPREL32LSB, 0x2d) \ _ELF_DEFINE_RELOC(R_IA_64_GPREL64MSB, 0x2e) \ _ELF_DEFINE_RELOC(R_IA_64_GPREL64LSB, 0x2f) \ _ELF_DEFINE_RELOC(R_IA_64_LTOFF22, 0x32) \ _ELF_DEFINE_RELOC(R_IA_64_LTOFF64I, 0x33) \ _ELF_DEFINE_RELOC(R_IA_64_PLTOFF22, 0x3a) \ _ELF_DEFINE_RELOC(R_IA_64_PLTOFF64I, 0x3b) \ _ELF_DEFINE_RELOC(R_IA_64_PLTOFF64MSB, 0x3e) \ _ELF_DEFINE_RELOC(R_IA_64_PLTOFF64LSB, 0x3f) \ _ELF_DEFINE_RELOC(R_IA_64_FPTR64I, 0x43) \ _ELF_DEFINE_RELOC(R_IA_64_FPTR32MSB, 0x44) \ _ELF_DEFINE_RELOC(R_IA_64_FPTR32LSB, 0x45) \ _ELF_DEFINE_RELOC(R_IA_64_FPTR64MSB, 0x46) \ _ELF_DEFINE_RELOC(R_IA_64_FPTR64LSB, 0x47) \ _ELF_DEFINE_RELOC(R_IA_64_PCREL60B, 0x48) \ _ELF_DEFINE_RELOC(R_IA_64_PCREL21B, 0x49) \ _ELF_DEFINE_RELOC(R_IA_64_PCREL21M, 0x4a) \ _ELF_DEFINE_RELOC(R_IA_64_PCREL21F, 0x4b) \ _ELF_DEFINE_RELOC(R_IA_64_PCREL32MSB, 0x4c) \ _ELF_DEFINE_RELOC(R_IA_64_PCREL32LSB, 0x4d) \ _ELF_DEFINE_RELOC(R_IA_64_PCREL64MSB, 0x4e) \ _ELF_DEFINE_RELOC(R_IA_64_PCREL64LSB, 0x4f) \ _ELF_DEFINE_RELOC(R_IA_64_LTOFF_FPTR22, 0x52) \ _ELF_DEFINE_RELOC(R_IA_64_LTOFF_FPTR64I, 0x53) \ _ELF_DEFINE_RELOC(R_IA_64_LTOFF_FPTR32MSB, 0x54) \ _ELF_DEFINE_RELOC(R_IA_64_LTOFF_FPTR32LSB, 0x55) \ _ELF_DEFINE_RELOC(R_IA_64_LTOFF_FPTR64MSB, 0x56) \ _ELF_DEFINE_RELOC(R_IA_64_LTOFF_FPTR64LSB, 0x57) \ _ELF_DEFINE_RELOC(R_IA_64_SEGREL32MSB, 0x5c) \ _ELF_DEFINE_RELOC(R_IA_64_SEGREL32LSB, 0x5d) \ _ELF_DEFINE_RELOC(R_IA_64_SEGREL64MSB, 0x5e) \ _ELF_DEFINE_RELOC(R_IA_64_SEGREL64LSB, 0x5f) \ _ELF_DEFINE_RELOC(R_IA_64_SECREL32MSB, 0x64) \ _ELF_DEFINE_RELOC(R_IA_64_SECREL32LSB, 0x65) \ _ELF_DEFINE_RELOC(R_IA_64_SECREL64MSB, 0x66) \ _ELF_DEFINE_RELOC(R_IA_64_SECREL64LSB, 0x67) \ _ELF_DEFINE_RELOC(R_IA_64_REL32MSB, 0x6c) \ _ELF_DEFINE_RELOC(R_IA_64_REL32LSB, 0x6d) \ _ELF_DEFINE_RELOC(R_IA_64_REL64MSB, 0x6e) \ _ELF_DEFINE_RELOC(R_IA_64_REL64LSB, 0x6f) \ _ELF_DEFINE_RELOC(R_IA_64_LTV32MSB, 0x74) \ _ELF_DEFINE_RELOC(R_IA_64_LTV32LSB, 0x75) \ _ELF_DEFINE_RELOC(R_IA_64_LTV64MSB, 0x76) \ _ELF_DEFINE_RELOC(R_IA_64_LTV64LSB, 0x77) \ _ELF_DEFINE_RELOC(R_IA_64_PCREL21BI, 0x79) \ _ELF_DEFINE_RELOC(R_IA_64_PCREL22, 0x7A) \ _ELF_DEFINE_RELOC(R_IA_64_PCREL64I, 0x7B) \ _ELF_DEFINE_RELOC(R_IA_64_IPLTMSB, 0x80) \ _ELF_DEFINE_RELOC(R_IA_64_IPLTLSB, 0x81) \ _ELF_DEFINE_RELOC(R_IA_64_SUB, 0x85) \ _ELF_DEFINE_RELOC(R_IA_64_LTOFF22X, 0x86) \ _ELF_DEFINE_RELOC(R_IA_64_LDXMOV, 0x87) \ _ELF_DEFINE_RELOC(R_IA_64_TPREL14, 0x91) \ _ELF_DEFINE_RELOC(R_IA_64_TPREL22, 0x92) \ _ELF_DEFINE_RELOC(R_IA_64_TPREL64I, 0x93) \ _ELF_DEFINE_RELOC(R_IA_64_TPREL64MSB, 0x96) \ _ELF_DEFINE_RELOC(R_IA_64_TPREL64LSB, 0x97) \ _ELF_DEFINE_RELOC(R_IA_64_LTOFF_TPREL22, 0x9A) \ _ELF_DEFINE_RELOC(R_IA_64_DTPMOD64MSB, 0xA6) \ _ELF_DEFINE_RELOC(R_IA_64_DTPMOD64LSB, 0xA7) \ _ELF_DEFINE_RELOC(R_IA_64_LTOFF_DTPMOD22, 0xAA) \ _ELF_DEFINE_RELOC(R_IA_64_DTPREL14, 0xB1) \ _ELF_DEFINE_RELOC(R_IA_64_DTPREL22, 0xB2) \ _ELF_DEFINE_RELOC(R_IA_64_DTPREL64I, 0xB3) \ _ELF_DEFINE_RELOC(R_IA_64_DTPREL32MSB, 0xB4) \ _ELF_DEFINE_RELOC(R_IA_64_DTPREL32LSB, 0xB5) \ _ELF_DEFINE_RELOC(R_IA_64_DTPREL64MSB, 0xB6) \ _ELF_DEFINE_RELOC(R_IA_64_DTPREL64LSB, 0xB7) \ _ELF_DEFINE_RELOC(R_IA_64_LTOFF_DTPREL22, 0xBA) #define _ELF_DEFINE_MIPS_RELOCATIONS() \ _ELF_DEFINE_RELOC(R_MIPS_NONE, 0) \ _ELF_DEFINE_RELOC(R_MIPS_16, 1) \ _ELF_DEFINE_RELOC(R_MIPS_32, 2) \ _ELF_DEFINE_RELOC(R_MIPS_REL32, 3) \ _ELF_DEFINE_RELOC(R_MIPS_26, 4) \ _ELF_DEFINE_RELOC(R_MIPS_HI16, 5) \ _ELF_DEFINE_RELOC(R_MIPS_LO16, 6) \ _ELF_DEFINE_RELOC(R_MIPS_GPREL16, 7) \ _ELF_DEFINE_RELOC(R_MIPS_LITERAL, 8) \ _ELF_DEFINE_RELOC(R_MIPS_GOT16, 9) \ _ELF_DEFINE_RELOC(R_MIPS_PC16, 10) \ _ELF_DEFINE_RELOC(R_MIPS_CALL16, 11) \ _ELF_DEFINE_RELOC(R_MIPS_GPREL32, 12) \ +_ELF_DEFINE_RELOC(R_MIPS_SHIFT5, 16) \ +_ELF_DEFINE_RELOC(R_MIPS_SHIFT6, 17) \ _ELF_DEFINE_RELOC(R_MIPS_64, 18) \ -_ELF_DEFINE_RELOC(R_MIPS_GOTHI16, 21) \ -_ELF_DEFINE_RELOC(R_MIPS_GOTLO16, 22) \ +_ELF_DEFINE_RELOC(R_MIPS_GOT_DISP, 19) \ +_ELF_DEFINE_RELOC(R_MIPS_GOT_PAGE, 20) \ +_ELF_DEFINE_RELOC(R_MIPS_GOT_OFST, 21) \ +_ELF_DEFINE_RELOC(R_MIPS_GOT_HI16, 22) \ +_ELF_DEFINE_RELOC(R_MIPS_GOT_LO16, 23) \ +_ELF_DEFINE_RELOC(R_MIPS_SUB, 24) \ _ELF_DEFINE_RELOC(R_MIPS_CALLHI16, 30) \ _ELF_DEFINE_RELOC(R_MIPS_CALLLO16, 31) \ +_ELF_DEFINE_RELOC(R_MIPS_JALR, 37) \ _ELF_DEFINE_RELOC(R_MIPS_TLS_DTPMOD32, 38) \ _ELF_DEFINE_RELOC(R_MIPS_TLS_DTPREL32, 39) \ _ELF_DEFINE_RELOC(R_MIPS_TLS_DTPMOD64, 40) \ _ELF_DEFINE_RELOC(R_MIPS_TLS_DTPREL64, 41) \ _ELF_DEFINE_RELOC(R_MIPS_TLS_GD, 42) \ _ELF_DEFINE_RELOC(R_MIPS_TLS_LDM, 43) \ _ELF_DEFINE_RELOC(R_MIPS_TLS_DTPREL_HI16, 44) \ _ELF_DEFINE_RELOC(R_MIPS_TLS_DTPREL_LO16, 45) \ _ELF_DEFINE_RELOC(R_MIPS_TLS_GOTTPREL, 46) \ _ELF_DEFINE_RELOC(R_MIPS_TLS_TPREL32, 47) \ _ELF_DEFINE_RELOC(R_MIPS_TLS_TPREL64, 48) \ _ELF_DEFINE_RELOC(R_MIPS_TLS_TPREL_HI16, 49) \ _ELF_DEFINE_RELOC(R_MIPS_TLS_TPREL_LO16, 50) #define _ELF_DEFINE_PPC32_RELOCATIONS() \ _ELF_DEFINE_RELOC(R_PPC_NONE, 0) \ _ELF_DEFINE_RELOC(R_PPC_ADDR32, 1) \ _ELF_DEFINE_RELOC(R_PPC_ADDR24, 2) \ _ELF_DEFINE_RELOC(R_PPC_ADDR16, 3) \ _ELF_DEFINE_RELOC(R_PPC_ADDR16_LO, 4) \ _ELF_DEFINE_RELOC(R_PPC_ADDR16_HI, 5) \ _ELF_DEFINE_RELOC(R_PPC_ADDR16_HA, 6) \ _ELF_DEFINE_RELOC(R_PPC_ADDR14, 7) \ _ELF_DEFINE_RELOC(R_PPC_ADDR14_BRTAKEN, 8) \ _ELF_DEFINE_RELOC(R_PPC_ADDR14_BRNTAKEN, 9) \ _ELF_DEFINE_RELOC(R_PPC_REL24, 10) \ _ELF_DEFINE_RELOC(R_PPC_REL14, 11) \ _ELF_DEFINE_RELOC(R_PPC_REL14_BRTAKEN, 12) \ _ELF_DEFINE_RELOC(R_PPC_REL14_BRNTAKEN, 13) \ _ELF_DEFINE_RELOC(R_PPC_GOT16, 14) \ _ELF_DEFINE_RELOC(R_PPC_GOT16_LO, 15) \ _ELF_DEFINE_RELOC(R_PPC_GOT16_HI, 16) \ _ELF_DEFINE_RELOC(R_PPC_GOT16_HA, 17) \ _ELF_DEFINE_RELOC(R_PPC_PLTREL24, 18) \ _ELF_DEFINE_RELOC(R_PPC_COPY, 19) \ _ELF_DEFINE_RELOC(R_PPC_GLOB_DAT, 20) \ _ELF_DEFINE_RELOC(R_PPC_JMP_SLOT, 21) \ _ELF_DEFINE_RELOC(R_PPC_RELATIVE, 22) \ _ELF_DEFINE_RELOC(R_PPC_LOCAL24PC, 23) \ _ELF_DEFINE_RELOC(R_PPC_UADDR32, 24) \ _ELF_DEFINE_RELOC(R_PPC_UADDR16, 25) \ _ELF_DEFINE_RELOC(R_PPC_REL32, 26) \ _ELF_DEFINE_RELOC(R_PPC_PLT32, 27) \ _ELF_DEFINE_RELOC(R_PPC_PLTREL32, 28) \ _ELF_DEFINE_RELOC(R_PPC_PLT16_LO, 29) \ _ELF_DEFINE_RELOC(R_PPC_PLT16_HI, 30) \ _ELF_DEFINE_RELOC(R_PPC_PLT16_HA, 31) \ _ELF_DEFINE_RELOC(R_PPC_SDAREL16, 32) \ _ELF_DEFINE_RELOC(R_PPC_SECTOFF, 33) \ _ELF_DEFINE_RELOC(R_PPC_SECTOFF_LO, 34) \ _ELF_DEFINE_RELOC(R_PPC_SECTOFF_HI, 35) \ _ELF_DEFINE_RELOC(R_PPC_SECTOFF_HA, 36) \ _ELF_DEFINE_RELOC(R_PPC_ADDR30, 37) \ _ELF_DEFINE_RELOC(R_PPC_TLS, 67) \ _ELF_DEFINE_RELOC(R_PPC_DTPMOD32, 68) \ _ELF_DEFINE_RELOC(R_PPC_TPREL16, 69) \ _ELF_DEFINE_RELOC(R_PPC_TPREL16_LO, 70) \ _ELF_DEFINE_RELOC(R_PPC_TPREL16_HI, 71) \ _ELF_DEFINE_RELOC(R_PPC_TPREL16_HA, 72) \ _ELF_DEFINE_RELOC(R_PPC_TPREL32, 73) \ _ELF_DEFINE_RELOC(R_PPC_DTPREL16, 74) \ _ELF_DEFINE_RELOC(R_PPC_DTPREL16_LO, 75) \ _ELF_DEFINE_RELOC(R_PPC_DTPREL16_HI, 76) \ _ELF_DEFINE_RELOC(R_PPC_DTPREL16_HA, 77) \ _ELF_DEFINE_RELOC(R_PPC_DTPREL32, 78) \ _ELF_DEFINE_RELOC(R_PPC_GOT_TLSGD16, 79) \ _ELF_DEFINE_RELOC(R_PPC_GOT_TLSGD16_LO, 80) \ _ELF_DEFINE_RELOC(R_PPC_GOT_TLSGD16_HI, 81) \ _ELF_DEFINE_RELOC(R_PPC_GOT_TLSGD16_HA, 82) \ _ELF_DEFINE_RELOC(R_PPC_GOT_TLSLD16, 83) \ _ELF_DEFINE_RELOC(R_PPC_GOT_TLSLD16_LO, 84) \ _ELF_DEFINE_RELOC(R_PPC_GOT_TLSLD16_HI, 85) \ _ELF_DEFINE_RELOC(R_PPC_GOT_TLSLD16_HA, 86) \ _ELF_DEFINE_RELOC(R_PPC_GOT_TPREL16, 87) \ _ELF_DEFINE_RELOC(R_PPC_GOT_TPREL16_LO, 88) \ _ELF_DEFINE_RELOC(R_PPC_GOT_TPREL16_HI, 89) \ _ELF_DEFINE_RELOC(R_PPC_GOT_TPREL16_HA, 90) \ _ELF_DEFINE_RELOC(R_PPC_GOT_DTPREL16, 91) \ _ELF_DEFINE_RELOC(R_PPC_GOT_DTPREL16_LO, 92) \ _ELF_DEFINE_RELOC(R_PPC_GOT_DTPREL16_HI, 93) \ _ELF_DEFINE_RELOC(R_PPC_GOT_DTPREL16_HA, 94) \ _ELF_DEFINE_RELOC(R_PPC_TLSGD, 95) \ _ELF_DEFINE_RELOC(R_PPC_TLSLD, 96) \ _ELF_DEFINE_RELOC(R_PPC_EMB_NADDR32, 101) \ _ELF_DEFINE_RELOC(R_PPC_EMB_NADDR16, 102) \ _ELF_DEFINE_RELOC(R_PPC_EMB_NADDR16_LO, 103) \ _ELF_DEFINE_RELOC(R_PPC_EMB_NADDR16_HI, 104) \ _ELF_DEFINE_RELOC(R_PPC_EMB_NADDR16_HA, 105) \ _ELF_DEFINE_RELOC(R_PPC_EMB_SDAI16, 106) \ _ELF_DEFINE_RELOC(R_PPC_EMB_SDA2I16, 107) \ _ELF_DEFINE_RELOC(R_PPC_EMB_SDA2REL, 108) \ _ELF_DEFINE_RELOC(R_PPC_EMB_SDA21, 109) \ _ELF_DEFINE_RELOC(R_PPC_EMB_MRKREF, 110) \ _ELF_DEFINE_RELOC(R_PPC_EMB_RELSEC16, 111) \ _ELF_DEFINE_RELOC(R_PPC_EMB_RELST_LO, 112) \ _ELF_DEFINE_RELOC(R_PPC_EMB_RELST_HI, 113) \ _ELF_DEFINE_RELOC(R_PPC_EMB_RELST_HA, 114) \ _ELF_DEFINE_RELOC(R_PPC_EMB_BIT_FLD, 115) \ _ELF_DEFINE_RELOC(R_PPC_EMB_RELSDA, 116) \ #define _ELF_DEFINE_PPC64_RELOCATIONS() \ _ELF_DEFINE_RELOC(R_PPC64_NONE, 0) \ _ELF_DEFINE_RELOC(R_PPC64_ADDR32, 1) \ _ELF_DEFINE_RELOC(R_PPC64_ADDR24, 2) \ _ELF_DEFINE_RELOC(R_PPC64_ADDR16, 3) \ _ELF_DEFINE_RELOC(R_PPC64_ADDR16_LO, 4) \ _ELF_DEFINE_RELOC(R_PPC64_ADDR16_HI, 5) \ _ELF_DEFINE_RELOC(R_PPC64_ADDR16_HA, 6) \ _ELF_DEFINE_RELOC(R_PPC64_ADDR14, 7) \ _ELF_DEFINE_RELOC(R_PPC64_ADDR14_BRTAKEN, 8) \ _ELF_DEFINE_RELOC(R_PPC64_ADDR14_BRNTAKEN, 9) \ _ELF_DEFINE_RELOC(R_PPC64_REL24, 10) \ _ELF_DEFINE_RELOC(R_PPC64_REL14, 11) \ _ELF_DEFINE_RELOC(R_PPC64_REL14_BRTAKEN, 12) \ _ELF_DEFINE_RELOC(R_PPC64_REL14_BRNTAKEN, 13) \ _ELF_DEFINE_RELOC(R_PPC64_GOT16, 14) \ _ELF_DEFINE_RELOC(R_PPC64_GOT16_LO, 15) \ _ELF_DEFINE_RELOC(R_PPC64_GOT16_HI, 16) \ _ELF_DEFINE_RELOC(R_PPC64_GOT16_HA, 17) \ _ELF_DEFINE_RELOC(R_PPC64_COPY, 19) \ _ELF_DEFINE_RELOC(R_PPC64_GLOB_DAT, 20) \ _ELF_DEFINE_RELOC(R_PPC64_JMP_SLOT, 21) \ _ELF_DEFINE_RELOC(R_PPC64_RELATIVE, 22) \ _ELF_DEFINE_RELOC(R_PPC64_UADDR32, 24) \ _ELF_DEFINE_RELOC(R_PPC64_UADDR16, 25) \ _ELF_DEFINE_RELOC(R_PPC64_REL32, 26) \ _ELF_DEFINE_RELOC(R_PPC64_PLT32, 27) \ _ELF_DEFINE_RELOC(R_PPC64_PLTREL32, 28) \ _ELF_DEFINE_RELOC(R_PPC64_PLT16_LO, 29) \ _ELF_DEFINE_RELOC(R_PPC64_PLT16_HI, 30) \ _ELF_DEFINE_RELOC(R_PPC64_PLT16_HA, 31) \ _ELF_DEFINE_RELOC(R_PPC64_SECTOFF, 33) \ _ELF_DEFINE_RELOC(R_PPC64_SECTOFF_LO, 34) \ _ELF_DEFINE_RELOC(R_PPC64_SECTOFF_HI, 35) \ _ELF_DEFINE_RELOC(R_PPC64_SECTOFF_HA, 36) \ _ELF_DEFINE_RELOC(R_PPC64_ADDR30, 37) \ _ELF_DEFINE_RELOC(R_PPC64_ADDR64, 38) \ _ELF_DEFINE_RELOC(R_PPC64_ADDR16_HIGHER, 39) \ _ELF_DEFINE_RELOC(R_PPC64_ADDR16_HIGHERA, 40) \ _ELF_DEFINE_RELOC(R_PPC64_ADDR16_HIGHEST, 41) \ _ELF_DEFINE_RELOC(R_PPC64_ADDR16_HIGHESTA, 42) \ _ELF_DEFINE_RELOC(R_PPC64_UADDR64, 43) \ _ELF_DEFINE_RELOC(R_PPC64_REL64, 44) \ _ELF_DEFINE_RELOC(R_PPC64_PLT64, 45) \ _ELF_DEFINE_RELOC(R_PPC64_PLTREL64, 46) \ _ELF_DEFINE_RELOC(R_PPC64_TOC16, 47) \ _ELF_DEFINE_RELOC(R_PPC64_TOC16_LO, 48) \ _ELF_DEFINE_RELOC(R_PPC64_TOC16_HI, 49) \ _ELF_DEFINE_RELOC(R_PPC64_TOC16_HA, 50) \ _ELF_DEFINE_RELOC(R_PPC64_TOC, 51) \ _ELF_DEFINE_RELOC(R_PPC64_PLTGOT16, 52) \ _ELF_DEFINE_RELOC(R_PPC64_PLTGOT16_LO, 53) \ _ELF_DEFINE_RELOC(R_PPC64_PLTGOT16_HI, 54) \ _ELF_DEFINE_RELOC(R_PPC64_PLTGOT16_HA, 55) \ _ELF_DEFINE_RELOC(R_PPC64_ADDR16_DS, 56) \ _ELF_DEFINE_RELOC(R_PPC64_ADDR16_LO_DS, 57) \ _ELF_DEFINE_RELOC(R_PPC64_GOT16_DS, 58) \ _ELF_DEFINE_RELOC(R_PPC64_GOT16_LO_DS, 59) \ _ELF_DEFINE_RELOC(R_PPC64_PLT16_LO_DS, 60) \ _ELF_DEFINE_RELOC(R_PPC64_SECTOFF_DS, 61) \ _ELF_DEFINE_RELOC(R_PPC64_SECTOFF_LO_DS, 62) \ _ELF_DEFINE_RELOC(R_PPC64_TOC16_DS, 63) \ _ELF_DEFINE_RELOC(R_PPC64_TOC16_LO_DS, 64) \ _ELF_DEFINE_RELOC(R_PPC64_PLTGOT16_DS, 65) \ _ELF_DEFINE_RELOC(R_PPC64_PLTGOT16_LO_DS, 66) \ _ELF_DEFINE_RELOC(R_PPC64_TLS, 67) \ _ELF_DEFINE_RELOC(R_PPC64_DTPMOD64, 68) \ _ELF_DEFINE_RELOC(R_PPC64_TPREL16, 69) \ _ELF_DEFINE_RELOC(R_PPC64_TPREL16_LO, 60) \ _ELF_DEFINE_RELOC(R_PPC64_TPREL16_HI, 71) \ _ELF_DEFINE_RELOC(R_PPC64_TPREL16_HA, 72) \ _ELF_DEFINE_RELOC(R_PPC64_TPREL64, 73) \ _ELF_DEFINE_RELOC(R_PPC64_DTPREL16, 74) \ _ELF_DEFINE_RELOC(R_PPC64_DTPREL16_LO, 75) \ _ELF_DEFINE_RELOC(R_PPC64_DTPREL16_HI, 76) \ _ELF_DEFINE_RELOC(R_PPC64_DTPREL16_HA, 77) \ _ELF_DEFINE_RELOC(R_PPC64_DTPREL64, 78) \ _ELF_DEFINE_RELOC(R_PPC64_GOT_TLSGD16, 79) \ _ELF_DEFINE_RELOC(R_PPC64_GOT_TLSGD16_LO, 80) \ _ELF_DEFINE_RELOC(R_PPC64_GOT_TLSGD16_HI, 81) \ _ELF_DEFINE_RELOC(R_PPC64_GOT_TLSGD16_HA, 82) \ _ELF_DEFINE_RELOC(R_PPC64_GOT_TLSLD16, 83) \ _ELF_DEFINE_RELOC(R_PPC64_GOT_TLSLD16_LO, 84) \ _ELF_DEFINE_RELOC(R_PPC64_GOT_TLSLD16_HI, 85) \ _ELF_DEFINE_RELOC(R_PPC64_GOT_TLSLD16_HA, 86) \ _ELF_DEFINE_RELOC(R_PPC64_GOT_TPREL16_DS, 87) \ _ELF_DEFINE_RELOC(R_PPC64_GOT_TPREL16_LO_DS, 88) \ _ELF_DEFINE_RELOC(R_PPC64_GOT_TPREL16_HI, 89) \ _ELF_DEFINE_RELOC(R_PPC64_GOT_TPREL16_HA, 90) \ _ELF_DEFINE_RELOC(R_PPC64_GOT_DTPREL16_DS, 91) \ _ELF_DEFINE_RELOC(R_PPC64_GOT_DTPREL16_LO_DS, 92) \ _ELF_DEFINE_RELOC(R_PPC64_GOT_DTPREL16_HI, 93) \ _ELF_DEFINE_RELOC(R_PPC64_GOT_DTPREL16_HA, 94) \ _ELF_DEFINE_RELOC(R_PPC64_TPREL16_DS, 95) \ _ELF_DEFINE_RELOC(R_PPC64_TPREL16_LO_DS, 96) \ _ELF_DEFINE_RELOC(R_PPC64_TPREL16_HIGHER, 97) \ _ELF_DEFINE_RELOC(R_PPC64_TPREL16_HIGHERA, 98) \ _ELF_DEFINE_RELOC(R_PPC64_TPREL16_HIGHEST, 99) \ _ELF_DEFINE_RELOC(R_PPC64_TPREL16_HIGHESTA, 100) \ _ELF_DEFINE_RELOC(R_PPC64_DTPREL16_DS, 101) \ _ELF_DEFINE_RELOC(R_PPC64_DTPREL16_LO_DS, 102) \ _ELF_DEFINE_RELOC(R_PPC64_DTPREL16_HIGHER, 103) \ _ELF_DEFINE_RELOC(R_PPC64_DTPREL16_HIGHERA, 104) \ _ELF_DEFINE_RELOC(R_PPC64_DTPREL16_HIGHEST, 105) \ _ELF_DEFINE_RELOC(R_PPC64_DTPREL16_HIGHESTA, 106) \ _ELF_DEFINE_RELOC(R_PPC64_TLSGD, 107) \ _ELF_DEFINE_RELOC(R_PPC64_TLSLD, 108) #define _ELF_DEFINE_RISCV_RELOCATIONS() \ _ELF_DEFINE_RELOC(R_RISCV_NONE, 0) \ _ELF_DEFINE_RELOC(R_RISCV_32, 1) \ _ELF_DEFINE_RELOC(R_RISCV_64, 2) \ _ELF_DEFINE_RELOC(R_RISCV_RELATIVE, 3) \ _ELF_DEFINE_RELOC(R_RISCV_COPY, 4) \ _ELF_DEFINE_RELOC(R_RISCV_JUMP_SLOT, 5) \ _ELF_DEFINE_RELOC(R_RISCV_TLS_DTPMOD32, 6) \ _ELF_DEFINE_RELOC(R_RISCV_TLS_DTPMOD64, 7) \ _ELF_DEFINE_RELOC(R_RISCV_TLS_DTPREL32, 8) \ _ELF_DEFINE_RELOC(R_RISCV_TLS_DTPREL64, 9) \ _ELF_DEFINE_RELOC(R_RISCV_TLS_TPREL32, 10) \ _ELF_DEFINE_RELOC(R_RISCV_TLS_TPREL64, 11) \ _ELF_DEFINE_RELOC(R_RISCV_BRANCH, 16) \ _ELF_DEFINE_RELOC(R_RISCV_JAL, 17) \ _ELF_DEFINE_RELOC(R_RISCV_CALL, 18) \ _ELF_DEFINE_RELOC(R_RISCV_CALL_PLT, 19) \ _ELF_DEFINE_RELOC(R_RISCV_GOT_HI20, 20) \ _ELF_DEFINE_RELOC(R_RISCV_TLS_GOT_HI20, 21) \ _ELF_DEFINE_RELOC(R_RISCV_TLS_GD_HI20, 22) \ _ELF_DEFINE_RELOC(R_RISCV_PCREL_HI20, 23) \ _ELF_DEFINE_RELOC(R_RISCV_PCREL_LO12_I, 24) \ _ELF_DEFINE_RELOC(R_RISCV_PCREL_LO12_S, 25) \ _ELF_DEFINE_RELOC(R_RISCV_HI20, 26) \ _ELF_DEFINE_RELOC(R_RISCV_LO12_I, 27) \ _ELF_DEFINE_RELOC(R_RISCV_LO12_S, 28) \ _ELF_DEFINE_RELOC(R_RISCV_TPREL_HI20, 29) \ _ELF_DEFINE_RELOC(R_RISCV_TPREL_LO12_I, 30) \ _ELF_DEFINE_RELOC(R_RISCV_TPREL_LO12_S, 31) \ _ELF_DEFINE_RELOC(R_RISCV_TPREL_ADD, 32) \ _ELF_DEFINE_RELOC(R_RISCV_ADD8, 33) \ _ELF_DEFINE_RELOC(R_RISCV_ADD16, 34) \ _ELF_DEFINE_RELOC(R_RISCV_ADD32, 35) \ _ELF_DEFINE_RELOC(R_RISCV_ADD64, 36) \ _ELF_DEFINE_RELOC(R_RISCV_SUB8, 37) \ _ELF_DEFINE_RELOC(R_RISCV_SUB16, 38) \ _ELF_DEFINE_RELOC(R_RISCV_SUB32, 39) \ _ELF_DEFINE_RELOC(R_RISCV_SUB64, 40) \ _ELF_DEFINE_RELOC(R_RISCV_GNU_VTINHERIT, 41) \ _ELF_DEFINE_RELOC(R_RISCV_GNU_VTENTRY, 42) \ _ELF_DEFINE_RELOC(R_RISCV_ALIGN, 43) \ _ELF_DEFINE_RELOC(R_RISCV_RVC_BRANCH, 44) \ _ELF_DEFINE_RELOC(R_RISCV_RVC_JUMP, 45) #define _ELF_DEFINE_SPARC_RELOCATIONS() \ _ELF_DEFINE_RELOC(R_SPARC_NONE, 0) \ _ELF_DEFINE_RELOC(R_SPARC_8, 1) \ _ELF_DEFINE_RELOC(R_SPARC_16, 2) \ _ELF_DEFINE_RELOC(R_SPARC_32, 3) \ _ELF_DEFINE_RELOC(R_SPARC_DISP8, 4) \ _ELF_DEFINE_RELOC(R_SPARC_DISP16, 5) \ _ELF_DEFINE_RELOC(R_SPARC_DISP32, 6) \ _ELF_DEFINE_RELOC(R_SPARC_WDISP30, 7) \ _ELF_DEFINE_RELOC(R_SPARC_WDISP22, 8) \ _ELF_DEFINE_RELOC(R_SPARC_HI22, 9) \ _ELF_DEFINE_RELOC(R_SPARC_22, 10) \ _ELF_DEFINE_RELOC(R_SPARC_13, 11) \ _ELF_DEFINE_RELOC(R_SPARC_LO10, 12) \ _ELF_DEFINE_RELOC(R_SPARC_GOT10, 13) \ _ELF_DEFINE_RELOC(R_SPARC_GOT13, 14) \ _ELF_DEFINE_RELOC(R_SPARC_GOT22, 15) \ _ELF_DEFINE_RELOC(R_SPARC_PC10, 16) \ _ELF_DEFINE_RELOC(R_SPARC_PC22, 17) \ _ELF_DEFINE_RELOC(R_SPARC_WPLT30, 18) \ _ELF_DEFINE_RELOC(R_SPARC_COPY, 19) \ _ELF_DEFINE_RELOC(R_SPARC_GLOB_DAT, 20) \ _ELF_DEFINE_RELOC(R_SPARC_JMP_SLOT, 21) \ _ELF_DEFINE_RELOC(R_SPARC_RELATIVE, 22) \ _ELF_DEFINE_RELOC(R_SPARC_UA32, 23) \ _ELF_DEFINE_RELOC(R_SPARC_PLT32, 24) \ _ELF_DEFINE_RELOC(R_SPARC_HIPLT22, 25) \ _ELF_DEFINE_RELOC(R_SPARC_LOPLT10, 26) \ _ELF_DEFINE_RELOC(R_SPARC_PCPLT32, 27) \ _ELF_DEFINE_RELOC(R_SPARC_PCPLT22, 28) \ _ELF_DEFINE_RELOC(R_SPARC_PCPLT10, 29) \ _ELF_DEFINE_RELOC(R_SPARC_10, 30) \ _ELF_DEFINE_RELOC(R_SPARC_11, 31) \ _ELF_DEFINE_RELOC(R_SPARC_64, 32) \ _ELF_DEFINE_RELOC(R_SPARC_OLO10, 33) \ _ELF_DEFINE_RELOC(R_SPARC_HH22, 34) \ _ELF_DEFINE_RELOC(R_SPARC_HM10, 35) \ _ELF_DEFINE_RELOC(R_SPARC_LM22, 36) \ _ELF_DEFINE_RELOC(R_SPARC_PC_HH22, 37) \ _ELF_DEFINE_RELOC(R_SPARC_PC_HM10, 38) \ _ELF_DEFINE_RELOC(R_SPARC_PC_LM22, 39) \ _ELF_DEFINE_RELOC(R_SPARC_WDISP16, 40) \ _ELF_DEFINE_RELOC(R_SPARC_WDISP19, 41) \ +_ELF_DEFINE_RELOC(R_SPARC_GLOB_JMP, 42) \ _ELF_DEFINE_RELOC(R_SPARC_7, 43) \ _ELF_DEFINE_RELOC(R_SPARC_5, 44) \ _ELF_DEFINE_RELOC(R_SPARC_6, 45) \ _ELF_DEFINE_RELOC(R_SPARC_DISP64, 46) \ _ELF_DEFINE_RELOC(R_SPARC_PLT64, 47) \ _ELF_DEFINE_RELOC(R_SPARC_HIX22, 48) \ _ELF_DEFINE_RELOC(R_SPARC_LOX10, 49) \ _ELF_DEFINE_RELOC(R_SPARC_H44, 50) \ _ELF_DEFINE_RELOC(R_SPARC_M44, 51) \ _ELF_DEFINE_RELOC(R_SPARC_L44, 52) \ _ELF_DEFINE_RELOC(R_SPARC_REGISTER, 53) \ _ELF_DEFINE_RELOC(R_SPARC_UA64, 54) \ _ELF_DEFINE_RELOC(R_SPARC_UA16, 55) \ +_ELF_DEFINE_RELOC(R_SPARC_TLS_GD_HI22, 56) \ +_ELF_DEFINE_RELOC(R_SPARC_TLS_GD_LO10, 57) \ +_ELF_DEFINE_RELOC(R_SPARC_TLS_GD_ADD, 58) \ +_ELF_DEFINE_RELOC(R_SPARC_TLS_GD_CALL, 59) \ +_ELF_DEFINE_RELOC(R_SPARC_TLS_LDM_HI22, 60) \ +_ELF_DEFINE_RELOC(R_SPARC_TLS_LDM_LO10, 61) \ +_ELF_DEFINE_RELOC(R_SPARC_TLS_LDM_ADD, 62) \ +_ELF_DEFINE_RELOC(R_SPARC_TLS_LDM_CALL, 63) \ +_ELF_DEFINE_RELOC(R_SPARC_TLS_LDO_HIX22, 64) \ +_ELF_DEFINE_RELOC(R_SPARC_TLS_LDO_LOX10, 65) \ +_ELF_DEFINE_RELOC(R_SPARC_TLS_LDO_ADD, 66) \ +_ELF_DEFINE_RELOC(R_SPARC_TLS_IE_HI22, 67) \ +_ELF_DEFINE_RELOC(R_SPARC_TLS_IE_LO10, 68) \ +_ELF_DEFINE_RELOC(R_SPARC_TLS_IE_LD, 69) \ +_ELF_DEFINE_RELOC(R_SPARC_TLS_IE_LDX, 70) \ +_ELF_DEFINE_RELOC(R_SPARC_TLS_IE_ADD, 71) \ +_ELF_DEFINE_RELOC(R_SPARC_TLS_LE_HIX22, 72) \ +_ELF_DEFINE_RELOC(R_SPARC_TLS_LE_LOX10, 73) \ +_ELF_DEFINE_RELOC(R_SPARC_TLS_DTPMOD32, 74) \ +_ELF_DEFINE_RELOC(R_SPARC_TLS_DTPMOD64, 75) \ +_ELF_DEFINE_RELOC(R_SPARC_TLS_DTPOFF32, 76) \ +_ELF_DEFINE_RELOC(R_SPARC_TLS_DTPOFF64, 77) \ +_ELF_DEFINE_RELOC(R_SPARC_TLS_TPOFF32, 78) \ +_ELF_DEFINE_RELOC(R_SPARC_TLS_TPOFF64, 79) \ _ELF_DEFINE_RELOC(R_SPARC_GOTDATA_HIX22, 80) \ _ELF_DEFINE_RELOC(R_SPARC_GOTDATA_LOX10, 81) \ _ELF_DEFINE_RELOC(R_SPARC_GOTDATA_OP_HIX22, 82) \ _ELF_DEFINE_RELOC(R_SPARC_GOTDATA_OP_LOX10, 83) \ _ELF_DEFINE_RELOC(R_SPARC_GOTDATA_OP, 84) \ _ELF_DEFINE_RELOC(R_SPARC_H34, 85) #define _ELF_DEFINE_X86_64_RELOCATIONS() \ _ELF_DEFINE_RELOC(R_X86_64_NONE, 0) \ _ELF_DEFINE_RELOC(R_X86_64_64, 1) \ _ELF_DEFINE_RELOC(R_X86_64_PC32, 2) \ _ELF_DEFINE_RELOC(R_X86_64_GOT32, 3) \ _ELF_DEFINE_RELOC(R_X86_64_PLT32, 4) \ _ELF_DEFINE_RELOC(R_X86_64_COPY, 5) \ _ELF_DEFINE_RELOC(R_X86_64_GLOB_DAT, 6) \ _ELF_DEFINE_RELOC(R_X86_64_JUMP_SLOT, 7) \ _ELF_DEFINE_RELOC(R_X86_64_RELATIVE, 8) \ _ELF_DEFINE_RELOC(R_X86_64_GOTPCREL, 9) \ _ELF_DEFINE_RELOC(R_X86_64_32, 10) \ _ELF_DEFINE_RELOC(R_X86_64_32S, 11) \ _ELF_DEFINE_RELOC(R_X86_64_16, 12) \ _ELF_DEFINE_RELOC(R_X86_64_PC16, 13) \ _ELF_DEFINE_RELOC(R_X86_64_8, 14) \ _ELF_DEFINE_RELOC(R_X86_64_PC8, 15) \ _ELF_DEFINE_RELOC(R_X86_64_DTPMOD64, 16) \ _ELF_DEFINE_RELOC(R_X86_64_DTPOFF64, 17) \ _ELF_DEFINE_RELOC(R_X86_64_TPOFF64, 18) \ _ELF_DEFINE_RELOC(R_X86_64_TLSGD, 19) \ _ELF_DEFINE_RELOC(R_X86_64_TLSLD, 20) \ _ELF_DEFINE_RELOC(R_X86_64_DTPOFF32, 21) \ _ELF_DEFINE_RELOC(R_X86_64_GOTTPOFF, 22) \ _ELF_DEFINE_RELOC(R_X86_64_TPOFF32, 23) \ _ELF_DEFINE_RELOC(R_X86_64_PC64, 24) \ _ELF_DEFINE_RELOC(R_X86_64_GOTOFF64, 25) \ _ELF_DEFINE_RELOC(R_X86_64_GOTPC32, 26) \ _ELF_DEFINE_RELOC(R_X86_64_GOT64, 27) \ _ELF_DEFINE_RELOC(R_X86_64_GOTPCREL64, 28) \ _ELF_DEFINE_RELOC(R_X86_64_GOTPC64, 29) \ _ELF_DEFINE_RELOC(R_X86_64_GOTPLT64, 30) \ _ELF_DEFINE_RELOC(R_X86_64_PLTOFF64, 31) \ _ELF_DEFINE_RELOC(R_X86_64_SIZE32, 32) \ _ELF_DEFINE_RELOC(R_X86_64_SIZE64, 33) \ _ELF_DEFINE_RELOC(R_X86_64_GOTPC32_TLSDESC, 34) \ _ELF_DEFINE_RELOC(R_X86_64_TLSDESC_CALL, 35) \ _ELF_DEFINE_RELOC(R_X86_64_TLSDESC, 36) \ -_ELF_DEFINE_RELOC(R_X86_64_IRELATIVE, 37) +_ELF_DEFINE_RELOC(R_X86_64_IRELATIVE, 37) \ +_ELF_DEFINE_RELOC(R_X86_64_RELATIVE64, 38) \ +_ELF_DEFINE_RELOC(R_X86_64_GOTPCRELX, 41) \ +_ELF_DEFINE_RELOC(R_X86_64_REX_GOTPCRELX, 42) #define _ELF_DEFINE_RELOCATIONS() \ _ELF_DEFINE_386_RELOCATIONS() \ _ELF_DEFINE_AARCH64_RELOCATIONS() \ _ELF_DEFINE_AMD64_RELOCATIONS() \ _ELF_DEFINE_ARM_RELOCATIONS() \ _ELF_DEFINE_IA64_RELOCATIONS() \ _ELF_DEFINE_MIPS_RELOCATIONS() \ _ELF_DEFINE_PPC32_RELOCATIONS() \ _ELF_DEFINE_PPC64_RELOCATIONS() \ _ELF_DEFINE_RISCV_RELOCATIONS() \ _ELF_DEFINE_SPARC_RELOCATIONS() \ _ELF_DEFINE_X86_64_RELOCATIONS() #undef _ELF_DEFINE_RELOC #define _ELF_DEFINE_RELOC(N, V) N = V , enum { _ELF_DEFINE_RELOCATIONS() R__LAST__ }; #define PN_XNUM 0xFFFFU /* Use extended section numbering. */ /** ** ELF Types. **/ typedef uint32_t Elf32_Addr; /* Program address. */ typedef uint8_t Elf32_Byte; /* Unsigned tiny integer. */ typedef uint16_t Elf32_Half; /* Unsigned medium integer. */ typedef uint32_t Elf32_Off; /* File offset. */ typedef uint16_t Elf32_Section; /* Section index. */ typedef int32_t Elf32_Sword; /* Signed integer. */ typedef uint32_t Elf32_Word; /* Unsigned integer. */ typedef uint64_t Elf32_Lword; /* Unsigned long integer. */ typedef uint64_t Elf64_Addr; /* Program address. */ typedef uint8_t Elf64_Byte; /* Unsigned tiny integer. */ typedef uint16_t Elf64_Half; /* Unsigned medium integer. */ typedef uint64_t Elf64_Off; /* File offset. */ typedef uint16_t Elf64_Section; /* Section index. */ typedef int32_t Elf64_Sword; /* Signed integer. */ typedef uint32_t Elf64_Word; /* Unsigned integer. */ typedef uint64_t Elf64_Lword; /* Unsigned long integer. */ typedef uint64_t Elf64_Xword; /* Unsigned long integer. */ typedef int64_t Elf64_Sxword; /* Signed long integer. */ /* * Capability descriptors. */ /* 32-bit capability descriptor. */ typedef struct { Elf32_Word c_tag; /* Type of entry. */ union { Elf32_Word c_val; /* Integer value. */ Elf32_Addr c_ptr; /* Pointer value. */ } c_un; } Elf32_Cap; /* 64-bit capability descriptor. */ typedef struct { Elf64_Xword c_tag; /* Type of entry. */ union { Elf64_Xword c_val; /* Integer value. */ Elf64_Addr c_ptr; /* Pointer value. */ } c_un; } Elf64_Cap; /* * MIPS .conflict section entries. */ /* 32-bit entry. */ typedef struct { Elf32_Addr c_index; } Elf32_Conflict; /* 64-bit entry. */ typedef struct { Elf64_Addr c_index; } Elf64_Conflict; /* * Dynamic section entries. */ /* 32-bit entry. */ typedef struct { Elf32_Sword d_tag; /* Type of entry. */ union { Elf32_Word d_val; /* Integer value. */ Elf32_Addr d_ptr; /* Pointer value. */ } d_un; } Elf32_Dyn; /* 64-bit entry. */ typedef struct { Elf64_Sxword d_tag; /* Type of entry. */ union { Elf64_Xword d_val; /* Integer value. */ Elf64_Addr d_ptr; /* Pointer value; */ } d_un; } Elf64_Dyn; /* * The executable header (EHDR). */ /* 32 bit EHDR. */ typedef struct { unsigned char e_ident[EI_NIDENT]; /* ELF identification. */ Elf32_Half e_type; /* Object file type (ET_*). */ Elf32_Half e_machine; /* Machine type (EM_*). */ Elf32_Word e_version; /* File format version (EV_*). */ Elf32_Addr e_entry; /* Start address. */ Elf32_Off e_phoff; /* File offset to the PHDR table. */ Elf32_Off e_shoff; /* File offset to the SHDRheader. */ Elf32_Word e_flags; /* Flags (EF_*). */ Elf32_Half e_ehsize; /* Elf header size in bytes. */ Elf32_Half e_phentsize; /* PHDR table entry size in bytes. */ Elf32_Half e_phnum; /* Number of PHDR entries. */ Elf32_Half e_shentsize; /* SHDR table entry size in bytes. */ Elf32_Half e_shnum; /* Number of SHDR entries. */ Elf32_Half e_shstrndx; /* Index of section name string table. */ } Elf32_Ehdr; /* 64 bit EHDR. */ typedef struct { unsigned char e_ident[EI_NIDENT]; /* ELF identification. */ Elf64_Half e_type; /* Object file type (ET_*). */ Elf64_Half e_machine; /* Machine type (EM_*). */ Elf64_Word e_version; /* File format version (EV_*). */ Elf64_Addr e_entry; /* Start address. */ Elf64_Off e_phoff; /* File offset to the PHDR table. */ Elf64_Off e_shoff; /* File offset to the SHDRheader. */ Elf64_Word e_flags; /* Flags (EF_*). */ Elf64_Half e_ehsize; /* Elf header size in bytes. */ Elf64_Half e_phentsize; /* PHDR table entry size in bytes. */ Elf64_Half e_phnum; /* Number of PHDR entries. */ Elf64_Half e_shentsize; /* SHDR table entry size in bytes. */ Elf64_Half e_shnum; /* Number of SHDR entries. */ Elf64_Half e_shstrndx; /* Index of section name string table. */ } Elf64_Ehdr; /* * Shared object information. */ /* 32-bit entry. */ typedef struct { Elf32_Word l_name; /* The name of a shared object. */ Elf32_Word l_time_stamp; /* 32-bit timestamp. */ Elf32_Word l_checksum; /* Checksum of visible symbols, sizes. */ Elf32_Word l_version; /* Interface version string index. */ Elf32_Word l_flags; /* Flags (LL_*). */ } Elf32_Lib; /* 64-bit entry. */ typedef struct { Elf64_Word l_name; /* The name of a shared object. */ Elf64_Word l_time_stamp; /* 32-bit timestamp. */ Elf64_Word l_checksum; /* Checksum of visible symbols, sizes. */ Elf64_Word l_version; /* Interface version string index. */ Elf64_Word l_flags; /* Flags (LL_*). */ } Elf64_Lib; #define _ELF_DEFINE_LL_FLAGS() \ _ELF_DEFINE_LL(LL_NONE, 0, \ "no flags") \ _ELF_DEFINE_LL(LL_EXACT_MATCH, 0x1, \ "require an exact match") \ _ELF_DEFINE_LL(LL_IGNORE_INT_VER, 0x2, \ "ignore version incompatibilities") \ _ELF_DEFINE_LL(LL_REQUIRE_MINOR, 0x4, \ "") \ _ELF_DEFINE_LL(LL_EXPORTS, 0x8, \ "") \ _ELF_DEFINE_LL(LL_DELAY_LOAD, 0x10, \ "") \ _ELF_DEFINE_LL(LL_DELTA, 0x20, \ "") #undef _ELF_DEFINE_LL #define _ELF_DEFINE_LL(N, V, DESCR) N = V , enum { _ELF_DEFINE_LL_FLAGS() LL__LAST__ }; /* * Note tags */ #define _ELF_DEFINE_NOTE_ENTRY_TYPES() \ _ELF_DEFINE_NT(NT_ABI_TAG, 1, "Tag indicating the ABI") \ _ELF_DEFINE_NT(NT_GNU_HWCAP, 2, "Hardware capabilities") \ _ELF_DEFINE_NT(NT_GNU_BUILD_ID, 3, "Build id, set by ld(1)") \ _ELF_DEFINE_NT(NT_GNU_GOLD_VERSION, 4, \ "Version number of the GNU gold linker") \ _ELF_DEFINE_NT(NT_PRSTATUS, 1, "Process status") \ _ELF_DEFINE_NT(NT_FPREGSET, 2, "Floating point information") \ _ELF_DEFINE_NT(NT_PRPSINFO, 3, "Process information") \ _ELF_DEFINE_NT(NT_AUXV, 6, "Auxiliary vector") \ _ELF_DEFINE_NT(NT_PRXFPREG, 0x46E62B7FUL, \ "Linux user_xfpregs structure") \ _ELF_DEFINE_NT(NT_PSTATUS, 10, "Linux process status") \ _ELF_DEFINE_NT(NT_FPREGS, 12, "Linux floating point regset") \ _ELF_DEFINE_NT(NT_PSINFO, 13, "Linux process information") \ _ELF_DEFINE_NT(NT_LWPSTATUS, 16, "Linux lwpstatus_t type") \ _ELF_DEFINE_NT(NT_LWPSINFO, 17, "Linux lwpinfo_t type") #undef _ELF_DEFINE_NT #define _ELF_DEFINE_NT(N, V, DESCR) N = V , enum { _ELF_DEFINE_NOTE_ENTRY_TYPES() NT__LAST__ }; /* Aliases for the ABI tag. */ #define NT_FREEBSD_ABI_TAG NT_ABI_TAG #define NT_GNU_ABI_TAG NT_ABI_TAG #define NT_NETBSD_IDENT NT_ABI_TAG #define NT_OPENBSD_IDENT NT_ABI_TAG /* * Note descriptors. */ typedef struct { uint32_t n_namesz; /* Length of note's name. */ uint32_t n_descsz; /* Length of note's value. */ uint32_t n_type; /* Type of note. */ } Elf_Note; typedef Elf_Note Elf32_Nhdr; /* 32-bit note header. */ typedef Elf_Note Elf64_Nhdr; /* 64-bit note header. */ /* * MIPS ELF options descriptor header. */ typedef struct { Elf64_Byte kind; /* Type of options. */ Elf64_Byte size; /* Size of option descriptor. */ Elf64_Half section; /* Index of section affected. */ Elf64_Word info; /* Kind-specific information. */ } Elf_Options; /* * Option kinds. */ #define _ELF_DEFINE_OPTION_KINDS() \ _ELF_DEFINE_ODK(ODK_NULL, 0, "undefined") \ _ELF_DEFINE_ODK(ODK_REGINFO, 1, "register usage info") \ _ELF_DEFINE_ODK(ODK_EXCEPTIONS, 2, "exception processing info") \ _ELF_DEFINE_ODK(ODK_PAD, 3, "section padding") \ _ELF_DEFINE_ODK(ODK_HWPATCH, 4, "hardware patch applied") \ _ELF_DEFINE_ODK(ODK_FILL, 5, "fill value used by linker") \ _ELF_DEFINE_ODK(ODK_TAGS, 6, "reserved space for tools") \ _ELF_DEFINE_ODK(ODK_HWAND, 7, "hardware AND patch applied") \ _ELF_DEFINE_ODK(ODK_HWOR, 8, "hardware OR patch applied") \ _ELF_DEFINE_ODK(ODK_GP_GROUP, 9, \ "GP group to use for text/data sections") \ _ELF_DEFINE_ODK(ODK_IDENT, 10, "ID information") \ -_ELF_DEFINE_ODK(ODK_PAGESIZE, 11, "page size infomation") +_ELF_DEFINE_ODK(ODK_PAGESIZE, 11, "page size information") #undef _ELF_DEFINE_ODK #define _ELF_DEFINE_ODK(N, V, DESCR) N = V , enum { _ELF_DEFINE_OPTION_KINDS() ODK__LAST__ }; /* * ODK_EXCEPTIONS info field masks. */ #define _ELF_DEFINE_ODK_EXCEPTIONS_MASK() \ _ELF_DEFINE_OEX(OEX_FPU_MIN, 0x0000001FUL, \ "minimum FPU exception which must be enabled") \ _ELF_DEFINE_OEX(OEX_FPU_MAX, 0x00001F00UL, \ "maximum FPU exception which can be enabled") \ _ELF_DEFINE_OEX(OEX_PAGE0, 0x00010000UL, \ "page zero must be mapped") \ _ELF_DEFINE_OEX(OEX_SMM, 0x00020000UL, \ "run in sequential memory mode") \ _ELF_DEFINE_OEX(OEX_PRECISEFP, 0x00040000UL, \ "run in precise FP exception mode") \ _ELF_DEFINE_OEX(OEX_DISMISS, 0x00080000UL, \ "dismiss invalid address traps") #undef _ELF_DEFINE_OEX #define _ELF_DEFINE_OEX(N, V, DESCR) N = V , enum { _ELF_DEFINE_ODK_EXCEPTIONS_MASK() OEX__LAST__ }; /* * ODK_PAD info field masks. */ #define _ELF_DEFINE_ODK_PAD_MASK() \ _ELF_DEFINE_OPAD(OPAD_PREFIX, 0x0001) \ _ELF_DEFINE_OPAD(OPAD_POSTFIX, 0x0002) \ _ELF_DEFINE_OPAD(OPAD_SYMBOL, 0x0004) #undef _ELF_DEFINE_OPAD #define _ELF_DEFINE_OPAD(N, V) N = V , enum { _ELF_DEFINE_ODK_PAD_MASK() OPAD__LAST__ }; /* * ODK_HWPATCH info field masks. */ #define _ELF_DEFINE_ODK_HWPATCH_MASK() \ _ELF_DEFINE_OHW(OHW_R4KEOP, 0x00000001UL, \ "patch for R4000 branch at end-of-page bug") \ _ELF_DEFINE_OHW(OHW_R8KPFETCH, 0x00000002UL, \ "R8000 prefetch bug may occur") \ _ELF_DEFINE_OHW(OHW_R5KEOP, 0x00000004UL, \ "patch for R5000 branch at end-of-page bug") \ _ELF_DEFINE_OHW(OHW_R5KCVTL, 0x00000008UL, \ "R5000 cvt.[ds].l bug: clean == 1") \ _ELF_DEFINE_OHW(OHW_R10KLDL, 0x00000010UL, \ "needd patch for R10000 misaligned load") #undef _ELF_DEFINE_OHW #define _ELF_DEFINE_OHW(N, V, DESCR) N = V , enum { _ELF_DEFINE_ODK_HWPATCH_MASK() OHW__LAST__ }; /* * ODK_HWAND/ODK_HWOR info field and hwp_flags[12] masks. */ #define _ELF_DEFINE_ODK_HWP_MASK() \ _ELF_DEFINE_HWP(OHWA0_R4KEOP_CHECKED, 0x00000001UL, \ "object checked for R4000 end-of-page bug") \ _ELF_DEFINE_HWP(OHWA0_R4KEOP_CLEAN, 0x00000002UL, \ "object verified clean for R4000 end-of-page bug") \ _ELF_DEFINE_HWP(OHWO0_FIXADE, 0x00000001UL, \ "object requires call to fixade") #undef _ELF_DEFINE_HWP #define _ELF_DEFINE_HWP(N, V, DESCR) N = V , enum { _ELF_DEFINE_ODK_HWP_MASK() OHWX0__LAST__ }; /* * ODK_IDENT/ODK_GP_GROUP info field masks. */ #define _ELF_DEFINE_ODK_GP_MASK() \ _ELF_DEFINE_OGP(OGP_GROUP, 0x0000FFFFUL, "GP group number") \ _ELF_DEFINE_OGP(OGP_SELF, 0x00010000UL, \ "GP group is self-contained") #undef _ELF_DEFINE_OGP #define _ELF_DEFINE_OGP(N, V, DESCR) N = V , enum { _ELF_DEFINE_ODK_GP_MASK() OGP__LAST__ }; /* * MIPS ELF register info descriptor. */ /* 32 bit RegInfo entry. */ typedef struct { Elf32_Word ri_gprmask; /* Mask of general register used. */ Elf32_Word ri_cprmask[4]; /* Mask of coprocessor register used. */ Elf32_Addr ri_gp_value; /* GP register value. */ } Elf32_RegInfo; /* 64 bit RegInfo entry. */ typedef struct { Elf64_Word ri_gprmask; /* Mask of general register used. */ Elf64_Word ri_pad; /* Padding. */ Elf64_Word ri_cprmask[4]; /* Mask of coprocessor register used. */ Elf64_Addr ri_gp_value; /* GP register value. */ } Elf64_RegInfo; /* * Program Header Table (PHDR) entries. */ /* 32 bit PHDR entry. */ typedef struct { Elf32_Word p_type; /* Type of segment. */ Elf32_Off p_offset; /* File offset to segment. */ Elf32_Addr p_vaddr; /* Virtual address in memory. */ Elf32_Addr p_paddr; /* Physical address (if relevant). */ Elf32_Word p_filesz; /* Size of segment in file. */ Elf32_Word p_memsz; /* Size of segment in memory. */ Elf32_Word p_flags; /* Segment flags. */ Elf32_Word p_align; /* Alignment constraints. */ } Elf32_Phdr; /* 64 bit PHDR entry. */ typedef struct { Elf64_Word p_type; /* Type of segment. */ Elf64_Word p_flags; /* Segment flags. */ Elf64_Off p_offset; /* File offset to segment. */ Elf64_Addr p_vaddr; /* Virtual address in memory. */ Elf64_Addr p_paddr; /* Physical address (if relevant). */ Elf64_Xword p_filesz; /* Size of segment in file. */ Elf64_Xword p_memsz; /* Size of segment in memory. */ Elf64_Xword p_align; /* Alignment constraints. */ } Elf64_Phdr; /* * Move entries, for describing data in COMMON blocks in a compact * manner. */ /* 32-bit move entry. */ typedef struct { Elf32_Lword m_value; /* Initialization value. */ Elf32_Word m_info; /* Encoded size and index. */ Elf32_Word m_poffset; /* Offset relative to symbol. */ Elf32_Half m_repeat; /* Repeat count. */ Elf32_Half m_stride; /* Number of units to skip. */ } Elf32_Move; /* 64-bit move entry. */ typedef struct { Elf64_Lword m_value; /* Initialization value. */ Elf64_Xword m_info; /* Encoded size and index. */ Elf64_Xword m_poffset; /* Offset relative to symbol. */ Elf64_Half m_repeat; /* Repeat count. */ Elf64_Half m_stride; /* Number of units to skip. */ } Elf64_Move; #define ELF32_M_SYM(I) ((I) >> 8) #define ELF32_M_SIZE(I) ((unsigned char) (I)) #define ELF32_M_INFO(M, S) (((M) << 8) + (unsigned char) (S)) #define ELF64_M_SYM(I) ((I) >> 8) #define ELF64_M_SIZE(I) ((unsigned char) (I)) #define ELF64_M_INFO(M, S) (((M) << 8) + (unsigned char) (S)) /* * Section Header Table (SHDR) entries. */ /* 32 bit SHDR */ typedef struct { Elf32_Word sh_name; /* index of section name */ Elf32_Word sh_type; /* section type */ Elf32_Word sh_flags; /* section flags */ Elf32_Addr sh_addr; /* in-memory address of section */ Elf32_Off sh_offset; /* file offset of section */ Elf32_Word sh_size; /* section size in bytes */ Elf32_Word sh_link; /* section header table link */ Elf32_Word sh_info; /* extra information */ Elf32_Word sh_addralign; /* alignment constraint */ Elf32_Word sh_entsize; /* size for fixed-size entries */ } Elf32_Shdr; /* 64 bit SHDR */ typedef struct { Elf64_Word sh_name; /* index of section name */ Elf64_Word sh_type; /* section type */ Elf64_Xword sh_flags; /* section flags */ Elf64_Addr sh_addr; /* in-memory address of section */ Elf64_Off sh_offset; /* file offset of section */ Elf64_Xword sh_size; /* section size in bytes */ Elf64_Word sh_link; /* section header table link */ Elf64_Word sh_info; /* extra information */ Elf64_Xword sh_addralign; /* alignment constraint */ Elf64_Xword sh_entsize; /* size for fixed-size entries */ } Elf64_Shdr; /* * Symbol table entries. */ typedef struct { Elf32_Word st_name; /* index of symbol's name */ Elf32_Addr st_value; /* value for the symbol */ Elf32_Word st_size; /* size of associated data */ unsigned char st_info; /* type and binding attributes */ unsigned char st_other; /* visibility */ Elf32_Half st_shndx; /* index of related section */ } Elf32_Sym; typedef struct { Elf64_Word st_name; /* index of symbol's name */ unsigned char st_info; /* type and binding attributes */ unsigned char st_other; /* visibility */ Elf64_Half st_shndx; /* index of related section */ Elf64_Addr st_value; /* value for the symbol */ Elf64_Xword st_size; /* size of associated data */ } Elf64_Sym; #define ELF32_ST_BIND(I) ((I) >> 4) #define ELF32_ST_TYPE(I) ((I) & 0xFU) #define ELF32_ST_INFO(B,T) (((B) << 4) + ((T) & 0xF)) #define ELF64_ST_BIND(I) ((I) >> 4) #define ELF64_ST_TYPE(I) ((I) & 0xFU) #define ELF64_ST_INFO(B,T) (((B) << 4) + ((T) & 0xF)) #define ELF32_ST_VISIBILITY(O) ((O) & 0x3) #define ELF64_ST_VISIBILITY(O) ((O) & 0x3) /* * Syminfo descriptors, containing additional symbol information. */ /* 32-bit entry. */ typedef struct { Elf32_Half si_boundto; /* Entry index with additional flags. */ Elf32_Half si_flags; /* Flags. */ } Elf32_Syminfo; /* 64-bit entry. */ typedef struct { Elf64_Half si_boundto; /* Entry index with additional flags. */ Elf64_Half si_flags; /* Flags. */ } Elf64_Syminfo; /* * Relocation descriptors. */ typedef struct { Elf32_Addr r_offset; /* location to apply relocation to */ Elf32_Word r_info; /* type+section for relocation */ } Elf32_Rel; typedef struct { Elf32_Addr r_offset; /* location to apply relocation to */ Elf32_Word r_info; /* type+section for relocation */ Elf32_Sword r_addend; /* constant addend */ } Elf32_Rela; typedef struct { Elf64_Addr r_offset; /* location to apply relocation to */ Elf64_Xword r_info; /* type+section for relocation */ } Elf64_Rel; typedef struct { Elf64_Addr r_offset; /* location to apply relocation to */ Elf64_Xword r_info; /* type+section for relocation */ Elf64_Sxword r_addend; /* constant addend */ } Elf64_Rela; #define ELF32_R_SYM(I) ((I) >> 8) #define ELF32_R_TYPE(I) ((unsigned char) (I)) #define ELF32_R_INFO(S,T) (((S) << 8) + (unsigned char) (T)) #define ELF64_R_SYM(I) ((I) >> 32) #define ELF64_R_TYPE(I) ((I) & 0xFFFFFFFFUL) #define ELF64_R_INFO(S,T) (((S) << 32) + ((T) & 0xFFFFFFFFUL)) /* * Symbol versioning structures. */ /* 32-bit structures. */ typedef struct { Elf32_Word vda_name; /* Index to name. */ Elf32_Word vda_next; /* Offset to next entry. */ } Elf32_Verdaux; typedef struct { Elf32_Word vna_hash; /* Hash value of dependency name. */ Elf32_Half vna_flags; /* Flags. */ Elf32_Half vna_other; /* Unused. */ Elf32_Word vna_name; /* Offset to dependency name. */ Elf32_Word vna_next; /* Offset to next vernaux entry. */ } Elf32_Vernaux; typedef struct { Elf32_Half vd_version; /* Version information. */ Elf32_Half vd_flags; /* Flags. */ Elf32_Half vd_ndx; /* Index into the versym section. */ Elf32_Half vd_cnt; /* Number of aux entries. */ Elf32_Word vd_hash; /* Hash value of name. */ Elf32_Word vd_aux; /* Offset to aux entries. */ Elf32_Word vd_next; /* Offset to next version definition. */ } Elf32_Verdef; typedef struct { Elf32_Half vn_version; /* Version number. */ Elf32_Half vn_cnt; /* Number of aux entries. */ Elf32_Word vn_file; /* Offset of associated file name. */ Elf32_Word vn_aux; /* Offset of vernaux array. */ Elf32_Word vn_next; /* Offset of next verneed entry. */ } Elf32_Verneed; typedef Elf32_Half Elf32_Versym; /* 64-bit structures. */ typedef struct { Elf64_Word vda_name; /* Index to name. */ Elf64_Word vda_next; /* Offset to next entry. */ } Elf64_Verdaux; typedef struct { Elf64_Word vna_hash; /* Hash value of dependency name. */ Elf64_Half vna_flags; /* Flags. */ Elf64_Half vna_other; /* Unused. */ Elf64_Word vna_name; /* Offset to dependency name. */ Elf64_Word vna_next; /* Offset to next vernaux entry. */ } Elf64_Vernaux; typedef struct { Elf64_Half vd_version; /* Version information. */ Elf64_Half vd_flags; /* Flags. */ Elf64_Half vd_ndx; /* Index into the versym section. */ Elf64_Half vd_cnt; /* Number of aux entries. */ Elf64_Word vd_hash; /* Hash value of name. */ Elf64_Word vd_aux; /* Offset to aux entries. */ Elf64_Word vd_next; /* Offset to next version definition. */ } Elf64_Verdef; typedef struct { Elf64_Half vn_version; /* Version number. */ Elf64_Half vn_cnt; /* Number of aux entries. */ Elf64_Word vn_file; /* Offset of associated file name. */ Elf64_Word vn_aux; /* Offset of vernaux array. */ Elf64_Word vn_next; /* Offset of next verneed entry. */ } Elf64_Verneed; typedef Elf64_Half Elf64_Versym; /* * The header for GNU-style hash sections. */ typedef struct { uint32_t gh_nbuckets; /* Number of hash buckets. */ uint32_t gh_symndx; /* First visible symbol in .dynsym. */ uint32_t gh_maskwords; /* #maskwords used in bloom filter. */ uint32_t gh_shift2; /* Bloom filter shift count. */ } Elf_GNU_Hash_Header; #endif /* _ELFDEFINITIONS_H_ */ Index: vendor/elftoolchain/dist/cxxfilt/cxxfilt.c =================================================================== --- vendor/elftoolchain/dist/cxxfilt/cxxfilt.c (revision 300227) +++ vendor/elftoolchain/dist/cxxfilt/cxxfilt.c (revision 300228) @@ -1,224 +1,202 @@ /*- * Copyright (c) 2009 Kai Wang * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer * in this position and unchanged. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include #include #include #include #include #include #include #include #include "_elftc.h" -ELFTC_VCSID("$Id: cxxfilt.c 3356 2016-01-22 22:31:38Z jkoshy $"); +ELFTC_VCSID("$Id: cxxfilt.c 3454 2016-05-07 17:11:05Z kaiwang27 $"); #define STRBUFSZ 8192 static int stripus = 0; static int noparam = 0; static int format = 0; enum options { OPTION_HELP, OPTION_VERSION }; static struct option longopts[] = { {"format", required_argument, NULL, 's'}, {"help", no_argument, NULL, OPTION_HELP}, {"no-params", no_argument, NULL, 'p'}, {"no-strip-underscores", no_argument, NULL, 'n'}, {"strip-underscores", no_argument, NULL, '_'}, {"version", no_argument, NULL, 'V'}, {NULL, 0, NULL, 0} }; static struct { const char *fname; int fvalue; } flist[] = { {"auto", 0}, {"arm", ELFTC_DEM_ARM}, {"gnu", ELFTC_DEM_GNU2}, {"gnu-v3", ELFTC_DEM_GNU3} }; #define USAGE_MESSAGE "\ Usage: %s [options] [encoded-names...]\n\ Translate C++ symbol names to human-readable form.\n\n\ Options:\n\ -_ | --strip-underscores Remove leading underscores prior to decoding.\n\ -n | --no-strip-underscores Do not remove leading underscores.\n\ -p | --no-params (Accepted but ignored).\n\ -s SCHEME | --format=SCHEME Select the encoding scheme to use.\n\ Valid schemes are: 'arm', 'auto', 'gnu' and\n\ 'gnu-v3'.\n\ --help Print a help message.\n\ --version Print a version identifier and exit.\n" static void usage(void) { (void) fprintf(stderr, USAGE_MESSAGE, ELFTC_GETPROGNAME()); exit(1); } static void version(void) { fprintf(stderr, "%s (%s)\n", ELFTC_GETPROGNAME(), elftc_version()); exit(0); } static int find_format(const char *fstr) { int i; for (i = 0; (size_t) i < sizeof(flist) / sizeof(flist[0]); i++) { if (!strcmp(fstr, flist[i].fname)) return (flist[i].fvalue); } return (-1); } static char * -demangle(char *name, int strict, size_t *pos) +demangle(char *name) { static char dem[STRBUFSZ]; - char nb[STRBUFSZ]; - size_t p, t; - if (stripus && *name == '_') { - strncpy(nb, name + 1, sizeof(nb) - 1); - t = 1; - } else { - strncpy(nb, name, sizeof(nb) - 1); - t = 0; - } - nb[sizeof(nb) - 1] = '\0'; + if (stripus && *name == '_') + name++; - p = strlen(nb); - if (p == 0) - return NULL; + if (strlen(name) == 0) + return (NULL); - while (elftc_demangle(nb, dem, sizeof(dem), (unsigned) format) < 0) { - if (!strict && p > 1) { - nb[--p] = '\0'; - continue; - } else - return (NULL); - } + if (elftc_demangle(name, dem, sizeof(dem), (unsigned) format) < 0) + return (NULL); - if (pos != NULL) - *pos = t ? p + 1 : p; - return (dem); } int main(int argc, char **argv) { char *dem, buf[STRBUFSZ]; - size_t i, p, s; + size_t p; int c, n, opt; while ((opt = getopt_long(argc, argv, "_nps:V", longopts, NULL)) != -1) { switch (opt) { case '_': stripus = 1; break; case 'n': stripus = 0; break; case 'p': noparam = 1; break; case 's': if ((format = find_format(optarg)) < 0) errx(EXIT_FAILURE, "unsupported format: %s", optarg); break; case 'V': version(); /* NOT REACHED */ case OPTION_HELP: default: usage(); /* NOT REACHED */ } } argv += optind; argc -= optind; if (*argv != NULL) { for (n = 0; n < argc; n++) { - if ((dem = demangle(argv[n], 1, NULL)) == NULL) - fprintf(stderr, "Failed: %s\n", argv[n]); + if ((dem = demangle(argv[n])) == NULL) + printf("%s\n", argv[n]); else printf("%s\n", dem); } } else { p = 0; for (;;) { c = fgetc(stdin); - if (c == EOF || !isprint(c) || strchr(" \t\n", c)) { + if (c == EOF || !(isalnum(c) || strchr(".$_", c))) { if (p > 0) { buf[p] = '\0'; - if ((dem = demangle(buf, 0, &s)) == - NULL) + if ((dem = demangle(buf)) == NULL) printf("%s", buf); - else { + else printf("%s", dem); - for (i = s; i < p; i++) - putchar(buf[i]); - } p = 0; } if (c == EOF) break; - if (isprint(c) || strchr(" \t\n", c)) - putchar(c); + putchar(c); } else { if ((size_t) p >= sizeof(buf) - 1) warnx("buffer overflowed"); else buf[p++] = (char) c; } } } exit(0); } Index: vendor/elftoolchain/dist/elfcopy/ascii.c =================================================================== --- vendor/elftoolchain/dist/elfcopy/ascii.c (revision 300227) +++ vendor/elftoolchain/dist/elfcopy/ascii.c (revision 300228) @@ -1,1078 +1,1078 @@ /*- * Copyright (c) 2010,2011 Kai Wang * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #include #include #include #include #include #include #include #include #include "elfcopy.h" -ELFTC_VCSID("$Id: ascii.c 3177 2015-03-30 18:19:41Z emaste $"); +ELFTC_VCSID("$Id: ascii.c 3446 2016-05-03 01:31:17Z emaste $"); static void append_data(struct section *s, const void *buf, size_t sz); static char hex_digit(uint8_t n); static int hex_value(int x); static void finalize_data_section(struct section *s); static int ishexdigit(int x); static int ihex_read(const char *line, char *type, uint64_t *addr, uint64_t *num, uint8_t *data, size_t *sz); static void ihex_write(int ofd, int type, uint64_t addr, uint64_t num, const void *buf, size_t sz); static void ihex_write_00(int ofd, uint64_t addr, const void *buf, size_t sz); static void ihex_write_01(int ofd); static void ihex_write_04(int ofd, uint16_t addr); static void ihex_write_05(int ofd, uint64_t e_entry); static struct section *new_data_section(struct elfcopy *ecp, int sec_index, uint64_t off, uint64_t addr); static int read_num(const char *line, int *len, uint64_t *num, size_t sz, int *checksum); static int srec_read(const char *line, char *type, uint64_t *addr, uint8_t *data, size_t *sz); static void srec_write(int ofd, char type, uint64_t addr, const void *buf, size_t sz); static void srec_write_symtab(int ofd, const char *ofn, Elf *e, Elf_Scn *scn, GElf_Shdr *sh); static void srec_write_S0(int ofd, const char *ofn); static void srec_write_Sd(int ofd, char dr, uint64_t addr, const void *buf, size_t sz, size_t rlen); static void srec_write_Se(int ofd, uint64_t e_entry, int forceS3); static void write_num(char *line, int *len, uint64_t num, size_t sz, int *checksum); #define _LINE_BUFSZ 1024 #define _DATA_BUFSZ 256 /* * Convert ELF object to S-Record. */ void create_srec(struct elfcopy *ecp, int ifd, int ofd, const char *ofn) { Elf *e; Elf_Scn *scn; Elf_Data *d; GElf_Ehdr eh; GElf_Shdr sh; uint64_t max_addr; size_t rlen; int elferr, addr_sz; char dr; if ((e = elf_begin(ifd, ELF_C_READ, NULL)) == NULL) errx(EXIT_FAILURE, "elf_begin() failed: %s", elf_errmsg(-1)); /* Output a symbol table for `symbolsrec' target. */ if (!strncmp(ecp->otgt, "symbolsrec", strlen("symbolsrec"))) { scn = NULL; while ((scn = elf_nextscn(e, scn)) != NULL) { if (gelf_getshdr(scn, &sh) == NULL) { warnx("gelf_getshdr failed: %s", elf_errmsg(-1)); (void) elf_errno(); continue; } if (sh.sh_type != SHT_SYMTAB) continue; srec_write_symtab(ofd, ofn, e, scn, &sh); break; } } if (ecp->flags & SREC_FORCE_S3) dr = '3'; else { /* * Find maximum address size in the first iteration. */ max_addr = 0; scn = NULL; while ((scn = elf_nextscn(e, scn)) != NULL) { if (gelf_getshdr(scn, &sh) == NULL) { warnx("gelf_getshdr failed: %s", elf_errmsg(-1)); (void) elf_errno(); continue; } if ((sh.sh_flags & SHF_ALLOC) == 0 || sh.sh_type == SHT_NOBITS || sh.sh_size == 0) continue; if ((uint64_t) sh.sh_addr > max_addr) max_addr = sh.sh_addr; } elferr = elf_errno(); if (elferr != 0) warnx("elf_nextscn failed: %s", elf_errmsg(elferr)); if (max_addr <= 0xFFFF) dr = '1'; else if (max_addr <= 0xFFFFFF) dr = '2'; else dr = '3'; } if (ecp->flags & SREC_FORCE_LEN) { addr_sz = dr - '0' + 1; if (ecp->srec_len < 1) rlen = 1; else if (ecp->srec_len + addr_sz + 1 > 255) rlen = 255 - (addr_sz + 1); else rlen = ecp->srec_len; } else rlen = 16; /* Generate S0 record which contains the output filename. */ srec_write_S0(ofd, ofn); /* Generate S{1,2,3} data records for section data. */ scn = NULL; while ((scn = elf_nextscn(e, scn)) != NULL) { if (gelf_getshdr(scn, &sh) == NULL) { warnx("gelf_getshdr failed: %s", elf_errmsg(-1)); (void) elf_errno(); continue; } if ((sh.sh_flags & SHF_ALLOC) == 0 || sh.sh_type == SHT_NOBITS || sh.sh_size == 0) continue; if (sh.sh_addr > 0xFFFFFFFF) { warnx("address space too big for S-Record file"); continue; } (void) elf_errno(); if ((d = elf_getdata(scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("elf_getdata failed: %s", elf_errmsg(-1)); continue; } if (d->d_buf == NULL || d->d_size == 0) continue; srec_write_Sd(ofd, dr, sh.sh_addr, d->d_buf, d->d_size, rlen); } elferr = elf_errno(); if (elferr != 0) warnx("elf_nextscn failed: %s", elf_errmsg(elferr)); - /* Generate S{7,8,9} end of block recrod. */ + /* Generate S{7,8,9} end of block record. */ if (gelf_getehdr(e, &eh) == NULL) errx(EXIT_FAILURE, "gelf_getehdr() failed: %s", elf_errmsg(-1)); srec_write_Se(ofd, eh.e_entry, ecp->flags & SREC_FORCE_S3); } void create_elf_from_srec(struct elfcopy *ecp, int ifd) { char line[_LINE_BUFSZ], name[_LINE_BUFSZ]; uint8_t data[_DATA_BUFSZ]; GElf_Ehdr oeh; struct section *s, *shtab; FILE *ifp; uint64_t addr, entry, off, sec_addr; uintmax_t st_value; size_t sz; int _ifd, first, sec_index, in_symtab, symtab_created; char *rlt; char type; if ((_ifd = dup(ifd)) < 0) err(EXIT_FAILURE, "dup failed"); if ((ifp = fdopen(_ifd, "r")) == NULL) err(EXIT_FAILURE, "fdopen failed"); /* Create EHDR for output .o file. */ if (gelf_newehdr(ecp->eout, ecp->oec) == NULL) errx(EXIT_FAILURE, "gelf_newehdr failed: %s", elf_errmsg(-1)); if (gelf_getehdr(ecp->eout, &oeh) == NULL) errx(EXIT_FAILURE, "gelf_getehdr() failed: %s", elf_errmsg(-1)); /* Initialise e_ident fields. */ oeh.e_ident[EI_CLASS] = ecp->oec; oeh.e_ident[EI_DATA] = ecp->oed; /* * TODO: Set OSABI according to the OS platform where elfcopy(1) * was build. (probably) */ oeh.e_ident[EI_OSABI] = ELFOSABI_NONE; oeh.e_machine = ecp->oem; oeh.e_type = ET_REL; oeh.e_entry = 0; ecp->flags |= RELOCATABLE; /* Create .shstrtab section */ init_shstrtab(ecp); ecp->shstrtab->off = 0; /* Data sections are inserted after EHDR. */ off = gelf_fsize(ecp->eout, ELF_T_EHDR, 1, EV_CURRENT); if (off == 0) errx(EXIT_FAILURE, "gelf_fsize() failed: %s", elf_errmsg(-1)); /* Create data sections. */ s = NULL; first = 1; sec_index = 1; sec_addr = entry = 0; while (fgets(line, _LINE_BUFSZ, ifp) != NULL) { if (line[0] == '\r' || line[0] == '\n') continue; if (line[0] == '$' && line[1] == '$') { ecp->flags |= SYMTAB_EXIST; while ((rlt = fgets(line, _LINE_BUFSZ, ifp)) != NULL) { if (line[0] == '$' && line[1] == '$') break; } if (rlt == NULL) break; continue; } if (line[0] != 'S' || line[1] < '0' || line[1] > '9') { warnx("Invalid srec record"); continue; } if (srec_read(line, &type, &addr, data, &sz) < 0) { warnx("Invalid srec record or mismatched checksum"); continue; } switch (type) { case '1': case '2': case '3': if (sz == 0) break; if (first || sec_addr != addr) { if (s != NULL) finalize_data_section(s); s = new_data_section(ecp, sec_index, off, addr); if (s == NULL) { warnx("new_data_section failed"); break; } sec_index++; sec_addr = addr; first = 0; } append_data(s, data, sz); off += sz; sec_addr += sz; break; case '7': case '8': case '9': entry = addr; break; default: break; } } if (s != NULL) finalize_data_section(s); if (ferror(ifp)) warn("fgets failed"); /* Insert .shstrtab after data sections. */ if ((ecp->shstrtab->os = elf_newscn(ecp->eout)) == NULL) errx(EXIT_FAILURE, "elf_newscn failed: %s", elf_errmsg(-1)); insert_to_sec_list(ecp, ecp->shstrtab, 1); /* Insert section header table here. */ shtab = insert_shtab(ecp, 1); /* * Rescan and create symbol table if we found '$$' section in * the first scan. */ symtab_created = 0; in_symtab = 0; if (ecp->flags & SYMTAB_EXIST) { if (fseek(ifp, 0, SEEK_SET) < 0) { warn("fseek failed"); ecp->flags &= ~SYMTAB_EXIST; goto done; } while (fgets(line, _LINE_BUFSZ, ifp) != NULL) { if (in_symtab) { if (line[0] == '$' && line[1] == '$') { in_symtab = 0; continue; } if (sscanf(line, "%s $%jx", name, &st_value) != 2) { warnx("Invalid symbolsrec record"); continue; } if (!symtab_created) { create_external_symtab(ecp); symtab_created = 1; } add_to_symtab(ecp, name, st_value, 0, SHN_ABS, ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE), 0, 1); } if (line[0] == '$' && line[1] == '$') { in_symtab = 1; continue; } } } if (ferror(ifp)) warn("fgets failed"); if (symtab_created) { finalize_external_symtab(ecp); create_symtab_data(ecp); /* Count in .symtab and .strtab section headers. */ shtab->sz += gelf_fsize(ecp->eout, ELF_T_SHDR, 2, EV_CURRENT); } else ecp->flags &= ~SYMTAB_EXIST; done: fclose(ifp); /* Set entry point. */ oeh.e_entry = entry; /* * Write the underlying ehdr. Note that it should be called * before elf_setshstrndx() since it will overwrite e->e_shstrndx. */ if (gelf_update_ehdr(ecp->eout, &oeh) == 0) errx(EXIT_FAILURE, "gelf_update_ehdr() failed: %s", elf_errmsg(-1)); /* Generate section name string table (.shstrtab). */ set_shstrtab(ecp); /* Update sh_name pointer for each section header entry. */ update_shdr(ecp, 0); /* Renew oeh to get the updated e_shstrndx. */ if (gelf_getehdr(ecp->eout, &oeh) == NULL) errx(EXIT_FAILURE, "gelf_getehdr() failed: %s", elf_errmsg(-1)); /* Resync section offsets. */ resync_sections(ecp); /* Store SHDR offset in EHDR. */ oeh.e_shoff = shtab->off; /* Update ehdr since we modified e_shoff. */ if (gelf_update_ehdr(ecp->eout, &oeh) == 0) errx(EXIT_FAILURE, "gelf_update_ehdr() failed: %s", elf_errmsg(-1)); /* Write out the output elf object. */ if (elf_update(ecp->eout, ELF_C_WRITE) < 0) errx(EXIT_FAILURE, "elf_update() failed: %s", elf_errmsg(-1)); /* Release allocated resource. */ free_elf(ecp); } void create_ihex(int ifd, int ofd) { Elf *e; Elf_Scn *scn; Elf_Data *d; GElf_Ehdr eh; GElf_Shdr sh; int elferr; uint16_t addr_hi, old_addr_hi; if ((e = elf_begin(ifd, ELF_C_READ, NULL)) == NULL) errx(EXIT_FAILURE, "elf_begin() failed: %s", elf_errmsg(-1)); old_addr_hi = 0; scn = NULL; while ((scn = elf_nextscn(e, scn)) != NULL) { if (gelf_getshdr(scn, &sh) == NULL) { warnx("gelf_getshdr failed: %s", elf_errmsg(-1)); (void) elf_errno(); continue; } if ((sh.sh_flags & SHF_ALLOC) == 0 || sh.sh_type == SHT_NOBITS || sh.sh_size == 0) continue; if (sh.sh_addr > 0xFFFFFFFF) { warnx("address space too big for Intel Hex file"); continue; } (void) elf_errno(); if ((d = elf_getdata(scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("elf_getdata failed: %s", elf_errmsg(-1)); continue; } if (d->d_buf == NULL || d->d_size == 0) continue; addr_hi = (sh.sh_addr >> 16) & 0xFFFF; if (addr_hi > 0 && addr_hi != old_addr_hi) { /* Write 04 record if addr_hi is new. */ old_addr_hi = addr_hi; ihex_write_04(ofd, addr_hi); } ihex_write_00(ofd, sh.sh_addr, d->d_buf, d->d_size); } elferr = elf_errno(); if (elferr != 0) warnx("elf_nextscn failed: %s", elf_errmsg(elferr)); if (gelf_getehdr(e, &eh) == NULL) errx(EXIT_FAILURE, "gelf_getehdr() failed: %s", elf_errmsg(-1)); ihex_write_05(ofd, eh.e_entry); ihex_write_01(ofd); } void create_elf_from_ihex(struct elfcopy *ecp, int ifd) { char line[_LINE_BUFSZ]; uint8_t data[_DATA_BUFSZ]; GElf_Ehdr oeh; struct section *s, *shtab; FILE *ifp; uint64_t addr, addr_base, entry, num, off, rec_addr, sec_addr; size_t sz; int _ifd, first, sec_index; char type; if ((_ifd = dup(ifd)) < 0) err(EXIT_FAILURE, "dup failed"); if ((ifp = fdopen(_ifd, "r")) == NULL) err(EXIT_FAILURE, "fdopen failed"); /* Create EHDR for output .o file. */ if (gelf_newehdr(ecp->eout, ecp->oec) == NULL) errx(EXIT_FAILURE, "gelf_newehdr failed: %s", elf_errmsg(-1)); if (gelf_getehdr(ecp->eout, &oeh) == NULL) errx(EXIT_FAILURE, "gelf_getehdr() failed: %s", elf_errmsg(-1)); /* Initialise e_ident fields. */ oeh.e_ident[EI_CLASS] = ecp->oec; oeh.e_ident[EI_DATA] = ecp->oed; /* * TODO: Set OSABI according to the OS platform where elfcopy(1) * was build. (probably) */ oeh.e_ident[EI_OSABI] = ELFOSABI_NONE; oeh.e_machine = ecp->oem; oeh.e_type = ET_REL; oeh.e_entry = 0; ecp->flags |= RELOCATABLE; /* Create .shstrtab section */ init_shstrtab(ecp); ecp->shstrtab->off = 0; /* Data sections are inserted after EHDR. */ off = gelf_fsize(ecp->eout, ELF_T_EHDR, 1, EV_CURRENT); if (off == 0) errx(EXIT_FAILURE, "gelf_fsize() failed: %s", elf_errmsg(-1)); /* Create data sections. */ s = NULL; first = 1; sec_index = 1; addr_base = rec_addr = sec_addr = entry = 0; while (fgets(line, _LINE_BUFSZ, ifp) != NULL) { if (line[0] == '\r' || line[0] == '\n') continue; if (line[0] != ':') { warnx("Invalid ihex record"); continue; } if (ihex_read(line, &type, &addr, &num, data, &sz) < 0) { warnx("Invalid ihex record or mismatched checksum"); continue; } switch (type) { case '0': /* Data record. */ if (sz == 0) break; rec_addr = addr_base + addr; if (first || sec_addr != rec_addr) { if (s != NULL) finalize_data_section(s); s = new_data_section(ecp, sec_index, off, rec_addr); if (s == NULL) { warnx("new_data_section failed"); break; } sec_index++; sec_addr = rec_addr; first = 0; } append_data(s, data, sz); off += sz; sec_addr += sz; break; case '1': /* End of file record. */ goto done; case '2': /* Extended segment address record. */ addr_base = addr << 4; break; case '3': /* Start segment address record (CS:IP). Ignored. */ break; case '4': /* Extended linear address record. */ addr_base = num << 16; break; case '5': /* Start linear address record. */ entry = num; break; default: break; } } done: if (s != NULL) finalize_data_section(s); if (ferror(ifp)) warn("fgets failed"); fclose(ifp); /* Insert .shstrtab after data sections. */ if ((ecp->shstrtab->os = elf_newscn(ecp->eout)) == NULL) errx(EXIT_FAILURE, "elf_newscn failed: %s", elf_errmsg(-1)); insert_to_sec_list(ecp, ecp->shstrtab, 1); /* Insert section header table here. */ shtab = insert_shtab(ecp, 1); /* Set entry point. */ oeh.e_entry = entry; /* * Write the underlying ehdr. Note that it should be called * before elf_setshstrndx() since it will overwrite e->e_shstrndx. */ if (gelf_update_ehdr(ecp->eout, &oeh) == 0) errx(EXIT_FAILURE, "gelf_update_ehdr() failed: %s", elf_errmsg(-1)); /* Generate section name string table (.shstrtab). */ set_shstrtab(ecp); /* Update sh_name pointer for each section header entry. */ update_shdr(ecp, 0); /* Renew oeh to get the updated e_shstrndx. */ if (gelf_getehdr(ecp->eout, &oeh) == NULL) errx(EXIT_FAILURE, "gelf_getehdr() failed: %s", elf_errmsg(-1)); /* Resync section offsets. */ resync_sections(ecp); /* Store SHDR offset in EHDR. */ oeh.e_shoff = shtab->off; /* Update ehdr since we modified e_shoff. */ if (gelf_update_ehdr(ecp->eout, &oeh) == 0) errx(EXIT_FAILURE, "gelf_update_ehdr() failed: %s", elf_errmsg(-1)); /* Write out the output elf object. */ if (elf_update(ecp->eout, ELF_C_WRITE) < 0) errx(EXIT_FAILURE, "elf_update() failed: %s", elf_errmsg(-1)); /* Release allocated resource. */ free_elf(ecp); } #define _SEC_NAMESZ 64 #define _SEC_INIT_CAP 1024 static struct section * new_data_section(struct elfcopy *ecp, int sec_index, uint64_t off, uint64_t addr) { char *name; if ((name = malloc(_SEC_NAMESZ)) == NULL) errx(EXIT_FAILURE, "malloc failed"); snprintf(name, _SEC_NAMESZ, ".sec%d", sec_index); return (create_external_section(ecp, name, name, NULL, 0, off, SHT_PROGBITS, ELF_T_BYTE, SHF_ALLOC | SHF_WRITE, 1, addr, 0)); } static void finalize_data_section(struct section *s) { Elf_Data *od; if ((od = elf_newdata(s->os)) == NULL) errx(EXIT_FAILURE, "elf_newdata() failed: %s", elf_errmsg(-1)); od->d_align = s->align; od->d_off = 0; od->d_buf = s->buf; od->d_size = s->sz; od->d_version = EV_CURRENT; } static void append_data(struct section *s, const void *buf, size_t sz) { uint8_t *p; if (s->buf == NULL) { s->sz = 0; s->cap = _SEC_INIT_CAP; if ((s->buf = malloc(s->cap)) == NULL) err(EXIT_FAILURE, "malloc failed"); } while (sz + s->sz > s->cap) { s->cap *= 2; if ((s->buf = realloc(s->buf, s->cap)) == NULL) err(EXIT_FAILURE, "realloc failed"); } p = s->buf; memcpy(&p[s->sz], buf, sz); s->sz += sz; } static int srec_read(const char *line, char *type, uint64_t *addr, uint8_t *data, size_t *sz) { uint64_t count, _checksum, num; size_t addr_sz; int checksum, i, len; checksum = 0; len = 2; if (read_num(line, &len, &count, 1, &checksum) < 0) return (-1); *type = line[1]; switch (*type) { case '0': case '1': case '5': case '9': addr_sz = 2; break; case '2': case '8': addr_sz = 3; break; case '3': case '7': addr_sz = 4; break; default: return (-1); } if (read_num(line, &len, addr, addr_sz, &checksum) < 0) return (-1); count -= addr_sz + 1; if (*type >= '0' && *type <= '3') { for (i = 0; (uint64_t) i < count; i++) { if (read_num(line, &len, &num, 1, &checksum) < 0) return -1; data[i] = (uint8_t) num; } *sz = count; } else *sz = 0; if (read_num(line, &len, &_checksum, 1, NULL) < 0) return (-1); if ((int) _checksum != (~checksum & 0xFF)) return (-1); return (0); } static void srec_write_symtab(int ofd, const char *ofn, Elf *e, Elf_Scn *scn, GElf_Shdr *sh) { char line[_LINE_BUFSZ]; GElf_Sym sym; Elf_Data *d; const char *name; size_t sc; int elferr, i; #define _WRITE_LINE do { \ if (write(ofd, line, strlen(line)) != (ssize_t) strlen(line)) \ errx(EXIT_FAILURE, "write failed"); \ } while (0) (void) elf_errno(); if ((d = elf_getdata(scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("elf_getdata failed: %s", elf_errmsg(-1)); return; } if (d->d_buf == NULL || d->d_size == 0) return; snprintf(line, sizeof(line), "$$ %s\r\n", ofn); _WRITE_LINE; sc = d->d_size / sh->sh_entsize; for (i = 1; (size_t) i < sc; i++) { if (gelf_getsym(d, i, &sym) != &sym) { warnx("gelf_getsym failed: %s", elf_errmsg(-1)); continue; } if (GELF_ST_TYPE(sym.st_info) == STT_SECTION || GELF_ST_TYPE(sym.st_info) == STT_FILE) continue; if ((name = elf_strptr(e, sh->sh_link, sym.st_name)) == NULL) { warnx("elf_strptr failed: %s", elf_errmsg(-1)); continue; } snprintf(line, sizeof(line), " %s $%jx\r\n", name, (uintmax_t) sym.st_value); _WRITE_LINE; } snprintf(line, sizeof(line), "$$ \r\n"); _WRITE_LINE; #undef _WRITE_LINE } static void srec_write_S0(int ofd, const char *ofn) { srec_write(ofd, '0', 0, ofn, strlen(ofn)); } static void srec_write_Sd(int ofd, char dr, uint64_t addr, const void *buf, size_t sz, size_t rlen) { const uint8_t *p, *pe; p = buf; pe = p + sz; while (pe - p >= (int) rlen) { srec_write(ofd, dr, addr, p, rlen); addr += rlen; p += rlen; } if (pe - p > 0) srec_write(ofd, dr, addr, p, pe - p); } static void srec_write_Se(int ofd, uint64_t e_entry, int forceS3) { char er; if (e_entry > 0xFFFFFFFF) { warnx("address space too big for S-Record file"); return; } if (forceS3) er = '7'; else { if (e_entry <= 0xFFFF) er = '9'; else if (e_entry <= 0xFFFFFF) er = '8'; else er = '7'; } srec_write(ofd, er, e_entry, NULL, 0); } static void srec_write(int ofd, char type, uint64_t addr, const void *buf, size_t sz) { char line[_LINE_BUFSZ]; const uint8_t *p, *pe; int len, addr_sz, checksum; if (type == '0' || type == '1' || type == '5' || type == '9') addr_sz = 2; else if (type == '2' || type == '8') addr_sz = 3; else addr_sz = 4; checksum = 0; line[0] = 'S'; line[1] = type; len = 2; write_num(line, &len, addr_sz + sz + 1, 1, &checksum); write_num(line, &len, addr, addr_sz, &checksum); for (p = buf, pe = p + sz; p < pe; p++) write_num(line, &len, *p, 1, &checksum); write_num(line, &len, ~checksum & 0xFF, 1, NULL); line[len++] = '\r'; line[len++] = '\n'; if (write(ofd, line, len) != (ssize_t) len) err(EXIT_FAILURE, "write failed"); } static void ihex_write_00(int ofd, uint64_t addr, const void *buf, size_t sz) { uint16_t addr_hi, old_addr_hi; const uint8_t *p, *pe; old_addr_hi = (addr >> 16) & 0xFFFF; p = buf; pe = p + sz; while (pe - p >= 16) { ihex_write(ofd, 0, addr, 0, p, 16); addr += 16; p += 16; addr_hi = (addr >> 16) & 0xFFFF; if (addr_hi != old_addr_hi) { old_addr_hi = addr_hi; ihex_write_04(ofd, addr_hi); } } if (pe - p > 0) ihex_write(ofd, 0, addr, 0, p, pe - p); } static int ihex_read(const char *line, char *type, uint64_t *addr, uint64_t *num, uint8_t *data, size_t *sz) { uint64_t count, _checksum; int checksum, i, len; *sz = 0; checksum = 0; len = 1; if (read_num(line, &len, &count, 1, &checksum) < 0) return (-1); if (read_num(line, &len, addr, 2, &checksum) < 0) return (-1); if (line[len++] != '0') return (-1); *type = line[len++]; checksum += *type - '0'; switch (*type) { case '0': for (i = 0; (uint64_t) i < count; i++) { if (read_num(line, &len, num, 1, &checksum) < 0) return (-1); data[i] = (uint8_t) *num; } *sz = count; break; case '1': if (count != 0) return (-1); break; case '2': case '4': if (count != 2) return (-1); if (read_num(line, &len, num, 2, &checksum) < 0) return (-1); break; case '3': case '5': if (count != 4) return (-1); if (read_num(line, &len, num, 4, &checksum) < 0) return (-1); break; default: return (-1); } if (read_num(line, &len, &_checksum, 1, &checksum) < 0) return (-1); if ((checksum & 0xFF) != 0) { return (-1); } return (0); } static void ihex_write_01(int ofd) { ihex_write(ofd, 1, 0, 0, NULL, 0); } static void ihex_write_04(int ofd, uint16_t addr) { ihex_write(ofd, 4, 0, addr, NULL, 2); } static void ihex_write_05(int ofd, uint64_t e_entry) { if (e_entry > 0xFFFFFFFF) { warnx("address space too big for Intel Hex file"); return; } ihex_write(ofd, 5, 0, e_entry, NULL, 4); } static void ihex_write(int ofd, int type, uint64_t addr, uint64_t num, const void *buf, size_t sz) { char line[_LINE_BUFSZ]; const uint8_t *p, *pe; int len, checksum; if (sz > 16) errx(EXIT_FAILURE, "Internal: ihex_write() sz too big"); checksum = 0; line[0] = ':'; len = 1; write_num(line, &len, sz, 1, &checksum); write_num(line, &len, addr, 2, &checksum); write_num(line, &len, type, 1, &checksum); if (sz > 0) { if (buf != NULL) { for (p = buf, pe = p + sz; p < pe; p++) write_num(line, &len, *p, 1, &checksum); } else write_num(line, &len, num, sz, &checksum); } write_num(line, &len, (~checksum + 1) & 0xFF, 1, NULL); line[len++] = '\r'; line[len++] = '\n'; if (write(ofd, line, len) != (ssize_t) len) err(EXIT_FAILURE, "write failed"); } static int read_num(const char *line, int *len, uint64_t *num, size_t sz, int *checksum) { uint8_t b; *num = 0; for (; sz > 0; sz--) { if (!ishexdigit(line[*len]) || !ishexdigit(line[*len + 1])) return (-1); b = (hex_value(line[*len]) << 4) | hex_value(line[*len + 1]); *num = (*num << 8) | b; *len += 2; if (checksum != NULL) *checksum = (*checksum + b) & 0xFF; } return (0); } static void write_num(char *line, int *len, uint64_t num, size_t sz, int *checksum) { uint8_t b; for (; sz > 0; sz--) { b = (num >> ((sz - 1) * 8)) & 0xFF; line[*len] = hex_digit((b >> 4) & 0xF); line[*len + 1] = hex_digit(b & 0xF); *len += 2; if (checksum != NULL) *checksum = (*checksum + b) & 0xFF; } } static char hex_digit(uint8_t n) { return ((n < 10) ? '0' + n : 'A' + (n - 10)); } static int hex_value(int x) { if (isdigit(x)) return (x - '0'); else if (x >= 'a' && x <= 'f') return (x - 'a' + 10); else return (x - 'A' + 10); } static int ishexdigit(int x) { if (isdigit(x)) return (1); if ((x >= 'a' && x <= 'f') || (x >= 'A' && x <= 'F')) return (1); return (0); } Index: vendor/elftoolchain/dist/elfcopy/binary.c =================================================================== --- vendor/elftoolchain/dist/elfcopy/binary.c (revision 300227) +++ vendor/elftoolchain/dist/elfcopy/binary.c (revision 300228) @@ -1,292 +1,293 @@ /*- * Copyright (c) 2010,2011 Kai Wang * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #include +#include #include #include #include #include #include #include #include "elfcopy.h" -ELFTC_VCSID("$Id: binary.c 3270 2015-12-11 18:48:56Z emaste $"); +ELFTC_VCSID("$Id: binary.c 3445 2016-04-20 19:08:30Z emaste $"); /* * Convert ELF object to `binary'. Sections with SHF_ALLOC flag set * are copied to the result binary. The relative offsets for each section * are retained, so the result binary file might contain "holes". */ void create_binary(int ifd, int ofd) { Elf *e; Elf_Scn *scn; Elf_Data *d; GElf_Shdr sh; off_t base, off; int elferr; if ((e = elf_begin(ifd, ELF_C_READ, NULL)) == NULL) errx(EXIT_FAILURE, "elf_begin() failed: %s", elf_errmsg(-1)); base = 0; if (lseek(ofd, base, SEEK_SET) < 0) err(EXIT_FAILURE, "lseek failed"); /* * Find base offset in the first iteration. */ base = -1; scn = NULL; while ((scn = elf_nextscn(e, scn)) != NULL) { if (gelf_getshdr(scn, &sh) == NULL) { warnx("gelf_getshdr failed: %s", elf_errmsg(-1)); (void) elf_errno(); continue; } if ((sh.sh_flags & SHF_ALLOC) == 0 || sh.sh_type == SHT_NOBITS || sh.sh_size == 0) continue; if (base == -1 || (off_t) sh.sh_offset < base) base = sh.sh_offset; } elferr = elf_errno(); if (elferr != 0) warnx("elf_nextscn failed: %s", elf_errmsg(elferr)); if (base == -1) return; /* * Write out sections in the second iteration. */ scn = NULL; while ((scn = elf_nextscn(e, scn)) != NULL) { if (gelf_getshdr(scn, &sh) == NULL) { warnx("gelf_getshdr failed: %s", elf_errmsg(-1)); (void) elf_errno(); continue; } if ((sh.sh_flags & SHF_ALLOC) == 0 || sh.sh_type == SHT_NOBITS || sh.sh_size == 0) continue; (void) elf_errno(); if ((d = elf_getdata(scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("elf_getdata failed: %s", elf_errmsg(-1)); continue; } if (d->d_buf == NULL || d->d_size == 0) continue; /* lseek to section offset relative to `base'. */ off = sh.sh_offset - base; if (lseek(ofd, off, SEEK_SET) < 0) err(EXIT_FAILURE, "lseek failed"); /* Write out section contents. */ if (write(ofd, d->d_buf, d->d_size) != (ssize_t) d->d_size) err(EXIT_FAILURE, "write failed"); } elferr = elf_errno(); if (elferr != 0) warnx("elf_nextscn failed: %s", elf_errmsg(elferr)); } #define _SYMBOL_NAMSZ 1024 /* * Convert `binary' to ELF object. The input `binary' is converted to * a relocatable (.o) file, a few symbols will also be created to make * it easier to access the binary data in other compilation units. */ void create_elf_from_binary(struct elfcopy *ecp, int ifd, const char *ifn) { char name[_SYMBOL_NAMSZ]; struct section *sec, *sec_temp, *shtab; struct stat sb; GElf_Ehdr oeh; GElf_Shdr sh; void *content; uint64_t off, data_start, data_end, data_size; char *sym_basename, *p; /* Reset internal section list. */ if (!TAILQ_EMPTY(&ecp->v_sec)) TAILQ_FOREACH_SAFE(sec, &ecp->v_sec, sec_list, sec_temp) { TAILQ_REMOVE(&ecp->v_sec, sec, sec_list); free(sec); } if (fstat(ifd, &sb) == -1) err(EXIT_FAILURE, "fstat failed"); /* Read the input binary file to a internal buffer. */ if ((content = malloc(sb.st_size)) == NULL) err(EXIT_FAILURE, "malloc failed"); if (read(ifd, content, sb.st_size) != sb.st_size) err(EXIT_FAILURE, "read failed"); /* * TODO: copy the input binary to output binary verbatim if -O is not * specified. */ /* Create EHDR for output .o file. */ if (gelf_newehdr(ecp->eout, ecp->oec) == NULL) errx(EXIT_FAILURE, "gelf_newehdr failed: %s", elf_errmsg(-1)); if (gelf_getehdr(ecp->eout, &oeh) == NULL) errx(EXIT_FAILURE, "gelf_getehdr() failed: %s", elf_errmsg(-1)); /* Initialise e_ident fields. */ oeh.e_ident[EI_CLASS] = ecp->oec; oeh.e_ident[EI_DATA] = ecp->oed; /* * TODO: Set OSABI according to the OS platform where elfcopy(1) * was build. (probably) */ oeh.e_ident[EI_OSABI] = ELFOSABI_NONE; oeh.e_machine = ecp->oem; oeh.e_type = ET_REL; oeh.e_entry = 0; ecp->flags |= RELOCATABLE; /* Create .shstrtab section */ init_shstrtab(ecp); ecp->shstrtab->off = 0; /* * Create `.data' section which contains the binary data. The * section is inserted immediately after EHDR. */ off = gelf_fsize(ecp->eout, ELF_T_EHDR, 1, EV_CURRENT); if (off == 0) errx(EXIT_FAILURE, "gelf_fsize() failed: %s", elf_errmsg(-1)); (void) create_external_section(ecp, ".data", NULL, content, sb.st_size, off, SHT_PROGBITS, ELF_T_BYTE, SHF_ALLOC | SHF_WRITE, 1, 0, 1); /* Insert .shstrtab after .data section. */ if ((ecp->shstrtab->os = elf_newscn(ecp->eout)) == NULL) errx(EXIT_FAILURE, "elf_newscn failed: %s", elf_errmsg(-1)); insert_to_sec_list(ecp, ecp->shstrtab, 1); /* Insert section header table here. */ shtab = insert_shtab(ecp, 1); /* Count in .symtab and .strtab section headers. */ shtab->sz += gelf_fsize(ecp->eout, ELF_T_SHDR, 2, EV_CURRENT); if ((sym_basename = strdup(ifn)) == NULL) err(1, "strdup"); - p = sym_basename; - while ((p = strchr(p, '.')) != NULL) - *p++ = '_'; + for (p = sym_basename; *p != '\0'; p++) + if (!isalnum(*p)) + *p = '_'; #define _GEN_SYMNAME(S) do { \ snprintf(name, sizeof(name), "%s%s%s", "_binary_", sym_basename, S); \ } while (0) /* * Create symbol table. */ create_external_symtab(ecp); data_start = 0; data_end = data_start + sb.st_size; data_size = sb.st_size; _GEN_SYMNAME("_start"); add_to_symtab(ecp, name, data_start, 0, 1, ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE), 0, 1); _GEN_SYMNAME("_end"); add_to_symtab(ecp, name, data_end, 0, 1, ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE), 0, 1); _GEN_SYMNAME("_size"); add_to_symtab(ecp, name, data_size, 0, SHN_ABS, ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE), 0, 1); finalize_external_symtab(ecp); create_symtab_data(ecp); #undef _GEN_SYMNAME free(sym_basename); /* * Write the underlying ehdr. Note that it should be called * before elf_setshstrndx() since it will overwrite e->e_shstrndx. */ if (gelf_update_ehdr(ecp->eout, &oeh) == 0) errx(EXIT_FAILURE, "gelf_update_ehdr() failed: %s", elf_errmsg(-1)); /* Generate section name string table (.shstrtab). */ ecp->flags |= SYMTAB_EXIST; set_shstrtab(ecp); /* Update sh_name pointer for each section header entry. */ update_shdr(ecp, 0); /* Properly set sh_link field of .symtab section. */ if (gelf_getshdr(ecp->symtab->os, &sh) == NULL) errx(EXIT_FAILURE, "692 gelf_getshdr() failed: %s", elf_errmsg(-1)); sh.sh_link = elf_ndxscn(ecp->strtab->os); if (!gelf_update_shdr(ecp->symtab->os, &sh)) errx(EXIT_FAILURE, "gelf_update_shdr() failed: %s", elf_errmsg(-1)); /* Renew oeh to get the updated e_shstrndx. */ if (gelf_getehdr(ecp->eout, &oeh) == NULL) errx(EXIT_FAILURE, "gelf_getehdr() failed: %s", elf_errmsg(-1)); /* Resync section offsets. */ resync_sections(ecp); /* Store SHDR offset in EHDR. */ oeh.e_shoff = shtab->off; /* Update ehdr since we modified e_shoff. */ if (gelf_update_ehdr(ecp->eout, &oeh) == 0) errx(EXIT_FAILURE, "gelf_update_ehdr() failed: %s", elf_errmsg(-1)); /* Write out the output elf object. */ if (elf_update(ecp->eout, ELF_C_WRITE) < 0) errx(EXIT_FAILURE, "elf_update() failed: %s", elf_errmsg(-1)); /* Release allocated resource. */ free(content); free_elf(ecp); } Index: vendor/elftoolchain/dist/elfcopy/elfcopy.1 =================================================================== --- vendor/elftoolchain/dist/elfcopy/elfcopy.1 (revision 300227) +++ vendor/elftoolchain/dist/elfcopy/elfcopy.1 (revision 300228) @@ -1,349 +1,364 @@ .\" Copyright (c) 2008-2009,2011 Joseph Koshy. All rights reserved. .\" .\" Redistribution and use in source and binary forms, with or without .\" modification, are permitted provided that the following conditions .\" are met: .\" 1. Redistributions of source code must retain the above copyright .\" notice, this list of conditions and the following disclaimer. .\" 2. Redistributions in binary form must reproduce the above copyright .\" notice, this list of conditions and the following disclaimer in the .\" documentation and/or other materials provided with the distribution. .\" .\" This software is provided by Joseph Koshy ``as is'' and .\" any express or implied warranties, including, but not limited to, the .\" implied warranties of merchantability and fitness for a particular purpose .\" are disclaimed. in no event shall Joseph Koshy be liable .\" for any direct, indirect, incidental, special, exemplary, or consequential .\" damages (including, but not limited to, procurement of substitute goods .\" or services; loss of use, data, or profits; or business interruption) .\" however caused and on any theory of liability, whether in contract, strict .\" liability, or tort (including negligence or otherwise) arising in any way .\" out of the use of this software, even if advised of the possibility of .\" such damage. .\" -.\" $Id: elfcopy.1 3381 2016-01-30 19:39:47Z jkoshy $ +.\" $Id: elfcopy.1 3426 2016-03-05 13:32:28Z emaste $ .\" -.Dd January 29, 2016 +.Dd March 5, 2016 .Os .Dt ELFCOPY 1 .Sh NAME .Nm elfcopy , .Nm objcopy .Nd copy and translate object files .Sh SYNOPSIS .Nm .Op Fl I Ar objformat | Fl s Ar objformat | Fl -input-target= Ns Ar objformat .Op Fl K Ar symbolname | Fl -keep-symbol= Ns Ar symbolname .Op Fl L Ar symbolname | Fl -localize-symbol= Ns Ar symbolname .Op Fl N Ar symbolname | Fl -strip-symbol= Ns Ar symbolname .Op Fl O Ar objformat | Fl -output-target= Ns Ar objformat .Op Fl R Ar sectionname | Fl -remove-section= Ns Ar sectionname .Op Fl S | Fl -strip-all .Op Fl V | Fl -version .Op Fl W Ar symbolname | Fl -weaken-symbol= Ns Ar symbolname .Op Fl X | Fl -discard-locals .Op Fl d | Fl g | Fl -strip-debug .Op Fl h | Fl -help .Op Fl j Ar sectionname | Fl -only-section= Ns Ar sectionname .Op Fl p | Fl -preserve-dates .Op Fl w | Fl -wildcard .Op Fl x | Fl -discard-all .Op Fl -add-gnu-debuglink Ns = Ns Ar filename .Op Fl -add-section Ar sectionname Ns = Ns Ar filename .Oo .Fl -adjust-section-vma Ar section Ns {+|-|=} Ns Ar val | .Fl -change-section-address Ar section Ns {+|-|=} Ns Ar val .Oc .Oo .Fl -adjust-start Ns = Ns Ar increment | .Fl -change-start Ns = Ns Ar increment .Oc .Oo .Fl -adjust-vma Ns = Ns Ar increment | .Fl -change-addresses Ns = Ns Ar increment .Oc .Op Fl -adjust-warnings | Fl -change-warnings .Op Fl -change-section-lma Ar section Ns {+|-|=} Ns Ar val .Op Fl -change-section-vma Ar section Ns {+|-|=} Ns Ar val .Op Fl -extract-dwo .Op Fl -gap-fill Ns = Ns Ar val +.Op Fl -globalize-symbol Ns = Ns ar symbolname +.Op Fl -globalize-symbols Ns = Ns Ar filename .Op Fl -localize-hidden +.Op Fl -localize-symbols Ns = Ns Ar filename .Op Fl -no-adjust-warnings | Fl -no-change-warnings .Op Fl -only-keep-debug .Op Fl -pad-to Ns = Ns Ar address .Op Fl -prefix-alloc-sections Ns = Ns Ar string .Op Fl -prefix-sections Ns = Ns Ar string .Op Fl -prefix-symbols Ns = Ns Ar string .Op Fl -rename-section Ar oldname Ns = Ns Ar newname Ns Op Ar ,flags .Op Fl -set-section-flags Ar sectionname Ns = Ns Ar flags .Op Fl -set-start Ns = Ns Ar address .Op Fl -srec-forceS3 .Op Fl -srec-len Ns = Ns Ar val .Op Fl -strip-dwo .Op Fl -strip-unneeded .Ar infile .Op Ar outfile .Sh DESCRIPTION The .Nm utility copies the content of the binary object named by argument .Ar infile to that named by argument .Ar outfile , transforming it according to the command line options specified. If argument .Ar outfile is not specified, .Nm will create a temporary file and will subsequently rename it as .Ar infile . .Pp The .Nm utility supports the following options: .Bl -tag -width indent .It Fl I Ar objformat | Fl s Ar objformat | Fl -input-target= Ns Ar objformat Specify that the input file named by the argument .Ar infile is in the object format specified by the argument .Ar objformat . .It Fl K Ar symbolname | Fl -keep-symbol= Ns Ar symbolname Copy the symbol named by argument .Ar symbolname to the output. .It Fl L Ar symbolname | Fl -localize-symbol= Ns Ar symbolname Make the symbol named by argument .Ar symbolname local to the output file. .It Fl N Ar symbol | Fl -strip-symbol= Ns Ar symbolname Do not copy the symbol named by argument .Ar symbolname to the output. .It Fl O Ar objformat | Fl -output-target= Ns Ar objformat Write the output file using the object format specified in argument .Ar objformat . The argument .Ar objformat should be one of the target names recognized by .Xr elftc_bfd_find_target 3 . .It Fl R Ar sectionname | Fl -remove-section= Ns Ar sectionname Remove any section with name .Ar sectionname from the output file. .It Fl S | Fl -strip-all Do not copy symbol and relocation information to the target file. .It Fl V | Fl -version Print a version identifier and exit. .It Fl W Ar symbolname | Fl -weaken-symbol= Ns Ar symbolname Mark the symbol named by argument .Ar symbolname as weak in the output. .It Fl X | Fl -discard-locals Do not copy compiler generated local symbols to the output. .It Fl d | Fl g | Fl -strip-debug Do not copy debugging information to the target file. .It Fl h | Fl -help Display a help message and exit. .It Fl j Ar sectionname | Fl -only-section= Ns Ar sectionname Copy only the section named by argument .Ar sectionname to the output. .It Fl p | Fl -preserve-dates Set the access and modification times of the output file to the same as those of the input. .It Fl w | Fl -wildcard Use shell-style patterns to name symbols. The following meta-characters are recognized in patterns: .Bl -tag -width "...." -compact .It Li ! If this is the first character of the pattern, invert the sense of the pattern match. .It Li * Matches any string of characters in a symbol name. .It Li ? Matches zero or one character in a symbol name. .It Li [ Mark the start of a character class. .It Li \e Remove the special meaning of the next character in the pattern. .It Li ] Mark the end of a character class. .El .It Fl x | Fl -discard-all Do not copy non-global symbols to the output. .It Fl -add-gnu-debuglink Ns = Ns Ar filename Create a .gnu_debuglink section in the output file that references the debug data in .Ar filename . .It Fl -add-section Ar sectionname Ns = Ns Ar filename Add a new section to the output file with name .Ar sectionname . The contents of the section are taken from the file named by argument .Ar filename . The size of the section will be the number of bytes in file .Ar filename . .It Xo .Fl -adjust-section-vma Ar section Ns {+|-|=} Ns Ar val | .Fl -change-section-address Ar section Ns {+|-|=} Ns Ar val .Xc Depending on the operator specified, increase, decrease or set both the virtual memory address and the load memory address of the section named by the argument .Ar section . The argument .Ar val specifies the desired increment, decrement or new value for the address. .It Xo .Fl -adjust-start Ns = Ns Ar increment | .Fl -change-start Ns = Ns Ar increment .Xc Increase the entry point address of the output ELF object by the value specified in the argument .Ar increment . .It Xo .Fl -adjust-vma Ns = Ns Ar increment | .Fl -change-addresses Ns = Ns Ar increment .Xc Increase the virtual memory address and the load memory address of all sections by the value specified by the argument .Ar increment . .It Fl -adjust-warnings | Fl -change-warnings Issue a warning if the section specified by the options .Fl -change-section-address , .Fl -change-section-lma or .Fl -change-section-vma does not exist in the input object. This is the default. .It Fl -change-section-lma Ar section Ns {+|-|=} Ns Ar val Change or set the load memory address of the section named by the argument .Ar section . Depending on the operator specified, the value in argument .Ar val will be used as an increment, a decrement or as the new value of the load memory address. .It Fl -change-section-vma Ar section Ns {+|-|=} Ns Ar val Change or set the virtual memory address of the section named by the argument .Ar section . Depending on the operator specified, the value in argument .Ar val will be used as an increment, a decrement or as the new value of the virtual memory address. .It Fl -extract-dwo Copy only .dwo debug sections to the output file. .It Fl -gap-fill Ns = Ns Ar val Fill the gaps between sections with the byte value specified by the argument .Ar val . +.It Fl -globalize-symbol Ns = Ns Ar symbolname +Make the symbol named by argument +.Ar symbolname +global, so that it is visible outside of the file in which it is defined. +.It Fl -globalize-symbols Ns = Ns Ar filename +Make each symbol listed in the file specified by +.Ar filename +global. .It Fl -localize-hidden Make all hidden symbols local to the output file. This includes symbols with internal visiblity. +.It Fl -localize-symbols Ns = Ns Ar filename +Make each symbol listed in the file specified by +.Ar filename +local to the output file. .It Fl -no-adjust-warnings | Fl -no-change-warnings Do not issue a warning if the section specified by the options .Fl -change-section-address , .Fl -change-section-lma or .Fl -change-section-vma is missing in the input object. .It Fl -only-keep-debug Copy only debugging information to the output file. .It Fl -pad-to Ns = Ns Ar address Pad the load memory address of the output object to the value specified by the argument .Ar address by increasing the size of the section with the highest load memory address. .It Fl -prefix-alloc-sections Ns = Ns Ar string Prefix the section names of all the allocated sections with .Ar string . .It Fl -prefix-sections Ns = Ns Ar string Prefix the section names of all the sections with .Ar string . .It Fl -prefix-symbols Ns = Ns Ar string Prefix the symbol names of all the symbols with .Ar string . .It Fl -rename-section Ar oldname Ns = Ns Ar newname Ns Op Ar ,flags Rename the section named by argument .Ar oldname to .Ar newname , optionally changing the sections flags to that specified by argument .Ar flags . Allowed values for the argument .Ar flags are as for option .Fl -set-section-flags below. .It Fl -set-section-flags Ar sectionname Ns = Ns Ar flags Set the flags for the section named by argument .Ar sectionname to those specified by argument .Ar flags . Argument .Ar flags is a comma separated list of the following flag names: .Bl -tag -width "readonly" -compact .It alloc The section occupies space in the output file. .It code The section contains machine instructions. .It contents This flag is accepted but is ignored. .It data The section contains writeable data. .It debug The section holds debugging information. .It load The section is loadable. .It noload The section should not be loaded into memory. .It readonly The section is not writable. .It rom The section contains ROM'able contents. .It share This flag is accepted but is ignored. .El .It Fl -set-start Ns = Ns Ar address Set the start address of the output ELF object to the value specified by the argument .Ar address . .It Fl -srec-forceS3 Only generate S-records of type .Dq S3 . This option is only meaningful when the output target is set to .Dq srec . .It Fl -srec-len Ns = Ns Ar val Set the maximum length of an S-record line to .Ar val . This option is only meaningful when the output target is set to .Dq srec . .It Fl -strip-dwo Do not copy .dwo debug sections to the output file. .It Fl -strip-unneeded Do not copy symbols that are not needed for relocation processing. .El .Sh DIAGNOSTICS .Ex -std .Sh SEE ALSO .Xr ar 1 , .Xr ld 1 , .Xr mcs 1 , .Xr strip 1 , .Xr elf 3 , .Xr elftc_bfd_find_target 3 , .Xr ar 5 , .Xr elf 5 .Sh COMPATIBILITY The .Nm utility is expected to be option compatible with GNU .Nm objcopy . .Sh HISTORY .Nm has been implemented by .An Kai Wang Aq Mt kaiwang27@users.sourceforge.net . Index: vendor/elftoolchain/dist/elfcopy/elfcopy.h =================================================================== --- vendor/elftoolchain/dist/elfcopy/elfcopy.h (revision 300227) +++ vendor/elftoolchain/dist/elfcopy/elfcopy.h (revision 300228) @@ -1,319 +1,320 @@ /*- * Copyright (c) 2007-2013 Kai Wang * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: elfcopy.h 3310 2016-01-10 09:10:54Z kaiwang27 $ + * $Id: elfcopy.h 3446 2016-05-03 01:31:17Z emaste $ */ #include #include #include #include "_elftc.h" /* * User specified symbol operation (strip, keep, localize, globalize, * weaken, rename, etc). */ struct symop { const char *name; const char *newname; #define SYMOP_KEEP 0x0001U #define SYMOP_STRIP 0x0002U #define SYMOP_GLOBALIZE 0x0004U #define SYMOP_LOCALIZE 0x0008U #define SYMOP_KEEPG 0x0010U #define SYMOP_WEAKEN 0x0020U #define SYMOP_REDEF 0x0040U unsigned int op; STAILQ_ENTRY(symop) symop_list; }; /* File containing symbol list. */ struct symfile { dev_t dev; ino_t ino; size_t size; char *data; unsigned int op; STAILQ_ENTRY(symfile) symfile_list; }; /* Sections to copy/remove/rename/... */ struct sec_action { const char *name; const char *addopt; const char *newname; const char *string; uint64_t lma; uint64_t vma; int64_t lma_adjust; int64_t vma_adjust; #define SF_ALLOC 0x0001U #define SF_LOAD 0x0002U #define SF_NOLOAD 0x0004U #define SF_READONLY 0x0008U #define SF_DEBUG 0x0010U #define SF_CODE 0x0020U #define SF_DATA 0x0040U #define SF_ROM 0x0080U #define SF_SHARED 0X0100U #define SF_CONTENTS 0x0200U int flags; int add; int append; int compress; int copy; int print; int remove; int rename; int setflags; int setlma; int setvma; STAILQ_ENTRY(sec_action) sac_list; }; /* Sections to add from file. */ struct sec_add { char *name; char *content; size_t size; STAILQ_ENTRY(sec_add) sadd_list; }; struct segment; /* Internal data structure for sections. */ struct section { struct segment *seg; /* containing segment */ struct segment *seg_tls; /* tls segment */ const char *name; /* section name */ char *newname; /* new section name */ Elf_Scn *is; /* input scn */ Elf_Scn *os; /* output scn */ void *buf; /* section content */ uint8_t *pad; /* section padding */ uint64_t off; /* section offset */ uint64_t sz; /* section size */ uint64_t cap; /* section capacity */ uint64_t align; /* section alignment */ uint64_t type; /* section type */ uint64_t vma; /* section virtual addr */ uint64_t lma; /* section load addr */ uint64_t pad_sz;/* section padding size */ int loadable; /* whether loadable */ int pseudo; int nocopy; TAILQ_ENTRY(section) sec_list; /* next section */ }; /* Internal data structure for segments. */ struct segment { - uint64_t addr; /* load addr */ + uint64_t vaddr; /* virtual addr (VMA) */ + uint64_t paddr; /* physical addr (LMA) */ uint64_t off; /* file offset */ uint64_t fsz; /* file size */ uint64_t msz; /* memory size */ uint64_t type; /* segment type */ int remove; /* whether remove */ int nsec; /* number of sections contained */ struct section **v_sec; /* list of sections contained */ STAILQ_ENTRY(segment) seg_list; /* next segment */ }; /* * In-memory representation of ar(1) archive member(object). */ struct ar_obj { char *name; /* member name */ char *buf; /* member content */ void *maddr; /* mmap start address */ uid_t uid; /* user id */ gid_t gid; /* group id */ mode_t md; /* octal file permissions */ size_t size; /* member size */ time_t mtime; /* modification time */ STAILQ_ENTRY(ar_obj) objs; }; /* * Structure encapsulates the "global" data for "elfcopy" program. */ struct elfcopy { const char *progname; /* program name */ int iec; /* elfclass of input object */ Elftc_Bfd_Target_Flavor itf; /* flavour of input object */ Elftc_Bfd_Target_Flavor otf; /* flavour of output object */ const char *otgt; /* output target name */ int oec; /* elfclass of output object */ - unsigned char oed; /* endianess of output object */ + unsigned char oed; /* endianness of output object */ int oem; /* EM_XXX of output object */ int abi; /* OSABI of output object */ Elf *ein; /* ELF descriptor of input object */ Elf *eout; /* ELF descriptor of output object */ int iphnum; /* num. of input object phdr entries */ int ophnum; /* num. of output object phdr entries */ int nos; /* num. of output object sections */ enum { STRIP_NONE = 0, STRIP_ALL, STRIP_DEBUG, STRIP_DWO, STRIP_NONDEBUG, STRIP_NONDWO, STRIP_UNNEEDED } strip; #define EXECUTABLE 0x00000001U #define DYNAMIC 0x00000002U #define RELOCATABLE 0x00000004U #define SYMTAB_EXIST 0x00000010U #define SYMTAB_INTACT 0x00000020U #define KEEP_GLOBAL 0x00000040U #define DISCARD_LOCAL 0x00000080U #define WEAKEN_ALL 0x00000100U #define PRESERVE_DATE 0x00001000U #define SREC_FORCE_S3 0x00002000U #define SREC_FORCE_LEN 0x00004000U #define SET_START 0x00008000U #define GAP_FILL 0x00010000U #define WILDCARD 0x00020000U #define NO_CHANGE_WARN 0x00040000U #define SEC_ADD 0x00080000U #define SEC_APPEND 0x00100000U #define SEC_COMPRESS 0x00200000U #define SEC_PRINT 0x00400000U #define SEC_REMOVE 0x00800000U #define SEC_COPY 0x01000000U #define DISCARD_LLABEL 0x02000000U #define LOCALIZE_HIDDEN 0x04000000U int flags; /* elfcopy run control flags. */ int64_t change_addr; /* Section address adjustment. */ int64_t change_start; /* Entry point adjustment. */ uint64_t set_start; /* Entry point value. */ unsigned long srec_len; /* S-Record length. */ uint64_t pad_to; /* load address padding. */ uint8_t fill; /* gap fill value. */ char *prefix_sec; /* section prefix. */ char *prefix_alloc; /* alloc section prefix. */ char *prefix_sym; /* symbol prefix. */ char *debuglink; /* GNU debuglink file. */ struct section *symtab; /* .symtab section. */ struct section *strtab; /* .strtab section. */ struct section *shstrtab; /* .shstrtab section. */ uint64_t *secndx; /* section index map. */ uint64_t *symndx; /* symbol index map. */ unsigned char *v_rel; /* symbols needed by relocation. */ - unsigned char *v_grp; /* symbols refered by section group. */ + unsigned char *v_grp; /* symbols referred by section group. */ unsigned char *v_secsym; /* sections with section symbol. */ STAILQ_HEAD(, segment) v_seg; /* list of segments. */ STAILQ_HEAD(, sec_action) v_sac;/* list of section operations. */ STAILQ_HEAD(, sec_add) v_sadd; /* list of sections to add. */ STAILQ_HEAD(, symop) v_symop; /* list of symbols operations. */ STAILQ_HEAD(, symfile) v_symfile; /* list of symlist files. */ TAILQ_HEAD(, section) v_sec; /* list of sections. */ /* * Fields for the ar(1) archive. */ char *as; /* buffer for archive string table. */ size_t as_sz; /* current size of as table. */ size_t as_cap; /* capacity of as table buffer. */ uint32_t s_cnt; /* current number of symbols. */ uint32_t *s_so; /* symbol offset table. */ size_t s_so_cap; /* capacity of so table buffer. */ char *s_sn; /* symbol name table */ size_t s_sn_cap; /* capacity of sn table buffer. */ size_t s_sn_sz; /* current size of sn table. */ off_t rela_off; /* offset relative to pseudo members. */ STAILQ_HEAD(, ar_obj) v_arobj; /* archive object(member) list. */ }; void add_section(struct elfcopy *_ecp, const char *_optarg); void add_to_shstrtab(struct elfcopy *_ecp, const char *_name); void add_to_symop_list(struct elfcopy *_ecp, const char *_name, const char *_newname, unsigned int _op); void add_to_symtab(struct elfcopy *_ecp, const char *_name, uint64_t _st_value, uint64_t _st_size, uint16_t _st_shndx, unsigned char _st_info, unsigned char _st_other, int _ndx_known); int add_to_inseg_list(struct elfcopy *_ecp, struct section *_sec); void adjust_addr(struct elfcopy *_ecp); void copy_content(struct elfcopy *_ecp); void copy_data(struct section *_s); void copy_phdr(struct elfcopy *_ecp); void copy_shdr(struct elfcopy *_ecp, struct section *_s, const char *_name, int _copy, int _sec_flags); void create_binary(int _ifd, int _ofd); void create_elf(struct elfcopy *_ecp); void create_elf_from_binary(struct elfcopy *_ecp, int _ifd, const char *ifn); void create_elf_from_ihex(struct elfcopy *_ecp, int _ifd); void create_elf_from_srec(struct elfcopy *_ecp, int _ifd); struct section *create_external_section(struct elfcopy *_ecp, const char *_name, char *_newname, void *_buf, uint64_t _size, uint64_t _off, uint64_t _stype, Elf_Type _dtype, uint64_t flags, uint64_t _align, uint64_t _vma, int _loadable); void create_external_symtab(struct elfcopy *_ecp); void create_ihex(int _ifd, int _ofd); void create_pe(struct elfcopy *_ecp, int _ifd, int _ofd); void create_scn(struct elfcopy *_ecp); void create_srec(struct elfcopy *_ecp, int _ifd, int _ofd, const char *_ofn); void create_symtab(struct elfcopy *_ecp); void create_symtab_data(struct elfcopy *_ecp); void create_tempfile(char **_fn, int *_fd); void finalize_external_symtab(struct elfcopy *_ecp); void free_elf(struct elfcopy *_ecp); void free_sec_act(struct elfcopy *_ecp); void free_sec_add(struct elfcopy *_ecp); void free_symtab(struct elfcopy *_ecp); void init_shstrtab(struct elfcopy *_ecp); void insert_to_sec_list(struct elfcopy *_ecp, struct section *_sec, int _tail); struct section *insert_shtab(struct elfcopy *_ecp, int tail); int is_remove_reloc_sec(struct elfcopy *_ecp, uint32_t _sh_info); int is_remove_section(struct elfcopy *_ecp, const char *_name); struct sec_action *lookup_sec_act(struct elfcopy *_ecp, const char *_name, int _add); struct symop *lookup_symop_list(struct elfcopy *_ecp, const char *_name, unsigned int _op); void resync_sections(struct elfcopy *_ecp); void set_shstrtab(struct elfcopy *_ecp); void setup_phdr(struct elfcopy *_ecp); void update_shdr(struct elfcopy *_ecp, int _update_link); #ifndef LIBELF_AR int ac_detect_ar(int _ifd); void ac_create_ar(struct elfcopy *_ecp, int _ifd, int _ofd); #endif /* ! LIBELF_AR */ Index: vendor/elftoolchain/dist/elfcopy/main.c =================================================================== --- vendor/elftoolchain/dist/elfcopy/main.c (revision 300227) +++ vendor/elftoolchain/dist/elfcopy/main.c (revision 300228) @@ -1,1564 +1,1577 @@ /*- * Copyright (c) 2007-2013 Kai Wang * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #include #include #include #include #include #include #include #include #include #include #include "elfcopy.h" -ELFTC_VCSID("$Id: main.c 3399 2016-02-12 18:07:56Z emaste $"); +ELFTC_VCSID("$Id: main.c 3446 2016-05-03 01:31:17Z emaste $"); enum options { ECP_ADD_GNU_DEBUGLINK, ECP_ADD_SECTION, ECP_CHANGE_ADDR, ECP_CHANGE_SEC_ADDR, ECP_CHANGE_SEC_LMA, ECP_CHANGE_SEC_VMA, ECP_CHANGE_START, ECP_CHANGE_WARN, ECP_GAP_FILL, ECP_GLOBALIZE_SYMBOL, ECP_GLOBALIZE_SYMBOLS, ECP_KEEP_SYMBOLS, ECP_KEEP_GLOBAL_SYMBOLS, ECP_LOCALIZE_HIDDEN, ECP_LOCALIZE_SYMBOLS, ECP_NO_CHANGE_WARN, ECP_ONLY_DEBUG, ECP_ONLY_DWO, ECP_PAD_TO, ECP_PREFIX_ALLOC, ECP_PREFIX_SEC, ECP_PREFIX_SYM, ECP_REDEF_SYMBOL, ECP_REDEF_SYMBOLS, ECP_RENAME_SECTION, ECP_SET_OSABI, ECP_SET_SEC_FLAGS, ECP_SET_START, ECP_SREC_FORCE_S3, ECP_SREC_LEN, ECP_STRIP_DWO, ECP_STRIP_SYMBOLS, ECP_STRIP_UNNEEDED, ECP_WEAKEN_ALL, ECP_WEAKEN_SYMBOLS }; static struct option mcs_longopts[] = { { "help", no_argument, NULL, 'h' }, { "version", no_argument, NULL, 'V' }, { NULL, 0, NULL, 0 } }; static struct option strip_longopts[] = { {"discard-all", no_argument, NULL, 'x'}, {"discard-locals", no_argument, NULL, 'X'}, {"help", no_argument, NULL, 'h'}, {"input-target", required_argument, NULL, 'I'}, {"keep-symbol", required_argument, NULL, 'K'}, {"only-keep-debug", no_argument, NULL, ECP_ONLY_DEBUG}, {"output-file", required_argument, NULL, 'o'}, {"output-target", required_argument, NULL, 'O'}, {"preserve-dates", no_argument, NULL, 'p'}, {"remove-section", required_argument, NULL, 'R'}, {"strip-all", no_argument, NULL, 's'}, {"strip-debug", no_argument, NULL, 'S'}, {"strip-symbol", required_argument, NULL, 'N'}, {"strip-unneeded", no_argument, NULL, ECP_STRIP_UNNEEDED}, {"version", no_argument, NULL, 'V'}, {"wildcard", no_argument, NULL, 'w'}, {NULL, 0, NULL, 0} }; static struct option elfcopy_longopts[] = { {"add-gnu-debuglink", required_argument, NULL, ECP_ADD_GNU_DEBUGLINK}, {"add-section", required_argument, NULL, ECP_ADD_SECTION}, {"adjust-section-vma", required_argument, NULL, ECP_CHANGE_SEC_ADDR}, {"adjust-vma", required_argument, NULL, ECP_CHANGE_ADDR}, {"adjust-start", required_argument, NULL, ECP_CHANGE_START}, {"adjust-warnings", no_argument, NULL, ECP_CHANGE_WARN}, {"binary-architecture", required_argument, NULL, 'B'}, {"change-addresses", required_argument, NULL, ECP_CHANGE_ADDR}, {"change-section-address", required_argument, NULL, ECP_CHANGE_SEC_ADDR}, {"change-section-lma", required_argument, NULL, ECP_CHANGE_SEC_LMA}, {"change-section-vma", required_argument, NULL, ECP_CHANGE_SEC_VMA}, {"change-start", required_argument, NULL, ECP_CHANGE_START}, {"change-warnings", no_argument, NULL, ECP_CHANGE_WARN}, {"discard-all", no_argument, NULL, 'x'}, {"discard-locals", no_argument, NULL, 'X'}, {"extract-dwo", no_argument, NULL, ECP_ONLY_DWO}, {"gap-fill", required_argument, NULL, ECP_GAP_FILL}, {"globalize-symbol", required_argument, NULL, ECP_GLOBALIZE_SYMBOL}, {"globalize-symbols", required_argument, NULL, ECP_GLOBALIZE_SYMBOLS}, {"help", no_argument, NULL, 'h'}, {"input-target", required_argument, NULL, 'I'}, {"keep-symbol", required_argument, NULL, 'K'}, {"keep-symbols", required_argument, NULL, ECP_KEEP_SYMBOLS}, {"keep-global-symbol", required_argument, NULL, 'G'}, {"keep-global-symbols", required_argument, NULL, ECP_KEEP_GLOBAL_SYMBOLS}, {"localize-hidden", no_argument, NULL, ECP_LOCALIZE_HIDDEN}, {"localize-symbol", required_argument, NULL, 'L'}, {"localize-symbols", required_argument, NULL, ECP_LOCALIZE_SYMBOLS}, {"no-adjust-warnings", no_argument, NULL, ECP_NO_CHANGE_WARN}, {"no-change-warnings", no_argument, NULL, ECP_NO_CHANGE_WARN}, {"only-keep-debug", no_argument, NULL, ECP_ONLY_DEBUG}, {"only-section", required_argument, NULL, 'j'}, {"osabi", required_argument, NULL, ECP_SET_OSABI}, {"output-target", required_argument, NULL, 'O'}, {"pad-to", required_argument, NULL, ECP_PAD_TO}, {"preserve-dates", no_argument, NULL, 'p'}, {"prefix-alloc-sections", required_argument, NULL, ECP_PREFIX_ALLOC}, {"prefix-sections", required_argument, NULL, ECP_PREFIX_SEC}, {"prefix-symbols", required_argument, NULL, ECP_PREFIX_SYM}, {"redefine-sym", required_argument, NULL, ECP_REDEF_SYMBOL}, {"redefine-syms", required_argument, NULL, ECP_REDEF_SYMBOLS}, {"remove-section", required_argument, NULL, 'R'}, {"rename-section", required_argument, NULL, ECP_RENAME_SECTION}, {"set-section-flags", required_argument, NULL, ECP_SET_SEC_FLAGS}, {"set-start", required_argument, NULL, ECP_SET_START}, {"srec-forceS3", no_argument, NULL, ECP_SREC_FORCE_S3}, {"srec-len", required_argument, NULL, ECP_SREC_LEN}, {"strip-all", no_argument, NULL, 'S'}, {"strip-debug", no_argument, 0, 'g'}, {"strip-dwo", no_argument, NULL, ECP_STRIP_DWO}, {"strip-symbol", required_argument, NULL, 'N'}, {"strip-symbols", required_argument, NULL, ECP_STRIP_SYMBOLS}, {"strip-unneeded", no_argument, NULL, ECP_STRIP_UNNEEDED}, {"version", no_argument, NULL, 'V'}, {"weaken", no_argument, NULL, ECP_WEAKEN_ALL}, {"weaken-symbol", required_argument, NULL, 'W'}, {"weaken-symbols", required_argument, NULL, ECP_WEAKEN_SYMBOLS}, {"wildcard", no_argument, NULL, 'w'}, {NULL, 0, NULL, 0} }; static struct { const char *name; int value; } sec_flags[] = { {"alloc", SF_ALLOC}, {"load", SF_LOAD}, {"noload", SF_NOLOAD}, {"readonly", SF_READONLY}, {"debug", SF_DEBUG}, {"code", SF_CODE}, {"data", SF_DATA}, {"rom", SF_ROM}, {"share", SF_SHARED}, {"contents", SF_CONTENTS}, {NULL, 0} }; static struct { const char *name; int abi; } osabis[] = { {"sysv", ELFOSABI_SYSV}, {"hpus", ELFOSABI_HPUX}, {"netbsd", ELFOSABI_NETBSD}, {"linux", ELFOSABI_LINUX}, {"hurd", ELFOSABI_HURD}, {"86open", ELFOSABI_86OPEN}, {"solaris", ELFOSABI_SOLARIS}, {"aix", ELFOSABI_AIX}, {"irix", ELFOSABI_IRIX}, {"freebsd", ELFOSABI_FREEBSD}, {"tru64", ELFOSABI_TRU64}, {"modesto", ELFOSABI_MODESTO}, {"openbsd", ELFOSABI_OPENBSD}, {"openvms", ELFOSABI_OPENVMS}, {"nsk", ELFOSABI_NSK}, + {"cloudabi", ELFOSABI_CLOUDABI}, {"arm", ELFOSABI_ARM}, {"standalone", ELFOSABI_STANDALONE}, {NULL, 0} }; static int copy_from_tempfile(const char *src, const char *dst, int infd, int *outfd, int in_place); static void create_file(struct elfcopy *ecp, const char *src, const char *dst); static void elfcopy_main(struct elfcopy *ecp, int argc, char **argv); static void elfcopy_usage(void); static void mcs_main(struct elfcopy *ecp, int argc, char **argv); static void mcs_usage(void); static void parse_sec_address_op(struct elfcopy *ecp, int optnum, const char *optname, char *s); static void parse_sec_flags(struct sec_action *sac, char *s); static void parse_symlist_file(struct elfcopy *ecp, const char *fn, unsigned int op); static void print_version(void); static void set_input_target(struct elfcopy *ecp, const char *target_name); static void set_osabi(struct elfcopy *ecp, const char *abi); static void set_output_target(struct elfcopy *ecp, const char *target_name); static void strip_main(struct elfcopy *ecp, int argc, char **argv); static void strip_usage(void); /* - * An ELF object usually has a sturcture described by the + * An ELF object usually has a structure described by the * diagram below. * _____________ * | | * | NULL | <- always a SHT_NULL section * |_____________| * | | * | .interp | * |_____________| * | | * | ... | * |_____________| * | | * | .text | * |_____________| * | | * | ... | * |_____________| * | | * | .comment | <- above(include) this: normal sections * |_____________| * | | * | add sections| <- unloadable sections added by --add-section * |_____________| * | | * | .shstrtab | <- section name string table * |_____________| * | | * | shdrs | <- section header table * |_____________| * | | * | .symtab | <- symbol table, if any * |_____________| * | | * | .strtab | <- symbol name string table, if any * |_____________| * | | * | .rel.text | <- relocation info for .o files. * |_____________| */ void create_elf(struct elfcopy *ecp) { struct section *shtab; GElf_Ehdr ieh; GElf_Ehdr oeh; size_t ishnum; ecp->flags |= SYMTAB_INTACT; /* Create EHDR. */ if (gelf_getehdr(ecp->ein, &ieh) == NULL) errx(EXIT_FAILURE, "gelf_getehdr() failed: %s", elf_errmsg(-1)); if ((ecp->iec = gelf_getclass(ecp->ein)) == ELFCLASSNONE) errx(EXIT_FAILURE, "getclass() failed: %s", elf_errmsg(-1)); if (ecp->oec == ELFCLASSNONE) ecp->oec = ecp->iec; if (ecp->oed == ELFDATANONE) ecp->oed = ieh.e_ident[EI_DATA]; if (gelf_newehdr(ecp->eout, ecp->oec) == NULL) errx(EXIT_FAILURE, "gelf_newehdr failed: %s", elf_errmsg(-1)); if (gelf_getehdr(ecp->eout, &oeh) == NULL) errx(EXIT_FAILURE, "gelf_getehdr() failed: %s", elf_errmsg(-1)); memcpy(oeh.e_ident, ieh.e_ident, sizeof(ieh.e_ident)); oeh.e_ident[EI_CLASS] = ecp->oec; oeh.e_ident[EI_DATA] = ecp->oed; if (ecp->abi != -1) oeh.e_ident[EI_OSABI] = ecp->abi; oeh.e_flags = ieh.e_flags; oeh.e_machine = ieh.e_machine; oeh.e_type = ieh.e_type; oeh.e_entry = ieh.e_entry; oeh.e_version = ieh.e_version; ecp->flags &= ~(EXECUTABLE | DYNAMIC | RELOCATABLE); if (ieh.e_type == ET_EXEC) ecp->flags |= EXECUTABLE; else if (ieh.e_type == ET_DYN) ecp->flags |= DYNAMIC; else if (ieh.e_type == ET_REL) ecp->flags |= RELOCATABLE; else errx(EXIT_FAILURE, "unsupported e_type"); if (!elf_getshnum(ecp->ein, &ishnum)) errx(EXIT_FAILURE, "elf_getshnum failed: %s", elf_errmsg(-1)); if (ishnum > 0 && (ecp->secndx = calloc(ishnum, sizeof(*ecp->secndx))) == NULL) err(EXIT_FAILURE, "calloc failed"); /* Read input object program header. */ setup_phdr(ecp); /* * Scan of input sections: we iterate through sections from input * object, skip sections need to be stripped, allot Elf_Scn and * create internal section structure for sections we want. * (i.e., determine output sections) */ create_scn(ecp); /* Apply section address changes, if any. */ adjust_addr(ecp); /* * Determine if the symbol table needs to be changed based on * command line options. */ if (ecp->strip == STRIP_DEBUG || ecp->strip == STRIP_UNNEEDED || ecp->flags & WEAKEN_ALL || ecp->flags & LOCALIZE_HIDDEN || ecp->flags & DISCARD_LOCAL || ecp->flags & DISCARD_LLABEL || ecp->prefix_sym != NULL || !STAILQ_EMPTY(&ecp->v_symop)) ecp->flags &= ~SYMTAB_INTACT; /* * Create symbol table. Symbols are filtered or stripped according to * command line args specified by user, and later updated for the new * layout of sections in the output object. */ if ((ecp->flags & SYMTAB_EXIST) != 0) create_symtab(ecp); /* * First processing of output sections: at this stage we copy the * content of each section from input to output object. Section * content will be modified and printed (mcs) if need. Also content of * relocation section probably will be filtered and updated according * to symbol table changes. */ copy_content(ecp); /* * Write the underlying ehdr. Note that it should be called * before elf_setshstrndx() since it will overwrite e->e_shstrndx. */ if (gelf_update_ehdr(ecp->eout, &oeh) == 0) errx(EXIT_FAILURE, "gelf_update_ehdr() failed: %s", elf_errmsg(-1)); /* Generate section name string table (.shstrtab). */ set_shstrtab(ecp); /* * Second processing of output sections: Update section headers. * At this stage we set name string index, update st_link and st_info * for output sections. */ update_shdr(ecp, 1); /* Renew oeh to get the updated e_shstrndx. */ if (gelf_getehdr(ecp->eout, &oeh) == NULL) errx(EXIT_FAILURE, "gelf_getehdr() failed: %s", elf_errmsg(-1)); /* * Insert SHDR table into the internal section list as a "pseudo" * section, so later it will get sorted and resynced just as "normal" * sections. * * Under FreeBSD, Binutils objcopy always put the section header * at the end of all the sections. We want to do the same here. * * However, note that the behaviour is still different with Binutils: * elfcopy checks the FreeBSD OSABI tag to tell whether it needs to * move the section headers, while Binutils is probably configured * this way when it's compiled on FreeBSD. */ if (oeh.e_ident[EI_OSABI] == ELFOSABI_FREEBSD) shtab = insert_shtab(ecp, 1); else shtab = insert_shtab(ecp, 0); /* * Resync section offsets in the output object. This is needed * because probably sections are modified or new sections are added, * as a result overlap/gap might appears. */ resync_sections(ecp); /* Store SHDR offset in EHDR. */ oeh.e_shoff = shtab->off; /* Put program header table immediately after the Elf header. */ if (ecp->ophnum > 0) { oeh.e_phoff = gelf_fsize(ecp->eout, ELF_T_EHDR, 1, EV_CURRENT); if (oeh.e_phoff == 0) errx(EXIT_FAILURE, "gelf_fsize() failed: %s", elf_errmsg(-1)); } /* * Update ELF object entry point if requested. */ if (ecp->change_addr != 0) oeh.e_entry += ecp->change_addr; if (ecp->flags & SET_START) oeh.e_entry = ecp->set_start; if (ecp->change_start != 0) oeh.e_entry += ecp->change_start; /* * Update ehdr again before we call elf_update(), since we * modified e_shoff and e_phoff. */ if (gelf_update_ehdr(ecp->eout, &oeh) == 0) errx(EXIT_FAILURE, "gelf_update_ehdr() failed: %s", elf_errmsg(-1)); if (ecp->ophnum > 0) copy_phdr(ecp); /* Write out the output elf object. */ if (elf_update(ecp->eout, ELF_C_WRITE) < 0) errx(EXIT_FAILURE, "elf_update() failed: %s", elf_errmsg(-1)); /* Release allocated resource. */ free_elf(ecp); } void free_elf(struct elfcopy *ecp) { struct segment *seg, *seg_temp; struct section *sec, *sec_temp; /* Free internal segment list. */ if (!STAILQ_EMPTY(&ecp->v_seg)) { STAILQ_FOREACH_SAFE(seg, &ecp->v_seg, seg_list, seg_temp) { STAILQ_REMOVE(&ecp->v_seg, seg, segment, seg_list); free(seg); } } /* Free symbol table buffers. */ free_symtab(ecp); /* Free internal section list. */ if (!TAILQ_EMPTY(&ecp->v_sec)) { TAILQ_FOREACH_SAFE(sec, &ecp->v_sec, sec_list, sec_temp) { TAILQ_REMOVE(&ecp->v_sec, sec, sec_list); if (sec->buf != NULL) free(sec->buf); if (sec->newname != NULL) free(sec->newname); if (sec->pad != NULL) free(sec->pad); free(sec); } } if (ecp->secndx != NULL) { free(ecp->secndx); ecp->secndx = NULL; } } /* Create a temporary file. */ void create_tempfile(char **fn, int *fd) { const char *tmpdir; char *cp, *tmpf; size_t tlen, plen; #define _TEMPFILE "ecp.XXXXXXXX" #define _TEMPFILEPATH "/tmp/ecp.XXXXXXXX" if (fn == NULL || fd == NULL) return; /* Repect TMPDIR environment variable. */ tmpdir = getenv("TMPDIR"); if (tmpdir != NULL && *tmpdir != '\0') { tlen = strlen(tmpdir); plen = strlen(_TEMPFILE); tmpf = malloc(tlen + plen + 2); if (tmpf == NULL) err(EXIT_FAILURE, "malloc failed"); strncpy(tmpf, tmpdir, tlen); cp = &tmpf[tlen - 1]; if (*cp++ != '/') *cp++ = '/'; strncpy(cp, _TEMPFILE, plen); cp[plen] = '\0'; } else { tmpf = strdup(_TEMPFILEPATH); if (tmpf == NULL) err(EXIT_FAILURE, "strdup failed"); } if ((*fd = mkstemp(tmpf)) == -1) err(EXIT_FAILURE, "mkstemp %s failed", tmpf); if (fchmod(*fd, 0644) == -1) err(EXIT_FAILURE, "fchmod %s failed", tmpf); *fn = tmpf; #undef _TEMPFILE #undef _TEMPFILEPATH } /* * Copy temporary file with path src and file descriptor infd to path dst. * If in_place is set act as if editing the file in place, avoiding rename() * to preserve hard and symbolic links. Output file remains open, with file * descriptor returned in outfd. */ static int copy_from_tempfile(const char *src, const char *dst, int infd, int *outfd, int in_place) { int tmpfd; /* * First, check if we can use rename(). */ if (in_place == 0) { if (rename(src, dst) >= 0) { *outfd = infd; return (0); } else if (errno != EXDEV) return (-1); /* * If the rename() failed due to 'src' and 'dst' residing in * two different file systems, invoke a helper function in * libelftc to do the copy. */ if (unlink(dst) < 0) return (-1); } if ((tmpfd = open(dst, O_CREAT | O_TRUNC | O_WRONLY, 0755)) < 0) return (-1); if (elftc_copyfile(infd, tmpfd) < 0) return (-1); /* * Remove the temporary file from the file system * namespace, and close its file descriptor. */ if (unlink(src) < 0) return (-1); (void) close(infd); /* * Return the file descriptor for the destination. */ *outfd = tmpfd; return (0); } static void create_file(struct elfcopy *ecp, const char *src, const char *dst) { struct stat sb; char *tempfile, *elftemp; int efd, ifd, ofd, ofd0, tfd; int in_place; tempfile = NULL; if (src == NULL) errx(EXIT_FAILURE, "internal: src == NULL"); if ((ifd = open(src, O_RDONLY)) == -1) err(EXIT_FAILURE, "open %s failed", src); if (fstat(ifd, &sb) == -1) err(EXIT_FAILURE, "fstat %s failed", src); if (dst == NULL) create_tempfile(&tempfile, &ofd); else if ((ofd = open(dst, O_RDWR|O_CREAT, 0755)) == -1) err(EXIT_FAILURE, "open %s failed", dst); #ifndef LIBELF_AR /* Detect and process ar(1) archive using libarchive. */ if (ac_detect_ar(ifd)) { ac_create_ar(ecp, ifd, ofd); goto copy_done; } #endif if (lseek(ifd, 0, SEEK_SET) < 0) err(EXIT_FAILURE, "lseek failed"); /* * If input object is not ELF file, convert it to an intermediate * ELF object before processing. */ if (ecp->itf != ETF_ELF) { + /* + * If the output object is not an ELF file, choose an arbitrary + * ELF format for the intermediate file. srec, ihex and binary + * formats are independent of class, endianness and machine + * type so these choices do not affect the output. + */ + if (ecp->otf != ETF_ELF) { + if (ecp->oec == ELFCLASSNONE) + ecp->oec = ELFCLASS64; + if (ecp->oed == ELFDATANONE) + ecp->oed = ELFDATA2LSB; + } create_tempfile(&elftemp, &efd); if ((ecp->eout = elf_begin(efd, ELF_C_WRITE, NULL)) == NULL) errx(EXIT_FAILURE, "elf_begin() failed: %s", elf_errmsg(-1)); elf_flagelf(ecp->eout, ELF_C_SET, ELF_F_LAYOUT); if (ecp->itf == ETF_BINARY) create_elf_from_binary(ecp, ifd, src); else if (ecp->itf == ETF_IHEX) create_elf_from_ihex(ecp, ifd); else if (ecp->itf == ETF_SREC) create_elf_from_srec(ecp, ifd); else errx(EXIT_FAILURE, "Internal: invalid target flavour"); elf_end(ecp->eout); /* Open intermediate ELF object as new input object. */ close(ifd); if ((ifd = open(elftemp, O_RDONLY)) == -1) err(EXIT_FAILURE, "open %s failed", src); close(efd); free(elftemp); } if ((ecp->ein = elf_begin(ifd, ELF_C_READ, NULL)) == NULL) errx(EXIT_FAILURE, "elf_begin() failed: %s", elf_errmsg(-1)); switch (elf_kind(ecp->ein)) { case ELF_K_NONE: errx(EXIT_FAILURE, "file format not recognized"); case ELF_K_ELF: if ((ecp->eout = elf_begin(ofd, ELF_C_WRITE, NULL)) == NULL) errx(EXIT_FAILURE, "elf_begin() failed: %s", elf_errmsg(-1)); /* elfcopy(1) manage ELF layout by itself. */ elf_flagelf(ecp->eout, ELF_C_SET, ELF_F_LAYOUT); /* * Create output ELF object. */ create_elf(ecp); elf_end(ecp->eout); /* * Convert the output ELF object to binary/srec/ihex if need. */ if (ecp->otf != ETF_ELF) { /* * Create (another) tempfile for binary/srec/ihex * output object. */ if (tempfile != NULL) { if (unlink(tempfile) < 0) err(EXIT_FAILURE, "unlink %s failed", tempfile); free(tempfile); } create_tempfile(&tempfile, &ofd0); /* * Rewind the file descriptor being processed. */ if (lseek(ofd, 0, SEEK_SET) < 0) err(EXIT_FAILURE, "lseek failed for the output object"); /* * Call flavour-specific conversion routine. */ switch (ecp->otf) { case ETF_BINARY: create_binary(ofd, ofd0); break; case ETF_IHEX: create_ihex(ofd, ofd0); break; case ETF_SREC: create_srec(ecp, ofd, ofd0, dst != NULL ? dst : src); break; case ETF_PE: case ETF_EFI: #if WITH_PE create_pe(ecp, ofd, ofd0); #else errx(EXIT_FAILURE, "PE/EFI support not enabled" " at compile time"); #endif break; default: errx(EXIT_FAILURE, "Internal: unsupported" " output flavour %d", ecp->oec); } close(ofd); ofd = ofd0; } break; case ELF_K_AR: /* XXX: Not yet supported. */ break; default: errx(EXIT_FAILURE, "file format not supported"); } elf_end(ecp->ein); #ifndef LIBELF_AR copy_done: #endif if (tempfile != NULL) { in_place = 0; if (dst == NULL) { dst = src; if (lstat(dst, &sb) != -1 && (sb.st_nlink > 1 || S_ISLNK(sb.st_mode))) in_place = 1; } if (copy_from_tempfile(tempfile, dst, ofd, &tfd, in_place) < 0) err(EXIT_FAILURE, "creation of %s failed", dst); free(tempfile); tempfile = NULL; ofd = tfd; } if (strcmp(dst, "/dev/null") && fchmod(ofd, sb.st_mode) == -1) err(EXIT_FAILURE, "fchmod %s failed", dst); if ((ecp->flags & PRESERVE_DATE) && elftc_set_timestamps(dst, &sb) < 0) err(EXIT_FAILURE, "setting timestamps failed"); close(ifd); close(ofd); } static void elfcopy_main(struct elfcopy *ecp, int argc, char **argv) { struct sec_action *sac; const char *infile, *outfile; char *fn, *s; int opt; while ((opt = getopt_long(argc, argv, "dB:gG:I:j:K:L:N:O:pR:s:SwW:xXV", elfcopy_longopts, NULL)) != -1) { switch(opt) { case 'B': /* ignored */ break; case 'R': sac = lookup_sec_act(ecp, optarg, 1); if (sac->copy != 0) errx(EXIT_FAILURE, "both copy and remove specified"); sac->remove = 1; ecp->flags |= SEC_REMOVE; break; case 'S': ecp->strip = STRIP_ALL; break; case 'g': ecp->strip = STRIP_DEBUG; break; case 'G': ecp->flags |= KEEP_GLOBAL; add_to_symop_list(ecp, optarg, NULL, SYMOP_KEEPG); break; case 'I': case 's': set_input_target(ecp, optarg); break; case 'j': sac = lookup_sec_act(ecp, optarg, 1); if (sac->remove != 0) errx(EXIT_FAILURE, "both copy and remove specified"); sac->copy = 1; ecp->flags |= SEC_COPY; break; case 'K': add_to_symop_list(ecp, optarg, NULL, SYMOP_KEEP); break; case 'L': add_to_symop_list(ecp, optarg, NULL, SYMOP_LOCALIZE); break; case 'N': add_to_symop_list(ecp, optarg, NULL, SYMOP_STRIP); break; case 'O': set_output_target(ecp, optarg); break; case 'p': ecp->flags |= PRESERVE_DATE; break; case 'V': print_version(); break; case 'w': ecp->flags |= WILDCARD; break; case 'W': add_to_symop_list(ecp, optarg, NULL, SYMOP_WEAKEN); break; case 'x': ecp->flags |= DISCARD_LOCAL; break; case 'X': ecp->flags |= DISCARD_LLABEL; break; case ECP_ADD_GNU_DEBUGLINK: ecp->debuglink = optarg; break; case ECP_ADD_SECTION: add_section(ecp, optarg); break; case ECP_CHANGE_ADDR: ecp->change_addr = (int64_t) strtoll(optarg, NULL, 0); break; case ECP_CHANGE_SEC_ADDR: parse_sec_address_op(ecp, opt, "--change-section-addr", optarg); break; case ECP_CHANGE_SEC_LMA: parse_sec_address_op(ecp, opt, "--change-section-lma", optarg); break; case ECP_CHANGE_SEC_VMA: parse_sec_address_op(ecp, opt, "--change-section-vma", optarg); break; case ECP_CHANGE_START: ecp->change_start = (int64_t) strtoll(optarg, NULL, 0); break; case ECP_CHANGE_WARN: /* default */ break; case ECP_GAP_FILL: ecp->fill = (uint8_t) strtoul(optarg, NULL, 0); ecp->flags |= GAP_FILL; break; case ECP_GLOBALIZE_SYMBOL: add_to_symop_list(ecp, optarg, NULL, SYMOP_GLOBALIZE); break; case ECP_GLOBALIZE_SYMBOLS: parse_symlist_file(ecp, optarg, SYMOP_GLOBALIZE); break; case ECP_KEEP_SYMBOLS: parse_symlist_file(ecp, optarg, SYMOP_KEEP); break; case ECP_KEEP_GLOBAL_SYMBOLS: parse_symlist_file(ecp, optarg, SYMOP_KEEPG); break; case ECP_LOCALIZE_HIDDEN: ecp->flags |= LOCALIZE_HIDDEN; break; case ECP_LOCALIZE_SYMBOLS: parse_symlist_file(ecp, optarg, SYMOP_LOCALIZE); break; case ECP_NO_CHANGE_WARN: ecp->flags |= NO_CHANGE_WARN; break; case ECP_ONLY_DEBUG: ecp->strip = STRIP_NONDEBUG; break; case ECP_ONLY_DWO: ecp->strip = STRIP_NONDWO; break; case ECP_PAD_TO: ecp->pad_to = (uint64_t) strtoull(optarg, NULL, 0); break; case ECP_PREFIX_ALLOC: ecp->prefix_alloc = optarg; break; case ECP_PREFIX_SEC: ecp->prefix_sec = optarg; break; case ECP_PREFIX_SYM: ecp->prefix_sym = optarg; break; case ECP_REDEF_SYMBOL: if ((s = strchr(optarg, '=')) == NULL) errx(EXIT_FAILURE, "illegal format for --redefine-sym"); *s++ = '\0'; add_to_symop_list(ecp, optarg, s, SYMOP_REDEF); break; case ECP_REDEF_SYMBOLS: parse_symlist_file(ecp, optarg, SYMOP_REDEF); break; case ECP_RENAME_SECTION: if ((fn = strchr(optarg, '=')) == NULL) errx(EXIT_FAILURE, "illegal format for --rename-section"); *fn++ = '\0'; /* Check for optional flags. */ if ((s = strchr(fn, ',')) != NULL) *s++ = '\0'; sac = lookup_sec_act(ecp, optarg, 1); sac->rename = 1; sac->newname = fn; if (s != NULL) parse_sec_flags(sac, s); break; case ECP_SET_OSABI: set_osabi(ecp, optarg); break; case ECP_SET_SEC_FLAGS: if ((s = strchr(optarg, '=')) == NULL) errx(EXIT_FAILURE, "illegal format for --set-section-flags"); *s++ = '\0'; sac = lookup_sec_act(ecp, optarg, 1); parse_sec_flags(sac, s); break; case ECP_SET_START: ecp->flags |= SET_START; ecp->set_start = (uint64_t) strtoull(optarg, NULL, 0); break; case ECP_SREC_FORCE_S3: ecp->flags |= SREC_FORCE_S3; break; case ECP_SREC_LEN: ecp->flags |= SREC_FORCE_LEN; ecp->srec_len = strtoul(optarg, NULL, 0); break; case ECP_STRIP_DWO: ecp->strip = STRIP_DWO; break; case ECP_STRIP_SYMBOLS: parse_symlist_file(ecp, optarg, SYMOP_STRIP); break; case ECP_STRIP_UNNEEDED: ecp->strip = STRIP_UNNEEDED; break; case ECP_WEAKEN_ALL: ecp->flags |= WEAKEN_ALL; break; case ECP_WEAKEN_SYMBOLS: parse_symlist_file(ecp, optarg, SYMOP_WEAKEN); break; default: elfcopy_usage(); } } if (optind == argc || optind + 2 < argc) elfcopy_usage(); infile = argv[optind]; outfile = NULL; if (optind + 1 < argc) outfile = argv[optind + 1]; create_file(ecp, infile, outfile); } static void mcs_main(struct elfcopy *ecp, int argc, char **argv) { struct sec_action *sac; const char *string; int append, delete, compress, name, print; int opt, i; append = delete = compress = name = print = 0; string = NULL; while ((opt = getopt_long(argc, argv, "a:cdhn:pV", mcs_longopts, NULL)) != -1) { switch(opt) { case 'a': append = 1; string = optarg; /* XXX multiple -a not supported */ break; case 'c': compress = 1; break; case 'd': delete = 1; break; case 'n': name = 1; (void)lookup_sec_act(ecp, optarg, 1); break; case 'p': print = 1; break; case 'V': print_version(); break; case 'h': default: mcs_usage(); } } if (optind == argc) mcs_usage(); /* Must specify one operation at least. */ if (!append && !compress && !delete && !print) mcs_usage(); /* * If we are going to delete, ignore other operations. This is * different from the Solaris implementation, which can print * and delete a section at the same time, for example. Also, this * implementation do not respect the order between operations that * user specified, i.e., "mcs -pc a.out" equals to "mcs -cp a.out". */ if (delete) { append = compress = print = 0; ecp->flags |= SEC_REMOVE; } if (append) ecp->flags |= SEC_APPEND; if (compress) ecp->flags |= SEC_COMPRESS; if (print) ecp->flags |= SEC_PRINT; /* .comment is the default section to operate on. */ if (!name) (void)lookup_sec_act(ecp, ".comment", 1); STAILQ_FOREACH(sac, &ecp->v_sac, sac_list) { sac->append = append; sac->compress = compress; sac->print = print; sac->remove = delete; sac->string = string; } for (i = optind; i < argc; i++) { /* If only -p is specified, output to /dev/null */ if (print && !append && !compress && !delete) create_file(ecp, argv[i], "/dev/null"); else create_file(ecp, argv[i], NULL); } } static void strip_main(struct elfcopy *ecp, int argc, char **argv) { struct sec_action *sac; const char *outfile; int opt; int i; outfile = NULL; while ((opt = getopt_long(argc, argv, "hI:K:N:o:O:pR:sSdgVxXw", strip_longopts, NULL)) != -1) { switch(opt) { case 'R': sac = lookup_sec_act(ecp, optarg, 1); sac->remove = 1; ecp->flags |= SEC_REMOVE; break; case 's': ecp->strip = STRIP_ALL; break; case 'S': case 'g': case 'd': ecp->strip = STRIP_DEBUG; break; case 'I': /* ignored */ break; case 'K': add_to_symop_list(ecp, optarg, NULL, SYMOP_KEEP); break; case 'N': add_to_symop_list(ecp, optarg, NULL, SYMOP_STRIP); break; case 'o': outfile = optarg; break; case 'O': set_output_target(ecp, optarg); break; case 'p': ecp->flags |= PRESERVE_DATE; break; case 'V': print_version(); break; case 'w': ecp->flags |= WILDCARD; break; case 'x': ecp->flags |= DISCARD_LOCAL; break; case 'X': ecp->flags |= DISCARD_LLABEL; break; case ECP_ONLY_DEBUG: ecp->strip = STRIP_NONDEBUG; break; case ECP_STRIP_UNNEEDED: ecp->strip = STRIP_UNNEEDED; break; case 'h': default: strip_usage(); } } if (ecp->strip == 0 && ((ecp->flags & DISCARD_LOCAL) == 0) && ((ecp->flags & DISCARD_LLABEL) == 0) && lookup_symop_list(ecp, NULL, SYMOP_STRIP) == NULL) ecp->strip = STRIP_ALL; if (optind == argc) strip_usage(); for (i = optind; i < argc; i++) create_file(ecp, argv[i], outfile); } static void parse_sec_flags(struct sec_action *sac, char *s) { const char *flag; int found, i; for (flag = strtok(s, ","); flag; flag = strtok(NULL, ",")) { found = 0; for (i = 0; sec_flags[i].name != NULL; i++) if (strcasecmp(sec_flags[i].name, flag) == 0) { sac->flags |= sec_flags[i].value; found = 1; break; } if (!found) errx(EXIT_FAILURE, "unrecognized section flag %s", flag); } } static void parse_sec_address_op(struct elfcopy *ecp, int optnum, const char *optname, char *s) { struct sec_action *sac; const char *name; char *v; char op; name = v = s; do { v++; } while (*v != '\0' && *v != '=' && *v != '+' && *v != '-'); if (*v == '\0' || *(v + 1) == '\0') errx(EXIT_FAILURE, "invalid format for %s", optname); op = *v; *v++ = '\0'; sac = lookup_sec_act(ecp, name, 1); switch (op) { case '=': if (optnum == ECP_CHANGE_SEC_LMA || optnum == ECP_CHANGE_SEC_ADDR) { sac->setlma = 1; sac->lma = (uint64_t) strtoull(v, NULL, 0); } if (optnum == ECP_CHANGE_SEC_VMA || optnum == ECP_CHANGE_SEC_ADDR) { sac->setvma = 1; sac->vma = (uint64_t) strtoull(v, NULL, 0); } break; case '+': if (optnum == ECP_CHANGE_SEC_LMA || optnum == ECP_CHANGE_SEC_ADDR) sac->lma_adjust = (int64_t) strtoll(v, NULL, 0); if (optnum == ECP_CHANGE_SEC_VMA || optnum == ECP_CHANGE_SEC_ADDR) sac->vma_adjust = (int64_t) strtoll(v, NULL, 0); break; case '-': if (optnum == ECP_CHANGE_SEC_LMA || optnum == ECP_CHANGE_SEC_ADDR) sac->lma_adjust = (int64_t) -strtoll(v, NULL, 0); if (optnum == ECP_CHANGE_SEC_VMA || optnum == ECP_CHANGE_SEC_ADDR) sac->vma_adjust = (int64_t) -strtoll(v, NULL, 0); break; default: break; } } static void parse_symlist_file(struct elfcopy *ecp, const char *fn, unsigned int op) { struct symfile *sf; struct stat sb; FILE *fp; char *data, *p, *line, *end, *e, *n; if (stat(fn, &sb) == -1) err(EXIT_FAILURE, "stat %s failed", fn); /* Check if we already read and processed this file. */ STAILQ_FOREACH(sf, &ecp->v_symfile, symfile_list) { if (sf->dev == sb.st_dev && sf->ino == sb.st_ino) goto process_symfile; } if ((fp = fopen(fn, "r")) == NULL) err(EXIT_FAILURE, "can not open %s", fn); if ((data = malloc(sb.st_size + 1)) == NULL) err(EXIT_FAILURE, "malloc failed"); if (fread(data, 1, sb.st_size, fp) == 0 || ferror(fp)) err(EXIT_FAILURE, "fread failed"); fclose(fp); data[sb.st_size] = '\0'; if ((sf = calloc(1, sizeof(*sf))) == NULL) err(EXIT_FAILURE, "malloc failed"); sf->dev = sb.st_dev; sf->ino = sb.st_ino; sf->size = sb.st_size + 1; sf->data = data; process_symfile: /* * Basically what we do here is to convert EOL to '\0', and remove * leading and trailing whitespaces for each line. */ end = sf->data + sf->size; line = NULL; for(p = sf->data; p < end; p++) { if ((*p == '\t' || *p == ' ') && line == NULL) continue; if (*p == '\r' || *p == '\n' || *p == '\0') { *p = '\0'; if (line == NULL) continue; /* Skip comment. */ if (*line == '#') { line = NULL; continue; } e = p - 1; while(e != line && (*e == '\t' || *e == ' ')) *e-- = '\0'; if (op != SYMOP_REDEF) add_to_symop_list(ecp, line, NULL, op); else { if (strlen(line) < 3) errx(EXIT_FAILURE, "illegal format for" " --redefine-sym"); for(n = line + 1; n < e; n++) { if (*n == ' ' || *n == '\t') { while(*n == ' ' || *n == '\t') *n++ = '\0'; break; } } if (n >= e) errx(EXIT_FAILURE, "illegal format for" " --redefine-sym"); add_to_symop_list(ecp, line, n, op); } line = NULL; continue; } if (line == NULL) line = p; } } static void set_input_target(struct elfcopy *ecp, const char *target_name) { Elftc_Bfd_Target *tgt; if ((tgt = elftc_bfd_find_target(target_name)) == NULL) errx(EXIT_FAILURE, "%s: invalid target name", target_name); ecp->itf = elftc_bfd_target_flavor(tgt); } static void set_output_target(struct elfcopy *ecp, const char *target_name) { Elftc_Bfd_Target *tgt; if ((tgt = elftc_bfd_find_target(target_name)) == NULL) errx(EXIT_FAILURE, "%s: invalid target name", target_name); ecp->otf = elftc_bfd_target_flavor(tgt); if (ecp->otf == ETF_ELF) { ecp->oec = elftc_bfd_target_class(tgt); ecp->oed = elftc_bfd_target_byteorder(tgt); ecp->oem = elftc_bfd_target_machine(tgt); } if (ecp->otf == ETF_EFI || ecp->otf == ETF_PE) ecp->oem = elftc_bfd_target_machine(tgt); ecp->otgt = target_name; } static void set_osabi(struct elfcopy *ecp, const char *abi) { int i, found; found = 0; for (i = 0; osabis[i].name != NULL; i++) if (strcasecmp(osabis[i].name, abi) == 0) { ecp->abi = osabis[i].abi; found = 1; break; } if (!found) errx(EXIT_FAILURE, "unrecognized OSABI %s", abi); } #define ELFCOPY_USAGE_MESSAGE "\ Usage: %s [options] infile [outfile]\n\ Transform object files.\n\n\ Options:\n\ -d | -g | --strip-debug Remove debugging information from the output.\n\ -j SECTION | --only-section=SECTION\n\ Copy only the named section to the output.\n\ -p | --preserve-dates Preserve access and modification times.\n\ -w | --wildcard Use shell-style patterns to name symbols.\n\ -x | --discard-all Do not copy non-globals to the output.\n\ -I FORMAT | --input-target=FORMAT\n\ Specify object format for the input file.\n\ -K SYM | --keep-symbol=SYM Copy symbol SYM to the output.\n\ -L SYM | --localize-symbol=SYM\n\ Make symbol SYM local to the output file.\n\ -N SYM | --strip-symbol=SYM Do not copy symbol SYM to the output.\n\ -O FORMAT | --output-target=FORMAT\n\ Specify object format for the output file.\n\ FORMAT should be a target name understood by\n\ elftc_bfd_find_target(3).\n\ -R NAME | --remove-section=NAME\n\ Remove the named section.\n\ -S | --strip-all Remove all symbol and relocation information\n\ from the output.\n\ -V | --version Print a version identifier and exit.\n\ -W SYM | --weaken-symbol=SYM Mark symbol SYM as weak in the output.\n\ -X | --discard-locals Do not copy compiler generated symbols to\n\ the output.\n\ --add-section NAME=FILE Add the contents of FILE to the ELF object as\n\ a new section named NAME.\n\ --adjust-section-vma SECTION{=,+,-}VAL | \\\n\ --change-section-address SECTION{=,+,-}VAL\n\ Set or adjust the VMA and the LMA of the\n\ named section by VAL.\n\ --adjust-start=INCR | --change-start=INCR\n\ Add INCR to the start address for the ELF\n\ object.\n\ --adjust-vma=INCR | --change-addresses=INCR\n\ Increase the VMA and LMA of all sections by\n\ INCR.\n\ --adjust-warning | --change-warnings\n\ Issue warnings for non-existent sections.\n\ --change-section-lma SECTION{=,+,-}VAL\n\ Set or adjust the LMA address of the named\n\ section by VAL.\n\ --change-section-vma SECTION{=,+,-}VAL\n\ Set or adjust the VMA address of the named\n\ section by VAL.\n\ --gap-fill=VAL Fill the gaps between sections with bytes\n\ of value VAL.\n\ --localize-hidden Make all hidden symbols local to the output\n\ file.\n\ --no-adjust-warning| --no-change-warnings\n\ Do not issue warnings for non-existent\n\ sections.\n\ --only-keep-debug Copy only debugging information.\n\ --output-target=FORMAT Use the specified format for the output.\n\ - --pad-to=ADDRESS Pad the output object upto the given address.\n\ + --pad-to=ADDRESS Pad the output object up to the given address.\n\ --prefix-alloc-sections=STRING\n\ Prefix the section names of all the allocated\n\ sections with STRING.\n\ --prefix-sections=STRING Prefix the section names of all the sections\n\ with STRING.\n\ --prefix-symbols=STRING Prefix the symbol names of all the symbols\n\ with STRING.\n\ --rename-section OLDNAME=NEWNAME[,FLAGS]\n\ Rename and optionally change section flags.\n\ --set-section-flags SECTION=FLAGS\n\ Set section flags for the named section.\n\ Supported flags are: 'alloc', 'code',\n\ 'contents', 'data', 'debug', 'load',\n\ 'noload', 'readonly', 'rom', and 'shared'.\n\ --set-start=ADDRESS Set the start address of the ELF object.\n\ --srec-forceS3 Only generate S3 S-Records.\n\ --srec-len=LEN Set the maximum length of a S-Record line.\n\ --strip-unneeded Do not copy relocation information.\n" static void elfcopy_usage(void) { (void) fprintf(stderr, ELFCOPY_USAGE_MESSAGE, ELFTC_GETPROGNAME()); exit(EXIT_FAILURE); } #define MCS_USAGE_MESSAGE "\ Usage: %s [options] file...\n\ Manipulate the comment section in an ELF object.\n\n\ Options:\n\ -a STRING Append 'STRING' to the comment section.\n\ -c Remove duplicate entries from the comment section.\n\ -d Delete the comment section.\n\ -h | --help Print a help message and exit.\n\ -n NAME Operate on the ELF section with name 'NAME'.\n\ -p Print the contents of the comment section.\n\ -V | --version Print a version identifier and exit.\n" static void mcs_usage(void) { (void) fprintf(stderr, MCS_USAGE_MESSAGE, ELFTC_GETPROGNAME()); exit(EXIT_FAILURE); } #define STRIP_USAGE_MESSAGE "\ Usage: %s [options] file...\n\ Discard information from ELF objects.\n\n\ Options:\n\ -d | -g | -S | --strip-debug Remove debugging symbols.\n\ -h | --help Print a help message.\n\ -o FILE | --output-file FILE Write output to FILE.\n\ --only-keep-debug Keep debugging information only.\n\ -p | --preserve-dates Preserve access and modification times.\n\ -s | --strip-all Remove all symbols.\n\ --strip-unneeded Remove symbols not needed for relocation\n\ processing.\n\ -w | --wildcard Use shell-style patterns to name symbols.\n\ -x | --discard-all Discard all non-global symbols.\n\ -I TGT| --input-target=TGT (Accepted, but ignored).\n\ -K SYM | --keep-symbol=SYM Keep symbol 'SYM' in the output.\n\ -N SYM | --strip-symbol=SYM Remove symbol 'SYM' from the output.\n\ -O TGT | --output-target=TGT Set the output file format to 'TGT'.\n\ -R SEC | --remove-section=SEC Remove the section named 'SEC'.\n\ -V | --version Print a version identifier and exit.\n\ -X | --discard-locals Remove compiler-generated local symbols.\n" static void strip_usage(void) { (void) fprintf(stderr, STRIP_USAGE_MESSAGE, ELFTC_GETPROGNAME()); exit(EXIT_FAILURE); } static void print_version(void) { (void) printf("%s (%s)\n", ELFTC_GETPROGNAME(), elftc_version()); exit(EXIT_SUCCESS); } int main(int argc, char **argv) { struct elfcopy *ecp; if (elf_version(EV_CURRENT) == EV_NONE) errx(EXIT_FAILURE, "ELF library initialization failed: %s", elf_errmsg(-1)); ecp = calloc(1, sizeof(*ecp)); if (ecp == NULL) err(EXIT_FAILURE, "calloc failed"); memset(ecp, 0, sizeof(*ecp)); ecp->itf = ecp->otf = ETF_ELF; ecp->iec = ecp->oec = ELFCLASSNONE; ecp->oed = ELFDATANONE; ecp->abi = -1; /* There is always an empty section. */ ecp->nos = 1; ecp->fill = 0; STAILQ_INIT(&ecp->v_seg); STAILQ_INIT(&ecp->v_sac); STAILQ_INIT(&ecp->v_sadd); STAILQ_INIT(&ecp->v_symop); STAILQ_INIT(&ecp->v_symfile); STAILQ_INIT(&ecp->v_arobj); TAILQ_INIT(&ecp->v_sec); if ((ecp->progname = ELFTC_GETPROGNAME()) == NULL) ecp->progname = "elfcopy"; if (strcmp(ecp->progname, "strip") == 0) strip_main(ecp, argc, argv); else if (strcmp(ecp->progname, "mcs") == 0) mcs_main(ecp, argc, argv); else elfcopy_main(ecp, argc, argv); free_sec_add(ecp); free_sec_act(ecp); free(ecp); exit(EXIT_SUCCESS); } Index: vendor/elftoolchain/dist/elfcopy/sections.c =================================================================== --- vendor/elftoolchain/dist/elfcopy/sections.c (revision 300227) +++ vendor/elftoolchain/dist/elfcopy/sections.c (revision 300228) @@ -1,1706 +1,1722 @@ /*- * Copyright (c) 2007-2011,2014 Kai Wang * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #include #include #include #include #include #include #include "elfcopy.h" -ELFTC_VCSID("$Id: sections.c 3346 2016-01-17 20:09:15Z kaiwang27 $"); +ELFTC_VCSID("$Id: sections.c 3443 2016-04-15 18:57:54Z kaiwang27 $"); static void add_gnu_debuglink(struct elfcopy *ecp); static uint32_t calc_crc32(const char *p, size_t len, uint32_t crc); static void check_section_rename(struct elfcopy *ecp, struct section *s); static void filter_reloc(struct elfcopy *ecp, struct section *s); static int get_section_flags(struct elfcopy *ecp, const char *name); static void insert_sections(struct elfcopy *ecp); static void insert_to_strtab(struct section *t, const char *s); static int is_append_section(struct elfcopy *ecp, const char *name); static int is_compress_section(struct elfcopy *ecp, const char *name); static int is_debug_section(const char *name); static int is_dwo_section(const char *name); static int is_modify_section(struct elfcopy *ecp, const char *name); static int is_print_section(struct elfcopy *ecp, const char *name); static int lookup_string(struct section *t, const char *s); static void modify_section(struct elfcopy *ecp, struct section *s); static void pad_section(struct elfcopy *ecp, struct section *s); static void print_data(const char *d, size_t sz); static void print_section(struct section *s); static void *read_section(struct section *s, size_t *size); static void update_reloc(struct elfcopy *ecp, struct section *s); static void update_section_group(struct elfcopy *ecp, struct section *s); int is_remove_section(struct elfcopy *ecp, const char *name) { /* Always keep section name table */ if (strcmp(name, ".shstrtab") == 0) return 0; if (strcmp(name, ".symtab") == 0 || strcmp(name, ".strtab") == 0) { if (ecp->strip == STRIP_ALL && lookup_symop_list( ecp, NULL, SYMOP_KEEP) == NULL) return (1); else return (0); } if (ecp->strip == STRIP_DWO && is_dwo_section(name)) return (1); if (ecp->strip == STRIP_NONDWO && !is_dwo_section(name)) return (1); if (is_debug_section(name)) { if (ecp->strip == STRIP_ALL || ecp->strip == STRIP_DEBUG || ecp->strip == STRIP_UNNEEDED || (ecp->flags & DISCARD_LOCAL)) return (1); if (ecp->strip == STRIP_NONDEBUG) return (0); } if ((ecp->flags & SEC_REMOVE) || (ecp->flags & SEC_COPY)) { struct sec_action *sac; sac = lookup_sec_act(ecp, name, 0); if ((ecp->flags & SEC_REMOVE) && sac != NULL && sac->remove) return (1); if ((ecp->flags & SEC_COPY) && (sac == NULL || !sac->copy)) return (1); } return (0); } /* * Relocation section needs to be removed if the section it applies to * will be removed. */ int is_remove_reloc_sec(struct elfcopy *ecp, uint32_t sh_info) { const char *name; GElf_Shdr ish; Elf_Scn *is; size_t indx; int elferr; if (elf_getshstrndx(ecp->ein, &indx) == 0) errx(EXIT_FAILURE, "elf_getshstrndx failed: %s", elf_errmsg(-1)); is = NULL; while ((is = elf_nextscn(ecp->ein, is)) != NULL) { if (sh_info == elf_ndxscn(is)) { if (gelf_getshdr(is, &ish) == NULL) errx(EXIT_FAILURE, "gelf_getshdr failed: %s", elf_errmsg(-1)); if ((name = elf_strptr(ecp->ein, indx, ish.sh_name)) == NULL) errx(EXIT_FAILURE, "elf_strptr failed: %s", elf_errmsg(-1)); if (is_remove_section(ecp, name)) return (1); else return (0); } } elferr = elf_errno(); if (elferr != 0) errx(EXIT_FAILURE, "elf_nextscn failed: %s", elf_errmsg(elferr)); /* Remove reloc section if we can't find the target section. */ return (1); } static int is_append_section(struct elfcopy *ecp, const char *name) { struct sec_action *sac; sac = lookup_sec_act(ecp, name, 0); if (sac != NULL && sac->append != 0 && sac->string != NULL) return (1); return (0); } static int is_compress_section(struct elfcopy *ecp, const char *name) { struct sec_action *sac; sac = lookup_sec_act(ecp, name, 0); if (sac != NULL && sac->compress != 0) return (1); return (0); } static void check_section_rename(struct elfcopy *ecp, struct section *s) { struct sec_action *sac; char *prefix; size_t namelen; if (s->pseudo) return; sac = lookup_sec_act(ecp, s->name, 0); if (sac != NULL && sac->rename) s->name = sac->newname; if (!strcmp(s->name, ".symtab") || !strcmp(s->name, ".strtab") || !strcmp(s->name, ".shstrtab")) return; prefix = NULL; if (s->loadable && ecp->prefix_alloc != NULL) prefix = ecp->prefix_alloc; else if (ecp->prefix_sec != NULL) prefix = ecp->prefix_sec; if (prefix != NULL) { namelen = strlen(s->name) + strlen(prefix) + 1; if ((s->newname = malloc(namelen)) == NULL) err(EXIT_FAILURE, "malloc failed"); snprintf(s->newname, namelen, "%s%s", prefix, s->name); s->name = s->newname; } } static int get_section_flags(struct elfcopy *ecp, const char *name) { struct sec_action *sac; sac = lookup_sec_act(ecp, name, 0); if (sac != NULL && sac->flags) return sac->flags; return (0); } /* * Determine whether the section are debugging section. * According to libbfd, debugging sections are recognized * only by name. */ static int is_debug_section(const char *name) { const char *dbg_sec[] = { ".apple_", ".debug", ".gnu.linkonce.wi.", ".line", ".stab", NULL }; const char **p; for(p = dbg_sec; *p; p++) { if (strncmp(name, *p, strlen(*p)) == 0) return (1); } return (0); } static int is_dwo_section(const char *name) { size_t len; if ((len = strlen(name)) > 4 && strcmp(name + len - 4, ".dwo") == 0) return (1); return (0); } static int is_print_section(struct elfcopy *ecp, const char *name) { struct sec_action *sac; sac = lookup_sec_act(ecp, name, 0); if (sac != NULL && sac->print != 0) return (1); return (0); } static int is_modify_section(struct elfcopy *ecp, const char *name) { if (is_append_section(ecp, name) || is_compress_section(ecp, name)) return (1); return (0); } struct sec_action* lookup_sec_act(struct elfcopy *ecp, const char *name, int add) { struct sec_action *sac; if (name == NULL) return NULL; STAILQ_FOREACH(sac, &ecp->v_sac, sac_list) { if (strcmp(name, sac->name) == 0) return sac; } if (add == 0) return NULL; if ((sac = malloc(sizeof(*sac))) == NULL) errx(EXIT_FAILURE, "not enough memory"); memset(sac, 0, sizeof(*sac)); sac->name = name; STAILQ_INSERT_TAIL(&ecp->v_sac, sac, sac_list); return (sac); } void free_sec_act(struct elfcopy *ecp) { struct sec_action *sac, *sac_temp; STAILQ_FOREACH_SAFE(sac, &ecp->v_sac, sac_list, sac_temp) { STAILQ_REMOVE(&ecp->v_sac, sac, sec_action, sac_list); free(sac); } } void insert_to_sec_list(struct elfcopy *ecp, struct section *sec, int tail) { struct section *s; if (!tail) { TAILQ_FOREACH(s, &ecp->v_sec, sec_list) { if (sec->off < s->off) { TAILQ_INSERT_BEFORE(s, sec, sec_list); goto inc_nos; } } } TAILQ_INSERT_TAIL(&ecp->v_sec, sec, sec_list); inc_nos: if (sec->pseudo == 0) ecp->nos++; } /* * First step of section creation: create scn and internal section * structure, discard sections to be removed. */ void create_scn(struct elfcopy *ecp) { struct section *s; const char *name; Elf_Scn *is; GElf_Shdr ish; size_t indx; uint64_t oldndx, newndx; - int elferr, sec_flags; + int elferr, sec_flags, reorder; /* * Insert a pseudo section that contains the ELF header * and program header. Used as reference for section offset * or load address adjustment. */ if ((s = calloc(1, sizeof(*s))) == NULL) err(EXIT_FAILURE, "calloc failed"); s->off = 0; s->sz = gelf_fsize(ecp->eout, ELF_T_EHDR, 1, EV_CURRENT) + gelf_fsize(ecp->eout, ELF_T_PHDR, ecp->ophnum, EV_CURRENT); s->align = 1; s->pseudo = 1; s->loadable = add_to_inseg_list(ecp, s); insert_to_sec_list(ecp, s, 0); /* Create internal .shstrtab section. */ init_shstrtab(ecp); if (elf_getshstrndx(ecp->ein, &indx) == 0) errx(EXIT_FAILURE, "elf_getshstrndx failed: %s", elf_errmsg(-1)); + reorder = 0; is = NULL; while ((is = elf_nextscn(ecp->ein, is)) != NULL) { if (gelf_getshdr(is, &ish) == NULL) errx(EXIT_FAILURE, "gelf_getshdr failed: %s", elf_errmsg(-1)); if ((name = elf_strptr(ecp->ein, indx, ish.sh_name)) == NULL) errx(EXIT_FAILURE, "elf_strptr failed: %s", elf_errmsg(-1)); /* Skip sections to be removed. */ if (is_remove_section(ecp, name)) continue; /* * Relocation section need to be remove if the section * it applies will be removed. */ if (ish.sh_type == SHT_REL || ish.sh_type == SHT_RELA) if (ish.sh_info != 0 && is_remove_reloc_sec(ecp, ish.sh_info)) continue; /* * Section groups should be removed if symbol table will * be removed. (section group's signature stored in symbol * table) */ if (ish.sh_type == SHT_GROUP && ecp->strip == STRIP_ALL) continue; /* Get section flags set by user. */ sec_flags = get_section_flags(ecp, name); /* Create internal section object. */ if (strcmp(name, ".shstrtab") != 0) { if ((s = calloc(1, sizeof(*s))) == NULL) err(EXIT_FAILURE, "calloc failed"); s->name = name; s->is = is; s->off = ish.sh_offset; s->sz = ish.sh_size; s->align = ish.sh_addralign; s->type = ish.sh_type; s->vma = ish.sh_addr; /* * Search program headers to determine whether section * is loadable, but if user explicitly set section flags * while neither "load" nor "alloc" is set, we make the * section unloadable. * * Sections in relocatable object is loadable if * section flag SHF_ALLOC is set. */ if (sec_flags && (sec_flags & (SF_LOAD | SF_ALLOC)) == 0) s->loadable = 0; else { s->loadable = add_to_inseg_list(ecp, s); if ((ecp->flags & RELOCATABLE) && (ish.sh_flags & SHF_ALLOC)) s->loadable = 1; } } else { /* Assuming .shstrtab is "unloadable". */ s = ecp->shstrtab; s->off = ish.sh_offset; } oldndx = newndx = SHN_UNDEF; if (strcmp(name, ".symtab") != 0 && strcmp(name, ".strtab") != 0) { if (!strcmp(name, ".shstrtab")) { /* * Add sections specified by --add-section and * gnu debuglink. we want these sections have * smaller index than .shstrtab section. */ if (ecp->debuglink != NULL) add_gnu_debuglink(ecp); if (ecp->flags & SEC_ADD) insert_sections(ecp); } if ((s->os = elf_newscn(ecp->eout)) == NULL) errx(EXIT_FAILURE, "elf_newscn failed: %s", elf_errmsg(-1)); if ((newndx = elf_ndxscn(s->os)) == SHN_UNDEF) errx(EXIT_FAILURE, "elf_ndxscn failed: %s", elf_errmsg(-1)); } if ((oldndx = elf_ndxscn(is)) == SHN_UNDEF) errx(EXIT_FAILURE, "elf_ndxscn failed: %s", elf_errmsg(-1)); if (oldndx != SHN_UNDEF && newndx != SHN_UNDEF) ecp->secndx[oldndx] = newndx; /* * If strip action is STRIP_NONDEBUG(only keep debug), * change sections type of loadable sections and section * groups to SHT_NOBITS, and the content of those sections * will be discarded. However, SHT_NOTE sections should * be kept. */ if (ecp->strip == STRIP_NONDEBUG) { if (((ish.sh_flags & SHF_ALLOC) || (ish.sh_flags & SHF_GROUP)) && ish.sh_type != SHT_NOTE) s->type = SHT_NOBITS; } check_section_rename(ecp, s); /* create section header based on input object. */ if (strcmp(name, ".symtab") != 0 && strcmp(name, ".strtab") != 0 && - strcmp(name, ".shstrtab") != 0) + strcmp(name, ".shstrtab") != 0) { copy_shdr(ecp, s, NULL, 0, sec_flags); + /* + * elfcopy puts .symtab, .strtab and .shstrtab + * sections in the end of the output object. + * If the input objects have more sections + * after any of these 3 sections, the section + * table will be reordered. section symbols + * should be regenerated for relocations. + */ + if (reorder) + ecp->flags &= ~SYMTAB_INTACT; + } else + reorder = 1; if (strcmp(name, ".symtab") == 0) { ecp->flags |= SYMTAB_EXIST; ecp->symtab = s; } if (strcmp(name, ".strtab") == 0) ecp->strtab = s; insert_to_sec_list(ecp, s, 0); } elferr = elf_errno(); if (elferr != 0) errx(EXIT_FAILURE, "elf_nextscn failed: %s", elf_errmsg(elferr)); } struct section * insert_shtab(struct elfcopy *ecp, int tail) { struct section *s, *shtab; GElf_Ehdr ieh; int nsecs; /* * Treat section header table as a "pseudo" section, insert it * into section list, so later it will get sorted and resynced * just as normal sections. */ if ((shtab = calloc(1, sizeof(*shtab))) == NULL) errx(EXIT_FAILURE, "calloc failed"); if (!tail) { /* * "shoff" of input object is used as a hint for section * resync later. */ if (gelf_getehdr(ecp->ein, &ieh) == NULL) errx(EXIT_FAILURE, "gelf_getehdr() failed: %s", elf_errmsg(-1)); shtab->off = ieh.e_shoff; } else shtab->off = 0; /* Calculate number of sections in the output object. */ nsecs = 0; TAILQ_FOREACH(s, &ecp->v_sec, sec_list) { if (!s->pseudo) nsecs++; } /* Remember there is always a null section, so we +1 here. */ shtab->sz = gelf_fsize(ecp->eout, ELF_T_SHDR, nsecs + 1, EV_CURRENT); if (shtab->sz == 0) errx(EXIT_FAILURE, "gelf_fsize() failed: %s", elf_errmsg(-1)); shtab->align = (ecp->oec == ELFCLASS32 ? 4 : 8); shtab->loadable = 0; shtab->pseudo = 1; insert_to_sec_list(ecp, shtab, tail); return (shtab); } void copy_content(struct elfcopy *ecp) { struct section *s; TAILQ_FOREACH(s, &ecp->v_sec, sec_list) { /* Skip pseudo section. */ if (s->pseudo) continue; /* Skip special sections. */ if (strcmp(s->name, ".symtab") == 0 || strcmp(s->name, ".strtab") == 0 || strcmp(s->name, ".shstrtab") == 0) continue; /* * If strip action is STRIP_ALL, relocation info need * to be stripped. Skip filtering otherwisw. */ if (ecp->strip == STRIP_ALL && (s->type == SHT_REL || s->type == SHT_RELA)) filter_reloc(ecp, s); /* * The section indices in the SHT_GROUP section needs * to be updated since we might have stripped some * sections and changed section numbering. */ if (s->type == SHT_GROUP) update_section_group(ecp, s); if (is_modify_section(ecp, s->name)) modify_section(ecp, s); copy_data(s); /* * If symbol table is modified, relocation info might * need update, as symbol index may have changed. */ if ((ecp->flags & SYMTAB_INTACT) == 0 && (ecp->flags & SYMTAB_EXIST) && (s->type == SHT_REL || s->type == SHT_RELA)) update_reloc(ecp, s); if (is_print_section(ecp, s->name)) print_section(s); } } /* * Update section group section. The section indices in the SHT_GROUP * section need update after section numbering changed. */ static void update_section_group(struct elfcopy *ecp, struct section *s) { GElf_Shdr ish; Elf_Data *id; uint32_t *ws, *wd; uint64_t n; size_t ishnum; int i, j; if (!elf_getshnum(ecp->ein, &ishnum)) errx(EXIT_FAILURE, "elf_getshnum failed: %s", elf_errmsg(-1)); if (gelf_getshdr(s->is, &ish) == NULL) errx(EXIT_FAILURE, "gelf_getehdr() failed: %s", elf_errmsg(-1)); if ((id = elf_getdata(s->is, NULL)) == NULL) errx(EXIT_FAILURE, "elf_getdata() failed: %s", elf_errmsg(-1)); if (ish.sh_size == 0) return; if (ish.sh_entsize == 0) ish.sh_entsize = 4; ws = id->d_buf; /* We only support COMDAT section. */ if ((*ws & GRP_COMDAT) == 0) return; if ((s->buf = malloc(ish.sh_size)) == NULL) err(EXIT_FAILURE, "malloc failed"); s->sz = ish.sh_size; wd = s->buf; /* Copy the flag word as-is. */ *wd = *ws; /* Update the section indices. */ n = ish.sh_size / ish.sh_entsize; for(i = 1, j = 1; (uint64_t)i < n; i++) { if (ws[i] != SHN_UNDEF && ws[i] < ishnum && ecp->secndx[ws[i]] != 0) wd[j++] = ecp->secndx[ws[i]]; else s->sz -= 4; } s->nocopy = 1; } /* * Filter relocation entries, only keep those entries whose * symbol is in the keep list. */ static void filter_reloc(struct elfcopy *ecp, struct section *s) { const char *name; GElf_Shdr ish; GElf_Rel rel; GElf_Rela rela; Elf32_Rel *rel32; Elf64_Rel *rel64; Elf32_Rela *rela32; Elf64_Rela *rela64; Elf_Data *id; uint64_t cap, n, nrels; int elferr, i; if (gelf_getshdr(s->is, &ish) == NULL) errx(EXIT_FAILURE, "gelf_getehdr() failed: %s", elf_errmsg(-1)); /* We don't want to touch relocation info for dynamic symbols. */ if ((ecp->flags & SYMTAB_EXIST) == 0) { if (ish.sh_link == 0 || ecp->secndx[ish.sh_link] == 0) { /* * This reloc section applies to the symbol table * that was stripped, so discard whole section. */ s->nocopy = 1; s->sz = 0; } return; } else { /* Symbol table exist, check if index equals. */ if (ish.sh_link != elf_ndxscn(ecp->symtab->is)) return; } #define COPYREL(REL, SZ) do { \ if (nrels == 0) { \ if ((REL##SZ = malloc(cap * \ sizeof(Elf##SZ##_Rel))) == NULL) \ err(EXIT_FAILURE, "malloc failed"); \ } \ if (nrels >= cap) { \ cap *= 2; \ if ((REL##SZ = realloc(REL##SZ, cap * \ sizeof(Elf##SZ##_Rel))) == NULL) \ err(EXIT_FAILURE, "realloc failed"); \ } \ REL##SZ[nrels].r_offset = REL.r_offset; \ REL##SZ[nrels].r_info = REL.r_info; \ if (s->type == SHT_RELA) \ rela##SZ[nrels].r_addend = rela.r_addend; \ nrels++; \ } while (0) nrels = 0; cap = 4; /* keep list is usually small. */ rel32 = NULL; rel64 = NULL; rela32 = NULL; rela64 = NULL; if ((id = elf_getdata(s->is, NULL)) == NULL) errx(EXIT_FAILURE, "elf_getdata() failed: %s", elf_errmsg(-1)); n = ish.sh_size / ish.sh_entsize; for(i = 0; (uint64_t)i < n; i++) { if (s->type == SHT_REL) { if (gelf_getrel(id, i, &rel) != &rel) errx(EXIT_FAILURE, "gelf_getrel failed: %s", elf_errmsg(-1)); } else { if (gelf_getrela(id, i, &rela) != &rela) errx(EXIT_FAILURE, "gelf_getrel failed: %s", elf_errmsg(-1)); } name = elf_strptr(ecp->ein, elf_ndxscn(ecp->strtab->is), GELF_R_SYM(rel.r_info)); if (name == NULL) errx(EXIT_FAILURE, "elf_strptr failed: %s", elf_errmsg(-1)); if (lookup_symop_list(ecp, name, SYMOP_KEEP) != NULL) { if (ecp->oec == ELFCLASS32) { if (s->type == SHT_REL) COPYREL(rel, 32); else COPYREL(rela, 32); } else { if (s->type == SHT_REL) COPYREL(rel, 64); else COPYREL(rela, 64); } } } elferr = elf_errno(); if (elferr != 0) errx(EXIT_FAILURE, "elf_getdata() failed: %s", elf_errmsg(elferr)); if (ecp->oec == ELFCLASS32) { if (s->type == SHT_REL) s->buf = rel32; else s->buf = rela32; } else { if (s->type == SHT_REL) s->buf = rel64; else s->buf = rela64; } s->sz = gelf_fsize(ecp->eout, (s->type == SHT_REL ? ELF_T_REL : ELF_T_RELA), nrels, EV_CURRENT); s->nocopy = 1; } static void update_reloc(struct elfcopy *ecp, struct section *s) { GElf_Shdr osh; GElf_Rel rel; GElf_Rela rela; Elf_Data *od; uint64_t n; int i; #define UPDATEREL(REL) do { \ if (gelf_get##REL(od, i, &REL) != &REL) \ errx(EXIT_FAILURE, "gelf_get##REL failed: %s", \ elf_errmsg(-1)); \ REL.r_info = GELF_R_INFO(ecp->symndx[GELF_R_SYM(REL.r_info)], \ GELF_R_TYPE(REL.r_info)); \ if (!gelf_update_##REL(od, i, &REL)) \ errx(EXIT_FAILURE, "gelf_update_##REL failed: %s", \ elf_errmsg(-1)); \ } while(0) if (s->sz == 0) return; if (gelf_getshdr(s->os, &osh) == NULL) errx(EXIT_FAILURE, "gelf_getehdr() failed: %s", elf_errmsg(-1)); /* Only process .symtab reloc info. */ if (osh.sh_link != elf_ndxscn(ecp->symtab->is)) return; if ((od = elf_getdata(s->os, NULL)) == NULL) errx(EXIT_FAILURE, "elf_getdata() failed: %s", elf_errmsg(-1)); n = osh.sh_size / osh.sh_entsize; for(i = 0; (uint64_t)i < n; i++) { if (s->type == SHT_REL) UPDATEREL(rel); else UPDATEREL(rela); } } static void pad_section(struct elfcopy *ecp, struct section *s) { GElf_Shdr osh; Elf_Data *od; if (s == NULL || s->pad_sz == 0) return; if ((s->pad = malloc(s->pad_sz)) == NULL) err(EXIT_FAILURE, "malloc failed"); memset(s->pad, ecp->fill, s->pad_sz); /* Create a new Elf_Data to contain the padding bytes. */ if ((od = elf_newdata(s->os)) == NULL) errx(EXIT_FAILURE, "elf_newdata() failed: %s", elf_errmsg(-1)); od->d_align = 1; od->d_off = s->sz; od->d_buf = s->pad; od->d_type = ELF_T_BYTE; od->d_size = s->pad_sz; od->d_version = EV_CURRENT; /* Update section header. */ if (gelf_getshdr(s->os, &osh) == NULL) errx(EXIT_FAILURE, "gelf_getshdr() failed: %s", elf_errmsg(-1)); osh.sh_size = s->sz + s->pad_sz; if (!gelf_update_shdr(s->os, &osh)) errx(EXIT_FAILURE, "elf_update_shdr failed: %s", elf_errmsg(-1)); } void resync_sections(struct elfcopy *ecp) { struct section *s, *ps; GElf_Shdr osh; uint64_t off; int first; ps = NULL; first = 1; off = 0; TAILQ_FOREACH(s, &ecp->v_sec, sec_list) { if (first) { off = s->off; first = 0; } /* * Ignore TLS sections with load address 0 and without * content. We don't need to adjust their file offset or * VMA, only the size matters. */ if (s->seg_tls != NULL && s->type == SHT_NOBITS && s->off == 0) continue; /* Align section offset. */ if (s->align == 0) s->align = 1; if (off <= s->off) { if (!s->loadable || (ecp->flags & RELOCATABLE)) s->off = roundup(off, s->align); } else { if (s->loadable && (ecp->flags & RELOCATABLE) == 0) warnx("moving loadable section %s, " "is this intentional?", s->name); s->off = roundup(off, s->align); } /* Calculate next section offset. */ off = s->off; if (s->pseudo || (s->type != SHT_NOBITS && s->type != SHT_NULL)) off += s->sz; if (s->pseudo) { ps = NULL; continue; } /* Count padding bytes added through --pad-to. */ if (s->pad_sz > 0) off += s->pad_sz; /* Update section header accordingly. */ if (gelf_getshdr(s->os, &osh) == NULL) errx(EXIT_FAILURE, "gelf_getshdr() failed: %s", elf_errmsg(-1)); osh.sh_addr = s->vma; osh.sh_offset = s->off; osh.sh_size = s->sz; if (!gelf_update_shdr(s->os, &osh)) errx(EXIT_FAILURE, "elf_update_shdr failed: %s", elf_errmsg(-1)); /* Add padding for previous section, if need. */ if (ps != NULL) { if (ps->pad_sz > 0) { /* Apply padding added by --pad-to. */ pad_section(ecp, ps); } else if ((ecp->flags & GAP_FILL) && (ps->off + ps->sz < s->off)) { /* * Fill the gap between sections by padding * the section with lower address. */ ps->pad_sz = s->off - (ps->off + ps->sz); pad_section(ecp, ps); } } ps = s; } /* Pad the last section, if need. */ if (ps != NULL && ps->pad_sz > 0) pad_section(ecp, ps); } static void modify_section(struct elfcopy *ecp, struct section *s) { struct sec_action *sac; size_t srcsz, dstsz, p, len; char *b, *c, *d, *src, *end; int dupe; src = read_section(s, &srcsz); if (src == NULL || srcsz == 0) { /* For empty section, we proceed if we need to append. */ if (!is_append_section(ecp, s->name)) return; } /* Allocate buffer needed for new section data. */ dstsz = srcsz; if (is_append_section(ecp, s->name)) { sac = lookup_sec_act(ecp, s->name, 0); dstsz += strlen(sac->string) + 1; } if ((b = malloc(dstsz)) == NULL) err(EXIT_FAILURE, "malloc failed"); s->buf = b; /* Compress section. */ p = 0; if (is_compress_section(ecp, s->name)) { end = src + srcsz; for(c = src; c < end;) { len = 0; while(c + len < end && c[len] != '\0') len++; if (c + len == end) { /* XXX should we warn here? */ strncpy(&b[p], c, len); p += len; break; } dupe = 0; for (d = b; d < b + p; ) { if (strcmp(d, c) == 0) { dupe = 1; break; } d += strlen(d) + 1; } if (!dupe) { strncpy(&b[p], c, len); b[p + len] = '\0'; p += len + 1; } c += len + 1; } } else { memcpy(b, src, srcsz); p += srcsz; } /* Append section. */ if (is_append_section(ecp, s->name)) { sac = lookup_sec_act(ecp, s->name, 0); len = strlen(sac->string); strncpy(&b[p], sac->string, len); b[p + len] = '\0'; p += len + 1; } s->sz = p; s->nocopy = 1; } static void print_data(const char *d, size_t sz) { const char *c; for (c = d; c < d + sz; c++) { if (*c == '\0') putchar('\n'); else putchar(*c); } } static void print_section(struct section *s) { Elf_Data *id; int elferr; if (s->buf != NULL && s->sz > 0) { print_data(s->buf, s->sz); } else { id = NULL; while ((id = elf_getdata(s->is, id)) != NULL || (id = elf_rawdata(s->is, id)) != NULL) { (void) elf_errno(); print_data(id->d_buf, id->d_size); } elferr = elf_errno(); if (elferr != 0) errx(EXIT_FAILURE, "elf_getdata() failed: %s", elf_errmsg(elferr)); } putchar('\n'); } static void * read_section(struct section *s, size_t *size) { Elf_Data *id; char *b; size_t sz; int elferr; sz = 0; b = NULL; id = NULL; while ((id = elf_getdata(s->is, id)) != NULL || (id = elf_rawdata(s->is, id)) != NULL) { (void) elf_errno(); if (b == NULL) b = malloc(id->d_size); else b = malloc(sz + id->d_size); if (b == NULL) err(EXIT_FAILURE, "malloc or realloc failed"); memcpy(&b[sz], id->d_buf, id->d_size); sz += id->d_size; } elferr = elf_errno(); if (elferr != 0) errx(EXIT_FAILURE, "elf_getdata() failed: %s", elf_errmsg(elferr)); *size = sz; return (b); } void copy_shdr(struct elfcopy *ecp, struct section *s, const char *name, int copy, int sec_flags) { GElf_Shdr ish, osh; if (gelf_getshdr(s->is, &ish) == NULL) errx(EXIT_FAILURE, "gelf_getshdr() failed: %s", elf_errmsg(-1)); if (gelf_getshdr(s->os, &osh) == NULL) errx(EXIT_FAILURE, "gelf_getshdr() failed: %s", elf_errmsg(-1)); if (copy) (void) memcpy(&osh, &ish, sizeof(ish)); else { osh.sh_type = s->type; osh.sh_addr = s->vma; osh.sh_offset = s->off; osh.sh_size = s->sz; osh.sh_link = ish.sh_link; osh.sh_info = ish.sh_info; osh.sh_addralign = s->align; osh.sh_entsize = ish.sh_entsize; if (sec_flags) { osh.sh_flags = 0; if (sec_flags & SF_ALLOC) osh.sh_flags |= SHF_ALLOC; if ((sec_flags & SF_READONLY) == 0) osh.sh_flags |= SHF_WRITE; if (sec_flags & SF_CODE) osh.sh_flags |= SHF_EXECINSTR; if ((sec_flags & SF_CONTENTS) && s->type == SHT_NOBITS && s->sz > 0) { /* * Convert SHT_NOBITS section to section with * (zero'ed) content on file. */ osh.sh_type = s->type = SHT_PROGBITS; if ((s->buf = calloc(1, s->sz)) == NULL) err(EXIT_FAILURE, "malloc failed"); s->nocopy = 1; } } else { osh.sh_flags = ish.sh_flags; /* * Newer binutils as(1) emits the section flag * SHF_INFO_LINK for relocation sections. elfcopy * emits this flag in the output section if it's * missing in the input section, to remain compatible * with binutils. */ if (ish.sh_type == SHT_REL || ish.sh_type == SHT_RELA) osh.sh_flags |= SHF_INFO_LINK; } } if (name == NULL) add_to_shstrtab(ecp, s->name); else add_to_shstrtab(ecp, name); if (!gelf_update_shdr(s->os, &osh)) errx(EXIT_FAILURE, "elf_update_shdr failed: %s", elf_errmsg(-1)); } void copy_data(struct section *s) { Elf_Data *id, *od; int elferr; if (s->nocopy && s->buf == NULL) return; if ((id = elf_getdata(s->is, NULL)) == NULL) { (void) elf_errno(); if ((id = elf_rawdata(s->is, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) errx(EXIT_FAILURE, "failed to read section:" " %s", s->name); return; } } if ((od = elf_newdata(s->os)) == NULL) errx(EXIT_FAILURE, "elf_newdata() failed: %s", elf_errmsg(-1)); if (s->nocopy) { /* Use s->buf as content if s->nocopy is set. */ od->d_align = id->d_align; od->d_off = 0; od->d_buf = s->buf; od->d_type = id->d_type; od->d_size = s->sz; od->d_version = id->d_version; } else { od->d_align = id->d_align; od->d_off = id->d_off; od->d_buf = id->d_buf; od->d_type = id->d_type; od->d_size = id->d_size; od->d_version = id->d_version; } /* * Alignment Fixup. libelf does not allow the alignment for * Elf_Data descriptor to be set to 0. In this case we workaround * it by setting the alignment to 1. * * According to the ELF ABI, alignment 0 and 1 has the same * meaning: the section has no alignment constraints. */ if (od->d_align == 0) od->d_align = 1; } struct section * create_external_section(struct elfcopy *ecp, const char *name, char *newname, void *buf, uint64_t size, uint64_t off, uint64_t stype, Elf_Type dtype, uint64_t flags, uint64_t align, uint64_t vma, int loadable) { struct section *s; Elf_Scn *os; Elf_Data *od; GElf_Shdr osh; if ((os = elf_newscn(ecp->eout)) == NULL) errx(EXIT_FAILURE, "elf_newscn() failed: %s", elf_errmsg(-1)); if ((s = calloc(1, sizeof(*s))) == NULL) err(EXIT_FAILURE, "calloc failed"); s->name = name; s->newname = newname; /* needs to be free()'ed */ s->off = off; s->sz = size; s->vma = vma; s->align = align; s->loadable = loadable; s->is = NULL; s->os = os; s->type = stype; s->nocopy = 1; insert_to_sec_list(ecp, s, 1); if (gelf_getshdr(os, &osh) == NULL) errx(EXIT_FAILURE, "gelf_getshdr() failed: %s", elf_errmsg(-1)); osh.sh_flags = flags; osh.sh_type = s->type; osh.sh_addr = s->vma; osh.sh_addralign = s->align; if (!gelf_update_shdr(os, &osh)) errx(EXIT_FAILURE, "gelf_update_shdr() failed: %s", elf_errmsg(-1)); add_to_shstrtab(ecp, name); if (buf != NULL && size != 0) { if ((od = elf_newdata(os)) == NULL) errx(EXIT_FAILURE, "elf_newdata() failed: %s", elf_errmsg(-1)); od->d_align = align; od->d_off = 0; od->d_buf = buf; od->d_size = size; od->d_type = dtype; od->d_version = EV_CURRENT; } /* * Clear SYMTAB_INTACT, as we probably need to update/add new * STT_SECTION symbols into the symbol table. */ ecp->flags &= ~SYMTAB_INTACT; return (s); } /* * Insert sections specified by --add-section to the end of section list. */ static void insert_sections(struct elfcopy *ecp) { struct sec_add *sa; struct section *s; size_t off; uint64_t stype; /* Put these sections in the end of current list. */ off = 0; TAILQ_FOREACH(s, &ecp->v_sec, sec_list) { if (s->type != SHT_NOBITS && s->type != SHT_NULL) off = s->off + s->sz; else off = s->off; } STAILQ_FOREACH(sa, &ecp->v_sadd, sadd_list) { /* TODO: Add section header vma/lma, flag changes here */ /* * The default section type for user added section is * SHT_PROGBITS. If the section name match certain patterns, * elfcopy will try to set a more appropriate section type. * However, data type is always set to ELF_T_BYTE and no * translation is performed by libelf. */ stype = SHT_PROGBITS; if (strcmp(sa->name, ".note") == 0 || strncmp(sa->name, ".note.", strlen(".note.")) == 0) stype = SHT_NOTE; (void) create_external_section(ecp, sa->name, NULL, sa->content, sa->size, off, stype, ELF_T_BYTE, 0, 1, 0, 0); } } void add_to_shstrtab(struct elfcopy *ecp, const char *name) { struct section *s; s = ecp->shstrtab; insert_to_strtab(s, name); } void update_shdr(struct elfcopy *ecp, int update_link) { struct section *s; GElf_Shdr osh; int elferr; TAILQ_FOREACH(s, &ecp->v_sec, sec_list) { if (s->pseudo) continue; if (gelf_getshdr(s->os, &osh) == NULL) errx(EXIT_FAILURE, "gelf_getshdr failed: %s", elf_errmsg(-1)); /* Find section name in string table and set sh_name. */ osh.sh_name = lookup_string(ecp->shstrtab, s->name); /* * sh_link needs to be updated, since the index of the * linked section might have changed. */ if (update_link && osh.sh_link != 0) osh.sh_link = ecp->secndx[osh.sh_link]; /* * sh_info of relocation section links to the section to which * its relocation info applies. So it may need update as well. */ if ((s->type == SHT_REL || s->type == SHT_RELA) && osh.sh_info != 0) osh.sh_info = ecp->secndx[osh.sh_info]; /* * sh_info of SHT_GROUP section needs to point to the correct * string in the symbol table. */ if (s->type == SHT_GROUP && (ecp->flags & SYMTAB_EXIST) && (ecp->flags & SYMTAB_INTACT) == 0) osh.sh_info = ecp->symndx[osh.sh_info]; if (!gelf_update_shdr(s->os, &osh)) errx(EXIT_FAILURE, "gelf_update_shdr() failed: %s", elf_errmsg(-1)); } elferr = elf_errno(); if (elferr != 0) errx(EXIT_FAILURE, "elf_nextscn failed: %s", elf_errmsg(elferr)); } void init_shstrtab(struct elfcopy *ecp) { struct section *s; if ((ecp->shstrtab = calloc(1, sizeof(*ecp->shstrtab))) == NULL) err(EXIT_FAILURE, "calloc failed"); s = ecp->shstrtab; s->name = ".shstrtab"; s->is = NULL; s->sz = 0; s->align = 1; s->loadable = 0; s->type = SHT_STRTAB; s->vma = 0; insert_to_strtab(s, ""); insert_to_strtab(s, ".symtab"); insert_to_strtab(s, ".strtab"); insert_to_strtab(s, ".shstrtab"); } void set_shstrtab(struct elfcopy *ecp) { struct section *s; Elf_Data *data; GElf_Shdr sh; s = ecp->shstrtab; if (s->os == NULL) { /* Input object does not contain .shstrtab section */ if ((s->os = elf_newscn(ecp->eout)) == NULL) errx(EXIT_FAILURE, "elf_newscn failed: %s", elf_errmsg(-1)); insert_to_sec_list(ecp, s, 1); } if (gelf_getshdr(s->os, &sh) == NULL) errx(EXIT_FAILURE, "gelf_getshdr() failed: %s", elf_errmsg(-1)); sh.sh_addr = 0; sh.sh_addralign = 1; sh.sh_offset = s->off; sh.sh_type = SHT_STRTAB; sh.sh_flags = 0; sh.sh_entsize = 0; sh.sh_info = 0; sh.sh_link = 0; if ((data = elf_newdata(s->os)) == NULL) errx(EXIT_FAILURE, "elf_newdata() failed: %s", elf_errmsg(-1)); /* * If we don't have a symbol table, skip those a few bytes * which are reserved for this in the beginning of shstrtab. */ if (!(ecp->flags & SYMTAB_EXIST)) { s->sz -= sizeof(".symtab\0.strtab"); memmove(s->buf, (char *)s->buf + sizeof(".symtab\0.strtab"), s->sz); } sh.sh_size = s->sz; if (!gelf_update_shdr(s->os, &sh)) errx(EXIT_FAILURE, "gelf_update_shdr() failed: %s", elf_errmsg(-1)); data->d_align = 1; data->d_buf = s->buf; data->d_size = s->sz; data->d_off = 0; data->d_type = ELF_T_BYTE; data->d_version = EV_CURRENT; if (!elf_setshstrndx(ecp->eout, elf_ndxscn(s->os))) errx(EXIT_FAILURE, "elf_setshstrndx() failed: %s", elf_errmsg(-1)); } void add_section(struct elfcopy *ecp, const char *arg) { struct sec_add *sa; struct stat sb; const char *s, *fn; FILE *fp; int len; if ((s = strchr(arg, '=')) == NULL) errx(EXIT_FAILURE, "illegal format for --add-section option"); if ((sa = malloc(sizeof(*sa))) == NULL) err(EXIT_FAILURE, "malloc failed"); len = s - arg; if ((sa->name = malloc(len + 1)) == NULL) err(EXIT_FAILURE, "malloc failed"); strncpy(sa->name, arg, len); sa->name[len] = '\0'; fn = s + 1; if (stat(fn, &sb) == -1) err(EXIT_FAILURE, "stat failed"); sa->size = sb.st_size; if (sa->size > 0) { if ((sa->content = malloc(sa->size)) == NULL) err(EXIT_FAILURE, "malloc failed"); if ((fp = fopen(fn, "r")) == NULL) err(EXIT_FAILURE, "can not open %s", fn); if (fread(sa->content, 1, sa->size, fp) == 0 || ferror(fp)) err(EXIT_FAILURE, "fread failed"); fclose(fp); } else sa->content = NULL; STAILQ_INSERT_TAIL(&ecp->v_sadd, sa, sadd_list); ecp->flags |= SEC_ADD; } void free_sec_add(struct elfcopy *ecp) { struct sec_add *sa, *sa_temp; STAILQ_FOREACH_SAFE(sa, &ecp->v_sadd, sadd_list, sa_temp) { STAILQ_REMOVE(&ecp->v_sadd, sa, sec_add, sadd_list); free(sa->name); free(sa->content); free(sa); } } static void add_gnu_debuglink(struct elfcopy *ecp) { struct sec_add *sa; struct stat sb; FILE *fp; char *fnbase, *buf; int crc_off; int crc; if (ecp->debuglink == NULL) return; /* Read debug file content. */ if ((sa = malloc(sizeof(*sa))) == NULL) err(EXIT_FAILURE, "malloc failed"); if ((sa->name = strdup(".gnu_debuglink")) == NULL) err(EXIT_FAILURE, "strdup failed"); if (stat(ecp->debuglink, &sb) == -1) err(EXIT_FAILURE, "stat failed"); + if (sb.st_size == 0) + errx(EXIT_FAILURE, "empty debug link target %s", + ecp->debuglink); if ((buf = malloc(sb.st_size)) == NULL) err(EXIT_FAILURE, "malloc failed"); if ((fp = fopen(ecp->debuglink, "r")) == NULL) err(EXIT_FAILURE, "can not open %s", ecp->debuglink); if (fread(buf, 1, sb.st_size, fp) == 0 || ferror(fp)) err(EXIT_FAILURE, "fread failed"); fclose(fp); /* Calculate crc checksum. */ crc = calc_crc32(buf, sb.st_size, 0xFFFFFFFF); free(buf); /* Calculate section size and the offset to store crc checksum. */ if ((fnbase = basename(ecp->debuglink)) == NULL) err(EXIT_FAILURE, "basename failed"); crc_off = roundup(strlen(fnbase) + 1, 4); sa->size = crc_off + 4; /* Section content. */ if ((sa->content = calloc(1, sa->size)) == NULL) err(EXIT_FAILURE, "malloc failed"); strncpy(sa->content, fnbase, strlen(fnbase)); if (ecp->oed == ELFDATA2LSB) { sa->content[crc_off] = crc & 0xFF; sa->content[crc_off + 1] = (crc >> 8) & 0xFF; sa->content[crc_off + 2] = (crc >> 16) & 0xFF; sa->content[crc_off + 3] = crc >> 24; } else { sa->content[crc_off] = crc >> 24; sa->content[crc_off + 1] = (crc >> 16) & 0xFF; sa->content[crc_off + 2] = (crc >> 8) & 0xFF; sa->content[crc_off + 3] = crc & 0xFF; } STAILQ_INSERT_TAIL(&ecp->v_sadd, sa, sadd_list); ecp->flags |= SEC_ADD; } static void insert_to_strtab(struct section *t, const char *s) { const char *r; char *b, *c; size_t len, slen; int append; if (t->sz == 0) { t->cap = 512; if ((t->buf = malloc(t->cap)) == NULL) err(EXIT_FAILURE, "malloc failed"); } slen = strlen(s); append = 0; b = t->buf; for (c = b; c < b + t->sz;) { len = strlen(c); if (!append && len >= slen) { r = c + (len - slen); if (strcmp(r, s) == 0) return; } else if (len < slen && len != 0) { r = s + (slen - len); if (strcmp(c, r) == 0) { t->sz -= len + 1; memmove(c, c + len + 1, t->sz - (c - b)); append = 1; continue; } } c += len + 1; } while (t->sz + slen + 1 >= t->cap) { t->cap *= 2; if ((t->buf = realloc(t->buf, t->cap)) == NULL) err(EXIT_FAILURE, "realloc failed"); } b = t->buf; strncpy(&b[t->sz], s, slen); b[t->sz + slen] = '\0'; t->sz += slen + 1; } static int lookup_string(struct section *t, const char *s) { const char *b, *c, *r; size_t len, slen; slen = strlen(s); b = t->buf; for (c = b; c < b + t->sz;) { len = strlen(c); if (len >= slen) { r = c + (len - slen); if (strcmp(r, s) == 0) return (r - b); } c += len + 1; } return (-1); } static uint32_t crctable[256] = { 0x00000000L, 0x77073096L, 0xEE0E612CL, 0x990951BAL, 0x076DC419L, 0x706AF48FL, 0xE963A535L, 0x9E6495A3L, 0x0EDB8832L, 0x79DCB8A4L, 0xE0D5E91EL, 0x97D2D988L, 0x09B64C2BL, 0x7EB17CBDL, 0xE7B82D07L, 0x90BF1D91L, 0x1DB71064L, 0x6AB020F2L, 0xF3B97148L, 0x84BE41DEL, 0x1ADAD47DL, 0x6DDDE4EBL, 0xF4D4B551L, 0x83D385C7L, 0x136C9856L, 0x646BA8C0L, 0xFD62F97AL, 0x8A65C9ECL, 0x14015C4FL, 0x63066CD9L, 0xFA0F3D63L, 0x8D080DF5L, 0x3B6E20C8L, 0x4C69105EL, 0xD56041E4L, 0xA2677172L, 0x3C03E4D1L, 0x4B04D447L, 0xD20D85FDL, 0xA50AB56BL, 0x35B5A8FAL, 0x42B2986CL, 0xDBBBC9D6L, 0xACBCF940L, 0x32D86CE3L, 0x45DF5C75L, 0xDCD60DCFL, 0xABD13D59L, 0x26D930ACL, 0x51DE003AL, 0xC8D75180L, 0xBFD06116L, 0x21B4F4B5L, 0x56B3C423L, 0xCFBA9599L, 0xB8BDA50FL, 0x2802B89EL, 0x5F058808L, 0xC60CD9B2L, 0xB10BE924L, 0x2F6F7C87L, 0x58684C11L, 0xC1611DABL, 0xB6662D3DL, 0x76DC4190L, 0x01DB7106L, 0x98D220BCL, 0xEFD5102AL, 0x71B18589L, 0x06B6B51FL, 0x9FBFE4A5L, 0xE8B8D433L, 0x7807C9A2L, 0x0F00F934L, 0x9609A88EL, 0xE10E9818L, 0x7F6A0DBBL, 0x086D3D2DL, 0x91646C97L, 0xE6635C01L, 0x6B6B51F4L, 0x1C6C6162L, 0x856530D8L, 0xF262004EL, 0x6C0695EDL, 0x1B01A57BL, 0x8208F4C1L, 0xF50FC457L, 0x65B0D9C6L, 0x12B7E950L, 0x8BBEB8EAL, 0xFCB9887CL, 0x62DD1DDFL, 0x15DA2D49L, 0x8CD37CF3L, 0xFBD44C65L, 0x4DB26158L, 0x3AB551CEL, 0xA3BC0074L, 0xD4BB30E2L, 0x4ADFA541L, 0x3DD895D7L, 0xA4D1C46DL, 0xD3D6F4FBL, 0x4369E96AL, 0x346ED9FCL, 0xAD678846L, 0xDA60B8D0L, 0x44042D73L, 0x33031DE5L, 0xAA0A4C5FL, 0xDD0D7CC9L, 0x5005713CL, 0x270241AAL, 0xBE0B1010L, 0xC90C2086L, 0x5768B525L, 0x206F85B3L, 0xB966D409L, 0xCE61E49FL, 0x5EDEF90EL, 0x29D9C998L, 0xB0D09822L, 0xC7D7A8B4L, 0x59B33D17L, 0x2EB40D81L, 0xB7BD5C3BL, 0xC0BA6CADL, 0xEDB88320L, 0x9ABFB3B6L, 0x03B6E20CL, 0x74B1D29AL, 0xEAD54739L, 0x9DD277AFL, 0x04DB2615L, 0x73DC1683L, 0xE3630B12L, 0x94643B84L, 0x0D6D6A3EL, 0x7A6A5AA8L, 0xE40ECF0BL, 0x9309FF9DL, 0x0A00AE27L, 0x7D079EB1L, 0xF00F9344L, 0x8708A3D2L, 0x1E01F268L, 0x6906C2FEL, 0xF762575DL, 0x806567CBL, 0x196C3671L, 0x6E6B06E7L, 0xFED41B76L, 0x89D32BE0L, 0x10DA7A5AL, 0x67DD4ACCL, 0xF9B9DF6FL, 0x8EBEEFF9L, 0x17B7BE43L, 0x60B08ED5L, 0xD6D6A3E8L, 0xA1D1937EL, 0x38D8C2C4L, 0x4FDFF252L, 0xD1BB67F1L, 0xA6BC5767L, 0x3FB506DDL, 0x48B2364BL, 0xD80D2BDAL, 0xAF0A1B4CL, 0x36034AF6L, 0x41047A60L, 0xDF60EFC3L, 0xA867DF55L, 0x316E8EEFL, 0x4669BE79L, 0xCB61B38CL, 0xBC66831AL, 0x256FD2A0L, 0x5268E236L, 0xCC0C7795L, 0xBB0B4703L, 0x220216B9L, 0x5505262FL, 0xC5BA3BBEL, 0xB2BD0B28L, 0x2BB45A92L, 0x5CB36A04L, 0xC2D7FFA7L, 0xB5D0CF31L, 0x2CD99E8BL, 0x5BDEAE1DL, 0x9B64C2B0L, 0xEC63F226L, 0x756AA39CL, 0x026D930AL, 0x9C0906A9L, 0xEB0E363FL, 0x72076785L, 0x05005713L, 0x95BF4A82L, 0xE2B87A14L, 0x7BB12BAEL, 0x0CB61B38L, 0x92D28E9BL, 0xE5D5BE0DL, 0x7CDCEFB7L, 0x0BDBDF21L, 0x86D3D2D4L, 0xF1D4E242L, 0x68DDB3F8L, 0x1FDA836EL, 0x81BE16CDL, 0xF6B9265BL, 0x6FB077E1L, 0x18B74777L, 0x88085AE6L, 0xFF0F6A70L, 0x66063BCAL, 0x11010B5CL, 0x8F659EFFL, 0xF862AE69L, 0x616BFFD3L, 0x166CCF45L, 0xA00AE278L, 0xD70DD2EEL, 0x4E048354L, 0x3903B3C2L, 0xA7672661L, 0xD06016F7L, 0x4969474DL, 0x3E6E77DBL, 0xAED16A4AL, 0xD9D65ADCL, 0x40DF0B66L, 0x37D83BF0L, 0xA9BCAE53L, 0xDEBB9EC5L, 0x47B2CF7FL, 0x30B5FFE9L, 0xBDBDF21CL, 0xCABAC28AL, 0x53B39330L, 0x24B4A3A6L, 0xBAD03605L, 0xCDD70693L, 0x54DE5729L, 0x23D967BFL, 0xB3667A2EL, 0xC4614AB8L, 0x5D681B02L, 0x2A6F2B94L, 0xB40BBE37L, 0xC30C8EA1L, 0x5A05DF1BL, 0x2D02EF8DL }; static uint32_t calc_crc32(const char *p, size_t len, uint32_t crc) { uint32_t i; for (i = 0; i < len; i++) { crc = crctable[(crc ^ *p++) & 0xFFL] ^ (crc >> 8); } return (crc ^ 0xFFFFFFFF); } Index: vendor/elftoolchain/dist/elfcopy/segments.c =================================================================== --- vendor/elftoolchain/dist/elfcopy/segments.c (revision 300227) +++ vendor/elftoolchain/dist/elfcopy/segments.c (revision 300228) @@ -1,497 +1,590 @@ /*- * Copyright (c) 2007-2010,2012 Kai Wang * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #include #include #include #include #include #include #include "elfcopy.h" -ELFTC_VCSID("$Id: segments.c 3397 2016-02-12 14:35:19Z emaste $"); +ELFTC_VCSID("$Id: segments.c 3449 2016-05-03 13:59:29Z emaste $"); static void insert_to_inseg_list(struct segment *seg, struct section *sec); /* * elfcopy's segment handling is relatively simpler and less powerful than * libbfd. Program headers are modified or copied from input to output objects, * but never re-generated. As a result, if the input object has incorrect * program headers, the output object's program headers will remain incorrect * or become even worse. */ /* * Check whether a section is "loadable". If so, add it to the * corresponding segment list(s) and return 1. */ int add_to_inseg_list(struct elfcopy *ecp, struct section *s) { struct segment *seg; int loadable; if (ecp->ophnum == 0) return (0); /* * Segment is a different view of an ELF object. One segment can * contain one or more sections, and one section can be included * in one or more segments, or not included in any segment at all. * We call those sections which can be found in one or more segments * "loadable" sections, and call the rest "unloadable" sections. * We keep track of "loadable" sections in their containing * segment(s)' v_sec queue. These information are later used to * recalculate the extents of segments, when sections are removed, * for example. */ loadable = 0; STAILQ_FOREACH(seg, &ecp->v_seg, seg_list) { - if (s->off < seg->off || (s->vma < seg->addr && !s->pseudo)) + if (s->off < seg->off || (s->vma < seg->vaddr && !s->pseudo)) continue; if (s->off + s->sz > seg->off + seg->fsz && s->type != SHT_NOBITS) continue; - if (s->vma + s->sz > seg->addr + seg->msz) + if (s->vma + s->sz > seg->vaddr + seg->msz) continue; insert_to_inseg_list(seg, s); if (seg->type == PT_LOAD) s->seg = seg; else if (seg->type == PT_TLS) s->seg_tls = seg; - s->lma = seg->addr + (s->off - seg->off); + if (s->pseudo) + s->vma = seg->vaddr + (s->off - seg->off); + if (seg->paddr > 0) + s->lma = seg->paddr + (s->off - seg->off); + else + s->lma = 0; loadable = 1; } return (loadable); } void adjust_addr(struct elfcopy *ecp) { struct section *s, *s0; struct segment *seg; struct sec_action *sac; - uint64_t dl, lma, start, end; + uint64_t dl, vma, lma, start, end; int found, i; /* * Apply VMA and global LMA changes in the first iteration. */ TAILQ_FOREACH(s, &ecp->v_sec, sec_list) { /* Only adjust loadable section's address. */ if (!s->loadable) continue; + /* Apply global VMA adjustment. */ + if (ecp->change_addr != 0) + s->vma += ecp->change_addr; + /* Apply global LMA adjustment. */ - if (ecp->change_addr != 0 && s->seg != NULL) + if (ecp->change_addr != 0 && s->seg != NULL && + s->seg->paddr > 0) s->lma += ecp->change_addr; - - if (!s->pseudo) { - /* Apply global VMA adjustment. */ - if (ecp->change_addr != 0) - s->vma += ecp->change_addr; - - /* Apply section VMA adjustment. */ - sac = lookup_sec_act(ecp, s->name, 0); - if (sac == NULL) - continue; - if (sac->setvma) - s->vma = sac->vma; - if (sac->vma_adjust != 0) - s->vma += sac->vma_adjust; - } } /* - * Apply sections LMA change in the second iteration. + * Apply sections VMA change in the second iteration. */ TAILQ_FOREACH(s, &ecp->v_sec, sec_list) { - /* - * Only loadable section that's inside a segment can have - * LMA adjusted. - */ - if (!s->loadable || s->seg == NULL) + if (!s->loadable) continue; /* - * Check if there is a LMA change request for this + * Check if there is a VMA change request for this * section. */ sac = lookup_sec_act(ecp, s->name, 0); if (sac == NULL) continue; - if (!sac->setlma && sac->lma_adjust == 0) + vma = s->vma; + if (sac->setvma) + vma = sac->vma; + if (sac->vma_adjust != 0) + vma += sac->vma_adjust; + if (vma == s->vma) continue; - lma = s->lma; - if (sac->setlma) - lma = sac->lma; - if (sac->lma_adjust != 0) - lma += sac->lma_adjust; - if (lma == s->lma) + + /* + * No need to make segment adjustment if the section doesn't + * belong to any segment. + */ + if (s->seg == NULL) { + s->vma = vma; continue; + } /* - * Check if the LMA change is viable. + * Check if the VMA change is viable. * - * 1. Check if the new LMA is properly aligned accroding to + * 1. Check if the new VMA is properly aligned accroding to * section alignment. * * 2. Compute the new extent of segment that contains this * section, make sure it doesn't overlap with other * segments. */ #ifdef DEBUG - printf("LMA for section %s: %#jx\n", s->name, lma); + printf("VMA for section %s: %#jx\n", s->name, vma); #endif - if (lma % s->align != 0) - errx(EXIT_FAILURE, "The load address %#jx for " + if (vma % s->align != 0) + errx(EXIT_FAILURE, "The VMA %#jx for " "section %s is not aligned to %ju", - (uintmax_t) lma, s->name, (uintmax_t) s->align); + (uintmax_t) vma, s->name, (uintmax_t) s->align); - if (lma < s->lma) { + if (vma < s->vma) { /* Move section to lower address. */ - if (lma < s->lma - s->seg->addr) + if (vma < s->vma - s->seg->vaddr) errx(EXIT_FAILURE, "Not enough space to move " - "section %s load address to %#jx", s->name, - (uintmax_t) lma); - start = lma - (s->lma - s->seg->addr); + "section %s VMA to %#jx", s->name, + (uintmax_t) vma); + start = vma - (s->vma - s->seg->vaddr); if (s == s->seg->v_sec[s->seg->nsec - 1]) end = start + s->seg->msz; else - end = s->seg->addr + s->seg->msz; - + end = s->seg->vaddr + s->seg->msz; } else { /* Move section to upper address. */ if (s == s->seg->v_sec[0]) - start = lma; + start = vma; else - start = s->seg->addr; - end = lma + (s->seg->addr + s->seg->msz - s->lma); + start = s->seg->vaddr; + end = vma + (s->seg->vaddr + s->seg->msz - s->vma); if (end < start) errx(EXIT_FAILURE, "Not enough space to move " - "section %s load address to %#jx", s->name, - (uintmax_t) lma); + "section %s VMA to %#jx", s->name, + (uintmax_t) vma); } #ifdef DEBUG printf("new extent for segment containing %s: (%#jx,%#jx)\n", s->name, start, end); #endif STAILQ_FOREACH(seg, &ecp->v_seg, seg_list) { if (seg == s->seg || seg->type != PT_LOAD) continue; - if (start > seg->addr + seg->msz) + if (start > seg->vaddr + seg->msz) continue; - if (end < seg->addr) + if (end < seg->vaddr) continue; errx(EXIT_FAILURE, "The extent of segment containing " "section %s overlaps with segment(%#jx,%#jx)", - s->name, (uintmax_t) seg->addr, - (uintmax_t) (seg->addr + seg->msz)); + s->name, (uintmax_t) seg->vaddr, + (uintmax_t) (seg->vaddr + seg->msz)); } /* - * Update section LMA and file offset. + * Update section VMA and file offset. */ - if (lma < s->lma) { + if (vma < s->vma) { /* - * To move a section to lower load address, we decrease - * the load addresses of the section and all the - * sections that are before it, and we increase the - * file offsets of all the sections that are after it. + * To move a section to lower VMA, we decrease + * the VMA of the section and all the sections that + * are before it, and we increase the file offsets + * of all the sections that are after it. */ - dl = s->lma - lma; + dl = s->vma - vma; for (i = 0; i < s->seg->nsec; i++) { s0 = s->seg->v_sec[i]; - s0->lma -= dl; + s0->vma -= dl; #ifdef DEBUG - printf("section %s LMA set to %#jx\n", - s0->name, (uintmax_t) s0->lma); + printf("section %s VMA set to %#jx\n", + s0->name, (uintmax_t) s0->vma); #endif if (s0 == s) break; } for (i = i + 1; i < s->seg->nsec; i++) { s0 = s->seg->v_sec[i]; s0->off += dl; #ifdef DEBUG printf("section %s offset set to %#jx\n", s0->name, (uintmax_t) s0->off); #endif } } else { /* - * To move a section to upper load address, we increase - * the load addresses of the section and all the - * sections that are after it, and we increase the - * their file offsets too unless the section in question + * To move a section to upper VMA, we increase + * the VMA of the section and all the sections that + * are after it, and we increase the their file + * offsets too unless the section in question * is the first in its containing segment. */ - dl = lma - s->lma; + dl = vma - s->vma; for (i = 0; i < s->seg->nsec; i++) if (s->seg->v_sec[i] == s) break; if (i >= s->seg->nsec) errx(EXIT_FAILURE, "Internal: section `%s' not" " found in its containing segement", s->name); for (; i < s->seg->nsec; i++) { s0 = s->seg->v_sec[i]; - s0->lma += dl; + s0->vma += dl; #ifdef DEBUG - printf("section %s LMA set to %#jx\n", + printf("section %s VMA set to %#jx\n", s0->name, (uintmax_t) s0->lma); #endif if (s != s->seg->v_sec[0]) { s0->off += dl; #ifdef DEBUG printf("section %s offset set to %#jx\n", s0->name, (uintmax_t) s0->off); #endif } } } } /* * Apply load address padding. */ if (ecp->pad_to != 0) { /* - * Find the section with highest load address. + * Find the section with highest VMA. */ - s = NULL; STAILQ_FOREACH(seg, &ecp->v_seg, seg_list) { if (seg->type != PT_LOAD) continue; for (i = seg->nsec - 1; i >= 0; i--) if (seg->v_sec[i]->type != SHT_NOBITS) break; if (i < 0) continue; if (s == NULL) s = seg->v_sec[i]; else { s0 = seg->v_sec[i]; - if (s0->lma > s->lma) + if (s0->vma > s->vma) s = s0; } } if (s == NULL) - goto issue_warn; + goto adjust_lma; /* No need to pad if the pad_to address is lower. */ - if (ecp->pad_to <= s->lma + s->sz) - goto issue_warn; + if (ecp->pad_to <= s->vma + s->sz) + goto adjust_lma; - s->pad_sz = ecp->pad_to - (s->lma + s->sz); + s->pad_sz = ecp->pad_to - (s->vma + s->sz); #ifdef DEBUG - printf("pad section %s load to address %#jx by %#jx\n", s->name, + printf("pad section %s VMA to address %#jx by %#jx\n", s->name, (uintmax_t) ecp->pad_to, (uintmax_t) s->pad_sz); #endif } -issue_warn: +adjust_lma: + /* + * Apply sections LMA change in the third iteration. + */ + TAILQ_FOREACH(s, &ecp->v_sec, sec_list) { + + /* + * Only loadable section that's inside a segment can have + * LMA adjusted. Also, if LMA of the containing segment is + * set to 0, it probably means we should ignore the LMA. + */ + if (!s->loadable || s->seg == NULL || s->seg->paddr == 0) + continue; + + /* + * Check if there is a LMA change request for this + * section. + */ + sac = lookup_sec_act(ecp, s->name, 0); + if (sac == NULL) + continue; + if (!sac->setlma && sac->lma_adjust == 0) + continue; + lma = s->lma; + if (sac->setlma) + lma = sac->lma; + if (sac->lma_adjust != 0) + lma += sac->lma_adjust; + if (lma == s->lma) + continue; + +#ifdef DEBUG + printf("LMA for section %s: %#jx\n", s->name, lma); +#endif + + /* Check alignment. */ + if (lma % s->align != 0) + errx(EXIT_FAILURE, "The LMA %#jx for " + "section %s is not aligned to %ju", + (uintmax_t) lma, s->name, (uintmax_t) s->align); + + /* + * Update section LMA. + */ + + if (lma < s->lma) { + /* + * To move a section to lower LMA, we decrease + * the LMA of the section and all the sections that + * are before it. + */ + dl = s->lma - lma; + for (i = 0; i < s->seg->nsec; i++) { + s0 = s->seg->v_sec[i]; + s0->lma -= dl; +#ifdef DEBUG + printf("section %s LMA set to %#jx\n", + s0->name, (uintmax_t) s0->lma); +#endif + if (s0 == s) + break; + } + } else { + /* + * To move a section to upper LMA, we increase + * the LMA of the section and all the sections that + * are after it. + */ + dl = lma - s->lma; + for (i = 0; i < s->seg->nsec; i++) + if (s->seg->v_sec[i] == s) + break; + if (i >= s->seg->nsec) + errx(EXIT_FAILURE, "Internal: section `%s' not" + " found in its containing segement", + s->name); + for (; i < s->seg->nsec; i++) { + s0 = s->seg->v_sec[i]; + s0->lma += dl; +#ifdef DEBUG + printf("section %s LMA set to %#jx\n", + s0->name, (uintmax_t) s0->lma); +#endif + } + } + } + + /* * Issue a warning if there are VMA/LMA adjust requests for * some nonexistent sections. */ if ((ecp->flags & NO_CHANGE_WARN) == 0) { STAILQ_FOREACH(sac, &ecp->v_sac, sac_list) { if (!sac->setvma && !sac->setlma && !sac->vma_adjust && !sac->lma_adjust) continue; found = 0; TAILQ_FOREACH(s, &ecp->v_sec, sec_list) { if (s->pseudo || s->name == NULL) continue; if (!strcmp(s->name, sac->name)) { found = 1; break; } } if (!found) warnx("cannot find section `%s'", sac->name); } } } static void insert_to_inseg_list(struct segment *seg, struct section *sec) { struct section *s; int i; seg->nsec++; seg->v_sec = realloc(seg->v_sec, seg->nsec * sizeof(*seg->v_sec)); if (seg->v_sec == NULL) err(EXIT_FAILURE, "realloc failed"); /* * Sort the section in order of offset. */ for (i = seg->nsec - 1; i > 0; i--) { s = seg->v_sec[i - 1]; if (sec->off >= s->off) { seg->v_sec[i] = sec; break; } else seg->v_sec[i] = s; } if (i == 0) seg->v_sec[0] = sec; } void setup_phdr(struct elfcopy *ecp) { struct segment *seg; GElf_Phdr iphdr; - size_t iphnum; - int i; + size_t iphnum, i; if (elf_getphnum(ecp->ein, &iphnum) == 0) errx(EXIT_FAILURE, "elf_getphnum failed: %s", elf_errmsg(-1)); ecp->ophnum = ecp->iphnum = iphnum; if (iphnum == 0) return; /* If --only-keep-debug is specified, discard all program headers. */ if (ecp->strip == STRIP_NONDEBUG) { ecp->ophnum = 0; return; } - for (i = 0; (size_t)i < iphnum; i++) { + for (i = 0; i < iphnum; i++) { if (gelf_getphdr(ecp->ein, i, &iphdr) != &iphdr) errx(EXIT_FAILURE, "gelf_getphdr failed: %s", elf_errmsg(-1)); if ((seg = calloc(1, sizeof(*seg))) == NULL) err(EXIT_FAILURE, "calloc failed"); - seg->addr = iphdr.p_vaddr; + seg->vaddr = iphdr.p_vaddr; + seg->paddr = iphdr.p_paddr; seg->off = iphdr.p_offset; seg->fsz = iphdr.p_filesz; seg->msz = iphdr.p_memsz; seg->type = iphdr.p_type; STAILQ_INSERT_TAIL(&ecp->v_seg, seg, seg_list); } } void copy_phdr(struct elfcopy *ecp) { struct segment *seg; struct section *s; GElf_Phdr iphdr, ophdr; int i; STAILQ_FOREACH(seg, &ecp->v_seg, seg_list) { if (seg->type == PT_PHDR) { if (!TAILQ_EMPTY(&ecp->v_sec)) { s = TAILQ_FIRST(&ecp->v_sec); - if (s->pseudo) - seg->addr = s->lma + + if (s->pseudo) { + seg->vaddr = s->vma + gelf_fsize(ecp->eout, ELF_T_EHDR, 1, EV_CURRENT); + seg->paddr = s->lma + + gelf_fsize(ecp->eout, ELF_T_EHDR, + 1, EV_CURRENT); + } } seg->fsz = seg->msz = gelf_fsize(ecp->eout, ELF_T_PHDR, ecp->ophnum, EV_CURRENT); continue; } + if (seg->nsec > 0) { + s = seg->v_sec[0]; + seg->vaddr = s->vma; + seg->paddr = s->lma; + } + seg->fsz = seg->msz = 0; for (i = 0; i < seg->nsec; i++) { s = seg->v_sec[i]; - seg->msz = s->vma + s->sz - seg->addr; + seg->msz = s->vma + s->sz - seg->vaddr; if (s->type != SHT_NOBITS) seg->fsz = s->off + s->sz - seg->off; } } /* * Allocate space for program headers, note that libelf keep * track of the number in internal variable, and a call to * elf_update is needed to update e_phnum of ehdr. */ if (gelf_newphdr(ecp->eout, ecp->ophnum) == NULL) errx(EXIT_FAILURE, "gelf_newphdr() failed: %s", elf_errmsg(-1)); /* * This elf_update() call is to update the e_phnum field in * ehdr. It's necessary because later we will call gelf_getphdr(), * which does sanity check by comparing ndx argument with e_phnum. */ if (elf_update(ecp->eout, ELF_C_NULL) < 0) errx(EXIT_FAILURE, "elf_update() failed: %s", elf_errmsg(-1)); /* * iphnum == ophnum, since we don't remove program headers even if * they no longer contain sections. */ i = 0; STAILQ_FOREACH(seg, &ecp->v_seg, seg_list) { if (i >= ecp->iphnum) break; if (gelf_getphdr(ecp->ein, i, &iphdr) != &iphdr) errx(EXIT_FAILURE, "gelf_getphdr failed: %s", elf_errmsg(-1)); if (gelf_getphdr(ecp->eout, i, &ophdr) != &ophdr) errx(EXIT_FAILURE, "gelf_getphdr failed: %s", elf_errmsg(-1)); ophdr.p_type = iphdr.p_type; - ophdr.p_vaddr = seg->addr; - ophdr.p_paddr = seg->addr; + ophdr.p_vaddr = seg->vaddr; + ophdr.p_paddr = seg->paddr; ophdr.p_flags = iphdr.p_flags; ophdr.p_align = iphdr.p_align; ophdr.p_offset = seg->off; ophdr.p_filesz = seg->fsz; ophdr.p_memsz = seg->msz; if (!gelf_update_phdr(ecp->eout, i, &ophdr)) errx(EXIT_FAILURE, "gelf_update_phdr failed: %s", elf_errmsg(-1)); i++; } } Index: vendor/elftoolchain/dist/elfcopy/symbols.c =================================================================== --- vendor/elftoolchain/dist/elfcopy/symbols.c (revision 300227) +++ vendor/elftoolchain/dist/elfcopy/symbols.c (revision 300228) @@ -1,1205 +1,1205 @@ /*- * Copyright (c) 2007-2013 Kai Wang * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #include #include #include #include #include #include #include "elfcopy.h" -ELFTC_VCSID("$Id: symbols.c 3376 2016-01-26 18:41:39Z emaste $"); +ELFTC_VCSID("$Id: symbols.c 3446 2016-05-03 01:31:17Z emaste $"); /* Symbol table buffer structure. */ struct symbuf { Elf32_Sym *l32; /* 32bit local symbol */ Elf32_Sym *g32; /* 32bit global symbol */ Elf64_Sym *l64; /* 64bit local symbol */ Elf64_Sym *g64; /* 64bit global symbol */ size_t ngs, nls; /* number of each kind */ size_t gcap, lcap; /* buffer capacities. */ }; struct sthash { LIST_ENTRY(sthash) sh_next; size_t sh_off; }; typedef LIST_HEAD(,sthash) hash_head; #define STHASHSIZE 65536 struct strimpl { char *buf; /* string table */ size_t sz; /* entries */ size_t cap; /* buffer capacity */ hash_head hash[STHASHSIZE]; }; /* String table buffer structure. */ struct strbuf { struct strimpl l; /* local symbols */ struct strimpl g; /* global symbols */ }; static int is_debug_symbol(unsigned char st_info); static int is_global_symbol(unsigned char st_info); static int is_local_symbol(unsigned char st_info); static int is_local_label(const char *name); static int is_needed_symbol(struct elfcopy *ecp, int i, GElf_Sym *s); static int is_remove_symbol(struct elfcopy *ecp, size_t sc, int i, GElf_Sym *s, const char *name); static int is_weak_symbol(unsigned char st_info); static int lookup_exact_string(hash_head *hash, const char *buf, const char *s); static int generate_symbols(struct elfcopy *ecp); static void mark_reloc_symbols(struct elfcopy *ecp, size_t sc); static void mark_section_group_symbols(struct elfcopy *ecp, size_t sc); uint32_t str_hash(const char *s); /* Convenient bit vector operation macros. */ #define BIT_SET(v, n) (v[(n)>>3] |= 1U << ((n) & 7)) #define BIT_CLR(v, n) (v[(n)>>3] &= ~(1U << ((n) & 7))) #define BIT_ISSET(v, n) (v[(n)>>3] & (1U << ((n) & 7))) static int is_debug_symbol(unsigned char st_info) { if (GELF_ST_TYPE(st_info) == STT_SECTION || GELF_ST_TYPE(st_info) == STT_FILE) return (1); return (0); } static int is_global_symbol(unsigned char st_info) { if (GELF_ST_BIND(st_info) == STB_GLOBAL || GELF_ST_BIND(st_info) == STB_GNU_UNIQUE) return (1); return (0); } static int is_weak_symbol(unsigned char st_info) { if (GELF_ST_BIND(st_info) == STB_WEAK) return (1); return (0); } static int is_local_symbol(unsigned char st_info) { if (GELF_ST_BIND(st_info) == STB_LOCAL) return (1); return (0); } static int is_hidden_symbol(unsigned char st_other) { if (GELF_ST_VISIBILITY(st_other) == STV_HIDDEN || GELF_ST_VISIBILITY(st_other) == STV_INTERNAL) return (1); return (0); } static int is_local_label(const char *name) { /* Compiler generated local symbols that start with .L */ if (name[0] == '.' && name[1] == 'L') return (1); return (0); } /* * Symbols related to relocation are needed. */ static int is_needed_symbol(struct elfcopy *ecp, int i, GElf_Sym *s) { /* If symbol involves relocation, it is needed. */ if (BIT_ISSET(ecp->v_rel, i)) return (1); - /* Symbols refered by COMDAT sections are needed. */ + /* Symbols referred by COMDAT sections are needed. */ if (BIT_ISSET(ecp->v_grp, i)) return (1); /* * For relocatable files (.o files), global and weak symbols * are needed. */ if (ecp->flags & RELOCATABLE) { if (is_global_symbol(s->st_info) || is_weak_symbol(s->st_info)) return (1); } return (0); } static int is_remove_symbol(struct elfcopy *ecp, size_t sc, int i, GElf_Sym *s, const char *name) { GElf_Sym sym0 = { 0, /* st_name */ 0, /* st_value */ 0, /* st_size */ 0, /* st_info */ 0, /* st_other */ SHN_UNDEF, /* st_shndx */ }; /* * Keep the first symbol if it is the special reserved symbol. * XXX Should we generate one if it's missing? */ if (i == 0 && !memcmp(s, &sym0, sizeof(GElf_Sym))) return (0); /* Remove the symbol if the section it refers to was removed. */ if (s->st_shndx != SHN_UNDEF && s->st_shndx < SHN_LORESERVE && ecp->secndx[s->st_shndx] == 0) return (1); /* Keep the symbol if specified by command line option -K. */ if (lookup_symop_list(ecp, name, SYMOP_KEEP) != NULL) return (0); if (ecp->strip == STRIP_ALL) return (1); /* Mark symbols used in relocation. */ if (ecp->v_rel == NULL) mark_reloc_symbols(ecp, sc); /* Mark symbols used in section groups. */ if (ecp->v_grp == NULL) mark_section_group_symbols(ecp, sc); /* * Strip the symbol if specified by command line option -N, * unless it's used in relocation. */ if (lookup_symop_list(ecp, name, SYMOP_STRIP) != NULL) { if (BIT_ISSET(ecp->v_rel, i)) { warnx("not stripping symbol `%s' because it is named" " in a relocation", name); return (0); } return (1); } if (is_needed_symbol(ecp, i, s)) return (0); if (ecp->strip == STRIP_UNNEEDED) return (1); if ((ecp->flags & DISCARD_LOCAL) && is_local_symbol(s->st_info) && !is_debug_symbol(s->st_info)) return (1); if ((ecp->flags & DISCARD_LLABEL) && is_local_symbol(s->st_info) && !is_debug_symbol(s->st_info) && is_local_label(name)) return (1); if (ecp->strip == STRIP_DEBUG && is_debug_symbol(s->st_info)) return (1); return (0); } /* - * Mark symbols refered by relocation entries. + * Mark symbols referred by relocation entries. */ static void mark_reloc_symbols(struct elfcopy *ecp, size_t sc) { const char *name; Elf_Data *d; Elf_Scn *s; GElf_Rel r; GElf_Rela ra; GElf_Shdr sh; size_t n, indx; int elferr, i, len; ecp->v_rel = calloc((sc + 7) / 8, 1); if (ecp->v_rel == NULL) err(EXIT_FAILURE, "calloc failed"); if (elf_getshstrndx(ecp->ein, &indx) == 0) errx(EXIT_FAILURE, "elf_getshstrndx failed: %s", elf_errmsg(-1)); s = NULL; while ((s = elf_nextscn(ecp->ein, s)) != NULL) { if (gelf_getshdr(s, &sh) != &sh) errx(EXIT_FAILURE, "elf_getshdr failed: %s", elf_errmsg(-1)); if (sh.sh_type != SHT_REL && sh.sh_type != SHT_RELA) continue; /* * Skip if this reloc section won't appear in the * output object. */ if ((name = elf_strptr(ecp->ein, indx, sh.sh_name)) == NULL) errx(EXIT_FAILURE, "elf_strptr failed: %s", elf_errmsg(-1)); if (is_remove_section(ecp, name) || is_remove_reloc_sec(ecp, sh.sh_info)) continue; /* Skip if it's not for .symtab */ if (sh.sh_link != elf_ndxscn(ecp->symtab->is)) continue; d = NULL; n = 0; while (n < sh.sh_size && (d = elf_getdata(s, d)) != NULL) { len = d->d_size / sh.sh_entsize; for (i = 0; i < len; i++) { if (sh.sh_type == SHT_REL) { if (gelf_getrel(d, i, &r) != &r) errx(EXIT_FAILURE, "elf_getrel failed: %s", elf_errmsg(-1)); n = GELF_R_SYM(r.r_info); } else { if (gelf_getrela(d, i, &ra) != &ra) errx(EXIT_FAILURE, "elf_getrela failed: %s", elf_errmsg(-1)); n = GELF_R_SYM(ra.r_info); } if (n > 0 && n < sc) BIT_SET(ecp->v_rel, n); else if (n != 0) warnx("invalid symbox index"); } } elferr = elf_errno(); if (elferr != 0) errx(EXIT_FAILURE, "elf_getdata failed: %s", elf_errmsg(elferr)); } elferr = elf_errno(); if (elferr != 0) errx(EXIT_FAILURE, "elf_nextscn failed: %s", elf_errmsg(elferr)); } static void mark_section_group_symbols(struct elfcopy *ecp, size_t sc) { const char *name; Elf_Scn *s; GElf_Shdr sh; size_t indx; int elferr; ecp->v_grp = calloc((sc + 7) / 8, 1); if (ecp->v_grp == NULL) err(EXIT_FAILURE, "calloc failed"); if (elf_getshstrndx(ecp->ein, &indx) == 0) errx(EXIT_FAILURE, "elf_getshstrndx failed: %s", elf_errmsg(-1)); s = NULL; while ((s = elf_nextscn(ecp->ein, s)) != NULL) { if (gelf_getshdr(s, &sh) != &sh) errx(EXIT_FAILURE, "elf_getshdr failed: %s", elf_errmsg(-1)); if (sh.sh_type != SHT_GROUP) continue; if ((name = elf_strptr(ecp->ein, indx, sh.sh_name)) == NULL) errx(EXIT_FAILURE, "elf_strptr failed: %s", elf_errmsg(-1)); if (is_remove_section(ecp, name)) continue; if (sh.sh_info > 0 && sh.sh_info < sc) BIT_SET(ecp->v_grp, sh.sh_info); else if (sh.sh_info != 0) warnx("invalid symbox index"); } elferr = elf_errno(); if (elferr != 0) errx(EXIT_FAILURE, "elf_nextscn failed: %s", elf_errmsg(elferr)); } static int generate_symbols(struct elfcopy *ecp) { struct section *s; struct symop *sp; struct symbuf *sy_buf; struct strbuf *st_buf; const char *name; char *newname; unsigned char *gsym; GElf_Shdr ish; GElf_Sym sym; Elf_Data* id; Elf_Scn *is; size_t ishstrndx, namelen, ndx, sc, symndx; int ec, elferr, i; if (elf_getshstrndx(ecp->ein, &ishstrndx) == 0) errx(EXIT_FAILURE, "elf_getshstrndx failed: %s", elf_errmsg(-1)); if ((ec = gelf_getclass(ecp->eout)) == ELFCLASSNONE) errx(EXIT_FAILURE, "gelf_getclass failed: %s", elf_errmsg(-1)); /* Create buffers for .symtab and .strtab. */ if ((sy_buf = calloc(1, sizeof(*sy_buf))) == NULL) err(EXIT_FAILURE, "calloc failed"); if ((st_buf = calloc(1, sizeof(*st_buf))) == NULL) err(EXIT_FAILURE, "calloc failed"); sy_buf->gcap = sy_buf->lcap = 64; st_buf->g.cap = 256; st_buf->l.cap = 64; st_buf->l.sz = 1; /* '\0' at start. */ st_buf->g.sz = 0; ecp->symtab->sz = 0; ecp->strtab->sz = 0; ecp->symtab->buf = sy_buf; ecp->strtab->buf = st_buf; gsym = NULL; /* * Create bit vector v_secsym, which is used to mark sections * that already have corresponding STT_SECTION symbols. */ ecp->v_secsym = calloc((ecp->nos + 7) / 8, 1); if (ecp->v_secsym == NULL) err(EXIT_FAILURE, "calloc failed"); /* Locate .strtab of input object. */ symndx = 0; name = NULL; is = NULL; while ((is = elf_nextscn(ecp->ein, is)) != NULL) { if (gelf_getshdr(is, &ish) != &ish) errx(EXIT_FAILURE, "elf_getshdr failed: %s", elf_errmsg(-1)); if ((name = elf_strptr(ecp->ein, ishstrndx, ish.sh_name)) == NULL) errx(EXIT_FAILURE, "elf_strptr failed: %s", elf_errmsg(-1)); if (strcmp(name, ".strtab") == 0) { symndx = elf_ndxscn(is); break; } } elferr = elf_errno(); if (elferr != 0) errx(EXIT_FAILURE, "elf_nextscn failed: %s", elf_errmsg(elferr)); /* Symbol table should exist if this function is called. */ if (symndx == 0) { warnx("can't find .strtab section"); goto clean; } /* Locate .symtab of input object. */ is = NULL; while ((is = elf_nextscn(ecp->ein, is)) != NULL) { if (gelf_getshdr(is, &ish) != &ish) errx(EXIT_FAILURE, "elf_getshdr failed: %s", elf_errmsg(-1)); if ((name = elf_strptr(ecp->ein, ishstrndx, ish.sh_name)) == NULL) errx(EXIT_FAILURE, "elf_strptr failed: %s", elf_errmsg(-1)); if (strcmp(name, ".symtab") == 0) break; } elferr = elf_errno(); if (elferr != 0) errx(EXIT_FAILURE, "elf_nextscn failed: %s", elf_errmsg(elferr)); if (is == NULL) errx(EXIT_FAILURE, "can't find .strtab section"); /* * Create bit vector gsym to mark global symbols, and symndx * to keep track of symbol index changes from input object to * output object, it is used by update_reloc() later to update * relocation information. */ sc = ish.sh_size / ish.sh_entsize; if (sc > 0) { ecp->symndx = calloc(sc, sizeof(*ecp->symndx)); if (ecp->symndx == NULL) err(EXIT_FAILURE, "calloc failed"); gsym = calloc((sc + 7) / 8, sizeof(*gsym)); if (gsym == NULL) err(EXIT_FAILURE, "calloc failed"); if ((id = elf_getdata(is, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) errx(EXIT_FAILURE, "elf_getdata failed: %s", elf_errmsg(elferr)); goto clean; } } else return (0); /* Copy/Filter each symbol. */ for (i = 0; (size_t)i < sc; i++) { if (gelf_getsym(id, i, &sym) != &sym) errx(EXIT_FAILURE, "gelf_getsym failed: %s", elf_errmsg(-1)); if ((name = elf_strptr(ecp->ein, symndx, sym.st_name)) == NULL) errx(EXIT_FAILURE, "elf_strptr failed: %s", elf_errmsg(-1)); /* Symbol filtering. */ if (is_remove_symbol(ecp, sc, i, &sym, name) != 0) continue; /* Check if we need to change the binding of this symbol. */ if (is_global_symbol(sym.st_info) || is_weak_symbol(sym.st_info)) { /* * XXX Binutils objcopy does not weaken certain * symbols. */ if (ecp->flags & WEAKEN_ALL || lookup_symop_list(ecp, name, SYMOP_WEAKEN) != NULL) sym.st_info = GELF_ST_INFO(STB_WEAK, GELF_ST_TYPE(sym.st_info)); /* Do not localize undefined symbols. */ if (sym.st_shndx != SHN_UNDEF && lookup_symop_list(ecp, name, SYMOP_LOCALIZE) != NULL) sym.st_info = GELF_ST_INFO(STB_LOCAL, GELF_ST_TYPE(sym.st_info)); if (ecp->flags & KEEP_GLOBAL && sym.st_shndx != SHN_UNDEF && lookup_symop_list(ecp, name, SYMOP_KEEPG) == NULL) sym.st_info = GELF_ST_INFO(STB_LOCAL, GELF_ST_TYPE(sym.st_info)); if (ecp->flags & LOCALIZE_HIDDEN && sym.st_shndx != SHN_UNDEF && is_hidden_symbol(sym.st_other)) sym.st_info = GELF_ST_INFO(STB_LOCAL, GELF_ST_TYPE(sym.st_info)); } else { /* STB_LOCAL binding. */ if (lookup_symop_list(ecp, name, SYMOP_GLOBALIZE) != NULL) sym.st_info = GELF_ST_INFO(STB_GLOBAL, GELF_ST_TYPE(sym.st_info)); /* XXX We should globalize weak symbol? */ } /* Check if we need to rename this symbol. */ if ((sp = lookup_symop_list(ecp, name, SYMOP_REDEF)) != NULL) name = sp->newname; /* Check if we need to prefix the symbols. */ newname = NULL; if (ecp->prefix_sym != NULL && name != NULL && *name != '\0') { namelen = strlen(name) + strlen(ecp->prefix_sym) + 1; if ((newname = malloc(namelen)) == NULL) err(EXIT_FAILURE, "malloc failed"); snprintf(newname, namelen, "%s%s", ecp->prefix_sym, name); name = newname; } /* Copy symbol, mark global/weak symbol and add to index map. */ if (is_global_symbol(sym.st_info) || is_weak_symbol(sym.st_info)) { BIT_SET(gsym, i); ecp->symndx[i] = sy_buf->ngs; } else ecp->symndx[i] = sy_buf->nls; add_to_symtab(ecp, name, sym.st_value, sym.st_size, sym.st_shndx, sym.st_info, sym.st_other, 0); if (newname != NULL) free(newname); /* * If the symbol is a STT_SECTION symbol, mark the section * it points to. */ if (GELF_ST_TYPE(sym.st_info) == STT_SECTION && sym.st_shndx < SHN_LORESERVE) { assert(ecp->secndx[sym.st_shndx] < (uint64_t)ecp->nos); BIT_SET(ecp->v_secsym, ecp->secndx[sym.st_shndx]); } } /* * Give up if there is no real symbols inside the table. * XXX The logic here needs to be improved. We need to * check if that only local symbol is the reserved symbol. */ if (sy_buf->nls <= 1 && sy_buf->ngs == 0) goto clean; /* * Create STT_SECTION symbols for sections that do not already * got one. However, we do not create STT_SECTION symbol for * .symtab, .strtab, .shstrtab and reloc sec of relocatables. */ TAILQ_FOREACH(s, &ecp->v_sec, sec_list) { if (s->pseudo) continue; if (strcmp(s->name, ".symtab") == 0 || strcmp(s->name, ".strtab") == 0 || strcmp(s->name, ".shstrtab") == 0) continue; if ((ecp->flags & RELOCATABLE) != 0 && ((s->type == SHT_REL) || (s->type == SHT_RELA))) continue; if ((ndx = elf_ndxscn(s->os)) == SHN_UNDEF) errx(EXIT_FAILURE, "elf_ndxscn failed: %s", elf_errmsg(-1)); if (!BIT_ISSET(ecp->v_secsym, ndx)) { sym.st_name = 0; sym.st_value = s->vma; sym.st_size = 0; sym.st_info = GELF_ST_INFO(STB_LOCAL, STT_SECTION); sym.st_other = STV_DEFAULT; /* * Don't let add_to_symtab() touch sym.st_shndx. * In this case, we know the index already. */ add_to_symtab(ecp, NULL, sym.st_value, sym.st_size, ndx, sym.st_info, sym.st_other, 1); } } /* * Update st_name and index map for global/weak symbols. Note that * global/weak symbols are put after local symbols. */ if (gsym != NULL) { for(i = 0; (size_t) i < sc; i++) { if (!BIT_ISSET(gsym, i)) continue; /* Update st_name. */ if (ec == ELFCLASS32) sy_buf->g32[ecp->symndx[i]].st_name += st_buf->l.sz; else sy_buf->g64[ecp->symndx[i]].st_name += st_buf->l.sz; /* Update index map. */ ecp->symndx[i] += sy_buf->nls; } free(gsym); } return (1); clean: free(gsym); free_symtab(ecp); return (0); } void create_symtab(struct elfcopy *ecp) { struct section *s, *sy, *st; size_t maxndx, ndx; sy = ecp->symtab; st = ecp->strtab; /* * Set section index map for .symtab and .strtab. We need to set * these map because otherwise symbols which refer to .symtab and * .strtab will be removed by symbol filtering unconditionally. * And we have to figure out scn index this way (instead of calling * elf_ndxscn) because we can not create Elf_Scn before we're certain * that .symtab and .strtab will exist in the output object. */ maxndx = 0; TAILQ_FOREACH(s, &ecp->v_sec, sec_list) { if (s->os == NULL) continue; if ((ndx = elf_ndxscn(s->os)) == SHN_UNDEF) errx(EXIT_FAILURE, "elf_ndxscn failed: %s", elf_errmsg(-1)); if (ndx > maxndx) maxndx = ndx; } ecp->secndx[elf_ndxscn(sy->is)] = maxndx + 1; ecp->secndx[elf_ndxscn(st->is)] = maxndx + 2; /* * Generate symbols for output object if SYMTAB_INTACT is not set. * If there is no symbol in the input object or all the symbols are * stripped, then free all the resouces allotted for symbol table, * and clear SYMTAB_EXIST flag. */ if (((ecp->flags & SYMTAB_INTACT) == 0) && !generate_symbols(ecp)) { TAILQ_REMOVE(&ecp->v_sec, ecp->symtab, sec_list); TAILQ_REMOVE(&ecp->v_sec, ecp->strtab, sec_list); free(ecp->symtab->buf); free(ecp->symtab); free(ecp->strtab->buf); free(ecp->strtab); ecp->symtab = NULL; ecp->strtab = NULL; ecp->flags &= ~SYMTAB_EXIST; return; } /* Create output Elf_Scn for .symtab and .strtab. */ if ((sy->os = elf_newscn(ecp->eout)) == NULL || (st->os = elf_newscn(ecp->eout)) == NULL) errx(EXIT_FAILURE, "elf_newscn failed: %s", elf_errmsg(-1)); /* Update secndx anyway. */ ecp->secndx[elf_ndxscn(sy->is)] = elf_ndxscn(sy->os); ecp->secndx[elf_ndxscn(st->is)] = elf_ndxscn(st->os); /* * Copy .symtab and .strtab section headers from input to output * object to start with, these will be overridden later if need. */ copy_shdr(ecp, sy, ".symtab", 1, 0); copy_shdr(ecp, st, ".strtab", 1, 0); /* Copy verbatim if symbol table is intact. */ if (ecp->flags & SYMTAB_INTACT) { copy_data(sy); copy_data(st); return; } create_symtab_data(ecp); } void free_symtab(struct elfcopy *ecp) { struct symbuf *sy_buf; struct strbuf *st_buf; struct sthash *sh, *shtmp; int i; if (ecp->symtab != NULL && ecp->symtab->buf != NULL) { sy_buf = ecp->symtab->buf; if (sy_buf->l32 != NULL) free(sy_buf->l32); if (sy_buf->g32 != NULL) free(sy_buf->g32); if (sy_buf->l64 != NULL) free(sy_buf->l64); if (sy_buf->g64 != NULL) free(sy_buf->g64); } if (ecp->strtab != NULL && ecp->strtab->buf != NULL) { st_buf = ecp->strtab->buf; if (st_buf->l.buf != NULL) free(st_buf->l.buf); if (st_buf->g.buf != NULL) free(st_buf->g.buf); for (i = 0; i < STHASHSIZE; i++) { LIST_FOREACH_SAFE(sh, &st_buf->l.hash[i], sh_next, shtmp) { LIST_REMOVE(sh, sh_next); free(sh); } LIST_FOREACH_SAFE(sh, &st_buf->g.hash[i], sh_next, shtmp) { LIST_REMOVE(sh, sh_next); free(sh); } } } if (ecp->symndx != NULL) { free(ecp->symndx); ecp->symndx = NULL; } if (ecp->v_rel != NULL) { free(ecp->v_rel); ecp->v_rel = NULL; } if (ecp->v_grp != NULL) { free(ecp->v_grp); ecp->v_grp = NULL; } if (ecp->v_secsym != NULL) { free(ecp->v_secsym); ecp->v_secsym = NULL; } } void create_external_symtab(struct elfcopy *ecp) { struct section *s; struct symbuf *sy_buf; struct strbuf *st_buf; GElf_Shdr sh; size_t ndx; if (ecp->oec == ELFCLASS32) ecp->symtab = create_external_section(ecp, ".symtab", NULL, NULL, 0, 0, SHT_SYMTAB, ELF_T_SYM, 0, 4, 0, 0); else ecp->symtab = create_external_section(ecp, ".symtab", NULL, NULL, 0, 0, SHT_SYMTAB, ELF_T_SYM, 0, 8, 0, 0); ecp->strtab = create_external_section(ecp, ".strtab", NULL, NULL, 0, 0, SHT_STRTAB, ELF_T_BYTE, 0, 1, 0, 0); /* Let sh_link field of .symtab section point to .strtab section. */ if (gelf_getshdr(ecp->symtab->os, &sh) == NULL) errx(EXIT_FAILURE, "gelf_getshdr() failed: %s", elf_errmsg(-1)); sh.sh_link = elf_ndxscn(ecp->strtab->os); if (!gelf_update_shdr(ecp->symtab->os, &sh)) errx(EXIT_FAILURE, "gelf_update_shdr() failed: %s", elf_errmsg(-1)); /* Create buffers for .symtab and .strtab. */ if ((sy_buf = calloc(1, sizeof(*sy_buf))) == NULL) err(EXIT_FAILURE, "calloc failed"); if ((st_buf = calloc(1, sizeof(*st_buf))) == NULL) err(EXIT_FAILURE, "calloc failed"); sy_buf->gcap = sy_buf->lcap = 64; st_buf->g.cap = 256; st_buf->l.cap = 64; st_buf->l.sz = 1; /* '\0' at start. */ st_buf->g.sz = 0; ecp->symtab->sz = 0; ecp->strtab->sz = 0; ecp->symtab->buf = sy_buf; ecp->strtab->buf = st_buf; /* Always create the special symbol at the symtab beginning. */ add_to_symtab(ecp, NULL, 0, 0, SHN_UNDEF, ELF32_ST_INFO(STB_LOCAL, STT_NOTYPE), 0, 1); /* Create STT_SECTION symbols. */ TAILQ_FOREACH(s, &ecp->v_sec, sec_list) { if (s->pseudo) continue; if (strcmp(s->name, ".symtab") == 0 || strcmp(s->name, ".strtab") == 0 || strcmp(s->name, ".shstrtab") == 0) continue; (void) elf_errno(); if ((ndx = elf_ndxscn(s->os)) == SHN_UNDEF) { warnx("elf_ndxscn failed: %s", elf_errmsg(-1)); continue; } add_to_symtab(ecp, NULL, 0, 0, ndx, GELF_ST_INFO(STB_LOCAL, STT_SECTION), 0, 1); } } void add_to_symtab(struct elfcopy *ecp, const char *name, uint64_t st_value, uint64_t st_size, uint16_t st_shndx, unsigned char st_info, unsigned char st_other, int ndx_known) { struct symbuf *sy_buf; struct strbuf *st_buf; struct sthash *sh; uint32_t hash; int pos; /* * Convenient macro for copying global/local 32/64 bit symbols * from input object to the buffer created for output object. * It handles buffer growing, st_name calculating and st_shndx * updating for symbols with non-special section index. */ #define _ST_NAME_EMPTY_l 0 #define _ST_NAME_EMPTY_g -1 #define _ADDSYM(B, SZ) do { \ if (sy_buf->B##SZ == NULL) { \ sy_buf->B##SZ = malloc(sy_buf->B##cap * \ sizeof(Elf##SZ##_Sym)); \ if (sy_buf->B##SZ == NULL) \ err(EXIT_FAILURE, "malloc failed"); \ } else if (sy_buf->n##B##s >= sy_buf->B##cap) { \ sy_buf->B##cap *= 2; \ sy_buf->B##SZ = realloc(sy_buf->B##SZ, sy_buf->B##cap * \ sizeof(Elf##SZ##_Sym)); \ if (sy_buf->B##SZ == NULL) \ err(EXIT_FAILURE, "realloc failed"); \ } \ sy_buf->B##SZ[sy_buf->n##B##s].st_info = st_info; \ sy_buf->B##SZ[sy_buf->n##B##s].st_other = st_other; \ sy_buf->B##SZ[sy_buf->n##B##s].st_value = st_value; \ sy_buf->B##SZ[sy_buf->n##B##s].st_size = st_size; \ if (ndx_known) \ sy_buf->B##SZ[sy_buf->n##B##s].st_shndx = st_shndx; \ else if (st_shndx == SHN_UNDEF || st_shndx >= SHN_LORESERVE) \ sy_buf->B##SZ[sy_buf->n##B##s].st_shndx = st_shndx; \ else \ sy_buf->B##SZ[sy_buf->n##B##s].st_shndx = \ ecp->secndx[st_shndx]; \ if (st_buf->B.buf == NULL) { \ st_buf->B.buf = calloc(st_buf->B.cap, \ sizeof(*st_buf->B.buf)); \ if (st_buf->B.buf == NULL) \ err(EXIT_FAILURE, "malloc failed"); \ } \ if (name != NULL && *name != '\0') { \ pos = lookup_exact_string(st_buf->B.hash, st_buf->B.buf,\ name); \ if (pos != -1) \ sy_buf->B##SZ[sy_buf->n##B##s].st_name = pos; \ else { \ sy_buf->B##SZ[sy_buf->n##B##s].st_name = \ st_buf->B.sz; \ while (st_buf->B.sz + strlen(name) >= \ st_buf->B.cap - 1) { \ st_buf->B.cap *= 2; \ st_buf->B.buf = realloc(st_buf->B.buf, \ st_buf->B.cap); \ if (st_buf->B.buf == NULL) \ err(EXIT_FAILURE, \ "realloc failed"); \ } \ if ((sh = malloc(sizeof(*sh))) == NULL) \ err(EXIT_FAILURE, "malloc failed"); \ sh->sh_off = st_buf->B.sz; \ hash = str_hash(name); \ LIST_INSERT_HEAD(&st_buf->B.hash[hash], sh, \ sh_next); \ strncpy(&st_buf->B.buf[st_buf->B.sz], name, \ strlen(name)); \ st_buf->B.buf[st_buf->B.sz + strlen(name)] = '\0'; \ st_buf->B.sz += strlen(name) + 1; \ } \ } else \ sy_buf->B##SZ[sy_buf->n##B##s].st_name = \ (Elf##SZ##_Word)_ST_NAME_EMPTY_##B; \ sy_buf->n##B##s++; \ } while (0) sy_buf = ecp->symtab->buf; st_buf = ecp->strtab->buf; if (ecp->oec == ELFCLASS32) { if (is_local_symbol(st_info)) _ADDSYM(l, 32); else _ADDSYM(g, 32); } else { if (is_local_symbol(st_info)) _ADDSYM(l, 64); else _ADDSYM(g, 64); } /* Update section size. */ ecp->symtab->sz = (sy_buf->nls + sy_buf->ngs) * (ecp->oec == ELFCLASS32 ? sizeof(Elf32_Sym) : sizeof(Elf64_Sym)); ecp->strtab->sz = st_buf->l.sz + st_buf->g.sz; #undef _ADDSYM #undef _ST_NAME_EMPTY_l #undef _ST_NAME_EMPTY_g } void finalize_external_symtab(struct elfcopy *ecp) { struct symbuf *sy_buf; struct strbuf *st_buf; int i; /* * Update st_name for global/weak symbols. (global/weak symbols * are put after local symbols) */ sy_buf = ecp->symtab->buf; st_buf = ecp->strtab->buf; for (i = 0; (size_t) i < sy_buf->ngs; i++) { if (ecp->oec == ELFCLASS32) { if (sy_buf->g32[i].st_name == (Elf32_Word)-1) sy_buf->g32[i].st_name = 0; else sy_buf->g32[i].st_name += st_buf->l.sz; } else { if (sy_buf->g64[i].st_name == (Elf64_Word)-1) sy_buf->g64[i].st_name = 0; else sy_buf->g64[i].st_name += st_buf->l.sz; } } } void create_symtab_data(struct elfcopy *ecp) { struct section *sy, *st; struct symbuf *sy_buf; struct strbuf *st_buf; Elf_Data *gsydata, *lsydata, *gstdata, *lstdata; GElf_Shdr shy, sht; sy = ecp->symtab; st = ecp->strtab; if (gelf_getshdr(sy->os, ­) == NULL) errx(EXIT_FAILURE, "gelf_getshdr() failed: %s", elf_errmsg(-1)); if (gelf_getshdr(st->os, &sht) == NULL) errx(EXIT_FAILURE, "gelf_getshdr() failed: %s", elf_errmsg(-1)); /* * Create two Elf_Data for .symtab section of output object, one * for local symbols and another for global symbols. Note that * local symbols appear first in the .symtab. */ sy_buf = sy->buf; if (sy_buf->nls > 0) { if ((lsydata = elf_newdata(sy->os)) == NULL) errx(EXIT_FAILURE, "elf_newdata() failed: %s.", elf_errmsg(-1)); if (ecp->oec == ELFCLASS32) { lsydata->d_align = 4; lsydata->d_off = 0; lsydata->d_buf = sy_buf->l32; lsydata->d_size = sy_buf->nls * sizeof(Elf32_Sym); lsydata->d_type = ELF_T_SYM; lsydata->d_version = EV_CURRENT; } else { lsydata->d_align = 8; lsydata->d_off = 0; lsydata->d_buf = sy_buf->l64; lsydata->d_size = sy_buf->nls * sizeof(Elf64_Sym); lsydata->d_type = ELF_T_SYM; lsydata->d_version = EV_CURRENT; } } if (sy_buf->ngs > 0) { if ((gsydata = elf_newdata(sy->os)) == NULL) errx(EXIT_FAILURE, "elf_newdata() failed: %s.", elf_errmsg(-1)); if (ecp->oec == ELFCLASS32) { gsydata->d_align = 4; gsydata->d_off = sy_buf->nls * sizeof(Elf32_Sym); gsydata->d_buf = sy_buf->g32; gsydata->d_size = sy_buf->ngs * sizeof(Elf32_Sym); gsydata->d_type = ELF_T_SYM; gsydata->d_version = EV_CURRENT; } else { gsydata->d_align = 8; gsydata->d_off = sy_buf->nls * sizeof(Elf64_Sym); gsydata->d_buf = sy_buf->g64; gsydata->d_size = sy_buf->ngs * sizeof(Elf64_Sym); gsydata->d_type = ELF_T_SYM; gsydata->d_version = EV_CURRENT; } } /* * Create two Elf_Data for .strtab, one for local symbol name * and another for globals. Same as .symtab, local symbol names * appear first. */ st_buf = st->buf; if ((lstdata = elf_newdata(st->os)) == NULL) errx(EXIT_FAILURE, "elf_newdata() failed: %s.", elf_errmsg(-1)); lstdata->d_align = 1; lstdata->d_off = 0; lstdata->d_buf = st_buf->l.buf; lstdata->d_size = st_buf->l.sz; lstdata->d_type = ELF_T_BYTE; lstdata->d_version = EV_CURRENT; if (st_buf->g.sz > 0) { if ((gstdata = elf_newdata(st->os)) == NULL) errx(EXIT_FAILURE, "elf_newdata() failed: %s.", elf_errmsg(-1)); gstdata->d_align = 1; gstdata->d_off = lstdata->d_size; gstdata->d_buf = st_buf->g.buf; gstdata->d_size = st_buf->g.sz; gstdata->d_type = ELF_T_BYTE; gstdata->d_version = EV_CURRENT; } shy.sh_addr = 0; shy.sh_addralign = (ecp->oec == ELFCLASS32 ? 4 : 8); shy.sh_size = sy->sz; shy.sh_type = SHT_SYMTAB; shy.sh_flags = 0; shy.sh_entsize = gelf_fsize(ecp->eout, ELF_T_SYM, 1, EV_CURRENT); /* * According to SYSV abi, here sh_info is one greater than * the symbol table index of the last local symbol(binding * STB_LOCAL). */ shy.sh_info = sy_buf->nls; sht.sh_addr = 0; sht.sh_addralign = 1; sht.sh_size = st->sz; sht.sh_type = SHT_STRTAB; sht.sh_flags = 0; sht.sh_entsize = 0; sht.sh_info = 0; sht.sh_link = 0; if (!gelf_update_shdr(sy->os, ­)) errx(EXIT_FAILURE, "gelf_update_shdr() failed: %s", elf_errmsg(-1)); if (!gelf_update_shdr(st->os, &sht)) errx(EXIT_FAILURE, "gelf_update_shdr() failed: %s", elf_errmsg(-1)); } void add_to_symop_list(struct elfcopy *ecp, const char *name, const char *newname, unsigned int op) { struct symop *s; assert (name != NULL); STAILQ_FOREACH(s, &ecp->v_symop, symop_list) if (!strcmp(name, s->name)) goto found; if ((s = calloc(1, sizeof(*s))) == NULL) errx(EXIT_FAILURE, "not enough memory"); STAILQ_INSERT_TAIL(&ecp->v_symop, s, symop_list); s->name = name; found: if (op == SYMOP_REDEF) s->newname = newname; s->op |= op; } struct symop * lookup_symop_list(struct elfcopy *ecp, const char *name, unsigned int op) { struct symop *s, *ret; const char *pattern; STAILQ_FOREACH(s, &ecp->v_symop, symop_list) { if ((s->op & op) == 0) continue; if (name == NULL || !strcmp(name, s->name)) - return (s); + return (s); if ((ecp->flags & WILDCARD) == 0) continue; /* Handle wildcards. */ pattern = s->name; if (pattern[0] == '!') { /* Negative match. */ pattern++; ret = NULL; } else { /* Regular wildcard match. */ ret = s; } if (!fnmatch(pattern, name, 0)) return (ret); } return (NULL); } static int lookup_exact_string(hash_head *buckets, const char *buf, const char *s) { struct sthash *sh; uint32_t hash; hash = str_hash(s); LIST_FOREACH(sh, &buckets[hash], sh_next) if (strcmp(buf + sh->sh_off, s) == 0) return sh->sh_off; return (-1); } uint32_t str_hash(const char *s) { uint32_t hash; for (hash = 2166136261UL; *s; s++) hash = (hash ^ *s) * 16777619; return (hash & (STHASHSIZE - 1)); } Index: vendor/elftoolchain/dist/elfdump/elfdump.c =================================================================== --- vendor/elftoolchain/dist/elfdump/elfdump.c (revision 300227) +++ vendor/elftoolchain/dist/elfdump/elfdump.c (revision 300228) @@ -1,2972 +1,2678 @@ /*- * Copyright (c) 2007-2012 Kai Wang * Copyright (c) 2003 David O'Brien. All rights reserved. * Copyright (c) 2001 Jake Burkholder * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef USE_LIBARCHIVE_AR #include #include #endif #include "_elftc.h" -ELFTC_VCSID("$Id: elfdump.c 3391 2016-02-05 19:43:01Z emaste $"); +ELFTC_VCSID("$Id: elfdump.c 3474 2016-05-17 20:44:53Z emaste $"); #if defined(ELFTC_NEED_ELF_NOTE_DEFINITION) #include "native-elf-format.h" #if ELFTC_CLASS == ELFCLASS32 typedef Elf32_Nhdr Elf_Note; #else typedef Elf64_Nhdr Elf_Note; #endif #endif /* elfdump(1) options. */ #define ED_DYN (1<<0) #define ED_EHDR (1<<1) #define ED_GOT (1<<2) #define ED_HASH (1<<3) #define ED_INTERP (1<<4) #define ED_NOTE (1<<5) #define ED_PHDR (1<<6) #define ED_REL (1<<7) #define ED_SHDR (1<<8) #define ED_SYMTAB (1<<9) #define ED_SYMVER (1<<10) #define ED_CHECKSUM (1<<11) #define ED_ALL ((1<<12)-1) /* elfdump(1) run control flags. */ #define SOLARIS_FMT (1<<0) #define PRINT_FILENAME (1<<1) #define PRINT_ARSYM (1<<2) #define ONLY_ARSYM (1<<3) /* Convenient print macro. */ #define PRT(...) fprintf(ed->out, __VA_ARGS__) /* Internal data structure for sections. */ struct section { const char *name; /* section name */ Elf_Scn *scn; /* section scn */ uint64_t off; /* section offset */ uint64_t sz; /* section size */ uint64_t entsize; /* section entsize */ uint64_t align; /* section alignment */ uint64_t type; /* section type */ uint64_t flags; /* section flags */ uint64_t addr; /* section virtual addr */ uint32_t link; /* section link ndx */ uint32_t info; /* section info ndx */ }; struct spec_name { const char *name; STAILQ_ENTRY(spec_name) sn_list; }; /* Structure encapsulates the global data for readelf(1). */ struct elfdump { FILE *out; /* output redirection. */ const char *filename; /* current processing file. */ const char *archive; /* archive name */ int options; /* command line options. */ int flags; /* run control flags. */ Elf *elf; /* underlying ELF descriptor. */ #ifndef USE_LIBARCHIVE_AR Elf *ar; /* ar(1) archive descriptor. */ #endif GElf_Ehdr ehdr; /* ELF header. */ int ec; /* ELF class. */ size_t shnum; /* #sections. */ struct section *sl; /* list of sections. */ STAILQ_HEAD(, spec_name) snl; /* list of names specified by -N. */ }; /* Relocation entry. */ struct rel_entry { union { GElf_Rel rel; GElf_Rela rela; } u_r; const char *symn; uint32_t type; }; #if defined(ELFTC_NEED_BYTEORDER_EXTENSIONS) static __inline uint32_t be32dec(const void *pp) { unsigned char const *p = (unsigned char const *)pp; return ((p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3]); } static __inline uint32_t le32dec(const void *pp) { unsigned char const *p = (unsigned char const *)pp; return ((p[3] << 24) | (p[2] << 16) | (p[1] << 8) | p[0]); } #endif /* http://www.sco.com/developers/gabi/latest/ch5.dynamic.html#tag_encodings */ static const char * d_tags(uint64_t tag) { static char unknown_buf[64]; switch (tag) { case DT_NULL: return "DT_NULL"; case DT_NEEDED: return "DT_NEEDED"; case DT_PLTRELSZ: return "DT_PLTRELSZ"; case DT_PLTGOT: return "DT_PLTGOT"; case DT_HASH: return "DT_HASH"; case DT_STRTAB: return "DT_STRTAB"; case DT_SYMTAB: return "DT_SYMTAB"; case DT_RELA: return "DT_RELA"; case DT_RELASZ: return "DT_RELASZ"; case DT_RELAENT: return "DT_RELAENT"; case DT_STRSZ: return "DT_STRSZ"; case DT_SYMENT: return "DT_SYMENT"; case DT_INIT: return "DT_INIT"; case DT_FINI: return "DT_FINI"; case DT_SONAME: return "DT_SONAME"; case DT_RPATH: return "DT_RPATH"; case DT_SYMBOLIC: return "DT_SYMBOLIC"; case DT_REL: return "DT_REL"; case DT_RELSZ: return "DT_RELSZ"; case DT_RELENT: return "DT_RELENT"; case DT_PLTREL: return "DT_PLTREL"; case DT_DEBUG: return "DT_DEBUG"; case DT_TEXTREL: return "DT_TEXTREL"; case DT_JMPREL: return "DT_JMPREL"; case DT_BIND_NOW: return "DT_BIND_NOW"; case DT_INIT_ARRAY: return "DT_INIT_ARRAY"; case DT_FINI_ARRAY: return "DT_FINI_ARRAY"; case DT_INIT_ARRAYSZ: return "DT_INIT_ARRAYSZ"; case DT_FINI_ARRAYSZ: return "DT_FINI_ARRAYSZ"; case DT_RUNPATH: return "DT_RUNPATH"; case DT_FLAGS: return "DT_FLAGS"; case DT_PREINIT_ARRAY: return "DT_PREINIT_ARRAY"; /* XXX DT_ENCODING */ case DT_PREINIT_ARRAYSZ:return "DT_PREINIT_ARRAYSZ"; /* 0x6000000D - 0x6ffff000 operating system-specific semantics */ case 0x6ffffdf5: return "DT_GNU_PRELINKED"; case 0x6ffffdf6: return "DT_GNU_CONFLICTSZ"; case 0x6ffffdf7: return "DT_GNU_LIBLISTSZ"; case 0x6ffffdf8: return "DT_SUNW_CHECKSUM"; case DT_PLTPADSZ: return "DT_PLTPADSZ"; case DT_MOVEENT: return "DT_MOVEENT"; case DT_MOVESZ: return "DT_MOVESZ"; case 0x6ffffdfc: return "DT_FEATURE"; case DT_POSFLAG_1: return "DT_POSFLAG_1"; case DT_SYMINSZ: return "DT_SYMINSZ"; case DT_SYMINENT: return "DT_SYMINENT (DT_VALRNGHI)"; case DT_ADDRRNGLO: return "DT_ADDRRNGLO"; case DT_GNU_HASH: return "DT_GNU_HASH"; case 0x6ffffef8: return "DT_GNU_CONFLICT"; case 0x6ffffef9: return "DT_GNU_LIBLIST"; case 0x6ffffefa: return "DT_CONFIG"; case 0x6ffffefb: return "DT_DEPAUDIT"; case 0x6ffffefc: return "DT_AUDIT"; case 0x6ffffefd: return "DT_PLTPAD"; case 0x6ffffefe: return "DT_MOVETAB"; case DT_SYMINFO: return "DT_SYMINFO (DT_ADDRRNGHI)"; case DT_RELACOUNT: return "DT_RELACOUNT"; case DT_RELCOUNT: return "DT_RELCOUNT"; case DT_FLAGS_1: return "DT_FLAGS_1"; case DT_VERDEF: return "DT_VERDEF"; case DT_VERDEFNUM: return "DT_VERDEFNUM"; case DT_VERNEED: return "DT_VERNEED"; case DT_VERNEEDNUM: return "DT_VERNEEDNUM"; case 0x6ffffff0: return "DT_GNU_VERSYM"; /* 0x70000000 - 0x7fffffff processor-specific semantics */ case 0x70000000: return "DT_IA_64_PLT_RESERVE"; case 0x7ffffffd: return "DT_SUNW_AUXILIARY"; case 0x7ffffffe: return "DT_SUNW_USED"; case 0x7fffffff: return "DT_SUNW_FILTER"; } snprintf(unknown_buf, sizeof(unknown_buf), "", (unsigned long long)tag); return (unknown_buf); } static const char * e_machines(unsigned int mach) { static char machdesc[64]; switch (mach) { case EM_NONE: return "EM_NONE"; case EM_M32: return "EM_M32"; case EM_SPARC: return "EM_SPARC"; case EM_386: return "EM_386"; case EM_68K: return "EM_68K"; case EM_88K: return "EM_88K"; case EM_IAMCU: return "EM_IAMCU"; case EM_860: return "EM_860"; case EM_MIPS: return "EM_MIPS"; case EM_PPC: return "EM_PPC"; case EM_PPC64: return "EM_PPC64"; case EM_ARM: return "EM_ARM"; case EM_ALPHA: return "EM_ALPHA (legacy)"; case EM_SPARCV9:return "EM_SPARCV9"; case EM_IA_64: return "EM_IA_64"; case EM_X86_64: return "EM_X86_64"; case EM_AARCH64:return "EM_AARCH64"; case EM_RISCV: return "EM_RISCV"; } snprintf(machdesc, sizeof(machdesc), "(unknown machine) -- type 0x%x", mach); return (machdesc); } -static const char *e_types[] = { - "ET_NONE", "ET_REL", "ET_EXEC", "ET_DYN", "ET_CORE" -}; +static const char * +elf_type_str(unsigned int type) +{ + static char s_type[32]; -static const char *ei_versions[] = { - "EV_NONE", "EV_CURRENT" -}; + switch (type) + { + case ET_NONE: return "ET_NONE"; + case ET_REL: return "ET_REL"; + case ET_EXEC: return "ET_EXEC"; + case ET_DYN: return "ET_DYN"; + case ET_CORE: return "ET_CORE"; + } + if (type >= ET_LOPROC) + snprintf(s_type, sizeof(s_type), "", type); + else if (type >= ET_LOOS && type <= ET_HIOS) + snprintf(s_type, sizeof(s_type), "", type); + else + snprintf(s_type, sizeof(s_type), "", ver); + return (s_ver); +} +static const char * +elf_class_str(unsigned int class) +{ + static char s_class[32]; + + switch (class) { + case ELFCLASSNONE: return "ELFCLASSNONE"; + case ELFCLASS32: return "ELFCLASS32"; + case ELFCLASS64: return "ELFCLASS64"; + } + snprintf(s_class, sizeof(s_class), "", class); + return (s_class); +} + +static const char * +elf_data_str(unsigned int data) +{ + static char s_data[32]; + + switch (data) { + case ELFDATANONE: return "ELFDATANONE"; + case ELFDATA2LSB: return "ELFDATA2LSB"; + case ELFDATA2MSB: return "ELFDATA2MSB"; + } + snprintf(s_data, sizeof(s_data), "", data); + return (s_data); +} + static const char *ei_abis[256] = { "ELFOSABI_NONE", "ELFOSABI_HPUX", "ELFOSABI_NETBSD", "ELFOSABI_LINUX", "ELFOSABI_HURD", "ELFOSABI_86OPEN", "ELFOSABI_SOLARIS", "ELFOSABI_AIX", "ELFOSABI_IRIX", "ELFOSABI_FREEBSD", "ELFOSABI_TRU64", "ELFOSABI_MODESTO", "ELFOSABI_OPENBSD", + [17] = "ELFOSABI_CLOUDABI", [255] = "ELFOSABI_STANDALONE" }; -static const char *p_types[] = { - "PT_NULL", "PT_LOAD", "PT_DYNAMIC", "PT_INTERP", "PT_NOTE", - "PT_SHLIB", "PT_PHDR", "PT_TLS" -}; +static const char * +elf_phdr_type_str(unsigned int type) +{ + static char s_type[32]; + switch (type) { + case PT_NULL: return "PT_NULL"; + case PT_LOAD: return "PT_LOAD"; + case PT_DYNAMIC: return "PT_DYNAMIC"; + case PT_INTERP: return "PT_INTERP"; + case PT_NOTE: return "PT_NOTE"; + case PT_SHLIB: return "PT_SHLIB"; + case PT_PHDR: return "PT_PHDR"; + case PT_TLS: return "PT_TLS"; + case PT_GNU_EH_FRAME: return "PT_GNU_EH_FRAME"; + case PT_GNU_STACK: return "PT_GNU_STACK"; + case PT_GNU_RELRO: return "PT_GNU_RELRO"; + } + snprintf(s_type, sizeof(s_type), "", type); + return (s_type); +} + static const char *p_flags[] = { "", "PF_X", "PF_W", "PF_X|PF_W", "PF_R", "PF_X|PF_R", "PF_W|PF_R", "PF_X|PF_W|PF_R" }; static const char * sh_name(struct elfdump *ed, int ndx) { static char num[10]; switch (ndx) { case SHN_UNDEF: return "UNDEF"; case SHN_ABS: return "ABS"; case SHN_COMMON: return "COMMON"; default: if ((uint64_t)ndx < ed->shnum) return (ed->sl[ndx].name); else { snprintf(num, sizeof(num), "%d", ndx); return (num); } } } /* http://www.sco.com/developers/gabi/latest/ch4.sheader.html#sh_type */ static const char * sh_types(uint64_t mach, uint64_t sht) { static char unknown_buf[64]; if (sht < 0x60000000) { switch (sht) { case SHT_NULL: return "SHT_NULL"; case SHT_PROGBITS: return "SHT_PROGBITS"; case SHT_SYMTAB: return "SHT_SYMTAB"; case SHT_STRTAB: return "SHT_STRTAB"; case SHT_RELA: return "SHT_RELA"; case SHT_HASH: return "SHT_HASH"; case SHT_DYNAMIC: return "SHT_DYNAMIC"; case SHT_NOTE: return "SHT_NOTE"; case SHT_NOBITS: return "SHT_NOBITS"; case SHT_REL: return "SHT_REL"; case SHT_SHLIB: return "SHT_SHLIB"; case SHT_DYNSYM: return "SHT_DYNSYM"; case SHT_INIT_ARRAY: return "SHT_INIT_ARRAY"; case SHT_FINI_ARRAY: return "SHT_FINI_ARRAY"; case SHT_PREINIT_ARRAY: return "SHT_PREINIT_ARRAY"; case SHT_GROUP: return "SHT_GROUP"; case SHT_SYMTAB_SHNDX: return "SHT_SYMTAB_SHNDX"; } } else if (sht < 0x70000000) { /* 0x60000000-0x6fffffff operating system-specific semantics */ switch (sht) { case 0x6ffffff0: return "XXX:VERSYM"; case SHT_SUNW_dof: return "SHT_SUNW_dof"; case SHT_GNU_HASH: return "SHT_GNU_HASH"; case 0x6ffffff7: return "SHT_GNU_LIBLIST"; case 0x6ffffffc: return "XXX:VERDEF"; case SHT_SUNW_verdef: return "SHT_SUNW(GNU)_verdef"; case SHT_SUNW_verneed: return "SHT_SUNW(GNU)_verneed"; case SHT_SUNW_versym: return "SHT_SUNW(GNU)_versym"; } } else if (sht < 0x80000000) { /* 0x70000000 - 0x7fffffff processor-specific semantics */ switch (mach) { case EM_ARM: switch (sht) { case SHT_ARM_EXIDX: return "SHT_ARM_EXIDX"; case SHT_ARM_PREEMPTMAP: return "SHT_ARM_PREEMPTMAP"; case SHT_ARM_ATTRIBUTES: return "SHT_ARM_ATTRIBUTES"; case SHT_ARM_DEBUGOVERLAY: return "SHT_ARM_DEBUGOVERLAY"; case SHT_ARM_OVERLAYSECTION: return "SHT_ARM_OVERLAYSECTION"; } break; case EM_IA_64: switch (sht) { case 0x70000000: return "SHT_IA_64_EXT"; case 0x70000001: return "SHT_IA_64_UNWIND"; } break; case EM_MIPS: switch (sht) { case SHT_MIPS_REGINFO: return "SHT_MIPS_REGINFO"; case SHT_MIPS_OPTIONS: return "SHT_MIPS_OPTIONS"; case SHT_MIPS_ABIFLAGS: return "SHT_MIPS_ABIFLAGS"; } break; } switch (sht) { case 0x7ffffffd: return "XXX:AUXILIARY"; case 0x7fffffff: return "XXX:FILTER"; } } /* 0x80000000 - 0xffffffff application programs */ snprintf(unknown_buf, sizeof(unknown_buf), "", (unsigned long long)sht); return (unknown_buf); } /* * Define known section flags. These flags are defined in the order * they are to be printed out. */ #define DEFINE_SHFLAGS() \ DEFINE_SHF(WRITE) \ DEFINE_SHF(ALLOC) \ DEFINE_SHF(EXECINSTR) \ DEFINE_SHF(MERGE) \ DEFINE_SHF(STRINGS) \ DEFINE_SHF(INFO_LINK) \ DEFINE_SHF(LINK_ORDER) \ DEFINE_SHF(OS_NONCONFORMING) \ DEFINE_SHF(GROUP) \ - DEFINE_SHF(TLS) + DEFINE_SHF(TLS) \ + DEFINE_SHF(COMPRESSED) #undef DEFINE_SHF #define DEFINE_SHF(F) "SHF_" #F "|" #define ALLSHFLAGS DEFINE_SHFLAGS() static const char * sh_flags(uint64_t shf) { static char flg[sizeof(ALLSHFLAGS)+1]; flg[0] = '\0'; #undef DEFINE_SHF #define DEFINE_SHF(N) \ if (shf & SHF_##N) \ strcat(flg, "SHF_" #N "|"); \ DEFINE_SHFLAGS() flg[strlen(flg) - 1] = '\0'; /* Remove the trailing "|". */ return (flg); } static const char * st_type(unsigned int mach, unsigned int type) { static char s_type[32]; switch (type) { case STT_NOTYPE: return "STT_NOTYPE"; case STT_OBJECT: return "STT_OBJECT"; case STT_FUNC: return "STT_FUNC"; case STT_SECTION: return "STT_SECTION"; case STT_FILE: return "STT_FILE"; case STT_COMMON: return "STT_COMMON"; case STT_TLS: return "STT_TLS"; case 13: if (mach == EM_SPARCV9) return "STT_SPARC_REGISTER"; break; } snprintf(s_type, sizeof(s_type), "", type); return (s_type); } static const char * st_type_S(unsigned int type) { static char s_type[32]; switch (type) { case STT_NOTYPE: return "NOTY"; case STT_OBJECT: return "OBJT"; case STT_FUNC: return "FUNC"; case STT_SECTION: return "SECT"; case STT_FILE: return "FILE"; } snprintf(s_type, sizeof(s_type), "", type); return (s_type); } static const char * st_bindings(unsigned int sbind) { static char s_sbind[32]; switch (sbind) { case STB_LOCAL: return "STB_LOCAL"; case STB_GLOBAL: return "STB_GLOBAL"; case STB_WEAK: return "STB_WEAK"; case STB_GNU_UNIQUE: return "STB_GNU_UNIQUE"; default: if (sbind >= STB_LOOS && sbind <= STB_HIOS) return "OS"; else if (sbind >= STB_LOPROC && sbind <= STB_HIPROC) return "PROC"; else snprintf(s_sbind, sizeof(s_sbind), "", sbind); return (s_sbind); } } static const char * st_bindings_S(unsigned int sbind) { static char s_sbind[32]; switch (sbind) { case STB_LOCAL: return "LOCL"; case STB_GLOBAL: return "GLOB"; case STB_WEAK: return "WEAK"; case STB_GNU_UNIQUE: return "UNIQ"; default: if (sbind >= STB_LOOS && sbind <= STB_HIOS) return "OS"; else if (sbind >= STB_LOPROC && sbind <= STB_HIPROC) return "PROC"; else snprintf(s_sbind, sizeof(s_sbind), "<%#x>", sbind); return (s_sbind); } } static unsigned char st_others[] = { 'D', 'I', 'H', 'P' }; -static const char * -r_type(unsigned int mach, unsigned int type) -{ - switch(mach) { - case EM_NONE: return ""; - case EM_386: - case EM_IAMCU: - switch(type) { - case 0: return "R_386_NONE"; - case 1: return "R_386_32"; - case 2: return "R_386_PC32"; - case 3: return "R_386_GOT32"; - case 4: return "R_386_PLT32"; - case 5: return "R_386_COPY"; - case 6: return "R_386_GLOB_DAT"; - case 7: return "R_386_JUMP_SLOT"; - case 8: return "R_386_RELATIVE"; - case 9: return "R_386_GOTOFF"; - case 10: return "R_386_GOTPC"; - case 14: return "R_386_TLS_TPOFF"; - case 15: return "R_386_TLS_IE"; - case 16: return "R_386_TLS_GOTIE"; - case 17: return "R_386_TLS_LE"; - case 18: return "R_386_TLS_GD"; - case 19: return "R_386_TLS_LDM"; - case 24: return "R_386_TLS_GD_32"; - case 25: return "R_386_TLS_GD_PUSH"; - case 26: return "R_386_TLS_GD_CALL"; - case 27: return "R_386_TLS_GD_POP"; - case 28: return "R_386_TLS_LDM_32"; - case 29: return "R_386_TLS_LDM_PUSH"; - case 30: return "R_386_TLS_LDM_CALL"; - case 31: return "R_386_TLS_LDM_POP"; - case 32: return "R_386_TLS_LDO_32"; - case 33: return "R_386_TLS_IE_32"; - case 34: return "R_386_TLS_LE_32"; - case 35: return "R_386_TLS_DTPMOD32"; - case 36: return "R_386_TLS_DTPOFF32"; - case 37: return "R_386_TLS_TPOFF32"; - default: return ""; - } - case EM_ARM: - switch(type) { - case 0: return "R_ARM_NONE"; - case 1: return "R_ARM_PC24"; - case 2: return "R_ARM_ABS32"; - case 3: return "R_ARM_REL32"; - case 4: return "R_ARM_PC13"; - case 5: return "R_ARM_ABS16"; - case 6: return "R_ARM_ABS12"; - case 7: return "R_ARM_THM_ABS5"; - case 8: return "R_ARM_ABS8"; - case 9: return "R_ARM_SBREL32"; - case 10: return "R_ARM_THM_PC22"; - case 11: return "R_ARM_THM_PC8"; - case 12: return "R_ARM_AMP_VCALL9"; - case 13: return "R_ARM_SWI24"; - case 14: return "R_ARM_THM_SWI8"; - case 15: return "R_ARM_XPC25"; - case 16: return "R_ARM_THM_XPC22"; - case 20: return "R_ARM_COPY"; - case 21: return "R_ARM_GLOB_DAT"; - case 22: return "R_ARM_JUMP_SLOT"; - case 23: return "R_ARM_RELATIVE"; - case 24: return "R_ARM_GOTOFF"; - case 25: return "R_ARM_GOTPC"; - case 26: return "R_ARM_GOT32"; - case 27: return "R_ARM_PLT32"; - case 100: return "R_ARM_GNU_VTENTRY"; - case 101: return "R_ARM_GNU_VTINHERIT"; - case 250: return "R_ARM_RSBREL32"; - case 251: return "R_ARM_THM_RPC22"; - case 252: return "R_ARM_RREL32"; - case 253: return "R_ARM_RABS32"; - case 254: return "R_ARM_RPC24"; - case 255: return "R_ARM_RBASE"; - default: return ""; - } - case EM_IA_64: - switch(type) { - case 0: return "R_IA_64_NONE"; - case 33: return "R_IA_64_IMM14"; - case 34: return "R_IA_64_IMM22"; - case 35: return "R_IA_64_IMM64"; - case 36: return "R_IA_64_DIR32MSB"; - case 37: return "R_IA_64_DIR32LSB"; - case 38: return "R_IA_64_DIR64MSB"; - case 39: return "R_IA_64_DIR64LSB"; - case 42: return "R_IA_64_GPREL22"; - case 43: return "R_IA_64_GPREL64I"; - case 44: return "R_IA_64_GPREL32MSB"; - case 45: return "R_IA_64_GPREL32LSB"; - case 46: return "R_IA_64_GPREL64MSB"; - case 47: return "R_IA_64_GPREL64LSB"; - case 50: return "R_IA_64_LTOFF22"; - case 51: return "R_IA_64_LTOFF64I"; - case 58: return "R_IA_64_PLTOFF22"; - case 59: return "R_IA_64_PLTOFF64I"; - case 62: return "R_IA_64_PLTOFF64MSB"; - case 63: return "R_IA_64_PLTOFF64LSB"; - case 67: return "R_IA_64_FPTR64I"; - case 68: return "R_IA_64_FPTR32MSB"; - case 69: return "R_IA_64_FPTR32LSB"; - case 70: return "R_IA_64_FPTR64MSB"; - case 71: return "R_IA_64_FPTR64LSB"; - case 72: return "R_IA_64_PCREL60B"; - case 73: return "R_IA_64_PCREL21B"; - case 74: return "R_IA_64_PCREL21M"; - case 75: return "R_IA_64_PCREL21F"; - case 76: return "R_IA_64_PCREL32MSB"; - case 77: return "R_IA_64_PCREL32LSB"; - case 78: return "R_IA_64_PCREL64MSB"; - case 79: return "R_IA_64_PCREL64LSB"; - case 82: return "R_IA_64_LTOFF_FPTR22"; - case 83: return "R_IA_64_LTOFF_FPTR64I"; - case 84: return "R_IA_64_LTOFF_FPTR32MSB"; - case 85: return "R_IA_64_LTOFF_FPTR32LSB"; - case 86: return "R_IA_64_LTOFF_FPTR64MSB"; - case 87: return "R_IA_64_LTOFF_FPTR64LSB"; - case 92: return "R_IA_64_SEGREL32MSB"; - case 93: return "R_IA_64_SEGREL32LSB"; - case 94: return "R_IA_64_SEGREL64MSB"; - case 95: return "R_IA_64_SEGREL64LSB"; - case 100: return "R_IA_64_SECREL32MSB"; - case 101: return "R_IA_64_SECREL32LSB"; - case 102: return "R_IA_64_SECREL64MSB"; - case 103: return "R_IA_64_SECREL64LSB"; - case 108: return "R_IA_64_REL32MSB"; - case 109: return "R_IA_64_REL32LSB"; - case 110: return "R_IA_64_REL64MSB"; - case 111: return "R_IA_64_REL64LSB"; - case 116: return "R_IA_64_LTV32MSB"; - case 117: return "R_IA_64_LTV32LSB"; - case 118: return "R_IA_64_LTV64MSB"; - case 119: return "R_IA_64_LTV64LSB"; - case 121: return "R_IA_64_PCREL21BI"; - case 122: return "R_IA_64_PCREL22"; - case 123: return "R_IA_64_PCREL64I"; - case 128: return "R_IA_64_IPLTMSB"; - case 129: return "R_IA_64_IPLTLSB"; - case 133: return "R_IA_64_SUB"; - case 134: return "R_IA_64_LTOFF22X"; - case 135: return "R_IA_64_LDXMOV"; - case 145: return "R_IA_64_TPREL14"; - case 146: return "R_IA_64_TPREL22"; - case 147: return "R_IA_64_TPREL64I"; - case 150: return "R_IA_64_TPREL64MSB"; - case 151: return "R_IA_64_TPREL64LSB"; - case 154: return "R_IA_64_LTOFF_TPREL22"; - case 166: return "R_IA_64_DTPMOD64MSB"; - case 167: return "R_IA_64_DTPMOD64LSB"; - case 170: return "R_IA_64_LTOFF_DTPMOD22"; - case 177: return "R_IA_64_DTPREL14"; - case 178: return "R_IA_64_DTPREL22"; - case 179: return "R_IA_64_DTPREL64I"; - case 180: return "R_IA_64_DTPREL32MSB"; - case 181: return "R_IA_64_DTPREL32LSB"; - case 182: return "R_IA_64_DTPREL64MSB"; - case 183: return "R_IA_64_DTPREL64LSB"; - case 186: return "R_IA_64_LTOFF_DTPREL22"; - default: return ""; - } - case EM_MIPS: - switch(type) { - case 0: return "R_MIPS_NONE"; - case 1: return "R_MIPS_16"; - case 2: return "R_MIPS_32"; - case 3: return "R_MIPS_REL32"; - case 4: return "R_MIPS_26"; - case 5: return "R_MIPS_HI16"; - case 6: return "R_MIPS_LO16"; - case 7: return "R_MIPS_GPREL16"; - case 8: return "R_MIPS_LITERAL"; - case 9: return "R_MIPS_GOT16"; - case 10: return "R_MIPS_PC16"; - case 11: return "R_MIPS_CALL16"; - case 12: return "R_MIPS_GPREL32"; - case 21: return "R_MIPS_GOTHI16"; - case 22: return "R_MIPS_GOTLO16"; - case 30: return "R_MIPS_CALLHI16"; - case 31: return "R_MIPS_CALLLO16"; - default: return ""; - } - case EM_PPC: - switch(type) { - case 0: return "R_PPC_NONE"; - case 1: return "R_PPC_ADDR32"; - case 2: return "R_PPC_ADDR24"; - case 3: return "R_PPC_ADDR16"; - case 4: return "R_PPC_ADDR16_LO"; - case 5: return "R_PPC_ADDR16_HI"; - case 6: return "R_PPC_ADDR16_HA"; - case 7: return "R_PPC_ADDR14"; - case 8: return "R_PPC_ADDR14_BRTAKEN"; - case 9: return "R_PPC_ADDR14_BRNTAKEN"; - case 10: return "R_PPC_REL24"; - case 11: return "R_PPC_REL14"; - case 12: return "R_PPC_REL14_BRTAKEN"; - case 13: return "R_PPC_REL14_BRNTAKEN"; - case 14: return "R_PPC_GOT16"; - case 15: return "R_PPC_GOT16_LO"; - case 16: return "R_PPC_GOT16_HI"; - case 17: return "R_PPC_GOT16_HA"; - case 18: return "R_PPC_PLTREL24"; - case 19: return "R_PPC_COPY"; - case 20: return "R_PPC_GLOB_DAT"; - case 21: return "R_PPC_JMP_SLOT"; - case 22: return "R_PPC_RELATIVE"; - case 23: return "R_PPC_LOCAL24PC"; - case 24: return "R_PPC_UADDR32"; - case 25: return "R_PPC_UADDR16"; - case 26: return "R_PPC_REL32"; - case 27: return "R_PPC_PLT32"; - case 28: return "R_PPC_PLTREL32"; - case 29: return "R_PPC_PLT16_LO"; - case 30: return "R_PPC_PLT16_HI"; - case 31: return "R_PPC_PLT16_HA"; - case 32: return "R_PPC_SDAREL16"; - case 33: return "R_PPC_SECTOFF"; - case 34: return "R_PPC_SECTOFF_LO"; - case 35: return "R_PPC_SECTOFF_HI"; - case 36: return "R_PPC_SECTOFF_HA"; - case 67: return "R_PPC_TLS"; - case 68: return "R_PPC_DTPMOD32"; - case 69: return "R_PPC_TPREL16"; - case 70: return "R_PPC_TPREL16_LO"; - case 71: return "R_PPC_TPREL16_HI"; - case 72: return "R_PPC_TPREL16_HA"; - case 73: return "R_PPC_TPREL32"; - case 74: return "R_PPC_DTPREL16"; - case 75: return "R_PPC_DTPREL16_LO"; - case 76: return "R_PPC_DTPREL16_HI"; - case 77: return "R_PPC_DTPREL16_HA"; - case 78: return "R_PPC_DTPREL32"; - case 79: return "R_PPC_GOT_TLSGD16"; - case 80: return "R_PPC_GOT_TLSGD16_LO"; - case 81: return "R_PPC_GOT_TLSGD16_HI"; - case 82: return "R_PPC_GOT_TLSGD16_HA"; - case 83: return "R_PPC_GOT_TLSLD16"; - case 84: return "R_PPC_GOT_TLSLD16_LO"; - case 85: return "R_PPC_GOT_TLSLD16_HI"; - case 86: return "R_PPC_GOT_TLSLD16_HA"; - case 87: return "R_PPC_GOT_TPREL16"; - case 88: return "R_PPC_GOT_TPREL16_LO"; - case 89: return "R_PPC_GOT_TPREL16_HI"; - case 90: return "R_PPC_GOT_TPREL16_HA"; - case 101: return "R_PPC_EMB_NADDR32"; - case 102: return "R_PPC_EMB_NADDR16"; - case 103: return "R_PPC_EMB_NADDR16_LO"; - case 104: return "R_PPC_EMB_NADDR16_HI"; - case 105: return "R_PPC_EMB_NADDR16_HA"; - case 106: return "R_PPC_EMB_SDAI16"; - case 107: return "R_PPC_EMB_SDA2I16"; - case 108: return "R_PPC_EMB_SDA2REL"; - case 109: return "R_PPC_EMB_SDA21"; - case 110: return "R_PPC_EMB_MRKREF"; - case 111: return "R_PPC_EMB_RELSEC16"; - case 112: return "R_PPC_EMB_RELST_LO"; - case 113: return "R_PPC_EMB_RELST_HI"; - case 114: return "R_PPC_EMB_RELST_HA"; - case 115: return "R_PPC_EMB_BIT_FLD"; - case 116: return "R_PPC_EMB_RELSDA"; - default: return ""; - } - case EM_SPARC: - case EM_SPARCV9: - switch(type) { - case 0: return "R_SPARC_NONE"; - case 1: return "R_SPARC_8"; - case 2: return "R_SPARC_16"; - case 3: return "R_SPARC_32"; - case 4: return "R_SPARC_DISP8"; - case 5: return "R_SPARC_DISP16"; - case 6: return "R_SPARC_DISP32"; - case 7: return "R_SPARC_WDISP30"; - case 8: return "R_SPARC_WDISP22"; - case 9: return "R_SPARC_HI22"; - case 10: return "R_SPARC_22"; - case 11: return "R_SPARC_13"; - case 12: return "R_SPARC_LO10"; - case 13: return "R_SPARC_GOT10"; - case 14: return "R_SPARC_GOT13"; - case 15: return "R_SPARC_GOT22"; - case 16: return "R_SPARC_PC10"; - case 17: return "R_SPARC_PC22"; - case 18: return "R_SPARC_WPLT30"; - case 19: return "R_SPARC_COPY"; - case 20: return "R_SPARC_GLOB_DAT"; - case 21: return "R_SPARC_JMP_SLOT"; - case 22: return "R_SPARC_RELATIVE"; - case 23: return "R_SPARC_UA32"; - case 24: return "R_SPARC_PLT32"; - case 25: return "R_SPARC_HIPLT22"; - case 26: return "R_SPARC_LOPLT10"; - case 27: return "R_SPARC_PCPLT32"; - case 28: return "R_SPARC_PCPLT22"; - case 29: return "R_SPARC_PCPLT10"; - case 30: return "R_SPARC_10"; - case 31: return "R_SPARC_11"; - case 32: return "R_SPARC_64"; - case 33: return "R_SPARC_OLO10"; - case 34: return "R_SPARC_HH22"; - case 35: return "R_SPARC_HM10"; - case 36: return "R_SPARC_LM22"; - case 37: return "R_SPARC_PC_HH22"; - case 38: return "R_SPARC_PC_HM10"; - case 39: return "R_SPARC_PC_LM22"; - case 40: return "R_SPARC_WDISP16"; - case 41: return "R_SPARC_WDISP19"; - case 42: return "R_SPARC_GLOB_JMP"; - case 43: return "R_SPARC_7"; - case 44: return "R_SPARC_5"; - case 45: return "R_SPARC_6"; - case 46: return "R_SPARC_DISP64"; - case 47: return "R_SPARC_PLT64"; - case 48: return "R_SPARC_HIX22"; - case 49: return "R_SPARC_LOX10"; - case 50: return "R_SPARC_H44"; - case 51: return "R_SPARC_M44"; - case 52: return "R_SPARC_L44"; - case 53: return "R_SPARC_REGISTER"; - case 54: return "R_SPARC_UA64"; - case 55: return "R_SPARC_UA16"; - case 56: return "R_SPARC_TLS_GD_HI22"; - case 57: return "R_SPARC_TLS_GD_LO10"; - case 58: return "R_SPARC_TLS_GD_ADD"; - case 59: return "R_SPARC_TLS_GD_CALL"; - case 60: return "R_SPARC_TLS_LDM_HI22"; - case 61: return "R_SPARC_TLS_LDM_LO10"; - case 62: return "R_SPARC_TLS_LDM_ADD"; - case 63: return "R_SPARC_TLS_LDM_CALL"; - case 64: return "R_SPARC_TLS_LDO_HIX22"; - case 65: return "R_SPARC_TLS_LDO_LOX10"; - case 66: return "R_SPARC_TLS_LDO_ADD"; - case 67: return "R_SPARC_TLS_IE_HI22"; - case 68: return "R_SPARC_TLS_IE_LO10"; - case 69: return "R_SPARC_TLS_IE_LD"; - case 70: return "R_SPARC_TLS_IE_LDX"; - case 71: return "R_SPARC_TLS_IE_ADD"; - case 72: return "R_SPARC_TLS_LE_HIX22"; - case 73: return "R_SPARC_TLS_LE_LOX10"; - case 74: return "R_SPARC_TLS_DTPMOD32"; - case 75: return "R_SPARC_TLS_DTPMOD64"; - case 76: return "R_SPARC_TLS_DTPOFF32"; - case 77: return "R_SPARC_TLS_DTPOFF64"; - case 78: return "R_SPARC_TLS_TPOFF32"; - case 79: return "R_SPARC_TLS_TPOFF64"; - default: return ""; - } - case EM_X86_64: - switch(type) { - case 0: return "R_X86_64_NONE"; - case 1: return "R_X86_64_64"; - case 2: return "R_X86_64_PC32"; - case 3: return "R_X86_64_GOT32"; - case 4: return "R_X86_64_PLT32"; - case 5: return "R_X86_64_COPY"; - case 6: return "R_X86_64_GLOB_DAT"; - case 7: return "R_X86_64_JUMP_SLOT"; - case 8: return "R_X86_64_RELATIVE"; - case 9: return "R_X86_64_GOTPCREL"; - case 10: return "R_X86_64_32"; - case 11: return "R_X86_64_32S"; - case 12: return "R_X86_64_16"; - case 13: return "R_X86_64_PC16"; - case 14: return "R_X86_64_8"; - case 15: return "R_X86_64_PC8"; - case 16: return "R_X86_64_DTPMOD64"; - case 17: return "R_X86_64_DTPOFF64"; - case 18: return "R_X86_64_TPOFF64"; - case 19: return "R_X86_64_TLSGD"; - case 20: return "R_X86_64_TLSLD"; - case 21: return "R_X86_64_DTPOFF32"; - case 22: return "R_X86_64_GOTTPOFF"; - case 23: return "R_X86_64_TPOFF32"; - default: return ""; - } - default: return ""; - } -} - static void add_name(struct elfdump *ed, const char *name); static void elf_print_object(struct elfdump *ed); static void elf_print_elf(struct elfdump *ed); static void elf_print_ehdr(struct elfdump *ed); static void elf_print_phdr(struct elfdump *ed); static void elf_print_shdr(struct elfdump *ed); static void elf_print_symtab(struct elfdump *ed, int i); static void elf_print_symtabs(struct elfdump *ed); static void elf_print_symver(struct elfdump *ed); static void elf_print_verdef(struct elfdump *ed, struct section *s); static void elf_print_verneed(struct elfdump *ed, struct section *s); static void elf_print_interp(struct elfdump *ed); static void elf_print_dynamic(struct elfdump *ed); static void elf_print_rel_entry(struct elfdump *ed, struct section *s, int j, struct rel_entry *r); static void elf_print_rela(struct elfdump *ed, struct section *s, Elf_Data *data); static void elf_print_rel(struct elfdump *ed, struct section *s, Elf_Data *data); static void elf_print_reloc(struct elfdump *ed); static void elf_print_got(struct elfdump *ed); static void elf_print_got_section(struct elfdump *ed, struct section *s); static void elf_print_note(struct elfdump *ed); static void elf_print_svr4_hash(struct elfdump *ed, struct section *s); static void elf_print_svr4_hash64(struct elfdump *ed, struct section *s); static void elf_print_gnu_hash(struct elfdump *ed, struct section *s); static void elf_print_hash(struct elfdump *ed); static void elf_print_checksum(struct elfdump *ed); static void find_gotrel(struct elfdump *ed, struct section *gs, struct rel_entry *got); static struct spec_name *find_name(struct elfdump *ed, const char *name); static int get_ent_count(const struct section *s, int *ent_count); -static const char *get_symbol_name(struct elfdump *ed, int symtab, int i); +static const char *get_symbol_name(struct elfdump *ed, uint32_t symtab, int i); static const char *get_string(struct elfdump *ed, int strtab, size_t off); static void get_versym(struct elfdump *ed, int i, uint16_t **vs, int *nvs); static void load_sections(struct elfdump *ed); static void unload_sections(struct elfdump *ed); static void usage(void); #ifdef USE_LIBARCHIVE_AR static int ac_detect_ar(int fd); static void ac_print_ar(struct elfdump *ed, int fd); #else static void elf_print_ar(struct elfdump *ed, int fd); #endif /* USE_LIBARCHIVE_AR */ static struct option elfdump_longopts[] = { { "help", no_argument, NULL, 'H' }, { "version", no_argument, NULL, 'V' }, { NULL, 0, NULL, 0 } }; int main(int ac, char **av) { struct elfdump *ed, ed_storage; struct spec_name *sn; int ch, i; ed = &ed_storage; memset(ed, 0, sizeof(*ed)); STAILQ_INIT(&ed->snl); ed->out = stdout; while ((ch = getopt_long(ac, av, "acdeiGHhknN:prsSvVw:", elfdump_longopts, NULL)) != -1) switch (ch) { case 'a': ed->options = ED_ALL; break; case 'c': ed->options |= ED_SHDR; break; case 'd': ed->options |= ED_DYN; break; case 'e': ed->options |= ED_EHDR; break; case 'i': ed->options |= ED_INTERP; break; case 'G': ed->options |= ED_GOT; break; case 'h': ed->options |= ED_HASH; break; case 'k': ed->options |= ED_CHECKSUM; break; case 'n': ed->options |= ED_NOTE; break; case 'N': add_name(ed, optarg); break; case 'p': ed->options |= ED_PHDR; break; case 'r': ed->options |= ED_REL; break; case 's': ed->options |= ED_SYMTAB; break; case 'S': ed->flags |= SOLARIS_FMT; break; case 'v': ed->options |= ED_SYMVER; break; case 'V': (void) printf("%s (%s)\n", ELFTC_GETPROGNAME(), elftc_version()); exit(EXIT_SUCCESS); break; case 'w': if ((ed->out = fopen(optarg, "w")) == NULL) err(EXIT_FAILURE, "%s", optarg); break; case '?': case 'H': default: usage(); } ac -= optind; av += optind; if (ed->options == 0) ed->options = ED_ALL; sn = NULL; if (ed->options & ED_SYMTAB && (STAILQ_EMPTY(&ed->snl) || (sn = find_name(ed, "ARSYM")) != NULL)) { ed->flags |= PRINT_ARSYM; if (sn != NULL) { STAILQ_REMOVE(&ed->snl, sn, spec_name, sn_list); if (STAILQ_EMPTY(&ed->snl)) ed->flags |= ONLY_ARSYM; } } if (ac == 0) usage(); if (ac > 1) ed->flags |= PRINT_FILENAME; if (elf_version(EV_CURRENT) == EV_NONE) errx(EXIT_FAILURE, "ELF library initialization failed: %s", elf_errmsg(-1)); for (i = 0; i < ac; i++) { ed->filename = av[i]; ed->archive = NULL; elf_print_object(ed); } exit(EXIT_SUCCESS); } #ifdef USE_LIBARCHIVE_AR /* Archive symbol table entry. */ struct arsym_entry { char *sym_name; size_t off; }; /* * Convenient wrapper for general libarchive error handling. */ #define AC(CALL) do { \ if ((CALL)) { \ warnx("%s", archive_error_string(a)); \ return; \ } \ } while (0) /* * Detect an ar(1) archive using libarchive(3). */ static int ac_detect_ar(int fd) { struct archive *a; struct archive_entry *entry; int r; r = -1; if ((a = archive_read_new()) == NULL) return (0); archive_read_support_format_ar(a); if (archive_read_open_fd(a, fd, 10240) == ARCHIVE_OK) r = archive_read_next_header(a, &entry); archive_read_close(a); archive_read_free(a); return (r == ARCHIVE_OK); } /* * Dump an ar(1) archive using libarchive(3). */ static void ac_print_ar(struct elfdump *ed, int fd) { struct archive *a; struct archive_entry *entry; struct arsym_entry *arsym; const char *name; char idx[10], *b; void *buff; size_t size; - uint32_t cnt; - int i, r; + uint32_t cnt, i; + int r; if (lseek(fd, 0, SEEK_SET) == -1) err(EXIT_FAILURE, "lseek failed"); if ((a = archive_read_new()) == NULL) errx(EXIT_FAILURE, "%s", archive_error_string(a)); archive_read_support_format_ar(a); AC(archive_read_open_fd(a, fd, 10240)); for(;;) { r = archive_read_next_header(a, &entry); if (r == ARCHIVE_FATAL) errx(EXIT_FAILURE, "%s", archive_error_string(a)); if (r == ARCHIVE_EOF) break; if (r == ARCHIVE_WARN || r == ARCHIVE_RETRY) warnx("%s", archive_error_string(a)); if (r == ARCHIVE_RETRY) continue; name = archive_entry_pathname(entry); size = archive_entry_size(entry); if (size == 0) continue; if ((buff = malloc(size)) == NULL) { warn("malloc failed"); continue; } if (archive_read_data(a, buff, size) != (ssize_t)size) { warnx("%s", archive_error_string(a)); free(buff); continue; } /* * Note that when processing arsym via libarchive, there is * no way to tell which member a certain symbol belongs to, * since we can not just "lseek" to a member offset and read * the member header. */ if (!strcmp(name, "/") && ed->flags & PRINT_ARSYM) { b = buff; cnt = be32dec(b); if (cnt == 0) { free(buff); continue; } arsym = calloc(cnt, sizeof(*arsym)); if (arsym == NULL) err(EXIT_FAILURE, "calloc failed"); b += sizeof(uint32_t); - for (i = 0; (size_t)i < cnt; i++) { + for (i = 0; i < cnt; i++) { arsym[i].off = be32dec(b); b += sizeof(uint32_t); } - for (i = 0; (size_t)i < cnt; i++) { + for (i = 0; i < cnt; i++) { arsym[i].sym_name = b; b += strlen(b) + 1; } if (ed->flags & SOLARIS_FMT) { PRT("\nSymbol Table: (archive)\n"); PRT(" index offset symbol\n"); } else PRT("\nsymbol table (archive):\n"); - for (i = 0; (size_t)i < cnt; i++) { + for (i = 0; i < cnt; i++) { if (ed->flags & SOLARIS_FMT) { snprintf(idx, sizeof(idx), "[%d]", i); PRT("%10s ", idx); PRT("0x%8.8jx ", (uintmax_t)arsym[i].off); PRT("%s\n", arsym[i].sym_name); } else { PRT("\nentry: %d\n", i); PRT("\toffset: %#jx\n", (uintmax_t)arsym[i].off); PRT("\tsymbol: %s\n", arsym[i].sym_name); } } free(arsym); free(buff); /* No need to continue if we only dump ARSYM. */ if (ed->flags & ONLY_ARSYM) { AC(archive_read_close(a)); AC(archive_read_free(a)); return; } continue; } if ((ed->elf = elf_memory(buff, size)) == NULL) { warnx("elf_memroy() failed: %s", elf_errmsg(-1)); free(buff); continue; } /* Skip non-ELF member. */ if (elf_kind(ed->elf) == ELF_K_ELF) { printf("\n%s(%s):\n", ed->archive, name); elf_print_elf(ed); } elf_end(ed->elf); free(buff); } AC(archive_read_close(a)); AC(archive_read_free(a)); } #else /* USE_LIBARCHIVE_AR */ /* * Dump an ar(1) archive. */ static void elf_print_ar(struct elfdump *ed, int fd) { Elf *e; Elf_Arhdr *arh; Elf_Arsym *arsym; Elf_Cmd cmd; char idx[10]; - size_t cnt; - int i; + size_t cnt, i; ed->ar = ed->elf; if (ed->flags & PRINT_ARSYM) { cnt = 0; if ((arsym = elf_getarsym(ed->ar, &cnt)) == NULL) { warnx("elf_getarsym failed: %s", elf_errmsg(-1)); goto print_members; } if (cnt == 0) goto print_members; if (ed->flags & SOLARIS_FMT) { PRT("\nSymbol Table: (archive)\n"); PRT(" index offset member name and symbol\n"); } else PRT("\nsymbol table (archive):\n"); - for (i = 0; (size_t)i < cnt - 1; i++) { + for (i = 0; i < cnt - 1; i++) { if (elf_rand(ed->ar, arsym[i].as_off) != arsym[i].as_off) { warnx("elf_rand failed: %s", elf_errmsg(-1)); break; } if ((e = elf_begin(fd, ELF_C_READ, ed->ar)) == NULL) { warnx("elf_begin failed: %s", elf_errmsg(-1)); break; } if ((arh = elf_getarhdr(e)) == NULL) { warnx("elf_getarhdr failed: %s", elf_errmsg(-1)); break; } if (ed->flags & SOLARIS_FMT) { - snprintf(idx, sizeof(idx), "[%d]", i); + snprintf(idx, sizeof(idx), "[%zu]", i); PRT("%10s ", idx); PRT("0x%8.8jx ", (uintmax_t)arsym[i].as_off); PRT("(%s):%s\n", arh->ar_name, arsym[i].as_name); } else { - PRT("\nentry: %d\n", i); + PRT("\nentry: %zu\n", i); PRT("\toffset: %#jx\n", (uintmax_t)arsym[i].as_off); PRT("\tmember: %s\n", arh->ar_name); PRT("\tsymbol: %s\n", arsym[i].as_name); } elf_end(e); } /* No need to continue if we only dump ARSYM. */ if (ed->flags & ONLY_ARSYM) return; } print_members: /* Rewind the archive. */ if (elf_rand(ed->ar, SARMAG) != SARMAG) { warnx("elf_rand failed: %s", elf_errmsg(-1)); return; } /* Dump each member of the archive. */ cmd = ELF_C_READ; while ((ed->elf = elf_begin(fd, cmd, ed->ar)) != NULL) { /* Skip non-ELF member. */ if (elf_kind(ed->elf) == ELF_K_ELF) { if ((arh = elf_getarhdr(ed->elf)) == NULL) { warnx("elf_getarhdr failed: %s", elf_errmsg(-1)); break; } printf("\n%s(%s):\n", ed->archive, arh->ar_name); elf_print_elf(ed); } cmd = elf_next(ed->elf); elf_end(ed->elf); } } #endif /* USE_LIBARCHIVE_AR */ /* * Dump an object. (ELF object or ar(1) archive) */ static void elf_print_object(struct elfdump *ed) { int fd; if ((fd = open(ed->filename, O_RDONLY)) == -1) { warn("open %s failed", ed->filename); return; } #ifdef USE_LIBARCHIVE_AR if (ac_detect_ar(fd)) { ed->archive = ed->filename; ac_print_ar(ed, fd); return; } #endif /* USE_LIBARCHIVE_AR */ if ((ed->elf = elf_begin(fd, ELF_C_READ, NULL)) == NULL) { warnx("elf_begin() failed: %s", elf_errmsg(-1)); return; } switch (elf_kind(ed->elf)) { case ELF_K_NONE: warnx("Not an ELF file."); return; case ELF_K_ELF: if (ed->flags & PRINT_FILENAME) printf("\n%s:\n", ed->filename); elf_print_elf(ed); break; case ELF_K_AR: #ifndef USE_LIBARCHIVE_AR ed->archive = ed->filename; elf_print_ar(ed, fd); #endif break; default: warnx("Internal: libelf returned unknown elf kind."); return; } elf_end(ed->elf); } /* * Dump an ELF object. */ static void elf_print_elf(struct elfdump *ed) { if (gelf_getehdr(ed->elf, &ed->ehdr) == NULL) { warnx("gelf_getehdr failed: %s", elf_errmsg(-1)); return; } if ((ed->ec = gelf_getclass(ed->elf)) == ELFCLASSNONE) { warnx("gelf_getclass failed: %s", elf_errmsg(-1)); return; } if (ed->options & (ED_SHDR | ED_DYN | ED_REL | ED_GOT | ED_SYMTAB | ED_SYMVER | ED_NOTE | ED_HASH)) load_sections(ed); if (ed->options & ED_EHDR) elf_print_ehdr(ed); if (ed->options & ED_PHDR) elf_print_phdr(ed); if (ed->options & ED_INTERP) elf_print_interp(ed); if (ed->options & ED_SHDR) elf_print_shdr(ed); if (ed->options & ED_DYN) elf_print_dynamic(ed); if (ed->options & ED_REL) elf_print_reloc(ed); if (ed->options & ED_GOT) elf_print_got(ed); if (ed->options & ED_SYMTAB) elf_print_symtabs(ed); if (ed->options & ED_SYMVER) elf_print_symver(ed); if (ed->options & ED_NOTE) elf_print_note(ed); if (ed->options & ED_HASH) elf_print_hash(ed); if (ed->options & ED_CHECKSUM) elf_print_checksum(ed); unload_sections(ed); } /* * Read the section headers from ELF object and store them in the * internal cache. */ static void load_sections(struct elfdump *ed) { struct section *s; const char *name; Elf_Scn *scn; GElf_Shdr sh; size_t shstrndx, ndx; int elferr; assert(ed->sl == NULL); if (!elf_getshnum(ed->elf, &ed->shnum)) { warnx("elf_getshnum failed: %s", elf_errmsg(-1)); return; } if (ed->shnum == 0) return; if ((ed->sl = calloc(ed->shnum, sizeof(*ed->sl))) == NULL) err(EXIT_FAILURE, "calloc failed"); if (!elf_getshstrndx(ed->elf, &shstrndx)) { warnx("elf_getshstrndx failed: %s", elf_errmsg(-1)); return; } if ((scn = elf_getscn(ed->elf, 0)) == NULL) { warnx("elf_getscn failed: %s", elf_errmsg(-1)); return; } (void) elf_errno(); do { if (gelf_getshdr(scn, &sh) == NULL) { warnx("gelf_getshdr failed: %s", elf_errmsg(-1)); (void) elf_errno(); continue; } if ((name = elf_strptr(ed->elf, shstrndx, sh.sh_name)) == NULL) { (void) elf_errno(); name = "ERROR"; } if ((ndx = elf_ndxscn(scn)) == SHN_UNDEF) if ((elferr = elf_errno()) != 0) { warnx("elf_ndxscn failed: %s", elf_errmsg(elferr)); continue; } if (ndx >= ed->shnum) { warnx("section index of '%s' out of range", name); continue; } s = &ed->sl[ndx]; s->name = name; s->scn = scn; s->off = sh.sh_offset; s->sz = sh.sh_size; s->entsize = sh.sh_entsize; s->align = sh.sh_addralign; s->type = sh.sh_type; s->flags = sh.sh_flags; s->addr = sh.sh_addr; s->link = sh.sh_link; s->info = sh.sh_info; } while ((scn = elf_nextscn(ed->elf, scn)) != NULL); elferr = elf_errno(); if (elferr != 0) warnx("elf_nextscn failed: %s", elf_errmsg(elferr)); } /* * Release section related resources. */ static void unload_sections(struct elfdump *ed) { if (ed->sl != NULL) { free(ed->sl); ed->sl = NULL; } } /* * Add a name to the '-N' name list. */ static void add_name(struct elfdump *ed, const char *name) { struct spec_name *sn; if (find_name(ed, name)) return; if ((sn = malloc(sizeof(*sn))) == NULL) { warn("malloc failed"); return; } sn->name = name; STAILQ_INSERT_TAIL(&ed->snl, sn, sn_list); } /* * Lookup a name in the '-N' name list. */ static struct spec_name * find_name(struct elfdump *ed, const char *name) { struct spec_name *sn; STAILQ_FOREACH(sn, &ed->snl, sn_list) { if (!strcmp(sn->name, name)) return (sn); } return (NULL); } /* * Retrieve the name of a symbol using the section index of the symbol * table and the index of the symbol within that table. */ static const char * -get_symbol_name(struct elfdump *ed, int symtab, int i) +get_symbol_name(struct elfdump *ed, uint32_t symtab, int i) { static char sname[64]; struct section *s; const char *name; GElf_Sym sym; Elf_Data *data; int elferr; + if (symtab >= ed->shnum) + return (""); s = &ed->sl[symtab]; if (s->type != SHT_SYMTAB && s->type != SHT_DYNSYM) return (""); (void) elf_errno(); if ((data = elf_getdata(s->scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("elf_getdata failed: %s", elf_errmsg(elferr)); return (""); } if (gelf_getsym(data, i, &sym) != &sym) return (""); if (GELF_ST_TYPE(sym.st_info) == STT_SECTION) { if (sym.st_shndx < ed->shnum) { snprintf(sname, sizeof(sname), "%s (section)", ed->sl[sym.st_shndx].name); return (sname); } else return (""); } if ((name = elf_strptr(ed->elf, s->link, sym.st_name)) == NULL) return (""); return (name); } /* * Retrieve a string using string table section index and the string offset. */ static const char* get_string(struct elfdump *ed, int strtab, size_t off) { const char *name; if ((name = elf_strptr(ed->elf, strtab, off)) == NULL) return (""); return (name); } /* * Dump the ELF Executable Header. */ static void elf_print_ehdr(struct elfdump *ed) { if (!STAILQ_EMPTY(&ed->snl)) return; if (ed->flags & SOLARIS_FMT) { PRT("\nELF Header\n"); PRT(" ei_magic: { %#x, %c, %c, %c }\n", ed->ehdr.e_ident[0], ed->ehdr.e_ident[1], ed->ehdr.e_ident[2], ed->ehdr.e_ident[3]); PRT(" ei_class: %-18s", - ei_classes[ed->ehdr.e_ident[EI_CLASS]]); - PRT(" ei_data: %s\n", ei_data[ed->ehdr.e_ident[EI_DATA]]); + elf_class_str(ed->ehdr.e_ident[EI_CLASS])); + PRT(" ei_data: %s\n", + elf_data_str(ed->ehdr.e_ident[EI_DATA])); PRT(" e_machine: %-18s", e_machines(ed->ehdr.e_machine)); - PRT(" e_version: %s\n", ei_versions[ed->ehdr.e_version]); - PRT(" e_type: %s\n", e_types[ed->ehdr.e_type]); + PRT(" e_version: %s\n", + elf_version_str(ed->ehdr.e_version)); + PRT(" e_type: %s\n", elf_type_str(ed->ehdr.e_type)); PRT(" e_flags: %18d\n", ed->ehdr.e_flags); PRT(" e_entry: %#18jx", (uintmax_t)ed->ehdr.e_entry); PRT(" e_ehsize: %6d", ed->ehdr.e_ehsize); PRT(" e_shstrndx:%5d\n", ed->ehdr.e_shstrndx); PRT(" e_shoff: %#18jx", (uintmax_t)ed->ehdr.e_shoff); PRT(" e_shentsize: %3d", ed->ehdr.e_shentsize); PRT(" e_shnum: %5d\n", ed->ehdr.e_shnum); PRT(" e_phoff: %#18jx", (uintmax_t)ed->ehdr.e_phoff); PRT(" e_phentsize: %3d", ed->ehdr.e_phentsize); PRT(" e_phnum: %5d\n", ed->ehdr.e_phnum); } else { PRT("\nelf header:\n"); PRT("\n"); PRT("\te_ident: %s %s %s\n", - ei_classes[ed->ehdr.e_ident[EI_CLASS]], - ei_data[ed->ehdr.e_ident[EI_DATA]], + elf_class_str(ed->ehdr.e_ident[EI_CLASS]), + elf_data_str(ed->ehdr.e_ident[EI_DATA]), ei_abis[ed->ehdr.e_ident[EI_OSABI]]); - PRT("\te_type: %s\n", e_types[ed->ehdr.e_type]); + PRT("\te_type: %s\n", elf_type_str(ed->ehdr.e_type)); PRT("\te_machine: %s\n", e_machines(ed->ehdr.e_machine)); - PRT("\te_version: %s\n", ei_versions[ed->ehdr.e_version]); + PRT("\te_version: %s\n", elf_version_str(ed->ehdr.e_version)); PRT("\te_entry: %#jx\n", (uintmax_t)ed->ehdr.e_entry); PRT("\te_phoff: %ju\n", (uintmax_t)ed->ehdr.e_phoff); PRT("\te_shoff: %ju\n", (uintmax_t) ed->ehdr.e_shoff); PRT("\te_flags: %u\n", ed->ehdr.e_flags); PRT("\te_ehsize: %u\n", ed->ehdr.e_ehsize); PRT("\te_phentsize: %u\n", ed->ehdr.e_phentsize); PRT("\te_phnum: %u\n", ed->ehdr.e_phnum); PRT("\te_shentsize: %u\n", ed->ehdr.e_shentsize); PRT("\te_shnum: %u\n", ed->ehdr.e_shnum); PRT("\te_shstrndx: %u\n", ed->ehdr.e_shstrndx); } } /* * Dump the ELF Program Header Table. */ static void elf_print_phdr(struct elfdump *ed) { GElf_Phdr ph; - size_t phnum; - int header, i; + size_t phnum, i; + int header; if (elf_getphnum(ed->elf, &phnum) == 0) { warnx("elf_getphnum failed: %s", elf_errmsg(-1)); return; } header = 0; - for (i = 0; (u_int64_t) i < phnum; i++) { + for (i = 0; i < phnum; i++) { if (gelf_getphdr(ed->elf, i, &ph) != &ph) { warnx("elf_getphdr failed: %s", elf_errmsg(-1)); continue; } if (!STAILQ_EMPTY(&ed->snl) && - find_name(ed, p_types[ph.p_type & 0x7]) == NULL) + find_name(ed, elf_phdr_type_str(ph.p_type)) == NULL) continue; if (ed->flags & SOLARIS_FMT) { - PRT("\nProgram Header[%d]:\n", i); + PRT("\nProgram Header[%zu]:\n", i); PRT(" p_vaddr: %#-14jx", (uintmax_t)ph.p_vaddr); - PRT(" p_flags: [ %s ]\n", p_flags[ph.p_flags]); + PRT(" p_flags: [ %s ]\n", + p_flags[ph.p_flags & 0x7]); PRT(" p_paddr: %#-14jx", (uintmax_t)ph.p_paddr); - PRT(" p_type: [ %s ]\n", p_types[ph.p_type & 0x7]); + PRT(" p_type: [ %s ]\n", + elf_phdr_type_str(ph.p_type)); PRT(" p_filesz: %#-14jx", (uintmax_t)ph.p_filesz); PRT(" p_memsz: %#jx\n", (uintmax_t)ph.p_memsz); PRT(" p_offset: %#-14jx", (uintmax_t)ph.p_offset); PRT(" p_align: %#jx\n", (uintmax_t)ph.p_align); } else { if (!header) { PRT("\nprogram header:\n"); header = 1; } PRT("\n"); - PRT("entry: %d\n", i); - PRT("\tp_type: %s\n", p_types[ph.p_type & 0x7]); + PRT("entry: %zu\n", i); + PRT("\tp_type: %s\n", elf_phdr_type_str(ph.p_type)); PRT("\tp_offset: %ju\n", (uintmax_t)ph.p_offset); PRT("\tp_vaddr: %#jx\n", (uintmax_t)ph.p_vaddr); PRT("\tp_paddr: %#jx\n", (uintmax_t)ph.p_paddr); PRT("\tp_filesz: %ju\n", (uintmax_t)ph.p_filesz); PRT("\tp_memsz: %ju\n", (uintmax_t)ph.p_memsz); - PRT("\tp_flags: %s\n", p_flags[ph.p_flags]); + PRT("\tp_flags: %s\n", p_flags[ph.p_flags & 0x7]); PRT("\tp_align: %ju\n", (uintmax_t)ph.p_align); } } } /* * Dump the ELF Section Header Table. */ static void elf_print_shdr(struct elfdump *ed) { struct section *s; - int i; + size_t i; if (!STAILQ_EMPTY(&ed->snl)) return; if ((ed->flags & SOLARIS_FMT) == 0) PRT("\nsection header:\n"); - for (i = 0; (size_t)i < ed->shnum; i++) { + for (i = 0; i < ed->shnum; i++) { s = &ed->sl[i]; if (ed->flags & SOLARIS_FMT) { if (i == 0) continue; - PRT("\nSection Header[%d]:", i); + PRT("\nSection Header[%zu]:", i); PRT(" sh_name: %s\n", s->name); PRT(" sh_addr: %#-14jx", (uintmax_t)s->addr); if (s->flags != 0) PRT(" sh_flags: [ %s ]\n", sh_flags(s->flags)); else PRT(" sh_flags: 0\n"); PRT(" sh_size: %#-14jx", (uintmax_t)s->sz); PRT(" sh_type: [ %s ]\n", sh_types(ed->ehdr.e_machine, s->type)); PRT(" sh_offset: %#-14jx", (uintmax_t)s->off); PRT(" sh_entsize: %#jx\n", (uintmax_t)s->entsize); PRT(" sh_link: %-14u", s->link); PRT(" sh_info: %u\n", s->info); PRT(" sh_addralign: %#jx\n", (uintmax_t)s->align); } else { PRT("\n"); PRT("entry: %ju\n", (uintmax_t)i); PRT("\tsh_name: %s\n", s->name); PRT("\tsh_type: %s\n", sh_types(ed->ehdr.e_machine, s->type)); PRT("\tsh_flags: %s\n", sh_flags(s->flags)); PRT("\tsh_addr: %#jx\n", (uintmax_t)s->addr); PRT("\tsh_offset: %ju\n", (uintmax_t)s->off); PRT("\tsh_size: %ju\n", (uintmax_t)s->sz); PRT("\tsh_link: %u\n", s->link); PRT("\tsh_info: %u\n", s->info); PRT("\tsh_addralign: %ju\n", (uintmax_t)s->align); PRT("\tsh_entsize: %ju\n", (uintmax_t)s->entsize); } } } /* * Return number of entries in the given section. We'd prefer ent_count be a * size_t, but libelf APIs already use int for section indices. */ static int get_ent_count(const struct section *s, int *ent_count) { if (s->entsize == 0) { warnx("section %s has entry size 0", s->name); return (0); } else if (s->sz / s->entsize > INT_MAX) { warnx("section %s has invalid section count", s->name); return (0); } *ent_count = (int)(s->sz / s->entsize); return (1); } /* * Retrieve the content of the corresponding SHT_SUNW_versym section for * a symbol table section. */ static void get_versym(struct elfdump *ed, int i, uint16_t **vs, int *nvs) { struct section *s; Elf_Data *data; - int j, elferr; + size_t j; + int elferr; s = NULL; - for (j = 0; (size_t)j < ed->shnum; j++) { + for (j = 0; j < ed->shnum; j++) { s = &ed->sl[j]; if (s->type == SHT_SUNW_versym && s->link == (uint32_t)i) break; } - if ((size_t)j >= ed->shnum) { + if (j >= ed->shnum) { *vs = NULL; return; } (void) elf_errno(); if ((data = elf_getdata(s->scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("elf_getdata failed: %s", elf_errmsg(elferr)); *vs = NULL; return; } *vs = data->d_buf; assert(data->d_size == s->sz); if (!get_ent_count(s, nvs)) *nvs = 0; } /* * Dump the symbol table section. */ static void elf_print_symtab(struct elfdump *ed, int i) { struct section *s; const char *name; uint16_t *vs; char idx[10]; Elf_Data *data; GElf_Sym sym; int len, j, elferr, nvs; s = &ed->sl[i]; if (ed->flags & SOLARIS_FMT) PRT("\nSymbol Table Section: %s\n", s->name); else PRT("\nsymbol table (%s):\n", s->name); (void) elf_errno(); if ((data = elf_getdata(s->scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("elf_getdata failed: %s", elf_errmsg(elferr)); return; } vs = NULL; nvs = 0; assert(data->d_size == s->sz); if (!get_ent_count(s, &len)) return; if (ed->flags & SOLARIS_FMT) { if (ed->ec == ELFCLASS32) PRT(" index value "); else PRT(" index value "); PRT("size type bind oth ver shndx name\n"); get_versym(ed, i, &vs, &nvs); if (vs != NULL && nvs != len) { warnx("#symbol not equal to #versym"); vs = NULL; } } for (j = 0; j < len; j++) { if (gelf_getsym(data, j, &sym) != &sym) { warnx("gelf_getsym failed: %s", elf_errmsg(-1)); continue; } name = get_string(ed, s->link, sym.st_name); if (ed->flags & SOLARIS_FMT) { snprintf(idx, sizeof(idx), "[%d]", j); if (ed->ec == ELFCLASS32) PRT("%10s ", idx); else PRT("%10s ", idx); PRT("0x%8.8jx ", (uintmax_t)sym.st_value); if (ed->ec == ELFCLASS32) PRT("0x%8.8jx ", (uintmax_t)sym.st_size); else PRT("0x%12.12jx ", (uintmax_t)sym.st_size); PRT("%s ", st_type_S(GELF_ST_TYPE(sym.st_info))); PRT("%s ", st_bindings_S(GELF_ST_BIND(sym.st_info))); PRT("%c ", st_others[sym.st_other]); PRT("%3u ", (vs == NULL ? 0 : vs[j])); PRT("%-11.11s ", sh_name(ed, sym.st_shndx)); PRT("%s\n", name); } else { PRT("\nentry: %d\n", j); PRT("\tst_name: %s\n", name); PRT("\tst_value: %#jx\n", (uintmax_t)sym.st_value); PRT("\tst_size: %ju\n", (uintmax_t)sym.st_size); PRT("\tst_info: %s %s\n", st_type(ed->ehdr.e_machine, GELF_ST_TYPE(sym.st_info)), st_bindings(GELF_ST_BIND(sym.st_info))); PRT("\tst_shndx: %ju\n", (uintmax_t)sym.st_shndx); } } } /* * Dump the symbol tables. (.dynsym and .symtab) */ static void elf_print_symtabs(struct elfdump *ed) { - int i; + size_t i; - for (i = 0; (size_t)i < ed->shnum; i++) + for (i = 0; i < ed->shnum; i++) if ((ed->sl[i].type == SHT_SYMTAB || ed->sl[i].type == SHT_DYNSYM) && (STAILQ_EMPTY(&ed->snl) || find_name(ed, ed->sl[i].name))) elf_print_symtab(ed, i); } /* * Dump the content of .dynamic section. */ static void elf_print_dynamic(struct elfdump *ed) { struct section *s; const char *name; char idx[10]; Elf_Data *data; GElf_Dyn dyn; int elferr, i, len; s = NULL; for (i = 0; (size_t)i < ed->shnum; i++) { s = &ed->sl[i]; if (s->type == SHT_DYNAMIC && (STAILQ_EMPTY(&ed->snl) || find_name(ed, s->name))) break; } if ((size_t)i >= ed->shnum) return; if (ed->flags & SOLARIS_FMT) { PRT("Dynamic Section: %s\n", s->name); PRT(" index tag value\n"); } else PRT("\ndynamic:\n"); (void) elf_errno(); if ((data = elf_getdata(s->scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("elf_getdata failed: %s", elf_errmsg(elferr)); return; } assert(data->d_size == s->sz); if (!get_ent_count(s, &len)) return; for (i = 0; i < len; i++) { if (gelf_getdyn(data, i, &dyn) != &dyn) { warnx("gelf_getdyn failed: %s", elf_errmsg(-1)); continue; } if (ed->flags & SOLARIS_FMT) { snprintf(idx, sizeof(idx), "[%d]", i); PRT("%10s %-16s ", idx, d_tags(dyn.d_tag)); } else { PRT("\n"); PRT("entry: %d\n", i); PRT("\td_tag: %s\n", d_tags(dyn.d_tag)); } switch(dyn.d_tag) { case DT_NEEDED: case DT_SONAME: case DT_RPATH: + case DT_RUNPATH: if ((name = elf_strptr(ed->elf, s->link, dyn.d_un.d_val)) == NULL) name = ""; if (ed->flags & SOLARIS_FMT) PRT("%#-16jx %s\n", (uintmax_t)dyn.d_un.d_val, name); else PRT("\td_val: %s\n", name); break; case DT_PLTRELSZ: case DT_RELA: case DT_RELASZ: case DT_RELAENT: case DT_RELACOUNT: case DT_STRSZ: case DT_SYMENT: case DT_RELSZ: case DT_RELENT: case DT_PLTREL: case DT_VERDEF: case DT_VERDEFNUM: case DT_VERNEED: case DT_VERNEEDNUM: case DT_VERSYM: if (ed->flags & SOLARIS_FMT) PRT("%#jx\n", (uintmax_t)dyn.d_un.d_val); else PRT("\td_val: %ju\n", (uintmax_t)dyn.d_un.d_val); break; case DT_PLTGOT: case DT_HASH: case DT_GNU_HASH: case DT_STRTAB: case DT_SYMTAB: case DT_INIT: case DT_FINI: case DT_REL: case DT_JMPREL: case DT_DEBUG: if (ed->flags & SOLARIS_FMT) PRT("%#jx\n", (uintmax_t)dyn.d_un.d_ptr); else PRT("\td_ptr: %#jx\n", (uintmax_t)dyn.d_un.d_ptr); break; case DT_NULL: case DT_SYMBOLIC: case DT_TEXTREL: default: if (ed->flags & SOLARIS_FMT) PRT("\n"); break; } } } /* * Dump a .rel/.rela section entry. */ static void elf_print_rel_entry(struct elfdump *ed, struct section *s, int j, struct rel_entry *r) { if (ed->flags & SOLARIS_FMT) { - PRT(" %-23s ", r_type(ed->ehdr.e_machine, + PRT(" %-23s ", elftc_reloc_type_str(ed->ehdr.e_machine, GELF_R_TYPE(r->u_r.rel.r_info))); PRT("%#12jx ", (uintmax_t)r->u_r.rel.r_offset); if (r->type == SHT_RELA) PRT("%10jd ", (intmax_t)r->u_r.rela.r_addend); else PRT(" "); PRT("%-14s ", s->name); PRT("%s\n", r->symn); } else { PRT("\n"); PRT("entry: %d\n", j); PRT("\tr_offset: %#jx\n", (uintmax_t)r->u_r.rel.r_offset); if (ed->ec == ELFCLASS32) PRT("\tr_info: %#jx\n", (uintmax_t) ELF32_R_INFO(ELF64_R_SYM(r->u_r.rel.r_info), ELF64_R_TYPE(r->u_r.rel.r_info))); else PRT("\tr_info: %#jx\n", (uintmax_t)r->u_r.rel.r_info); if (r->type == SHT_RELA) PRT("\tr_addend: %jd\n", (intmax_t)r->u_r.rela.r_addend); } } /* * Dump a relocation section of type SHT_RELA. */ static void elf_print_rela(struct elfdump *ed, struct section *s, Elf_Data *data) { struct rel_entry r; int j, len; if (ed->flags & SOLARIS_FMT) { PRT("\nRelocation Section: %s\n", s->name); PRT(" type offset " "addend section with respect to\n"); } else PRT("\nrelocation with addend (%s):\n", s->name); r.type = SHT_RELA; assert(data->d_size == s->sz); if (!get_ent_count(s, &len)) return; for (j = 0; j < len; j++) { if (gelf_getrela(data, j, &r.u_r.rela) != &r.u_r.rela) { warnx("gelf_getrela failed: %s", elf_errmsg(-1)); continue; } r.symn = get_symbol_name(ed, s->link, GELF_R_SYM(r.u_r.rela.r_info)); elf_print_rel_entry(ed, s, j, &r); } } /* * Dump a relocation section of type SHT_REL. */ static void elf_print_rel(struct elfdump *ed, struct section *s, Elf_Data *data) { struct rel_entry r; int j, len; if (ed->flags & SOLARIS_FMT) { PRT("\nRelocation Section: %s\n", s->name); PRT(" type offset " "section with respect to\n"); } else PRT("\nrelocation (%s):\n", s->name); r.type = SHT_REL; assert(data->d_size == s->sz); if (!get_ent_count(s, &len)) return; for (j = 0; j < len; j++) { if (gelf_getrel(data, j, &r.u_r.rel) != &r.u_r.rel) { warnx("gelf_getrel failed: %s", elf_errmsg(-1)); continue; } r.symn = get_symbol_name(ed, s->link, GELF_R_SYM(r.u_r.rel.r_info)); elf_print_rel_entry(ed, s, j, &r); } } /* * Dump relocation sections. */ static void elf_print_reloc(struct elfdump *ed) { struct section *s; Elf_Data *data; - int i, elferr; + size_t i; + int elferr; - for (i = 0; (size_t)i < ed->shnum; i++) { + for (i = 0; i < ed->shnum; i++) { s = &ed->sl[i]; if ((s->type == SHT_REL || s->type == SHT_RELA) && (STAILQ_EMPTY(&ed->snl) || find_name(ed, s->name))) { (void) elf_errno(); if ((data = elf_getdata(s->scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("elf_getdata failed: %s", elf_errmsg(elferr)); continue; } if (s->type == SHT_REL) elf_print_rel(ed, s, data); else elf_print_rela(ed, s, data); } } } /* * Dump the content of PT_INTERP segment. */ static void elf_print_interp(struct elfdump *ed) { const char *s; GElf_Phdr phdr; - size_t phnum; - int i; + size_t filesize, i, phnum; if (!STAILQ_EMPTY(&ed->snl) && find_name(ed, "PT_INTERP") == NULL) return; - if ((s = elf_rawfile(ed->elf, NULL)) == NULL) { + if ((s = elf_rawfile(ed->elf, &filesize)) == NULL) { warnx("elf_rawfile failed: %s", elf_errmsg(-1)); return; } if (!elf_getphnum(ed->elf, &phnum)) { warnx("elf_getphnum failed: %s", elf_errmsg(-1)); return; } - for (i = 0; (size_t)i < phnum; i++) { + for (i = 0; i < phnum; i++) { if (gelf_getphdr(ed->elf, i, &phdr) != &phdr) { warnx("elf_getphdr failed: %s", elf_errmsg(-1)); continue; } if (phdr.p_type == PT_INTERP) { + if (phdr.p_offset >= filesize) { + warnx("invalid phdr offset"); + continue; + } PRT("\ninterp:\n"); PRT("\t%s\n", s + phdr.p_offset); } } } /* - * Search the relocation sections for entries refering to the .got section. + * Search the relocation sections for entries referring to the .got section. */ static void find_gotrel(struct elfdump *ed, struct section *gs, struct rel_entry *got) { struct section *s; struct rel_entry r; Elf_Data *data; - int elferr, i, j, k, len; + size_t i; + int elferr, j, k, len; - for(i = 0; (size_t)i < ed->shnum; i++) { + for(i = 0; i < ed->shnum; i++) { s = &ed->sl[i]; if (s->type != SHT_REL && s->type != SHT_RELA) continue; (void) elf_errno(); if ((data = elf_getdata(s->scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("elf_getdata failed: %s", elf_errmsg(elferr)); return; } memset(&r, 0, sizeof(struct rel_entry)); r.type = s->type; assert(data->d_size == s->sz); if (!get_ent_count(s, &len)) return; for (j = 0; j < len; j++) { if (s->type == SHT_REL) { if (gelf_getrel(data, j, &r.u_r.rel) != &r.u_r.rel) { warnx("gelf_getrel failed: %s", elf_errmsg(-1)); continue; } } else { if (gelf_getrela(data, j, &r.u_r.rela) != &r.u_r.rela) { warnx("gelf_getrel failed: %s", elf_errmsg(-1)); continue; } } if (r.u_r.rel.r_offset >= gs->addr && r.u_r.rel.r_offset < gs->addr + gs->sz) { r.symn = get_symbol_name(ed, s->link, GELF_R_SYM(r.u_r.rel.r_info)); k = (r.u_r.rel.r_offset - gs->addr) / gs->entsize; memcpy(&got[k], &r, sizeof(struct rel_entry)); } } } } static void elf_print_got_section(struct elfdump *ed, struct section *s) { struct rel_entry *got; Elf_Data *data, dst; int elferr, i, len; if (s->entsize == 0) { /* XXX IA64 GOT section generated by gcc has entry size 0. */ if (s->align != 0) s->entsize = s->align; else return; } if (!get_ent_count(s, &len)) return; if (ed->flags & SOLARIS_FMT) PRT("\nGlobal Offset Table Section: %s (%d entries)\n", s->name, len); else PRT("\nglobal offset table: %s\n", s->name); (void) elf_errno(); if ((data = elf_getdata(s->scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("elf_getdata failed: %s", elf_errmsg(elferr)); return; } /* * GOT section has section type SHT_PROGBITS, thus libelf treats it as - * byte stream and will not perfrom any translation on it. As a result, + * byte stream and will not perform any translation on it. As a result, * an exlicit call to gelf_xlatetom is needed here. Depends on arch, * GOT section should be translated to either WORD or XWORD. */ if (ed->ec == ELFCLASS32) data->d_type = ELF_T_WORD; else data->d_type = ELF_T_XWORD; memcpy(&dst, data, sizeof(Elf_Data)); if (gelf_xlatetom(ed->elf, &dst, data, ed->ehdr.e_ident[EI_DATA]) != &dst) { warnx("gelf_xlatetom failed: %s", elf_errmsg(-1)); return; } assert(dst.d_size == s->sz); if (ed->flags & SOLARIS_FMT) { /* * In verbose/Solaris mode, we search the relocation sections * and try to find the corresponding reloc entry for each GOT * section entry. */ if ((got = calloc(len, sizeof(struct rel_entry))) == NULL) err(EXIT_FAILURE, "calloc failed"); find_gotrel(ed, s, got); if (ed->ec == ELFCLASS32) { PRT(" ndx addr value reloc "); PRT("addend symbol\n"); } else { PRT(" ndx addr value "); PRT("reloc addend symbol\n"); } for(i = 0; i < len; i++) { PRT("[%5.5d] ", i); if (ed->ec == ELFCLASS32) { PRT("%-8.8jx ", (uintmax_t) (s->addr + i * s->entsize)); PRT("%-8.8x ", *((uint32_t *)dst.d_buf + i)); } else { PRT("%-16.16jx ", (uintmax_t) (s->addr + i * s->entsize)); PRT("%-16.16jx ", (uintmax_t) *((uint64_t *)dst.d_buf + i)); } - PRT("%-18s ", r_type(ed->ehdr.e_machine, + PRT("%-18s ", elftc_reloc_type_str(ed->ehdr.e_machine, GELF_R_TYPE(got[i].u_r.rel.r_info))); if (ed->ec == ELFCLASS32) PRT("%-8.8jd ", (intmax_t)got[i].u_r.rela.r_addend); else PRT("%-12.12jd ", (intmax_t)got[i].u_r.rela.r_addend); if (got[i].symn == NULL) got[i].symn = ""; PRT("%s\n", got[i].symn); } free(got); } else { for(i = 0; i < len; i++) { PRT("\nentry: %d\n", i); if (ed->ec == ELFCLASS32) PRT("\t%#x\n", *((uint32_t *)dst.d_buf + i)); else PRT("\t%#jx\n", (uintmax_t) *((uint64_t *)dst.d_buf + i)); } } } /* * Dump the content of Global Offset Table section. */ static void elf_print_got(struct elfdump *ed) { struct section *s; - int i; + size_t i; if (!STAILQ_EMPTY(&ed->snl)) return; s = NULL; - for (i = 0; (size_t)i < ed->shnum; i++) { + for (i = 0; i < ed->shnum; i++) { s = &ed->sl[i]; if (s->name && !strncmp(s->name, ".got", 4) && (STAILQ_EMPTY(&ed->snl) || find_name(ed, s->name))) elf_print_got_section(ed, s); } } /* * Dump the content of .note.ABI-tag section. */ static void elf_print_note(struct elfdump *ed) { struct section *s; Elf_Data *data; Elf_Note *en; uint32_t namesz; uint32_t descsz; uint32_t desc; size_t count; int elferr, i; - char *src, idx[10]; + uint8_t *src; + char idx[10]; s = NULL; for (i = 0; (size_t)i < ed->shnum; i++) { s = &ed->sl[i]; if (s->type == SHT_NOTE && s->name && !strcmp(s->name, ".note.ABI-tag") && (STAILQ_EMPTY(&ed->snl) || find_name(ed, s->name))) break; } if ((size_t)i >= ed->shnum) return; if (ed->flags & SOLARIS_FMT) PRT("\nNote Section: %s\n", s->name); else PRT("\nnote (%s):\n", s->name); (void) elf_errno(); if ((data = elf_getdata(s->scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("elf_getdata failed: %s", elf_errmsg(elferr)); return; } src = data->d_buf; count = data->d_size; while (count > sizeof(Elf_Note)) { en = (Elf_Note *) (uintptr_t) src; namesz = en->n_namesz; descsz = en->n_descsz; src += sizeof(Elf_Note); count -= sizeof(Elf_Note); + if (roundup2(namesz, 4) + roundup2(descsz, 4) > count) { + warnx("truncated note section"); + return; + } if (ed->flags & SOLARIS_FMT) { PRT("\n type %#x\n", en->n_type); PRT(" namesz %#x:\n", en->n_namesz); PRT("%s\n", src); } else PRT("\t%s ", src); src += roundup2(namesz, 4); count -= roundup2(namesz, 4); /* * Note that we dump the whole desc part if we're in * "Solaris mode", while in the normal mode, we only look * at the first 4 bytes (a 32bit word) of the desc, i.e, * we assume that it's always a FreeBSD version number. */ if (ed->flags & SOLARIS_FMT) { PRT(" descsz %#x:", en->n_descsz); for (i = 0; (uint32_t)i < descsz; i++) { if ((i & 0xF) == 0) { snprintf(idx, sizeof(idx), "desc[%d]", i); PRT("\n %-9s", idx); } else if ((i & 0x3) == 0) PRT(" "); PRT(" %2.2x", src[i]); } PRT("\n"); } else { if (ed->ehdr.e_ident[EI_DATA] == ELFDATA2MSB) desc = be32dec(src); else desc = le32dec(src); PRT("%d\n", desc); } src += roundup2(descsz, 4); count -= roundup2(descsz, 4); } } /* * Dump a hash table. */ static void elf_print_svr4_hash(struct elfdump *ed, struct section *s) { Elf_Data *data; uint32_t *buf; uint32_t *bucket, *chain; uint32_t nbucket, nchain; uint32_t *bl, *c, maxl, total; - int i, j, first, elferr; + uint32_t i, j; + int first, elferr; char idx[10]; if (ed->flags & SOLARIS_FMT) PRT("\nHash Section: %s\n", s->name); else PRT("\nhash table (%s):\n", s->name); (void) elf_errno(); if ((data = elf_getdata(s->scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("elf_getdata failed: %s", elf_errmsg(elferr)); return; } if (data->d_size < 2 * sizeof(uint32_t)) { warnx(".hash section too small"); return; } buf = data->d_buf; nbucket = buf[0]; nchain = buf[1]; if (nbucket <= 0 || nchain <= 0) { warnx("Malformed .hash section"); return; } - if (data->d_size != (nbucket + nchain + 2) * sizeof(uint32_t)) { + if (data->d_size != + ((uint64_t)nbucket + (uint64_t)nchain + 2) * sizeof(uint32_t)) { warnx("Malformed .hash section"); return; } bucket = &buf[2]; chain = &buf[2 + nbucket]; if (ed->flags & SOLARIS_FMT) { maxl = 0; if ((bl = calloc(nbucket, sizeof(*bl))) == NULL) err(EXIT_FAILURE, "calloc failed"); - for (i = 0; (uint32_t)i < nbucket; i++) - for (j = bucket[i]; j > 0 && (uint32_t)j < nchain; - j = chain[j]) + for (i = 0; i < nbucket; i++) + for (j = bucket[i]; j > 0 && j < nchain; j = chain[j]) if (++bl[i] > maxl) maxl = bl[i]; if ((c = calloc(maxl + 1, sizeof(*c))) == NULL) err(EXIT_FAILURE, "calloc failed"); - for (i = 0; (uint32_t)i < nbucket; i++) + for (i = 0; i < nbucket; i++) c[bl[i]]++; PRT(" bucket symndx name\n"); - for (i = 0; (uint32_t)i < nbucket; i++) { + for (i = 0; i < nbucket; i++) { first = 1; - for (j = bucket[i]; j > 0 && (uint32_t)j < nchain; - j = chain[j]) { + for (j = bucket[i]; j > 0 && j < nchain; j = chain[j]) { if (first) { PRT("%10d ", i); first = 0; } else PRT(" "); snprintf(idx, sizeof(idx), "[%d]", j); PRT("%-10s ", idx); PRT("%s\n", get_symbol_name(ed, s->link, j)); } } PRT("\n"); total = 0; - for (i = 0; (uint32_t)i <= maxl; i++) { + for (i = 0; i <= maxl; i++) { total += c[i] * i; PRT("%10u buckets contain %8d symbols\n", c[i], i); } PRT("%10u buckets %8u symbols (globals)\n", nbucket, total); } else { PRT("\nnbucket: %u\n", nbucket); PRT("nchain: %u\n\n", nchain); - for (i = 0; (uint32_t)i < nbucket; i++) + for (i = 0; i < nbucket; i++) PRT("bucket[%d]:\n\t%u\n\n", i, bucket[i]); - for (i = 0; (uint32_t)i < nchain; i++) + for (i = 0; i < nchain; i++) PRT("chain[%d]:\n\t%u\n\n", i, chain[i]); } } /* * Dump a 64bit hash table. */ static void elf_print_svr4_hash64(struct elfdump *ed, struct section *s) { Elf_Data *data, dst; uint64_t *buf; uint64_t *bucket, *chain; uint64_t nbucket, nchain; uint64_t *bl, *c, maxl, total; - int i, j, elferr, first; + uint64_t i, j; + int elferr, first; char idx[10]; if (ed->flags & SOLARIS_FMT) PRT("\nHash Section: %s\n", s->name); else PRT("\nhash table (%s):\n", s->name); /* * ALPHA uses 64-bit hash entries. Since libelf assumes that * .hash section contains only 32-bit entry, an explicit * gelf_xlatetom is needed here. */ (void) elf_errno(); if ((data = elf_rawdata(s->scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("elf_rawdata failed: %s", elf_errmsg(elferr)); return; } data->d_type = ELF_T_XWORD; memcpy(&dst, data, sizeof(Elf_Data)); if (gelf_xlatetom(ed->elf, &dst, data, ed->ehdr.e_ident[EI_DATA]) != &dst) { warnx("gelf_xlatetom failed: %s", elf_errmsg(-1)); return; } if (dst.d_size < 2 * sizeof(uint64_t)) { warnx(".hash section too small"); return; } buf = dst.d_buf; nbucket = buf[0]; nchain = buf[1]; if (nbucket <= 0 || nchain <= 0) { warnx("Malformed .hash section"); return; } if (dst.d_size != (nbucket + nchain + 2) * sizeof(uint64_t)) { warnx("Malformed .hash section"); return; } bucket = &buf[2]; chain = &buf[2 + nbucket]; if (ed->flags & SOLARIS_FMT) { maxl = 0; if ((bl = calloc(nbucket, sizeof(*bl))) == NULL) err(EXIT_FAILURE, "calloc failed"); - for (i = 0; (uint64_t)i < nbucket; i++) - for (j = bucket[i]; j > 0 && (uint64_t)j < nchain; - j = chain[j]) + for (i = 0; i < nbucket; i++) + for (j = bucket[i]; j > 0 && j < nchain; j = chain[j]) if (++bl[i] > maxl) maxl = bl[i]; if ((c = calloc(maxl + 1, sizeof(*c))) == NULL) err(EXIT_FAILURE, "calloc failed"); - for (i = 0; (uint64_t)i < nbucket; i++) + for (i = 0; i < nbucket; i++) c[bl[i]]++; PRT(" bucket symndx name\n"); - for (i = 0; (uint64_t)i < nbucket; i++) { + for (i = 0; i < nbucket; i++) { first = 1; - for (j = bucket[i]; j > 0 && (uint64_t)j < nchain; - j = chain[j]) { + for (j = bucket[i]; j > 0 && j < nchain; j = chain[j]) { if (first) { - PRT("%10d ", i); + PRT("%10zu ", i); first = 0; } else PRT(" "); - snprintf(idx, sizeof(idx), "[%d]", j); + snprintf(idx, sizeof(idx), "[%zu]", (size_t)j); PRT("%-10s ", idx); PRT("%s\n", get_symbol_name(ed, s->link, j)); } } PRT("\n"); total = 0; - for (i = 0; (uint64_t)i <= maxl; i++) { + for (i = 0; i <= maxl; i++) { total += c[i] * i; - PRT("%10ju buckets contain %8d symbols\n", + PRT("%10ju buckets contain %8zu symbols\n", (uintmax_t)c[i], i); } PRT("%10ju buckets %8ju symbols (globals)\n", (uintmax_t)nbucket, (uintmax_t)total); } else { PRT("\nnbucket: %ju\n", (uintmax_t)nbucket); PRT("nchain: %ju\n\n", (uintmax_t)nchain); - for (i = 0; (uint64_t)i < nbucket; i++) - PRT("bucket[%d]:\n\t%ju\n\n", i, (uintmax_t)bucket[i]); - for (i = 0; (uint64_t)i < nchain; i++) - PRT("chain[%d]:\n\t%ju\n\n", i, (uintmax_t)chain[i]); + for (i = 0; i < nbucket; i++) + PRT("bucket[%zu]:\n\t%ju\n\n", i, (uintmax_t)bucket[i]); + for (i = 0; i < nchain; i++) + PRT("chain[%zu]:\n\t%ju\n\n", i, (uintmax_t)chain[i]); } } /* * Dump a GNU hash table. */ static void elf_print_gnu_hash(struct elfdump *ed, struct section *s) { struct section *ds; Elf_Data *data; uint32_t *buf; uint32_t *bucket, *chain; uint32_t nbucket, nchain, symndx, maskwords, shift2; uint32_t *bl, *c, maxl, total; - int i, j, first, elferr, dynsymcount; + uint32_t i, j; + int first, elferr, dynsymcount; char idx[10]; if (ed->flags & SOLARIS_FMT) PRT("\nGNU Hash Section: %s\n", s->name); else PRT("\ngnu hash table (%s):\n", s->name); (void) elf_errno(); if ((data = elf_getdata(s->scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("elf_getdata failed: %s", elf_errmsg(elferr)); return; } if (data->d_size < 4 * sizeof(uint32_t)) { warnx(".gnu.hash section too small"); return; } buf = data->d_buf; nbucket = buf[0]; symndx = buf[1]; maskwords = buf[2]; shift2 = buf[3]; buf += 4; + if (s->link >= ed->shnum) { + warnx("Malformed .gnu.hash section"); + return; + } ds = &ed->sl[s->link]; if (!get_ent_count(ds, &dynsymcount)) return; + if (symndx >= (uint32_t)dynsymcount) { + warnx("Malformed .gnu.hash section"); + return; + } nchain = dynsymcount - symndx; if (data->d_size != 4 * sizeof(uint32_t) + maskwords * (ed->ec == ELFCLASS32 ? sizeof(uint32_t) : sizeof(uint64_t)) + - (nbucket + nchain) * sizeof(uint32_t)) { + ((uint64_t)nbucket + (uint64_t)nchain) * sizeof(uint32_t)) { warnx("Malformed .gnu.hash section"); return; } bucket = buf + (ed->ec == ELFCLASS32 ? maskwords : maskwords * 2); chain = bucket + nbucket; if (ed->flags & SOLARIS_FMT) { maxl = 0; if ((bl = calloc(nbucket, sizeof(*bl))) == NULL) err(EXIT_FAILURE, "calloc failed"); - for (i = 0; (uint32_t)i < nbucket; i++) - for (j = bucket[i]; - j > 0 && (uint32_t)j - symndx < nchain; - j++) { + for (i = 0; i < nbucket; i++) + for (j = bucket[i]; j > 0 && j - symndx < nchain; j++) { if (++bl[i] > maxl) maxl = bl[i]; if (chain[j - symndx] & 1) break; } if ((c = calloc(maxl + 1, sizeof(*c))) == NULL) err(EXIT_FAILURE, "calloc failed"); - for (i = 0; (uint32_t)i < nbucket; i++) + for (i = 0; i < nbucket; i++) c[bl[i]]++; PRT(" bucket symndx name\n"); - for (i = 0; (uint32_t)i < nbucket; i++) { + for (i = 0; i < nbucket; i++) { first = 1; - for (j = bucket[i]; - j > 0 && (uint32_t)j - symndx < nchain; - j++) { + for (j = bucket[i]; j > 0 && j - symndx < nchain; j++) { if (first) { PRT("%10d ", i); first = 0; } else PRT(" "); snprintf(idx, sizeof(idx), "[%d]", j ); PRT("%-10s ", idx); PRT("%s\n", get_symbol_name(ed, s->link, j)); if (chain[j - symndx] & 1) break; } } PRT("\n"); total = 0; - for (i = 0; (uint32_t)i <= maxl; i++) { + for (i = 0; i <= maxl; i++) { total += c[i] * i; PRT("%10u buckets contain %8d symbols\n", c[i], i); } PRT("%10u buckets %8u symbols (globals)\n", nbucket, total); } else { PRT("\nnbucket: %u\n", nbucket); PRT("symndx: %u\n", symndx); PRT("maskwords: %u\n", maskwords); PRT("shift2: %u\n", shift2); PRT("nchain: %u\n\n", nchain); - for (i = 0; (uint32_t)i < nbucket; i++) + for (i = 0; i < nbucket; i++) PRT("bucket[%d]:\n\t%u\n\n", i, bucket[i]); - for (i = 0; (uint32_t)i < nchain; i++) + for (i = 0; i < nchain; i++) PRT("chain[%d]:\n\t%u\n\n", i, chain[i]); } } /* * Dump hash tables. */ static void elf_print_hash(struct elfdump *ed) { struct section *s; - int i; + size_t i; - for (i = 0; (size_t)i < ed->shnum; i++) { + for (i = 0; i < ed->shnum; i++) { s = &ed->sl[i]; if ((s->type == SHT_HASH || s->type == SHT_GNU_HASH) && (STAILQ_EMPTY(&ed->snl) || find_name(ed, s->name))) { if (s->type == SHT_GNU_HASH) elf_print_gnu_hash(ed, s); else if (ed->ehdr.e_machine == EM_ALPHA && s->entsize == 8) elf_print_svr4_hash64(ed, s); else elf_print_svr4_hash(ed, s); } } } /* * Dump the content of a Version Definition(SHT_SUNW_Verdef) Section. */ static void elf_print_verdef(struct elfdump *ed, struct section *s) { Elf_Data *data; Elf32_Verdef *vd; Elf32_Verdaux *vda; const char *str; char idx[10]; uint8_t *buf, *end, *buf2; int i, j, elferr, count; if (ed->flags & SOLARIS_FMT) PRT("Version Definition Section: %s\n", s->name); else PRT("\nversion definition section (%s):\n", s->name); (void) elf_errno(); if ((data = elf_getdata(s->scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("elf_getdata failed: %s", elf_errmsg(elferr)); return; } buf = data->d_buf; end = buf + data->d_size; i = 0; if (ed->flags & SOLARIS_FMT) PRT(" index version dependency\n"); while (buf + sizeof(Elf32_Verdef) <= end) { vd = (Elf32_Verdef *) (uintptr_t) buf; if (ed->flags & SOLARIS_FMT) { snprintf(idx, sizeof(idx), "[%d]", vd->vd_ndx); PRT("%10s ", idx); } else { PRT("\nentry: %d\n", i++); PRT("\tvd_version: %u\n", vd->vd_version); PRT("\tvd_flags: %u\n", vd->vd_flags); PRT("\tvd_ndx: %u\n", vd->vd_ndx); PRT("\tvd_cnt: %u\n", vd->vd_cnt); PRT("\tvd_hash: %u\n", vd->vd_hash); PRT("\tvd_aux: %u\n", vd->vd_aux); PRT("\tvd_next: %u\n\n", vd->vd_next); } buf2 = buf + vd->vd_aux; j = 0; count = 0; while (buf2 + sizeof(Elf32_Verdaux) <= end && j < vd->vd_cnt) { vda = (Elf32_Verdaux *) (uintptr_t) buf2; str = get_string(ed, s->link, vda->vda_name); if (ed->flags & SOLARIS_FMT) { if (count == 0) PRT("%-26.26s", str); else if (count == 1) PRT(" %-20.20s", str); else { PRT("\n%40.40s", ""); PRT("%s", str); } } else { PRT("\t\tvda: %d\n", j++); PRT("\t\t\tvda_name: %s\n", str); PRT("\t\t\tvda_next: %u\n", vda->vda_next); } if (vda->vda_next == 0) { if (ed->flags & SOLARIS_FMT) { if (vd->vd_flags & VER_FLG_BASE) { if (count == 0) PRT("%-20.20s", ""); PRT("%s", "[ BASE ]"); } PRT("\n"); } break; } if (ed->flags & SOLARIS_FMT) count++; buf2 += vda->vda_next; } if (vd->vd_next == 0) break; buf += vd->vd_next; } } /* * Dump the content of a Version Needed(SHT_SUNW_Verneed) Section. */ static void elf_print_verneed(struct elfdump *ed, struct section *s) { Elf_Data *data; Elf32_Verneed *vn; Elf32_Vernaux *vna; uint8_t *buf, *end, *buf2; int i, j, elferr, first; if (ed->flags & SOLARIS_FMT) PRT("\nVersion Needed Section: %s\n", s->name); else PRT("\nversion need section (%s):\n", s->name); (void) elf_errno(); if ((data = elf_getdata(s->scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("elf_getdata failed: %s", elf_errmsg(elferr)); return; } buf = data->d_buf; end = buf + data->d_size; if (ed->flags & SOLARIS_FMT) PRT(" file version\n"); i = 0; while (buf + sizeof(Elf32_Verneed) <= end) { vn = (Elf32_Verneed *) (uintptr_t) buf; if (ed->flags & SOLARIS_FMT) PRT(" %-26.26s ", get_string(ed, s->link, vn->vn_file)); else { PRT("\nentry: %d\n", i++); PRT("\tvn_version: %u\n", vn->vn_version); PRT("\tvn_cnt: %u\n", vn->vn_cnt); PRT("\tvn_file: %s\n", get_string(ed, s->link, vn->vn_file)); PRT("\tvn_aux: %u\n", vn->vn_aux); PRT("\tvn_next: %u\n\n", vn->vn_next); } buf2 = buf + vn->vn_aux; j = 0; first = 1; while (buf2 + sizeof(Elf32_Vernaux) <= end && j < vn->vn_cnt) { vna = (Elf32_Vernaux *) (uintptr_t) buf2; if (ed->flags & SOLARIS_FMT) { if (!first) PRT("%40.40s", ""); else first = 0; PRT("%s\n", get_string(ed, s->link, vna->vna_name)); } else { PRT("\t\tvna: %d\n", j++); PRT("\t\t\tvna_hash: %u\n", vna->vna_hash); PRT("\t\t\tvna_flags: %u\n", vna->vna_flags); PRT("\t\t\tvna_other: %u\n", vna->vna_other); PRT("\t\t\tvna_name: %s\n", get_string(ed, s->link, vna->vna_name)); PRT("\t\t\tvna_next: %u\n", vna->vna_next); } if (vna->vna_next == 0) break; buf2 += vna->vna_next; } if (vn->vn_next == 0) break; buf += vn->vn_next; } } /* * Dump the symbol-versioning sections. */ static void elf_print_symver(struct elfdump *ed) { struct section *s; - int i; + size_t i; - for (i = 0; (size_t)i < ed->shnum; i++) { + for (i = 0; i < ed->shnum; i++) { s = &ed->sl[i]; if (!STAILQ_EMPTY(&ed->snl) && !find_name(ed, s->name)) continue; if (s->type == SHT_SUNW_verdef) elf_print_verdef(ed, s); if (s->type == SHT_SUNW_verneed) elf_print_verneed(ed, s); } } /* * Dump the ELF checksum. See gelf_checksum(3) for details. */ static void elf_print_checksum(struct elfdump *ed) { if (!STAILQ_EMPTY(&ed->snl)) return; PRT("\nelf checksum: %#lx\n", gelf_checksum(ed->elf)); } #define USAGE_MESSAGE "\ Usage: %s [options] file...\n\ Display information about ELF objects and ar(1) archives.\n\n\ Options:\n\ -a Show all information.\n\ -c Show shared headers.\n\ -d Show dynamic symbols.\n\ -e Show the ELF header.\n\ -G Show the GOT.\n\ -H | --help Show a usage message and exit.\n\ -h Show hash values.\n\ -i Show the dynamic interpreter.\n\ -k Show the ELF checksum.\n\ -n Show the contents of note sections.\n\ -N NAME Show the section named \"NAME\".\n\ -p Show the program header.\n\ -r Show relocations.\n\ -s Show the symbol table.\n\ -S Use the Solaris elfdump format.\n\ -v Show symbol-versioning information.\n\ -V | --version Print a version identifier and exit.\n\ -w FILE Write output to \"FILE\".\n" static void usage(void) { fprintf(stderr, USAGE_MESSAGE, ELFTC_GETPROGNAME()); exit(EXIT_FAILURE); } Index: vendor/elftoolchain/dist/findtextrel/findtextrel.c =================================================================== --- vendor/elftoolchain/dist/findtextrel/findtextrel.c (revision 300227) +++ vendor/elftoolchain/dist/findtextrel/findtextrel.c (revision 300228) @@ -1,416 +1,424 @@ /*- * Copyright (c) 2010 Kai Wang * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #include #include #include #include #include #include #include #include #include #include #include "_elftc.h" -ELFTC_VCSID("$Id: findtextrel.c 3359 2016-01-24 17:06:20Z jkoshy $"); +ELFTC_VCSID("$Id: findtextrel.c 3461 2016-05-10 18:00:05Z emaste $"); static struct option longopts[] = { {"help", no_argument, NULL, 'H'}, {"version", no_argument, NULL, 'V'}, {NULL, 0, NULL, 0} }; #define USAGE_MESSAGE "\ Usage: %s [options] [files...]\n\ Show text relocations present in position independent code.\n\n\ Options:\n\ -H Print a help message.\n\ -V Print a version identifier and exit.\n" static void usage(void) { (void) fprintf(stderr, USAGE_MESSAGE, ELFTC_GETPROGNAME()); exit(1); } static void version(void) { (void) printf("%s (%s)\n", ELFTC_GETPROGNAME(), elftc_version()); exit(0); } static const char * find_symbol(const char *fn, Elf *e, Elf_Data *d, GElf_Shdr *sh, uintmax_t off) { const char *name; GElf_Sym sym; int i, len; + if (sh->sh_entsize == 0) { + warnx("invalid sh_entsize"); + return (NULL); + } len = (int) (d->d_size / sh->sh_entsize); for (i = 0; i < len; i++) { if (gelf_getsym(d, i, &sym) != &sym) { warnx("%s: gelf_getsym() failed: %s", fn, elf_errmsg(-1)); continue; } if (GELF_ST_TYPE(sym.st_info) != STT_FUNC) continue; if (off >= sym.st_value && off < sym.st_value + sym.st_size) { name = elf_strptr(e, sh->sh_link, sym.st_name); if (name == NULL) warnx("%s: elf_strptr() failed: %s", fn, elf_errmsg(-1)); return (name); } } return (NULL); } static void report_textrel(const char *fn, Elf *e, Dwarf_Debug dbg, uintmax_t off, int *textrel) { Dwarf_Die die; Dwarf_Line *lbuf; Dwarf_Error de; Dwarf_Half tag; Dwarf_Unsigned lopc, hipc, lineno, plineno; Dwarf_Signed lcount; Dwarf_Addr lineaddr, plineaddr; Elf_Scn *scn; Elf_Data *d; GElf_Shdr sh; const char *name; char *file, *pfile; int elferr, found, i, ret; if (!*textrel) { printf("%s: ELF object contains text relocation records:\n", fn); *textrel = 1; } printf("%s: off: %#jx", fn, off); found = 0; scn = NULL; while ((scn = elf_nextscn(e, scn)) != NULL) { if (gelf_getshdr(scn, &sh) == NULL) { warnx("%s: gelf_getshdr() failed: %s", fn, elf_errmsg(-1)); continue; } if (sh.sh_type != SHT_DYNSYM && sh.sh_type != SHT_SYMTAB) continue; (void) elf_errno(); if ((d = elf_getdata(scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("%s: elf_getdata() failed: %s", fn, elf_errmsg(-1)); continue; } if (d->d_size <= 0) continue; if ((name = find_symbol(fn, e, d, &sh, off)) != NULL) { printf(", func: %s", name); break; } } elferr = elf_errno(); if (elferr != 0) warnx("%s: elf_nextscn() failed: %s", fn, elf_errmsg(elferr)); if (dbg == NULL) goto done; /* * More verbose output if debugging information is available. */ while ((ret = dwarf_next_cu_header(dbg, NULL, NULL, NULL, NULL, NULL, &de)) == DW_DLV_OK) { die = NULL; while (dwarf_siblingof(dbg, die, &die, &de) == DW_DLV_OK) { if (dwarf_tag(die, &tag, &de) != DW_DLV_OK) goto out; /* XXX: What about DW_TAG_partial_unit? */ if (tag == DW_TAG_compile_unit) break; } if (die == NULL) { /* Could not find DW_TAG_compile_unit DIE. */ goto out; } if (!dwarf_attrval_unsigned(die, DW_AT_low_pc, &lopc, &de) && !dwarf_attrval_unsigned(die, DW_AT_high_pc, &hipc, &de)) { /* * Check if the address falls into the PC range of * this CU. */ if (off < lopc || off >= hipc) continue; } else continue; if (dwarf_srclines(die, &lbuf, &lcount, &de) != DW_DLV_OK) continue; found = 0; plineaddr = ~0ULL; plineno = 0; pfile = NULL; for (i = 0; i < lcount; i++) { if (dwarf_lineaddr(lbuf[i], &lineaddr, &de)) continue; if (dwarf_lineno(lbuf[i], &lineno, &de)) continue; if (dwarf_linesrc(lbuf[i], &file, &de)) continue; if (off == lineaddr) { found = 1; goto out; } else if (off < lineaddr && off > plineaddr) { lineno = plineno; file = pfile; found = 1; goto out; } plineaddr = lineaddr; plineno = lineno; pfile = file; } } out: if (found) printf(", file: %s, line: %ju", file, (uintmax_t) lineno); /* * Reset internal CU pointer, so we will start from the first CU * next round. */ while (ret != DW_DLV_NO_ENTRY) { if (ret == DW_DLV_ERROR) break; ret = dwarf_next_cu_header(dbg, NULL, NULL, NULL, NULL, NULL, &de); } done: putchar('\n'); } static void examine_reloc(const char *fn, Elf *e, Elf_Data *d, GElf_Shdr *sh, GElf_Phdr *ph, int phnum, Dwarf_Debug dbg, int *textrel) { GElf_Rela rela; int i, j, len; GElf_Rel rel; + if (sh->sh_entsize == 0) { + warnx("invalid sh_entsize"); + return; + } len = (int) (d->d_size / sh->sh_entsize); for (i = 0; i < len; i++) { if (sh->sh_type == SHT_REL) { if (gelf_getrel(d, i, &rel) != &rel) { warnx("%s: gelf_getrel() failed: %s", fn, elf_errmsg(-1)); continue; } } else { if (gelf_getrela(d, i, &rela) != &rela) { warnx("%s: gelf_getrela() failed: %s", fn, elf_errmsg(-1)); continue; } } for (j = 0; j < phnum; j++) { if (sh->sh_type == SHT_REL) { if (rel.r_offset >= ph[j].p_offset && rel.r_offset < ph[j].p_offset + ph[j].p_filesz) report_textrel(fn, e, dbg, (uintmax_t) rel.r_offset, textrel); } else { if (rela.r_offset >= ph[j].p_offset && rela.r_offset < ph[j].p_offset + ph[j].p_filesz) report_textrel(fn, e, dbg, (uintmax_t) rela.r_offset, textrel); } } } } static void find_textrel(const char *fn) { Elf *e; Elf_Scn *scn; Elf_Data *d; GElf_Ehdr eh; GElf_Phdr *ph; GElf_Shdr sh; Dwarf_Debug dbg; Dwarf_Error de; int elferr, fd, i, phnum, textrel; e = NULL; ph = NULL; dbg = NULL; if ((fd = open(fn, O_RDONLY)) < 0) { warn("%s", fn); return; } if ((e = elf_begin(fd, ELF_C_READ, NULL)) == NULL) { warnx("%s: elf_begin() failed: %s", fn, elf_errmsg(-1)); goto exit; } if (gelf_getehdr(e, &eh) != &eh) { warnx("%s: gelf_getehdr() failed: %s", fn, elf_errmsg(-1)); goto exit; } if (eh.e_type != ET_DYN) { printf("%s: ELF object is not a DSO/PIE\n", fn); goto exit; } /* * Search program header for executable segments. */ if (eh.e_phnum == 0) { printf("%s: ELF object does not contain program headers\n", fn); goto exit; } if ((ph = calloc(eh.e_phnum, sizeof(GElf_Phdr))) == NULL) err(EXIT_FAILURE, "calloc failed"); phnum = 0; for (i = 0; (unsigned) i < eh.e_phnum; i++) { if (gelf_getphdr(e, i, &ph[phnum]) != &ph[phnum]) { warnx("%s: gelf_getphdr() failed: %s", fn, elf_errmsg(-1)); continue; } if (ph[phnum].p_flags & PF_X) phnum++; } if (phnum == 0) { printf("%s: ELF object does not contain any executable " "segment\n", fn); goto exit; } /* Check if debugging information is available. */ if (dwarf_elf_init(e, DW_DLC_READ, NULL, NULL, &dbg, &de)) dbg = NULL; /* * Search relocation records for possible text relocations. */ textrel = 0; scn = NULL; while ((scn = elf_nextscn(e, scn)) != NULL) { if (gelf_getshdr(scn, &sh) == NULL) { warnx("%s: gelf_getshdr() failed: %s", fn, elf_errmsg(-1)); continue; } if (sh.sh_type == SHT_REL || sh.sh_type == SHT_RELA) { (void) elf_errno(); if ((d = elf_getdata(scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("%s: elf_getdata() failed: %s", fn, elf_errmsg(-1)); continue; } if (d->d_size <= 0) continue; examine_reloc(fn, e, d, &sh, ph, phnum, dbg, &textrel); } } elferr = elf_errno(); if (elferr != 0) warnx("%s: elf_nextscn() failed: %s", fn, elf_errmsg(elferr)); if (!textrel) printf("%s: ELF object does not contain a text relocation\n", fn); exit: if (dbg) dwarf_finish(dbg, &de); if (ph) free(ph); if (e) (void) elf_end(e); close(fd); } int main(int argc, char **argv) { int i, opt; if (elf_version(EV_CURRENT) == EV_NONE) errx(EXIT_FAILURE, "elf_version(): %s", elf_errmsg(-1)); while ((opt = getopt_long(argc, argv, "HV", longopts, NULL)) != -1) { switch (opt) { case 'H': usage(); case 'V': version(); default: usage(); } } argv += optind; argc -= optind; if (argc > 0) for (i = 0; i < argc; i++) find_textrel(argv[i]); else find_textrel("a.out"); exit(0); } Index: vendor/elftoolchain/dist/ld/Makefile =================================================================== --- vendor/elftoolchain/dist/ld/Makefile (revision 300227) +++ vendor/elftoolchain/dist/ld/Makefile (revision 300228) @@ -1,54 +1,52 @@ -# $Id: Makefile 3385 2016-01-31 14:26:26Z jkoshy $ +# $Id: Makefile 3407 2016-02-14 17:47:23Z jkoshy $ TOP= .. PROG= ld WARNS?= 5 SRCS= amd64.c \ amd64_script.c \ i386.c \ i386_script.c \ ld_arch.c \ ld_dynamic.c \ ld_ehframe.c \ ld_error.c \ ld_exp.c \ ld_file.c \ ld_hash.c \ ld_input.c \ ld_layout.c \ ld_main.c \ ld_options.c \ ld_output.c \ ld_path.c \ ld_reloc.c \ ld_script.c \ ld_strtab.c \ ld_symbols.c \ ld_symver.c \ mips.c \ littlemips_script.c \ bigmips_script.c LSRC= ld_script_lexer.l YSRC= ld_script_parser.y GENSRCS= amd64_script.c i386_script.c littlemips_script.c \ bigmips_script.c CLEANFILES+= ${GENSRCS} DPADD= ${LIBELFTC} ${LIBELF} ${LIBDWARF} LDADD= -lelftc -ldwarf -lelf CFLAGS+= -I. -I${.CURDIR} YFLAGS= -d - -NOMAN= .SUFFIXES: .ld .c .ld.c: awk -f ld_script.awk ${.ALLSRC} > ${.TARGET} .include "${TOP}/mk/elftoolchain.prog.mk" Index: vendor/elftoolchain/dist/ld/amd64.c =================================================================== --- vendor/elftoolchain/dist/ld/amd64.c (revision 300227) +++ vendor/elftoolchain/dist/ld/amd64.c (revision 300228) @@ -1,1362 +1,1327 @@ /*- * Copyright (c) 2012,2013 Kai Wang * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include "ld.h" #include "ld_arch.h" #include "ld_dynamic.h" #include "ld_input.h" #include "ld_layout.h" #include "ld_output.h" #include "ld_reloc.h" #include "ld_symbols.h" #include "ld_utils.h" #include "amd64.h" -ELFTC_VCSID("$Id: amd64.c 3390 2016-02-05 16:15:58Z emaste $"); +ELFTC_VCSID("$Id: amd64.c 3419 2016-02-19 20:07:15Z emaste $"); static void _create_plt_reloc(struct ld *ld, struct ld_symbol *lsb, uint64_t offset); static void _create_got_reloc(struct ld *ld, struct ld_symbol *lsb, uint64_t type, uint64_t offset); static void _create_copy_reloc(struct ld *ld, struct ld_symbol *lsb); static void _create_dynamic_reloc(struct ld *ld, struct ld_input_section *is, struct ld_symbol *lsb, uint64_t type, uint64_t offset, int64_t addend); static void _scan_reloc(struct ld *ld, struct ld_input_section *is, struct ld_reloc_entry *lre); static struct ld_input_section *_find_and_create_got_section(struct ld *ld, int create); static struct ld_input_section *_find_and_create_gotplt_section(struct ld *ld, int create); static struct ld_input_section *_find_and_create_plt_section(struct ld *ld, int create); static void _finalize_got_and_plt(struct ld *ld); static uint64_t _get_max_page_size(struct ld *ld); static uint64_t _get_common_page_size(struct ld *ld); static void _adjust_reloc(struct ld *ld, struct ld_input_section *is, struct ld_reloc_entry *lre, struct ld_symbol *lsb, uint8_t *buf); static void _process_reloc(struct ld *ld, struct ld_input_section *is, struct ld_reloc_entry *lre, struct ld_symbol *lsb, uint8_t *buf); -static const char *_reloc2str(uint64_t r); static void _reserve_got_entry(struct ld *ld, struct ld_symbol *lsb, int num); static void _reserve_gotplt_entry(struct ld *ld, struct ld_symbol *lsb); static void _reserve_plt_entry(struct ld *ld, struct ld_symbol *lsb); static int _is_absolute_reloc(uint64_t r); static void _warn_pic(struct ld *ld, struct ld_reloc_entry *lre); static void _create_tls_gd_reloc(struct ld *ld, struct ld_symbol *lsb); static void _create_tls_ld_reloc(struct ld *ld, struct ld_symbol *lsb); static void _create_tls_ie_reloc(struct ld *ld, struct ld_symbol *lsb); static enum ld_tls_relax _tls_check_relax(struct ld *ld, struct ld_reloc_entry *lre); static uint64_t _got_offset(struct ld *ld, struct ld_symbol *lsb); static int _tls_verify_gd(uint8_t *buf, uint64_t off); static int _tls_verify_ld(uint8_t *buf, uint64_t off); static void _tls_relax_gd_to_ie(struct ld *ld, struct ld_state *ls, struct ld_output *lo,struct ld_reloc_entry *lre, uint64_t p, uint64_t g, uint8_t *buf); static void _tls_relax_gd_to_le(struct ld *ld, struct ld_state *ls, struct ld_output *lo, struct ld_reloc_entry *lre, struct ld_symbol *lsb, uint8_t *buf); static void _tls_relax_ld_to_le(struct ld *ld, struct ld_state *ls, struct ld_reloc_entry *lre, uint8_t *buf); static void _tls_relax_ie_to_le(struct ld *ld, struct ld_output *lo, struct ld_reloc_entry *lre, struct ld_symbol *lsb, uint8_t *buf); static int32_t _tls_dtpoff(struct ld_output *lo, struct ld_symbol *lsb); static int32_t _tls_tpoff(struct ld_output *lo, struct ld_symbol *lsb); static uint64_t _get_max_page_size(struct ld *ld) { (void) ld; return (0x200000); } static uint64_t _get_common_page_size(struct ld *ld) { (void) ld; return (0x1000); } -static const char * -_reloc2str(uint64_t r) -{ - static char s[32]; - - switch (r) { - case 0: return "R_X86_64_NONE"; - case 1: return "R_X86_64_64"; - case 2: return "R_X86_64_PC32"; - case 3: return "R_X86_64_GOT32"; - case 4: return "R_X86_64_PLT32"; - case 5: return "R_X86_64_COPY"; - case 6: return "R_X86_64_GLOB_DAT"; - case 7: return "R_X86_64_JUMP_SLOT"; - case 8: return "R_X86_64_RELATIVE"; - case 9: return "R_X86_64_GOTPCREL"; - case 10: return "R_X86_64_32"; - case 11: return "R_X86_64_32S"; - case 12: return "R_X86_64_16"; - case 13: return "R_X86_64_PC16"; - case 14: return "R_X86_64_8"; - case 15: return "R_X86_64_PC8"; - case 16: return "R_X86_64_DTPMOD64"; - case 17: return "R_X86_64_DTPOFF64"; - case 18: return "R_X86_64_TPOFF64"; - case 19: return "R_X86_64_TLSGD"; - case 20: return "R_X86_64_TLSLD"; - case 21: return "R_X86_64_DTPOFF32"; - case 22: return "R_X86_64_GOTTPOFF"; - case 23: return "R_X86_64_TPOFF32"; - default: - snprintf(s, sizeof(s), "", (uintmax_t) r); - return (s); - } -} - static int _is_absolute_reloc(uint64_t r) { if (r == R_X86_64_64 || r == R_X86_64_32 || r == R_X86_64_32S || r == R_X86_64_16 || r == R_X86_64_8) return (1); return (0); } static int _is_relative_reloc(uint64_t r) { if (r == R_X86_64_RELATIVE) return (1); return (0); } static void _warn_pic(struct ld *ld, struct ld_reloc_entry *lre) { struct ld_symbol *lsb; lsb = lre->lre_sym; if (lsb->lsb_bind != STB_LOCAL) ld_warn(ld, "relocation %s against `%s' can not be used" " by runtime linker; recompile with -fPIC", - _reloc2str(lre->lre_type), lsb->lsb_name); + elftc_reloc_type_str(EM_X86_64, + lre->lre_type), lsb->lsb_name); else ld_warn(ld, "relocation %s can not be used by runtime linker;" - " recompile with -fPIC", _reloc2str(lre->lre_type)); + " recompile with -fPIC", elftc_reloc_type_str(EM_X86_64, + lre->lre_type)); } static struct ld_input_section * _find_and_create_got_section(struct ld *ld, int create) { struct ld_input_section *is; /* Check if the GOT section is already created. */ is = ld_input_find_internal_section(ld, ".got"); if (is != NULL) return (is); if (create) { is = ld_input_add_internal_section(ld, ".got"); is->is_entsize = 8; is->is_align = 8; is->is_type = SHT_PROGBITS; is->is_flags = SHF_ALLOC | SHF_WRITE; } return (is); } static struct ld_input_section * _find_and_create_gotplt_section(struct ld *ld, int create) { struct ld_input_section *is; /* Check if the GOT (for PLT) section is already created. */ is = ld_input_find_internal_section(ld, ".got.plt"); if (is != NULL) return (is); if (create) { is = ld_input_add_internal_section(ld, ".got.plt"); is->is_entsize = 8; is->is_align = 8; is->is_type = SHT_PROGBITS; is->is_flags = SHF_ALLOC | SHF_WRITE; /* Reserve space for the initial entries. */ (void) ld_input_reserve_ibuf(is, 3); /* Create _GLOBAL_OFFSET_TABLE_ symbol. */ ld_symbols_add_internal(ld, "_GLOBAL_OFFSET_TABLE_", 0, 0, is->is_index, STB_LOCAL, STT_OBJECT, STV_HIDDEN, is, NULL); } return (is); } static struct ld_input_section * _find_and_create_plt_section(struct ld *ld, int create) { struct ld_input_section *is; /* Check if the PLT section is already created. */ is = ld_input_find_internal_section(ld, ".plt"); if (is != NULL) return (is); if (create) { is = ld_input_add_internal_section(ld, ".plt"); is->is_entsize = 16; is->is_align = 4; is->is_type = SHT_PROGBITS; is->is_flags = SHF_ALLOC | SHF_EXECINSTR; /* Reserve space for the initial entry. */ (void) ld_input_reserve_ibuf(is, 1); } return (is); } static void _reserve_got_entry(struct ld *ld, struct ld_symbol *lsb, int num) { struct ld_input_section *is; is = _find_and_create_got_section(ld, 1); /* Check if the entry already has a GOT entry. */ if (lsb->lsb_got) return; /* Reserve GOT entries. */ lsb->lsb_got_off = ld_input_reserve_ibuf(is, num); lsb->lsb_got = 1; } static void _reserve_gotplt_entry(struct ld *ld, struct ld_symbol *lsb) { struct ld_input_section *is; is = _find_and_create_gotplt_section(ld, 1); /* Reserve a GOT entry for PLT. */ (void) ld_input_reserve_ibuf(is, 1); /* * Record a R_X86_64_JUMP_SLOT entry for this symbol. Note that * we don't need to record the offset (relative to the GOT section) * here, since the PLT relocations will be sorted later and we * will generate GOT section according to the new order. */ _create_plt_reloc(ld, lsb, 0); } static void _reserve_plt_entry(struct ld *ld, struct ld_symbol *lsb) { struct ld_input_section *is; is = _find_and_create_plt_section(ld, 1); (void) ld_input_reserve_ibuf(is, 1); lsb->lsb_plt = 1; } static void _create_plt_reloc(struct ld *ld, struct ld_symbol *lsb, uint64_t offset) { ld_reloc_create_entry(ld, ".rela.plt", NULL, R_X86_64_JUMP_SLOT, lsb, offset, 0); lsb->lsb_dynrel = 1; } static void _create_got_reloc(struct ld *ld, struct ld_symbol *lsb, uint64_t type, uint64_t offset) { struct ld_input_section *tis; tis = _find_and_create_got_section(ld, 0); assert(tis != NULL); ld_reloc_create_entry(ld, ".rela.got", tis, type, lsb, offset, 0); if (type != R_X86_64_RELATIVE) lsb->lsb_dynrel = 1; } static void _create_copy_reloc(struct ld *ld, struct ld_symbol *lsb) { struct ld_input_section *tis; ld_dynamic_reserve_dynbss_entry(ld, lsb); tis = ld_input_find_internal_section(ld, ".dynbss"); assert(tis != NULL); ld_reloc_create_entry(ld, ".rela.bss", tis, R_X86_64_COPY, lsb, lsb->lsb_value, 0); lsb->lsb_dynrel = 1; } static void _create_dynamic_reloc(struct ld *ld, struct ld_input_section *is, struct ld_symbol *lsb, uint64_t type, uint64_t offset, int64_t addend) { if (lsb->lsb_bind == STB_LOCAL) { if (is->is_flags & SHF_WRITE) ld_reloc_create_entry(ld, ".rela.data.rel.local", is, type, lsb, offset, addend); else ld_reloc_create_entry(ld, ".rela.data.rel.ro.local", is, type, lsb, offset, addend); } else { if (is->is_flags & SHF_WRITE) ld_reloc_create_entry(ld, ".rela.data.rel", is, type, lsb, offset, addend); else ld_reloc_create_entry(ld, ".rela.data.rel.ro", is, type, lsb, offset, addend); } if (type != R_X86_64_RELATIVE) lsb->lsb_dynrel = 1; } static void _finalize_reloc(struct ld *ld, struct ld_input_section *tis, struct ld_reloc_entry *lre) { struct ld_symbol *lsb; (void) ld; (void) tis; lsb = ld_symbols_ref(lre->lre_sym); switch (lre->lre_type) { case R_X86_64_RELATIVE: /* * Update the addend stored in the original relocation to * point to the new location, by adding the updated symbol * value. */ lre->lre_addend += lsb->lsb_value; /* R_X86_64_RELATIVE should not associate with a symbol. */ lre->lre_sym = NULL; break; case R_X86_64_DTPMOD64: /* * Relocation R_X86_64_DTPMOD64 generated for local dynamic * TLS model should not assoicate with a symbol. */ if (lre->lre_type == R_X86_64_DTPMOD64 && lsb->lsb_tls_ld) lre->lre_sym = NULL; break; default: break; } } static void _finalize_got_and_plt(struct ld *ld) { struct ld_output *lo; struct ld_input_section *got_is, *rela_got_is, *plt_is, *rela_plt_is; struct ld_output_section *got_os, *plt_os, *rela_plt_os; struct ld_reloc_entry *lre; struct ld_symbol *lsb; char dynamic_symbol[] = "_DYNAMIC"; uint8_t *got, *plt; uint64_t u64; int32_t s32, pltgot, gotpcrel; int i, j; lo = ld->ld_output; assert(lo != NULL); /* * Intiailze all .got section entries to zero. */ got_is = _find_and_create_got_section(ld, 0); if (got_is != NULL) memset(got_is->is_ibuf, 0, got_is->is_size); /* * Search for GOT relocations that requires filling in symbol * value. */ rela_got_is = ld_input_find_internal_section(ld, ".rela.got"); if (rela_got_is != NULL && rela_got_is->is_reloc != NULL) { STAILQ_FOREACH(lre, rela_got_is->is_reloc, lre_next) { if (lre->lre_type == R_X86_64_RELATIVE) { lsb = lre->lre_sym; got = (uint8_t *) got_is->is_ibuf + lsb->lsb_got_off; WRITE_64(got, lsb->lsb_value); } } } /* * Find the .plt section. The buffers should have been allocated * at this point. */ plt_is = _find_and_create_plt_section(ld, 0); if (plt_is == NULL) return; plt_os = plt_is->is_output; plt = plt_is->is_ibuf; assert(plt != NULL); /* * Find the .got.plt and .rela.plt section. If the .plt section * exists, the .got.plt and .rela.plt section should exist too. */ got_is = _find_and_create_gotplt_section(ld, 0); assert(got_is != NULL); got_os = got_is->is_output; lo->lo_gotplt = got_os; got = got_is->is_ibuf; assert(got != NULL); rela_plt_is = ld_input_find_internal_section(ld, ".rela.plt"); assert(rela_plt_is != NULL); rela_plt_os = rela_plt_is->is_output; lo->lo_rel_plt = rela_plt_os; /* Point sh_info field of the .rela.plt to .plt section. */ rela_plt_os->os_info = plt_os; /* Fill in the value of symbol _DYNAMIC in the first GOT entry. */ ld_symbols_get_value(ld, dynamic_symbol, &u64); WRITE_64(got, u64); got += 8; /* Reserve the second and the third entry for the dynamic linker. */ memset(got, 0, 16); got += 16; /* * Write the initial PLT entry. */ /* Calculate the relative offset from PLT to GOT. */ pltgot = got_os->os_addr - plt_os->os_addr; /* * Push the second GOT entry to the stack for the dynamic * linker. (PUSH reg/memXX [RIP+disp32]) (6 bytes for push) */ WRITE_8(plt, 0xff); WRITE_8(plt + 1, 0x35); s32 = pltgot - 6 + 8; WRITE_32(plt + 2, s32); plt += 6; /* * Jump to the address in the third GOT entry (call into * the dynamic linker). (JMP reg/memXX [RIP+disp32]) * (6 bytes for jmp) */ WRITE_8(plt, 0xff); WRITE_8(plt + 1, 0x25); s32 = pltgot - 12 + 16; WRITE_32(plt + 2, s32); plt += 6; /* Padding: 4-byte nop. (NOP [rAx+disp8]) */ WRITE_8(plt, 0x0f); WRITE_8(plt + 1, 0x1f); WRITE_8(plt + 2, 0x40); WRITE_8(plt + 3, 0x0); plt += 4; /* * Walk through the sorted PLT relocations in the output section * and fill in each GOT and PLT entries. */ i = 3; j = 0; STAILQ_FOREACH(lre, rela_plt_is->is_reloc, lre_next) { lsb = ld_symbols_ref(lre->lre_sym); /* * Set symbol's PLT offset to the address of this PLT entry. * The PLT offset is used in relocation processing later. */ lsb->lsb_plt_off = plt_os->os_addr + (i - 2) * 16; /* * Update the offset for the R_X86_64_JUMP_SLOT relocation * entry, pointing to the corresponding GOT entry. */ lre->lre_offset = got_os->os_addr + i * 8; /* * Calculate the IP-relative offset to the GOT entry for * this function. (6 bytes for jmp) */ gotpcrel = pltgot + i * 8 - (i - 2) * 16 - 6; /* * PLT: Jump to the address in the GOT entry for this * function. (JMP reg/memXX [RIP+disp32]) */ WRITE_8(plt, 0xff); WRITE_8(plt + 1, 0x25); WRITE_32(plt + 2, gotpcrel); plt += 6; /* * PLT: Symbol is not resolved, push the relocation index to * the stack. (PUSH imm32) */ WRITE_8(plt, 0x68); WRITE_32(plt + 1, j); plt += 5; /* * PLT: Jump to the first PLT entry, eventually call the * dynamic linker. (JMP rel32off) */ WRITE_8(plt, 0xe9); s32 = - (i - 1) * 16; WRITE_32(plt + 1, s32); plt += 5; /* * GOT: Write the GOT entry for this function, pointing to * the push op. */ u64 = plt_os->os_addr + (i - 2) * 16 + 6; WRITE_64(got, u64); /* Increase relocation entry index. */ j++; /* Move to next GOT entry. */ got += 8; i++; } assert(got == (uint8_t *) got_is->is_ibuf + got_is->is_size); assert(plt == (uint8_t *) plt_is->is_ibuf + plt_is->is_size); } static void _scan_reloc(struct ld *ld, struct ld_input_section *is, struct ld_reloc_entry *lre) { struct ld_symbol *lsb; enum ld_tls_relax tr; lsb = ld_symbols_ref(lre->lre_sym); /* * TODO: We do not yet support "Large Models" and relevant * relocation types R_X86_64_GOT64, R_X86_64_GOTPCREL64, * R_X86_64_GOTPC64, R_X86_64_GOTPLT64 and R_X86_64_PLTOFF64. * Refer to AMD64 ELF ABI for details. */ switch (lre->lre_type) { case R_X86_64_NONE: break; case R_X86_64_64: case R_X86_64_32: case R_X86_64_32S: case R_X86_64_16: case R_X86_64_8: /* * For a local symbol, if the linker output a PIE or DSO, * we should generate a R_X86_64_RELATIVE reloc for * R_X86_64_64. We don't know how to generate dynamic reloc * for other reloc types since R_X86_64_RELATIVE is 64 bits. * We can not use them directly either because FreeBSD rtld(1) * (and probably glibc) doesn't accept absolute address * reloction other than R_X86_64_64. */ if (lsb->lsb_bind == STB_LOCAL) { if (ld->ld_pie || ld->ld_dso) { if (lre->lre_type == R_X86_64_64) _create_dynamic_reloc(ld, is, lsb, R_X86_64_RELATIVE, lre->lre_offset, lre->lre_addend); else _warn_pic(ld, lre); } break; } /* * For a global symbol, we probably need to generate PLT entry * and/or a dynamic relocation. * * Note here, normally the compiler will generate a PC-relative * relocation for function calls. However, if the code retrieve * the address of a function and call it indirectly, assembler * will generate absolute relocation instead. That's why we * should check if we need to create a PLT entry here. Also, if * we're going to create the PLT entry, we should also set the * symbol value to the address of PLT entry just in case the * function address is used to compare with other function * addresses. (If PLT address is used, function will have * unified address in the main executable and DSOs) */ if (ld_reloc_require_plt(ld, lre)) { if (!lsb->lsb_plt) { _reserve_gotplt_entry(ld, lsb); _reserve_plt_entry(ld, lsb); } /* * Note here even if we have generated PLT for this * function before, we still need to set this flag. * It's possible that we first see the relative * relocation then this absolute relocation, in * other words, the same function can be called in * different ways. */ lsb->lsb_func_addr = 1; } if (ld_reloc_require_copy_reloc(ld, lre) && !lsb->lsb_copy_reloc) _create_copy_reloc(ld, lsb); else if (ld_reloc_require_dynamic_reloc(ld, lre)) { /* We only support R_X86_64_64. (See above) */ if (lre->lre_type != R_X86_64_64) { _warn_pic(ld, lre); break; } /* * Check if we can relax R_X86_64_64 to * R_X86_64_RELATIVE instead. */ if (ld_reloc_relative_relax(ld, lre)) _create_dynamic_reloc(ld, is, lsb, R_X86_64_RELATIVE, lre->lre_offset, lre->lre_addend); else _create_dynamic_reloc(ld, is, lsb, R_X86_64_64, lre->lre_offset, lre->lre_addend); } break; case R_X86_64_PLT32: /* * In some cases we don't really need to generate a PLT * entry, then a R_X86_64_PLT32 relocation can be relaxed * to a R_X86_64_PC32 relocation. */ if (lsb->lsb_bind == STB_LOCAL || !ld_reloc_require_plt(ld, lre)) { lre->lre_type = R_X86_64_PC32; break; } /* * If linker outputs an normal executable and the symbol is * defined but is not defined inside a DSO, we can generate * a R_X86_64_PC32 relocation instead. */ if (ld->ld_exec && lsb->lsb_shndx != SHN_UNDEF && (lsb->lsb_input == NULL || lsb->lsb_input->li_type != LIT_DSO)) { lre->lre_type = R_X86_64_PC32; break; } /* Create an PLT entry otherwise. */ if (!lsb->lsb_plt) { _reserve_gotplt_entry(ld, lsb); _reserve_plt_entry(ld, lsb); } break; case R_X86_64_PC64: case R_X86_64_PC32: case R_X86_64_PC16: case R_X86_64_PC8: /* * When these relocations apply to a global symbol, we should * check if we need to generate PLT entry and/or a dynamic * relocation. */ if (lsb->lsb_bind != STB_LOCAL) { if (ld_reloc_require_plt(ld, lre) && !lsb->lsb_plt) { _reserve_gotplt_entry(ld, lsb); _reserve_plt_entry(ld, lsb); } if (ld_reloc_require_copy_reloc(ld, lre) && !lsb->lsb_copy_reloc) _create_copy_reloc(ld, lsb); else if (ld_reloc_require_dynamic_reloc(ld, lre)) { /* * We can not generate dynamic relocation for * these PC-relative relocation since they * are probably not supported by the runtime * linkers. * * Note: FreeBSD rtld(1) does support * R_X86_64_PC32. */ _warn_pic(ld, lre); } } break; case R_X86_64_GOTOFF64: case R_X86_64_GOTPC32: /* * These relocation types use GOT address as a base address * and instruct the linker to build a GOT. */ (void) _find_and_create_got_section(ld, 1); break; case R_X86_64_GOT32: case R_X86_64_GOTPCREL: /* * These relocation types instruct the linker to build a * GOT and generate a GOT entry. */ if (!lsb->lsb_got) { _reserve_got_entry(ld, lsb, 1); /* * TODO: For now we always create a R_X86_64_GLOB_DAT * relocation for a GOT entry. There are cases that * the symbol's address is known at link time and * the GOT entry value can be filled in by the program * linker instead. */ if (ld_reloc_require_glob_dat(ld, lre)) _create_got_reloc(ld, lsb, R_X86_64_GLOB_DAT, lsb->lsb_got_off); else _create_got_reloc(ld, lsb, R_X86_64_RELATIVE, lsb->lsb_got_off); } break; case R_X86_64_TLSGD: /* Global Dynamic */ tr = _tls_check_relax(ld, lre); switch (tr) { case TLS_RELAX_NONE: _create_tls_gd_reloc(ld, lsb); break; case TLS_RELAX_INIT_EXEC: _create_tls_ie_reloc(ld, lsb); break; case TLS_RELAX_LOCAL_EXEC: break; default: ld_fatal(ld, "Internal: invalid TLS relaxation %d", tr); break; } break; case R_X86_64_TLSLD: /* Local Dynamic */ tr = _tls_check_relax(ld, lre); if (tr == TLS_RELAX_NONE) _create_tls_ld_reloc(ld, lsb); else if (tr != TLS_RELAX_LOCAL_EXEC) ld_fatal(ld, "Internal: invalid TLS relaxation %d", tr); break; case R_X86_64_DTPOFF32: /* Handled by R_X86_64_TLSLD case. */ break; case R_X86_64_GOTTPOFF: /* Initial Exec */ tr = _tls_check_relax(ld, lre); if (tr == TLS_RELAX_NONE) _create_tls_ie_reloc(ld, lsb); else if (tr != TLS_RELAX_LOCAL_EXEC) ld_fatal(ld, "Internal: invalid TLS relaxation %d", tr); break; case R_X86_64_TPOFF32: /* Local Exec */ /* No further relaxation possible. */ break; case R_X86_64_GOTPC32_TLSDESC: case R_X86_64_TLSDESC_CALL: /* TODO. */ break; default: ld_warn(ld, "can not handle relocation %ju", lre->lre_type); break; } } static uint64_t _got_offset(struct ld *ld, struct ld_symbol *lsb) { struct ld_output_section *os; assert(lsb->lsb_got); if (ld->ld_got == NULL) { ld->ld_got = _find_and_create_got_section(ld, 0); assert(ld->ld_got != NULL); } os = ld->ld_got->is_output; return (os->os_addr + ld->ld_got->is_reloff + lsb->lsb_got_off); } static void _process_reloc(struct ld *ld, struct ld_input_section *is, struct ld_reloc_entry *lre, struct ld_symbol *lsb, uint8_t *buf) { struct ld_state *ls; struct ld_output *lo; uint64_t u64, s, l, p, g; int64_t s64; uint32_t u32; int32_t s32; enum ld_tls_relax tr; ls = &ld->ld_state; lo = ld->ld_output; assert(lo != NULL); l = lsb->lsb_plt_off; p = lre->lre_offset + is->is_output->os_addr + is->is_reloff; s = lsb->lsb_value; switch (lre->lre_type) { case R_X86_64_NONE: break; case R_X86_64_64: WRITE_64(buf + lre->lre_offset, s + lre->lre_addend); break; case R_X86_64_PC32: if (lsb->lsb_plt) s32 = l + lre->lre_addend - p; else s32 = s + lre->lre_addend - p; WRITE_32(buf + lre->lre_offset, s32); break; case R_X86_64_PLT32: if (!ls->ls_ignore_next_plt) { s32 = l + lre->lre_addend - p; WRITE_32(buf + lre->lre_offset, s32); } else ls->ls_ignore_next_plt = 0; break; case R_X86_64_GOTPCREL: g = _got_offset(ld, lsb); s32 = g + lre->lre_addend - p; WRITE_32(buf + lre->lre_offset, s32); break; case R_X86_64_32: u64 = s + lre->lre_addend; u32 = u64 & 0xffffffff; if (u64 != u32) ld_fatal(ld, "R_X86_64_32 relocation failed"); WRITE_32(buf + lre->lre_offset, u32); break; case R_X86_64_32S: s64 = s + lre->lre_addend; s32 = s64 & 0xffffffff; if (s64 != s32) ld_fatal(ld, "R_X86_64_32S relocation failed"); WRITE_32(buf + lre->lre_offset, s32); break; case R_X86_64_TLSGD: /* Global Dynamic */ tr = _tls_check_relax(ld, lre); switch (tr) { case TLS_RELAX_NONE: g = _got_offset(ld, lsb); s32 = g + lre->lre_addend - p; WRITE_32(buf + lre->lre_offset, s32); break; case TLS_RELAX_INIT_EXEC: g = _got_offset(ld, lsb); _tls_relax_gd_to_ie(ld, ls, lo, lre, p, g, buf); break; case TLS_RELAX_LOCAL_EXEC: _tls_relax_gd_to_le(ld, ls, lo, lre, lsb, buf); break; default: ld_fatal(ld, "Internal: invalid TLS relaxation %d", tr); break; } break; case R_X86_64_TLSLD: /* Local Dynamic */ tr = _tls_check_relax(ld, lre); switch (tr) { case TLS_RELAX_NONE: g = _got_offset(ld, lsb); s32 = g + lre->lre_addend - p; WRITE_32(buf + lre->lre_offset, s32); break; case TLS_RELAX_LOCAL_EXEC: _tls_relax_ld_to_le(ld, ls, lre, buf); break; default: ld_fatal(ld, "Internal: invalid TLS relaxation %d", tr); break; } break; case R_X86_64_DTPOFF32: /* Local Dynamic (offset) */ tr = _tls_check_relax(ld, lre); switch (tr) { case TLS_RELAX_NONE: s32 = _tls_dtpoff(lo, lsb); WRITE_32(buf + lre->lre_offset, s32); break; case TLS_RELAX_LOCAL_EXEC: s32 = _tls_tpoff(lo, lsb); WRITE_32(buf + lre->lre_offset, s32); break; default: ld_fatal(ld, "Internal: invalid TLS relaxation %d", tr); break; } break; case R_X86_64_GOTTPOFF: /* Initial Exec */ tr = _tls_check_relax(ld, lre); switch (tr) { case TLS_RELAX_NONE: g = _got_offset(ld, lsb); s32 = g + lre->lre_addend - p; WRITE_32(buf + lre->lre_offset, s32); break; case TLS_RELAX_LOCAL_EXEC: _tls_relax_ie_to_le(ld, lo, lre, lsb, buf); break; default: ld_fatal(ld, "Internal: invalid TLS relaxation %d", tr); break; } break; case R_X86_64_TPOFF32: /* Local Exec */ s32 = _tls_tpoff(lo, lsb); WRITE_32(buf + lre->lre_offset, s32); break; default: ld_warn(ld, "Relocation %s not supported", - _reloc2str(lre->lre_type)); + elftc_reloc_type_str(EM_X86_64, lre->lre_type)); break; } } static void _adjust_reloc(struct ld *ld, struct ld_input_section *is, struct ld_reloc_entry *lre, struct ld_symbol *lsb, uint8_t *buf) { struct ld_input_section *_is; (void) ld; (void) is; (void) buf; /* Only need to adjust relocation against section symbols. */ if (lsb->lsb_type != STT_SECTION) return; if ((_is = lsb->lsb_is) == NULL || _is->is_output == NULL) return; /* * Update the relocation addend to point to the new location * in the output object. */ lre->lre_addend += _is->is_reloff; } static enum ld_tls_relax _tls_check_relax(struct ld *ld, struct ld_reloc_entry *lre) { struct ld_symbol *lsb; lsb = ld_symbols_ref(lre->lre_sym); /* * If the linker is performing -static linking, we should always * use the Local Exec model. */ if (!ld->ld_dynamic_link) return (TLS_RELAX_LOCAL_EXEC); /* * If the linker is creating a DSO, we can not perform any TLS * relaxation. */ if (ld->ld_dso) return (TLS_RELAX_NONE); /* * The linker is creating an executable, if the symbol is * defined in a regular object, we can use the Local Exec model. */ if (lsb->lsb_shndx != SHN_UNDEF && ld_symbols_in_regular(lsb)) return (TLS_RELAX_LOCAL_EXEC); /* * If the TLS model is Global Dynamic, we can relax it to Initial * Exec model since the linker is creating an executable. */ if (lre->lre_type == R_X86_64_TLSGD) return (TLS_RELAX_INIT_EXEC); /* For all the other cases, no relaxation can be done. */ return (TLS_RELAX_NONE); } static int32_t _tls_tpoff(struct ld_output *lo, struct ld_symbol *lsb) { int32_t tls_off; tls_off = -roundup(lo->lo_tls_size, lo->lo_tls_align); return (tls_off + (lsb->lsb_value - lo->lo_tls_addr)); } static int32_t _tls_dtpoff(struct ld_output *lo, struct ld_symbol *lsb) { return (lsb->lsb_value - lo->lo_tls_addr); } static int _tls_verify_gd(uint8_t *buf, uint64_t off) { /* * Global Dynamic model: * * 0x00 .byte 0x66 * 0x01 leaq x@tlsgd(%rip), %rdi * 0x08 .word 0x6666 * 0x0a rex64 * 0x0b call _tls_get_addr@plt */ uint8_t gd[] = "\x66\x48\x8d\x3d\x00\x00\x00\x00" "\x66\x66\x48\xe8\x00\x00\x00\x00"; if (memcmp(buf + off, gd, sizeof(gd) - 1) == 0) return (1); return (0); } static int _tls_verify_ld(uint8_t *buf, uint64_t off) { /* * Local Dynamic model: * * 0x00 leaq x@tlsld(%rip), %rdi * 0x07 call _tls_get_addr@plt */ uint8_t ld[] = "\x48\x8d\x3d\x00\x00\x00\x00" "\xe8\x00\x00\x00\x00"; if (memcmp(buf + off, ld, sizeof(ld) - 1) == 0) return (1); return (0); } static void _tls_relax_gd_to_ie(struct ld *ld, struct ld_state *ls, struct ld_output *lo, struct ld_reloc_entry *lre, uint64_t p, uint64_t g, uint8_t *buf) { /* * Initial Exec model: * * 0x00 movq %fs:0, %rax * 0x09 addq x@gottpoff(%rip), %rax */ uint8_t ie[] = "\x64\x48\x8b\x04\x25\x00\x00\x00\x00" "\x48\x03\x05\x00\x00\x00\x00"; int32_t s32; assert(lre->lre_type == R_X86_64_TLSGD); if (!_tls_verify_gd(buf, lre->lre_offset - 4)) ld_warn(ld, "unrecognized TLS global dynamic model code"); /* Rewrite Global Dynamic to Initial Exec model. */ memcpy((uint8_t *) buf + lre->lre_offset - 4, ie, sizeof(ie) - 1); /* * R_X86_64_TLSGD relocation is applied at gd[4]. After it's relaxed * to Initial Exec model, the resulting R_X86_64_GOTTPOFF relocation * should be applied at ie[12]. The addend should remain the same * since instruction "leaq x@tlsgd(%rip), %rdi" and * "addq x@gottpoff(%rip), %rax" has the same length. `p' is moved * 8 bytes forward. */ s32 = g + lre->lre_addend - (p + 8); WRITE_32(buf + lre->lre_offset + 8, s32); /* Ignore the next R_X86_64_PLT32 relocation for _tls_get_addr. */ ls->ls_ignore_next_plt = 1; } static void _tls_relax_gd_to_le(struct ld *ld, struct ld_state *ls, struct ld_output *lo, struct ld_reloc_entry *lre, struct ld_symbol *lsb, uint8_t *buf) { /* * Local Exec model: * * 0x00 movq %fs:0, %rax * 0x09 leaq x@tpoff(%rax), %rax */ uint8_t le[] = "\x64\x48\x8b\x04\x25\x00\x00\x00\x00" "\x48\x8d\x80\x00\x00\x00\x00"; int32_t s32; if (!_tls_verify_gd(buf, lre->lre_offset - 4)) ld_warn(ld, "unrecognized TLS global dynamic model code"); /* Rewrite Global Dynamic to Local Exec model. */ memcpy((uint8_t *) buf + lre->lre_offset - 4, le, sizeof(le) - 1); /* * R_X86_64_TLSGD relocation is applied at gd[4]. After it's relaxed * to Local Exec model, the resulting R_X86_64_TPOFF32 should be * applied at le[12]. */ s32 = _tls_tpoff(lo, lsb); WRITE_32(buf + lre->lre_offset + 8, s32); /* Ignore the next R_X86_64_PLT32 relocation for _tls_get_addr. */ ls->ls_ignore_next_plt = 1; } static void _tls_relax_ld_to_le(struct ld *ld, struct ld_state *ls, struct ld_reloc_entry *lre, uint8_t *buf) { /* * Local Exec model: (with padding) * * 0x00 .word 0x6666 * 0x02 .byte 0x66 * 0x03 movq %fs:0, %rax */ uint8_t le_p[] = "\x66\x66\x66\x64\x48\x8b\x04\x25\x00\x00\x00\x00"; assert(lre->lre_type == R_X86_64_TLSLD); if (!_tls_verify_ld(buf, lre->lre_offset - 3)) ld_warn(ld, "unrecognized TLS local dynamic model code"); /* Rewrite Local Dynamic to Local Exec model. */ memcpy(buf + lre->lre_offset - 3, le_p, sizeof(le_p) - 1); /* Ignore the next R_X86_64_PLT32 relocation for _tls_get_addr. */ ls->ls_ignore_next_plt = 1; } static void _tls_relax_ie_to_le(struct ld *ld, struct ld_output *lo, struct ld_reloc_entry *lre, struct ld_symbol *lsb, uint8_t *buf) { int32_t s32; uint8_t reg; (void) ld; assert(lre->lre_type == R_X86_64_GOTTPOFF); /* * Rewrite Initial Exec to Local Exec model: rewrite * "movq 0x0(%rip),%reg" to "movq 0x0,%reg". or, * "addq 0x0(%rip),%rsp" to "addq 0x0,%rsp". or, * "addq 0x0(%rip),%reg" to "leaq 0x0(%reg),%reg" */ reg = buf[lre->lre_offset - 1] >> 3; if (buf[lre->lre_offset - 2] == 0x8b) { /* movq 0x0(%rip),%reg -> movq 0x0,%reg. */ buf[lre->lre_offset - 2] = 0xc7; buf[lre->lre_offset - 1] = 0xc0 | reg; /* Set r/m to `reg' */ /* * Set REX.B (high bit for r/m) if REX.R (high bit for reg) * is set. */ if (buf[lre->lre_offset - 3] == 0x4c) buf[lre->lre_offset - 3] = 0x49; } else if (reg == 4) { /* addq 0x0(%rip),%rsp -> addq 0x0,%rsp */ buf[lre->lre_offset - 2] = 0x81; buf[lre->lre_offset - 1] = 0xc0 | reg; /* Set r/m to `reg' */ /* * Set REX.B (high bit for r/m) if REX.R (high bit for reg) * is set. */ if (buf[lre->lre_offset - 3] == 0x4c) buf[lre->lre_offset - 3] = 0x49; } else { /* addq 0x0(%rip),%reg -> leaq 0x0(%reg),%reg */ buf[lre->lre_offset - 2] = 0x8d; /* Both reg and r/m in ModRM should be set to `reg' */ buf[lre->lre_offset - 1] = 0x80 | reg | (reg << 3); /* Set both REX.B and REX.R if REX.R is set */ if (buf[lre->lre_offset - 3] == 0x4c) buf[lre->lre_offset - 3] = 0x4d; } /* * R_X86_64_GOTTPOFF relocation is applied at ie[12]. After it's * relaxed to Local Exec model, the resulting R_X86_64_TPOFF32 * should be applied at le[12]. Thus the offset remains the same. */ s32 = _tls_tpoff(lo, lsb); WRITE_32(buf + lre->lre_offset, s32); } static void _create_tls_gd_reloc(struct ld *ld, struct ld_symbol *lsb) { /* * Reserve 2 GOT entries and generate R_X86_64_DTPMOD64 and * R_X86_64_DTPOFF64 relocations. */ if (!lsb->lsb_got) { _reserve_got_entry(ld, lsb, 2); _create_got_reloc(ld, lsb, R_X86_64_DTPMOD64, lsb->lsb_got_off); _create_got_reloc(ld, lsb, R_X86_64_DTPOFF64, lsb->lsb_got_off + 8); } } static void _create_tls_ld_reloc(struct ld *ld, struct ld_symbol *lsb) { /* Reserve 2 GOT entries and generate R_X86_64_DTPMOD64 reloation. */ if (!lsb->lsb_got) { _reserve_got_entry(ld, lsb, 2); _create_got_reloc(ld, lsb, R_X86_64_DTPMOD64, lsb->lsb_got_off); lsb->lsb_tls_ld = 1; } } static void _create_tls_ie_reloc(struct ld *ld, struct ld_symbol *lsb) { /* Reserve 1 GOT entry and generate R_X86_64_TPOFF64 relocation. */ if (!lsb->lsb_got) { _reserve_got_entry(ld, lsb, 1); _create_got_reloc(ld, lsb, R_X86_64_TPOFF64, lsb->lsb_got_off); } } void amd64_register(struct ld *ld) { struct ld_arch *amd64, *amd64_alt; if ((amd64 = calloc(1, sizeof(*amd64))) == NULL) ld_fatal_std(ld, "calloc"); snprintf(amd64->name, sizeof(amd64->name), "%s", "amd64"); amd64->script = amd64_script; amd64->interp = "/libexec/ld-elf.so.1"; amd64->get_max_page_size = _get_max_page_size; amd64->get_common_page_size = _get_common_page_size; amd64->scan_reloc = _scan_reloc; amd64->process_reloc = _process_reloc; amd64->adjust_reloc = _adjust_reloc; amd64->is_absolute_reloc = _is_absolute_reloc; amd64->is_relative_reloc = _is_relative_reloc; amd64->finalize_reloc = _finalize_reloc; amd64->finalize_got_and_plt = _finalize_got_and_plt; amd64->reloc_is_64bit = 1; amd64->reloc_is_rela = 1; amd64->reloc_entsize = sizeof(Elf64_Rela); HASH_ADD_STR(ld->ld_arch_list, name, amd64); if ((amd64_alt = calloc(1, sizeof(*amd64_alt))) == NULL) ld_fatal_std(ld, "calloc"); memcpy(amd64_alt, amd64, sizeof(struct ld_arch)); amd64_alt->alias = amd64; snprintf(amd64_alt->name, sizeof(amd64_alt->name), "%s", "x86-64"); HASH_ADD_STR(ld->ld_arch_list, name, amd64_alt); } Index: vendor/elftoolchain/dist/ld/i386.c =================================================================== --- vendor/elftoolchain/dist/ld/i386.c (revision 300227) +++ vendor/elftoolchain/dist/ld/i386.c (revision 300228) @@ -1,623 +1,579 @@ /*- * Copyright (c) 2012,2013 Kai Wang * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include "ld.h" #include "ld_arch.h" #include "ld_dynamic.h" #include "ld_input.h" #include "ld_output.h" #include "ld_reloc.h" #include "ld_symbols.h" #include "ld_utils.h" #include "i386.h" -ELFTC_VCSID("$Id: i386.c 3391 2016-02-05 19:43:01Z emaste $"); +ELFTC_VCSID("$Id: i386.c 3419 2016-02-19 20:07:15Z emaste $"); static void _create_plt_reloc(struct ld *ld, struct ld_symbol *lsb, uint64_t offset); static void _create_got_reloc(struct ld *ld, struct ld_symbol *lsb, uint64_t type, uint64_t offset); static void _create_copy_reloc(struct ld *ld, struct ld_symbol *lsb); static void _create_dynamic_reloc(struct ld *ld, struct ld_input_section *is, struct ld_symbol *lsb, uint64_t type, uint64_t offset); static void _scan_reloc(struct ld *ld, struct ld_input_section *is, struct ld_reloc_entry *lre); static struct ld_input_section *_find_and_create_got_section(struct ld *ld, int create); static struct ld_input_section *_find_and_create_gotplt_section(struct ld *ld, int create); static struct ld_input_section *_find_and_create_plt_section(struct ld *ld, int create); static uint64_t _get_max_page_size(struct ld *ld); static uint64_t _get_common_page_size(struct ld *ld); static void _process_reloc(struct ld *ld, struct ld_input_section *is, struct ld_reloc_entry *lre, struct ld_symbol *lsb, uint8_t *buf); -static const char *_reloc2str(uint64_t r); static void _reserve_got_entry(struct ld *ld, struct ld_symbol *lsb, int num); static void _reserve_gotplt_entry(struct ld *ld, struct ld_symbol *lsb); static void _reserve_plt_entry(struct ld *ld, struct ld_symbol *lsb); static int _is_absolute_reloc(uint64_t r); static int _is_relative_reloc(uint64_t r); static void _warn_pic(struct ld *ld, struct ld_reloc_entry *lre); static uint32_t _got_offset(struct ld *ld, struct ld_symbol *lsb); static uint64_t _get_max_page_size(struct ld *ld) { (void) ld; return (0x1000); } static uint64_t _get_common_page_size(struct ld *ld) { (void) ld; return (0x1000); } -static const char * -_reloc2str(uint64_t r) -{ - static char s[32]; - - switch (r) { - case 0: return "R_386_NONE"; - case 1: return "R_386_32"; - case 2: return "R_386_PC32"; - case 3: return "R_386_GOT32"; - case 4: return "R_386_PLT32"; - case 5: return "R_386_COPY"; - case 6: return "R_386_GLOB_DAT"; - case 7: return "R_386_JUMP_SLOT"; - case 8: return "R_386_RELATIVE"; - case 9: return "R_386_GOTOFF"; - case 10: return "R_386_GOTPC"; - case 14: return "R_386_TLS_TPOFF"; - case 15: return "R_386_TLS_IE"; - case 16: return "R_386_TLS_GOTI"; - case 17: return "R_386_TLS_LE"; - case 18: return "R_386_TLS_GD"; - case 19: return "R_386_TLS_LDM"; - case 24: return "R_386_TLS_GD_32"; - case 25: return "R_386_TLS_GD_PUSH"; - case 26: return "R_386_TLS_GD_CALL"; - case 27: return "R_386_TLS_GD_POP"; - case 28: return "R_386_TLS_LDM_32"; - case 29: return "R_386_TLS_LDM_PUSH"; - case 30: return "R_386_TLS_LDM_CALL"; - case 31: return "R_386_TLS_LDM_POP"; - case 32: return "R_386_TLS_LDO_32"; - case 33: return "R_386_TLS_IE_32"; - case 34: return "R_386_TLS_LE_32"; - case 35: return "R_386_TLS_DTPMOD32"; - case 36: return "R_386_TLS_DTPOFF32"; - case 37: return "R_386_TLS_TPOFF32"; - - default: - snprintf(s, sizeof(s), "", (uintmax_t) r); - return (s); - } -} - static int _is_absolute_reloc(uint64_t r) { if (r == R_386_32) return (1); return (0); } static int _is_relative_reloc(uint64_t r) { if (r == R_386_RELATIVE) return (1); return (0); } static void _warn_pic(struct ld *ld, struct ld_reloc_entry *lre) { struct ld_symbol *lsb; lsb = lre->lre_sym; if (lsb->lsb_bind != STB_LOCAL) ld_warn(ld, "relocation %s against `%s' can not be used" " by runtime linker; recompile with -fPIC", - _reloc2str(lre->lre_type), lsb->lsb_name); + elftc_reloc_type_str(EM_386, lre->lre_type), lsb->lsb_name); else ld_warn(ld, "relocation %s can not be used by runtime linker;" - " recompile with -fPIC", _reloc2str(lre->lre_type)); + " recompile with -fPIC", + elftc_reloc_type_str(EM_386, lre->lre_type)); } static struct ld_input_section * _find_and_create_got_section(struct ld *ld, int create) { struct ld_input_section *is; /* Check if the GOT section is already created. */ is = ld_input_find_internal_section(ld, ".got"); if (is != NULL) return (is); if (create) { is = ld_input_add_internal_section(ld, ".got"); is->is_entsize = 4; is->is_align = 4; is->is_type = SHT_PROGBITS; is->is_flags = SHF_ALLOC | SHF_WRITE; } return (is); } static struct ld_input_section * _find_and_create_gotplt_section(struct ld *ld, int create) { struct ld_input_section *is; /* Check if the GOT (for PLT) section is already created. */ is = ld_input_find_internal_section(ld, ".got.plt"); if (is != NULL) return (is); if (create) { is = ld_input_add_internal_section(ld, ".got.plt"); is->is_entsize = 4; is->is_align = 4; is->is_type = SHT_PROGBITS; is->is_flags = SHF_ALLOC | SHF_WRITE; /* Reserve space for the initial entries. */ (void) ld_input_reserve_ibuf(is, 3); /* Create _GLOBAL_OFFSET_TABLE_ symbol. */ ld_symbols_add_internal(ld, "_GLOBAL_OFFSET_TABLE_", 0, 0, is->is_index, STB_LOCAL, STT_OBJECT, STV_HIDDEN, is, NULL); } return (is); } static struct ld_input_section * _find_and_create_plt_section(struct ld *ld, int create) { struct ld_input_section *is; /* Check if the PLT section is already created. */ is = ld_input_find_internal_section(ld, ".plt"); if (is != NULL) return (is); if (create) { is = ld_input_add_internal_section(ld, ".plt"); is->is_entsize = 4; is->is_align = 4; is->is_type = SHT_PROGBITS; is->is_flags = SHF_ALLOC | SHF_EXECINSTR; /* Reserve space for the initial entry. */ (void) ld_input_reserve_ibuf(is, 1); } return (is); } static void _reserve_got_entry(struct ld *ld, struct ld_symbol *lsb, int num) { struct ld_input_section *is; is = _find_and_create_got_section(ld, 1); /* Check if the entry already has a GOT entry. */ if (lsb->lsb_got) return; /* Reserve GOT entries. */ lsb->lsb_got_off = ld_input_reserve_ibuf(is, num); lsb->lsb_got = 1; } static void _reserve_gotplt_entry(struct ld *ld, struct ld_symbol *lsb) { struct ld_input_section *is; is = _find_and_create_gotplt_section(ld, 1); /* Reserve a GOT entry for PLT. */ (void) ld_input_reserve_ibuf(is, 1); /* * Record a R_386_JUMP_SLOT entry for this symbol. Note that * we don't need to record the offset (relative to the GOT section) * here, since the PLT relocations will be sorted later and we * will generate GOT section according to the new order. */ _create_plt_reloc(ld, lsb, 0); } static void _reserve_plt_entry(struct ld *ld, struct ld_symbol *lsb) { struct ld_input_section *is; is = _find_and_create_plt_section(ld, 1); (void) ld_input_reserve_ibuf(is, 1); lsb->lsb_plt = 1; } static void _create_plt_reloc(struct ld *ld, struct ld_symbol *lsb, uint64_t offset) { ld_reloc_create_entry(ld, ".rel.plt", NULL, R_386_JUMP_SLOT, lsb, offset, 0); lsb->lsb_dynrel = 1; } static void _create_got_reloc(struct ld *ld, struct ld_symbol *lsb, uint64_t type, uint64_t offset) { struct ld_input_section *tis; tis = _find_and_create_got_section(ld, 0); assert(tis != NULL); ld_reloc_create_entry(ld, ".rel.got", tis, type, lsb, offset, 0); if (type != R_386_RELATIVE) lsb->lsb_dynrel = 1; } static void _create_copy_reloc(struct ld *ld, struct ld_symbol *lsb) { struct ld_input_section *tis; ld_dynamic_reserve_dynbss_entry(ld, lsb); tis = ld_input_find_internal_section(ld, ".dynbss"); assert(tis != NULL); ld_reloc_create_entry(ld, ".rel.bss", tis, R_386_COPY, lsb, lsb->lsb_value, 0); lsb->lsb_dynrel = 1; } static void _create_dynamic_reloc(struct ld *ld, struct ld_input_section *is, struct ld_symbol *lsb, uint64_t type, uint64_t offset) { if (lsb->lsb_bind == STB_LOCAL) { if (is->is_flags & SHF_WRITE) ld_reloc_create_entry(ld, ".rel.data.rel.local", is, type, lsb, offset, 0); else ld_reloc_create_entry(ld, ".rel.data.rel.ro.local", is, type, lsb, offset, 0); } else { if (is->is_flags & SHF_WRITE) ld_reloc_create_entry(ld, ".rel.data.rel", is, type, lsb, offset, 0); else ld_reloc_create_entry(ld, ".rel.data.rel.ro", is, type, lsb, offset, 0); } if (type != R_386_RELATIVE) lsb->lsb_dynrel = 1; } static void _scan_reloc(struct ld *ld, struct ld_input_section *is, struct ld_reloc_entry *lre) { struct ld_symbol *lsb; lsb = ld_symbols_ref(lre->lre_sym); switch (lre->lre_type) { case R_386_NONE: break; case R_386_32: /* * For a local symbol, if te linker output a PIE or DSO, * we should generate a R_386_RELATIVE reloc for R_386_32. */ if (lsb->lsb_bind == STB_LOCAL) { if (ld->ld_pie || ld->ld_dso) _create_dynamic_reloc(ld, is, lsb, R_386_RELATIVE, lre->lre_offset); break; } /* * For a global symbol, we probably need to generate PLE entry * and/ore a dynamic relocation. * * Note here, normally the compiler will generate a PC-relative * relocation for function calls. However, if the code retrieve * the address of a function and call it indirectly, assembler * will generate absolute relocation instead. That's why we * should check if we need to create a PLT entry here. Also, if * we're going to create the PLT entry, we should also set the * symbol value to the address of PLT entry just in case the * function address is used to compare with other function * addresses. (If PLT address is used, function will have * unified address in the main executable and DSOs) */ if (ld_reloc_require_plt(ld, lre)) { if (!lsb->lsb_plt) { _reserve_gotplt_entry(ld, lsb); _reserve_plt_entry(ld, lsb); } /* * Note here even if we have generated PLT for this * function before, we still need to set this flag. * It's possible that we first see the relative * relocation then this absolute relocation, in * other words, the same function can be called in * different ways. */ lsb->lsb_func_addr = 1; } if (ld_reloc_require_copy_reloc(ld, lre) && !lsb->lsb_copy_reloc) _create_copy_reloc(ld, lsb); else if (ld_reloc_require_dynamic_reloc(ld, lre)) { /* * Check if we can relax R_386_32 to * R_386_RELATIVE instead. */ if (ld_reloc_relative_relax(ld, lre)) _create_dynamic_reloc(ld, is, lsb, R_386_RELATIVE, lre->lre_offset); else _create_dynamic_reloc(ld, is, lsb, R_386_32, lre->lre_offset); } break; case R_386_PLT32: /* * In some cases we don't really need to generate a PLT * entry, then a R_386_PLT32 relocation can be relaxed * to a R_386_PC32 relocation. */ if (lsb->lsb_bind == STB_LOCAL || !ld_reloc_require_plt(ld, lre)) { lre->lre_type = R_386_PC32; break; } /* * If linker outputs an normal executable and the symbol is * defined but is not defined inside a DSO, we can generate * a R_386_PC32 relocation instead. */ if (ld->ld_exec && lsb->lsb_shndx != SHN_UNDEF && (lsb->lsb_input == NULL || lsb->lsb_input->li_type != LIT_DSO)) { lre->lre_type = R_386_PC32; break; } /* Create an PLT entry otherwise. */ if (!lsb->lsb_plt) { _reserve_gotplt_entry(ld, lsb); _reserve_plt_entry(ld, lsb); } break; case R_386_PC32: /* * When R_386_PC32 apply to a global symbol, we should * check if we need to generate PLT entry and/or a dynamic * relocation. */ if (lsb->lsb_bind != STB_LOCAL) { if (ld_reloc_require_plt(ld, lre) && !lsb->lsb_plt) { _reserve_gotplt_entry(ld, lsb); _reserve_plt_entry(ld, lsb); } if (ld_reloc_require_copy_reloc(ld, lre) && !lsb->lsb_copy_reloc) _create_copy_reloc(ld, lsb); else if (ld_reloc_require_dynamic_reloc(ld, lre)) { /* * We can not generate dynamic relocation for * these PC-relative relocation since they * are probably not supported by the runtime * linkers. */ _warn_pic(ld, lre); } } break; case R_386_GOTOFF: case R_386_GOTPC: /* * These relocation types use GOT address as a base address * and instruct the linker to build a GOT. */ (void) _find_and_create_got_section(ld, 1); break; case R_386_GOT32: /* * R_386_GOT32 relocation instructs the linker to build a * GOT and generate a GOT entry. */ if (!lsb->lsb_got) { _reserve_got_entry(ld, lsb, 1); /* * TODO: For now we always create a R_386_GLOB_DAT * relocation for a GOT entry. There are cases that * the symbol's address is known at link time and * the GOT entry value can be filled in by the program * linker instead. */ if (ld_reloc_require_glob_dat(ld, lre)) _create_got_reloc(ld, lsb, R_386_GLOB_DAT, lsb->lsb_got_off); else _create_got_reloc(ld, lsb, R_386_RELATIVE, lsb->lsb_got_off); } default: ld_warn(ld, "can not handle relocation %ju", lre->lre_type); break; } } static uint32_t _got_offset(struct ld *ld, struct ld_symbol *lsb) { struct ld_output_section *os; assert(lsb->lsb_got); if (ld->ld_got == NULL) { ld->ld_got = _find_and_create_got_section(ld, 0); assert(ld->ld_got != NULL); } os = ld->ld_got->is_output; return (os->os_addr + ld->ld_got->is_reloff + lsb->lsb_got_off); } static void _process_reloc(struct ld *ld, struct ld_input_section *is, struct ld_reloc_entry *lre, struct ld_symbol *lsb, uint8_t *buf) { struct ld_state *ls; struct ld_output *lo; uint32_t p, s, l, g, got; int32_t a, v; ls = &ld->ld_state; lo = ld->ld_output; assert(lo != NULL); l = lsb->lsb_plt_off; p = lre->lre_offset + is->is_output->os_addr + is->is_reloff; got = ld->ld_got->is_output->os_addr; s = (uint32_t) lsb->lsb_value; READ_32(buf + lre->lre_offset, a); switch (lre->lre_type) { case R_386_NONE: break; case R_386_32: v = s + a; WRITE_32(buf + lre->lre_offset, v); break; case R_386_PC32: if (lsb->lsb_plt) v = l + a - p; else v = s + a - p; WRITE_32(buf + lre->lre_offset, v); break; case R_386_PLT32: if (!ls->ls_ignore_next_plt) { v = l + a - p; WRITE_32(buf + lre->lre_offset, v); } else ls->ls_ignore_next_plt = 0; break; case R_386_GOT32: g = _got_offset(ld, lsb); v = g + a; WRITE_32(buf + lre->lre_offset, v); break; case R_386_GOTOFF: v = s + a - got; WRITE_32(buf + lre->lre_offset, v); break; case R_386_GOTPC: v = got + a - p; WRITE_32(buf + lre->lre_offset, v); break; default: ld_fatal(ld, "Relocation %d not supported", lre->lre_type); break; } } void i386_register(struct ld *ld) { struct ld_arch *i386_arch; if ((i386_arch = calloc(1, sizeof(*i386_arch))) == NULL) ld_fatal_std(ld, "calloc"); snprintf(i386_arch->name, sizeof(i386_arch->name), "%s", "i386"); i386_arch->script = i386_script; i386_arch->get_max_page_size = _get_max_page_size; i386_arch->get_common_page_size = _get_common_page_size; i386_arch->scan_reloc = _scan_reloc; i386_arch->process_reloc = _process_reloc; i386_arch->is_absolute_reloc = _is_absolute_reloc; i386_arch->is_relative_reloc = _is_relative_reloc; i386_arch->reloc_is_64bit = 0; i386_arch->reloc_is_rela = 0; i386_arch->reloc_entsize = sizeof(Elf32_Rel); HASH_ADD_STR(ld->ld_arch_list, name, i386_arch); } Index: vendor/elftoolchain/dist/ld/ld.1 =================================================================== --- vendor/elftoolchain/dist/ld/ld.1 (nonexistent) +++ vendor/elftoolchain/dist/ld/ld.1 (revision 300228) @@ -0,0 +1,478 @@ +.\" Copyright (c) 2016 Joseph Koshy. All rights reserved. +.\" +.\" Redistribution and use in source and binary forms, with or without +.\" modification, are permitted provided that the following conditions +.\" are met: +.\" 1. Redistributions of source code must retain the above copyright +.\" notice, this list of conditions and the following disclaimer. +.\" 2. Redistributions in binary form must reproduce the above copyright +.\" notice, this list of conditions and the following disclaimer in the +.\" documentation and/or other materials provided with the distribution. +.\" +.\" This software is provided by the author and contributors ``as is'' +.\" and any express or implied warranties, including, but not limited +.\" to, the implied warranties of merchantability and fitness for a +.\" particular purpose are disclaimed. In no event shall the author or +.\" contributors be liable for any direct, indirect, incidental, special, +.\" exemplary, or consequential damages (including, but not limited to, +.\" procurement of substitute goods or services; loss of use, data, or +.\" profits; or business interruption) however caused and on any +.\" theory of liability, whether in contract, strict liability, or +.\" tort (including negligence or otherwise) arising in any way +.\" out of the use of this software, even if advised of the +.\" possibility of such damage. +.\" +.\" $Id$ +.\" +.Dd February 14, 2016 +.Os +.Dt LD 1 +.Sh NAME +.Nm ld +.Nd link editor +.Sh SYNOPSIS +.Nm +.Op Fl \&( +.Op Fl \&) +.Op Fl Bdynamic +.Op Fl Bshareable +.Op Fl Bstatic +.Op Fl I Ar file | Fl -dynamic-linker= Ns Ar file +.Op Fl L Ar dir | Fl -library-path= Ns Ar dir +.Op Fl M | Fl -print-map +.Op Fl T Ar script-file | Fl -script= Ns Ar script-file +.Op Fl V | Fl v | Fl -version +.Op Fl a Ar linkmode +.Op Fl b Ar input-format | Fl -format= Ns Ar input-format +.Op Fl call_shared +.Op Fl d | Fl dc | Fl dp +.Op Fl dn +.Op Fl dy +.Op Fl e Ar symbol | Fl -entry= Ns Ar symbol +.Op Fl h Ar name | Fl soname= Ns Ar name +.Op Fl l Ar library | Fl -library= Ns Ar library +.Op Fl o Ar output-file | Fl -output= Ns Ar output-file +.Op Fl q | Fl -emit-relocs +.Op Fl r | Fl -relocatable +.Op Fl u Ar name | Fl -undefined= Ns Ar name +.Op Fl z Ar keyword +.Op Fl -as-needed +.Op Fl -eh-frame-hdr +.Op Fl -end-group +.Op Fl -gc-sections +.Op Fl -no-as-needed +.Op Fl -no-define-common +.Op Fl -no-gc-sections +.Op Fl -no-print-gc-sections +.Op Fl -no-whole-archive +.Op Fl -oformat= Ns Ar format +.Op Fl -pic-executable | Fl pie +.Op Fl -print-gc-sections +.Op Fl -rpath= Ns Ar dirs +.Op Fl -rpath-link= Ns Ar dirs +.Op Fl -start-group +.Op Fl shared +.Op Fl static +.Op Fl -version-script= Ns Ar script +.Op Fl -whole-archive +.Ar +.Sh DESCRIPTION +The +.Nm +utility combines ELF objects and +.Xr ar 1 +archives containing ELF objects into an executable or a partially +relocated object. +.Pp +The +.Nm +utility processes options and files in the order presented on the +command line. +Unlike most +.Ux +utilities, options and file names may be interspersed. +Options seen on the command line will generally apply to subsequent +files, or till overridden by another option. +.Sh OPTIONS +.Pp +The +.Nm +utility supports the following options: +.Bl -tag -width indent +.It Xo +.Fl \&( +.Ar archives Ns ... +.Fl \&) +.Xc +Start a group of archives that are to be searched repeatedly until no new +undefined references are created. +This option is used when there are circular references between one or +more archives in the archive group. +.Pp +The files named by the arguments +.Ar archives +are expected to be archive files. +.Pp +Each use of the +.Fl \&( +option starts a new archive group that is ended by a matching +.Fl \&) +option. +.It Fl Bdynamic +Choose dynamic libraries for the libraries specified by subsequent +.Fl l +options. +.It Fl Bshareable +Create a shared library. +.It Fl Bstatic +Choose static libraries for the libraries specified by subsequent +.Fl l +options. +.It Fl I Ar file | Fl -dynamic-linker= Ns Ar file +Set the name of the dynamic linker when generating ELF executables. +.It Fl L Ar dir | Fl -library-path= Ns Ar dir +Add directory +.Ar dir +to the list of paths that +.Nm +will search for archive libraries. +This option may be specified multiple times. +User supplied directories are searched in the order specified on +the command line. +.It Fl M | Fl -print-map +Print a link map to standard output. +.It Fl T Ar script-file | Fl -script= Ns Ar script-file +Use the file name by argument +.Ar script-file +as the linker script instead of the default. +.It Fl V | Fl v | Fl version +Print a version identifier for +.Nm +and exit. +.It Fl a Ar linkmode +Select linking mode. +The value of the argument +.Ar linkmode +should be one of the following literals: +.Bl -tag -width ".Li default" -compact +.It Cm default +Equivalent to specifying +.Fl Bdynamic . +.It Cm archive +Equivalent to specifying +.Fl Bstatic . +.It Cm shared +Equivalent to specifying +.Fl Bdynamic . +.El +.It Fl b Ar input-format | Fl -format Ar input-format +Set the input format to that specified by argument +.Ar input-format . +The legal values for the argument +.Ar input-format +are those supported by +.Xr elftc_bfd_find_target 3 . +.It Fl d | Fl dc | Fl dp +Assign space for common symbols even if generating a relocatable object. +.It Fl dn +Equivalent to specifying option +.Fl Bstatic . +.It Fl dy +Equivalent to specifying option +.Fl Bdynamic . +.It Fl e Ar entry | Fl -entry Ar entry +Set execution to start at the symbol named by the argument +.Ar entry . +The argument should be the name of a symbol. +.It Fl h Ar name | Fl soname Ar name +Set the +.Li DT_SONAME +field in the object to that specified by the argument +.Ar name . +.It Fl l Ar name | Fl -library= Ns Ar name +Add the archive library or shared library named by argument +.Ar name +to the set of files to link. +This file is looked for in the list of directories specified by prior +.Fl L +options on the command line. +.It Fl o Ar output-file | Fl -output= Ns Ar output-file +Use the file specified by argument +.Ar output-file +for the output, instead of the default file name of +.Sq a.out . +.It Fl q | Fl -emit-relocs +Preserve relocation information in executables, for use by post-link +analysis tools. +.It Fl r | Fl -relocatable +Generate a relocatable output file that can be used as input for subsequent +linker runs. +.It Fl u Ar name | Fl -undefined= Ns Ar name +Add the symbol specified by argument +.Ar name +to the output file as an undefined symbol. +This option may be specified multiple times. +.It Fl z Ar keyword +Recognized keywords include: +.Bl -tag -width ".Li defaultextract" -compact +.It Cm execstack +Require the object to use an executable stack. +.It Cm noexecstack +Do not require the object to use an executable stack. +.El +.It Fl -as-needed +Add +.Li DT_NEEDED +tags for only those shared libraries that satisfy non-weak +unresolved references from object files or other dynamic libraries +seen so far on the command line. +.It Fl call_shared +Equivalent to specifying option +.Fl Bdynamic . +.It Fl -eh-frame-hdr +Create a +.Dq ".eh_frame_hdr" +section, and a +.Li PT_GNU_EH_FRAME +segment header, containing exception handling information. +.It Fl -end-group +Equivalent to specifying option +.Fl \&) . +.It Fl -gc-sections +Garbage collect unused input sections. +.It Fl -no-as-needed +Insert +.Li DT_NEEDED +tags for all shared libraries seen henceforth on the command line, +irrespective of whether the shared library is needed to resolve an +undefined symbol or not. +This behavior is the default. +.It Fl -no-define-common +Do not assign addresses to common symbols. +.It Fl -no-gc-sections +Do not garbage collect input sections that contain unreferenced +symbols. +.It Fl -no-print-gc-sections +Do not print the list of sections removed when the +.Fl -gc-sections +directive is active. +.It Fl -no-whole-archive +Only include objects in an archive that satisfy an unresolved reference +in the link. +This behavior is the default. +.It Fl non_shared +Equivalent to specifying option +.Fl Bstatic . +.It Fl -oformat= Ns Ar format +Set the desired output format to that specified by the argument +.Ar format . +Supported values for argument +.Ar format +are those understood by +.Xr elftc_bfd_find_target 3 . +.It Fl -pic-executable | Fl pie +Create a position-independent executable. +.It Fl -print-gc-sections +Print the list of sections removed when the +.Fl -gc-sections +directive is active. +The output is printed to stderr. +.It Fl -rpath= Ns Ar dirs +Add the colon-separated list of directories named by the argument +.Ar dirs +to the runtime library search path and to the link-time search +path. +.It Fl -rpath-link= Ns Ar dirs +Add the directories specified by the colon-separated list of directories +in argument +.Ar dirs +to the link-time search path for libraries. +The directories specified by this option are searched before those +specified by +.Fl -rpath +options. +.It Fl shared +Equivalent to specifying option +.Fl Bshareable . +.It Fl -start-group +Equivalent to specifying option +.Fl \&( . +.It Fl static +Equivalent to specifying option +.Fl Bstatic . +.It Fl -version-script= Ns Ar script-file +Use the version script in the file named by argument +.Ar script-file . +.It Fl -whole-archive +Include the entire contents of every archive file encountered on the +command line after this option in the link. +.El +.Sh DIAGNOSTICS +.Ex -std +.Sh SEE ALSO +.Xr ar 1 , +.Xr ranlib 1 , +.Xr archive 3 , +.Xr elf 3 , +.Xr elftc_bfd_find_target 3 , +.Xr dwarf 3 +.Sh IMPLEMENTATION NOTES +The +.Nm +utility differs from its GNU equivalent in the following: +.Bl -bullet +.It +The +.Nm +utility currently supports a limited range of output formats. +.It +The +.Fl e +and +.Fl -entry +options only accept a symbol name as an argument, and not a numeric +address. +.It +The +.Fl l +option only searches files in the directories specified by +prior +.Fl L +options. +.It +The +.Fl T | Fl -script +option does not search for script files in the directories specified +by prior +.Fl L +options. +.It +The +.Fl -rpath +option accepts a colon-separated list of directories instead of +single directory. +.El +.Pp +The following options are recognized, but are currently unimplemented: +.Fl Bgroup , +.Fl Bsymbolic , +.Fl Bsymbolic_functions , +.Fl E , +.Fl EB , +.Fl EL , +.Fl F , +.Fl Map , +.Fl N , +.Fl O , +.Fl Qy , +.Fl R , +.Fl S , +.Fl Tbss , +.Fl Tdata , +.Fl Ttext , +.Fl X , +.Fl Y , +.Fl Ur , +.Fl c , +.Fl f , +.Fl g , +.Fl i , +.Fl m , +.Fl n , +.Fl s , +.Fl t , +.Fl x , +.Fl y , +.Fl -accept-unknown-input-arch , +.Fl -allow-multiple-definition , +.Fl -allow-shlib-undefined , +.Fl -assert , +.Fl -auxiliary , +.Fl -build-id , +.Fl -check-sections , +.Fl -cref , +.Fl -defsym , +.Fl -demangle , +.Fl -disable-new-dtags , +.Fl -discard-all , +.Fl -discard-locals , +.Fl -error-unresolved-symbols , +.Fl -export-dynamic , +.Fl -emulation , +.Fl -enable-new-dtags , +.Fl -fatal-warnings , +.Fl -filter , +.Fl -fini , +.Fl -hash-style , +.Fl -help , +.Fl -init , +.Fl -just-symbols , +.Fl -mri-script , +.Fl -nmagic , +.Fl nostdlib , +.Fl -no-accept-unknown-input-arch , +.Fl -no-allow-shlib-undefined , +.Fl -no-assert , +.Fl -no-check-sections , +.Fl -no-demangle , +.Fl -no-keep-memory , +.Fl -no-omagic , +.Fl -no-undefined , +.Fl -no-undefined-version , +.Fl -no-warn-mismatch , +.Fl -omagic , +.Fl -qmagic , +.Fl -relax , +.Fl -retain-symbols-file , +.Fl -runpath , +.Fl -section-start , +.Fl -sort-common , +.Fl -split-by-file , +.Fl -split-by-reloc , +.Fl -stats , +.Fl -strip-all , +.Fl -strip-debug , +.Fl -trace , +.Fl -trace_symbol , +.Fl -traditional-format , +.Fl -unique , +.Fl -unresolved-symbols , +.Fl -verbose , +.Fl -warn-common , +.Fl -warn-constructors , +.Fl -warn-multiple-gp , +.Fl -warn-once , +.Fl -warn-section-align , +.Fl -warn-shared-textrel , +.Fl -warn-unresolved-symbols , +.Fl -wrap . +.Pp +The following keywords are recognized by the +.Fl z +option, but are currently unimplemented: +.Cm allextract , +.Cm defaultextract , +.Cm defs , +.Cm ignore , +.Cm initfirst , +.Cm lazyload , +.Cm muldefs , +.Cm nodefaultlib , +.Cm nodefs , +.Cm nodelete , +.Cm nodlopen , +.Cm nolazyload , +.Cm now , +.Cm origin , +.Cm record , +.Cm systemlibrary , +.Cm weakextract . +.Sh HISTORY +A +.Nm +command first appeared in AT&T UNIX Version 1. +.Pp +The Elftoolchain implementation of +.Nm +was written by +.An Kai Wang Aq Mt kaiwang27@gmail.com . Property changes on: vendor/elftoolchain/dist/ld/ld.1 ___________________________________________________________________ Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +FreeBSD=%H \ No newline at end of property Added: svn:mime-type ## -0,0 +1 ## +text/plain \ No newline at end of property Index: vendor/elftoolchain/dist/ld/ld_options.c =================================================================== --- vendor/elftoolchain/dist/ld/ld_options.c (revision 300227) +++ vendor/elftoolchain/dist/ld/ld_options.c (revision 300228) @@ -1,507 +1,507 @@ /*- * Copyright (c) 2010-2013 Kai Wang * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include "ld.h" #include "ld_file.h" #include "ld_path.h" #include "ld_script.h" #include "ld_symbols.h" #include "ld_options.h" #include "ld_output.h" -ELFTC_VCSID("$Id: ld_options.c 2926 2013-03-17 22:53:54Z kaiwang27 $"); +ELFTC_VCSID("$Id: ld_options.c 3406 2016-02-14 17:45:43Z jkoshy $"); /* * Support routines for parsing command line options. */ static const char *ld_short_opts = "b:c:de:Ef:Fgh:iI:l:L:m:MnNo:O::qrR:sStT:xXyY:u:vV()"; static struct ld_option ld_opts[] = { {"aarchive", KEY_STATIC, ONE_DASH, NO_ARG}, {"adefault", KEY_DYNAMIC, ONE_DASH, NO_ARG}, {"ashared", KEY_DYNAMIC, ONE_DASH, NO_ARG}, {"accept-unknown-input-arch", KEY_ACCEPT_UNKNOWN, ANY_DASH, NO_ARG}, {"allow-multiple-definition", KEY_Z_MULDEFS, ANY_DASH, NO_ARG}, {"allow-shlib-undefined", KEY_ALLOW_SHLIB_UNDEF, ANY_DASH, NO_ARG}, {"assert", KEY_ASSERT, ANY_DASH, NO_ARG}, {"as-needed", KEY_AS_NEEDED, ANY_DASH, NO_ARG}, {"auxiliary", 'f', ANY_DASH, REQ_ARG}, {"build-id", KEY_BUILD_ID, ANY_DASH, OPT_ARG}, {"call_shared", KEY_DYNAMIC, ONE_DASH, NO_ARG}, {"check-sections", KEY_CHECK_SECTIONS, ANY_DASH, NO_ARG}, {"cref", KEY_CREF, ANY_DASH, NO_ARG}, {"defsym", KEY_DEFSYM, ANY_DASH, REQ_ARG}, {"demangle", KEY_DEMANGLE, ANY_DASH, OPT_ARG}, {"dc", 'd', ONE_DASH, NO_ARG}, {"dp", 'd', ONE_DASH, NO_ARG}, {"disable-new-dtags", KEY_DISABLE_NEW_DTAGS, ANY_DASH, NO_ARG}, {"discard-all", 'x', ANY_DASH, NO_ARG}, {"discard-locals", 'X', ANY_DASH, NO_ARG}, {"dn", KEY_STATIC, ONE_DASH, NO_ARG}, {"dy", KEY_DYNAMIC, ONE_DASH, NO_ARG}, {"dynamic-linker", 'I', ANY_DASH, REQ_ARG}, {"end-group", ')', ANY_DASH, NO_ARG}, {"entry", 'e', ANY_DASH, REQ_ARG}, {"error-unresolved-symbols", KEY_ERR_UNRESOLVE_SYM, ANY_DASH, NO_ARG}, {"export-dynamic", 'E', ANY_DASH, NO_ARG}, {"eh-frame-hdr", KEY_EH_FRAME_HDR, ANY_DASH, NO_ARG}, {"emit-relocs", 'q', ANY_DASH, NO_ARG}, {"emulation", 'm', ANY_DASH, REQ_ARG}, {"enable-new-dtags", KEY_ENABLE_NEW_DTAGS, ANY_DASH, NO_ARG}, {"fatal-warnings", KEY_FATAL_WARNINGS, ANY_DASH, NO_ARG}, {"filter", 'F', ANY_DASH, NO_ARG}, {"fini", KEY_FINI, ANY_DASH, NO_ARG}, {"format", 'b', ANY_DASH, REQ_ARG}, {"gc-sections", KEY_GC_SECTIONS, ANY_DASH, NO_ARG}, {"hash-style", KEY_HASH_STYLE, ANY_DASH, REQ_ARG}, {"help", KEY_HELP, ANY_DASH, NO_ARG}, {"init", KEY_INIT, ANY_DASH, REQ_ARG}, {"just-symbols", 'R', ANY_DASH, REQ_ARG}, {"library", 'l', ANY_DASH, REQ_ARG}, {"library-path", 'L', ANY_DASH, REQ_ARG}, {"mri-script", 'c', ANY_DASH, REQ_ARG}, {"nmagic", 'n', ANY_DASH, NO_ARG}, {"nostdlib", KEY_NO_STDLIB, ONE_DASH, NO_ARG}, {"no-accept-unknown-input-arch", KEY_NO_UNKNOWN, ANY_DASH, NO_ARG}, {"no-allow-shlib-undefined", KEY_NO_SHLIB_UNDEF, ANY_DASH, NO_ARG}, {"no-as-needed", KEY_NO_AS_NEEDED, ANY_DASH, NO_ARG}, {"no-check-sections", KEY_NO_CHECK_SECTIONS, ANY_DASH, NO_ARG}, {"no-define-common", KEY_NO_DEFINE_COMMON, ANY_DASH, NO_ARG}, {"no-demangle", KEY_NO_DEMANGLE, ANY_DASH, OPT_ARG}, {"no-gc-sections", KEY_NO_GC_SECTIONS, ANY_DASH, NO_ARG}, - {"no-keep-memorg", KEY_NO_KEEP_MEMORY, ANY_DASH, NO_ARG}, + {"no-keep-memory", KEY_NO_KEEP_MEMORY, ANY_DASH, NO_ARG}, {"no-omagic", KEY_NO_OMAGIC, ANY_DASH, NO_ARG}, {"no-print-gc-sections", KEY_NO_PRINT_GC_SECTIONS, ANY_DASH, NO_ARG}, {"no-undefined", KEY_Z_DEFS, ANY_DASH, NO_ARG}, {"no-undefined-version", KEY_NO_UNDEF_VERSION, ANY_DASH, NO_ARG}, {"no-whole-archive", KEY_NO_WHOLE_ARCHIVE, ANY_DASH, NO_ARG}, {"no-warn-mismatch", KEY_NO_WARN_MISMATCH, ANY_DASH, NO_ARG}, {"non_shared", KEY_STATIC, ONE_DASH, NO_ARG}, {"oformat", KEY_OFORMAT, TWO_DASH, REQ_ARG}, {"omagic", 'N', TWO_DASH, NO_ARG}, {"output", 'o', TWO_DASH, REQ_ARG}, {"pic-executable", KEY_PIE, ANY_DASH, NO_ARG}, {"pie", KEY_PIE, ONE_DASH, NO_ARG}, {"print-gc-sections", KEY_PRINT_GC_SECTIONS, ANY_DASH, NO_ARG}, {"print-map", 'M', ANY_DASH, NO_ARG}, {"qmagic", KEY_QMAGIC, ANY_DASH, NO_ARG}, {"relax", KEY_RELAX, ANY_DASH, NO_ARG}, {"relocatable", 'r', ANY_DASH, NO_ARG}, {"retain-symbols-file", KEY_RETAIN_SYM_FILE, ANY_DASH, REQ_ARG}, {"rpath", KEY_RPATH, ANY_DASH, REQ_ARG}, {"rpath-link", KEY_RPATH_LINK, ANY_DASH, REQ_ARG}, {"runpath", KEY_RUNPATH, ANY_DASH, REQ_ARG}, {"script", 'T', ANY_DASH, REQ_ARG}, {"section-start", KEY_SECTION_START, ANY_DASH, REQ_ARG}, - {"shared", KEY_SHARED, ANY_DASH, NO_ARG}, + {"shared", KEY_SHARED, ONE_DASH, NO_ARG}, {"soname", 'h', ONE_DASH, REQ_ARG}, {"sort-common", KEY_SORT_COMMON, ANY_DASH, NO_ARG}, {"split-by-file", KEY_SPLIT_BY_FILE, ANY_DASH, REQ_ARG}, {"split-by-reloc", KEY_SPLIT_BY_RELOC, ANY_DASH, REQ_ARG}, {"start-group", '(', ANY_DASH, NO_ARG}, {"stats", KEY_STATS, ANY_DASH, NO_ARG}, {"static", KEY_STATIC, ONE_DASH, NO_ARG}, {"strip-all", 's', ANY_DASH, NO_ARG}, {"strip-debug", 'S', ANY_DASH, NO_ARG}, {"trace", 't', ANY_DASH, NO_ARG}, {"trace_symbol", 'y', ANY_DASH, NO_ARG}, {"traditional-format", KEY_TRADITIONAL_FORMAT, ANY_DASH, NO_ARG}, {"undefined", 'u', ANY_DASH, REQ_ARG}, {"unique", KEY_UNIQUE, ANY_DASH, OPT_ARG}, {"unresolved-symbols", KEY_UNRESOLVED_SYMBOLS, ANY_DASH, REQ_ARG}, - {"verbose" , 'v', ANY_DASH, NO_ARG}, - {"version", KEY_VERSION, ANY_DASH, NO_ARG}, + {"verbose" , KEY_VERBOSE, ANY_DASH, NO_ARG}, + {"version", 'V', ANY_DASH, NO_ARG}, {"version-script", KEY_VERSION_SCRIPT, ANY_DASH, REQ_ARG}, {"warn-common", KEY_WARN_COMMON, ANY_DASH, NO_ARG}, {"warn-constructors", KEY_WARN_CONSTRUCTORS, ANY_DASH, NO_ARG}, {"warn-multiple-gp", KEY_WARN_MULTIPLE_GP, ANY_DASH, NO_ARG}, {"warn-once", KEY_WARN_ONCE, ANY_DASH, NO_ARG}, {"warn-section-align", KEY_WARN_SECTION_ALIGN, ANY_DASH, NO_ARG}, {"warn-shared-textrel", KEY_WARN_SHARED_TEXTREL, ANY_DASH, NO_ARG}, {"warn-unresolved-symbols", KEY_WARN_UNRESOLVE_SYM, ANY_DASH, NO_ARG}, - {"whole_archive", KEY_WHOLE_ARCHIVE, ANY_DASH, NO_ARG}, + {"whole-archive", KEY_WHOLE_ARCHIVE, ANY_DASH, NO_ARG}, {"wrap", KEY_WRAP, ANY_DASH, REQ_ARG}, {"EB", KEY_EB, ONE_DASH, NO_ARG}, {"EL", KEY_EL, ONE_DASH, NO_ARG}, {"Map", KEY_MAP, ONE_DASH, REQ_ARG}, {"Qy", KEY_QY, ONE_DASH, NO_ARG}, {"Tbss", KEY_TBSS, ONE_DASH, REQ_ARG}, {"Tdata", KEY_TDATA, ONE_DASH, REQ_ARG}, {"Ttext", KEY_TTEXT, ONE_DASH, REQ_ARG}, {"Ur", KEY_UR, ONE_DASH, NO_ARG}, {NULL, 0, 0, 0}, }; static struct ld_option ld_opts_B[] = { {"shareable", KEY_SHARED, ONE_DASH, NO_ARG}, {"static", KEY_STATIC, ONE_DASH, NO_ARG}, {"dynamic", KEY_DYNAMIC, ONE_DASH, NO_ARG}, {"group", KEY_GROUP, ONE_DASH, NO_ARG}, {"symbolic", KEY_SYMBOLIC, ONE_DASH, NO_ARG}, {"symbolic_functions", KEY_SYMBOLIC_FUNC, ONE_DASH, NO_ARG}, }; static struct ld_option ld_opts_z[] = { {"nodefaultlib", KEY_Z_NO_DEFAULT_LIB, ONE_DASH, NO_ARG}, {"allextract", KEY_WHOLE_ARCHIVE, ONE_DASH, NO_ARG}, {"defaultextract", KEY_Z_DEFAULT_EXTRACT, ONE_DASH, NO_ARG}, {"weakextract", KEY_Z_WEAK_EXTRACT, ONE_DASH, NO_ARG}, {"muldefs", KEY_Z_MULDEFS, ONE_DASH, NO_ARG}, {"defs", KEY_Z_DEFS, ONE_DASH, NO_ARG}, {"execstack", KEY_Z_EXEC_STACK, ONE_DASH, NO_ARG}, {"nodefs", KEY_Z_NO_DEFS, ONE_DASH, NO_ARG}, {"origin", KEY_Z_ORIGIN, ONE_DASH, NO_ARG}, {"now", KEY_Z_NOW, ONE_DASH, NO_ARG}, {"nodelete", KEY_Z_NO_DELETE, ONE_DASH, NO_ARG}, {"initfirst", KEY_Z_INIT_FIRST, ONE_DASH, NO_ARG}, {"lazyload", KEY_Z_LAZYLOAD, ONE_DASH, NO_ARG}, {"noexecstack", KEY_Z_NO_EXEC_STACK, ONE_DASH, NO_ARG}, {"nodlopen", KEY_Z_NO_DLOPEN, ONE_DASH, NO_ARG}, {"nolazyload", KEY_Z_NO_LAZYLOAD, ONE_DASH, NO_ARG}, {"ignore", KEY_Z_IGNORE, ONE_DASH, NO_ARG}, {"record", KEY_Z_RECORD, ONE_DASH, NO_ARG}, {"systemlibrary", KEY_Z_SYSTEM_LIBRARY, ONE_DASH, NO_ARG}, }; static void _copy_optarg(struct ld *ld, char **dst, char *src); static void _process_options(struct ld *ld, int key, char *arg); static int _parse_long_options(struct ld *, struct ld_option *, int, int, char **, char *, enum ld_dash); static void _print_version(struct ld *ld); void ld_options_parse(struct ld* ld, int argc, char **argv) { enum ld_dash d; char *p, *p0, *oli; int ac, ac0; ac = 1; while (ac < argc) { p = argv[ac]; if (*p != '-' || p[1] == '\0') { _process_options(ld, KEY_FILE, p); ac++; continue; } if (*++p == '-') { if (p[1] == '\0') { /* Option --. Ignore the rest of options. */ return; } p++; d = TWO_DASH; } else { d = ONE_DASH; if (*p == 'B' || *p == 'z') { ac0 = ac; if (*(p0 = p + 1) == '\0') p0 = argv[++ac0]; ac = _parse_long_options(ld, *p == 'B' ? ld_opts_B : ld_opts_z, ac0, argc, argv, p0, d); if (ac > 0) continue; ld_fatal(ld, "unrecognized options -%c: %s", *p, p0); } } ac0 = _parse_long_options(ld, ld_opts, ac, argc, argv, p, d); if (ac0 > 0) { ac = ac0; continue; } if (d == TWO_DASH) ld_fatal(ld, "unrecognized option %s", p); /* * Search short options. */ while (*p != '\0') { if ((oli = strchr(ld_short_opts, *p)) == NULL) ld_fatal(ld, "unrecognized option -%c", *p); if (*++oli != ':') { _process_options(ld, *p++, NULL); continue; } if (p[1] != '\0') _process_options(ld, *p, &p[1]); else if (oli[1] != ':') { if (++ac >= argc) ld_fatal(ld, "require arg for" " option -%c", *p); _process_options(ld, *p, argv[ac]); } break; } ac++; } } static int _parse_long_options(struct ld *ld, struct ld_option *opts, int ac, int argc, char **argv, char *opt, enum ld_dash dash) { char *equal; size_t av_len; int i, match; if ((equal = strchr(opt, '=')) != NULL) { av_len = equal - opt; equal++; if (*equal == '\0') ld_fatal(ld, "no argument after ="); } else av_len = strlen(opt); match = 0; for (i = 0; opts[i].lo_long != NULL; i++) { if (opts[i].lo_dash != ANY_DASH && opts[i].lo_dash != dash) continue; if (strlen(opts[i].lo_long) == av_len && !strncmp(opt, opts[i].lo_long, av_len)) { match = 1; break; } } if (!match) return (-1); switch (opts[i].lo_arg) { case NO_ARG: if (equal != NULL) { ld_fatal(ld, "option %s does not accept argument", opts[i].lo_long); } _process_options(ld, opts[i].lo_key, NULL); break; case REQ_ARG: if (equal != NULL) _process_options(ld, opts[i].lo_key, equal); else { if (++ac >= argc) ld_fatal(ld, "require arg for option %s", opts[i].lo_long); _process_options(ld, opts[i].lo_key, argv[ac]); } break; case OPT_ARG: _process_options(ld, opts[i].lo_key, equal); break; default: assert(0); break; } return (++ac); } static void _process_options(struct ld *ld, int key, char *arg) { struct ld_state *ls; assert(ld != NULL); ls = &ld->ld_state; switch (key) { case 'b': ls->ls_itgt = elftc_bfd_find_target(arg); if (ls->ls_itgt == NULL) ld_fatal(ld, "invalid BFD target `%s'", arg); break; case 'd': ld->ld_common_alloc = 1; break; case 'e': _copy_optarg(ld, &ld->ld_entry, arg); break; case 'h': _copy_optarg(ld, &ld->ld_soname, arg); break; case 'I': _copy_optarg(ld, &ld->ld_interp, arg); break; case 'l': ld_path_search_library(ld, arg); break; case 'L': ld_path_add(ld, arg, LPT_L); break; case 'M': ld->ld_print_linkmap = 1; break; case 'o': _copy_optarg(ld, &ld->ld_output_file, arg); break; case 'q': ld->ld_emit_reloc = 1; break; case 'r': ld->ld_reloc = 1; break; case 'T': ld_script_parse(arg); break; case 'u': ld_symbols_add_extern(ld, arg); break; case 'v': case 'V': _print_version(ld); break; case '(': ls->ls_group_level++; if (ls->ls_group_level > LD_MAX_NESTED_GROUP) ld_fatal(ld, "too many nested archive groups"); break; case ')': ls->ls_group_level--; break; case KEY_AS_NEEDED: ls->ls_as_needed = 1; break; case KEY_DYNAMIC: ls->ls_static = 0; break; case KEY_EH_FRAME_HDR: ld->ld_ehframe_hdr = 1; break; case KEY_GC_SECTIONS: ld->ld_gc = 1; break; case KEY_NO_AS_NEEDED: ls->ls_as_needed = 0; break; case KEY_NO_DEFINE_COMMON: ld->ld_common_no_alloc = 1; break; case KEY_NO_GC_SECTIONS: ld->ld_gc = 0; break; case KEY_NO_PRINT_GC_SECTIONS: ld->ld_gc_print = 0; break; case KEY_NO_WHOLE_ARCHIVE: ls->ls_whole_archive = 0; break; case KEY_OFORMAT: ld_output_format(ld, arg, arg, arg); break; case KEY_PIE: ld->ld_exec = 0; ld->ld_pie = 1; ld->ld_dynamic_link = 1; break; case KEY_PRINT_GC_SECTIONS: ld->ld_gc_print = 1; break; case KEY_RPATH: ld_path_add_multiple(ld, arg, LPT_RPATH); break; case KEY_RPATH_LINK: ld_path_add_multiple(ld, arg, LPT_RPATH_LINK); break; case KEY_SHARED: ld->ld_exec = 0; ld->ld_dso = 1; ld->ld_dynamic_link = 1; break; case KEY_STATIC: ls->ls_static = 1; break; case KEY_WHOLE_ARCHIVE: ls->ls_whole_archive = 1; break; case KEY_FILE: ld_file_add(ld, arg, LFT_UNKNOWN); break; case KEY_VERSION_SCRIPT: ld_script_parse(arg); break; case KEY_Z_EXEC_STACK: ld->ld_gen_gnustack = 1; ld->ld_stack_exec_set = 1; ld->ld_stack_exec = 1; break; case KEY_Z_NO_EXEC_STACK: ld->ld_gen_gnustack = 1; ld->ld_stack_exec_set = 1; ld->ld_stack_exec = 0; break; default: break; } } static void _print_version(struct ld *ld) { (void) printf("%s (%s)\n", ELFTC_GETPROGNAME(), elftc_version()); ld->ld_print_version = 1; } static void _copy_optarg(struct ld *ld, char **dst, char *src) { if (*dst != NULL) free(*dst); if ((*dst = strdup(src)) == NULL) ld_fatal_std(ld, "strdup"); } struct ld_wildcard * ld_wildcard_alloc(struct ld *ld) { struct ld_wildcard *lw; if ((lw = calloc(1, sizeof(*lw))) == NULL) ld_fatal_std(ld, "calloc"); return (lw); } void ld_wildcard_free(void *ptr) { struct ld_wildcard *lw; lw = ptr; if (lw == NULL) return; free(lw->lw_name); free(lw); } Index: vendor/elftoolchain/dist/ld/ld_options.h =================================================================== --- vendor/elftoolchain/dist/ld/ld_options.h (revision 300227) +++ vendor/elftoolchain/dist/ld/ld_options.h (revision 300228) @@ -1,161 +1,161 @@ /*- * Copyright (c) 2010-2013 Kai Wang * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: ld_options.h 2894 2013-01-15 23:05:24Z kaiwang27 $ + * $Id: ld_options.h 3405 2016-02-14 10:56:34Z jkoshy $ */ enum ld_dash { ONE_DASH, TWO_DASH, ANY_DASH }; enum ld_arg { NO_ARG, REQ_ARG, OPT_ARG }; enum ld_key { KEY_ACCEPT_UNKNOWN = 0x10000, KEY_ALLOW_SHLIB_UNDEF, KEY_ASSERT, KEY_AS_NEEDED, KEY_BUILD_ID, KEY_CHECK_SECTIONS, KEY_CREF, KEY_DEFSYM, KEY_DEMANGLE, KEY_DISABLE_NEW_DTAGS, KEY_DYNAMIC, KEY_EB, KEY_EL, KEY_EH_FRAME_HDR, KEY_ENABLE_NEW_DTAGS, KEY_ERR_UNRESOLVE_SYM, KEY_FATAL_WARNINGS, KEY_FINI, KEY_GC_SECTIONS, KEY_GROUP, KEY_HASH_STYLE, KEY_HELP, KEY_INIT, KEY_MAP, KEY_NO_AS_NEEDED, KEY_NO_CHECK_SECTIONS, KEY_NO_DEFINE_COMMON, KEY_NO_DEMANGLE, KEY_NO_GC_SECTIONS, KEY_NO_KEEP_MEMORY, KEY_NO_OMAGIC, KEY_NO_PRINT_GC_SECTIONS, KEY_NO_SHLIB_UNDEF, KEY_NO_STDLIB, KEY_NO_UNDEF_VERSION, KEY_NO_UNKNOWN, KEY_NO_WHOLE_ARCHIVE, KEY_NO_WARN_MISMATCH, KEY_RPATH, KEY_RPATH_LINK, KEY_RUNPATH, KEY_SECTION_START, KEY_OFORMAT, KEY_PIE, KEY_PRINT_GC_SECTIONS, KEY_QMAGIC, KEY_QY, KEY_RELAX, KEY_RETAIN_SYM_FILE, KEY_SHARED, KEY_SORT_COMMON, KEY_SPLIT_BY_FILE, KEY_SPLIT_BY_RELOC, KEY_STATIC, KEY_STATS, KEY_SYMBOLIC, KEY_SYMBOLIC_FUNC, KEY_TBSS, KEY_TDATA, KEY_TTEXT, KEY_TRADITIONAL_FORMAT, KEY_UNRESOLVED_SYMBOLS, KEY_UNIQUE, KEY_UR, - KEY_VERSION, + KEY_VERBOSE, KEY_VERSION_SCRIPT, KEY_WARN_COMMON, KEY_WARN_CONSTRUCTORS, KEY_WARN_MULTIPLE_GP, KEY_WARN_ONCE, KEY_WARN_SECTION_ALIGN, KEY_WARN_SHARED_TEXTREL, KEY_WARN_UNRESOLVE_SYM, KEY_WHOLE_ARCHIVE, KEY_WRAP, KEY_Z_DEFAULT_EXTRACT, KEY_Z_DEFS, KEY_Z_EXEC_STACK, KEY_Z_IGNORE, KEY_Z_INIT_FIRST, KEY_Z_LAZYLOAD, KEY_Z_MULDEFS, KEY_Z_NOW, KEY_Z_NO_DEFAULT_LIB, KEY_Z_NO_DEFS, KEY_Z_NO_DELETE, KEY_Z_NO_DLOPEN, KEY_Z_NO_EXEC_STACK, KEY_Z_NO_LAZYLOAD, KEY_Z_ORIGIN, KEY_Z_RECORD, KEY_Z_SYSTEM_LIBRARY, KEY_Z_WEAK_EXTRACT, KEY_FILE = 0x10000000, }; struct ld_option { const char *lo_long; int lo_key; enum ld_dash lo_dash; enum ld_arg lo_arg; }; enum ld_wildcard_sort { LWS_NONE, LWS_NAME, LWS_ALIGN, LWS_NAME_ALIGN, LWS_ALIGN_NAME, }; struct ld_wildcard { char *lw_name; /* wildcard */ enum ld_wildcard_sort lw_sort; /* sort mode */ }; void ld_options_parse(struct ld*, int, char **); struct ld_wildcard *ld_wildcard_alloc(struct ld *); void ld_wildcard_free(void *); Index: vendor/elftoolchain/dist/libdwarf/libdwarf_abbrev.c =================================================================== --- vendor/elftoolchain/dist/libdwarf/libdwarf_abbrev.c (revision 300227) +++ vendor/elftoolchain/dist/libdwarf/libdwarf_abbrev.c (revision 300228) @@ -1,268 +1,266 @@ /*- * Copyright (c) 2007 John Birrell (jb@freebsd.org) * Copyright (c) 2009-2011 Kai Wang * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include "_libdwarf.h" -ELFTC_VCSID("$Id: libdwarf_abbrev.c 3136 2014-12-24 16:04:38Z kaiwang27 $"); +ELFTC_VCSID("$Id: libdwarf_abbrev.c 3420 2016-02-27 02:14:05Z emaste $"); int _dwarf_abbrev_add(Dwarf_CU cu, uint64_t entry, uint64_t tag, uint8_t children, uint64_t aboff, Dwarf_Abbrev *abp, Dwarf_Error *error) { Dwarf_Abbrev ab; Dwarf_Debug dbg; dbg = cu != NULL ? cu->cu_dbg : NULL; if ((ab = malloc(sizeof(struct _Dwarf_Abbrev))) == NULL) { DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY); return (DW_DLE_MEMORY); } /* Initialise the abbrev structure. */ ab->ab_entry = entry; ab->ab_tag = tag; ab->ab_children = children; ab->ab_offset = aboff; ab->ab_length = 0; /* fill in later. */ ab->ab_atnum = 0; /* fill in later. */ /* Initialise the list of attribute definitions. */ STAILQ_INIT(&ab->ab_attrdef); /* Add the abbrev to the hash table of the compilation unit. */ if (cu != NULL) HASH_ADD(ab_hh, cu->cu_abbrev_hash, ab_entry, sizeof(ab->ab_entry), ab); if (abp != NULL) *abp = ab; return (DW_DLE_NONE); } int _dwarf_attrdef_add(Dwarf_Debug dbg, Dwarf_Abbrev ab, uint64_t attr, uint64_t form, uint64_t adoff, Dwarf_AttrDef *adp, Dwarf_Error *error) { Dwarf_AttrDef ad; if (ab == NULL) { DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT); return (DW_DLE_ARGUMENT); } if ((ad = malloc(sizeof(struct _Dwarf_AttrDef))) == NULL) { DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY); return (DW_DLE_MEMORY); } /* Initialise the attribute definition structure. */ ad->ad_attrib = attr; ad->ad_form = form; ad->ad_offset = adoff; /* Add the attribute definition to the list in the abbrev. */ STAILQ_INSERT_TAIL(&ab->ab_attrdef, ad, ad_next); /* Increase number of attribute counter. */ ab->ab_atnum++; if (adp != NULL) *adp = ad; return (DW_DLE_NONE); } int _dwarf_abbrev_parse(Dwarf_Debug dbg, Dwarf_CU cu, Dwarf_Unsigned *offset, Dwarf_Abbrev *abp, Dwarf_Error *error) { Dwarf_Section *ds; uint64_t attr; uint64_t entry; uint64_t form; uint64_t aboff; uint64_t adoff; uint64_t tag; uint8_t children; int ret; assert(abp != NULL); ds = _dwarf_find_section(dbg, ".debug_abbrev"); - assert(ds != NULL); - - if (*offset >= ds->ds_size) + if (ds == NULL || *offset >= ds->ds_size) return (DW_DLE_NO_ENTRY); aboff = *offset; entry = _dwarf_read_uleb128(ds->ds_data, offset); if (entry == 0) { /* Last entry. */ ret = _dwarf_abbrev_add(cu, entry, 0, 0, aboff, abp, error); if (ret == DW_DLE_NONE) { (*abp)->ab_length = 1; return (ret); } else return (ret); } tag = _dwarf_read_uleb128(ds->ds_data, offset); children = dbg->read(ds->ds_data, offset, 1); if ((ret = _dwarf_abbrev_add(cu, entry, tag, children, aboff, abp, error)) != DW_DLE_NONE) return (ret); /* Parse attribute definitions. */ do { adoff = *offset; attr = _dwarf_read_uleb128(ds->ds_data, offset); form = _dwarf_read_uleb128(ds->ds_data, offset); if (attr != 0) if ((ret = _dwarf_attrdef_add(dbg, *abp, attr, form, adoff, NULL, error)) != DW_DLE_NONE) return (ret); } while (attr != 0); (*abp)->ab_length = *offset - aboff; return (ret); } int _dwarf_abbrev_find(Dwarf_CU cu, uint64_t entry, Dwarf_Abbrev *abp, Dwarf_Error *error) { Dwarf_Abbrev ab; Dwarf_Section *ds; Dwarf_Unsigned offset; int ret; if (entry == 0) return (DW_DLE_NO_ENTRY); /* Check if the desired abbrev entry is already in the hash table. */ HASH_FIND(ab_hh, cu->cu_abbrev_hash, &entry, sizeof(entry), ab); if (ab != NULL) { *abp = ab; return (DW_DLE_NONE); } if (cu->cu_abbrev_loaded) { return (DW_DLE_NO_ENTRY); } /* Load and search the abbrev table. */ ds = _dwarf_find_section(cu->cu_dbg, ".debug_abbrev"); if (ds == NULL) return (DW_DLE_NO_ENTRY); offset = cu->cu_abbrev_offset_cur; while (offset < ds->ds_size) { ret = _dwarf_abbrev_parse(cu->cu_dbg, cu, &offset, &ab, error); if (ret != DW_DLE_NONE) return (ret); if (ab->ab_entry == entry) { cu->cu_abbrev_offset_cur = offset; *abp = ab; return (DW_DLE_NONE); } if (ab->ab_entry == 0) { cu->cu_abbrev_offset_cur = offset; cu->cu_abbrev_loaded = 1; break; } } return (DW_DLE_NO_ENTRY); } void _dwarf_abbrev_cleanup(Dwarf_CU cu) { Dwarf_Abbrev ab, tab; Dwarf_AttrDef ad, tad; assert(cu != NULL); HASH_ITER(ab_hh, cu->cu_abbrev_hash, ab, tab) { HASH_DELETE(ab_hh, cu->cu_abbrev_hash, ab); STAILQ_FOREACH_SAFE(ad, &ab->ab_attrdef, ad_next, tad) { STAILQ_REMOVE(&ab->ab_attrdef, ad, _Dwarf_AttrDef, ad_next); free(ad); } free(ab); } } int _dwarf_abbrev_gen(Dwarf_P_Debug dbg, Dwarf_Error *error) { Dwarf_CU cu; Dwarf_Abbrev ab; Dwarf_AttrDef ad; Dwarf_P_Section ds; int ret; cu = STAILQ_FIRST(&dbg->dbg_cu); if (cu == NULL) return (DW_DLE_NONE); /* Create .debug_abbrev section. */ if ((ret = _dwarf_section_init(dbg, &ds, ".debug_abbrev", 0, error)) != DW_DLE_NONE) return (ret); for (ab = cu->cu_abbrev_hash; ab != NULL; ab = ab->ab_hh.next) { RCHECK(WRITE_ULEB128(ab->ab_entry)); RCHECK(WRITE_ULEB128(ab->ab_tag)); RCHECK(WRITE_VALUE(ab->ab_children, 1)); STAILQ_FOREACH(ad, &ab->ab_attrdef, ad_next) { RCHECK(WRITE_ULEB128(ad->ad_attrib)); RCHECK(WRITE_ULEB128(ad->ad_form)); } /* Signal end of attribute spec list. */ RCHECK(WRITE_ULEB128(0)); RCHECK(WRITE_ULEB128(0)); } /* End of abbreviation for this CU. */ RCHECK(WRITE_ULEB128(0)); /* Notify the creation of .debug_abbrev ELF section. */ RCHECK(_dwarf_section_callback(dbg, ds, SHT_PROGBITS, 0, 0, 0, error)); return (DW_DLE_NONE); gen_fail: _dwarf_section_free(dbg, &ds); return (ret); } Index: vendor/elftoolchain/dist/libdwarf/libdwarf_elf_init.c =================================================================== --- vendor/elftoolchain/dist/libdwarf/libdwarf_elf_init.c (revision 300227) +++ vendor/elftoolchain/dist/libdwarf/libdwarf_elf_init.c (revision 300228) @@ -1,353 +1,390 @@ /*- * Copyright (c) 2009 Kai Wang * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include "_libdwarf.h" -ELFTC_VCSID("$Id: libdwarf_elf_init.c 3161 2015-02-15 21:43:36Z emaste $"); +ELFTC_VCSID("$Id: libdwarf_elf_init.c 3475 2016-05-18 18:11:26Z emaste $"); static const char *debug_name[] = { ".debug_abbrev", ".debug_aranges", ".debug_frame", ".debug_info", ".debug_types", ".debug_line", ".debug_pubnames", ".eh_frame", ".debug_macinfo", ".debug_str", ".debug_loc", ".debug_pubtypes", ".debug_ranges", ".debug_static_func", ".debug_static_vars", ".debug_typenames", ".debug_weaknames", NULL }; static void -_dwarf_elf_write_reloc(Dwarf_Debug dbg, Elf_Data *symtab_data, int endian, - void *buf, uint64_t offset, GElf_Xword r_info, GElf_Sxword r_addend) +_dwarf_elf_apply_rel_reloc(Dwarf_Debug dbg, void *buf, uint64_t bufsize, + Elf_Data *rel_data, Elf_Data *symtab_data, int endian) { + Dwarf_Unsigned type; + GElf_Rel rel; GElf_Sym sym; - int size; + size_t symndx; + uint64_t offset; + uint64_t addend; + int size, j; - if (gelf_getsym(symtab_data, GELF_R_SYM(r_info), &sym) == NULL) - return; - if ((size = _dwarf_get_reloc_size(dbg, GELF_R_TYPE(r_info))) == 0) - return; /* Unknown or non-absolute relocation. */ - if (endian == ELFDATA2MSB) - _dwarf_write_msb(buf, &offset, sym.st_value + r_addend, size); - else - _dwarf_write_lsb(buf, &offset, sym.st_value + r_addend, size); -} + j = 0; + while (gelf_getrel(rel_data, j++, &rel) != NULL) { + symndx = GELF_R_SYM(rel.r_info); + type = GELF_R_TYPE(rel.r_info); -static void -_dwarf_elf_apply_rel_reloc(Dwarf_Debug dbg, void *buf, Elf_Data *rel_data, - Elf_Data *symtab_data, int endian) -{ - GElf_Rel rel; - int j; + if (gelf_getsym(symtab_data, symndx, &sym) == NULL) + continue; - j = 0; - while (gelf_getrel(rel_data, j++, &rel) != NULL) - _dwarf_elf_write_reloc(dbg, symtab_data, endian, buf, - rel.r_offset, rel.r_info, 0); + size = _dwarf_get_reloc_size(dbg, type); + if (size == 0) + continue; /* Unknown or non-absolute relocation. */ + + offset = rel.r_offset; + if (offset + size >= bufsize) + continue; + + if (endian == ELFDATA2MSB) + addend = _dwarf_read_msb(buf, &offset, size); + else + addend = _dwarf_read_lsb(buf, &offset, size); + + offset = rel.r_offset; + if (endian == ELFDATA2MSB) + _dwarf_write_msb(buf, &offset, sym.st_value + addend, + size); + else + _dwarf_write_lsb(buf, &offset, sym.st_value + addend, + size); + } } static void -_dwarf_elf_apply_rela_reloc(Dwarf_Debug dbg, void *buf, Elf_Data *rel_data, - Elf_Data *symtab_data, int endian) +_dwarf_elf_apply_rela_reloc(Dwarf_Debug dbg, void *buf, uint64_t bufsize, + Elf_Data *rel_data, Elf_Data *symtab_data, int endian) { + Dwarf_Unsigned type; GElf_Rela rela; - int j; + GElf_Sym sym; + size_t symndx; + uint64_t offset; + int size, j; j = 0; - while (gelf_getrela(rel_data, j++, &rela) != NULL) - _dwarf_elf_write_reloc(dbg, symtab_data, endian, buf, - rela.r_offset, rela.r_info, rela.r_addend); + while (gelf_getrela(rel_data, j++, &rela) != NULL) { + symndx = GELF_R_SYM(rela.r_info); + type = GELF_R_TYPE(rela.r_info); + + if (gelf_getsym(symtab_data, symndx, &sym) == NULL) + continue; + + offset = rela.r_offset; + size = _dwarf_get_reloc_size(dbg, type); + if (size == 0) + continue; /* Unknown or non-absolute relocation. */ + if (offset + size >= bufsize) + continue; + + if (endian == ELFDATA2MSB) + _dwarf_write_msb(buf, &offset, + sym.st_value + rela.r_addend, size); + else + _dwarf_write_lsb(buf, &offset, + sym.st_value + rela.r_addend, size); + } } static int _dwarf_elf_relocate(Dwarf_Debug dbg, Elf *elf, Dwarf_Elf_Data *ed, size_t shndx, size_t symtab, Elf_Data *symtab_data, Dwarf_Error *error) { GElf_Ehdr eh; GElf_Shdr sh; Elf_Scn *scn; Elf_Data *rel; int elferr; if (symtab == 0 || symtab_data == NULL) return (DW_DLE_NONE); if (gelf_getehdr(elf, &eh) == NULL) { DWARF_SET_ELF_ERROR(dbg, error); return (DW_DLE_ELF); } scn = NULL; (void) elf_errno(); while ((scn = elf_nextscn(elf, scn)) != NULL) { if (gelf_getshdr(scn, &sh) == NULL) { DWARF_SET_ELF_ERROR(dbg, error); return (DW_DLE_ELF); } if ((sh.sh_type != SHT_REL && sh.sh_type != SHT_RELA) || sh.sh_size == 0) continue; if (sh.sh_info == shndx && sh.sh_link == symtab) { if ((rel = elf_getdata(scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) { _DWARF_SET_ERROR(NULL, error, DW_DLE_ELF, elferr); return (DW_DLE_ELF); } else return (DW_DLE_NONE); } ed->ed_alloc = malloc(ed->ed_data->d_size); if (ed->ed_alloc == NULL) { DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY); return (DW_DLE_MEMORY); } memcpy(ed->ed_alloc, ed->ed_data->d_buf, ed->ed_data->d_size); if (sh.sh_type == SHT_REL) - _dwarf_elf_apply_rel_reloc(dbg, ed->ed_alloc, + _dwarf_elf_apply_rel_reloc(dbg, + ed->ed_alloc, ed->ed_data->d_size, rel, symtab_data, eh.e_ident[EI_DATA]); else - _dwarf_elf_apply_rela_reloc(dbg, ed->ed_alloc, + _dwarf_elf_apply_rela_reloc(dbg, + ed->ed_alloc, ed->ed_data->d_size, rel, symtab_data, eh.e_ident[EI_DATA]); return (DW_DLE_NONE); } } elferr = elf_errno(); if (elferr != 0) { DWARF_SET_ELF_ERROR(dbg, error); return (DW_DLE_ELF); } return (DW_DLE_NONE); } int _dwarf_elf_init(Dwarf_Debug dbg, Elf *elf, Dwarf_Error *error) { Dwarf_Obj_Access_Interface *iface; Dwarf_Elf_Object *e; const char *name; GElf_Shdr sh; Elf_Scn *scn; Elf_Data *symtab_data; size_t symtab_ndx; int elferr, i, j, n, ret; ret = DW_DLE_NONE; if ((iface = calloc(1, sizeof(*iface))) == NULL) { DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY); return (DW_DLE_MEMORY); } if ((e = calloc(1, sizeof(*e))) == NULL) { free(iface); DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY); return (DW_DLE_MEMORY); } e->eo_elf = elf; e->eo_methods.get_section_info = _dwarf_elf_get_section_info; e->eo_methods.get_byte_order = _dwarf_elf_get_byte_order; e->eo_methods.get_length_size = _dwarf_elf_get_length_size; e->eo_methods.get_pointer_size = _dwarf_elf_get_pointer_size; e->eo_methods.get_section_count = _dwarf_elf_get_section_count; e->eo_methods.load_section = _dwarf_elf_load_section; iface->object = e; iface->methods = &e->eo_methods; dbg->dbg_iface = iface; if (gelf_getehdr(elf, &e->eo_ehdr) == NULL) { DWARF_SET_ELF_ERROR(dbg, error); ret = DW_DLE_ELF; goto fail_cleanup; } dbg->dbg_machine = e->eo_ehdr.e_machine; if (!elf_getshstrndx(elf, &e->eo_strndx)) { DWARF_SET_ELF_ERROR(dbg, error); ret = DW_DLE_ELF; goto fail_cleanup; } n = 0; symtab_ndx = 0; symtab_data = NULL; scn = NULL; (void) elf_errno(); while ((scn = elf_nextscn(elf, scn)) != NULL) { if (gelf_getshdr(scn, &sh) == NULL) { DWARF_SET_ELF_ERROR(dbg, error); ret = DW_DLE_ELF; goto fail_cleanup; } if ((name = elf_strptr(elf, e->eo_strndx, sh.sh_name)) == NULL) { DWARF_SET_ELF_ERROR(dbg, error); ret = DW_DLE_ELF; goto fail_cleanup; } if (!strcmp(name, ".symtab")) { symtab_ndx = elf_ndxscn(scn); if ((symtab_data = elf_getdata(scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) { _DWARF_SET_ERROR(NULL, error, DW_DLE_ELF, elferr); ret = DW_DLE_ELF; goto fail_cleanup; } } continue; } for (i = 0; debug_name[i] != NULL; i++) { if (!strcmp(name, debug_name[i])) n++; } } elferr = elf_errno(); if (elferr != 0) { DWARF_SET_ELF_ERROR(dbg, error); return (DW_DLE_ELF); } e->eo_seccnt = n; if (n == 0) return (DW_DLE_NONE); if ((e->eo_data = calloc(n, sizeof(Dwarf_Elf_Data))) == NULL || (e->eo_shdr = calloc(n, sizeof(GElf_Shdr))) == NULL) { DWARF_SET_ERROR(NULL, error, DW_DLE_MEMORY); ret = DW_DLE_MEMORY; goto fail_cleanup; } scn = NULL; j = 0; while ((scn = elf_nextscn(elf, scn)) != NULL && j < n) { if (gelf_getshdr(scn, &sh) == NULL) { DWARF_SET_ELF_ERROR(dbg, error); ret = DW_DLE_ELF; goto fail_cleanup; } memcpy(&e->eo_shdr[j], &sh, sizeof(sh)); if ((name = elf_strptr(elf, e->eo_strndx, sh.sh_name)) == NULL) { DWARF_SET_ELF_ERROR(dbg, error); ret = DW_DLE_ELF; goto fail_cleanup; } for (i = 0; debug_name[i] != NULL; i++) { if (strcmp(name, debug_name[i])) continue; (void) elf_errno(); if ((e->eo_data[j].ed_data = elf_getdata(scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) { _DWARF_SET_ERROR(dbg, error, DW_DLE_ELF, elferr); ret = DW_DLE_ELF; goto fail_cleanup; } } if (_libdwarf.applyreloc) { if (_dwarf_elf_relocate(dbg, elf, &e->eo_data[j], elf_ndxscn(scn), symtab_ndx, symtab_data, error) != DW_DLE_NONE) goto fail_cleanup; } j++; } } assert(j == n); return (DW_DLE_NONE); fail_cleanup: _dwarf_elf_deinit(dbg); return (ret); } void _dwarf_elf_deinit(Dwarf_Debug dbg) { Dwarf_Obj_Access_Interface *iface; Dwarf_Elf_Object *e; int i; iface = dbg->dbg_iface; assert(iface != NULL); e = iface->object; assert(e != NULL); if (e->eo_data) { for (i = 0; (Dwarf_Unsigned) i < e->eo_seccnt; i++) { if (e->eo_data[i].ed_alloc) free(e->eo_data[i].ed_alloc); } free(e->eo_data); } if (e->eo_shdr) free(e->eo_shdr); free(e); free(iface); dbg->dbg_iface = NULL; } Index: vendor/elftoolchain/dist/libelf/_libelf_config.h =================================================================== --- vendor/elftoolchain/dist/libelf/_libelf_config.h (revision 300227) +++ vendor/elftoolchain/dist/libelf/_libelf_config.h (revision 300228) @@ -1,189 +1,189 @@ /*- * Copyright (c) 2008-2011 Joseph Koshy * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: _libelf_config.h 3396 2016-02-10 21:50:05Z emaste $ + * $Id: _libelf_config.h 3400 2016-02-12 18:38:49Z emaste $ */ #if defined(__APPLE__) || defined(__DragonFly__) #if defined(__amd64__) #define LIBELF_ARCH EM_X86_64 #define LIBELF_BYTEORDER ELFDATA2LSB #define LIBELF_CLASS ELFCLASS64 #elif defined(__i386__) #define LIBELF_ARCH EM_386 #define LIBELF_BYTEORDER ELFDATA2LSB #define LIBELF_CLASS ELFCLASS32 #endif #endif /* __DragonFly__ */ #ifdef __FreeBSD__ /* * Define LIBELF_{ARCH,BYTEORDER,CLASS} based on the machine architecture. * See also: . */ #if defined(__amd64__) #define LIBELF_ARCH EM_X86_64 #define LIBELF_BYTEORDER ELFDATA2LSB #define LIBELF_CLASS ELFCLASS64 #elif defined(__aarch64__) #define LIBELF_ARCH EM_AARCH64 #define LIBELF_BYTEORDER ELFDATA2LSB #define LIBELF_CLASS ELFCLASS64 #elif defined(__arm__) #define LIBELF_ARCH EM_ARM #if defined(__ARMEB__) /* Big-endian ARM. */ #define LIBELF_BYTEORDER ELFDATA2MSB #else #define LIBELF_BYTEORDER ELFDATA2LSB #endif #define LIBELF_CLASS ELFCLASS32 #elif defined(__i386__) #define LIBELF_ARCH EM_386 #define LIBELF_BYTEORDER ELFDATA2LSB #define LIBELF_CLASS ELFCLASS32 #elif defined(__ia64__) #define LIBELF_ARCH EM_IA_64 #define LIBELF_BYTEORDER ELFDATA2LSB #define LIBELF_CLASS ELFCLASS64 #elif defined(__mips__) #define LIBELF_ARCH EM_MIPS #if defined(__MIPSEB__) #define LIBELF_BYTEORDER ELFDATA2MSB #else #define LIBELF_BYTEORDER ELFDATA2LSB #endif #define LIBELF_CLASS ELFCLASS32 #elif defined(__powerpc__) #define LIBELF_ARCH EM_PPC #define LIBELF_BYTEORDER ELFDATA2MSB #define LIBELF_CLASS ELFCLASS32 #elif defined(__riscv64) -#define LIBELF_ARCH EM_RISCV -#define LIBELF_BYTEORDER ELFDATA2LSB -#define LIBELF_CLASS ELFCLASS64 +#define LIBELF_ARCH EM_RISCV +#define LIBELF_BYTEORDER ELFDATA2LSB +#define LIBELF_CLASS ELFCLASS64 #elif defined(__sparc__) #define LIBELF_ARCH EM_SPARCV9 #define LIBELF_BYTEORDER ELFDATA2MSB #define LIBELF_CLASS ELFCLASS64 #else #error Unknown FreeBSD architecture. #endif #endif /* __FreeBSD__ */ /* * Definitions for Minix3. */ #ifdef __minix #define LIBELF_ARCH EM_386 #define LIBELF_BYTEORDER ELFDATA2LSB #define LIBELF_CLASS ELFCLASS32 #endif /* __minix */ #ifdef __NetBSD__ #include #if !defined(ARCH_ELFSIZE) #error ARCH_ELFSIZE is not defined. #endif #if ARCH_ELFSIZE == 32 #define LIBELF_ARCH ELF32_MACHDEP_ID #define LIBELF_BYTEORDER ELF32_MACHDEP_ENDIANNESS #define LIBELF_CLASS ELFCLASS32 #define Elf_Note Elf32_Nhdr #else #define LIBELF_ARCH ELF64_MACHDEP_ID #define LIBELF_BYTEORDER ELF64_MACHDEP_ENDIANNESS #define LIBELF_CLASS ELFCLASS64 #define Elf_Note Elf64_Nhdr #endif #endif /* __NetBSD__ */ #if defined(__OpenBSD__) #include #define LIBELF_ARCH ELF_TARG_MACH #define LIBELF_BYTEORDER ELF_TARG_DATA #define LIBELF_CLASS ELF_TARG_CLASS #endif /* * GNU & Linux compatibility. * * `__linux__' is defined in an environment runs the Linux kernel and glibc. * `__GNU__' is defined in an environment runs a GNU kernel (Hurd) and glibc. * `__GLIBC__' is defined for an environment that runs glibc over a non-GNU * kernel such as GNU/kFreeBSD. */ #if defined(__linux__) || defined(__GNU__) || defined(__GLIBC__) #if defined(__linux__) #include "native-elf-format.h" #define LIBELF_CLASS ELFTC_CLASS #define LIBELF_ARCH ELFTC_ARCH #define LIBELF_BYTEORDER ELFTC_BYTEORDER #endif /* defined(__linux__) */ #if LIBELF_CLASS == ELFCLASS32 #define Elf_Note Elf32_Nhdr #elif LIBELF_CLASS == ELFCLASS64 #define Elf_Note Elf64_Nhdr #else #error LIBELF_CLASS needs to be one of ELFCLASS32 or ELFCLASS64 #endif #endif /* defined(__linux__) || defined(__GNU__) || defined(__GLIBC__) */ Index: vendor/elftoolchain/dist/libelf/elf_data.c =================================================================== --- vendor/elftoolchain/dist/libelf/elf_data.c (revision 300227) +++ vendor/elftoolchain/dist/libelf/elf_data.c (revision 300228) @@ -1,276 +1,276 @@ /*- * Copyright (c) 2006,2008,2011 Joseph Koshy * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #include #include #include #include #include "_libelf.h" -ELFTC_VCSID("$Id: elf_data.c 3258 2015-11-20 18:59:43Z emaste $"); +ELFTC_VCSID("$Id: elf_data.c 3466 2016-05-11 18:35:44Z emaste $"); Elf_Data * elf_getdata(Elf_Scn *s, Elf_Data *ed) { Elf *e; unsigned int sh_type; int elfclass, elftype; size_t count, fsz, msz; struct _Libelf_Data *d; uint64_t sh_align, sh_offset, sh_size; int (*xlate)(unsigned char *_d, size_t _dsz, unsigned char *_s, size_t _c, int _swap); d = (struct _Libelf_Data *) ed; if (s == NULL || (e = s->s_elf) == NULL || (d != NULL && s != d->d_scn)) { LIBELF_SET_ERROR(ARGUMENT, 0); return (NULL); } assert(e->e_kind == ELF_K_ELF); if (d == NULL && (d = STAILQ_FIRST(&s->s_data)) != NULL) return (&d->d_data); if (d != NULL) return (&STAILQ_NEXT(d, d_next)->d_data); if (e->e_rawfile == NULL) { /* * In the ELF_C_WRITE case, there is no source that * can provide data for the section. */ LIBELF_SET_ERROR(ARGUMENT, 0); return (NULL); } elfclass = e->e_class; assert(elfclass == ELFCLASS32 || elfclass == ELFCLASS64); if (elfclass == ELFCLASS32) { sh_type = s->s_shdr.s_shdr32.sh_type; sh_offset = (uint64_t) s->s_shdr.s_shdr32.sh_offset; sh_size = (uint64_t) s->s_shdr.s_shdr32.sh_size; sh_align = (uint64_t) s->s_shdr.s_shdr32.sh_addralign; } else { sh_type = s->s_shdr.s_shdr64.sh_type; sh_offset = s->s_shdr.s_shdr64.sh_offset; sh_size = s->s_shdr.s_shdr64.sh_size; sh_align = s->s_shdr.s_shdr64.sh_addralign; } if (sh_type == SHT_NULL) { LIBELF_SET_ERROR(SECTION, 0); return (NULL); } if ((elftype = _libelf_xlate_shtype(sh_type)) < ELF_T_FIRST || elftype > ELF_T_LAST || (sh_type != SHT_NOBITS && - sh_offset + sh_size > (uint64_t) e->e_rawsize)) { + (sh_offset > e->e_rawsize || sh_size > e->e_rawsize - sh_offset))) { LIBELF_SET_ERROR(SECTION, 0); return (NULL); } if ((fsz = (elfclass == ELFCLASS32 ? elf32_fsize : elf64_fsize) (elftype, (size_t) 1, e->e_version)) == 0) { LIBELF_SET_ERROR(UNIMPL, 0); return (NULL); } if (sh_size % fsz) { LIBELF_SET_ERROR(SECTION, 0); return (NULL); } if (sh_size / fsz > SIZE_MAX) { LIBELF_SET_ERROR(RANGE, 0); return (NULL); } count = (size_t) (sh_size / fsz); msz = _libelf_msize(elftype, elfclass, e->e_version); if (count > 0 && msz > SIZE_MAX / count) { LIBELF_SET_ERROR(RANGE, 0); return (NULL); } assert(msz > 0); assert(count <= SIZE_MAX); assert(msz * count <= SIZE_MAX); if ((d = _libelf_allocate_data(s)) == NULL) return (NULL); d->d_data.d_buf = NULL; d->d_data.d_off = 0; d->d_data.d_align = sh_align; d->d_data.d_size = msz * count; d->d_data.d_type = elftype; d->d_data.d_version = e->e_version; if (sh_type == SHT_NOBITS || sh_size == 0) { STAILQ_INSERT_TAIL(&s->s_data, d, d_next); return (&d->d_data); } if ((d->d_data.d_buf = malloc(msz * count)) == NULL) { (void) _libelf_release_data(d); LIBELF_SET_ERROR(RESOURCE, 0); return (NULL); } d->d_flags |= LIBELF_F_DATA_MALLOCED; xlate = _libelf_get_translator(elftype, ELF_TOMEMORY, elfclass); if (!(*xlate)(d->d_data.d_buf, (size_t) d->d_data.d_size, e->e_rawfile + sh_offset, count, e->e_byteorder != LIBELF_PRIVATE(byteorder))) { _libelf_release_data(d); LIBELF_SET_ERROR(DATA, 0); return (NULL); } STAILQ_INSERT_TAIL(&s->s_data, d, d_next); return (&d->d_data); } Elf_Data * elf_newdata(Elf_Scn *s) { Elf *e; struct _Libelf_Data *d; if (s == NULL || (e = s->s_elf) == NULL) { LIBELF_SET_ERROR(ARGUMENT, 0); return (NULL); } assert(e->e_kind == ELF_K_ELF); /* * elf_newdata() has to append a data descriptor, so * bring in existing section data if not already present. */ if (e->e_rawfile && s->s_size > 0 && STAILQ_EMPTY(&s->s_data)) if (elf_getdata(s, NULL) == NULL) return (NULL); if ((d = _libelf_allocate_data(s)) == NULL) return (NULL); STAILQ_INSERT_TAIL(&s->s_data, d, d_next); d->d_data.d_align = 1; d->d_data.d_buf = NULL; d->d_data.d_off = (uint64_t) ~0; d->d_data.d_size = 0; d->d_data.d_type = ELF_T_BYTE; d->d_data.d_version = LIBELF_PRIVATE(version); (void) elf_flagscn(s, ELF_C_SET, ELF_F_DIRTY); return (&d->d_data); } /* * Retrieve a data descriptor for raw (untranslated) data for section * `s'. */ Elf_Data * elf_rawdata(Elf_Scn *s, Elf_Data *ed) { Elf *e; int elf_class; uint32_t sh_type; struct _Libelf_Data *d; uint64_t sh_align, sh_offset, sh_size; if (s == NULL || (e = s->s_elf) == NULL || e->e_rawfile == NULL) { LIBELF_SET_ERROR(ARGUMENT, 0); return (NULL); } assert(e->e_kind == ELF_K_ELF); d = (struct _Libelf_Data *) ed; if (d == NULL && (d = STAILQ_FIRST(&s->s_rawdata)) != NULL) return (&d->d_data); if (d != NULL) return (&STAILQ_NEXT(d, d_next)->d_data); elf_class = e->e_class; assert(elf_class == ELFCLASS32 || elf_class == ELFCLASS64); if (elf_class == ELFCLASS32) { sh_type = s->s_shdr.s_shdr32.sh_type; sh_offset = (uint64_t) s->s_shdr.s_shdr32.sh_offset; sh_size = (uint64_t) s->s_shdr.s_shdr32.sh_size; sh_align = (uint64_t) s->s_shdr.s_shdr32.sh_addralign; } else { sh_type = s->s_shdr.s_shdr64.sh_type; sh_offset = s->s_shdr.s_shdr64.sh_offset; sh_size = s->s_shdr.s_shdr64.sh_size; sh_align = s->s_shdr.s_shdr64.sh_addralign; } if (sh_type == SHT_NULL) { LIBELF_SET_ERROR(SECTION, 0); return (NULL); } if (sh_type != SHT_NOBITS && - sh_offset + sh_size > (uint64_t) e->e_rawsize) { + (sh_offset > e->e_rawsize || sh_size > e->e_rawsize - sh_offset)) { LIBELF_SET_ERROR(SECTION, 0); return (NULL); } if ((d = _libelf_allocate_data(s)) == NULL) return (NULL); d->d_data.d_buf = (sh_type == SHT_NOBITS || sh_size == 0) ? NULL : e->e_rawfile + sh_offset; d->d_data.d_off = 0; d->d_data.d_align = sh_align; d->d_data.d_size = sh_size; d->d_data.d_type = ELF_T_BYTE; d->d_data.d_version = e->e_version; STAILQ_INSERT_TAIL(&s->s_rawdata, d, d_next); return (&d->d_data); } Index: vendor/elftoolchain/dist/libelf/libelf_ar.c =================================================================== --- vendor/elftoolchain/dist/libelf/libelf_ar.c (revision 300227) +++ vendor/elftoolchain/dist/libelf/libelf_ar.c (revision 300228) @@ -1,466 +1,466 @@ /*- * Copyright (c) 2006,2008,2010 Joseph Koshy * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS `AS IS' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #include #include #include #include #include "_libelf.h" #include "_libelf_ar.h" -ELFTC_VCSID("$Id: libelf_ar.c 3174 2015-03-27 17:13:41Z emaste $"); +ELFTC_VCSID("$Id: libelf_ar.c 3446 2016-05-03 01:31:17Z emaste $"); #define LIBELF_NALLOC_SIZE 16 /* * `ar' archive handling. * * `ar' archives start with signature `ARMAG'. Each archive member is * preceded by a header containing meta-data for the member. This * header is described in (struct ar_hdr). The header always * starts on an even address. File data is padded with "\n" * characters to keep this invariant. * * Special considerations for `ar' archives: * * There are two variants of the `ar' archive format: traditional BSD * and SVR4. These differ in the way long file names are treated, and * in the layout of the archive symbol table. * * The `ar' header only has space for a 16 character file name. * * In the SVR4 format, file names are terminated with a '/', so this * effectively leaves 15 characters for the actual file name. Longer * file names stored in a separate 'string table' and referenced * indirectly from the name field. The string table itself appears as * an archive member with name "// ". An `indirect' file name in an * `ar' header matches the pattern "/[0-9]*". The digits form a * decimal number that corresponds to a byte offset into the string * table where the actual file name of the object starts. Strings in * the string table are padded to start on even addresses. * - * In the BSD format, file names can be upto 16 characters. File + * In the BSD format, file names can be up to 16 characters. File * names shorter than 16 characters are padded to 16 characters using * (ASCII) space characters. File names with embedded spaces and file * names longer than 16 characters are stored immediately after the * archive header and the name field set to a special indirect name * matching the pattern "#1/[0-9]+". The digits form a decimal number * that corresponds to the actual length of the file name following * the archive header. The content of the archive member immediately * follows the file name, and the size field of the archive member * holds the sum of the sizes of the member and of the appended file * name. * * Archives may also have a symbol table (see ranlib(1)), mapping * program symbols to object files inside the archive. * * In the SVR4 format, a symbol table uses a file name of "/ " in its * archive header. The symbol table is structured as: * - a 4-byte count of entries stored as a binary value, MSB first * - 'n' 4-byte offsets, stored as binary values, MSB first * - 'n' NUL-terminated strings, for ELF symbol names, stored unpadded. * * In the BSD format, the symbol table uses a file name of "__.SYMDEF". * It is structured as two parts: * - The first part is an array of "ranlib" structures preceded by * the size of the array in bytes. Each "ranlib" structure * describes one symbol. Each structure contains an offset into * the string table for the symbol name, and a file offset into the * archive for the member defining the symbol. * - The second part is a string table containing NUL-terminated * strings, preceded by the size of the string table in bytes. * * If the symbol table and string table are is present in an archive * they must be the very first objects and in that order. */ /* * Retrieve an archive header descriptor. */ Elf_Arhdr * _libelf_ar_gethdr(Elf *e) { Elf *parent; Elf_Arhdr *eh; char *namelen; size_t n, nlen; struct ar_hdr *arh; if ((parent = e->e_parent) == NULL) { LIBELF_SET_ERROR(ARGUMENT, 0); return (NULL); } assert((e->e_flags & LIBELF_F_AR_HEADER) == 0); arh = (struct ar_hdr *) (uintptr_t) e->e_hdr.e_rawhdr; assert((uintptr_t) arh >= (uintptr_t) parent->e_rawfile + SARMAG); assert((uintptr_t) arh <= (uintptr_t) parent->e_rawfile + parent->e_rawsize - sizeof(struct ar_hdr)); if ((eh = malloc(sizeof(Elf_Arhdr))) == NULL) { LIBELF_SET_ERROR(RESOURCE, 0); return (NULL); } e->e_hdr.e_arhdr = eh; e->e_flags |= LIBELF_F_AR_HEADER; eh->ar_name = eh->ar_rawname = NULL; if ((eh->ar_name = _libelf_ar_get_translated_name(arh, parent)) == NULL) goto error; if (_libelf_ar_get_number(arh->ar_uid, sizeof(arh->ar_uid), 10, &n) == 0) goto error; eh->ar_uid = (uid_t) n; if (_libelf_ar_get_number(arh->ar_gid, sizeof(arh->ar_gid), 10, &n) == 0) goto error; eh->ar_gid = (gid_t) n; if (_libelf_ar_get_number(arh->ar_mode, sizeof(arh->ar_mode), 8, &n) == 0) goto error; eh->ar_mode = (mode_t) n; if (_libelf_ar_get_number(arh->ar_size, sizeof(arh->ar_size), 10, &n) == 0) goto error; /* * Get the true size of the member if extended naming is being used. */ if (IS_EXTENDED_BSD_NAME(arh->ar_name)) { namelen = arh->ar_name + LIBELF_AR_BSD_EXTENDED_NAME_PREFIX_SIZE; if (_libelf_ar_get_number(namelen, sizeof(arh->ar_name) - LIBELF_AR_BSD_EXTENDED_NAME_PREFIX_SIZE, 10, &nlen) == 0) goto error; n -= nlen; } eh->ar_size = n; if ((eh->ar_rawname = _libelf_ar_get_raw_name(arh)) == NULL) goto error; eh->ar_flags = 0; return (eh); error: if (eh) { if (eh->ar_name) free(eh->ar_name); if (eh->ar_rawname) free(eh->ar_rawname); free(eh); } e->e_flags &= ~LIBELF_F_AR_HEADER; e->e_hdr.e_rawhdr = (unsigned char *) arh; return (NULL); } Elf * _libelf_ar_open_member(int fd, Elf_Cmd c, Elf *elf) { Elf *e; off_t next; size_t nsz, sz; struct ar_hdr *arh; char *member, *namelen; assert(elf->e_kind == ELF_K_AR); next = elf->e_u.e_ar.e_next; /* * `next' is only set to zero by elf_next() when the last * member of an archive is processed. */ if (next == (off_t) 0) return (NULL); assert((next & 1) == 0); arh = (struct ar_hdr *) (elf->e_rawfile + next); /* * Retrieve the size of the member. */ if (_libelf_ar_get_number(arh->ar_size, sizeof(arh->ar_size), 10, &sz) == 0) { LIBELF_SET_ERROR(ARCHIVE, 0); return (NULL); } /* * Adjust the size field for members in BSD archives using * extended naming. */ if (IS_EXTENDED_BSD_NAME(arh->ar_name)) { namelen = arh->ar_name + LIBELF_AR_BSD_EXTENDED_NAME_PREFIX_SIZE; if (_libelf_ar_get_number(namelen, sizeof(arh->ar_name) - LIBELF_AR_BSD_EXTENDED_NAME_PREFIX_SIZE, 10, &nsz) == 0) { LIBELF_SET_ERROR(ARCHIVE, 0); return (NULL); } member = (char *) (arh + 1) + nsz; sz -= nsz; } else member = (char *) (arh + 1); if ((e = elf_memory(member, sz)) == NULL) return (NULL); e->e_fd = fd; e->e_cmd = c; e->e_hdr.e_rawhdr = (unsigned char *) arh; elf->e_u.e_ar.e_nchildren++; e->e_parent = elf; return (e); } /* * A BSD-style ar(1) symbol table has the following layout: * * - A count of bytes used by the following array of 'ranlib' * structures, stored as a 'long'. * - An array of 'ranlib' structures. Each array element is * two 'long's in size. * - A count of bytes used for the following symbol table. * - The symbol table itself. */ /* * A helper macro to read in a 'long' value from the archive. * * We use memcpy() since the source pointer may be misaligned with * respect to the natural alignment for a C 'long'. */ #define GET_LONG(P, V)do { \ memcpy(&(V), (P), sizeof(long)); \ (P) += sizeof(long); \ } while (0) Elf_Arsym * _libelf_ar_process_bsd_symtab(Elf *e, size_t *count) { Elf_Arsym *symtab, *sym; unsigned int n, nentries; unsigned char *end, *p, *p0, *s, *s0; const size_t entrysize = 2 * sizeof(long); long arraysize, fileoffset, stroffset, strtabsize; assert(e != NULL); assert(count != NULL); assert(e->e_u.e_ar.e_symtab == NULL); symtab = NULL; /* * The BSD symbol table always contains the count fields even * if there are no entries in it. */ if (e->e_u.e_ar.e_rawsymtabsz < 2 * sizeof(long)) goto symtaberror; p = p0 = (unsigned char *) e->e_u.e_ar.e_rawsymtab; end = p0 + e->e_u.e_ar.e_rawsymtabsz; /* * Retrieve the size of the array of ranlib descriptors and * check it for validity. */ GET_LONG(p, arraysize); if (arraysize < 0 || p0 + arraysize >= end || ((size_t) arraysize % entrysize != 0)) goto symtaberror; /* * Check the value of the string table size. */ s = p + arraysize; GET_LONG(s, strtabsize); s0 = s; /* Start of string table. */ if (strtabsize < 0 || s0 + strtabsize > end) goto symtaberror; nentries = (size_t) arraysize / entrysize; /* * Allocate space for the returned Elf_Arsym array. */ if ((symtab = malloc(sizeof(Elf_Arsym) * (nentries + 1))) == NULL) { LIBELF_SET_ERROR(RESOURCE, 0); return (NULL); } /* Read in symbol table entries. */ for (n = 0, sym = symtab; n < nentries; n++, sym++) { GET_LONG(p, stroffset); GET_LONG(p, fileoffset); if (stroffset < 0 || fileoffset < 0 || (size_t) fileoffset >= e->e_rawsize) goto symtaberror; s = s0 + stroffset; if (s >= end) goto symtaberror; sym->as_off = (off_t) fileoffset; sym->as_hash = elf_hash((char *) s); sym->as_name = (char *) s; } /* Fill up the sentinel entry. */ sym->as_name = NULL; sym->as_hash = ~0UL; sym->as_off = (off_t) 0; /* Remember the processed symbol table. */ e->e_u.e_ar.e_symtab = symtab; *count = e->e_u.e_ar.e_symtabsz = nentries + 1; return (symtab); symtaberror: if (symtab) free(symtab); LIBELF_SET_ERROR(ARCHIVE, 0); return (NULL); } /* * An SVR4-style ar(1) symbol table has the following layout: * * - The first 4 bytes are a binary count of the number of entries in the * symbol table, stored MSB-first. * - Then there are 'n' 4-byte binary offsets, also stored MSB first. * - Following this, there are 'n' null-terminated strings. */ #define GET_WORD(P, V) do { \ (V) = 0; \ (V) = (P)[0]; (V) <<= 8; \ (V) += (P)[1]; (V) <<= 8; \ (V) += (P)[2]; (V) <<= 8; \ (V) += (P)[3]; \ } while (0) #define INTSZ 4 Elf_Arsym * _libelf_ar_process_svr4_symtab(Elf *e, size_t *count) { uint32_t off; size_t n, nentries; Elf_Arsym *symtab, *sym; unsigned char *p, *s, *end; assert(e != NULL); assert(count != NULL); assert(e->e_u.e_ar.e_symtab == NULL); symtab = NULL; if (e->e_u.e_ar.e_rawsymtabsz < INTSZ) goto symtaberror; p = (unsigned char *) e->e_u.e_ar.e_rawsymtab; end = p + e->e_u.e_ar.e_rawsymtabsz; GET_WORD(p, nentries); p += INTSZ; if (nentries == 0 || p + nentries * INTSZ >= end) goto symtaberror; /* Allocate space for a nentries + a sentinel. */ if ((symtab = malloc(sizeof(Elf_Arsym) * (nentries+1))) == NULL) { LIBELF_SET_ERROR(RESOURCE, 0); return (NULL); } s = p + (nentries * INTSZ); /* start of the string table. */ for (n = nentries, sym = symtab; n > 0; n--) { if (s >= end) goto symtaberror; GET_WORD(p, off); if (off >= e->e_rawsize) goto symtaberror; sym->as_off = (off_t) off; sym->as_hash = elf_hash((char *) s); sym->as_name = (char *) s; p += INTSZ; sym++; for (; s < end && *s++ != '\0';) /* skip to next string */ ; } /* Fill up the sentinel entry. */ sym->as_name = NULL; sym->as_hash = ~0UL; sym->as_off = (off_t) 0; *count = e->e_u.e_ar.e_symtabsz = nentries + 1; e->e_u.e_ar.e_symtab = symtab; return (symtab); symtaberror: if (symtab) free(symtab); LIBELF_SET_ERROR(ARCHIVE, 0); return (NULL); } Index: vendor/elftoolchain/dist/libelf/libelf_convert.m4 =================================================================== --- vendor/elftoolchain/dist/libelf/libelf_convert.m4 (revision 300227) +++ vendor/elftoolchain/dist/libelf/libelf_convert.m4 (revision 300228) @@ -1,1087 +1,1088 @@ /*- * Copyright (c) 2006-2011 Joseph Koshy * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #include #include #include "_libelf.h" -ELFTC_VCSID("$Id: libelf_convert.m4 3174 2015-03-27 17:13:41Z emaste $"); +ELFTC_VCSID("$Id: libelf_convert.m4 3429 2016-03-12 04:12:39Z emaste $"); /* WARNING: GENERATED FROM __file__. */ divert(-1) # Generate conversion routines for converting between in-memory and # file representations of Elf data structures. # # These conversions use the type information defined in `elf_types.m4'. include(SRCDIR`/elf_types.m4') # For the purposes of generating conversion code, ELF types may be # classified according to the following characteristics: # # 1. Whether the ELF type can be directly mapped to an integral C # language type. For example, the ELF_T_WORD type maps directly to # a 'uint32_t', but ELF_T_GNUHASH lacks a matching C type. # # 2. Whether the type has word size dependent variants. For example, # ELT_T_EHDR is represented using C types Elf32_Ehdr and El64_Ehdr, # and the ELF_T_ADDR and ELF_T_OFF types have integral C types that # can be 32- or 64- bit wide. # # 3. Whether the ELF types has a fixed representation or not. For # example, the ELF_T_SYM type has a fixed size file representation, # some types like ELF_T_NOTE and ELF_T_GNUHASH use a variable size # representation. # # We use m4 macros to generate conversion code for ELF types that have # a fixed size representation. Conversion functions for the remaining # types are coded by hand. # #* Handling File and Memory Representations # # `In-memory' representations of an Elf data structure use natural # alignments and native byte ordering. This allows pointer arithmetic # and casting to work as expected. On the other hand, the `file' # representation of an ELF data structure could possibly be packed # tighter than its `in-memory' representation, and could be of a # differing byte order. Reading ELF objects that are members of `ar' # archives present an additional complication: `ar' pads file data to # even addresses, so file data structures in an archive member # residing inside an `ar' archive could be at misaligned memory # addresses when brought into memory. # # In summary, casting the `char *' pointers that point to memory # representations (i.e., source pointers for the *_tof() functions and # the destination pointers for the *_tom() functions), is safe, as # these pointers should be correctly aligned for the memory type # already. However, pointers to file representations have to be # treated as being potentially unaligned and no casting can be done. # NOCVT(TYPE) -- Do not generate the cvt[] structure entry for TYPE define(`NOCVT',`define(`NOCVT_'$1,1)') # NOFUNC(TYPE) -- Do not generate a conversion function for TYPE define(`NOFUNC',`define(`NOFUNC_'$1,1)') # IGNORE(TYPE) -- Completely ignore the type. define(`IGNORE',`NOCVT($1)NOFUNC($1)') # Mark ELF types that should not be processed by the M4 macros below. # Types for which we use functions with non-standard names. IGNORE(`BYTE') # Uses a wrapper around memcpy(). IGNORE(`NOTE') # Not a fixed size type. # Types for which we supply hand-coded functions. NOFUNC(`GNUHASH') # A type with complex internal structure. NOFUNC(`VDEF') # See MAKE_VERSION_CONVERTERS below. NOFUNC(`VNEED') # .. # Unimplemented types. IGNORE(`MOVEP') # ELF types that don't exist in a 32-bit world. NOFUNC(`XWORD32') NOFUNC(`SXWORD32') # `Primitive' ELF types are those that are an alias for an integral # type. As they have no internal structure, they can be copied using # a `memcpy()', and byteswapped in straightforward way. # # Mark all ELF types that directly map to integral C types. define(`PRIM_ADDR', 1) define(`PRIM_BYTE', 1) define(`PRIM_HALF', 1) define(`PRIM_LWORD', 1) define(`PRIM_OFF', 1) define(`PRIM_SWORD', 1) define(`PRIM_SXWORD', 1) define(`PRIM_WORD', 1) define(`PRIM_XWORD', 1) # Note the primitive types that are size-dependent. define(`SIZEDEP_ADDR', 1) define(`SIZEDEP_OFF', 1) # Generate conversion functions for primitive types. # # Macro use: MAKEPRIMFUNCS(ELFTYPE,CTYPE,TYPESIZE,SYMSIZE) # `$1': Name of the ELF type. # `$2': C structure name suffix. # `$3': ELF class specifier for types, one of [`32', `64']. # `$4': Additional ELF class specifier, one of [`', `32', `64']. # # Generates a pair of conversion functions. define(`MAKEPRIMFUNCS',` static int _libelf_cvt_$1$4_tof(unsigned char *dst, size_t dsz, unsigned char *src, size_t count, int byteswap) { Elf$3_$2 t, *s = (Elf$3_$2 *) (uintptr_t) src; size_t c; (void) dsz; if (!byteswap) { (void) memcpy(dst, src, count * sizeof(*s)); return (1); } for (c = 0; c < count; c++) { t = *s++; SWAP_$1$4(t); WRITE_$1$4(dst,t); } return (1); } static int _libelf_cvt_$1$4_tom(unsigned char *dst, size_t dsz, unsigned char *src, size_t count, int byteswap) { Elf$3_$2 t, *d = (Elf$3_$2 *) (uintptr_t) dst; size_t c; if (dsz < count * sizeof(Elf$3_$2)) return (0); if (!byteswap) { (void) memcpy(dst, src, count * sizeof(*d)); return (1); } for (c = 0; c < count; c++) { READ_$1$4(src,t); SWAP_$1$4(t); *d++ = t; } return (1); } ') # # Handling composite ELF types # # SWAP_FIELD(FIELDNAME,ELFTYPE) -- Generate code to swap one field. define(`SWAP_FIELD', `ifdef(`SIZEDEP_'$2, `SWAP_$2'SZ()`(t.$1); ', `SWAP_$2(t.$1); ')') # SWAP_MEMBERS(STRUCT) -- Iterate over a structure definition. define(`SWAP_MEMBERS', `ifelse($#,1,`/**/', `SWAP_FIELD($1)SWAP_MEMBERS(shift($@))')') # SWAP_STRUCT(CTYPE,SIZE) -- Generate code to swap an ELF structure. define(`SWAP_STRUCT', `pushdef(`SZ',$2)/* Swap an Elf$2_$1 */ SWAP_MEMBERS(Elf$2_$1_DEF)popdef(`SZ')') # WRITE_FIELD(ELFTYPE,FIELDNAME) -- Generate code to write one field. define(`WRITE_FIELD', `ifdef(`SIZEDEP_'$2, `WRITE_$2'SZ()`(dst,t.$1); ', `WRITE_$2(dst,t.$1); ')') # WRITE_MEMBERS(ELFTYPELIST) -- Iterate over a structure definition. define(`WRITE_MEMBERS', `ifelse($#,1,`/**/', `WRITE_FIELD($1)WRITE_MEMBERS(shift($@))')') # WRITE_STRUCT(CTYPE,SIZE) -- Generate code to write out an ELF structure. define(`WRITE_STRUCT', `pushdef(`SZ',$2)/* Write an Elf$2_$1 */ WRITE_MEMBERS(Elf$2_$1_DEF)popdef(`SZ')') # READ_FIELD(ELFTYPE,CTYPE) -- Generate code to read one field. define(`READ_FIELD', `ifdef(`SIZEDEP_'$2, `READ_$2'SZ()`(s,t.$1); ', `READ_$2(s,t.$1); ')') # READ_MEMBERS(ELFTYPELIST) -- Iterate over a structure definition. define(`READ_MEMBERS', `ifelse($#,1,`/**/', `READ_FIELD($1)READ_MEMBERS(shift($@))')') # READ_STRUCT(CTYPE,SIZE) -- Generate code to read an ELF structure. define(`READ_STRUCT', `pushdef(`SZ',$2)/* Read an Elf$2_$1 */ READ_MEMBERS(Elf$2_$1_DEF)popdef(`SZ')') # MAKECOMPFUNCS -- Generate converters for composite ELF structures. # # When converting data to file representation, the source pointer will # be naturally aligned for a data structure's in-memory # representation. When converting data to memory, the destination # pointer will be similarly aligned. # # For in-place conversions, when converting to file representations, # the source buffer is large enough to hold `file' data. When # converting from file to memory, we need to be careful to work # `backwards', to avoid overwriting unconverted data. # # Macro use: # `$1': Name of the ELF type. # `$2': C structure name suffix. # `$3': ELF class specifier, one of [`', `32', `64'] define(`MAKECOMPFUNCS', `ifdef(`NOFUNC_'$1$3,`',` static int _libelf_cvt_$1$3_tof(unsigned char *dst, size_t dsz, unsigned char *src, size_t count, int byteswap) { Elf$3_$2 t, *s; size_t c; (void) dsz; s = (Elf$3_$2 *) (uintptr_t) src; for (c = 0; c < count; c++) { t = *s++; if (byteswap) { SWAP_STRUCT($2,$3) } WRITE_STRUCT($2,$3) } return (1); } static int _libelf_cvt_$1$3_tom(unsigned char *dst, size_t dsz, unsigned char *src, size_t count, int byteswap) { Elf$3_$2 t, *d; unsigned char *s,*s0; size_t fsz; fsz = elf$3_fsize(ELF_T_$1, (size_t) 1, EV_CURRENT); d = ((Elf$3_$2 *) (uintptr_t) dst) + (count - 1); s0 = src + (count - 1) * fsz; if (dsz < count * sizeof(Elf$3_$2)) return (0); while (count--) { s = s0; READ_STRUCT($2,$3) if (byteswap) { SWAP_STRUCT($2,$3) } *d-- = t; s0 -= fsz; } return (1); } ')') # MAKE_TYPE_CONVERTER(ELFTYPE,CTYPE) # # Make type convertor functions from the type definition # of the ELF type: # - Skip convertors marked as `NOFUNC'. # - Invoke `MAKEPRIMFUNCS' or `MAKECOMPFUNCS' as appropriate. define(`MAKE_TYPE_CONVERTER', `ifdef(`NOFUNC_'$1,`', `ifdef(`PRIM_'$1, `ifdef(`SIZEDEP_'$1, `MAKEPRIMFUNCS($1,$2,32,32)dnl MAKEPRIMFUNCS($1,$2,64,64)', `MAKEPRIMFUNCS($1,$2,64)')', `MAKECOMPFUNCS($1,$2,32)dnl MAKECOMPFUNCS($1,$2,64)')')') # MAKE_TYPE_CONVERTERS(ELFTYPELIST) -- Generate conversion functions. define(`MAKE_TYPE_CONVERTERS', `ifelse($#,1,`', `MAKE_TYPE_CONVERTER($1)MAKE_TYPE_CONVERTERS(shift($@))')') # # Macros to generate entries for the table of convertors. # # CONV(ELFTYPE,SIZE,DIRECTION) # # Generate the name of a convertor function. define(`CONV', `ifdef(`NOFUNC_'$1$2, `.$3$2 = NULL', `ifdef(`PRIM_'$1, `ifdef(`SIZEDEP_'$1, `.$3$2 = _libelf_cvt_$1$2_$3', `.$3$2 = _libelf_cvt_$1_$3')', `.$3$2 = _libelf_cvt_$1$2_$3')')') # CONVERTER_NAME(ELFTYPE) # # Generate the contents of one `struct cvt' instance. define(`CONVERTER_NAME', `ifdef(`NOCVT_'$1,`', ` [ELF_T_$1] = { CONV($1,32,tof), CONV($1,32,tom), CONV($1,64,tof), CONV($1,64,tom) }, ')') # CONVERTER_NAMES(ELFTYPELIST) # # Generate the `struct cvt[]' array. define(`CONVERTER_NAMES', `ifelse($#,1,`', `CONVERTER_NAME($1)CONVERTER_NAMES(shift($@))')') # # Handling ELF version sections. # # _FSZ(FIELD,BASETYPE) - return the file size for a field. define(`_FSZ', `ifelse($2,`HALF',2, $2,`WORD',4)') # FSZ(STRUCT) - determine the file size of a structure. define(`FSZ', `ifelse($#,1,0, `eval(_FSZ($1) + FSZ(shift($@)))')') # MAKE_VERSION_CONVERTERS(TYPE,BASE,AUX,PFX) -- Generate conversion # functions for versioning structures. define(`MAKE_VERSION_CONVERTERS', `MAKE_VERSION_CONVERTER($1,$2,$3,$4,32) MAKE_VERSION_CONVERTER($1,$2,$3,$4,64)') # MAKE_VERSION_CONVERTOR(TYPE,CBASE,CAUX,PFX,SIZE) -- Generate a # conversion function. define(`MAKE_VERSION_CONVERTER',` static int _libelf_cvt_$1$5_tof(unsigned char *dst, size_t dsz, unsigned char *src, size_t count, int byteswap) { Elf$5_$2 t; Elf$5_$3 a; const size_t verfsz = FSZ(Elf$5_$2_DEF); const size_t auxfsz = FSZ(Elf$5_$3_DEF); const size_t vermsz = sizeof(Elf$5_$2); const size_t auxmsz = sizeof(Elf$5_$3); unsigned char * const dstend = dst + dsz; unsigned char * const srcend = src + count; unsigned char *dtmp, *dstaux, *srcaux; Elf$5_Word aux, anext, cnt, vnext; for (dtmp = dst, vnext = ~0U; vnext != 0 && dtmp + verfsz <= dstend && src + vermsz <= srcend; dtmp += vnext, src += vnext) { /* Read in an Elf$5_$2 structure. */ t = *((Elf$5_$2 *) (uintptr_t) src); aux = t.$4_aux; cnt = t.$4_cnt; vnext = t.$4_next; if (byteswap) { SWAP_STRUCT($2, $5) } dst = dtmp; WRITE_STRUCT($2, $5) if (aux < verfsz) return (0); /* Process AUX entries. */ for (anext = ~0U, dstaux = dtmp + aux, srcaux = src + aux; cnt != 0 && anext != 0 && dstaux + auxfsz <= dstend && srcaux + auxmsz <= srcend; dstaux += anext, srcaux += anext, cnt--) { /* Read in an Elf$5_$3 structure. */ a = *((Elf$5_$3 *) (uintptr_t) srcaux); anext = a.$4a_next; if (byteswap) { pushdef(`t',`a')SWAP_STRUCT($3, $5)popdef(`t') } dst = dstaux; pushdef(`t',`a')WRITE_STRUCT($3, $5)popdef(`t') } if (anext || cnt) return (0); } if (vnext) return (0); return (1); } static int _libelf_cvt_$1$5_tom(unsigned char *dst, size_t dsz, unsigned char *src, size_t count, int byteswap) { Elf$5_$2 t, *dp; Elf$5_$3 a, *ap; const size_t verfsz = FSZ(Elf$5_$2_DEF); const size_t auxfsz = FSZ(Elf$5_$3_DEF); const size_t vermsz = sizeof(Elf$5_$2); const size_t auxmsz = sizeof(Elf$5_$3); unsigned char * const dstend = dst + dsz; unsigned char * const srcend = src + count; unsigned char *dstaux, *s, *srcaux, *stmp; Elf$5_Word aux, anext, cnt, vnext; for (stmp = src, vnext = ~0U; vnext != 0 && stmp + verfsz <= srcend && dst + vermsz <= dstend; stmp += vnext, dst += vnext) { /* Read in a $1 structure. */ s = stmp; READ_STRUCT($2, $5) if (byteswap) { SWAP_STRUCT($2, $5) } dp = (Elf$5_$2 *) (uintptr_t) dst; *dp = t; aux = t.$4_aux; cnt = t.$4_cnt; vnext = t.$4_next; if (aux < vermsz) return (0); /* Process AUX entries. */ for (anext = ~0U, dstaux = dst + aux, srcaux = stmp + aux; cnt != 0 && anext != 0 && dstaux + auxmsz <= dstend && srcaux + auxfsz <= srcend; dstaux += anext, srcaux += anext, cnt--) { s = srcaux; pushdef(`t',`a')READ_STRUCT($3, $5)popdef(`t') if (byteswap) { pushdef(`t',`a')SWAP_STRUCT($3, $5)popdef(`t') } anext = a.$4a_next; ap = ((Elf$5_$3 *) (uintptr_t) dstaux); *ap = a; } if (anext || cnt) return (0); } if (vnext) return (0); return (1); }') divert(0) /* * C macros to byte swap integral quantities. */ #define SWAP_BYTE(X) do { (void) (X); } while (0) #define SWAP_IDENT(X) do { (void) (X); } while (0) #define SWAP_HALF(X) do { \ uint16_t _x = (uint16_t) (X); \ uint32_t _t = _x & 0xFFU; \ _t <<= 8U; _x >>= 8U; _t |= _x & 0xFFU; \ (X) = (uint16_t) _t; \ } while (0) #define _SWAP_WORD(X, T) do { \ uint32_t _x = (uint32_t) (X); \ uint32_t _t = _x & 0xFF; \ _t <<= 8; _x >>= 8; _t |= _x & 0xFF; \ _t <<= 8; _x >>= 8; _t |= _x & 0xFF; \ _t <<= 8; _x >>= 8; _t |= _x & 0xFF; \ (X) = (T) _t; \ } while (0) #define SWAP_ADDR32(X) _SWAP_WORD(X, Elf32_Addr) #define SWAP_OFF32(X) _SWAP_WORD(X, Elf32_Off) #define SWAP_SWORD(X) _SWAP_WORD(X, Elf32_Sword) #define SWAP_WORD(X) _SWAP_WORD(X, Elf32_Word) #define _SWAP_WORD64(X, T) do { \ uint64_t _x = (uint64_t) (X); \ uint64_t _t = _x & 0xFF; \ _t <<= 8; _x >>= 8; _t |= _x & 0xFF; \ _t <<= 8; _x >>= 8; _t |= _x & 0xFF; \ _t <<= 8; _x >>= 8; _t |= _x & 0xFF; \ _t <<= 8; _x >>= 8; _t |= _x & 0xFF; \ _t <<= 8; _x >>= 8; _t |= _x & 0xFF; \ _t <<= 8; _x >>= 8; _t |= _x & 0xFF; \ _t <<= 8; _x >>= 8; _t |= _x & 0xFF; \ (X) = (T) _t; \ } while (0) #define SWAP_ADDR64(X) _SWAP_WORD64(X, Elf64_Addr) #define SWAP_LWORD(X) _SWAP_WORD64(X, Elf64_Lword) #define SWAP_OFF64(X) _SWAP_WORD64(X, Elf64_Off) #define SWAP_SXWORD(X) _SWAP_WORD64(X, Elf64_Sxword) #define SWAP_XWORD(X) _SWAP_WORD64(X, Elf64_Xword) /* * C macros to write out various integral values. * * Note: * - The destination pointer could be unaligned. * - Values are written out in native byte order. * - The destination pointer is incremented after the write. */ #define WRITE_BYTE(P,X) do { \ unsigned char *const _p = (unsigned char *) (P); \ _p[0] = (unsigned char) (X); \ (P) = _p + 1; \ } while (0) #define WRITE_HALF(P,X) do { \ uint16_t _t = (X); \ unsigned char *const _p = (unsigned char *) (P); \ const unsigned char *const _q = (unsigned char *) &_t; \ _p[0] = _q[0]; \ _p[1] = _q[1]; \ (P) = _p + 2; \ } while (0) #define WRITE_WORD(P,X) do { \ uint32_t _t = (uint32_t) (X); \ unsigned char *const _p = (unsigned char *) (P); \ const unsigned char *const _q = (unsigned char *) &_t; \ _p[0] = _q[0]; \ _p[1] = _q[1]; \ _p[2] = _q[2]; \ _p[3] = _q[3]; \ (P) = _p + 4; \ } while (0) #define WRITE_ADDR32(P,X) WRITE_WORD(P,X) #define WRITE_OFF32(P,X) WRITE_WORD(P,X) #define WRITE_SWORD(P,X) WRITE_WORD(P,X) #define WRITE_WORD64(P,X) do { \ uint64_t _t = (uint64_t) (X); \ unsigned char *const _p = (unsigned char *) (P); \ const unsigned char *const _q = (unsigned char *) &_t; \ _p[0] = _q[0]; \ _p[1] = _q[1]; \ _p[2] = _q[2]; \ _p[3] = _q[3]; \ _p[4] = _q[4]; \ _p[5] = _q[5]; \ _p[6] = _q[6]; \ _p[7] = _q[7]; \ (P) = _p + 8; \ } while (0) #define WRITE_ADDR64(P,X) WRITE_WORD64(P,X) #define WRITE_LWORD(P,X) WRITE_WORD64(P,X) #define WRITE_OFF64(P,X) WRITE_WORD64(P,X) #define WRITE_SXWORD(P,X) WRITE_WORD64(P,X) #define WRITE_XWORD(P,X) WRITE_WORD64(P,X) #define WRITE_IDENT(P,X) do { \ (void) memcpy((P), (X), sizeof((X))); \ (P) = (P) + EI_NIDENT; \ } while (0) /* * C macros to read in various integral values. * * Note: * - The source pointer could be unaligned. * - Values are read in native byte order. * - The source pointer is incremented appropriately. */ #define READ_BYTE(P,X) do { \ const unsigned char *const _p = \ (const unsigned char *) (P); \ (X) = _p[0]; \ (P) = (P) + 1; \ } while (0) #define READ_HALF(P,X) do { \ uint16_t _t; \ unsigned char *const _q = (unsigned char *) &_t; \ const unsigned char *const _p = \ (const unsigned char *) (P); \ _q[0] = _p[0]; \ _q[1] = _p[1]; \ (P) = (P) + 2; \ (X) = _t; \ } while (0) #define _READ_WORD(P,X,T) do { \ uint32_t _t; \ unsigned char *const _q = (unsigned char *) &_t; \ const unsigned char *const _p = \ (const unsigned char *) (P); \ _q[0] = _p[0]; \ _q[1] = _p[1]; \ _q[2] = _p[2]; \ _q[3] = _p[3]; \ (P) = (P) + 4; \ (X) = (T) _t; \ } while (0) #define READ_ADDR32(P,X) _READ_WORD(P, X, Elf32_Addr) #define READ_OFF32(P,X) _READ_WORD(P, X, Elf32_Off) #define READ_SWORD(P,X) _READ_WORD(P, X, Elf32_Sword) #define READ_WORD(P,X) _READ_WORD(P, X, Elf32_Word) #define _READ_WORD64(P,X,T) do { \ uint64_t _t; \ unsigned char *const _q = (unsigned char *) &_t; \ const unsigned char *const _p = \ (const unsigned char *) (P); \ _q[0] = _p[0]; \ _q[1] = _p[1]; \ _q[2] = _p[2]; \ _q[3] = _p[3]; \ _q[4] = _p[4]; \ _q[5] = _p[5]; \ _q[6] = _p[6]; \ _q[7] = _p[7]; \ (P) = (P) + 8; \ (X) = (T) _t; \ } while (0) #define READ_ADDR64(P,X) _READ_WORD64(P, X, Elf64_Addr) #define READ_LWORD(P,X) _READ_WORD64(P, X, Elf64_Lword) #define READ_OFF64(P,X) _READ_WORD64(P, X, Elf64_Off) #define READ_SXWORD(P,X) _READ_WORD64(P, X, Elf64_Sxword) #define READ_XWORD(P,X) _READ_WORD64(P, X, Elf64_Xword) #define READ_IDENT(P,X) do { \ (void) memcpy((X), (P), sizeof((X))); \ (P) = (P) + EI_NIDENT; \ } while (0) #define ROUNDUP2(V,N) (V) = ((((V) + (N) - 1)) & ~((N) - 1)) /*[*/ MAKE_TYPE_CONVERTERS(ELF_TYPE_LIST) MAKE_VERSION_CONVERTERS(VDEF,Verdef,Verdaux,vd) MAKE_VERSION_CONVERTERS(VNEED,Verneed,Vernaux,vn) /*]*/ /* * Sections of type ELF_T_BYTE are never byteswapped, consequently a * simple memcpy suffices for both directions of conversion. */ static int _libelf_cvt_BYTE_tox(unsigned char *dst, size_t dsz, unsigned char *src, size_t count, int byteswap) { (void) byteswap; if (dsz < count) return (0); if (dst != src) (void) memcpy(dst, src, count); return (1); } /* * Sections of type ELF_T_GNUHASH start with a header containing 4 32-bit * words. Bloom filter data comes next, followed by hash buckets and the * hash chain. * * Bloom filter words are 64 bit wide on ELFCLASS64 objects and are 32 bit * wide on ELFCLASS32 objects. The other objects in this section are 32 * bits wide. * * Argument `srcsz' denotes the number of bytes to be converted. In the * 32-bit case we need to translate `srcsz' to a count of 32-bit words. */ static int _libelf_cvt_GNUHASH32_tom(unsigned char *dst, size_t dsz, unsigned char *src, size_t srcsz, int byteswap) { return (_libelf_cvt_WORD_tom(dst, dsz, src, srcsz / sizeof(uint32_t), byteswap)); } static int _libelf_cvt_GNUHASH32_tof(unsigned char *dst, size_t dsz, unsigned char *src, size_t srcsz, int byteswap) { return (_libelf_cvt_WORD_tof(dst, dsz, src, srcsz / sizeof(uint32_t), byteswap)); } static int _libelf_cvt_GNUHASH64_tom(unsigned char *dst, size_t dsz, unsigned char *src, size_t srcsz, int byteswap) { size_t sz; uint64_t t64, *bloom64; Elf_GNU_Hash_Header *gh; uint32_t n, nbuckets, nchains, maskwords, shift2, symndx, t32; uint32_t *buckets, *chains; sz = 4 * sizeof(uint32_t); /* File header is 4 words long. */ if (dsz < sizeof(Elf_GNU_Hash_Header) || srcsz < sz) return (0); /* Read in the section header and byteswap if needed. */ READ_WORD(src, nbuckets); READ_WORD(src, symndx); READ_WORD(src, maskwords); READ_WORD(src, shift2); srcsz -= sz; if (byteswap) { SWAP_WORD(nbuckets); SWAP_WORD(symndx); SWAP_WORD(maskwords); SWAP_WORD(shift2); } /* Check source buffer and destination buffer sizes. */ sz = nbuckets * sizeof(uint32_t) + maskwords * sizeof(uint64_t); if (srcsz < sz || dsz < sz + sizeof(Elf_GNU_Hash_Header)) return (0); gh = (Elf_GNU_Hash_Header *) (uintptr_t) dst; gh->gh_nbuckets = nbuckets; gh->gh_symndx = symndx; gh->gh_maskwords = maskwords; gh->gh_shift2 = shift2; dsz -= sizeof(Elf_GNU_Hash_Header); dst += sizeof(Elf_GNU_Hash_Header); bloom64 = (uint64_t *) (uintptr_t) dst; /* Copy bloom filter data. */ for (n = 0; n < maskwords; n++) { READ_XWORD(src, t64); if (byteswap) SWAP_XWORD(t64); bloom64[n] = t64; } /* The hash buckets follows the bloom filter. */ dst += maskwords * sizeof(uint64_t); buckets = (uint32_t *) (uintptr_t) dst; for (n = 0; n < nbuckets; n++) { READ_WORD(src, t32); if (byteswap) SWAP_WORD(t32); buckets[n] = t32; } dst += nbuckets * sizeof(uint32_t); /* The hash chain follows the hash buckets. */ dsz -= sz; srcsz -= sz; if (dsz < srcsz) /* Destination lacks space. */ return (0); nchains = srcsz / sizeof(uint32_t); chains = (uint32_t *) (uintptr_t) dst; for (n = 0; n < nchains; n++) { READ_WORD(src, t32); if (byteswap) SWAP_WORD(t32); *chains++ = t32; } return (1); } static int _libelf_cvt_GNUHASH64_tof(unsigned char *dst, size_t dsz, unsigned char *src, size_t srcsz, int byteswap) { uint32_t *s32; size_t sz, hdrsz; uint64_t *s64, t64; Elf_GNU_Hash_Header *gh; uint32_t maskwords, n, nbuckets, nchains, t0, t1, t2, t3, t32; hdrsz = 4 * sizeof(uint32_t); /* Header is 4x32 bits. */ if (dsz < hdrsz || srcsz < sizeof(Elf_GNU_Hash_Header)) return (0); gh = (Elf_GNU_Hash_Header *) (uintptr_t) src; t0 = nbuckets = gh->gh_nbuckets; t1 = gh->gh_symndx; t2 = maskwords = gh->gh_maskwords; t3 = gh->gh_shift2; src += sizeof(Elf_GNU_Hash_Header); srcsz -= sizeof(Elf_GNU_Hash_Header); dsz -= hdrsz; sz = gh->gh_nbuckets * sizeof(uint32_t) + gh->gh_maskwords * sizeof(uint64_t); if (srcsz < sz || dsz < sz) return (0); /* Write out the header. */ if (byteswap) { SWAP_WORD(t0); SWAP_WORD(t1); SWAP_WORD(t2); SWAP_WORD(t3); } WRITE_WORD(dst, t0); WRITE_WORD(dst, t1); WRITE_WORD(dst, t2); WRITE_WORD(dst, t3); /* Copy the bloom filter and the hash table. */ s64 = (uint64_t *) (uintptr_t) src; for (n = 0; n < maskwords; n++) { t64 = *s64++; if (byteswap) SWAP_XWORD(t64); WRITE_WORD64(dst, t64); } s32 = (uint32_t *) s64; for (n = 0; n < nbuckets; n++) { t32 = *s32++; if (byteswap) SWAP_WORD(t32); WRITE_WORD(dst, t32); } srcsz -= sz; dsz -= sz; /* Copy out the hash chains. */ if (dsz < srcsz) return (0); nchains = srcsz / sizeof(uint32_t); for (n = 0; n < nchains; n++) { t32 = *s32++; if (byteswap) SWAP_WORD(t32); WRITE_WORD(dst, t32); } return (1); } /* * Elf_Note structures comprise a fixed size header followed by variable * length strings. The fixed size header needs to be byte swapped, but * not the strings. * * Argument `count' denotes the total number of bytes to be converted. * The destination buffer needs to be at least `count' bytes in size. */ static int _libelf_cvt_NOTE_tom(unsigned char *dst, size_t dsz, unsigned char *src, size_t count, int byteswap) { uint32_t namesz, descsz, type; Elf_Note *en; size_t sz, hdrsz; if (dsz < count) /* Destination buffer is too small. */ return (0); hdrsz = 3 * sizeof(uint32_t); if (count < hdrsz) /* Source too small. */ return (0); if (!byteswap) { (void) memcpy(dst, src, count); return (1); } /* Process all notes in the section. */ while (count > hdrsz) { /* Read the note header. */ READ_WORD(src, namesz); READ_WORD(src, descsz); READ_WORD(src, type); /* Translate. */ SWAP_WORD(namesz); SWAP_WORD(descsz); SWAP_WORD(type); /* Copy out the translated note header. */ en = (Elf_Note *) (uintptr_t) dst; en->n_namesz = namesz; en->n_descsz = descsz; en->n_type = type; dsz -= sizeof(Elf_Note); dst += sizeof(Elf_Note); count -= hdrsz; ROUNDUP2(namesz, 4U); ROUNDUP2(descsz, 4U); sz = namesz + descsz; if (count < sz || dsz < sz) /* Buffers are too small. */ return (0); (void) memcpy(dst, src, sz); src += sz; dst += sz; count -= sz; dsz -= sz; } return (1); } static int _libelf_cvt_NOTE_tof(unsigned char *dst, size_t dsz, unsigned char *src, size_t count, int byteswap) { uint32_t namesz, descsz, type; Elf_Note *en; size_t sz; if (dsz < count) return (0); if (!byteswap) { (void) memcpy(dst, src, count); return (1); } while (count > sizeof(Elf_Note)) { en = (Elf_Note *) (uintptr_t) src; namesz = en->n_namesz; descsz = en->n_descsz; type = en->n_type; sz = namesz; ROUNDUP2(sz, 4U); sz += descsz; ROUNDUP2(sz, 4U); SWAP_WORD(namesz); SWAP_WORD(descsz); SWAP_WORD(type); WRITE_WORD(dst, namesz); WRITE_WORD(dst, descsz); WRITE_WORD(dst, type); src += sizeof(Elf_Note); + count -= sizeof(Elf_Note); if (count < sz) sz = count; (void) memcpy(dst, src, sz); src += sz; dst += sz; count -= sz; } return (1); } struct converters { int (*tof32)(unsigned char *dst, size_t dsz, unsigned char *src, size_t cnt, int byteswap); int (*tom32)(unsigned char *dst, size_t dsz, unsigned char *src, size_t cnt, int byteswap); int (*tof64)(unsigned char *dst, size_t dsz, unsigned char *src, size_t cnt, int byteswap); int (*tom64)(unsigned char *dst, size_t dsz, unsigned char *src, size_t cnt, int byteswap); }; static struct converters cvt[ELF_T_NUM] = { /*[*/ CONVERTER_NAMES(ELF_TYPE_LIST) /*]*/ /* * Types that need hand-coded converters follow. */ [ELF_T_BYTE] = { .tof32 = _libelf_cvt_BYTE_tox, .tom32 = _libelf_cvt_BYTE_tox, .tof64 = _libelf_cvt_BYTE_tox, .tom64 = _libelf_cvt_BYTE_tox }, [ELF_T_NOTE] = { .tof32 = _libelf_cvt_NOTE_tof, .tom32 = _libelf_cvt_NOTE_tom, .tof64 = _libelf_cvt_NOTE_tof, .tom64 = _libelf_cvt_NOTE_tom } }; int (*_libelf_get_translator(Elf_Type t, int direction, int elfclass)) (unsigned char *_dst, size_t dsz, unsigned char *_src, size_t _cnt, int _byteswap) { assert(elfclass == ELFCLASS32 || elfclass == ELFCLASS64); assert(direction == ELF_TOFILE || direction == ELF_TOMEMORY); if (t >= ELF_T_NUM || (elfclass != ELFCLASS32 && elfclass != ELFCLASS64) || (direction != ELF_TOFILE && direction != ELF_TOMEMORY)) return (NULL); return ((elfclass == ELFCLASS32) ? (direction == ELF_TOFILE ? cvt[t].tof32 : cvt[t].tom32) : (direction == ELF_TOFILE ? cvt[t].tof64 : cvt[t].tom64)); } Index: vendor/elftoolchain/dist/libelftc/Makefile =================================================================== --- vendor/elftoolchain/dist/libelftc/Makefile (revision 300227) +++ vendor/elftoolchain/dist/libelftc/Makefile (revision 300228) @@ -1,56 +1,58 @@ -# $Id: Makefile 3292 2016-01-06 21:46:32Z jkoshy $ +# $Id: Makefile 3418 2016-02-19 20:04:42Z emaste $ TOP= ${.CURDIR}/.. LIB= elftc SRCS= elftc_bfdtarget.c \ elftc_copyfile.c \ elftc_demangle.c \ + elftc_reloc_type_str.c \ elftc_set_timestamps.c \ elftc_string_table.c \ elftc_version.c \ libelftc_bfdtarget.c \ libelftc_dem_arm.c \ libelftc_dem_gnu2.c \ libelftc_dem_gnu3.c \ libelftc_hash.c \ libelftc_vstr.c INCS= libelftc.h INCSDIR= /usr/include RELEASE= HEAD # Change this on release branches. SHLIB_MAJOR= 1 WARNS?= 6 CLEANFILES+= elftc_version.c LDADD+= -lelf MAN= elftc.3 \ elftc_bfd_find_target.3 \ elftc_copyfile.3 \ elftc_demangle.3 \ + elftc_reloc_type_str.3 \ elftc_set_timestamps.3 \ elftc_string_table_create.3 \ elftc_version.3 MLINKS= elftc_bfd_find_target.3 elftc_bfd_target_byteorder.3 \ elftc_bfd_find_target.3 elftc_bfd_target_class.3 \ elftc_bfd_find_target.3 elftc_bfd_target_flavor.3 \ elftc_string_table_create.3 elftc_string_table_from_section.3 \ elftc_string_table_create.3 elftc_string_table_destroy.3 \ elftc_string_table_create.3 elftc_string_table_image.3 \ elftc_string_table_create.3 elftc_string_table_insert.3 \ elftc_string_table_create.3 elftc_string_table_lookup.3 .if !make(clean) && !make(clobber) .BEGIN: .SILENT ${.CURDIR}/make-toolchain-version -t ${TOP} -r ${RELEASE} \ -h ${OS_HOST} .endif .include "${TOP}/mk/elftoolchain.lib.mk" Index: vendor/elftoolchain/dist/libelftc/elftc_reloc_type_str.3 =================================================================== --- vendor/elftoolchain/dist/libelftc/elftc_reloc_type_str.3 (nonexistent) +++ vendor/elftoolchain/dist/libelftc/elftc_reloc_type_str.3 (revision 300228) @@ -0,0 +1,72 @@ +.\" Copyright (c) 2016 The FreeBSD Foundation. All rights reserved. +.\" +.\" This documentation was written by Ed Maste under sponsorship of +.\" the FreeBSD Foundation. +.\" +.\" Redistribution and use in source and binary forms, with or without +.\" modification, are permitted provided that the following conditions +.\" are met: +.\" 1. Redistributions of source code must retain the above copyright +.\" notice, this list of conditions and the following disclaimer. +.\" 2. Redistributions in binary form must reproduce the above copyright +.\" notice, this list of conditions and the following disclaimer in the +.\" documentation and/or other materials provided with the distribution. +.\" +.\" This software is provided by the author and contributors ``as is'' and +.\" any express or implied warranties, including, but not limited to, the +.\" implied warranties of merchantability and fitness for a particular purpose +.\" are disclaimed. In no event shall the author or contributors be liable +.\" for any direct, indirect, incidental, special, exemplary, or consequential +.\" damages (including, but not limited to, procurement of substitute goods +.\" or services; loss of use, data, or profits; or business interruption) +.\" however caused and on any theory of liability, whether in contract, strict +.\" liability, or tort (including negligence or otherwise) arising in any way +.\" out of the use of this software, even if advised of the possibility of +.\" such damage. +.\" +.\" $Id$ +.\" +.Dd February 19, 2016 +.Os +.Dt ELFTC_RELOC_TYPE_STR 3 +.Sh NAME +.Nm elftc_reloc_type_str +.Nd return the type name for an ELF relocation +.Sh LIBRARY +.Lb libelftc +.Sh SYNOPSIS +.In libelftc.h +.Ft const char * +.Fo elftc_reloc_type_str +.Fa "unsigned int mach" +.Fa "unsigned int type" +.Fc +.Sh DESCRIPTION +Function +.Fn elftc_reloc_type_str +returns the name for specified relocation type. +.Pp +Argument +.Ar mach +specifies the machine (architecture) type. +Argument +.Ar type +specifies the relocation value. +.Sh RETURN VALUE +Function +.Fn elftc_program_version +returns a pointer to a string constant, or to an internal character buffer +if the relocation type is unknown. +.Sh EXAMPLES +To print ARM relocation type 7, use: +.Bd -literal -offset indent +#include +#include +#include + +(void) printf("%s\en", elftc_reloc_type_str(EM_ARM, 7)); +.Ed +.Sh ERRORS +Function +.Fn elftc_reloc_type_str +always succeeds. Property changes on: vendor/elftoolchain/dist/libelftc/elftc_reloc_type_str.3 ___________________________________________________________________ Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +FreeBSD=%H \ No newline at end of property Added: svn:mime-type ## -0,0 +1 ## +text/plain \ No newline at end of property Index: vendor/elftoolchain/dist/libelftc/elftc_reloc_type_str.c =================================================================== --- vendor/elftoolchain/dist/libelftc/elftc_reloc_type_str.c (nonexistent) +++ vendor/elftoolchain/dist/libelftc/elftc_reloc_type_str.c (revision 300228) @@ -0,0 +1,684 @@ +/*- + * Copyright (c) 2009-2015 Kai Wang + * Copyright (c) 2016 The FreeBSD Foundation + * All rights reserved. + * + * Portions of this software were developed by Ed Maste under sponsorship + * of the FreeBSD Foundation. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include +#include + +const char * +elftc_reloc_type_str(unsigned int mach, unsigned int type) +{ + static char s_type[32]; + + switch(mach) { + case EM_386: + case EM_IAMCU: + switch(type) { + case 0: return "R_386_NONE"; + case 1: return "R_386_32"; + case 2: return "R_386_PC32"; + case 3: return "R_386_GOT32"; + case 4: return "R_386_PLT32"; + case 5: return "R_386_COPY"; + case 6: return "R_386_GLOB_DAT"; + case 7: return "R_386_JUMP_SLOT"; + case 8: return "R_386_RELATIVE"; + case 9: return "R_386_GOTOFF"; + case 10: return "R_386_GOTPC"; + case 11: return "R_386_32PLT"; /* Not in psabi */ + case 14: return "R_386_TLS_TPOFF"; + case 15: return "R_386_TLS_IE"; + case 16: return "R_386_TLS_GOTIE"; + case 17: return "R_386_TLS_LE"; + case 18: return "R_386_TLS_GD"; + case 19: return "R_386_TLS_LDM"; + case 20: return "R_386_16"; + case 21: return "R_386_PC16"; + case 22: return "R_386_8"; + case 23: return "R_386_PC8"; + case 24: return "R_386_TLS_GD_32"; + case 25: return "R_386_TLS_GD_PUSH"; + case 26: return "R_386_TLS_GD_CALL"; + case 27: return "R_386_TLS_GD_POP"; + case 28: return "R_386_TLS_LDM_32"; + case 29: return "R_386_TLS_LDM_PUSH"; + case 30: return "R_386_TLS_LDM_CALL"; + case 31: return "R_386_TLS_LDM_POP"; + case 32: return "R_386_TLS_LDO_32"; + case 33: return "R_386_TLS_IE_32"; + case 34: return "R_386_TLS_LE_32"; + case 35: return "R_386_TLS_DTPMOD32"; + case 36: return "R_386_TLS_DTPOFF32"; + case 37: return "R_386_TLS_TPOFF32"; + case 38: return "R_386_SIZE32"; + case 39: return "R_386_TLS_GOTDESC"; + case 40: return "R_386_TLS_DESC_CALL"; + case 41: return "R_386_TLS_DESC"; + case 42: return "R_386_IRELATIVE"; + case 43: return "R_386_GOT32X"; + } + break; + case EM_AARCH64: + switch(type) { + case 0: return "R_AARCH64_NONE"; + case 257: return "R_AARCH64_ABS64"; + case 258: return "R_AARCH64_ABS32"; + case 259: return "R_AARCH64_ABS16"; + case 260: return "R_AARCH64_PREL64"; + case 261: return "R_AARCH64_PREL32"; + case 262: return "R_AARCH64_PREL16"; + case 263: return "R_AARCH64_MOVW_UABS_G0"; + case 264: return "R_AARCH64_MOVW_UABS_G0_NC"; + case 265: return "R_AARCH64_MOVW_UABS_G1"; + case 266: return "R_AARCH64_MOVW_UABS_G1_NC"; + case 267: return "R_AARCH64_MOVW_UABS_G2"; + case 268: return "R_AARCH64_MOVW_UABS_G2_NC"; + case 269: return "R_AARCH64_MOVW_UABS_G3"; + case 270: return "R_AARCH64_MOVW_SABS_G0"; + case 271: return "R_AARCH64_MOVW_SABS_G1"; + case 272: return "R_AARCH64_MOVW_SABS_G2"; + case 273: return "R_AARCH64_LD_PREL_LO19"; + case 274: return "R_AARCH64_ADR_PREL_LO21"; + case 275: return "R_AARCH64_ADR_PREL_PG_HI21"; + case 276: return "R_AARCH64_ADR_PREL_PG_HI21_NC"; + case 277: return "R_AARCH64_ADD_ABS_LO12_NC"; + case 278: return "R_AARCH64_LDST8_ABS_LO12_NC"; + case 279: return "R_AARCH64_TSTBR14"; + case 280: return "R_AARCH64_CONDBR19"; + case 282: return "R_AARCH64_JUMP26"; + case 283: return "R_AARCH64_CALL26"; + case 284: return "R_AARCH64_LDST16_ABS_LO12_NC"; + case 285: return "R_AARCH64_LDST32_ABS_LO12_NC"; + case 286: return "R_AARCH64_LDST64_ABS_LO12_NC"; + case 287: return "R_AARCH64_MOVW_PREL_G0"; + case 288: return "R_AARCH64_MOVW_PREL_G0_NC"; + case 289: return "R_AARCH64_MOVW_PREL_G1"; + case 290: return "R_AARCH64_MOVW_PREL_G1_NC"; + case 291: return "R_AARCH64_MOVW_PREL_G2"; + case 292: return "R_AARCH64_MOVW_PREL_G2_NC"; + case 293: return "R_AARCH64_MOVW_PREL_G3"; + case 299: return "R_AARCH64_LDST128_ABS_LO12_NC"; + case 300: return "R_AARCH64_MOVW_GOTOFF_G0"; + case 301: return "R_AARCH64_MOVW_GOTOFF_G0_NC"; + case 302: return "R_AARCH64_MOVW_GOTOFF_G1"; + case 303: return "R_AARCH64_MOVW_GOTOFF_G1_NC"; + case 304: return "R_AARCH64_MOVW_GOTOFF_G2"; + case 305: return "R_AARCH64_MOVW_GOTOFF_G2_NC"; + case 306: return "R_AARCH64_MOVW_GOTOFF_G3"; + case 307: return "R_AARCH64_GOTREL64"; + case 308: return "R_AARCH64_GOTREL32"; + case 309: return "R_AARCH64_GOT_LD_PREL19"; + case 310: return "R_AARCH64_LD64_GOTOFF_LO15"; + case 311: return "R_AARCH64_ADR_GOT_PAGE"; + case 312: return "R_AARCH64_LD64_GOT_LO12_NC"; + case 313: return "R_AARCH64_LD64_GOTPAGE_LO15"; + case 560: return "R_AARCH64_TLSDESC_LD_PREL19"; + case 561: return "R_AARCH64_TLSDESC_ADR_PREL21"; + case 562: return "R_AARCH64_TLSDESC_ADR_PAGE21"; + case 563: return "R_AARCH64_TLSDESC_LD64_LO12"; + case 564: return "R_AARCH64_TLSDESC_ADD_LO12"; + case 565: return "R_AARCH64_TLSDESC_OFF_G1"; + case 566: return "R_AARCH64_TLSDESC_OFF_G0_NC"; + case 567: return "R_AARCH64_TLSDESC_LDR"; + case 568: return "R_AARCH64_TLSDESC_ADD"; + case 569: return "R_AARCH64_TLSDESC_CALL"; + case 1024: return "R_AARCH64_COPY"; + case 1025: return "R_AARCH64_GLOB_DAT"; + case 1026: return "R_AARCH64_JUMP_SLOT"; + case 1027: return "R_AARCH64_RELATIVE"; + case 1028: return "R_AARCH64_TLS_DTPREL64"; + case 1029: return "R_AARCH64_TLS_DTPMOD64"; + case 1030: return "R_AARCH64_TLS_TPREL64"; + case 1031: return "R_AARCH64_TLSDESC"; + case 1032: return "R_AARCH64_IRELATIVE"; + } + break; + case EM_ARM: + switch(type) { + case 0: return "R_ARM_NONE"; + case 1: return "R_ARM_PC24"; /* Deprecated */ + case 2: return "R_ARM_ABS32"; + case 3: return "R_ARM_REL32"; + case 4: return "R_ARM_LDR_PC_G0"; /* Also R_ARM_PC13 */ + case 5: return "R_ARM_ABS16"; + case 6: return "R_ARM_ABS12"; + case 7: return "R_ARM_THM_ABS5"; + case 8: return "R_ARM_ABS8"; + case 9: return "R_ARM_SBREL32"; + case 10: return "R_ARM_THM_CALL"; /* Also R_ARM_THM_PC22 */ + case 11: return "R_ARM_THM_PC8"; + case 12: return "R_ARM_BREL_ADJ"; /* Also R_ARM_AMP_VCALL9 */ + case 13: return "R_ARM_TLS_DESC"; /* Also R_ARM_SWI24 */ + case 14: return "R_ARM_THM_SWI8"; /* Obsolete */ + case 15: return "R_ARM_XPC25"; /* Obsolete */ + case 16: return "R_ARM_THM_XPC22"; /* Obsolete */ + case 17: return "R_ARM_TLS_DTPMOD32"; + case 18: return "R_ARM_TLS_DTPOFF32"; + case 19: return "R_ARM_TLS_TPOFF32"; + case 20: return "R_ARM_COPY"; + case 21: return "R_ARM_GLOB_DAT"; + case 22: return "R_ARM_JUMP_SLOT"; + case 23: return "R_ARM_RELATIVE"; + case 24: return "R_ARM_GOTOFF32"; /* Also R_ARM_GOTOFF */ + case 25: return "R_ARM_BASE_PREL"; /* GNU R_ARM_GOTPC */ + case 26: return "R_ARM_GOT_BREL"; /* GNU R_ARM_GOT32 */ + case 27: return "R_ARM_PLT32"; /* Deprecated */ + case 28: return "R_ARM_CALL"; + case 29: return "R_ARM_JUMP24"; + case 30: return "R_ARM_THM_JUMP24"; + case 31: return "R_ARM_BASE_ABS"; + case 32: return "R_ARM_ALU_PCREL_7_0"; /* Obsolete */ + case 33: return "R_ARM_ALU_PCREL_15_8"; /* Obsolete */ + case 34: return "R_ARM_ALU_PCREL_23_15"; /* Obsolete */ + case 35: return "R_ARM_LDR_SBREL_11_0_NC"; /* Deprecated */ + case 36: return "R_ARM_ALU_SBREL_19_12_NC"; /* Deprecated */ + case 37: return "R_ARM_ALU_SBREL_27_20_CK"; /* Deprecated */ + case 38: return "R_ARM_TARGET1"; + case 39: return "R_ARM_SBREL31"; /* Deprecated. */ + case 40: return "R_ARM_V4BX"; + case 41: return "R_ARM_TARGET2"; + case 42: return "R_ARM_PREL31"; + case 43: return "R_ARM_MOVW_ABS_NC"; + case 44: return "R_ARM_MOVT_ABS"; + case 45: return "R_ARM_MOVW_PREL_NC"; + case 46: return "R_ARM_MOVT_PREL"; + case 47: return "R_ARM_THM_MOVW_ABS_NC"; + case 48: return "R_ARM_THM_MOVT_ABS"; + case 49: return "R_ARM_THM_MOVW_PREL_NC"; + case 50: return "R_ARM_THM_MOVT_PREL"; + case 51: return "R_ARM_THM_JUMP19"; + case 52: return "R_ARM_THM_JUMP6"; + case 53: return "R_ARM_THM_ALU_PREL_11_0"; + case 54: return "R_ARM_THM_PC12"; + case 55: return "R_ARM_ABS32_NOI"; + case 56: return "R_ARM_REL32_NOI"; + case 57: return "R_ARM_ALU_PC_G0_NC"; + case 58: return "R_ARM_ALU_PC_G0"; + case 59: return "R_ARM_ALU_PC_G1_NC"; + case 60: return "R_ARM_ALU_PC_G1"; + case 61: return "R_ARM_ALU_PC_G2"; + case 62: return "R_ARM_LDR_PC_G1"; + case 63: return "R_ARM_LDR_PC_G2"; + case 64: return "R_ARM_LDRS_PC_G0"; + case 65: return "R_ARM_LDRS_PC_G1"; + case 66: return "R_ARM_LDRS_PC_G2"; + case 67: return "R_ARM_LDC_PC_G0"; + case 68: return "R_ARM_LDC_PC_G1"; + case 69: return "R_ARM_LDC_PC_G2"; + case 70: return "R_ARM_ALU_SB_G0_NC"; + case 71: return "R_ARM_ALU_SB_G0"; + case 72: return "R_ARM_ALU_SB_G1_NC"; + case 73: return "R_ARM_ALU_SB_G1"; + case 74: return "R_ARM_ALU_SB_G2"; + case 75: return "R_ARM_LDR_SB_G0"; + case 76: return "R_ARM_LDR_SB_G1"; + case 77: return "R_ARM_LDR_SB_G2"; + case 78: return "R_ARM_LDRS_SB_G0"; + case 79: return "R_ARM_LDRS_SB_G1"; + case 80: return "R_ARM_LDRS_SB_G2"; + case 81: return "R_ARM_LDC_SB_G0"; + case 82: return "R_ARM_LDC_SB_G1"; + case 83: return "R_ARM_LDC_SB_G2"; + case 84: return "R_ARM_MOVW_BREL_NC"; + case 85: return "R_ARM_MOVT_BREL"; + case 86: return "R_ARM_MOVW_BREL"; + case 87: return "R_ARM_THM_MOVW_BREL_NC"; + case 88: return "R_ARM_THM_MOVT_BREL"; + case 89: return "R_ARM_THM_MOVW_BREL"; + case 90: return "R_ARM_TLS_GOTDESC"; + case 91: return "R_ARM_TLS_CALL"; + case 92: return "R_ARM_TLS_DESCSEQ"; + case 93: return "R_ARM_THM_TLS_CALL"; + case 94: return "R_ARM_PLT32_ABS"; + case 95: return "R_ARM_GOT_ABS"; + case 96: return "R_ARM_GOT_PREL"; + case 97: return "R_ARM_GOT_BREL12"; + case 98: return "R_ARM_GOTOFF12"; + case 99: return "R_ARM_GOTRELAX"; + case 100: return "R_ARM_GNU_VTENTRY"; + case 101: return "R_ARM_GNU_VTINHERIT"; + case 102: return "R_ARM_THM_JUMP11"; /* Also R_ARM_THM_PC11 */ + case 103: return "R_ARM_THM_JUMP8"; /* Also R_ARM_THM_PC9 */ + case 104: return "R_ARM_TLS_GD32"; + case 105: return "R_ARM_TLS_LDM32"; + case 106: return "R_ARM_TLS_LDO32"; + case 107: return "R_ARM_TLS_IE32"; + case 108: return "R_ARM_TLS_LE32"; + case 109: return "R_ARM_TLS_LDO12"; + case 110: return "R_ARM_TLS_LE12"; + case 111: return "R_ARM_TLS_IE12GP"; + /* 112-127 R_ARM_PRIVATE_ */ + case 128: return "R_ARM_ME_TOO"; /* Obsolete */ + case 129: return "R_ARM_THM_TLS_DESCSEQ16"; + case 130: return "R_ARM_THM_TLS_DESCSEQ32"; + case 131: return "R_ARM_THM_GOT_BREL12"; + case 132: return "R_ARM_THM_ALU_ABS_G0_NC"; + case 133: return "R_ARM_THM_ALU_ABS_G1_NC"; + case 134: return "R_ARM_THM_ALU_ABS_G2_NC"; + case 135: return "R_ARM_THM_ALU_ABS_G3"; + /* 136-159 Reserved for future allocation. */ + case 160: return "R_ARM_IRELATIVE"; + /* 161-255 Reserved for future allocation. */ + case 249: return "R_ARM_RXPC25"; + case 250: return "R_ARM_RSBREL32"; + case 251: return "R_ARM_THM_RPC22"; + case 252: return "R_ARM_RREL32"; + case 253: return "R_ARM_RABS32"; + case 254: return "R_ARM_RPC24"; + case 255: return "R_ARM_RBASE"; + } + break; + case EM_IA_64: + switch(type) { + case 0: return "R_IA_64_NONE"; + case 33: return "R_IA_64_IMM14"; + case 34: return "R_IA_64_IMM22"; + case 35: return "R_IA_64_IMM64"; + case 36: return "R_IA_64_DIR32MSB"; + case 37: return "R_IA_64_DIR32LSB"; + case 38: return "R_IA_64_DIR64MSB"; + case 39: return "R_IA_64_DIR64LSB"; + case 42: return "R_IA_64_GPREL22"; + case 43: return "R_IA_64_GPREL64I"; + case 44: return "R_IA_64_GPREL32MSB"; + case 45: return "R_IA_64_GPREL32LSB"; + case 46: return "R_IA_64_GPREL64MSB"; + case 47: return "R_IA_64_GPREL64LSB"; + case 50: return "R_IA_64_LTOFF22"; + case 51: return "R_IA_64_LTOFF64I"; + case 58: return "R_IA_64_PLTOFF22"; + case 59: return "R_IA_64_PLTOFF64I"; + case 62: return "R_IA_64_PLTOFF64MSB"; + case 63: return "R_IA_64_PLTOFF64LSB"; + case 67: return "R_IA_64_FPTR64I"; + case 68: return "R_IA_64_FPTR32MSB"; + case 69: return "R_IA_64_FPTR32LSB"; + case 70: return "R_IA_64_FPTR64MSB"; + case 71: return "R_IA_64_FPTR64LSB"; + case 72: return "R_IA_64_PCREL60B"; + case 73: return "R_IA_64_PCREL21B"; + case 74: return "R_IA_64_PCREL21M"; + case 75: return "R_IA_64_PCREL21F"; + case 76: return "R_IA_64_PCREL32MSB"; + case 77: return "R_IA_64_PCREL32LSB"; + case 78: return "R_IA_64_PCREL64MSB"; + case 79: return "R_IA_64_PCREL64LSB"; + case 82: return "R_IA_64_LTOFF_FPTR22"; + case 83: return "R_IA_64_LTOFF_FPTR64I"; + case 84: return "R_IA_64_LTOFF_FPTR32MSB"; + case 85: return "R_IA_64_LTOFF_FPTR32LSB"; + case 86: return "R_IA_64_LTOFF_FPTR64MSB"; + case 87: return "R_IA_64_LTOFF_FPTR64LSB"; + case 92: return "R_IA_64_SEGREL32MSB"; + case 93: return "R_IA_64_SEGREL32LSB"; + case 94: return "R_IA_64_SEGREL64MSB"; + case 95: return "R_IA_64_SEGREL64LSB"; + case 100: return "R_IA_64_SECREL32MSB"; + case 101: return "R_IA_64_SECREL32LSB"; + case 102: return "R_IA_64_SECREL64MSB"; + case 103: return "R_IA_64_SECREL64LSB"; + case 108: return "R_IA_64_REL32MSB"; + case 109: return "R_IA_64_REL32LSB"; + case 110: return "R_IA_64_REL64MSB"; + case 111: return "R_IA_64_REL64LSB"; + case 116: return "R_IA_64_LTV32MSB"; + case 117: return "R_IA_64_LTV32LSB"; + case 118: return "R_IA_64_LTV64MSB"; + case 119: return "R_IA_64_LTV64LSB"; + case 121: return "R_IA_64_PCREL21BI"; + case 122: return "R_IA_64_PCREL22"; + case 123: return "R_IA_64_PCREL64I"; + case 128: return "R_IA_64_IPLTMSB"; + case 129: return "R_IA_64_IPLTLSB"; + case 133: return "R_IA_64_SUB"; + case 134: return "R_IA_64_LTOFF22X"; + case 135: return "R_IA_64_LDXMOV"; + case 145: return "R_IA_64_TPREL14"; + case 146: return "R_IA_64_TPREL22"; + case 147: return "R_IA_64_TPREL64I"; + case 150: return "R_IA_64_TPREL64MSB"; + case 151: return "R_IA_64_TPREL64LSB"; + case 154: return "R_IA_64_LTOFF_TPREL22"; + case 166: return "R_IA_64_DTPMOD64MSB"; + case 167: return "R_IA_64_DTPMOD64LSB"; + case 170: return "R_IA_64_LTOFF_DTPMOD22"; + case 177: return "R_IA_64_DTPREL14"; + case 178: return "R_IA_64_DTPREL22"; + case 179: return "R_IA_64_DTPREL64I"; + case 180: return "R_IA_64_DTPREL32MSB"; + case 181: return "R_IA_64_DTPREL32LSB"; + case 182: return "R_IA_64_DTPREL64MSB"; + case 183: return "R_IA_64_DTPREL64LSB"; + case 186: return "R_IA_64_LTOFF_DTPREL22"; + } + break; + case EM_MIPS: + switch(type) { + case 0: return "R_MIPS_NONE"; + case 1: return "R_MIPS_16"; + case 2: return "R_MIPS_32"; + case 3: return "R_MIPS_REL32"; + case 4: return "R_MIPS_26"; + case 5: return "R_MIPS_HI16"; + case 6: return "R_MIPS_LO16"; + case 7: return "R_MIPS_GPREL16"; + case 8: return "R_MIPS_LITERAL"; + case 9: return "R_MIPS_GOT16"; + case 10: return "R_MIPS_PC16"; + case 11: return "R_MIPS_CALL16"; + case 12: return "R_MIPS_GPREL32"; + case 16: return "R_MIPS_SHIFT5"; + case 17: return "R_MIPS_SHIFT6"; + case 18: return "R_MIPS_64"; + case 19: return "R_MIPS_GOT_DISP"; + case 20: return "R_MIPS_GOT_PAGE"; + case 21: return "R_MIPS_GOT_OFST"; + case 22: return "R_MIPS_GOT_HI16"; + case 23: return "R_MIPS_GOT_LO16"; + case 24: return "R_MIPS_SUB"; + case 30: return "R_MIPS_CALLHI16"; + case 31: return "R_MIPS_CALLLO16"; + case 37: return "R_MIPS_JALR"; + case 38: return "R_MIPS_TLS_DTPMOD32"; + case 39: return "R_MIPS_TLS_DTPREL32"; + case 40: return "R_MIPS_TLS_DTPMOD64"; + case 41: return "R_MIPS_TLS_DTPREL64"; + case 42: return "R_MIPS_TLS_GD"; + case 43: return "R_MIPS_TLS_LDM"; + case 44: return "R_MIPS_TLS_DTPREL_HI16"; + case 45: return "R_MIPS_TLS_DTPREL_LO16"; + case 46: return "R_MIPS_TLS_GOTTPREL"; + case 47: return "R_MIPS_TLS_TPREL32"; + case 48: return "R_MIPS_TLS_TPREL64"; + case 49: return "R_MIPS_TLS_TPREL_HI16"; + case 50: return "R_MIPS_TLS_TPREL_LO16"; + } + break; + case EM_PPC: + switch(type) { + case 0: return "R_PPC_NONE"; + case 1: return "R_PPC_ADDR32"; + case 2: return "R_PPC_ADDR24"; + case 3: return "R_PPC_ADDR16"; + case 4: return "R_PPC_ADDR16_LO"; + case 5: return "R_PPC_ADDR16_HI"; + case 6: return "R_PPC_ADDR16_HA"; + case 7: return "R_PPC_ADDR14"; + case 8: return "R_PPC_ADDR14_BRTAKEN"; + case 9: return "R_PPC_ADDR14_BRNTAKEN"; + case 10: return "R_PPC_REL24"; + case 11: return "R_PPC_REL14"; + case 12: return "R_PPC_REL14_BRTAKEN"; + case 13: return "R_PPC_REL14_BRNTAKEN"; + case 14: return "R_PPC_GOT16"; + case 15: return "R_PPC_GOT16_LO"; + case 16: return "R_PPC_GOT16_HI"; + case 17: return "R_PPC_GOT16_HA"; + case 18: return "R_PPC_PLTREL24"; + case 19: return "R_PPC_COPY"; + case 20: return "R_PPC_GLOB_DAT"; + case 21: return "R_PPC_JMP_SLOT"; + case 22: return "R_PPC_RELATIVE"; + case 23: return "R_PPC_LOCAL24PC"; + case 24: return "R_PPC_UADDR32"; + case 25: return "R_PPC_UADDR16"; + case 26: return "R_PPC_REL32"; + case 27: return "R_PPC_PLT32"; + case 28: return "R_PPC_PLTREL32"; + case 29: return "R_PPC_PLT16_LO"; + case 30: return "R_PPC_PLT16_HI"; + case 31: return "R_PPC_PLT16_HA"; + case 32: return "R_PPC_SDAREL16"; + case 33: return "R_PPC_SECTOFF"; + case 34: return "R_PPC_SECTOFF_LO"; + case 35: return "R_PPC_SECTOFF_HI"; + case 36: return "R_PPC_SECTOFF_HA"; + case 67: return "R_PPC_TLS"; + case 68: return "R_PPC_DTPMOD32"; + case 69: return "R_PPC_TPREL16"; + case 70: return "R_PPC_TPREL16_LO"; + case 71: return "R_PPC_TPREL16_HI"; + case 72: return "R_PPC_TPREL16_HA"; + case 73: return "R_PPC_TPREL32"; + case 74: return "R_PPC_DTPREL16"; + case 75: return "R_PPC_DTPREL16_LO"; + case 76: return "R_PPC_DTPREL16_HI"; + case 77: return "R_PPC_DTPREL16_HA"; + case 78: return "R_PPC_DTPREL32"; + case 79: return "R_PPC_GOT_TLSGD16"; + case 80: return "R_PPC_GOT_TLSGD16_LO"; + case 81: return "R_PPC_GOT_TLSGD16_HI"; + case 82: return "R_PPC_GOT_TLSGD16_HA"; + case 83: return "R_PPC_GOT_TLSLD16"; + case 84: return "R_PPC_GOT_TLSLD16_LO"; + case 85: return "R_PPC_GOT_TLSLD16_HI"; + case 86: return "R_PPC_GOT_TLSLD16_HA"; + case 87: return "R_PPC_GOT_TPREL16"; + case 88: return "R_PPC_GOT_TPREL16_LO"; + case 89: return "R_PPC_GOT_TPREL16_HI"; + case 90: return "R_PPC_GOT_TPREL16_HA"; + case 101: return "R_PPC_EMB_NADDR32"; + case 102: return "R_PPC_EMB_NADDR16"; + case 103: return "R_PPC_EMB_NADDR16_LO"; + case 104: return "R_PPC_EMB_NADDR16_HI"; + case 105: return "R_PPC_EMB_NADDR16_HA"; + case 106: return "R_PPC_EMB_SDAI16"; + case 107: return "R_PPC_EMB_SDA2I16"; + case 108: return "R_PPC_EMB_SDA2REL"; + case 109: return "R_PPC_EMB_SDA21"; + case 110: return "R_PPC_EMB_MRKREF"; + case 111: return "R_PPC_EMB_RELSEC16"; + case 112: return "R_PPC_EMB_RELST_LO"; + case 113: return "R_PPC_EMB_RELST_HI"; + case 114: return "R_PPC_EMB_RELST_HA"; + case 115: return "R_PPC_EMB_BIT_FLD"; + case 116: return "R_PPC_EMB_RELSDA"; + } + break; + case EM_RISCV: + switch(type) { + case 0: return "R_RISCV_NONE"; + case 1: return "R_RISCV_32"; + case 2: return "R_RISCV_64"; + case 3: return "R_RISCV_RELATIVE"; + case 4: return "R_RISCV_COPY"; + case 5: return "R_RISCV_JUMP_SLOT"; + case 6: return "R_RISCV_TLS_DTPMOD32"; + case 7: return "R_RISCV_TLS_DTPMOD64"; + case 8: return "R_RISCV_TLS_DTPREL32"; + case 9: return "R_RISCV_TLS_DTPREL64"; + case 10: return "R_RISCV_TLS_TPREL32"; + case 11: return "R_RISCV_TLS_TPREL64"; + case 16: return "R_RISCV_BRANCH"; + case 17: return "R_RISCV_JAL"; + case 18: return "R_RISCV_CALL"; + case 19: return "R_RISCV_CALL_PLT"; + case 20: return "R_RISCV_GOT_HI20"; + case 21: return "R_RISCV_TLS_GOT_HI20"; + case 22: return "R_RISCV_TLS_GD_HI20"; + case 23: return "R_RISCV_PCREL_HI20"; + case 24: return "R_RISCV_PCREL_LO12_I"; + case 25: return "R_RISCV_PCREL_LO12_S"; + case 26: return "R_RISCV_HI20"; + case 27: return "R_RISCV_LO12_I"; + case 28: return "R_RISCV_LO12_S"; + case 29: return "R_RISCV_TPREL_HI20"; + case 30: return "R_RISCV_TPREL_LO12_I"; + case 31: return "R_RISCV_TPREL_LO12_S"; + case 32: return "R_RISCV_TPREL_ADD"; + case 33: return "R_RISCV_ADD8"; + case 34: return "R_RISCV_ADD16"; + case 35: return "R_RISCV_ADD32"; + case 36: return "R_RISCV_ADD64"; + case 37: return "R_RISCV_SUB8"; + case 38: return "R_RISCV_SUB16"; + case 39: return "R_RISCV_SUB32"; + case 40: return "R_RISCV_SUB64"; + case 41: return "R_RISCV_GNU_VTINHERIT"; + case 42: return "R_RISCV_GNU_VTENTRY"; + case 43: return "R_RISCV_ALIGN"; + case 44: return "R_RISCV_RVC_BRANCH"; + case 45: return "R_RISCV_RVC_JUMP"; + } + break; + case EM_SPARC: + case EM_SPARCV9: + switch(type) { + case 0: return "R_SPARC_NONE"; + case 1: return "R_SPARC_8"; + case 2: return "R_SPARC_16"; + case 3: return "R_SPARC_32"; + case 4: return "R_SPARC_DISP8"; + case 5: return "R_SPARC_DISP16"; + case 6: return "R_SPARC_DISP32"; + case 7: return "R_SPARC_WDISP30"; + case 8: return "R_SPARC_WDISP22"; + case 9: return "R_SPARC_HI22"; + case 10: return "R_SPARC_22"; + case 11: return "R_SPARC_13"; + case 12: return "R_SPARC_LO10"; + case 13: return "R_SPARC_GOT10"; + case 14: return "R_SPARC_GOT13"; + case 15: return "R_SPARC_GOT22"; + case 16: return "R_SPARC_PC10"; + case 17: return "R_SPARC_PC22"; + case 18: return "R_SPARC_WPLT30"; + case 19: return "R_SPARC_COPY"; + case 20: return "R_SPARC_GLOB_DAT"; + case 21: return "R_SPARC_JMP_SLOT"; + case 22: return "R_SPARC_RELATIVE"; + case 23: return "R_SPARC_UA32"; + case 24: return "R_SPARC_PLT32"; + case 25: return "R_SPARC_HIPLT22"; + case 26: return "R_SPARC_LOPLT10"; + case 27: return "R_SPARC_PCPLT32"; + case 28: return "R_SPARC_PCPLT22"; + case 29: return "R_SPARC_PCPLT10"; + case 30: return "R_SPARC_10"; + case 31: return "R_SPARC_11"; + case 32: return "R_SPARC_64"; + case 33: return "R_SPARC_OLO10"; + case 34: return "R_SPARC_HH22"; + case 35: return "R_SPARC_HM10"; + case 36: return "R_SPARC_LM22"; + case 37: return "R_SPARC_PC_HH22"; + case 38: return "R_SPARC_PC_HM10"; + case 39: return "R_SPARC_PC_LM22"; + case 40: return "R_SPARC_WDISP16"; + case 41: return "R_SPARC_WDISP19"; + case 42: return "R_SPARC_GLOB_JMP"; + case 43: return "R_SPARC_7"; + case 44: return "R_SPARC_5"; + case 45: return "R_SPARC_6"; + case 46: return "R_SPARC_DISP64"; + case 47: return "R_SPARC_PLT64"; + case 48: return "R_SPARC_HIX22"; + case 49: return "R_SPARC_LOX10"; + case 50: return "R_SPARC_H44"; + case 51: return "R_SPARC_M44"; + case 52: return "R_SPARC_L44"; + case 53: return "R_SPARC_REGISTER"; + case 54: return "R_SPARC_UA64"; + case 55: return "R_SPARC_UA16"; + case 56: return "R_SPARC_TLS_GD_HI22"; + case 57: return "R_SPARC_TLS_GD_LO10"; + case 58: return "R_SPARC_TLS_GD_ADD"; + case 59: return "R_SPARC_TLS_GD_CALL"; + case 60: return "R_SPARC_TLS_LDM_HI22"; + case 61: return "R_SPARC_TLS_LDM_LO10"; + case 62: return "R_SPARC_TLS_LDM_ADD"; + case 63: return "R_SPARC_TLS_LDM_CALL"; + case 64: return "R_SPARC_TLS_LDO_HIX22"; + case 65: return "R_SPARC_TLS_LDO_LOX10"; + case 66: return "R_SPARC_TLS_LDO_ADD"; + case 67: return "R_SPARC_TLS_IE_HI22"; + case 68: return "R_SPARC_TLS_IE_LO10"; + case 69: return "R_SPARC_TLS_IE_LD"; + case 70: return "R_SPARC_TLS_IE_LDX"; + case 71: return "R_SPARC_TLS_IE_ADD"; + case 72: return "R_SPARC_TLS_LE_HIX22"; + case 73: return "R_SPARC_TLS_LE_LOX10"; + case 74: return "R_SPARC_TLS_DTPMOD32"; + case 75: return "R_SPARC_TLS_DTPMOD64"; + case 76: return "R_SPARC_TLS_DTPOFF32"; + case 77: return "R_SPARC_TLS_DTPOFF64"; + case 78: return "R_SPARC_TLS_TPOFF32"; + case 79: return "R_SPARC_TLS_TPOFF64"; + } + break; + case EM_X86_64: + switch(type) { + case 0: return "R_X86_64_NONE"; + case 1: return "R_X86_64_64"; + case 2: return "R_X86_64_PC32"; + case 3: return "R_X86_64_GOT32"; + case 4: return "R_X86_64_PLT32"; + case 5: return "R_X86_64_COPY"; + case 6: return "R_X86_64_GLOB_DAT"; + case 7: return "R_X86_64_JUMP_SLOT"; + case 8: return "R_X86_64_RELATIVE"; + case 9: return "R_X86_64_GOTPCREL"; + case 10: return "R_X86_64_32"; + case 11: return "R_X86_64_32S"; + case 12: return "R_X86_64_16"; + case 13: return "R_X86_64_PC16"; + case 14: return "R_X86_64_8"; + case 15: return "R_X86_64_PC8"; + case 16: return "R_X86_64_DTPMOD64"; + case 17: return "R_X86_64_DTPOFF64"; + case 18: return "R_X86_64_TPOFF64"; + case 19: return "R_X86_64_TLSGD"; + case 20: return "R_X86_64_TLSLD"; + case 21: return "R_X86_64_DTPOFF32"; + case 22: return "R_X86_64_GOTTPOFF"; + case 23: return "R_X86_64_TPOFF32"; + case 24: return "R_X86_64_PC64"; + case 25: return "R_X86_64_GOTOFF64"; + case 26: return "R_X86_64_GOTPC32"; + case 27: return "R_X86_64_GOT64"; + case 28: return "R_X86_64_GOTPCREL64"; + case 29: return "R_X86_64_GOTPC64"; + case 30: return "R_X86_64_GOTPLT64"; + case 31: return "R_X86_64_PLTOFF64"; + case 32: return "R_X86_64_SIZE32"; + case 33: return "R_X86_64_SIZE64"; + case 34: return "R_X86_64_GOTPC32_TLSDESC"; + case 35: return "R_X86_64_TLSDESC_CALL"; + case 36: return "R_X86_64_TLSDESC"; + case 37: return "R_X86_64_IRELATIVE"; + case 38: return "R_X86_64_RELATIVE64"; + case 41: return "R_X86_64_GOTPCRELX"; + case 42: return "R_X86_64_REX_GOTPCRELX"; + } + break; + } + + snprintf(s_type, sizeof(s_type), "", type); + return (s_type); +} Property changes on: vendor/elftoolchain/dist/libelftc/elftc_reloc_type_str.c ___________________________________________________________________ Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +FreeBSD=%H \ No newline at end of property Added: svn:mime-type ## -0,0 +1 ## +text/plain \ No newline at end of property Index: vendor/elftoolchain/dist/libelftc/libelftc.h =================================================================== --- vendor/elftoolchain/dist/libelftc/libelftc.h (revision 300227) +++ vendor/elftoolchain/dist/libelftc/libelftc.h (revision 300228) @@ -1,98 +1,99 @@ /*- * Copyright (c) 2009 Kai Wang * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer * in this position and unchanged. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * $FreeBSD: users/kaiwang27/elftc/libelftc.h 392 2009-05-31 19:17:46Z kaiwang27 $ - * $Id: libelftc.h 3309 2016-01-10 09:10:51Z kaiwang27 $ + * $Id: libelftc.h 3418 2016-02-19 20:04:42Z emaste $ */ #ifndef _LIBELFTC_H_ #define _LIBELFTC_H_ #include #include /* * Types meant to be opaque to the consumers of these APIs. */ typedef struct _Elftc_Bfd_Target Elftc_Bfd_Target; typedef struct _Elftc_String_Table Elftc_String_Table; /* Target types. */ typedef enum { ETF_NONE, ETF_ELF, ETF_BINARY, ETF_SREC, ETF_IHEX, ETF_PE, ETF_EFI, } Elftc_Bfd_Target_Flavor; /* * Demangler flags. */ /* Name mangling style. */ #define ELFTC_DEM_UNKNOWN 0x00000000U /* Not specified. */ #define ELFTC_DEM_ARM 0x00000001U /* C++ Ann. Ref. Manual. */ #define ELFTC_DEM_GNU2 0x00000002U /* GNU version 2. */ #define ELFTC_DEM_GNU3 0x00000004U /* GNU version 3. */ /* Demangling behaviour control. */ #define ELFTC_DEM_NOPARAM 0x00010000U #ifdef __cplusplus extern "C" { #endif Elftc_Bfd_Target *elftc_bfd_find_target(const char *_tgt_name); Elftc_Bfd_Target_Flavor elftc_bfd_target_flavor(Elftc_Bfd_Target *_tgt); unsigned int elftc_bfd_target_byteorder(Elftc_Bfd_Target *_tgt); unsigned int elftc_bfd_target_class(Elftc_Bfd_Target *_tgt); unsigned int elftc_bfd_target_machine(Elftc_Bfd_Target *_tgt); int elftc_copyfile(int _srcfd, int _dstfd); int elftc_demangle(const char *_mangledname, char *_buffer, size_t _bufsize, unsigned int _flags); +const char *elftc_reloc_type_str(unsigned int mach, unsigned int type); int elftc_set_timestamps(const char *_filename, struct stat *_sb); Elftc_String_Table *elftc_string_table_create(int _hint); void elftc_string_table_destroy(Elftc_String_Table *_table); Elftc_String_Table *elftc_string_table_from_section(Elf_Scn *_scn, int _hint); const char *elftc_string_table_image(Elftc_String_Table *_table, size_t *_sz); size_t elftc_string_table_insert(Elftc_String_Table *_table, const char *_string); size_t elftc_string_table_lookup(Elftc_String_Table *_table, const char *_string); int elftc_string_table_remove(Elftc_String_Table *_table, const char *_string); const char *elftc_string_table_to_string(Elftc_String_Table *_table, size_t offset); const char *elftc_version(void); #ifdef __cplusplus } #endif #endif /* _LIBELFTC_H_ */ Index: vendor/elftoolchain/dist/libelftc/libelftc_dem_arm.c =================================================================== --- vendor/elftoolchain/dist/libelftc/libelftc_dem_arm.c (revision 300227) +++ vendor/elftoolchain/dist/libelftc/libelftc_dem_arm.c (revision 300228) @@ -1,1227 +1,1227 @@ /*- * Copyright (c) 2008 Hyogeol Lee * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer * in this position and unchanged. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include #include #include #include #include #include #include #include #include #include #include "_libelftc.h" -ELFTC_VCSID("$Id: libelftc_dem_arm.c 2065 2011-10-26 15:24:47Z jkoshy $"); +ELFTC_VCSID("$Id: libelftc_dem_arm.c 3447 2016-05-03 13:32:23Z emaste $"); /** * @file cpp_demangle_arm.c * @brief Decode function name encoding in ARM. * * Function name encoding in "The Annotated C++ Reference Manual". * * Ref : "The Annotated C++ Reference Manual", Margaet A.Ellis, * Bjarne Stroustrup, AT&T Bell Laboratories 1990, pp 122-126. */ enum encode_type { ENCODE_FUNC, ENCODE_OP, ENCODE_OP_CT, ENCODE_OP_DT, ENCODE_OP_USER }; struct cstring { char *buf; size_t size; }; struct demangle_data { bool ptr, ref, cnst, array; struct cstring array_str; const char *p; enum encode_type type; struct vector_str vec; struct vector_str arg; }; #define SIMPLE_HASH(x,y) (64 * x + y) #define CPP_DEMANGLE_ARM_TRY 128 static void dest_cstring(struct cstring *); static void dest_demangle_data(struct demangle_data *); static bool init_cstring(struct cstring *, size_t); static bool init_demangle_data(struct demangle_data *); static bool push_CTDT(const char *, size_t, struct vector_str *); static bool read_array(struct demangle_data *); static bool read_class(struct demangle_data *); static bool read_func(struct demangle_data *); static bool read_func_name(struct demangle_data *); static bool read_func_ptr(struct demangle_data *); static bool read_memptr(struct demangle_data *); static bool read_op(struct demangle_data *); static bool read_op_user(struct demangle_data *); static bool read_qual_name(struct demangle_data *); static int read_subst(struct demangle_data *); static int read_subst_iter(struct demangle_data *); static bool read_type(struct demangle_data *); /** * @brief Decode the input string by the ARM style. * * @return New allocated demangled string or NULL if failed. */ char * cpp_demangle_ARM(const char *org) { struct demangle_data d; size_t arg_begin, arg_len; unsigned int try; char *rtn, *arg; if (org == NULL) return (NULL); if (init_demangle_data(&d) == false) return (NULL); try = 0; rtn = NULL; d.p = org; if (read_func_name(&d) == false) goto clean; if (d.type == ENCODE_OP_CT) { if (push_CTDT("::", 2, &d.vec) == false) goto clean; goto flat; } if (d.type == ENCODE_OP_DT) { if (push_CTDT("::~", 3, &d.vec) == false) goto clean; goto flat; } if (d.type == ENCODE_OP_USER) goto flat; /* function type */ if (*d.p != 'F') goto clean; ++d.p; /* start argument types */ if (vector_str_push(&d.vec, "(", 1) == false) goto clean; for (;;) { if (*d.p == 'T') { const int rtn_subst = read_subst(&d); if (rtn_subst == -1) goto clean; else if (rtn_subst == 1) break; continue; } if (*d.p == 'N') { const int rtn_subst_iter = read_subst_iter(&d); if (rtn_subst_iter == -1) goto clean; else if(rtn_subst_iter == 1) break; continue; } arg_begin = d.vec.size; if (read_type(&d) == false) goto clean; if (d.ptr == true) { if (vector_str_push(&d.vec, "*", 1) == false) goto clean; d.ptr = false; } if (d.ref == true) { if (vector_str_push(&d.vec, "&", 1) == false) goto clean; d.ref = false; } if (d.cnst == true) { if (vector_str_push(&d.vec, " const", 6) == false) goto clean; d.cnst = false; } if (d.array == true) { if (vector_str_push(&d.vec, d.array_str.buf, d.array_str.size) == false) goto clean; dest_cstring(&d.array_str); d.array = false; } if (*d.p == '\0') break; if ((arg = vector_str_substr(&d.vec, arg_begin, d.vec.size - 1, &arg_len)) == NULL) goto clean; if (vector_str_push(&d.arg, arg, arg_len) == false) goto clean; free(arg); if (vector_str_push(&d.vec, ", ", 2) == false) goto clean; if (++try > CPP_DEMANGLE_ARM_TRY) goto clean; } /* end argument types */ if (vector_str_push(&d.vec, ")", 1) == false) goto clean; flat: rtn = vector_str_get_flat(&d.vec, NULL); clean: dest_demangle_data(&d); return (rtn); } /** * @brief Test input string is encoded by the ARM style. * * @return True if input string is encoded by the ARM style. */ bool is_cpp_mangled_ARM(const char *org) { if (org == NULL) return (false); return (strstr(org, "__") != NULL); } static void dest_cstring(struct cstring *s) { if (s == NULL) return; free(s->buf); s->buf = NULL; s->size = 0; } static void dest_demangle_data(struct demangle_data *d) { if (d != NULL) { vector_str_dest(&d->arg); vector_str_dest(&d->vec); dest_cstring(&d->array_str); } } static bool init_cstring(struct cstring *s, size_t len) { if (s == NULL || len <= 1) return (false); if ((s->buf = malloc(sizeof(char) * len)) == NULL) return (false); s->size = len - 1; return (true); } static bool init_demangle_data(struct demangle_data *d) { if (d == NULL) return (false); d->ptr = false; d->ref = false; d->cnst = false; d->array = false; d->array_str.buf = NULL; d->array_str.size = 0; d->type = ENCODE_FUNC; if (vector_str_init(&d->vec) == false) return (false); if (vector_str_init(&d->arg) == false) { vector_str_dest(&d->vec); return (false); } return (true); } static bool push_CTDT(const char *s, size_t l, struct vector_str *v) { if (s == NULL || l == 0 || v == NULL) return (false); if (vector_str_push(v, s, l) == false) return (false); assert(v->size > 1); if (vector_str_push(v, v->container[v->size - 2], strlen(v->container[v->size - 2])) == false) return (false); if (vector_str_push(v, "()", 2) == false) return (false); return (true); } static bool read_array(struct demangle_data *d) { size_t len; const char *end; if (d == NULL || d->p == NULL) return (false); end = d->p; assert(end != NULL); for (;;) { if (*end == '\0') return (false); if (ELFTC_ISDIGIT(*end) == 0) break; ++end; } if (*end != '_') return (false); len = end - d->p; assert(len > 0); dest_cstring(&d->array_str); if (init_cstring(&d->array_str, len + 3) == false) return (false); strncpy(d->array_str.buf + 1, d->p, len); *d->array_str.buf = '['; *(d->array_str.buf + len + 1) = ']'; d->array = true; d->p = end + 1; return (true); } static bool read_class(struct demangle_data *d) { size_t len; char *str; if (d == NULL) return (false); len = strtol(d->p, &str, 10); if (len == 0 && (errno == EINVAL || errno == ERANGE)) return (false); assert(len > 0); assert(str != NULL); if (vector_str_push(&d->vec, str, len) == false) return (false); d->p = str + len; return (true); } static bool read_func(struct demangle_data *d) { size_t len; const char *name; char *delim; if (d == NULL) return (false); assert(d->p != NULL && "d->p (org str) is NULL"); if ((delim = strstr(d->p, "__")) == NULL) return (false); len = delim - d->p; assert(len != 0); name = d->p; d->p = delim + 2; if (*d->p == 'Q' && ELFTC_ISDIGIT(*(d->p + 1))) { ++d->p; if (read_qual_name(d) == false) return (false); } else if (ELFTC_ISDIGIT(*d->p)) { if (read_class(d) == false) return (false); if (vector_str_push(&d->vec, "::", 2) == false) return (false); } if (vector_str_push(&d->vec, name, len) == false) return (false); return (true); } static bool read_func_name(struct demangle_data *d) { size_t len; bool rtn; char *op_name; if (d == NULL) return (false); rtn = false; op_name = NULL; assert(d->p != NULL && "d->p (org str) is NULL"); if (*d->p == '_' && *(d->p + 1) == '_') { d->p += 2; d->type = ENCODE_OP; if (read_op(d) == false) return (false); if (d->type == ENCODE_OP_CT || d->type == ENCODE_OP_DT || d->type == ENCODE_OP_USER) return (true); /* skip "__" */ d->p += 2; /* assume delimiter is removed */ if (*d->p == 'Q' && ELFTC_ISDIGIT(*(d->p + 1))) { ++d->p; assert(d->vec.size > 0); len = strlen(d->vec.container[d->vec.size - 1]); if ((op_name = malloc(sizeof(char) * (len + 1))) == NULL) return (false); snprintf(op_name, len + 1, "%s", d->vec.container[d->vec.size - 1]); vector_str_pop(&d->vec); if (read_qual_name(d) == false) goto clean; if (vector_str_push(&d->vec, "::", 2) == false) goto clean; if (vector_str_push(&d->vec, op_name, len) == false) goto clean; rtn = true; } else if (ELFTC_ISDIGIT(*d->p)) { assert(d->vec.size > 0); len = strlen(d->vec.container[d->vec.size - 1]); if ((op_name = malloc(sizeof(char) * (len + 1))) == NULL) return (false); snprintf(op_name, len + 1, "%s", d->vec.container[d->vec.size - 1]); vector_str_pop(&d->vec); if (read_class(d) == false) goto clean; if (vector_str_push(&d->vec, "::", 2) == false) goto clean; if (vector_str_push(&d->vec, op_name, len) == false) goto clean; rtn = true; } } else return (read_func(d)); clean: free(op_name); return (rtn); } /* Read function ptr type */ static bool read_func_ptr(struct demangle_data *d) { struct demangle_data fptr; size_t arg_len, rtn_len; char *arg_type, *rtn_type; int lim; if (d == NULL) return (false); if (init_demangle_data(&fptr) == false) return (false); fptr.p = d->p + 1; lim = 0; arg_type = NULL; rtn_type = NULL; for (;;) { if (read_type(&fptr) == false) { dest_demangle_data(&fptr); return (false); } if (fptr.ptr == true) { if (vector_str_push(&fptr.vec, "*", 1) == false) { dest_demangle_data(&fptr); return (false); } fptr.ptr = false; } if (fptr.ref == true) { if (vector_str_push(&fptr.vec, "&", 1) == false) { dest_demangle_data(&fptr); return (false); } fptr.ref = false; } if (fptr.cnst == true) { if (vector_str_push(&fptr.vec, " const", 6) == false) { dest_demangle_data(&fptr); return (false); } fptr.cnst = false; } if (*fptr.p == '_') break; if (vector_str_push(&fptr.vec, ", ", 2) == false) { dest_demangle_data(&fptr); return (false); } if (++lim > CPP_DEMANGLE_ARM_TRY) { dest_demangle_data(&fptr); return (false); } } arg_type = vector_str_get_flat(&fptr.vec, &arg_len); /* skip '_' */ d->p = fptr.p + 1; dest_demangle_data(&fptr); if (init_demangle_data(&fptr) == false) { free(arg_type); return (false); } fptr.p = d->p; lim = 0; if (read_type(&fptr) == false) { free(arg_type); dest_demangle_data(&fptr); return (false); } rtn_type = vector_str_get_flat(&fptr.vec, &rtn_len); d->p = fptr.p; dest_demangle_data(&fptr); if (vector_str_push(&d->vec, rtn_type, rtn_len) == false) { free(rtn_type); free(arg_type); return (false); } free(rtn_type); if (vector_str_push(&d->vec, " (*)(", 5) == false) { free(arg_type); return (false); } if (vector_str_push(&d->vec, arg_type, arg_len) == false) { free(arg_type); return (false); } free(arg_type); return (vector_str_push(&d->vec, ")", 1)); } static bool read_memptr(struct demangle_data *d) { struct demangle_data mptr; size_t len; bool rtn; char *mptr_str; if (d == NULL || d->p == NULL) return (false); if (init_demangle_data(&mptr) == false) return (false); rtn = false; mptr_str = NULL; mptr.p = d->p; if (*mptr.p == 'Q') { ++mptr.p; if (read_qual_name(&mptr) == false) goto clean; } else { if (read_class(&mptr) == false) goto clean; } d->p = mptr.p; if ((mptr_str = vector_str_get_flat(&mptr.vec, &len)) == NULL) goto clean; if (vector_str_push(&d->vec, mptr_str, len) == false) goto clean; if (vector_str_push(&d->vec, "::*", 3) == false) goto clean; rtn = true; clean: free(mptr_str); dest_demangle_data(&mptr); return (rtn); } static bool read_op(struct demangle_data *d) { if (d == NULL) return (false); assert(d->p != NULL && "d->p (org str) is NULL"); switch (SIMPLE_HASH(*(d->p), *(d->p+1))) { case SIMPLE_HASH('m', 'l') : d->p += 2; return (vector_str_push(&d->vec, "operator*", 9)); case SIMPLE_HASH('d', 'v') : d->p += 2; return (vector_str_push(&d->vec, "operator/", 9)); case SIMPLE_HASH('m', 'd') : d->p += 2; return (vector_str_push(&d->vec, "operator%", 9)); case SIMPLE_HASH('p', 'l') : d->p += 2; return (vector_str_push(&d->vec, "operator+", 9)); case SIMPLE_HASH('m', 'i') : d->p += 2; return (vector_str_push(&d->vec, "operator-", 9)); case SIMPLE_HASH('l', 's') : d->p += 2; return (vector_str_push(&d->vec, "operator<<", 10)); case SIMPLE_HASH('r', 's') : d->p += 2; return (vector_str_push(&d->vec, "operator>>", 10)); case SIMPLE_HASH('e', 'q') : d->p += 2; return (vector_str_push(&d->vec, "operator==", 10)); case SIMPLE_HASH('n', 'e') : d->p += 2; return (vector_str_push(&d->vec, "operator!=", 10)); case SIMPLE_HASH('l', 't') : d->p += 2; return (vector_str_push(&d->vec, "operator<", 9)); case SIMPLE_HASH('g', 't') : d->p += 2; return (vector_str_push(&d->vec, "operator>", 9)); case SIMPLE_HASH('l', 'e') : d->p += 2; return (vector_str_push(&d->vec, "operator<=", 10)); case SIMPLE_HASH('g', 'e') : d->p += 2; return (vector_str_push(&d->vec, "operator>=", 10)); case SIMPLE_HASH('a', 'd') : d->p += 2; if (*d->p == 'v') { ++d->p; return (vector_str_push(&d->vec, "operator/=", 10)); } else return (vector_str_push(&d->vec, "operator&", 9)); case SIMPLE_HASH('o', 'r') : d->p += 2; return (vector_str_push(&d->vec, "operator|", 9)); case SIMPLE_HASH('e', 'r') : d->p += 2; return (vector_str_push(&d->vec, "operator^", 9)); case SIMPLE_HASH('a', 'a') : d->p += 2; if (*d->p == 'd') { ++d->p; return (vector_str_push(&d->vec, "operator&=", 10)); } else return (vector_str_push(&d->vec, "operator&&", 10)); case SIMPLE_HASH('o', 'o') : d->p += 2; return (vector_str_push(&d->vec, "operator||", 10)); case SIMPLE_HASH('n', 't') : d->p += 2; return (vector_str_push(&d->vec, "operator!", 9)); case SIMPLE_HASH('c', 'o') : d->p += 2; return (vector_str_push(&d->vec, "operator~", 9)); case SIMPLE_HASH('p', 'p') : d->p += 2; return (vector_str_push(&d->vec, "operator++", 10)); case SIMPLE_HASH('m', 'm') : d->p += 2; return (vector_str_push(&d->vec, "operator--", 10)); case SIMPLE_HASH('a', 's') : d->p += 2; return (vector_str_push(&d->vec, "operator=", 9)); case SIMPLE_HASH('r', 'f') : d->p += 2; return (vector_str_push(&d->vec, "operator->", 10)); case SIMPLE_HASH('a', 'p') : /* apl */ if (*(d->p + 2) != 'l') return (false); d->p += 3; return (vector_str_push(&d->vec, "operator+=", 10)); case SIMPLE_HASH('a', 'm') : d->p += 2; if (*d->p == 'i') { ++d->p; return (vector_str_push(&d->vec, "operator-=", 10)); } else if (*d->p == 'u') { ++d->p; return (vector_str_push(&d->vec, "operator*=", 10)); } else if (*d->p == 'd') { ++d->p; return (vector_str_push(&d->vec, "operator%=", 10)); } return (false); case SIMPLE_HASH('a', 'l') : /* als */ if (*(d->p + 2) != 's') return (false); d->p += 3; return (vector_str_push(&d->vec, "operator<<=", 11)); case SIMPLE_HASH('a', 'r') : /* ars */ if (*(d->p + 2) != 's') return (false); d->p += 3; return (vector_str_push(&d->vec, "operator>>=", 11)); case SIMPLE_HASH('a', 'o') : /* aor */ if (*(d->p + 2) != 'r') return (false); d->p += 3; return (vector_str_push(&d->vec, "operator|=", 10)); case SIMPLE_HASH('a', 'e') : /* aer */ if (*(d->p + 2) != 'r') return (false); d->p += 3; return (vector_str_push(&d->vec, "operator^=", 10)); case SIMPLE_HASH('c', 'm') : d->p += 2; return (vector_str_push(&d->vec, "operator,", 9)); case SIMPLE_HASH('r', 'm') : d->p += 2; return (vector_str_push(&d->vec, "operator->*", 11)); case SIMPLE_HASH('c', 'l') : d->p += 2; return (vector_str_push(&d->vec, "()", 2)); case SIMPLE_HASH('v', 'c') : d->p += 2; return (vector_str_push(&d->vec, "[]", 2)); case SIMPLE_HASH('c', 't') : d->p += 4; d->type = ENCODE_OP_CT; if (*d->p == 'Q' && ELFTC_ISDIGIT(*(d->p + 1))) { ++d->p; return (read_qual_name(d)); } else if (ELFTC_ISDIGIT(*d->p)) return (read_class(d)); return (false); case SIMPLE_HASH('d', 't') : d->p += 4; d->type = ENCODE_OP_DT; if (*d->p == 'Q' && ELFTC_ISDIGIT(*(d->p + 1))) { ++d->p; return (read_qual_name(d)); } else if (ELFTC_ISDIGIT(*d->p)) return (read_class(d)); return (false); case SIMPLE_HASH('n', 'w') : d->p += 2; return (vector_str_push(&d->vec, "operator new()", 14)); case SIMPLE_HASH('d', 'l') : d->p += 2; return (vector_str_push(&d->vec, "operator delete()", 17)); case SIMPLE_HASH('o', 'p') : /* __op__ */ d->p += 2; d->type = ENCODE_OP_USER; return (read_op_user(d)); default : return (false); }; } static bool read_op_user(struct demangle_data *d) { struct demangle_data from, to; size_t from_len, to_len; bool rtn; char *from_str, *to_str; if (d == NULL) return (false); if (init_demangle_data(&from) == false) return (false); rtn = false; from_str = NULL; to_str = NULL; if (init_demangle_data(&to) == false) goto clean; to.p = d->p; if (*to.p == 'Q') { ++to.p; if (read_qual_name(&to) == false) goto clean; /* pop last '::' */ if (vector_str_pop(&to.vec) == false) goto clean; } else { if (read_class(&to) == false) goto clean; /* skip '__' */ to.p += 2; } if ((to_str = vector_str_get_flat(&to.vec, &to_len)) == NULL) goto clean; from.p = to.p; if (*from.p == 'Q') { ++from.p; if (read_qual_name(&from) == false) goto clean; /* pop last '::' */ if (vector_str_pop(&from.vec) == false) goto clean; } else { if (read_class(&from) == false) goto clean; } if ((from_str = vector_str_get_flat(&from.vec, &from_len)) == NULL) goto clean; if (vector_str_push(&d->vec, from_str, from_len) == false) goto clean; if (vector_str_push(&d->vec, "::operator ", 11) == false) return (false); if (vector_str_push(&d->vec, to_str, to_len) == false) goto clean; rtn = vector_str_push(&d->vec, "()", 2); clean: free(to_str); free(from_str); dest_demangle_data(&to); dest_demangle_data(&from); return (rtn); } /* single digit + class names */ static bool read_qual_name(struct demangle_data *d) { int i; char num; if (d == NULL) return (false); assert(d->p != NULL && "d->p (org str) is NULL"); assert(*d->p > 48 && *d->p < 58 && "*d->p not in ASCII numeric range"); num = *d->p - 48; assert(num > 0); ++d->p; for (i = 0; i < num ; ++i) { if (read_class(d) == false) return (false); if (vector_str_push(&d->vec, "::", 2) == false) return (false); } if (*d->p != '\0') d->p = d->p + 2; return (true); } /* Return -1 at fail, 0 at success, and 1 at end */ static int read_subst(struct demangle_data *d) { size_t idx; char *str; if (d == NULL) return (-1); idx = strtol(d->p + 1, &str, 10); if (idx == 0 && (errno == EINVAL || errno == ERANGE)) return (-1); assert(idx > 0); assert(str != NULL); d->p = str; if (vector_str_push(&d->vec, d->arg.container[idx - 1], strlen(d->arg.container[idx - 1])) == false) return (-1); if (vector_str_push(&d->arg, d->arg.container[idx - 1], strlen(d->arg.container[idx - 1])) == false) return (-1); if (*d->p == '\0') return (1); return (0); } static int read_subst_iter(struct demangle_data *d) { int i; size_t idx; char repeat; char *str; if (d == NULL) return (-1); ++d->p; assert(*d->p > 48 && *d->p < 58 && "*d->p not in ASCII numeric range"); repeat = *d->p - 48; assert(repeat > 1); ++d->p; idx = strtol(d->p, &str, 10); if (idx == 0 && (errno == EINVAL || errno == ERANGE)) return (-1); assert(idx > 0); assert(str != NULL); d->p = str; for (i = 0; i < repeat ; ++i) { if (vector_str_push(&d->vec, d->arg.container[idx - 1], strlen(d->arg.container[idx - 1])) == false) return (-1); if (vector_str_push(&d->arg, d->arg.container[idx - 1], strlen(d->arg.container[idx - 1])) == false) return (-1); if (i != repeat - 1 && vector_str_push(&d->vec, ", ", 2) == false) return (-1); } if (*d->p == '\0') return (1); return (0); } static bool read_type(struct demangle_data *d) { if (d == NULL) return (false); assert(d->p != NULL && "d->p (org str) is NULL"); while (*d->p == 'U' || *d->p == 'C' || *d->p == 'V' || *d->p == 'S' || *d->p == 'P' || *d->p == 'R' || *d->p == 'A' || *d->p == 'F' || *d->p == 'M') { switch (*d->p) { case 'U' : ++d->p; if (vector_str_push(&d->vec, "unsigned ", 9) == false) return (false); break; case 'C' : ++d->p; if (*d->p == 'P') d->cnst = true; else { if (vector_str_push(&d->vec, "const ", 6) == false) return (false); } break; case 'V' : ++d->p; if (vector_str_push(&d->vec, "volatile ", 9) == false) return (false); break; case 'S' : ++d->p; if (vector_str_push(&d->vec, "signed ", 7) == false) return (false); break; case 'P' : ++d->p; if (*d->p == 'F') return (read_func_ptr(d)); else d->ptr = true; break; case 'R' : ++d->p; d->ref = true; break; case 'F' : break; case 'A' : ++d->p; if (read_array(d) == false) return (false); break; case 'M' : ++d->p; if (read_memptr(d) == false) return (false); break; default : break; - }; - }; + } + } if (ELFTC_ISDIGIT(*d->p)) return (read_class(d)); switch (*d->p) { case 'Q' : ++d->p; return (read_qual_name(d)); case 'v' : ++d->p; return (vector_str_push(&d->vec, "void", 4)); case 'c' : ++d->p; return (vector_str_push(&d->vec, "char", 4)); case 's' : ++d->p; return (vector_str_push(&d->vec, "short", 5)); case 'i' : ++d->p; return (vector_str_push(&d->vec, "int", 3)); case 'l' : ++d->p; return (vector_str_push(&d->vec, "long", 4)); case 'f' : ++d->p; return (vector_str_push(&d->vec, "float", 5)); case 'd': ++d->p; return (vector_str_push(&d->vec, "double", 6)); case 'r': ++d->p; return (vector_str_push(&d->vec, "long double", 11)); case 'e': ++d->p; return (vector_str_push(&d->vec, "...", 3)); default: return (false); }; /* NOTREACHED */ return (false); } Index: vendor/elftoolchain/dist/libelftc/libelftc_dem_gnu2.c =================================================================== --- vendor/elftoolchain/dist/libelftc/libelftc_dem_gnu2.c (revision 300227) +++ vendor/elftoolchain/dist/libelftc/libelftc_dem_gnu2.c (revision 300228) @@ -1,1376 +1,1376 @@ /*- * Copyright (c) 2008 Hyogeol Lee * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer * in this position and unchanged. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include #include #include #include #include #include #include #include #include #include #include "_libelftc.h" -ELFTC_VCSID("$Id: libelftc_dem_gnu2.c 2065 2011-10-26 15:24:47Z jkoshy $"); +ELFTC_VCSID("$Id: libelftc_dem_gnu2.c 3447 2016-05-03 13:32:23Z emaste $"); /** * @file cpp_demangle_gnu2.c * @brief Decode function name encoding in GNU 2. * * Function name encoding in GNU 2 based on ARM style. */ enum encode_type { ENCODE_FUNC, ENCODE_OP, ENCODE_OP_CT, ENCODE_OP_DT, ENCODE_OP_USER, ENCODE_OP_TF, ENCODE_OP_TI, ENCODE_OP_VT }; struct cstring { char *buf; size_t size; }; struct demangle_data { bool ptr, ref, cnst, array, cnst_fn, class_name; struct cstring array_str; const char *p; enum encode_type type; struct vector_str vec; struct vector_str arg; }; #define SIMPLE_HASH(x,y) (64 * x + y) #define CPP_DEMANGLE_GNU2_TRY 128 static void dest_cstring(struct cstring *); static void dest_demangle_data(struct demangle_data *); static bool init_cstring(struct cstring *, size_t); static bool init_demangle_data(struct demangle_data *); static bool push_CTDT(const char *, size_t, struct vector_str *); static bool read_array(struct demangle_data *); static bool read_class(struct demangle_data *); static bool read_func(struct demangle_data *); static bool read_func_name(struct demangle_data *); static bool read_func_ptr(struct demangle_data *); static bool read_memptr(struct demangle_data *); static bool read_op(struct demangle_data *); static bool read_op_user(struct demangle_data *); static bool read_qual_name(struct demangle_data *); static int read_subst(struct demangle_data *); static int read_subst_iter(struct demangle_data *); static bool read_type(struct demangle_data *); /** * @brief Decode the input string by the GNU 2 style. * * @return New allocated demangled string or NULL if failed. */ char * cpp_demangle_gnu2(const char *org) { struct demangle_data d; size_t arg_begin, arg_len; unsigned int try; char *rtn, *arg; if (org == NULL) return (NULL); if (init_demangle_data(&d) == false) return (NULL); try = 0; rtn = NULL; d.p = org; if (read_func_name(&d) == false) goto clean; switch (d.type) { case ENCODE_FUNC : case ENCODE_OP : break; case ENCODE_OP_CT : if (push_CTDT("::", 2, &d.vec) == false) goto clean; break; case ENCODE_OP_DT : if (push_CTDT("::~", 3, &d.vec) == false) goto clean; if (vector_str_push(&d.vec, "(void)", 6) == false) goto clean; goto flat; case ENCODE_OP_USER : case ENCODE_OP_TF : case ENCODE_OP_TI : case ENCODE_OP_VT : goto flat; - }; + } if (*d.p == 'F') ++d.p; else if (*d.p == '\0') { if (d.class_name == true) { if (vector_str_push(&d.vec, "(void)", 6) == false) goto clean; goto flat; } else goto clean; } /* start argument types */ if (vector_str_push(&d.vec, "(", 1) == false) goto clean; for (;;) { if (*d.p == 'T') { const int rtn_subst = read_subst(&d); if (rtn_subst == -1) goto clean; else if (rtn_subst == 1) break; continue; } if (*d.p == 'N') { const int rtn_subst_iter = read_subst_iter(&d); if (rtn_subst_iter == -1) goto clean; else if(rtn_subst_iter == 1) break; continue; } arg_begin = d.vec.size; if (read_type(&d) == false) goto clean; if (d.ptr == true) { if (vector_str_push(&d.vec, "*", 1) == false) goto clean; d.ptr = false; } if (d.ref == true) { if (vector_str_push(&d.vec, "&", 1) == false) goto clean; d.ref = false; } if (d.cnst == true) { if (vector_str_push(&d.vec, " const", 6) == false) goto clean; d.cnst = false; } if (d.array == true) { if (vector_str_push(&d.vec, d.array_str.buf, d.array_str.size) == false) goto clean; dest_cstring(&d.array_str); d.array = false; } if (*d.p == '\0') break; if ((arg = vector_str_substr(&d.vec, arg_begin, d.vec.size - 1, &arg_len)) == NULL) goto clean; if (vector_str_push(&d.arg, arg, arg_len) == false) goto clean; free(arg); if (vector_str_push(&d.vec, ", ", 2) == false) goto clean; if (++try > CPP_DEMANGLE_GNU2_TRY) goto clean; } /* end argument types */ if (vector_str_push(&d.vec, ")", 1) == false) goto clean; flat: if (d.cnst_fn == true && vector_str_push(&d.vec, " const", 6) == false) goto clean; rtn = vector_str_get_flat(&d.vec, NULL); clean: dest_demangle_data(&d); return (rtn); } /** * @brief Test input string is encoded by the GNU 2 style. * * @return True if input string is encoded by the GNU 2 style. */ bool is_cpp_mangled_gnu2(const char *org) { char *str; bool rtn = false; if (org == NULL) return (false); /* search valid text to end */ str = strstr(org, "__"); while (str != NULL) { if (*(str + 2) != '\0') { if (*(str + 2) == 'C' || *(str + 2) == 'F' || *(str + 2) == 'Q' || ELFTC_ISDIGIT(*(str + 2))) { rtn |= true; break; } if (*(str + 3) != '\0') { switch (SIMPLE_HASH(*(str + 2), *(str + 3))) { case SIMPLE_HASH('m', 'l') : case SIMPLE_HASH('d', 'v') : case SIMPLE_HASH('m', 'd') : case SIMPLE_HASH('p', 'l') : case SIMPLE_HASH('m', 'i') : case SIMPLE_HASH('l', 's') : case SIMPLE_HASH('r', 's') : case SIMPLE_HASH('e', 'q') : case SIMPLE_HASH('n', 'e') : case SIMPLE_HASH('l', 't') : case SIMPLE_HASH('g', 't') : case SIMPLE_HASH('l', 'e') : case SIMPLE_HASH('g', 'e') : case SIMPLE_HASH('a', 'd') : case SIMPLE_HASH('o', 'r') : case SIMPLE_HASH('e', 'r') : case SIMPLE_HASH('a', 'a') : case SIMPLE_HASH('o', 'o') : case SIMPLE_HASH('n', 't') : case SIMPLE_HASH('c', 'o') : case SIMPLE_HASH('p', 'p') : case SIMPLE_HASH('m', 'm') : case SIMPLE_HASH('a', 's') : case SIMPLE_HASH('r', 'f') : case SIMPLE_HASH('a', 'p') : case SIMPLE_HASH('a', 'm') : case SIMPLE_HASH('a', 'l') : case SIMPLE_HASH('a', 'r') : case SIMPLE_HASH('a', 'o') : case SIMPLE_HASH('a', 'e') : case SIMPLE_HASH('c', 'm') : case SIMPLE_HASH('r', 'm') : case SIMPLE_HASH('c', 'l') : case SIMPLE_HASH('v', 'c') : case SIMPLE_HASH('n', 'w') : case SIMPLE_HASH('d', 'l') : case SIMPLE_HASH('o', 'p') : case SIMPLE_HASH('t', 'f') : case SIMPLE_HASH('t', 'i') : rtn |= true; break; - }; + } } } str = strstr(str + 2, "__"); } rtn |= strstr(org, "_$_") != NULL; rtn |= strstr(org, "_vt$") != NULL; return (rtn); } static void dest_cstring(struct cstring *s) { if (s == NULL) return; free(s->buf); s->buf = NULL; s->size = 0; } static void dest_demangle_data(struct demangle_data *d) { if (d != NULL) { vector_str_dest(&d->arg); vector_str_dest(&d->vec); dest_cstring(&d->array_str); } } static bool init_cstring(struct cstring *s, size_t len) { if (s == NULL || len <= 1) return (false); if ((s->buf = malloc(sizeof(char) * len)) == NULL) return (false); s->size = len - 1; return (true); } static bool init_demangle_data(struct demangle_data *d) { if (d == NULL) return (false); d->ptr = false; d->ref = false; d->cnst = false; d->array = false; d->cnst_fn = false; d->class_name = false; d->array_str.buf = NULL; d->array_str.size = 0; d->type = ENCODE_FUNC; if (vector_str_init(&d->vec) == false) return (false); if (vector_str_init(&d->arg) == false) { vector_str_dest(&d->vec); return (false); } return (true); } static bool push_CTDT(const char *s, size_t l, struct vector_str *v) { if (s == NULL || l == 0 || v == NULL) return (false); if (vector_str_push(v, s, l) == false) return (false); assert(v->size > 1); return (vector_str_push(v, v->container[v->size - 2], strlen(v->container[v->size - 2]))); } static bool read_array(struct demangle_data *d) { size_t len; const char *end; if (d == NULL || d->p == NULL) return (false); end = d->p; assert(end != NULL); for (;;) { if (*end == '\0') return (false); if (ELFTC_ISDIGIT(*end) == 0) break; ++end; } if (*end != '_') return (false); len = end - d->p; assert(len > 0); dest_cstring(&d->array_str); if (init_cstring(&d->array_str, len + 3) == false) return (false); strncpy(d->array_str.buf + 1, d->p, len); *d->array_str.buf = '['; *(d->array_str.buf + len + 1) = ']'; d->array = true; d->p = end + 1; return (true); } static bool read_class(struct demangle_data *d) { size_t len; char *str; if (d == NULL) return (false); len = strtol(d->p, &str, 10); if (len == 0 && (errno == EINVAL || errno == ERANGE)) return (false); assert(len > 0); assert(str != NULL); if (vector_str_push(&d->vec, str, len) == false) return (false); d->p = str + len; d->class_name = true; return (true); } static bool read_func(struct demangle_data *d) { size_t len; const char *name; char *delim; if (d == NULL) return (false); assert(d->p != NULL && "d->p (org str) is NULL"); if ((delim = strstr(d->p, "__")) == NULL) return (false); len = delim - d->p; assert(len != 0); name = d->p; d->p = delim + 2; if (*d->p == 'C') { ++d->p; d->cnst_fn = true; } if (*d->p == 'Q' && ELFTC_ISDIGIT(*(d->p + 1))) { ++d->p; if (read_qual_name(d) == false) return (false); } else if (ELFTC_ISDIGIT(*d->p)) { if (read_class(d) == false) return (false); if (vector_str_push(&d->vec, "::", 2) == false) return (false); } return (vector_str_push(&d->vec, name, len)); } static bool read_func_name(struct demangle_data *d) { size_t len; bool rtn; char *op_name; if (d == NULL) return (false); rtn = false; op_name = NULL; assert(d->p != NULL && "d->p (org str) is NULL"); if (*d->p == '_' && *(d->p + 1) == '_') { d->p += 2; /* CTOR */ if (*d->p == 'Q' && ELFTC_ISDIGIT(*(d->p + 1))) { ++d->p; d->type = ENCODE_OP_CT; if (read_qual_name(d) == false) return (false); return (vector_str_pop(&d->vec)); } else if (ELFTC_ISDIGIT(*d->p)) { d->type = ENCODE_OP_CT; return (read_class(d)); } d->type = ENCODE_OP; if (read_op(d) == false) { /* not good condition, start function name with '__' */ d->type = ENCODE_FUNC; if (vector_str_push(&d->vec, "__", 2) == false) return (false); return (read_func(d)); } if (d->type == ENCODE_OP_USER || d->type == ENCODE_OP_TF || d->type == ENCODE_OP_TI) return (true); /* skip "__" */ d->p += 2; if (*d->p == 'C') { ++d->p; d->cnst_fn = true; } /* assume delimiter is removed */ if (*d->p == 'Q' && ELFTC_ISDIGIT(*(d->p + 1))) { ++d->p; assert(d->vec.size > 0); len = strlen(d->vec.container[d->vec.size - 1]); if ((op_name = malloc(sizeof(char) * (len + 1))) == NULL) return (false); snprintf(op_name, len + 1, "%s", d->vec.container[d->vec.size - 1]); vector_str_pop(&d->vec); if (read_qual_name(d) == false) goto clean; if (vector_str_push(&d->vec, "::", 2) == false) goto clean; if (vector_str_push(&d->vec, op_name, len) == false) goto clean; rtn = true; } else if (ELFTC_ISDIGIT(*d->p)) { assert(d->vec.size > 0); len = strlen(d->vec.container[d->vec.size - 1]); if ((op_name = malloc(sizeof(char) * (len + 1))) == NULL) return (false); snprintf(op_name, len + 1, "%s", d->vec.container[d->vec.size - 1]); vector_str_pop(&d->vec); if (read_class(d) == false) goto clean; if (vector_str_push(&d->vec, "::", 2) == false) goto clean; if (vector_str_push(&d->vec, op_name, len) == false) goto clean; rtn = true; } } else if (memcmp(d->p, "_$_", 3) == 0) { /* DTOR */ d->p += 3; d->type = ENCODE_OP_DT; if (*d->p == 'Q' && ELFTC_ISDIGIT(*(d->p + 1))) { ++d->p; if (read_qual_name(d) == false) return (false); return (vector_str_pop(&d->vec)); } else if (ELFTC_ISDIGIT(*d->p)) return (read_class(d)); return (false); } else if (memcmp(d->p, "_vt$", 4) == 0) { /* vtable */ d->p += 4; d->type = ENCODE_OP_VT; if (*d->p == 'Q' && ELFTC_ISDIGIT(*(d->p + 1))) { ++d->p; if (read_qual_name(d) == false) return (false); if (vector_str_pop(&d->vec) == false) return (false); } else if (ELFTC_ISDIGIT(*d->p)) { if (read_class(d) == false) return (false); } return (vector_str_push(&d->vec, " virtual table", 14)); } else return (read_func(d)); clean: free(op_name); return (rtn); } /* Read function ptr type */ static bool read_func_ptr(struct demangle_data *d) { struct demangle_data fptr; size_t arg_len, rtn_len; char *arg_type, *rtn_type; int lim; if (d == NULL) return (false); if (init_demangle_data(&fptr) == false) return (false); fptr.p = d->p + 1; lim = 0; arg_type = NULL; rtn_type = NULL; for (;;) { if (read_type(&fptr) == false) { dest_demangle_data(&fptr); return (false); } if (fptr.ptr == true) { if (vector_str_push(&fptr.vec, "*", 1) == false) { dest_demangle_data(&fptr); return (false); } fptr.ptr = false; } if (fptr.ref == true) { if (vector_str_push(&fptr.vec, "&", 1) == false) { dest_demangle_data(&fptr); return (false); } fptr.ref = false; } if (fptr.cnst == true) { if (vector_str_push(&fptr.vec, " const", 6) == false) { dest_demangle_data(&fptr); return (false); } fptr.cnst = false; } if (*fptr.p == '_') break; if (vector_str_push(&fptr.vec, ", ", 2) == false) { dest_demangle_data(&fptr); return (false); } if (++lim > CPP_DEMANGLE_GNU2_TRY) { dest_demangle_data(&fptr); return (false); } } arg_type = vector_str_get_flat(&fptr.vec, &arg_len); /* skip '_' */ d->p = fptr.p + 1; dest_demangle_data(&fptr); if (init_demangle_data(&fptr) == false) { free(arg_type); return (false); } fptr.p = d->p; lim = 0; if (read_type(&fptr) == false) { free(arg_type); dest_demangle_data(&fptr); return (false); } rtn_type = vector_str_get_flat(&fptr.vec, &rtn_len); d->p = fptr.p; dest_demangle_data(&fptr); if (vector_str_push(&d->vec, rtn_type, rtn_len) == false) { free(rtn_type); free(arg_type); return (false); } free(rtn_type); if (vector_str_push(&d->vec, " (*)(", 5) == false) { free(arg_type); return (false); } if (vector_str_push(&d->vec, arg_type, arg_len) == false) { free(arg_type); return (false); } free(arg_type); return (vector_str_push(&d->vec, ")", 1)); } static bool read_memptr(struct demangle_data *d) { struct demangle_data mptr; size_t len; bool rtn; char *mptr_str; if (d == NULL || d->p == NULL) return (false); if (init_demangle_data(&mptr) == false) return (false); rtn = false; mptr_str = NULL; mptr.p = d->p; if (*mptr.p == 'Q') { ++mptr.p; if (read_qual_name(&mptr) == false) goto clean; } else if (read_class(&mptr) == false) goto clean; d->p = mptr.p; if ((mptr_str = vector_str_get_flat(&mptr.vec, &len)) == NULL) goto clean; if (vector_str_push(&d->vec, mptr_str, len) == false) goto clean; if (vector_str_push(&d->vec, "::*", 3) == false) goto clean; rtn = true; clean: free(mptr_str); dest_demangle_data(&mptr); return (rtn); } static bool read_op(struct demangle_data *d) { if (d == NULL) return (false); assert(d->p != NULL && "d->p (org str) is NULL"); switch (SIMPLE_HASH(*(d->p), *(d->p+1))) { case SIMPLE_HASH('m', 'l') : d->p += 2; return (vector_str_push(&d->vec, "operator*", 9)); case SIMPLE_HASH('d', 'v') : d->p += 2; return (vector_str_push(&d->vec, "operator/", 9)); case SIMPLE_HASH('m', 'd') : d->p += 2; return (vector_str_push(&d->vec, "operator%", 9)); case SIMPLE_HASH('p', 'l') : d->p += 2; return (vector_str_push(&d->vec, "operator+", 9)); case SIMPLE_HASH('m', 'i') : d->p += 2; return (vector_str_push(&d->vec, "operator-", 9)); case SIMPLE_HASH('l', 's') : d->p += 2; return (vector_str_push(&d->vec, "operator<<", 10)); case SIMPLE_HASH('r', 's') : d->p += 2; return (vector_str_push(&d->vec, "operator>>", 10)); case SIMPLE_HASH('e', 'q') : d->p += 2; return (vector_str_push(&d->vec, "operator==", 10)); case SIMPLE_HASH('n', 'e') : d->p += 2; return (vector_str_push(&d->vec, "operator!=", 10)); case SIMPLE_HASH('l', 't') : d->p += 2; return (vector_str_push(&d->vec, "operator<", 9)); case SIMPLE_HASH('g', 't') : d->p += 2; return (vector_str_push(&d->vec, "operator>", 9)); case SIMPLE_HASH('l', 'e') : d->p += 2; return (vector_str_push(&d->vec, "operator<=", 10)); case SIMPLE_HASH('g', 'e') : d->p += 2; return (vector_str_push(&d->vec, "operator>=", 10)); case SIMPLE_HASH('a', 'd') : d->p += 2; if (*d->p == 'v') { ++d->p; return (vector_str_push(&d->vec, "operator/=", 10)); } else return (vector_str_push(&d->vec, "operator&", 9)); case SIMPLE_HASH('o', 'r') : d->p += 2; return (vector_str_push(&d->vec, "operator|", 9)); case SIMPLE_HASH('e', 'r') : d->p += 2; return (vector_str_push(&d->vec, "operator^", 9)); case SIMPLE_HASH('a', 'a') : d->p += 2; if (*d->p == 'd') { ++d->p; return (vector_str_push(&d->vec, "operator&=", 10)); } else return (vector_str_push(&d->vec, "operator&&", 10)); case SIMPLE_HASH('o', 'o') : d->p += 2; return (vector_str_push(&d->vec, "operator||", 10)); case SIMPLE_HASH('n', 't') : d->p += 2; return (vector_str_push(&d->vec, "operator!", 9)); case SIMPLE_HASH('c', 'o') : d->p += 2; return (vector_str_push(&d->vec, "operator~", 9)); case SIMPLE_HASH('p', 'p') : d->p += 2; return (vector_str_push(&d->vec, "operator++", 10)); case SIMPLE_HASH('m', 'm') : d->p += 2; return (vector_str_push(&d->vec, "operator--", 10)); case SIMPLE_HASH('a', 's') : d->p += 2; return (vector_str_push(&d->vec, "operator=", 9)); case SIMPLE_HASH('r', 'f') : d->p += 2; return (vector_str_push(&d->vec, "operator->", 10)); case SIMPLE_HASH('a', 'p') : /* apl */ if (*(d->p + 2) != 'l') return (false); d->p += 3; return (vector_str_push(&d->vec, "operator+=", 10)); case SIMPLE_HASH('a', 'm') : d->p += 2; if (*d->p == 'i') { ++d->p; return (vector_str_push(&d->vec, "operator-=", 10)); } else if (*d->p == 'u') { ++d->p; return (vector_str_push(&d->vec, "operator*=", 10)); } else if (*d->p == 'd') { ++d->p; return (vector_str_push(&d->vec, "operator%=", 10)); } return (false); case SIMPLE_HASH('a', 'l') : /* als */ if (*(d->p + 2) != 's') return (false); d->p += 3; return (vector_str_push(&d->vec, "operator<<=", 11)); case SIMPLE_HASH('a', 'r') : /* ars */ if (*(d->p + 2) != 's') return (false); d->p += 3; return (vector_str_push(&d->vec, "operator>>=", 11)); case SIMPLE_HASH('a', 'o') : /* aor */ if (*(d->p + 2) != 'r') return (false); d->p += 3; return (vector_str_push(&d->vec, "operator|=", 10)); case SIMPLE_HASH('a', 'e') : /* aer */ if (*(d->p + 2) != 'r') return (false); d->p += 3; return (vector_str_push(&d->vec, "operator^=", 10)); case SIMPLE_HASH('c', 'm') : d->p += 2; return (vector_str_push(&d->vec, "operator,", 9)); case SIMPLE_HASH('r', 'm') : d->p += 2; return (vector_str_push(&d->vec, "operator->*", 11)); case SIMPLE_HASH('c', 'l') : d->p += 2; return (vector_str_push(&d->vec, "()", 2)); case SIMPLE_HASH('v', 'c') : d->p += 2; return (vector_str_push(&d->vec, "[]", 2)); case SIMPLE_HASH('n', 'w') : d->p += 2; return (vector_str_push(&d->vec, "operator new()", 14)); case SIMPLE_HASH('d', 'l') : d->p += 2; return (vector_str_push(&d->vec, "operator delete()", 17)); case SIMPLE_HASH('o', 'p') : /* __op__ */ d->p += 2; d->type = ENCODE_OP_USER; return (read_op_user(d)); case SIMPLE_HASH('t', 'f') : d->p += 2; d->type = ENCODE_OP_TF; if (read_type(d) == false) return (false); return (vector_str_push(&d->vec, " type_info function", 19)); case SIMPLE_HASH('t', 'i') : d->p += 2; d->type = ENCODE_OP_TI; if (read_type(d) == false) return (false); return (vector_str_push(&d->vec, " type_info node", 15)); default : return (false); }; } static bool read_op_user(struct demangle_data *d) { struct demangle_data from, to; size_t from_len, to_len; bool rtn; char *from_str, *to_str; if (d == NULL) return (false); if (init_demangle_data(&from) == false) return (false); rtn = false; from_str = NULL; to_str = NULL; if (init_demangle_data(&to) == false) goto clean; to.p = d->p; if (*to.p == 'Q') { ++to.p; if (read_qual_name(&to) == false) goto clean; /* pop last '::' */ if (vector_str_pop(&to.vec) == false) goto clean; } else { if (read_class(&to) == false) goto clean; /* skip '__' */ to.p += 2; } if ((to_str = vector_str_get_flat(&to.vec, &to_len)) == NULL) goto clean; from.p = to.p; if (*from.p == 'Q') { ++from.p; if (read_qual_name(&from) == false) goto clean; /* pop last '::' */ if (vector_str_pop(&from.vec) == false) goto clean; } else if (read_class(&from) == false) goto clean; if ((from_str = vector_str_get_flat(&from.vec, &from_len)) == NULL) goto clean; if (vector_str_push(&d->vec, from_str, from_len) == false) goto clean; if (vector_str_push(&d->vec, "::operator ", 11) == false) goto clean; if (vector_str_push(&d->vec, to_str, to_len) == false) goto clean; rtn = vector_str_push(&d->vec, "()", 2); clean: free(to_str); free(from_str); dest_demangle_data(&to); dest_demangle_data(&from); return (rtn); } /* single digit + class names */ static bool read_qual_name(struct demangle_data *d) { int i; char num; if (d == NULL) return (false); assert(d->p != NULL && "d->p (org str) is NULL"); assert(*d->p > 48 && *d->p < 58 && "*d->p not in ASCII numeric range"); num = *d->p - 48; assert(num > 0); ++d->p; for (i = 0; i < num ; ++i) { if (read_class(d) == false) return (false); if (vector_str_push(&d->vec, "::", 2) == false) return (false); } if (*d->p != '\0') d->p = d->p + 2; return (true); } /* Return -1 at fail, 0 at success, and 1 at end */ static int read_subst(struct demangle_data *d) { size_t idx; char *str; if (d == NULL) return (-1); idx = strtol(d->p + 1, &str, 10); if (idx == 0 && (errno == EINVAL || errno == ERANGE)) return (-1); assert(idx > 0); assert(str != NULL); d->p = str; if (vector_str_push(&d->vec, d->arg.container[idx - 1], strlen(d->arg.container[idx - 1])) == false) return (-1); if (vector_str_push(&d->arg, d->arg.container[idx - 1], strlen(d->arg.container[idx - 1])) == false) return (-1); if (*d->p == '\0') return (1); return (0); } static int read_subst_iter(struct demangle_data *d) { int i; size_t idx; char repeat; char *str; if (d == NULL) return (-1); ++d->p; assert(*d->p > 48 && *d->p < 58 && "*d->p not in ASCII numeric range"); repeat = *d->p - 48; assert(repeat > 1); ++d->p; idx = strtol(d->p, &str, 10); if (idx == 0 && (errno == EINVAL || errno == ERANGE)) return (-1); assert(idx > 0); assert(str != NULL); d->p = str; for (i = 0; i < repeat ; ++i) { if (vector_str_push(&d->vec, d->arg.container[idx - 1], strlen(d->arg.container[idx - 1])) == false) return (-1); if (vector_str_push(&d->arg, d->arg.container[idx - 1], strlen(d->arg.container[idx - 1])) == false) return (-1); if (i != repeat - 1 && vector_str_push(&d->vec, ", ", 2) == false) return (-1); } if (*d->p == '\0') return (1); return (0); } static bool read_type(struct demangle_data *d) { if (d == NULL) return (false); assert(d->p != NULL && "d->p (org str) is NULL"); while (*d->p == 'U' || *d->p == 'C' || *d->p == 'V' || *d->p == 'S' || *d->p == 'P' || *d->p == 'R' || *d->p == 'A' || *d->p == 'F' || *d->p == 'M') { switch (*d->p) { case 'U' : ++d->p; if (vector_str_push(&d->vec, "unsigned ", 9) == false) return (false); break; case 'C' : ++d->p; if (*d->p == 'P') d->cnst = true; else { if (vector_str_push(&d->vec, "const ", 6) == false) return (false); } break; case 'V' : ++d->p; if (vector_str_push(&d->vec, "volatile ", 9) == false) return (false); break; case 'S' : ++d->p; if (vector_str_push(&d->vec, "signed ", 7) == false) return (false); break; case 'P' : ++d->p; if (*d->p == 'F') return (read_func_ptr(d)); else d->ptr = true; break; case 'R' : ++d->p; d->ref = true; break; case 'F' : break; case 'A' : ++d->p; if (read_array(d) == false) return (false); break; case 'M' : ++d->p; if (read_memptr(d) == false) return (false); break; default : break; - }; - }; + } + } if (ELFTC_ISDIGIT(*d->p)) return (read_class(d)); switch (*d->p) { case 'Q' : ++d->p; return (read_qual_name(d)); case 'v' : ++d->p; return (vector_str_push(&d->vec, "void", 4)); case 'b': ++d->p; return(vector_str_push(&d->vec, "bool", 4)); case 'c' : ++d->p; return (vector_str_push(&d->vec, "char", 4)); case 's' : ++d->p; return (vector_str_push(&d->vec, "short", 5)); case 'i' : ++d->p; return (vector_str_push(&d->vec, "int", 3)); case 'l' : ++d->p; return (vector_str_push(&d->vec, "long", 4)); case 'f' : ++d->p; return (vector_str_push(&d->vec, "float", 5)); case 'd': ++d->p; return (vector_str_push(&d->vec, "double", 6)); case 'r': ++d->p; return (vector_str_push(&d->vec, "long double", 11)); case 'e': ++d->p; return (vector_str_push(&d->vec, "...", 3)); case 'w': ++d->p; return (vector_str_push(&d->vec, "wchar_t", 7)); case 'x': ++d->p; return (vector_str_push(&d->vec, "long long", 9)); default: return (false); }; /* NOTREACHED */ return (false); } Index: vendor/elftoolchain/dist/libelftc/libelftc_dem_gnu3.c =================================================================== --- vendor/elftoolchain/dist/libelftc/libelftc_dem_gnu3.c (revision 300227) +++ vendor/elftoolchain/dist/libelftc/libelftc_dem_gnu3.c (revision 300228) @@ -1,3618 +1,3618 @@ /*- * Copyright (c) 2007 Hyogeol Lee * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer * in this position and unchanged. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include #include #include #include #include #include #include #include #include #include #include "_libelftc.h" -ELFTC_VCSID("$Id: libelftc_dem_gnu3.c 3291 2016-01-04 02:36:38Z emaste $"); +ELFTC_VCSID("$Id: libelftc_dem_gnu3.c 3447 2016-05-03 13:32:23Z emaste $"); /** * @file cpp_demangle.c * @brief Decode IA-64 C++ ABI style implementation. * * IA-64 standard ABI(Itanium C++ ABI) references. * * http://www.codesourcery.com/cxx-abi/abi.html#mangling \n * http://www.codesourcery.com/cxx-abi/abi-mangling.html */ enum type_qualifier { TYPE_PTR, TYPE_REF, TYPE_CMX, TYPE_IMG, TYPE_EXT, TYPE_RST, TYPE_VAT, TYPE_CST, TYPE_VEC }; struct vector_type_qualifier { size_t size, capacity; enum type_qualifier *q_container; struct vector_str ext_name; }; enum read_cmd { READ_FAIL, READ_NEST, READ_TMPL, READ_EXPR, READ_EXPL, READ_LOCAL, READ_TYPE, READ_FUNC, READ_PTRMEM }; struct vector_read_cmd { size_t size, capacity; enum read_cmd *r_container; }; struct cpp_demangle_data { struct vector_str output; /* output string vector */ struct vector_str output_tmp; struct vector_str subst; /* substitution string vector */ struct vector_str tmpl; struct vector_str class_type; struct vector_read_cmd cmd; bool paren; /* parenthesis opened */ bool pfirst; /* first element of parameter */ bool mem_rst; /* restrict member function */ bool mem_vat; /* volatile member function */ bool mem_cst; /* const member function */ int func_type; const char *cur; /* current mangled name ptr */ const char *last_sname; /* last source name */ int push_head; }; #define CPP_DEMANGLE_TRY_LIMIT 128 #define FLOAT_SPRINTF_TRY_LIMIT 5 #define FLOAT_QUADRUPLE_BYTES 16 #define FLOAT_EXTENED_BYTES 10 #define SIMPLE_HASH(x,y) (64 * x + y) static void cpp_demangle_data_dest(struct cpp_demangle_data *); static int cpp_demangle_data_init(struct cpp_demangle_data *, const char *); static int cpp_demangle_get_subst(struct cpp_demangle_data *, size_t); static int cpp_demangle_get_tmpl_param(struct cpp_demangle_data *, size_t); static int cpp_demangle_push_fp(struct cpp_demangle_data *, char *(*)(const char *, size_t)); static int cpp_demangle_push_str(struct cpp_demangle_data *, const char *, size_t); static int cpp_demangle_push_subst(struct cpp_demangle_data *, const char *, size_t); static int cpp_demangle_push_subst_v(struct cpp_demangle_data *, struct vector_str *); static int cpp_demangle_push_type_qualifier(struct cpp_demangle_data *, struct vector_type_qualifier *, const char *); static int cpp_demangle_read_array(struct cpp_demangle_data *); static int cpp_demangle_read_encoding(struct cpp_demangle_data *); static int cpp_demangle_read_expr_primary(struct cpp_demangle_data *); static int cpp_demangle_read_expression(struct cpp_demangle_data *); static int cpp_demangle_read_expression_flat(struct cpp_demangle_data *, char **); static int cpp_demangle_read_expression_binary(struct cpp_demangle_data *, const char *, size_t); static int cpp_demangle_read_expression_unary(struct cpp_demangle_data *, const char *, size_t); static int cpp_demangle_read_expression_trinary(struct cpp_demangle_data *, const char *, size_t, const char *, size_t); static int cpp_demangle_read_function(struct cpp_demangle_data *, int *, struct vector_type_qualifier *); static int cpp_demangle_local_source_name(struct cpp_demangle_data *ddata); static int cpp_demangle_read_local_name(struct cpp_demangle_data *); static int cpp_demangle_read_name(struct cpp_demangle_data *); static int cpp_demangle_read_name_flat(struct cpp_demangle_data *, char**); static int cpp_demangle_read_nested_name(struct cpp_demangle_data *); static int cpp_demangle_read_number(struct cpp_demangle_data *, long *); static int cpp_demangle_read_number_as_string(struct cpp_demangle_data *, char **); static int cpp_demangle_read_nv_offset(struct cpp_demangle_data *); static int cpp_demangle_read_offset(struct cpp_demangle_data *); static int cpp_demangle_read_offset_number(struct cpp_demangle_data *); static int cpp_demangle_read_pointer_to_member(struct cpp_demangle_data *); static int cpp_demangle_read_sname(struct cpp_demangle_data *); static int cpp_demangle_read_subst(struct cpp_demangle_data *); static int cpp_demangle_read_subst_std(struct cpp_demangle_data *); static int cpp_demangle_read_subst_stdtmpl(struct cpp_demangle_data *, const char *, size_t); static int cpp_demangle_read_tmpl_arg(struct cpp_demangle_data *); static int cpp_demangle_read_tmpl_args(struct cpp_demangle_data *); static int cpp_demangle_read_tmpl_param(struct cpp_demangle_data *); static int cpp_demangle_read_type(struct cpp_demangle_data *, int); static int cpp_demangle_read_type_flat(struct cpp_demangle_data *, char **); static int cpp_demangle_read_uqname(struct cpp_demangle_data *); static int cpp_demangle_read_v_offset(struct cpp_demangle_data *); static char *decode_fp_to_double(const char *, size_t); static char *decode_fp_to_float(const char *, size_t); static char *decode_fp_to_float128(const char *, size_t); static char *decode_fp_to_float80(const char *, size_t); static char *decode_fp_to_long_double(const char *, size_t); static int hex_to_dec(char); static void vector_read_cmd_dest(struct vector_read_cmd *); static int vector_read_cmd_find(struct vector_read_cmd *, enum read_cmd); static int vector_read_cmd_init(struct vector_read_cmd *); static int vector_read_cmd_pop(struct vector_read_cmd *); static int vector_read_cmd_push(struct vector_read_cmd *, enum read_cmd); static void vector_type_qualifier_dest(struct vector_type_qualifier *); static int vector_type_qualifier_init(struct vector_type_qualifier *); static int vector_type_qualifier_push(struct vector_type_qualifier *, enum type_qualifier); /** * @brief Decode the input string by IA-64 C++ ABI style. * * GNU GCC v3 use IA-64 standard ABI. * @return New allocated demangled string or NULL if failed. * @todo 1. Testing and more test case. 2. Code cleaning. */ char * cpp_demangle_gnu3(const char *org) { struct cpp_demangle_data ddata; ssize_t org_len; unsigned int limit; char *rtn; if (org == NULL || (org_len = strlen(org)) < 2) return (NULL); if (org_len > 11 && !strncmp(org, "_GLOBAL__I_", 11)) { if ((rtn = malloc(org_len + 19)) == NULL) return (NULL); snprintf(rtn, org_len + 19, "global constructors keyed to %s", org + 11); return (rtn); } if (org[0] != '_' || org[1] != 'Z') return (NULL); if (!cpp_demangle_data_init(&ddata, org + 2)) return (NULL); rtn = NULL; if (!cpp_demangle_read_encoding(&ddata)) goto clean; limit = 0; while (*ddata.cur != '\0') { /* * Breaking at some gcc info at tail. e.g) @@GLIBCXX_3.4 */ if (*ddata.cur == '@' && *(ddata.cur + 1) == '@') break; if (!cpp_demangle_read_type(&ddata, 1)) goto clean; if (limit++ > CPP_DEMANGLE_TRY_LIMIT) goto clean; } if (ddata.output.size == 0) goto clean; if (ddata.paren && !vector_str_push(&ddata.output, ")", 1)) goto clean; if (ddata.mem_vat && !vector_str_push(&ddata.output, " volatile", 9)) goto clean; if (ddata.mem_cst && !vector_str_push(&ddata.output, " const", 6)) goto clean; if (ddata.mem_rst && !vector_str_push(&ddata.output, " restrict", 9)) goto clean; rtn = vector_str_get_flat(&ddata.output, (size_t *) NULL); clean: cpp_demangle_data_dest(&ddata); return (rtn); } static void cpp_demangle_data_dest(struct cpp_demangle_data *d) { if (d == NULL) return; vector_read_cmd_dest(&d->cmd); vector_str_dest(&d->class_type); vector_str_dest(&d->tmpl); vector_str_dest(&d->subst); vector_str_dest(&d->output_tmp); vector_str_dest(&d->output); } static int cpp_demangle_data_init(struct cpp_demangle_data *d, const char *cur) { if (d == NULL || cur == NULL) return (0); if (!vector_str_init(&d->output)) return (0); if (!vector_str_init(&d->output_tmp)) goto clean1; if (!vector_str_init(&d->subst)) goto clean2; if (!vector_str_init(&d->tmpl)) goto clean3; if (!vector_str_init(&d->class_type)) goto clean4; if (!vector_read_cmd_init(&d->cmd)) goto clean5; assert(d->output.container != NULL); assert(d->output_tmp.container != NULL); assert(d->subst.container != NULL); assert(d->tmpl.container != NULL); assert(d->class_type.container != NULL); d->paren = false; d->pfirst = false; d->mem_rst = false; d->mem_vat = false; d->mem_cst = false; d->func_type = 0; d->cur = cur; d->last_sname = NULL; d->push_head = 0; return (1); clean5: vector_str_dest(&d->class_type); clean4: vector_str_dest(&d->tmpl); clean3: vector_str_dest(&d->subst); clean2: vector_str_dest(&d->output_tmp); clean1: vector_str_dest(&d->output); return (0); } static int cpp_demangle_push_fp(struct cpp_demangle_data *ddata, char *(*decoder)(const char *, size_t)) { size_t len; int rtn; const char *fp; char *f; if (ddata == NULL || decoder == NULL) return (0); fp = ddata->cur; while (*ddata->cur != 'E') ++ddata->cur; if ((f = decoder(fp, ddata->cur - fp)) == NULL) return (0); rtn = 0; if ((len = strlen(f)) > 0) rtn = cpp_demangle_push_str(ddata, f, len); free(f); ++ddata->cur; return (rtn); } static int cpp_demangle_push_str(struct cpp_demangle_data *ddata, const char *str, size_t len) { if (ddata == NULL || str == NULL || len == 0) return (0); if (ddata->push_head > 0) return (vector_str_push(&ddata->output_tmp, str, len)); return (vector_str_push(&ddata->output, str, len)); } static int cpp_demangle_push_subst(struct cpp_demangle_data *ddata, const char *str, size_t len) { if (ddata == NULL || str == NULL || len == 0) return (0); if (!vector_str_find(&ddata->subst, str, len)) return (vector_str_push(&ddata->subst, str, len)); return (1); } static int cpp_demangle_push_subst_v(struct cpp_demangle_data *ddata, struct vector_str *v) { size_t str_len; int rtn; char *str; if (ddata == NULL || v == NULL) return (0); if ((str = vector_str_get_flat(v, &str_len)) == NULL) return (0); rtn = cpp_demangle_push_subst(ddata, str, str_len); free(str); return (rtn); } static int cpp_demangle_push_type_qualifier(struct cpp_demangle_data *ddata, struct vector_type_qualifier *v, const char *type_str) { struct vector_str subst_v; size_t idx, e_idx, e_len; int rtn; char *buf; if (ddata == NULL || v == NULL) return (0); if ((idx = v->size) == 0) return (1); rtn = 0; if (type_str != NULL) { if (!vector_str_init(&subst_v)) return (0); if (!vector_str_push(&subst_v, type_str, strlen(type_str))) goto clean; } e_idx = 0; while (idx > 0) { switch (v->q_container[idx - 1]) { case TYPE_PTR: if (!cpp_demangle_push_str(ddata, "*", 1)) goto clean; if (type_str != NULL) { if (!vector_str_push(&subst_v, "*", 1)) goto clean; if (!cpp_demangle_push_subst_v(ddata, &subst_v)) goto clean; } break; case TYPE_REF: if (!cpp_demangle_push_str(ddata, "&", 1)) goto clean; if (type_str != NULL) { if (!vector_str_push(&subst_v, "&", 1)) goto clean; if (!cpp_demangle_push_subst_v(ddata, &subst_v)) goto clean; } break; case TYPE_CMX: if (!cpp_demangle_push_str(ddata, " complex", 8)) goto clean; if (type_str != NULL) { if (!vector_str_push(&subst_v, " complex", 8)) goto clean; if (!cpp_demangle_push_subst_v(ddata, &subst_v)) goto clean; } break; case TYPE_IMG: if (!cpp_demangle_push_str(ddata, " imaginary", 10)) goto clean; if (type_str != NULL) { if (!vector_str_push(&subst_v, " imaginary", 10)) goto clean; if (!cpp_demangle_push_subst_v(ddata, &subst_v)) goto clean; } break; case TYPE_EXT: if (v->ext_name.size == 0 || e_idx > v->ext_name.size - 1) goto clean; if ((e_len = strlen(v->ext_name.container[e_idx])) == 0) goto clean; if ((buf = malloc(e_len + 2)) == NULL) goto clean; snprintf(buf, e_len + 2, " %s", v->ext_name.container[e_idx]); if (!cpp_demangle_push_str(ddata, buf, e_len + 1)) { free(buf); goto clean; } if (type_str != NULL) { if (!vector_str_push(&subst_v, buf, e_len + 1)) { free(buf); goto clean; } if (!cpp_demangle_push_subst_v(ddata, &subst_v)) { free(buf); goto clean; } } free(buf); ++e_idx; break; case TYPE_RST: if (!cpp_demangle_push_str(ddata, " restrict", 9)) goto clean; if (type_str != NULL) { if (!vector_str_push(&subst_v, " restrict", 9)) goto clean; if (!cpp_demangle_push_subst_v(ddata, &subst_v)) goto clean; } break; case TYPE_VAT: if (!cpp_demangle_push_str(ddata, " volatile", 9)) goto clean; if (type_str != NULL) { if (!vector_str_push(&subst_v, " volatile", 9)) goto clean; if (!cpp_demangle_push_subst_v(ddata, &subst_v)) goto clean; } break; case TYPE_CST: if (!cpp_demangle_push_str(ddata, " const", 6)) goto clean; if (type_str != NULL) { if (!vector_str_push(&subst_v, " const", 6)) goto clean; if (!cpp_demangle_push_subst_v(ddata, &subst_v)) goto clean; } break; case TYPE_VEC: if (v->ext_name.size == 0 || e_idx > v->ext_name.size - 1) goto clean; if ((e_len = strlen(v->ext_name.container[e_idx])) == 0) goto clean; if ((buf = malloc(e_len + 12)) == NULL) goto clean; snprintf(buf, e_len + 12, " __vector(%s)", v->ext_name.container[e_idx]); if (!cpp_demangle_push_str(ddata, buf, e_len + 11)) { free(buf); goto clean; } if (type_str != NULL) { if (!vector_str_push(&subst_v, buf, e_len + 11)) { free(buf); goto clean; } if (!cpp_demangle_push_subst_v(ddata, &subst_v)) { free(buf); goto clean; } } free(buf); ++e_idx; break; - }; + } --idx; } rtn = 1; clean: if (type_str != NULL) vector_str_dest(&subst_v); return (rtn); } static int cpp_demangle_get_subst(struct cpp_demangle_data *ddata, size_t idx) { size_t len; if (ddata == NULL || ddata->subst.size <= idx) return (0); if ((len = strlen(ddata->subst.container[idx])) == 0) return (0); if (!cpp_demangle_push_str(ddata, ddata->subst.container[idx], len)) return (0); /* skip '_' */ ++ddata->cur; return (1); } static int cpp_demangle_get_tmpl_param(struct cpp_demangle_data *ddata, size_t idx) { size_t len; if (ddata == NULL || ddata->tmpl.size <= idx) return (0); if ((len = strlen(ddata->tmpl.container[idx])) == 0) return (0); if (!cpp_demangle_push_str(ddata, ddata->tmpl.container[idx], len)) return (0); ++ddata->cur; return (1); } static int cpp_demangle_read_array(struct cpp_demangle_data *ddata) { size_t i, num_len, exp_len, p_idx, idx; const char *num; char *exp; if (ddata == NULL || *(++ddata->cur) == '\0') return (0); if (*ddata->cur == '_') { if (*(++ddata->cur) == '\0') return (0); if (!cpp_demangle_read_type(ddata, 0)) return (0); if (!cpp_demangle_push_str(ddata, "[]", 2)) return (0); } else { if (ELFTC_ISDIGIT(*ddata->cur) != 0) { num = ddata->cur; while (ELFTC_ISDIGIT(*ddata->cur) != 0) ++ddata->cur; if (*ddata->cur != '_') return (0); num_len = ddata->cur - num; assert(num_len > 0); if (*(++ddata->cur) == '\0') return (0); if (!cpp_demangle_read_type(ddata, 0)) return (0); if (!cpp_demangle_push_str(ddata, "[", 1)) return (0); if (!cpp_demangle_push_str(ddata, num, num_len)) return (0); if (!cpp_demangle_push_str(ddata, "]", 1)) return (0); } else { p_idx = ddata->output.size; if (!cpp_demangle_read_expression(ddata)) return (0); if ((exp = vector_str_substr(&ddata->output, p_idx, ddata->output.size - 1, &exp_len)) == NULL) return (0); idx = ddata->output.size; for (i = p_idx; i < idx; ++i) if (!vector_str_pop(&ddata->output)) { free(exp); return (0); } if (*ddata->cur != '_') { free(exp); return (0); } ++ddata->cur; if (*ddata->cur == '\0') { free(exp); return (0); } if (!cpp_demangle_read_type(ddata, 0)) { free(exp); return (0); } if (!cpp_demangle_push_str(ddata, "[", 1)) { free(exp); return (0); } if (!cpp_demangle_push_str(ddata, exp, exp_len)) { free(exp); return (0); } if (!cpp_demangle_push_str(ddata, "]", 1)) { free(exp); return (0); } free(exp); } } return (1); } static int cpp_demangle_read_expr_primary(struct cpp_demangle_data *ddata) { const char *num; if (ddata == NULL || *(++ddata->cur) == '\0') return (0); if (*ddata->cur == '_' && *(ddata->cur + 1) == 'Z') { ddata->cur += 2; if (*ddata->cur == '\0') return (0); if (!cpp_demangle_read_encoding(ddata)) return (0); ++ddata->cur; return (1); } switch (*ddata->cur) { case 'b': if (*(ddata->cur + 2) != 'E') return (0); switch (*(++ddata->cur)) { case '0': ddata->cur += 2; return (cpp_demangle_push_str(ddata, "false", 5)); case '1': ddata->cur += 2; return (cpp_demangle_push_str(ddata, "true", 4)); default: return (0); - }; + } case 'd': ++ddata->cur; return (cpp_demangle_push_fp(ddata, decode_fp_to_double)); case 'e': ++ddata->cur; if (sizeof(long double) == 10) return (cpp_demangle_push_fp(ddata, decode_fp_to_double)); return (cpp_demangle_push_fp(ddata, decode_fp_to_float80)); case 'f': ++ddata->cur; return (cpp_demangle_push_fp(ddata, decode_fp_to_float)); case 'g': ++ddata->cur; if (sizeof(long double) == 16) return (cpp_demangle_push_fp(ddata, decode_fp_to_double)); return (cpp_demangle_push_fp(ddata, decode_fp_to_float128)); case 'i': case 'j': case 'l': case 'm': case 'n': case 's': case 't': case 'x': case 'y': if (*(++ddata->cur) == 'n') { if (!cpp_demangle_push_str(ddata, "-", 1)) return (0); ++ddata->cur; } num = ddata->cur; while (*ddata->cur != 'E') { if (!ELFTC_ISDIGIT(*ddata->cur)) return (0); ++ddata->cur; } ++ddata->cur; return (cpp_demangle_push_str(ddata, num, ddata->cur - num - 1)); default: return (0); - }; + } } static int cpp_demangle_read_expression(struct cpp_demangle_data *ddata) { if (ddata == NULL || *ddata->cur == '\0') return (0); switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) { case SIMPLE_HASH('s', 't'): ddata->cur += 2; return (cpp_demangle_read_type(ddata, 0)); case SIMPLE_HASH('s', 'r'): ddata->cur += 2; if (!cpp_demangle_read_type(ddata, 0)) return (0); if (!cpp_demangle_read_uqname(ddata)) return (0); if (*ddata->cur == 'I') return (cpp_demangle_read_tmpl_args(ddata)); return (1); case SIMPLE_HASH('a', 'a'): /* operator && */ ddata->cur += 2; return (cpp_demangle_read_expression_binary(ddata, "&&", 2)); case SIMPLE_HASH('a', 'd'): /* operator & (unary) */ ddata->cur += 2; return (cpp_demangle_read_expression_unary(ddata, "&", 1)); case SIMPLE_HASH('a', 'n'): /* operator & */ ddata->cur += 2; return (cpp_demangle_read_expression_binary(ddata, "&", 1)); case SIMPLE_HASH('a', 'N'): /* operator &= */ ddata->cur += 2; return (cpp_demangle_read_expression_binary(ddata, "&=", 2)); case SIMPLE_HASH('a', 'S'): /* operator = */ ddata->cur += 2; return (cpp_demangle_read_expression_binary(ddata, "=", 1)); case SIMPLE_HASH('c', 'l'): /* operator () */ ddata->cur += 2; return (cpp_demangle_read_expression_binary(ddata, "()", 2)); case SIMPLE_HASH('c', 'm'): /* operator , */ ddata->cur += 2; return (cpp_demangle_read_expression_binary(ddata, ",", 1)); case SIMPLE_HASH('c', 'o'): /* operator ~ */ ddata->cur += 2; return (cpp_demangle_read_expression_binary(ddata, "~", 1)); case SIMPLE_HASH('c', 'v'): /* operator (cast) */ ddata->cur += 2; return (cpp_demangle_read_expression_binary(ddata, "(cast)", 6)); case SIMPLE_HASH('d', 'a'): /* operator delete [] */ ddata->cur += 2; return (cpp_demangle_read_expression_unary(ddata, "delete []", 9)); case SIMPLE_HASH('d', 'e'): /* operator * (unary) */ ddata->cur += 2; return (cpp_demangle_read_expression_unary(ddata, "*", 1)); case SIMPLE_HASH('d', 'l'): /* operator delete */ ddata->cur += 2; return (cpp_demangle_read_expression_unary(ddata, "delete", 6)); case SIMPLE_HASH('d', 'v'): /* operator / */ ddata->cur += 2; return (cpp_demangle_read_expression_binary(ddata, "/", 1)); case SIMPLE_HASH('d', 'V'): /* operator /= */ ddata->cur += 2; return (cpp_demangle_read_expression_binary(ddata, "/=", 2)); case SIMPLE_HASH('e', 'o'): /* operator ^ */ ddata->cur += 2; return (cpp_demangle_read_expression_binary(ddata, "^", 1)); case SIMPLE_HASH('e', 'O'): /* operator ^= */ ddata->cur += 2; return (cpp_demangle_read_expression_binary(ddata, "^=", 2)); case SIMPLE_HASH('e', 'q'): /* operator == */ ddata->cur += 2; return (cpp_demangle_read_expression_binary(ddata, "==", 2)); case SIMPLE_HASH('g', 'e'): /* operator >= */ ddata->cur += 2; return (cpp_demangle_read_expression_binary(ddata, ">=", 2)); case SIMPLE_HASH('g', 't'): /* operator > */ ddata->cur += 2; return (cpp_demangle_read_expression_binary(ddata, ">", 1)); case SIMPLE_HASH('i', 'x'): /* operator [] */ ddata->cur += 2; return (cpp_demangle_read_expression_binary(ddata, "[]", 2)); case SIMPLE_HASH('l', 'e'): /* operator <= */ ddata->cur += 2; return (cpp_demangle_read_expression_binary(ddata, "<=", 2)); case SIMPLE_HASH('l', 's'): /* operator << */ ddata->cur += 2; return (cpp_demangle_read_expression_binary(ddata, "<<", 2)); case SIMPLE_HASH('l', 'S'): /* operator <<= */ ddata->cur += 2; return (cpp_demangle_read_expression_binary(ddata, "<<=", 3)); case SIMPLE_HASH('l', 't'): /* operator < */ ddata->cur += 2; return (cpp_demangle_read_expression_binary(ddata, "<", 1)); case SIMPLE_HASH('m', 'i'): /* operator - */ ddata->cur += 2; return (cpp_demangle_read_expression_binary(ddata, "-", 1)); case SIMPLE_HASH('m', 'I'): /* operator -= */ ddata->cur += 2; return (cpp_demangle_read_expression_binary(ddata, "-=", 2)); case SIMPLE_HASH('m', 'l'): /* operator * */ ddata->cur += 2; return (cpp_demangle_read_expression_binary(ddata, "*", 1)); case SIMPLE_HASH('m', 'L'): /* operator *= */ ddata->cur += 2; return (cpp_demangle_read_expression_binary(ddata, "*=", 2)); case SIMPLE_HASH('m', 'm'): /* operator -- */ ddata->cur += 2; return (cpp_demangle_read_expression_binary(ddata, "--", 2)); case SIMPLE_HASH('n', 'a'): /* operator new[] */ ddata->cur += 2; return (cpp_demangle_read_expression_unary(ddata, "new []", 6)); case SIMPLE_HASH('n', 'e'): /* operator != */ ddata->cur += 2; return (cpp_demangle_read_expression_binary(ddata, "!=", 2)); case SIMPLE_HASH('n', 'g'): /* operator - (unary) */ ddata->cur += 2; return (cpp_demangle_read_expression_unary(ddata, "-", 1)); case SIMPLE_HASH('n', 't'): /* operator ! */ ddata->cur += 2; return (cpp_demangle_read_expression_binary(ddata, "!", 1)); case SIMPLE_HASH('n', 'w'): /* operator new */ ddata->cur += 2; return (cpp_demangle_read_expression_unary(ddata, "new", 3)); case SIMPLE_HASH('o', 'o'): /* operator || */ ddata->cur += 2; return (cpp_demangle_read_expression_binary(ddata, "||", 2)); case SIMPLE_HASH('o', 'r'): /* operator | */ ddata->cur += 2; return (cpp_demangle_read_expression_binary(ddata, "|", 1)); case SIMPLE_HASH('o', 'R'): /* operator |= */ ddata->cur += 2; return (cpp_demangle_read_expression_binary(ddata, "|=", 2)); case SIMPLE_HASH('p', 'l'): /* operator + */ ddata->cur += 2; return (cpp_demangle_read_expression_binary(ddata, "+", 1)); case SIMPLE_HASH('p', 'L'): /* operator += */ ddata->cur += 2; return (cpp_demangle_read_expression_binary(ddata, "+=", 2)); case SIMPLE_HASH('p', 'm'): /* operator ->* */ ddata->cur += 2; return (cpp_demangle_read_expression_binary(ddata, "->*", 3)); case SIMPLE_HASH('p', 'p'): /* operator ++ */ ddata->cur += 2; return (cpp_demangle_read_expression_binary(ddata, "++", 2)); case SIMPLE_HASH('p', 's'): /* operator + (unary) */ ddata->cur += 2; return (cpp_demangle_read_expression_unary(ddata, "+", 1)); case SIMPLE_HASH('p', 't'): /* operator -> */ ddata->cur += 2; return (cpp_demangle_read_expression_binary(ddata, "->", 2)); case SIMPLE_HASH('q', 'u'): /* operator ? */ ddata->cur += 2; return (cpp_demangle_read_expression_trinary(ddata, "?", 1, ":", 1)); case SIMPLE_HASH('r', 'm'): /* operator % */ ddata->cur += 2; return (cpp_demangle_read_expression_binary(ddata, "%", 1)); case SIMPLE_HASH('r', 'M'): /* operator %= */ ddata->cur += 2; return (cpp_demangle_read_expression_binary(ddata, "%=", 2)); case SIMPLE_HASH('r', 's'): /* operator >> */ ddata->cur += 2; return (cpp_demangle_read_expression_binary(ddata, ">>", 2)); case SIMPLE_HASH('r', 'S'): /* operator >>= */ ddata->cur += 2; return (cpp_demangle_read_expression_binary(ddata, ">>=", 3)); case SIMPLE_HASH('r', 'z'): /* operator sizeof */ ddata->cur += 2; return (cpp_demangle_read_expression_unary(ddata, "sizeof", 6)); case SIMPLE_HASH('s', 'v'): /* operator sizeof */ ddata->cur += 2; return (cpp_demangle_read_expression_unary(ddata, "sizeof", 6)); - }; + } switch (*ddata->cur) { case 'L': return (cpp_demangle_read_expr_primary(ddata)); case 'T': return (cpp_demangle_read_tmpl_param(ddata)); - }; + } return (0); } static int cpp_demangle_read_expression_flat(struct cpp_demangle_data *ddata, char **str) { struct vector_str *output; size_t i, p_idx, idx, exp_len; char *exp; output = ddata->push_head > 0 ? &ddata->output_tmp : &ddata->output; p_idx = output->size; if (!cpp_demangle_read_expression(ddata)) return (0); if ((exp = vector_str_substr(output, p_idx, output->size - 1, &exp_len)) == NULL) return (0); idx = output->size; for (i = p_idx; i < idx; ++i) { if (!vector_str_pop(output)) { free(exp); return (0); } } *str = exp; return (1); } static int cpp_demangle_read_expression_binary(struct cpp_demangle_data *ddata, const char *name, size_t len) { if (ddata == NULL || name == NULL || len == 0) return (0); if (!cpp_demangle_read_expression(ddata)) return (0); if (!cpp_demangle_push_str(ddata, name, len)) return (0); return (cpp_demangle_read_expression(ddata)); } static int cpp_demangle_read_expression_unary(struct cpp_demangle_data *ddata, const char *name, size_t len) { if (ddata == NULL || name == NULL || len == 0) return (0); if (!cpp_demangle_read_expression(ddata)) return (0); return (cpp_demangle_push_str(ddata, name, len)); } static int cpp_demangle_read_expression_trinary(struct cpp_demangle_data *ddata, const char *name1, size_t len1, const char *name2, size_t len2) { if (ddata == NULL || name1 == NULL || len1 == 0 || name2 == NULL || len2 == 0) return (0); if (!cpp_demangle_read_expression(ddata)) return (0); if (!cpp_demangle_push_str(ddata, name1, len1)) return (0); if (!cpp_demangle_read_expression(ddata)) return (0); if (!cpp_demangle_push_str(ddata, name2, len2)) return (0); return (cpp_demangle_read_expression(ddata)); } static int cpp_demangle_read_function(struct cpp_demangle_data *ddata, int *ext_c, struct vector_type_qualifier *v) { size_t class_type_size, class_type_len, limit; const char *class_type; if (ddata == NULL || *ddata->cur != 'F' || v == NULL) return (0); ++ddata->cur; if (*ddata->cur == 'Y') { if (ext_c != NULL) *ext_c = 1; ++ddata->cur; } if (!cpp_demangle_read_type(ddata, 0)) return (0); if (*ddata->cur != 'E') { if (!cpp_demangle_push_str(ddata, "(", 1)) return (0); if (vector_read_cmd_find(&ddata->cmd, READ_PTRMEM)) { if ((class_type_size = ddata->class_type.size) == 0) return (0); class_type = ddata->class_type.container[class_type_size - 1]; if (class_type == NULL) return (0); if ((class_type_len = strlen(class_type)) == 0) return (0); if (!cpp_demangle_push_str(ddata, class_type, class_type_len)) return (0); if (!cpp_demangle_push_str(ddata, "::*", 3)) return (0); ++ddata->func_type; } else { if (!cpp_demangle_push_type_qualifier(ddata, v, (const char *) NULL)) return (0); vector_type_qualifier_dest(v); if (!vector_type_qualifier_init(v)) return (0); } if (!cpp_demangle_push_str(ddata, ")(", 2)) return (0); limit = 0; for (;;) { if (!cpp_demangle_read_type(ddata, 0)) return (0); if (*ddata->cur == 'E') break; if (limit++ > CPP_DEMANGLE_TRY_LIMIT) return (0); } if (vector_read_cmd_find(&ddata->cmd, READ_PTRMEM) == 1) { if (!cpp_demangle_push_type_qualifier(ddata, v, (const char *) NULL)) return (0); vector_type_qualifier_dest(v); if (!vector_type_qualifier_init(v)) return (0); } if (!cpp_demangle_push_str(ddata, ")", 1)) return (0); } ++ddata->cur; return (1); } /* read encoding, encoding are function name, data name, special-name */ static int cpp_demangle_read_encoding(struct cpp_demangle_data *ddata) { char *name, *type, *num_str; long offset; int rtn; if (ddata == NULL || *ddata->cur == '\0') return (0); /* special name */ switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) { case SIMPLE_HASH('G', 'A'): if (!cpp_demangle_push_str(ddata, "hidden alias for ", 17)) return (0); ddata->cur += 2; if (*ddata->cur == '\0') return (0); return (cpp_demangle_read_encoding(ddata)); case SIMPLE_HASH('G', 'R'): if (!cpp_demangle_push_str(ddata, "reference temporary #", 21)) return (0); ddata->cur += 2; if (*ddata->cur == '\0') return (0); if (!cpp_demangle_read_name_flat(ddata, &name)) return (0); rtn = 0; if (!cpp_demangle_read_number_as_string(ddata, &num_str)) goto clean1; if (!cpp_demangle_push_str(ddata, num_str, strlen(num_str))) goto clean2; if (!cpp_demangle_push_str(ddata, " for ", 5)) goto clean2; if (!cpp_demangle_push_str(ddata, name, strlen(name))) goto clean2; rtn = 1; clean2: free(num_str); clean1: free(name); return (rtn); case SIMPLE_HASH('G', 'T'): ddata->cur += 2; if (*ddata->cur == '\0') return (0); switch (*ddata->cur) { case 'n': if (!cpp_demangle_push_str(ddata, "non-transaction clone for ", 26)) return (0); break; case 't': default: if (!cpp_demangle_push_str(ddata, "transaction clone for ", 22)) return (0); break; } ++ddata->cur; return (cpp_demangle_read_encoding(ddata)); case SIMPLE_HASH('G', 'V'): /* sentry object for 1 time init */ if (!cpp_demangle_push_str(ddata, "guard variable for ", 20)) return (0); ddata->cur += 2; break; case SIMPLE_HASH('T', 'c'): /* virtual function covariant override thunk */ if (!cpp_demangle_push_str(ddata, "virtual function covariant override ", 36)) return (0); ddata->cur += 2; if (*ddata->cur == '\0') return (0); if (!cpp_demangle_read_offset(ddata)) return (0); if (!cpp_demangle_read_offset(ddata)) return (0); return (cpp_demangle_read_encoding(ddata)); case SIMPLE_HASH('T', 'C'): /* construction vtable */ if (!cpp_demangle_push_str(ddata, "construction vtable for ", 24)) return (0); ddata->cur += 2; if (*ddata->cur == '\0') return (0); if (!cpp_demangle_read_type_flat(ddata, &type)) return (0); rtn = 0; if (!cpp_demangle_read_number(ddata, &offset)) goto clean3; if (*ddata->cur++ != '_') goto clean3; if (!cpp_demangle_read_type(ddata, 0)) goto clean3; if (!cpp_demangle_push_str(ddata, "-in-", 4)) goto clean3; if (!cpp_demangle_push_str(ddata, type, strlen(type))) goto clean3; rtn = 1; clean3: free(type); return (rtn); case SIMPLE_HASH('T', 'D'): /* typeinfo common proxy */ break; case SIMPLE_HASH('T', 'F'): /* typeinfo fn */ if (!cpp_demangle_push_str(ddata, "typeinfo fn for ", 16)) return (0); ddata->cur += 2; if (*ddata->cur == '\0') return (0); return (cpp_demangle_read_type(ddata, 0)); case SIMPLE_HASH('T', 'h'): /* virtual function non-virtual override thunk */ if (!cpp_demangle_push_str(ddata, "virtual function non-virtual override ", 38)) return (0); ddata->cur += 2; if (*ddata->cur == '\0') return (0); if (!cpp_demangle_read_nv_offset(ddata)) return (0); return (cpp_demangle_read_encoding(ddata)); case SIMPLE_HASH('T', 'H'): /* TLS init function */ if (!cpp_demangle_push_str(ddata, "TLS init function for ", 22)) return (0); ddata->cur += 2; if (*ddata->cur == '\0') return (0); break; case SIMPLE_HASH('T', 'I'): /* typeinfo structure */ if (!cpp_demangle_push_str(ddata, "typeinfo for ", 13)) return (0); ddata->cur += 2; if (*ddata->cur == '\0') return (0); return (cpp_demangle_read_type(ddata, 0)); case SIMPLE_HASH('T', 'J'): /* java class */ if (!cpp_demangle_push_str(ddata, "java Class for ", 15)) return (0); ddata->cur += 2; if (*ddata->cur == '\0') return (0); return (cpp_demangle_read_type(ddata, 0)); case SIMPLE_HASH('T', 'S'): /* RTTI name (NTBS) */ if (!cpp_demangle_push_str(ddata, "typeinfo name for ", 18)) return (0); ddata->cur += 2; if (*ddata->cur == '\0') return (0); return (cpp_demangle_read_type(ddata, 0)); case SIMPLE_HASH('T', 'T'): /* VTT table */ if (!cpp_demangle_push_str(ddata, "VTT for ", 8)) return (0); ddata->cur += 2; if (*ddata->cur == '\0') return (0); return (cpp_demangle_read_type(ddata, 0)); case SIMPLE_HASH('T', 'v'): /* virtual function virtual override thunk */ if (!cpp_demangle_push_str(ddata, "virtual function virtual override ", 34)) return (0); ddata->cur += 2; if (*ddata->cur == '\0') return (0); if (!cpp_demangle_read_v_offset(ddata)) return (0); return (cpp_demangle_read_encoding(ddata)); case SIMPLE_HASH('T', 'V'): /* virtual table */ if (!cpp_demangle_push_str(ddata, "vtable for ", 12)) return (0); ddata->cur += 2; if (*ddata->cur == '\0') return (0); return (cpp_demangle_read_type(ddata, 0)); case SIMPLE_HASH('T', 'W'): /* TLS wrapper function */ if (!cpp_demangle_push_str(ddata, "TLS wrapper function for ", 25)) return (0); ddata->cur += 2; if (*ddata->cur == '\0') return (0); break; - }; + } return (cpp_demangle_read_name(ddata)); } static int cpp_demangle_read_local_name(struct cpp_demangle_data *ddata) { size_t limit; if (ddata == NULL) return (0); if (*(++ddata->cur) == '\0') return (0); if (!cpp_demangle_read_encoding(ddata)) return (0); limit = 0; for (;;) { if (!cpp_demangle_read_type(ddata, 1)) return (0); if (*ddata->cur == 'E') break; if (limit++ > CPP_DEMANGLE_TRY_LIMIT) return (0); } if (*(++ddata->cur) == '\0') return (0); if (ddata->paren == true) { if (!cpp_demangle_push_str(ddata, ")", 1)) return (0); ddata->paren = false; } if (*ddata->cur == 's') ++ddata->cur; else { if (!cpp_demangle_push_str(ddata, "::", 2)) return (0); if (!cpp_demangle_read_name(ddata)) return (0); } if (*ddata->cur == '_') { ++ddata->cur; while (ELFTC_ISDIGIT(*ddata->cur) != 0) ++ddata->cur; } return (1); } static int cpp_demangle_read_name(struct cpp_demangle_data *ddata) { struct vector_str *output, v; size_t p_idx, subst_str_len; int rtn; char *subst_str; if (ddata == NULL || *ddata->cur == '\0') return (0); output = ddata->push_head > 0 ? &ddata->output_tmp : &ddata->output; subst_str = NULL; switch (*ddata->cur) { case 'S': return (cpp_demangle_read_subst(ddata)); case 'N': return (cpp_demangle_read_nested_name(ddata)); case 'Z': return (cpp_demangle_read_local_name(ddata)); - }; + } if (!vector_str_init(&v)) return (0); p_idx = output->size; rtn = 0; if (!cpp_demangle_read_uqname(ddata)) goto clean; if ((subst_str = vector_str_substr(output, p_idx, output->size - 1, &subst_str_len)) == NULL) goto clean; if (subst_str_len > 8 && strstr(subst_str, "operator") != NULL) { rtn = 1; goto clean; } if (!vector_str_push(&v, subst_str, subst_str_len)) goto clean; if (!cpp_demangle_push_subst_v(ddata, &v)) goto clean; if (*ddata->cur == 'I') { p_idx = output->size; if (!cpp_demangle_read_tmpl_args(ddata)) goto clean; free(subst_str); if ((subst_str = vector_str_substr(output, p_idx, output->size - 1, &subst_str_len)) == NULL) goto clean; if (!vector_str_push(&v, subst_str, subst_str_len)) goto clean; if (!cpp_demangle_push_subst_v(ddata, &v)) goto clean; } rtn = 1; clean: free(subst_str); vector_str_dest(&v); return (rtn); } static int cpp_demangle_read_name_flat(struct cpp_demangle_data *ddata, char **str) { struct vector_str *output; size_t i, p_idx, idx, name_len; char *name; output = ddata->push_head > 0 ? &ddata->output_tmp : &ddata->output; p_idx = output->size; if (!cpp_demangle_read_name(ddata)) return (0); if ((name = vector_str_substr(output, p_idx, output->size - 1, &name_len)) == NULL) return (0); idx = output->size; for (i = p_idx; i < idx; ++i) { if (!vector_str_pop(output)) { free(name); return (0); } } *str = name; return (1); } static int cpp_demangle_read_nested_name(struct cpp_demangle_data *ddata) { struct vector_str *output, v; size_t limit, p_idx, subst_str_len; int rtn; char *subst_str; if (ddata == NULL || *ddata->cur != 'N') return (0); if (*(++ddata->cur) == '\0') return (0); while (*ddata->cur == 'r' || *ddata->cur == 'V' || *ddata->cur == 'K') { switch (*ddata->cur) { case 'r': ddata->mem_rst = true; break; case 'V': ddata->mem_vat = true; break; case 'K': ddata->mem_cst = true; break; - }; + } ++ddata->cur; } output = ddata->push_head > 0 ? &ddata->output_tmp : &ddata->output; if (!vector_str_init(&v)) return (0); rtn = 0; limit = 0; for (;;) { p_idx = output->size; switch (*ddata->cur) { case 'I': if (!cpp_demangle_read_tmpl_args(ddata)) goto clean; break; case 'S': if (!cpp_demangle_read_subst(ddata)) goto clean; break; case 'T': if (!cpp_demangle_read_tmpl_param(ddata)) goto clean; break; default: if (!cpp_demangle_read_uqname(ddata)) goto clean; - }; + } if ((subst_str = vector_str_substr(output, p_idx, output->size - 1, &subst_str_len)) == NULL) goto clean; if (!vector_str_push(&v, subst_str, subst_str_len)) { free(subst_str); goto clean; } free(subst_str); if (!cpp_demangle_push_subst_v(ddata, &v)) goto clean; if (*ddata->cur == 'E') break; else if (*ddata->cur != 'I' && *ddata->cur != 'C' && *ddata->cur != 'D') { if (!cpp_demangle_push_str(ddata, "::", 2)) goto clean; if (!vector_str_push(&v, "::", 2)) goto clean; } if (limit++ > CPP_DEMANGLE_TRY_LIMIT) goto clean; } ++ddata->cur; rtn = 1; clean: vector_str_dest(&v); return (rtn); } /* * read number * number ::= [n] */ static int cpp_demangle_read_number(struct cpp_demangle_data *ddata, long *rtn) { long len, negative_factor; if (ddata == NULL || rtn == NULL) return (0); negative_factor = 1; if (*ddata->cur == 'n') { negative_factor = -1; ++ddata->cur; } if (ELFTC_ISDIGIT(*ddata->cur) == 0) return (0); errno = 0; if ((len = strtol(ddata->cur, (char **) NULL, 10)) == 0 && errno != 0) return (0); while (ELFTC_ISDIGIT(*ddata->cur) != 0) ++ddata->cur; assert(len >= 0); assert(negative_factor == 1 || negative_factor == -1); *rtn = len * negative_factor; return (1); } static int cpp_demangle_read_number_as_string(struct cpp_demangle_data *ddata, char **str) { long n; if (!cpp_demangle_read_number(ddata, &n)) { *str = NULL; return (0); } if (asprintf(str, "%ld", n) < 0) { *str = NULL; return (0); } return (1); } static int cpp_demangle_read_nv_offset(struct cpp_demangle_data *ddata) { if (ddata == NULL) return (0); if (!cpp_demangle_push_str(ddata, "offset : ", 9)) return (0); return (cpp_demangle_read_offset_number(ddata)); } /* read offset, offset are nv-offset, v-offset */ static int cpp_demangle_read_offset(struct cpp_demangle_data *ddata) { if (ddata == NULL) return (0); if (*ddata->cur == 'h') { ++ddata->cur; return (cpp_demangle_read_nv_offset(ddata)); } else if (*ddata->cur == 'v') { ++ddata->cur; return (cpp_demangle_read_v_offset(ddata)); } return (0); } static int cpp_demangle_read_offset_number(struct cpp_demangle_data *ddata) { bool negative; const char *start; if (ddata == NULL || *ddata->cur == '\0') return (0); /* offset could be negative */ if (*ddata->cur == 'n') { negative = true; start = ddata->cur + 1; } else { negative = false; start = ddata->cur; } while (*ddata->cur != '_') ++ddata->cur; if (negative && !cpp_demangle_push_str(ddata, "-", 1)) return (0); assert(start != NULL); if (!cpp_demangle_push_str(ddata, start, ddata->cur - start)) return (0); if (!cpp_demangle_push_str(ddata, " ", 1)) return (0); ++ddata->cur; return (1); } static int cpp_demangle_read_pointer_to_member(struct cpp_demangle_data *ddata) { size_t class_type_len, i, idx, p_idx; int p_func_type, rtn; char *class_type; if (ddata == NULL || *ddata->cur != 'M' || *(++ddata->cur) == '\0') return (0); p_idx = ddata->output.size; if (!cpp_demangle_read_type(ddata, 0)) return (0); if ((class_type = vector_str_substr(&ddata->output, p_idx, ddata->output.size - 1, &class_type_len)) == NULL) return (0); rtn = 0; idx = ddata->output.size; for (i = p_idx; i < idx; ++i) if (!vector_str_pop(&ddata->output)) goto clean1; if (!vector_read_cmd_push(&ddata->cmd, READ_PTRMEM)) goto clean1; if (!vector_str_push(&ddata->class_type, class_type, class_type_len)) goto clean2; p_func_type = ddata->func_type; if (!cpp_demangle_read_type(ddata, 0)) goto clean3; if (p_func_type == ddata->func_type) { if (!cpp_demangle_push_str(ddata, " ", 1)) goto clean3; if (!cpp_demangle_push_str(ddata, class_type, class_type_len)) goto clean3; if (!cpp_demangle_push_str(ddata, "::*", 3)) goto clean3; } rtn = 1; clean3: if (!vector_str_pop(&ddata->class_type)) rtn = 0; clean2: if (!vector_read_cmd_pop(&ddata->cmd)) rtn = 0; clean1: free(class_type); return (rtn); } /* read source-name, source-name is */ static int cpp_demangle_read_sname(struct cpp_demangle_data *ddata) { long len; int err; if (ddata == NULL || cpp_demangle_read_number(ddata, &len) == 0 || len <= 0) return (0); if (len == 12 && (memcmp("_GLOBAL__N_1", ddata->cur, 12) == 0)) err = cpp_demangle_push_str(ddata, "(anonymous namespace)", 21); else err = cpp_demangle_push_str(ddata, ddata->cur, len); if (err == 0) return (0); assert(ddata->output.size > 0); if (vector_read_cmd_find(&ddata->cmd, READ_TMPL) == 0) ddata->last_sname = ddata->output.container[ddata->output.size - 1]; ddata->cur += len; return (1); } static int cpp_demangle_read_subst(struct cpp_demangle_data *ddata) { long nth; if (ddata == NULL || *ddata->cur == '\0') return (0); /* abbreviations of the form Sx */ switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) { case SIMPLE_HASH('S', 'a'): /* std::allocator */ if (cpp_demangle_push_str(ddata, "std::allocator", 14) == 0) return (0); ddata->cur += 2; if (*ddata->cur == 'I') return (cpp_demangle_read_subst_stdtmpl(ddata, "std::allocator", 14)); return (1); case SIMPLE_HASH('S', 'b'): /* std::basic_string */ if (!cpp_demangle_push_str(ddata, "std::basic_string", 17)) return (0); ddata->cur += 2; if (*ddata->cur == 'I') return (cpp_demangle_read_subst_stdtmpl(ddata, "std::basic_string", 17)); return (1); case SIMPLE_HASH('S', 'd'): /* std::basic_iostream > */ if (!cpp_demangle_push_str(ddata, "std::basic_iostream", 19)) return (0); ddata->last_sname = "basic_iostream"; ddata->cur += 2; if (*ddata->cur == 'I') return (cpp_demangle_read_subst_stdtmpl(ddata, "std::basic_iostream", 19)); return (1); case SIMPLE_HASH('S', 'i'): /* std::basic_istream > */ if (!cpp_demangle_push_str(ddata, "std::basic_istream", 18)) return (0); ddata->last_sname = "basic_istream"; ddata->cur += 2; if (*ddata->cur == 'I') return (cpp_demangle_read_subst_stdtmpl(ddata, "std::basic_istream", 18)); return (1); case SIMPLE_HASH('S', 'o'): /* std::basic_ostream > */ if (!cpp_demangle_push_str(ddata, "std::basic_ostream", 18)) return (0); ddata->last_sname = "basic_ostream"; ddata->cur += 2; if (*ddata->cur == 'I') return (cpp_demangle_read_subst_stdtmpl(ddata, "std::basic_ostream", 18)); return (1); case SIMPLE_HASH('S', 's'): /* * std::basic_string, * std::allocator > * * a.k.a std::string */ if (!cpp_demangle_push_str(ddata, "std::string", 11)) return (0); ddata->last_sname = "string"; ddata->cur += 2; if (*ddata->cur == 'I') return (cpp_demangle_read_subst_stdtmpl(ddata, "std::string", 11)); return (1); case SIMPLE_HASH('S', 't'): /* std:: */ return (cpp_demangle_read_subst_std(ddata)); - }; + } if (*(++ddata->cur) == '\0') return (0); /* substitution */ if (*ddata->cur == '_') return (cpp_demangle_get_subst(ddata, 0)); else { errno = 0; /* substitution number is base 36 */ if ((nth = strtol(ddata->cur, (char **) NULL, 36)) == 0 && errno != 0) return (0); /* first was '_', so increase one */ ++nth; while (*ddata->cur != '_') ++ddata->cur; assert(nth > 0); return (cpp_demangle_get_subst(ddata, nth)); } /* NOTREACHED */ return (0); } static int cpp_demangle_read_subst_std(struct cpp_demangle_data *ddata) { struct vector_str *output, v; size_t p_idx, subst_str_len; int rtn; char *subst_str; if (ddata == NULL) return (0); if (!vector_str_init(&v)) return (0); subst_str = NULL; rtn = 0; if (!cpp_demangle_push_str(ddata, "std::", 5)) goto clean; if (!vector_str_push(&v, "std::", 5)) goto clean; ddata->cur += 2; output = ddata->push_head > 0 ? &ddata->output_tmp : &ddata->output; p_idx = output->size; if (!cpp_demangle_read_uqname(ddata)) goto clean; if ((subst_str = vector_str_substr(output, p_idx, output->size - 1, &subst_str_len)) == NULL) goto clean; if (!vector_str_push(&v, subst_str, subst_str_len)) goto clean; if (!cpp_demangle_push_subst_v(ddata, &v)) goto clean; if (*ddata->cur == 'I') { p_idx = output->size; if (!cpp_demangle_read_tmpl_args(ddata)) goto clean; free(subst_str); if ((subst_str = vector_str_substr(output, p_idx, output->size - 1, &subst_str_len)) == NULL) goto clean; if (!vector_str_push(&v, subst_str, subst_str_len)) goto clean; if (!cpp_demangle_push_subst_v(ddata, &v)) goto clean; } rtn = 1; clean: free(subst_str); vector_str_dest(&v); return (rtn); } static int cpp_demangle_read_subst_stdtmpl(struct cpp_demangle_data *ddata, const char *str, size_t len) { struct vector_str *output; size_t p_idx, substr_len; int rtn; char *subst_str, *substr; if (ddata == NULL || str == NULL || len == 0) return (0); output = ddata->push_head > 0 ? &ddata->output_tmp : &ddata->output; p_idx = output->size; substr = NULL; subst_str = NULL; if (!cpp_demangle_read_tmpl_args(ddata)) return (0); if ((substr = vector_str_substr(output, p_idx, output->size - 1, &substr_len)) == NULL) return (0); rtn = 0; if ((subst_str = malloc(sizeof(char) * (substr_len + len + 1))) == NULL) goto clean; memcpy(subst_str, str, len); memcpy(subst_str + len, substr, substr_len); subst_str[substr_len + len] = '\0'; if (!cpp_demangle_push_subst(ddata, subst_str, substr_len + len)) goto clean; rtn = 1; clean: free(subst_str); free(substr); return (rtn); } static int cpp_demangle_read_tmpl_arg(struct cpp_demangle_data *ddata) { if (ddata == NULL || *ddata->cur == '\0') return (0); switch (*ddata->cur) { case 'L': return (cpp_demangle_read_expr_primary(ddata)); case 'X': return (cpp_demangle_read_expression(ddata)); - }; + } return (cpp_demangle_read_type(ddata, 0)); } static int cpp_demangle_read_tmpl_args(struct cpp_demangle_data *ddata) { struct vector_str *v; size_t arg_len, idx, limit, size; char *arg; if (ddata == NULL || *ddata->cur == '\0') return (0); ++ddata->cur; if (!vector_read_cmd_push(&ddata->cmd, READ_TMPL)) return (0); if (!cpp_demangle_push_str(ddata, "<", 1)) return (0); limit = 0; v = ddata->push_head > 0 ? &ddata->output_tmp : &ddata->output; for (;;) { idx = v->size; if (!cpp_demangle_read_tmpl_arg(ddata)) return (0); if ((arg = vector_str_substr(v, idx, v->size - 1, &arg_len)) == NULL) return (0); if (!vector_str_find(&ddata->tmpl, arg, arg_len) && !vector_str_push(&ddata->tmpl, arg, arg_len)) { free(arg); return (0); } free(arg); if (*ddata->cur == 'E') { ++ddata->cur; size = v->size; assert(size > 0); if (!strncmp(v->container[size - 1], ">", 1)) { if (!cpp_demangle_push_str(ddata, " >", 2)) return (0); } else if (!cpp_demangle_push_str(ddata, ">", 1)) return (0); break; } else if (*ddata->cur != 'I' && !cpp_demangle_push_str(ddata, ", ", 2)) return (0); if (limit++ > CPP_DEMANGLE_TRY_LIMIT) return (0); } return (vector_read_cmd_pop(&ddata->cmd)); } /* * Read template parameter that forms in 'T[number]_'. * This function much like to read_subst but only for types. */ static int cpp_demangle_read_tmpl_param(struct cpp_demangle_data *ddata) { long nth; if (ddata == NULL || *ddata->cur != 'T') return (0); ++ddata->cur; if (*ddata->cur == '_') return (cpp_demangle_get_tmpl_param(ddata, 0)); else { errno = 0; if ((nth = strtol(ddata->cur, (char **) NULL, 36)) == 0 && errno != 0) return (0); /* T_ is first */ ++nth; while (*ddata->cur != '_') ++ddata->cur; assert(nth > 0); return (cpp_demangle_get_tmpl_param(ddata, nth)); } /* NOTREACHED */ return (0); } static int cpp_demangle_read_type(struct cpp_demangle_data *ddata, int delimit) { struct vector_type_qualifier v; struct vector_str *output; size_t p_idx, type_str_len; int extern_c, is_builtin; long len; char *type_str, *exp_str, *num_str; if (ddata == NULL) return (0); output = &ddata->output; if (!strncmp(ddata->output.container[ddata->output.size - 1], ">", 1)) { ddata->push_head++; output = &ddata->output_tmp; } else if (delimit == 1) { if (ddata->paren == false) { if (!cpp_demangle_push_str(ddata, "(", 1)) return (0); if (ddata->output.size < 2) return (0); ddata->paren = true; ddata->pfirst = true; /* Need pop function name */ if (ddata->subst.size == 1 && !vector_str_pop(&ddata->subst)) return (0); } if (ddata->pfirst) ddata->pfirst = false; else if (*ddata->cur != 'I' && !cpp_demangle_push_str(ddata, ", ", 2)) return (0); } assert(output != NULL); /* * [r, V, K] [P, R, C, G, U] builtin, function, class-enum, array * pointer-to-member, template-param, template-template-param, subst */ if (!vector_type_qualifier_init(&v)) return (0); extern_c = 0; is_builtin = 1; p_idx = output->size; type_str = exp_str = num_str = NULL; again: /* builtin type */ switch (*ddata->cur) { case 'a': /* signed char */ if (!cpp_demangle_push_str(ddata, "signed char", 11)) goto clean; ++ddata->cur; goto rtn; case 'A': /* array type */ if (!cpp_demangle_read_array(ddata)) goto clean; is_builtin = 0; goto rtn; case 'b': /* bool */ if (!cpp_demangle_push_str(ddata, "bool", 4)) goto clean; ++ddata->cur; goto rtn; case 'C': /* complex pair */ if (!vector_type_qualifier_push(&v, TYPE_CMX)) goto clean; ++ddata->cur; goto again; case 'c': /* char */ if (!cpp_demangle_push_str(ddata, "char", 4)) goto clean; ++ddata->cur; goto rtn; case 'd': /* double */ if (!cpp_demangle_push_str(ddata, "double", 6)) goto clean; ++ddata->cur; goto rtn; case 'D': ++ddata->cur; switch (*ddata->cur) { case 'd': /* IEEE 754r decimal floating point (64 bits) */ if (!cpp_demangle_push_str(ddata, "decimal64", 9)) goto clean; ++ddata->cur; break; case 'e': /* IEEE 754r decimal floating point (128 bits) */ if (!cpp_demangle_push_str(ddata, "decimal128", 10)) goto clean; ++ddata->cur; break; case 'f': /* IEEE 754r decimal floating point (32 bits) */ if (!cpp_demangle_push_str(ddata, "decimal32", 9)) goto clean; ++ddata->cur; break; case 'h': /* IEEE 754r half-precision floating point (16 bits) */ if (!cpp_demangle_push_str(ddata, "half", 4)) goto clean; ++ddata->cur; break; case 'i': /* char32_t */ if (!cpp_demangle_push_str(ddata, "char32_t", 8)) goto clean; ++ddata->cur; break; case 'n': /* std::nullptr_t (i.e., decltype(nullptr)) */ if (!cpp_demangle_push_str(ddata, "decltype(nullptr)", 17)) goto clean; ++ddata->cur; break; case 's': /* char16_t */ if (!cpp_demangle_push_str(ddata, "char16_t", 8)) goto clean; ++ddata->cur; break; case 'v': /* gcc vector_size extension. */ ++ddata->cur; if (*ddata->cur == '_') { ++ddata->cur; if (!cpp_demangle_read_expression_flat(ddata, &exp_str)) goto clean; if (!vector_str_push(&v.ext_name, exp_str, strlen(exp_str))) goto clean; } else { if (!cpp_demangle_read_number_as_string(ddata, &num_str)) goto clean; if (!vector_str_push(&v.ext_name, num_str, strlen(num_str))) goto clean; } if (*ddata->cur != '_') goto clean; ++ddata->cur; if (!vector_type_qualifier_push(&v, TYPE_VEC)) goto clean; goto again; default: goto clean; } goto rtn; case 'e': /* long double */ if (!cpp_demangle_push_str(ddata, "long double", 11)) goto clean; ++ddata->cur; goto rtn; case 'f': /* float */ if (!cpp_demangle_push_str(ddata, "float", 5)) goto clean; ++ddata->cur; goto rtn; case 'F': /* function */ if (!cpp_demangle_read_function(ddata, &extern_c, &v)) goto clean; is_builtin = 0; goto rtn; case 'g': /* __float128 */ if (!cpp_demangle_push_str(ddata, "__float128", 10)) goto clean; ++ddata->cur; goto rtn; case 'G': /* imaginary */ if (!vector_type_qualifier_push(&v, TYPE_IMG)) goto clean; ++ddata->cur; goto again; case 'h': /* unsigned char */ if (!cpp_demangle_push_str(ddata, "unsigned char", 13)) goto clean; ++ddata->cur; goto rtn; case 'i': /* int */ if (!cpp_demangle_push_str(ddata, "int", 3)) goto clean; ++ddata->cur; goto rtn; case 'j': /* unsigned int */ if (!cpp_demangle_push_str(ddata, "unsigned int", 12)) goto clean; ++ddata->cur; goto rtn; case 'K': /* const */ if (!vector_type_qualifier_push(&v, TYPE_CST)) goto clean; ++ddata->cur; goto again; case 'l': /* long */ if (!cpp_demangle_push_str(ddata, "long", 4)) goto clean; ++ddata->cur; goto rtn; case 'm': /* unsigned long */ if (!cpp_demangle_push_str(ddata, "unsigned long", 13)) goto clean; ++ddata->cur; goto rtn; case 'M': /* pointer to member */ if (!cpp_demangle_read_pointer_to_member(ddata)) goto clean; is_builtin = 0; goto rtn; case 'n': /* __int128 */ if (!cpp_demangle_push_str(ddata, "__int128", 8)) goto clean; ++ddata->cur; goto rtn; case 'o': /* unsigned __int128 */ if (!cpp_demangle_push_str(ddata, "unsigned __int128", 17)) goto clean; ++ddata->cur; goto rtn; case 'P': /* pointer */ if (!vector_type_qualifier_push(&v, TYPE_PTR)) goto clean; ++ddata->cur; goto again; case 'r': /* restrict */ if (!vector_type_qualifier_push(&v, TYPE_RST)) goto clean; ++ddata->cur; goto again; case 'R': /* reference */ if (!vector_type_qualifier_push(&v, TYPE_REF)) goto clean; ++ddata->cur; goto again; case 's': /* short, local string */ if (!cpp_demangle_push_str(ddata, "short", 5)) goto clean; ++ddata->cur; goto rtn; case 'S': /* substitution */ if (!cpp_demangle_read_subst(ddata)) goto clean; is_builtin = 0; goto rtn; case 't': /* unsigned short */ if (!cpp_demangle_push_str(ddata, "unsigned short", 14)) goto clean; ++ddata->cur; goto rtn; case 'T': /* template parameter */ if (!cpp_demangle_read_tmpl_param(ddata)) goto clean; is_builtin = 0; goto rtn; case 'u': /* vendor extended builtin */ ++ddata->cur; if (!cpp_demangle_read_sname(ddata)) goto clean; is_builtin = 0; goto rtn; case 'U': /* vendor extended type qualifier */ if (!cpp_demangle_read_number(ddata, &len)) goto clean; if (len <= 0) goto clean; if (!vector_str_push(&v.ext_name, ddata->cur, len)) return (0); ddata->cur += len; if (!vector_type_qualifier_push(&v, TYPE_EXT)) goto clean; goto again; case 'v': /* void */ if (!cpp_demangle_push_str(ddata, "void", 4)) goto clean; ++ddata->cur; goto rtn; case 'V': /* volatile */ if (!vector_type_qualifier_push(&v, TYPE_VAT)) goto clean; ++ddata->cur; goto again; case 'w': /* wchar_t */ if (!cpp_demangle_push_str(ddata, "wchar_t", 6)) goto clean; ++ddata->cur; goto rtn; case 'x': /* long long */ if (!cpp_demangle_push_str(ddata, "long long", 9)) goto clean; ++ddata->cur; goto rtn; case 'y': /* unsigned long long */ if (!cpp_demangle_push_str(ddata, "unsigned long long", 18)) goto clean; ++ddata->cur; goto rtn; case 'z': /* ellipsis */ if (!cpp_demangle_push_str(ddata, "ellipsis", 8)) goto clean; ++ddata->cur; goto rtn; - }; + } if (!cpp_demangle_read_name(ddata)) goto clean; is_builtin = 0; rtn: if ((type_str = vector_str_substr(output, p_idx, output->size - 1, &type_str_len)) == NULL) goto clean; if (is_builtin == 0) { if (!vector_str_find(&ddata->subst, type_str, type_str_len) && !vector_str_push(&ddata->subst, type_str, type_str_len)) goto clean; } if (!cpp_demangle_push_type_qualifier(ddata, &v, type_str)) goto clean; free(type_str); free(exp_str); free(num_str); vector_type_qualifier_dest(&v); if (ddata->push_head > 0) { if (*ddata->cur == 'I' && cpp_demangle_read_tmpl_args(ddata) == 0) return (0); if (--ddata->push_head > 0) return (1); if (!vector_str_push(&ddata->output_tmp, " ", 1)) return (0); if (!vector_str_push_vector_head(&ddata->output, &ddata->output_tmp)) return (0); vector_str_dest(&ddata->output_tmp); if (!vector_str_init(&ddata->output_tmp)) return (0); if (!cpp_demangle_push_str(ddata, "(", 1)) return (0); ddata->paren = true; ddata->pfirst = true; } return (1); clean: free(type_str); free(exp_str); free(num_str); vector_type_qualifier_dest(&v); return (0); } static int cpp_demangle_read_type_flat(struct cpp_demangle_data *ddata, char **str) { struct vector_str *output; size_t i, p_idx, idx, type_len; char *type; output = ddata->push_head > 0 ? &ddata->output_tmp : &ddata->output; p_idx = output->size; if (!cpp_demangle_read_type(ddata, 0)) return (0); if ((type = vector_str_substr(output, p_idx, output->size - 1, &type_len)) == NULL) return (0); idx = output->size; for (i = p_idx; i < idx; ++i) { if (!vector_str_pop(output)) { free(type); return (0); } } *str = type; return (1); } /* * read unqualified-name, unqualified name are operator-name, ctor-dtor-name, * source-name */ static int cpp_demangle_read_uqname(struct cpp_demangle_data *ddata) { size_t len; if (ddata == NULL || *ddata->cur == '\0') return (0); /* operator name */ switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) { case SIMPLE_HASH('a', 'a'): /* operator && */ if (!cpp_demangle_push_str(ddata, "operator&&", 10)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('a', 'd'): /* operator & (unary) */ if (!cpp_demangle_push_str(ddata, "operator&", 9)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('a', 'n'): /* operator & */ if (!cpp_demangle_push_str(ddata, "operator&", 9)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('a', 'N'): /* operator &= */ if (!cpp_demangle_push_str(ddata, "operator&=", 10)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('a', 'S'): /* operator = */ if (!cpp_demangle_push_str(ddata, "operator=", 9)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('c', 'l'): /* operator () */ if (!cpp_demangle_push_str(ddata, "operator()", 10)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('c', 'm'): /* operator , */ if (!cpp_demangle_push_str(ddata, "operator,", 9)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('c', 'o'): /* operator ~ */ if (!cpp_demangle_push_str(ddata, "operator~", 9)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('c', 'v'): /* operator (cast) */ if (!cpp_demangle_push_str(ddata, "operator(cast)", 14)) return (0); ddata->cur += 2; return (cpp_demangle_read_type(ddata, 1)); case SIMPLE_HASH('d', 'a'): /* operator delete [] */ if (!cpp_demangle_push_str(ddata, "operator delete []", 18)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('d', 'e'): /* operator * (unary) */ if (!cpp_demangle_push_str(ddata, "operator*", 9)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('d', 'l'): /* operator delete */ if (!cpp_demangle_push_str(ddata, "operator delete", 15)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('d', 'v'): /* operator / */ if (!cpp_demangle_push_str(ddata, "operator/", 9)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('d', 'V'): /* operator /= */ if (!cpp_demangle_push_str(ddata, "operator/=", 10)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('e', 'o'): /* operator ^ */ if (!cpp_demangle_push_str(ddata, "operator^", 9)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('e', 'O'): /* operator ^= */ if (!cpp_demangle_push_str(ddata, "operator^=", 10)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('e', 'q'): /* operator == */ if (!cpp_demangle_push_str(ddata, "operator==", 10)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('g', 'e'): /* operator >= */ if (!cpp_demangle_push_str(ddata, "operator>=", 10)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('g', 't'): /* operator > */ if (!cpp_demangle_push_str(ddata, "operator>", 9)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('i', 'x'): /* operator [] */ if (!cpp_demangle_push_str(ddata, "operator[]", 10)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('l', 'e'): /* operator <= */ if (!cpp_demangle_push_str(ddata, "operator<=", 10)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('l', 's'): /* operator << */ if (!cpp_demangle_push_str(ddata, "operator<<", 10)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('l', 'S'): /* operator <<= */ if (!cpp_demangle_push_str(ddata, "operator<<=", 11)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('l', 't'): /* operator < */ if (!cpp_demangle_push_str(ddata, "operator<", 9)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('m', 'i'): /* operator - */ if (!cpp_demangle_push_str(ddata, "operator-", 9)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('m', 'I'): /* operator -= */ if (!cpp_demangle_push_str(ddata, "operator-=", 10)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('m', 'l'): /* operator * */ if (!cpp_demangle_push_str(ddata, "operator*", 9)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('m', 'L'): /* operator *= */ if (!cpp_demangle_push_str(ddata, "operator*=", 10)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('m', 'm'): /* operator -- */ if (!cpp_demangle_push_str(ddata, "operator--", 10)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('n', 'a'): /* operator new[] */ if (!cpp_demangle_push_str(ddata, "operator new []", 15)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('n', 'e'): /* operator != */ if (!cpp_demangle_push_str(ddata, "operator!=", 10)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('n', 'g'): /* operator - (unary) */ if (!cpp_demangle_push_str(ddata, "operator-", 9)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('n', 't'): /* operator ! */ if (!cpp_demangle_push_str(ddata, "operator!", 9)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('n', 'w'): /* operator new */ if (!cpp_demangle_push_str(ddata, "operator new", 12)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('o', 'o'): /* operator || */ if (!cpp_demangle_push_str(ddata, "operator||", 10)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('o', 'r'): /* operator | */ if (!cpp_demangle_push_str(ddata, "operator|", 9)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('o', 'R'): /* operator |= */ if (!cpp_demangle_push_str(ddata, "operator|=", 10)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('p', 'l'): /* operator + */ if (!cpp_demangle_push_str(ddata, "operator+", 9)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('p', 'L'): /* operator += */ if (!cpp_demangle_push_str(ddata, "operator+=", 10)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('p', 'm'): /* operator ->* */ if (!cpp_demangle_push_str(ddata, "operator->*", 11)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('p', 'p'): /* operator ++ */ if (!cpp_demangle_push_str(ddata, "operator++", 10)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('p', 's'): /* operator + (unary) */ if (!cpp_demangle_push_str(ddata, "operator+", 9)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('p', 't'): /* operator -> */ if (!cpp_demangle_push_str(ddata, "operator->", 10)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('q', 'u'): /* operator ? */ if (!cpp_demangle_push_str(ddata, "operator?", 9)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('r', 'm'): /* operator % */ if (!cpp_demangle_push_str(ddata, "operator%", 9)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('r', 'M'): /* operator %= */ if (!cpp_demangle_push_str(ddata, "operator%=", 10)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('r', 's'): /* operator >> */ if (!cpp_demangle_push_str(ddata, "operator>>", 10)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('r', 'S'): /* operator >>= */ if (!cpp_demangle_push_str(ddata, "operator>>=", 11)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('r', 'z'): /* operator sizeof */ if (!cpp_demangle_push_str(ddata, "operator sizeof ", 16)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('s', 'r'): /* scope resolution operator */ if (!cpp_demangle_push_str(ddata, "scope resolution operator ", 26)) return (0); ddata->cur += 2; return (1); case SIMPLE_HASH('s', 'v'): /* operator sizeof */ if (!cpp_demangle_push_str(ddata, "operator sizeof ", 16)) return (0); ddata->cur += 2; return (1); - }; + } /* vendor extened operator */ if (*ddata->cur == 'v' && ELFTC_ISDIGIT(*(ddata->cur + 1))) { if (!cpp_demangle_push_str(ddata, "vendor extened operator ", 24)) return (0); if (!cpp_demangle_push_str(ddata, ddata->cur + 1, 1)) return (0); ddata->cur += 2; return (cpp_demangle_read_sname(ddata)); } /* ctor-dtor-name */ switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) { case SIMPLE_HASH('C', '1'): /* FALLTHROUGH */ case SIMPLE_HASH('C', '2'): /* FALLTHROUGH */ case SIMPLE_HASH('C', '3'): if (ddata->last_sname == NULL) return (0); if ((len = strlen(ddata->last_sname)) == 0) return (0); if (!cpp_demangle_push_str(ddata, "::", 2)) return (0); if (!cpp_demangle_push_str(ddata, ddata->last_sname, len)) return (0); ddata->cur +=2; return (1); case SIMPLE_HASH('D', '0'): /* FALLTHROUGH */ case SIMPLE_HASH('D', '1'): /* FALLTHROUGH */ case SIMPLE_HASH('D', '2'): if (ddata->last_sname == NULL) return (0); if ((len = strlen(ddata->last_sname)) == 0) return (0); if (!cpp_demangle_push_str(ddata, "::~", 3)) return (0); if (!cpp_demangle_push_str(ddata, ddata->last_sname, len)) return (0); ddata->cur +=2; return (1); - }; + } /* source name */ if (ELFTC_ISDIGIT(*ddata->cur) != 0) return (cpp_demangle_read_sname(ddata)); /* local source name */ if (*ddata->cur == 'L') return (cpp_demangle_local_source_name(ddata)); return (1); } /* * Read local source name. * * References: * http://gcc.gnu.org/bugzilla/show_bug.cgi?id=31775 * http://gcc.gnu.org/viewcvs?view=rev&revision=124467 */ static int cpp_demangle_local_source_name(struct cpp_demangle_data *ddata) { /* L */ if (ddata == NULL || *ddata->cur != 'L') return (0); ++ddata->cur; /* source name */ if (!cpp_demangle_read_sname(ddata)) return (0); /* discriminator */ if (*ddata->cur == '_') { ++ddata->cur; while (ELFTC_ISDIGIT(*ddata->cur) != 0) ++ddata->cur; } return (1); } static int cpp_demangle_read_v_offset(struct cpp_demangle_data *ddata) { if (ddata == NULL) return (0); if (!cpp_demangle_push_str(ddata, "offset : ", 9)) return (0); if (!cpp_demangle_read_offset_number(ddata)) return (0); if (!cpp_demangle_push_str(ddata, "virtual offset : ", 17)) return (0); return (!cpp_demangle_read_offset_number(ddata)); } /* * Decode floating point representation to string * Return new allocated string or NULL * * Todo * Replace these functions to macro. */ static char * decode_fp_to_double(const char *p, size_t len) { double f; size_t rtn_len, limit, i; int byte; char *rtn; if (p == NULL || len == 0 || len % 2 != 0 || len / 2 > sizeof(double)) return (NULL); memset(&f, 0, sizeof(double)); for (i = 0; i < len / 2; ++i) { byte = hex_to_dec(p[len - i * 2 - 1]) + hex_to_dec(p[len - i * 2 - 2]) * 16; if (byte < 0 || byte > 255) return (NULL); #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN ((unsigned char *)&f)[i] = (unsigned char)(byte); #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */ ((unsigned char *)&f)[sizeof(double) - i - 1] = (unsigned char)(byte); #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */ } rtn_len = 64; limit = 0; again: if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL) return (NULL); if (snprintf(rtn, rtn_len, "%fld", f) >= (int)rtn_len) { free(rtn); if (limit++ > FLOAT_SPRINTF_TRY_LIMIT) return (NULL); rtn_len *= BUFFER_GROWFACTOR; goto again; } return rtn; } static char * decode_fp_to_float(const char *p, size_t len) { size_t i, rtn_len, limit; float f; int byte; char *rtn; if (p == NULL || len == 0 || len % 2 != 0 || len / 2 > sizeof(float)) return (NULL); memset(&f, 0, sizeof(float)); for (i = 0; i < len / 2; ++i) { byte = hex_to_dec(p[len - i * 2 - 1]) + hex_to_dec(p[len - i * 2 - 2]) * 16; if (byte < 0 || byte > 255) return (NULL); #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN ((unsigned char *)&f)[i] = (unsigned char)(byte); #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */ ((unsigned char *)&f)[sizeof(float) - i - 1] = (unsigned char)(byte); #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */ } rtn_len = 64; limit = 0; again: if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL) return (NULL); if (snprintf(rtn, rtn_len, "%ff", f) >= (int)rtn_len) { free(rtn); if (limit++ > FLOAT_SPRINTF_TRY_LIMIT) return (NULL); rtn_len *= BUFFER_GROWFACTOR; goto again; } return rtn; } static char * decode_fp_to_float128(const char *p, size_t len) { long double f; size_t rtn_len, limit, i; int byte; unsigned char buf[FLOAT_QUADRUPLE_BYTES]; char *rtn; switch(sizeof(long double)) { case FLOAT_QUADRUPLE_BYTES: return (decode_fp_to_long_double(p, len)); case FLOAT_EXTENED_BYTES: if (p == NULL || len == 0 || len % 2 != 0 || len / 2 > FLOAT_QUADRUPLE_BYTES) return (NULL); memset(buf, 0, FLOAT_QUADRUPLE_BYTES); for (i = 0; i < len / 2; ++i) { byte = hex_to_dec(p[len - i * 2 - 1]) + hex_to_dec(p[len - i * 2 - 2]) * 16; if (byte < 0 || byte > 255) return (NULL); #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN buf[i] = (unsigned char)(byte); #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */ buf[FLOAT_QUADRUPLE_BYTES - i -1] = (unsigned char)(byte); #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */ } memset(&f, 0, FLOAT_EXTENED_BYTES); #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN memcpy(&f, buf, FLOAT_EXTENED_BYTES); #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */ memcpy(&f, buf + 6, FLOAT_EXTENED_BYTES); #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */ rtn_len = 256; limit = 0; again: if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL) return (NULL); if (snprintf(rtn, rtn_len, "%Lfd", f) >= (int)rtn_len) { free(rtn); if (limit++ > FLOAT_SPRINTF_TRY_LIMIT) return (NULL); rtn_len *= BUFFER_GROWFACTOR; goto again; } return (rtn); default: return (NULL); } } static char * decode_fp_to_float80(const char *p, size_t len) { long double f; size_t rtn_len, limit, i; int byte; unsigned char buf[FLOAT_EXTENED_BYTES]; char *rtn; switch(sizeof(long double)) { case FLOAT_QUADRUPLE_BYTES: if (p == NULL || len == 0 || len % 2 != 0 || len / 2 > FLOAT_EXTENED_BYTES) return (NULL); memset(buf, 0, FLOAT_EXTENED_BYTES); for (i = 0; i < len / 2; ++i) { byte = hex_to_dec(p[len - i * 2 - 1]) + hex_to_dec(p[len - i * 2 - 2]) * 16; if (byte < 0 || byte > 255) return (NULL); #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN buf[i] = (unsigned char)(byte); #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */ buf[FLOAT_EXTENED_BYTES - i -1] = (unsigned char)(byte); #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */ } memset(&f, 0, FLOAT_QUADRUPLE_BYTES); #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN memcpy(&f, buf, FLOAT_EXTENED_BYTES); #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */ memcpy((unsigned char *)(&f) + 6, buf, FLOAT_EXTENED_BYTES); #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */ rtn_len = 256; limit = 0; again: if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL) return (NULL); if (snprintf(rtn, rtn_len, "%Lfd", f) >= (int)rtn_len) { free(rtn); if (limit++ > FLOAT_SPRINTF_TRY_LIMIT) return (NULL); rtn_len *= BUFFER_GROWFACTOR; goto again; } return (rtn); case FLOAT_EXTENED_BYTES: return (decode_fp_to_long_double(p, len)); default: return (NULL); } } static char * decode_fp_to_long_double(const char *p, size_t len) { long double f; size_t rtn_len, limit, i; int byte; char *rtn; if (p == NULL || len == 0 || len % 2 != 0 || len / 2 > sizeof(long double)) return (NULL); memset(&f, 0, sizeof(long double)); for (i = 0; i < len / 2; ++i) { byte = hex_to_dec(p[len - i * 2 - 1]) + hex_to_dec(p[len - i * 2 - 2]) * 16; if (byte < 0 || byte > 255) return (NULL); #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN ((unsigned char *)&f)[i] = (unsigned char)(byte); #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */ ((unsigned char *)&f)[sizeof(long double) - i - 1] = (unsigned char)(byte); #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */ } rtn_len = 256; limit = 0; again: if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL) return (NULL); if (snprintf(rtn, rtn_len, "%Lfd", f) >= (int)rtn_len) { free(rtn); if (limit++ > FLOAT_SPRINTF_TRY_LIMIT) return (NULL); rtn_len *= BUFFER_GROWFACTOR; goto again; } return (rtn); } /* Simple hex to integer function used by decode_to_* function. */ static int hex_to_dec(char c) { switch (c) { case '0': return (0); case '1': return (1); case '2': return (2); case '3': return (3); case '4': return (4); case '5': return (5); case '6': return (6); case '7': return (7); case '8': return (8); case '9': return (9); case 'a': return (10); case 'b': return (11); case 'c': return (12); case 'd': return (13); case 'e': return (14); case 'f': return (15); default: return (-1); - }; + } } /** * @brief Test input string is mangled by IA-64 C++ ABI style. * * Test string heads with "_Z" or "_GLOBAL__I_". * @return Return 0 at false. */ bool is_cpp_mangled_gnu3(const char *org) { size_t len; len = strlen(org); return ((len > 2 && *org == '_' && *(org + 1) == 'Z') || (len > 11 && !strncmp(org, "_GLOBAL__I_", 11))); } static void vector_read_cmd_dest(struct vector_read_cmd *v) { if (v == NULL) return; free(v->r_container); } /* return -1 at failed, 0 at not found, 1 at found. */ static int vector_read_cmd_find(struct vector_read_cmd *v, enum read_cmd dst) { size_t i; if (v == NULL || dst == READ_FAIL) return (-1); for (i = 0; i < v->size; ++i) if (v->r_container[i] == dst) return (1); return (0); } static int vector_read_cmd_init(struct vector_read_cmd *v) { if (v == NULL) return (0); v->size = 0; v->capacity = VECTOR_DEF_CAPACITY; if ((v->r_container = malloc(sizeof(enum read_cmd) * v->capacity)) == NULL) return (0); return (1); } static int vector_read_cmd_pop(struct vector_read_cmd *v) { if (v == NULL || v->size == 0) return (0); --v->size; v->r_container[v->size] = READ_FAIL; return (1); } static int vector_read_cmd_push(struct vector_read_cmd *v, enum read_cmd cmd) { enum read_cmd *tmp_r_ctn; size_t tmp_cap; size_t i; if (v == NULL) return (0); if (v->size == v->capacity) { tmp_cap = v->capacity * BUFFER_GROWFACTOR; if ((tmp_r_ctn = malloc(sizeof(enum read_cmd) * tmp_cap)) == NULL) return (0); for (i = 0; i < v->size; ++i) tmp_r_ctn[i] = v->r_container[i]; free(v->r_container); v->r_container = tmp_r_ctn; v->capacity = tmp_cap; } v->r_container[v->size] = cmd; ++v->size; return (1); } static void vector_type_qualifier_dest(struct vector_type_qualifier *v) { if (v == NULL) return; free(v->q_container); vector_str_dest(&v->ext_name); } /* size, capacity, ext_name */ static int vector_type_qualifier_init(struct vector_type_qualifier *v) { if (v == NULL) return (0); v->size = 0; v->capacity = VECTOR_DEF_CAPACITY; if ((v->q_container = malloc(sizeof(enum type_qualifier) * v->capacity)) == NULL) return (0); assert(v->q_container != NULL); if (vector_str_init(&v->ext_name) == false) { free(v->q_container); return (0); } return (1); } static int vector_type_qualifier_push(struct vector_type_qualifier *v, enum type_qualifier t) { enum type_qualifier *tmp_ctn; size_t tmp_cap; size_t i; if (v == NULL) return (0); if (v->size == v->capacity) { tmp_cap = v->capacity * BUFFER_GROWFACTOR; if ((tmp_ctn = malloc(sizeof(enum type_qualifier) * tmp_cap)) == NULL) return (0); for (i = 0; i < v->size; ++i) tmp_ctn[i] = v->q_container[i]; free(v->q_container); v->q_container = tmp_ctn; v->capacity = tmp_cap; } v->q_container[v->size] = t; ++v->size; return (1); } Index: vendor/elftoolchain/dist/libelftc/make-toolchain-version =================================================================== --- vendor/elftoolchain/dist/libelftc/make-toolchain-version (revision 300227) +++ vendor/elftoolchain/dist/libelftc/make-toolchain-version (revision 300228) @@ -1,104 +1,110 @@ #!/bin/sh # # This script generates a project-wide version identifier for use by # the `elftc_version()' API. # -# $Id: make-toolchain-version 3299 2016-01-09 19:58:46Z jkoshy $ +# $Id: make-toolchain-version 3414 2016-02-16 22:55:28Z jkoshy $ # # Defaults. # buildhost=`uname -s` elftcname="elftoolchain" options="e:h:o:r:t:" top="" version="HEAD" versionfile="elftc_version.c" progname=`basename ${0}` usage() { exec >&2 # Print a message, if supplied. if [ -n "${*}" ]; then echo "##${@}"; fi echo "Usage: ${progname} [options]" echo " Generate a toolchain-wide version number" echo " -e PROJECTNAME Set the project name [default: ${elftcname}]." echo " -h HOSTOS Set the build OS [default: ${buildhost}]." echo " -o OUTPUT Set the output file [default: ${versionfile}]." echo " -r VERSION Set the version string [default: ${version}]." echo " -t TOPDIR Set the top-of-tree directory [required]." exit 1 } # # Parse options. # while getopts ${options} option do case ${option} in 'e') elftcname="${OPTARG}" ;; 'h') buildhost="${OPTARG}" ;; 'o') versionfile="${OPTARG}" ;; 'r') version="${OPTARG}" ;; 't') top="${OPTARG}" ;; '?') usage ;; esac done [ -n "${top}" ] || usage # Try to determine the in-tree revision number. # # This script attempts to handle the case where our sources have been # incorporated into an operating system's base sources. # # - If SVN is detected, we use the `svninfo' tool to determine the # in-tree revision number. # - If CVS is detected, we use the string `unknown'. # - Otherwise, we use `git --describe'. curdir=`pwd` cd ${top} || usage "ERROR: Cannot change directory to \"${top}\"." -if [ -d .svn -o -d ../.svn ]; then # FreeBSD and SF.Net sources. - versionstring=" svn:"$(svnversion) -elif [ -d CVS ]; then # NetBSD. +if [ -d CVS ]; then # Look for CVS (NetBSD). versionstring=" cvs:unknown" -else # DragonFlyBSD. - versionstring=" git:"$(git describe --all --dirty --long 2> /dev/null) - - # Cannot determine an in-tree version number. - if [ $? -ne 0 ]; then - versionstring="" +else # Try git (DragonFlyBSD). + gitversion="$(git describe --all --dirty --long 2> /dev/null)" + if [ -n "${gitversion}" ]; then + versionstring=" git:${gitversion}" + else # Assume an SVN checkout (SourceForge or FreeBSD). + svnversion="$(svnversion)" + if [ -n "${svnversion}" ]; then + versionstring=" svn:$(svnversion)" + fi fi +fi + +if [ -z "${versionstring}" ]; then + echo "ERROR: cannot determine a revision number." 1>&2 + exit 1 fi cd ${curdir} || usage "Cannot change back to ${curdir}." # # Only replace the source file if its content has changed. # tmpfile=`mktemp ${TMPDIR:-/tmp}/MV.XXXXXXX` trap "rm -f ${tmpfile};" 0 1 2 3 15 cat > ${tmpfile} < #include const char * elftc_version(void) { return "${elftcname} ${version} ${buildhost}${versionstring}"; } EOF if ! cmp -s ${tmpfile} ${versionfile}; then echo "@ ${progname}: building \"${versionfile}\"." cp ${tmpfile} ${versionfile} || exit ${?} fi Index: vendor/elftoolchain/dist/libpe/libpe_section.c =================================================================== --- vendor/elftoolchain/dist/libpe/libpe_section.c (revision 300227) +++ vendor/elftoolchain/dist/libpe/libpe_section.c (revision 300228) @@ -1,518 +1,518 @@ /*- * Copyright (c) 2016 Kai Wang * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #include #include #include #include #include #include "_libpe.h" -ELFTC_VCSID("$Id: libpe_section.c 3312 2016-01-10 09:23:51Z kaiwang27 $"); +ELFTC_VCSID("$Id: libpe_section.c 3446 2016-05-03 01:31:17Z emaste $"); PE_Scn * libpe_alloc_scn(PE *pe) { PE_Scn *ps; if ((ps = calloc(1, sizeof(PE_Scn))) == NULL) { errno = ENOMEM; return (NULL); } STAILQ_INIT(&ps->ps_b); ps->ps_pe = pe; return (ps); } void libpe_release_scn(PE_Scn *ps) { PE *pe; PE_SecBuf *sb, *_sb; assert(ps != NULL); pe = ps->ps_pe; STAILQ_REMOVE(&pe->pe_scn, ps, _PE_Scn, ps_next); STAILQ_FOREACH_SAFE(sb, &ps->ps_b, sb_next, _sb) libpe_release_buffer(sb); free(ps); } static int cmp_scn(PE_Scn *a, PE_Scn *b) { if (a->ps_sh.sh_addr < b->ps_sh.sh_addr) return (-1); else if (a->ps_sh.sh_addr == b->ps_sh.sh_addr) return (0); else return (1); } static void sort_sections(PE *pe) { if (STAILQ_EMPTY(&pe->pe_scn)) return; /* Sort the list of Scn by RVA in ascending order. */ STAILQ_SORT(&pe->pe_scn, _PE_Scn, ps_next, cmp_scn); } int libpe_parse_section_headers(PE *pe) { char tmp[sizeof(PE_SecHdr)], *hdr; PE_Scn *ps; PE_SecHdr *sh; PE_CoffHdr *ch; PE_DataDir *dd; int found, i; assert(pe->pe_ch != NULL); for (i = 0; (uint16_t) i < pe->pe_ch->ch_nsec; i++) { if (read(pe->pe_fd, tmp, sizeof(PE_SecHdr)) != (ssize_t) sizeof(PE_SecHdr)) { pe->pe_flags |= LIBPE_F_BAD_SEC_HEADER; return (0); } if ((ps = libpe_alloc_scn(pe)) == NULL) return (-1); STAILQ_INSERT_TAIL(&pe->pe_scn, ps, ps_next); ps->ps_ndx = ++pe->pe_nscn; /* Setion index is 1-based */ sh = &ps->ps_sh; /* * Note that the section name won't be NUL-terminated if * its length happens to be 8. */ memcpy(sh->sh_name, tmp, sizeof(sh->sh_name)); hdr = tmp + 8; PE_READ32(hdr, sh->sh_virtsize); PE_READ32(hdr, sh->sh_addr); PE_READ32(hdr, sh->sh_rawsize); PE_READ32(hdr, sh->sh_rawptr); PE_READ32(hdr, sh->sh_relocptr); PE_READ32(hdr, sh->sh_lineptr); PE_READ16(hdr, sh->sh_nreloc); PE_READ16(hdr, sh->sh_nline); PE_READ32(hdr, sh->sh_char); } /* * For all the data directories that don't belong to any section, * we create pseudo sections for them to make layout easier. */ dd = pe->pe_dd; if (dd != NULL && dd->dd_total > 0) { for (i = 0; (uint32_t) i < pe->pe_dd->dd_total; i++) { if (dd->dd_e[i].de_size == 0) continue; found = 0; STAILQ_FOREACH(ps, &pe->pe_scn, ps_next) { sh = &ps->ps_sh; if (dd->dd_e[i].de_addr >= sh->sh_addr && dd->dd_e[i].de_addr + dd->dd_e[i].de_size <= sh->sh_addr + sh->sh_virtsize) { found = 1; break; } } if (found) continue; if ((ps = libpe_alloc_scn(pe)) == NULL) return (-1); STAILQ_INSERT_TAIL(&pe->pe_scn, ps, ps_next); ps->ps_ndx = 0xFFFF0000U | i; sh = &ps->ps_sh; sh->sh_rawptr = dd->dd_e[i].de_addr; /* FIXME */ sh->sh_rawsize = dd->dd_e[i].de_size; } } /* * Also consider the COFF symbol table as a pseudo section. */ ch = pe->pe_ch; if (ch->ch_nsym > 0) { if ((ps = libpe_alloc_scn(pe)) == NULL) return (-1); STAILQ_INSERT_TAIL(&pe->pe_scn, ps, ps_next); ps->ps_ndx = 0xFFFFFFFFU; sh = &ps->ps_sh; sh->sh_rawptr = ch->ch_symptr; sh->sh_rawsize = ch->ch_nsym * PE_SYM_ENTRY_SIZE; pe->pe_nsym = ch->ch_nsym; } /* PE file headers initialization is complete if we reach here. */ return (0); } int libpe_load_section(PE *pe, PE_Scn *ps) { PE_SecHdr *sh; PE_SecBuf *sb; size_t sz; char tmp[4]; assert(pe != NULL && ps != NULL); assert((ps->ps_flags & LIBPE_F_LOAD_SECTION) == 0); sh = &ps->ps_sh; /* Allocate a PE_SecBuf struct without buffer for empty sections. */ if (sh->sh_rawsize == 0) { (void) libpe_alloc_buffer(ps, 0); ps->ps_flags |= LIBPE_F_LOAD_SECTION; return (0); } if ((pe->pe_flags & LIBPE_F_SPECIAL_FILE) == 0) { if (lseek(pe->pe_fd, (off_t) sh->sh_rawptr, SEEK_SET) < 0) { errno = EIO; return (-1); } } if ((sb = libpe_alloc_buffer(ps, sh->sh_rawsize)) == NULL) return (-1); if (read(pe->pe_fd, sb->sb_pb.pb_buf, sh->sh_rawsize) != (ssize_t) sh->sh_rawsize) { errno = EIO; return (-1); } if (ps->ps_ndx == 0xFFFFFFFFU) { /* * Index 0xFFFFFFFF indicates this section is a pseudo * section that contains the COFF symbol table. We should * read in the string table right after it. */ if (read(pe->pe_fd, tmp, sizeof(tmp)) != (ssize_t) sizeof(tmp)) { errno = EIO; return (-1); } sz = le32dec(tmp); /* * The minimum value for the size field is 4, which indicates * there is no string table. */ if (sz > 4) { sz -= 4; if ((sb = libpe_alloc_buffer(ps, sz)) == NULL) return (-1); if (read(pe->pe_fd, sb->sb_pb.pb_buf, sz) != (ssize_t) sz) { errno = EIO; return (-1); } } } ps->ps_flags |= LIBPE_F_LOAD_SECTION; return (0); } int libpe_load_all_sections(PE *pe) { PE_Scn *ps; PE_SecHdr *sh; unsigned r, s; off_t off; char tmp[256]; /* Calculate the current offset into the file. */ off = 0; if (pe->pe_dh != NULL) off += pe->pe_dh->dh_lfanew + 4; if (pe->pe_ch != NULL) off += sizeof(PE_CoffHdr) + pe->pe_ch->ch_optsize; STAILQ_FOREACH(ps, &pe->pe_scn, ps_next) { if (ps->ps_flags & LIBPE_F_LOAD_SECTION) continue; sh = &ps->ps_sh; /* * For special files, we consume the padding in between * and advance to the section offset. */ if (pe->pe_flags & LIBPE_F_SPECIAL_FILE) { /* Can't go backwards. */ if (off > sh->sh_rawptr) { errno = EIO; return (-1); } if (off < sh->sh_rawptr) { r = sh->sh_rawptr - off; for (; r > 0; r -= s) { s = r > sizeof(tmp) ? sizeof(tmp) : r; if (read(pe->pe_fd, tmp, s) != (ssize_t) s) { errno = EIO; return (-1); } } } } /* Load the section content. */ if (libpe_load_section(pe, ps) < 0) return (-1); } return (0); } int libpe_resync_sections(PE *pe, off_t off) { PE_Scn *ps; PE_SecHdr *sh; size_t falign, nsec; /* Firstly, sort all sections by their file offsets. */ sort_sections(pe); /* Count the number of sections. */ nsec = 0; STAILQ_FOREACH(ps, &pe->pe_scn, ps_next) { if (ps->ps_flags & LIBPE_F_STRIP_SECTION) continue; if (ps->ps_ndx & 0xFFFF0000U) continue; nsec++; } pe->pe_nscn = nsec; /* * Calculate the file offset for the first section. (`off' is * currently pointing to the COFF header.) */ off += sizeof(PE_CoffHdr); if (pe->pe_ch != NULL && pe->pe_ch->ch_optsize > 0) off += pe->pe_ch->ch_optsize; else { switch (pe->pe_obj) { case PE_O_PE32: off += PE_COFF_OPT_SIZE_32; break; case PE_O_PE32P: off += PE_COFF_OPT_SIZE_32P; break; case PE_O_COFF: default: break; } } off += nsec * sizeof(PE_SecHdr); /* * Determine the file alignment for sections. */ if (pe->pe_oh != NULL && pe->pe_oh->oh_filealign > 0) falign = pe->pe_oh->oh_filealign; else { /* * Use the default file alignment defined by the * PE/COFF specification. */ if (pe->pe_obj == PE_O_COFF) falign = 4; else falign = 512; } /* * Step through each section (and pseduo section) and verify * alignment constraint and overlapping, make adjustment if need. */ pe->pe_rvamax = 0; STAILQ_FOREACH(ps, &pe->pe_scn, ps_next) { if (ps->ps_flags & LIBPE_F_STRIP_SECTION) continue; sh = &ps->ps_sh; if (sh->sh_addr + sh->sh_virtsize > pe->pe_rvamax) pe->pe_rvamax = sh->sh_addr + sh->sh_virtsize; if (ps->ps_ndx & 0xFFFF0000U) ps->ps_falign = 4; else ps->ps_falign = falign; off = roundup(off, ps->ps_falign); if (off != sh->sh_rawptr) ps->ps_flags |= PE_F_DIRTY; if (ps->ps_flags & PE_F_DIRTY) { if ((ps->ps_flags & LIBPE_F_LOAD_SECTION) == 0) { if (libpe_load_section(pe, ps) < 0) return (-1); } sh->sh_rawsize = libpe_resync_buffers(ps); } /* * Sections only contains uninitialized data should set * PointerToRawData to zero according to the PE/COFF * specification. */ if (sh->sh_rawsize == 0) sh->sh_rawptr = 0; else sh->sh_rawptr = off; off += sh->sh_rawsize; } return (0); } off_t libpe_write_section_headers(PE *pe, off_t off) { char tmp[sizeof(PE_SecHdr)], *hdr; PE_Scn *ps; PE_SecHdr *sh; if (pe->pe_flags & LIBPE_F_BAD_SEC_HEADER || pe->pe_nscn == 0) return (off); if ((pe->pe_flags & LIBPE_F_DIRTY_SEC_HEADER) == 0) { off += sizeof(PE_SecHdr) * pe->pe_ch->ch_nsec; return (off); } STAILQ_FOREACH(ps, &pe->pe_scn, ps_next) { if (ps->ps_flags & LIBPE_F_STRIP_SECTION) continue; if (ps->ps_ndx & 0xFFFF0000U) continue; if ((pe->pe_flags & LIBPE_F_DIRTY_SEC_HEADER) == 0 && (ps->ps_flags & PE_F_DIRTY) == 0) goto next_header; sh = &ps->ps_sh; memcpy(tmp, sh->sh_name, sizeof(sh->sh_name)); hdr = tmp + 8; PE_WRITE32(hdr, sh->sh_virtsize); PE_WRITE32(hdr, sh->sh_addr); PE_WRITE32(hdr, sh->sh_rawsize); PE_WRITE32(hdr, sh->sh_rawptr); PE_WRITE32(hdr, sh->sh_relocptr); PE_WRITE32(hdr, sh->sh_lineptr); PE_WRITE16(hdr, sh->sh_nreloc); PE_WRITE16(hdr, sh->sh_nline); PE_WRITE32(hdr, sh->sh_char); if (write(pe->pe_fd, tmp, sizeof(PE_SecHdr)) != (ssize_t) sizeof(PE_SecHdr)) { errno = EIO; return (-1); } next_header: off += sizeof(PE_SecHdr); } return (off); } off_t libpe_write_sections(PE *pe, off_t off) { PE_Scn *ps; PE_SecHdr *sh; if (pe->pe_flags & LIBPE_F_BAD_SEC_HEADER) return (off); STAILQ_FOREACH(ps, &pe->pe_scn, ps_next) { sh = &ps->ps_sh; if (ps->ps_flags & LIBPE_F_STRIP_SECTION) continue; /* Skip empty sections. */ if (sh->sh_rawptr == 0 || sh->sh_rawsize == 0) continue; /* * Padding between sections. (padding always written * in case the the section headers or sections are - * moved or shrinked.) + * moved or shrunk.) */ assert(off <= sh->sh_rawptr); if (off < sh->sh_rawptr) libpe_pad(pe, sh->sh_rawptr - off); if ((ps->ps_flags & PE_F_DIRTY) == 0) { assert((pe->pe_flags & LIBPE_F_SPECIAL_FILE) == 0); if (lseek(pe->pe_fd, (off_t) (sh->sh_rawptr + sh->sh_rawsize), SEEK_SET) < 0) { errno = EIO; return (-1); } off = sh->sh_rawptr + sh->sh_rawsize; continue; } off = sh->sh_rawptr; if (libpe_write_buffers(ps) < 0) return (-1); off += sh->sh_rawsize; ps->ps_flags &= ~PE_F_DIRTY; } return (off); } Index: vendor/elftoolchain/dist/libpe/pe.h =================================================================== --- vendor/elftoolchain/dist/libpe/pe.h (revision 300227) +++ vendor/elftoolchain/dist/libpe/pe.h (revision 300228) @@ -1,292 +1,295 @@ /*- * Copyright (c) 2015 Kai Wang * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: pe.h 3312 2016-01-10 09:23:51Z kaiwang27 $ + * $Id: pe.h 3441 2016-04-07 15:04:20Z emaste $ */ #ifndef _PE_H_ #define _PE_H_ #include /* * MS-DOS header. */ typedef struct _PE_DosHdr { char dh_magic[2]; uint16_t dh_lastsize; uint16_t dh_nblock; uint16_t dh_nreloc; uint16_t dh_hdrsize; uint16_t dh_minalloc; uint16_t dh_maxalloc; uint16_t dh_ss; uint16_t dh_sp; uint16_t dh_checksum; uint16_t dh_ip; uint16_t dh_cs; uint16_t dh_relocpos; uint16_t dh_noverlay; uint16_t dh_reserved1[4]; uint16_t dh_oemid; uint16_t dh_oeminfo; uint16_t dh_reserved2[10]; uint32_t dh_lfanew; } PE_DosHdr; /* * Rich header. */ typedef struct _PE_RichHdr { uint32_t rh_xor; uint32_t rh_total; uint32_t *rh_compid; uint32_t *rh_cnt; } PE_RichHdr; /* * COFF header: Machine Types. */ #define IMAGE_FILE_MACHINE_UNKNOWN 0x0 /* not specified */ #define IMAGE_FILE_MACHINE_AM33 0x1d3 /* Matsushita AM33 */ #define IMAGE_FILE_MACHINE_AMD64 0x8664 /* x86-64 */ #define IMAGE_FILE_MACHINE_ARM 0x1c0 /* ARM LE */ #define IMAGE_FILE_MACHINE_ARMNT 0x1c4 /* ARMv7(or higher) Thumb */ #define IMAGE_FILE_MACHINE_ARM64 0xaa64 /* ARMv8 64-bit */ #define IMAGE_FILE_MACHINE_EBC 0xebc /* EFI byte code */ #define IMAGE_FILE_MACHINE_I386 0x14c /* x86 */ #define IMAGE_FILE_MACHINE_IA64 0x200 /* IA64 */ #define IMAGE_FILE_MACHINE_M32R 0x9041 /* Mitsubishi M32R LE */ #define IMAGE_FILE_MACHINE_MIPS16 0x266 /* MIPS16 */ #define IMAGE_FILE_MACHINE_MIPSFPU 0x366 /* MIPS with FPU */ #define IMAGE_FILE_MACHINE_MIPSFPU16 0x466 /* MIPS16 with FPU */ #define IMAGE_FILE_MACHINE_POWERPC 0x1f0 /* Power PC LE */ #define IMAGE_FILE_MACHINE_POWERPCFP 0x1f1 /* Power PC floating point */ #define IMAGE_FILE_MACHINE_R4000 0x166 /* MIPS R4000 LE */ +#define IMAGE_FILE_MACHINE_RISCV32 0x5032 /* RISC-V 32-bit */ +#define IMAGE_FILE_MACHINE_RISCV64 0x5064 /* RISC-V 64-bit */ +#define IMAGE_FILE_MACHINE_RISCV128 0x5128 /* RISC-V 128-bit */ #define IMAGE_FILE_MACHINE_SH3 0x1a2 /* Hitachi SH3 */ #define IMAGE_FILE_MACHINE_SH3DSP 0x1a3 /* Hitachi SH3 DSP */ #define IMAGE_FILE_MACHINE_SH4 0x1a6 /* Hitachi SH4 */ #define IMAGE_FILE_MACHINE_SH5 0x1a8 /* Hitachi SH5 */ #define IMAGE_FILE_MACHINE_THUMB 0x1c2 /* ARM or Thumb interworking */ #define IMAGE_FILE_MACHINE_WCEMIPSV2 0x169 /* MIPS LE WCE v2 */ /* * COFF header: Characteristics */ #define IMAGE_FILE_RELOCS_STRIPPED 0x0001 #define IMAGE_FILE_EXECUTABLE_IMAGE 0x0002 #define IMAGE_FILE_LINE_NUMS_STRIPPED 0x0004 #define IMAGE_FILE_LOCAL_SYMS_STRIPPED 0x0008 #define IMAGE_FILE_AGGRESSIVE_WS_TRIM 0x0010 #define IMAGE_FILE_LARGE_ADDRESS_AWARE 0x0020 #define IMAGE_FILE_BYTES_REVERSED_LO 0x0080 #define IMAGE_FILE_32BIT_MACHINE 0x0100 #define IMAGE_FILE_DEBUG_STRIPPED 0x0200 #define IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP 0x0400 #define IMAGE_FILE_NET_RUN_FROM_SWAP 0x0800 #define IMAGE_FILE_SYSTEM 0x1000 #define IMAGE_FILE_DLL 0x2000 #define IMAGE_FILE_UP_SYSTEM_ONLY 0x4000 #define IMAGE_FILE_BYTES_REVERSED_HI 0x8000 /* * COFF Header. */ typedef struct _PE_CoffHdr { uint16_t ch_machine; uint16_t ch_nsec; uint32_t ch_timestamp; uint32_t ch_symptr; uint32_t ch_nsym; uint16_t ch_optsize; uint16_t ch_char; } PE_CoffHdr; /* * Optional Header: Subsystem. */ #define IMAGE_SUBSYSTEM_UNKNOWN 0 #define IMAGE_SUBSYSTEM_NATIVE 1 #define IMAGE_SUBSYSTEM_WINDOWS_GUI 2 #define IMAGE_SUBSYSTEM_WINDOWS_CUI 3 #define IMAGE_SUBSYSTEM_POSIX_CUI 7 #define IMAGE_SUBSYSTEM_WINDOWS_CE_GUI 9 #define IMAGE_SUBSYSTEM_EFI_APPLICATION 10 #define IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER 11 #define IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER 12 #define IMAGE_SUBSYSTEM_EFI_ROM 13 #define IMAGE_SUBSYSTEM_XBOX 14 /* * Optional Header: DLL Characteristics */ #define IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE 0x0040 #define IMAGE_DLL_CHARACTERISTICS_FORCE_INTEGRITY 0x0080 #define IMAGE_DLL_CHARACTERISTICS_NX_COMPAT 0x0100 #define IMAGE_DLL_CHARACTERISTICS_NO_ISOLATION 0x0200 #define IMAGE_DLL_CHARACTERISTICS_NO_SEH 0x0400 #define IMAGE_DLL_CHARACTERISTICS_NO_BIND 0x0800 #define IMAGE_DLL_CHARACTERISTICS_WDM_DRIVER 0x2000 #define IMAGE_DLL_CHARACTERISTICS_TERMINAL_SERVER_AWARE 0x8000 /* * Optional Header. */ #define PE_FORMAT_ROM 0x107 #define PE_FORMAT_32 0x10b #define PE_FORMAT_32P 0x20b typedef struct _PE_OptHdr { uint16_t oh_magic; uint8_t oh_ldvermajor; uint8_t oh_ldverminor; uint32_t oh_textsize; uint32_t oh_datasize; uint32_t oh_bsssize; uint32_t oh_entry; uint32_t oh_textbase; uint32_t oh_database; uint64_t oh_imgbase; uint32_t oh_secalign; uint32_t oh_filealign; uint16_t oh_osvermajor; uint16_t oh_osverminor; uint16_t oh_imgvermajor; uint16_t oh_imgverminor; uint16_t oh_subvermajor; uint16_t oh_subverminor; uint32_t oh_win32ver; uint32_t oh_imgsize; uint32_t oh_hdrsize; uint32_t oh_checksum; uint16_t oh_subsystem; uint16_t oh_dllchar; uint64_t oh_stacksizer; uint64_t oh_stacksizec; uint64_t oh_heapsizer; uint64_t oh_heapsizec; uint32_t oh_ldrflags; uint32_t oh_ndatadir; } PE_OptHdr; /* * Optional Header: Data Directories. */ #define PE_DD_EXPORT 0 #define PE_DD_IMPORT 1 #define PE_DD_RESROUCE 2 #define PE_DD_EXCEPTION 3 #define PE_DD_CERTIFICATE 4 #define PE_DD_BASERELOC 5 #define PE_DD_DEBUG 6 #define PE_DD_ARCH 7 #define PE_DD_GLOBALPTR 8 #define PE_DD_TLS 9 #define PE_DD_LOADCONFIG 10 #define PE_DD_BOUNDIMPORT 11 #define PE_DD_IAT 12 #define PE_DD_DELAYIMPORT 13 #define PE_DD_CLRRUNTIME 14 #define PE_DD_RESERVED 15 #define PE_DD_MAX 16 typedef struct _PE_DataDirEntry { uint32_t de_addr; uint32_t de_size; } PE_DataDirEntry; typedef struct _PE_DataDir { PE_DataDirEntry dd_e[PE_DD_MAX]; uint32_t dd_total; } PE_DataDir; /* * Section Headers: Section flags. */ #define IMAGE_SCN_TYPE_NO_PAD 0x00000008 #define IMAGE_SCN_CNT_CODE 0x00000020 #define IMAGE_SCN_CNT_INITIALIZED_DATA 0x00000040 #define IMAGE_SCN_CNT_UNINITIALIZED_DATA 0x00000080 #define IMAGE_SCN_LNK_OTHER 0x00000100 #define IMAGE_SCN_LNK_INFO 0x00000200 #define IMAGE_SCN_LNK_REMOVE 0x00000800 #define IMAGE_SCN_LNK_COMDAT 0x00001000 #define IMAGE_SCN_GPREL 0x00008000 #define IMAGE_SCN_MEM_PURGEABLE 0x00020000 #define IMAGE_SCN_MEM_16BIT 0x00020000 #define IMAGE_SCN_MEM_LOCKED 0x00040000 #define IMAGE_SCN_MEM_PRELOAD 0x00080000 #define IMAGE_SCN_ALIGN_1BYTES 0x00100000 #define IMAGE_SCN_ALIGN_2BYTES 0x00200000 #define IMAGE_SCN_ALIGN_4BYTES 0x00300000 #define IMAGE_SCN_ALIGN_8BYTES 0x00400000 #define IMAGE_SCN_ALIGN_16BYTES 0x00500000 #define IMAGE_SCN_ALIGN_32BYTES 0x00600000 #define IMAGE_SCN_ALIGN_64BYTES 0x00700000 #define IMAGE_SCN_ALIGN_128BYTES 0x00800000 #define IMAGE_SCN_ALIGN_256BYTES 0x00900000 #define IMAGE_SCN_ALIGN_512BYTES 0x00A00000 #define IMAGE_SCN_ALIGN_1024BYTES 0x00B00000 #define IMAGE_SCN_ALIGN_2048BYTES 0x00C00000 #define IMAGE_SCN_ALIGN_4096BYTES 0x00D00000 #define IMAGE_SCN_ALIGN_8192BYTES 0x00E00000 #define IMAGE_SCN_LNK_NRELOC_OVFL 0x01000000 #define IMAGE_SCN_MEM_DISCARDABLE 0x02000000 #define IMAGE_SCN_MEM_NOT_CACHED 0x04000000 #define IMAGE_SCN_MEM_NOT_PAGED 0x08000000 #define IMAGE_SCN_MEM_SHARED 0x10000000 #define IMAGE_SCN_MEM_EXECUTE 0x20000000 #define IMAGE_SCN_MEM_READ 0x40000000 #define IMAGE_SCN_MEM_WRITE 0x80000000 /* * Section Headers. */ typedef struct _PE_SecHdr { char sh_name[8]; uint32_t sh_virtsize; uint32_t sh_addr; uint32_t sh_rawsize; uint32_t sh_rawptr; uint32_t sh_relocptr; uint32_t sh_lineptr; uint16_t sh_nreloc; uint16_t sh_nline; uint32_t sh_char; } PE_SecHdr; #endif /* !_PE_H_ */ Index: vendor/elftoolchain/dist/nm/nm.c =================================================================== --- vendor/elftoolchain/dist/nm/nm.c (revision 300227) +++ vendor/elftoolchain/dist/nm/nm.c (revision 300228) @@ -1,2119 +1,2120 @@ /*- * Copyright (c) 2007 Hyogeol Lee * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer * in this position and unchanged. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "_elftc.h" -ELFTC_VCSID("$Id: nm.c 3179 2015-03-31 19:38:56Z emaste $"); +ELFTC_VCSID("$Id: nm.c 3472 2016-05-17 20:11:16Z emaste $"); /* symbol information list */ STAILQ_HEAD(sym_head, sym_entry); struct sym_entry { char *name; GElf_Sym *sym; STAILQ_ENTRY(sym_entry) sym_entries; }; typedef int (*fn_sort)(const void *, const void *); typedef void (*fn_elem_print)(char, const char *, const GElf_Sym *, const char *); typedef void (*fn_sym_print)(const GElf_Sym *); typedef int (*fn_filter)(char, const GElf_Sym *, const char *); /* output filter list */ static SLIST_HEAD(filter_head, filter_entry) nm_out_filter = SLIST_HEAD_INITIALIZER(nm_out_filter); struct filter_entry { fn_filter fn; SLIST_ENTRY(filter_entry) filter_entries; }; struct sym_print_data { struct sym_head *headp; size_t sh_num, list_num; const char *t_table, **s_table, *filename, *objname; }; struct nm_prog_info { const char *name; const char *def_filename; }; /* List for line number information. */ struct line_info_entry { uint64_t addr; /* address */ uint64_t line; /* line number */ char *file; /* file name with path */ SLIST_ENTRY(line_info_entry) entries; }; SLIST_HEAD(line_info_head, line_info_entry); /* List for function line number information. */ struct func_info_entry { char *name; /* function name */ char *file; /* file name with path */ uint64_t lowpc; /* low address */ uint64_t highpc; /* high address */ uint64_t line; /* line number */ SLIST_ENTRY(func_info_entry) entries; }; SLIST_HEAD(func_info_head, func_info_entry); /* List for variable line number information. */ struct var_info_entry { char *name; /* variable name */ char *file; /* file name with path */ uint64_t addr; /* address */ uint64_t line; /* line number */ SLIST_ENTRY(var_info_entry) entries; }; SLIST_HEAD(var_info_head, var_info_entry); /* output numric type */ enum radix { RADIX_OCT, RADIX_HEX, RADIX_DEC }; /* output symbol type, PRINT_SYM_DYN for dynamic symbol only */ enum print_symbol { PRINT_SYM_SYM, PRINT_SYM_DYN }; /* output name type */ enum print_name { PRINT_NAME_NONE, PRINT_NAME_FULL, PRINT_NAME_MULTI }; struct nm_prog_options { enum print_symbol print_symbol; enum print_name print_name; enum radix t; int demangle_type; bool print_debug; bool print_armap; int print_size; bool debug_line; int def_only; bool undef_only; int sort_size; bool sort_reverse; int no_demangle; /* * function pointer to sort symbol list. * possible function - cmp_name, cmp_none, cmp_size, cmp_value */ fn_sort sort_fn; /* * function pointer to print symbol elem. * possible function - sym_elem_print_all * sym_elem_print_all_portable * sym_elem_print_all_sysv */ fn_elem_print elem_print_fn; fn_sym_print value_print_fn; fn_sym_print size_print_fn; }; #define CHECK_SYM_PRINT_DATA(p) (p->headp == NULL || p->sh_num == 0 || \ p->t_table == NULL || p->s_table == NULL || p->filename == NULL) #define IS_SYM_TYPE(t) ((t) == '?' || isalpha((t)) != 0) #define IS_UNDEF_SYM_TYPE(t) ((t) == 'U' || (t) == 'v' || (t) == 'w') #define UNUSED(p) ((void)p) static int cmp_name(const void *, const void *); static int cmp_none(const void *, const void *); static int cmp_size(const void *, const void *); static int cmp_value(const void *, const void *); static void filter_dest(void); static int filter_insert(fn_filter); static void get_opt(int, char **); static int get_sym(Elf *, struct sym_head *, int, size_t, size_t, const char *, const char **, int); static const char * get_sym_name(Elf *, const GElf_Sym *, size_t, const char **, int); static char get_sym_type(const GElf_Sym *, const char *); static void global_dest(void); static void global_init(void); static bool is_sec_data(GElf_Shdr *); static bool is_sec_debug(const char *); static bool is_sec_nobits(GElf_Shdr *); static bool is_sec_readonly(GElf_Shdr *); static bool is_sec_text(GElf_Shdr *); static void print_ar_index(int, Elf *); static void print_header(const char *, const char *); static void print_version(void); static int read_elf(Elf *, const char *, Elf_Kind); static int read_object(const char *); static int read_files(int, char **); static void set_opt_value_print_fn(enum radix); static int sym_elem_def(char, const GElf_Sym *, const char *); static int sym_elem_global(char, const GElf_Sym *, const char *); static int sym_elem_global_static(char, const GElf_Sym *, const char *); static int sym_elem_nondebug(char, const GElf_Sym *, const char *); static int sym_elem_nonzero_size(char, const GElf_Sym *, const char *); static void sym_elem_print_all(char, const char *, const GElf_Sym *, const char *); static void sym_elem_print_all_portable(char, const char *, const GElf_Sym *, const char *); static void sym_elem_print_all_sysv(char, const char *, const GElf_Sym *, const char *); static int sym_elem_undef(char, const GElf_Sym *, const char *); static void sym_list_dest(struct sym_head *); static int sym_list_insert(struct sym_head *, const char *, const GElf_Sym *); static void sym_list_print(struct sym_print_data *, struct func_info_head *, struct var_info_head *, struct line_info_head *); static void sym_list_print_each(struct sym_entry *, struct sym_print_data *, struct func_info_head *, struct var_info_head *, struct line_info_head *); static struct sym_entry *sym_list_sort(struct sym_print_data *); static void sym_size_oct_print(const GElf_Sym *); static void sym_size_hex_print(const GElf_Sym *); static void sym_size_dec_print(const GElf_Sym *); static void sym_value_oct_print(const GElf_Sym *); static void sym_value_hex_print(const GElf_Sym *); static void sym_value_dec_print(const GElf_Sym *); static void usage(int); static struct nm_prog_info nm_info; static struct nm_prog_options nm_opts; static int nm_elfclass; /* * Point to current sym_print_data to use portable qsort function. * (e.g. There is no qsort_r function in NetBSD.) * * Using in sym_list_sort. */ static struct sym_print_data *nm_print_data; static const struct option nm_longopts[] = { { "debug-syms", no_argument, NULL, 'a' }, { "defined-only", no_argument, &nm_opts.def_only, 1}, { "demangle", optional_argument, NULL, 'C' }, { "dynamic", no_argument, NULL, 'D' }, { "extern-only", no_argument, NULL, 'g' }, { "format", required_argument, NULL, 'F' }, { "help", no_argument, NULL, 'h' }, { "line-numbers", no_argument, NULL, 'l' }, { "no-demangle", no_argument, &nm_opts.no_demangle, 1}, { "no-sort", no_argument, NULL, 'p' }, { "numeric-sort", no_argument, NULL, 'v' }, { "print-armap", no_argument, NULL, 's' }, { "print-file-name", no_argument, NULL, 'A' }, { "print-size", no_argument, NULL, 'S' }, { "radix", required_argument, NULL, 't' }, { "reverse-sort", no_argument, NULL, 'r' }, { "size-sort", no_argument, &nm_opts.sort_size, 1}, { "undefined-only", no_argument, NULL, 'u' }, { "version", no_argument, NULL, 'V' }, { NULL, 0, NULL, 0 } }; #if defined(ELFTC_NEED_BYTEORDER_EXTENSIONS) static __inline uint32_t be32dec(const void *pp) { unsigned char const *p = (unsigned char const *)pp; return ((p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3]); } static __inline uint32_t le32dec(const void *pp) { unsigned char const *p = (unsigned char const *)pp; return ((p[3] << 24) | (p[2] << 16) | (p[1] << 8) | p[0]); } static __inline uint64_t be64dec(const void *pp) { unsigned char const *p = (unsigned char const *)pp; return (((uint64_t)be32dec(p) << 32) | be32dec(p + 4)); } static __inline uint64_t le64dec(const void *pp) { unsigned char const *p = (unsigned char const *)pp; return (((uint64_t)le32dec(p + 4) << 32) | le32dec(p)); } #endif static int cmp_name(const void *l, const void *r) { assert(l != NULL); assert(r != NULL); assert(((const struct sym_entry *)l)->name != NULL); assert(((const struct sym_entry *)r)->name != NULL); return (strcmp(((const struct sym_entry *)l)->name, ((const struct sym_entry *)r)->name)); } static int cmp_none(const void *l, const void *r) { UNUSED(l); UNUSED(r); return (0); } /* Size comparison. If l and r have same size, compare their name. */ static int cmp_size(const void *lp, const void *rp) { const struct sym_entry *l, *r; l = lp; r = rp; assert(l != NULL); assert(l->name != NULL); assert(l->sym != NULL); assert(r != NULL); assert(r->name != NULL); assert(r->sym != NULL); if (l->sym->st_size == r->sym->st_size) return (strcmp(l->name, r->name)); return (l->sym->st_size - r->sym->st_size); } /* Value comparison. Undefined symbols come first. */ static int cmp_value(const void *lp, const void *rp) { const struct sym_entry *l, *r; const char *ttable; int l_is_undef, r_is_undef; l = lp; r = rp; assert(nm_print_data != NULL); ttable = nm_print_data->t_table; assert(l != NULL); assert(l->name != NULL); assert(l->sym != NULL); assert(r != NULL); assert(r->name != NULL); assert(r->sym != NULL); assert(ttable != NULL); l_is_undef = IS_UNDEF_SYM_TYPE(get_sym_type(l->sym, ttable)) ? 1 : 0; r_is_undef = IS_UNDEF_SYM_TYPE(get_sym_type(r->sym, ttable)) ? 1 : 0; assert(l_is_undef + r_is_undef >= 0); assert(l_is_undef + r_is_undef <= 2); switch (l_is_undef + r_is_undef) { case 0: /* Both defined */ if (l->sym->st_value == r->sym->st_value) return (strcmp(l->name, r->name)); return (l->sym->st_value > r->sym->st_value ? 1 : -1); case 1: /* One undefined */ return (l_is_undef == 0 ? 1 : -1); case 2: /* Both undefined */ return (strcmp(l->name, r->name)); } /* NOTREACHED */ return (l->sym->st_value - r->sym->st_value); } static void filter_dest(void) { struct filter_entry *e; while (!SLIST_EMPTY(&nm_out_filter)) { e = SLIST_FIRST(&nm_out_filter); SLIST_REMOVE_HEAD(&nm_out_filter, filter_entries); free(e); } } static int filter_insert(fn_filter filter_fn) { struct filter_entry *e; assert(filter_fn != NULL); if ((e = malloc(sizeof(struct filter_entry))) == NULL) { warn("malloc"); return (0); } e->fn = filter_fn; SLIST_INSERT_HEAD(&nm_out_filter, e, filter_entries); return (1); } static int parse_demangle_option(const char *opt) { if (opt == NULL) return (ELFTC_DEM_UNKNOWN); else if (!strncasecmp(opt, "gnu-v2", 6)) return (ELFTC_DEM_GNU2); else if (!strncasecmp(opt, "gnu-v3", 6)) return (ELFTC_DEM_GNU3); else if (!strncasecmp(opt, "arm", 3)) return (ELFTC_DEM_ARM); else errx(EXIT_FAILURE, "unknown demangling style '%s'", opt); /* NOTREACHED */ return (0); } static void get_opt(int argc, char **argv) { int ch; bool is_posix, oflag; if (argc <= 0 || argv == NULL) return; oflag = is_posix = false; nm_opts.t = RADIX_HEX; while ((ch = getopt_long(argc, argv, "ABCDF:PSVaefghlnoprst:uvx", nm_longopts, NULL)) != -1) { switch (ch) { case 'A': nm_opts.print_name = PRINT_NAME_FULL; break; case 'B': nm_opts.elem_print_fn = &sym_elem_print_all; break; case 'C': nm_opts.demangle_type = parse_demangle_option(optarg); break; case 'D': nm_opts.print_symbol = PRINT_SYM_DYN; break; case 'F': /* sysv, bsd, posix */ switch (optarg[0]) { case 'B': case 'b': nm_opts.elem_print_fn = &sym_elem_print_all; break; case 'P': case 'p': is_posix = true; nm_opts.elem_print_fn = &sym_elem_print_all_portable; break; case 'S': case 's': nm_opts.elem_print_fn = &sym_elem_print_all_sysv; break; default: warnx("%s: Invalid format", optarg); usage(1); } break; case 'P': is_posix = true; nm_opts.elem_print_fn = &sym_elem_print_all_portable; break; case 'S': nm_opts.print_size = 1; break; case 'V': print_version(); /* NOTREACHED */ case 'a': nm_opts.print_debug = true; break; case 'e': filter_insert(sym_elem_global_static); break; case 'f': break; case 'g': filter_insert(sym_elem_global); break; case 'h': usage(0); break; case 'l': nm_opts.debug_line = true; break; case 'n': case 'v': nm_opts.sort_fn = &cmp_value; break; case 'o': oflag = true; break; case 'p': nm_opts.sort_fn = &cmp_none; break; case 'r': nm_opts.sort_reverse = true; break; case 's': nm_opts.print_armap = true; break; case 't': /* t require always argument to getopt_long */ switch (optarg[0]) { case 'd': nm_opts.t = RADIX_DEC; break; case 'o': nm_opts.t = RADIX_OCT; break; case 'x': nm_opts.t = RADIX_HEX; break; default: warnx("%s: Invalid radix", optarg); usage(1); } break; case 'u': filter_insert(sym_elem_undef); nm_opts.undef_only = true; break; /* case 'v': see case 'n' above. */ case 'x': nm_opts.t = RADIX_HEX; break; case 0: if (nm_opts.sort_size != 0) { nm_opts.sort_fn = &cmp_size; filter_insert(sym_elem_def); filter_insert(sym_elem_nonzero_size); } if (nm_opts.def_only != 0) filter_insert(sym_elem_def); if (nm_opts.no_demangle != 0) nm_opts.demangle_type = -1; break; default : usage(1); } } /* * In POSIX mode, the '-o' option controls the output radix. * In non-POSIX mode, the option is a synonym for the '-A' and * '--print-file-name' options. */ if (oflag) { if (is_posix) nm_opts.t = RADIX_OCT; else nm_opts.print_name = PRINT_NAME_FULL; } assert(nm_opts.sort_fn != NULL && "nm_opts.sort_fn is null"); assert(nm_opts.elem_print_fn != NULL && "nm_opts.elem_print_fn is null"); assert(nm_opts.value_print_fn != NULL && "nm_opts.value_print_fn is null"); set_opt_value_print_fn(nm_opts.t); if (nm_opts.undef_only == true) { if (nm_opts.sort_fn == &cmp_size) errx(EXIT_FAILURE, "--size-sort with -u is meaningless"); if (nm_opts.def_only != 0) errx(EXIT_FAILURE, "-u with --defined-only is meaningless"); } if (nm_opts.print_debug == false) filter_insert(sym_elem_nondebug); if (nm_opts.sort_reverse == true && nm_opts.sort_fn == cmp_none) nm_opts.sort_reverse = false; } /* * Get symbol information from elf. */ static int get_sym(Elf *elf, struct sym_head *headp, int shnum, size_t dynndx, size_t strndx, const char *type_table, const char **sec_table, int sec_table_size) { Elf_Scn *scn; Elf_Data *data; GElf_Shdr shdr; GElf_Sym sym; struct filter_entry *fep; size_t ndx; int rtn; const char *sym_name; char type; bool filter; int i, j; assert(elf != NULL); assert(headp != NULL); rtn = 0; for (i = 1; i < shnum; i++) { if ((scn = elf_getscn(elf, i)) == NULL) { warnx("elf_getscn failed: %s", elf_errmsg(-1)); continue; } if (gelf_getshdr(scn, &shdr) != &shdr) { warnx("gelf_getshdr failed: %s", elf_errmsg(-1)); continue; } if (shdr.sh_type == SHT_SYMTAB) { if (nm_opts.print_symbol != PRINT_SYM_SYM) continue; } else if (shdr.sh_type == SHT_DYNSYM) { if (nm_opts.print_symbol != PRINT_SYM_DYN) continue; } else continue; ndx = shdr.sh_type == SHT_DYNSYM ? dynndx : strndx; data = NULL; while ((data = elf_getdata(scn, data)) != NULL) { j = 1; while (gelf_getsym(data, j++, &sym) != NULL) { sym_name = get_sym_name(elf, &sym, ndx, sec_table, sec_table_size); filter = false; type = get_sym_type(&sym, type_table); SLIST_FOREACH(fep, &nm_out_filter, filter_entries) { if (!fep->fn(type, &sym, sym_name)) { filter = true; break; } } if (filter == false) { if (sym_list_insert(headp, sym_name, &sym) == 0) return (0); rtn++; } } } } return (rtn); } static const char * get_sym_name(Elf *elf, const GElf_Sym *sym, size_t ndx, const char **sec_table, int sec_table_size) { const char *sym_name; sym_name = NULL; /* Show section name as symbol name for STT_SECTION symbols. */ if (GELF_ST_TYPE(sym->st_info) == STT_SECTION) { if (sec_table != NULL && sym->st_shndx < sec_table_size) sym_name = sec_table[sym->st_shndx]; } else sym_name = elf_strptr(elf, ndx, sym->st_name); if (sym_name == NULL) sym_name = "(null)"; return (sym_name); } static char get_sym_type(const GElf_Sym *sym, const char *type_table) { bool is_local; if (sym == NULL || type_table == NULL) return ('?'); is_local = sym->st_info >> 4 == STB_LOCAL; if (sym->st_shndx == SHN_ABS) /* absolute */ return (is_local ? 'a' : 'A'); if (sym->st_shndx == SHN_COMMON) /* common */ return ('C'); if ((sym->st_info) >> 4 == STB_WEAK) { /* weak */ if ((sym->st_info & 0xf) == STT_OBJECT) return (sym->st_shndx == SHN_UNDEF ? 'v' : 'V'); return (sym->st_shndx == SHN_UNDEF ? 'w' : 'W'); } if (sym->st_shndx == SHN_UNDEF) /* undefined */ return ('U'); return (is_local == true && type_table[sym->st_shndx] != 'N' ? tolower((unsigned char) type_table[sym->st_shndx]) : type_table[sym->st_shndx]); } static void global_dest(void) { filter_dest(); } static void global_init(void) { if (elf_version(EV_CURRENT) == EV_NONE) errx(EXIT_FAILURE, "elf_version error"); nm_info.name = ELFTC_GETPROGNAME(); nm_info.def_filename = "a.out"; nm_opts.print_symbol = PRINT_SYM_SYM; nm_opts.print_name = PRINT_NAME_NONE; nm_opts.demangle_type = -1; nm_opts.print_debug = false; nm_opts.print_armap = false; nm_opts.print_size = 0; nm_opts.debug_line = false; nm_opts.def_only = 0; nm_opts.undef_only = false; nm_opts.sort_size = 0; nm_opts.sort_reverse = false; nm_opts.no_demangle = 0; nm_opts.sort_fn = &cmp_name; nm_opts.elem_print_fn = &sym_elem_print_all; nm_opts.value_print_fn = &sym_value_dec_print; nm_opts.size_print_fn = &sym_size_dec_print; SLIST_INIT(&nm_out_filter); } static bool is_sec_data(GElf_Shdr *s) { assert(s != NULL && "shdr is NULL"); return (((s->sh_flags & SHF_ALLOC) != 0) && s->sh_type != SHT_NOBITS); } static bool is_sec_debug(const char *shname) { const char *dbg_sec[] = { ".debug", ".gnu.linkonce.wi.", ".line", ".rel.debug", ".rela.debug", ".stab", NULL }; const char **p; - assert(shname != NULL && "shname is NULL"); + if (shname == NULL) + return (false); for (p = dbg_sec; *p; p++) { if (!strncmp(shname, *p, strlen(*p))) return (true); } return (false); } static bool is_sec_nobits(GElf_Shdr *s) { assert(s != NULL && "shdr is NULL"); return (s->sh_type == SHT_NOBITS); } static bool is_sec_readonly(GElf_Shdr *s) { assert(s != NULL && "shdr is NULL"); return ((s->sh_flags & SHF_WRITE) == 0); } static bool is_sec_text(GElf_Shdr *s) { assert(s != NULL && "shdr is NULL"); return ((s->sh_flags & SHF_EXECINSTR) != 0); } static void print_ar_index(int fd, Elf *arf) { Elf *elf; Elf_Arhdr *arhdr; Elf_Arsym *arsym; Elf_Cmd cmd; off_t start; size_t arsym_size; if (arf == NULL) return; if ((arsym = elf_getarsym(arf, &arsym_size)) == NULL) return; printf("\nArchive index:\n"); start = arsym->as_off; cmd = ELF_C_READ; while (arsym_size > 1) { if (elf_rand(arf, arsym->as_off) == arsym->as_off && (elf = elf_begin(fd, cmd, arf)) != NULL) { if ((arhdr = elf_getarhdr(elf)) != NULL) printf("%s in %s\n", arsym->as_name, arhdr->ar_name != NULL ? arhdr->ar_name : arhdr->ar_rawname); elf_end(elf); } ++arsym; --arsym_size; } elf_rand(arf, start); } #define DEMANGLED_BUFFER_SIZE (8 * 1024) #define PRINT_DEMANGLED_NAME(FORMAT, NAME) do { \ char _demangled[DEMANGLED_BUFFER_SIZE]; \ if (nm_opts.demangle_type < 0 || \ elftc_demangle((NAME), _demangled, sizeof(_demangled), \ nm_opts.demangle_type) < 0) \ printf((FORMAT), (NAME)); \ else \ printf((FORMAT), _demangled); \ } while (0) static void print_header(const char *file, const char *obj) { if (file == NULL) return; if (nm_opts.elem_print_fn == &sym_elem_print_all_sysv) { printf("\n\n%s from %s", nm_opts.undef_only == false ? "Symbols" : "Undefined symbols", file); if (obj != NULL) printf("[%s]", obj); printf(":\n\n"); printf("\ Name Value Class Type Size Line Section\n\n"); } else { /* archive file without -A option and POSIX */ if (nm_opts.print_name != PRINT_NAME_FULL && obj != NULL) { if (nm_opts.elem_print_fn == sym_elem_print_all_portable) printf("%s[%s]:\n", file, obj); else if (nm_opts.elem_print_fn == sym_elem_print_all) printf("\n%s:\n", obj); /* multiple files(not archive) without -A option */ } else if (nm_opts.print_name == PRINT_NAME_MULTI) { if (nm_opts.elem_print_fn == sym_elem_print_all) printf("\n"); printf("%s:\n", file); } } } static void print_version(void) { (void) printf("%s (%s)\n", nm_info.name, elftc_version()); exit(0); } static uint64_t get_block_value(Dwarf_Debug dbg, Dwarf_Block *block) { Elf *elf; GElf_Ehdr eh; Dwarf_Error de; if (dwarf_get_elf(dbg, &elf, &de) != DW_DLV_OK) { warnx("dwarf_get_elf failed: %s", dwarf_errmsg(de)); return (0); } if (gelf_getehdr(elf, &eh) != &eh) { warnx("gelf_getehdr failed: %s", elf_errmsg(-1)); return (0); } if (block->bl_len == 5) { if (eh.e_ident[EI_DATA] == ELFDATA2LSB) return (le32dec((uint8_t *) block->bl_data + 1)); else return (be32dec((uint8_t *) block->bl_data + 1)); } else if (block->bl_len == 9) { if (eh.e_ident[EI_DATA] == ELFDATA2LSB) return (le64dec((uint8_t *) block->bl_data + 1)); else return (be64dec((uint8_t *) block->bl_data + 1)); } return (0); } static char * find_object_name(Dwarf_Debug dbg, Dwarf_Die die) { Dwarf_Die ret_die; Dwarf_Attribute at; Dwarf_Off off; Dwarf_Error de; const char *str; char *name; if (dwarf_attrval_string(die, DW_AT_name, &str, &de) == DW_DLV_OK) { if ((name = strdup(str)) == NULL) { warn("strdup"); return (NULL); } return (name); } if (dwarf_attr(die, DW_AT_specification, &at, &de) != DW_DLV_OK) return (NULL); if (dwarf_global_formref(at, &off, &de) != DW_DLV_OK) return (NULL); if (dwarf_offdie(dbg, off, &ret_die, &de) != DW_DLV_OK) return (NULL); return (find_object_name(dbg, ret_die)); } static void search_line_attr(Dwarf_Debug dbg, struct func_info_head *func_info, struct var_info_head *var_info, Dwarf_Die die, char **src_files, Dwarf_Signed filecount) { Dwarf_Attribute at; Dwarf_Unsigned udata; Dwarf_Half tag; Dwarf_Block *block; Dwarf_Bool flag; Dwarf_Die ret_die; Dwarf_Error de; struct func_info_entry *func; struct var_info_entry *var; int ret; if (dwarf_tag(die, &tag, &de) != DW_DLV_OK) { warnx("dwarf_tag failed: %s", dwarf_errmsg(de)); goto cont_search; } /* We're interested in DIEs which define functions or variables. */ if (tag != DW_TAG_subprogram && tag != DW_TAG_entry_point && tag != DW_TAG_inlined_subroutine && tag != DW_TAG_variable) goto cont_search; if (tag == DW_TAG_variable) { /* Ignore "artificial" variable. */ if (dwarf_attrval_flag(die, DW_AT_artificial, &flag, &de) == DW_DLV_OK && flag) goto cont_search; /* Ignore pure declaration. */ if (dwarf_attrval_flag(die, DW_AT_declaration, &flag, &de) == DW_DLV_OK && flag) goto cont_search; /* Ignore stack varaibles. */ if (dwarf_attrval_flag(die, DW_AT_external, &flag, &de) != DW_DLV_OK || !flag) goto cont_search; if ((var = calloc(1, sizeof(*var))) == NULL) { warn("calloc failed"); goto cont_search; } if (dwarf_attrval_unsigned(die, DW_AT_decl_file, &udata, &de) == DW_DLV_OK && udata > 0 && (Dwarf_Signed) (udata - 1) < filecount) { var->file = strdup(src_files[udata - 1]); if (var->file == NULL) { warn("strdup"); free(var); goto cont_search; } } if (dwarf_attrval_unsigned(die, DW_AT_decl_line, &udata, &de) == DW_DLV_OK) var->line = udata; var->name = find_object_name(dbg, die); if (var->name == NULL) { if (var->file) free(var->file); free(var); goto cont_search; } if (dwarf_attr(die, DW_AT_location, &at, &de) == DW_DLV_OK && dwarf_formblock(at, &block, &de) == DW_DLV_OK) { /* * Since we ignored stack variables, the rest are the * external varaibles which should always use DW_OP_addr * operator for DW_AT_location value. */ if (*((uint8_t *)block->bl_data) == DW_OP_addr) var->addr = get_block_value(dbg, block); } SLIST_INSERT_HEAD(var_info, var, entries); } else { if ((func = calloc(1, sizeof(*func))) == NULL) { warn("calloc failed"); goto cont_search; } /* * Note that dwarf_attrval_unsigned() handles DW_AT_abstract_origin * internally, so it can retrieve DW_AT_decl_file/DW_AT_decl_line * attributes for inlined functions as well. */ if (dwarf_attrval_unsigned(die, DW_AT_decl_file, &udata, &de) == DW_DLV_OK && udata > 0 && (Dwarf_Signed) (udata - 1) < filecount) { func->file = strdup(src_files[udata - 1]); if (func->file == NULL) { warn("strdup"); free(func); goto cont_search; } } if (dwarf_attrval_unsigned(die, DW_AT_decl_line, &udata, &de) == DW_DLV_OK) func->line = udata; func->name = find_object_name(dbg, die); if (func->name == NULL) { if (func->file) free(func->file); free(func); goto cont_search; } if (dwarf_attrval_unsigned(die, DW_AT_low_pc, &udata, &de) == DW_DLV_OK) func->lowpc = udata; if (dwarf_attrval_unsigned(die, DW_AT_high_pc, &udata, &de) == DW_DLV_OK) func->highpc = udata; SLIST_INSERT_HEAD(func_info, func, entries); } cont_search: /* Search children. */ ret = dwarf_child(die, &ret_die, &de); if (ret == DW_DLV_ERROR) warnx("dwarf_child: %s", dwarf_errmsg(de)); else if (ret == DW_DLV_OK) search_line_attr(dbg, func_info, var_info, ret_die, src_files, filecount); /* Search sibling. */ ret = dwarf_siblingof(dbg, die, &ret_die, &de); if (ret == DW_DLV_ERROR) warnx("dwarf_siblingof: %s", dwarf_errmsg(de)); else if (ret == DW_DLV_OK) search_line_attr(dbg, func_info, var_info, ret_die, src_files, filecount); dwarf_dealloc(dbg, die, DW_DLA_DIE); } /* * Read elf file and collect symbol information, sort them, print. * Return 1 at failed, 0 at success. */ static int read_elf(Elf *elf, const char *filename, Elf_Kind kind) { Dwarf_Debug dbg; Dwarf_Die die; Dwarf_Error de; Dwarf_Half tag; Elf_Arhdr *arhdr; Elf_Scn *scn; GElf_Shdr shdr; GElf_Half i; Dwarf_Line *lbuf; Dwarf_Unsigned lineno; Dwarf_Signed lcount, filecount; Dwarf_Addr lineaddr; struct sym_print_data p_data; struct sym_head list_head; struct line_info_head *line_info; struct func_info_head *func_info; struct var_info_head *var_info; struct line_info_entry *lie; struct func_info_entry *func; struct var_info_entry *var; const char *shname, *objname; char *type_table, **sec_table, *sfile, **src_files; size_t shstrndx, shnum, dynndx, strndx; int ret, rtn, e_err; #define OBJNAME (objname == NULL ? filename : objname) assert(filename != NULL && "filename is null"); STAILQ_INIT(&list_head); type_table = NULL; sec_table = NULL; line_info = NULL; func_info = NULL; var_info = NULL; objname = NULL; dynndx = SHN_UNDEF; strndx = SHN_UNDEF; rtn = 0; nm_elfclass = gelf_getclass(elf); if (kind == ELF_K_AR) { if ((arhdr = elf_getarhdr(elf)) == NULL) goto next_cmd; objname = arhdr->ar_name != NULL ? arhdr->ar_name : arhdr->ar_rawname; } if (!elf_getshnum(elf, &shnum)) { if ((e_err = elf_errno()) != 0) warnx("%s: %s", OBJNAME, elf_errmsg(e_err)); else warnx("%s: cannot get section number", OBJNAME); rtn = 1; goto next_cmd; } if (shnum == 0) { warnx("%s: has no section", OBJNAME); rtn = 1; goto next_cmd; } if (!elf_getshstrndx(elf, &shstrndx)) { warnx("%s: cannot get str index", OBJNAME); rtn = 1; goto next_cmd; } /* type_table for type determine */ if ((type_table = malloc(sizeof(char) * shnum)) == NULL) { warn("%s: malloc", OBJNAME); rtn = 1; goto next_cmd; } /* sec_table for section name to display in sysv format */ if ((sec_table = calloc(shnum, sizeof(char *))) == NULL) { warn("%s: calloc", OBJNAME); rtn = 1; goto next_cmd; } type_table[0] = 'U'; if ((sec_table[0] = strdup("*UND*")) == NULL) { warn("strdup"); goto next_cmd; } for (i = 1; i < shnum; ++i) { type_table[i] = 'U'; if ((scn = elf_getscn(elf, i)) == NULL) { if ((e_err = elf_errno()) != 0) warnx("%s: %s", OBJNAME, elf_errmsg(e_err)); else warnx("%s: cannot get section", OBJNAME); rtn = 1; goto next_cmd; } if (gelf_getshdr(scn, &shdr) == NULL) goto next_cmd; /* * Cannot test by type and attribute for dynstr, strtab */ shname = elf_strptr(elf, shstrndx, (size_t) shdr.sh_name); if (shname != NULL) { if ((sec_table[i] = strdup(shname)) == NULL) { warn("strdup"); goto next_cmd; } if (!strncmp(shname, ".dynstr", 7)) { dynndx = elf_ndxscn(scn); if (dynndx == SHN_UNDEF) { warnx("%s: elf_ndxscn failed: %s", OBJNAME, elf_errmsg(-1)); goto next_cmd; } } if (!strncmp(shname, ".strtab", 7)) { strndx = elf_ndxscn(scn); if (strndx == SHN_UNDEF) { warnx("%s: elf_ndxscn failed: %s", OBJNAME, elf_errmsg(-1)); goto next_cmd; } } } else { sec_table[i] = strdup("*UND*"); if (sec_table[i] == NULL) { warn("strdup"); goto next_cmd; } } if (is_sec_text(&shdr)) type_table[i] = 'T'; else if (is_sec_data(&shdr)) { if (is_sec_readonly(&shdr)) type_table[i] = 'R'; else type_table[i] = 'D'; } else if (is_sec_nobits(&shdr)) type_table[i] = 'B'; else if (is_sec_debug(shname)) type_table[i] = 'N'; else if (is_sec_readonly(&shdr) && !is_sec_nobits(&shdr)) type_table[i] = 'n'; } print_header(filename, objname); if ((dynndx == SHN_UNDEF && nm_opts.print_symbol == PRINT_SYM_DYN) || (strndx == SHN_UNDEF && nm_opts.print_symbol == PRINT_SYM_SYM)) { warnx("%s: no symbols", OBJNAME); /* This is not an error case */ goto next_cmd; } STAILQ_INIT(&list_head); if (!nm_opts.debug_line) goto process_sym; /* * Collect dwarf line number information. */ if (dwarf_elf_init(elf, DW_DLC_READ, NULL, NULL, &dbg, &de) != DW_DLV_OK) { warnx("dwarf_elf_init failed: %s", dwarf_errmsg(de)); goto process_sym; } line_info = malloc(sizeof(struct line_info_head)); func_info = malloc(sizeof(struct func_info_head)); var_info = malloc(sizeof(struct var_info_head)); if (line_info == NULL || func_info == NULL || var_info == NULL) { warn("malloc"); (void) dwarf_finish(dbg, &de); goto process_sym; } SLIST_INIT(line_info); SLIST_INIT(func_info); SLIST_INIT(var_info); while ((ret = dwarf_next_cu_header(dbg, NULL, NULL, NULL, NULL, NULL, &de)) == DW_DLV_OK) { die = NULL; while (dwarf_siblingof(dbg, die, &die, &de) == DW_DLV_OK) { if (dwarf_tag(die, &tag, &de) != DW_DLV_OK) { warnx("dwarf_tag failed: %s", dwarf_errmsg(de)); continue; } /* XXX: What about DW_TAG_partial_unit? */ if (tag == DW_TAG_compile_unit) break; } if (die == NULL) { warnx("could not find DW_TAG_compile_unit die"); continue; } /* Retrieve source file list. */ ret = dwarf_srcfiles(die, &src_files, &filecount, &de); if (ret == DW_DLV_ERROR) warnx("dwarf_srclines: %s", dwarf_errmsg(de)); if (ret != DW_DLV_OK) continue; /* * Retrieve line number information from .debug_line section. */ ret = dwarf_srclines(die, &lbuf, &lcount, &de); if (ret == DW_DLV_ERROR) warnx("dwarf_srclines: %s", dwarf_errmsg(de)); if (ret != DW_DLV_OK) goto line_attr; for (i = 0; (Dwarf_Signed) i < lcount; i++) { if (dwarf_lineaddr(lbuf[i], &lineaddr, &de)) { warnx("dwarf_lineaddr: %s", dwarf_errmsg(de)); continue; } if (dwarf_lineno(lbuf[i], &lineno, &de)) { warnx("dwarf_lineno: %s", dwarf_errmsg(de)); continue; } if (dwarf_linesrc(lbuf[i], &sfile, &de)) { warnx("dwarf_linesrc: %s", dwarf_errmsg(de)); continue; } if ((lie = malloc(sizeof(*lie))) == NULL) { warn("malloc"); continue; } lie->addr = lineaddr; lie->line = lineno; lie->file = strdup(sfile); if (lie->file == NULL) { warn("strdup"); free(lie); continue; } SLIST_INSERT_HEAD(line_info, lie, entries); } line_attr: /* Retrieve line number information from DIEs. */ search_line_attr(dbg, func_info, var_info, die, src_files, filecount); } (void) dwarf_finish(dbg, &de); process_sym: p_data.list_num = get_sym(elf, &list_head, shnum, dynndx, strndx, type_table, (void *) sec_table, shnum); if (p_data.list_num == 0) goto next_cmd; p_data.headp = &list_head; p_data.sh_num = shnum; p_data.t_table = type_table; p_data.s_table = (void *) sec_table; p_data.filename = filename; p_data.objname = objname; sym_list_print(&p_data, func_info, var_info, line_info); next_cmd: if (nm_opts.debug_line) { if (func_info != NULL) { while (!SLIST_EMPTY(func_info)) { func = SLIST_FIRST(func_info); SLIST_REMOVE_HEAD(func_info, entries); free(func->file); free(func->name); free(func); } free(func_info); func_info = NULL; } if (var_info != NULL) { while (!SLIST_EMPTY(var_info)) { var = SLIST_FIRST(var_info); SLIST_REMOVE_HEAD(var_info, entries); free(var->file); free(var->name); free(var); } free(var_info); var_info = NULL; } if (line_info != NULL) { while (!SLIST_EMPTY(line_info)) { lie = SLIST_FIRST(line_info); SLIST_REMOVE_HEAD(line_info, entries); free(lie->file); free(lie); } free(line_info); line_info = NULL; } } if (sec_table != NULL) for (i = 0; i < shnum; ++i) free(sec_table[i]); free(sec_table); free(type_table); sym_list_dest(&list_head); return (rtn); #undef OBJNAME } static int read_object(const char *filename) { Elf *elf, *arf; Elf_Cmd elf_cmd; Elf_Kind kind; int fd, rtn, e_err; assert(filename != NULL && "filename is null"); if ((fd = open(filename, O_RDONLY)) == -1) { warn("'%s'", filename); return (1); } elf_cmd = ELF_C_READ; if ((arf = elf_begin(fd, elf_cmd, (Elf *) NULL)) == NULL) { if ((e_err = elf_errno()) != 0) warnx("elf_begin error: %s", elf_errmsg(e_err)); else warnx("elf_begin error"); close(fd); return (1); } assert(arf != NULL && "arf is null."); rtn = 0; if ((kind = elf_kind(arf)) == ELF_K_NONE) { warnx("%s: File format not recognized", filename); elf_end(arf); close(fd); return (1); } if (kind == ELF_K_AR) { if (nm_opts.print_name == PRINT_NAME_MULTI && nm_opts.elem_print_fn == sym_elem_print_all) printf("\n%s:\n", filename); if (nm_opts.print_armap == true) print_ar_index(fd, arf); } while ((elf = elf_begin(fd, elf_cmd, arf)) != NULL) { rtn |= read_elf(elf, filename, kind); /* * If file is not archive, elf_next return ELF_C_NULL and * stop the loop. */ elf_cmd = elf_next(elf); elf_end(elf); } elf_end(arf); close(fd); return (rtn); } static int read_files(int argc, char **argv) { int rtn = 0; if (argc < 0 || argv == NULL) return (1); if (argc == 0) rtn |= read_object(nm_info.def_filename); else { if (nm_opts.print_name == PRINT_NAME_NONE && argc > 1) nm_opts.print_name = PRINT_NAME_MULTI; while (argc > 0) { rtn |= read_object(*argv); --argc; ++argv; } } return (rtn); } static void print_lineno(struct sym_entry *ep, struct func_info_head *func_info, struct var_info_head *var_info, struct line_info_head *line_info) { struct func_info_entry *func; struct var_info_entry *var; struct line_info_entry *lie; /* For function symbol, search the function line information list. */ if ((ep->sym->st_info & 0xf) == STT_FUNC && func_info != NULL) { SLIST_FOREACH(func, func_info, entries) { if (func->name != NULL && !strcmp(ep->name, func->name) && ep->sym->st_value >= func->lowpc && ep->sym->st_value < func->highpc) { printf("\t%s:%" PRIu64, func->file, func->line); return; } } } /* For variable symbol, search the variable line information list. */ if ((ep->sym->st_info & 0xf) == STT_OBJECT && var_info != NULL) { SLIST_FOREACH(var, var_info, entries) { if (!strcmp(ep->name, var->name) && ep->sym->st_value == var->addr) { printf("\t%s:%" PRIu64, var->file, var->line); return; } } } /* Otherwise search line number information the .debug_line section. */ if (line_info != NULL) { SLIST_FOREACH(lie, line_info, entries) { if (ep->sym->st_value == lie->addr) { printf("\t%s:%" PRIu64, lie->file, lie->line); return; } } } } static void set_opt_value_print_fn(enum radix t) { switch (t) { case RADIX_OCT: nm_opts.value_print_fn = &sym_value_oct_print; nm_opts.size_print_fn = &sym_size_oct_print; break; case RADIX_DEC: nm_opts.value_print_fn = &sym_value_dec_print; nm_opts.size_print_fn = &sym_size_dec_print; break; case RADIX_HEX: default : nm_opts.value_print_fn = &sym_value_hex_print; nm_opts.size_print_fn = &sym_size_hex_print; } assert(nm_opts.value_print_fn != NULL && "nm_opts.value_print_fn is null"); } static void sym_elem_print_all(char type, const char *sec, const GElf_Sym *sym, const char *name) { if (sec == NULL || sym == NULL || name == NULL || nm_opts.value_print_fn == NULL) return; if (IS_UNDEF_SYM_TYPE(type)) { if (nm_opts.t == RADIX_HEX && nm_elfclass == ELFCLASS32) printf("%-8s", ""); else printf("%-16s", ""); } else { switch ((nm_opts.sort_fn == & cmp_size ? 2 : 0) + nm_opts.print_size) { case 3: if (sym->st_size != 0) { nm_opts.value_print_fn(sym); printf(" "); nm_opts.size_print_fn(sym); } break; case 2: if (sym->st_size != 0) nm_opts.size_print_fn(sym); break; case 1: nm_opts.value_print_fn(sym); if (sym->st_size != 0) { printf(" "); nm_opts.size_print_fn(sym); } break; case 0: default: nm_opts.value_print_fn(sym); } } printf(" %c ", type); PRINT_DEMANGLED_NAME("%s", name); } static void sym_elem_print_all_portable(char type, const char *sec, const GElf_Sym *sym, const char *name) { if (sec == NULL || sym == NULL || name == NULL || nm_opts.value_print_fn == NULL) return; PRINT_DEMANGLED_NAME("%s", name); printf(" %c ", type); if (!IS_UNDEF_SYM_TYPE(type)) { nm_opts.value_print_fn(sym); printf(" "); if (sym->st_size != 0) nm_opts.size_print_fn(sym); } else printf(" "); } static void sym_elem_print_all_sysv(char type, const char *sec, const GElf_Sym *sym, const char *name) { if (sec == NULL || sym == NULL || name == NULL || nm_opts.value_print_fn == NULL) return; PRINT_DEMANGLED_NAME("%-20s|", name); if (IS_UNDEF_SYM_TYPE(type)) printf(" "); else nm_opts.value_print_fn(sym); printf("| %c |", type); switch (sym->st_info & 0xf) { case STT_OBJECT: printf("%18s|", "OBJECT"); break; case STT_FUNC: printf("%18s|", "FUNC"); break; case STT_SECTION: printf("%18s|", "SECTION"); break; case STT_FILE: printf("%18s|", "FILE"); break; case STT_LOPROC: printf("%18s|", "LOPROC"); break; case STT_HIPROC: printf("%18s|", "HIPROC"); break; case STT_NOTYPE: default: printf("%18s|", "NOTYPE"); - }; + } if (sym->st_size != 0) nm_opts.size_print_fn(sym); else printf(" "); printf("| |%s", sec); } static int sym_elem_def(char type, const GElf_Sym *sym, const char *name) { assert(IS_SYM_TYPE((unsigned char) type)); UNUSED(sym); UNUSED(name); return (!IS_UNDEF_SYM_TYPE((unsigned char) type)); } static int sym_elem_global(char type, const GElf_Sym *sym, const char *name) { assert(IS_SYM_TYPE((unsigned char) type)); UNUSED(sym); UNUSED(name); /* weak symbols resemble global. */ return (isupper((unsigned char) type) || type == 'w'); } static int sym_elem_global_static(char type, const GElf_Sym *sym, const char *name) { unsigned char info; assert(sym != NULL); UNUSED(type); UNUSED(name); info = sym->st_info >> 4; return (info == STB_LOCAL || info == STB_GLOBAL || info == STB_WEAK); } static int sym_elem_nondebug(char type, const GElf_Sym *sym, const char *name) { assert(sym != NULL); UNUSED(type); UNUSED(name); if (sym->st_value == 0 && (sym->st_info & 0xf) == STT_FILE) return (0); if (sym->st_name == 0) return (0); return (1); } static int sym_elem_nonzero_size(char type, const GElf_Sym *sym, const char *name) { assert(sym != NULL); UNUSED(type); UNUSED(name); return (sym->st_size > 0); } static int sym_elem_undef(char type, const GElf_Sym *sym, const char *name) { assert(IS_SYM_TYPE((unsigned char) type)); UNUSED(sym); UNUSED(name); return (IS_UNDEF_SYM_TYPE((unsigned char) type)); } static void sym_list_dest(struct sym_head *headp) { struct sym_entry *ep, *ep_n; if (headp == NULL) return; ep = STAILQ_FIRST(headp); while (ep != NULL) { ep_n = STAILQ_NEXT(ep, sym_entries); free(ep->sym); free(ep->name); free(ep); ep = ep_n; } } static int sym_list_insert(struct sym_head *headp, const char *name, const GElf_Sym *sym) { struct sym_entry *e; if (headp == NULL || name == NULL || sym == NULL) return (0); if ((e = malloc(sizeof(struct sym_entry))) == NULL) { warn("malloc"); return (0); } if ((e->name = strdup(name)) == NULL) { warn("strdup"); free(e); return (0); } if ((e->sym = malloc(sizeof(GElf_Sym))) == NULL) { warn("malloc"); free(e->name); free(e); return (0); } memcpy(e->sym, sym, sizeof(GElf_Sym)); /* Display size instead of value for common symbol. */ if (sym->st_shndx == SHN_COMMON) e->sym->st_value = sym->st_size; STAILQ_INSERT_TAIL(headp, e, sym_entries); return (1); } /* If file has not .debug_info, line_info will be NULL */ static void sym_list_print(struct sym_print_data *p, struct func_info_head *func_info, struct var_info_head *var_info, struct line_info_head *line_info) { struct sym_entry *e_v; size_t si; int i; if (p == NULL || CHECK_SYM_PRINT_DATA(p)) return; if ((e_v = sym_list_sort(p)) == NULL) return; if (nm_opts.sort_reverse == false) for (si = 0; si != p->list_num; ++si) sym_list_print_each(&e_v[si], p, func_info, var_info, line_info); else for (i = p->list_num - 1; i != -1; --i) sym_list_print_each(&e_v[i], p, func_info, var_info, line_info); free(e_v); } /* If file has not .debug_info, line_info will be NULL */ static void sym_list_print_each(struct sym_entry *ep, struct sym_print_data *p, struct func_info_head *func_info, struct var_info_head *var_info, struct line_info_head *line_info) { const char *sec; char type; if (ep == NULL || CHECK_SYM_PRINT_DATA(p)) return; assert(ep->name != NULL); assert(ep->sym != NULL); type = get_sym_type(ep->sym, p->t_table); if (nm_opts.print_name == PRINT_NAME_FULL) { printf("%s", p->filename); if (nm_opts.elem_print_fn == &sym_elem_print_all_portable) { if (p->objname != NULL) printf("[%s]", p->objname); printf(": "); } else { if (p->objname != NULL) printf(":%s", p->objname); printf(":"); } } switch (ep->sym->st_shndx) { case SHN_LOPROC: /* LOPROC or LORESERVE */ sec = "*LOPROC*"; break; case SHN_HIPROC: sec = "*HIPROC*"; break; case SHN_LOOS: sec = "*LOOS*"; break; case SHN_HIOS: sec = "*HIOS*"; break; case SHN_ABS: sec = "*ABS*"; break; case SHN_COMMON: sec = "*COM*"; break; case SHN_HIRESERVE: /* HIRESERVE or XINDEX */ sec = "*HIRESERVE*"; break; default: if (ep->sym->st_shndx > p->sh_num) return; sec = p->s_table[ep->sym->st_shndx]; break; - }; + } nm_opts.elem_print_fn(type, sec, ep->sym, ep->name); if (nm_opts.debug_line == true && !IS_UNDEF_SYM_TYPE(type)) print_lineno(ep, func_info, var_info, line_info); printf("\n"); } static struct sym_entry * sym_list_sort(struct sym_print_data *p) { struct sym_entry *ep, *e_v; int idx; if (p == NULL || CHECK_SYM_PRINT_DATA(p)) return (NULL); if ((e_v = malloc(sizeof(struct sym_entry) * p->list_num)) == NULL) { warn("malloc"); return (NULL); } idx = 0; STAILQ_FOREACH(ep, p->headp, sym_entries) { if (ep->name != NULL && ep->sym != NULL) { e_v[idx].name = ep->name; e_v[idx].sym = ep->sym; ++idx; } } assert((size_t)idx == p->list_num); if (nm_opts.sort_fn != &cmp_none) { nm_print_data = p; assert(nm_print_data != NULL); qsort(e_v, p->list_num, sizeof(struct sym_entry), nm_opts.sort_fn); } return (e_v); } static void sym_size_oct_print(const GElf_Sym *sym) { assert(sym != NULL && "sym is null"); printf("%016" PRIo64, sym->st_size); } static void sym_size_hex_print(const GElf_Sym *sym) { assert(sym != NULL && "sym is null"); if (nm_elfclass == ELFCLASS32) printf("%08" PRIx64, sym->st_size); else printf("%016" PRIx64, sym->st_size); } static void sym_size_dec_print(const GElf_Sym *sym) { assert(sym != NULL && "sym is null"); printf("%016" PRId64, sym->st_size); } static void sym_value_oct_print(const GElf_Sym *sym) { assert(sym != NULL && "sym is null"); printf("%016" PRIo64, sym->st_value); } static void sym_value_hex_print(const GElf_Sym *sym) { assert(sym != NULL && "sym is null"); if (nm_elfclass == ELFCLASS32) printf("%08" PRIx64, sym->st_value); else printf("%016" PRIx64, sym->st_value); } static void sym_value_dec_print(const GElf_Sym *sym) { assert(sym != NULL && "sym is null"); printf("%016" PRId64, sym->st_value); } static void usage(int exitcode) { printf("Usage: %s [options] file ...\ \n Display symbolic information in file.\n\ \n Options: \ \n -A, --print-file-name Write the full pathname or library name of an\ \n object on each line.\ \n -a, --debug-syms Display all symbols include debugger-only\ \n symbols.", nm_info.name); printf("\ \n -B Equivalent to specifying \"--format=bsd\".\ \n -C, --demangle[=style] Decode low-level symbol names.\ \n --no-demangle Do not demangle low-level symbol names.\ \n -D, --dynamic Display only dynamic symbols.\ \n -e Display only global and static symbols."); printf("\ \n -f Produce full output (default).\ \n --format=format Display output in specific format. Allowed\ \n formats are: \"bsd\", \"posix\" and \"sysv\".\ \n -g, --extern-only Display only global symbol information.\ \n -h, --help Show this help message.\ \n -l, --line-numbers Display filename and linenumber using\ \n debugging information.\ \n -n, --numeric-sort Sort symbols numerically by value."); printf("\ \n -o Write numeric values in octal. Equivalent to\ \n specifying \"-t o\".\ \n -p, --no-sort Do not sort symbols.\ \n -P Write information in a portable output format.\ \n Equivalent to specifying \"--format=posix\".\ \n -r, --reverse-sort Reverse the order of the sort.\ \n -S, --print-size Print symbol sizes instead values.\ \n -s, --print-armap Include an index of archive members.\ \n --size-sort Sort symbols by size."); printf("\ \n -t, --radix=format Write each numeric value in the specified\ \n format:\ \n d In decimal,\ \n o In octal,\ \n x In hexadecimal."); printf("\ \n -u, --undefined-only Display only undefined symbols.\ \n --defined-only Display only defined symbols.\ \n -V, --version Show the version identifier for %s.\ \n -v Sort output by value.\ \n -x Write numeric values in hexadecimal.\ \n Equivalent to specifying \"-t x\".", nm_info.name); printf("\n\ \n The default options are: output in bsd format, use a hexadecimal radix,\ \n sort by symbol name, do not demangle names.\n"); exit(exitcode); } /* * Display symbolic information in file. * Return 0 at success, >0 at failed. */ int main(int argc, char **argv) { int rtn; global_init(); get_opt(argc, argv); rtn = read_files(argc - optind, argv + optind); global_dest(); exit(rtn); } Index: vendor/elftoolchain/dist/readelf/readelf.c =================================================================== --- vendor/elftoolchain/dist/readelf/readelf.c (revision 300227) +++ vendor/elftoolchain/dist/readelf/readelf.c (revision 300228) @@ -1,7733 +1,7206 @@ /*- * Copyright (c) 2009-2015 Kai Wang * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "_elftc.h" -ELFTC_VCSID("$Id: readelf.c 3395 2016-02-10 16:29:44Z emaste $"); +ELFTC_VCSID("$Id: readelf.c 3469 2016-05-15 23:16:09Z emaste $"); /* * readelf(1) options. */ #define RE_AA 0x00000001 #define RE_C 0x00000002 #define RE_DD 0x00000004 #define RE_D 0x00000008 #define RE_G 0x00000010 #define RE_H 0x00000020 #define RE_II 0x00000040 #define RE_I 0x00000080 #define RE_L 0x00000100 #define RE_NN 0x00000200 #define RE_N 0x00000400 #define RE_P 0x00000800 #define RE_R 0x00001000 #define RE_SS 0x00002000 #define RE_S 0x00004000 #define RE_T 0x00008000 #define RE_U 0x00010000 #define RE_VV 0x00020000 #define RE_WW 0x00040000 #define RE_W 0x00080000 #define RE_X 0x00100000 /* * dwarf dump options. */ #define DW_A 0x00000001 #define DW_FF 0x00000002 #define DW_F 0x00000004 #define DW_I 0x00000008 #define DW_LL 0x00000010 #define DW_L 0x00000020 #define DW_M 0x00000040 #define DW_O 0x00000080 #define DW_P 0x00000100 #define DW_RR 0x00000200 #define DW_R 0x00000400 #define DW_S 0x00000800 #define DW_DEFAULT_OPTIONS (DW_A | DW_F | DW_I | DW_L | DW_O | DW_P | \ DW_R | DW_RR | DW_S) /* * readelf(1) run control flags. */ #define DISPLAY_FILENAME 0x0001 /* * Internal data structure for sections. */ struct section { const char *name; /* section name */ Elf_Scn *scn; /* section scn */ uint64_t off; /* section offset */ uint64_t sz; /* section size */ uint64_t entsize; /* section entsize */ uint64_t align; /* section alignment */ uint64_t type; /* section type */ uint64_t flags; /* section flags */ uint64_t addr; /* section virtual addr */ uint32_t link; /* section link ndx */ uint32_t info; /* section info ndx */ }; struct dumpop { union { size_t si; /* section index */ const char *sn; /* section name */ } u; enum { DUMP_BY_INDEX = 0, DUMP_BY_NAME } type; /* dump type */ #define HEX_DUMP 0x0001 #define STR_DUMP 0x0002 int op; /* dump operation */ STAILQ_ENTRY(dumpop) dumpop_list; }; struct symver { const char *name; int type; }; /* * Structure encapsulates the global data for readelf(1). */ struct readelf { const char *filename; /* current processing file. */ int options; /* command line options. */ int flags; /* run control flags. */ int dop; /* dwarf dump options. */ Elf *elf; /* underlying ELF descriptor. */ Elf *ar; /* archive ELF descriptor. */ Dwarf_Debug dbg; /* DWARF handle. */ Dwarf_Half cu_psize; /* DWARF CU pointer size. */ Dwarf_Half cu_osize; /* DWARF CU offset size. */ Dwarf_Half cu_ver; /* DWARF CU version. */ GElf_Ehdr ehdr; /* ELF header. */ int ec; /* ELF class. */ size_t shnum; /* #sections. */ struct section *vd_s; /* Verdef section. */ struct section *vn_s; /* Verneed section. */ struct section *vs_s; /* Versym section. */ uint16_t *vs; /* Versym array. */ int vs_sz; /* Versym array size. */ struct symver *ver; /* Version array. */ int ver_sz; /* Size of version array. */ struct section *sl; /* list of sections. */ STAILQ_HEAD(, dumpop) v_dumpop; /* list of dump ops. */ uint64_t (*dw_read)(Elf_Data *, uint64_t *, int); uint64_t (*dw_decode)(uint8_t **, int); }; enum options { OPTION_DEBUG_DUMP }; static struct option longopts[] = { {"all", no_argument, NULL, 'a'}, {"arch-specific", no_argument, NULL, 'A'}, {"archive-index", no_argument, NULL, 'c'}, {"debug-dump", optional_argument, NULL, OPTION_DEBUG_DUMP}, {"dynamic", no_argument, NULL, 'd'}, {"file-header", no_argument, NULL, 'h'}, {"full-section-name", no_argument, NULL, 'N'}, {"headers", no_argument, NULL, 'e'}, {"help", no_argument, 0, 'H'}, {"hex-dump", required_argument, NULL, 'x'}, {"histogram", no_argument, NULL, 'I'}, {"notes", no_argument, NULL, 'n'}, {"program-headers", no_argument, NULL, 'l'}, {"relocs", no_argument, NULL, 'r'}, {"sections", no_argument, NULL, 'S'}, {"section-headers", no_argument, NULL, 'S'}, {"section-groups", no_argument, NULL, 'g'}, {"section-details", no_argument, NULL, 't'}, {"segments", no_argument, NULL, 'l'}, {"string-dump", required_argument, NULL, 'p'}, {"symbols", no_argument, NULL, 's'}, {"syms", no_argument, NULL, 's'}, {"unwind", no_argument, NULL, 'u'}, {"use-dynamic", no_argument, NULL, 'D'}, {"version-info", no_argument, 0, 'V'}, {"version", no_argument, 0, 'v'}, {"wide", no_argument, 0, 'W'}, {NULL, 0, NULL, 0} }; struct eflags_desc { uint64_t flag; const char *desc; }; struct mips_option { uint64_t flag; const char *desc; }; static void add_dumpop(struct readelf *re, size_t si, const char *sn, int op, int t); static const char *aeabi_adv_simd_arch(uint64_t simd); static const char *aeabi_align_needed(uint64_t an); static const char *aeabi_align_preserved(uint64_t ap); static const char *aeabi_arm_isa(uint64_t ai); static const char *aeabi_cpu_arch(uint64_t arch); static const char *aeabi_cpu_arch_profile(uint64_t pf); static const char *aeabi_div(uint64_t du); static const char *aeabi_enum_size(uint64_t es); static const char *aeabi_fp_16bit_format(uint64_t fp16); static const char *aeabi_fp_arch(uint64_t fp); static const char *aeabi_fp_denormal(uint64_t fd); static const char *aeabi_fp_exceptions(uint64_t fe); static const char *aeabi_fp_hpext(uint64_t fh); static const char *aeabi_fp_number_model(uint64_t fn); static const char *aeabi_fp_optm_goal(uint64_t fog); static const char *aeabi_fp_rounding(uint64_t fr); static const char *aeabi_hardfp(uint64_t hfp); static const char *aeabi_mpext(uint64_t mp); static const char *aeabi_optm_goal(uint64_t og); static const char *aeabi_pcs_config(uint64_t pcs); static const char *aeabi_pcs_got(uint64_t got); static const char *aeabi_pcs_r9(uint64_t r9); static const char *aeabi_pcs_ro(uint64_t ro); static const char *aeabi_pcs_rw(uint64_t rw); static const char *aeabi_pcs_wchar_t(uint64_t wt); static const char *aeabi_t2ee(uint64_t t2ee); static const char *aeabi_thumb_isa(uint64_t ti); static const char *aeabi_fp_user_exceptions(uint64_t fu); static const char *aeabi_unaligned_access(uint64_t ua); static const char *aeabi_vfp_args(uint64_t va); static const char *aeabi_virtual(uint64_t vt); static const char *aeabi_wmmx_arch(uint64_t wmmx); static const char *aeabi_wmmx_args(uint64_t wa); static const char *elf_class(unsigned int class); static const char *elf_endian(unsigned int endian); static const char *elf_machine(unsigned int mach); static const char *elf_osabi(unsigned int abi); static const char *elf_type(unsigned int type); static const char *elf_ver(unsigned int ver); static const char *dt_type(unsigned int mach, unsigned int dtype); static void dump_ar(struct readelf *re, int); static void dump_arm_attributes(struct readelf *re, uint8_t *p, uint8_t *pe); static void dump_attributes(struct readelf *re); static uint8_t *dump_compatibility_tag(uint8_t *p, uint8_t *pe); static void dump_dwarf(struct readelf *re); static void dump_dwarf_abbrev(struct readelf *re); static void dump_dwarf_aranges(struct readelf *re); static void dump_dwarf_block(struct readelf *re, uint8_t *b, Dwarf_Unsigned len); static void dump_dwarf_die(struct readelf *re, Dwarf_Die die, int level); static void dump_dwarf_frame(struct readelf *re, int alt); static void dump_dwarf_frame_inst(struct readelf *re, Dwarf_Cie cie, uint8_t *insts, Dwarf_Unsigned len, Dwarf_Unsigned caf, Dwarf_Signed daf, Dwarf_Addr pc, Dwarf_Debug dbg); static int dump_dwarf_frame_regtable(struct readelf *re, Dwarf_Fde fde, Dwarf_Addr pc, Dwarf_Unsigned func_len, Dwarf_Half cie_ra); static void dump_dwarf_frame_section(struct readelf *re, struct section *s, int alt); static void dump_dwarf_info(struct readelf *re, Dwarf_Bool is_info); static void dump_dwarf_macinfo(struct readelf *re); static void dump_dwarf_line(struct readelf *re); static void dump_dwarf_line_decoded(struct readelf *re); static void dump_dwarf_loc(struct readelf *re, Dwarf_Loc *lr); static void dump_dwarf_loclist(struct readelf *re); static void dump_dwarf_pubnames(struct readelf *re); static void dump_dwarf_ranges(struct readelf *re); static void dump_dwarf_ranges_foreach(struct readelf *re, Dwarf_Die die, Dwarf_Addr base); static void dump_dwarf_str(struct readelf *re); static void dump_eflags(struct readelf *re, uint64_t e_flags); static void dump_elf(struct readelf *re); static void dump_dyn_val(struct readelf *re, GElf_Dyn *dyn, uint32_t stab); static void dump_dynamic(struct readelf *re); static void dump_liblist(struct readelf *re); static void dump_mips_attributes(struct readelf *re, uint8_t *p, uint8_t *pe); static void dump_mips_odk_reginfo(struct readelf *re, uint8_t *p, size_t sz); static void dump_mips_options(struct readelf *re, struct section *s); static void dump_mips_option_flags(const char *name, struct mips_option *opt, uint64_t info); static void dump_mips_reginfo(struct readelf *re, struct section *s); static void dump_mips_specific_info(struct readelf *re); static void dump_notes(struct readelf *re); static void dump_notes_content(struct readelf *re, const char *buf, size_t sz, off_t off); static void dump_svr4_hash(struct section *s); static void dump_svr4_hash64(struct readelf *re, struct section *s); static void dump_gnu_hash(struct readelf *re, struct section *s); static void dump_hash(struct readelf *re); static void dump_phdr(struct readelf *re); static void dump_ppc_attributes(uint8_t *p, uint8_t *pe); static void dump_section_groups(struct readelf *re); static void dump_symtab(struct readelf *re, int i); static void dump_symtabs(struct readelf *re); static uint8_t *dump_unknown_tag(uint64_t tag, uint8_t *p, uint8_t *pe); static void dump_ver(struct readelf *re); static void dump_verdef(struct readelf *re, int dump); static void dump_verneed(struct readelf *re, int dump); static void dump_versym(struct readelf *re); static const char *dwarf_reg(unsigned int mach, unsigned int reg); static const char *dwarf_regname(struct readelf *re, unsigned int num); static struct dumpop *find_dumpop(struct readelf *re, size_t si, const char *sn, int op, int t); static int get_ent_count(struct section *s, int *ent_count); static char *get_regoff_str(struct readelf *re, Dwarf_Half reg, Dwarf_Addr off); static const char *get_string(struct readelf *re, int strtab, size_t off); static const char *get_symbol_name(struct readelf *re, int symtab, int i); static uint64_t get_symbol_value(struct readelf *re, int symtab, int i); static void load_sections(struct readelf *re); static const char *mips_abi_fp(uint64_t fp); static const char *note_type(const char *note_name, unsigned int et, unsigned int nt); static const char *note_type_freebsd(unsigned int nt); static const char *note_type_freebsd_core(unsigned int nt); static const char *note_type_linux_core(unsigned int nt); static const char *note_type_gnu(unsigned int nt); static const char *note_type_netbsd(unsigned int nt); static const char *note_type_openbsd(unsigned int nt); static const char *note_type_unknown(unsigned int nt); static const char *note_type_xen(unsigned int nt); static const char *option_kind(uint8_t kind); static const char *phdr_type(unsigned int ptype); static const char *ppc_abi_fp(uint64_t fp); static const char *ppc_abi_vector(uint64_t vec); -static const char *r_type(unsigned int mach, unsigned int type); static void readelf_usage(int status); static void readelf_version(void); static void search_loclist_at(struct readelf *re, Dwarf_Die die, Dwarf_Unsigned lowpc); static void search_ver(struct readelf *re); static const char *section_type(unsigned int mach, unsigned int stype); static void set_cu_context(struct readelf *re, Dwarf_Half psize, Dwarf_Half osize, Dwarf_Half ver); static const char *st_bind(unsigned int sbind); static const char *st_shndx(unsigned int shndx); -static const char *st_type(unsigned int mach, unsigned int stype); +static const char *st_type(unsigned int mach, unsigned int os, + unsigned int stype); static const char *st_vis(unsigned int svis); static const char *top_tag(unsigned int tag); static void unload_sections(struct readelf *re); static uint64_t _read_lsb(Elf_Data *d, uint64_t *offsetp, int bytes_to_read); static uint64_t _read_msb(Elf_Data *d, uint64_t *offsetp, int bytes_to_read); static uint64_t _decode_lsb(uint8_t **data, int bytes_to_read); static uint64_t _decode_msb(uint8_t **data, int bytes_to_read); static int64_t _decode_sleb128(uint8_t **dp, uint8_t *dpe); static uint64_t _decode_uleb128(uint8_t **dp, uint8_t *dpe); static struct eflags_desc arm_eflags_desc[] = { {EF_ARM_RELEXEC, "relocatable executable"}, {EF_ARM_HASENTRY, "has entry point"}, {EF_ARM_SYMSARESORTED, "sorted symbol tables"}, {EF_ARM_DYNSYMSUSESEGIDX, "dynamic symbols use segment index"}, {EF_ARM_MAPSYMSFIRST, "mapping symbols precede others"}, {EF_ARM_BE8, "BE8"}, {EF_ARM_LE8, "LE8"}, {EF_ARM_INTERWORK, "interworking enabled"}, {EF_ARM_APCS_26, "uses APCS/26"}, {EF_ARM_APCS_FLOAT, "uses APCS/float"}, {EF_ARM_PIC, "position independent"}, {EF_ARM_ALIGN8, "8 bit structure alignment"}, {EF_ARM_NEW_ABI, "uses new ABI"}, {EF_ARM_OLD_ABI, "uses old ABI"}, {EF_ARM_SOFT_FLOAT, "software FP"}, {EF_ARM_VFP_FLOAT, "VFP"}, {EF_ARM_MAVERICK_FLOAT, "Maverick FP"}, {0, NULL} }; static struct eflags_desc mips_eflags_desc[] = { {EF_MIPS_NOREORDER, "noreorder"}, {EF_MIPS_PIC, "pic"}, {EF_MIPS_CPIC, "cpic"}, {EF_MIPS_UCODE, "ugen_reserved"}, {EF_MIPS_ABI2, "abi2"}, {EF_MIPS_OPTIONS_FIRST, "odk first"}, {EF_MIPS_ARCH_ASE_MDMX, "mdmx"}, {EF_MIPS_ARCH_ASE_M16, "mips16"}, {0, NULL} }; static struct eflags_desc powerpc_eflags_desc[] = { {EF_PPC_EMB, "emb"}, {EF_PPC_RELOCATABLE, "relocatable"}, {EF_PPC_RELOCATABLE_LIB, "relocatable-lib"}, {0, NULL} }; static struct eflags_desc sparc_eflags_desc[] = { {EF_SPARC_32PLUS, "v8+"}, {EF_SPARC_SUN_US1, "ultrasparcI"}, {EF_SPARC_HAL_R1, "halr1"}, {EF_SPARC_SUN_US3, "ultrasparcIII"}, {0, NULL} }; static const char * elf_osabi(unsigned int abi) { static char s_abi[32]; switch(abi) { case ELFOSABI_NONE: return "NONE"; case ELFOSABI_HPUX: return "HPUX"; case ELFOSABI_NETBSD: return "NetBSD"; case ELFOSABI_GNU: return "GNU"; case ELFOSABI_HURD: return "HURD"; case ELFOSABI_86OPEN: return "86OPEN"; case ELFOSABI_SOLARIS: return "Solaris"; case ELFOSABI_AIX: return "AIX"; case ELFOSABI_IRIX: return "IRIX"; case ELFOSABI_FREEBSD: return "FreeBSD"; case ELFOSABI_TRU64: return "TRU64"; case ELFOSABI_MODESTO: return "MODESTO"; case ELFOSABI_OPENBSD: return "OpenBSD"; case ELFOSABI_OPENVMS: return "OpenVMS"; case ELFOSABI_NSK: return "NSK"; + case ELFOSABI_CLOUDABI: return "CloudABI"; case ELFOSABI_ARM: return "ARM"; case ELFOSABI_STANDALONE: return "StandAlone"; default: snprintf(s_abi, sizeof(s_abi), "", abi); return (s_abi); } }; static const char * elf_machine(unsigned int mach) { static char s_mach[32]; switch (mach) { case EM_NONE: return "Unknown machine"; case EM_M32: return "AT&T WE32100"; case EM_SPARC: return "Sun SPARC"; case EM_386: return "Intel i386"; case EM_68K: return "Motorola 68000"; case EM_IAMCU: return "Intel MCU"; case EM_88K: return "Motorola 88000"; case EM_860: return "Intel i860"; case EM_MIPS: return "MIPS R3000 Big-Endian only"; case EM_S370: return "IBM System/370"; case EM_MIPS_RS3_LE: return "MIPS R3000 Little-Endian"; case EM_PARISC: return "HP PA-RISC"; case EM_VPP500: return "Fujitsu VPP500"; case EM_SPARC32PLUS: return "SPARC v8plus"; case EM_960: return "Intel 80960"; case EM_PPC: return "PowerPC 32-bit"; case EM_PPC64: return "PowerPC 64-bit"; case EM_S390: return "IBM System/390"; case EM_V800: return "NEC V800"; case EM_FR20: return "Fujitsu FR20"; case EM_RH32: return "TRW RH-32"; case EM_RCE: return "Motorola RCE"; case EM_ARM: return "ARM"; case EM_SH: return "Hitachi SH"; case EM_SPARCV9: return "SPARC v9 64-bit"; case EM_TRICORE: return "Siemens TriCore embedded processor"; case EM_ARC: return "Argonaut RISC Core"; case EM_H8_300: return "Hitachi H8/300"; case EM_H8_300H: return "Hitachi H8/300H"; case EM_H8S: return "Hitachi H8S"; case EM_H8_500: return "Hitachi H8/500"; case EM_IA_64: return "Intel IA-64 Processor"; case EM_MIPS_X: return "Stanford MIPS-X"; case EM_COLDFIRE: return "Motorola ColdFire"; case EM_68HC12: return "Motorola M68HC12"; case EM_MMA: return "Fujitsu MMA"; case EM_PCP: return "Siemens PCP"; case EM_NCPU: return "Sony nCPU"; case EM_NDR1: return "Denso NDR1 microprocessor"; case EM_STARCORE: return "Motorola Star*Core processor"; case EM_ME16: return "Toyota ME16 processor"; case EM_ST100: return "STMicroelectronics ST100 processor"; case EM_TINYJ: return "Advanced Logic Corp. TinyJ processor"; case EM_X86_64: return "Advanced Micro Devices x86-64"; case EM_PDSP: return "Sony DSP Processor"; case EM_FX66: return "Siemens FX66 microcontroller"; case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 microcontroller"; case EM_ST7: return "STmicroelectronics ST7 8-bit microcontroller"; case EM_68HC16: return "Motorola MC68HC16 microcontroller"; case EM_68HC11: return "Motorola MC68HC11 microcontroller"; case EM_68HC08: return "Motorola MC68HC08 microcontroller"; case EM_68HC05: return "Motorola MC68HC05 microcontroller"; case EM_SVX: return "Silicon Graphics SVx"; case EM_ST19: return "STMicroelectronics ST19 8-bit mc"; case EM_VAX: return "Digital VAX"; case EM_CRIS: return "Axis Communications 32-bit embedded processor"; case EM_JAVELIN: return "Infineon Tech. 32bit embedded processor"; case EM_FIREPATH: return "Element 14 64-bit DSP Processor"; case EM_ZSP: return "LSI Logic 16-bit DSP Processor"; case EM_MMIX: return "Donald Knuth's educational 64-bit proc"; case EM_HUANY: return "Harvard University MI object files"; case EM_PRISM: return "SiTera Prism"; case EM_AVR: return "Atmel AVR 8-bit microcontroller"; case EM_FR30: return "Fujitsu FR30"; case EM_D10V: return "Mitsubishi D10V"; case EM_D30V: return "Mitsubishi D30V"; case EM_V850: return "NEC v850"; case EM_M32R: return "Mitsubishi M32R"; case EM_MN10300: return "Matsushita MN10300"; case EM_MN10200: return "Matsushita MN10200"; case EM_PJ: return "picoJava"; case EM_OPENRISC: return "OpenRISC 32-bit embedded processor"; case EM_ARC_A5: return "ARC Cores Tangent-A5"; case EM_XTENSA: return "Tensilica Xtensa Architecture"; case EM_VIDEOCORE: return "Alphamosaic VideoCore processor"; case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor"; case EM_NS32K: return "National Semiconductor 32000 series"; case EM_TPC: return "Tenor Network TPC processor"; case EM_SNP1K: return "Trebia SNP 1000 processor"; case EM_ST200: return "STMicroelectronics ST200 microcontroller"; case EM_IP2K: return "Ubicom IP2xxx microcontroller family"; case EM_MAX: return "MAX Processor"; case EM_CR: return "National Semiconductor CompactRISC microprocessor"; case EM_F2MC16: return "Fujitsu F2MC16"; case EM_MSP430: return "TI embedded microcontroller msp430"; case EM_BLACKFIN: return "Analog Devices Blackfin (DSP) processor"; case EM_SE_C33: return "S1C33 Family of Seiko Epson processors"; case EM_SEP: return "Sharp embedded microprocessor"; case EM_ARCA: return "Arca RISC Microprocessor"; case EM_UNICORE: return "Microprocessor series from PKU-Unity Ltd"; case EM_AARCH64: return "AArch64"; case EM_RISCV: return "RISC-V"; default: snprintf(s_mach, sizeof(s_mach), "", mach); return (s_mach); } } static const char * elf_class(unsigned int class) { static char s_class[32]; switch (class) { case ELFCLASSNONE: return "none"; case ELFCLASS32: return "ELF32"; case ELFCLASS64: return "ELF64"; default: snprintf(s_class, sizeof(s_class), "", class); return (s_class); } } static const char * elf_endian(unsigned int endian) { static char s_endian[32]; switch (endian) { case ELFDATANONE: return "none"; case ELFDATA2LSB: return "2's complement, little endian"; case ELFDATA2MSB: return "2's complement, big endian"; default: snprintf(s_endian, sizeof(s_endian), "", endian); return (s_endian); } } static const char * elf_type(unsigned int type) { static char s_type[32]; switch (type) { case ET_NONE: return "NONE (None)"; case ET_REL: return "REL (Relocatable file)"; case ET_EXEC: return "EXEC (Executable file)"; case ET_DYN: return "DYN (Shared object file)"; case ET_CORE: return "CORE (Core file)"; default: if (type >= ET_LOPROC) snprintf(s_type, sizeof(s_type), "", type); else if (type >= ET_LOOS && type <= ET_HIOS) snprintf(s_type, sizeof(s_type), "", type); else snprintf(s_type, sizeof(s_type), "", type); return (s_type); } } static const char * elf_ver(unsigned int ver) { static char s_ver[32]; switch (ver) { case EV_CURRENT: return "(current)"; case EV_NONE: return "(none)"; default: snprintf(s_ver, sizeof(s_ver), "", ver); return (s_ver); } } static const char * phdr_type(unsigned int ptype) { static char s_ptype[32]; switch (ptype) { case PT_NULL: return "NULL"; case PT_LOAD: return "LOAD"; case PT_DYNAMIC: return "DYNAMIC"; case PT_INTERP: return "INTERP"; case PT_NOTE: return "NOTE"; case PT_SHLIB: return "SHLIB"; case PT_PHDR: return "PHDR"; case PT_TLS: return "TLS"; case PT_GNU_EH_FRAME: return "GNU_EH_FRAME"; case PT_GNU_STACK: return "GNU_STACK"; case PT_GNU_RELRO: return "GNU_RELRO"; default: if (ptype >= PT_LOPROC && ptype <= PT_HIPROC) snprintf(s_ptype, sizeof(s_ptype), "LOPROC+%#x", ptype - PT_LOPROC); else if (ptype >= PT_LOOS && ptype <= PT_HIOS) snprintf(s_ptype, sizeof(s_ptype), "LOOS+%#x", ptype - PT_LOOS); else snprintf(s_ptype, sizeof(s_ptype), "", ptype); return (s_ptype); } } static const char * section_type(unsigned int mach, unsigned int stype) { static char s_stype[32]; if (stype >= SHT_LOPROC && stype <= SHT_HIPROC) { switch (mach) { case EM_X86_64: switch (stype) { - case SHT_AMD64_UNWIND: return "AMD64_UNWIND"; + case SHT_X86_64_UNWIND: return "X86_64_UNWIND"; default: break; } break; case EM_MIPS: case EM_MIPS_RS3_LE: switch (stype) { case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST"; case SHT_MIPS_MSYM: return "MIPS_MSYM"; case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT"; case SHT_MIPS_GPTAB: return "MIPS_GPTAB"; case SHT_MIPS_UCODE: return "MIPS_UCODE"; case SHT_MIPS_DEBUG: return "MIPS_DEBUG"; case SHT_MIPS_REGINFO: return "MIPS_REGINFO"; case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE"; case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM"; case SHT_MIPS_RELD: return "MIPS_RELD"; case SHT_MIPS_IFACE: return "MIPS_IFACE"; case SHT_MIPS_CONTENT: return "MIPS_CONTENT"; case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS"; case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM"; case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST"; case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS"; case SHT_MIPS_DWARF: return "MIPS_DWARF"; case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL"; case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB"; case SHT_MIPS_EVENTS: return "MIPS_EVENTS"; case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE"; case SHT_MIPS_PIXIE: return "MIPS_PIXIE"; case SHT_MIPS_XLATE: return "MIPS_XLATE"; case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG"; case SHT_MIPS_WHIRL: return "MIPS_WHIRL"; case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION"; case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD"; case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION"; default: break; } break; default: break; } snprintf(s_stype, sizeof(s_stype), "LOPROC+%#x", stype - SHT_LOPROC); return (s_stype); } switch (stype) { case SHT_NULL: return "NULL"; case SHT_PROGBITS: return "PROGBITS"; case SHT_SYMTAB: return "SYMTAB"; case SHT_STRTAB: return "STRTAB"; case SHT_RELA: return "RELA"; case SHT_HASH: return "HASH"; case SHT_DYNAMIC: return "DYNAMIC"; case SHT_NOTE: return "NOTE"; case SHT_NOBITS: return "NOBITS"; case SHT_REL: return "REL"; case SHT_SHLIB: return "SHLIB"; case SHT_DYNSYM: return "DYNSYM"; case SHT_INIT_ARRAY: return "INIT_ARRAY"; case SHT_FINI_ARRAY: return "FINI_ARRAY"; case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY"; case SHT_GROUP: return "GROUP"; case SHT_SYMTAB_SHNDX: return "SYMTAB_SHNDX"; case SHT_SUNW_dof: return "SUNW_dof"; case SHT_SUNW_cap: return "SUNW_cap"; case SHT_GNU_HASH: return "GNU_HASH"; case SHT_SUNW_ANNOTATE: return "SUNW_ANNOTATE"; case SHT_SUNW_DEBUGSTR: return "SUNW_DEBUGSTR"; case SHT_SUNW_DEBUG: return "SUNW_DEBUG"; case SHT_SUNW_move: return "SUNW_move"; case SHT_SUNW_COMDAT: return "SUNW_COMDAT"; case SHT_SUNW_syminfo: return "SUNW_syminfo"; case SHT_SUNW_verdef: return "SUNW_verdef"; case SHT_SUNW_verneed: return "SUNW_verneed"; case SHT_SUNW_versym: return "SUNW_versym"; default: if (stype >= SHT_LOOS && stype <= SHT_HIOS) snprintf(s_stype, sizeof(s_stype), "LOOS+%#x", stype - SHT_LOOS); else if (stype >= SHT_LOUSER) snprintf(s_stype, sizeof(s_stype), "LOUSER+%#x", stype - SHT_LOUSER); else snprintf(s_stype, sizeof(s_stype), "", stype); return (s_stype); } } static const char * dt_type(unsigned int mach, unsigned int dtype) { static char s_dtype[32]; if (dtype >= DT_LOPROC && dtype <= DT_HIPROC) { switch (mach) { case EM_ARM: switch (dtype) { case DT_ARM_SYMTABSZ: return "ARM_SYMTABSZ"; default: break; } break; case EM_MIPS: case EM_MIPS_RS3_LE: switch (dtype) { case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION"; case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP"; case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM"; case DT_MIPS_IVERSION: return "MIPS_IVERSION"; case DT_MIPS_FLAGS: return "MIPS_FLAGS"; case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS"; case DT_MIPS_CONFLICT: return "MIPS_CONFLICT"; case DT_MIPS_LIBLIST: return "MIPS_LIBLIST"; case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO"; case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO"; case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO"; case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO"; case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO"; case DT_MIPS_GOTSYM: return "MIPS_GOTSYM"; case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO"; case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP"; case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS"; case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO"; case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE"; case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO"; case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC"; case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO"; case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM"; case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO"; case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM"; case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO"; case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS"; case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT"; case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB"; case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX"; case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX"; case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX"; case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX"; case DT_MIPS_OPTIONS: return "MIPS_OPTIONS"; case DT_MIPS_INTERFACE: return "MIPS_INTERFACE"; case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN"; case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE"; case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR"; case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX"; case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE"; case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE"; case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC"; case DT_MIPS_PLTGOT: return "MIPS_PLTGOT"; case DT_MIPS_RLD_OBJ_UPDATE: return "MIPS_RLD_OBJ_UPDATE"; case DT_MIPS_RWPLT: return "MIPS_RWPLT"; default: break; } break; case EM_SPARC: case EM_SPARC32PLUS: case EM_SPARCV9: switch (dtype) { case DT_SPARC_REGISTER: return "DT_SPARC_REGISTER"; default: break; } break; default: break; } snprintf(s_dtype, sizeof(s_dtype), "", dtype); return (s_dtype); } switch (dtype) { case DT_NULL: return "NULL"; case DT_NEEDED: return "NEEDED"; case DT_PLTRELSZ: return "PLTRELSZ"; case DT_PLTGOT: return "PLTGOT"; case DT_HASH: return "HASH"; case DT_STRTAB: return "STRTAB"; case DT_SYMTAB: return "SYMTAB"; case DT_RELA: return "RELA"; case DT_RELASZ: return "RELASZ"; case DT_RELAENT: return "RELAENT"; case DT_STRSZ: return "STRSZ"; case DT_SYMENT: return "SYMENT"; case DT_INIT: return "INIT"; case DT_FINI: return "FINI"; case DT_SONAME: return "SONAME"; case DT_RPATH: return "RPATH"; case DT_SYMBOLIC: return "SYMBOLIC"; case DT_REL: return "REL"; case DT_RELSZ: return "RELSZ"; case DT_RELENT: return "RELENT"; case DT_PLTREL: return "PLTREL"; case DT_DEBUG: return "DEBUG"; case DT_TEXTREL: return "TEXTREL"; case DT_JMPREL: return "JMPREL"; case DT_BIND_NOW: return "BIND_NOW"; case DT_INIT_ARRAY: return "INIT_ARRAY"; case DT_FINI_ARRAY: return "FINI_ARRAY"; case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ"; case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ"; case DT_RUNPATH: return "RUNPATH"; case DT_FLAGS: return "FLAGS"; case DT_PREINIT_ARRAY: return "PREINIT_ARRAY"; case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ"; case DT_MAXPOSTAGS: return "MAXPOSTAGS"; case DT_SUNW_AUXILIARY: return "SUNW_AUXILIARY"; case DT_SUNW_RTLDINF: return "SUNW_RTLDINF"; case DT_SUNW_FILTER: return "SUNW_FILTER"; case DT_SUNW_CAP: return "SUNW_CAP"; case DT_CHECKSUM: return "CHECKSUM"; case DT_PLTPADSZ: return "PLTPADSZ"; case DT_MOVEENT: return "MOVEENT"; case DT_MOVESZ: return "MOVESZ"; case DT_FEATURE: return "FEATURE"; case DT_POSFLAG_1: return "POSFLAG_1"; case DT_SYMINSZ: return "SYMINSZ"; case DT_SYMINENT: return "SYMINENT"; case DT_GNU_HASH: return "GNU_HASH"; + case DT_TLSDESC_PLT: return "DT_TLSDESC_PLT"; + case DT_TLSDESC_GOT: return "DT_TLSDESC_GOT"; case DT_GNU_CONFLICT: return "GNU_CONFLICT"; case DT_GNU_LIBLIST: return "GNU_LIBLIST"; case DT_CONFIG: return "CONFIG"; case DT_DEPAUDIT: return "DEPAUDIT"; case DT_AUDIT: return "AUDIT"; case DT_PLTPAD: return "PLTPAD"; case DT_MOVETAB: return "MOVETAB"; case DT_SYMINFO: return "SYMINFO"; case DT_VERSYM: return "VERSYM"; case DT_RELACOUNT: return "RELACOUNT"; case DT_RELCOUNT: return "RELCOUNT"; case DT_FLAGS_1: return "FLAGS_1"; case DT_VERDEF: return "VERDEF"; case DT_VERDEFNUM: return "VERDEFNUM"; case DT_VERNEED: return "VERNEED"; case DT_VERNEEDNUM: return "VERNEEDNUM"; case DT_AUXILIARY: return "AUXILIARY"; case DT_USED: return "USED"; case DT_FILTER: return "FILTER"; case DT_GNU_PRELINKED: return "GNU_PRELINKED"; case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ"; case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ"; default: snprintf(s_dtype, sizeof(s_dtype), "", dtype); return (s_dtype); } } static const char * st_bind(unsigned int sbind) { static char s_sbind[32]; switch (sbind) { case STB_LOCAL: return "LOCAL"; case STB_GLOBAL: return "GLOBAL"; case STB_WEAK: return "WEAK"; case STB_GNU_UNIQUE: return "UNIQUE"; default: if (sbind >= STB_LOOS && sbind <= STB_HIOS) return "OS"; else if (sbind >= STB_LOPROC && sbind <= STB_HIPROC) return "PROC"; else snprintf(s_sbind, sizeof(s_sbind), "", sbind); return (s_sbind); } } static const char * -st_type(unsigned int mach, unsigned int stype) +st_type(unsigned int mach, unsigned int os, unsigned int stype) { static char s_stype[32]; switch (stype) { case STT_NOTYPE: return "NOTYPE"; case STT_OBJECT: return "OBJECT"; case STT_FUNC: return "FUNC"; case STT_SECTION: return "SECTION"; case STT_FILE: return "FILE"; case STT_COMMON: return "COMMON"; case STT_TLS: return "TLS"; default: - if (stype >= STT_LOOS && stype <= STT_HIOS) + if (stype >= STT_LOOS && stype <= STT_HIOS) { + if ((os == ELFOSABI_GNU || os == ELFOSABI_FREEBSD) && + stype == STT_GNU_IFUNC) + return "IFUNC"; snprintf(s_stype, sizeof(s_stype), "OS+%#x", stype - STT_LOOS); - else if (stype >= STT_LOPROC && stype <= STT_HIPROC) { + } else if (stype >= STT_LOPROC && stype <= STT_HIPROC) { if (mach == EM_SPARCV9 && stype == STT_SPARC_REGISTER) return "REGISTER"; snprintf(s_stype, sizeof(s_stype), "PROC+%#x", stype - STT_LOPROC); } else snprintf(s_stype, sizeof(s_stype), "", stype); return (s_stype); } } static const char * st_vis(unsigned int svis) { static char s_svis[32]; switch(svis) { case STV_DEFAULT: return "DEFAULT"; case STV_INTERNAL: return "INTERNAL"; case STV_HIDDEN: return "HIDDEN"; case STV_PROTECTED: return "PROTECTED"; default: snprintf(s_svis, sizeof(s_svis), "", svis); return (s_svis); } } static const char * st_shndx(unsigned int shndx) { static char s_shndx[32]; switch (shndx) { case SHN_UNDEF: return "UND"; case SHN_ABS: return "ABS"; case SHN_COMMON: return "COM"; default: if (shndx >= SHN_LOPROC && shndx <= SHN_HIPROC) return "PRC"; else if (shndx >= SHN_LOOS && shndx <= SHN_HIOS) return "OS"; else snprintf(s_shndx, sizeof(s_shndx), "%u", shndx); return (s_shndx); } } static struct { const char *ln; char sn; int value; } section_flag[] = { {"WRITE", 'W', SHF_WRITE}, {"ALLOC", 'A', SHF_ALLOC}, {"EXEC", 'X', SHF_EXECINSTR}, {"MERGE", 'M', SHF_MERGE}, {"STRINGS", 'S', SHF_STRINGS}, {"INFO LINK", 'I', SHF_INFO_LINK}, {"OS NONCONF", 'O', SHF_OS_NONCONFORMING}, {"GROUP", 'G', SHF_GROUP}, {"TLS", 'T', SHF_TLS}, + {"COMPRESSED", 'C', SHF_COMPRESSED}, {NULL, 0, 0} }; static const char * -r_type(unsigned int mach, unsigned int type) -{ - static char s_type[32]; - - switch(mach) { - case EM_386: - case EM_IAMCU: - switch(type) { - case 0: return "R_386_NONE"; - case 1: return "R_386_32"; - case 2: return "R_386_PC32"; - case 3: return "R_386_GOT32"; - case 4: return "R_386_PLT32"; - case 5: return "R_386_COPY"; - case 6: return "R_386_GLOB_DAT"; - case 7: return "R_386_JUMP_SLOT"; - case 8: return "R_386_RELATIVE"; - case 9: return "R_386_GOTOFF"; - case 10: return "R_386_GOTPC"; - case 14: return "R_386_TLS_TPOFF"; - case 15: return "R_386_TLS_IE"; - case 16: return "R_386_TLS_GOTIE"; - case 17: return "R_386_TLS_LE"; - case 18: return "R_386_TLS_GD"; - case 19: return "R_386_TLS_LDM"; - case 24: return "R_386_TLS_GD_32"; - case 25: return "R_386_TLS_GD_PUSH"; - case 26: return "R_386_TLS_GD_CALL"; - case 27: return "R_386_TLS_GD_POP"; - case 28: return "R_386_TLS_LDM_32"; - case 29: return "R_386_TLS_LDM_PUSH"; - case 30: return "R_386_TLS_LDM_CALL"; - case 31: return "R_386_TLS_LDM_POP"; - case 32: return "R_386_TLS_LDO_32"; - case 33: return "R_386_TLS_IE_32"; - case 34: return "R_386_TLS_LE_32"; - case 35: return "R_386_TLS_DTPMOD32"; - case 36: return "R_386_TLS_DTPOFF32"; - case 37: return "R_386_TLS_TPOFF32"; - } - break; - case EM_AARCH64: - switch(type) { - case 0: return "R_AARCH64_NONE"; - case 257: return "R_AARCH64_ABS64"; - case 258: return "R_AARCH64_ABS32"; - case 259: return "R_AARCH64_ABS16"; - case 260: return "R_AARCH64_PREL64"; - case 261: return "R_AARCH64_PREL32"; - case 262: return "R_AARCH64_PREL16"; - case 263: return "R_AARCH64_MOVW_UABS_G0"; - case 264: return "R_AARCH64_MOVW_UABS_G0_NC"; - case 265: return "R_AARCH64_MOVW_UABS_G1"; - case 266: return "R_AARCH64_MOVW_UABS_G1_NC"; - case 267: return "R_AARCH64_MOVW_UABS_G2"; - case 268: return "R_AARCH64_MOVW_UABS_G2_NC"; - case 269: return "R_AARCH64_MOVW_UABS_G3"; - case 270: return "R_AARCH64_MOVW_SABS_G0"; - case 271: return "R_AARCH64_MOVW_SABS_G1"; - case 272: return "R_AARCH64_MOVW_SABS_G2"; - case 273: return "R_AARCH64_LD_PREL_LO19"; - case 274: return "R_AARCH64_ADR_PREL_LO21"; - case 275: return "R_AARCH64_ADR_PREL_PG_HI21"; - case 276: return "R_AARCH64_ADR_PREL_PG_HI21_NC"; - case 277: return "R_AARCH64_ADD_ABS_LO12_NC"; - case 278: return "R_AARCH64_LDST8_ABS_LO12_NC"; - case 279: return "R_AARCH64_TSTBR14"; - case 280: return "R_AARCH64_CONDBR19"; - case 282: return "R_AARCH64_JUMP26"; - case 283: return "R_AARCH64_CALL26"; - case 284: return "R_AARCH64_LDST16_ABS_LO12_NC"; - case 285: return "R_AARCH64_LDST32_ABS_LO12_NC"; - case 286: return "R_AARCH64_LDST64_ABS_LO12_NC"; - case 287: return "R_AARCH64_MOVW_PREL_G0"; - case 288: return "R_AARCH64_MOVW_PREL_G0_NC"; - case 289: return "R_AARCH64_MOVW_PREL_G1"; - case 290: return "R_AARCH64_MOVW_PREL_G1_NC"; - case 291: return "R_AARCH64_MOVW_PREL_G2"; - case 292: return "R_AARCH64_MOVW_PREL_G2_NC"; - case 293: return "R_AARCH64_MOVW_PREL_G3"; - case 299: return "R_AARCH64_LDST128_ABS_LO12_NC"; - case 300: return "R_AARCH64_MOVW_GOTOFF_G0"; - case 301: return "R_AARCH64_MOVW_GOTOFF_G0_NC"; - case 302: return "R_AARCH64_MOVW_GOTOFF_G1"; - case 303: return "R_AARCH64_MOVW_GOTOFF_G1_NC"; - case 304: return "R_AARCH64_MOVW_GOTOFF_G2"; - case 305: return "R_AARCH64_MOVW_GOTOFF_G2_NC"; - case 306: return "R_AARCH64_MOVW_GOTOFF_G3"; - case 307: return "R_AARCH64_GOTREL64"; - case 308: return "R_AARCH64_GOTREL32"; - case 309: return "R_AARCH64_GOT_LD_PREL19"; - case 310: return "R_AARCH64_LD64_GOTOFF_LO15"; - case 311: return "R_AARCH64_ADR_GOT_PAGE"; - case 312: return "R_AARCH64_LD64_GOT_LO12_NC"; - case 313: return "R_AARCH64_LD64_GOTPAGE_LO15"; - case 560: return "R_AARCH64_TLSDESC_LD_PREL19"; - case 561: return "R_AARCH64_TLSDESC_ADR_PREL21"; - case 562: return "R_AARCH64_TLSDESC_ADR_PAGE21"; - case 563: return "R_AARCH64_TLSDESC_LD64_LO12"; - case 564: return "R_AARCH64_TLSDESC_ADD_LO12"; - case 565: return "R_AARCH64_TLSDESC_OFF_G1"; - case 566: return "R_AARCH64_TLSDESC_OFF_G0_NC"; - case 567: return "R_AARCH64_TLSDESC_LDR"; - case 568: return "R_AARCH64_TLSDESC_ADD"; - case 569: return "R_AARCH64_TLSDESC_CALL"; - case 1024: return "R_AARCH64_COPY"; - case 1025: return "R_AARCH64_GLOB_DAT"; - case 1026: return "R_AARCH64_JUMP_SLOT"; - case 1027: return "R_AARCH64_RELATIVE"; - case 1028: return "R_AARCH64_TLS_DTPREL64"; - case 1029: return "R_AARCH64_TLS_DTPMOD64"; - case 1030: return "R_AARCH64_TLS_TPREL64"; - case 1031: return "R_AARCH64_TLSDESC"; - case 1032: return "R_AARCH64_IRELATIVE"; - } - break; - case EM_ARM: - switch(type) { - case 0: return "R_ARM_NONE"; - case 1: return "R_ARM_PC24"; - case 2: return "R_ARM_ABS32"; - case 3: return "R_ARM_REL32"; - case 4: return "R_ARM_PC13"; - case 5: return "R_ARM_ABS16"; - case 6: return "R_ARM_ABS12"; - case 7: return "R_ARM_THM_ABS5"; - case 8: return "R_ARM_ABS8"; - case 9: return "R_ARM_SBREL32"; - case 10: return "R_ARM_THM_PC22"; - case 11: return "R_ARM_THM_PC8"; - case 12: return "R_ARM_AMP_VCALL9"; - case 13: return "R_ARM_TLS_DESC"; - /* Obsolete R_ARM_SWI24 is also 13 */ - case 14: return "R_ARM_THM_SWI8"; - case 15: return "R_ARM_XPC25"; - case 16: return "R_ARM_THM_XPC22"; - case 17: return "R_ARM_TLS_DTPMOD32"; - case 18: return "R_ARM_TLS_DTPOFF32"; - case 19: return "R_ARM_TLS_TPOFF32"; - case 20: return "R_ARM_COPY"; - case 21: return "R_ARM_GLOB_DAT"; - case 22: return "R_ARM_JUMP_SLOT"; - case 23: return "R_ARM_RELATIVE"; - case 24: return "R_ARM_GOTOFF"; - case 25: return "R_ARM_GOTPC"; - case 26: return "R_ARM_GOT32"; - case 27: return "R_ARM_PLT32"; - case 28: return "R_ARM_CALL"; - case 29: return "R_ARM_JUMP24"; - case 30: return "R_ARM_THM_JUMP24"; - case 31: return "R_ARM_BASE_ABS"; - case 38: return "R_ARM_TARGET1"; - case 40: return "R_ARM_V4BX"; - case 42: return "R_ARM_PREL31"; - case 43: return "R_ARM_MOVW_ABS_NC"; - case 44: return "R_ARM_MOVT_ABS"; - case 45: return "R_ARM_MOVW_PREL_NC"; - case 46: return "R_ARM_MOVT_PREL"; - case 100: return "R_ARM_GNU_VTENTRY"; - case 101: return "R_ARM_GNU_VTINHERIT"; - case 250: return "R_ARM_RSBREL32"; - case 251: return "R_ARM_THM_RPC22"; - case 252: return "R_ARM_RREL32"; - case 253: return "R_ARM_RABS32"; - case 254: return "R_ARM_RPC24"; - case 255: return "R_ARM_RBASE"; - } - break; - case EM_IA_64: - switch(type) { - case 0: return "R_IA_64_NONE"; - case 33: return "R_IA_64_IMM14"; - case 34: return "R_IA_64_IMM22"; - case 35: return "R_IA_64_IMM64"; - case 36: return "R_IA_64_DIR32MSB"; - case 37: return "R_IA_64_DIR32LSB"; - case 38: return "R_IA_64_DIR64MSB"; - case 39: return "R_IA_64_DIR64LSB"; - case 42: return "R_IA_64_GPREL22"; - case 43: return "R_IA_64_GPREL64I"; - case 44: return "R_IA_64_GPREL32MSB"; - case 45: return "R_IA_64_GPREL32LSB"; - case 46: return "R_IA_64_GPREL64MSB"; - case 47: return "R_IA_64_GPREL64LSB"; - case 50: return "R_IA_64_LTOFF22"; - case 51: return "R_IA_64_LTOFF64I"; - case 58: return "R_IA_64_PLTOFF22"; - case 59: return "R_IA_64_PLTOFF64I"; - case 62: return "R_IA_64_PLTOFF64MSB"; - case 63: return "R_IA_64_PLTOFF64LSB"; - case 67: return "R_IA_64_FPTR64I"; - case 68: return "R_IA_64_FPTR32MSB"; - case 69: return "R_IA_64_FPTR32LSB"; - case 70: return "R_IA_64_FPTR64MSB"; - case 71: return "R_IA_64_FPTR64LSB"; - case 72: return "R_IA_64_PCREL60B"; - case 73: return "R_IA_64_PCREL21B"; - case 74: return "R_IA_64_PCREL21M"; - case 75: return "R_IA_64_PCREL21F"; - case 76: return "R_IA_64_PCREL32MSB"; - case 77: return "R_IA_64_PCREL32LSB"; - case 78: return "R_IA_64_PCREL64MSB"; - case 79: return "R_IA_64_PCREL64LSB"; - case 82: return "R_IA_64_LTOFF_FPTR22"; - case 83: return "R_IA_64_LTOFF_FPTR64I"; - case 84: return "R_IA_64_LTOFF_FPTR32MSB"; - case 85: return "R_IA_64_LTOFF_FPTR32LSB"; - case 86: return "R_IA_64_LTOFF_FPTR64MSB"; - case 87: return "R_IA_64_LTOFF_FPTR64LSB"; - case 92: return "R_IA_64_SEGREL32MSB"; - case 93: return "R_IA_64_SEGREL32LSB"; - case 94: return "R_IA_64_SEGREL64MSB"; - case 95: return "R_IA_64_SEGREL64LSB"; - case 100: return "R_IA_64_SECREL32MSB"; - case 101: return "R_IA_64_SECREL32LSB"; - case 102: return "R_IA_64_SECREL64MSB"; - case 103: return "R_IA_64_SECREL64LSB"; - case 108: return "R_IA_64_REL32MSB"; - case 109: return "R_IA_64_REL32LSB"; - case 110: return "R_IA_64_REL64MSB"; - case 111: return "R_IA_64_REL64LSB"; - case 116: return "R_IA_64_LTV32MSB"; - case 117: return "R_IA_64_LTV32LSB"; - case 118: return "R_IA_64_LTV64MSB"; - case 119: return "R_IA_64_LTV64LSB"; - case 121: return "R_IA_64_PCREL21BI"; - case 122: return "R_IA_64_PCREL22"; - case 123: return "R_IA_64_PCREL64I"; - case 128: return "R_IA_64_IPLTMSB"; - case 129: return "R_IA_64_IPLTLSB"; - case 133: return "R_IA_64_SUB"; - case 134: return "R_IA_64_LTOFF22X"; - case 135: return "R_IA_64_LDXMOV"; - case 145: return "R_IA_64_TPREL14"; - case 146: return "R_IA_64_TPREL22"; - case 147: return "R_IA_64_TPREL64I"; - case 150: return "R_IA_64_TPREL64MSB"; - case 151: return "R_IA_64_TPREL64LSB"; - case 154: return "R_IA_64_LTOFF_TPREL22"; - case 166: return "R_IA_64_DTPMOD64MSB"; - case 167: return "R_IA_64_DTPMOD64LSB"; - case 170: return "R_IA_64_LTOFF_DTPMOD22"; - case 177: return "R_IA_64_DTPREL14"; - case 178: return "R_IA_64_DTPREL22"; - case 179: return "R_IA_64_DTPREL64I"; - case 180: return "R_IA_64_DTPREL32MSB"; - case 181: return "R_IA_64_DTPREL32LSB"; - case 182: return "R_IA_64_DTPREL64MSB"; - case 183: return "R_IA_64_DTPREL64LSB"; - case 186: return "R_IA_64_LTOFF_DTPREL22"; - } - break; - case EM_MIPS: - switch(type) { - case 0: return "R_MIPS_NONE"; - case 1: return "R_MIPS_16"; - case 2: return "R_MIPS_32"; - case 3: return "R_MIPS_REL32"; - case 4: return "R_MIPS_26"; - case 5: return "R_MIPS_HI16"; - case 6: return "R_MIPS_LO16"; - case 7: return "R_MIPS_GPREL16"; - case 8: return "R_MIPS_LITERAL"; - case 9: return "R_MIPS_GOT16"; - case 10: return "R_MIPS_PC16"; - case 11: return "R_MIPS_CALL16"; - case 12: return "R_MIPS_GPREL32"; - case 21: return "R_MIPS_GOTHI16"; - case 22: return "R_MIPS_GOTLO16"; - case 30: return "R_MIPS_CALLHI16"; - case 31: return "R_MIPS_CALLLO16"; - case 38: return "R_MIPS_TLS_DTPMOD32"; - case 39: return "R_MIPS_TLS_DTPREL32"; - case 40: return "R_MIPS_TLS_DTPMOD64"; - case 41: return "R_MIPS_TLS_DTPREL64"; - case 42: return "R_MIPS_TLS_GD"; - case 43: return "R_MIPS_TLS_LDM"; - case 44: return "R_MIPS_TLS_DTPREL_HI16"; - case 45: return "R_MIPS_TLS_DTPREL_LO16"; - case 46: return "R_MIPS_TLS_GOTTPREL"; - case 47: return "R_MIPS_TLS_TPREL32"; - case 48: return "R_MIPS_TLS_TPREL64"; - case 49: return "R_MIPS_TLS_TPREL_HI16"; - case 50: return "R_MIPS_TLS_TPREL_LO16"; - } - break; - case EM_PPC: - switch(type) { - case 0: return "R_PPC_NONE"; - case 1: return "R_PPC_ADDR32"; - case 2: return "R_PPC_ADDR24"; - case 3: return "R_PPC_ADDR16"; - case 4: return "R_PPC_ADDR16_LO"; - case 5: return "R_PPC_ADDR16_HI"; - case 6: return "R_PPC_ADDR16_HA"; - case 7: return "R_PPC_ADDR14"; - case 8: return "R_PPC_ADDR14_BRTAKEN"; - case 9: return "R_PPC_ADDR14_BRNTAKEN"; - case 10: return "R_PPC_REL24"; - case 11: return "R_PPC_REL14"; - case 12: return "R_PPC_REL14_BRTAKEN"; - case 13: return "R_PPC_REL14_BRNTAKEN"; - case 14: return "R_PPC_GOT16"; - case 15: return "R_PPC_GOT16_LO"; - case 16: return "R_PPC_GOT16_HI"; - case 17: return "R_PPC_GOT16_HA"; - case 18: return "R_PPC_PLTREL24"; - case 19: return "R_PPC_COPY"; - case 20: return "R_PPC_GLOB_DAT"; - case 21: return "R_PPC_JMP_SLOT"; - case 22: return "R_PPC_RELATIVE"; - case 23: return "R_PPC_LOCAL24PC"; - case 24: return "R_PPC_UADDR32"; - case 25: return "R_PPC_UADDR16"; - case 26: return "R_PPC_REL32"; - case 27: return "R_PPC_PLT32"; - case 28: return "R_PPC_PLTREL32"; - case 29: return "R_PPC_PLT16_LO"; - case 30: return "R_PPC_PLT16_HI"; - case 31: return "R_PPC_PLT16_HA"; - case 32: return "R_PPC_SDAREL16"; - case 33: return "R_PPC_SECTOFF"; - case 34: return "R_PPC_SECTOFF_LO"; - case 35: return "R_PPC_SECTOFF_HI"; - case 36: return "R_PPC_SECTOFF_HA"; - case 67: return "R_PPC_TLS"; - case 68: return "R_PPC_DTPMOD32"; - case 69: return "R_PPC_TPREL16"; - case 70: return "R_PPC_TPREL16_LO"; - case 71: return "R_PPC_TPREL16_HI"; - case 72: return "R_PPC_TPREL16_HA"; - case 73: return "R_PPC_TPREL32"; - case 74: return "R_PPC_DTPREL16"; - case 75: return "R_PPC_DTPREL16_LO"; - case 76: return "R_PPC_DTPREL16_HI"; - case 77: return "R_PPC_DTPREL16_HA"; - case 78: return "R_PPC_DTPREL32"; - case 79: return "R_PPC_GOT_TLSGD16"; - case 80: return "R_PPC_GOT_TLSGD16_LO"; - case 81: return "R_PPC_GOT_TLSGD16_HI"; - case 82: return "R_PPC_GOT_TLSGD16_HA"; - case 83: return "R_PPC_GOT_TLSLD16"; - case 84: return "R_PPC_GOT_TLSLD16_LO"; - case 85: return "R_PPC_GOT_TLSLD16_HI"; - case 86: return "R_PPC_GOT_TLSLD16_HA"; - case 87: return "R_PPC_GOT_TPREL16"; - case 88: return "R_PPC_GOT_TPREL16_LO"; - case 89: return "R_PPC_GOT_TPREL16_HI"; - case 90: return "R_PPC_GOT_TPREL16_HA"; - case 101: return "R_PPC_EMB_NADDR32"; - case 102: return "R_PPC_EMB_NADDR16"; - case 103: return "R_PPC_EMB_NADDR16_LO"; - case 104: return "R_PPC_EMB_NADDR16_HI"; - case 105: return "R_PPC_EMB_NADDR16_HA"; - case 106: return "R_PPC_EMB_SDAI16"; - case 107: return "R_PPC_EMB_SDA2I16"; - case 108: return "R_PPC_EMB_SDA2REL"; - case 109: return "R_PPC_EMB_SDA21"; - case 110: return "R_PPC_EMB_MRKREF"; - case 111: return "R_PPC_EMB_RELSEC16"; - case 112: return "R_PPC_EMB_RELST_LO"; - case 113: return "R_PPC_EMB_RELST_HI"; - case 114: return "R_PPC_EMB_RELST_HA"; - case 115: return "R_PPC_EMB_BIT_FLD"; - case 116: return "R_PPC_EMB_RELSDA"; - } - break; - case EM_RISCV: - switch(type) { - case 0: return "R_RISCV_NONE"; - case 1: return "R_RISCV_32"; - case 2: return "R_RISCV_64"; - case 3: return "R_RISCV_RELATIVE"; - case 4: return "R_RISCV_COPY"; - case 5: return "R_RISCV_JUMP_SLOT"; - case 6: return "R_RISCV_TLS_DTPMOD32"; - case 7: return "R_RISCV_TLS_DTPMOD64"; - case 8: return "R_RISCV_TLS_DTPREL32"; - case 9: return "R_RISCV_TLS_DTPREL64"; - case 10: return "R_RISCV_TLS_TPREL32"; - case 11: return "R_RISCV_TLS_TPREL64"; - case 16: return "R_RISCV_BRANCH"; - case 17: return "R_RISCV_JAL"; - case 18: return "R_RISCV_CALL"; - case 19: return "R_RISCV_CALL_PLT"; - case 20: return "R_RISCV_GOT_HI20"; - case 21: return "R_RISCV_TLS_GOT_HI20"; - case 22: return "R_RISCV_TLS_GD_HI20"; - case 23: return "R_RISCV_PCREL_HI20"; - case 24: return "R_RISCV_PCREL_LO12_I"; - case 25: return "R_RISCV_PCREL_LO12_S"; - case 26: return "R_RISCV_HI20"; - case 27: return "R_RISCV_LO12_I"; - case 28: return "R_RISCV_LO12_S"; - case 29: return "R_RISCV_TPREL_HI20"; - case 30: return "R_RISCV_TPREL_LO12_I"; - case 31: return "R_RISCV_TPREL_LO12_S"; - case 32: return "R_RISCV_TPREL_ADD"; - case 33: return "R_RISCV_ADD8"; - case 34: return "R_RISCV_ADD16"; - case 35: return "R_RISCV_ADD32"; - case 36: return "R_RISCV_ADD64"; - case 37: return "R_RISCV_SUB8"; - case 38: return "R_RISCV_SUB16"; - case 39: return "R_RISCV_SUB32"; - case 40: return "R_RISCV_SUB64"; - case 41: return "R_RISCV_GNU_VTINHERIT"; - case 42: return "R_RISCV_GNU_VTENTRY"; - case 43: return "R_RISCV_ALIGN"; - case 44: return "R_RISCV_RVC_BRANCH"; - case 45: return "R_RISCV_RVC_JUMP"; - } - break; - case EM_SPARC: - case EM_SPARCV9: - switch(type) { - case 0: return "R_SPARC_NONE"; - case 1: return "R_SPARC_8"; - case 2: return "R_SPARC_16"; - case 3: return "R_SPARC_32"; - case 4: return "R_SPARC_DISP8"; - case 5: return "R_SPARC_DISP16"; - case 6: return "R_SPARC_DISP32"; - case 7: return "R_SPARC_WDISP30"; - case 8: return "R_SPARC_WDISP22"; - case 9: return "R_SPARC_HI22"; - case 10: return "R_SPARC_22"; - case 11: return "R_SPARC_13"; - case 12: return "R_SPARC_LO10"; - case 13: return "R_SPARC_GOT10"; - case 14: return "R_SPARC_GOT13"; - case 15: return "R_SPARC_GOT22"; - case 16: return "R_SPARC_PC10"; - case 17: return "R_SPARC_PC22"; - case 18: return "R_SPARC_WPLT30"; - case 19: return "R_SPARC_COPY"; - case 20: return "R_SPARC_GLOB_DAT"; - case 21: return "R_SPARC_JMP_SLOT"; - case 22: return "R_SPARC_RELATIVE"; - case 23: return "R_SPARC_UA32"; - case 24: return "R_SPARC_PLT32"; - case 25: return "R_SPARC_HIPLT22"; - case 26: return "R_SPARC_LOPLT10"; - case 27: return "R_SPARC_PCPLT32"; - case 28: return "R_SPARC_PCPLT22"; - case 29: return "R_SPARC_PCPLT10"; - case 30: return "R_SPARC_10"; - case 31: return "R_SPARC_11"; - case 32: return "R_SPARC_64"; - case 33: return "R_SPARC_OLO10"; - case 34: return "R_SPARC_HH22"; - case 35: return "R_SPARC_HM10"; - case 36: return "R_SPARC_LM22"; - case 37: return "R_SPARC_PC_HH22"; - case 38: return "R_SPARC_PC_HM10"; - case 39: return "R_SPARC_PC_LM22"; - case 40: return "R_SPARC_WDISP16"; - case 41: return "R_SPARC_WDISP19"; - case 42: return "R_SPARC_GLOB_JMP"; - case 43: return "R_SPARC_7"; - case 44: return "R_SPARC_5"; - case 45: return "R_SPARC_6"; - case 46: return "R_SPARC_DISP64"; - case 47: return "R_SPARC_PLT64"; - case 48: return "R_SPARC_HIX22"; - case 49: return "R_SPARC_LOX10"; - case 50: return "R_SPARC_H44"; - case 51: return "R_SPARC_M44"; - case 52: return "R_SPARC_L44"; - case 53: return "R_SPARC_REGISTER"; - case 54: return "R_SPARC_UA64"; - case 55: return "R_SPARC_UA16"; - case 56: return "R_SPARC_TLS_GD_HI22"; - case 57: return "R_SPARC_TLS_GD_LO10"; - case 58: return "R_SPARC_TLS_GD_ADD"; - case 59: return "R_SPARC_TLS_GD_CALL"; - case 60: return "R_SPARC_TLS_LDM_HI22"; - case 61: return "R_SPARC_TLS_LDM_LO10"; - case 62: return "R_SPARC_TLS_LDM_ADD"; - case 63: return "R_SPARC_TLS_LDM_CALL"; - case 64: return "R_SPARC_TLS_LDO_HIX22"; - case 65: return "R_SPARC_TLS_LDO_LOX10"; - case 66: return "R_SPARC_TLS_LDO_ADD"; - case 67: return "R_SPARC_TLS_IE_HI22"; - case 68: return "R_SPARC_TLS_IE_LO10"; - case 69: return "R_SPARC_TLS_IE_LD"; - case 70: return "R_SPARC_TLS_IE_LDX"; - case 71: return "R_SPARC_TLS_IE_ADD"; - case 72: return "R_SPARC_TLS_LE_HIX22"; - case 73: return "R_SPARC_TLS_LE_LOX10"; - case 74: return "R_SPARC_TLS_DTPMOD32"; - case 75: return "R_SPARC_TLS_DTPMOD64"; - case 76: return "R_SPARC_TLS_DTPOFF32"; - case 77: return "R_SPARC_TLS_DTPOFF64"; - case 78: return "R_SPARC_TLS_TPOFF32"; - case 79: return "R_SPARC_TLS_TPOFF64"; - } - break; - case EM_X86_64: - switch(type) { - case 0: return "R_X86_64_NONE"; - case 1: return "R_X86_64_64"; - case 2: return "R_X86_64_PC32"; - case 3: return "R_X86_64_GOT32"; - case 4: return "R_X86_64_PLT32"; - case 5: return "R_X86_64_COPY"; - case 6: return "R_X86_64_GLOB_DAT"; - case 7: return "R_X86_64_JUMP_SLOT"; - case 8: return "R_X86_64_RELATIVE"; - case 9: return "R_X86_64_GOTPCREL"; - case 10: return "R_X86_64_32"; - case 11: return "R_X86_64_32S"; - case 12: return "R_X86_64_16"; - case 13: return "R_X86_64_PC16"; - case 14: return "R_X86_64_8"; - case 15: return "R_X86_64_PC8"; - case 16: return "R_X86_64_DTPMOD64"; - case 17: return "R_X86_64_DTPOFF64"; - case 18: return "R_X86_64_TPOFF64"; - case 19: return "R_X86_64_TLSGD"; - case 20: return "R_X86_64_TLSLD"; - case 21: return "R_X86_64_DTPOFF32"; - case 22: return "R_X86_64_GOTTPOFF"; - case 23: return "R_X86_64_TPOFF32"; - case 24: return "R_X86_64_PC64"; - case 25: return "R_X86_64_GOTOFF64"; - case 26: return "R_X86_64_GOTPC32"; - case 27: return "R_X86_64_GOT64"; - case 28: return "R_X86_64_GOTPCREL64"; - case 29: return "R_X86_64_GOTPC64"; - case 30: return "R_X86_64_GOTPLT64"; - case 31: return "R_X86_64_PLTOFF64"; - case 32: return "R_X86_64_SIZE32"; - case 33: return "R_X86_64_SIZE64"; - case 34: return "R_X86_64_GOTPC32_TLSDESC"; - case 35: return "R_X86_64_TLSDESC_CALL"; - case 36: return "R_X86_64_TLSDESC"; - case 37: return "R_X86_64_IRELATIVE"; - } - break; - } - - snprintf(s_type, sizeof(s_type), "", type); - return (s_type); -} - -static const char * note_type(const char *name, unsigned int et, unsigned int nt) { if ((strcmp(name, "CORE") == 0 || strcmp(name, "LINUX") == 0) && et == ET_CORE) return note_type_linux_core(nt); else if (strcmp(name, "FreeBSD") == 0) if (et == ET_CORE) return note_type_freebsd_core(nt); else return note_type_freebsd(nt); else if (strcmp(name, "GNU") == 0 && et != ET_CORE) return note_type_gnu(nt); else if (strcmp(name, "NetBSD") == 0 && et != ET_CORE) return note_type_netbsd(nt); else if (strcmp(name, "OpenBSD") == 0 && et != ET_CORE) return note_type_openbsd(nt); else if (strcmp(name, "Xen") == 0 && et != ET_CORE) return note_type_xen(nt); return note_type_unknown(nt); } static const char * note_type_freebsd(unsigned int nt) { switch (nt) { case 1: return "NT_FREEBSD_ABI_TAG"; case 2: return "NT_FREEBSD_NOINIT_TAG"; case 3: return "NT_FREEBSD_ARCH_TAG"; default: return (note_type_unknown(nt)); } } static const char * note_type_freebsd_core(unsigned int nt) { switch (nt) { case 1: return "NT_PRSTATUS"; case 2: return "NT_FPREGSET"; case 3: return "NT_PRPSINFO"; case 7: return "NT_THRMISC"; case 8: return "NT_PROCSTAT_PROC"; case 9: return "NT_PROCSTAT_FILES"; case 10: return "NT_PROCSTAT_VMMAP"; case 11: return "NT_PROCSTAT_GROUPS"; case 12: return "NT_PROCSTAT_UMASK"; case 13: return "NT_PROCSTAT_RLIMIT"; case 14: return "NT_PROCSTAT_OSREL"; case 15: return "NT_PROCSTAT_PSSTRINGS"; case 16: return "NT_PROCSTAT_AUXV"; case 0x202: return "NT_X86_XSTATE (x86 XSAVE extended state)"; default: return (note_type_unknown(nt)); } } static const char * note_type_linux_core(unsigned int nt) { switch (nt) { case 1: return "NT_PRSTATUS (Process status)"; case 2: return "NT_FPREGSET (Floating point information)"; case 3: return "NT_PRPSINFO (Process information)"; case 4: return "NT_TASKSTRUCT (Task structure)"; case 6: return "NT_AUXV (Auxiliary vector)"; case 10: return "NT_PSTATUS (Linux process status)"; case 12: return "NT_FPREGS (Linux floating point regset)"; case 13: return "NT_PSINFO (Linux process information)"; case 16: return "NT_LWPSTATUS (Linux lwpstatus_t type)"; case 17: return "NT_LWPSINFO (Linux lwpinfo_t type)"; case 18: return "NT_WIN32PSTATUS (win32_pstatus structure)"; case 0x100: return "NT_PPC_VMX (ppc Altivec registers)"; case 0x102: return "NT_PPC_VSX (ppc VSX registers)"; case 0x202: return "NT_X86_XSTATE (x86 XSAVE extended state)"; case 0x300: return "NT_S390_HIGH_GPRS (s390 upper register halves)"; case 0x301: return "NT_S390_TIMER (s390 timer register)"; case 0x302: return "NT_S390_TODCMP (s390 TOD comparator register)"; case 0x303: return "NT_S390_TODPREG (s390 TOD programmable register)"; case 0x304: return "NT_S390_CTRS (s390 control registers)"; case 0x305: return "NT_S390_PREFIX (s390 prefix register)"; case 0x400: return "NT_ARM_VFP (arm VFP registers)"; case 0x46494c45UL: return "NT_FILE (mapped files)"; case 0x46E62B7FUL: return "NT_PRXFPREG (Linux user_xfpregs structure)"; case 0x53494749UL: return "NT_SIGINFO (siginfo_t data)"; default: return (note_type_unknown(nt)); } } static const char * note_type_gnu(unsigned int nt) { switch (nt) { case 1: return "NT_GNU_ABI_TAG"; case 2: return "NT_GNU_HWCAP (Hardware capabilities)"; case 3: return "NT_GNU_BUILD_ID (Build id set by ld(1))"; case 4: return "NT_GNU_GOLD_VERSION (GNU gold version)"; default: return (note_type_unknown(nt)); } } static const char * note_type_netbsd(unsigned int nt) { switch (nt) { case 1: return "NT_NETBSD_IDENT"; default: return (note_type_unknown(nt)); } } static const char * note_type_openbsd(unsigned int nt) { switch (nt) { case 1: return "NT_OPENBSD_IDENT"; default: return (note_type_unknown(nt)); } } static const char * note_type_unknown(unsigned int nt) { static char s_nt[32]; snprintf(s_nt, sizeof(s_nt), nt >= 0x100 ? "" : "", nt); return (s_nt); } static const char * note_type_xen(unsigned int nt) { switch (nt) { case 0: return "XEN_ELFNOTE_INFO"; case 1: return "XEN_ELFNOTE_ENTRY"; case 2: return "XEN_ELFNOTE_HYPERCALL_PAGE"; case 3: return "XEN_ELFNOTE_VIRT_BASE"; case 4: return "XEN_ELFNOTE_PADDR_OFFSET"; case 5: return "XEN_ELFNOTE_XEN_VERSION"; case 6: return "XEN_ELFNOTE_GUEST_OS"; case 7: return "XEN_ELFNOTE_GUEST_VERSION"; case 8: return "XEN_ELFNOTE_LOADER"; case 9: return "XEN_ELFNOTE_PAE_MODE"; case 10: return "XEN_ELFNOTE_FEATURES"; case 11: return "XEN_ELFNOTE_BSD_SYMTAB"; case 12: return "XEN_ELFNOTE_HV_START_LOW"; case 13: return "XEN_ELFNOTE_L1_MFN_VALID"; case 14: return "XEN_ELFNOTE_SUSPEND_CANCEL"; case 15: return "XEN_ELFNOTE_INIT_P2M"; case 16: return "XEN_ELFNOTE_MOD_START_PFN"; case 17: return "XEN_ELFNOTE_SUPPORTED_FEATURES"; default: return (note_type_unknown(nt)); } } static struct { const char *name; int value; } l_flag[] = { {"EXACT_MATCH", LL_EXACT_MATCH}, {"IGNORE_INT_VER", LL_IGNORE_INT_VER}, {"REQUIRE_MINOR", LL_REQUIRE_MINOR}, {"EXPORTS", LL_EXPORTS}, {"DELAY_LOAD", LL_DELAY_LOAD}, {"DELTA", LL_DELTA}, {NULL, 0} }; static struct mips_option mips_exceptions_option[] = { {OEX_PAGE0, "PAGE0"}, {OEX_SMM, "SMM"}, {OEX_PRECISEFP, "PRECISEFP"}, {OEX_DISMISS, "DISMISS"}, {0, NULL} }; static struct mips_option mips_pad_option[] = { {OPAD_PREFIX, "PREFIX"}, {OPAD_POSTFIX, "POSTFIX"}, {OPAD_SYMBOL, "SYMBOL"}, {0, NULL} }; static struct mips_option mips_hwpatch_option[] = { {OHW_R4KEOP, "R4KEOP"}, {OHW_R8KPFETCH, "R8KPFETCH"}, {OHW_R5KEOP, "R5KEOP"}, {OHW_R5KCVTL, "R5KCVTL"}, {0, NULL} }; static struct mips_option mips_hwa_option[] = { {OHWA0_R4KEOP_CHECKED, "R4KEOP_CHECKED"}, {OHWA0_R4KEOP_CLEAN, "R4KEOP_CLEAN"}, {0, NULL} }; static struct mips_option mips_hwo_option[] = { {OHWO0_FIXADE, "FIXADE"}, {0, NULL} }; static const char * option_kind(uint8_t kind) { static char s_kind[32]; switch (kind) { case ODK_NULL: return "NULL"; case ODK_REGINFO: return "REGINFO"; case ODK_EXCEPTIONS: return "EXCEPTIONS"; case ODK_PAD: return "PAD"; case ODK_HWPATCH: return "HWPATCH"; case ODK_FILL: return "FILL"; case ODK_TAGS: return "TAGS"; case ODK_HWAND: return "HWAND"; case ODK_HWOR: return "HWOR"; case ODK_GP_GROUP: return "GP_GROUP"; case ODK_IDENT: return "IDENT"; default: snprintf(s_kind, sizeof(s_kind), "", kind); return (s_kind); } } static const char * top_tag(unsigned int tag) { static char s_top_tag[32]; switch (tag) { case 1: return "File Attributes"; case 2: return "Section Attributes"; case 3: return "Symbol Attributes"; default: snprintf(s_top_tag, sizeof(s_top_tag), "Unknown tag: %u", tag); return (s_top_tag); } } static const char * aeabi_cpu_arch(uint64_t arch) { static char s_cpu_arch[32]; switch (arch) { case 0: return "Pre-V4"; case 1: return "ARM v4"; case 2: return "ARM v4T"; case 3: return "ARM v5T"; case 4: return "ARM v5TE"; case 5: return "ARM v5TEJ"; case 6: return "ARM v6"; case 7: return "ARM v6KZ"; case 8: return "ARM v6T2"; case 9: return "ARM v6K"; case 10: return "ARM v7"; case 11: return "ARM v6-M"; case 12: return "ARM v6S-M"; case 13: return "ARM v7E-M"; default: snprintf(s_cpu_arch, sizeof(s_cpu_arch), "Unknown (%ju)", (uintmax_t) arch); return (s_cpu_arch); } } static const char * aeabi_cpu_arch_profile(uint64_t pf) { static char s_arch_profile[32]; switch (pf) { case 0: return "Not applicable"; case 0x41: /* 'A' */ return "Application Profile"; case 0x52: /* 'R' */ return "Real-Time Profile"; case 0x4D: /* 'M' */ return "Microcontroller Profile"; case 0x53: /* 'S' */ return "Application or Real-Time Profile"; default: snprintf(s_arch_profile, sizeof(s_arch_profile), "Unknown (%ju)\n", (uintmax_t) pf); return (s_arch_profile); } } static const char * aeabi_arm_isa(uint64_t ai) { static char s_ai[32]; switch (ai) { case 0: return "No"; case 1: return "Yes"; default: snprintf(s_ai, sizeof(s_ai), "Unknown (%ju)\n", (uintmax_t) ai); return (s_ai); } } static const char * aeabi_thumb_isa(uint64_t ti) { static char s_ti[32]; switch (ti) { case 0: return "No"; case 1: return "16-bit Thumb"; case 2: return "32-bit Thumb"; default: snprintf(s_ti, sizeof(s_ti), "Unknown (%ju)\n", (uintmax_t) ti); return (s_ti); } } static const char * aeabi_fp_arch(uint64_t fp) { static char s_fp_arch[32]; switch (fp) { case 0: return "No"; case 1: return "VFPv1"; case 2: return "VFPv2"; case 3: return "VFPv3"; case 4: return "VFPv3-D16"; case 5: return "VFPv4"; case 6: return "VFPv4-D16"; default: snprintf(s_fp_arch, sizeof(s_fp_arch), "Unknown (%ju)", (uintmax_t) fp); return (s_fp_arch); } } static const char * aeabi_wmmx_arch(uint64_t wmmx) { static char s_wmmx[32]; switch (wmmx) { case 0: return "No"; case 1: return "WMMXv1"; case 2: return "WMMXv2"; default: snprintf(s_wmmx, sizeof(s_wmmx), "Unknown (%ju)", (uintmax_t) wmmx); return (s_wmmx); } } static const char * aeabi_adv_simd_arch(uint64_t simd) { static char s_simd[32]; switch (simd) { case 0: return "No"; case 1: return "NEONv1"; case 2: return "NEONv2"; default: snprintf(s_simd, sizeof(s_simd), "Unknown (%ju)", (uintmax_t) simd); return (s_simd); } } static const char * aeabi_pcs_config(uint64_t pcs) { static char s_pcs[32]; switch (pcs) { case 0: return "None"; case 1: return "Bare platform"; case 2: return "Linux"; case 3: return "Linux DSO"; case 4: return "Palm OS 2004"; case 5: return "Palm OS (future)"; case 6: return "Symbian OS 2004"; case 7: return "Symbian OS (future)"; default: snprintf(s_pcs, sizeof(s_pcs), "Unknown (%ju)", (uintmax_t) pcs); return (s_pcs); } } static const char * aeabi_pcs_r9(uint64_t r9) { static char s_r9[32]; switch (r9) { case 0: return "V6"; case 1: return "SB"; case 2: return "TLS pointer"; case 3: return "Unused"; default: snprintf(s_r9, sizeof(s_r9), "Unknown (%ju)", (uintmax_t) r9); return (s_r9); } } static const char * aeabi_pcs_rw(uint64_t rw) { static char s_rw[32]; switch (rw) { case 0: return "Absolute"; case 1: return "PC-relative"; case 2: return "SB-relative"; case 3: return "None"; default: snprintf(s_rw, sizeof(s_rw), "Unknown (%ju)", (uintmax_t) rw); return (s_rw); } } static const char * aeabi_pcs_ro(uint64_t ro) { static char s_ro[32]; switch (ro) { case 0: return "Absolute"; case 1: return "PC-relative"; case 2: return "None"; default: snprintf(s_ro, sizeof(s_ro), "Unknown (%ju)", (uintmax_t) ro); return (s_ro); } } static const char * aeabi_pcs_got(uint64_t got) { static char s_got[32]; switch (got) { case 0: return "None"; case 1: return "direct"; case 2: return "indirect via GOT"; default: snprintf(s_got, sizeof(s_got), "Unknown (%ju)", (uintmax_t) got); return (s_got); } } static const char * aeabi_pcs_wchar_t(uint64_t wt) { static char s_wt[32]; switch (wt) { case 0: return "None"; case 2: return "wchar_t size 2"; case 4: return "wchar_t size 4"; default: snprintf(s_wt, sizeof(s_wt), "Unknown (%ju)", (uintmax_t) wt); return (s_wt); } } static const char * aeabi_enum_size(uint64_t es) { static char s_es[32]; switch (es) { case 0: return "None"; case 1: return "smallest"; case 2: return "32-bit"; case 3: return "visible 32-bit"; default: snprintf(s_es, sizeof(s_es), "Unknown (%ju)", (uintmax_t) es); return (s_es); } } static const char * aeabi_align_needed(uint64_t an) { static char s_align_n[64]; switch (an) { case 0: return "No"; case 1: return "8-byte align"; case 2: return "4-byte align"; case 3: return "Reserved"; default: if (an >= 4 && an <= 12) snprintf(s_align_n, sizeof(s_align_n), "8-byte align" " and up to 2^%ju-byte extended align", (uintmax_t) an); else snprintf(s_align_n, sizeof(s_align_n), "Unknown (%ju)", (uintmax_t) an); return (s_align_n); } } static const char * aeabi_align_preserved(uint64_t ap) { static char s_align_p[128]; switch (ap) { case 0: return "No"; case 1: return "8-byte align"; case 2: return "8-byte align and SP % 8 == 0"; case 3: return "Reserved"; default: if (ap >= 4 && ap <= 12) snprintf(s_align_p, sizeof(s_align_p), "8-byte align" " and SP %% 8 == 0 and up to 2^%ju-byte extended" " align", (uintmax_t) ap); else snprintf(s_align_p, sizeof(s_align_p), "Unknown (%ju)", (uintmax_t) ap); return (s_align_p); } } static const char * aeabi_fp_rounding(uint64_t fr) { static char s_fp_r[32]; switch (fr) { case 0: return "Unused"; case 1: return "Needed"; default: snprintf(s_fp_r, sizeof(s_fp_r), "Unknown (%ju)", (uintmax_t) fr); return (s_fp_r); } } static const char * aeabi_fp_denormal(uint64_t fd) { static char s_fp_d[32]; switch (fd) { case 0: return "Unused"; case 1: return "Needed"; case 2: return "Sign Only"; default: snprintf(s_fp_d, sizeof(s_fp_d), "Unknown (%ju)", (uintmax_t) fd); return (s_fp_d); } } static const char * aeabi_fp_exceptions(uint64_t fe) { static char s_fp_e[32]; switch (fe) { case 0: return "Unused"; case 1: return "Needed"; default: snprintf(s_fp_e, sizeof(s_fp_e), "Unknown (%ju)", (uintmax_t) fe); return (s_fp_e); } } static const char * aeabi_fp_user_exceptions(uint64_t fu) { static char s_fp_u[32]; switch (fu) { case 0: return "Unused"; case 1: return "Needed"; default: snprintf(s_fp_u, sizeof(s_fp_u), "Unknown (%ju)", (uintmax_t) fu); return (s_fp_u); } } static const char * aeabi_fp_number_model(uint64_t fn) { static char s_fp_n[32]; switch (fn) { case 0: return "Unused"; case 1: return "IEEE 754 normal"; case 2: return "RTABI"; case 3: return "IEEE 754"; default: snprintf(s_fp_n, sizeof(s_fp_n), "Unknown (%ju)", (uintmax_t) fn); return (s_fp_n); } } static const char * aeabi_fp_16bit_format(uint64_t fp16) { static char s_fp_16[64]; switch (fp16) { case 0: return "None"; case 1: return "IEEE 754"; case 2: return "VFPv3/Advanced SIMD (alternative format)"; default: snprintf(s_fp_16, sizeof(s_fp_16), "Unknown (%ju)", (uintmax_t) fp16); return (s_fp_16); } } static const char * aeabi_mpext(uint64_t mp) { static char s_mp[32]; switch (mp) { case 0: return "Not allowed"; case 1: return "Allowed"; default: snprintf(s_mp, sizeof(s_mp), "Unknown (%ju)", (uintmax_t) mp); return (s_mp); } } static const char * aeabi_div(uint64_t du) { static char s_du[32]; switch (du) { case 0: return "Yes (V7-R/V7-M)"; case 1: return "No"; case 2: return "Yes (V7-A)"; default: snprintf(s_du, sizeof(s_du), "Unknown (%ju)", (uintmax_t) du); return (s_du); } } static const char * aeabi_t2ee(uint64_t t2ee) { static char s_t2ee[32]; switch (t2ee) { case 0: return "Not allowed"; case 1: return "Allowed"; default: snprintf(s_t2ee, sizeof(s_t2ee), "Unknown(%ju)", (uintmax_t) t2ee); return (s_t2ee); } } static const char * aeabi_hardfp(uint64_t hfp) { static char s_hfp[32]; switch (hfp) { case 0: return "Tag_FP_arch"; case 1: return "only SP"; case 2: return "only DP"; case 3: return "both SP and DP"; default: snprintf(s_hfp, sizeof(s_hfp), "Unknown (%ju)", (uintmax_t) hfp); return (s_hfp); } } static const char * aeabi_vfp_args(uint64_t va) { static char s_va[32]; switch (va) { case 0: return "AAPCS (base variant)"; case 1: return "AAPCS (VFP variant)"; case 2: return "toolchain-specific"; default: snprintf(s_va, sizeof(s_va), "Unknown (%ju)", (uintmax_t) va); return (s_va); } } static const char * aeabi_wmmx_args(uint64_t wa) { static char s_wa[32]; switch (wa) { case 0: return "AAPCS (base variant)"; case 1: return "Intel WMMX"; case 2: return "toolchain-specific"; default: snprintf(s_wa, sizeof(s_wa), "Unknown(%ju)", (uintmax_t) wa); return (s_wa); } } static const char * aeabi_unaligned_access(uint64_t ua) { static char s_ua[32]; switch (ua) { case 0: return "Not allowed"; case 1: return "Allowed"; default: snprintf(s_ua, sizeof(s_ua), "Unknown(%ju)", (uintmax_t) ua); return (s_ua); } } static const char * aeabi_fp_hpext(uint64_t fh) { static char s_fh[32]; switch (fh) { case 0: return "Not allowed"; case 1: return "Allowed"; default: snprintf(s_fh, sizeof(s_fh), "Unknown(%ju)", (uintmax_t) fh); return (s_fh); } } static const char * aeabi_optm_goal(uint64_t og) { static char s_og[32]; switch (og) { case 0: return "None"; case 1: return "Speed"; case 2: return "Speed aggressive"; case 3: return "Space"; case 4: return "Space aggressive"; case 5: return "Debugging"; case 6: return "Best Debugging"; default: snprintf(s_og, sizeof(s_og), "Unknown(%ju)", (uintmax_t) og); return (s_og); } } static const char * aeabi_fp_optm_goal(uint64_t fog) { static char s_fog[32]; switch (fog) { case 0: return "None"; case 1: return "Speed"; case 2: return "Speed aggressive"; case 3: return "Space"; case 4: return "Space aggressive"; case 5: return "Accurary"; case 6: return "Best Accurary"; default: snprintf(s_fog, sizeof(s_fog), "Unknown(%ju)", (uintmax_t) fog); return (s_fog); } } static const char * aeabi_virtual(uint64_t vt) { static char s_virtual[64]; switch (vt) { case 0: return "No"; case 1: return "TrustZone"; case 2: return "Virtualization extension"; case 3: return "TrustZone and virtualization extension"; default: snprintf(s_virtual, sizeof(s_virtual), "Unknown(%ju)", (uintmax_t) vt); return (s_virtual); } } static struct { uint64_t tag; const char *s_tag; const char *(*get_desc)(uint64_t val); } aeabi_tags[] = { {4, "Tag_CPU_raw_name", NULL}, {5, "Tag_CPU_name", NULL}, {6, "Tag_CPU_arch", aeabi_cpu_arch}, {7, "Tag_CPU_arch_profile", aeabi_cpu_arch_profile}, {8, "Tag_ARM_ISA_use", aeabi_arm_isa}, {9, "Tag_THUMB_ISA_use", aeabi_thumb_isa}, {10, "Tag_FP_arch", aeabi_fp_arch}, {11, "Tag_WMMX_arch", aeabi_wmmx_arch}, {12, "Tag_Advanced_SIMD_arch", aeabi_adv_simd_arch}, {13, "Tag_PCS_config", aeabi_pcs_config}, {14, "Tag_ABI_PCS_R9_use", aeabi_pcs_r9}, {15, "Tag_ABI_PCS_RW_data", aeabi_pcs_rw}, {16, "Tag_ABI_PCS_RO_data", aeabi_pcs_ro}, {17, "Tag_ABI_PCS_GOT_use", aeabi_pcs_got}, {18, "Tag_ABI_PCS_wchar_t", aeabi_pcs_wchar_t}, {19, "Tag_ABI_FP_rounding", aeabi_fp_rounding}, {20, "Tag_ABI_FP_denormal", aeabi_fp_denormal}, {21, "Tag_ABI_FP_exceptions", aeabi_fp_exceptions}, {22, "Tag_ABI_FP_user_exceptions", aeabi_fp_user_exceptions}, {23, "Tag_ABI_FP_number_model", aeabi_fp_number_model}, {24, "Tag_ABI_align_needed", aeabi_align_needed}, {25, "Tag_ABI_align_preserved", aeabi_align_preserved}, {26, "Tag_ABI_enum_size", aeabi_enum_size}, {27, "Tag_ABI_HardFP_use", aeabi_hardfp}, {28, "Tag_ABI_VFP_args", aeabi_vfp_args}, {29, "Tag_ABI_WMMX_args", aeabi_wmmx_args}, {30, "Tag_ABI_optimization_goals", aeabi_optm_goal}, {31, "Tag_ABI_FP_optimization_goals", aeabi_fp_optm_goal}, {32, "Tag_compatibility", NULL}, {34, "Tag_CPU_unaligned_access", aeabi_unaligned_access}, {36, "Tag_FP_HP_extension", aeabi_fp_hpext}, {38, "Tag_ABI_FP_16bit_format", aeabi_fp_16bit_format}, {42, "Tag_MPextension_use", aeabi_mpext}, {44, "Tag_DIV_use", aeabi_div}, {64, "Tag_nodefaults", NULL}, {65, "Tag_also_compatible_with", NULL}, {66, "Tag_T2EE_use", aeabi_t2ee}, {67, "Tag_conformance", NULL}, {68, "Tag_Virtualization_use", aeabi_virtual}, {70, "Tag_MPextension_use", aeabi_mpext}, }; static const char * mips_abi_fp(uint64_t fp) { static char s_mips_abi_fp[64]; switch (fp) { case 0: return "N/A"; case 1: return "Hard float (double precision)"; case 2: return "Hard float (single precision)"; case 3: return "Soft float"; case 4: return "64-bit float (-mips32r2 -mfp64)"; default: snprintf(s_mips_abi_fp, sizeof(s_mips_abi_fp), "Unknown(%ju)", (uintmax_t) fp); return (s_mips_abi_fp); } } static const char * ppc_abi_fp(uint64_t fp) { static char s_ppc_abi_fp[64]; switch (fp) { case 0: return "N/A"; case 1: return "Hard float (double precision)"; case 2: return "Soft float"; case 3: return "Hard float (single precision)"; default: snprintf(s_ppc_abi_fp, sizeof(s_ppc_abi_fp), "Unknown(%ju)", (uintmax_t) fp); return (s_ppc_abi_fp); } } static const char * ppc_abi_vector(uint64_t vec) { static char s_vec[64]; switch (vec) { case 0: return "N/A"; case 1: return "Generic purpose registers"; case 2: return "AltiVec registers"; case 3: return "SPE registers"; default: snprintf(s_vec, sizeof(s_vec), "Unknown(%ju)", (uintmax_t) vec); return (s_vec); } } static const char * dwarf_reg(unsigned int mach, unsigned int reg) { switch (mach) { case EM_386: case EM_IAMCU: switch (reg) { case 0: return "eax"; case 1: return "ecx"; case 2: return "edx"; case 3: return "ebx"; case 4: return "esp"; case 5: return "ebp"; case 6: return "esi"; case 7: return "edi"; case 8: return "eip"; case 9: return "eflags"; case 11: return "st0"; case 12: return "st1"; case 13: return "st2"; case 14: return "st3"; case 15: return "st4"; case 16: return "st5"; case 17: return "st6"; case 18: return "st7"; case 21: return "xmm0"; case 22: return "xmm1"; case 23: return "xmm2"; case 24: return "xmm3"; case 25: return "xmm4"; case 26: return "xmm5"; case 27: return "xmm6"; case 28: return "xmm7"; case 29: return "mm0"; case 30: return "mm1"; case 31: return "mm2"; case 32: return "mm3"; case 33: return "mm4"; case 34: return "mm5"; case 35: return "mm6"; case 36: return "mm7"; case 37: return "fcw"; case 38: return "fsw"; case 39: return "mxcsr"; case 40: return "es"; case 41: return "cs"; case 42: return "ss"; case 43: return "ds"; case 44: return "fs"; case 45: return "gs"; case 48: return "tr"; case 49: return "ldtr"; default: return (NULL); } case EM_X86_64: switch (reg) { case 0: return "rax"; case 1: return "rdx"; case 2: return "rcx"; case 3: return "rbx"; case 4: return "rsi"; case 5: return "rdi"; case 6: return "rbp"; case 7: return "rsp"; case 16: return "rip"; case 17: return "xmm0"; case 18: return "xmm1"; case 19: return "xmm2"; case 20: return "xmm3"; case 21: return "xmm4"; case 22: return "xmm5"; case 23: return "xmm6"; case 24: return "xmm7"; case 25: return "xmm8"; case 26: return "xmm9"; case 27: return "xmm10"; case 28: return "xmm11"; case 29: return "xmm12"; case 30: return "xmm13"; case 31: return "xmm14"; case 32: return "xmm15"; case 33: return "st0"; case 34: return "st1"; case 35: return "st2"; case 36: return "st3"; case 37: return "st4"; case 38: return "st5"; case 39: return "st6"; case 40: return "st7"; case 41: return "mm0"; case 42: return "mm1"; case 43: return "mm2"; case 44: return "mm3"; case 45: return "mm4"; case 46: return "mm5"; case 47: return "mm6"; case 48: return "mm7"; case 49: return "rflags"; case 50: return "es"; case 51: return "cs"; case 52: return "ss"; case 53: return "ds"; case 54: return "fs"; case 55: return "gs"; case 58: return "fs.base"; case 59: return "gs.base"; case 62: return "tr"; case 63: return "ldtr"; case 64: return "mxcsr"; case 65: return "fcw"; case 66: return "fsw"; default: return (NULL); } default: return (NULL); } } static void dump_ehdr(struct readelf *re) { size_t shnum, shstrndx; int i; printf("ELF Header:\n"); /* e_ident[]. */ printf(" Magic: "); for (i = 0; i < EI_NIDENT; i++) printf("%.2x ", re->ehdr.e_ident[i]); putchar('\n'); /* EI_CLASS. */ printf("%-37s%s\n", " Class:", elf_class(re->ehdr.e_ident[EI_CLASS])); /* EI_DATA. */ printf("%-37s%s\n", " Data:", elf_endian(re->ehdr.e_ident[EI_DATA])); /* EI_VERSION. */ printf("%-37s%d %s\n", " Version:", re->ehdr.e_ident[EI_VERSION], elf_ver(re->ehdr.e_ident[EI_VERSION])); /* EI_OSABI. */ printf("%-37s%s\n", " OS/ABI:", elf_osabi(re->ehdr.e_ident[EI_OSABI])); /* EI_ABIVERSION. */ printf("%-37s%d\n", " ABI Version:", re->ehdr.e_ident[EI_ABIVERSION]); /* e_type. */ printf("%-37s%s\n", " Type:", elf_type(re->ehdr.e_type)); /* e_machine. */ printf("%-37s%s\n", " Machine:", elf_machine(re->ehdr.e_machine)); /* e_version. */ printf("%-37s%#x\n", " Version:", re->ehdr.e_version); /* e_entry. */ printf("%-37s%#jx\n", " Entry point address:", (uintmax_t)re->ehdr.e_entry); /* e_phoff. */ printf("%-37s%ju (bytes into file)\n", " Start of program headers:", (uintmax_t)re->ehdr.e_phoff); /* e_shoff. */ printf("%-37s%ju (bytes into file)\n", " Start of section headers:", (uintmax_t)re->ehdr.e_shoff); /* e_flags. */ printf("%-37s%#x", " Flags:", re->ehdr.e_flags); dump_eflags(re, re->ehdr.e_flags); putchar('\n'); /* e_ehsize. */ printf("%-37s%u (bytes)\n", " Size of this header:", re->ehdr.e_ehsize); /* e_phentsize. */ printf("%-37s%u (bytes)\n", " Size of program headers:", re->ehdr.e_phentsize); /* e_phnum. */ printf("%-37s%u\n", " Number of program headers:", re->ehdr.e_phnum); /* e_shentsize. */ printf("%-37s%u (bytes)\n", " Size of section headers:", re->ehdr.e_shentsize); /* e_shnum. */ printf("%-37s%u", " Number of section headers:", re->ehdr.e_shnum); if (re->ehdr.e_shnum == SHN_UNDEF) { /* Extended section numbering is in use. */ if (elf_getshnum(re->elf, &shnum)) printf(" (%ju)", (uintmax_t)shnum); } putchar('\n'); /* e_shstrndx. */ printf("%-37s%u", " Section header string table index:", re->ehdr.e_shstrndx); if (re->ehdr.e_shstrndx == SHN_XINDEX) { /* Extended section numbering is in use. */ if (elf_getshstrndx(re->elf, &shstrndx)) printf(" (%ju)", (uintmax_t)shstrndx); } putchar('\n'); } static void dump_eflags(struct readelf *re, uint64_t e_flags) { struct eflags_desc *edesc; int arm_eabi; edesc = NULL; switch (re->ehdr.e_machine) { case EM_ARM: arm_eabi = (e_flags & EF_ARM_EABIMASK) >> 24; if (arm_eabi == 0) printf(", GNU EABI"); else if (arm_eabi <= 5) printf(", Version%d EABI", arm_eabi); edesc = arm_eflags_desc; break; case EM_MIPS: case EM_MIPS_RS3_LE: switch ((e_flags & EF_MIPS_ARCH) >> 28) { case 0: printf(", mips1"); break; case 1: printf(", mips2"); break; case 2: printf(", mips3"); break; case 3: printf(", mips4"); break; case 4: printf(", mips5"); break; case 5: printf(", mips32"); break; case 6: printf(", mips64"); break; case 7: printf(", mips32r2"); break; case 8: printf(", mips64r2"); break; default: break; } switch ((e_flags & 0x00FF0000) >> 16) { case 0x81: printf(", 3900"); break; case 0x82: printf(", 4010"); break; case 0x83: printf(", 4100"); break; case 0x85: printf(", 4650"); break; case 0x87: printf(", 4120"); break; case 0x88: printf(", 4111"); break; case 0x8a: printf(", sb1"); break; case 0x8b: printf(", octeon"); break; case 0x8c: printf(", xlr"); break; case 0x91: printf(", 5400"); break; case 0x98: printf(", 5500"); break; case 0x99: printf(", 9000"); break; case 0xa0: printf(", loongson-2e"); break; case 0xa1: printf(", loongson-2f"); break; default: break; } switch ((e_flags & 0x0000F000) >> 12) { case 1: printf(", o32"); break; case 2: printf(", o64"); break; case 3: printf(", eabi32"); break; case 4: printf(", eabi64"); break; default: break; } edesc = mips_eflags_desc; break; case EM_PPC: case EM_PPC64: edesc = powerpc_eflags_desc; break; case EM_SPARC: case EM_SPARC32PLUS: case EM_SPARCV9: switch ((e_flags & EF_SPARCV9_MM)) { case EF_SPARCV9_TSO: printf(", tso"); break; case EF_SPARCV9_PSO: printf(", pso"); break; case EF_SPARCV9_MM: printf(", rmo"); break; default: break; } edesc = sparc_eflags_desc; break; default: break; } if (edesc != NULL) { while (edesc->desc != NULL) { if (e_flags & edesc->flag) printf(", %s", edesc->desc); edesc++; } } } static void dump_phdr(struct readelf *re) { const char *rawfile; GElf_Phdr phdr; size_t phnum, size; int i, j; #define PH_HDR "Type", "Offset", "VirtAddr", "PhysAddr", "FileSiz", \ "MemSiz", "Flg", "Align" #define PH_CT phdr_type(phdr.p_type), (uintmax_t)phdr.p_offset, \ (uintmax_t)phdr.p_vaddr, (uintmax_t)phdr.p_paddr, \ (uintmax_t)phdr.p_filesz, (uintmax_t)phdr.p_memsz, \ phdr.p_flags & PF_R ? 'R' : ' ', \ phdr.p_flags & PF_W ? 'W' : ' ', \ phdr.p_flags & PF_X ? 'E' : ' ', \ (uintmax_t)phdr.p_align if (elf_getphnum(re->elf, &phnum) == 0) { warnx("elf_getphnum failed: %s", elf_errmsg(-1)); return; } if (phnum == 0) { printf("\nThere are no program headers in this file.\n"); return; } printf("\nElf file type is %s", elf_type(re->ehdr.e_type)); printf("\nEntry point 0x%jx\n", (uintmax_t)re->ehdr.e_entry); printf("There are %ju program headers, starting at offset %ju\n", (uintmax_t)phnum, (uintmax_t)re->ehdr.e_phoff); /* Dump program headers. */ printf("\nProgram Headers:\n"); if (re->ec == ELFCLASS32) printf(" %-15s%-9s%-11s%-11s%-8s%-8s%-4s%s\n", PH_HDR); else if (re->options & RE_WW) printf(" %-15s%-9s%-19s%-19s%-9s%-9s%-4s%s\n", PH_HDR); else printf(" %-15s%-19s%-19s%s\n %-19s%-20s" "%-7s%s\n", PH_HDR); for (i = 0; (size_t) i < phnum; i++) { if (gelf_getphdr(re->elf, i, &phdr) != &phdr) { warnx("gelf_getphdr failed: %s", elf_errmsg(-1)); continue; } /* TODO: Add arch-specific segment type dump. */ if (re->ec == ELFCLASS32) printf(" %-14.14s 0x%6.6jx 0x%8.8jx 0x%8.8jx " "0x%5.5jx 0x%5.5jx %c%c%c %#jx\n", PH_CT); else if (re->options & RE_WW) printf(" %-14.14s 0x%6.6jx 0x%16.16jx 0x%16.16jx " "0x%6.6jx 0x%6.6jx %c%c%c %#jx\n", PH_CT); else printf(" %-14.14s 0x%16.16jx 0x%16.16jx 0x%16.16jx\n" " 0x%16.16jx 0x%16.16jx %c%c%c" " %#jx\n", PH_CT); if (phdr.p_type == PT_INTERP) { if ((rawfile = elf_rawfile(re->elf, &size)) == NULL) { warnx("elf_rawfile failed: %s", elf_errmsg(-1)); continue; } if (phdr.p_offset >= size) { warnx("invalid program header offset"); continue; } printf(" [Requesting program interpreter: %s]\n", rawfile + phdr.p_offset); } } /* Dump section to segment mapping. */ if (re->shnum == 0) return; printf("\n Section to Segment mapping:\n"); printf(" Segment Sections...\n"); for (i = 0; (size_t)i < phnum; i++) { if (gelf_getphdr(re->elf, i, &phdr) != &phdr) { warnx("gelf_getphdr failed: %s", elf_errmsg(-1)); continue; } printf(" %2.2d ", i); /* skip NULL section. */ for (j = 1; (size_t)j < re->shnum; j++) if (re->sl[j].addr >= phdr.p_vaddr && re->sl[j].addr + re->sl[j].sz <= phdr.p_vaddr + phdr.p_memsz) printf("%s ", re->sl[j].name); printf("\n"); } #undef PH_HDR #undef PH_CT } static char * section_flags(struct readelf *re, struct section *s) { #define BUF_SZ 256 static char buf[BUF_SZ]; int i, p, nb; p = 0; nb = re->ec == ELFCLASS32 ? 8 : 16; if (re->options & RE_T) { snprintf(buf, BUF_SZ, "[%*.*jx]: ", nb, nb, (uintmax_t)s->flags); p += nb + 4; } for (i = 0; section_flag[i].ln != NULL; i++) { if ((s->flags & section_flag[i].value) == 0) continue; if (re->options & RE_T) { snprintf(&buf[p], BUF_SZ - p, "%s, ", section_flag[i].ln); p += strlen(section_flag[i].ln) + 2; } else buf[p++] = section_flag[i].sn; } if (re->options & RE_T && p > nb + 4) p -= 2; buf[p] = '\0'; return (buf); } static void dump_shdr(struct readelf *re) { struct section *s; int i; #define S_HDR "[Nr] Name", "Type", "Addr", "Off", "Size", "ES", \ "Flg", "Lk", "Inf", "Al" #define S_HDRL "[Nr] Name", "Type", "Address", "Offset", "Size", \ "EntSize", "Flags", "Link", "Info", "Align" #define ST_HDR "[Nr] Name", "Type", "Addr", "Off", "Size", "ES", \ "Lk", "Inf", "Al", "Flags" #define ST_HDRL "[Nr] Name", "Type", "Address", "Offset", "Link", \ "Size", "EntSize", "Info", "Align", "Flags" #define S_CT i, s->name, section_type(re->ehdr.e_machine, s->type), \ (uintmax_t)s->addr, (uintmax_t)s->off, (uintmax_t)s->sz,\ (uintmax_t)s->entsize, section_flags(re, s), \ s->link, s->info, (uintmax_t)s->align #define ST_CT i, s->name, section_type(re->ehdr.e_machine, s->type), \ (uintmax_t)s->addr, (uintmax_t)s->off, (uintmax_t)s->sz,\ (uintmax_t)s->entsize, s->link, s->info, \ (uintmax_t)s->align, section_flags(re, s) #define ST_CTL i, s->name, section_type(re->ehdr.e_machine, s->type), \ (uintmax_t)s->addr, (uintmax_t)s->off, s->link, \ (uintmax_t)s->sz, (uintmax_t)s->entsize, s->info, \ (uintmax_t)s->align, section_flags(re, s) if (re->shnum == 0) { printf("\nThere are no sections in this file.\n"); return; } printf("There are %ju section headers, starting at offset 0x%jx:\n", (uintmax_t)re->shnum, (uintmax_t)re->ehdr.e_shoff); printf("\nSection Headers:\n"); if (re->ec == ELFCLASS32) { if (re->options & RE_T) printf(" %s\n %-16s%-9s%-7s%-7s%-5s%-3s%-4s%s\n" "%12s\n", ST_HDR); else printf(" %-23s%-16s%-9s%-7s%-7s%-3s%-4s%-3s%-4s%s\n", S_HDR); } else if (re->options & RE_WW) { if (re->options & RE_T) printf(" %s\n %-16s%-17s%-7s%-7s%-5s%-3s%-4s%s\n" "%12s\n", ST_HDR); else printf(" %-23s%-16s%-17s%-7s%-7s%-3s%-4s%-3s%-4s%s\n", S_HDR); } else { if (re->options & RE_T) printf(" %s\n %-18s%-17s%-18s%s\n %-18s" "%-17s%-18s%s\n%12s\n", ST_HDRL); else printf(" %-23s%-17s%-18s%s\n %-18s%-17s%-7s%" "-6s%-6s%s\n", S_HDRL); } for (i = 0; (size_t)i < re->shnum; i++) { s = &re->sl[i]; if (re->ec == ELFCLASS32) { if (re->options & RE_T) printf(" [%2d] %s\n %-15.15s %8.8jx" " %6.6jx %6.6jx %2.2jx %2u %3u %2ju\n" " %s\n", ST_CT); else printf(" [%2d] %-17.17s %-15.15s %8.8jx" " %6.6jx %6.6jx %2.2jx %3s %2u %3u %2ju\n", S_CT); } else if (re->options & RE_WW) { if (re->options & RE_T) printf(" [%2d] %s\n %-15.15s %16.16jx" " %6.6jx %6.6jx %2.2jx %2u %3u %2ju\n" " %s\n", ST_CT); else printf(" [%2d] %-17.17s %-15.15s %16.16jx" " %6.6jx %6.6jx %2.2jx %3s %2u %3u %2ju\n", S_CT); } else { if (re->options & RE_T) printf(" [%2d] %s\n %-15.15s %16.16jx" " %16.16jx %u\n %16.16jx %16.16jx" " %-16u %ju\n %s\n", ST_CTL); else printf(" [%2d] %-17.17s %-15.15s %16.16jx" " %8.8jx\n %16.16jx %16.16jx " "%3s %2u %3u %ju\n", S_CT); } } if ((re->options & RE_T) == 0) printf("Key to Flags:\n W (write), A (alloc)," " X (execute), M (merge), S (strings)\n" " I (info), L (link order), G (group), x (unknown)\n" " O (extra OS processing required)" " o (OS specific), p (processor specific)\n"); #undef S_HDR #undef S_HDRL #undef ST_HDR #undef ST_HDRL #undef S_CT #undef ST_CT #undef ST_CTL } /* * Return number of entries in the given section. We'd prefer ent_count be a * size_t *, but libelf APIs already use int for section indices. */ static int get_ent_count(struct section *s, int *ent_count) { if (s->entsize == 0) { warnx("section %s has entry size 0", s->name); return (0); } else if (s->sz / s->entsize > INT_MAX) { warnx("section %s has invalid section count", s->name); return (0); } *ent_count = (int)(s->sz / s->entsize); return (1); } static void dump_dynamic(struct readelf *re) { GElf_Dyn dyn; Elf_Data *d; struct section *s; int elferr, i, is_dynamic, j, jmax, nentries; is_dynamic = 0; for (i = 0; (size_t)i < re->shnum; i++) { s = &re->sl[i]; if (s->type != SHT_DYNAMIC) continue; (void) elf_errno(); if ((d = elf_getdata(s->scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("elf_getdata failed: %s", elf_errmsg(-1)); continue; } if (d->d_size <= 0) continue; is_dynamic = 1; /* Determine the actual number of table entries. */ nentries = 0; if (!get_ent_count(s, &jmax)) continue; for (j = 0; j < jmax; j++) { if (gelf_getdyn(d, j, &dyn) != &dyn) { warnx("gelf_getdyn failed: %s", elf_errmsg(-1)); continue; } nentries ++; if (dyn.d_tag == DT_NULL) break; } printf("\nDynamic section at offset 0x%jx", (uintmax_t)s->off); printf(" contains %u entries:\n", nentries); if (re->ec == ELFCLASS32) printf("%5s%12s%28s\n", "Tag", "Type", "Name/Value"); else printf("%5s%20s%28s\n", "Tag", "Type", "Name/Value"); for (j = 0; j < nentries; j++) { if (gelf_getdyn(d, j, &dyn) != &dyn) continue; /* Dump dynamic entry type. */ if (re->ec == ELFCLASS32) printf(" 0x%8.8jx", (uintmax_t)dyn.d_tag); else printf(" 0x%16.16jx", (uintmax_t)dyn.d_tag); printf(" %-20s", dt_type(re->ehdr.e_machine, dyn.d_tag)); /* Dump dynamic entry value. */ dump_dyn_val(re, &dyn, s->link); } } if (!is_dynamic) printf("\nThere is no dynamic section in this file.\n"); } static char * timestamp(time_t ti) { static char ts[32]; struct tm *t; t = gmtime(&ti); snprintf(ts, sizeof(ts), "%04d-%02d-%02dT%02d:%02d:%02d", t->tm_year + 1900, t->tm_mon + 1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec); return (ts); } static const char * dyn_str(struct readelf *re, uint32_t stab, uint64_t d_val) { const char *name; if (stab == SHN_UNDEF) name = "ERROR"; else if ((name = elf_strptr(re->elf, stab, d_val)) == NULL) { (void) elf_errno(); /* clear error */ name = "ERROR"; } return (name); } static void dump_arch_dyn_val(struct readelf *re, GElf_Dyn *dyn, uint32_t stab) { const char *name; switch (re->ehdr.e_machine) { case EM_MIPS: case EM_MIPS_RS3_LE: switch (dyn->d_tag) { case DT_MIPS_RLD_VERSION: case DT_MIPS_LOCAL_GOTNO: case DT_MIPS_CONFLICTNO: case DT_MIPS_LIBLISTNO: case DT_MIPS_SYMTABNO: case DT_MIPS_UNREFEXTNO: case DT_MIPS_GOTSYM: case DT_MIPS_HIPAGENO: case DT_MIPS_DELTA_CLASS_NO: case DT_MIPS_DELTA_INSTANCE_NO: case DT_MIPS_DELTA_RELOC_NO: case DT_MIPS_DELTA_SYM_NO: case DT_MIPS_DELTA_CLASSSYM_NO: case DT_MIPS_LOCALPAGE_GOTIDX: case DT_MIPS_LOCAL_GOTIDX: case DT_MIPS_HIDDEN_GOTIDX: case DT_MIPS_PROTECTED_GOTIDX: printf(" %ju\n", (uintmax_t) dyn->d_un.d_val); break; case DT_MIPS_ICHECKSUM: case DT_MIPS_FLAGS: case DT_MIPS_BASE_ADDRESS: case DT_MIPS_CONFLICT: case DT_MIPS_LIBLIST: case DT_MIPS_RLD_MAP: case DT_MIPS_DELTA_CLASS: case DT_MIPS_DELTA_INSTANCE: case DT_MIPS_DELTA_RELOC: case DT_MIPS_DELTA_SYM: case DT_MIPS_DELTA_CLASSSYM: case DT_MIPS_CXX_FLAGS: case DT_MIPS_PIXIE_INIT: case DT_MIPS_SYMBOL_LIB: case DT_MIPS_OPTIONS: case DT_MIPS_INTERFACE: case DT_MIPS_DYNSTR_ALIGN: case DT_MIPS_INTERFACE_SIZE: case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: case DT_MIPS_COMPACT_SIZE: case DT_MIPS_GP_VALUE: case DT_MIPS_AUX_DYNAMIC: case DT_MIPS_PLTGOT: case DT_MIPS_RLD_OBJ_UPDATE: case DT_MIPS_RWPLT: printf(" 0x%jx\n", (uintmax_t) dyn->d_un.d_val); break; case DT_MIPS_IVERSION: case DT_MIPS_PERF_SUFFIX: case DT_AUXILIARY: case DT_FILTER: name = dyn_str(re, stab, dyn->d_un.d_val); printf(" %s\n", name); break; case DT_MIPS_TIME_STAMP: printf(" %s\n", timestamp(dyn->d_un.d_val)); break; } break; default: printf("\n"); break; } } static void dump_dyn_val(struct readelf *re, GElf_Dyn *dyn, uint32_t stab) { const char *name; if (dyn->d_tag >= DT_LOPROC && dyn->d_tag <= DT_HIPROC) { dump_arch_dyn_val(re, dyn, stab); return; } /* These entry values are index into the string table. */ name = NULL; if (dyn->d_tag == DT_NEEDED || dyn->d_tag == DT_SONAME || dyn->d_tag == DT_RPATH || dyn->d_tag == DT_RUNPATH) name = dyn_str(re, stab, dyn->d_un.d_val); switch(dyn->d_tag) { case DT_NULL: case DT_PLTGOT: case DT_HASH: case DT_STRTAB: case DT_SYMTAB: case DT_RELA: case DT_INIT: case DT_SYMBOLIC: case DT_REL: case DT_DEBUG: case DT_TEXTREL: case DT_JMPREL: case DT_FINI: case DT_VERDEF: case DT_VERNEED: case DT_VERSYM: case DT_GNU_HASH: case DT_GNU_LIBLIST: case DT_GNU_CONFLICT: printf(" 0x%jx\n", (uintmax_t) dyn->d_un.d_val); break; case DT_PLTRELSZ: case DT_RELASZ: case DT_RELAENT: case DT_STRSZ: case DT_SYMENT: case DT_RELSZ: case DT_RELENT: case DT_INIT_ARRAYSZ: case DT_FINI_ARRAYSZ: case DT_GNU_CONFLICTSZ: case DT_GNU_LIBLISTSZ: printf(" %ju (bytes)\n", (uintmax_t) dyn->d_un.d_val); break; case DT_RELACOUNT: case DT_RELCOUNT: case DT_VERDEFNUM: case DT_VERNEEDNUM: printf(" %ju\n", (uintmax_t) dyn->d_un.d_val); break; case DT_NEEDED: printf(" Shared library: [%s]\n", name); break; case DT_SONAME: printf(" Library soname: [%s]\n", name); break; case DT_RPATH: printf(" Library rpath: [%s]\n", name); break; case DT_RUNPATH: printf(" Library runpath: [%s]\n", name); break; case DT_PLTREL: printf(" %s\n", dt_type(re->ehdr.e_machine, dyn->d_un.d_val)); break; case DT_GNU_PRELINKED: printf(" %s\n", timestamp(dyn->d_un.d_val)); break; default: printf("\n"); } } static void dump_rel(struct readelf *re, struct section *s, Elf_Data *d) { GElf_Rel r; const char *symname; uint64_t symval; int i, len; if (s->link >= re->shnum) return; #define REL_HDR "r_offset", "r_info", "r_type", "st_value", "st_name" #define REL_CT32 (uintmax_t)r.r_offset, (uintmax_t)r.r_info, \ - r_type(re->ehdr.e_machine, ELF32_R_TYPE(r.r_info)), \ - (uintmax_t)symval, symname + elftc_reloc_type_str(re->ehdr.e_machine, \ + ELF32_R_TYPE(r.r_info)), (uintmax_t)symval, symname #define REL_CT64 (uintmax_t)r.r_offset, (uintmax_t)r.r_info, \ - r_type(re->ehdr.e_machine, ELF64_R_TYPE(r.r_info)), \ - (uintmax_t)symval, symname + elftc_reloc_type_str(re->ehdr.e_machine, \ + ELF64_R_TYPE(r.r_info)), (uintmax_t)symval, symname printf("\nRelocation section (%s):\n", s->name); if (re->ec == ELFCLASS32) printf("%-8s %-8s %-19s %-8s %s\n", REL_HDR); else { if (re->options & RE_WW) printf("%-16s %-16s %-24s %-16s %s\n", REL_HDR); else printf("%-12s %-12s %-19s %-16s %s\n", REL_HDR); } assert(d->d_size == s->sz); if (!get_ent_count(s, &len)) return; for (i = 0; i < len; i++) { if (gelf_getrel(d, i, &r) != &r) { warnx("gelf_getrel failed: %s", elf_errmsg(-1)); continue; } symname = get_symbol_name(re, s->link, GELF_R_SYM(r.r_info)); symval = get_symbol_value(re, s->link, GELF_R_SYM(r.r_info)); if (re->ec == ELFCLASS32) { r.r_info = ELF32_R_INFO(ELF64_R_SYM(r.r_info), ELF64_R_TYPE(r.r_info)); printf("%8.8jx %8.8jx %-19.19s %8.8jx %s\n", REL_CT32); } else { if (re->options & RE_WW) printf("%16.16jx %16.16jx %-24.24s" " %16.16jx %s\n", REL_CT64); else printf("%12.12jx %12.12jx %-19.19s" " %16.16jx %s\n", REL_CT64); } } #undef REL_HDR #undef REL_CT } static void dump_rela(struct readelf *re, struct section *s, Elf_Data *d) { GElf_Rela r; const char *symname; uint64_t symval; int i, len; if (s->link >= re->shnum) return; #define RELA_HDR "r_offset", "r_info", "r_type", "st_value", \ "st_name + r_addend" #define RELA_CT32 (uintmax_t)r.r_offset, (uintmax_t)r.r_info, \ - r_type(re->ehdr.e_machine, ELF32_R_TYPE(r.r_info)), \ - (uintmax_t)symval, symname + elftc_reloc_type_str(re->ehdr.e_machine, \ + ELF32_R_TYPE(r.r_info)), (uintmax_t)symval, symname #define RELA_CT64 (uintmax_t)r.r_offset, (uintmax_t)r.r_info, \ - r_type(re->ehdr.e_machine, ELF64_R_TYPE(r.r_info)), \ - (uintmax_t)symval, symname + elftc_reloc_type_str(re->ehdr.e_machine, \ + ELF64_R_TYPE(r.r_info)), (uintmax_t)symval, symname printf("\nRelocation section with addend (%s):\n", s->name); if (re->ec == ELFCLASS32) printf("%-8s %-8s %-19s %-8s %s\n", RELA_HDR); else { if (re->options & RE_WW) printf("%-16s %-16s %-24s %-16s %s\n", RELA_HDR); else printf("%-12s %-12s %-19s %-16s %s\n", RELA_HDR); } assert(d->d_size == s->sz); if (!get_ent_count(s, &len)) return; for (i = 0; i < len; i++) { if (gelf_getrela(d, i, &r) != &r) { warnx("gelf_getrel failed: %s", elf_errmsg(-1)); continue; } symname = get_symbol_name(re, s->link, GELF_R_SYM(r.r_info)); symval = get_symbol_value(re, s->link, GELF_R_SYM(r.r_info)); if (re->ec == ELFCLASS32) { r.r_info = ELF32_R_INFO(ELF64_R_SYM(r.r_info), ELF64_R_TYPE(r.r_info)); printf("%8.8jx %8.8jx %-19.19s %8.8jx %s", RELA_CT32); printf(" + %x\n", (uint32_t) r.r_addend); } else { if (re->options & RE_WW) printf("%16.16jx %16.16jx %-24.24s" " %16.16jx %s", RELA_CT64); else printf("%12.12jx %12.12jx %-19.19s" " %16.16jx %s", RELA_CT64); printf(" + %jx\n", (uintmax_t) r.r_addend); } } #undef RELA_HDR #undef RELA_CT } static void dump_reloc(struct readelf *re) { struct section *s; Elf_Data *d; int i, elferr; for (i = 0; (size_t)i < re->shnum; i++) { s = &re->sl[i]; if (s->type == SHT_REL || s->type == SHT_RELA) { (void) elf_errno(); if ((d = elf_getdata(s->scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("elf_getdata failed: %s", elf_errmsg(elferr)); continue; } if (s->type == SHT_REL) dump_rel(re, s, d); else dump_rela(re, s, d); } } } static void dump_symtab(struct readelf *re, int i) { struct section *s; Elf_Data *d; GElf_Sym sym; const char *name; uint32_t stab; int elferr, j, len; uint16_t vs; s = &re->sl[i]; if (s->link >= re->shnum) return; stab = s->link; (void) elf_errno(); if ((d = elf_getdata(s->scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("elf_getdata failed: %s", elf_errmsg(elferr)); return; } if (d->d_size <= 0) return; if (!get_ent_count(s, &len)) return; printf("Symbol table (%s)", s->name); printf(" contains %d entries:\n", len); printf("%7s%9s%14s%5s%8s%6s%9s%5s\n", "Num:", "Value", "Size", "Type", "Bind", "Vis", "Ndx", "Name"); for (j = 0; j < len; j++) { if (gelf_getsym(d, j, &sym) != &sym) { warnx("gelf_getsym failed: %s", elf_errmsg(-1)); continue; } printf("%6d:", j); printf(" %16.16jx", (uintmax_t) sym.st_value); printf(" %5ju", (uintmax_t) sym.st_size); printf(" %-7s", st_type(re->ehdr.e_machine, - GELF_ST_TYPE(sym.st_info))); + re->ehdr.e_ident[EI_OSABI], GELF_ST_TYPE(sym.st_info))); printf(" %-6s", st_bind(GELF_ST_BIND(sym.st_info))); printf(" %-8s", st_vis(GELF_ST_VISIBILITY(sym.st_other))); printf(" %3s", st_shndx(sym.st_shndx)); if ((name = elf_strptr(re->elf, stab, sym.st_name)) != NULL) printf(" %s", name); /* Append symbol version string for SHT_DYNSYM symbol table. */ if (s->type == SHT_DYNSYM && re->ver != NULL && re->vs != NULL && re->vs[j] > 1) { vs = re->vs[j] & VERSYM_VERSION; if (vs >= re->ver_sz || re->ver[vs].name == NULL) { warnx("invalid versym version index %u", vs); break; } if (re->vs[j] & VERSYM_HIDDEN || re->ver[vs].type == 0) printf("@%s (%d)", re->ver[vs].name, vs); else printf("@@%s (%d)", re->ver[vs].name, vs); } putchar('\n'); } } static void dump_symtabs(struct readelf *re) { GElf_Dyn dyn; Elf_Data *d; struct section *s; uint64_t dyn_off; int elferr, i, len; /* * If -D is specified, only dump the symbol table specified by * the DT_SYMTAB entry in the .dynamic section. */ dyn_off = 0; if (re->options & RE_DD) { s = NULL; for (i = 0; (size_t)i < re->shnum; i++) if (re->sl[i].type == SHT_DYNAMIC) { s = &re->sl[i]; break; } if (s == NULL) return; (void) elf_errno(); if ((d = elf_getdata(s->scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("elf_getdata failed: %s", elf_errmsg(-1)); return; } if (d->d_size <= 0) return; if (!get_ent_count(s, &len)) return; for (i = 0; i < len; i++) { if (gelf_getdyn(d, i, &dyn) != &dyn) { warnx("gelf_getdyn failed: %s", elf_errmsg(-1)); continue; } if (dyn.d_tag == DT_SYMTAB) { dyn_off = dyn.d_un.d_val; break; } } } /* Find and dump symbol tables. */ for (i = 0; (size_t)i < re->shnum; i++) { s = &re->sl[i]; if (s->type == SHT_SYMTAB || s->type == SHT_DYNSYM) { if (re->options & RE_DD) { if (dyn_off == s->addr) { dump_symtab(re, i); break; } } else dump_symtab(re, i); } } } static void dump_svr4_hash(struct section *s) { Elf_Data *d; uint32_t *buf; uint32_t nbucket, nchain; uint32_t *bucket, *chain; uint32_t *bl, *c, maxl, total; int elferr, i, j; /* Read and parse the content of .hash section. */ (void) elf_errno(); if ((d = elf_getdata(s->scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("elf_getdata failed: %s", elf_errmsg(elferr)); return; } if (d->d_size < 2 * sizeof(uint32_t)) { warnx(".hash section too small"); return; } buf = d->d_buf; nbucket = buf[0]; nchain = buf[1]; if (nbucket <= 0 || nchain <= 0) { warnx("Malformed .hash section"); return; } if (d->d_size != (nbucket + nchain + 2) * sizeof(uint32_t)) { warnx("Malformed .hash section"); return; } bucket = &buf[2]; chain = &buf[2 + nbucket]; maxl = 0; if ((bl = calloc(nbucket, sizeof(*bl))) == NULL) errx(EXIT_FAILURE, "calloc failed"); for (i = 0; (uint32_t)i < nbucket; i++) for (j = bucket[i]; j > 0 && (uint32_t)j < nchain; j = chain[j]) if (++bl[i] > maxl) maxl = bl[i]; if ((c = calloc(maxl + 1, sizeof(*c))) == NULL) errx(EXIT_FAILURE, "calloc failed"); for (i = 0; (uint32_t)i < nbucket; i++) c[bl[i]]++; printf("\nHistogram for bucket list length (total of %u buckets):\n", nbucket); printf(" Length\tNumber\t\t%% of total\tCoverage\n"); total = 0; for (i = 0; (uint32_t)i <= maxl; i++) { total += c[i] * i; printf("%7u\t%-10u\t(%5.1f%%)\t%5.1f%%\n", i, c[i], c[i] * 100.0 / nbucket, total * 100.0 / (nchain - 1)); } free(c); free(bl); } static void dump_svr4_hash64(struct readelf *re, struct section *s) { Elf_Data *d, dst; uint64_t *buf; uint64_t nbucket, nchain; uint64_t *bucket, *chain; uint64_t *bl, *c, maxl, total; int elferr, i, j; /* * ALPHA uses 64-bit hash entries. Since libelf assumes that * .hash section contains only 32-bit entry, an explicit * gelf_xlatetom is needed here. */ (void) elf_errno(); if ((d = elf_rawdata(s->scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("elf_rawdata failed: %s", elf_errmsg(elferr)); return; } d->d_type = ELF_T_XWORD; memcpy(&dst, d, sizeof(Elf_Data)); if (gelf_xlatetom(re->elf, &dst, d, re->ehdr.e_ident[EI_DATA]) != &dst) { warnx("gelf_xlatetom failed: %s", elf_errmsg(-1)); return; } if (dst.d_size < 2 * sizeof(uint64_t)) { warnx(".hash section too small"); return; } buf = dst.d_buf; nbucket = buf[0]; nchain = buf[1]; if (nbucket <= 0 || nchain <= 0) { warnx("Malformed .hash section"); return; } if (d->d_size != (nbucket + nchain + 2) * sizeof(uint32_t)) { warnx("Malformed .hash section"); return; } bucket = &buf[2]; chain = &buf[2 + nbucket]; maxl = 0; if ((bl = calloc(nbucket, sizeof(*bl))) == NULL) errx(EXIT_FAILURE, "calloc failed"); for (i = 0; (uint32_t)i < nbucket; i++) for (j = bucket[i]; j > 0 && (uint32_t)j < nchain; j = chain[j]) if (++bl[i] > maxl) maxl = bl[i]; if ((c = calloc(maxl + 1, sizeof(*c))) == NULL) errx(EXIT_FAILURE, "calloc failed"); for (i = 0; (uint64_t)i < nbucket; i++) c[bl[i]]++; printf("Histogram for bucket list length (total of %ju buckets):\n", (uintmax_t)nbucket); printf(" Length\tNumber\t\t%% of total\tCoverage\n"); total = 0; for (i = 0; (uint64_t)i <= maxl; i++) { total += c[i] * i; printf("%7u\t%-10ju\t(%5.1f%%)\t%5.1f%%\n", i, (uintmax_t)c[i], c[i] * 100.0 / nbucket, total * 100.0 / (nchain - 1)); } free(c); free(bl); } static void dump_gnu_hash(struct readelf *re, struct section *s) { struct section *ds; Elf_Data *d; uint32_t *buf; uint32_t *bucket, *chain; uint32_t nbucket, nchain, symndx, maskwords; uint32_t *bl, *c, maxl, total; int elferr, dynsymcount, i, j; (void) elf_errno(); if ((d = elf_getdata(s->scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("elf_getdata failed: %s", elf_errmsg(elferr)); return; } if (d->d_size < 4 * sizeof(uint32_t)) { warnx(".gnu.hash section too small"); return; } buf = d->d_buf; nbucket = buf[0]; symndx = buf[1]; maskwords = buf[2]; buf += 4; if (s->link >= re->shnum) return; ds = &re->sl[s->link]; if (!get_ent_count(ds, &dynsymcount)) return; + if (symndx >= (uint32_t)dynsymcount) { + warnx("Malformed .gnu.hash section (symndx out of range)"); + return; + } nchain = dynsymcount - symndx; if (d->d_size != 4 * sizeof(uint32_t) + maskwords * (re->ec == ELFCLASS32 ? sizeof(uint32_t) : sizeof(uint64_t)) + (nbucket + nchain) * sizeof(uint32_t)) { warnx("Malformed .gnu.hash section"); return; } bucket = buf + (re->ec == ELFCLASS32 ? maskwords : maskwords * 2); chain = bucket + nbucket; maxl = 0; if ((bl = calloc(nbucket, sizeof(*bl))) == NULL) errx(EXIT_FAILURE, "calloc failed"); for (i = 0; (uint32_t)i < nbucket; i++) for (j = bucket[i]; j > 0 && (uint32_t)j - symndx < nchain; j++) { if (++bl[i] > maxl) maxl = bl[i]; if (chain[j - symndx] & 1) break; } if ((c = calloc(maxl + 1, sizeof(*c))) == NULL) errx(EXIT_FAILURE, "calloc failed"); for (i = 0; (uint32_t)i < nbucket; i++) c[bl[i]]++; printf("Histogram for bucket list length (total of %u buckets):\n", nbucket); printf(" Length\tNumber\t\t%% of total\tCoverage\n"); total = 0; for (i = 0; (uint32_t)i <= maxl; i++) { total += c[i] * i; printf("%7u\t%-10u\t(%5.1f%%)\t%5.1f%%\n", i, c[i], c[i] * 100.0 / nbucket, total * 100.0 / (nchain - 1)); } free(c); free(bl); } static void dump_hash(struct readelf *re) { struct section *s; int i; for (i = 0; (size_t) i < re->shnum; i++) { s = &re->sl[i]; if (s->type == SHT_HASH || s->type == SHT_GNU_HASH) { if (s->type == SHT_GNU_HASH) dump_gnu_hash(re, s); else if (re->ehdr.e_machine == EM_ALPHA && s->entsize == 8) dump_svr4_hash64(re, s); else dump_svr4_hash(s); } } } static void dump_notes(struct readelf *re) { struct section *s; const char *rawfile; GElf_Phdr phdr; Elf_Data *d; - size_t phnum; + size_t filesize, phnum; int i, elferr; if (re->ehdr.e_type == ET_CORE) { /* * Search program headers in the core file for * PT_NOTE entry. */ if (elf_getphnum(re->elf, &phnum) == 0) { warnx("elf_getphnum failed: %s", elf_errmsg(-1)); return; } if (phnum == 0) return; - if ((rawfile = elf_rawfile(re->elf, NULL)) == NULL) { + if ((rawfile = elf_rawfile(re->elf, &filesize)) == NULL) { warnx("elf_rawfile failed: %s", elf_errmsg(-1)); return; } for (i = 0; (size_t) i < phnum; i++) { if (gelf_getphdr(re->elf, i, &phdr) != &phdr) { warnx("gelf_getphdr failed: %s", elf_errmsg(-1)); continue; } - if (phdr.p_type == PT_NOTE) + if (phdr.p_type == PT_NOTE) { + if (phdr.p_offset >= filesize || + phdr.p_filesz > filesize - phdr.p_offset) { + warnx("invalid PHDR offset"); + continue; + } dump_notes_content(re, rawfile + phdr.p_offset, phdr.p_filesz, phdr.p_offset); + } } } else { /* * For objects other than core files, Search for * SHT_NOTE sections. */ for (i = 0; (size_t) i < re->shnum; i++) { s = &re->sl[i]; if (s->type == SHT_NOTE) { (void) elf_errno(); if ((d = elf_getdata(s->scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("elf_getdata failed: %s", elf_errmsg(elferr)); continue; } dump_notes_content(re, d->d_buf, d->d_size, s->off); } } } } static void dump_notes_content(struct readelf *re, const char *buf, size_t sz, off_t off) { Elf_Note *note; const char *end, *name; printf("\nNotes at offset %#010jx with length %#010jx:\n", (uintmax_t) off, (uintmax_t) sz); printf(" %-13s %-15s %s\n", "Owner", "Data size", "Description"); end = buf + sz; while (buf < end) { if (buf + sizeof(*note) > end) { warnx("invalid note header"); return; } note = (Elf_Note *)(uintptr_t) buf; name = (char *)(uintptr_t)(note + 1); /* * The name field is required to be nul-terminated, and * n_namesz includes the terminating nul in observed * implementations (contrary to the ELF-64 spec). A special * case is needed for cores generated by some older Linux * versions, which write a note named "CORE" without a nul * terminator and n_namesz = 4. */ if (note->n_namesz == 0) name = ""; else if (note->n_namesz == 4 && strncmp(name, "CORE", 4) == 0) name = "CORE"; else if (strnlen(name, note->n_namesz) >= note->n_namesz) name = ""; printf(" %-13s %#010jx", name, (uintmax_t) note->n_descsz); printf(" %s\n", note_type(name, re->ehdr.e_type, note->n_type)); buf += sizeof(Elf_Note) + roundup2(note->n_namesz, 4) + roundup2(note->n_descsz, 4); } } /* * Symbol versioning sections are the same for 32bit and 64bit * ELF objects. */ #define Elf_Verdef Elf32_Verdef #define Elf_Verdaux Elf32_Verdaux #define Elf_Verneed Elf32_Verneed #define Elf_Vernaux Elf32_Vernaux #define SAVE_VERSION_NAME(x, n, t) \ do { \ while (x >= re->ver_sz) { \ nv = realloc(re->ver, \ sizeof(*re->ver) * re->ver_sz * 2); \ if (nv == NULL) { \ warn("realloc failed"); \ free(re->ver); \ return; \ } \ re->ver = nv; \ for (i = re->ver_sz; i < re->ver_sz * 2; i++) { \ re->ver[i].name = NULL; \ re->ver[i].type = 0; \ } \ re->ver_sz *= 2; \ } \ if (x > 1) { \ re->ver[x].name = n; \ re->ver[x].type = t; \ } \ } while (0) static void dump_verdef(struct readelf *re, int dump) { struct section *s; struct symver *nv; Elf_Data *d; Elf_Verdef *vd; Elf_Verdaux *vda; uint8_t *buf, *end, *buf2; const char *name; int elferr, i, j; if ((s = re->vd_s) == NULL) return; if (s->link >= re->shnum) return; if (re->ver == NULL) { re->ver_sz = 16; if ((re->ver = calloc(re->ver_sz, sizeof(*re->ver))) == NULL) { warn("calloc failed"); return; } re->ver[0].name = "*local*"; re->ver[1].name = "*global*"; } if (dump) printf("\nVersion definition section (%s):\n", s->name); (void) elf_errno(); if ((d = elf_getdata(s->scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("elf_getdata failed: %s", elf_errmsg(elferr)); return; } if (d->d_size == 0) return; buf = d->d_buf; end = buf + d->d_size; while (buf + sizeof(Elf_Verdef) <= end) { vd = (Elf_Verdef *) (uintptr_t) buf; if (dump) { printf(" 0x%4.4lx", (unsigned long) (buf - (uint8_t *)d->d_buf)); printf(" vd_version: %u vd_flags: %d" " vd_ndx: %u vd_cnt: %u", vd->vd_version, vd->vd_flags, vd->vd_ndx, vd->vd_cnt); } buf2 = buf + vd->vd_aux; j = 0; while (buf2 + sizeof(Elf_Verdaux) <= end && j < vd->vd_cnt) { vda = (Elf_Verdaux *) (uintptr_t) buf2; name = get_string(re, s->link, vda->vda_name); if (j == 0) { if (dump) printf(" vda_name: %s\n", name); SAVE_VERSION_NAME((int)vd->vd_ndx, name, 1); } else if (dump) printf(" 0x%4.4lx parent: %s\n", (unsigned long) (buf2 - (uint8_t *)d->d_buf), name); if (vda->vda_next == 0) break; buf2 += vda->vda_next; j++; } if (vd->vd_next == 0) break; buf += vd->vd_next; } } static void dump_verneed(struct readelf *re, int dump) { struct section *s; struct symver *nv; Elf_Data *d; Elf_Verneed *vn; Elf_Vernaux *vna; uint8_t *buf, *end, *buf2; const char *name; int elferr, i, j; if ((s = re->vn_s) == NULL) return; if (s->link >= re->shnum) return; if (re->ver == NULL) { re->ver_sz = 16; if ((re->ver = calloc(re->ver_sz, sizeof(*re->ver))) == NULL) { warn("calloc failed"); return; } re->ver[0].name = "*local*"; re->ver[1].name = "*global*"; } if (dump) printf("\nVersion needed section (%s):\n", s->name); (void) elf_errno(); if ((d = elf_getdata(s->scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("elf_getdata failed: %s", elf_errmsg(elferr)); return; } if (d->d_size == 0) return; buf = d->d_buf; end = buf + d->d_size; while (buf + sizeof(Elf_Verneed) <= end) { vn = (Elf_Verneed *) (uintptr_t) buf; if (dump) { printf(" 0x%4.4lx", (unsigned long) (buf - (uint8_t *)d->d_buf)); printf(" vn_version: %u vn_file: %s vn_cnt: %u\n", vn->vn_version, get_string(re, s->link, vn->vn_file), vn->vn_cnt); } buf2 = buf + vn->vn_aux; j = 0; while (buf2 + sizeof(Elf_Vernaux) <= end && j < vn->vn_cnt) { vna = (Elf32_Vernaux *) (uintptr_t) buf2; if (dump) printf(" 0x%4.4lx", (unsigned long) (buf2 - (uint8_t *)d->d_buf)); name = get_string(re, s->link, vna->vna_name); if (dump) printf(" vna_name: %s vna_flags: %u" " vna_other: %u\n", name, vna->vna_flags, vna->vna_other); SAVE_VERSION_NAME((int)vna->vna_other, name, 0); if (vna->vna_next == 0) break; buf2 += vna->vna_next; j++; } if (vn->vn_next == 0) break; buf += vn->vn_next; } } static void dump_versym(struct readelf *re) { int i; uint16_t vs; if (re->vs_s == NULL || re->ver == NULL || re->vs == NULL) return; printf("\nVersion symbol section (%s):\n", re->vs_s->name); for (i = 0; i < re->vs_sz; i++) { if ((i & 3) == 0) { if (i > 0) putchar('\n'); printf(" %03x:", i); } vs = re->vs[i] & VERSYM_VERSION; if (vs >= re->ver_sz || re->ver[vs].name == NULL) { warnx("invalid versym version index %u", re->vs[i]); break; } if (re->vs[i] & VERSYM_HIDDEN) printf(" %3xh %-12s ", vs, re->ver[re->vs[i] & VERSYM_VERSION].name); else printf(" %3x %-12s ", vs, re->ver[re->vs[i]].name); } putchar('\n'); } static void dump_ver(struct readelf *re) { if (re->vs_s && re->ver && re->vs) dump_versym(re); if (re->vd_s) dump_verdef(re, 1); if (re->vn_s) dump_verneed(re, 1); } static void search_ver(struct readelf *re) { struct section *s; Elf_Data *d; int elferr, i; for (i = 0; (size_t) i < re->shnum; i++) { s = &re->sl[i]; if (s->type == SHT_SUNW_versym) re->vs_s = s; if (s->type == SHT_SUNW_verneed) re->vn_s = s; if (s->type == SHT_SUNW_verdef) re->vd_s = s; } if (re->vd_s) dump_verdef(re, 0); if (re->vn_s) dump_verneed(re, 0); if (re->vs_s && re->ver != NULL) { (void) elf_errno(); if ((d = elf_getdata(re->vs_s->scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("elf_getdata failed: %s", elf_errmsg(elferr)); return; } if (d->d_size == 0) return; re->vs = d->d_buf; re->vs_sz = d->d_size / sizeof(Elf32_Half); } } #undef Elf_Verdef #undef Elf_Verdaux #undef Elf_Verneed #undef Elf_Vernaux #undef SAVE_VERSION_NAME /* * Elf32_Lib and Elf64_Lib are identical. */ #define Elf_Lib Elf32_Lib static void dump_liblist(struct readelf *re) { struct section *s; struct tm *t; time_t ti; char tbuf[20]; Elf_Data *d; Elf_Lib *lib; int i, j, k, elferr, first, len; for (i = 0; (size_t) i < re->shnum; i++) { s = &re->sl[i]; if (s->type != SHT_GNU_LIBLIST) continue; if (s->link >= re->shnum) continue; (void) elf_errno(); if ((d = elf_getdata(s->scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("elf_getdata failed: %s", elf_errmsg(elferr)); continue; } if (d->d_size <= 0) continue; lib = d->d_buf; if (!get_ent_count(s, &len)) continue; printf("\nLibrary list section '%s' ", s->name); printf("contains %d entries:\n", len); printf("%12s%24s%18s%10s%6s\n", "Library", "Time Stamp", "Checksum", "Version", "Flags"); for (j = 0; (uint64_t) j < s->sz / s->entsize; j++) { printf("%3d: ", j); printf("%-20.20s ", get_string(re, s->link, lib->l_name)); ti = lib->l_time_stamp; t = gmtime(&ti); snprintf(tbuf, sizeof(tbuf), "%04d-%02d-%02dT%02d:%02d" ":%2d", t->tm_year + 1900, t->tm_mon + 1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec); printf("%-19.19s ", tbuf); printf("0x%08x ", lib->l_checksum); printf("%-7d %#x", lib->l_version, lib->l_flags); if (lib->l_flags != 0) { first = 1; putchar('('); for (k = 0; l_flag[k].name != NULL; k++) { if ((l_flag[k].value & lib->l_flags) == 0) continue; if (!first) putchar(','); else first = 0; printf("%s", l_flag[k].name); } putchar(')'); } putchar('\n'); lib++; } } } #undef Elf_Lib static void dump_section_groups(struct readelf *re) { struct section *s; const char *symname; Elf_Data *d; uint32_t *w; int i, j, elferr; size_t n; for (i = 0; (size_t) i < re->shnum; i++) { s = &re->sl[i]; if (s->type != SHT_GROUP) continue; if (s->link >= re->shnum) continue; (void) elf_errno(); if ((d = elf_getdata(s->scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("elf_getdata failed: %s", elf_errmsg(elferr)); continue; } if (d->d_size <= 0) continue; w = d->d_buf; /* We only support COMDAT section. */ if ((*w++ & GRP_COMDAT) == 0) return; if (s->entsize == 0) s->entsize = 4; symname = get_symbol_name(re, s->link, s->info); n = s->sz / s->entsize; if (n-- < 1) return; printf("\nCOMDAT group section [%5d] `%s' [%s] contains %ju" " sections:\n", i, s->name, symname, (uintmax_t)n); printf(" %-10.10s %s\n", "[Index]", "Name"); for (j = 0; (size_t) j < n; j++, w++) { if (*w >= re->shnum) { warnx("invalid section index: %u", *w); continue; } printf(" [%5u] %s\n", *w, re->sl[*w].name); } } } static uint8_t * dump_unknown_tag(uint64_t tag, uint8_t *p, uint8_t *pe) { uint64_t val; /* * According to ARM EABI: For tags > 32, even numbered tags have * a ULEB128 param and odd numbered ones have NUL-terminated * string param. This rule probably also applies for tags <= 32 * if the object arch is not ARM. */ printf(" Tag_unknown_%ju: ", (uintmax_t) tag); if (tag & 1) { printf("%s\n", (char *) p); p += strlen((char *) p) + 1; } else { val = _decode_uleb128(&p, pe); printf("%ju\n", (uintmax_t) val); } return (p); } static uint8_t * dump_compatibility_tag(uint8_t *p, uint8_t *pe) { uint64_t val; val = _decode_uleb128(&p, pe); printf("flag = %ju, vendor = %s\n", (uintmax_t) val, p); p += strlen((char *) p) + 1; return (p); } static void dump_arm_attributes(struct readelf *re, uint8_t *p, uint8_t *pe) { uint64_t tag, val; size_t i; int found, desc; (void) re; while (p < pe) { tag = _decode_uleb128(&p, pe); found = desc = 0; for (i = 0; i < sizeof(aeabi_tags) / sizeof(aeabi_tags[0]); i++) { if (tag == aeabi_tags[i].tag) { found = 1; printf(" %s: ", aeabi_tags[i].s_tag); if (aeabi_tags[i].get_desc) { desc = 1; val = _decode_uleb128(&p, pe); printf("%s\n", aeabi_tags[i].get_desc(val)); } break; } if (tag < aeabi_tags[i].tag) break; } if (!found) { p = dump_unknown_tag(tag, p, pe); continue; } if (desc) continue; switch (tag) { case 4: /* Tag_CPU_raw_name */ case 5: /* Tag_CPU_name */ case 67: /* Tag_conformance */ printf("%s\n", (char *) p); p += strlen((char *) p) + 1; break; case 32: /* Tag_compatibility */ p = dump_compatibility_tag(p, pe); break; case 64: /* Tag_nodefaults */ /* ignored, written as 0. */ (void) _decode_uleb128(&p, pe); printf("True\n"); break; case 65: /* Tag_also_compatible_with */ val = _decode_uleb128(&p, pe); /* Must be Tag_CPU_arch */ if (val != 6) { printf("unknown\n"); break; } val = _decode_uleb128(&p, pe); printf("%s\n", aeabi_cpu_arch(val)); /* Skip NUL terminator. */ p++; break; default: putchar('\n'); break; } } } #ifndef Tag_GNU_MIPS_ABI_FP #define Tag_GNU_MIPS_ABI_FP 4 #endif static void dump_mips_attributes(struct readelf *re, uint8_t *p, uint8_t *pe) { uint64_t tag, val; (void) re; while (p < pe) { tag = _decode_uleb128(&p, pe); switch (tag) { case Tag_GNU_MIPS_ABI_FP: val = _decode_uleb128(&p, pe); printf(" Tag_GNU_MIPS_ABI_FP: %s\n", mips_abi_fp(val)); break; case 32: /* Tag_compatibility */ p = dump_compatibility_tag(p, pe); break; default: p = dump_unknown_tag(tag, p, pe); break; } } } #ifndef Tag_GNU_Power_ABI_FP #define Tag_GNU_Power_ABI_FP 4 #endif #ifndef Tag_GNU_Power_ABI_Vector #define Tag_GNU_Power_ABI_Vector 8 #endif static void dump_ppc_attributes(uint8_t *p, uint8_t *pe) { uint64_t tag, val; while (p < pe) { tag = _decode_uleb128(&p, pe); switch (tag) { case Tag_GNU_Power_ABI_FP: val = _decode_uleb128(&p, pe); printf(" Tag_GNU_Power_ABI_FP: %s\n", ppc_abi_fp(val)); break; case Tag_GNU_Power_ABI_Vector: val = _decode_uleb128(&p, pe); printf(" Tag_GNU_Power_ABI_Vector: %s\n", ppc_abi_vector(val)); break; case 32: /* Tag_compatibility */ p = dump_compatibility_tag(p, pe); break; default: p = dump_unknown_tag(tag, p, pe); break; } } } static void dump_attributes(struct readelf *re) { struct section *s; Elf_Data *d; uint8_t *p, *pe, *sp; size_t len, seclen, nlen, sublen; uint64_t val; int tag, i, elferr; for (i = 0; (size_t) i < re->shnum; i++) { s = &re->sl[i]; if (s->type != SHT_GNU_ATTRIBUTES && (re->ehdr.e_machine != EM_ARM || s->type != SHT_LOPROC + 3)) continue; (void) elf_errno(); if ((d = elf_rawdata(s->scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("elf_rawdata failed: %s", elf_errmsg(elferr)); continue; } if (d->d_size <= 0) continue; p = d->d_buf; pe = p + d->d_size; if (*p != 'A') { printf("Unknown Attribute Section Format: %c\n", (char) *p); continue; } len = d->d_size - 1; p++; while (len > 0) { if (len < 4) { warnx("truncated attribute section length"); return; } seclen = re->dw_decode(&p, 4); if (seclen > len) { warnx("invalid attribute section length"); return; } len -= seclen; nlen = strlen((char *) p) + 1; if (nlen + 4 > seclen) { warnx("invalid attribute section name"); return; } printf("Attribute Section: %s\n", (char *) p); p += nlen; seclen -= nlen + 4; while (seclen > 0) { sp = p; tag = *p++; sublen = re->dw_decode(&p, 4); if (sublen > seclen) { warnx("invalid attribute sub-section" " length"); return; } seclen -= sublen; printf("%s", top_tag(tag)); if (tag == 2 || tag == 3) { putchar(':'); for (;;) { val = _decode_uleb128(&p, pe); if (val == 0) break; printf(" %ju", (uintmax_t) val); } } putchar('\n'); if (re->ehdr.e_machine == EM_ARM && s->type == SHT_LOPROC + 3) dump_arm_attributes(re, p, sp + sublen); else if (re->ehdr.e_machine == EM_MIPS || re->ehdr.e_machine == EM_MIPS_RS3_LE) dump_mips_attributes(re, p, sp + sublen); else if (re->ehdr.e_machine == EM_PPC) dump_ppc_attributes(p, sp + sublen); p = sp + sublen; } } } } static void dump_mips_specific_info(struct readelf *re) { struct section *s; int i, options_found; options_found = 0; s = NULL; for (i = 0; (size_t) i < re->shnum; i++) { s = &re->sl[i]; if (s->name != NULL && (!strcmp(s->name, ".MIPS.options") || (s->type == SHT_MIPS_OPTIONS))) { dump_mips_options(re, s); options_found = 1; } } /* * According to SGI mips64 spec, .reginfo should be ignored if * .MIPS.options section is present. */ if (!options_found) { for (i = 0; (size_t) i < re->shnum; i++) { s = &re->sl[i]; if (s->name != NULL && (!strcmp(s->name, ".reginfo") || (s->type == SHT_MIPS_REGINFO))) dump_mips_reginfo(re, s); } } } static void dump_mips_reginfo(struct readelf *re, struct section *s) { Elf_Data *d; int elferr, len; (void) elf_errno(); if ((d = elf_rawdata(s->scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("elf_rawdata failed: %s", elf_errmsg(elferr)); return; } if (d->d_size <= 0) return; if (!get_ent_count(s, &len)) return; printf("\nSection '%s' contains %d entries:\n", s->name, len); dump_mips_odk_reginfo(re, d->d_buf, d->d_size); } static void dump_mips_options(struct readelf *re, struct section *s) { Elf_Data *d; uint32_t info; uint16_t sndx; uint8_t *p, *pe; uint8_t kind, size; int elferr; (void) elf_errno(); if ((d = elf_rawdata(s->scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("elf_rawdata failed: %s", elf_errmsg(elferr)); return; } if (d->d_size == 0) return; printf("\nSection %s contains:\n", s->name); p = d->d_buf; pe = p + d->d_size; while (p < pe) { if (pe - p < 8) { warnx("Truncated MIPS option header"); return; } kind = re->dw_decode(&p, 1); size = re->dw_decode(&p, 1); sndx = re->dw_decode(&p, 2); info = re->dw_decode(&p, 4); if (size < 8 || size - 8 > pe - p) { warnx("Malformed MIPS option header"); return; } size -= 8; switch (kind) { case ODK_REGINFO: dump_mips_odk_reginfo(re, p, size); break; case ODK_EXCEPTIONS: printf(" EXCEPTIONS FPU_MIN: %#x\n", info & OEX_FPU_MIN); printf("%11.11s FPU_MAX: %#x\n", "", info & OEX_FPU_MAX); dump_mips_option_flags("", mips_exceptions_option, info); break; case ODK_PAD: printf(" %-10.10s section: %ju\n", "OPAD", (uintmax_t) sndx); dump_mips_option_flags("", mips_pad_option, info); break; case ODK_HWPATCH: dump_mips_option_flags("HWPATCH", mips_hwpatch_option, info); break; case ODK_HWAND: dump_mips_option_flags("HWAND", mips_hwa_option, info); break; case ODK_HWOR: dump_mips_option_flags("HWOR", mips_hwo_option, info); break; case ODK_FILL: printf(" %-10.10s %#jx\n", "FILL", (uintmax_t) info); break; case ODK_TAGS: printf(" %-10.10s\n", "TAGS"); break; case ODK_GP_GROUP: printf(" %-10.10s GP group number: %#x\n", "GP_GROUP", info & 0xFFFF); if (info & 0x10000) printf(" %-10.10s GP group is " "self-contained\n", ""); break; case ODK_IDENT: printf(" %-10.10s default GP group number: %#x\n", "IDENT", info & 0xFFFF); if (info & 0x10000) printf(" %-10.10s default GP group is " "self-contained\n", ""); break; case ODK_PAGESIZE: printf(" %-10.10s\n", "PAGESIZE"); break; default: break; } p += size; } } static void dump_mips_option_flags(const char *name, struct mips_option *opt, uint64_t info) { int first; first = 1; for (; opt->desc != NULL; opt++) { if (info & opt->flag) { printf(" %-10.10s %s\n", first ? name : "", opt->desc); first = 0; } } } static void dump_mips_odk_reginfo(struct readelf *re, uint8_t *p, size_t sz) { uint32_t ri_gprmask; uint32_t ri_cprmask[4]; uint64_t ri_gp_value; uint8_t *pe; int i; pe = p + sz; while (p < pe) { ri_gprmask = re->dw_decode(&p, 4); /* Skip ri_pad padding field for mips64. */ if (re->ec == ELFCLASS64) re->dw_decode(&p, 4); for (i = 0; i < 4; i++) ri_cprmask[i] = re->dw_decode(&p, 4); if (re->ec == ELFCLASS32) ri_gp_value = re->dw_decode(&p, 4); else ri_gp_value = re->dw_decode(&p, 8); printf(" %s ", option_kind(ODK_REGINFO)); printf("ri_gprmask: 0x%08jx\n", (uintmax_t) ri_gprmask); for (i = 0; i < 4; i++) printf("%11.11s ri_cprmask[%d]: 0x%08jx\n", "", i, (uintmax_t) ri_cprmask[i]); printf("%12.12s", ""); printf("ri_gp_value: %#jx\n", (uintmax_t) ri_gp_value); } } static void dump_arch_specific_info(struct readelf *re) { dump_liblist(re); dump_attributes(re); switch (re->ehdr.e_machine) { case EM_MIPS: case EM_MIPS_RS3_LE: dump_mips_specific_info(re); default: break; } } static const char * dwarf_regname(struct readelf *re, unsigned int num) { static char rx[32]; const char *rn; if ((rn = dwarf_reg(re->ehdr.e_machine, num)) != NULL) return (rn); snprintf(rx, sizeof(rx), "r%u", num); return (rx); } static void dump_dwarf_line(struct readelf *re) { struct section *s; Dwarf_Die die; Dwarf_Error de; Dwarf_Half tag, version, pointer_size; Dwarf_Unsigned offset, endoff, length, hdrlen, dirndx, mtime, fsize; Dwarf_Small minlen, defstmt, lrange, opbase, oplen; Elf_Data *d; char *pn; uint64_t address, file, line, column, isa, opsize, udelta; int64_t sdelta; uint8_t *p, *pe; int8_t lbase; int i, is_stmt, dwarf_size, elferr, ret; printf("\nDump of debug contents of section .debug_line:\n"); s = NULL; for (i = 0; (size_t) i < re->shnum; i++) { s = &re->sl[i]; if (s->name != NULL && !strcmp(s->name, ".debug_line")) break; } if ((size_t) i >= re->shnum) return; (void) elf_errno(); if ((d = elf_getdata(s->scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("elf_getdata failed: %s", elf_errmsg(-1)); return; } if (d->d_size <= 0) return; while ((ret = dwarf_next_cu_header(re->dbg, NULL, NULL, NULL, NULL, NULL, &de)) == DW_DLV_OK) { die = NULL; while (dwarf_siblingof(re->dbg, die, &die, &de) == DW_DLV_OK) { if (dwarf_tag(die, &tag, &de) != DW_DLV_OK) { warnx("dwarf_tag failed: %s", dwarf_errmsg(de)); return; } /* XXX: What about DW_TAG_partial_unit? */ if (tag == DW_TAG_compile_unit) break; } if (die == NULL) { warnx("could not find DW_TAG_compile_unit die"); return; } if (dwarf_attrval_unsigned(die, DW_AT_stmt_list, &offset, &de) != DW_DLV_OK) continue; length = re->dw_read(d, &offset, 4); if (length == 0xffffffff) { dwarf_size = 8; length = re->dw_read(d, &offset, 8); } else dwarf_size = 4; if (length > d->d_size - offset) { warnx("invalid .dwarf_line section"); continue; } endoff = offset + length; pe = (uint8_t *) d->d_buf + endoff; version = re->dw_read(d, &offset, 2); hdrlen = re->dw_read(d, &offset, dwarf_size); minlen = re->dw_read(d, &offset, 1); defstmt = re->dw_read(d, &offset, 1); lbase = re->dw_read(d, &offset, 1); lrange = re->dw_read(d, &offset, 1); opbase = re->dw_read(d, &offset, 1); printf("\n"); printf(" Length:\t\t\t%ju\n", (uintmax_t) length); printf(" DWARF version:\t\t%u\n", version); printf(" Prologue Length:\t\t%ju\n", (uintmax_t) hdrlen); printf(" Minimum Instruction Length:\t%u\n", minlen); printf(" Initial value of 'is_stmt':\t%u\n", defstmt); printf(" Line Base:\t\t\t%d\n", lbase); printf(" Line Range:\t\t\t%u\n", lrange); printf(" Opcode Base:\t\t\t%u\n", opbase); (void) dwarf_get_address_size(re->dbg, &pointer_size, &de); printf(" (Pointer size:\t\t%u)\n", pointer_size); printf("\n"); printf(" Opcodes:\n"); for (i = 1; i < opbase; i++) { oplen = re->dw_read(d, &offset, 1); printf(" Opcode %d has %u args\n", i, oplen); } printf("\n"); printf(" The Directory Table:\n"); p = (uint8_t *) d->d_buf + offset; while (*p != '\0') { printf(" %s\n", (char *) p); p += strlen((char *) p) + 1; } p++; printf("\n"); printf(" The File Name Table:\n"); printf(" Entry\tDir\tTime\tSize\tName\n"); i = 0; while (*p != '\0') { i++; pn = (char *) p; p += strlen(pn) + 1; dirndx = _decode_uleb128(&p, pe); mtime = _decode_uleb128(&p, pe); fsize = _decode_uleb128(&p, pe); printf(" %d\t%ju\t%ju\t%ju\t%s\n", i, (uintmax_t) dirndx, (uintmax_t) mtime, (uintmax_t) fsize, pn); } #define RESET_REGISTERS \ do { \ address = 0; \ file = 1; \ line = 1; \ column = 0; \ is_stmt = defstmt; \ } while(0) #define LINE(x) (lbase + (((x) - opbase) % lrange)) #define ADDRESS(x) ((((x) - opbase) / lrange) * minlen) p++; printf("\n"); printf(" Line Number Statements:\n"); RESET_REGISTERS; while (p < pe) { if (*p == 0) { /* * Extended Opcodes. */ p++; opsize = _decode_uleb128(&p, pe); printf(" Extended opcode %u: ", *p); switch (*p) { case DW_LNE_end_sequence: p++; RESET_REGISTERS; printf("End of Sequence\n"); break; case DW_LNE_set_address: p++; address = re->dw_decode(&p, pointer_size); printf("set Address to %#jx\n", (uintmax_t) address); break; case DW_LNE_define_file: p++; pn = (char *) p; p += strlen(pn) + 1; dirndx = _decode_uleb128(&p, pe); mtime = _decode_uleb128(&p, pe); fsize = _decode_uleb128(&p, pe); printf("define new file: %s\n", pn); break; default: /* Unrecognized extened opcodes. */ p += opsize; printf("unknown opcode\n"); } } else if (*p > 0 && *p < opbase) { /* * Standard Opcodes. */ switch(*p++) { case DW_LNS_copy: printf(" Copy\n"); break; case DW_LNS_advance_pc: udelta = _decode_uleb128(&p, pe) * minlen; address += udelta; printf(" Advance PC by %ju to %#jx\n", (uintmax_t) udelta, (uintmax_t) address); break; case DW_LNS_advance_line: sdelta = _decode_sleb128(&p, pe); line += sdelta; printf(" Advance Line by %jd to %ju\n", (intmax_t) sdelta, (uintmax_t) line); break; case DW_LNS_set_file: file = _decode_uleb128(&p, pe); printf(" Set File to %ju\n", (uintmax_t) file); break; case DW_LNS_set_column: column = _decode_uleb128(&p, pe); printf(" Set Column to %ju\n", (uintmax_t) column); break; case DW_LNS_negate_stmt: is_stmt = !is_stmt; printf(" Set is_stmt to %d\n", is_stmt); break; case DW_LNS_set_basic_block: printf(" Set basic block flag\n"); break; case DW_LNS_const_add_pc: address += ADDRESS(255); printf(" Advance PC by constant %ju" " to %#jx\n", (uintmax_t) ADDRESS(255), (uintmax_t) address); break; case DW_LNS_fixed_advance_pc: udelta = re->dw_decode(&p, 2); address += udelta; printf(" Advance PC by fixed value " "%ju to %#jx\n", (uintmax_t) udelta, (uintmax_t) address); break; case DW_LNS_set_prologue_end: printf(" Set prologue end flag\n"); break; case DW_LNS_set_epilogue_begin: printf(" Set epilogue begin flag\n"); break; case DW_LNS_set_isa: isa = _decode_uleb128(&p, pe); printf(" Set isa to %ju\n", (uintmax_t) isa); break; default: /* Unrecognized extended opcodes. */ printf(" Unknown extended opcode %u\n", *(p - 1)); break; } } else { /* * Special Opcodes. */ line += LINE(*p); address += ADDRESS(*p); printf(" Special opcode %u: advance Address " "by %ju to %#jx and Line by %jd to %ju\n", *p - opbase, (uintmax_t) ADDRESS(*p), (uintmax_t) address, (intmax_t) LINE(*p), (uintmax_t) line); p++; } } } if (ret == DW_DLV_ERROR) warnx("dwarf_next_cu_header: %s", dwarf_errmsg(de)); #undef RESET_REGISTERS #undef LINE #undef ADDRESS } static void dump_dwarf_line_decoded(struct readelf *re) { Dwarf_Die die; Dwarf_Line *linebuf, ln; Dwarf_Addr lineaddr; Dwarf_Signed linecount, srccount; Dwarf_Unsigned lineno, fn; Dwarf_Error de; const char *dir, *file; char **srcfiles; int i, ret; printf("Decoded dump of debug contents of section .debug_line:\n\n"); while ((ret = dwarf_next_cu_header(re->dbg, NULL, NULL, NULL, NULL, NULL, &de)) == DW_DLV_OK) { if (dwarf_siblingof(re->dbg, NULL, &die, &de) != DW_DLV_OK) continue; if (dwarf_attrval_string(die, DW_AT_name, &file, &de) != DW_DLV_OK) file = NULL; if (dwarf_attrval_string(die, DW_AT_comp_dir, &dir, &de) != DW_DLV_OK) dir = NULL; printf("CU: "); if (dir && file) printf("%s/", dir); if (file) printf("%s", file); putchar('\n'); printf("%-37s %11s %s\n", "Filename", "Line Number", "Starting Address"); if (dwarf_srclines(die, &linebuf, &linecount, &de) != DW_DLV_OK) continue; if (dwarf_srcfiles(die, &srcfiles, &srccount, &de) != DW_DLV_OK) continue; for (i = 0; i < linecount; i++) { ln = linebuf[i]; if (dwarf_line_srcfileno(ln, &fn, &de) != DW_DLV_OK) continue; if (dwarf_lineno(ln, &lineno, &de) != DW_DLV_OK) continue; if (dwarf_lineaddr(ln, &lineaddr, &de) != DW_DLV_OK) continue; printf("%-37s %11ju %#18jx\n", basename(srcfiles[fn - 1]), (uintmax_t) lineno, (uintmax_t) lineaddr); } putchar('\n'); } } static void dump_dwarf_die(struct readelf *re, Dwarf_Die die, int level) { Dwarf_Attribute *attr_list; Dwarf_Die ret_die; Dwarf_Off dieoff, cuoff, culen, attroff; Dwarf_Unsigned ate, lang, v_udata, v_sig; Dwarf_Signed attr_count, v_sdata; Dwarf_Off v_off; Dwarf_Addr v_addr; Dwarf_Half tag, attr, form; Dwarf_Block *v_block; Dwarf_Bool v_bool, is_info; Dwarf_Sig8 v_sig8; Dwarf_Error de; Dwarf_Ptr v_expr; const char *tag_str, *attr_str, *ate_str, *lang_str; char unk_tag[32], unk_attr[32]; char *v_str; uint8_t *b, *p; int i, j, abc, ret; if (dwarf_dieoffset(die, &dieoff, &de) != DW_DLV_OK) { warnx("dwarf_dieoffset failed: %s", dwarf_errmsg(de)); goto cont_search; } printf(" <%d><%jx>: ", level, (uintmax_t) dieoff); if (dwarf_die_CU_offset_range(die, &cuoff, &culen, &de) != DW_DLV_OK) { warnx("dwarf_die_CU_offset_range failed: %s", dwarf_errmsg(de)); cuoff = 0; } abc = dwarf_die_abbrev_code(die); if (dwarf_tag(die, &tag, &de) != DW_DLV_OK) { warnx("dwarf_tag failed: %s", dwarf_errmsg(de)); goto cont_search; } if (dwarf_get_TAG_name(tag, &tag_str) != DW_DLV_OK) { snprintf(unk_tag, sizeof(unk_tag), "[Unknown Tag: %#x]", tag); tag_str = unk_tag; } printf("Abbrev Number: %d (%s)\n", abc, tag_str); if ((ret = dwarf_attrlist(die, &attr_list, &attr_count, &de)) != DW_DLV_OK) { if (ret == DW_DLV_ERROR) warnx("dwarf_attrlist failed: %s", dwarf_errmsg(de)); goto cont_search; } for (i = 0; i < attr_count; i++) { if (dwarf_whatform(attr_list[i], &form, &de) != DW_DLV_OK) { warnx("dwarf_whatform failed: %s", dwarf_errmsg(de)); continue; } if (dwarf_whatattr(attr_list[i], &attr, &de) != DW_DLV_OK) { warnx("dwarf_whatattr failed: %s", dwarf_errmsg(de)); continue; } if (dwarf_get_AT_name(attr, &attr_str) != DW_DLV_OK) { snprintf(unk_attr, sizeof(unk_attr), "[Unknown AT: %#x]", attr); attr_str = unk_attr; } if (dwarf_attroffset(attr_list[i], &attroff, &de) != DW_DLV_OK) { warnx("dwarf_attroffset failed: %s", dwarf_errmsg(de)); attroff = 0; } printf(" <%jx> %-18s: ", (uintmax_t) attroff, attr_str); switch (form) { case DW_FORM_ref_addr: case DW_FORM_sec_offset: if (dwarf_global_formref(attr_list[i], &v_off, &de) != DW_DLV_OK) { warnx("dwarf_global_formref failed: %s", dwarf_errmsg(de)); continue; } if (form == DW_FORM_ref_addr) printf("<0x%jx>", (uintmax_t) v_off); else printf("0x%jx", (uintmax_t) v_off); break; case DW_FORM_ref1: case DW_FORM_ref2: case DW_FORM_ref4: case DW_FORM_ref8: case DW_FORM_ref_udata: if (dwarf_formref(attr_list[i], &v_off, &de) != DW_DLV_OK) { warnx("dwarf_formref failed: %s", dwarf_errmsg(de)); continue; } v_off += cuoff; printf("<0x%jx>", (uintmax_t) v_off); break; case DW_FORM_addr: if (dwarf_formaddr(attr_list[i], &v_addr, &de) != DW_DLV_OK) { warnx("dwarf_formaddr failed: %s", dwarf_errmsg(de)); continue; } printf("%#jx", (uintmax_t) v_addr); break; case DW_FORM_data1: case DW_FORM_data2: case DW_FORM_data4: case DW_FORM_data8: case DW_FORM_udata: if (dwarf_formudata(attr_list[i], &v_udata, &de) != DW_DLV_OK) { warnx("dwarf_formudata failed: %s", dwarf_errmsg(de)); continue; } if (attr == DW_AT_high_pc) printf("0x%jx", (uintmax_t) v_udata); else printf("%ju", (uintmax_t) v_udata); break; case DW_FORM_sdata: if (dwarf_formsdata(attr_list[i], &v_sdata, &de) != DW_DLV_OK) { warnx("dwarf_formudata failed: %s", dwarf_errmsg(de)); continue; } printf("%jd", (intmax_t) v_sdata); break; case DW_FORM_flag: if (dwarf_formflag(attr_list[i], &v_bool, &de) != DW_DLV_OK) { warnx("dwarf_formflag failed: %s", dwarf_errmsg(de)); continue; } printf("%jd", (intmax_t) v_bool); break; case DW_FORM_flag_present: putchar('1'); break; case DW_FORM_string: case DW_FORM_strp: if (dwarf_formstring(attr_list[i], &v_str, &de) != DW_DLV_OK) { warnx("dwarf_formstring failed: %s", dwarf_errmsg(de)); continue; } if (form == DW_FORM_string) printf("%s", v_str); else printf("(indirect string) %s", v_str); break; case DW_FORM_block: case DW_FORM_block1: case DW_FORM_block2: case DW_FORM_block4: if (dwarf_formblock(attr_list[i], &v_block, &de) != DW_DLV_OK) { warnx("dwarf_formblock failed: %s", dwarf_errmsg(de)); continue; } printf("%ju byte block:", (uintmax_t) v_block->bl_len); b = v_block->bl_data; for (j = 0; (Dwarf_Unsigned) j < v_block->bl_len; j++) printf(" %x", b[j]); printf("\t("); dump_dwarf_block(re, v_block->bl_data, v_block->bl_len); putchar(')'); break; case DW_FORM_exprloc: if (dwarf_formexprloc(attr_list[i], &v_udata, &v_expr, &de) != DW_DLV_OK) { warnx("dwarf_formexprloc failed: %s", dwarf_errmsg(de)); continue; } printf("%ju byte block:", (uintmax_t) v_udata); b = v_expr; for (j = 0; (Dwarf_Unsigned) j < v_udata; j++) printf(" %x", b[j]); printf("\t("); dump_dwarf_block(re, v_expr, v_udata); putchar(')'); break; case DW_FORM_ref_sig8: if (dwarf_formsig8(attr_list[i], &v_sig8, &de) != DW_DLV_OK) { warnx("dwarf_formsig8 failed: %s", dwarf_errmsg(de)); continue; } p = (uint8_t *)(uintptr_t) &v_sig8.signature[0]; v_sig = re->dw_decode(&p, 8); printf("signature: 0x%jx", (uintmax_t) v_sig); } switch (attr) { case DW_AT_encoding: if (dwarf_attrval_unsigned(die, attr, &ate, &de) != DW_DLV_OK) break; if (dwarf_get_ATE_name(ate, &ate_str) != DW_DLV_OK) ate_str = "DW_ATE_UNKNOWN"; printf("\t(%s)", &ate_str[strlen("DW_ATE_")]); break; case DW_AT_language: if (dwarf_attrval_unsigned(die, attr, &lang, &de) != DW_DLV_OK) break; if (dwarf_get_LANG_name(lang, &lang_str) != DW_DLV_OK) break; printf("\t(%s)", &lang_str[strlen("DW_LANG_")]); break; case DW_AT_location: case DW_AT_string_length: case DW_AT_return_addr: case DW_AT_data_member_location: case DW_AT_frame_base: case DW_AT_segment: case DW_AT_static_link: case DW_AT_use_location: case DW_AT_vtable_elem_location: switch (form) { case DW_FORM_data4: case DW_FORM_data8: case DW_FORM_sec_offset: printf("\t(location list)"); break; default: break; } default: break; } putchar('\n'); } cont_search: /* Search children. */ ret = dwarf_child(die, &ret_die, &de); if (ret == DW_DLV_ERROR) warnx("dwarf_child: %s", dwarf_errmsg(de)); else if (ret == DW_DLV_OK) dump_dwarf_die(re, ret_die, level + 1); /* Search sibling. */ is_info = dwarf_get_die_infotypes_flag(die); ret = dwarf_siblingof_b(re->dbg, die, &ret_die, is_info, &de); if (ret == DW_DLV_ERROR) warnx("dwarf_siblingof: %s", dwarf_errmsg(de)); else if (ret == DW_DLV_OK) dump_dwarf_die(re, ret_die, level); dwarf_dealloc(re->dbg, die, DW_DLA_DIE); } static void set_cu_context(struct readelf *re, Dwarf_Half psize, Dwarf_Half osize, Dwarf_Half ver) { re->cu_psize = psize; re->cu_osize = osize; re->cu_ver = ver; } static void dump_dwarf_info(struct readelf *re, Dwarf_Bool is_info) { struct section *s; Dwarf_Die die; Dwarf_Error de; Dwarf_Half tag, version, pointer_size, off_size; Dwarf_Off cu_offset, cu_length; Dwarf_Off aboff; Dwarf_Unsigned typeoff; Dwarf_Sig8 sig8; Dwarf_Unsigned sig; uint8_t *p; const char *sn; int i, ret; sn = is_info ? ".debug_info" : ".debug_types"; s = NULL; for (i = 0; (size_t) i < re->shnum; i++) { s = &re->sl[i]; if (s->name != NULL && !strcmp(s->name, sn)) break; } if ((size_t) i >= re->shnum) return; do { printf("\nDump of debug contents of section %s:\n", sn); while ((ret = dwarf_next_cu_header_c(re->dbg, is_info, NULL, &version, &aboff, &pointer_size, &off_size, NULL, &sig8, &typeoff, NULL, &de)) == DW_DLV_OK) { set_cu_context(re, pointer_size, off_size, version); die = NULL; while (dwarf_siblingof_b(re->dbg, die, &die, is_info, &de) == DW_DLV_OK) { if (dwarf_tag(die, &tag, &de) != DW_DLV_OK) { warnx("dwarf_tag failed: %s", dwarf_errmsg(de)); continue; } /* XXX: What about DW_TAG_partial_unit? */ if ((is_info && tag == DW_TAG_compile_unit) || (!is_info && tag == DW_TAG_type_unit)) break; } if (die == NULL && is_info) { warnx("could not find DW_TAG_compile_unit " "die"); continue; } else if (die == NULL && !is_info) { warnx("could not find DW_TAG_type_unit die"); continue; } if (dwarf_die_CU_offset_range(die, &cu_offset, &cu_length, &de) != DW_DLV_OK) { warnx("dwarf_die_CU_offset failed: %s", dwarf_errmsg(de)); continue; } cu_length -= off_size == 4 ? 4 : 12; sig = 0; if (!is_info) { p = (uint8_t *)(uintptr_t) &sig8.signature[0]; sig = re->dw_decode(&p, 8); } printf("\n Type Unit @ offset 0x%jx:\n", (uintmax_t) cu_offset); printf(" Length:\t\t%#jx (%d-bit)\n", (uintmax_t) cu_length, off_size == 4 ? 32 : 64); printf(" Version:\t\t%u\n", version); printf(" Abbrev Offset:\t0x%jx\n", (uintmax_t) aboff); printf(" Pointer Size:\t%u\n", pointer_size); if (!is_info) { printf(" Signature:\t\t0x%016jx\n", (uintmax_t) sig); printf(" Type Offset:\t0x%jx\n", (uintmax_t) typeoff); } dump_dwarf_die(re, die, 0); } if (ret == DW_DLV_ERROR) warnx("dwarf_next_cu_header: %s", dwarf_errmsg(de)); if (is_info) break; } while (dwarf_next_types_section(re->dbg, &de) == DW_DLV_OK); } static void dump_dwarf_abbrev(struct readelf *re) { Dwarf_Abbrev ab; Dwarf_Off aboff, atoff; Dwarf_Unsigned length, attr_count; Dwarf_Signed flag, form; Dwarf_Half tag, attr; Dwarf_Error de; const char *tag_str, *attr_str, *form_str; char unk_tag[32], unk_attr[32], unk_form[32]; int i, j, ret; printf("\nContents of section .debug_abbrev:\n\n"); while ((ret = dwarf_next_cu_header(re->dbg, NULL, NULL, &aboff, NULL, NULL, &de)) == DW_DLV_OK) { printf(" Number TAG\n"); i = 0; while ((ret = dwarf_get_abbrev(re->dbg, aboff, &ab, &length, &attr_count, &de)) == DW_DLV_OK) { if (length == 1) { dwarf_dealloc(re->dbg, ab, DW_DLA_ABBREV); break; } aboff += length; printf("%4d", ++i); if (dwarf_get_abbrev_tag(ab, &tag, &de) != DW_DLV_OK) { warnx("dwarf_get_abbrev_tag failed: %s", dwarf_errmsg(de)); goto next_abbrev; } if (dwarf_get_TAG_name(tag, &tag_str) != DW_DLV_OK) { snprintf(unk_tag, sizeof(unk_tag), "[Unknown Tag: %#x]", tag); tag_str = unk_tag; } if (dwarf_get_abbrev_children_flag(ab, &flag, &de) != DW_DLV_OK) { warnx("dwarf_get_abbrev_children_flag failed:" " %s", dwarf_errmsg(de)); goto next_abbrev; } printf(" %s %s\n", tag_str, flag ? "[has children]" : "[no children]"); for (j = 0; (Dwarf_Unsigned) j < attr_count; j++) { if (dwarf_get_abbrev_entry(ab, (Dwarf_Signed) j, &attr, &form, &atoff, &de) != DW_DLV_OK) { warnx("dwarf_get_abbrev_entry failed:" " %s", dwarf_errmsg(de)); continue; } if (dwarf_get_AT_name(attr, &attr_str) != DW_DLV_OK) { snprintf(unk_attr, sizeof(unk_attr), "[Unknown AT: %#x]", attr); attr_str = unk_attr; } if (dwarf_get_FORM_name(form, &form_str) != DW_DLV_OK) { snprintf(unk_form, sizeof(unk_form), "[Unknown Form: %#x]", (Dwarf_Half) form); form_str = unk_form; } printf(" %-18s %s\n", attr_str, form_str); } next_abbrev: dwarf_dealloc(re->dbg, ab, DW_DLA_ABBREV); } if (ret != DW_DLV_OK) warnx("dwarf_get_abbrev: %s", dwarf_errmsg(de)); } if (ret == DW_DLV_ERROR) warnx("dwarf_next_cu_header: %s", dwarf_errmsg(de)); } static void dump_dwarf_pubnames(struct readelf *re) { struct section *s; Dwarf_Off die_off; Dwarf_Unsigned offset, length, nt_cu_offset, nt_cu_length; Dwarf_Signed cnt; Dwarf_Global *globs; Dwarf_Half nt_version; Dwarf_Error de; Elf_Data *d; char *glob_name; int i, dwarf_size, elferr; printf("\nContents of the .debug_pubnames section:\n"); s = NULL; for (i = 0; (size_t) i < re->shnum; i++) { s = &re->sl[i]; if (s->name != NULL && !strcmp(s->name, ".debug_pubnames")) break; } if ((size_t) i >= re->shnum) return; (void) elf_errno(); if ((d = elf_getdata(s->scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("elf_getdata failed: %s", elf_errmsg(-1)); return; } if (d->d_size <= 0) return; /* Read in .debug_pubnames section table header. */ offset = 0; length = re->dw_read(d, &offset, 4); if (length == 0xffffffff) { dwarf_size = 8; length = re->dw_read(d, &offset, 8); } else dwarf_size = 4; if (length > d->d_size - offset) { warnx("invalid .dwarf_pubnames section"); return; } nt_version = re->dw_read(d, &offset, 2); nt_cu_offset = re->dw_read(d, &offset, dwarf_size); nt_cu_length = re->dw_read(d, &offset, dwarf_size); printf(" Length:\t\t\t\t%ju\n", (uintmax_t) length); printf(" Version:\t\t\t\t%u\n", nt_version); printf(" Offset into .debug_info section:\t%ju\n", (uintmax_t) nt_cu_offset); printf(" Size of area in .debug_info section:\t%ju\n", (uintmax_t) nt_cu_length); if (dwarf_get_globals(re->dbg, &globs, &cnt, &de) != DW_DLV_OK) { warnx("dwarf_get_globals failed: %s", dwarf_errmsg(de)); return; } printf("\n Offset Name\n"); for (i = 0; i < cnt; i++) { if (dwarf_globname(globs[i], &glob_name, &de) != DW_DLV_OK) { warnx("dwarf_globname failed: %s", dwarf_errmsg(de)); continue; } if (dwarf_global_die_offset(globs[i], &die_off, &de) != DW_DLV_OK) { warnx("dwarf_global_die_offset failed: %s", dwarf_errmsg(de)); continue; } printf(" %-11ju %s\n", (uintmax_t) die_off, glob_name); } } static void dump_dwarf_aranges(struct readelf *re) { struct section *s; Dwarf_Arange *aranges; Dwarf_Addr start; Dwarf_Unsigned offset, length, as_cu_offset; Dwarf_Off die_off; Dwarf_Signed cnt; Dwarf_Half as_version, as_addrsz, as_segsz; Dwarf_Error de; Elf_Data *d; int i, dwarf_size, elferr; printf("\nContents of section .debug_aranges:\n"); s = NULL; for (i = 0; (size_t) i < re->shnum; i++) { s = &re->sl[i]; if (s->name != NULL && !strcmp(s->name, ".debug_aranges")) break; } if ((size_t) i >= re->shnum) return; (void) elf_errno(); if ((d = elf_getdata(s->scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("elf_getdata failed: %s", elf_errmsg(-1)); return; } if (d->d_size <= 0) return; /* Read in the .debug_aranges section table header. */ offset = 0; length = re->dw_read(d, &offset, 4); if (length == 0xffffffff) { dwarf_size = 8; length = re->dw_read(d, &offset, 8); } else dwarf_size = 4; if (length > d->d_size - offset) { warnx("invalid .dwarf_aranges section"); return; } as_version = re->dw_read(d, &offset, 2); as_cu_offset = re->dw_read(d, &offset, dwarf_size); as_addrsz = re->dw_read(d, &offset, 1); as_segsz = re->dw_read(d, &offset, 1); printf(" Length:\t\t\t%ju\n", (uintmax_t) length); printf(" Version:\t\t\t%u\n", as_version); printf(" Offset into .debug_info:\t%ju\n", (uintmax_t) as_cu_offset); printf(" Pointer Size:\t\t\t%u\n", as_addrsz); printf(" Segment Size:\t\t\t%u\n", as_segsz); if (dwarf_get_aranges(re->dbg, &aranges, &cnt, &de) != DW_DLV_OK) { warnx("dwarf_get_aranges failed: %s", dwarf_errmsg(de)); return; } printf("\n Address Length\n"); for (i = 0; i < cnt; i++) { if (dwarf_get_arange_info(aranges[i], &start, &length, &die_off, &de) != DW_DLV_OK) { warnx("dwarf_get_arange_info failed: %s", dwarf_errmsg(de)); continue; } printf(" %08jx %ju\n", (uintmax_t) start, (uintmax_t) length); } } static void dump_dwarf_ranges_foreach(struct readelf *re, Dwarf_Die die, Dwarf_Addr base) { Dwarf_Attribute *attr_list; Dwarf_Ranges *ranges; Dwarf_Die ret_die; Dwarf_Error de; Dwarf_Addr base0; Dwarf_Half attr; Dwarf_Signed attr_count, cnt; Dwarf_Unsigned off, bytecnt; int i, j, ret; if ((ret = dwarf_attrlist(die, &attr_list, &attr_count, &de)) != DW_DLV_OK) { if (ret == DW_DLV_ERROR) warnx("dwarf_attrlist failed: %s", dwarf_errmsg(de)); goto cont_search; } for (i = 0; i < attr_count; i++) { if (dwarf_whatattr(attr_list[i], &attr, &de) != DW_DLV_OK) { warnx("dwarf_whatattr failed: %s", dwarf_errmsg(de)); continue; } if (attr != DW_AT_ranges) continue; if (dwarf_formudata(attr_list[i], &off, &de) != DW_DLV_OK) { warnx("dwarf_formudata failed: %s", dwarf_errmsg(de)); continue; } if (dwarf_get_ranges(re->dbg, (Dwarf_Off) off, &ranges, &cnt, &bytecnt, &de) != DW_DLV_OK) continue; base0 = base; for (j = 0; j < cnt; j++) { printf(" %08jx ", (uintmax_t) off); if (ranges[j].dwr_type == DW_RANGES_END) { printf("%s\n", ""); continue; } else if (ranges[j].dwr_type == DW_RANGES_ADDRESS_SELECTION) { base0 = ranges[j].dwr_addr2; continue; } if (re->ec == ELFCLASS32) printf("%08jx %08jx\n", (uintmax_t) (ranges[j].dwr_addr1 + base0), (uintmax_t) (ranges[j].dwr_addr2 + base0)); else printf("%016jx %016jx\n", (uintmax_t) (ranges[j].dwr_addr1 + base0), (uintmax_t) (ranges[j].dwr_addr2 + base0)); } } cont_search: /* Search children. */ ret = dwarf_child(die, &ret_die, &de); if (ret == DW_DLV_ERROR) warnx("dwarf_child: %s", dwarf_errmsg(de)); else if (ret == DW_DLV_OK) dump_dwarf_ranges_foreach(re, ret_die, base); /* Search sibling. */ ret = dwarf_siblingof(re->dbg, die, &ret_die, &de); if (ret == DW_DLV_ERROR) warnx("dwarf_siblingof: %s", dwarf_errmsg(de)); else if (ret == DW_DLV_OK) dump_dwarf_ranges_foreach(re, ret_die, base); } static void dump_dwarf_ranges(struct readelf *re) { Dwarf_Ranges *ranges; Dwarf_Die die; Dwarf_Signed cnt; Dwarf_Unsigned bytecnt; Dwarf_Half tag; Dwarf_Error de; Dwarf_Unsigned lowpc; int ret; if (dwarf_get_ranges(re->dbg, 0, &ranges, &cnt, &bytecnt, &de) != DW_DLV_OK) return; printf("Contents of the .debug_ranges section:\n\n"); if (re->ec == ELFCLASS32) printf(" %-8s %-8s %s\n", "Offset", "Begin", "End"); else printf(" %-8s %-16s %s\n", "Offset", "Begin", "End"); while ((ret = dwarf_next_cu_header(re->dbg, NULL, NULL, NULL, NULL, NULL, &de)) == DW_DLV_OK) { die = NULL; if (dwarf_siblingof(re->dbg, die, &die, &de) != DW_DLV_OK) continue; if (dwarf_tag(die, &tag, &de) != DW_DLV_OK) { warnx("dwarf_tag failed: %s", dwarf_errmsg(de)); continue; } /* XXX: What about DW_TAG_partial_unit? */ lowpc = 0; if (tag == DW_TAG_compile_unit) { if (dwarf_attrval_unsigned(die, DW_AT_low_pc, &lowpc, &de) != DW_DLV_OK) lowpc = 0; } dump_dwarf_ranges_foreach(re, die, (Dwarf_Addr) lowpc); } putchar('\n'); } static void dump_dwarf_macinfo(struct readelf *re) { Dwarf_Unsigned offset; Dwarf_Signed cnt; Dwarf_Macro_Details *md; Dwarf_Error de; const char *mi_str; char unk_mi[32]; int i; #define _MAX_MACINFO_ENTRY 65535 printf("\nContents of section .debug_macinfo:\n\n"); offset = 0; while (dwarf_get_macro_details(re->dbg, offset, _MAX_MACINFO_ENTRY, &cnt, &md, &de) == DW_DLV_OK) { for (i = 0; i < cnt; i++) { offset = md[i].dmd_offset + 1; if (md[i].dmd_type == 0) break; if (dwarf_get_MACINFO_name(md[i].dmd_type, &mi_str) != DW_DLV_OK) { snprintf(unk_mi, sizeof(unk_mi), "[Unknown MACINFO: %#x]", md[i].dmd_type); mi_str = unk_mi; } printf(" %s", mi_str); switch (md[i].dmd_type) { case DW_MACINFO_define: case DW_MACINFO_undef: printf(" - lineno : %jd macro : %s\n", (intmax_t) md[i].dmd_lineno, md[i].dmd_macro); break; case DW_MACINFO_start_file: printf(" - lineno : %jd filenum : %jd\n", (intmax_t) md[i].dmd_lineno, (intmax_t) md[i].dmd_fileindex); break; default: putchar('\n'); break; } } } #undef _MAX_MACINFO_ENTRY } static void dump_dwarf_frame_inst(struct readelf *re, Dwarf_Cie cie, uint8_t *insts, Dwarf_Unsigned len, Dwarf_Unsigned caf, Dwarf_Signed daf, Dwarf_Addr pc, Dwarf_Debug dbg) { Dwarf_Frame_Op *oplist; Dwarf_Signed opcnt, delta; Dwarf_Small op; Dwarf_Error de; const char *op_str; char unk_op[32]; int i; if (dwarf_expand_frame_instructions(cie, insts, len, &oplist, &opcnt, &de) != DW_DLV_OK) { warnx("dwarf_expand_frame_instructions failed: %s", dwarf_errmsg(de)); return; } for (i = 0; i < opcnt; i++) { if (oplist[i].fp_base_op != 0) op = oplist[i].fp_base_op << 6; else op = oplist[i].fp_extended_op; if (dwarf_get_CFA_name(op, &op_str) != DW_DLV_OK) { snprintf(unk_op, sizeof(unk_op), "[Unknown CFA: %#x]", op); op_str = unk_op; } printf(" %s", op_str); switch (op) { case DW_CFA_advance_loc: delta = oplist[i].fp_offset * caf; pc += delta; printf(": %ju to %08jx", (uintmax_t) delta, (uintmax_t) pc); break; case DW_CFA_offset: case DW_CFA_offset_extended: case DW_CFA_offset_extended_sf: delta = oplist[i].fp_offset * daf; printf(": r%u (%s) at cfa%+jd", oplist[i].fp_register, dwarf_regname(re, oplist[i].fp_register), (intmax_t) delta); break; case DW_CFA_restore: printf(": r%u (%s)", oplist[i].fp_register, dwarf_regname(re, oplist[i].fp_register)); break; case DW_CFA_set_loc: pc = oplist[i].fp_offset; printf(": to %08jx", (uintmax_t) pc); break; case DW_CFA_advance_loc1: case DW_CFA_advance_loc2: case DW_CFA_advance_loc4: pc += oplist[i].fp_offset; printf(": %jd to %08jx", (intmax_t) oplist[i].fp_offset, (uintmax_t) pc); break; case DW_CFA_def_cfa: printf(": r%u (%s) ofs %ju", oplist[i].fp_register, dwarf_regname(re, oplist[i].fp_register), (uintmax_t) oplist[i].fp_offset); break; case DW_CFA_def_cfa_sf: printf(": r%u (%s) ofs %jd", oplist[i].fp_register, dwarf_regname(re, oplist[i].fp_register), (intmax_t) (oplist[i].fp_offset * daf)); break; case DW_CFA_def_cfa_register: printf(": r%u (%s)", oplist[i].fp_register, dwarf_regname(re, oplist[i].fp_register)); break; case DW_CFA_def_cfa_offset: printf(": %ju", (uintmax_t) oplist[i].fp_offset); break; case DW_CFA_def_cfa_offset_sf: printf(": %jd", (intmax_t) (oplist[i].fp_offset * daf)); break; default: break; } putchar('\n'); } dwarf_dealloc(dbg, oplist, DW_DLA_FRAME_BLOCK); } static char * get_regoff_str(struct readelf *re, Dwarf_Half reg, Dwarf_Addr off) { static char rs[16]; if (reg == DW_FRAME_UNDEFINED_VAL || reg == DW_FRAME_REG_INITIAL_VALUE) snprintf(rs, sizeof(rs), "%c", 'u'); else if (reg == DW_FRAME_CFA_COL) snprintf(rs, sizeof(rs), "c%+jd", (intmax_t) off); else snprintf(rs, sizeof(rs), "%s%+jd", dwarf_regname(re, reg), (intmax_t) off); return (rs); } static int dump_dwarf_frame_regtable(struct readelf *re, Dwarf_Fde fde, Dwarf_Addr pc, Dwarf_Unsigned func_len, Dwarf_Half cie_ra) { Dwarf_Regtable rt; Dwarf_Addr row_pc, end_pc, pre_pc, cur_pc; Dwarf_Error de; char *vec; int i; #define BIT_SET(v, n) (v[(n)>>3] |= 1U << ((n) & 7)) #define BIT_CLR(v, n) (v[(n)>>3] &= ~(1U << ((n) & 7))) #define BIT_ISSET(v, n) (v[(n)>>3] & (1U << ((n) & 7))) #define RT(x) rt.rules[(x)] vec = calloc((DW_REG_TABLE_SIZE + 7) / 8, 1); if (vec == NULL) err(EXIT_FAILURE, "calloc failed"); pre_pc = ~((Dwarf_Addr) 0); cur_pc = pc; end_pc = pc + func_len; for (; cur_pc < end_pc; cur_pc++) { if (dwarf_get_fde_info_for_all_regs(fde, cur_pc, &rt, &row_pc, &de) != DW_DLV_OK) { warnx("dwarf_get_fde_info_for_all_regs failed: %s\n", dwarf_errmsg(de)); return (-1); } if (row_pc == pre_pc) continue; pre_pc = row_pc; for (i = 1; i < DW_REG_TABLE_SIZE; i++) { if (rt.rules[i].dw_regnum != DW_FRAME_REG_INITIAL_VALUE) BIT_SET(vec, i); } } printf(" LOC CFA "); for (i = 1; i < DW_REG_TABLE_SIZE; i++) { if (BIT_ISSET(vec, i)) { if ((Dwarf_Half) i == cie_ra) printf("ra "); else printf("%-5s", dwarf_regname(re, (unsigned int) i)); } } putchar('\n'); pre_pc = ~((Dwarf_Addr) 0); cur_pc = pc; end_pc = pc + func_len; for (; cur_pc < end_pc; cur_pc++) { if (dwarf_get_fde_info_for_all_regs(fde, cur_pc, &rt, &row_pc, &de) != DW_DLV_OK) { warnx("dwarf_get_fde_info_for_all_regs failed: %s\n", dwarf_errmsg(de)); return (-1); } if (row_pc == pre_pc) continue; pre_pc = row_pc; printf("%08jx ", (uintmax_t) row_pc); printf("%-8s ", get_regoff_str(re, RT(0).dw_regnum, RT(0).dw_offset)); for (i = 1; i < DW_REG_TABLE_SIZE; i++) { if (BIT_ISSET(vec, i)) { printf("%-5s", get_regoff_str(re, RT(i).dw_regnum, RT(i).dw_offset)); } } putchar('\n'); } free(vec); return (0); #undef BIT_SET #undef BIT_CLR #undef BIT_ISSET #undef RT } static void dump_dwarf_frame_section(struct readelf *re, struct section *s, int alt) { Dwarf_Cie *cie_list, cie, pre_cie; Dwarf_Fde *fde_list, fde; Dwarf_Off cie_offset, fde_offset; Dwarf_Unsigned cie_length, fde_instlen; Dwarf_Unsigned cie_caf, cie_daf, cie_instlen, func_len, fde_length; Dwarf_Signed cie_count, fde_count, cie_index; Dwarf_Addr low_pc; Dwarf_Half cie_ra; Dwarf_Small cie_version; Dwarf_Ptr fde_addr, fde_inst, cie_inst; char *cie_aug, c; int i, eh_frame; Dwarf_Error de; printf("\nThe section %s contains:\n\n", s->name); if (!strcmp(s->name, ".debug_frame")) { eh_frame = 0; if (dwarf_get_fde_list(re->dbg, &cie_list, &cie_count, &fde_list, &fde_count, &de) != DW_DLV_OK) { warnx("dwarf_get_fde_list failed: %s", dwarf_errmsg(de)); return; } } else if (!strcmp(s->name, ".eh_frame")) { eh_frame = 1; if (dwarf_get_fde_list_eh(re->dbg, &cie_list, &cie_count, &fde_list, &fde_count, &de) != DW_DLV_OK) { warnx("dwarf_get_fde_list_eh failed: %s", dwarf_errmsg(de)); return; } } else return; pre_cie = NULL; for (i = 0; i < fde_count; i++) { if (dwarf_get_fde_n(fde_list, i, &fde, &de) != DW_DLV_OK) { warnx("dwarf_get_fde_n failed: %s", dwarf_errmsg(de)); continue; } if (dwarf_get_cie_of_fde(fde, &cie, &de) != DW_DLV_OK) { warnx("dwarf_get_fde_n failed: %s", dwarf_errmsg(de)); continue; } if (dwarf_get_fde_range(fde, &low_pc, &func_len, &fde_addr, &fde_length, &cie_offset, &cie_index, &fde_offset, &de) != DW_DLV_OK) { warnx("dwarf_get_fde_range failed: %s", dwarf_errmsg(de)); continue; } if (dwarf_get_fde_instr_bytes(fde, &fde_inst, &fde_instlen, &de) != DW_DLV_OK) { warnx("dwarf_get_fde_instr_bytes failed: %s", dwarf_errmsg(de)); continue; } if (pre_cie == NULL || cie != pre_cie) { pre_cie = cie; if (dwarf_get_cie_info(cie, &cie_length, &cie_version, &cie_aug, &cie_caf, &cie_daf, &cie_ra, &cie_inst, &cie_instlen, &de) != DW_DLV_OK) { warnx("dwarf_get_cie_info failed: %s", dwarf_errmsg(de)); continue; } printf("%08jx %08jx %8.8jx CIE", (uintmax_t) cie_offset, (uintmax_t) cie_length, (uintmax_t) (eh_frame ? 0 : ~0U)); if (!alt) { putchar('\n'); printf(" Version:\t\t\t%u\n", cie_version); printf(" Augmentation:\t\t\t\""); while ((c = *cie_aug++) != '\0') putchar(c); printf("\"\n"); printf(" Code alignment factor:\t%ju\n", (uintmax_t) cie_caf); printf(" Data alignment factor:\t%jd\n", (intmax_t) cie_daf); printf(" Return address column:\t%ju\n", (uintmax_t) cie_ra); putchar('\n'); dump_dwarf_frame_inst(re, cie, cie_inst, cie_instlen, cie_caf, cie_daf, 0, re->dbg); putchar('\n'); } else { printf(" \""); while ((c = *cie_aug++) != '\0') putchar(c); putchar('"'); printf(" cf=%ju df=%jd ra=%ju\n", (uintmax_t) cie_caf, (uintmax_t) cie_daf, (uintmax_t) cie_ra); dump_dwarf_frame_regtable(re, fde, low_pc, 1, cie_ra); putchar('\n'); } } printf("%08jx %08jx %08jx FDE cie=%08jx pc=%08jx..%08jx\n", (uintmax_t) fde_offset, (uintmax_t) fde_length, (uintmax_t) cie_offset, (uintmax_t) (eh_frame ? fde_offset + 4 - cie_offset : cie_offset), (uintmax_t) low_pc, (uintmax_t) (low_pc + func_len)); if (!alt) dump_dwarf_frame_inst(re, cie, fde_inst, fde_instlen, cie_caf, cie_daf, low_pc, re->dbg); else dump_dwarf_frame_regtable(re, fde, low_pc, func_len, cie_ra); putchar('\n'); } } static void dump_dwarf_frame(struct readelf *re, int alt) { struct section *s; int i; (void) dwarf_set_frame_cfa_value(re->dbg, DW_FRAME_CFA_COL); for (i = 0; (size_t) i < re->shnum; i++) { s = &re->sl[i]; if (s->name != NULL && (!strcmp(s->name, ".debug_frame") || !strcmp(s->name, ".eh_frame"))) dump_dwarf_frame_section(re, s, alt); } } static void dump_dwarf_str(struct readelf *re) { struct section *s; Elf_Data *d; unsigned char *p; int elferr, end, i, j; printf("\nContents of section .debug_str:\n"); s = NULL; for (i = 0; (size_t) i < re->shnum; i++) { s = &re->sl[i]; if (s->name != NULL && !strcmp(s->name, ".debug_str")) break; } if ((size_t) i >= re->shnum) return; (void) elf_errno(); if ((d = elf_getdata(s->scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("elf_getdata failed: %s", elf_errmsg(-1)); return; } if (d->d_size <= 0) return; for (i = 0, p = d->d_buf; (size_t) i < d->d_size; i += 16) { printf(" 0x%08x", (unsigned int) i); if ((size_t) i + 16 > d->d_size) end = d->d_size; else end = i + 16; for (j = i; j < i + 16; j++) { if ((j - i) % 4 == 0) putchar(' '); if (j >= end) { printf(" "); continue; } printf("%02x", (uint8_t) p[j]); } putchar(' '); for (j = i; j < end; j++) { if (isprint(p[j])) putchar(p[j]); else if (p[j] == 0) putchar('.'); else putchar(' '); } putchar('\n'); } } struct loc_at { Dwarf_Attribute la_at; Dwarf_Unsigned la_off; Dwarf_Unsigned la_lowpc; Dwarf_Half la_cu_psize; Dwarf_Half la_cu_osize; Dwarf_Half la_cu_ver; TAILQ_ENTRY(loc_at) la_next; }; static TAILQ_HEAD(, loc_at) lalist = TAILQ_HEAD_INITIALIZER(lalist); static void search_loclist_at(struct readelf *re, Dwarf_Die die, Dwarf_Unsigned lowpc) { Dwarf_Attribute *attr_list; Dwarf_Die ret_die; Dwarf_Unsigned off; Dwarf_Off ref; Dwarf_Signed attr_count; Dwarf_Half attr, form; Dwarf_Bool is_info; Dwarf_Error de; struct loc_at *la, *nla; int i, ret; is_info = dwarf_get_die_infotypes_flag(die); if ((ret = dwarf_attrlist(die, &attr_list, &attr_count, &de)) != DW_DLV_OK) { if (ret == DW_DLV_ERROR) warnx("dwarf_attrlist failed: %s", dwarf_errmsg(de)); goto cont_search; } for (i = 0; i < attr_count; i++) { if (dwarf_whatattr(attr_list[i], &attr, &de) != DW_DLV_OK) { warnx("dwarf_whatattr failed: %s", dwarf_errmsg(de)); continue; } if (attr != DW_AT_location && attr != DW_AT_string_length && attr != DW_AT_return_addr && attr != DW_AT_data_member_location && attr != DW_AT_frame_base && attr != DW_AT_segment && attr != DW_AT_static_link && attr != DW_AT_use_location && attr != DW_AT_vtable_elem_location) continue; if (dwarf_whatform(attr_list[i], &form, &de) != DW_DLV_OK) { warnx("dwarf_whatform failed: %s", dwarf_errmsg(de)); continue; } if (form == DW_FORM_data4 || form == DW_FORM_data8) { if (dwarf_formudata(attr_list[i], &off, &de) != DW_DLV_OK) { warnx("dwarf_formudata failed: %s", dwarf_errmsg(de)); continue; } } else if (form == DW_FORM_sec_offset) { if (dwarf_global_formref(attr_list[i], &ref, &de) != DW_DLV_OK) { warnx("dwarf_global_formref failed: %s", dwarf_errmsg(de)); continue; } off = ref; } else continue; TAILQ_FOREACH(la, &lalist, la_next) { if (off == la->la_off) break; if (off < la->la_off) { if ((nla = malloc(sizeof(*nla))) == NULL) err(EXIT_FAILURE, "malloc failed"); nla->la_at = attr_list[i]; nla->la_off = off; nla->la_lowpc = lowpc; nla->la_cu_psize = re->cu_psize; nla->la_cu_osize = re->cu_osize; nla->la_cu_ver = re->cu_ver; TAILQ_INSERT_BEFORE(la, nla, la_next); break; } } if (la == NULL) { if ((nla = malloc(sizeof(*nla))) == NULL) err(EXIT_FAILURE, "malloc failed"); nla->la_at = attr_list[i]; nla->la_off = off; nla->la_lowpc = lowpc; nla->la_cu_psize = re->cu_psize; nla->la_cu_osize = re->cu_osize; nla->la_cu_ver = re->cu_ver; TAILQ_INSERT_TAIL(&lalist, nla, la_next); } } cont_search: /* Search children. */ ret = dwarf_child(die, &ret_die, &de); if (ret == DW_DLV_ERROR) warnx("dwarf_child: %s", dwarf_errmsg(de)); else if (ret == DW_DLV_OK) search_loclist_at(re, ret_die, lowpc); /* Search sibling. */ ret = dwarf_siblingof_b(re->dbg, die, &ret_die, is_info, &de); if (ret == DW_DLV_ERROR) warnx("dwarf_siblingof: %s", dwarf_errmsg(de)); else if (ret == DW_DLV_OK) search_loclist_at(re, ret_die, lowpc); } static void dump_dwarf_loc(struct readelf *re, Dwarf_Loc *lr) { const char *op_str; char unk_op[32]; uint8_t *b, n; int i; if (dwarf_get_OP_name(lr->lr_atom, &op_str) != DW_DLV_OK) { snprintf(unk_op, sizeof(unk_op), "[Unknown OP: %#x]", lr->lr_atom); op_str = unk_op; } printf("%s", op_str); switch (lr->lr_atom) { case DW_OP_reg0: case DW_OP_reg1: case DW_OP_reg2: case DW_OP_reg3: case DW_OP_reg4: case DW_OP_reg5: case DW_OP_reg6: case DW_OP_reg7: case DW_OP_reg8: case DW_OP_reg9: case DW_OP_reg10: case DW_OP_reg11: case DW_OP_reg12: case DW_OP_reg13: case DW_OP_reg14: case DW_OP_reg15: case DW_OP_reg16: case DW_OP_reg17: case DW_OP_reg18: case DW_OP_reg19: case DW_OP_reg20: case DW_OP_reg21: case DW_OP_reg22: case DW_OP_reg23: case DW_OP_reg24: case DW_OP_reg25: case DW_OP_reg26: case DW_OP_reg27: case DW_OP_reg28: case DW_OP_reg29: case DW_OP_reg30: case DW_OP_reg31: printf(" (%s)", dwarf_regname(re, lr->lr_atom - DW_OP_reg0)); break; case DW_OP_deref: case DW_OP_lit0: case DW_OP_lit1: case DW_OP_lit2: case DW_OP_lit3: case DW_OP_lit4: case DW_OP_lit5: case DW_OP_lit6: case DW_OP_lit7: case DW_OP_lit8: case DW_OP_lit9: case DW_OP_lit10: case DW_OP_lit11: case DW_OP_lit12: case DW_OP_lit13: case DW_OP_lit14: case DW_OP_lit15: case DW_OP_lit16: case DW_OP_lit17: case DW_OP_lit18: case DW_OP_lit19: case DW_OP_lit20: case DW_OP_lit21: case DW_OP_lit22: case DW_OP_lit23: case DW_OP_lit24: case DW_OP_lit25: case DW_OP_lit26: case DW_OP_lit27: case DW_OP_lit28: case DW_OP_lit29: case DW_OP_lit30: case DW_OP_lit31: case DW_OP_dup: case DW_OP_drop: case DW_OP_over: case DW_OP_swap: case DW_OP_rot: case DW_OP_xderef: case DW_OP_abs: case DW_OP_and: case DW_OP_div: case DW_OP_minus: case DW_OP_mod: case DW_OP_mul: case DW_OP_neg: case DW_OP_not: case DW_OP_or: case DW_OP_plus: case DW_OP_shl: case DW_OP_shr: case DW_OP_shra: case DW_OP_xor: case DW_OP_eq: case DW_OP_ge: case DW_OP_gt: case DW_OP_le: case DW_OP_lt: case DW_OP_ne: case DW_OP_nop: case DW_OP_push_object_address: case DW_OP_form_tls_address: case DW_OP_call_frame_cfa: case DW_OP_stack_value: case DW_OP_GNU_push_tls_address: case DW_OP_GNU_uninit: break; case DW_OP_const1u: case DW_OP_pick: case DW_OP_deref_size: case DW_OP_xderef_size: case DW_OP_const2u: case DW_OP_bra: case DW_OP_skip: case DW_OP_const4u: case DW_OP_const8u: case DW_OP_constu: case DW_OP_plus_uconst: case DW_OP_regx: case DW_OP_piece: printf(": %ju", (uintmax_t) lr->lr_number); break; case DW_OP_const1s: case DW_OP_const2s: case DW_OP_const4s: case DW_OP_const8s: case DW_OP_consts: printf(": %jd", (intmax_t) lr->lr_number); break; case DW_OP_breg0: case DW_OP_breg1: case DW_OP_breg2: case DW_OP_breg3: case DW_OP_breg4: case DW_OP_breg5: case DW_OP_breg6: case DW_OP_breg7: case DW_OP_breg8: case DW_OP_breg9: case DW_OP_breg10: case DW_OP_breg11: case DW_OP_breg12: case DW_OP_breg13: case DW_OP_breg14: case DW_OP_breg15: case DW_OP_breg16: case DW_OP_breg17: case DW_OP_breg18: case DW_OP_breg19: case DW_OP_breg20: case DW_OP_breg21: case DW_OP_breg22: case DW_OP_breg23: case DW_OP_breg24: case DW_OP_breg25: case DW_OP_breg26: case DW_OP_breg27: case DW_OP_breg28: case DW_OP_breg29: case DW_OP_breg30: case DW_OP_breg31: printf(" (%s): %jd", dwarf_regname(re, lr->lr_atom - DW_OP_breg0), (intmax_t) lr->lr_number); break; case DW_OP_fbreg: printf(": %jd", (intmax_t) lr->lr_number); break; case DW_OP_bregx: printf(": %ju (%s) %jd", (uintmax_t) lr->lr_number, dwarf_regname(re, (unsigned int) lr->lr_number), (intmax_t) lr->lr_number2); break; case DW_OP_addr: case DW_OP_GNU_encoded_addr: printf(": %#jx", (uintmax_t) lr->lr_number); break; case DW_OP_GNU_implicit_pointer: printf(": <0x%jx> %jd", (uintmax_t) lr->lr_number, (intmax_t) lr->lr_number2); break; case DW_OP_implicit_value: printf(": %ju byte block:", (uintmax_t) lr->lr_number); b = (uint8_t *)(uintptr_t) lr->lr_number2; for (i = 0; (Dwarf_Unsigned) i < lr->lr_number; i++) printf(" %x", b[i]); break; case DW_OP_GNU_entry_value: printf(": ("); dump_dwarf_block(re, (uint8_t *)(uintptr_t) lr->lr_number2, lr->lr_number); putchar(')'); break; case DW_OP_GNU_const_type: printf(": <0x%jx> ", (uintmax_t) lr->lr_number); b = (uint8_t *)(uintptr_t) lr->lr_number2; n = *b; for (i = 1; (uint8_t) i < n; i++) printf(" %x", b[i]); break; case DW_OP_GNU_regval_type: printf(": %ju (%s) <0x%jx>", (uintmax_t) lr->lr_number, dwarf_regname(re, (unsigned int) lr->lr_number), (uintmax_t) lr->lr_number2); break; case DW_OP_GNU_convert: case DW_OP_GNU_deref_type: case DW_OP_GNU_parameter_ref: case DW_OP_GNU_reinterpret: printf(": <0x%jx>", (uintmax_t) lr->lr_number); break; default: break; } } static void dump_dwarf_block(struct readelf *re, uint8_t *b, Dwarf_Unsigned len) { Dwarf_Locdesc *llbuf; Dwarf_Signed lcnt; Dwarf_Error de; int i; if (dwarf_loclist_from_expr_b(re->dbg, b, len, re->cu_psize, re->cu_osize, re->cu_ver, &llbuf, &lcnt, &de) != DW_DLV_OK) { warnx("dwarf_loclist_form_expr_b: %s", dwarf_errmsg(de)); return; } for (i = 0; (Dwarf_Half) i < llbuf->ld_cents; i++) { dump_dwarf_loc(re, &llbuf->ld_s[i]); if (i < llbuf->ld_cents - 1) printf("; "); } dwarf_dealloc(re->dbg, llbuf->ld_s, DW_DLA_LOC_BLOCK); dwarf_dealloc(re->dbg, llbuf, DW_DLA_LOCDESC); } static void dump_dwarf_loclist(struct readelf *re) { Dwarf_Die die; Dwarf_Locdesc **llbuf; Dwarf_Unsigned lowpc; Dwarf_Signed lcnt; Dwarf_Half tag, version, pointer_size, off_size; Dwarf_Error de; struct loc_at *la; int i, j, ret; printf("\nContents of section .debug_loc:\n"); /* Search .debug_info section. */ while ((ret = dwarf_next_cu_header_b(re->dbg, NULL, &version, NULL, &pointer_size, &off_size, NULL, NULL, &de)) == DW_DLV_OK) { set_cu_context(re, pointer_size, off_size, version); die = NULL; if (dwarf_siblingof(re->dbg, die, &die, &de) != DW_DLV_OK) continue; if (dwarf_tag(die, &tag, &de) != DW_DLV_OK) { warnx("dwarf_tag failed: %s", dwarf_errmsg(de)); continue; } /* XXX: What about DW_TAG_partial_unit? */ lowpc = 0; if (tag == DW_TAG_compile_unit) { if (dwarf_attrval_unsigned(die, DW_AT_low_pc, &lowpc, &de) != DW_DLV_OK) lowpc = 0; } /* Search attributes for reference to .debug_loc section. */ search_loclist_at(re, die, lowpc); } if (ret == DW_DLV_ERROR) warnx("dwarf_next_cu_header: %s", dwarf_errmsg(de)); /* Search .debug_types section. */ do { while ((ret = dwarf_next_cu_header_c(re->dbg, 0, NULL, &version, NULL, &pointer_size, &off_size, NULL, NULL, NULL, NULL, &de)) == DW_DLV_OK) { set_cu_context(re, pointer_size, off_size, version); die = NULL; if (dwarf_siblingof(re->dbg, die, &die, &de) != DW_DLV_OK) continue; if (dwarf_tag(die, &tag, &de) != DW_DLV_OK) { warnx("dwarf_tag failed: %s", dwarf_errmsg(de)); continue; } lowpc = 0; if (tag == DW_TAG_type_unit) { if (dwarf_attrval_unsigned(die, DW_AT_low_pc, &lowpc, &de) != DW_DLV_OK) lowpc = 0; } /* * Search attributes for reference to .debug_loc * section. */ search_loclist_at(re, die, lowpc); } if (ret == DW_DLV_ERROR) warnx("dwarf_next_cu_header: %s", dwarf_errmsg(de)); } while (dwarf_next_types_section(re->dbg, &de) == DW_DLV_OK); if (TAILQ_EMPTY(&lalist)) return; printf(" Offset Begin End Expression\n"); TAILQ_FOREACH(la, &lalist, la_next) { if (dwarf_loclist_n(la->la_at, &llbuf, &lcnt, &de) != DW_DLV_OK) { warnx("dwarf_loclist_n failed: %s", dwarf_errmsg(de)); continue; } set_cu_context(re, la->la_cu_psize, la->la_cu_osize, la->la_cu_ver); for (i = 0; i < lcnt; i++) { printf(" %8.8jx ", (uintmax_t) la->la_off); if (llbuf[i]->ld_lopc == 0 && llbuf[i]->ld_hipc == 0) { printf("\n"); continue; } /* TODO: handle base selection entry. */ printf("%8.8jx %8.8jx ", (uintmax_t) (la->la_lowpc + llbuf[i]->ld_lopc), (uintmax_t) (la->la_lowpc + llbuf[i]->ld_hipc)); putchar('('); for (j = 0; (Dwarf_Half) j < llbuf[i]->ld_cents; j++) { dump_dwarf_loc(re, &llbuf[i]->ld_s[j]); if (j < llbuf[i]->ld_cents - 1) printf("; "); } putchar(')'); if (llbuf[i]->ld_lopc == llbuf[i]->ld_hipc) printf(" (start == end)"); putchar('\n'); } for (i = 0; i < lcnt; i++) { dwarf_dealloc(re->dbg, llbuf[i]->ld_s, DW_DLA_LOC_BLOCK); dwarf_dealloc(re->dbg, llbuf[i], DW_DLA_LOCDESC); } dwarf_dealloc(re->dbg, llbuf, DW_DLA_LIST); } } /* * Retrieve a string using string table section index and the string offset. */ static const char* get_string(struct readelf *re, int strtab, size_t off) { const char *name; if ((name = elf_strptr(re->elf, strtab, off)) == NULL) return (""); return (name); } /* * Retrieve the name of a symbol using the section index of the symbol * table and the index of the symbol within that table. */ static const char * get_symbol_name(struct readelf *re, int symtab, int i) { struct section *s; const char *name; GElf_Sym sym; Elf_Data *data; int elferr; s = &re->sl[symtab]; if (s->type != SHT_SYMTAB && s->type != SHT_DYNSYM) return (""); (void) elf_errno(); if ((data = elf_getdata(s->scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("elf_getdata failed: %s", elf_errmsg(elferr)); return (""); } if (gelf_getsym(data, i, &sym) != &sym) return (""); /* Return section name for STT_SECTION symbol. */ - if (GELF_ST_TYPE(sym.st_info) == STT_SECTION && - re->sl[sym.st_shndx].name != NULL) - return (re->sl[sym.st_shndx].name); + if (GELF_ST_TYPE(sym.st_info) == STT_SECTION) { + if (sym.st_shndx < re->shnum && + re->sl[sym.st_shndx].name != NULL) + return (re->sl[sym.st_shndx].name); + return (""); + } if (s->link >= re->shnum || (name = elf_strptr(re->elf, s->link, sym.st_name)) == NULL) return (""); return (name); } static uint64_t get_symbol_value(struct readelf *re, int symtab, int i) { struct section *s; GElf_Sym sym; Elf_Data *data; int elferr; s = &re->sl[symtab]; if (s->type != SHT_SYMTAB && s->type != SHT_DYNSYM) return (0); (void) elf_errno(); if ((data = elf_getdata(s->scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("elf_getdata failed: %s", elf_errmsg(elferr)); return (0); } if (gelf_getsym(data, i, &sym) != &sym) return (0); return (sym.st_value); } static void hex_dump(struct readelf *re) { struct section *s; Elf_Data *d; uint8_t *buf; size_t sz, nbytes; uint64_t addr; int elferr, i, j; for (i = 1; (size_t) i < re->shnum; i++) { s = &re->sl[i]; if (find_dumpop(re, (size_t) i, s->name, HEX_DUMP, -1) == NULL) continue; (void) elf_errno(); if ((d = elf_getdata(s->scn, NULL)) == NULL && (d = elf_rawdata(s->scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("elf_getdata failed: %s", elf_errmsg(elferr)); continue; } (void) elf_errno(); if (d->d_size <= 0 || d->d_buf == NULL) { printf("\nSection '%s' has no data to dump.\n", s->name); continue; } buf = d->d_buf; sz = d->d_size; addr = s->addr; printf("\nHex dump of section '%s':\n", s->name); while (sz > 0) { printf(" 0x%8.8jx ", (uintmax_t)addr); nbytes = sz > 16? 16 : sz; for (j = 0; j < 16; j++) { if ((size_t)j < nbytes) printf("%2.2x", buf[j]); else printf(" "); if ((j & 3) == 3) printf(" "); } for (j = 0; (size_t)j < nbytes; j++) { if (isprint(buf[j])) printf("%c", buf[j]); else printf("."); } printf("\n"); buf += nbytes; addr += nbytes; sz -= nbytes; } } } static void str_dump(struct readelf *re) { struct section *s; Elf_Data *d; unsigned char *start, *end, *buf_end; unsigned int len; int i, j, elferr, found; for (i = 1; (size_t) i < re->shnum; i++) { s = &re->sl[i]; if (find_dumpop(re, (size_t) i, s->name, STR_DUMP, -1) == NULL) continue; (void) elf_errno(); if ((d = elf_getdata(s->scn, NULL)) == NULL && (d = elf_rawdata(s->scn, NULL)) == NULL) { elferr = elf_errno(); if (elferr != 0) warnx("elf_getdata failed: %s", elf_errmsg(elferr)); continue; } (void) elf_errno(); if (d->d_size <= 0 || d->d_buf == NULL) { printf("\nSection '%s' has no data to dump.\n", s->name); continue; } buf_end = (unsigned char *) d->d_buf + d->d_size; start = (unsigned char *) d->d_buf; found = 0; printf("\nString dump of section '%s':\n", s->name); for (;;) { while (start < buf_end && !isprint(*start)) start++; if (start >= buf_end) break; end = start + 1; while (end < buf_end && isprint(*end)) end++; printf(" [%6lx] ", (long) (start - (unsigned char *) d->d_buf)); len = end - start; for (j = 0; (unsigned int) j < len; j++) putchar(start[j]); putchar('\n'); found = 1; if (end >= buf_end) break; start = end + 1; } if (!found) printf(" No strings found in this section."); putchar('\n'); } } static void load_sections(struct readelf *re) { struct section *s; const char *name; Elf_Scn *scn; GElf_Shdr sh; size_t shstrndx, ndx; int elferr; /* Allocate storage for internal section list. */ if (!elf_getshnum(re->elf, &re->shnum)) { warnx("elf_getshnum failed: %s", elf_errmsg(-1)); return; } if (re->sl != NULL) free(re->sl); if ((re->sl = calloc(re->shnum, sizeof(*re->sl))) == NULL) err(EXIT_FAILURE, "calloc failed"); /* Get the index of .shstrtab section. */ if (!elf_getshstrndx(re->elf, &shstrndx)) { warnx("elf_getshstrndx failed: %s", elf_errmsg(-1)); return; } if ((scn = elf_getscn(re->elf, 0)) == NULL) return; (void) elf_errno(); do { if (gelf_getshdr(scn, &sh) == NULL) { warnx("gelf_getshdr failed: %s", elf_errmsg(-1)); (void) elf_errno(); continue; } if ((name = elf_strptr(re->elf, shstrndx, sh.sh_name)) == NULL) { (void) elf_errno(); name = "ERROR"; } if ((ndx = elf_ndxscn(scn)) == SHN_UNDEF) { if ((elferr = elf_errno()) != 0) warnx("elf_ndxscn failed: %s", elf_errmsg(elferr)); continue; } if (ndx >= re->shnum) { warnx("section index of '%s' out of range", name); continue; } if (sh.sh_link >= re->shnum) warnx("section link %llu of '%s' out of range", (unsigned long long)sh.sh_link, name); s = &re->sl[ndx]; s->name = name; s->scn = scn; s->off = sh.sh_offset; s->sz = sh.sh_size; s->entsize = sh.sh_entsize; s->align = sh.sh_addralign; s->type = sh.sh_type; s->flags = sh.sh_flags; s->addr = sh.sh_addr; s->link = sh.sh_link; s->info = sh.sh_info; } while ((scn = elf_nextscn(re->elf, scn)) != NULL); elferr = elf_errno(); if (elferr != 0) warnx("elf_nextscn failed: %s", elf_errmsg(elferr)); } static void unload_sections(struct readelf *re) { if (re->sl != NULL) { free(re->sl); re->sl = NULL; } re->shnum = 0; re->vd_s = NULL; re->vn_s = NULL; re->vs_s = NULL; re->vs = NULL; re->vs_sz = 0; if (re->ver != NULL) { free(re->ver); re->ver = NULL; re->ver_sz = 0; } } static void dump_elf(struct readelf *re) { /* Fetch ELF header. No need to continue if it fails. */ if (gelf_getehdr(re->elf, &re->ehdr) == NULL) { warnx("gelf_getehdr failed: %s", elf_errmsg(-1)); return; } if ((re->ec = gelf_getclass(re->elf)) == ELFCLASSNONE) { warnx("gelf_getclass failed: %s", elf_errmsg(-1)); return; } if (re->ehdr.e_ident[EI_DATA] == ELFDATA2MSB) { re->dw_read = _read_msb; re->dw_decode = _decode_msb; } else { re->dw_read = _read_lsb; re->dw_decode = _decode_lsb; } if (re->options & ~RE_H) load_sections(re); if ((re->options & RE_VV) || (re->options & RE_S)) search_ver(re); if (re->options & RE_H) dump_ehdr(re); if (re->options & RE_L) dump_phdr(re); if (re->options & RE_SS) dump_shdr(re); if (re->options & RE_G) dump_section_groups(re); if (re->options & RE_D) dump_dynamic(re); if (re->options & RE_R) dump_reloc(re); if (re->options & RE_S) dump_symtabs(re); if (re->options & RE_N) dump_notes(re); if (re->options & RE_II) dump_hash(re); if (re->options & RE_X) hex_dump(re); if (re->options & RE_P) str_dump(re); if (re->options & RE_VV) dump_ver(re); if (re->options & RE_AA) dump_arch_specific_info(re); if (re->options & RE_W) dump_dwarf(re); if (re->options & ~RE_H) unload_sections(re); } static void dump_dwarf(struct readelf *re) { int error; Dwarf_Error de; if (dwarf_elf_init(re->elf, DW_DLC_READ, NULL, NULL, &re->dbg, &de)) { if ((error = dwarf_errno(de)) != DW_DLE_DEBUG_INFO_NULL) errx(EXIT_FAILURE, "dwarf_elf_init failed: %s", dwarf_errmsg(de)); return; } if (re->dop & DW_A) dump_dwarf_abbrev(re); if (re->dop & DW_L) dump_dwarf_line(re); if (re->dop & DW_LL) dump_dwarf_line_decoded(re); if (re->dop & DW_I) { dump_dwarf_info(re, 0); dump_dwarf_info(re, 1); } if (re->dop & DW_P) dump_dwarf_pubnames(re); if (re->dop & DW_R) dump_dwarf_aranges(re); if (re->dop & DW_RR) dump_dwarf_ranges(re); if (re->dop & DW_M) dump_dwarf_macinfo(re); if (re->dop & DW_F) dump_dwarf_frame(re, 0); else if (re->dop & DW_FF) dump_dwarf_frame(re, 1); if (re->dop & DW_S) dump_dwarf_str(re); if (re->dop & DW_O) dump_dwarf_loclist(re); dwarf_finish(re->dbg, &de); } static void dump_ar(struct readelf *re, int fd) { Elf_Arsym *arsym; Elf_Arhdr *arhdr; Elf_Cmd cmd; Elf *e; size_t sz; off_t off; int i; re->ar = re->elf; if (re->options & RE_C) { if ((arsym = elf_getarsym(re->ar, &sz)) == NULL) { warnx("elf_getarsym() failed: %s", elf_errmsg(-1)); goto process_members; } printf("Index of archive %s: (%ju entries)\n", re->filename, (uintmax_t) sz - 1); off = 0; for (i = 0; (size_t) i < sz; i++) { if (arsym[i].as_name == NULL) break; if (arsym[i].as_off != off) { off = arsym[i].as_off; if (elf_rand(re->ar, off) != off) { warnx("elf_rand() failed: %s", elf_errmsg(-1)); continue; } if ((e = elf_begin(fd, ELF_C_READ, re->ar)) == NULL) { warnx("elf_begin() failed: %s", elf_errmsg(-1)); continue; } if ((arhdr = elf_getarhdr(e)) == NULL) { warnx("elf_getarhdr() failed: %s", elf_errmsg(-1)); elf_end(e); continue; } printf("Binary %s(%s) contains:\n", re->filename, arhdr->ar_name); } printf("\t%s\n", arsym[i].as_name); } if (elf_rand(re->ar, SARMAG) != SARMAG) { warnx("elf_rand() failed: %s", elf_errmsg(-1)); return; } } process_members: if ((re->options & ~RE_C) == 0) return; cmd = ELF_C_READ; while ((re->elf = elf_begin(fd, cmd, re->ar)) != NULL) { if ((arhdr = elf_getarhdr(re->elf)) == NULL) { warnx("elf_getarhdr() failed: %s", elf_errmsg(-1)); goto next_member; } if (strcmp(arhdr->ar_name, "/") == 0 || strcmp(arhdr->ar_name, "//") == 0 || strcmp(arhdr->ar_name, "__.SYMDEF") == 0) goto next_member; printf("\nFile: %s(%s)\n", re->filename, arhdr->ar_name); dump_elf(re); next_member: cmd = elf_next(re->elf); elf_end(re->elf); } re->elf = re->ar; } static void dump_object(struct readelf *re) { int fd; if ((fd = open(re->filename, O_RDONLY)) == -1) { warn("open %s failed", re->filename); return; } if ((re->flags & DISPLAY_FILENAME) != 0) printf("\nFile: %s\n", re->filename); if ((re->elf = elf_begin(fd, ELF_C_READ, NULL)) == NULL) { warnx("elf_begin() failed: %s", elf_errmsg(-1)); return; } switch (elf_kind(re->elf)) { case ELF_K_NONE: warnx("Not an ELF file."); return; case ELF_K_ELF: dump_elf(re); break; case ELF_K_AR: dump_ar(re, fd); break; default: warnx("Internal: libelf returned unknown elf kind."); return; } elf_end(re->elf); } static void add_dumpop(struct readelf *re, size_t si, const char *sn, int op, int t) { struct dumpop *d; if ((d = find_dumpop(re, si, sn, -1, t)) == NULL) { if ((d = calloc(1, sizeof(*d))) == NULL) err(EXIT_FAILURE, "calloc failed"); if (t == DUMP_BY_INDEX) d->u.si = si; else d->u.sn = sn; d->type = t; d->op = op; STAILQ_INSERT_TAIL(&re->v_dumpop, d, dumpop_list); } else d->op |= op; } static struct dumpop * find_dumpop(struct readelf *re, size_t si, const char *sn, int op, int t) { struct dumpop *d; STAILQ_FOREACH(d, &re->v_dumpop, dumpop_list) { if ((op == -1 || op & d->op) && (t == -1 || (unsigned) t == d->type)) { if ((d->type == DUMP_BY_INDEX && d->u.si == si) || (d->type == DUMP_BY_NAME && !strcmp(d->u.sn, sn))) return (d); } } return (NULL); } static struct { const char *ln; char sn; int value; } dwarf_op[] = { {"rawline", 'l', DW_L}, {"decodedline", 'L', DW_LL}, {"info", 'i', DW_I}, {"abbrev", 'a', DW_A}, {"pubnames", 'p', DW_P}, {"aranges", 'r', DW_R}, {"ranges", 'r', DW_R}, {"Ranges", 'R', DW_RR}, {"macro", 'm', DW_M}, {"frames", 'f', DW_F}, {"frames-interp", 'F', DW_FF}, {"str", 's', DW_S}, {"loc", 'o', DW_O}, {NULL, 0, 0} }; static void parse_dwarf_op_short(struct readelf *re, const char *op) { int i; if (op == NULL) { re->dop |= DW_DEFAULT_OPTIONS; return; } for (; *op != '\0'; op++) { for (i = 0; dwarf_op[i].ln != NULL; i++) { if (dwarf_op[i].sn == *op) { re->dop |= dwarf_op[i].value; break; } } } } static void parse_dwarf_op_long(struct readelf *re, const char *op) { char *p, *token, *bp; int i; if (op == NULL) { re->dop |= DW_DEFAULT_OPTIONS; return; } if ((p = strdup(op)) == NULL) err(EXIT_FAILURE, "strdup failed"); bp = p; while ((token = strsep(&p, ",")) != NULL) { for (i = 0; dwarf_op[i].ln != NULL; i++) { if (!strcmp(token, dwarf_op[i].ln)) { re->dop |= dwarf_op[i].value; break; } } } free(bp); } static uint64_t _read_lsb(Elf_Data *d, uint64_t *offsetp, int bytes_to_read) { uint64_t ret; uint8_t *src; src = (uint8_t *) d->d_buf + *offsetp; ret = 0; switch (bytes_to_read) { case 8: ret |= ((uint64_t) src[4]) << 32 | ((uint64_t) src[5]) << 40; ret |= ((uint64_t) src[6]) << 48 | ((uint64_t) src[7]) << 56; /* FALLTHROUGH */ case 4: ret |= ((uint64_t) src[2]) << 16 | ((uint64_t) src[3]) << 24; /* FALLTHROUGH */ case 2: ret |= ((uint64_t) src[1]) << 8; /* FALLTHROUGH */ case 1: ret |= src[0]; break; default: return (0); } *offsetp += bytes_to_read; return (ret); } static uint64_t _read_msb(Elf_Data *d, uint64_t *offsetp, int bytes_to_read) { uint64_t ret; uint8_t *src; src = (uint8_t *) d->d_buf + *offsetp; switch (bytes_to_read) { case 1: ret = src[0]; break; case 2: ret = src[1] | ((uint64_t) src[0]) << 8; break; case 4: ret = src[3] | ((uint64_t) src[2]) << 8; ret |= ((uint64_t) src[1]) << 16 | ((uint64_t) src[0]) << 24; break; case 8: ret = src[7] | ((uint64_t) src[6]) << 8; ret |= ((uint64_t) src[5]) << 16 | ((uint64_t) src[4]) << 24; ret |= ((uint64_t) src[3]) << 32 | ((uint64_t) src[2]) << 40; ret |= ((uint64_t) src[1]) << 48 | ((uint64_t) src[0]) << 56; break; default: return (0); } *offsetp += bytes_to_read; return (ret); } static uint64_t _decode_lsb(uint8_t **data, int bytes_to_read) { uint64_t ret; uint8_t *src; src = *data; ret = 0; switch (bytes_to_read) { case 8: ret |= ((uint64_t) src[4]) << 32 | ((uint64_t) src[5]) << 40; ret |= ((uint64_t) src[6]) << 48 | ((uint64_t) src[7]) << 56; /* FALLTHROUGH */ case 4: ret |= ((uint64_t) src[2]) << 16 | ((uint64_t) src[3]) << 24; /* FALLTHROUGH */ case 2: ret |= ((uint64_t) src[1]) << 8; /* FALLTHROUGH */ case 1: ret |= src[0]; break; default: return (0); } *data += bytes_to_read; return (ret); } static uint64_t _decode_msb(uint8_t **data, int bytes_to_read) { uint64_t ret; uint8_t *src; src = *data; ret = 0; switch (bytes_to_read) { case 1: ret = src[0]; break; case 2: ret = src[1] | ((uint64_t) src[0]) << 8; break; case 4: ret = src[3] | ((uint64_t) src[2]) << 8; ret |= ((uint64_t) src[1]) << 16 | ((uint64_t) src[0]) << 24; break; case 8: ret = src[7] | ((uint64_t) src[6]) << 8; ret |= ((uint64_t) src[5]) << 16 | ((uint64_t) src[4]) << 24; ret |= ((uint64_t) src[3]) << 32 | ((uint64_t) src[2]) << 40; ret |= ((uint64_t) src[1]) << 48 | ((uint64_t) src[0]) << 56; break; default: return (0); break; } *data += bytes_to_read; return (ret); } static int64_t _decode_sleb128(uint8_t **dp, uint8_t *dpe) { int64_t ret = 0; uint8_t b = 0; int shift = 0; uint8_t *src = *dp; do { if (src >= dpe) break; b = *src++; ret |= ((b & 0x7f) << shift); shift += 7; } while ((b & 0x80) != 0); if (shift < 32 && (b & 0x40) != 0) ret |= (-1 << shift); *dp = src; return (ret); } static uint64_t _decode_uleb128(uint8_t **dp, uint8_t *dpe) { uint64_t ret = 0; uint8_t b; int shift = 0; uint8_t *src = *dp; do { if (src >= dpe) break; b = *src++; ret |= ((b & 0x7f) << shift); shift += 7; } while ((b & 0x80) != 0); *dp = src; return (ret); } static void readelf_version(void) { (void) printf("%s (%s)\n", ELFTC_GETPROGNAME(), elftc_version()); exit(EXIT_SUCCESS); } #define USAGE_MESSAGE "\ Usage: %s [options] file...\n\ Display information about ELF objects and ar(1) archives.\n\n\ Options:\n\ -a | --all Equivalent to specifying options '-dhIlrsASV'.\n\ -c | --archive-index Print the archive symbol table for archives.\n\ -d | --dynamic Print the contents of SHT_DYNAMIC sections.\n\ -e | --headers Print all headers in the object.\n\ -g | --section-groups Print the contents of the section groups.\n\ -h | --file-header Print the file header for the object.\n\ -l | --program-headers Print the PHDR table for the object.\n\ -n | --notes Print the contents of SHT_NOTE sections.\n\ -p INDEX | --string-dump=INDEX\n\ Print the contents of section at index INDEX.\n\ -r | --relocs Print relocation information.\n\ -s | --syms | --symbols Print symbol tables.\n\ -t | --section-details Print additional information about sections.\n\ -v | --version Print a version identifier and exit.\n\ -w[afilmoprsFLR] | --debug-dump={abbrev,aranges,decodedline,frames,\n\ frames-interp,info,loc,macro,pubnames,\n\ ranges,Ranges,rawline,str}\n\ Display DWARF information.\n\ -x INDEX | --hex-dump=INDEX\n\ Display contents of a section as hexadecimal.\n\ -A | --arch-specific (accepted, but ignored)\n\ -D | --use-dynamic Print the symbol table specified by the DT_SYMTAB\n\ entry in the \".dynamic\" section.\n\ -H | --help Print a help message.\n\ -I | --histogram Print information on bucket list lengths for \n\ hash sections.\n\ -N | --full-section-name (accepted, but ignored)\n\ -S | --sections | --section-headers\n\ Print information about section headers.\n\ -V | --version-info Print symbol versoning information.\n\ -W | --wide Print information without wrapping long lines.\n" static void readelf_usage(int status) { fprintf(stderr, USAGE_MESSAGE, ELFTC_GETPROGNAME()); exit(status); } int main(int argc, char **argv) { struct readelf *re, re_storage; unsigned long si; int opt, i; char *ep; re = &re_storage; memset(re, 0, sizeof(*re)); STAILQ_INIT(&re->v_dumpop); while ((opt = getopt_long(argc, argv, "AacDdegHhIi:lNnp:rSstuVvWw::x:", longopts, NULL)) != -1) { switch(opt) { case '?': readelf_usage(EXIT_SUCCESS); break; case 'A': re->options |= RE_AA; break; case 'a': re->options |= RE_AA | RE_D | RE_G | RE_H | RE_II | RE_L | RE_R | RE_SS | RE_S | RE_VV; break; case 'c': re->options |= RE_C; break; case 'D': re->options |= RE_DD; break; case 'd': re->options |= RE_D; break; case 'e': re->options |= RE_H | RE_L | RE_SS; break; case 'g': re->options |= RE_G; break; case 'H': readelf_usage(EXIT_SUCCESS); break; case 'h': re->options |= RE_H; break; case 'I': re->options |= RE_II; break; case 'i': /* Not implemented yet. */ break; case 'l': re->options |= RE_L; break; case 'N': re->options |= RE_NN; break; case 'n': re->options |= RE_N; break; case 'p': re->options |= RE_P; si = strtoul(optarg, &ep, 10); if (*ep == '\0') add_dumpop(re, (size_t) si, NULL, STR_DUMP, DUMP_BY_INDEX); else add_dumpop(re, 0, optarg, STR_DUMP, DUMP_BY_NAME); break; case 'r': re->options |= RE_R; break; case 'S': re->options |= RE_SS; break; case 's': re->options |= RE_S; break; case 't': re->options |= RE_T; break; case 'u': re->options |= RE_U; break; case 'V': re->options |= RE_VV; break; case 'v': readelf_version(); break; case 'W': re->options |= RE_WW; break; case 'w': re->options |= RE_W; parse_dwarf_op_short(re, optarg); break; case 'x': re->options |= RE_X; si = strtoul(optarg, &ep, 10); if (*ep == '\0') add_dumpop(re, (size_t) si, NULL, HEX_DUMP, DUMP_BY_INDEX); else add_dumpop(re, 0, optarg, HEX_DUMP, DUMP_BY_NAME); break; case OPTION_DEBUG_DUMP: re->options |= RE_W; parse_dwarf_op_long(re, optarg); } } argv += optind; argc -= optind; if (argc == 0 || re->options == 0) readelf_usage(EXIT_FAILURE); if (argc > 1) re->flags |= DISPLAY_FILENAME; if (elf_version(EV_CURRENT) == EV_NONE) errx(EXIT_FAILURE, "ELF library initialization failed: %s", elf_errmsg(-1)); for (i = 0; i < argc; i++) { re->filename = argv[i]; dump_object(re); } exit(EXIT_SUCCESS); } Index: vendor/elftoolchain/dist/size/size.c =================================================================== --- vendor/elftoolchain/dist/size/size.c (revision 300227) +++ vendor/elftoolchain/dist/size/size.c (revision 300228) @@ -1,912 +1,925 @@ /*- * Copyright (c) 2007 S.Sam Arun Raj * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #include #include #include #include #include #include #include #include #include #include #include "_elftc.h" -ELFTC_VCSID("$Id: size.c 3242 2015-08-07 12:47:11Z emaste $"); +ELFTC_VCSID("$Id: size.c 3458 2016-05-09 15:01:25Z emaste $"); #define BUF_SIZE 1024 #define ELF_ALIGN(val,x) (((val)+(x)-1) & ~((x)-1)) #define SIZE_VERSION_STRING "size 1.0" enum return_code { RETURN_OK, RETURN_NOINPUT, RETURN_DATAERR, RETURN_USAGE }; enum output_style { STYLE_BERKELEY, STYLE_SYSV }; enum radix_style { RADIX_OCTAL, RADIX_DECIMAL, RADIX_HEX }; static uint64_t bss_size, data_size, text_size, total_size; static uint64_t bss_size_total, data_size_total, text_size_total; static int show_totals; static int size_option; static enum radix_style radix = RADIX_DECIMAL; static enum output_style style = STYLE_BERKELEY; static const char *default_args[2] = { "a.out", NULL }; static struct { int row; int col; int *width; char ***tbl; } *tb; enum { OPT_FORMAT, OPT_RADIX }; static struct option size_longopts[] = { { "format", required_argument, &size_option, OPT_FORMAT }, { "help", no_argument, NULL, 'h' }, { "radix", required_argument, &size_option, OPT_RADIX }, { "totals", no_argument, NULL, 't' }, { "version", no_argument, NULL, 'V' }, { NULL, 0, NULL, 0 } }; static void berkeley_calc(GElf_Shdr *); static void berkeley_footer(const char *, const char *, const char *); static void berkeley_header(void); static void berkeley_totals(void); static int handle_core(char const *, Elf *elf, GElf_Ehdr *); static void handle_core_note(Elf *, GElf_Ehdr *, GElf_Phdr *, char **); static int handle_elf(char const *); static void handle_phdr(Elf *, GElf_Ehdr *, GElf_Phdr *, uint32_t, const char *); static void show_version(void); static void sysv_header(const char *, Elf_Arhdr *); static void sysv_footer(void); static void sysv_calc(Elf *, GElf_Ehdr *, GElf_Shdr *); static void usage(void); static void tbl_new(int); static void tbl_print(const char *, int); static void tbl_print_num(uint64_t, enum radix_style, int); static void tbl_append(void); static void tbl_flush(void); /* * size utility using elf(3) and gelf(3) API to list section sizes and * total in elf files. Supports only elf files (core dumps in elf * included) that can be opened by libelf, other formats are not supported. */ int main(int argc, char **argv) { int ch, r, rc; const char **files, *fn; rc = RETURN_OK; if (elf_version(EV_CURRENT) == EV_NONE) errx(EXIT_FAILURE, "ELF library initialization failed: %s", elf_errmsg(-1)); while ((ch = getopt_long(argc, argv, "ABVdhotx", size_longopts, NULL)) != -1) switch((char)ch) { case 'A': style = STYLE_SYSV; break; case 'B': style = STYLE_BERKELEY; break; case 'V': show_version(); break; case 'd': radix = RADIX_DECIMAL; break; case 'o': radix = RADIX_OCTAL; break; case 't': show_totals = 1; break; case 'x': radix = RADIX_HEX; break; case 0: switch (size_option) { case OPT_FORMAT: if (*optarg == 's' || *optarg == 'S') style = STYLE_SYSV; else if (*optarg == 'b' || *optarg == 'B') style = STYLE_BERKELEY; else { warnx("unrecognized format \"%s\".", optarg); usage(); } break; case OPT_RADIX: r = strtol(optarg, NULL, 10); if (r == 8) radix = RADIX_OCTAL; else if (r == 10) radix = RADIX_DECIMAL; else if (r == 16) radix = RADIX_HEX; else { warnx("unsupported radix \"%s\".", optarg); usage(); } break; default: err(EXIT_FAILURE, "Error in option handling."); /*NOTREACHED*/ } break; case 'h': case '?': default: usage(); /* NOTREACHED */ } argc -= optind; argv += optind; files = (argc == 0) ? default_args : (void *) argv; while ((fn = *files) != NULL) { rc = handle_elf(fn); if (rc != RETURN_OK) warnx(rc == RETURN_NOINPUT ? "'%s': No such file" : "%s: File format not recognized", fn); files++; } if (style == STYLE_BERKELEY) { if (show_totals) berkeley_totals(); tbl_flush(); } return (rc); } static Elf_Data * xlatetom(Elf *elf, GElf_Ehdr *elfhdr, void *_src, void *_dst, Elf_Type type, size_t size) { Elf_Data src, dst; src.d_buf = _src; src.d_type = type; src.d_version = elfhdr->e_version; src.d_size = size; dst.d_buf = _dst; dst.d_version = elfhdr->e_version; dst.d_size = size; return (gelf_xlatetom(elf, &dst, &src, elfhdr->e_ident[EI_DATA])); } #define NOTE_OFFSET_32(nhdr, namesz, offset) \ ((char *)nhdr + sizeof(Elf32_Nhdr) + \ ELF_ALIGN((int32_t)namesz, 4) + offset) #define NOTE_OFFSET_64(nhdr, namesz, offset) \ ((char *)nhdr + sizeof(Elf32_Nhdr) + \ ELF_ALIGN((int32_t)namesz, 8) + offset) #define PID32(nhdr, namesz, offset) \ (pid_t)*((int *)((uintptr_t)NOTE_OFFSET_32(nhdr, \ namesz, offset))); #define PID64(nhdr, namesz, offset) \ (pid_t)*((int *)((uintptr_t)NOTE_OFFSET_64(nhdr, \ namesz, offset))); #define NEXT_NOTE(elfhdr, descsz, namesz, offset) do { \ if (elfhdr->e_ident[EI_CLASS] == ELFCLASS32) { \ offset += ELF_ALIGN((int32_t)descsz, 4) + \ sizeof(Elf32_Nhdr) + \ ELF_ALIGN((int32_t)namesz, 4); \ } else { \ offset += ELF_ALIGN((int32_t)descsz, 8) + \ sizeof(Elf32_Nhdr) + \ ELF_ALIGN((int32_t)namesz, 8); \ } \ } while (0) /* * Parse individual note entries inside a PT_NOTE segment. */ static void handle_core_note(Elf *elf, GElf_Ehdr *elfhdr, GElf_Phdr *phdr, char **cmd_line) { - size_t max_size; + size_t max_size, segment_end; uint64_t raw_size; GElf_Off offset; static pid_t pid; uintptr_t ver; Elf32_Nhdr *nhdr, nhdr_l; static int reg_pseudo = 0, reg2_pseudo = 0, regxfp_pseudo = 0; char buf[BUF_SIZE], *data, *name; if (elf == NULL || elfhdr == NULL || phdr == NULL) return; data = elf_rawfile(elf, &max_size); offset = phdr->p_offset; - while (data != NULL && offset < phdr->p_offset + phdr->p_filesz) { + if (offset >= max_size || phdr->p_filesz > max_size - offset) { + warnx("invalid PHDR offset"); + return; + } + segment_end = phdr->p_offset + phdr->p_filesz; + + while (data != NULL && offset + sizeof(Elf32_Nhdr) < segment_end) { nhdr = (Elf32_Nhdr *)(uintptr_t)((char*)data + offset); memset(&nhdr_l, 0, sizeof(Elf32_Nhdr)); if (!xlatetom(elf, elfhdr, &nhdr->n_type, &nhdr_l.n_type, ELF_T_WORD, sizeof(Elf32_Word)) || !xlatetom(elf, elfhdr, &nhdr->n_descsz, &nhdr_l.n_descsz, ELF_T_WORD, sizeof(Elf32_Word)) || !xlatetom(elf, elfhdr, &nhdr->n_namesz, &nhdr_l.n_namesz, ELF_T_WORD, sizeof(Elf32_Word))) break; + if (offset + sizeof(Elf32_Nhdr) + + ELF_ALIGN(nhdr_l.n_namesz, 4) + + ELF_ALIGN(nhdr_l.n_descsz, 4) >= segment_end) { + warnx("invalid note header"); + return; + } + name = (char *)((char *)nhdr + sizeof(Elf32_Nhdr)); switch (nhdr_l.n_type) { case NT_PRSTATUS: { raw_size = 0; if (elfhdr->e_ident[EI_OSABI] == ELFOSABI_FREEBSD && nhdr_l.n_namesz == 0x8 && !strcmp(name,"FreeBSD")) { if (elfhdr->e_ident[EI_CLASS] == ELFCLASS32) { raw_size = (uint64_t)*((uint32_t *) (uintptr_t)(name + ELF_ALIGN((int32_t) nhdr_l.n_namesz, 4) + 8)); ver = (uintptr_t)NOTE_OFFSET_32(nhdr, nhdr_l.n_namesz,0); if (*((int *)ver) == 1) pid = PID32(nhdr, nhdr_l.n_namesz, 24); } else { raw_size = *((uint64_t *)(uintptr_t) (name + ELF_ALIGN((int32_t) nhdr_l.n_namesz, 8) + 16)); ver = (uintptr_t)NOTE_OFFSET_64(nhdr, nhdr_l.n_namesz,0); if (*((int *)ver) == 1) pid = PID64(nhdr, nhdr_l.n_namesz, 40); } xlatetom(elf, elfhdr, &raw_size, &raw_size, ELF_T_WORD, sizeof(uint64_t)); xlatetom(elf, elfhdr, &pid, &pid, ELF_T_WORD, sizeof(pid_t)); } if (raw_size != 0 && style == STYLE_SYSV) { (void) snprintf(buf, BUF_SIZE, "%s/%d", ".reg", pid); tbl_append(); tbl_print(buf, 0); tbl_print_num(raw_size, radix, 1); tbl_print_num(0, radix, 2); if (!reg_pseudo) { tbl_append(); tbl_print(".reg", 0); tbl_print_num(raw_size, radix, 1); tbl_print_num(0, radix, 2); reg_pseudo = 1; text_size_total += raw_size; } text_size_total += raw_size; } } break; case NT_FPREGSET: /* same as NT_PRFPREG */ if (style == STYLE_SYSV) { (void) snprintf(buf, BUF_SIZE, "%s/%d", ".reg2", pid); tbl_append(); tbl_print(buf, 0); tbl_print_num(nhdr_l.n_descsz, radix, 1); tbl_print_num(0, radix, 2); if (!reg2_pseudo) { tbl_append(); tbl_print(".reg2", 0); tbl_print_num(nhdr_l.n_descsz, radix, 1); tbl_print_num(0, radix, 2); reg2_pseudo = 1; text_size_total += nhdr_l.n_descsz; } text_size_total += nhdr_l.n_descsz; } break; case NT_AUXV: if (style == STYLE_SYSV) { tbl_append(); tbl_print(".auxv", 0); tbl_print_num(nhdr_l.n_descsz, radix, 1); tbl_print_num(0, radix, 2); text_size_total += nhdr_l.n_descsz; } break; case NT_PRXFPREG: if (style == STYLE_SYSV) { (void) snprintf(buf, BUF_SIZE, "%s/%d", ".reg-xfp", pid); tbl_append(); tbl_print(buf, 0); tbl_print_num(nhdr_l.n_descsz, radix, 1); tbl_print_num(0, radix, 2); if (!regxfp_pseudo) { tbl_append(); tbl_print(".reg-xfp", 0); tbl_print_num(nhdr_l.n_descsz, radix, 1); tbl_print_num(0, radix, 2); regxfp_pseudo = 1; text_size_total += nhdr_l.n_descsz; } text_size_total += nhdr_l.n_descsz; } break; case NT_PSINFO: case NT_PRPSINFO: { /* FreeBSD 64-bit */ if (nhdr_l.n_descsz == 0x78 && !strcmp(name,"FreeBSD")) { *cmd_line = strdup(NOTE_OFFSET_64(nhdr, nhdr_l.n_namesz, 33)); /* FreeBSD 32-bit */ } else if (nhdr_l.n_descsz == 0x6c && !strcmp(name,"FreeBSD")) { *cmd_line = strdup(NOTE_OFFSET_32(nhdr, nhdr_l.n_namesz, 25)); } /* Strip any trailing spaces */ if (*cmd_line != NULL) { char *s; s = *cmd_line + strlen(*cmd_line); while (s > *cmd_line) { if (*(s-1) != 0x20) break; s--; } *s = 0; } break; } case NT_PSTATUS: case NT_LWPSTATUS: default: break; } NEXT_NOTE(elfhdr, nhdr_l.n_descsz, nhdr_l.n_namesz, offset); } } /* - * Handles program headers except for PT_NOTE, when sysv output stlye is - * choosen, prints out the segment name and length. For berkely output + * Handles program headers except for PT_NOTE, when sysv output style is + * chosen, prints out the segment name and length. For berkely output * style only PT_LOAD segments are handled, and text, * data, bss size is calculated for them. */ static void handle_phdr(Elf *elf, GElf_Ehdr *elfhdr, GElf_Phdr *phdr, uint32_t idx, const char *name) { uint64_t addr, size; int split; char buf[BUF_SIZE]; if (elf == NULL || elfhdr == NULL || phdr == NULL) return; split = (phdr->p_memsz > 0) && (phdr->p_filesz > 0) && (phdr->p_memsz > phdr->p_filesz); if (style == STYLE_SYSV) { (void) snprintf(buf, BUF_SIZE, "%s%d%s", name, idx, (split ? "a" : "")); tbl_append(); tbl_print(buf, 0); tbl_print_num(phdr->p_filesz, radix, 1); tbl_print_num(phdr->p_vaddr, radix, 2); text_size_total += phdr->p_filesz; if (split) { size = phdr->p_memsz - phdr->p_filesz; addr = phdr->p_vaddr + phdr->p_filesz; (void) snprintf(buf, BUF_SIZE, "%s%d%s", name, idx, "b"); text_size_total += phdr->p_memsz - phdr->p_filesz; tbl_append(); tbl_print(buf, 0); tbl_print_num(size, radix, 1); tbl_print_num(addr, radix, 2); } } else { if (phdr->p_type != PT_LOAD) return; if ((phdr->p_flags & PF_W) && !(phdr->p_flags & PF_X)) { data_size += phdr->p_filesz; if (split) data_size += phdr->p_memsz - phdr->p_filesz; } else { text_size += phdr->p_filesz; if (split) text_size += phdr->p_memsz - phdr->p_filesz; } } } /* * Given a core dump file, this function maps program headers to segments. */ static int handle_core(char const *name, Elf *elf, GElf_Ehdr *elfhdr) { GElf_Phdr phdr; uint32_t i; char *core_cmdline; const char *seg_name; if (name == NULL || elf == NULL || elfhdr == NULL) return (RETURN_DATAERR); if (elfhdr->e_shnum != 0 || elfhdr->e_type != ET_CORE) return (RETURN_DATAERR); seg_name = core_cmdline = NULL; if (style == STYLE_SYSV) sysv_header(name, NULL); else berkeley_header(); for (i = 0; i < elfhdr->e_phnum; i++) { if (gelf_getphdr(elf, i, &phdr) != NULL) { if (phdr.p_type == PT_NOTE) { handle_phdr(elf, elfhdr, &phdr, i, "note"); handle_core_note(elf, elfhdr, &phdr, &core_cmdline); } else { switch(phdr.p_type) { case PT_NULL: seg_name = "null"; break; case PT_LOAD: seg_name = "load"; break; case PT_DYNAMIC: seg_name = "dynamic"; break; case PT_INTERP: seg_name = "interp"; break; case PT_SHLIB: seg_name = "shlib"; break; case PT_PHDR: seg_name = "phdr"; break; case PT_GNU_EH_FRAME: seg_name = "eh_frame_hdr"; break; case PT_GNU_STACK: seg_name = "stack"; break; default: seg_name = "segment"; } handle_phdr(elf, elfhdr, &phdr, i, seg_name); } } } if (style == STYLE_BERKELEY) { if (core_cmdline != NULL) { berkeley_footer(core_cmdline, name, "core file invoked as"); } else { berkeley_footer(core_cmdline, name, "core file"); } } else { sysv_footer(); if (core_cmdline != NULL) { (void) printf(" (core file invoked as %s)\n\n", core_cmdline); } else { (void) printf(" (core file)\n\n"); } } free(core_cmdline); return (RETURN_OK); } /* * Given an elf object,ar(1) filename, and based on the output style * and radix format the various sections and their length will be printed * or the size of the text, data, bss sections will be printed out. */ static int handle_elf(char const *name) { GElf_Ehdr elfhdr; GElf_Shdr shdr; Elf *elf, *elf1; Elf_Arhdr *arhdr; Elf_Scn *scn; Elf_Cmd elf_cmd; int exit_code, fd; if (name == NULL) return (RETURN_NOINPUT); if ((fd = open(name, O_RDONLY, 0)) < 0) return (RETURN_NOINPUT); elf_cmd = ELF_C_READ; elf1 = elf_begin(fd, elf_cmd, NULL); while ((elf = elf_begin(fd, elf_cmd, elf1)) != NULL) { arhdr = elf_getarhdr(elf); if (elf_kind(elf) == ELF_K_NONE && arhdr == NULL) { (void) elf_end(elf); (void) elf_end(elf1); (void) close(fd); return (RETURN_DATAERR); } if (elf_kind(elf) != ELF_K_ELF || (gelf_getehdr(elf, &elfhdr) == NULL)) { elf_cmd = elf_next(elf); (void) elf_end(elf); warnx("%s: File format not recognized", - arhdr->ar_name); + arhdr != NULL ? arhdr->ar_name : name); continue; } /* Core dumps are handled separately */ if (elfhdr.e_shnum == 0 && elfhdr.e_type == ET_CORE) { exit_code = handle_core(name, elf, &elfhdr); (void) elf_end(elf); (void) elf_end(elf1); (void) close(fd); return (exit_code); } else { scn = NULL; if (style == STYLE_BERKELEY) { berkeley_header(); while ((scn = elf_nextscn(elf, scn)) != NULL) { if (gelf_getshdr(scn, &shdr) != NULL) berkeley_calc(&shdr); } } else { sysv_header(name, arhdr); scn = NULL; while ((scn = elf_nextscn(elf, scn)) != NULL) { if (gelf_getshdr(scn, &shdr) != NULL) sysv_calc(elf, &elfhdr, &shdr); } } if (style == STYLE_BERKELEY) { if (arhdr != NULL) { berkeley_footer(name, arhdr->ar_name, "ex"); } else { berkeley_footer(name, NULL, "ex"); } } else { sysv_footer(); } } elf_cmd = elf_next(elf); (void) elf_end(elf); } (void) elf_end(elf1); (void) close(fd); return (RETURN_OK); } /* * Sysv formatting helper functions. */ static void sysv_header(const char *name, Elf_Arhdr *arhdr) { text_size_total = 0; if (arhdr != NULL) (void) printf("%s (ex %s):\n", arhdr->ar_name, name); else (void) printf("%s :\n", name); tbl_new(3); tbl_append(); tbl_print("section", 0); tbl_print("size", 1); tbl_print("addr", 2); } static void sysv_calc(Elf *elf, GElf_Ehdr *elfhdr, GElf_Shdr *shdr) { char *section_name; section_name = elf_strptr(elf, elfhdr->e_shstrndx, (size_t) shdr->sh_name); if ((shdr->sh_type == SHT_SYMTAB || shdr->sh_type == SHT_STRTAB || shdr->sh_type == SHT_RELA || shdr->sh_type == SHT_REL) && shdr->sh_addr == 0) return; tbl_append(); tbl_print(section_name, 0); tbl_print_num(shdr->sh_size, radix, 1); tbl_print_num(shdr->sh_addr, radix, 2); text_size_total += shdr->sh_size; } static void sysv_footer(void) { tbl_append(); tbl_print("Total", 0); tbl_print_num(text_size_total, radix, 1); tbl_flush(); putchar('\n'); } /* * berkeley style output formatting helper functions. */ static void berkeley_header(void) { static int printed; text_size = data_size = bss_size = 0; if (!printed) { tbl_new(6); tbl_append(); tbl_print("text", 0); tbl_print("data", 1); tbl_print("bss", 2); if (radix == RADIX_OCTAL) tbl_print("oct", 3); else tbl_print("dec", 3); tbl_print("hex", 4); tbl_print("filename", 5); printed = 1; } } static void berkeley_calc(GElf_Shdr *shdr) { if (shdr != NULL) { if (!(shdr->sh_flags & SHF_ALLOC)) return; if ((shdr->sh_flags & SHF_ALLOC) && ((shdr->sh_flags & SHF_EXECINSTR) || !(shdr->sh_flags & SHF_WRITE))) text_size += shdr->sh_size; else if ((shdr->sh_flags & SHF_ALLOC) && (shdr->sh_flags & SHF_WRITE) && (shdr->sh_type != SHT_NOBITS)) data_size += shdr->sh_size; else bss_size += shdr->sh_size; } } static void berkeley_totals(void) { - long unsigned int grand_total; + uint64_t grand_total; grand_total = text_size_total + data_size_total + bss_size_total; tbl_append(); tbl_print_num(text_size_total, radix, 0); tbl_print_num(data_size_total, radix, 1); tbl_print_num(bss_size_total, radix, 2); if (radix == RADIX_OCTAL) tbl_print_num(grand_total, RADIX_OCTAL, 3); else tbl_print_num(grand_total, RADIX_DECIMAL, 3); tbl_print_num(grand_total, RADIX_HEX, 4); } static void berkeley_footer(const char *name, const char *ar_name, const char *msg) { char buf[BUF_SIZE]; total_size = text_size + data_size + bss_size; if (show_totals) { text_size_total += text_size; bss_size_total += bss_size; data_size_total += data_size; } tbl_append(); tbl_print_num(text_size, radix, 0); tbl_print_num(data_size, radix, 1); tbl_print_num(bss_size, radix, 2); if (radix == RADIX_OCTAL) tbl_print_num(total_size, RADIX_OCTAL, 3); else tbl_print_num(total_size, RADIX_DECIMAL, 3); tbl_print_num(total_size, RADIX_HEX, 4); if (ar_name != NULL && name != NULL) (void) snprintf(buf, BUF_SIZE, "%s (%s %s)", ar_name, msg, name); else if (ar_name != NULL && name == NULL) (void) snprintf(buf, BUF_SIZE, "%s (%s)", ar_name, msg); else (void) snprintf(buf, BUF_SIZE, "%s", name); tbl_print(buf, 5); } static void tbl_new(int col) { assert(tb == NULL); assert(col > 0); if ((tb = calloc(1, sizeof(*tb))) == NULL) err(EXIT_FAILURE, "calloc"); if ((tb->tbl = calloc(col, sizeof(*tb->tbl))) == NULL) err(EXIT_FAILURE, "calloc"); if ((tb->width = calloc(col, sizeof(*tb->width))) == NULL) err(EXIT_FAILURE, "calloc"); tb->col = col; tb->row = 0; } static void tbl_print(const char *s, int col) { int len; assert(tb != NULL && tb->col > 0 && tb->row > 0 && col < tb->col); assert(s != NULL && tb->tbl[col][tb->row - 1] == NULL); if ((tb->tbl[col][tb->row - 1] = strdup(s)) == NULL) err(EXIT_FAILURE, "strdup"); len = strlen(s); if (len > tb->width[col]) tb->width[col] = len; } static void tbl_print_num(uint64_t num, enum radix_style rad, int col) { char buf[BUF_SIZE]; (void) snprintf(buf, BUF_SIZE, (rad == RADIX_DECIMAL ? "%ju" : ((rad == RADIX_OCTAL) ? "0%jo" : "0x%jx")), (uintmax_t) num); tbl_print(buf, col); } static void tbl_append(void) { int i; assert(tb != NULL && tb->col > 0); tb->row++; for (i = 0; i < tb->col; i++) { tb->tbl[i] = realloc(tb->tbl[i], sizeof(*tb->tbl[i]) * tb->row); if (tb->tbl[i] == NULL) err(EXIT_FAILURE, "realloc"); tb->tbl[i][tb->row - 1] = NULL; } } static void tbl_flush(void) { const char *str; int i, j; if (tb == NULL) return; assert(tb->col > 0); for (i = 0; i < tb->row; i++) { if (style == STYLE_BERKELEY) printf(" "); for (j = 0; j < tb->col; j++) { str = (tb->tbl[j][i] != NULL ? tb->tbl[j][i] : ""); if (style == STYLE_SYSV && j == 0) printf("%-*s", tb->width[j], str); else if (style == STYLE_BERKELEY && j == tb->col - 1) printf("%s", str); else printf("%*s", tb->width[j], str); if (j == tb->col -1) putchar('\n'); else printf(" "); } } for (i = 0; i < tb->col; i++) { for (j = 0; j < tb->row; j++) { if (tb->tbl[i][j]) free(tb->tbl[i][j]); } free(tb->tbl[i]); } free(tb->tbl); free(tb->width); free(tb); tb = NULL; } #define USAGE_MESSAGE "\ Usage: %s [options] file ...\n\ Display sizes of ELF sections.\n\n\ Options:\n\ --format=format Display output in specified format. Supported\n\ values are `berkeley' and `sysv'.\n\ --help Display this help message and exit.\n\ --radix=radix Display numeric values in the specified radix.\n\ Supported values are: 8, 10 and 16.\n\ --totals Show cumulative totals of section sizes.\n\ --version Display a version identifier and exit.\n\ -A Equivalent to `--format=sysv'.\n\ -B Equivalent to `--format=berkeley'.\n\ -V Equivalent to `--version'.\n\ -d Equivalent to `--radix=10'.\n\ -h Same as option --help.\n\ -o Equivalent to `--radix=8'.\n\ -t Equivalent to option --totals.\n\ -x Equivalent to `--radix=16'.\n" static void usage(void) { (void) fprintf(stderr, USAGE_MESSAGE, ELFTC_GETPROGNAME()); exit(EXIT_FAILURE); } static void show_version(void) { (void) printf("%s (%s)\n", ELFTC_GETPROGNAME(), elftc_version()); exit(EXIT_SUCCESS); } Index: vendor/elftoolchain/dist/strings/strings.c =================================================================== --- vendor/elftoolchain/dist/strings/strings.c (revision 300227) +++ vendor/elftoolchain/dist/strings/strings.c (revision 300228) @@ -1,457 +1,457 @@ /*- * Copyright (c) 2007 S.Sam Arun Raj * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "_elftc.h" -ELFTC_VCSID("$Id: strings.c 3360 2016-01-24 18:34:06Z jkoshy $"); +ELFTC_VCSID("$Id: strings.c 3446 2016-05-03 01:31:17Z emaste $"); enum return_code { RETURN_OK, RETURN_NOINPUT, RETURN_SOFTWARE }; enum radix_style { RADIX_DECIMAL, RADIX_HEX, RADIX_OCTAL }; enum encoding_style { ENCODING_7BIT, ENCODING_8BIT, ENCODING_16BIT_BIG, ENCODING_16BIT_LITTLE, ENCODING_32BIT_BIG, ENCODING_32BIT_LITTLE }; #define PRINTABLE(c) \ ((c) >= 0 && (c) <= 255 && \ ((c) == '\t' || isprint((c)) || \ (encoding == ENCODING_8BIT && (c) > 127))) static int encoding_size, entire_file, show_filename, show_loc; static enum encoding_style encoding; static enum radix_style radix; static intmax_t min_len; static struct option strings_longopts[] = { { "all", no_argument, NULL, 'a'}, { "bytes", required_argument, NULL, 'n'}, { "encoding", required_argument, NULL, 'e'}, { "help", no_argument, NULL, 'h'}, { "print-file-name", no_argument, NULL, 'f'}, { "radix", required_argument, NULL, 't'}, { "version", no_argument, NULL, 'v'}, { NULL, 0, NULL, 0 } }; long getcharacter(void); int handle_file(const char *); int handle_elf(const char *, int); int handle_binary(const char *, int); int find_strings(const char *, off_t, off_t); void show_version(void); void usage(void); /* * strings(1) extracts text(contiguous printable characters) * from elf and binary files. */ int main(int argc, char **argv) { int ch, rc; rc = RETURN_OK; min_len = 0; encoding_size = 1; if (elf_version(EV_CURRENT) == EV_NONE) errx(EXIT_FAILURE, "ELF library initialization failed: %s", elf_errmsg(-1)); while ((ch = getopt_long(argc, argv, "1234567890ae:fhn:ot:Vv", strings_longopts, NULL)) != -1) switch((char)ch) { case 'a': entire_file = 1; break; case 'e': if (*optarg == 's') { encoding = ENCODING_7BIT; } else if (*optarg == 'S') { encoding = ENCODING_8BIT; } else if (*optarg == 'b') { encoding = ENCODING_16BIT_BIG; encoding_size = 2; } else if (*optarg == 'B') { encoding = ENCODING_32BIT_BIG; encoding_size = 4; } else if (*optarg == 'l') { encoding = ENCODING_16BIT_LITTLE; encoding_size = 2; } else if (*optarg == 'L') { encoding = ENCODING_32BIT_LITTLE; encoding_size = 4; } else usage(); /* NOTREACHED */ break; case 'f': show_filename = 1; break; case 'n': min_len = strtoimax(optarg, (char**)NULL, 10); if (min_len <= 0) errx(EX_USAGE, "option -n should specify a " "positive decimal integer."); break; case 'o': show_loc = 1; radix = RADIX_OCTAL; break; case 't': show_loc = 1; if (*optarg == 'd') radix = RADIX_DECIMAL; else if (*optarg == 'o') radix = RADIX_OCTAL; else if (*optarg == 'x') radix = RADIX_HEX; else usage(); /* NOTREACHED */ break; case 'v': case 'V': show_version(); /* NOTREACHED */ case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': min_len *= 10; min_len += ch - '0'; break; case 'h': case '?': default: usage(); /* NOTREACHED */ } argc -= optind; argv += optind; if (!min_len) min_len = 4; if (!*argv) rc = handle_file("{standard input}"); else while (*argv) { rc = handle_file(*argv); argv++; } return (rc); } int handle_file(const char *name) { int fd, rt; if (name == NULL) return (RETURN_NOINPUT); if (strcmp("{standard input}", name) != 0) { if (freopen(name, "rb", stdin) == NULL) { warnx("'%s': %s", name, strerror(errno)); return (RETURN_NOINPUT); } } else { return (find_strings(name, (off_t)0, (off_t)0)); } fd = fileno(stdin); if (fd < 0) return (RETURN_NOINPUT); rt = handle_elf(name, fd); return (rt); } /* * Files not understood by handle_elf, will be passed off here and will * treated as a binary file. This would include text file, core dumps ... */ int handle_binary(const char *name, int fd) { struct stat buf; memset(&buf, 0, sizeof(struct stat)); (void) lseek(fd, (off_t)0, SEEK_SET); if (!fstat(fd, &buf)) return (find_strings(name, (off_t)0, buf.st_size)); return (RETURN_SOFTWARE); } /* * Will analyse a file to see if it ELF, other files including ar(1), * core dumps are passed off and treated as flat binary files. Unlike * GNU size in FreeBSD this routine will not treat ELF object from * different archs as flat binary files(has to overridden using -a). */ int handle_elf(const char *name, int fd) { GElf_Ehdr elfhdr; GElf_Shdr shdr; Elf *elf; Elf_Scn *scn; int rc; rc = RETURN_OK; - /* If entire file is choosen, treat it as a binary file */ + /* If entire file is chosen, treat it as a binary file */ if (entire_file) return (handle_binary(name, fd)); (void) lseek(fd, (off_t)0, SEEK_SET); elf = elf_begin(fd, ELF_C_READ, NULL); if (elf_kind(elf) != ELF_K_ELF) { (void) elf_end(elf); return (handle_binary(name, fd)); } if (gelf_getehdr(elf, &elfhdr) == NULL) { (void) elf_end(elf); warnx("%s: ELF file could not be processed", name); return (RETURN_SOFTWARE); } if (elfhdr.e_shnum == 0 && elfhdr.e_type == ET_CORE) { (void) elf_end(elf); return (handle_binary(name, fd)); } else { scn = NULL; while ((scn = elf_nextscn(elf, scn)) != NULL) { if (gelf_getshdr(scn, &shdr) == NULL) continue; if (shdr.sh_type != SHT_NOBITS && (shdr.sh_flags & SHF_ALLOC) != 0) { rc = find_strings(name, shdr.sh_offset, shdr.sh_size); } } } (void) elf_end(elf); return (rc); } /* * Retrieves a character from input stream based on the encoding * type requested. */ long getcharacter(void) { long rt; int i; char buf[4], c; rt = EOF; for(i = 0; i < encoding_size; i++) { c = getc(stdin); if (feof(stdin)) return (EOF); buf[i] = c; } switch(encoding) { case ENCODING_7BIT: case ENCODING_8BIT: rt = buf[0]; break; case ENCODING_16BIT_BIG: rt = (buf[0] << 8) | buf[1]; break; case ENCODING_16BIT_LITTLE: rt = buf[0] | (buf[1] << 8); break; case ENCODING_32BIT_BIG: rt = ((long) buf[0] << 24) | ((long) buf[1] << 16) | ((long) buf[2] << 8) | buf[3]; break; case ENCODING_32BIT_LITTLE: rt = buf[0] | ((long) buf[1] << 8) | ((long) buf[2] << 16) | ((long) buf[3] << 24); break; } return (rt); } /* * Input stream stdin is read until the end of file is reached or until * the section size is reached in case of ELF files. Contiguous * characters of >= min_size(default 4) will be displayed. */ int find_strings(const char *name, off_t offset, off_t size) { off_t cur_off, start_off; char *obuf; long c; int i; if ((obuf = (char*)calloc(1, min_len + 1)) == NULL) { (void) fprintf(stderr, "Unable to allocate memory: %s\n", strerror(errno)); return (RETURN_SOFTWARE); } (void) fseeko(stdin, offset, SEEK_SET); cur_off = offset; start_off = 0; while(1) { if ((offset + size) && (cur_off >= offset + size)) break; start_off = cur_off; memset(obuf, 0, min_len+1); for(i = 0; i < min_len; i++) { c = getcharacter(); if (c == EOF && feof(stdin)) goto _exit1; if (PRINTABLE(c)) { obuf[i] = c; obuf[i+1] = 0; cur_off += encoding_size; } else { if (encoding == ENCODING_8BIT && (uint8_t)c > 127) { obuf[i] = c; obuf[i+1] = 0; cur_off += encoding_size; continue; } cur_off += encoding_size; break; } } if (i >= min_len && ((cur_off <= offset + size) || !(offset + size))) { if (show_filename) printf ("%s: ", name); if (show_loc) { switch(radix) { case RADIX_DECIMAL: (void) printf("%7ju ", (uintmax_t)start_off); break; case RADIX_HEX: (void) printf("%7jx ", (uintmax_t)start_off); break; case RADIX_OCTAL: (void) printf("%7jo ", (uintmax_t)start_off); break; } } printf("%s", obuf); while(1) { if ((offset + size) && (cur_off >= offset + size)) break; c = getcharacter(); cur_off += encoding_size; if (encoding == ENCODING_8BIT && (uint8_t)c > 127) { putchar(c); continue; } if (!PRINTABLE(c) || c == EOF) break; putchar(c); } putchar('\n'); } } _exit1: free(obuf); return (RETURN_OK); } #define USAGE_MESSAGE "\ Usage: %s [options] [file...]\n\ Print contiguous sequences of printable characters.\n\n\ Options:\n\ -a | --all Scan the entire file for strings.\n\ -e ENC | --encoding=ENC Select the character encoding to use.\n\ -f | --print-file-name Print the file name before each string.\n\ -h | --help Print a help message and exit.\n\ -n N | --bytes=N | -N Print sequences with 'N' or more characters.\n\ -o Print offsets in octal.\n\ -t R | --radix=R Print offsets using the radix named by 'R'.\n\ -v | --version Print a version identifier and exit.\n" void usage(void) { (void) fprintf(stderr, USAGE_MESSAGE, ELFTC_GETPROGNAME()); exit(EXIT_FAILURE); } void show_version(void) { (void) printf("%s (%s)\n", ELFTC_GETPROGNAME(), elftc_version()); exit(EXIT_SUCCESS); } Index: vendor/elftoolchain/dist/test/cxxfilt/Makefile =================================================================== --- vendor/elftoolchain/dist/test/cxxfilt/Makefile (nonexistent) +++ vendor/elftoolchain/dist/test/cxxfilt/Makefile (revision 300228) @@ -0,0 +1,6 @@ +# $Id$ + +TOP= ../.. +SUBDIR= ts + +.include "${TOP}/mk/elftoolchain.tetbase.mk" Property changes on: vendor/elftoolchain/dist/test/cxxfilt/Makefile ___________________________________________________________________ Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +FreeBSD=%H \ No newline at end of property Added: svn:mime-type ## -0,0 +1 ## +text/plain \ No newline at end of property Index: vendor/elftoolchain/dist/test/cxxfilt/tet_scen =================================================================== --- vendor/elftoolchain/dist/test/cxxfilt/tet_scen (nonexistent) +++ vendor/elftoolchain/dist/test/cxxfilt/tet_scen (revision 300228) @@ -0,0 +1,11 @@ +# $Id$ + +all + "Starting Test Suite" + ^misc + "Complete Test Suite" + +misc + "Starting noarg Test" + /ts/misc/tc + "Complete noarg Test" Index: vendor/elftoolchain/dist/test/cxxfilt/tetexec.cfg =================================================================== --- vendor/elftoolchain/dist/test/cxxfilt/tetexec.cfg (nonexistent) +++ vendor/elftoolchain/dist/test/cxxfilt/tetexec.cfg (revision 300228) @@ -0,0 +1,5 @@ +# elfdump Test Suite. +# +# $Id$ + +TET_OUTPUT_CAPTURE=False Index: vendor/elftoolchain/dist/test/cxxfilt/ts/Makefile =================================================================== --- vendor/elftoolchain/dist/test/cxxfilt/ts/Makefile (nonexistent) +++ vendor/elftoolchain/dist/test/cxxfilt/ts/Makefile (revision 300228) @@ -0,0 +1,7 @@ +# $Id$ + +TOP= ../../.. + +SUBDIR+= misc + +.include "${TOP}/mk/elftoolchain.subdir.mk" \ No newline at end of file Property changes on: vendor/elftoolchain/dist/test/cxxfilt/ts/Makefile ___________________________________________________________________ Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +FreeBSD=%H \ No newline at end of property Added: svn:mime-type ## -0,0 +1 ## +text/plain \ No newline at end of property Index: vendor/elftoolchain/dist/test/cxxfilt/ts/common/func.sh =================================================================== --- vendor/elftoolchain/dist/test/cxxfilt/ts/common/func.sh (nonexistent) +++ vendor/elftoolchain/dist/test/cxxfilt/ts/common/func.sh (revision 300228) @@ -0,0 +1,49 @@ +#!/bin/sh +# +# $Id$ + +tpstart() # write test purpose banner and initialise variables +{ + tet_infoline "$*" + FAIL=N +} + +tpresult() # give test purpose result +{ + # $1 is result code to give if FAIL=N (default PASS) + if [ $FAIL = N ]; then + tet_result ${1-PASS} + else + tet_result FAIL + fi +} + +check_rlt() # execute command (saving output) and check exit code +{ + # $1 is command, $2 is expected exit code (0 or "N" for non-zero) + RLT=`$1` + CODE=$? + if [ $2 = 0 -a $CODE -ne 0 ]; then + tet_infoline "Command ($1) gave exit code $CODE, expected 0" + FAIL=Y + elif [ $2 != 0 -a $CODE -eq 0 ]; then + tet_infoline "Command ($1) gave exit code $CODE, expected non-zero" + FAIL=Y + fi + + # $3 is expected result. + if [ "$RLT" != "$3" ]; then + tet_infoline "Command ($1) gave wrong result:" + tet_infoline "$RLT" + tet_infoline "expected:" + tet_infoline "$3" + FAIL=Y + fi +} + +run() +{ + tpstart "Running test '$1'" + check_rlt "$TET_SUITE_ROOT/../../cxxfilt/c++filt $1" 0 "$2" + tpresult +} Property changes on: vendor/elftoolchain/dist/test/cxxfilt/ts/common/func.sh ___________________________________________________________________ Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:executable ## -0,0 +1 ## +* \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +FreeBSD=%H \ No newline at end of property Added: svn:mime-type ## -0,0 +1 ## +text/plain \ No newline at end of property Index: vendor/elftoolchain/dist/test/cxxfilt/ts/common/gen.awk =================================================================== --- vendor/elftoolchain/dist/test/cxxfilt/ts/common/gen.awk (nonexistent) +++ vendor/elftoolchain/dist/test/cxxfilt/ts/common/gen.awk (revision 300228) @@ -0,0 +1,33 @@ +#!/usr/bin/awk -f +# +# $Id$ + +BEGIN { + FS = "\"" + tp = 0 + print "#!/bin/sh\n" +} + +{ + sub(/#.*/, ""); + if (NF >= 5) { + tp++ + printf("tp%d()\n{\n run \"%s\" \"%s\"\n}\n\n", tp, $2, $4); + } +} + +END { + print "tet_startup=\"\"" + print "tet_cleanup=\"\"\n" + printf("%s", "iclist=\""); + for (i = 1; i <= tp; i++) { + printf("ic%d", i); + if (i != tp) + printf(" "); + } + printf("\"\n\n"); + for (i = 1; i <= tp; i++) + printf("ic%d=\"tp%d\"\n", i, i); + print "\n. $TET_SUITE_ROOT/ts/common/func.sh"; + print ". $TET_ROOT/lib/xpg3sh/tcm.sh"; +} Property changes on: vendor/elftoolchain/dist/test/cxxfilt/ts/common/gen.awk ___________________________________________________________________ Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:executable ## -0,0 +1 ## +* \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +FreeBSD=%H \ No newline at end of property Added: svn:mime-type ## -0,0 +1 ## +text/plain \ No newline at end of property Index: vendor/elftoolchain/dist/test/cxxfilt/ts/common/ts.mk =================================================================== --- vendor/elftoolchain/dist/test/cxxfilt/ts/common/ts.mk (nonexistent) +++ vendor/elftoolchain/dist/test/cxxfilt/ts/common/ts.mk (revision 300228) @@ -0,0 +1,15 @@ +# $Id$ + +TCLIST?= tclist + +.PHONY: all + +all: tc + +tc: ${TCLIST} + ${.CURDIR}/../common/gen.awk ${.ALLSRC} > ${.TARGET} + chmod +x ${.TARGET} + +clean: + rm -rf tc + Property changes on: vendor/elftoolchain/dist/test/cxxfilt/ts/common/ts.mk ___________________________________________________________________ Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +FreeBSD=%H \ No newline at end of property Added: svn:mime-type ## -0,0 +1 ## +text/plain \ No newline at end of property Index: vendor/elftoolchain/dist/test/cxxfilt/ts/misc/Makefile =================================================================== --- vendor/elftoolchain/dist/test/cxxfilt/ts/misc/Makefile (nonexistent) +++ vendor/elftoolchain/dist/test/cxxfilt/ts/misc/Makefile (revision 300228) @@ -0,0 +1,5 @@ +# $Id$ + +TOP= ../../../.. + +.include "../common/ts.mk" Property changes on: vendor/elftoolchain/dist/test/cxxfilt/ts/misc/Makefile ___________________________________________________________________ Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +FreeBSD=%H \ No newline at end of property Added: svn:mime-type ## -0,0 +1 ## +text/plain \ No newline at end of property Index: vendor/elftoolchain/dist/test/cxxfilt/ts/misc/tclist =================================================================== --- vendor/elftoolchain/dist/test/cxxfilt/ts/misc/tclist (nonexistent) +++ vendor/elftoolchain/dist/test/cxxfilt/ts/misc/tclist (revision 300228) @@ -0,0 +1,15 @@ +# simple function + +"_Z1f", "f" +"_Z1fi", "f(int)" +"_Z1fic", "f(int, char)" + +# namespace + +"_ZN12elftoolchainE", "elftoolchain" +"_ZN11elftoolchainE", "_ZN11elftoolchainE" +"_ZN12elftoolchain", "_ZN12elftoolchain" +"_ZN12elftoolchain3foo3barE", "elftoolchain::foo::bar" +"_ZN12elftoolchain3foo3barEi", "elftoolchain::foo::bar(int)" +"_ZN12elftoolchain3foo3barEic", "elftoolchain::foo::bar(int, char)" + Index: vendor/elftoolchain/dist/test/elfdump/ts/dso1/@S@p%libelf.so.out =================================================================== --- vendor/elftoolchain/dist/test/elfdump/ts/dso1/@S@p%libelf.so.out (revision 300227) +++ vendor/elftoolchain/dist/test/elfdump/ts/dso1/@S@p%libelf.so.out (revision 300228) @@ -1,24 +1,24 @@ Program Header[0]: p_vaddr: 0 p_flags: [ PF_X|PF_R ] p_paddr: 0 p_type: [ PT_LOAD ] p_filesz: 0x16114 p_memsz: 0x16114 p_offset: 0 p_align: 0x100000 Program Header[1]: p_vaddr: 0x116120 p_flags: [ PF_W|PF_R ] p_paddr: 0x116120 p_type: [ PT_LOAD ] p_filesz: 0x2438 p_memsz: 0x2440 p_offset: 0x16120 p_align: 0x100000 Program Header[2]: p_vaddr: 0x118208 p_flags: [ PF_W|PF_R ] p_paddr: 0x118208 p_type: [ PT_DYNAMIC ] p_filesz: 0x1b0 p_memsz: 0x1b0 p_offset: 0x18208 p_align: 0x8 Program Header[3]: p_vaddr: 0x1610c p_flags: [ PF_R ] - p_paddr: 0x1610c p_type: [ PT_NULL ] + p_paddr: 0x1610c p_type: [ PT_GNU_EH_FRAME ] p_filesz: 0x8 p_memsz: 0x8 p_offset: 0x1610c p_align: 0x4 Index: vendor/elftoolchain/dist/test/elfdump/ts/dso1/@c@p@n%libelf.so.out =================================================================== --- vendor/elftoolchain/dist/test/elfdump/ts/dso1/@c@p@n%libelf.so.out (revision 300227) +++ vendor/elftoolchain/dist/test/elfdump/ts/dso1/@c@p@n%libelf.so.out (revision 300228) @@ -1,344 +1,344 @@ program header: entry: 0 p_type: PT_LOAD p_offset: 0 p_vaddr: 0 p_paddr: 0 p_filesz: 90388 p_memsz: 90388 p_flags: PF_X|PF_R p_align: 1048576 entry: 1 p_type: PT_LOAD p_offset: 90400 p_vaddr: 0x116120 p_paddr: 0x116120 p_filesz: 9272 p_memsz: 9280 p_flags: PF_W|PF_R p_align: 1048576 entry: 2 p_type: PT_DYNAMIC p_offset: 98824 p_vaddr: 0x118208 p_paddr: 0x118208 p_filesz: 432 p_memsz: 432 p_flags: PF_W|PF_R p_align: 8 entry: 3 - p_type: PT_NULL + p_type: PT_GNU_EH_FRAME p_offset: 90380 p_vaddr: 0x1610c p_paddr: 0x1610c p_filesz: 8 p_memsz: 8 p_flags: PF_R p_align: 4 section header: entry: 0 sh_name: sh_type: SHT_NULL sh_flags: sh_addr: 0 sh_offset: 0 sh_size: 0 sh_link: 0 sh_info: 0 sh_addralign: 0 sh_entsize: 0 entry: 1 sh_name: .hash sh_type: SHT_HASH sh_flags: SHF_ALLOC sh_addr: 0x120 sh_offset: 288 sh_size: 1108 sh_link: 2 sh_info: 0 sh_addralign: 8 sh_entsize: 4 entry: 2 sh_name: .dynsym sh_type: SHT_DYNSYM sh_flags: SHF_ALLOC sh_addr: 0x578 sh_offset: 1400 sh_size: 3456 sh_link: 3 sh_info: 33 sh_addralign: 8 sh_entsize: 24 entry: 3 sh_name: .dynstr sh_type: SHT_STRTAB sh_flags: SHF_ALLOC sh_addr: 0x12f8 sh_offset: 4856 sh_size: 1457 sh_link: 0 sh_info: 0 sh_addralign: 1 sh_entsize: 0 entry: 4 sh_name: .gnu.version sh_type: SHT_SUNW(GNU)_versym sh_flags: SHF_ALLOC sh_addr: 0x18aa sh_offset: 6314 sh_size: 288 sh_link: 2 sh_info: 0 sh_addralign: 2 sh_entsize: 2 entry: 5 sh_name: .gnu.version_d sh_type: SHT_SUNW(GNU)_verdef sh_flags: SHF_ALLOC sh_addr: 0x19d0 sh_offset: 6608 sh_size: 84 sh_link: 3 sh_info: 3 sh_addralign: 8 sh_entsize: 0 entry: 6 sh_name: .gnu.version_r sh_type: SHT_SUNW(GNU)_verneed sh_flags: SHF_ALLOC sh_addr: 0x1a28 sh_offset: 6696 sh_size: 32 sh_link: 3 sh_info: 1 sh_addralign: 8 sh_entsize: 0 entry: 7 sh_name: .rela.dyn sh_type: SHT_RELA sh_flags: SHF_ALLOC sh_addr: 0x1a48 sh_offset: 6728 sh_size: 2664 sh_link: 2 sh_info: 0 sh_addralign: 8 sh_entsize: 24 entry: 8 sh_name: .rela.plt sh_type: SHT_RELA sh_flags: SHF_ALLOC sh_addr: 0x24b0 sh_offset: 9392 sh_size: 888 sh_link: 2 sh_info: 10 sh_addralign: 8 sh_entsize: 24 entry: 9 sh_name: .init sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC|SHF_EXECINSTR sh_addr: 0x2828 sh_offset: 10280 sh_size: 19 sh_link: 0 sh_info: 0 sh_addralign: 4 sh_entsize: 0 entry: 10 sh_name: .plt sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC|SHF_EXECINSTR sh_addr: 0x283c sh_offset: 10300 sh_size: 608 sh_link: 0 sh_info: 0 sh_addralign: 4 sh_entsize: 16 entry: 11 sh_name: .text sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC|SHF_EXECINSTR sh_addr: 0x2aa0 sh_offset: 10912 sh_size: 74792 sh_link: 0 sh_info: 0 sh_addralign: 16 sh_entsize: 0 entry: 12 sh_name: .fini sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC|SHF_EXECINSTR sh_addr: 0x14ec8 sh_offset: 85704 sh_size: 14 sh_link: 0 sh_info: 0 sh_addralign: 4 sh_entsize: 0 entry: 13 sh_name: .rodata sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC sh_addr: 0x14ee0 sh_offset: 85728 sh_size: 4650 sh_link: 0 sh_info: 0 sh_addralign: 32 sh_entsize: 0 entry: 14 sh_name: .eh_frame_hdr sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC sh_addr: 0x1610c sh_offset: 90380 sh_size: 8 sh_link: 0 sh_info: 0 sh_addralign: 4 sh_entsize: 0 entry: 15 sh_name: .data sh_type: SHT_PROGBITS sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x116120 sh_offset: 90400 sh_size: 1208 sh_link: 0 sh_info: 0 sh_addralign: 32 sh_entsize: 0 entry: 16 sh_name: .eh_frame sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC sh_addr: 0x1165d8 sh_offset: 91608 sh_size: 7216 sh_link: 0 sh_info: 0 sh_addralign: 8 sh_entsize: 0 entry: 17 sh_name: .dynamic sh_type: SHT_DYNAMIC sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x118208 sh_offset: 98824 sh_size: 432 sh_link: 3 sh_info: 0 sh_addralign: 8 sh_entsize: 16 entry: 18 sh_name: .ctors sh_type: SHT_PROGBITS sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x1183b8 sh_offset: 99256 sh_size: 16 sh_link: 0 sh_info: 0 sh_addralign: 8 sh_entsize: 0 entry: 19 sh_name: .dtors sh_type: SHT_PROGBITS sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x1183c8 sh_offset: 99272 sh_size: 16 sh_link: 0 sh_info: 0 sh_addralign: 8 sh_entsize: 0 entry: 20 sh_name: .jcr sh_type: SHT_PROGBITS sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x1183d8 sh_offset: 99288 sh_size: 8 sh_link: 0 sh_info: 0 sh_addralign: 8 sh_entsize: 0 entry: 21 sh_name: .got sh_type: SHT_PROGBITS sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x1183e0 sh_offset: 99296 sh_size: 376 sh_link: 0 sh_info: 0 sh_addralign: 8 sh_entsize: 8 entry: 22 sh_name: .bss sh_type: SHT_NOBITS sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x118558 sh_offset: 99672 sh_size: 8 sh_link: 0 sh_info: 0 sh_addralign: 4 sh_entsize: 0 entry: 23 sh_name: .comment sh_type: SHT_PROGBITS sh_flags: sh_addr: 0 sh_offset: 99672 sh_size: 4945 sh_link: 0 sh_info: 0 sh_addralign: 1 sh_entsize: 0 entry: 24 sh_name: .shstrtab sh_type: SHT_STRTAB sh_flags: sh_addr: 0 sh_offset: 104617 sh_size: 199 sh_link: 0 sh_info: 0 sh_addralign: 1 sh_entsize: 0 Index: vendor/elftoolchain/dist/test/elfdump/ts/dso1/@e@p@c%libelf.so.out =================================================================== --- vendor/elftoolchain/dist/test/elfdump/ts/dso1/@e@p@c%libelf.so.out (revision 300227) +++ vendor/elftoolchain/dist/test/elfdump/ts/dso1/@e@p@c%libelf.so.out (revision 300228) @@ -1,361 +1,361 @@ elf header: e_ident: ELFCLASS64 ELFDATA2LSB ELFOSABI_FREEBSD e_type: ET_DYN e_machine: EM_X86_64 e_version: EV_CURRENT e_entry: 0x2aa0 e_phoff: 64 e_shoff: 104816 e_flags: 0 e_ehsize: 64 e_phentsize: 56 e_phnum: 4 e_shentsize: 64 e_shnum: 25 e_shstrndx: 24 program header: entry: 0 p_type: PT_LOAD p_offset: 0 p_vaddr: 0 p_paddr: 0 p_filesz: 90388 p_memsz: 90388 p_flags: PF_X|PF_R p_align: 1048576 entry: 1 p_type: PT_LOAD p_offset: 90400 p_vaddr: 0x116120 p_paddr: 0x116120 p_filesz: 9272 p_memsz: 9280 p_flags: PF_W|PF_R p_align: 1048576 entry: 2 p_type: PT_DYNAMIC p_offset: 98824 p_vaddr: 0x118208 p_paddr: 0x118208 p_filesz: 432 p_memsz: 432 p_flags: PF_W|PF_R p_align: 8 entry: 3 - p_type: PT_NULL + p_type: PT_GNU_EH_FRAME p_offset: 90380 p_vaddr: 0x1610c p_paddr: 0x1610c p_filesz: 8 p_memsz: 8 p_flags: PF_R p_align: 4 section header: entry: 0 sh_name: sh_type: SHT_NULL sh_flags: sh_addr: 0 sh_offset: 0 sh_size: 0 sh_link: 0 sh_info: 0 sh_addralign: 0 sh_entsize: 0 entry: 1 sh_name: .hash sh_type: SHT_HASH sh_flags: SHF_ALLOC sh_addr: 0x120 sh_offset: 288 sh_size: 1108 sh_link: 2 sh_info: 0 sh_addralign: 8 sh_entsize: 4 entry: 2 sh_name: .dynsym sh_type: SHT_DYNSYM sh_flags: SHF_ALLOC sh_addr: 0x578 sh_offset: 1400 sh_size: 3456 sh_link: 3 sh_info: 33 sh_addralign: 8 sh_entsize: 24 entry: 3 sh_name: .dynstr sh_type: SHT_STRTAB sh_flags: SHF_ALLOC sh_addr: 0x12f8 sh_offset: 4856 sh_size: 1457 sh_link: 0 sh_info: 0 sh_addralign: 1 sh_entsize: 0 entry: 4 sh_name: .gnu.version sh_type: SHT_SUNW(GNU)_versym sh_flags: SHF_ALLOC sh_addr: 0x18aa sh_offset: 6314 sh_size: 288 sh_link: 2 sh_info: 0 sh_addralign: 2 sh_entsize: 2 entry: 5 sh_name: .gnu.version_d sh_type: SHT_SUNW(GNU)_verdef sh_flags: SHF_ALLOC sh_addr: 0x19d0 sh_offset: 6608 sh_size: 84 sh_link: 3 sh_info: 3 sh_addralign: 8 sh_entsize: 0 entry: 6 sh_name: .gnu.version_r sh_type: SHT_SUNW(GNU)_verneed sh_flags: SHF_ALLOC sh_addr: 0x1a28 sh_offset: 6696 sh_size: 32 sh_link: 3 sh_info: 1 sh_addralign: 8 sh_entsize: 0 entry: 7 sh_name: .rela.dyn sh_type: SHT_RELA sh_flags: SHF_ALLOC sh_addr: 0x1a48 sh_offset: 6728 sh_size: 2664 sh_link: 2 sh_info: 0 sh_addralign: 8 sh_entsize: 24 entry: 8 sh_name: .rela.plt sh_type: SHT_RELA sh_flags: SHF_ALLOC sh_addr: 0x24b0 sh_offset: 9392 sh_size: 888 sh_link: 2 sh_info: 10 sh_addralign: 8 sh_entsize: 24 entry: 9 sh_name: .init sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC|SHF_EXECINSTR sh_addr: 0x2828 sh_offset: 10280 sh_size: 19 sh_link: 0 sh_info: 0 sh_addralign: 4 sh_entsize: 0 entry: 10 sh_name: .plt sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC|SHF_EXECINSTR sh_addr: 0x283c sh_offset: 10300 sh_size: 608 sh_link: 0 sh_info: 0 sh_addralign: 4 sh_entsize: 16 entry: 11 sh_name: .text sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC|SHF_EXECINSTR sh_addr: 0x2aa0 sh_offset: 10912 sh_size: 74792 sh_link: 0 sh_info: 0 sh_addralign: 16 sh_entsize: 0 entry: 12 sh_name: .fini sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC|SHF_EXECINSTR sh_addr: 0x14ec8 sh_offset: 85704 sh_size: 14 sh_link: 0 sh_info: 0 sh_addralign: 4 sh_entsize: 0 entry: 13 sh_name: .rodata sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC sh_addr: 0x14ee0 sh_offset: 85728 sh_size: 4650 sh_link: 0 sh_info: 0 sh_addralign: 32 sh_entsize: 0 entry: 14 sh_name: .eh_frame_hdr sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC sh_addr: 0x1610c sh_offset: 90380 sh_size: 8 sh_link: 0 sh_info: 0 sh_addralign: 4 sh_entsize: 0 entry: 15 sh_name: .data sh_type: SHT_PROGBITS sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x116120 sh_offset: 90400 sh_size: 1208 sh_link: 0 sh_info: 0 sh_addralign: 32 sh_entsize: 0 entry: 16 sh_name: .eh_frame sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC sh_addr: 0x1165d8 sh_offset: 91608 sh_size: 7216 sh_link: 0 sh_info: 0 sh_addralign: 8 sh_entsize: 0 entry: 17 sh_name: .dynamic sh_type: SHT_DYNAMIC sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x118208 sh_offset: 98824 sh_size: 432 sh_link: 3 sh_info: 0 sh_addralign: 8 sh_entsize: 16 entry: 18 sh_name: .ctors sh_type: SHT_PROGBITS sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x1183b8 sh_offset: 99256 sh_size: 16 sh_link: 0 sh_info: 0 sh_addralign: 8 sh_entsize: 0 entry: 19 sh_name: .dtors sh_type: SHT_PROGBITS sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x1183c8 sh_offset: 99272 sh_size: 16 sh_link: 0 sh_info: 0 sh_addralign: 8 sh_entsize: 0 entry: 20 sh_name: .jcr sh_type: SHT_PROGBITS sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x1183d8 sh_offset: 99288 sh_size: 8 sh_link: 0 sh_info: 0 sh_addralign: 8 sh_entsize: 0 entry: 21 sh_name: .got sh_type: SHT_PROGBITS sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x1183e0 sh_offset: 99296 sh_size: 376 sh_link: 0 sh_info: 0 sh_addralign: 8 sh_entsize: 8 entry: 22 sh_name: .bss sh_type: SHT_NOBITS sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x118558 sh_offset: 99672 sh_size: 8 sh_link: 0 sh_info: 0 sh_addralign: 4 sh_entsize: 0 entry: 23 sh_name: .comment sh_type: SHT_PROGBITS sh_flags: sh_addr: 0 sh_offset: 99672 sh_size: 4945 sh_link: 0 sh_info: 0 sh_addralign: 1 sh_entsize: 0 entry: 24 sh_name: .shstrtab sh_type: SHT_STRTAB sh_flags: sh_addr: 0 sh_offset: 104617 sh_size: 199 sh_link: 0 sh_info: 0 sh_addralign: 1 sh_entsize: 0 Index: vendor/elftoolchain/dist/test/elfdump/ts/dso1/@p%libelf.so.out =================================================================== --- vendor/elftoolchain/dist/test/elfdump/ts/dso1/@p%libelf.so.out (revision 300227) +++ vendor/elftoolchain/dist/test/elfdump/ts/dso1/@p%libelf.so.out (revision 300228) @@ -1,42 +1,42 @@ program header: entry: 0 p_type: PT_LOAD p_offset: 0 p_vaddr: 0 p_paddr: 0 p_filesz: 90388 p_memsz: 90388 p_flags: PF_X|PF_R p_align: 1048576 entry: 1 p_type: PT_LOAD p_offset: 90400 p_vaddr: 0x116120 p_paddr: 0x116120 p_filesz: 9272 p_memsz: 9280 p_flags: PF_W|PF_R p_align: 1048576 entry: 2 p_type: PT_DYNAMIC p_offset: 98824 p_vaddr: 0x118208 p_paddr: 0x118208 p_filesz: 432 p_memsz: 432 p_flags: PF_W|PF_R p_align: 8 entry: 3 - p_type: PT_NULL + p_type: PT_GNU_EH_FRAME p_offset: 90380 p_vaddr: 0x1610c p_paddr: 0x1610c p_filesz: 8 p_memsz: 8 p_flags: PF_R p_align: 4 Index: vendor/elftoolchain/dist/test/elfdump/ts/dso1/@p@s%libelf.so.out =================================================================== --- vendor/elftoolchain/dist/test/elfdump/ts/dso1/@p@s%libelf.so.out (revision 300227) +++ vendor/elftoolchain/dist/test/elfdump/ts/dso1/@p@s%libelf.so.out (revision 300228) @@ -1,1052 +1,1052 @@ program header: entry: 0 p_type: PT_LOAD p_offset: 0 p_vaddr: 0 p_paddr: 0 p_filesz: 90388 p_memsz: 90388 p_flags: PF_X|PF_R p_align: 1048576 entry: 1 p_type: PT_LOAD p_offset: 90400 p_vaddr: 0x116120 p_paddr: 0x116120 p_filesz: 9272 p_memsz: 9280 p_flags: PF_W|PF_R p_align: 1048576 entry: 2 p_type: PT_DYNAMIC p_offset: 98824 p_vaddr: 0x118208 p_paddr: 0x118208 p_filesz: 432 p_memsz: 432 p_flags: PF_W|PF_R p_align: 8 entry: 3 - p_type: PT_NULL + p_type: PT_GNU_EH_FRAME p_offset: 90380 p_vaddr: 0x1610c p_paddr: 0x1610c p_filesz: 8 p_memsz: 8 p_flags: PF_R p_align: 4 symbol table (.dynsym): entry: 0 st_name: st_value: 0 st_size: 0 st_info: STT_NOTYPE STB_LOCAL st_shndx: 0 entry: 1 st_name: st_value: 0x120 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 1 entry: 2 st_name: st_value: 0x578 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 2 entry: 3 st_name: st_value: 0x12f8 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 3 entry: 4 st_name: st_value: 0x18aa st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 4 entry: 5 st_name: st_value: 0x19d0 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 5 entry: 6 st_name: st_value: 0x1a28 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 6 entry: 7 st_name: st_value: 0x1a48 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 7 entry: 8 st_name: st_value: 0x24b0 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 8 entry: 9 st_name: st_value: 0x2828 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 9 entry: 10 st_name: st_value: 0x283c st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 10 entry: 11 st_name: st_value: 0x2aa0 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 11 entry: 12 st_name: st_value: 0x14ec8 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 12 entry: 13 st_name: st_value: 0x14ee0 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 13 entry: 14 st_name: st_value: 0x1610c st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 14 entry: 15 st_name: st_value: 0x116120 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 15 entry: 16 st_name: st_value: 0x1165d8 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 16 entry: 17 st_name: st_value: 0x118208 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 17 entry: 18 st_name: st_value: 0x1183b8 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 18 entry: 19 st_name: st_value: 0x1183c8 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 19 entry: 20 st_name: st_value: 0x1183d8 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 20 entry: 21 st_name: st_value: 0x1183e0 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 21 entry: 22 st_name: st_value: 0x118558 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 22 entry: 23 st_name: st_value: 0 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 23 entry: 24 st_name: st_value: 0 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 24 entry: 25 st_name: st_value: 0 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 25 entry: 26 st_name: st_value: 0 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 26 entry: 27 st_name: st_value: 0 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 27 entry: 28 st_name: st_value: 0 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 28 entry: 29 st_name: st_value: 0 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 29 entry: 30 st_name: st_value: 0 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 30 entry: 31 st_name: st_value: 0 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 31 entry: 32 st_name: st_value: 0 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 32 entry: 33 st_name: gelf_getsyminfo st_value: 0x2fb0 st_size: 346 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 34 st_name: elf_strptr st_value: 0x5dd0 st_size: 361 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 35 st_name: write st_value: 0 st_size: 0 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 36 st_name: elf_newscn st_value: 0x7c60 st_size: 330 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 37 st_name: elf32_checksum st_value: 0x44e0 st_size: 10 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 38 st_name: gelf_getmove st_value: 0x4010 st_size: 404 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 39 st_name: elf_flagscn st_value: 0x8d10 st_size: 68 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 40 st_name: elf_rawdata st_value: 0x7e90 st_size: 360 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 41 st_name: elf_rawfile st_value: 0x6120 st_size: 74 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 42 st_name: elf_flagelf st_value: 0x8bd0 st_size: 116 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 43 st_name: strlcat st_value: 0 st_size: 123 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 44 st_name: elf_getident st_value: 0x6310 st_size: 202 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 45 st_name: elf_flagdata st_value: 0x8b70 st_size: 92 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 46 st_name: elf64_xlatetof st_value: 0x2bb0 st_size: 13 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 47 st_name: gelf_checksum st_value: 0x44a0 st_size: 40 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 48 st_name: gelf_getehdr st_value: 0x7870 st_size: 279 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 49 st_name: _libelf_get_no_error_message st_value: 0x6520 st_size: 11 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 50 st_name: __cxa_finalize st_value: 0 st_size: 305 st_info: STT_FUNC STB_WEAK st_shndx: 0 entry: 51 st_name: elf_begin st_value: 0x6690 st_size: 483 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 52 st_name: gelf_getrela st_value: 0x3600 st_size: 388 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 53 st_name: FBSD_1.0 st_value: 0 st_size: 0 st_info: STT_OBJECT STB_GLOBAL st_shndx: 65521 entry: 54 st_name: gelf_update_shdr st_value: 0x7390 st_size: 371 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 55 st_name: elf64_getphdr st_value: 0x3e40 st_size: 10 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 56 st_name: elf64_checksum st_value: 0x44d0 st_size: 10 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 57 st_name: elf64_xlatetom st_value: 0x2b90 st_size: 16 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 58 st_name: elf32_newehdr st_value: 0x7690 st_size: 15 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 59 st_name: elf_hash st_value: 0x14950 st_size: 70 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 60 st_name: __stack_chk_guard st_value: 0 st_size: 64 st_info: STT_OBJECT STB_GLOBAL st_shndx: 0 entry: 61 st_name: elf_getphnum st_value: 0x60b0 st_size: 106 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 62 st_name: gelf_getcap st_value: 0x4660 st_size: 345 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 63 st_name: elf64_newehdr st_value: 0x7680 st_size: 15 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 64 st_name: strerror st_value: 0 st_size: 48 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 65 st_name: elf32_getehdr st_value: 0x76b0 st_size: 12 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 66 st_name: gelf_fsize st_value: 0x13d00 st_size: 53 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 67 st_name: elf_getshstrndx st_value: 0x5f40 st_size: 106 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 68 st_name: gelf_update_syminfo st_value: 0x2e60 st_size: 329 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 69 st_name: gelf_getclass st_value: 0x41b0 st_size: 12 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 70 st_name: gelf_update_move st_value: 0x3e60 st_size: 419 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 71 st_name: elf_flagshdr st_value: 0x8d60 st_size: 5 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 72 st_name: gelf_getsym st_value: 0x32b0 st_size: 396 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 73 st_name: munmap st_value: 0 st_size: 0 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 74 st_name: gelf_xlatetof st_value: 0x2b20 st_size: 46 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 75 st_name: elf_nextscn st_value: 0x7e50 st_size: 59 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 76 st_name: elf64_newphdr st_value: 0x3c90 st_size: 13 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 77 st_name: strncpy st_value: 0 st_size: 76 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 78 st_name: gelf_newehdr st_value: 0x7650 st_size: 40 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 79 st_name: elf_getscn st_value: 0x7db0 st_size: 157 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 80 st_name: gelf_getdyn st_value: 0x4340 st_size: 346 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 81 st_name: elf_fill st_value: 0x64c0 st_size: 11 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 82 st_name: gelf_update_rel st_value: 0x3790 st_size: 396 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 83 st_name: gelf_newphdr st_value: 0x3c60 st_size: 36 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 84 st_name: gelf_update_dyn st_value: 0x41c0 st_size: 370 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 85 st_name: memset st_value: 0 st_size: 84 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 86 st_name: elf_getdata st_value: 0x8000 st_size: 766 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 87 st_name: elf_flagarhdr st_value: 0x8b20 st_size: 68 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 88 st_name: mmap st_value: 0 st_size: 190 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 89 st_name: __error st_value: 0 st_size: 8 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 90 st_name: __assert st_value: 0 st_size: 88 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 91 st_name: elf_version st_value: 0x47c0 st_size: 54 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 92 st_name: lseek st_value: 0 st_size: 103 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 93 st_name: gelf_xlatetom st_value: 0x2b50 st_size: 49 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 94 st_name: elf64_fsize st_value: 0x13d40 st_size: 13 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 95 st_name: elf_newdata st_value: 0x8300 st_size: 229 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 96 st_name: elf32_xlatetof st_value: 0x2bc0 st_size: 13 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 97 st_name: elf_setshstrndx st_value: 0x5fb0 st_size: 135 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 98 st_name: gelf_getsymshndx st_value: 0x2d10 st_size: 328 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 99 st_name: gelf_update_rela st_value: 0x3440 st_size: 441 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 100 st_name: ftruncate st_value: 0 st_size: 81 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 101 st_name: _libelf_get_max_error st_value: 0x64f0 st_size: 6 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 102 st_name: _libelf_get_unknown_error_message st_value: 0x6510 st_size: 12 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 103 st_name: calloc st_value: 0 st_size: 330 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 104 st_name: FBSDprivate_1.0 st_value: 0 st_size: 0 st_info: STT_OBJECT STB_GLOBAL st_shndx: 65521 entry: 105 st_name: elf32_getshdr st_value: 0x7520 st_size: 10 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 106 st_name: elf_end st_value: 0x83f0 st_size: 298 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 107 st_name: elf32_fsize st_value: 0x13d50 st_size: 13 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 108 st_name: elf_rand st_value: 0x6170 st_size: 97 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 109 st_name: elf_next st_value: 0x61e0 st_size: 267 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 110 st_name: gelf_getshdr st_value: 0x7530 st_size: 281 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 111 st_name: gelf_getphdr st_value: 0x3cb0 st_size: 397 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 112 st_name: elf64_getshdr st_value: 0x7510 st_size: 10 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 113 st_name: gelf_update_sym st_value: 0x3110 st_size: 416 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 114 st_name: elf_errmsg st_value: 0x6530 st_size: 226 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 115 st_name: elf32_xlatetom st_value: 0x2ba0 st_size: 16 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 116 st_name: _libelf_set_error st_value: 0x6500 st_size: 11 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 117 st_name: gelf_getrel st_value: 0x3920 st_size: 360 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 118 st_name: elf_getshnum st_value: 0x6040 st_size: 106 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 119 st_name: malloc st_value: 0 st_size: 175 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 120 st_name: elf64_getehdr st_value: 0x76a0 st_size: 12 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 121 st_name: elf_getarsym st_value: 0x6410 st_size: 127 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 122 st_name: memcpy st_value: 0 st_size: 74 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 123 st_name: elf_errno st_value: 0x64d0 st_size: 23 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 124 st_name: free st_value: 0 st_size: 118 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 125 st_name: gelf_update_symshndx st_value: 0x2bd0 st_size: 316 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 126 st_name: elf_ndxscn st_value: 0x7990 st_size: 33 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 127 st_name: elf_flagphdr st_value: 0x8cb0 st_size: 89 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 128 st_name: gelf_update_ehdr st_value: 0x76c0 st_size: 428 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 129 st_name: __stack_chk_fail st_value: 0 st_size: 12 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 130 st_name: gelf_update_phdr st_value: 0x3a90 st_size: 449 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 131 st_name: elf_getbase st_value: 0x63e0 st_size: 45 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 132 st_name: elf_getarhdr st_value: 0x6490 st_size: 38 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 133 st_name: gelf_update_cap st_value: 0x44f0 st_size: 364 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 134 st_name: elf_cntl st_value: 0x6620 st_size: 104 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 135 st_name: elf_memory st_value: 0x147c0 st_size: 390 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 136 st_name: elf_kind st_value: 0x62f0 st_size: 22 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 137 st_name: elf32_getphdr st_value: 0x3e50 st_size: 10 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 138 st_name: elf_flagehdr st_value: 0x8c50 st_size: 89 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 139 st_name: _Jv_RegisterClasses st_value: 0 st_size: 0 st_info: STT_NOTYPE STB_WEAK st_shndx: 0 entry: 140 st_name: elf32_newphdr st_value: 0x3ca0 st_size: 13 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 141 st_name: elf_update st_value: 0x4800 st_size: 5584 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 142 st_name: fstat st_value: 0 st_size: 0 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 143 st_name: strlcpy st_value: 0 st_size: 74 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 Index: vendor/elftoolchain/dist/test/elfdump/ts/dso2/@S@p%test.so.out =================================================================== --- vendor/elftoolchain/dist/test/elfdump/ts/dso2/@S@p%test.so.out (revision 300227) +++ vendor/elftoolchain/dist/test/elfdump/ts/dso2/@S@p%test.so.out (revision 300228) @@ -1,30 +1,30 @@ Program Header[0]: p_vaddr: 0 p_flags: [ PF_X|PF_R ] p_paddr: 0 p_type: [ PT_LOAD ] p_filesz: 0xc2c p_memsz: 0xc2c p_offset: 0 p_align: 0x200000 Program Header[1]: p_vaddr: 0x200c30 p_flags: [ PF_W|PF_R ] p_paddr: 0x200c30 p_type: [ PT_LOAD ] p_filesz: 0x240 p_memsz: 0x248 p_offset: 0xc30 p_align: 0x200000 Program Header[2]: p_vaddr: 0x200c58 p_flags: [ PF_W|PF_R ] p_paddr: 0x200c58 p_type: [ PT_DYNAMIC ] p_filesz: 0x190 p_memsz: 0x190 p_offset: 0xc58 p_align: 0x8 Program Header[3]: p_vaddr: 0xb10 p_flags: [ PF_R ] - p_paddr: 0xb10 p_type: [ PT_NULL ] + p_paddr: 0xb10 p_type: [ PT_GNU_EH_FRAME ] p_filesz: 0x3c p_memsz: 0x3c p_offset: 0xb10 p_align: 0x4 Program Header[4]: p_vaddr: 0 p_flags: [ PF_W|PF_R ] - p_paddr: 0 p_type: [ PT_LOAD ] + p_paddr: 0 p_type: [ PT_GNU_STACK ] p_filesz: 0 p_memsz: 0 p_offset: 0 p_align: 0x8 Index: vendor/elftoolchain/dist/test/elfdump/ts/dso2/@c@p@n%test.so.out =================================================================== --- vendor/elftoolchain/dist/test/elfdump/ts/dso2/@c@p@n%test.so.out (revision 300227) +++ vendor/elftoolchain/dist/test/elfdump/ts/dso2/@c@p@n%test.so.out (revision 300228) @@ -1,426 +1,426 @@ program header: entry: 0 p_type: PT_LOAD p_offset: 0 p_vaddr: 0 p_paddr: 0 p_filesz: 3116 p_memsz: 3116 p_flags: PF_X|PF_R p_align: 2097152 entry: 1 p_type: PT_LOAD p_offset: 3120 p_vaddr: 0x200c30 p_paddr: 0x200c30 p_filesz: 576 p_memsz: 584 p_flags: PF_W|PF_R p_align: 2097152 entry: 2 p_type: PT_DYNAMIC p_offset: 3160 p_vaddr: 0x200c58 p_paddr: 0x200c58 p_filesz: 400 p_memsz: 400 p_flags: PF_W|PF_R p_align: 8 entry: 3 - p_type: PT_NULL + p_type: PT_GNU_EH_FRAME p_offset: 2832 p_vaddr: 0xb10 p_paddr: 0xb10 p_filesz: 60 p_memsz: 60 p_flags: PF_R p_align: 4 entry: 4 - p_type: PT_LOAD + p_type: PT_GNU_STACK p_offset: 0 p_vaddr: 0 p_paddr: 0 p_filesz: 0 p_memsz: 0 p_flags: PF_W|PF_R p_align: 8 section header: entry: 0 sh_name: sh_type: SHT_NULL sh_flags: sh_addr: 0 sh_offset: 0 sh_size: 0 sh_link: 0 sh_info: 0 sh_addralign: 0 sh_entsize: 0 entry: 1 sh_name: .gnu.hash sh_type: SHT_GNU_HASH sh_flags: SHF_ALLOC sh_addr: 0x158 sh_offset: 344 sh_size: 80 sh_link: 2 sh_info: 0 sh_addralign: 8 sh_entsize: 0 entry: 2 sh_name: .dynsym sh_type: SHT_DYNSYM sh_flags: SHF_ALLOC sh_addr: 0x1a8 sh_offset: 424 sh_size: 576 sh_link: 3 sh_info: 2 sh_addralign: 8 sh_entsize: 24 entry: 3 sh_name: .dynstr sh_type: SHT_STRTAB sh_flags: SHF_ALLOC sh_addr: 0x3e8 sh_offset: 1000 sh_size: 196 sh_link: 0 sh_info: 0 sh_addralign: 1 sh_entsize: 0 entry: 4 sh_name: .gnu.version sh_type: SHT_SUNW(GNU)_versym sh_flags: SHF_ALLOC sh_addr: 0x4ac sh_offset: 1196 sh_size: 48 sh_link: 2 sh_info: 0 sh_addralign: 2 sh_entsize: 2 entry: 5 sh_name: .gnu.version_r sh_type: SHT_SUNW(GNU)_verneed sh_flags: SHF_ALLOC sh_addr: 0x4e0 sh_offset: 1248 sh_size: 64 sh_link: 3 sh_info: 2 sh_addralign: 8 sh_entsize: 0 entry: 6 sh_name: .rela.dyn sh_type: SHT_RELA sh_flags: SHF_ALLOC sh_addr: 0x520 sh_offset: 1312 sh_size: 120 sh_link: 2 sh_info: 0 sh_addralign: 8 sh_entsize: 24 entry: 7 sh_name: .rela.plt sh_type: SHT_RELA sh_flags: SHF_ALLOC sh_addr: 0x598 sh_offset: 1432 sh_size: 216 sh_link: 2 sh_info: 9 sh_addralign: 8 sh_entsize: 24 entry: 8 sh_name: .init sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC|SHF_EXECINSTR sh_addr: 0x670 sh_offset: 1648 sh_size: 24 sh_link: 0 sh_info: 0 sh_addralign: 4 sh_entsize: 0 entry: 9 sh_name: .plt sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC|SHF_EXECINSTR sh_addr: 0x688 sh_offset: 1672 sh_size: 160 sh_link: 0 sh_info: 0 sh_addralign: 4 sh_entsize: 16 entry: 10 sh_name: .text sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC|SHF_EXECINSTR sh_addr: 0x730 sh_offset: 1840 sh_size: 856 sh_link: 0 sh_info: 0 sh_addralign: 16 sh_entsize: 0 entry: 11 sh_name: .fini sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC|SHF_EXECINSTR sh_addr: 0xa88 sh_offset: 2696 sh_size: 14 sh_link: 0 sh_info: 0 sh_addralign: 4 sh_entsize: 0 entry: 12 sh_name: .rodata sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC sh_addr: 0xa98 sh_offset: 2712 sh_size: 120 sh_link: 0 sh_info: 0 sh_addralign: 8 sh_entsize: 0 entry: 13 sh_name: .eh_frame_hdr sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC sh_addr: 0xb10 sh_offset: 2832 sh_size: 60 sh_link: 0 sh_info: 0 sh_addralign: 4 sh_entsize: 0 entry: 14 sh_name: .eh_frame sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC sh_addr: 0xb50 sh_offset: 2896 sh_size: 220 sh_link: 0 sh_info: 0 sh_addralign: 8 sh_entsize: 0 entry: 15 sh_name: .ctors sh_type: SHT_PROGBITS sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x200c30 sh_offset: 3120 sh_size: 16 sh_link: 0 sh_info: 0 sh_addralign: 8 sh_entsize: 0 entry: 16 sh_name: .dtors sh_type: SHT_PROGBITS sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x200c40 sh_offset: 3136 sh_size: 16 sh_link: 0 sh_info: 0 sh_addralign: 8 sh_entsize: 0 entry: 17 sh_name: .jcr sh_type: SHT_PROGBITS sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x200c50 sh_offset: 3152 sh_size: 8 sh_link: 0 sh_info: 0 sh_addralign: 8 sh_entsize: 0 entry: 18 sh_name: .dynamic sh_type: SHT_DYNAMIC sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x200c58 sh_offset: 3160 sh_size: 400 sh_link: 3 sh_info: 0 sh_addralign: 8 sh_entsize: 16 entry: 19 sh_name: .got sh_type: SHT_PROGBITS sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x200de8 sh_offset: 3560 sh_size: 24 sh_link: 0 sh_info: 0 sh_addralign: 8 sh_entsize: 8 entry: 20 sh_name: .got.plt sh_type: SHT_PROGBITS sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x200e00 sh_offset: 3584 sh_size: 96 sh_link: 0 sh_info: 0 sh_addralign: 8 sh_entsize: 8 entry: 21 sh_name: .data sh_type: SHT_PROGBITS sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x200e60 sh_offset: 3680 sh_size: 16 sh_link: 0 sh_info: 0 sh_addralign: 8 sh_entsize: 0 entry: 22 sh_name: .bss sh_type: SHT_NOBITS sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x200e70 sh_offset: 3696 sh_size: 8 sh_link: 0 sh_info: 0 sh_addralign: 4 sh_entsize: 0 entry: 23 sh_name: .comment sh_type: SHT_PROGBITS sh_flags: sh_addr: 0 sh_offset: 3696 sh_size: 290 sh_link: 0 sh_info: 0 sh_addralign: 1 sh_entsize: 0 entry: 24 sh_name: .debug_aranges sh_type: SHT_PROGBITS sh_flags: sh_addr: 0 sh_offset: 4000 sh_size: 144 sh_link: 0 sh_info: 0 sh_addralign: 16 sh_entsize: 0 entry: 25 sh_name: .debug_info sh_type: SHT_PROGBITS sh_flags: sh_addr: 0 sh_offset: 4144 sh_size: 420 sh_link: 0 sh_info: 0 sh_addralign: 1 sh_entsize: 0 entry: 26 sh_name: .debug_abbrev sh_type: SHT_PROGBITS sh_flags: sh_addr: 0 sh_offset: 4564 sh_size: 32 sh_link: 0 sh_info: 0 sh_addralign: 1 sh_entsize: 0 entry: 27 sh_name: .debug_line sh_type: SHT_PROGBITS sh_flags: sh_addr: 0 sh_offset: 4596 sh_size: 352 sh_link: 0 sh_info: 0 sh_addralign: 1 sh_entsize: 0 entry: 28 sh_name: .shstrtab sh_type: SHT_STRTAB sh_flags: sh_addr: 0 sh_offset: 4948 sh_size: 266 sh_link: 0 sh_info: 0 sh_addralign: 1 sh_entsize: 0 entry: 29 sh_name: .symtab sh_type: SHT_SYMTAB sh_flags: sh_addr: 0 sh_offset: 7200 sh_size: 1752 sh_link: 30 sh_info: 51 sh_addralign: 8 sh_entsize: 24 entry: 30 sh_name: .strtab sh_type: SHT_STRTAB sh_flags: sh_addr: 0 sh_offset: 8952 sh_size: 732 sh_link: 0 sh_info: 0 sh_addralign: 1 sh_entsize: 0 Index: vendor/elftoolchain/dist/test/elfdump/ts/dso2/@e@p@c%test.so.out =================================================================== --- vendor/elftoolchain/dist/test/elfdump/ts/dso2/@e@p@c%test.so.out (revision 300227) +++ vendor/elftoolchain/dist/test/elfdump/ts/dso2/@e@p@c%test.so.out (revision 300228) @@ -1,443 +1,443 @@ elf header: e_ident: ELFCLASS64 ELFDATA2LSB ELFOSABI_NONE e_type: ET_DYN e_machine: EM_X86_64 e_version: EV_CURRENT e_entry: 0x730 e_phoff: 64 e_shoff: 5216 e_flags: 0 e_ehsize: 64 e_phentsize: 56 e_phnum: 5 e_shentsize: 64 e_shnum: 31 e_shstrndx: 28 program header: entry: 0 p_type: PT_LOAD p_offset: 0 p_vaddr: 0 p_paddr: 0 p_filesz: 3116 p_memsz: 3116 p_flags: PF_X|PF_R p_align: 2097152 entry: 1 p_type: PT_LOAD p_offset: 3120 p_vaddr: 0x200c30 p_paddr: 0x200c30 p_filesz: 576 p_memsz: 584 p_flags: PF_W|PF_R p_align: 2097152 entry: 2 p_type: PT_DYNAMIC p_offset: 3160 p_vaddr: 0x200c58 p_paddr: 0x200c58 p_filesz: 400 p_memsz: 400 p_flags: PF_W|PF_R p_align: 8 entry: 3 - p_type: PT_NULL + p_type: PT_GNU_EH_FRAME p_offset: 2832 p_vaddr: 0xb10 p_paddr: 0xb10 p_filesz: 60 p_memsz: 60 p_flags: PF_R p_align: 4 entry: 4 - p_type: PT_LOAD + p_type: PT_GNU_STACK p_offset: 0 p_vaddr: 0 p_paddr: 0 p_filesz: 0 p_memsz: 0 p_flags: PF_W|PF_R p_align: 8 section header: entry: 0 sh_name: sh_type: SHT_NULL sh_flags: sh_addr: 0 sh_offset: 0 sh_size: 0 sh_link: 0 sh_info: 0 sh_addralign: 0 sh_entsize: 0 entry: 1 sh_name: .gnu.hash sh_type: SHT_GNU_HASH sh_flags: SHF_ALLOC sh_addr: 0x158 sh_offset: 344 sh_size: 80 sh_link: 2 sh_info: 0 sh_addralign: 8 sh_entsize: 0 entry: 2 sh_name: .dynsym sh_type: SHT_DYNSYM sh_flags: SHF_ALLOC sh_addr: 0x1a8 sh_offset: 424 sh_size: 576 sh_link: 3 sh_info: 2 sh_addralign: 8 sh_entsize: 24 entry: 3 sh_name: .dynstr sh_type: SHT_STRTAB sh_flags: SHF_ALLOC sh_addr: 0x3e8 sh_offset: 1000 sh_size: 196 sh_link: 0 sh_info: 0 sh_addralign: 1 sh_entsize: 0 entry: 4 sh_name: .gnu.version sh_type: SHT_SUNW(GNU)_versym sh_flags: SHF_ALLOC sh_addr: 0x4ac sh_offset: 1196 sh_size: 48 sh_link: 2 sh_info: 0 sh_addralign: 2 sh_entsize: 2 entry: 5 sh_name: .gnu.version_r sh_type: SHT_SUNW(GNU)_verneed sh_flags: SHF_ALLOC sh_addr: 0x4e0 sh_offset: 1248 sh_size: 64 sh_link: 3 sh_info: 2 sh_addralign: 8 sh_entsize: 0 entry: 6 sh_name: .rela.dyn sh_type: SHT_RELA sh_flags: SHF_ALLOC sh_addr: 0x520 sh_offset: 1312 sh_size: 120 sh_link: 2 sh_info: 0 sh_addralign: 8 sh_entsize: 24 entry: 7 sh_name: .rela.plt sh_type: SHT_RELA sh_flags: SHF_ALLOC sh_addr: 0x598 sh_offset: 1432 sh_size: 216 sh_link: 2 sh_info: 9 sh_addralign: 8 sh_entsize: 24 entry: 8 sh_name: .init sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC|SHF_EXECINSTR sh_addr: 0x670 sh_offset: 1648 sh_size: 24 sh_link: 0 sh_info: 0 sh_addralign: 4 sh_entsize: 0 entry: 9 sh_name: .plt sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC|SHF_EXECINSTR sh_addr: 0x688 sh_offset: 1672 sh_size: 160 sh_link: 0 sh_info: 0 sh_addralign: 4 sh_entsize: 16 entry: 10 sh_name: .text sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC|SHF_EXECINSTR sh_addr: 0x730 sh_offset: 1840 sh_size: 856 sh_link: 0 sh_info: 0 sh_addralign: 16 sh_entsize: 0 entry: 11 sh_name: .fini sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC|SHF_EXECINSTR sh_addr: 0xa88 sh_offset: 2696 sh_size: 14 sh_link: 0 sh_info: 0 sh_addralign: 4 sh_entsize: 0 entry: 12 sh_name: .rodata sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC sh_addr: 0xa98 sh_offset: 2712 sh_size: 120 sh_link: 0 sh_info: 0 sh_addralign: 8 sh_entsize: 0 entry: 13 sh_name: .eh_frame_hdr sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC sh_addr: 0xb10 sh_offset: 2832 sh_size: 60 sh_link: 0 sh_info: 0 sh_addralign: 4 sh_entsize: 0 entry: 14 sh_name: .eh_frame sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC sh_addr: 0xb50 sh_offset: 2896 sh_size: 220 sh_link: 0 sh_info: 0 sh_addralign: 8 sh_entsize: 0 entry: 15 sh_name: .ctors sh_type: SHT_PROGBITS sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x200c30 sh_offset: 3120 sh_size: 16 sh_link: 0 sh_info: 0 sh_addralign: 8 sh_entsize: 0 entry: 16 sh_name: .dtors sh_type: SHT_PROGBITS sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x200c40 sh_offset: 3136 sh_size: 16 sh_link: 0 sh_info: 0 sh_addralign: 8 sh_entsize: 0 entry: 17 sh_name: .jcr sh_type: SHT_PROGBITS sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x200c50 sh_offset: 3152 sh_size: 8 sh_link: 0 sh_info: 0 sh_addralign: 8 sh_entsize: 0 entry: 18 sh_name: .dynamic sh_type: SHT_DYNAMIC sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x200c58 sh_offset: 3160 sh_size: 400 sh_link: 3 sh_info: 0 sh_addralign: 8 sh_entsize: 16 entry: 19 sh_name: .got sh_type: SHT_PROGBITS sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x200de8 sh_offset: 3560 sh_size: 24 sh_link: 0 sh_info: 0 sh_addralign: 8 sh_entsize: 8 entry: 20 sh_name: .got.plt sh_type: SHT_PROGBITS sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x200e00 sh_offset: 3584 sh_size: 96 sh_link: 0 sh_info: 0 sh_addralign: 8 sh_entsize: 8 entry: 21 sh_name: .data sh_type: SHT_PROGBITS sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x200e60 sh_offset: 3680 sh_size: 16 sh_link: 0 sh_info: 0 sh_addralign: 8 sh_entsize: 0 entry: 22 sh_name: .bss sh_type: SHT_NOBITS sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x200e70 sh_offset: 3696 sh_size: 8 sh_link: 0 sh_info: 0 sh_addralign: 4 sh_entsize: 0 entry: 23 sh_name: .comment sh_type: SHT_PROGBITS sh_flags: sh_addr: 0 sh_offset: 3696 sh_size: 290 sh_link: 0 sh_info: 0 sh_addralign: 1 sh_entsize: 0 entry: 24 sh_name: .debug_aranges sh_type: SHT_PROGBITS sh_flags: sh_addr: 0 sh_offset: 4000 sh_size: 144 sh_link: 0 sh_info: 0 sh_addralign: 16 sh_entsize: 0 entry: 25 sh_name: .debug_info sh_type: SHT_PROGBITS sh_flags: sh_addr: 0 sh_offset: 4144 sh_size: 420 sh_link: 0 sh_info: 0 sh_addralign: 1 sh_entsize: 0 entry: 26 sh_name: .debug_abbrev sh_type: SHT_PROGBITS sh_flags: sh_addr: 0 sh_offset: 4564 sh_size: 32 sh_link: 0 sh_info: 0 sh_addralign: 1 sh_entsize: 0 entry: 27 sh_name: .debug_line sh_type: SHT_PROGBITS sh_flags: sh_addr: 0 sh_offset: 4596 sh_size: 352 sh_link: 0 sh_info: 0 sh_addralign: 1 sh_entsize: 0 entry: 28 sh_name: .shstrtab sh_type: SHT_STRTAB sh_flags: sh_addr: 0 sh_offset: 4948 sh_size: 266 sh_link: 0 sh_info: 0 sh_addralign: 1 sh_entsize: 0 entry: 29 sh_name: .symtab sh_type: SHT_SYMTAB sh_flags: sh_addr: 0 sh_offset: 7200 sh_size: 1752 sh_link: 30 sh_info: 51 sh_addralign: 8 sh_entsize: 24 entry: 30 sh_name: .strtab sh_type: SHT_STRTAB sh_flags: sh_addr: 0 sh_offset: 8952 sh_size: 732 sh_link: 0 sh_info: 0 sh_addralign: 1 sh_entsize: 0 Index: vendor/elftoolchain/dist/test/elfdump/ts/dso2/@p%test.so.out =================================================================== --- vendor/elftoolchain/dist/test/elfdump/ts/dso2/@p%test.so.out (revision 300227) +++ vendor/elftoolchain/dist/test/elfdump/ts/dso2/@p%test.so.out (revision 300228) @@ -1,52 +1,52 @@ program header: entry: 0 p_type: PT_LOAD p_offset: 0 p_vaddr: 0 p_paddr: 0 p_filesz: 3116 p_memsz: 3116 p_flags: PF_X|PF_R p_align: 2097152 entry: 1 p_type: PT_LOAD p_offset: 3120 p_vaddr: 0x200c30 p_paddr: 0x200c30 p_filesz: 576 p_memsz: 584 p_flags: PF_W|PF_R p_align: 2097152 entry: 2 p_type: PT_DYNAMIC p_offset: 3160 p_vaddr: 0x200c58 p_paddr: 0x200c58 p_filesz: 400 p_memsz: 400 p_flags: PF_W|PF_R p_align: 8 entry: 3 - p_type: PT_NULL + p_type: PT_GNU_EH_FRAME p_offset: 2832 p_vaddr: 0xb10 p_paddr: 0xb10 p_filesz: 60 p_memsz: 60 p_flags: PF_R p_align: 4 entry: 4 - p_type: PT_LOAD + p_type: PT_GNU_STACK p_offset: 0 p_vaddr: 0 p_paddr: 0 p_filesz: 0 p_memsz: 0 p_flags: PF_W|PF_R p_align: 8 Index: vendor/elftoolchain/dist/test/elfdump/ts/dso2/@p@s%test.so.out =================================================================== --- vendor/elftoolchain/dist/test/elfdump/ts/dso2/@p@s%test.so.out (revision 300227) +++ vendor/elftoolchain/dist/test/elfdump/ts/dso2/@p@s%test.so.out (revision 300228) @@ -1,735 +1,735 @@ program header: entry: 0 p_type: PT_LOAD p_offset: 0 p_vaddr: 0 p_paddr: 0 p_filesz: 3116 p_memsz: 3116 p_flags: PF_X|PF_R p_align: 2097152 entry: 1 p_type: PT_LOAD p_offset: 3120 p_vaddr: 0x200c30 p_paddr: 0x200c30 p_filesz: 576 p_memsz: 584 p_flags: PF_W|PF_R p_align: 2097152 entry: 2 p_type: PT_DYNAMIC p_offset: 3160 p_vaddr: 0x200c58 p_paddr: 0x200c58 p_filesz: 400 p_memsz: 400 p_flags: PF_W|PF_R p_align: 8 entry: 3 - p_type: PT_NULL + p_type: PT_GNU_EH_FRAME p_offset: 2832 p_vaddr: 0xb10 p_paddr: 0xb10 p_filesz: 60 p_memsz: 60 p_flags: PF_R p_align: 4 entry: 4 - p_type: PT_LOAD + p_type: PT_GNU_STACK p_offset: 0 p_vaddr: 0 p_paddr: 0 p_filesz: 0 p_memsz: 0 p_flags: PF_W|PF_R p_align: 8 symbol table (.dynsym): entry: 0 st_name: st_value: 0 st_size: 0 st_info: STT_NOTYPE STB_LOCAL st_shndx: 0 entry: 1 st_name: st_value: 0x670 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 8 entry: 2 st_name: printf st_value: 0 st_size: 0 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 3 st_name: __gmon_start__ st_value: 0 st_size: 0 st_info: STT_NOTYPE STB_WEAK st_shndx: 0 entry: 4 st_name: _Jv_RegisterClasses st_value: 0 st_size: 0 st_info: STT_NOTYPE STB_WEAK st_shndx: 0 entry: 5 st_name: puts st_value: 0 st_size: 0 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 6 st_name: toupper st_value: 0 st_size: 0 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 7 st_name: cos st_value: 0 st_size: 0 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 8 st_name: cosh st_value: 0 st_size: 0 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 9 st_name: __cxa_finalize st_value: 0 st_size: 0 st_info: STT_FUNC STB_WEAK st_shndx: 0 entry: 10 st_name: gets st_value: 0 st_size: 0 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 11 st_name: tolower st_value: 0 st_size: 0 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 12 st_name: acos st_value: 0 st_size: 0 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 13 st_name: _end st_value: 0x200e78 st_size: 0 st_info: STT_NOTYPE STB_GLOBAL st_shndx: 65521 entry: 14 st_name: _edata st_value: 0x200e70 st_size: 0 st_info: STT_NOTYPE STB_GLOBAL st_shndx: 65521 entry: 15 st_name: add4 st_value: 0x802 st_size: 18 st_info: STT_FUNC STB_GLOBAL st_shndx: 10 entry: 16 st_name: mathstring st_value: 0x828 st_size: 538 st_info: STT_FUNC STB_GLOBAL st_shndx: 10 entry: 17 st_name: add2 st_value: 0x7de st_size: 18 st_info: STT_FUNC STB_GLOBAL st_shndx: 10 entry: 18 st_name: add st_value: 0x7cc st_size: 18 st_info: STT_FUNC STB_GLOBAL st_shndx: 10 entry: 19 st_name: __bss_start st_value: 0x200e70 st_size: 0 st_info: STT_NOTYPE STB_GLOBAL st_shndx: 65521 entry: 20 st_name: _init st_value: 0x670 st_size: 0 st_info: STT_FUNC STB_GLOBAL st_shndx: 8 entry: 21 st_name: _fini st_value: 0xa88 st_size: 0 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 22 st_name: add3 st_value: 0x7f0 st_size: 18 st_info: STT_FUNC STB_GLOBAL st_shndx: 10 entry: 23 st_name: sub st_value: 0x814 st_size: 20 st_info: STT_FUNC STB_GLOBAL st_shndx: 10 symbol table (.symtab): entry: 0 st_name: st_value: 0 st_size: 0 st_info: STT_NOTYPE STB_LOCAL st_shndx: 0 entry: 1 st_name: st_value: 0x158 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 1 entry: 2 st_name: st_value: 0x1a8 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 2 entry: 3 st_name: st_value: 0x3e8 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 3 entry: 4 st_name: st_value: 0x4ac st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 4 entry: 5 st_name: st_value: 0x4e0 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 5 entry: 6 st_name: st_value: 0x520 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 6 entry: 7 st_name: st_value: 0x598 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 7 entry: 8 st_name: st_value: 0x670 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 8 entry: 9 st_name: st_value: 0x688 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 9 entry: 10 st_name: st_value: 0x730 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 10 entry: 11 st_name: st_value: 0xa88 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 11 entry: 12 st_name: st_value: 0xa98 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 12 entry: 13 st_name: st_value: 0xb10 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 13 entry: 14 st_name: st_value: 0xb50 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 14 entry: 15 st_name: st_value: 0x200c30 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 15 entry: 16 st_name: st_value: 0x200c40 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 16 entry: 17 st_name: st_value: 0x200c50 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 17 entry: 18 st_name: st_value: 0x200c58 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 18 entry: 19 st_name: st_value: 0x200de8 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 19 entry: 20 st_name: st_value: 0x200e00 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 20 entry: 21 st_name: st_value: 0x200e60 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 21 entry: 22 st_name: st_value: 0x200e70 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 22 entry: 23 st_name: st_value: 0 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 23 entry: 24 st_name: st_value: 0 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 24 entry: 25 st_name: st_value: 0 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 25 entry: 26 st_name: st_value: 0 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 26 entry: 27 st_name: st_value: 0 st_size: 0 st_info: STT_SECTION STB_LOCAL st_shndx: 27 entry: 28 st_name: initfini.c st_value: 0 st_size: 0 st_info: STT_FILE STB_LOCAL st_shndx: 65521 entry: 29 st_name: /home/aurel32/debian/co-packages/glibc/etch/glibc-2.3.6.ds1/build-tree/amd64-libc/csu/crti.S st_value: 0 st_size: 0 st_info: STT_FILE STB_LOCAL st_shndx: 65521 entry: 30 st_name: call_gmon_start st_value: 0x730 st_size: 0 st_info: STT_FUNC STB_LOCAL st_shndx: 10 entry: 31 st_name: crtstuff.c st_value: 0 st_size: 0 st_info: STT_FILE STB_LOCAL st_shndx: 65521 entry: 32 st_name: __CTOR_LIST__ st_value: 0x200c30 st_size: 0 st_info: STT_OBJECT STB_LOCAL st_shndx: 15 entry: 33 st_name: __DTOR_LIST__ st_value: 0x200c40 st_size: 0 st_info: STT_OBJECT STB_LOCAL st_shndx: 16 entry: 34 st_name: __JCR_LIST__ st_value: 0x200c50 st_size: 0 st_info: STT_OBJECT STB_LOCAL st_shndx: 17 entry: 35 st_name: completed.5959 st_value: 0x200e70 st_size: 1 st_info: STT_OBJECT STB_LOCAL st_shndx: 22 entry: 36 st_name: p.5957 st_value: 0x200e68 st_size: 0 st_info: STT_OBJECT STB_LOCAL st_shndx: 21 entry: 37 st_name: __do_global_dtors_aux st_value: 0x750 st_size: 0 st_info: STT_FUNC STB_LOCAL st_shndx: 10 entry: 38 st_name: frame_dummy st_value: 0x7a0 st_size: 0 st_info: STT_FUNC STB_LOCAL st_shndx: 10 entry: 39 st_name: crtstuff.c st_value: 0 st_size: 0 st_info: STT_FILE STB_LOCAL st_shndx: 65521 entry: 40 st_name: __CTOR_END__ st_value: 0x200c38 st_size: 0 st_info: STT_OBJECT STB_LOCAL st_shndx: 15 entry: 41 st_name: __DTOR_END__ st_value: 0x200c48 st_size: 0 st_info: STT_OBJECT STB_LOCAL st_shndx: 16 entry: 42 st_name: __FRAME_END__ st_value: 0xc28 st_size: 0 st_info: STT_OBJECT STB_LOCAL st_shndx: 14 entry: 43 st_name: __JCR_END__ st_value: 0x200c50 st_size: 0 st_info: STT_OBJECT STB_LOCAL st_shndx: 17 entry: 44 st_name: __do_global_ctors_aux st_value: 0xa50 st_size: 0 st_info: STT_FUNC STB_LOCAL st_shndx: 10 entry: 45 st_name: initfini.c st_value: 0 st_size: 0 st_info: STT_FILE STB_LOCAL st_shndx: 65521 entry: 46 st_name: /home/aurel32/debian/co-packages/glibc/etch/glibc-2.3.6.ds1/build-tree/amd64-libc/csu/crtn.S st_value: 0 st_size: 0 st_info: STT_FILE STB_LOCAL st_shndx: 65521 entry: 47 st_name: test2.c st_value: 0 st_size: 0 st_info: STT_FILE STB_LOCAL st_shndx: 65521 entry: 48 st_name: _GLOBAL_OFFSET_TABLE_ st_value: 0x200e00 st_size: 0 st_info: STT_OBJECT STB_LOCAL st_shndx: 65521 entry: 49 st_name: __dso_handle st_value: 0x200e60 st_size: 0 st_info: STT_OBJECT STB_LOCAL st_shndx: 21 entry: 50 st_name: _DYNAMIC st_value: 0x200c58 st_size: 0 st_info: STT_OBJECT STB_LOCAL st_shndx: 65521 entry: 51 st_name: printf@@GLIBC_2.2.5 st_value: 0 st_size: 0 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 52 st_name: mathstring st_value: 0x828 st_size: 538 st_info: STT_FUNC STB_GLOBAL st_shndx: 10 entry: 53 st_name: __gmon_start__ st_value: 0 st_size: 0 st_info: STT_NOTYPE STB_WEAK st_shndx: 0 entry: 54 st_name: _Jv_RegisterClasses st_value: 0 st_size: 0 st_info: STT_NOTYPE STB_WEAK st_shndx: 0 entry: 55 st_name: puts@@GLIBC_2.2.5 st_value: 0 st_size: 0 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 56 st_name: toupper@@GLIBC_2.2.5 st_value: 0 st_size: 0 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 57 st_name: _fini st_value: 0xa88 st_size: 0 st_info: STT_FUNC STB_GLOBAL st_shndx: 11 entry: 58 st_name: add3 st_value: 0x7f0 st_size: 18 st_info: STT_FUNC STB_GLOBAL st_shndx: 10 entry: 59 st_name: cos@@GLIBC_2.2.5 st_value: 0 st_size: 0 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 60 st_name: cosh@@GLIBC_2.2.5 st_value: 0 st_size: 0 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 61 st_name: __cxa_finalize@@GLIBC_2.2.5 st_value: 0 st_size: 0 st_info: STT_FUNC STB_WEAK st_shndx: 0 entry: 62 st_name: add2 st_value: 0x7de st_size: 18 st_info: STT_FUNC STB_GLOBAL st_shndx: 10 entry: 63 st_name: gets@@GLIBC_2.2.5 st_value: 0 st_size: 0 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 64 st_name: add st_value: 0x7cc st_size: 18 st_info: STT_FUNC STB_GLOBAL st_shndx: 10 entry: 65 st_name: __bss_start st_value: 0x200e70 st_size: 0 st_info: STT_NOTYPE STB_GLOBAL st_shndx: 65521 entry: 66 st_name: tolower@@GLIBC_2.2.5 st_value: 0 st_size: 0 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 67 st_name: acos@@GLIBC_2.2.5 st_value: 0 st_size: 0 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 68 st_name: _end st_value: 0x200e78 st_size: 0 st_info: STT_NOTYPE STB_GLOBAL st_shndx: 65521 entry: 69 st_name: _edata st_value: 0x200e70 st_size: 0 st_info: STT_NOTYPE STB_GLOBAL st_shndx: 65521 entry: 70 st_name: sub st_value: 0x814 st_size: 20 st_info: STT_FUNC STB_GLOBAL st_shndx: 10 entry: 71 st_name: _init st_value: 0x670 st_size: 0 st_info: STT_FUNC STB_GLOBAL st_shndx: 8 entry: 72 st_name: add4 st_value: 0x802 st_size: 18 st_info: STT_FUNC STB_GLOBAL st_shndx: 10 Index: vendor/elftoolchain/dist/test/elfdump/ts/exec1/@S@e@p%ls.out =================================================================== --- vendor/elftoolchain/dist/test/elfdump/ts/exec1/@S@e@p%ls.out (revision 300227) +++ vendor/elftoolchain/dist/test/elfdump/ts/exec1/@S@e@p%ls.out (revision 300228) @@ -1,52 +1,52 @@ ELF Header ei_magic: { 0x7f, E, L, F } ei_class: ELFCLASS64 ei_data: ELFDATA2LSB e_machine: EM_X86_64 e_version: EV_CURRENT e_type: ET_EXEC e_flags: 0 e_entry: 0x401cc0 e_ehsize: 64 e_shstrndx: 25 e_shoff: 0x6eb0 e_shentsize: 64 e_shnum: 26 e_phoff: 0x40 e_phentsize: 56 e_phnum: 7 Program Header[0]: p_vaddr: 0x400040 p_flags: [ PF_X|PF_R ] p_paddr: 0x400040 p_type: [ PT_PHDR ] p_filesz: 0x188 p_memsz: 0x188 p_offset: 0x40 p_align: 0x8 Program Header[1]: p_vaddr: 0x4001c8 p_flags: [ PF_R ] p_paddr: 0x4001c8 p_type: [ PT_INTERP ] p_filesz: 0x15 p_memsz: 0x15 p_offset: 0x1c8 p_align: 0x1 Program Header[2]: p_vaddr: 0x400000 p_flags: [ PF_X|PF_R ] p_paddr: 0x400000 p_type: [ PT_LOAD ] p_filesz: 0x6144 p_memsz: 0x6144 p_offset: 0 p_align: 0x100000 Program Header[3]: p_vaddr: 0x506150 p_flags: [ PF_W|PF_R ] p_paddr: 0x506150 p_type: [ PT_LOAD ] p_filesz: 0x9d8 p_memsz: 0xc08 p_offset: 0x6150 p_align: 0x100000 Program Header[4]: p_vaddr: 0x506708 p_flags: [ PF_W|PF_R ] p_paddr: 0x506708 p_type: [ PT_DYNAMIC ] p_filesz: 0x1b0 p_memsz: 0x1b0 p_offset: 0x6708 p_align: 0x8 Program Header[5]: p_vaddr: 0x4001e0 p_flags: [ PF_R ] p_paddr: 0x4001e0 p_type: [ PT_NOTE ] p_filesz: 0x18 p_memsz: 0x18 p_offset: 0x1e0 p_align: 0x4 Program Header[6]: p_vaddr: 0x40613c p_flags: [ PF_R ] - p_paddr: 0x40613c p_type: [ PT_NULL ] + p_paddr: 0x40613c p_type: [ PT_GNU_EH_FRAME ] p_filesz: 0x8 p_memsz: 0x8 p_offset: 0x613c p_align: 0x4 Index: vendor/elftoolchain/dist/test/elfdump/ts/exec1/@c@p@n%ls.out =================================================================== --- vendor/elftoolchain/dist/test/elfdump/ts/exec1/@c@p@n%ls.out (revision 300227) +++ vendor/elftoolchain/dist/test/elfdump/ts/exec1/@c@p@n%ls.out (revision 300228) @@ -1,389 +1,389 @@ program header: entry: 0 p_type: PT_PHDR p_offset: 64 p_vaddr: 0x400040 p_paddr: 0x400040 p_filesz: 392 p_memsz: 392 p_flags: PF_X|PF_R p_align: 8 entry: 1 p_type: PT_INTERP p_offset: 456 p_vaddr: 0x4001c8 p_paddr: 0x4001c8 p_filesz: 21 p_memsz: 21 p_flags: PF_R p_align: 1 entry: 2 p_type: PT_LOAD p_offset: 0 p_vaddr: 0x400000 p_paddr: 0x400000 p_filesz: 24900 p_memsz: 24900 p_flags: PF_X|PF_R p_align: 1048576 entry: 3 p_type: PT_LOAD p_offset: 24912 p_vaddr: 0x506150 p_paddr: 0x506150 p_filesz: 2520 p_memsz: 3080 p_flags: PF_W|PF_R p_align: 1048576 entry: 4 p_type: PT_DYNAMIC p_offset: 26376 p_vaddr: 0x506708 p_paddr: 0x506708 p_filesz: 432 p_memsz: 432 p_flags: PF_W|PF_R p_align: 8 entry: 5 p_type: PT_NOTE p_offset: 480 p_vaddr: 0x4001e0 p_paddr: 0x4001e0 p_filesz: 24 p_memsz: 24 p_flags: PF_R p_align: 4 entry: 6 - p_type: PT_NULL + p_type: PT_GNU_EH_FRAME p_offset: 24892 p_vaddr: 0x40613c p_paddr: 0x40613c p_filesz: 8 p_memsz: 8 p_flags: PF_R p_align: 4 section header: entry: 0 sh_name: sh_type: SHT_NULL sh_flags: sh_addr: 0 sh_offset: 0 sh_size: 0 sh_link: 0 sh_info: 0 sh_addralign: 0 sh_entsize: 0 entry: 1 sh_name: .interp sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC sh_addr: 0x4001c8 sh_offset: 456 sh_size: 21 sh_link: 0 sh_info: 0 sh_addralign: 1 sh_entsize: 0 entry: 2 sh_name: .note.ABI-tag sh_type: SHT_NOTE sh_flags: SHF_ALLOC sh_addr: 0x4001e0 sh_offset: 480 sh_size: 24 sh_link: 0 sh_info: 0 sh_addralign: 4 sh_entsize: 0 entry: 3 sh_name: .hash sh_type: SHT_HASH sh_flags: SHF_ALLOC sh_addr: 0x4001f8 sh_offset: 504 sh_size: 632 sh_link: 4 sh_info: 0 sh_addralign: 8 sh_entsize: 4 entry: 4 sh_name: .dynsym sh_type: SHT_DYNSYM sh_flags: SHF_ALLOC sh_addr: 0x400470 sh_offset: 1136 sh_size: 2136 sh_link: 5 sh_info: 1 sh_addralign: 8 sh_entsize: 24 entry: 5 sh_name: .dynstr sh_type: SHT_STRTAB sh_flags: SHF_ALLOC sh_addr: 0x400cc8 sh_offset: 3272 sh_size: 828 sh_link: 0 sh_info: 0 sh_addralign: 1 sh_entsize: 0 entry: 6 sh_name: .gnu.version sh_type: SHT_SUNW(GNU)_versym sh_flags: SHF_ALLOC sh_addr: 0x401004 sh_offset: 4100 sh_size: 178 sh_link: 4 sh_info: 0 sh_addralign: 2 sh_entsize: 2 entry: 7 sh_name: .gnu.version_r sh_type: SHT_SUNW(GNU)_verneed sh_flags: SHF_ALLOC sh_addr: 0x4010b8 sh_offset: 4280 sh_size: 48 sh_link: 5 sh_info: 1 sh_addralign: 8 sh_entsize: 0 entry: 8 sh_name: .rela.dyn sh_type: SHT_RELA sh_flags: SHF_ALLOC sh_addr: 0x4010e8 sh_offset: 4328 sh_size: 192 sh_link: 4 sh_info: 0 sh_addralign: 8 sh_entsize: 24 entry: 9 sh_name: .rela.plt sh_type: SHT_RELA sh_flags: SHF_ALLOC sh_addr: 0x4011a8 sh_offset: 4520 sh_size: 1680 sh_link: 4 sh_info: 11 sh_addralign: 8 sh_entsize: 24 entry: 10 sh_name: .init sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC|SHF_EXECINSTR sh_addr: 0x401838 sh_offset: 6200 sh_size: 19 sh_link: 0 sh_info: 0 sh_addralign: 4 sh_entsize: 0 entry: 11 sh_name: .plt sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC|SHF_EXECINSTR sh_addr: 0x40184c sh_offset: 6220 sh_size: 1136 sh_link: 0 sh_info: 0 sh_addralign: 4 sh_entsize: 16 entry: 12 sh_name: .text sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC|SHF_EXECINSTR sh_addr: 0x401cc0 sh_offset: 7360 sh_size: 16008 sh_link: 0 sh_info: 0 sh_addralign: 16 sh_entsize: 0 entry: 13 sh_name: .fini sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC|SHF_EXECINSTR sh_addr: 0x405b48 sh_offset: 23368 sh_size: 14 sh_link: 0 sh_info: 0 sh_addralign: 4 sh_entsize: 0 entry: 14 sh_name: .rodata sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC sh_addr: 0x405b60 sh_offset: 23392 sh_size: 1500 sh_link: 0 sh_info: 0 sh_addralign: 16 sh_entsize: 0 entry: 15 sh_name: .eh_frame_hdr sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC sh_addr: 0x40613c sh_offset: 24892 sh_size: 8 sh_link: 0 sh_info: 0 sh_addralign: 4 sh_entsize: 0 entry: 16 sh_name: .data sh_type: SHT_PROGBITS sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x506150 sh_offset: 24912 sh_size: 76 sh_link: 0 sh_info: 0 sh_addralign: 16 sh_entsize: 0 entry: 17 sh_name: .eh_frame sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC sh_addr: 0x5061a0 sh_offset: 24992 sh_size: 1384 sh_link: 0 sh_info: 0 sh_addralign: 8 sh_entsize: 0 entry: 18 sh_name: .dynamic sh_type: SHT_DYNAMIC sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x506708 sh_offset: 26376 sh_size: 432 sh_link: 5 sh_info: 0 sh_addralign: 8 sh_entsize: 16 entry: 19 sh_name: .ctors sh_type: SHT_PROGBITS sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x5068b8 sh_offset: 26808 sh_size: 16 sh_link: 0 sh_info: 0 sh_addralign: 8 sh_entsize: 0 entry: 20 sh_name: .dtors sh_type: SHT_PROGBITS sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x5068c8 sh_offset: 26824 sh_size: 16 sh_link: 0 sh_info: 0 sh_addralign: 8 sh_entsize: 0 entry: 21 sh_name: .jcr sh_type: SHT_PROGBITS sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x5068d8 sh_offset: 26840 sh_size: 8 sh_link: 0 sh_info: 0 sh_addralign: 8 sh_entsize: 0 entry: 22 sh_name: .got sh_type: SHT_PROGBITS sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x5068e0 sh_offset: 26848 sh_size: 584 sh_link: 0 sh_info: 0 sh_addralign: 8 sh_entsize: 8 entry: 23 sh_name: .bss sh_type: SHT_NOBITS sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x506b40 sh_offset: 27456 sh_size: 536 sh_link: 0 sh_info: 0 sh_addralign: 32 sh_entsize: 0 entry: 24 sh_name: .comment sh_type: SHT_PROGBITS sh_flags: sh_addr: 0 sh_offset: 27456 sh_size: 672 sh_link: 0 sh_info: 0 sh_addralign: 1 sh_entsize: 0 entry: 25 sh_name: .shstrtab sh_type: SHT_STRTAB sh_flags: sh_addr: 0 sh_offset: 28128 sh_size: 206 sh_link: 0 sh_info: 0 sh_addralign: 1 sh_entsize: 0 note (.note.ABI-tag): FreeBSD 800074 Index: vendor/elftoolchain/dist/test/elfdump/ts/exec1/@e@p%ls.out =================================================================== --- vendor/elftoolchain/dist/test/elfdump/ts/exec1/@e@p%ls.out (revision 300227) +++ vendor/elftoolchain/dist/test/elfdump/ts/exec1/@e@p%ls.out (revision 300228) @@ -1,89 +1,89 @@ elf header: e_ident: ELFCLASS64 ELFDATA2LSB ELFOSABI_FREEBSD e_type: ET_EXEC e_machine: EM_X86_64 e_version: EV_CURRENT e_entry: 0x401cc0 e_phoff: 64 e_shoff: 28336 e_flags: 0 e_ehsize: 64 e_phentsize: 56 e_phnum: 7 e_shentsize: 64 e_shnum: 26 e_shstrndx: 25 program header: entry: 0 p_type: PT_PHDR p_offset: 64 p_vaddr: 0x400040 p_paddr: 0x400040 p_filesz: 392 p_memsz: 392 p_flags: PF_X|PF_R p_align: 8 entry: 1 p_type: PT_INTERP p_offset: 456 p_vaddr: 0x4001c8 p_paddr: 0x4001c8 p_filesz: 21 p_memsz: 21 p_flags: PF_R p_align: 1 entry: 2 p_type: PT_LOAD p_offset: 0 p_vaddr: 0x400000 p_paddr: 0x400000 p_filesz: 24900 p_memsz: 24900 p_flags: PF_X|PF_R p_align: 1048576 entry: 3 p_type: PT_LOAD p_offset: 24912 p_vaddr: 0x506150 p_paddr: 0x506150 p_filesz: 2520 p_memsz: 3080 p_flags: PF_W|PF_R p_align: 1048576 entry: 4 p_type: PT_DYNAMIC p_offset: 26376 p_vaddr: 0x506708 p_paddr: 0x506708 p_filesz: 432 p_memsz: 432 p_flags: PF_W|PF_R p_align: 8 entry: 5 p_type: PT_NOTE p_offset: 480 p_vaddr: 0x4001e0 p_paddr: 0x4001e0 p_filesz: 24 p_memsz: 24 p_flags: PF_R p_align: 4 entry: 6 - p_type: PT_NULL + p_type: PT_GNU_EH_FRAME p_offset: 24892 p_vaddr: 0x40613c p_paddr: 0x40613c p_filesz: 8 p_memsz: 8 p_flags: PF_R p_align: 4 Index: vendor/elftoolchain/dist/test/elfdump/ts/exec1/@e@p@c@d%ls.out =================================================================== --- vendor/elftoolchain/dist/test/elfdump/ts/exec1/@e@p@c@d%ls.out (revision 300227) +++ vendor/elftoolchain/dist/test/elfdump/ts/exec1/@e@p@c@d%ls.out (revision 300228) @@ -1,507 +1,507 @@ elf header: e_ident: ELFCLASS64 ELFDATA2LSB ELFOSABI_FREEBSD e_type: ET_EXEC e_machine: EM_X86_64 e_version: EV_CURRENT e_entry: 0x401cc0 e_phoff: 64 e_shoff: 28336 e_flags: 0 e_ehsize: 64 e_phentsize: 56 e_phnum: 7 e_shentsize: 64 e_shnum: 26 e_shstrndx: 25 program header: entry: 0 p_type: PT_PHDR p_offset: 64 p_vaddr: 0x400040 p_paddr: 0x400040 p_filesz: 392 p_memsz: 392 p_flags: PF_X|PF_R p_align: 8 entry: 1 p_type: PT_INTERP p_offset: 456 p_vaddr: 0x4001c8 p_paddr: 0x4001c8 p_filesz: 21 p_memsz: 21 p_flags: PF_R p_align: 1 entry: 2 p_type: PT_LOAD p_offset: 0 p_vaddr: 0x400000 p_paddr: 0x400000 p_filesz: 24900 p_memsz: 24900 p_flags: PF_X|PF_R p_align: 1048576 entry: 3 p_type: PT_LOAD p_offset: 24912 p_vaddr: 0x506150 p_paddr: 0x506150 p_filesz: 2520 p_memsz: 3080 p_flags: PF_W|PF_R p_align: 1048576 entry: 4 p_type: PT_DYNAMIC p_offset: 26376 p_vaddr: 0x506708 p_paddr: 0x506708 p_filesz: 432 p_memsz: 432 p_flags: PF_W|PF_R p_align: 8 entry: 5 p_type: PT_NOTE p_offset: 480 p_vaddr: 0x4001e0 p_paddr: 0x4001e0 p_filesz: 24 p_memsz: 24 p_flags: PF_R p_align: 4 entry: 6 - p_type: PT_NULL + p_type: PT_GNU_EH_FRAME p_offset: 24892 p_vaddr: 0x40613c p_paddr: 0x40613c p_filesz: 8 p_memsz: 8 p_flags: PF_R p_align: 4 section header: entry: 0 sh_name: sh_type: SHT_NULL sh_flags: sh_addr: 0 sh_offset: 0 sh_size: 0 sh_link: 0 sh_info: 0 sh_addralign: 0 sh_entsize: 0 entry: 1 sh_name: .interp sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC sh_addr: 0x4001c8 sh_offset: 456 sh_size: 21 sh_link: 0 sh_info: 0 sh_addralign: 1 sh_entsize: 0 entry: 2 sh_name: .note.ABI-tag sh_type: SHT_NOTE sh_flags: SHF_ALLOC sh_addr: 0x4001e0 sh_offset: 480 sh_size: 24 sh_link: 0 sh_info: 0 sh_addralign: 4 sh_entsize: 0 entry: 3 sh_name: .hash sh_type: SHT_HASH sh_flags: SHF_ALLOC sh_addr: 0x4001f8 sh_offset: 504 sh_size: 632 sh_link: 4 sh_info: 0 sh_addralign: 8 sh_entsize: 4 entry: 4 sh_name: .dynsym sh_type: SHT_DYNSYM sh_flags: SHF_ALLOC sh_addr: 0x400470 sh_offset: 1136 sh_size: 2136 sh_link: 5 sh_info: 1 sh_addralign: 8 sh_entsize: 24 entry: 5 sh_name: .dynstr sh_type: SHT_STRTAB sh_flags: SHF_ALLOC sh_addr: 0x400cc8 sh_offset: 3272 sh_size: 828 sh_link: 0 sh_info: 0 sh_addralign: 1 sh_entsize: 0 entry: 6 sh_name: .gnu.version sh_type: SHT_SUNW(GNU)_versym sh_flags: SHF_ALLOC sh_addr: 0x401004 sh_offset: 4100 sh_size: 178 sh_link: 4 sh_info: 0 sh_addralign: 2 sh_entsize: 2 entry: 7 sh_name: .gnu.version_r sh_type: SHT_SUNW(GNU)_verneed sh_flags: SHF_ALLOC sh_addr: 0x4010b8 sh_offset: 4280 sh_size: 48 sh_link: 5 sh_info: 1 sh_addralign: 8 sh_entsize: 0 entry: 8 sh_name: .rela.dyn sh_type: SHT_RELA sh_flags: SHF_ALLOC sh_addr: 0x4010e8 sh_offset: 4328 sh_size: 192 sh_link: 4 sh_info: 0 sh_addralign: 8 sh_entsize: 24 entry: 9 sh_name: .rela.plt sh_type: SHT_RELA sh_flags: SHF_ALLOC sh_addr: 0x4011a8 sh_offset: 4520 sh_size: 1680 sh_link: 4 sh_info: 11 sh_addralign: 8 sh_entsize: 24 entry: 10 sh_name: .init sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC|SHF_EXECINSTR sh_addr: 0x401838 sh_offset: 6200 sh_size: 19 sh_link: 0 sh_info: 0 sh_addralign: 4 sh_entsize: 0 entry: 11 sh_name: .plt sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC|SHF_EXECINSTR sh_addr: 0x40184c sh_offset: 6220 sh_size: 1136 sh_link: 0 sh_info: 0 sh_addralign: 4 sh_entsize: 16 entry: 12 sh_name: .text sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC|SHF_EXECINSTR sh_addr: 0x401cc0 sh_offset: 7360 sh_size: 16008 sh_link: 0 sh_info: 0 sh_addralign: 16 sh_entsize: 0 entry: 13 sh_name: .fini sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC|SHF_EXECINSTR sh_addr: 0x405b48 sh_offset: 23368 sh_size: 14 sh_link: 0 sh_info: 0 sh_addralign: 4 sh_entsize: 0 entry: 14 sh_name: .rodata sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC sh_addr: 0x405b60 sh_offset: 23392 sh_size: 1500 sh_link: 0 sh_info: 0 sh_addralign: 16 sh_entsize: 0 entry: 15 sh_name: .eh_frame_hdr sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC sh_addr: 0x40613c sh_offset: 24892 sh_size: 8 sh_link: 0 sh_info: 0 sh_addralign: 4 sh_entsize: 0 entry: 16 sh_name: .data sh_type: SHT_PROGBITS sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x506150 sh_offset: 24912 sh_size: 76 sh_link: 0 sh_info: 0 sh_addralign: 16 sh_entsize: 0 entry: 17 sh_name: .eh_frame sh_type: SHT_PROGBITS sh_flags: SHF_ALLOC sh_addr: 0x5061a0 sh_offset: 24992 sh_size: 1384 sh_link: 0 sh_info: 0 sh_addralign: 8 sh_entsize: 0 entry: 18 sh_name: .dynamic sh_type: SHT_DYNAMIC sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x506708 sh_offset: 26376 sh_size: 432 sh_link: 5 sh_info: 0 sh_addralign: 8 sh_entsize: 16 entry: 19 sh_name: .ctors sh_type: SHT_PROGBITS sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x5068b8 sh_offset: 26808 sh_size: 16 sh_link: 0 sh_info: 0 sh_addralign: 8 sh_entsize: 0 entry: 20 sh_name: .dtors sh_type: SHT_PROGBITS sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x5068c8 sh_offset: 26824 sh_size: 16 sh_link: 0 sh_info: 0 sh_addralign: 8 sh_entsize: 0 entry: 21 sh_name: .jcr sh_type: SHT_PROGBITS sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x5068d8 sh_offset: 26840 sh_size: 8 sh_link: 0 sh_info: 0 sh_addralign: 8 sh_entsize: 0 entry: 22 sh_name: .got sh_type: SHT_PROGBITS sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x5068e0 sh_offset: 26848 sh_size: 584 sh_link: 0 sh_info: 0 sh_addralign: 8 sh_entsize: 8 entry: 23 sh_name: .bss sh_type: SHT_NOBITS sh_flags: SHF_WRITE|SHF_ALLOC sh_addr: 0x506b40 sh_offset: 27456 sh_size: 536 sh_link: 0 sh_info: 0 sh_addralign: 32 sh_entsize: 0 entry: 24 sh_name: .comment sh_type: SHT_PROGBITS sh_flags: sh_addr: 0 sh_offset: 27456 sh_size: 672 sh_link: 0 sh_info: 0 sh_addralign: 1 sh_entsize: 0 entry: 25 sh_name: .shstrtab sh_type: SHT_STRTAB sh_flags: sh_addr: 0 sh_offset: 28128 sh_size: 206 sh_link: 0 sh_info: 0 sh_addralign: 1 sh_entsize: 0 dynamic: entry: 0 d_tag: DT_NEEDED d_val: libutil.so.7 entry: 1 d_tag: DT_NEEDED d_val: libncurses.so.7 entry: 2 d_tag: DT_NEEDED d_val: libc.so.7 entry: 3 d_tag: DT_INIT d_ptr: 0x401838 entry: 4 d_tag: DT_FINI d_ptr: 0x405b48 entry: 5 d_tag: DT_HASH d_ptr: 0x4001f8 entry: 6 d_tag: DT_STRTAB d_ptr: 0x400cc8 entry: 7 d_tag: DT_SYMTAB d_ptr: 0x400470 entry: 8 d_tag: DT_STRSZ d_val: 828 entry: 9 d_tag: DT_SYMENT d_val: 24 entry: 10 d_tag: DT_DEBUG d_ptr: 0 entry: 11 d_tag: DT_PLTGOT d_ptr: 0x5068e0 entry: 12 d_tag: DT_PLTRELSZ d_val: 1680 entry: 13 d_tag: DT_PLTREL d_val: 7 entry: 14 d_tag: DT_JMPREL d_ptr: 0x4011a8 entry: 15 d_tag: DT_RELA d_val: 4198632 entry: 16 d_tag: DT_RELASZ d_val: 192 entry: 17 d_tag: DT_RELAENT d_val: 24 entry: 18 d_tag: DT_VERNEED d_val: 4198584 entry: 19 d_tag: DT_VERNEEDNUM d_val: 1 entry: 20 d_tag: DT_GNU_VERSYM d_val: 4198404 entry: 21 d_tag: DT_NULL entry: 22 d_tag: DT_NULL entry: 23 d_tag: DT_NULL entry: 24 d_tag: DT_NULL entry: 25 d_tag: DT_NULL entry: 26 d_tag: DT_NULL Index: vendor/elftoolchain/dist/test/elfdump/ts/exec1/@p@e%ls.out =================================================================== --- vendor/elftoolchain/dist/test/elfdump/ts/exec1/@p@e%ls.out (revision 300227) +++ vendor/elftoolchain/dist/test/elfdump/ts/exec1/@p@e%ls.out (revision 300228) @@ -1,89 +1,89 @@ elf header: e_ident: ELFCLASS64 ELFDATA2LSB ELFOSABI_FREEBSD e_type: ET_EXEC e_machine: EM_X86_64 e_version: EV_CURRENT e_entry: 0x401cc0 e_phoff: 64 e_shoff: 28336 e_flags: 0 e_ehsize: 64 e_phentsize: 56 e_phnum: 7 e_shentsize: 64 e_shnum: 26 e_shstrndx: 25 program header: entry: 0 p_type: PT_PHDR p_offset: 64 p_vaddr: 0x400040 p_paddr: 0x400040 p_filesz: 392 p_memsz: 392 p_flags: PF_X|PF_R p_align: 8 entry: 1 p_type: PT_INTERP p_offset: 456 p_vaddr: 0x4001c8 p_paddr: 0x4001c8 p_filesz: 21 p_memsz: 21 p_flags: PF_R p_align: 1 entry: 2 p_type: PT_LOAD p_offset: 0 p_vaddr: 0x400000 p_paddr: 0x400000 p_filesz: 24900 p_memsz: 24900 p_flags: PF_X|PF_R p_align: 1048576 entry: 3 p_type: PT_LOAD p_offset: 24912 p_vaddr: 0x506150 p_paddr: 0x506150 p_filesz: 2520 p_memsz: 3080 p_flags: PF_W|PF_R p_align: 1048576 entry: 4 p_type: PT_DYNAMIC p_offset: 26376 p_vaddr: 0x506708 p_paddr: 0x506708 p_filesz: 432 p_memsz: 432 p_flags: PF_W|PF_R p_align: 8 entry: 5 p_type: PT_NOTE p_offset: 480 p_vaddr: 0x4001e0 p_paddr: 0x4001e0 p_filesz: 24 p_memsz: 24 p_flags: PF_R p_align: 4 entry: 6 - p_type: PT_NULL + p_type: PT_GNU_EH_FRAME p_offset: 24892 p_vaddr: 0x40613c p_paddr: 0x40613c p_filesz: 8 p_memsz: 8 p_flags: PF_R p_align: 4 Index: vendor/elftoolchain/dist/test/elfdump/ts/exec1/@p@n%ls.out =================================================================== --- vendor/elftoolchain/dist/test/elfdump/ts/exec1/@p@n%ls.out (revision 300227) +++ vendor/elftoolchain/dist/test/elfdump/ts/exec1/@p@n%ls.out (revision 300228) @@ -1,75 +1,75 @@ program header: entry: 0 p_type: PT_PHDR p_offset: 64 p_vaddr: 0x400040 p_paddr: 0x400040 p_filesz: 392 p_memsz: 392 p_flags: PF_X|PF_R p_align: 8 entry: 1 p_type: PT_INTERP p_offset: 456 p_vaddr: 0x4001c8 p_paddr: 0x4001c8 p_filesz: 21 p_memsz: 21 p_flags: PF_R p_align: 1 entry: 2 p_type: PT_LOAD p_offset: 0 p_vaddr: 0x400000 p_paddr: 0x400000 p_filesz: 24900 p_memsz: 24900 p_flags: PF_X|PF_R p_align: 1048576 entry: 3 p_type: PT_LOAD p_offset: 24912 p_vaddr: 0x506150 p_paddr: 0x506150 p_filesz: 2520 p_memsz: 3080 p_flags: PF_W|PF_R p_align: 1048576 entry: 4 p_type: PT_DYNAMIC p_offset: 26376 p_vaddr: 0x506708 p_paddr: 0x506708 p_filesz: 432 p_memsz: 432 p_flags: PF_W|PF_R p_align: 8 entry: 5 p_type: PT_NOTE p_offset: 480 p_vaddr: 0x4001e0 p_paddr: 0x4001e0 p_filesz: 24 p_memsz: 24 p_flags: PF_R p_align: 4 entry: 6 - p_type: PT_NULL + p_type: PT_GNU_EH_FRAME p_offset: 24892 p_vaddr: 0x40613c p_paddr: 0x40613c p_filesz: 8 p_memsz: 8 p_flags: PF_R p_align: 4 note (.note.ABI-tag): FreeBSD 800074 Index: vendor/elftoolchain/dist/test/elfdump/ts/exec1/@p@s%ls.out =================================================================== --- vendor/elftoolchain/dist/test/elfdump/ts/exec1/@p@s%ls.out (revision 300227) +++ vendor/elftoolchain/dist/test/elfdump/ts/exec1/@p@s%ls.out (revision 300228) @@ -1,697 +1,697 @@ program header: entry: 0 p_type: PT_PHDR p_offset: 64 p_vaddr: 0x400040 p_paddr: 0x400040 p_filesz: 392 p_memsz: 392 p_flags: PF_X|PF_R p_align: 8 entry: 1 p_type: PT_INTERP p_offset: 456 p_vaddr: 0x4001c8 p_paddr: 0x4001c8 p_filesz: 21 p_memsz: 21 p_flags: PF_R p_align: 1 entry: 2 p_type: PT_LOAD p_offset: 0 p_vaddr: 0x400000 p_paddr: 0x400000 p_filesz: 24900 p_memsz: 24900 p_flags: PF_X|PF_R p_align: 1048576 entry: 3 p_type: PT_LOAD p_offset: 24912 p_vaddr: 0x506150 p_paddr: 0x506150 p_filesz: 2520 p_memsz: 3080 p_flags: PF_W|PF_R p_align: 1048576 entry: 4 p_type: PT_DYNAMIC p_offset: 26376 p_vaddr: 0x506708 p_paddr: 0x506708 p_filesz: 432 p_memsz: 432 p_flags: PF_W|PF_R p_align: 8 entry: 5 p_type: PT_NOTE p_offset: 480 p_vaddr: 0x4001e0 p_paddr: 0x4001e0 p_filesz: 24 p_memsz: 24 p_flags: PF_R p_align: 4 entry: 6 - p_type: PT_NULL + p_type: PT_GNU_EH_FRAME p_offset: 24892 p_vaddr: 0x40613c p_paddr: 0x40613c p_filesz: 8 p_memsz: 8 p_flags: PF_R p_align: 4 symbol table (.dynsym): entry: 0 st_name: st_value: 0 st_size: 0 st_info: STT_NOTYPE STB_LOCAL st_shndx: 0 entry: 1 st_name: fflagstostr st_value: 0x40185c st_size: 138 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 2 st_name: puts st_value: 0x40186c st_size: 210 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 3 st_name: fprintf st_value: 0x40187c st_size: 144 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 4 st_name: atoi st_value: 0x40188c st_size: 21 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 5 st_name: time st_value: 0x40189c st_size: 50 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 6 st_name: mbrtowc st_value: 0x4018ac st_size: 27 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 7 st_name: write st_value: 0x4018bc st_size: 0 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 8 st_name: fputc st_value: 0x4018cc st_size: 158 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 9 st_name: getenv st_value: 0x4018dc st_size: 389 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 10 st_name: _DYNAMIC st_value: 0x506708 st_size: 0 st_info: STT_OBJECT STB_GLOBAL st_shndx: 65521 entry: 11 st_name: kill st_value: 0x4018ec st_size: 0 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 12 st_name: humanize_number st_value: 0x4018fc st_size: 959 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 13 st_name: tgoto st_value: 0x40190c st_size: 993 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 14 st_name: putc st_value: 0x40191c st_size: 158 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 15 st_name: strdup st_value: 0x40192c st_size: 85 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 16 st_name: mac_get_link st_value: 0x40193c st_size: 5 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 17 st_name: fputs st_value: 0x40194c st_size: 154 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 18 st_name: ___runetype st_value: 0x40195c st_size: 117 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 19 st_name: mac_prepare_file_label st_value: 0x40196c st_size: 12 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 20 st_name: mac_to_text st_value: 0x40197c st_size: 27 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 21 st_name: __stack_chk_guard st_value: 0x506b40 st_size: 64 st_info: STT_OBJECT STB_GLOBAL st_shndx: 23 entry: 22 st_name: ioctl st_value: 0x40198c st_size: 0 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 23 st_name: group_from_gid st_value: 0x40199c st_size: 271 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 24 st_name: strftime st_value: 0x4019ac st_size: 391 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 25 st_name: strerror st_value: 0x4019bc st_size: 48 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 26 st_name: _init_tls st_value: 0x4019cc st_size: 2 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 27 st_name: realloc st_value: 0x4019dc st_size: 1276 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 28 st_name: _init st_value: 0x401838 st_size: 0 st_info: STT_FUNC STB_GLOBAL st_shndx: 10 entry: 29 st_name: localtime st_value: 0x4019ec st_size: 321 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 30 st_name: environ st_value: 0x506cc8 st_size: 8 st_info: STT_OBJECT STB_GLOBAL st_shndx: 23 entry: 31 st_name: mac_free st_value: 0x4019fc st_size: 30 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 32 st_name: acl_get_entry st_value: 0x401a0c st_size: 95 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 33 st_name: fts_set st_value: 0x401a1c st_size: 40 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 34 st_name: strchr st_value: 0x401a2c st_size: 41 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 35 st_name: strcoll st_value: 0x401a3c st_size: 488 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 36 st_name: __isthreaded st_value: 0x506b80 st_size: 4 st_info: STT_OBJECT STB_GLOBAL st_shndx: 23 entry: 37 st_name: getopt st_value: 0x401a4c st_size: 685 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 38 st_name: __progname st_value: 0x506150 st_size: 8 st_info: STT_OBJECT STB_GLOBAL st_shndx: 16 entry: 39 st_name: strmode st_value: 0x401a5c st_size: 760 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 40 st_name: warnx st_value: 0x401a6c st_size: 149 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 41 st_name: tputs st_value: 0x401a7c st_size: 982 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 42 st_name: optarg st_value: 0x506b88 st_size: 8 st_info: STT_OBJECT STB_GLOBAL st_shndx: 23 entry: 43 st_name: sscanf st_value: 0x401a8c st_size: 323 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 44 st_name: memset st_value: 0x401a9c st_size: 84 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 45 st_name: __error st_value: 0x401aac st_size: 8 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 46 st_name: pathconf st_value: 0x401abc st_size: 0 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 47 st_name: fts_children st_value: 0x401acc st_size: 299 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 48 st_name: printf st_value: 0x401adc st_size: 162 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 49 st_name: user_from_uid st_value: 0x401aec st_size: 271 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 50 st_name: __bss_start st_value: 0x506b28 st_size: 0 st_info: STT_NOTYPE STB_GLOBAL st_shndx: 65521 entry: 51 st_name: snprintf st_value: 0x401afc st_size: 501 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 52 st_name: warn st_value: 0x401b0c st_size: 168 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 53 st_name: __mb_sb_limit st_value: 0x506b90 st_size: 4 st_info: STT_OBJECT STB_GLOBAL st_shndx: 23 entry: 54 st_name: tgetent st_value: 0x401b1c st_size: 1598 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 55 st_name: signal st_value: 0x401b2c st_size: 95 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 56 st_name: fts_read st_value: 0x401b3c st_size: 1240 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 57 st_name: _fini st_value: 0x405b48 st_size: 0 st_info: STT_FUNC STB_GLOBAL st_shndx: 13 entry: 58 st_name: nl_langinfo st_value: 0x401b4c st_size: 677 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 59 st_name: setenv st_value: 0x401b5c st_size: 147 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 60 st_name: __stdoutp st_value: 0x506b98 st_size: 8 st_info: STT_OBJECT STB_GLOBAL st_shndx: 23 entry: 61 st_name: fwrite st_value: 0x401b6c st_size: 202 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 62 st_name: _CurrentRuneLocale st_value: 0x506ba0 st_size: 8 st_info: STT_OBJECT STB_GLOBAL st_shndx: 23 entry: 63 st_name: fts_open st_value: 0x401b7c st_size: 645 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 64 st_name: getbsize st_value: 0x401b8c st_size: 545 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 65 st_name: __swbuf st_value: 0x401b9c st_size: 230 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 66 st_name: exit st_value: 0x401bac st_size: 47 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 67 st_name: malloc st_value: 0x401bbc st_size: 175 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 68 st_name: mac_get_file st_value: 0x401bcc st_size: 5 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 69 st_name: err st_value: 0x401bdc st_size: 170 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 70 st_name: _edata st_value: 0x506b28 st_size: 0 st_info: STT_NOTYPE STB_GLOBAL st_shndx: 65521 entry: 71 st_name: isatty st_value: 0x401bec st_size: 60 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 72 st_name: _GLOBAL_OFFSET_TABLE_ st_value: 0x5068e0 st_size: 0 st_info: STT_OBJECT STB_GLOBAL st_shndx: 65521 entry: 73 st_name: _end st_value: 0x506d58 st_size: 0 st_info: STT_NOTYPE STB_GLOBAL st_shndx: 65521 entry: 74 st_name: setlocale st_value: 0x401bfc st_size: 904 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 75 st_name: __stderrp st_value: 0x506ba8 st_size: 8 st_info: STT_OBJECT STB_GLOBAL st_shndx: 23 entry: 76 st_name: free st_value: 0x401c0c st_size: 118 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 77 st_name: optind st_value: 0x506bb0 st_size: 4 st_info: STT_OBJECT STB_GLOBAL st_shndx: 23 entry: 78 st_name: getuid st_value: 0x401c1c st_size: 0 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 79 st_name: __stack_chk_fail st_value: 0x401c2c st_size: 12 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 80 st_name: atexit st_value: 0x401c3c st_size: 47 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 81 st_name: acl_free st_value: 0x401c4c st_size: 21 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 82 st_name: getpid st_value: 0x401c5c st_size: 0 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 83 st_name: strlen st_value: 0x401c6c st_size: 199 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 84 st_name: strcpy st_value: 0x401c7c st_size: 174 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 85 st_name: _Jv_RegisterClasses st_value: 0 st_size: 0 st_info: STT_NOTYPE STB_WEAK st_shndx: 0 entry: 86 st_name: readlink st_value: 0x401c8c st_size: 0 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 87 st_name: tgetstr st_value: 0x401c9c st_size: 355 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 entry: 88 st_name: acl_get_file st_value: 0x401cac st_size: 93 st_info: STT_FUNC STB_GLOBAL st_shndx: 0 Index: vendor/elftoolchain/dist/test/elfdump/ts/exec2/@S@n%cp.out =================================================================== --- vendor/elftoolchain/dist/test/elfdump/ts/exec2/@S@n%cp.out (revision 300227) +++ vendor/elftoolchain/dist/test/elfdump/ts/exec2/@S@n%cp.out (revision 300228) @@ -1,8 +1,8 @@ Note Section: .note.ABI-tag type 0x1 namesz 0x8: FreeBSD descsz 0x4: - desc[0] ffffffac ffffffb2 0a 00 + desc[0] ac b2 0a 00