stand/common/load_elf_obj.c

   1 /*-
   2  * Copyright (c) 2004 Ian Dowse <iedowse@freebsd.org>
   3  * Copyright (c) 1998 Michael Smith <msmith@freebsd.org>
   4  * Copyright (c) 1998 Peter Wemm <peter@freebsd.org>
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32 #include <sys/param.h>
  33 #include <sys/exec.h>
  34 #include <sys/linker.h>
  35 #include <sys/module.h>
  36 #include <stdint.h>
  37 #include <string.h>
  38 #include <machine/elf.h>
  39 #include <stand.h>
  40 #define FREEBSD_ELF
  41 #include <sys/link_elf.h>
  42
  43 #include "bootstrap.h"
  44
  45 #define COPYOUT(s,d,l)  archsw.arch_copyout((vm_offset_t)(s), d, l)
  46
  47 #if defined(__i386__) && __ELF_WORD_SIZE == 64
  48 #undef ELF_TARG_CLASS
  49 #undef ELF_TARG_MACH
  50 #define ELF_TARG_CLASS  ELFCLASS64
  51 #define ELF_TARG_MACH   EM_X86_64
  52 #endif
  53
  54 typedef struct elf_file {
  55         Elf_Ehdr        hdr;
  56         Elf_Shdr        *e_shdr;
  57
  58         int             symtabindex;    /* Index of symbol table */
  59         int             shstrindex;     /* Index of section name string table */
  60
  61         int             fd;
  62         vm_offset_t     off;
  63 #ifdef LOADER_VERIEXEC_VECTX
  64         struct vectx    *vctx;
  65 #endif
  66 } *elf_file_t;
  67
  68 #ifdef LOADER_VERIEXEC_VECTX
  69 #define VECTX_HANDLE(ef) (ef)->vctx
  70 #else
  71 #define VECTX_HANDLE(ef) (ef)->fd
  72 #endif
  73
  74 static int __elfN(obj_loadimage)(struct preloaded_file *mp, elf_file_t ef,
  75     uint64_t loadaddr);
  76 static int __elfN(obj_lookup_set)(struct preloaded_file *mp, elf_file_t ef,
  77     const char *name, Elf_Addr *startp, Elf_Addr *stopp, int *countp);
  78 static int __elfN(obj_reloc_ptr)(struct preloaded_file *mp, elf_file_t ef,
  79     Elf_Addr p, void *val, size_t len);
  80 static int __elfN(obj_parse_modmetadata)(struct preloaded_file *mp,
  81     elf_file_t ef);
  82 static Elf_Addr __elfN(obj_symaddr)(struct elf_file *ef, Elf_Size symidx);
  83
  84 const char      *__elfN(obj_kerneltype) = "elf kernel";
  85 const char      *__elfN(obj_moduletype) = "elf obj module";
  86
  87 /*
  88  * Attempt to load the file (file) as an ELF module.  It will be stored at
  89  * (dest), and a pointer to a module structure describing the loaded object
  90  * will be saved in (result).
  91  */
  92 int
  93 __elfN(obj_loadfile)(char *filename, uint64_t dest,
  94     struct preloaded_file **result)
  95 {
  96         struct preloaded_file *fp, *kfp;
  97         struct elf_file ef;
  98         Elf_Ehdr *hdr;
  99         int err;
 100         ssize_t bytes_read;
 101
 102         fp = NULL;
 103         bzero(&ef, sizeof(struct elf_file));
 104
 105         /*
 106          * Open the image, read and validate the ELF header
 107          */
 108         if (filename == NULL)   /* can't handle nameless */
 109                 return(EFTYPE);
 110         if ((ef.fd = open(filename, O_RDONLY)) == -1)
 111                 return(errno);
 112 #ifdef LOADER_VERIEXEC_VECTX
 113         {
 114                 int verror;
 115
 116                 ef.vctx = vectx_open(ef.fd, filename, 0L, NULL, &verror, __func__);
 117                 if (verror) {
 118                         printf("Unverified %s: %s\n", filename, ve_error_get());
 119                         close(ef.fd);
 120                         free(ef.vctx);
 121                         return (EAUTH);
 122                 }
 123         }
 124 #endif
 125
 126         hdr = &ef.hdr;
 127         bytes_read = VECTX_READ(VECTX_HANDLE(&ef), hdr, sizeof(*hdr));
 128         if (bytes_read != sizeof(*hdr)) {
 129                 err = EFTYPE;   /* could be EIO, but may be small file */
 130                 goto oerr;
 131         }
 132
 133         /* Is it ELF? */
 134         if (!IS_ELF(*hdr)) {
 135                 err = EFTYPE;
 136                 goto oerr;
 137         }
 138         if (hdr->e_ident[EI_CLASS] != ELF_TARG_CLASS || /* Layout ? */
 139             hdr->e_ident[EI_DATA] != ELF_TARG_DATA ||
 140             hdr->e_ident[EI_VERSION] != EV_CURRENT ||   /* Version ? */
 141             hdr->e_version != EV_CURRENT ||
 142             hdr->e_machine != ELF_TARG_MACH ||          /* Machine ? */
 143             hdr->e_type != ET_REL) {
 144                 err = EFTYPE;
 145                 goto oerr;
 146         }
 147
 148         if (hdr->e_shnum * hdr->e_shentsize == 0 || hdr->e_shoff == 0 ||
 149             hdr->e_shentsize != sizeof(Elf_Shdr)) {
 150                 err = EFTYPE;
 151                 goto oerr;
 152         }
 153
 154 #if defined(LOADER_VERIEXEC) && !defined(LOADER_VERIEXEC_VECTX)
 155         if (verify_file(ef.fd, filename, bytes_read, VE_MUST, __func__) < 0) {
 156                 err = EAUTH;
 157                 goto oerr;
 158         }
 159 #endif
 160
 161         kfp = file_findfile(NULL, __elfN(obj_kerneltype));
 162         if (kfp == NULL) {
 163                 printf("elf" __XSTRING(__ELF_WORD_SIZE)
 164                     "_obj_loadfile: can't load module before kernel\n");
 165                 err = EPERM;
 166                 goto oerr;
 167         }
 168
 169         if (archsw.arch_loadaddr != NULL)
 170                 dest = archsw.arch_loadaddr(LOAD_ELF, hdr, dest);
 171         else
 172                 dest = roundup(dest, PAGE_SIZE);
 173
 174         /*
 175          * Ok, we think we should handle this.
 176          */
 177         fp = file_alloc();
 178         if (fp == NULL) {
 179                 printf("elf" __XSTRING(__ELF_WORD_SIZE)
 180                     "_obj_loadfile: cannot allocate module info\n");
 181                 err = EPERM;
 182                 goto out;
 183         }
 184         fp->f_name = strdup(filename);
 185         fp->f_type = strdup(__elfN(obj_moduletype));
 186
 187         printf("%s ", filename);
 188
 189         fp->f_size = __elfN(obj_loadimage)(fp, &ef, dest);
 190         if (fp->f_size == 0 || fp->f_addr == 0)
 191                 goto ioerr;
 192
 193         /* save exec header as metadata */
 194         file_addmetadata(fp, MODINFOMD_ELFHDR, sizeof(*hdr), hdr);
 195
 196         /* Load OK, return module pointer */
 197         *result = (struct preloaded_file *)fp;
 198         err = 0;
 199         goto out;
 200
 201 ioerr:
 202         err = EIO;
 203 oerr:
 204         file_discard(fp);
 205 out:
 206 #ifdef LOADER_VERIEXEC_VECTX
 207         if (!err && ef.vctx) {
 208                 int verror;
 209
 210                 verror = vectx_close(ef.vctx, VE_MUST, __func__);
 211                 if (verror) {
 212                         err = EAUTH;
 213                         file_discard(fp);
 214                 }
 215         }
 216 #endif
 217         close(ef.fd);
 218         if (ef.e_shdr != NULL)
 219                 free(ef.e_shdr);
 220
 221         return(err);
 222 }
 223
 224 /*
 225  * With the file (fd) open on the image, and (ehdr) containing
 226  * the Elf header, load the image at (off)
 227  */
 228 static int
 229 __elfN(obj_loadimage)(struct preloaded_file *fp, elf_file_t ef, uint64_t off)
 230 {
 231         Elf_Ehdr *hdr;
 232         Elf_Shdr *shdr, *cshdr, *lshdr;
 233         vm_offset_t firstaddr, lastaddr;
 234         int i, nsym, res, ret, shdrbytes, symstrindex;
 235
 236         ret = 0;
 237         firstaddr = lastaddr = (vm_offset_t)off;
 238         hdr = &ef->hdr;
 239         ef->off = (vm_offset_t)off;
 240
 241         /* Read in the section headers. */
 242         shdrbytes = hdr->e_shnum * hdr->e_shentsize;
 243         shdr = alloc_pread(VECTX_HANDLE(ef), (off_t)hdr->e_shoff, shdrbytes);
 244         if (shdr == NULL) {
 245                 printf("\nelf" __XSTRING(__ELF_WORD_SIZE)
 246                     "_obj_loadimage: read section headers failed\n");
 247                 goto out;
 248         }
 249         ef->e_shdr = shdr;
 250
 251         /*
 252          * Decide where to load everything, but don't read it yet.
 253          * We store the load address as a non-zero sh_addr value.
 254          * Start with the code/data and bss.
 255          */
 256         for (i = 0; i < hdr->e_shnum; i++)
 257                 shdr[i].sh_addr = 0;
 258         for (i = 0; i < hdr->e_shnum; i++) {
 259                 if (shdr[i].sh_size == 0)
 260                         continue;
 261                 switch (shdr[i].sh_type) {
 262                 case SHT_PROGBITS:
 263                 case SHT_NOBITS:
 264 #if defined(__i386__) || defined(__amd64__)
 265                 case SHT_X86_64_UNWIND:
 266 #endif
 267                         if ((shdr[i].sh_flags & SHF_ALLOC) == 0)
 268                                 break;
 269                         lastaddr = roundup(lastaddr, shdr[i].sh_addralign);
 270                         shdr[i].sh_addr = (Elf_Addr)lastaddr;
 271                         lastaddr += shdr[i].sh_size;
 272                         break;
 273                 }
 274         }
 275
 276         /* Symbols. */
 277         nsym = 0;
 278         for (i = 0; i < hdr->e_shnum; i++) {
 279                 switch (shdr[i].sh_type) {
 280                 case SHT_SYMTAB:
 281                         nsym++;
 282                         ef->symtabindex = i;
 283                         shdr[i].sh_addr = (Elf_Addr)lastaddr;
 284                         lastaddr += shdr[i].sh_size;
 285                         break;
 286                 }
 287         }
 288         if (nsym != 1) {
 289                 printf("\nelf" __XSTRING(__ELF_WORD_SIZE)
 290                     "_obj_loadimage: file has no valid symbol table\n");
 291                 goto out;
 292         }
 293         lastaddr = roundup(lastaddr, shdr[ef->symtabindex].sh_addralign);
 294         shdr[ef->symtabindex].sh_addr = (Elf_Addr)lastaddr;
 295         lastaddr += shdr[ef->symtabindex].sh_size;
 296
 297         symstrindex = shdr[ef->symtabindex].sh_link;
 298         if (symstrindex < 0 || symstrindex >= hdr->e_shnum ||
 299             shdr[symstrindex].sh_type != SHT_STRTAB) {
 300                 printf("\nelf" __XSTRING(__ELF_WORD_SIZE)
 301                     "_obj_loadimage: file has invalid symbol strings\n");
 302                 goto out;
 303         }
 304         lastaddr = roundup(lastaddr, shdr[symstrindex].sh_addralign);
 305         shdr[symstrindex].sh_addr = (Elf_Addr)lastaddr;
 306         lastaddr += shdr[symstrindex].sh_size;
 307
 308         /* Section names. */
 309         if (hdr->e_shstrndx == 0 || hdr->e_shstrndx >= hdr->e_shnum ||
 310             shdr[hdr->e_shstrndx].sh_type != SHT_STRTAB) {
 311                 printf("\nelf" __XSTRING(__ELF_WORD_SIZE)
 312                     "_obj_loadimage: file has no section names\n");
 313                 goto out;
 314         }
 315         ef->shstrindex = hdr->e_shstrndx;
 316         lastaddr = roundup(lastaddr, shdr[ef->shstrindex].sh_addralign);
 317         shdr[ef->shstrindex].sh_addr = (Elf_Addr)lastaddr;
 318         lastaddr += shdr[ef->shstrindex].sh_size;
 319
 320         /* Relocation tables. */
 321         for (i = 0; i < hdr->e_shnum; i++) {
 322                 switch (shdr[i].sh_type) {
 323                 case SHT_REL:
 324                 case SHT_RELA:
 325                         if ((shdr[shdr[i].sh_info].sh_flags & SHF_ALLOC) == 0)
 326                                 break;
 327                         lastaddr = roundup(lastaddr, shdr[i].sh_addralign);
 328                         shdr[i].sh_addr = (Elf_Addr)lastaddr;
 329                         lastaddr += shdr[i].sh_size;
 330                         break;
 331                 }
 332         }
 333
 334         /* Clear the whole area, including bss regions. */
 335         kern_bzero(firstaddr, lastaddr - firstaddr);
 336
 337         /* Figure section with the lowest file offset we haven't loaded yet. */
 338         for (cshdr = NULL; /* none */; /* none */)
 339         {
 340                 /*
 341                  * Find next section to load. The complexity of this loop is
 342                  * O(n^2), but with  the number of sections being typically
 343                  * small, we do not care.
 344                  */
 345                 lshdr = cshdr;
 346
 347                 for (i = 0; i < hdr->e_shnum; i++) {
 348                         if (shdr[i].sh_addr == 0 ||
 349                             shdr[i].sh_type == SHT_NOBITS)
 350                                 continue;
 351                         /* Skip sections that were loaded already. */
 352                         if (lshdr != NULL &&
 353                             lshdr->sh_offset >= shdr[i].sh_offset)
 354                                 continue;
 355                         /* Find section with smallest offset. */
 356                         if (cshdr == lshdr ||
 357                             cshdr->sh_offset > shdr[i].sh_offset)
 358                                 cshdr = &shdr[i];
 359                 }
 360
 361                 if (cshdr == lshdr)
 362                         break;
 363
 364                 if (kern_pread(VECTX_HANDLE(ef), (vm_offset_t)cshdr->sh_addr,
 365                     cshdr->sh_size, (off_t)cshdr->sh_offset) != 0) {
 366                         printf("\nelf" __XSTRING(__ELF_WORD_SIZE)
 367                             "_obj_loadimage: read failed\n");
 368                         goto out;
 369                 }
 370         }
 371
 372         file_addmetadata(fp, MODINFOMD_SHDR, shdrbytes, shdr);
 373
 374         res = __elfN(obj_parse_modmetadata)(fp, ef);
 375         if (res != 0)
 376                 goto out;
 377
 378         ret = lastaddr - firstaddr;
 379         fp->f_addr = firstaddr;
 380
 381         printf("size 0x%lx at 0x%lx", (u_long)ret, (u_long)firstaddr);
 382
 383 out:
 384         printf("\n");
 385         return ret;
 386 }
 387
 388 #if defined(__i386__) && __ELF_WORD_SIZE == 64
 389 struct mod_metadata64 {
 390         int             md_version;     /* structure version MDTV_* */
 391         int             md_type;        /* type of entry MDT_* */
 392         uint64_t        md_data;        /* specific data */
 393         uint64_t        md_cval;        /* common string label */
 394 };
 395 #endif
 396
 397 int
 398 __elfN(obj_parse_modmetadata)(struct preloaded_file *fp, elf_file_t ef)
 399 {
 400         struct mod_metadata md;
 401 #if defined(__i386__) && __ELF_WORD_SIZE == 64
 402         struct mod_metadata64 md64;
 403 #endif
 404         struct mod_depend *mdepend;
 405         struct mod_version mver;
 406         char *s;
 407         int error, modcnt, minfolen;
 408         Elf_Addr v, p, p_stop;
 409
 410         if (__elfN(obj_lookup_set)(fp, ef, "modmetadata_set", &p, &p_stop,
 411             &modcnt) != 0)
 412                 return 0;
 413
 414         modcnt = 0;
 415         while (p < p_stop) {
 416                 COPYOUT(p, &v, sizeof(v));
 417                 error = __elfN(obj_reloc_ptr)(fp, ef, p, &v, sizeof(v));
 418                 if (error != 0)
 419                         return (error);
 420 #if defined(__i386__) && __ELF_WORD_SIZE == 64
 421                 COPYOUT(v, &md64, sizeof(md64));
 422                 error = __elfN(obj_reloc_ptr)(fp, ef, v, &md64, sizeof(md64));
 423                 if (error != 0)
 424                         return (error);
 425                 md.md_version = md64.md_version;
 426                 md.md_type = md64.md_type;
 427                 md.md_cval = (const char *)(uintptr_t)md64.md_cval;
 428                 md.md_data = (void *)(uintptr_t)md64.md_data;
 429 #else
 430                 COPYOUT(v, &md, sizeof(md));
 431                 error = __elfN(obj_reloc_ptr)(fp, ef, v, &md, sizeof(md));
 432                 if (error != 0)
 433                         return (error);
 434 #endif
 435                 p += sizeof(Elf_Addr);
 436                 switch(md.md_type) {
 437                 case MDT_DEPEND:
 438                         s = strdupout((vm_offset_t)md.md_cval);
 439                         minfolen = sizeof(*mdepend) + strlen(s) + 1;
 440                         mdepend = malloc(minfolen);
 441                         if (mdepend == NULL)
 442                                 return ENOMEM;
 443                         COPYOUT((vm_offset_t)md.md_data, mdepend,
 444                             sizeof(*mdepend));
 445                         strcpy((char*)(mdepend + 1), s);
 446                         free(s);
 447                         file_addmetadata(fp, MODINFOMD_DEPLIST, minfolen,
 448                             mdepend);
 449                         free(mdepend);
 450                         break;
 451                 case MDT_VERSION:
 452                         s = strdupout((vm_offset_t)md.md_cval);
 453                         COPYOUT((vm_offset_t)md.md_data, &mver, sizeof(mver));
 454                         file_addmodule(fp, s, mver.mv_version, NULL);
 455                         free(s);
 456                         modcnt++;
 457                         break;
 458                 case MDT_MODULE:
 459                 case MDT_PNP_INFO:
 460                         break;
 461                 default:
 462                         printf("unknown type %d\n", md.md_type);
 463                         break;
 464                 }
 465         }
 466         return 0;
 467 }
 468
 469 static int
 470 __elfN(obj_lookup_set)(struct preloaded_file *fp, elf_file_t ef,
 471     const char* name, Elf_Addr *startp, Elf_Addr *stopp, int *countp)
 472 {
 473         Elf_Ehdr *hdr;
 474         Elf_Shdr *shdr;
 475         char *p;
 476         vm_offset_t shstrtab;
 477         int i;
 478
 479         hdr = &ef->hdr;
 480         shdr = ef->e_shdr;
 481         shstrtab = shdr[ef->shstrindex].sh_addr;
 482
 483         for (i = 0; i < hdr->e_shnum; i++) {
 484                 if (shdr[i].sh_type != SHT_PROGBITS)
 485                         continue;
 486                 if (shdr[i].sh_name == 0)
 487                         continue;
 488                 p = strdupout(shstrtab + shdr[i].sh_name);
 489                 if (strncmp(p, "set_", 4) == 0 && strcmp(p + 4, name) == 0) {
 490                         *startp = shdr[i].sh_addr;
 491                         *stopp = shdr[i].sh_addr +  shdr[i].sh_size;
 492                         *countp = (*stopp - *startp) / sizeof(Elf_Addr);
 493                         free(p);
 494                         return (0);
 495                 }
 496                 free(p);
 497         }
 498
 499         return (ESRCH);
 500 }
 501
 502 /*
 503  * Apply any intra-module relocations to the value. p is the load address
 504  * of the value and val/len is the value to be modified. This does NOT modify
 505  * the image in-place, because this is done by kern_linker later on.
 506  */
 507 static int
 508 __elfN(obj_reloc_ptr)(struct preloaded_file *mp, elf_file_t ef, Elf_Addr p,
 509     void *val, size_t len)
 510 {
 511         Elf_Ehdr *hdr;
 512         Elf_Shdr *shdr;
 513         Elf_Addr off = p;
 514         Elf_Addr base;
 515         Elf_Rela a, *abase;
 516         Elf_Rel r, *rbase;
 517         int error, i, j, nrel, nrela;
 518
 519         hdr = &ef->hdr;
 520         shdr = ef->e_shdr;
 521
 522         for (i = 0; i < hdr->e_shnum; i++) {
 523                 if (shdr[i].sh_type != SHT_RELA && shdr[i].sh_type != SHT_REL)
 524                         continue;
 525                 base = shdr[shdr[i].sh_info].sh_addr;
 526                 if (base == 0 || shdr[i].sh_addr == 0)
 527                         continue;
 528                 if (off < base || off + len > base +
 529                     shdr[shdr[i].sh_info].sh_size)
 530                         continue;
 531
 532                 switch (shdr[i].sh_type) {
 533                 case SHT_RELA:
 534                         abase = (Elf_Rela *)(intptr_t)shdr[i].sh_addr;
 535
 536                         nrela = shdr[i].sh_size / sizeof(Elf_Rela);
 537                         for (j = 0; j < nrela; j++) {
 538                                 COPYOUT(abase + j, &a, sizeof(a));
 539
 540                                 error = __elfN(reloc)(ef, __elfN(obj_symaddr),
 541                                     &a, ELF_RELOC_RELA, base, off, val, len);
 542                                 if (error != 0)
 543                                         return (error);
 544                         }
 545                         break;
 546                 case SHT_REL:
 547                         rbase = (Elf_Rel *)(intptr_t)shdr[i].sh_addr;
 548
 549                         nrel = shdr[i].sh_size / sizeof(Elf_Rel);
 550                         for (j = 0; j < nrel; j++) {
 551                                 COPYOUT(rbase + j, &r, sizeof(r));
 552
 553                                 error = __elfN(reloc)(ef, __elfN(obj_symaddr),
 554                                     &r, ELF_RELOC_REL, base, off, val, len);
 555                                 if (error != 0)
 556                                         return (error);
 557                         }
 558                         break;
 559                 }
 560         }
 561         return (0);
 562 }
 563
 564 /* Look up the address of a specified symbol. */
 565 static Elf_Addr
 566 __elfN(obj_symaddr)(struct elf_file *ef, Elf_Size symidx)
 567 {
 568         Elf_Sym sym;
 569         Elf_Addr base;
 570
 571         if (symidx >= ef->e_shdr[ef->symtabindex].sh_size / sizeof(Elf_Sym))
 572                 return (0);
 573         COPYOUT(ef->e_shdr[ef->symtabindex].sh_addr + symidx * sizeof(Elf_Sym),
 574             &sym, sizeof(sym));
 575         if (sym.st_shndx == SHN_UNDEF || sym.st_shndx >= ef->hdr.e_shnum)
 576                 return (0);
 577         base = ef->e_shdr[sym.st_shndx].sh_addr;
 578         if (base == 0)
 579                 return (0);
 580         return (base + sym.st_value);
 581 }