args.c revision f3324781c875e2f9865c291e43f86ee710b0c145
/*
* 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
* 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) 1988 AT&T
* All Rights Reserved
*
* Copyright 2007 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* Publicly available flags are defined in ld(1). The following flags are
* private, and may be removed at any time.
*
* OPTION MEANING
*
* -z dtrace=symbol assigns symbol to PT_SUNWDTRACE segment,
* providing scratch area for dtrace processing.
*
* -z noreloc suppress relocation processing. This provides
* a mechanism for validating kernel module symbol
* resolution that would normally incur fatal
* relocation errors.
*
* -z rtldinfo=symbol assigns symbol to SUNW_RTLDINF dynamic tag,
* providing pre-initialization specific routines
* for TLS initialization.
*
* -z nointerp suppress the addition of an interpreter
* section. This is used to generate the kernel,
* but makes no sense to be used by anyone else.
*/
#include <stdio.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>
#include <elf.h>
#include <unistd.h>
#include <debug.h>
#include "msg.h"
#include "_libld.h"
/*
* Define a set of local argument flags, the settings of these will be
* verified in check_flags() and lead to the appropriate output file flags
* being initialized.
*/
typedef enum {
SET_UNKNOWN = -1,
SET_FALSE = 0,
SET_TRUE = 1
} Setstate;
/*
* ztflag's state is set by pointing it to the matching string:
* text | textoff | textwarn
*/
static const char *ztflag = 0;
/*
* Print usage message to stderr - 2 modes, summary message only,
* and full usage message.
*/
static void
{
return;
}
/*
* Checks the command line option flags for consistency.
*/
static uintptr_t
{
}
if (rflag) {
if (dflag == SET_UNKNOWN)
}
}
if (zinflag)
if (sflag)
if (Blflag)
if (Beflag)
}
}
/*
* Set -Bdynamic on by default, setting is rechecked as input
* files are processed.
*/
if (aflag) {
}
if (bflag)
}
}
/*
* If the use of default library searching has been suppressed
* but no runpaths have been provided we're going to have a hard
* job running this object.
*/
/*
* By default, text relocation warnings are given when building
* an executable unless the -b flag is specified. This option
* implies that unclean text can be created, so no warnings are
* generated unless specifically asked for.
*/
/*
* Create a dynamic object. -Bdirect indicates that all
* references should be bound directly. This also
* enables lazyloading. Individual symbols can be
* bound directly (or not) using mapfiles and the
* DIRECT (NODIRECT) qualifier. With this capability,
* each syminfo entry is tagged SYMINFO_FLG_DIRECTBIND.
* Prior to this per-symbol direct binding, runtime
* direct binding was controlled via the DF_1_DIRECT
* flag. This flag affected all references from the
* object. -Bdirect continues to set this flag, and
* thus provides a means of taking a newly built
* direct binding object back to older systems.
*
* NOTE, any use of per-symbol NODIRECT bindings, or
* -znodirect, will disable the creation of the
* DF_1_DIRECT flag. Older runtime linkers do not
* have the capability to do per-symbol direct bindings.
*/
}
/*
* -Bnodirect disables directly binding to any symbols
* exported from the object being created. Individual
* references to external objects can still be affected
* by -zdirect or mapfile DIRECT directives.
*/
ofl->ofl_flags1 |=
}
}
/*
* Dynamically linked executable.
*/
if (Bsflag) {
}
if (ofl->ofl_soname) {
}
if (Btflag) {
}
if (ofl->ofl_filtees) {
} else {
}
}
} else if (!rflag) {
/*
* Shared library.
*/
/*
* By default, print text relocation errors for
* executables but *not* for shared objects.
*/
if (ztflag == 0)
if (Bsflag) {
/*
* -Bsymbolic, and -Bnodirect make no sense.
*/
}
}
if (Btflag) {
ofl->ofl_dtflags_1 |=
(DF_1_TRANS | DF_1_DIRECT);
}
} else {
/*
* Dynamic relocatable object
*/
/*
* By default we print relocation errors for
* executables but *not* for a shared object
*/
if (ztflag == 0)
}
} else {
if (bflag) {
}
if (ofl->ofl_soname) {
}
if (ofl->ofl_depaudit) {
}
}
if (ofl->ofl_config) {
}
if (ofl->ofl_filtees) {
} else {
}
}
if (ztflag) {
}
if (Gflag) {
}
}
if (rflag) {
/*
* We can only strip the symbol table and string table
* if no output relocations will refer to them
*/
if (sflag) {
}
if (ztflag == 0)
if (ofl->ofl_interp) {
}
} else {
/*
* Static executable.
*/
}
}
/*
* If the user didn't supply an output file name supply a default.
*/
/*
* We set the entrance criteria after all input argument processing as
* it is only at this point we're sure what the output image will be
* (static or dynamic).
*/
return (S_ERROR);
/*
* Does the host currently running the linker have the same
* byte order as the target for which the object is being produced?
* If not, set FLG_OF1_ENCDIFF so relocation code will know
* to check.
*/
if (_elf_sys_encoding() != M_DATA)
/*
* Initialize string tables. Symbol definitions within mapfiles can
* result in the creation of input sections.
*/
return (S_ERROR);
/*
* Process any mapfiles after establishing the entrance criteria as
*/
const char *name;
return (S_ERROR);
return (S_ERROR);
}
/*
* If a mapfile has been used to define a single symbolic scope of
* interfaces, -Bsymbolic is established. This global setting goes
* beyond individual symbol protection, and ensures all relocations
* (even those that reference section symbols) are processed within
* the object being built.
*/
}
/*
* If -zloadfltr is set, verify that filtering is in effect. Filters
* are either established from the command line, and affect the whole
* object, or are set on a per-symbol basis from a mapfile.
*/
if (zlflag) {
}
}
/*
* Check that we have something to work with. This check is carried out
* after mapfile processing as its possible a mapfile is being used to
* define symbols, in which case it would be sufficient to build the
* output file purely from the mapfile.
*/
else {
return (S_ERROR);
}
}
return (1);
}
/*
* Decompose the string pointed by optarg into argv[][] so that argv[][] can be
* used as an argument to getopt().
*
* If the second argument 'error' is not 0, then this is called from the first
* pass. Else this is called from the second pass.
*/
static uintptr_t
{
/*
* The argument being examined is either:
* ld32= or
* ld64=
*/
#if defined(_LP64)
return (0);
#else
return (0);
#endif
/*
* Count the number of arguments.
*/
while (*p0) {
/*
* Pointing at non-separator character.
*/
if (*p0 != ',') {
argc++;
p0++;
continue;
}
/*
* Pointing at a separator character.
*/
if (*p0 == ',') {
while (*p0 == ',')
p0++;
continue;
}
}
if (argc == 0)
return (0);
/*
* Allocate argument vector.
*/
return (S_ERROR);
return (S_ERROR);
while (*p0) {
char *p;
/*
* Pointing at the beginning of non-separator character string.
*/
if (*p0 != ',') {
p = p0;
p0++;
if (*p0) {
*p0 = '\0';
p0++;
}
continue;
}
/*
* Pointing at the beginining of separator character string.
*/
if (*p0 == ',') {
while (*p0 == ',')
p0++;
continue;
}
}
optind = 0;
/*
* Dispatch to pass1 or pass2
*/
if (error)
else
return (S_ERROR);
return (argc);
}
/*
* Parsing options pass1 for process_flags().
*/
static uintptr_t
{
int c;
switch (c) {
case '6': /* Processed by ld to */
/*
* -64 is processed by ld to determine the output class.
* Here we sanity check the option incase some other
* -6* option is mistakenly passed to us.
*/
if (optarg[0] != '4') {
}
continue;
case 'a':
break;
case 'b':
/*
* This is a hack, and may be undone later.
* The -b option is only used to build the Unix
* kernel and its related kernel-mode modules.
* We do not want those files to get a .SUNW_ldynsym
* section. At least for now, the kernel makes no
* use of .SUNW_ldynsym, and we do not want to use
* the space to hold it. Therefore, we overload
* the use of -b to also imply -znoldynsym.
*/
break;
case 'c':
if (ofl->ofl_config)
else
break;
case 'C':
demangle_flag = 1;
break;
case 'd':
if (dflag != SET_UNKNOWN)
else
if (dflag != SET_UNKNOWN)
else
} else {
}
break;
case 'e':
else
break;
case 'f':
if (ofl->ofl_filtees &&
} else {
if ((ofl->ofl_filtees =
(const char *)S_ERROR)
return (S_ERROR);
}
break;
case 'F':
if (ofl->ofl_filtees &&
} else {
if ((ofl->ofl_filtees =
(const char *)S_ERROR)
return (S_ERROR);
}
break;
case 'h':
if (ofl->ofl_soname)
else
break;
case 'i':
break;
case 'I':
if (ofl->ofl_interp)
else
break;
case 'l':
/*
* For now, count any library as a shared object. This
* is used to size the internal symbol cache. This
* value is recalculated later on actual file processing
* to get an accurate shared object count.
*/
ofl->ofl_soscnt++;
break;
case 'm':
break;
case 'o':
else
break;
case 'p':
/*
* Multiple instances of this option may occur. Each
* additional instance is effectively concatenated to
* the previous separated by a colon.
*/
if (*optarg != '\0') {
return (S_ERROR);
}
break;
case 'P':
/*
* Multiple instances of this option may occur. Each
* additional instance is effectively concatenated to
* the previous separated by a colon.
*/
if (*optarg != '\0') {
if ((ofl->ofl_depaudit =
return (S_ERROR);
}
break;
case 'r':
break;
case 'R':
/*
* Multiple instances of this option may occur. Each
* additional instance is effectively concatenated to
* the previous separated by a colon.
*/
if (*optarg != '\0') {
return (S_ERROR);
}
break;
case 's':
break;
case 't':
break;
case 'u':
break;
case 'z':
/*
* For specific help, print our usage message and exit
* immediately to ensure a 0 return code.
*/
MSG_ARG_HELP_SIZE) == 0) {
usage_mesg(1);
exit(0);
}
/*
* For some options set a flag - further consistancy
* checks will be carried out in check_flags().
*/
MSG_ARG_LD32_SIZE) == 0) ||
MSG_ARG_LD64_SIZE) == 0)) {
return (S_ERROR);
} else if (
if (zdflag != SET_UNKNOWN)
else
MSG_ORIG(MSG_ARG_NODEFS)) == 0) {
if (zdflag != SET_UNKNOWN)
else
MSG_ORIG(MSG_ARG_TEXT)) == 0) {
if (ztflag &&
ztflag);
}
MSG_ORIG(MSG_ARG_TEXTOFF)) == 0) {
if (ztflag &&
ztflag);
}
MSG_ORIG(MSG_ARG_TEXTWARN)) == 0) {
if (ztflag &&
ztflag);
}
/*
* For other options simply set the ofl flags directly.
*/
MSG_ORIG(MSG_ARG_RESCAN)) == 0) {
MSG_ORIG(MSG_ARG_ABSEXEC)) == 0) {
MSG_ORIG(MSG_ARG_LOADFLTR)) == 0) {
MSG_ORIG(MSG_ARG_NORELOC)) == 0) {
MSG_ORIG(MSG_ARG_NOVERSION)) == 0) {
MSG_ORIG(MSG_ARG_MULDEFS)) == 0) {
MSG_ORIG(MSG_ARG_REDLOCSYM)) == 0) {
MSG_ORIG(MSG_ARG_INITFIRST)) == 0) {
MSG_ORIG(MSG_ARG_NODELETE)) == 0) {
MSG_ORIG(MSG_ARG_NOPARTIAL)) == 0) {
MSG_ORIG(MSG_ARG_NOOPEN)) == 0) {
MSG_ORIG(MSG_ARG_NOW)) == 0) {
MSG_ORIG(MSG_ARG_ORIGIN)) == 0) {
MSG_ORIG(MSG_ARG_NODEFAULTLIB)) == 0) {
MSG_ORIG(MSG_ARG_NODUMP)) == 0) {
MSG_ORIG(MSG_ARG_ENDFILTEE)) == 0) {
MSG_ORIG(MSG_ARG_VERBOSE)) == 0) {
MSG_ORIG(MSG_ARG_COMBRELOC)) == 0) {
MSG_ORIG(MSG_ARG_NOCOMPSTRTAB)) == 0) {
MSG_ORIG(MSG_ARG_NOINTERP)) == 0) {
MSG_ORIG(MSG_ARG_INTERPOSE)) == 0) {
MSG_ORIG(MSG_ARG_IGNORE)) == 0) {
MSG_ORIG(MSG_ARG_RELAXRELOC)) == 0) {
MSG_ORIG(MSG_ARG_NOLDYNSYM)) == 0) {
MSG_ORIG(MSG_ARG_GLOBAUDIT)) == 0) {
/*
* The following options just need validation as they
* are interpreted on the second pass through the
* command line arguments.
*/
} else if (
}
break;
case 'D':
/*
* If we have not yet read any input files go ahead
* and process any debugging options (this allows any
* argument processing, entrance criteria and library
* initialization to be displayed). Otherwise, if an
* input file has been seen, skip interpretation until
* process_files (this allows debugging to be turned
* on and off around individual groups of files).
*/
if (ofl->ofl_objscnt == 0) {
return (S_ERROR);
}
break;
case 'B':
} else
MSG_ORIG(MSG_ARG_NODIRECT)) == 0) {
} else
MSG_ORIG(MSG_STR_SYMBOLIC)) == 0)
MSG_ORIG(MSG_ARG_TRANSLATOR)) == 0)
MSG_ORIG(MSG_STR_ELIMINATE)) == 0)
}
break;
case 'G':
break;
case 'L':
break;
case 'M':
return (S_ERROR);
break;
case 'N':
break;
case 'Q':
if (Qflag != SET_UNKNOWN)
else
if (Qflag != SET_UNKNOWN)
else
} else {
}
break;
case 'S':
return (S_ERROR);
break;
case 'V':
if (!Vflag)
break;
case 'Y':
if (Llibdir)
else
if (Ulibdir)
else
if (Plibpath)
else
} else {
}
break;
case '?':
(*error)++;
break;
default:
break;
}
}
return (1);
}
/*
* Parsing options pass2 for
*/
static uintptr_t
{
int c;
switch (c) {
case 'l':
return (S_ERROR);
break;
case 'B':
MSG_ORIG(MSG_STR_LD_DYNAMIC)) == 0) {
else {
}
MSG_ORIG(MSG_ARG_STATIC)) == 0)
break;
case 'L':
return (S_ERROR);
break;
case 'N':
/*
* Record DT_NEEDED string
*/
}
if (((ifl =
return (S_ERROR);
break;
case 'D':
break;
case 'u':
return (S_ERROR);
break;
case 'z':
MSG_ARG_LD32_SIZE) == 0) ||
MSG_ARG_LD64_SIZE) == 0)) {
return (S_ERROR);
MSG_ORIG(MSG_ARG_ALLEXTRT)) == 0) {
MSG_ORIG(MSG_ARG_WEAKEXT)) == 0) {
MSG_ORIG(MSG_ARG_DFLEXTRT)) == 0) {
ofl->ofl_flags1 &=
~(FLG_OF1_ALLEXRT |
MSG_ORIG(MSG_ARG_DIRECT)) == 0) {
MSG_ORIG(MSG_ARG_NODIRECT)) == 0) {
MSG_ORIG(MSG_ARG_IGNORE)) == 0) {
MSG_ORIG(MSG_ARG_RECORD)) == 0) {
MSG_ORIG(MSG_ARG_LAZYLOAD)) == 0) {
MSG_ORIG(MSG_ARG_NOLAZYLOAD)) == 0) {
MSG_ORIG(MSG_ARG_GROUPPERM)) == 0) {
MSG_ORIG(MSG_ARG_NOGROUPPERM)) == 0) {
MSG_ARG_INITARRAY_SIZE) == 0) {
MSG_STR_COMMAND)) ==
sdp) == 0))
return (S_ERROR);
MSG_ARG_FINIARRAY_SIZE) == 0) {
MSG_STR_COMMAND)) ==
sdp) == 0))
return (S_ERROR);
MSG_ARG_PREINITARRAY_SIZE) == 0) {
MSG_STR_COMMAND)) ==
sdp) == 0))
return (S_ERROR);
MSG_ARG_RTLDINFO_SIZE) == 0) {
MSG_STR_COMMAND)) ==
sdp) == 0))
return (S_ERROR);
MSG_ARG_DTRACE_SIZE) == 0) {
MSG_STR_COMMAND)) ==
return (S_ERROR);
}
default:
break;
}
}
return (1);
}
/*
*
* Pass 1 -- process_flags: collects all options and sets flags
*/
static uintptr_t
{
/*
* 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.
*/
return (S_ERROR);
continue;
}
break;
ofl->ofl_objscnt++;
}
return (1);
}
{
int error = 0; /* Collect all argument errors before exit */
if (argc < 2) {
return (S_ERROR);
}
/*
* Option handling
*/
return (S_ERROR);
/*
* Having parsed everything, did we have any errors.
*/
if (error) {
return (S_ERROR);
}
}
/*
* Pass 2 -- process_files: skips the flags collected in pass 1 and processes
* files.
*/
static uintptr_t
{
int fd;
char *path;
/*
* 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.
*/
return (S_ERROR);
continue;
}
break;
continue;
}
if (fd != -1)
return (S_ERROR);
/*
* Check for mismatched input.
*/
return (1);
}
}
return (1);
}
{
/*
* Process command line files (taking into account any applicable
* preseeding flags). Return if any fatal errors have occurred.
*/
return (S_ERROR);
return (1);
/*
* Now that all command line files have been processed see if there are
* any additional `needed' shared object dependencies.
*/
return (S_ERROR);
/*
* If rescanning archives is enabled, do so now to determine whether
* there might still be members extracted to satisfy references from any
* explicit objects. Continue until no new objects are extracted. Note
* that this pass is carried out *after* processing any implicit objects
* (above) as they may already have resolved any undefined references
* from any explicit dependencies.
*/
(FLG_OF1_RESCAN | FLG_OF1_EXTRACT)) {
int fd;
/*
* If this archive was processed with -z allextract,
* then all members have already been extracted.
*/
continue;
/*
* Reopen the file.
*/
return (S_ERROR);
}
/*
* Reestablish any archive specific command line flags.
*/
return (S_ERROR);
return (1);
}
}
/*
* If debugging, provide statistics on each archives extraction, or flag
* any archive that has provided no members. Note that this could be a
* nice place to free up much of the archive infrastructure, as we've
* extracted any members we need. However, as we presently don't free
* anything under ld(1) there's not much point in proceeding further.
*/
/*
* If any version definitions have been established, either via input
* from a mapfile or from the input relocatable objects, make sure any
* version dependencies are satisfied, and version symbols created.
*/
return (S_ERROR);
/*
* If segment ordering was specified (using mapfile) verify things
* are ok.
*/
return (1);
}
{
stflags = 0;
else
return (S_ERROR);
return (0);
}