usr/src/cmd/sgs/rtld.4.x/rtld.4.x.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License, Version 1.0 only
   6  * (the "License").  You may not use this file except in compliance
   7  * with the License.
   8  *
   9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  10  * or http://www.opensolaris.org/os/licensing.
  11  * See the License for the specific language governing permissions
  12  * and limitations under the License.
  13  *
  14  * When distributing Covered Code, include this CDDL HEADER in each
  15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  16  * If applicable, add the following below this CDDL HEADER, with the
  17  * fields enclosed by brackets "[]" replaced with your own identifying
  18  * information: Portions Copyright [yyyy] [name of copyright owner]
  19  *
  20  * CDDL HEADER END
  21  */
  22 /*
  23  * Copyright 2003 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  *
  26  * Binary compatibility ld.so.  Intercepts the reference of a pre-SVR4
  27  * SunOS executable to the dynamic linker, and then redirects to the
  28  * "real" post-SVR4 SunOS ld.so.
  29  */
  30 #pragma ident   "%Z%%M% %I%     %E% SMI"
  31
  32 /*
  33  * Import data structures (N.B.: from 5.x).
  34  */
  35 #include <sys/types.h>
  36 #include <sys/mman.h>
  37 #include <sys/fcntl.h>
  38 #include <sys/stat.h>
  39 #include <sys/sysconfig.h>
  40 #include <sys/auxv.h>
  41 #include <sys/archsystm.h>
  42 #include <elf.h>
  43 #include <link.h>
  44
  45 /*
  46  * Relocation manifest constants and macros.
  47  */
  48 #define ALIGN(x, a)             ((int)(x) & ~((int)(a) - 1))
  49 #define ROUND(x, a)             (((int)(x) + ((int)(a) - 1)) & \
  50                                     ~((int)(a) - 1))
  51 #define DYNAMIC_VERSION2        2
  52 #define RELOC_SIZE              (sizeof (struct relocation_info))
  53 #define RELOCOFF(x)             (x)->v2->ld_rel
  54 #define MASK(n)                 ((1<<(n))-1)
  55 #define IN_RANGE(v, n)          ((-(1<<((n)-1))) <= (v) && (v) < (1<<((n)-1)))
  56
  57 void    aout_reloc_write();
  58
  59 /*
  60  * 4.x SunOS Dynamic Link Editor public definitions (much derived from
  61  * SunOS 4.x <link.h>.)
  62  */
  63
  64 /*
  65  * Dynamic linking information.  With the exception of
  66  * ld_loaded (determined at execution time) and ld_stab_hash (a special
  67  * case of relocation handled at execution time), the values in this
  68  * structure reflect offsets from the containing link_dynamic structure.
  69  */
  70 struct link_dynamic_1 {
  71         struct  link_map *ld_loaded;    /* list of loaded objects */
  72         long    ld_need;                /* list of needed objects */
  73         long    ld_rules;               /* search rules for library objects */
  74         long    ld_got;                 /* global offset table */
  75         long    ld_plt;                 /* procedure linkage table */
  76         long    ld_rel;                 /* relocation table */
  77         long    ld_hash;                /* symbol hash table */
  78         long    ld_stab;                /* symbol table itself */
  79         long    (*ld_stab_hash)();      /* "pointer" to symbol hash function */
  80         long    ld_buckets;             /* number of hash buckets */
  81         long    ld_symbols;             /* symbol strings */
  82         long    ld_symb_size;           /* size of symbol strings */
  83         long    ld_text;                /* size of text area */
  84 };
  85
  86 struct link_dynamic_2 {
  87         struct  link_map *ld_loaded;    /* list of loaded objects */
  88         long    ld_need;                /* list of needed objects */
  89         long    ld_rules;               /* search rules for library objects */
  90         long    ld_got;                 /* global offset table */
  91         long    ld_plt;                 /* procedure linkage table */
  92         long    ld_rel;                 /* relocation table */
  93         long    ld_hash;                /* symbol hash table */
  94         long    ld_stab;                /* symbol table itself */
  95         long    (*ld_stab_hash)();      /* "pointer" to symbol hash function */
  96         long    ld_buckets;             /* number of hash buckets */
  97         long    ld_symbols;             /* symbol strings */
  98         long    ld_symb_size;           /* size of symbol strings */
  99         long    ld_text;                /* size of text area */
 100         long    ld_plt_sz;              /* size of procedure linkage table */
 101 };
 102
 103 /*
 104  * Debugger interface structure.
 105  */
 106 struct  ld_debug {
 107         int     ldd_version;            /* version # of interface */
 108         int     ldd_in_debugger;        /* a debugger is running us */
 109         int     ldd_sym_loaded;         /* we loaded some symbols */
 110         char    *ldd_bp_addr;           /* place for ld-generated bpt */
 111         int     ldd_bp_inst;            /* instruction which was there */
 112         struct rtc_symb *ldd_cp;        /* commons we built */
 113 };
 114
 115 /*
 116  * Structure associated with each object which may be or which requires
 117  * execution-time link editing.  Used by the run-time linkage editor to
 118  * identify needed objects and symbol definitions and references.
 119  */
 120 struct  link_dynamic {
 121         int     ld_version;
 122         struct  ld_debug *ldd;
 123         union {
 124                 struct link_dynamic_1 *ld_1;
 125                 struct link_dynamic_2 *ld_2;
 126         } ld_un;
 127 };
 128
 129 struct  old_link_dynamic {
 130         int     ld_version;             /* version # of this structure */
 131         union {
 132                 struct link_dynamic_1 ld_1;
 133         } ld_un;
 134
 135         int     in_debugging;
 136         int     sym_loaded;
 137         char    *bp_addr;
 138         int     bp_inst;
 139         struct rtc_symb *cp;            /* pointer to an array of runtime */
 140                                         /* allocated common symbols. */
 141 };
 142
 143 #define v2      ld_un.ld_2              /* short hands */
 144 #define v1      ld_un.ld_1
 145
 146 /*
 147  * SunOS 4.x SPARC relocation types and relocation record.  Note that
 148  * these, among other things, make this program not portable to things
 149  * other than SPARC.
 150  */
 151 enum reloc_type {
 152         RELOC_8, RELOC_16, RELOC_32,    /* simplest relocs */
 153         RELOC_DISP8, RELOC_DISP16, RELOC_DISP32,
 154                                         /* Disp's (pc-rel) */
 155         RELOC_WDISP30, RELOC_WDISP22,   /* SR word disp's */
 156         RELOC_HI22, RELOC_22,           /* SR 22-bit relocs */
 157         RELOC_13, RELOC_LO10,           /* SR 13&10-bit relocs */
 158         RELOC_SFA_BASE, RELOC_SFA_OFF13, /* SR S.F.A. relocs */
 159         RELOC_BASE10, RELOC_BASE13, RELOC_BASE22,
 160                                         /* PIC GOT references */
 161         RELOC_PC10, RELOC_PC22,         /* PIC reference to GOT */
 162         RELOC_JMP_TBL,                  /* PIC call */
 163         RELOC_SEGOFF16,                 /* .so offset-in-segment */
 164         RELOC_GLOB_DAT, RELOC_JMP_SLOT, RELOC_RELATIVE,
 165                                         /* ld.so relocation types */
 166 };
 167
 168 struct relocation_info {
 169         unsigned long int r_address;    /* relocation addr */
 170         unsigned int    r_index   :24;  /* segment index or symbol index */
 171         unsigned int    r_extern  : 1;  /* if F, r_index==SEG#; if T, SYM idx */
 172         int                       : 2;  /* <unused> */
 173         enum reloc_type r_type    : 5;  /* type of relocation to perform */
 174         long int        r_addend;       /* addend for relocation value */
 175 };
 176
 177 /*
 178  * Size of relocations.
 179  */
 180 #define GETRELSZ(x)     \
 181         (x->ld_version < 2 ? \
 182         ((struct old_link_dynamic *)x)->v1.ld_hash - \
 183                 ((struct old_link_dynamic *)x)->v1.ld_rel : \
 184         (x)->v2->ld_hash - (x)->v2->ld_rel)
 185
 186 /*
 187  * Interface between crt0 & ld.so.
 188  */
 189 struct crt_i1 {
 190         int     crt_baseaddr;           /* Address ld.so is at */
 191         int     crt_dzfd;               /* /dev/zero file descriptor */
 192         int     crt_rlfd;               /* ld.so file descriptor */
 193         struct  link_dynamic *crt_udp;  /* "main_" dynamic */
 194         char    **crt_ep;               /* environment strings */
 195         caddr_t crt_breakp;             /* place to put initial breakpoint */
 196 };
 197
 198 /*
 199  * Structure we provide to ELF ld.so upon entry.
 200  */
 201 Elf32_Boot      eb[EB_MAX];
 202
 203 /*
 204  * Global data.
 205  */
 206 char *program_name;                     /* used in messages */
 207
 208 /*
 209  * 4.0 ld.so main entry point.
 210  */
 211 rtld(version, ip, dp, argp)
 212         int version;                    /* interface version */
 213         struct crt_i1 *ip;              /* interface passed from program */
 214         register struct link_dynamic *dp; /* ld.so dynamic pointer */
 215         caddr_t argp;                   /* pointer to begining of args */
 216 {
 217         char *ldso;                     /* name of what we really want to be */
 218         int i, p;                       /* working */
 219         int r;                          /* working (# of *our* relocations */
 220         int page_size = 0;              /* size of a page */
 221         struct relocation_info *rp;     /* working pointer to our relocs */
 222         int fd;                         /* fd assigned to ld.so */
 223         Elf32_Ehdr *ehdr;               /* ELF header of ld.so */
 224         Elf32_Phdr *phdr;               /* first Phdr in file */
 225         Elf32_Phdr *pptr;               /* working Phdr */
 226         Elf32_Phdr *lph;                /* last loadable Phdr */
 227         Elf32_Phdr *fph = 0;            /* first loadable Phdr */
 228         caddr_t maddr;                  /* pointer to mapping claim */
 229         Elf32_Off mlen;                 /* total mapping claim */
 230         caddr_t faddr;                  /* first program mapping of ld.so */
 231         Elf32_Off foff;                 /* file offset for segment mapping */
 232         Elf32_Off flen;                 /* file length for segment mapping */
 233         caddr_t addr;                   /* working mapping address */
 234         caddr_t zaddr;                  /* /dev/zero working mapping addr */
 235         Elf32_Boot *ebp;                /* communication with ld.so */
 236         struct stat sb;                 /* stat buffer for sizing */
 237         auxv_t *ap;                     /* working aux pointer */
 238         void (* wrt)();                 /* address of write/iflush routine */
 239
 240         /*
 241          * ld.so must itself be relocated, take care of this now.
 242          * We can not refer to global data before this step is
 243          * complete.  Perform the relocation by stepping over all
 244          * entries in the relocation table and turn them into
 245          * absolute addresses.  Note that, in order to avoid invoking
 246          * as yet unrelocated items, we perform the relocation count
 247          * by counting rather than risk invoking subroutine calls
 248          * to intrinsic .div or .mul routines.  Note also that we
 249          * assume that there are no symbolic relocations to be
 250          * performed here.
 251          */
 252         dp->v2 = (struct link_dynamic_2 *)
 253             ((caddr_t)dp->v2 + ip->crt_baseaddr);
 254         r = 0;
 255         i = GETRELSZ(dp);
 256         while (i != 0) {
 257                 i -= RELOC_SIZE;
 258                 r++;
 259         }
 260         rp = (struct relocation_info *)(RELOCOFF(dp) +
 261             (dp->ld_version < DYNAMIC_VERSION2 ?
 262             (int)dp : ip->crt_baseaddr));
 263
 264         /*
 265          * Determine the location of the routine that will write the relocation.
 266          * This hasn't yet been relocated so determine the real address using
 267          * our base address.
 268          */
 269         wrt = (void (*)())((caddr_t)aout_reloc_write + ip->crt_baseaddr);
 270
 271         /*
 272          * Relocate ourselves - we only need RELOC_RELATIVE and RELOC_32.
 273          * Note, if panic() was called its probable that it will barf as the
 274          * corresponding plt wouldn't have been relocated yet.
 275          */
 276         for (i = 0; i < r; i++) {
 277             long *where = (long *)((caddr_t)rp->r_address + ip->crt_baseaddr);
 278             long what = ip->crt_baseaddr;
 279             long value;
 280
 281             switch (rp->r_type) {
 282             case RELOC_RELATIVE:
 283                 what += *where << (32-22);
 284                 value = (*where & ~MASK(22)) | ((what >> (32-22)) & MASK(22));
 285                 wrt(where, value);
 286                 where++;
 287                 what += (*where & MASK(10));
 288                 value = (*where & ~MASK(10)) | (what & MASK(10));
 289                 wrt(where, value);
 290                 break;
 291
 292             case RELOC_32:
 293                 what += *where;
 294                 wrt(where, what);
 295                 break;
 296
 297             default:
 298                 panic("unknown relocation type %d\n", rp->r_type);
 299                 break;
 300             }
 301             rp++;
 302         }
 303
 304         /*
 305          * We're relocated, we can now initialize things referencing
 306          * static storage.
 307          */
 308         ldso = "/usr/lib/ld.so.1";
 309
 310         /*
 311          * Close off the file descriptor used to get us here -- let it
 312          * be available for the next (probable) use below.
 313          */
 314         (void) close(ip->crt_rlfd);
 315
 316         /*
 317          * Discover things about our environment: auxiliary vector (if
 318          * any), arguments, program name, and the like.
 319          */
 320         ebp = eb;
 321         program_name = (char *)(argp + sizeof (int));
 322         if (version != 1)
 323                 panic("bad startup interface version of %d",
 324                     version);
 325         ebp->eb_tag = EB_DYNAMIC,
 326             (ebp++)->eb_un.eb_ptr = (Elf32_Addr)ip->crt_udp;
 327         ebp->eb_tag = EB_ARGV, (ebp++)->eb_un.eb_ptr = (Elf32_Addr)program_name;
 328         ebp->eb_tag = EB_ENVP, (ebp++)->eb_un.eb_ptr = (Elf32_Addr)ip->crt_ep;
 329         ebp->eb_tag = EB_DEVZERO,
 330             (ebp++)->eb_un.eb_val = (Elf32_Word)ip->crt_dzfd;
 331         for (addr = (caddr_t)ip->crt_ep; *addr; addr += sizeof (char *))
 332                 ;
 333         addr += sizeof (char *);
 334
 335         /*
 336          * The kernel sends us an abbreviated aux vector with some
 337          * potentially handy stuff that saves us on syscalls.
 338          *
 339          * Notes on 1226113
 340          *
 341          * The f77 compiler shipped as part of SC1.0 on 4.x creates binaries
 342          * that use the _fix_libc_ feature of acc.  This makes the resulting
 343          * executable object dependent on the undocumented behaviour of
 344          * libc's .rem and .div routines e.g. that .div returns the
 345          * remainder in %o3 (and similarly .rem returns the division in %o3).
 346          *
 347          * The only simple solution is to disable hardware divide for
 348          * all 4.x applications so that the old software routines that have
 349          * this "support" in them are used instead.  And we do that by
 350          * clearing the divide-in-hardware flag from the aux vector before
 351          * libc's .init routine gets to see it.  Awful isn't it.
 352          */
 353         ebp->eb_tag = EB_AUXV, (ebp++)->eb_un.eb_ptr = (Elf32_Addr)addr;
 354         for (ap = (auxv_t *)addr; ap->a_type != AT_NULL; ap++)
 355                 if (ap->a_type == AT_PAGESZ) {
 356                         page_size = ap->a_un.a_val;
 357                         ebp->eb_tag = EB_PAGESIZE, (ebp++)->eb_un.eb_val =
 358                             (Elf32_Word)page_size;
 359                 } else if (ap->a_type == AT_SUN_HWCAP)
 360                         ap->a_un.a_val &= ~AV_SPARC_HWDIV_32x32;
 361
 362         /*
 363          * If we didn't get a page size from looking in the auxiliary
 364          * vector, we need to get one now.
 365          */
 366         if (page_size == 0) {
 367                 page_size = sysconfig(_CONFIG_PAGESIZE);
 368                 ebp->eb_tag = EB_PAGESIZE, (ebp++)->eb_un.eb_val =
 369                     (Elf32_Word)page_size;
 370         }
 371
 372         /*
 373          * Map in the ELF-based ld.so.  Note that we're mapping it as
 374          * an ELF database, not as a program -- we just want to walk it's
 375          * data structures.  Further mappings will actually establish the
 376          * program in the address space.
 377          */
 378         if ((fd = open(ldso, O_RDONLY)) == -1)
 379                 panic("unable to open %s", ldso);
 380         if (fstat(fd, &sb) == -1)
 381                 panic("unable to find size of %s", ldso);
 382         ehdr = (Elf32_Ehdr *)mmap(0, sb.st_size, PROT_READ | PROT_EXEC,
 383             MAP_SHARED, fd, 0);
 384         if (ehdr == (Elf32_Ehdr *)-1)
 385                 panic("unable to map %s", ldso);
 386
 387         /*
 388          * Validate the file we're looking at, ensure it has the correct
 389          * ELF structures, such as: ELF magic numbers, coded for SPARC,
 390          * is a ".so", etc.
 391          */
 392         if (ehdr->e_ident[EI_MAG0] != ELFMAG0 ||
 393             ehdr->e_ident[EI_MAG1] != ELFMAG1 ||
 394             ehdr->e_ident[EI_MAG2] != ELFMAG2 ||
 395             ehdr->e_ident[EI_MAG3] != ELFMAG3)
 396                 panic("%s is not an ELF file", ldso);
 397         if (ehdr->e_ident[EI_CLASS] != ELFCLASS32 ||
 398             ehdr->e_ident[EI_DATA] != ELFDATA2MSB)
 399                 panic("%s has wrong class or data encoding", ldso);
 400         if (ehdr->e_type != ET_DYN)
 401                 panic("%s is not a shared object", ldso);
 402         if ((ehdr->e_machine != EM_SPARC) &&
 403             (ehdr->e_machine != EM_SPARC32PLUS))
 404                 panic("%s is not a valid SPARC object: e_machine: %x",
 405                     ldso, ehdr->e_machine);
 406         if (ehdr->e_version > EV_CURRENT)
 407                 panic("%s has bad ELF version of %d", ldso, ehdr->e_version);
 408
 409         /*
 410          * Point at program headers and start figuring out what to load.
 411          */
 412         phdr = (Elf32_Phdr *)((caddr_t)ehdr + ehdr->e_phoff);
 413         for (p = 0, pptr = phdr; p < (int)ehdr->e_phnum; p++,
 414             pptr = (Elf32_Phdr *)((caddr_t)pptr + ehdr->e_phentsize))
 415                 if (pptr->p_type == PT_LOAD) {
 416                         if (fph == 0) {
 417                                 fph = pptr;
 418                         } else if (pptr->p_vaddr <= lph->p_vaddr)
 419                                 panic(
 420                 "%s invalid program header - segments out of order", ldso);
 421                         lph = pptr;
 422                 }
 423
 424         /*
 425          * We'd better have at least one loadable segment.
 426          */
 427         if (fph == 0)
 428                 panic("%s has no loadable segments", ldso);
 429
 430         /*
 431          * Map enough address space to hold the program (as opposed to the
 432          * file) represented by ld.so.  The amount to be assigned is the
 433          * range between the end of the last loadable segment and the
 434          * beginning of the first PLUS the alignment of the first segment.
 435          * mmap() can assign us any page-aligned address, but the relocations
 436          * assume the alignments included in the program header.  As an
 437          * optimization, however, let's assume that mmap() will actually
 438          * give us an aligned address -- since if it does, we can save
 439          * an munmap() later on.  If it doesn't -- then go try it again.
 440          */
 441         mlen = ROUND((lph->p_vaddr + lph->p_memsz) -
 442             ALIGN(fph->p_vaddr, page_size), page_size);
 443         maddr = (caddr_t)mmap(0, mlen, PROT_READ | PROT_EXEC,
 444             MAP_SHARED, fd, 0);
 445         if (maddr == (caddr_t)-1)
 446                 panic("unable to reserve space for %s", ldso);
 447         faddr = (caddr_t)ROUND(maddr, fph->p_align);
 448
 449         /*
 450          * Check to see whether alignment skew was really needed.
 451          */
 452         if (faddr != maddr) {
 453                 (void) munmap(maddr, mlen);
 454                 mlen = ROUND((lph->p_vaddr + lph->p_memsz) -
 455                     ALIGN(fph->p_vaddr, fph->p_align) + fph->p_align,
 456                     page_size);
 457                 maddr = (caddr_t)mmap(0, mlen, PROT_READ | PROT_EXEC,
 458                     MAP_SHARED, fd, 0);
 459                 if (maddr == (caddr_t)-1)
 460                         panic("unable to reserve space for %s", ldso);
 461                 faddr = (caddr_t)ROUND(maddr, fph->p_align);
 462         }
 463         ebp->eb_tag = EB_LDSO_BASE, (ebp++)->eb_un.eb_ptr = (Elf32_Addr)faddr;
 464
 465         /*
 466          * We have the address space reserved, so map each loadable segment.
 467          */
 468         for (pptr = phdr; (pptr - phdr) < (int)ehdr->e_phnum; pptr++) {
 469
 470                 /*
 471                  * Skip non-loadable segments or segments that don't occupy
 472                  * any memory.
 473                  */
 474                 if ((pptr->p_type != PT_LOAD) || (pptr->p_memsz == 0))
 475                         continue;
 476
 477                 /*
 478                  * Determine the file offset to which the mapping will
 479                  * directed (must be aligned) and how much to map (might
 480                  * be more than the file in the case of .bss.)
 481                  */
 482                 foff = ALIGN(pptr->p_offset, page_size);
 483                 flen = pptr->p_memsz + (pptr->p_offset - foff);
 484
 485                 /*
 486                  * Set address of this segment relative to our base.
 487                  */
 488                 addr = (caddr_t)ALIGN(faddr + pptr->p_vaddr, page_size);
 489
 490                 /*
 491                  * Unmap anything form the last mapping address to this
 492                  * one.
 493                  */
 494                 if (addr - maddr) {
 495                         (void) munmap(maddr, addr - maddr);
 496                         mlen -= addr - maddr;
 497                 }
 498
 499                 /*
 500                  * Determine the mapping protection from the section
 501                  * attributes.
 502                  */
 503                 i = 0;
 504                 if (pptr->p_flags & PF_R)
 505                         i |= PROT_READ;
 506                 if (pptr->p_flags & PF_W)
 507                         i |= PROT_WRITE;
 508                 if (pptr->p_flags & PF_X)
 509                         i |= PROT_EXEC;
 510                 if ((caddr_t)mmap((caddr_t)addr, flen, i,
 511                     MAP_FIXED | MAP_PRIVATE, fd, foff) == (caddr_t)-1)
 512                         panic("unable to map a segment from %s", ldso);
 513
 514                 /*
 515                  * If the memory occupancy of the segment overflows the
 516                  * definition in the file, we need to "zero out" the
 517                  * end of the mapping we've established, and if necessary,
 518                  * map some more space from /dev/zero.
 519                  */
 520                 if (pptr->p_memsz > pptr->p_filesz) {
 521                         foff = (int)faddr + pptr->p_vaddr + pptr->p_filesz;
 522                         zaddr = (caddr_t)ROUND(foff, page_size);
 523                         _zero(foff, zaddr - foff);
 524                         r = (faddr + pptr->p_vaddr + pptr->p_memsz) - zaddr;
 525                         if (r > 0)
 526                                 if ((caddr_t)mmap((caddr_t)zaddr, r, i,
 527                                     MAP_FIXED | MAP_PRIVATE, ip->crt_dzfd,
 528                                     0) == (caddr_t)-1)
 529                                         panic(
 530                                         "unable to map .bss /dev/zero for %s",
 531                                             ldso);
 532                 }
 533
 534                 /*
 535                  * Update the mapping claim pointer.
 536                  */
 537                 maddr = addr + ROUND(flen, page_size);
 538                 mlen -= maddr - addr;
 539         }
 540
 541         /*
 542          * Unmap any final reservation.
 543          */
 544         if (mlen > 0)
 545                 (void) munmap(maddr, mlen);
 546
 547         /*
 548          * Clean up file descriptor space we've consumed.  Pass along
 549          * the /dev/zero file descriptor we got -- every cycle counts.
 550          */
 551         (void) close(fd);
 552
 553         /*
 554          * The call itself.  Note that we start 1 instruction word in.
 555          * The ELF ld.so contains an "entry vector" of branch instructions,
 556          * which, for our interest are:
 557          *      +0:     ba, a   <normal startup>
 558          *      +4:     ba, a   <compatibility startup>
 559          * By starting at the compatibility startup, the ELF ld.so knows
 560          * that a pointer to "eb" is available to it and further knows
 561          * how to calculate the offset to the program's arguments and
 562          * other structures.
 563          */
 564         ebp->eb_tag = EB_NULL, ebp->eb_un.eb_val = 0;
 565         (*((void (*)())(ehdr->e_entry + faddr + sizeof (long))))(eb);
 566         return (0);
 567 }