syms.c revision dd94ecef63e3f299c1915ec8109e20b0c2bc0457
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (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 2005 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* Symbol table management routines
*/
#include <stdio.h>
#include <string.h>
#include "debug.h"
#include "msg.h"
#include "_libld.h"
/*
* AVL tree comparator function:
*
* The primary key is the 'sa_hashval' with a secondary
* key of the symbol name itself.
*/
int
{
int res;
if (res < 0)
return (-1);
if (res > 0)
return (1);
/*
* Hash is equal - now compare name
*/
if (res == 0)
return (0);
if (res > 0)
return (1);
return (-1);
}
/*
* Focal point for verifying symbol names.
*/
const char *
{
const char *regname;
if (name) {
return (0);
}
return (0);
}
}
/*
* Determine if we're dealing with a register and if so validate it.
* If it's a scratch register, a fabricated name will be returned.
*/
return (0);
}
if (regname)
return (regname);
/*
* If this isn't a register, but we have a global symbol with a null
* name, we're not going to be able to hash this, search for it, or
* do anything interesting. However, we've been accepting a symbol of
* this kind for ages now, so give the user a warning (rather than a
* fatal error), just in case this instance exists somewhere in the
* world and hasn't, as yet, been a problem.
*/
}
}
/*
* Shared objects can be built that define specific symbols that can not be
* directly bound to. These objects have a syminfo section (and an associated
* DF_1_NODIRECT dynamic flags entry). Scan this table looking for symbols
* that can't be bound to directly, and if this files symbol is presently
* referenced, mark it so that we don't directly bind to it.
*/
{
char *strdata;
/*
* Get the syminfo data, and determine the number of entries.
*/
/*
* Get the associated symbol table.
*/
/*
* Get the string table associated with the symbol table.
*/
/*
* Traverse the syminfo data for symbols that can't be directly
* bound to.
*/
char *str;
continue;
continue;
}
}
return (0);
}
/*
* If, during symbol processing, it is necessary to update a local symbols
* contents before we have generated the symbol tables in the output image,
* create a new symbol structure and copy the original symbol contents. While
* we are processing the input files, their local symbols are part of the
* read-only mapped image. Commonly, these symbols are copied to the new output
* file image and then updated to reflect their new address and any change in
* attributes. However, sometimes during relocation counting, it is necessary
* to adjust the symbols information. This routine provides for the generation
* of a new symbol image so that this update can be performed.
* All global symbols are copied to an internal symbol table to improve locality
* of reference and hence performance, and thus this copying is not necessary.
*/
{
return (S_ERROR);
}
return (1);
}
/*
* Finds a given name in the link editors internal symbol table. If no
* hash value is specified it is calculated. A pointer to the located
* Sym_desc entry is returned, or NULL if the symbol is not found.
*/
Sym_desc *
{
if (hash == SYM_NOHASH)
/* LINTED */
/*
* Perform search for symbol in AVL tree. Note that the 'where' field
* is passed in from the caller. If a 'where' is present, it can be
* used in subsequent 'sym_enter()' calls if required.
*/
/*
* If symbol was not found in the avl tree, return null to show that.
*/
if (sav == 0)
return (0);
/*
* Return symbol found.
*/
return (sav->sav_symdesc);
}
/*
* Enter a new symbol into the link editors internal symbol table.
* If the symbol is from an input file, information regarding the input file
* and input section is also recorded. Otherwise (file == NULL) the symbol
* has been internally generated (ie. _etext, _edata, etc.).
*/
Sym_desc *
{
char *_name;
/*
* Establish the file type.
*/
if (ifl)
else
ofl->ofl_entercnt++;
/*
* Allocate a Sym Descriptor, Auxiliary Descriptor, and a Sym AVLNode -
* contiguously.
*/
sizeof (Sym_aux), 1)) == 0)
/*
* Copy the symbol table entry from the input file into the internal
* entry and have the symbol descriptor use it.
*/
/*
* Enter Symbol in AVL tree.
*/
if (where == 0) {
/* LINTED */
/*
* If a previous sym_find() hasn't initialized 'where' do it
* now.
*/
}
/*
* Record the section index. This is possible because the
* `ifl_isdesc' table is filled before we start symbol processing.
*/
else {
/*
* If this symbol is from a relocatable object, make sure that
* it is still associated with a section. For example, an
* unknown section type (SHT_NULL) would have been rejected on
* input with a warning. Here, we make the use of the symbol
* fatal. A symbol descriptor is still returned, so that the
* caller can continue processing all symbols, and hence flush
* out as many error conditions as possible.
*/
return (sdp);
}
}
/*
* Mark any COMMON symbols as 'tentative'.
*/
/*
* Establish the symbols reference & visibility.
*/
/*
* Under -Bnodirect, all exported interfaces are tagged to
* prevent direct binding to them.
*/
} else {
/*
* Record the binding file for this symbol in the sa_bindto
* field. If this symbol is ever overridden by a REF_REL_NEED
* definition, sa_bindto is used when building a 'translator'.
*/
/*
* If this is a protected symbol, mark it.
*/
/*
* Mask out any visibility info from a DYN symbol.
*/
/*
* If the new symbol is from a shared library and it
* is associated with a SHT_NOBITS section then this
* symbol originated from a tentative symbol.
*/
}
/*
* Reclassify any SHN_SUNW_IGNORE symbols to SHN_UNDEF so as to
* simplify fucture processing.
*/
if (shndx == SHN_SUNW_IGNORE) {
}
/*
* If this is an undefined, or common symbol from a relocatable object
* determine whether it is a global or weak reference (see build_osym(),
* where REF_DYN_NEED definitions are returned back to undefines).
*/
/*
* Record the input filename on the referenced or defined files list
* for possible later diagnostics. The `sa_rfile' pointer contains the
* name of the file that first referenced this symbol and is used to
* generate undefined symbol diagnostics (refer to sym_undef_entry()).
* Note that this entry can be overridden if a reference from a
* relocatable object is found after a reference from a shared object
* (refer to sym_override()).
* The `sa_dfiles' list is used to maintain the list of files that
* define the same symbol. This list can be used for two reasons:
*
* o To save the first definition of a symbol that is not available
* for this link-edit.
*
* o To save all definitions of a symbol when the -m option is in
* effect. This is optional as it is used to list multiple
* (interposed) definitions of a symbol (refer to ldmap_out()),
* and can be quite expensive.
*/
} else {
/*
* A symbol is determined to be unavailable if it
* belongs to a version of a shared object that this
* user does not wish to use, or if it belongs to an
* implicit shared object.
*/
if (ifl->ifl_vercnt) {
}
}
/*
* If this symbol has been obtained from a versioned
* input relocatable object then the new symbol must be
* promoted to the versioning of the output file.
*/
if (ifl->ifl_versym)
}
((sdflags & FLG_SY_SPECSEC) == 0))
}
else
return (sdp);
}
/*
* Add a special symbol to the symbol table. Takes special symbol name with
* and without underscores. This routine is called, after all other symbol
* resolution has completed, to generate a reserved absolute symbol (the
* underscore version). Special symbols are updated with the appropriate
* values in update_osym(). If the user has already defined this symbol
* issue a warning and leave the symbol as is. If the non-underscore symbol
* is referenced then turn it into a weak alias of the underscored symbol.
*
* If this is a global symbol, and it hasn't explicitly been defined as being
* directly bound to, indicate that it can't be directly bound to.
* Historically, most special symbols only have meaning to the object in which
* they exist, however, they've always been global. To insure compatibility
* with any unexpected use presently in effect, insure these symbols don't get
* directly bound to. Note, that establishing this state here isn't sufficient
* to create a syminfo table, only if a syminfo table is being created by some
* other symbol directives will the nodirect binding be recorded. This insures
* we don't create syminfo sections for all objects we create, as this might add
* unnecessary bloat to users who haven't explicitly requested extra symbol
* information.
*/
static uintptr_t
{
/* LINTED */
/*
* If the underscore symbol exists and is undefined, or was
* defined in a shared library, convert it to a local symbol.
* Otherwise leave it as is and warn the user.
*/
/* LINTED */
/*
* If a user hasn't specifically indicated the scope of
* this symbol be made local then leave it as global
* (ie. prevent automatic scoping).
*/
(flags1 & FLG_SY1_GLOB)) {
}
/*
* If the reference originated from a mapfile insure
* we mark the symbol as used.
*/
} else
} else {
/*
* If the symbol does not exist create it.
*/
return (S_ERROR);
return (S_ERROR);
/* LINTED */
if (flags1 & FLG_SY1_GLOB)
}
/*
* If the non-underscore symbol exists and is undefined
* convert it to be a local. If the underscore has
* sa_symspec set (ie. it was created above) then simulate this
* as a weak alias.
*/
/* LINTED */
} else
bind = STB_GLOBAL;
/*
* If a user hasn't specifically indicated the scope of
* this symbol be made local then leave it as global
* (ie. prevent automatic scoping).
*/
(flags1 & FLG_SY1_GLOB)) {
}
/*
* If the reference originated from a mapfile insure
* we mark the symbol as used.
*/
}
return (1);
}
/*
* Print undefined symbols.
*/
void
{
undef_title = FALSE;
}
/*
* Undefined symbols can fall into one of four types:
*
* o the symbol is really undefined (SHN_UNDEF).
*
* o versioning has been enabled, however this symbol has not been assigned
* to one of the defined versions.
*
* o the symbol has been defined by an implicitly supplied library, ie. one
* which was encounted because it was NEEDED by another library, rather
* than from a command line supplied library which would become the only
* dependency of the output file being produced.
*
* o the symbol has been defined by a version of a shared object that is
* not permitted for this link-edit.
*
* In all cases the file who made the first reference to this symbol will have
* been recorded via the `sa_rfile' pointer.
*/
typedef enum {
} Type;
MSG_SYM_UND_UNDEF, /* MSG_INTL(MSG_SYM_UND_UNDEF) */
MSG_SYM_UND_NOVER, /* MSG_INTL(MSG_SYM_UND_NOVER) */
MSG_SYM_UND_IMPL, /* MSG_INTL(MSG_SYM_UND_IMPL) */
MSG_SYM_UND_NOTA, /* MSG_INTL(MSG_SYM_UND_NOTA) */
MSG_SYM_UND_BNDLOCAL /* MSG_INTL(MSG_SYM_UND_BNDLOCAL) */
};
void
{
if (undef_title)
switch (type) {
case UNDEF:
case BNDLOCAL:
break;
case NOVERSION:
break;
case IMPLICIT:
break;
case NOTAVAIL:
break;
default:
return;
}
}
/*
* At this point all symbol input processing has been completed, therefore
* complete the symbol table entries by generating any necessary internal
* symbols.
*/
{
if (!(flags & FLG_OF_RELOBJ)) {
return (S_ERROR);
return (S_ERROR);
return (S_ERROR);
return (S_ERROR);
return (S_ERROR);
/*
* Historically we've always produced a _DYNAMIC symbol, even
* for static executables (in which case its value will be 0).
*/
return (S_ERROR);
return (S_ERROR);
return (S_ERROR);
}
return (1);
}
/*
* This routine checks to see if a symbols visibility needs to be reduced to
* either SYMBOLIC or LOCAL. This routine can be called from either
* reloc_init() or sym_validate().
*/
void
{
/*
* If scoping is enabled, reduce any nonversioned global
* symbols (any symbol that has been processed for relocations
* will have already had this same reduction test applied).
* Indicate that the symbol has been reduced as it may be
* necessary to print these symbols later.
*/
if (((oflags & FLG_OF_AUTOLCL) ||
(oflags1 & FLG_OF1_AUTOELM)) &&
if (ofl->ofl_flags1 &
}
/*
* If '-Bsymbolic' is in effect - then bind all global symbols
* 'symbolically' and assign the STV_PROTECTED visibility
* attribute.
*/
if ((oflags & FLG_OF_SYMBOLIC) &&
}
}
/*
* Check to see if the symbol visibility needs to be adjusted due to any
* STV_* symbol attributes being set.
*
* STV_PROTECTED == symbolic binding
* STV_INTERNAL == reduce to local
* STV_HIDDEN == reduce to local
*
* Note, UNDEF symbols can be assigned a visibility, thus the refencing
* code can be dependent on this visibility. Here, by only ignoring
* REF_DYN_SEEN symbol definitions we can be assigning a visibility to
* REF_DYN_NEED. If the protected, or local assignment is made to
* a REF_DYN_NEED symbol, it will be caught later as an illegal
* visibility.
*/
if (symvis == STV_PROTECTED)
}
/*
* Indicate that this symbol has had it's visibility checked so that
* we don't need to do this investigation again.
*/
}
/*
* After all symbol table input processing has been finished, and all relocation
* counting has been carried out (ie. no more symbols will be read, generated,
* or modified), validate and count the relevant entries:
*
* o check and print any undefined symbols remaining. Note that
* if a symbol has been defined by virtue of the inclusion of
* an implicit shared library, it is still classed as undefined.
*
* o count the number of global needed symbols together with the
* size of their associated name strings (if scoping has been
* indicated these symbols may be reduced to locals).
*
* o establish the size and alignment requirements for the global
* .bss section (the alignment of this section is based on the
* first symbol that it will contain).
*/
{
/*
* If a symbol is undefined and this link-edit calls for no undefined
* symbols to remain (this is the default case when generating an
* executable but can be enforced for any object using -z defs), the
* symbol is classified as undefined and a fatal error condition will
* be indicated.
*
* If the symbol is undefined and we're creating a shared object with
* the -Bsymbolic flag, then the symbol is also classified as undefined
* and a warning condition will be indicated.
*/
undef = FLG_OF_WARN;
if (oflags & FLG_OF_NOUNDEF)
/*
* If the symbol is referenced from an implicitly included shared object
* (ie. it's not on the NEEDED list) then the symbol is also classified
* as undefined and a fatal error condition will be indicated.
*/
/*
* If the output image is being versioned all symbol definitions must be
* associated with a version. Any symbol that isn't is classified as
* undefined and a fatal error condition will be indicated.
*/
/*
* Collect and validate the globals from the internal symbol table.
*/
/*
* If undefined symbols are allowed ignore any symbols that are
* not needed.
*/
if (!(oflags & FLG_OF_NOUNDEF) &&
continue;
/*
* If the symbol originates from an external or parent mapfile
* reference and hasn't been matched to a reference from a
* relocatable object, ignore it.
*/
continue;
}
/*
* Sanity check TLS.
*/
(shndx != SHN_COMMON)) {
continue;
}
}
(oflags & FLG_OF_PROCRED)) {
}
/*
* If building a shared object or executable, and this is a
* non-weak UNDEF symbol with reduced visibility (STV_*), then
* give a fatal error.
*/
if (!(oflags & FLG_OF_RELOBJ) &&
continue;
}
/*
* If this symbol is defined in a non-allocatable section,
* reduce it to local symbol.
*/
}
/*
* If this symbol originated as a SHN_SUNW_IGNORE, it will have
* been processed as an SHN_UNDEF. Return the symbol to its
* original index for validation, and propagation to the output
* file.
*/
if (undef) {
/*
* If an non-weak reference remains undefined, or if a
* mapfile reference is not bound to the relocatable
* objects that make up the object being built, we have
* a fatal error.
*
* The exceptions are symbols which are defined to be
* found in the parent (FLG_SY_PARENT), which is really
* only meaningful for direct binding, or are defined
* external (FLG_SY_EXTERN) so as to suppress -zdefs
* errors.
*
* Register symbols are always allowed to be UNDEF.
*
* Note that we don't include references created via -u
* in the same shared object binding test. This is for
* backward compatibility, in that a number of archive
* makefile rules used -u to cause archive extraction.
* These same rules have been cut and pasted to apply
* to shared objects, and thus although the -u reference
* is redundant, flagging it as fatal could cause some
* build to fail. Also we have documented the use of
* -u as a mechanism to cause binding to weak version
* definitions, thus giving users an error condition
* would be incorrect.
*/
(FLG_SY_PARENT | FLG_SY_EXTERN)) == 0)) ||
(FLG_SY_MAPREF | FLG_SY_MAPUSED)) ==
FLG_SY_MAPREF) &&
FLG_SY1_PROT)) == 0)))) {
undeferr = 1;
}
} else {
/*
* For building things like shared objects (or anything
* -znodefs), undefined symbols are allowed.
*
* If a mapfile reference remains undefined the user
* would probably like a warning at least (they've
* usually mis-spelt the reference). Refer to the above
* comments for discussion on -u references, which
* are not tested for in the same manner.
*/
(FLG_SY_MAPREF | FLG_SY_MAPUSED)) ==
undeferr = 1;
}
}
/*
* If this symbol comes from a dependency mark the dependency
* as required (-z ignore can result in unused dependencies
* being dropped). If we need to record dependency versioning
* information indicate what version of the needed shared object
* this symbol is part of. Flag the symbol as undefined if it
* has not been made available to us.
*/
/*
* Capture that we've bound to a symbol that doesn't
* allow being directly bound to.
*/
int vndx;
} else {
continue;
}
}
}
/*
* Test that we do not bind to symbol supplied from an implicit
* shared object. If a binding is from a weak reference it can
* be ignored.
*/
continue;
}
/*
* Test that a symbol isn't going to be reduced to local scope
* which actually wants to bind to a shared object - if so it's
* a fatal error.
*/
continue;
}
/*
* If the output image is to be versioned then all symbol
* definitions must be associated with a version.
*/
continue;
}
/*
* If we don't need the symbol there's no need to process it
* any further.
*/
continue;
/*
* Calculate the size and alignment requirements for the global
* .bss and .tls sections. If we're building a relocatable
* object only account for scoped COMMON symbols (these will
* be converted to .bss references).
*
* For partially initialized symbol,
* if it is expanded, it goes to sunwdata1.
* if it is local, it goes to .bss.
* if the output is shared object, it goes to .sunwbss.
*
* Also refer to make_mvsections() in sunwmove.c
*/
(oflags & FLG_OF_PROCRED)))) {
int countbss = 0;
if (sdp->sd_psyminfo == 0) {
countbss = 1;
countbss = 0;
countbss = 1;
countbss = 0;
} else
countbss = 1;
if (countbss) {
} else {
}
}
}
/*
* If a symbol was referenced via the command line
* (ld -u <>, ...), then this counts as a reference against the
* symbol. Mark any section that symbol is defined in.
*/
}
/*
* Update the symbol count and the associated name string size.
* If scoping is in effect for this symbol assign it will be
* assigned to the .symtab/.strtab sections.
*/
(oflags & FLG_OF_PROCRED)) {
/*
* If symbol gets eliminated count it.
*
* If symbol gets reduced to local,
* count it's size for the .symtab.
*/
ofl->ofl_elimcnt++;
} else {
ofl->ofl_scopecnt++;
return (S_ERROR);
}
} else {
ofl->ofl_globcnt++;
/*
* If global direct bindings are in effect, or this
* symbol has bound to a dependency which was specified
* as requiring direct bindings, and it hasn't
* explicitly been defined as a non-direct binding
* symbol, mark it.
*/
/*
* Insert the symbol name.
*/
return (S_ERROR);
return (S_ERROR);
}
/*
* If this section offers a global symbol - record that
* fact.
*/
if (isp) {
}
}
}
/*
* If we've encountered a fatal error during symbol validation then
* return now.
*/
return (1);
/*
* Now that symbol resolution is completed, scan any register symbols.
* From now on, we're only interested in those that contribute to the
* output file.
*/
if (ofl->ofl_regsyms) {
int ndx;
continue;
continue;
}
ofl->ofl_regsymcnt++;
ofl->ofl_lregsymcnt++;
}
}
/*
* Generate the .bss section now that we know its size and alignment.
*/
return (S_ERROR);
}
if (tlssize) {
return (S_ERROR);
}
/*
* Determine what entry point symbol we need, and if found save its
* symbol descriptor so that we can update the ELF header entry with the
* symbols value later (see update_oehdr). Make sure the symbol is
* tagged to insure its update in case -s is in effect. Use any -e
* option first, or the default entry points `_start' and `main'.
*/
return (S_ERROR);
}
}
}
}
}
/*
* If ld -zdtrace=<sym> was given, then validate that the
* symbol is defined within the current object being built.
*/
return (S_ERROR);
}
}
}
/*
* If we're required to record any needed dependencies versioning
* information calculate it now that all symbols have been validated.
*/
return (vers_check_need(ofl));
else
return (1);
}
/*
* qsort(3c) comparison function. As an optimization for associating weak
* symbols to their strong counterparts sort global symbols according to their
* address and binding.
*/
static int
{
/*
* Symbol descriptors may be zero, move these to the front of the
* sorted array.
*/
if (sdp1 == 0)
return (-1);
if (sdp2 == 0)
return (1);
/*
* Compare the symbols value (address).
*/
return (1);
return (-1);
/*
* If two symbols have the same address place the weak symbol before
* any strong counterpart.
*/
return (-1);
return (1);
return (0);
}
/*
* Process the symbol table for the specified input file. At this point all
* input sections from this input file have been assigned an input section
* descriptor which is saved in the `ifl_isdesc' array.
*
* o local symbols are saved (as is) if the input file is a
* relocatable object
*
* o global symbols are added to the linkers internal symbol
* table if they are not already present, otherwise a symbol
* resolution function is called upon to resolve the conflict.
*/
{
char *strs;
const char *symsecname, *strsecname;
/*
* Its possible that a file may contain more that one symbol table,
* ie. .dynsym and .symtab in a shared library. Only process the first
* table (here, we assume .dynsym comes before .symtab).
*/
if (ifl->ifl_symscnt)
return (1);
if (isc->is_symshndx)
else
/*
* From the symbol tables section header information determine which
* strtab table is needed to locate the actual symbol names.
*/
return (S_ERROR);
}
else
} else {
/*
* There is no string table section in this input file
* although there are symbols in this symbol table section.
* This means that these symbols do not have names.
* Currently, only scratch register symbols are allowed
* not to have names.
*/
strsize = 0;
}
/*
* Determine the number of local symbols together with the total
* number we have to process.
*/
/*
* Allocate a symbol table index array and a local symbol array
* (global symbols are processed and added to the ofl->ofl_symbkt[]
* array). If we are dealing with a relocatable object, allocate the
* local symbol descriptors. If this isn't a relocatable object we
* still have to process any shared object locals to determine if any
* register symbols exist. Although these aren't added to the output
* image, they are used as part of symbol resolution.
*/
sizeof (Sym_desc *)))) == 0)
return (S_ERROR);
return (S_ERROR);
/* LINTED */
}
/*
* If there are local symbols to save add them to the symbol table
* index array.
*/
if (local) {
const char *name;
/*
* Determine the associated section index.
*/
/*
* Check if st_name has a valid value or not.
*/
continue;
}
/*
* If this local symbol table originates from a shared
* object, then we're only interested in recording
* register symbols. As local symbol descriptors aren't
* allocated for shared objects, one will be allocated
* to associated with the register symbol. This symbol
* won't become part of the output image, but we must
* process it to test for register conflicts.
*/
if (sdflags & FLG_SY_REGSYM) {
/*
* The fact that another register def-
* inition has been found is fatal.
* Call the verification routine to get
* the error message and move on.
*/
continue;
}
if ((sdp = libld_calloc(
sizeof (Sym_desc), 1)) == 0)
return (S_ERROR);
}
continue;
/*
* Fill in the remaining symbol descriptor information.
*/
if (sdp == 0) {
}
if (rsdp == 0) {
}
/*
* Reclassify any SHN_SUNW_IGNORE symbols to SHN_UNDEF
* so as to simplify future processing.
*/
if (shndx == SHN_SUNW_IGNORE) {
}
/*
* Process any register symbols.
*/
/*
* Add a diagnostic to indicate we've caught a
* register symbol, as this can be useful if a
* register conflict is later discovered.
*/
/*
* If this register symbol hasn't already been
* recorded, enter it now.
*/
return (S_ERROR);
}
/*
* Assign an input section.
*/
/*
* If this symbol falls within the range of a section
* being discarded, then discard the symbol itself.
* There is no reason to keep this local symbol.
*/
continue;
}
/*
* Skip any section symbols as new versions of these
* will be created.
*/
}
continue;
}
/*
* Sanity check for TLS
*/
continue;
}
}
/*
* Carry our some basic sanity checks (these are just
* some of the erroneous symbol entries we've come
* across, there's probably a lot more). The symbol
* will not be carried forward to the output file, which
* won't be a problem unless a relocation is required
* against it.
*/
((shndx == SHN_COMMON)) ||
continue;
}
/*
* As these local symbols will become part of the output
* image, record their number and name string size.
* Globals are counted after all input file processing
* (and hence symbol resolution) is complete during
* sym_validate().
*/
ofl->ofl_locscnt++;
return (S_ERROR);
}
}
}
/*
* Now scan the global symbols entering them in the internal symbol
* table or resolving them as necessary.
*/
/* LINTED */
const char *name;
/*
* Determine the associated section index.
*/
} else {
}
/*
* Check if st_name has a valid value or not.
*/
continue;
}
/*
* The linker itself will generate symbols for _end, _etext,
* _edata, _DYNAMIC and _PROCEDURE_LINKAGE_TABLE_, so don't
* bother entering these symbols from shared objects. This
* results in some wasted resolution processing, which is hard
* to feel, but if nothing else, pollutes diagnostic relocation
* output.
*/
continue;
}
/*
* Determine and validate the symbols binding.
*/
continue;
}
/*
* If this symbol falls within the range of a section being
* discarded, then discard the symbol itself.
*/
if (((sdflags & FLG_SY_SPECSEC) == 0) &&
/*
* Carry our some basic sanity checks
* The symbol will not be carried forward to
* the output file, which won't be a problem
* unless a relocation is required against it.
*/
continue;
}
if ((sdp =
return (S_ERROR);
/*
* Create a dummy symbol entry so that if we
* find any references to this discarded symbol
* we can compensate.
*/
continue;
}
}
/*
* If the symbol does not already exist in the internal symbol
* table add it, otherwise resolve the conflict. If the symbol
* from this file is kept, retain its symbol table index for
* possible use in associating a global alias.
*/
/* LINTED */
return (S_ERROR);
return (S_ERROR);
/*
* After we've compared a defined symbol in one shared
* object, flag the symbol so we don't compare it again.
*/
/*
* If the symbol is accepted from this file retain the symbol
* index for possible use in aliasing.
*/
/*
* If we've accepted a register symbol, continue to validate
* it.
*/
return (S_ERROR);
}
}
}
/*
* If this is a shared object scan the globals one more time and
* should the weak definition satisfy a reference in the dynamic
* executable:
*
* o if the symbol is a data item it will be copied to the
* executables address space, thus we must also reassociate the
* alias symbol with its new location in the executable.
*
* o if the symbol is a function then we may need to promote the
* symbols binding from undefined weak to undefined, otherwise the
* run-time linker will not generate the correct relocation error
* should the symbol not be found.
*
* symbol entries are identical, thus first we created a sorted symbol
* list keyed off of the symbols value (if the value is the same chances
* are the rest of the symbols data is). This list is then scanned for
* weak symbols, and if one is found then any strong association will
* exist in the following entries. Thus we just have to scan one
* (typical single alias) or more (in the uncommon instance of multiple
* weak to strong associations) entries to determine if a match exists.
*/
return (S_ERROR);
int sndx;
if (wsdp == 0)
continue;
continue;
/*
* We have a weak symbol, if it has a strong alias it
* will have been sorted to one of the following sort
* table entries. Note that we could have multiple weak
* symbols aliased to one strong (if this occurs then
* the strong symbol only maintains one alias back to
* the last weak).
*/
if (ssdp == 0)
break;
break;
break;
}
}
}
}
return (1);
}
/*
* Add an undefined symbol to the symbol table (ie. from -u name option)
*/
Sym_desc *
{
/*
* If the symbol reference already exists indicate that a reference
* also came from the command line.
*/
/* LINTED */
return (sdp);
}
/*
* Determine whether a pseudo input file descriptor exists to represent
* the command line, as any global symbol needs an input file descriptor
* during any symbol resolution (refer to map_ifl() which provides a
* similar method for adding symbols from mapfiles).
*/
break;
}
/*
* If no descriptor exists create one.
*/
if (ifl == 0) {
(Ifl_desc *)0)
1)) == 0)
}
/*
* Allocate a symbol structure and add it to the global symbol table.
*/
return (sdp);
}