ld/common/ld.c

	ld.c revision 5aefb6555731130ca4fd295960123d71f2d21fe8
/*
 * 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 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */
#pragma ident   "%Z%%M% %I% %E% SMI"


#include    <stdio.h>
#include    <stdlib.h>
#include    <unistd.h>
#include    <stdarg.h>
#include    <string.h>
#include    <errno.h>
#include    <fcntl.h>
#include    <libintl.h>
#include    <locale.h>
#include    <fcntl.h>
#include    "conv.h"
#include    "libld.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);

/*
 * Print a message to stdout
 */
/* VARARGS3 */
void
eprintf(Lm_list *lml, Error error, const char *format, ...)
{
    va_list         args;
    static const char   *strings[ERR_NUM] = { MSG_ORIG(MSG_STR_EMPTY) };

#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
    if (error > ERR_NONE) {
        if (error == ERR_WARNING) {
            if (strings[ERR_WARNING] == 0)
                strings[ERR_WARNING] = MSG_INTL(MSG_ERR_WARNING);
        } else if (error == ERR_FATAL) {
            if (strings[ERR_FATAL] == 0)
                strings[ERR_FATAL] = MSG_INTL(MSG_ERR_FATAL);
        } else if (error == ERR_ELF) {
            if (strings[ERR_ELF] == 0)
                strings[ERR_ELF] = MSG_INTL(MSG_ERR_ELF);
        }
        (void) fputs(MSG_ORIG(MSG_STR_LDDIAG), stderr);
    }
    (void) fputs(strings[error], stderr);

    va_start(args, format);
    (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);
    va_end(args);
}


/*
 * Determine whether we need the Elf32 or Elf64 libld.
 */
static int
determine_class(int argc, char ** argv)
{
    unsigned char   class = 0;
    int     c;

getmore:
    /*
     * Skip options.
     *
     * The only option we're interested in is -64, which enforces a 64-bit
     * link-edit.  This option is used when the only input to ld() is a
     * mapfile and a 64-bit object is required.  If we've already processed
     * a 32-bit object and we find -64, we have an error condition, but let
     * this fall through to libld to obtain the default error message.
     */
    opterr = 0;
    while ((c = getopt(argc, argv, MSG_ORIG(MSG_STR_OPTIONS))) != -1) {
        switch (c) {
            case '6':
                return (ELFCLASS64);
            default:
                break;
        }
    }

    /*
     * Otherwise look for the first ELF object to determine the class of
     * objects to operate on.
     */
    for (; optind < argc; optind++) {
        int     fd;
        unsigned char   ident[EI_NIDENT];

        /*
         * If we've already analyzed the initial object, continue.
         * We're only interested in skipping all files to check for
         * more options, and specifically if the -64 option is set.
         */
        if (class)
            continue;

        /*
         * 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 ((fd = open(argv[optind], O_RDONLY)) == -1) {
            int err = errno;

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

        /*
         * Determine the files ELF class.
         */
        if ((read(fd, ident, EI_NIDENT) == EI_NIDENT) &&
            (ident[EI_MAG0] == ELFMAG0) &&
            (ident[EI_MAG1] == ELFMAG1) &&
            (ident[EI_MAG2] == ELFMAG2) &&
            (ident[EI_MAG3] == ELFMAG3)) {
            if (((class = ident[EI_CLASS]) != ELFCLASS32) &&
                (class != ELFCLASS64))
                class = 0;
        }
        (void) close(fd);
    }

    /*
     * If we couldn't establish a class default to 32-bit.
     */
    if (class)
        return (class);

    return (ELFCLASS32);
}

/*
 * Prepend environment string as a series of options to the argv array.
 */
static int
prepend_ldoptions(char *ld_options, int *argcp, char ***argvp)
{
    int nargc;          /* new argc */
    char    **nargv;        /* new argv */
    char    *arg, *string;
    int count;

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

    nargc = 0;
    arg = string = ld_options;

    /*
     * Walk the environment string counting any arguments that are
     * separated by white space.
     */
    while (*string != '\0') {
        if (isspace(*string)) {
            nargc++;
            while (isspace(*string))
                string++;
            arg = string;
        } else
            string++;
    }
    if (arg != string)
        nargc++;

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

    /*
     * 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.
     */
    nargv[0] = (*argvp)[0];
    nargc = 0;
    arg = string = ld_options;
    while (*string != '\0') {
        if (isspace(*string)) {
            nargc++;
            *string++ = '\0';
            nargv[nargc] = arg;
            while (isspace(*string))
                string++;
            arg = string;
        } else
            string++;
    }
    if (arg != string) {
        nargc++;
        nargv[nargc] = arg;
    }

    /*
     * Now add the original argv array (skipping argv[0]) to the end of the
     * new argv array, and overwrite the old argc and argv.
     */
    for (count = 1; count < *argcp; count++) {
        nargc++;
        nargv[nargc] = (*argvp)[count];
    }
    *argcp = ++nargc;
    *argvp = nargv;

    return (1);
}

/*
 * 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.
 *
 * If LD_ALTEXEC= isn't set, or the exec() fails, silently return and allow the
 * current link-editor to execute.
 */
void
ld_altexec(char **argv, char **envp)
{
    char    *execstr;
    char    **str;
    for (str = envp; *str; str++) {
        if (strncmp(*str, MSG_ORIG(MSG_LD_ALTEXEC),
            MSG_LD_ALTEXEC_SIZE) == 0) {
            break;
        }
    }
    if (*str == 0)
        return;

    /*
     * get a pointer to the actual string - if it's
     * a null entry - we return.
     */
    execstr = strdup(*str + MSG_LD_ALTEXEC_SIZE);
    if (*execstr == '\0')
        return;
    /*
     * 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, silently fall through and continue execution of
     * the current link-editor.
     */
}

int
main(int argc, char **argv, char **envp)
{
    char        *ld_options, **oargv = argv;
    uchar_t     class;

    /*
     * XX64 -- Strip "-Wl," from the head of each argument.  This is to
     * accommodate awkwardness in passing ld arguments to gcc while
     * maintaining the structure of the OSNet build environment's Makefiles.
     */
    {
        int i;
        char *p;

        for (i = 0; i < argc; i++) {
            p = argv[i];
            while (*(p + 1) == 'W' && strncmp(p, "-Wl,-", 5) == 0)
                argv[i] = (p += 4);
        }
    }

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

    /*
     * Execute alternate linker if LD_ALTEXEC environment variable is set.
     */
    ld_altexec(argv, envp);

    /*
     * Check the LD_OPTIONS environment variable, and if present prepend
     * the arguments specified to the command line argument list.
     */
    if ((ld_options = getenv(MSG_ORIG(MSG_LD_OPTIONS))) != NULL) {
        /*
         * Prevent modification of actual environment strings.
         */
        if (((ld_options = strdup(ld_options)) == NULL) ||
            (prepend_ldoptions(ld_options, &argc, &argv) == 0))
            return (1);
    }

    /*
     * Locate the first input file and from this file determine the class of
     * objects we're going to process.  If the class is ELFCLASS64 we'll
     * call the ELF64 class of interfaces, else the ELF32 class.  Note that
     * if the option -64 is encountered a 64-bit link is explicitly being
     * requested.
     */
    if ((class = determine_class(argc, argv)) == 0)
        return (1);

    /*
     * If we're on a 64-bit kernel, try to exec a full 64-bit version of ld.
     */
    if (class == ELFCLASS64)
        conv_check_native(oargv, envp);

    /*
     * Reset the getopt(3c) error message flag, and call the generic entry
     * point using the appropriate class.
     */
    optind = opterr = 1;
    if (class == ELFCLASS64)
        return (ld64_main(argc, argv));
    else
        return (ld32_main(argc, argv));
}

/*
 * Exported interfaces required by our dependencies.  libld and friends bind to
 * the different implementations of these provided by either ld or ld.so.1.
 */
const char *
_ld_msg(Msg mid)
{
    return (gettext(MSG_ORIG(mid)));
}