sparc_elf.c revision 56deab0745753336570f5c63c3b5fa565eaab8f1
/*
* 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 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* Copyright (c) 1988 AT&T
* All Rights Reserved
*/
/*
* SPARC machine dependent and ELF file class dependent functions.
* Contains routines for performing function binding and symbol relocations.
*/
#include <stdio.h>
#include <sys/elf_SPARC.h>
#include <dlfcn.h>
#include <synch.h>
#include <string.h>
#include <debug.h>
#include <reloc.h>
#include <conv.h>
#include "_rtld.h"
#include "_audit.h"
#include "_elf.h"
#include "_inline.h"
#include "msg.h"
int
{
/*
* Check machine type and flags.
*/
return (0);
}
return (0);
}
return (0);
}
return (0);
}
return (1);
}
void
{
/*
* There is no need to analyze ld.so because we don't map in any of
* its dependencies. However we may map these dependencies in later
* (as if ld.so had dlopened them), so initialize the plt and the
* permission information.
*/
}
/*
* elf_plt_write() will test to see how far away our destination
* address lies. If it is close enough that a branch can
* be used instead of a jmpl - we will fill the plt in with
* single branch. The branches are much quicker then
* a jmpl instruction - see bug#4356879 for further
* details.
*
* NOTE: we pass in both a 'pltaddr' and a 'vpltaddr' since
* address is not the same as the 'virtual' runtime
* address.
*/
/* ARGSUSED4 */
{
long disp;
/*
* Test if the destination address is close enough to use
* a ba,a... instruction to reach it.
*/
/*
* The
*
* ba,a,pt %icc, <dest>
*
* is the most efficient of the PLT's. If we
* are within +-20 bits *and* running on a
* v8plus architecture - use that branch.
*/
if ((at_flags & EF_SPARC_32PLUS) &&
} else {
/*
* Otherwise - we fall back to the good old
*
* ba,a <dest>
*
* Which still beats a jmpl instruction.
*/
}
return (rc);
}
/*
* The PLT destination is not in reach of
* a branch instruction - so we fall back
* to a 'jmpl' sequence.
*/
DBG_CALL(pltcntfull++);
return (PLT_T_FULL);
}
/*
* Local storage space created on the stack created for this glue
* code includes space for:
* 0x4 pointer to dyn_data
* 0x4 size prev stack frame
*/
static const uchar_t dyn_plt_template[] = {
/* 0x00 */ 0x80, 0x90, 0x00, 0x1e, /* tst %fp */
/* 0x04 */ 0x02, 0x80, 0x00, 0x04, /* be 0x14 */
/* 0x08 */ 0x82, 0x27, 0x80, 0x0e, /* sub %sp, %fp, %g1 */
/* 0x0c */ 0x10, 0x80, 0x00, 0x03, /* ba 0x20 */
/* 0x10 */ 0x01, 0x00, 0x00, 0x00, /* nop */
/* 0x14 */ 0x82, 0x10, 0x20, 0x60, /* mov 0x60, %g1 */
/* 0x18 */ 0x9d, 0xe3, 0xbf, 0x98, /* save %sp, -0x68, %sp */
/* 0x1c */ 0xc2, 0x27, 0xbf, 0xf8, /* st %g1, [%fp + -0x8] */
/* 0x20 */ 0x03, 0x00, 0x00, 0x00, /* sethi %hi(val), %g1 */
/* 0x24 */ 0x82, 0x10, 0x60, 0x00, /* or %g1, %lo(val), %g1 */
/* 0x28 */ 0x40, 0x00, 0x00, 0x00, /* call <rel_addr> */
/* 0x2c */ 0xc2, 0x27, 0xbf, 0xfc /* st %g1, [%fp + -0x4] */
};
int dyn_plt_ent_size = sizeof (dyn_plt_template) +
sizeof (uintptr_t) + /* reflmp */
sizeof (uintptr_t) + /* deflmp */
sizeof (ulong_t) + /* symndx */
sizeof (ulong_t) + /* sb_flags */
sizeof (Sym); /* symdef */
/*
* the dynamic plt entry is:
*
* tst %fp
* be 1f
* nop
* sub %sp, %fp, %g1
* ba 2f
* nop
* 1:
* mov SA(MINFRAME), %g1 ! if %fp is null this is the
* ! 'minimum stack'. %fp is null
* ! on the initial stack frame
* 2:
* save %sp, -(SA(MINFRAME) + 2 * CLONGSIZE), %sp
* st %g1, [%fp + -0x8] ! store prev_stack size in [%fp - 8]
* sethi %hi(dyn_data), %g1
* or %g1, %lo(dyn_data), %g1
* call elf_plt_trace
* st %g1, [%fp + -0x4] ! store dyn_data ptr in [%fp - 4]
* dyn data:
* uintptr_t reflmp
* uintptr_t deflmp
* ulong_t symndx
* ulong_t sb_flags
* Sym symdef
*/
static caddr_t
int *fail)
{
extern ulong_t elf_plt_trace();
/*
* If both pltenter & pltexit have been disabled there
* there is no reason to even create the glue code.
*/
return (to);
}
/*
* We only need to add the glue code if there is an auditing
* library that is interested in this binding.
*/
(pltndx * dyn_plt_ent_size));
/*
* Have we initialized this dynamic plt entry yet? If we haven't do it
* now. Otherwise this function has been called before, but from a
* different plt (ie. from another shared object). In that case
* we just set the plt to point to the new dyn_plt.
*/
if (*dyn_plt == 0) {
sizeof (dyn_plt_template));
sizeof (dyn_plt_template));
/*
* relocating:
* sethi %hi(dyndata), %g1
*/
*fail = 1;
return (0);
}
/*
* relocating:
* or %g1, %lo(dyndata), %g1
*/
*fail = 1;
return (0);
}
/*
* relocating:
* call elf_plt_trace
*/
*fail = 1;
return (0);
}
}
}
/*
* Function binding routine - invoked on the first call to a function through
* the procedure linkage table;
* passes first through an assembly language interface.
*
* Takes the address of the PLT entry where the call originated,
* the offset into the relocation table of the associated
* relocation entry and the address of the link map (rt_private_map struct)
* for the entry.
*
* Returns the address of the function referenced after re-writing the PLT
* entry to invoke the function directly.
*
* On error, causes process to terminate with a signal.
*/
{
char *name;
/*
* For compatibility with libthread (TI_VERSION 1) we track the entry
* value. A zero value indicates we have recursed into ld.so.1 to
* further process a locking request. Under this recursion we disable
* tsort and cleanup activities.
*/
}
/*
* Must calculate true plt relocation address from reloc.
* Take offset, subtract number of reserved PLT entries, and divide
* by PLT entry size, which should give the index of the plt
* entry (and relocation entry since they have been defined to be
* in the same order). Then we must multiply by the size of
* a relocation entry, which will give us the offset of the
* plt relocation entry from the start of them given by JMPREL(lm).
*/
/*
* Perform some basic sanity checks. If we didn't get a load map
* or the plt offset is invalid then its possible someone has walked
* over the plt entries or jumped to plt[0] out of the blue.
*/
}
/*
* Use relocation entry to get symbol table entry and symbol name.
*/
/*
* Determine the last link-map of this list, this'll be the starting
* point for any tsort() processing.
*/
/*
* Find definition for symbol. Initialize the symbol lookup data
* structure.
*/
}
/*
* Record that this new link map is now bound to the caller.
*/
}
&sb_flags);
}
vaddr = 0;
else
pbtype = PLT_T_NONE;
if (!(rtld_flags & RT_FL_NOBIND)) {
int fail = 0;
if (fail)
} else {
/*
* Write standard PLT entry to jump directly
* to newly bound function.
*/
}
}
/*
* Print binding information and rebuild PLT entry.
*/
/*
* Complete any processing for newly loaded objects. Note we don't
* know exactly where any new objects are loaded (we know the object
* that supplied the symbol, but others may have been loaded lazily as
* we searched for the symbol), so sorting starts from the last
* link-map know on entry to this routine.
*/
if (entry)
/*
* Some operations like dldump() or dlopen()'ing a relocatable object
* result in objects being loaded on rtld's link-map, make sure these
* objects are initialized also.
*/
/*
* Make sure the object to which we've bound has had it's .init fired.
* Cleanup before return to user code.
*/
if (entry) {
}
if (lmflags & LML_FLG_RTLDLM)
return (symval);
}
/*
* Read and process the relocations for one link object, we assume all
* relocation sections for loadable segments are stored contiguously in
* the file.
*/
int
{
/*
* If an object has any DT_REGISTER entries associated with
* it, they are processed now.
*/
if (elf_regsyms(lmp) == 0)
return (0);
}
/*
* Although only necessary for lazy binding, initialize the first
* procedure linkage table entry to go to elf_rtbndr(). dbx(1) seems
* to find this useful.
*/
/*
* Make sure the segment is writable.
*/
if ((((mpp =
return (0);
}
/*
* Initialize the plt start and end addresses.
*/
/*
* If we've been called upon to promote an RTLD_LAZY object to an
* RTLD_NOW then we're only interested in scaning the .plt table.
*/
if (plt) {
} else {
/*
* The relocation sections appear to the run-time linker as a
* single table. Determine the address of the beginning and end
* of this table. There are two different interpretations of
* the ABI at this point:
*
* o The REL table and its associated RELSZ indicate the
* concatenation of *all* relocation sections (this is the
* model our link-editor constructs).
*
* o The REL table and its associated RELSZ indicate the
* concatenation of all *but* the .plt relocations. These
* relocations are specified individually by the JMPREL and
* PLTRELSZ entries.
*
* Determine from our knowledege of the relocation range and
* .plt range, the range of the total relocation table. Note
* that one other ABI assumption seems to be that the .plt
* relocations always follow any other relocations, the
* following range checking drops that assumption.
*/
if (pltbgn) {
}
}
return (1);
}
/*
* If we're processing in lazy mode there is no need to scan the
* .rela.plt table.
*/
noplt = 1;
/*
* Loop through relocations.
*/
/*
* If this is a RELATIVE relocation in a shared object (the
* common case), and if we are not debugging, then jump into one
* of the tighter relocation loops.
*/
if ((rtype == R_SPARC_RELATIVE) &&
if (relacount) {
relacount = 0;
} else {
}
break;
}
/*
* Optimizations.
*/
if (rtype == R_SPARC_NONE)
continue;
continue;
}
if (rtype != R_SPARC_REGISTER) {
/*
* If this is a shared object, add the base address
* to offset.
*/
/*
* If this relocation is not against part of the image
* mapped into memory we skip it.
*/
rsymndx);
continue;
}
}
/*
* If we're promoting .plts, try and determine if this one has
* already been written. An uninitialized .plts' second
* instruction is a branch. Note, elf_plt_write() optimizes
* .plt relocations, and it's possible that a relocated entry
* is a branch. If this is the case, we can't tell the
* difference between an uninitialized .plt and a relocated,
* .plt that uses a branch. In this case, we'll simply redo
* the relocation calculation, which is a bit sad.
*/
if (plt) {
_roffset++;
continue;
}
binfo = 0;
pbtype = PLT_T_NONE;
/*
* If a symbol index is specified then get the symbol table
* entry, locate the symbol definition, and determine its
* address.
*/
if (rsymndx) {
/*
* Get the local symbol table entry.
*/
/*
* If this is a local symbol, just use the base address.
* (we should have no local relocations in the
* executable).
*/
name = (char *)0;
/*
* Special case TLS relocations.
*/
if (rtype == R_SPARC_TLS_DTPMOD32) {
/*
* Use the TLS modid.
*/
} else if (rtype == R_SPARC_TLS_TPOFF32) {
ret = 0;
break;
}
}
} else {
/*
* If the symbol index is equal to the previous
* symbol index relocation we processed then
* reuse the previous values. (Note that there
* have been cases where a relocation exists
* against a copy relocation symbol, our ld(1)
* should optimize this away, but make sure we
* don't use the same symbol information should
* this case exist).
*/
(rtype != R_SPARC_COPY)) {
/* LINTED */
if (psymdef == 0) {
continue;
}
/* LINTED */
/* LINTED */
/* LINTED */
/* LINTED */
/* LINTED */
/* LINTED */
&sb_flags);
}
} else {
/*
* Lookup the symbol definition.
* Initialize the symbol lookup data
* structure.
*/
/*
* If the symbol is not found and the
* reference was not to a weak symbol,
* report an error. Weak references
* may be unresolved.
*/
/* BEGIN CSTYLED */
if (symdef == 0) {
continue;
ret = 0;
break;
} else {
psymdef = 0;
continue;
}
}
/* END CSTYLED */
/*
* If symbol was found in an object
* other than the referencing object
* then record the binding.
*/
FL1_RT_NOINIFIN) == 0)) {
AL_CNT_RELBIND) == 0) {
ret = 0;
break;
}
}
/*
* Calculate the location of definition;
* symbol value plus base address of
* containing shared object.
*/
else
STT_TLS))
/*
* Retain this symbol index and the
* value in case it can be used for the
* subsequent relocations.
*/
if (rtype != R_SPARC_COPY) {
}
&sb_flags);
}
}
/*
* If relocation is PC-relative, subtract
* offset address.
*/
if (IS_PC_RELATIVE(rtype))
/*
* Special case TLS relocations.
*/
if (rtype == R_SPARC_TLS_DTPMOD32) {
/*
* Relocation value is the TLS modid.
*/
} else if (rtype == R_SPARC_TLS_TPOFF32) {
value)) == 0) {
ret = 0;
break;
}
}
}
} else {
/*
* Special cases.
*/
if (rtype == R_SPARC_REGISTER) {
/*
* A register symbol associated with symbol
* index 0 is initialized (i.e. relocated) to
* a constant in the r_addend field rather than
* to a symbol value.
*/
value = 0;
} else if (rtype == R_SPARC_TLS_DTPMOD32) {
/*
* TLS relocation value is the TLS modid.
*/
} else
name = (char *)0;
}
/*
* Make sure the segment is writable.
*/
if ((rtype != R_SPARC_REGISTER) &&
ret = 0;
break;
}
/*
* Call relocation routine to perform required relocation.
*/
switch (rtype) {
case R_SPARC_REGISTER:
/*
* The v9 ABI 4.2.4 says that system objects may,
* but are not required to, use register symbols
* to inidcate how they use global registers. Thus
* at least %g6, %g7 must be allowed in addition
* to %g2 and %g3.
*/
if (roffset == STO_SPARC_REGISTER_G1) {
} else if (roffset == STO_SPARC_REGISTER_G2) {
} else if (roffset == STO_SPARC_REGISTER_G3) {
} else if (roffset == STO_SPARC_REGISTER_G4) {
} else if (roffset == STO_SPARC_REGISTER_G5) {
} else if (roffset == STO_SPARC_REGISTER_G6) {
} else if (roffset == STO_SPARC_REGISTER_G7) {
} else {
ret = 0;
break;
}
break;
case R_SPARC_COPY:
ret = 0;
break;
case R_SPARC_JMP_SLOT:
vaddr = 0;
else
int fail = 0;
if (fail)
ret = 0;
} else {
/*
* Write standard PLT entry to jump directly
* to newly bound function.
*/
pltndx);
}
break;
default:
/*
* Write the relocation out. If this relocation is a
* common basic write, skip the doreloc() engine.
*/
if ((rtype == R_SPARC_GLOB_DAT) ||
(rtype == R_SPARC_32)) {
if (roffset & 0x3) {
0, &inv_buf),
ret = 0;
} else
} else {
ret = 0;
}
/*
* The value now contains the 'bit-shifted' value that
* was or'ed into memory (this was set by
* do_reloc_rtld()).
*/
/*
* If this relocation is against a text segment, make
* sure that the instruction cache is flushed.
*/
if (textrel)
}
if ((ret == 0) &&
break;
if (binfo) {
}
}
}
/*
* Provide a machine specific interface to the conversion routine. By calling
* the machine specific version, rather than the generic version, we insure that
* ld.so.1.
*/
const char *
{
static Conv_inv_buf_t inv_buf;
}