OpenSolaris_b135/cmd/sgs/rtld/sparc/boot_elf.s
/*
* 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) 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"
#include <link.h>
#include "machdep.h"
#include "_audit.h"
#if defined(lint)
#include <sys/types.h>
#include "_rtld.h"
#else
#include <sys/stack.h>
#include <sys/asm_linkage.h>
.file "boot_elf.s"
.seg ".text"
#endif
/*
* We got here because the initial call to a function resolved to a procedure
* linkage table entry. That entry did a branch to the first PLT entry, which
* in turn did a call to elf_rtbndr (refer elf_plt_init()).
*
* the code sequence that got us here was:
*
* PLT entry for foo():
* sethi (.-PLT0), %g1 ! not changed by rtld
* ba,a .PLT0 ! patched atomically 2nd
* nop ! patched first
*
* Therefore on entry, %i7 has the address of the call, which will be added
* to the offset to the plt entry in %g1 to calculate the plt entry address
* we must also subtract 4 because the address of PLT0 points to the
* save instruction before the call.
*
* the plt entry is rewritten:
*
* PLT entry for foo():
* sethi (.-PLT0), %g1
* sethi %hi(entry_pt), %g1
* jmpl %g1 + %lo(entry_pt), %g0
*/
#if defined(lint)
extern unsigned long elf_bndr(Rt_map *, unsigned long, caddr_t);
static void
elf_rtbndr(Rt_map *lmp, unsigned long pltoff, caddr_t from)
{
(void) elf_bndr(lmp, pltoff, from);
}
#else
.weak _elf_rtbndr ! keep dbx happy as it likes to
_elf_rtbndr = elf_rtbndr ! rummage around for our symbols
.global elf_rtbndr
.type elf_rtbndr, #function
.align 4
elf_rtbndr:
mov %i7, %o0 ! Save callers address(profiling)
save %sp, -SA(MINFRAME), %sp ! Make a frame
srl %g1, 10, %o1 ! shift offset set by sethi
! %o1 has offset from jump slot
! to PLT0 which will be used to
! calculate plt relocation entry
! by elf_bndr
ld [%i7 + 8], %o0 ! %o0 has ptr to lm
call elf_bndr ! returns function address in %o0
mov %i0, %o2 ! Callers address is arg 3
mov %o0, %g1 ! save address of routine binded
restore ! how many restores needed ? 2
jmp %g1 ! jump to it
restore
.size elf_rtbndr, . - elf_rtbndr
#endif
#if defined(lint)
void
iflush_range(caddr_t addr, size_t len)
{
/* LINTED */
uintptr_t base;
base = (uintptr_t)addr & ~7; /* round down to 8 byte alignment */
len = (len + 7) & ~7; /* round up to multiple of 8 bytes */
for (len -= 8; (long)len >= 0; len -= 8)
/* iflush(base + len) */;
}
#else
ENTRY(iflush_range)
add %o1, 7, %o1
andn %o0, 7, %o0
andn %o1, 7, %o1
1: subcc %o1, 8, %o1
bge,a 1b
iflush %o0 + %o1
retl
nop
SET_SIZE(iflush_range)
#endif
/*
* Initialize the first plt entry so that function calls go to elf_rtbndr
*
* The first plt entry (PLT0) is:
*
* save %sp, -64, %sp
* call elf_rtbndr
* nop
* address of lm
*/
#if defined(lint)
void
elf_plt_init(void *plt, caddr_t lmp)
{
*((uint_t *)plt + 0) = (unsigned long) M_SAVESP64;
*((uint_t *)plt + 4) = M_CALL | (((unsigned long)elf_rtbndr -
((unsigned long)plt)) >> 2);
*((uint_t *)plt + 8) = M_NOP;
*((uint_t *)plt + 12) = (unsigned long) lmp;
}
#else
.global elf_plt_init
.type elf_plt_init, #function
.align 4
elf_plt_init:
save %sp, -SA(MINFRAME), %sp ! Make a frame
1:
call 2f
sethi %hi((_GLOBAL_OFFSET_TABLE_ - (1b - .))), %l7
2:
sethi %hi(M_SAVESP64), %o0 ! Get save instruction
or %o0, %lo(M_SAVESP64), %o0
or %l7, %lo((_GLOBAL_OFFSET_TABLE_ - (1b - .))), %l7
st %o0, [%i0] ! Store in plt[0]
iflush %i0
add %l7, %o7, %l7
ld [%l7 + elf_rtbndr], %l7
inc 4, %i0 ! Bump plt to point to plt[1]
sub %l7, %i0, %o0 ! Determine -pc so as to produce
! offset from plt[1]
srl %o0, 2, %o0 ! Express offset as number of words
sethi %hi(M_CALL), %o4 ! Get sethi instruction
or %o4, %o0, %o4 ! Add elf_rtbndr address
st %o4, [%i0] ! Store instruction in plt
iflush %i0
sethi %hi(M_NOP), %o0 ! Generate nop instruction
st %o0, [%i0 + 4] ! Store instruction in plt[2]
iflush %i0 + 4
st %i1, [%i0 + 8] ! Store instruction in plt[3]
iflush %i0 + 8
ret
restore
.size elf_plt_init, . - elf_plt_init
#endif
#if defined(lint)
ulong_t
elf_plt_trace()
{
return (0);
}
#else
.global elf_plt_trace
.type elf_plt_trace, #function
.align 4
/*
* The dyn_plt that called us has already created a stack-frame for
* us and placed the following entries in it:
*
* [%fp - 0x4] * dyndata
* [%fp - 0x8] * prev stack size
*
* dyndata currently contains:
*
* dyndata:
* 0x0 uintptr_t *reflmp
* 0x4 uintptr_t *deflmp
* 0x8 ulong_t symndx
* 0xc ulong_t sb_flags
* 0x10 Sym symdef.st_name
* 0x14 symdef.st_value
* 0x18 symdef.st_size
* 0x1c symdef.st_info
* 0x1d symdef.st_other
* 0x1e symdef.st_shndx
*/
#define REFLMP_OFF 0x0
#define DEFLMP_OFF 0x4
#define SYMNDX_OFF 0x8
#define SBFLAGS_OFF 0xc
#define SYMDEF_OFF 0x10
#define SYMDEF_VALUE_OFF 0x14
elf_plt_trace:
1: call 2f
sethi %hi(_GLOBAL_OFFSET_TABLE_+(.-1b)), %l7
2: or %l7, %lo(_GLOBAL_OFFSET_TABLE_+(.-1b)), %l7
add %l7, %o7, %l7
ld [%l7+audit_flags], %l3
ld [%l3], %l3 ! %l3 = audit_flags
andcc %l3, AF_PLTENTER, %g0
beq .end_pltenter
ld [%fp + -0x4], %l1 ! l1 = * dyndata
ld [%l1 + SBFLAGS_OFF], %l2 ! l2 = sb_flags
andcc %l2, LA_SYMB_NOPLTENTER, %g0
beq .start_pltenter
ld [%l1 + SYMDEF_VALUE_OFF], %l0 ! l0 =
! sym.st_value(calling address)
ba .end_pltenter
nop
/*
* save all registers into La_sparcv8_regs
*/
.start_pltenter:
sub %sp, 0x20, %sp ! create space for La_sparcv8_regs
! storage on the stack.
sub %fp, 0x28, %o4
st %i0, [%o4]
st %i1, [%o4 + 0x4]
st %i2, [%o4 + 0x8]
st %i3, [%o4 + 0xc] ! because a regwindow shift has
st %i4, [%o4 + 0x10] ! already occured our current %i*
st %i5, [%o4 + 0x14] ! register's are the equivalent of
st %i6, [%o4 + 0x18] ! the %o* registers that the final
st %i7, [%o4 + 0x1c] ! procedure shall see.
ld [%fp + -0x4], %l1 ! %l1 == * dyndata
ld [%l1 + REFLMP_OFF], %o0 ! %o0 = reflmp
ld [%l1 + DEFLMP_OFF], %o1 ! %o1 = deflmp
add %l1, SYMDEF_OFF, %o2 ! %o2 = symp
ld [%l1 + SYMNDX_OFF], %o3 ! %o3 = symndx
call audit_pltenter
add %l1, SBFLAGS_OFF, %o5 ! %o3 = * sb_flags
mov %o0, %l0 ! %l0 == calling address
add %sp, 0x20, %sp ! cleanup La_sparcv8_regs off
! of the stack.
.end_pltenter:
/*
* If *no* la_pltexit() routines exist we do not need to keep the
* stack frame before we call the actual routine. Instead we jump to
* it and remove our self from the stack at the same time.
*/
ld [%l7+audit_flags], %l3
ld [%l3], %l3 ! %l3 = audit_flags
andcc %l3, AF_PLTEXIT, %g0
beq .bypass_pltexit
ld [%fp + -0x4], %l1 ! %l1 = * dyndata
ld [%l1 + SBFLAGS_OFF], %l2 ! %l2 = sb_flags
andcc %l2, LA_SYMB_NOPLTEXIT, %g0
bne .bypass_pltexit
nop
ba .start_pltexit
nop
.bypass_pltexit:
jmpl %l0, %g0
restore
.start_pltexit:
/*
* In order to call la_pltexit() we must duplicate the
* arguments from the 'callers' stack on our stack frame.
*
* First we check the size of the callers stack and grow
* our stack to hold any of the arguments. That need
* duplicating (these are arguments 6->N), because the
* first 6 (0->5) are passed via register windows on sparc.
*/
/*
* The first calculation is to determine how large the
* argument passing area might be. Since there is no
* way to distinquish between 'argument passing' and
* 'local storage' from the previous stack this amount must
* cover both.
*/
ld [%fp + -0x8], %l1 ! %l1 = callers stack size
sub %l1, 0x58, %l1 ! %l1 = argument space on caller's
! stack
/*
* Next we compare the prev. stack size against the audit_argcnt.
* We copy at most 'audit_argcnt' arguments.
*
* NOTE: on sparc we always copy at least six args since these
* are in reg-windows and not on the stack.
*
* NOTE: Also note that we multiply (shift really) the arg count
* by 4 which is the 'word size' to calculate the amount
* of stack space needed.
*/
ld [%l7 + audit_argcnt], %l2
ld [%l2], %l2 ! %l2 = audit_arg_count
cmp %l2, 6
ble .grow_stack
sub %l2, 6, %l2
sll %l2, 2, %l2
cmp %l1, %l2
ble .grow_stack
nop
mov %l2, %l1
.grow_stack:
/*
* When duplicating the stack we skip the first '0x5c' bytes.
* This is the space on the stack reserved for preserving
* the register windows and such and do not need to be duplicated
* on this new stack frame. We start duplicating at the
* portion of the stack reserved for argument's above 6.
*/
sub %sp, %l1, %sp ! grow our stack by amount required.
sra %l1, 0x2, %l1 ! %l1 = %l1 / 4 (words to copy)
mov 0x5c, %l2 ! %l2 = index into stack & frame
1:
cmp %l1, 0
ble 2f
nop
ld [%fp + %l2], %l3 ! duplicate args from previous
st %l3, [%sp + %l2] ! stack onto current stack
add %l2, 0x4, %l2
ba 1b
sub %l1, 0x1, %l1
2:
mov %i0, %o0 ! copy ins to outs
mov %i1, %o1
mov %i2, %o2
mov %i3, %o3
mov %i4, %o4
call %l0 ! call routine
mov %i5, %o5
mov %o1, %l2 ! l2 = second 1/2 of return value
! for those those 64 bit operations
! link div64 - yuck...
! %o0 = retval
ld [%fp + -0x4], %l1
ld [%l1 + REFLMP_OFF], %o1 ! %o1 = reflmp
ld [%l1 + DEFLMP_OFF], %o2 ! %o2 = deflmp
add %l1, SYMDEF_OFF, %o3 ! %o3 = symp
call audit_pltexit
ld [%l1 + SYMNDX_OFF], %o4 ! %o4 = symndx
mov %o0, %i0 ! pass on return code
mov %l2, %i1
ret
restore
.size elf_plt_trace, . - elf_plt_trace
#endif
/*
* After the first call to a plt, elf_bndr() will have determined the true
* address of the function being bound. The plt is now rewritten so that
* any subsequent calls go directly to the bound function. If the library
* to which the function belongs is being profiled refer to _plt_cg_write.
*
* the new plt entry is:
*
* sethi (.-PLT0), %g1 ! constant
* sethi %hi(function address), %g1 ! patched second
* jmpl %g1 + %lo(function address, %g0 ! patched first
*/
#if defined(lint)
void
plt_full_range(uintptr_t pc, uintptr_t symval)
{
uint_t * plttab = (uint_t *)pc;
plttab[2] = (M_JMPL | ((unsigned long)symval & S_MASK(10)));
plttab[1] = (M_SETHIG1 | ((unsigned long)symval >> (32 - 22)));
}
#else
ENTRY(plt_full_range)
sethi %hi(M_JMPL), %o3 ! Get jmpl instruction
and %o1, 0x3ff, %o2 ! Lower part of function address
or %o3, %o2, %o3 ! is or'ed into instruction
st %o3, [%o0 + 8] ! Store instruction in plt[2]
iflush %o0 + 8
stbar
srl %o1, 10, %o1 ! Get high part of function address
sethi %hi(M_SETHIG1), %o3 ! Get sethi instruction
or %o3, %o1, %o3 ! Add sethi and function address
st %o3, [%o0 + 4] ! Store instruction in plt[1]
retl
iflush %o0 + 4
SET_SIZE(plt_full_range)
#endif /* defined(lint) */