relocate.c revision b3fbe5e6c0ab1f506cd04f8dd39bf9656909f535
/*
* 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"
/*
* set-up for relocations
*/
#include <string.h>
#include <stdio.h>
#include <alloca.h>
#include "debug.h"
#include "reloc.h"
#include "msg.h"
#include "_libld.h"
/*
* Structure to hold copy relocation items.
*/
typedef struct copy_rel {
} Copy_rel;
/*
* For each copy relocation symbol, determine if the symbol is:
* 1) to be *disp* relocated at runtime
* 2) a reference symbol for *disp* relocation
* 3) possibly *disp* relocated at ld time.
*
* The first and the second are serious errors.
*/
static void
{
/*
* This symbol may not be *disp* relocated at run time, but could
* already have been *disp* relocated when the shared object was
* created. Warn the user.
*/
return;
/*
* Traverse the input relocation sections.
*/
/*
* Decide entry size
*/
else
}
/*
* Traverse the relocation entries.
*/
const char *str;
continue;
/*
* First, check if this symbol is reference symbol
* for this relocation entry.
*/
}
}
/*
* Then check if this relocation entry is relocating
* this symbol.
*/
continue;
/*
* This symbol is truely *disp* relocated, so should
* really be fixed by user.
*/
}
}
}
}
/*
* The number of symbols provided by some objects can be very large. Use a
* binary search to match the associated value to a symbol table entry.
*/
static int
{
return (-1);
return (1);
return (0);
}
/*
* Given a sorted list of symbols, look for a symbol in which the relocation
* the symbol list is maintained in sorted order, we can bail once the
* relocation offset becomes less than the symbol values. The symbol is
* returned for use in error diagnostics.
*/
static Sym_desc *
{
/*
* Sorted symbol values have been uniquified by adding their associated
* section offset. Uniquify the relocation offset by adding its
* associated section offset, and search for the symbol.
*/
else
tsdp = 0;
if (inspect)
return (tsdp);
/*
* Determine the relocation reference symbol and its type.
*/
/*
* If there is no target symbol to match the relocation offset, then the
* offset is effectively local data. If the relocation symbol is global
* data we have a potential for this displacement relocation to be
* invalidated should the global symbol be copied.
*/
if (tsdp == 0) {
return (tsdp);
} else {
/*
* If both symbols are local, no copy relocations can occur to
* either.
*/
return (tsdp);
/*
* Determine the relocation target symbols type.
*/
/*
* One of the symbols must reference a data element.
*/
return (tsdp);
}
/*
* We have two global symbols, at least one of which is a data item.
* The last case where a displacement relocation can be ignored, is
* if the reference symbol is included in the target symbol.
*/
return (tsdp);
/*
* We have a displacement relocation that could be compromised by a
* copy relocation of one of the associated data items.
*/
return (tsdp);
}
void
{
const char *str;
else
}
/*
* qsort(3C) comparison routine used for the disp_sortsyms().
*/
static int
{
return (1);
return (-1);
return (0);
}
/*
* Determine whether a displacement relocation is between a local and global
* symbol pair. One symbol is used to perform the relocation, and the other
* is the destination offset of the relocation.
*/
static uintptr_t
{
/*
* If the input files symbols haven't been sorted yet, do so.
*/
if (ifl->ifl_sortsyms == 0) {
sizeof (Ssv_desc))) == 0)
return (S_ERROR);
/*
* As symbol resolution has already occurred, various
* symbols from this object may have been satisfied
* from other objects. Only select symbols from this
* object. For the displacement test, we only really
* need to observe data definitions, however, later as
* part of providing warning disgnostics, relating the
* relocation offset to a symbol is desirable. Thus,
* collect all symbols that define a memory area.
*/
continue;
/*
* As a further optimization for later checking, mark
* this section if this a global data definition.
*/
/*
* Capture the symbol. Within relocatable objects, a
* symbols value is its offset within its associated
* section. Add the section offset to this value to
* uniquify the symbol.
*/
nndx++;
}
/*
* Sort the list based on the symbols value (address).
*/
&disp_qsort);
}
/*
* If the reference symbol is local, and the section being relocated
* contains no global definitions, neither can be the target of a copy
* relocation.
*/
return (1);
/*
* Otherwise determine whether this relocation symbol and its offset
* could be candidates for a copy relocation.
*/
if (ifl->ifl_sortcnt)
return (1);
}
{
/*
* If this is the first time we've seen this symbol in a GOT
* relocation we need to assign it a GOT token. Once we've got
* all of the GOT's assigned we can assign the actual indexes.
*/
return (S_ERROR);
/*
* Now we initialize the GOT table entry.
*
* Pseudo code to describe the the decisions below:
*
* If (local)
* then
* enter symbol value in GOT table entry
* if (Shared Object)
* then
* create Relative relocation against symbol
* fi
* else
* clear GOT table entry
* create a GLOB_DAT relocation against symbol
* fi
*/
if (flags & FLG_OF_SHAROBJ) {
return (S_ERROR);
/*
* Add a RELATIVE relocation if this is
* anything but a ABS symbol.
*/
if (add_outrel((FLG_REL_GOT |
FLG_REL_ADVAL), rsp,
return (S_ERROR);
}
} else {
return (S_ERROR);
}
} else {
return (S_ERROR);
}
} else {
return (S_ERROR);
}
/*
* Perform relocation to GOT table entry.
*/
}
/*
* Perform relocations for PLT's
*/
{
#if defined(_ELF64)
/*
* AMD64 TLS code sequences do not use a unique
* TLS relocation to reference the __tls_get_addr()
* function call.
*/
}
#else
/*
* GNUC IA32 TLS code sequences do not use a unique
* TLS relocation to reference the ___tls_get_addr()
* function call.
*/
}
#endif
#endif /* __i386 && __amd64 */
/*
* if (not PLT yet assigned)
* then
* assign PLT index to symbol
* build output JMP_SLOT relocation
* fi
*/
/*
* If this symbol is binding to a LAZYLOADED object then
* set the LAZYLD symbol flag.
*/
return (S_ERROR);
}
/*
* Perform relocation to PLT table entry.
*/
return (S_ERROR);
return (1);
} else
}
/*
* process GLOBAL undefined and ref_dyn_need symbols.
*/
{
/*
* Reference is to a function so simply create a plt entry for it.
*/
/*
* Catch absolutes - these may cause a text relocation.
*/
/*
* If -zabsexec is set then promote the ABSOLUTE
* symbol to current the current object and
* perform the relocation now.
*/
}
/*
* If the relocation is against a writable section simply compute the
* necessary output relocation. As an optimization, if the symbol has
* already been transformed into a copy relocation then we can perform
* the relocation directly (copy relocations should only be generated
* for references from the text segment and these relocations are
* normally carried out before we get to the data segment relocations).
*/
else
}
/*
* If the reference isn't to an object (normally because some idiot
* hasn't defined a .type directive in some assembler source), then
* simply apply a generic relocation (this has a tendency to result in
* text relocations).
*/
}
/*
* Prepare for generating a copy relocation.
*
* If this symbol is one of an alias pair, we need to insure both
* symbols become part of the output (the strong symbol will be used to
* maintain the symbols state). And, if we did raise the precedence of
* a symbol we need to check and see if this is a weak symbol. If it is
* we want to use it's strong counter part.
*
* The results of this logic should be:
* rel_usym: assigned to strong
* rel_sym: assigned to symbol to perform
* copy_reloc against (weak or strong).
*/
if (sap->sa_linkndx) {
/*
* As we're going to replicate a symbol from a shared
* object, retain its correct binding status.
*/
/*
* As we're going to replicate a symbol from a shared
* object, retain its correct binding status.
*/
}
/*
* If this is a weak symbol then we want to move the strong
* symbol into local .bss. If there is a copy_reloc to be
* performed, that should still occur against the WEAK symbol.
*/
} else
_sdp = 0;
/*
* If the reference is to an object then allocate space for the object
* within the executables .bss. Relocations will now be performed from
* this new location. If the original shared objects data is
* initialized, then generate a copy relocation that will copy the data
* to the executables .bss at runtime.
*/
/*
* Indicate that the symbol(s) against which we're relocating
* have been moved to the executables common. Also, insure that
* the symbol(s) remain marked as global, as the shared object
* from which they are copied must be able to relocate to the
* new common location within the executable.
*
* Note that even though a new symbol has been generated in the
* output files' .bss, the symbol must remain REF_DYN_NEED and
* not be promoted to REF_REL_NEED. sym_validate() still needs
* to carry out a number of checks against the symbols binding
* that are triggered by the REF_DYN_NEED state.
*/
if (_sdp) {
/*
* Make sure the symbol has a reference in case of any
* error diagnostics against it (perhaps this belongs
* to a version that isn't allowable for this build).
* The resulting diagnostic (see sym_undef_entry())
* might seem a little bogus, as the symbol hasn't
* really been referenced by this file, but has been
* promoted as a consequence of its alias reference.
*/
}
/*
* Assign the symbol to the bss and insure sufficient alignment
* (we don't know the real alignment so we have to make the
* worst case guess).
*/
return (S_ERROR);
/*
* Whether or not the symbol references initialized
* data we generate a copy relocation - this differs
* from the past where we would not create the COPY_RELOC
* if we were binding against .bss. This is done
* for *two* reasons.
*
* o If the symbol in the shared object changes to
* a initialized data - we need the COPY to pick it
* up.
* o without the COPY RELOC we can't tell that the
* symbol from the COPY'd object has been moved
* and all bindings to it should bind here.
*/
/*
* Keep this symbol in the copy relocation list
* to check the validity later.
*/
return (S_ERROR);
return (S_ERROR);
return (S_ERROR);
/*
* If this symbol is a protected symbol, warn it.
*/
}
}
/*
* All relocations should have been handled by the other routines. This
* routine is hear as a catch all, if we do enter it we've goofed - but
* we'll try and to the best we can.
*/
{
/*
* If building a shared object then put the relocation off
* until runtime.
*/
if (flags & FLG_OF_SHAROBJ)
/*
* Otherwise process relocation now.
*/
}
{
/*
* Indicate this symbol is being used for relocation and therefore must
* have its output address updated accordingly (refer to update_osym()).
*/
/*
* Indicate the section this symbol is defined in has been referenced,
* therefor it *is not* a candidate for elimination.
*/
}
/*
* Determine if this symbol is actually an alias to another symbol. If
* so, and the alias is not REF_DYN_SEEN, set rel_usym to point to the
* weak symbols strong counter-part. The one exception is if the
* FLG_SY_MVTOCOMM flag is set on the weak symbol. If this is the case,
* the strong is only here because of its promotion, and the weak symbol
* should still be used for the relocation reference (see reloc_exec()).
*/
}
/*
* Determine whether this symbol should be bound locally or not.
* Symbols will be bound locally if one of the following is true:
*
* o the symbol is of type STB_LOCAL
*
* o the output image is not a relocatable object and the
* relocation is relative to the .got
*
* o the section being relocated is of type SHT_SUNW_dof;
* these sections are bound to the functions in the
* containing object and don't care about interpositioning
*
* o the symbol has been reduced (scoped to a local or
* symbolic) and reductions are being processed
*
* o the -Bsymbolic flag is in use when building a shared
* object or an executable (fixed address) is being created
*
* o Building an executable and the symbol is defined
* in the executable.
*
* o the relocation is against a segment which will not
* be loaded into memory. If that is the case we need
* to resolve the relocation now because ld.so.1 won't
* be able to.
*/
if (reld->rel_isdesc &&
} else if (!(flags & FLG_OF_RELOBJ) &&
}
}
/*
* If this is a PC_RELATIVE relocation, the relocation could be
* compromised if the relocated address is later used as a copy
* relocated symbol (PSARC 1999/636, bugid 4187211). Scan the input
* files symbol table to cross reference this relocation offset.
*/
return (S_ERROR);
}
/*
* GOT based relocations must bind to the object being built - since
* they are relevant to the current GOT. If not building a relocatable
* object - give a appropriate error message.
*/
return (S_ERROR);
}
/*
* TLS symbols can only have TLS relocations.
*/
/*
* The above test is relaxed if the target section is
* non-allocable.
*/
return (S_ERROR);
}
}
/*
* Select the relocation to perform.
*/
if (IS_REGISTER(rtype))
if (flags & FLG_OF_RELOBJ)
if (IS_TLS_INS(rtype))
if (IS_GOT_INS(rtype))
if (IS_GOT_RELATIVE(rtype))
if (local)
/*
* IS_NOT_REL(rtype)
*/
}
/*
* Generate relocation descriptor and dispatch
*/
static uintptr_t
{
/*
* Make sure the relocation is in the valid range.
*/
return (S_ERROR);
}
/*
* Special case: a register symbol associated with symbol index 0 is
* initialized (i.e., relocated) to a constant from the r_addend field
* rather than from a symbol value.
*/
}
/*
* Determine whether we're dealing with a named symbol. Note, bogus
* relocations can result in a null symbol descriptor (sdp), the error
* condition should be caught below after determining whether a valid
* symbol name exists.
*/
else {
static char *strunknown;
if (strunknown == 0)
}
/*
* If for some reason we have a null relocation record issue a
* warning and continue (the compiler folks can get into this
* state some time). Normal users should never see this error.
*/
return (1);
}
return (S_ERROR);
}
/*
* If we are here, we know that the relocation requires reference
* symbol. If no symbol is assigned, this is a fatal error.
*/
return (S_ERROR);
}
return (1);
/*
* If this symbol is part of a DISCARDED section attempt to find another
* definition.
*/
ofl)) == 0)) {
return (S_ERROR);
}
}
/*
* If this is a global symbol, determine whether its visibility needs
* adjusting.
*/
/*
* Ignore any relocation against a section that will not be in the
* output file (has been stripped).
*/
return (1);
/*
* If the symbol for this relocation is invalid (which should have
* generated a message during symbol processing), or the relocation
* record's symbol reference is in any other way invalid, then it's
* about time we gave up.
*/
return (S_ERROR);
}
}
static uintptr_t
{
/*
* Decide entry size.
*/
else
}
/*
* Build up the basic information in for the Rel_desc structure.
*/
flags |= FLG_REL_LOAD;
flags |= FLG_REL_NOINFO;
/*
* Initialize the relocation record information and process
* the individual relocation. Reinitialize the flags to
* insure we don't carry any state over from the previous
* relocation records processing.
*/
return (S_ERROR);
}
return (1);
}
{
continue;
osp->os_szoutrels = 0;
/*
* Determine the input section that this
* relocation information refers to.
*/
/*
* Do not process relocations against sections
* which are being discarded (COMDAT)
*/
continue;
return (S_ERROR);
}
/*
* Check for relocations against non-writable
* allocatable sections.
*/
if ((osp->os_szoutrels) &&
}
}
}
return (1);
}
/*
* Move Section related function
* Get move entry
*/
static Move *
{
/*
* Set info for the target move section
*/
if (mshdr->sh_entsize == 0)
return ((Move *)0);
/*
* If this is an illgal entry, retun NULL.
*/
return ((Move *)0);
return (ret);
}
/*
* Relocation against Move Table.
*/
static uintptr_t
{
/*
* Decide entry size
*/
if ((entsize == 0) ||
else
}
/*
* Go through the relocation entries.
*/
/*
* Initialize the relocation record information.
*/
return (S_ERROR);
reld.rel_roffset +=
/* LINTED */
/*
* Generate Reld
*/
if (process_reld(ofl,
return (S_ERROR);
}
} else {
/*
* Generate Reld
*/
if (process_reld(ofl,
return (S_ERROR);
}
}
return (1);
}
/*
* This function is similar to reloc_init().
*
* This function is called when the SHT_SUNW_move table is expanded
* and there were relocation against the SHT_SUNW_move section.
*/
static uintptr_t
{
/*
*/
return (S_ERROR);
}
return (1);
}
/*
* Count the number of output relocation entries, global offset table entries,
* and procedure linkage table entries. This function searches the segment and
* outsect lists and passes each input reloc section to process_reloc().
* It allocates space for any output relocations needed. And builds up
* the relocation structures for later processing.
*/
{
/*
* At this point we have finished processing all input symbols. Make
* sure we add any absolute (internal) symbols before continuing with
* any relocation processing.
*/
return (S_ERROR);
/*
* First process all of the relocations against NON-writable
* segments followed by relocations against the writeable segments.
*
* This separation is so that when the writable segments are processed
* we know whether or not a COPYRELOC will be produced for any symbols.
* If relocations aren't processed in this order, a COPYRELOC and a
* regular relocation can be produced against the same symbol. The
* regular relocation would be redundant.
*/
return (S_ERROR);
return (S_ERROR);
/*
* Process any extra relocations. These are relocation sections that
* have a NULL sh_info.
*/
return (S_ERROR);
}
/*
* If there were relocation against move table,
* process the relocation sections.
*/
return (S_ERROR);
/*
* Now all the relocations are pre-processed,
* check the validity of copy relocations.
*/
/*
* If there were no displacement relocation
* in this file, don't worry about it.
*/
}
}
/*
* Make a got section if:
*
* BLDGOT flag set
* or
* ofl_gotcnt != GOT_XNumber
* or
* not-relobj & GOT symbol referenced
*
*/
return (S_ERROR);
return (S_ERROR);
/* nothing to do */
#else
#endif
}
return (1);
}
/*
* Simple comparison routine to be used by qsort() for
* the sorting of the output relocation list.
*
* The reloc_compare() routine results in a relocation
* table which is located on:
*
* file referenced (NEEDED NDX)
* referenced symbol
* relocation offset
*
* This provides the most efficient traversal of the relocation
* table at run-time.
*/
int
{
/*
* first - sort on neededndx
*/
return (1);
return (-1);
/*
* Then sort on symbol
*/
return (1);
return (-1);
/*
* i->key2 == j->key2
*
* At this point we fall back to key2 (offsets) to
* sort the output relocations. Ideally this will
* make for the most efficient processing of these
* relocations at run-time.
*/
return (1);
return (-1);
return (0);
}
{
int debug = 0;
return (S_ERROR);
/*
* All but the PLT output relocations are sorted in the output file
* based upon their sym_desc. By doing this multiple relocations
* against the same symbol are grouped together, thus when the object
* is later relocated by ld.so.1 it will take advantage of the symbol
* cache that ld.so.1 has. This can significantly reduce the runtime
* relocation cost of a dynamic object.
*
* PLT relocations are not sorted because the order of the PLT
* relocations is used by ld.so.1 to determine what symbol a PLT
* relocation is against.
*/
/*LINTED*/
if (debug == 0) {
debug = 1;
}
/*
* If it's a PLT relocation we output it now in the
* order that it was originally processed.
*/
continue;
}
/* LINTED */
} else {
}
else {
else {
orsp->rel_roffset +
is_indata) +
}
}
}
}
(int (*)(const void *, const void *))reloc_compare);
/*
* All output relocations have now been sorted, go through
* and process each relocation.
*/
}
return (error);
}
/*
* Process relocations. Finds every input relocation section for each output
* section and invokes reloc_sec() to relocate that section.
*/
{
/*
* Determine the index of the symbol table that will be referenced by
* the relocation entries.
*/
/* LINTED */
/* LINTED */
/*
* Re-initialize counters. These are used to provide relocation
* offsets within the output buffers.
*/
ofl->ofl_relocpltsz = 0;
ofl->ofl_relocgotsz = 0;
ofl->ofl_relocbsssz = 0;
/*
* Now that the output file is created and symbol update has occurred,
* process the relocations collected in process_reloc().
*/
return (S_ERROR);
return (S_ERROR);
/*
* Process the relocation sections:
*
* o for each relocation section generated for the output
* image update its shdr information to reflect the
* symbol table it needs (sh_link) and the section to
* which the relocation must be applied (sh_info).
*/
if (osp->os_relosdesc == 0)
continue;
/* LINTED */
}
}
/*
* Since the .rel[a] section is not tied to any specific
* section, we'd of not found it above.
*/
}
} else {
/*
* We only have two relocation sections here, (PLT's,
* coalesced) so just hit them directly instead of stepping
* over the output sections.
*/
if (ofl->ofl_osrelhead) {
}
/* LINTED */
}
}
/*
* If the -z text option was given, and we have output relocations
* against a non-writable, allocatable section, issue a diagnostic and
* return (the actual entries that caused this error would have been
* output during the relocating section phase).
*/
(FLG_OF_PURETXT | FLG_OF_TEXTREL)) {
return (S_ERROR);
}
/*
* Finally, initialize the first got entry with the address of the
* .dynamic section (_DYNAMIC).
*/
if (flags & FLG_OF_DYNAMIC) {
return (S_ERROR);
}
return (1);
}
/*
* If the -z text option was given, and we have output relocations against a
* non-writable, allocatable section, issue a diagnostic. Print offending
* symbols in tabular form similar to the way undefined symbols are presented.
* Called from reloc_count(). The actual fatal error condition is triggered on
* in reloc_process() above.
*
* Note. For historic reasons -ztext is not a default option (however all OS
* shared object builds use this option). It can be argued that this option
* should also be default when generating an a.out (see 1163979). However, if
* an a.out contains text relocations it is either because the user is creating
* something pretty weird (they've used the -b or -znodefs options), or because
* the library against which they're building wasn't constructed correctly (ie.
* a function has a NOTYPE type, in which case the a.out won't generate an
* associated plt). In the latter case the builder of the a.out can't do
* anything to fix the error - thus we've chosen not to give the user an error,
* or warning, for this case.
*/
void
{
const char *str1;
if (warning)
else
str1,
}
void
{
/*
* -ztextoff
*/
return;
/*
* Only give relocation errors against loadable read-only segments.
*/
return;
/*
* If we are in -ztextwarn mode, it's a silent error if a relocation is
* due to a 'WEAK REFERENCE'. This is because if the symbol is not
* provided at run-time we will not perform a text-relocation.
*/
return;
if (reloc_title) {
/*
* If building with '-ztext' then emit a fatal error. If
* building a executable then only emit a 'warning'.
*/
else
reloc_title = FALSE;
}
}
/*
* The following functions are called from
* machine functions defined in {sparc,i386,sparcv9}/machrel.c
*/
/*
* Move Section related function
*/
static uintptr_t
{
int found = 0;
/*
* Search for matching move entry
*/
found = 0;
found = 1;
break;
}
}
if (found == 0) {
/*
* This should never happen.
*/
return (S_ERROR);
}
/*
* Update r_offset
*/
return (1);
}
void
{
/*
* We are relocating the move table itself.
*/
&newoffset);
} else {
/*
* We are expanding the partial symbol. So we are generating
* the relocation entry relocating the expanded partial symbol.
*/
arsp->rel_roffset +=
}
}
/*
* Partially Initialized Symbol Handling routines
* For sparc architecture, the second argument is reld->rel_raddend.
* For i386 acrchitecure, the second argument is the value stored
* at the relocation target address.
*/
Sym_desc *
{
for (i = 1; i < nlocs; i++) {
continue;
continue;
return (symd);
}
return ((Sym_desc *) 0);
}
/*
* Because of the combinations of 32-bit lib providing 64-bit support, and
* visa-versa, the use of krtld's dorelocs can result in differing message
* Thus the actual message files contain a couple of entries to satisfy
* each architectures build. Here we add dummy calls to quieten chkmsg.
*
* chkmsg: MSG_INTL(MSG_REL_NOFIT)
* chkmsg: MSG_INTL(MSG_REL_NONALIGN)
*/