8354 sync regcomp(3C) with upstream (fix make catalog)

[unleashed/tickless.git] / usr / src / cmd / sgs / ld / common / ld.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
 */

#include        <stdio.h>
#include        <stdlib.h>
#include        <unistd.h>
#include        <stdarg.h>
#include        <string.h>
#include        <strings.h>
#include        <errno.h>
#include        <fcntl.h>
#include        <libintl.h>
#include        <locale.h>
#include        <fcntl.h>
#include        <ar.h>
#include        <gelf.h>
#include        "conv.h"
#include        "libld.h"
#include        "machdep.h"
#include        "msg.h"

/*
 * The following prevent us from having to include ctype.h which defines these
 * functions as macros which reference the __ctype[] array.  Go through .plt's
 * to get to these functions in libc rather than have every invocation of ld
 * have to suffer the R_SPARC_COPY overhead of the __ctype[] array.
 */
extern int      isspace(int);

/*
 * We examine ELF objects, and archives containing ELF objects, in order
 * to determine the ELFCLASS of the resulting object and/or the linker to be
 * used. We want to avoid the overhead of libelf for this, at least until
 * we are certain that we need it, so we start by reading bytes from
 * the beginning of the file. This type defines the buffer used to read
 * these initial bytes.
 *
 * A plain ELF object will start with an ELF header, whereas an archive
 * starts with a magic string (ARMAG) that is SARMAG bytes long. Any valid
 * ELF file or archive will contain more bytes than this buffer, so any
 * file shorter than this can be safely assummed not to be of interest.
 *
 * The ELF header for ELFCLASS32 and ELFCLASS64 are identical up through the
 * the e_version field, and all the information we require is found in this
 * common prefix. Furthermore, this cannot change, as the layout of an ELF
 * header is fixed by the ELF ABI. Hence, the ehdr part of this union is
 * not a full ELF header, but only the class-independent prefix that we need.
 *
 * As this is a raw (non-libelf) read, we are responsible for handling any
 * byte order difference between the object and the system running this
 * program when we read any datum larger than a byte (i.e. e_machine) from
 * this header.
 */
typedef union {
        struct {        /* Must match start of ELFxx_Ehdr in <sys/elf.h> */
                uchar_t         e_ident[EI_NIDENT];     /* ident bytes */
                Half            e_type;                 /* file type */
                Half            e_machine;              /* target machine */
        } ehdr;
        char                    armag[SARMAG];
} FILE_HDR;


/*
 * Print a message to stdout
 */
void
veprintf(Lm_list *lml, Error error, const char *format, va_list args)
{
        static const char       *strings[ERR_NUM];

#if     defined(lint)
        /*
         * The lml argument is only meaningful for diagnostics sent to ld.so.1.
         * Supress the lint error by making a dummy assignment.
         */
        lml = 0;
#endif
        /*
         * For error types we issue a prefix for, make sure the necessary
         * string has been internationalized and is ready.
         */
        switch (error) {
        case ERR_WARNING_NF:
                if (strings[ERR_WARNING_NF] == NULL)
                        strings[ERR_WARNING_NF] = MSG_INTL(MSG_ERR_WARNING);
                break;
        case ERR_WARNING:
                if (strings[ERR_WARNING] == NULL)
                        strings[ERR_WARNING] = MSG_INTL(MSG_ERR_WARNING);
                break;
        case ERR_GUIDANCE:
                if (strings[ERR_GUIDANCE] == NULL)
                        strings[ERR_GUIDANCE] = MSG_INTL(MSG_ERR_GUIDANCE);
                break;
        case ERR_FATAL:
                if (strings[ERR_FATAL] == NULL)
                        strings[ERR_FATAL] = MSG_INTL(MSG_ERR_FATAL);
                break;
        case ERR_ELF:
                if (strings[ERR_ELF] == NULL)
                        strings[ERR_ELF] = MSG_INTL(MSG_ERR_ELF);
        }

        /* If strings[] element for our error type is non-NULL, issue prefix */
        if (strings[error] != NULL) {
                (void) fputs(MSG_ORIG(MSG_STR_LDDIAG), stderr);
                (void) fputs(strings[error], stderr);
        }

        (void) vfprintf(stderr, format, args);
        if (error == ERR_ELF) {
                int     elferr;

                if ((elferr = elf_errno()) != 0)
                        (void) fprintf(stderr, MSG_ORIG(MSG_STR_ELFDIAG),
                            elf_errmsg(elferr));
        }
        (void) fprintf(stderr, MSG_ORIG(MSG_STR_NL));
        (void) fflush(stderr);
}


/*
 * Print a message to stdout
 */
/* VARARGS3 */
void
eprintf(Lm_list *lml, Error error, const char *format, ...)
{
        va_list args;

        va_start(args, format);
        veprintf(lml, error, format, args);
        va_end(args);
}


/*
 * Examine the first object in an archive to determine its ELFCLASS
 * and machine type.
 *
 * entry:
 *      fd - Open file descriptor for file
 *      elf - libelf ELF descriptor
 *      class_ret, mach_ret - Address of variables to receive ELFCLASS
 *              and machine type.
 *
 * exit:
 *      On success, *class_ret and *mach_ret are filled in, and True (1)
 *      is returned. On failure, False (0) is returned.
 */
static int
archive(int fd, Elf *elf, uchar_t *class_ret, Half *mach_ret)
{
        Elf_Cmd         cmd = ELF_C_READ;
        Elf_Arhdr       *arhdr;
        Elf             *_elf = NULL;
        int             found = 0;

        /*
         * Process each item within the archive until we find the first
         * ELF object, or alternatively another archive to recurse into.
         * Stop after analyzing the first plain object found.
         */
        while (!found && ((_elf = elf_begin(fd, cmd, elf)) != NULL)) {
                if ((arhdr = elf_getarhdr(_elf)) == NULL)
                        return (0);
                if (*arhdr->ar_name != '/') {
                        switch (elf_kind(_elf)) {
                        case ELF_K_AR:
                                found = archive(fd, _elf, class_ret, mach_ret);
                                break;
                        case ELF_K_ELF:
                                if (gelf_getclass(_elf) == ELFCLASS64) {
                                        Elf64_Ehdr *ehdr;

                                        if ((ehdr = elf64_getehdr(_elf)) ==
                                            NULL)
                                                break;
                                        *class_ret = ehdr->e_ident[EI_CLASS];
                                        *mach_ret = ehdr->e_machine;
                                } else {
                                        Elf32_Ehdr *ehdr;

                                        if ((ehdr = elf32_getehdr(_elf)) ==
                                            NULL)
                                                break;
                                        *class_ret = ehdr->e_ident[EI_CLASS];
                                        *mach_ret = ehdr->e_machine;
                                }
                                found = 1;
                                break;
                        }
                }

                cmd = elf_next(_elf);
                (void) elf_end(_elf);
        }

        return (found);
}

/*
 * Determine:
 *      - ELFCLASS of resulting object (class)
 *      - Whether user specified class of the linker (ldclass)
 *      - ELF machine type of resulting object (m_mach)
 *
 * In order of priority, we determine this information as follows:
 *
 * -    Command line options (-32, -64, -z altexec64, -z target).
 * -    From the first plain object seen on the command line. (This is
 *      by far the most common case.)
 * -    From the first object contained within the first archive
 *      on the command line.
 * -    If all else fails, we assume a 32-bit object for the native machine.
 *
 * entry:
 *      argc, argv - Command line argument vector
 *      class_ret - Address of variable to receive ELFCLASS of output object
 *      ldclass_ret - Address of variable to receive ELFCLASS of
 *              linker to use. This will be ELFCLASS32/ELFCLASS64 if one
 *              is explicitly specified, and ELFCLASSNONE otherwise.
 *              ELFCLASSNONE therefore means that we should use the best
 *              link-editor that the system/kernel will allow.
 */
static int
process_args(int argc, char **argv, uchar_t *class_ret, uchar_t *ldclass_ret,
    Half *mach)
{
        uchar_t ldclass = ELFCLASSNONE, class = ELFCLASSNONE, ar_class;
        Half    mach32 = EM_NONE, mach64 = EM_NONE, ar_mach;
        int     c, ar_found = 0;

        /*
         * In general, libld.so is responsible for processing the
         * command line options. The exception to this are those options
         * that contain information about which linker to run and the
         * class/machine of the output object. We examine the options
         * here looking for the following:
         *
         *      -32     Produce an ELFCLASS32 object. This is the default, so
         *              -32 is only needed when linking entirely from archives,
         *              and the first archive contains a mix of 32 and 64-bit
         *              objects, and the first object in that archive is 64-bit.
         *              We do not expect this option to get much use, but it
         *              ensures that the user can handle any situation.
         *
         *      -64     Produce an ELFCLASS64 object. (Note that this will
         *              indirectly cause the use of the 64-bit linker if
         *              the system is 64-bit capable). The most common need
         *              for this option is when linking a filter object entirely
         *              from a mapfile. The less common case is when linking
         *              entirely from archives, and the first archive contains
         *              a mix of 32 and 64-bit objects, and the first object
         *              in that archive is 32-bit.
         *
         *      -z altexec64
         *              Use the 64-bit linker regardless of the class
         *              of the output object.
         *
         *      -z target=platform
         *              Produce output object for the specified platform.
         *              This option is needed when producing an object
         *              for a non-native target entirely from a mapfile,
         *              or when linking entirely from an archive containing
         *              objects for multiple targets, and the first object
         *              in the archive is not for the desired target.
         *
         * If we've already processed an object and we find -32/-64, and
         * the object is of the wrong class, we have an error condition.
         * We ignore it here, and let it fall through to libld, where the
         * proper diagnosis and error message will occur.
         */
        opterr = 0;
        optind = 1;
getmore:
        while ((c = ld_getopt(0, optind, argc, argv)) != -1) {
                switch (c) {
                case '3':
                        if (strncmp(optarg, MSG_ORIG(MSG_ARG_TWO),
                            MSG_ARG_TWO_SIZE) == 0)
                                class = ELFCLASS32;
                        break;

                case '6':
                        if (strncmp(optarg, MSG_ORIG(MSG_ARG_FOUR),
                            MSG_ARG_FOUR_SIZE) == 0)
                                class = ELFCLASS64;
                        break;

                case 'z':
#if     !defined(_LP64)
                        /* -z altexec64 */
                        if (strncmp(optarg, MSG_ORIG(MSG_ARG_ALTEXEC64),
                            MSG_ARG_ALTEXEC64_SIZE) == 0) {
                                ldclass = ELFCLASS64;
                                break;
                        }
#endif
                        /* -z target=platform */
                        if (strncmp(optarg, MSG_ORIG(MSG_ARG_TARGET),
                            MSG_ARG_TARGET_SIZE) == 0) {
                                char *pstr = optarg + MSG_ARG_TARGET_SIZE;

                                if (strcasecmp(pstr,
                                    MSG_ORIG(MSG_TARG_SPARC)) == 0) {
                                        mach32 = EM_SPARC;
                                        mach64 = EM_SPARCV9;
                                } else if (strcasecmp(pstr,
                                    MSG_ORIG(MSG_TARG_X86)) == 0) {
                                        mach32 = EM_386;
                                        mach64 = EM_AMD64;
                                } else {
                                        eprintf(0, ERR_FATAL,
                                            MSG_INTL(MSG_ERR_BADTARG), pstr);
                                        return (1);
                                }
                        }
                        break;
                }
        }

        /*
         * Continue to look for the first ELF object to determine the class of
         * objects to operate on. At the same time, look for the first archive
         * of ELF objects --- if no plain ELF object is specified, the type
         * of the first ELF object in the first archive will be used. If
         * there is no object, and no archive, then we fall back to a 32-bit
         * object for the native machine.
         */
        for (; optind < argc; optind++) {
                int             fd;
                FILE_HDR        hdr;

                /*
                 * If we detect some more options return to getopt().
                 * Checking argv[optind][1] against null prevents a forever
                 * loop if an unadorned `-' argument is passed to us.
                 */
                if (argv[optind][0] == '-') {
                        if (argv[optind][1] == '\0')
                                continue;
                        else
                                goto getmore;
                }

                /*
                 * If we've already determined the object class and
                 * machine type, continue to the next argument. Only
                 * the first object contributes to this decision, and
                 * there's no value to opening or examing the subsequent
                 * ones. We do need to keep going though, because there
                 * may be additional options that might affect our
                 * class/machine decision.
                 */
                if ((class != ELFCLASSNONE) && (mach32 != EM_NONE))
                        continue;

                /*
                 * Open the file and determine if it is an object. We are
                 * looking for ELF objects, or archives of ELF objects.
                 *
                 * Plain objects are simple, and are the common case, so
                 * we examine them directly and avoid the map-unmap-map
                 * that would occur if we used libelf. Archives are too
                 * complex to be worth accessing directly, so if we identify
                 * an archive, we use libelf on it and accept the cost.
                 */
                if ((fd = open(argv[optind], O_RDONLY)) == -1) {
                        int err = errno;

                        eprintf(0, ERR_FATAL, MSG_INTL(MSG_SYS_OPEN),
                            argv[optind], strerror(err));
                        return (1);
                }

                if (pread(fd, &hdr, sizeof (hdr), 0) != sizeof (hdr)) {
                        (void) close(fd);
                        continue;
                }

                if ((hdr.ehdr.e_ident[EI_MAG0] == ELFMAG0) &&
                    (hdr.ehdr.e_ident[EI_MAG1] == ELFMAG1) &&
                    (hdr.ehdr.e_ident[EI_MAG2] == ELFMAG2) &&
                    (hdr.ehdr.e_ident[EI_MAG3] == ELFMAG3)) {
                        if (class == ELFCLASSNONE) {
                                class = hdr.ehdr.e_ident[EI_CLASS];
                                if ((class != ELFCLASS32) &&
                                    (class != ELFCLASS64))
                                        class = ELFCLASSNONE;
                        }

                        if (mach32 == EM_NONE) {
                                int     one = 1;
                                uchar_t *one_p = (uchar_t *)&one;
                                int     ld_elfdata;

                                ld_elfdata = (one_p[0] == 1) ?
                                    ELFDATA2LSB : ELFDATA2MSB;
                                /*
                                 * Both the 32 and 64-bit versions get the
                                 * type from the object. If the user has
                                 * asked for an inconsistant class/machine
                                 * combination, libld will catch it.
                                 */
                                mach32 = mach64 =
                                    (ld_elfdata == hdr.ehdr.e_ident[EI_DATA]) ?
                                    hdr.ehdr.e_machine :
                                    BSWAP_HALF(hdr.ehdr.e_machine);
                        }
                } else if (!ar_found &&
                    (memcmp(&hdr.armag, ARMAG, SARMAG) == 0)) {
                        Elf     *elf;

                        (void) elf_version(EV_CURRENT);
                        if ((elf = elf_begin(fd, ELF_C_READ, NULL)) == NULL) {
                                (void) close(fd);
                                continue;
                        }
                        if (elf_kind(elf) == ELF_K_AR)
                                ar_found =
                                    archive(fd, elf, &ar_class, &ar_mach);
                        (void) elf_end(elf);
                }

                (void) close(fd);
        }

        /*
         * ELFCLASS of output object: If we did not establish a class from a
         * command option, or from the first plain object, then use the class
         * from the first archive, and failing that, default to 32-bit.
         */
        if (class == ELFCLASSNONE)
                class = ar_found ? ar_class : ELFCLASS32;
        *class_ret = class;

        /* ELFCLASS of link-editor to use */
        *ldclass_ret = ldclass;

        /*
         * Machine type of output object: If we did not establish a machine
         * type from the command line, or from the first plain object, then
         * use the machine established by the first archive, and failing that,
         * use the native machine.
         */
        *mach = (class == ELFCLASS64) ? mach64 : mach32;
        if (*mach == EM_NONE)
                if (ar_found)
                        *mach = ar_mach;
                else
                        *mach = (class == ELFCLASS64) ? M_MACH_64 : M_MACH_32;

        return (0);
}

/*
 * Process an LD_OPTIONS environment string.  This routine is first called to
 * count the number of options, and second to initialize a new argument array
 * with each option.
 */
static int
process_ldoptions(char *str, char **nargv)
{
        int     argc = 0;
        char    *arg = str;

        /*
         * Walk the environment string processing any arguments that are
         * separated by white space.
         */
        while (*str != '\0') {
                if (isspace(*str)) {
                        /*
                         * If a new argument array has been provided, terminate
                         * the original environment string, and initialize the
                         * appropriate argument array entry.
                         */
                        if (nargv) {
                                *str++ = '\0';
                                nargv[argc] = arg;
                        }

                        argc++;
                        while (isspace(*str))
                                str++;
                        arg = str;
                } else
                        str++;
        }
        if (arg != str) {
                /*
                 * If a new argument array has been provided, initialize the
                 * final argument array entry.
                 */
                if (nargv)
                        nargv[argc] = arg;
                argc++;
        }

        return (argc);
}

/*
 * Determine whether an LD_OPTIONS environment variable is set, and if so,
 * prepend environment string as a series of options to the argv array.
 */
static int
prepend_ldoptions(int *argcp, char ***argvp)
{
        int     nargc;
        char    **nargv, *ld_options;
        int     err, count;

        if ((ld_options = getenv(MSG_ORIG(MSG_LD_OPTIONS))) == NULL)
                return (0);

        /*
         * Get rid of any leading white space, and make sure the environment
         * string has size.
         */
        while (isspace(*ld_options))
                ld_options++;
        if (ld_options[0] == '\0')
                return (0);

        /*
         * Prevent modification of actual environment strings.
         */
        if ((ld_options = strdup(ld_options)) == NULL) {
                err = errno;
                eprintf(0, ERR_FATAL, MSG_INTL(MSG_SYS_ALLOC), strerror(err));
                return (1);
        }

        /*
         * Determine the number of options provided.
         */
        nargc = process_ldoptions(ld_options, NULL);

        /*
         * Allocate a new argv array big enough to hold the new options from
         * the environment string and the old argv options.
         */
        if ((nargv = malloc((nargc + *argcp + 1) * sizeof (char *))) == NULL) {
                err = errno;
                eprintf(0, ERR_FATAL, MSG_INTL(MSG_SYS_ALLOC), strerror(err));
                return (1);
        }

        /*
         * Initialize first element of new argv array to be the first element
         * of the old argv array (ie. calling programs name).  Then add the new
         * args obtained from the environment.
         */
        nargc = 0;
        nargv[nargc++] = (*argvp)[0];
        nargc += process_ldoptions(ld_options, &nargv[nargc]);

        /*
         * Now add the original argv array (skipping argv[0]) to the end of the
         * new argv array, and re-vector argc and argv to reference this new
         * array
         */
        for (count = 1; count < *argcp; count++, nargc++)
                nargv[nargc] = (*argvp)[count];

        nargv[nargc] = NULL;

        *argcp = nargc;
        *argvp = nargv;

        return (0);
}

/*
 * Check to see if there is a LD_ALTEXEC=<path to alternate ld> in the
 * environment.  If so, first null the environment variable out, and then
 * exec() the binary pointed to by the environment variable, passing the same
 * arguments as the originating process.  This mechanism permits using
 * alternate link-editors (debugging/developer copies) even in complex build
 * environments.
 */
static int
ld_altexec(char **argv, char **envp)
{
        char    *execstr;
        char    **str;
        int     err;

        for (str = envp; *str; str++) {
                if (strncmp(*str, MSG_ORIG(MSG_LD_ALTEXEC),
                    MSG_LD_ALTEXEC_SIZE) == 0) {
                        break;
                }
        }

        /*
         * If LD_ALTEXEC isn't set, return to continue executing the present
         * link-editor.
         */
        if (*str == 0)
                return (0);

        /*
         * Get a pointer to the actual string.  If it's a null entry, return.
         */
        execstr = strdup(*str + MSG_LD_ALTEXEC_SIZE);
        if (*execstr == '\0')
                return (0);

        /*
         * Null out the LD_ALTEXEC= environment entry.
         */
        (*str)[MSG_LD_ALTEXEC_SIZE] = '\0';

        /*
         * Set argv[0] to point to our new linker
         */
        argv[0] = execstr;

        /*
         * And attempt to execute it.
         */
        (void) execve(execstr, argv, envp);

        /*
         * If the exec() fails, return a failure indication.
         */
        err = errno;
        eprintf(0, ERR_FATAL, MSG_INTL(MSG_SYS_EXEC), execstr,
            strerror(err));
        return (1);
}

int
main(int argc, char **argv, char **envp)
{
        char            **oargv = argv;
        uchar_t         class, ldclass, checkclass;
        Half            mach;

        /*
         * Establish locale.
         */
        (void) setlocale(LC_MESSAGES, MSG_ORIG(MSG_STR_EMPTY));
        (void) textdomain(MSG_ORIG(MSG_SUNW_OST_SGS));

        /*
         * Execute an alternate linker if the LD_ALTEXEC environment variable is
         * set.  If a specified alternative could not be found, bail.
         */
        if (ld_altexec(argv, envp))
                return (1);

        /*
         * Check the LD_OPTIONS environment variable, and if present prepend
         * the arguments specified to the command line argument list.
         */
        if (prepend_ldoptions(&argc, &argv))
                return (1);

        /*
         * Examine the command arguments to determine:
         *      - object class
         *      - link-editor class
         *      - target machine
         */
        if (process_args(argc, argv, &class, &ldclass, &mach))
                return (1);

        /*
         * Unless a 32-bit link-editor was explicitly requested, try
         * to exec the 64-bit version.
         */
        if (ldclass != ELFCLASS32)
                checkclass = conv_check_native(oargv, envp);

        /*
         * If an attempt to exec the 64-bit link-editor fails:
         * -    Bail if the 64-bit linker was explicitly requested
         * -    Continue quietly if the 64-bit linker was not requested.
         *      This is undoubtedly due to hardware/kernel limitations,
         *      and therefore represents the best we can do. Note that
         *      the 32-bit linker is capable of linking anything the
         *      64-bit version is, subject to a 4GB limit on memory, and
         *      2GB object size.
         */
        if ((ldclass == ELFCLASS64) && (checkclass != ELFCLASS64)) {
                eprintf(0, ERR_FATAL, MSG_INTL(MSG_SYS_64));
                return (1);
        }

        /* Call the libld entry point for the specified ELFCLASS */
        if (class == ELFCLASS64)
                return (ld64_main(argc, argv, mach));
        else
                return (ld32_main(argc, argv, mach));
}

/*
 * We supply this function for the msg module
 */
const char *
_ld_msg(Msg mid)
{
        return (gettext(MSG_ORIG(mid)));
}