/*
* 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) 1989, 2010, Oracle and/or its affiliates. All rights reserved.
*/
/*
* Copyright (c) 1988 AT&T
* All Rights Reserved
*/
/*
* Copyright (c) 2018, Joyent, Inc.
*/
/*
* Utility functions
*/
#include <unistd.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/mman.h>
#include <errno.h>
#include <sgs.h>
#include <libintl.h>
#include <debug.h>
#include "msg.h"
#include "_libld.h"
/*
* Determine if a shared object definition structure already exists and if
* not create one. These definitions provide for recording information
* regarding shared objects that are still to be processed. Once processed
* shared objects are maintained on the ofl_sos list. The information
* recorded in this structure includes:
*
* o DT_USED requirements. In these cases definitions are added during
* mapfile processing of `-' entries (see map_dash()).
*
* o implicit NEEDED entries. As shared objects are processed from the
* command line so any of their dependencies are recorded in these
* structures for later processing (see process_dynamic()).
*
* o version requirements. Any explicit shared objects that have version
* dependencies on other objects have their version requirements recorded.
* In these cases definitions are added during mapfile processing of `-'
* entries (see map_dash()). Also, shared objects may have versioning
* requirements on their NEEDED entries. These cases are added during
* their version processing (see vers_need_process()).
*
* Note: Both process_dynamic() and vers_need_process() may generate the
* initial version definition structure because you can't rely on what
* section (.dynamic or .SUNW_version) may be processed first from any
* input file.
*/
Sdf_desc *
sdf_find(const char *name, APlist *alp)
{
Aliste idx;
Sdf_desc *sdf;
for (APLIST_TRAVERSE(alp, idx, sdf))
if (strcmp(name, sdf->sdf_name) == 0)
return (sdf);
return (NULL);
}
Sdf_desc *
sdf_add(const char *name, APlist **alpp)
{
Sdf_desc *sdf;
if ((sdf = libld_calloc(1, sizeof (Sdf_desc))) == NULL)
return ((Sdf_desc *)S_ERROR);
sdf->sdf_name = name;
if (aplist_append(alpp, sdf, AL_CNT_OFL_LIBS) == NULL)
return ((Sdf_desc *)S_ERROR);
return (sdf);
}
/*
* Add a string, separated by a colon, to an existing string. Typically used
* to maintain filter, rpath and audit names, of which there is normally only
* one string supplied anyway.
*/
char *
add_string(char *old, char *str)
{
char *new;
if (old) {
char *_str;
size_t len;
/*
* If an original string exists, make sure this new string
* doesn't get duplicated.
*/
if ((_str = strstr(old, str)) != NULL) {
if (((_str == old) ||
(*(_str - 1) == *(MSG_ORIG(MSG_STR_COLON)))) &&
(_str += strlen(str)) &&
((*_str == '\0') ||
(*_str == *(MSG_ORIG(MSG_STR_COLON)))))
return (old);
}
len = strlen(old) + strlen(str) + 2;
if ((new = libld_calloc(1, len)) == NULL)
return ((char *)S_ERROR);
(void) snprintf(new, len, MSG_ORIG(MSG_FMT_COLPATH), old, str);
} else {
if ((new = libld_malloc(strlen(str) + 1)) == NULL)
return ((char *)S_ERROR);
(void) strcpy(new, str);
}
return (new);
}
/*
* The GNU ld '-wrap=XXX' and '--wrap=XXX' options correspond to our
* '-z wrap=XXX'. When str2chr() does this conversion, we end up with
* the return character set to 'z' and optarg set to 'XXX'. This callback
* changes optarg to include the missing wrap= prefix.
*
* exit:
* Returns c on success, or '?' on error.
*/
static int
str2chr_wrap_cb(int c)
{
char *str;
size_t len = MSG_ARG_WRAP_SIZE + strlen(optarg) + 1;
if ((str = libld_malloc(len)) == NULL)
return ('?');
(void) snprintf(str, len, MSG_ORIG(MSG_FMT_STRCAT),
MSG_ORIG(MSG_ARG_WRAP), optarg);
optarg = str;
return (c);
}
/*
* Determine whether this string, possibly with an associated option, should
* be translated to an option character. If so, update the optind and optarg
* and optopt as described for short options in getopt(3c).
*
* entry:
* lml - Link map list for debug messages
* ndx - Starting optind for current item
* argc, argv - Command line arguments
* arg - Option to be examined
* c, opt - Option character (c) and corresponding long name (opt)
* optsz - 0 if option does not accept a value. If option does
* accept a value, strlen(opt), giving the offset to the
* value if the option and value are combined in one string.
* cbfunc - NULL, or pointer to function to call if a translation is
* successful.
*/
static int
str2chr(Lm_list *lml, int ndx, int argc, char **argv, char *arg, int c,
const char *opt, size_t optsz, int (*cbfunc)(int))
{
if (optsz == 0) {
/*
* Compare a single option (ie. there's no associated option
* argument).
*/
if (strcmp(arg, opt) == 0) {
DBG_CALL(Dbg_args_str2chr(lml, ndx, opt, c));
optind += 1;
optopt = c;
return (c);
}
} else if ((strcmp(arg, opt) == 0) ||
((arg[optsz] == '=') && strncmp(arg, opt, optsz) == 0)) {
/*
* Otherwise, compare the option name, which may be
* concatenated with the option argument.
*/
DBG_CALL(Dbg_args_str2chr(lml, ndx, opt, c));
if (arg[optsz] == '\0') {
/*
* Optarg is the next argument (white space separated).
* Make sure an optarg is available, and if not return
* a failure to prevent any fall-through to the generic
* getopt() processing.
*
* Since we'll be completely failing this option we
* don't want to update optopt with the translation,
* but also need to set it to _something_. Setting it
* to the '-' of the argument causes us to behave
* correctly.
*/
if ((++optind + 1) > argc) {
optopt = arg[0];
return ('?');
}
optarg = argv[optind];
optind++;
} else {
/*
* GNU option/option argument pairs can be represented
* with a "=" separator. If this is the case, remove
* the separator.
*/
optarg = &arg[optsz];
optind++;
if (*optarg == '=') {
if (*(++optarg) == '\0') {
optopt = arg[0];
return ('?');
}
}
}
if (cbfunc != NULL)
c = (*cbfunc)(c);
optopt = c;
return (c);
}
return (0);
}
/*
* Parse an individual option. The intent of this function is to determine if
* any known, non-Solaris options have been passed to ld(1). This condition
* can occur as a result of build configuration tools, because of users
* familiarity with other systems, or simply the users preferences. If a known
* non-Solaris option can be determined, translate that option into the Solaris
* counterpart.
*
* This function will probably never be a complete solution, as new, non-Solaris
* options are discovered, their translation will have to be added. Other
* non-Solaris options are incompatible with the Solaris link-editor, and will
* never be recognized. We support what we can.
*/
int
ld_getopt(Lm_list *lml, int ndx, int argc, char **argv)
{
int c;
if ((optind < argc) && argv[optind] && (argv[optind][0] == '-')) {
char *arg = &argv[optind][1];
switch (*arg) {
case 'r':
/* Translate -rpath <optarg> to -R <optarg> */
if ((c = str2chr(lml, ndx, argc, argv, arg, 'R',
MSG_ORIG(MSG_ARG_T_RPATH),
MSG_ARG_T_RPATH_SIZE, NULL)) != 0) {
return (c);
}
break;
case 's':
/* Translate -shared to -G */
if ((c = str2chr(lml, ndx, argc, argv, arg, 'G',
MSG_ORIG(MSG_ARG_T_SHARED), 0, NULL)) != 0) {
return (c);
/* Translate -soname <optarg> to -h <optarg> */
} else if ((c = str2chr(lml, ndx, argc, argv, arg, 'h',
MSG_ORIG(MSG_ARG_T_SONAME),
MSG_ARG_T_SONAME_SIZE, NULL)) != 0) {
return (c);
}
break;
case 'w':
/* Translate -wrap to -z wrap= */
if ((c = str2chr(lml, ndx, argc, argv, arg, 'z',
MSG_ORIG(MSG_ARG_T_WRAP) + 1,
MSG_ARG_T_WRAP_SIZE - 1, str2chr_wrap_cb)) != 0) {
return (c);
}
break;
case '(':
/*
* Translate -( to -z rescan-start
*/
if ((c = str2chr(lml, ndx, argc, argv,
arg, 'z', MSG_ORIG(MSG_ARG_T_OPAR), 0, NULL)) !=
0) {
optarg = (char *)MSG_ORIG(MSG_ARG_RESCAN_START);
return (c);
}
break;
case ')':
/*
* Translate -) to -z rescan-end
*/
if ((c = str2chr(lml, ndx, argc, argv,
arg, 'z', MSG_ORIG(MSG_ARG_T_CPAR), 0, NULL)) !=
0) {
optarg = (char *)MSG_ORIG(MSG_ARG_RESCAN_END);
return (c);
}
break;
case '-':
switch (*(arg + 1)) {
case 'a':
/*
* Translate --allow-multiple-definition to
* -zmuldefs
*/
if ((c = str2chr(lml, ndx, argc, argv, arg, 'z',
MSG_ORIG(MSG_ARG_T_MULDEFS), 0, NULL)) !=
0) {
optarg =
(char *)MSG_ORIG(MSG_ARG_MULDEFS);
return (c);
/*
* Translate --auxiliary <optarg> to
* -f <optarg>
*/
} else if ((c = str2chr(lml, argc, ndx, argv,
arg, 'f', MSG_ORIG(MSG_ARG_T_AUXFLTR),
MSG_ARG_T_AUXFLTR_SIZE, NULL)) != 0) {
return (c);
}
break;
case 'd':
/*
* Translate --dynamic-linker <optarg> to
* -I <optarg>
*/
if ((c = str2chr(lml, ndx, argc, argv, arg, 'I',
MSG_ORIG(MSG_ARG_T_INTERP),
MSG_ARG_T_INTERP_SIZE, NULL)) != 0) {
return (c);
}
break;
case 'e':
/* Translate --entry <optarg> to -e <optarg> */
if ((c = str2chr(lml, ndx, argc, argv, arg, 'e',
MSG_ORIG(MSG_ARG_T_ENTRY),
MSG_ARG_T_ENTRY_SIZE, NULL)) != 0) {
return (c);
}
/*
* Translate --end-group to -z rescan-end
*/
if ((c = str2chr(lml, ndx, argc, argv,
arg, 'z', MSG_ORIG(MSG_ARG_T_ENDGROUP),
0, NULL)) != 0) {
optarg = (char *)
MSG_ORIG(MSG_ARG_RESCAN_END);
return (c);
}
break;
case 'f':
/*
* Translate --fatal-warnings to
* -z fatal-warnings.
*/
if ((c = str2chr(lml, ndx, argc, argv, arg, 'z',
MSG_ORIG(MSG_ARG_T_FATWARN),
0, NULL)) != 0) {
optarg = (char *)
MSG_ORIG(MSG_ARG_FATWARN);
return (c);
}
/* Translate --filter <optarg> to -F <optarg> */
if ((c = str2chr(lml, ndx, argc, argv, arg, 'F',
MSG_ORIG(MSG_ARG_T_STDFLTR),
MSG_ARG_T_STDFLTR_SIZE, NULL)) != 0) {
return (c);
}
break;
case 'h':
/* Translate --help to -zhelp */
if ((c = str2chr(lml, ndx, argc, argv, arg, 'z',
MSG_ORIG(MSG_ARG_T_HELP), 0, NULL)) !=
0) {
optarg = (char *)MSG_ORIG(MSG_ARG_HELP);
return (c);
}
break;
case 'l':
/*
* Translate --library <optarg> to -l <optarg>
*/
if ((c = str2chr(lml, ndx, argc, argv, arg, 'l',
MSG_ORIG(MSG_ARG_T_LIBRARY),
MSG_ARG_T_LIBRARY_SIZE, NULL)) != 0) {
return (c);
/*
* Translate --library-path <optarg> to
* -L <optarg>
*/
} else if ((c = str2chr(lml, ndx, argc, argv,
arg, 'L', MSG_ORIG(MSG_ARG_T_LIBPATH),
MSG_ARG_T_LIBPATH_SIZE, NULL)) != 0) {
return (c);
}
break;
case 'n':
/*
* Translate --no-fatal-warnings to
* -z nofatal-warnings.
*/
if ((c = str2chr(lml, ndx, argc, argv, arg, 'z',
MSG_ORIG(MSG_ARG_T_NOFATWARN),
0, NULL)) != 0) {
optarg = (char *)
MSG_ORIG(MSG_ARG_NOFATWARN);
return (c);
}
/* Translate --no-undefined to -zdefs */
if ((c = str2chr(lml, ndx, argc, argv, arg, 'z',
MSG_ORIG(MSG_ARG_T_NOUNDEF), 0, NULL)) !=
0) {
optarg = (char *)MSG_ORIG(MSG_ARG_DEFS);
return (c);
/*
* Translate --no-whole-archive to
* -z defaultextract
*/
} else if ((c = str2chr(lml, ndx, argc, argv,
arg, 'z', MSG_ORIG(MSG_ARG_T_NOWHOLEARC),
0, NULL)) != 0) {
optarg =
(char *)MSG_ORIG(MSG_ARG_DFLEXTRT);
return (c);
}
break;
case 'o':
/* Translate --output <optarg> to -o <optarg> */
if ((c = str2chr(lml, ndx, argc, argv, arg, 'o',
MSG_ORIG(MSG_ARG_T_OUTPUT),
MSG_ARG_T_OUTPUT_SIZE, NULL)) != 0) {
return (c);
}
break;
case 'r':
/* Translate --relocatable to -r */
if ((c = str2chr(lml, ndx, argc, argv, arg, 'r',
MSG_ORIG(MSG_ARG_T_RELOCATABLE), 0,
NULL)) != 0) {
return (c);
}
break;
case 's':
/* Translate --strip-all to -s */
if ((c = str2chr(lml, ndx, argc, argv, arg, 's',
MSG_ORIG(MSG_ARG_T_STRIP), 0, NULL)) !=
0) {
return (c);
}
/*
* Translate --start-group to -z rescan-start
*/
if ((c = str2chr(lml, ndx, argc, argv,
arg, 'z', MSG_ORIG(MSG_ARG_T_STARTGROUP),
0, NULL)) != 0) {
optarg = (char *)
MSG_ORIG(MSG_ARG_RESCAN_START);
return (c);
}
break;
case 'u':
/*
* Translate --undefined <optarg> to
* -u <optarg>
*/
if ((c = str2chr(lml, ndx, argc, argv, arg, 'u',
MSG_ORIG(MSG_ARG_T_UNDEF),
MSG_ARG_T_UNDEF_SIZE, NULL)) != 0) {
return (c);
}
break;
case 'v':
/* Translate --version to -V */
if ((c = str2chr(lml, ndx, argc, argv, arg, 'V',
MSG_ORIG(MSG_ARG_T_VERSION), 0, NULL)) !=
0) {
return (c);
}
break;
case 'w':
/*
* Translate --whole-archive to -z alltextract
*/
if ((c = str2chr(lml, ndx, argc, argv,
arg, 'z', MSG_ORIG(MSG_ARG_T_WHOLEARC),
0, NULL)) != 0) {
optarg =
(char *)MSG_ORIG(MSG_ARG_ALLEXTRT);
return (c);
}
/*
* Translate --wrap to -z wrap=
*/
if ((c = str2chr(lml, ndx, argc, argv,
arg, 'z', MSG_ORIG(MSG_ARG_T_WRAP),
MSG_ARG_T_WRAP_SIZE, str2chr_wrap_cb)) !=
0) {
return (c);
}
break;
}
break;
}
}
if ((c = getopt(argc, argv, MSG_ORIG(MSG_STR_OPTIONS))) != -1) {
/*
* It is possible that a "-Wl," argument has been used to
* specify an option. This isn't advertized ld(1) syntax, but
* compiler drivers and configuration tools, have been known to
* pass this compiler option to ld(1). Strip off the "-Wl,"
* prefix and pass the option through.
*/
if ((c == 'W') && (strncmp(optarg,
MSG_ORIG(MSG_ARG_T_WL), MSG_ARG_T_WL_SIZE) == 0)) {
DBG_CALL(Dbg_args_Wldel(lml, ndx, optarg));
c = optarg[MSG_ARG_T_WL_SIZE];
optarg += MSG_ARG_T_WL_SIZE + 1;
}
}
return (c);
}
/*
* A compare routine for Isd_node AVL trees.
*/
int
isdavl_compare(const void *n1, const void *n2)
{
uint_t hash1, hash2;
const char *st1, *st2;
int rc;
hash1 = ((Isd_node *)n1)->isd_hash;
hash2 = ((Isd_node *)n2)->isd_hash;
if (hash1 > hash2)
return (1);
if (hash1 < hash2)
return (-1);
st1 = ((Isd_node *)n1)->isd_name;
st2 = ((Isd_node *)n2)->isd_name;
rc = strcmp(st1, st2);
if (rc > 0)
return (1);
if (rc < 0)
return (-1);
return (0);
}
/*
* Messaging support - funnel everything through dgettext().
*/
const char *
_libld_msg(Msg mid)
{
return (dgettext(MSG_ORIG(MSG_SUNW_OST_SGS), MSG_ORIG(mid)));
}
/*
* Determine whether a symbol name should be demangled.
*/
const char *
demangle(const char *name)
{
if (demangle_flag)
return (Elf_demangle_name(name));
else
return (name);
}
/*
* Compare a series of platform or machine hardware names.
*/
int
cap_names_match(Alist *alp1, Alist *alp2)
{
Capstr *capstr1;
Aliste idx1;
int match = 0;
Word nitems;
if ((nitems = alist_nitems(alp1)) != alist_nitems(alp2))
return (1);
for (ALIST_TRAVERSE(alp1, idx1, capstr1)) {
Capstr *capstr2;
Aliste idx2;
for (ALIST_TRAVERSE(alp2, idx2, capstr2)) {
if (strcmp(capstr1->cs_str, capstr2->cs_str))
continue;
match++;
break;
}
}
if (nitems == match)
return (0);
return (1);
}