usr/src/cmd/sgs/rtld/sparc/boot_elf.s

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  *      Copyright (c) 1988 AT&T
  24  *        All Rights Reserved
  25  *
  26  * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
  27  * Use is subject to license terms.
  28  */
  29 #pragma ident   "%Z%%M% %I%     %E% SMI"
  30
  31 #include        <link.h>
  32 #include        "machdep.h"
  33 #include        "_audit.h"
  34
  35 #if     defined(lint)
  36 #include        <sys/types.h>
  37 #include        "_rtld.h"
  38 #else
  39 #include        <sys/stack.h>
  40 #include        <sys/asm_linkage.h>
  41
  42         .file   "boot_elf.s"
  43         .seg    ".text"
  44 #endif
  45
  46 /*
  47  * We got here because the initial call to a function resolved to a procedure
  48  * linkage table entry.  That entry did a branch to the first PLT entry, which
  49  * in turn did a call to elf_rtbndr (refer elf_plt_init()).
  50  *
  51  * the code sequence that got us here was:
  52  *
  53  * PLT entry for foo():
  54  *      sethi   (.-PLT0), %g1                   ! not changed by rtld
  55  *      ba,a    .PLT0                           ! patched atomically 2nd
  56  *      nop                                     ! patched first
  57  *
  58  * Therefore on entry, %i7 has the address of the call, which will be added
  59  * to the offset to the plt entry in %g1 to calculate the plt entry address
  60  * we must also subtract 4 because the address of PLT0 points to the
  61  * save instruction before the call.
  62  *
  63  * the plt entry is rewritten:
  64  *
  65  * PLT entry for foo():
  66  *      sethi   (.-PLT0), %g1
  67  *      sethi   %hi(entry_pt), %g1
  68  *      jmpl    %g1 + %lo(entry_pt), %g0
  69  */
  70
  71 #if     defined(lint)
  72
  73 extern unsigned long    elf_bndr(Rt_map *, unsigned long, caddr_t);
  74
  75 static void
  76 elf_rtbndr(Rt_map *lmp, unsigned long pltoff, caddr_t from)
  77 {
  78         (void) elf_bndr(lmp, pltoff, from);
  79 }
  80
  81
  82 #else
  83         .weak   _elf_rtbndr             ! keep dbx happy as it likes to
  84         _elf_rtbndr = elf_rtbndr        ! rummage around for our symbols
  85
  86         .global elf_rtbndr
  87         .type   elf_rtbndr, #function
  88         .align  4
  89
  90 elf_rtbndr:
  91         mov     %i7, %o0                ! Save callers address(profiling)
  92         save    %sp, -SA(MINFRAME), %sp ! Make a frame
  93         srl     %g1, 10, %o1            ! shift offset set by sethi
  94                                         ! %o1 has offset from jump slot
  95                                         ! to PLT0 which will be used to
  96                                         ! calculate plt relocation entry
  97                                         ! by elf_bndr
  98         ld      [%i7 + 8], %o0          ! %o0 has ptr to lm
  99         call    elf_bndr                ! returns function address in %o0
 100         mov     %i0, %o2                ! Callers address is arg 3
 101         mov     %o0, %g1                ! save address of routine binded
 102         restore                         ! how many restores needed ? 2
 103         jmp     %g1                     ! jump to it
 104         restore
 105         .size   elf_rtbndr, . - elf_rtbndr
 106
 107 #endif
 108
 109
 110 #if defined(lint)
 111 void
 112 iflush_range(caddr_t addr, size_t len)
 113 {
 114         /* LINTED */
 115         uintptr_t base;
 116
 117         base = (uintptr_t)addr & ~7;    /* round down to 8 byte alignment */
 118         len = (len + 7) & ~7;           /* round up to multiple of 8 bytes */
 119         for (len -= 8; (long)len >= 0; len -= 8)
 120                 /* iflush(base + len) */;
 121 }
 122 #else
 123         ENTRY(iflush_range)
 124         add     %o1, 7, %o1
 125         andn    %o0, 7, %o0
 126         andn    %o1, 7, %o1
 127 1:      subcc   %o1, 8, %o1
 128         bge,a   1b
 129         iflush  %o0 + %o1
 130         retl
 131         nop
 132         SET_SIZE(iflush_range)
 133 #endif
 134
 135 /*
 136  * Initialize the first plt entry so that function calls go to elf_rtbndr
 137  *
 138  * The first plt entry (PLT0) is:
 139  *
 140  *      save    %sp, -64, %sp
 141  *      call    elf_rtbndr
 142  *      nop
 143  *      address of lm
 144  */
 145
 146 #if     defined(lint)
 147
 148 void
 149 elf_plt_init(void *plt, caddr_t lmp)
 150 {
 151         *((uint_t *)plt + 0) = (unsigned long) M_SAVESP64;
 152         *((uint_t *)plt + 4) = M_CALL | (((unsigned long)elf_rtbndr -
 153                         ((unsigned long)plt)) >> 2);
 154         *((uint_t *)plt + 8) = M_NOP;
 155         *((uint_t *)plt + 12) = (unsigned long) lmp;
 156 }
 157
 158 #else
 159         .global elf_plt_init
 160         .type   elf_plt_init, #function
 161         .align  4
 162
 163 elf_plt_init:
 164         save    %sp, -SA(MINFRAME), %sp ! Make a frame
 165 1:
 166         call    2f
 167         sethi   %hi((_GLOBAL_OFFSET_TABLE_ - (1b - .))), %l7
 168 2:
 169         sethi   %hi(M_SAVESP64), %o0    ! Get save instruction
 170         or      %o0, %lo(M_SAVESP64), %o0
 171         or      %l7, %lo((_GLOBAL_OFFSET_TABLE_ - (1b - .))), %l7
 172         st      %o0, [%i0]              ! Store in plt[0]
 173         iflush  %i0
 174         add     %l7, %o7, %l7
 175         ld      [%l7 + elf_rtbndr], %l7
 176         inc     4, %i0                  ! Bump plt to point to plt[1]
 177         sub     %l7, %i0, %o0           ! Determine -pc so as to produce
 178                                         ! offset from plt[1]
 179         srl     %o0, 2, %o0             ! Express offset as number of words
 180         sethi   %hi(M_CALL), %o4        ! Get sethi instruction
 181         or      %o4, %o0, %o4           ! Add elf_rtbndr address
 182         st      %o4, [%i0]              ! Store instruction in plt
 183         iflush  %i0
 184         sethi   %hi(M_NOP), %o0         ! Generate nop instruction
 185         st      %o0, [%i0 + 4]          ! Store instruction in plt[2]
 186         iflush  %i0 + 4
 187         st      %i1, [%i0 + 8]          ! Store instruction in plt[3]
 188         iflush  %i0 + 8
 189         ret
 190         restore
 191         .size   elf_plt_init, . - elf_plt_init
 192 #endif
 193
 194 #if     defined(lint)
 195
 196 ulong_t
 197 elf_plt_trace()
 198 {
 199         return (0);
 200 }
 201 #else
 202         .global elf_plt_trace
 203         .type   elf_plt_trace, #function
 204         .align  4
 205
 206 /*
 207  * The dyn_plt that called us has already created a stack-frame for
 208  * us and placed the following entries in it:
 209  *
 210  *      [%fp - 0x4]     * dyndata
 211  *      [%fp - 0x8]     * prev stack size
 212  *
 213  * dyndata currently contains:
 214  *
 215  *      dyndata:
 216  *      0x0     uintptr_t       *reflmp
 217  *      0x4     uintptr_t       *deflmp
 218  *      0x8     ulong_t         symndx
 219  *      0xc     ulong_t         sb_flags
 220  *      0x10    Sym             symdef.st_name
 221  *      0x14                    symdef.st_value
 222  *      0x18                    symdef.st_size
 223  *      0x1c                    symdef.st_info
 224  *      0x1d                    symdef.st_other
 225  *      0x1e                    symdef.st_shndx
 226  */
 227 #define REFLMP_OFF              0x0
 228 #define DEFLMP_OFF              0x4
 229 #define SYMNDX_OFF              0x8
 230 #define SBFLAGS_OFF             0xc
 231 #define SYMDEF_OFF              0x10
 232 #define SYMDEF_VALUE_OFF        0x14
 233
 234 elf_plt_trace:
 235 1:      call    2f
 236         sethi   %hi(_GLOBAL_OFFSET_TABLE_+(.-1b)), %l7
 237 2:      or      %l7, %lo(_GLOBAL_OFFSET_TABLE_+(.-1b)), %l7
 238         add     %l7, %o7, %l7
 239
 240         ld      [%l7+audit_flags], %l3
 241         ld      [%l3], %l3              ! %l3 = audit_flags
 242         andcc   %l3, AF_PLTENTER, %g0
 243         beq     .end_pltenter
 244         ld      [%fp + -0x4], %l1       ! l1 = * dyndata
 245         ld      [%l1 + SBFLAGS_OFF], %l2 ! l2 = sb_flags
 246         andcc   %l2, LA_SYMB_NOPLTENTER, %g0
 247         beq     .start_pltenter
 248         ld      [%l1 + SYMDEF_VALUE_OFF], %l0   ! l0 =
 249                                                 !  sym.st_value(calling address)
 250         ba      .end_pltenter
 251         nop
 252
 253         /*
 254          * save all registers into La_sparcv8_regs
 255          */
 256 .start_pltenter:
 257         sub     %sp, 0x20, %sp          ! create space for La_sparcv8_regs
 258                                         ! storage on the stack.
 259
 260         sub     %fp, 0x28, %o4
 261
 262         st      %i0, [%o4]
 263         st      %i1, [%o4 + 0x4]
 264         st      %i2, [%o4 + 0x8]
 265         st      %i3, [%o4 + 0xc]        ! because a regwindow shift has
 266         st      %i4, [%o4 + 0x10]       ! already occured our current %i*
 267         st      %i5, [%o4 + 0x14]       ! register's are the equivalent of
 268         st      %i6, [%o4 + 0x18]       ! the %o* registers that the final
 269         st      %i7, [%o4 + 0x1c]       ! procedure shall see.
 270
 271         ld      [%fp + -0x4], %l1       ! %l1 == * dyndata
 272         ld      [%l1 + REFLMP_OFF], %o0 ! %o0 = reflmp
 273         ld      [%l1 + DEFLMP_OFF], %o1 ! %o1 = deflmp
 274         add     %l1, SYMDEF_OFF, %o2    ! %o2 = symp
 275         ld      [%l1 + SYMNDX_OFF], %o3 ! %o3 = symndx
 276         call    audit_pltenter
 277         add     %l1, SBFLAGS_OFF, %o5   ! %o3 = * sb_flags
 278
 279         mov     %o0, %l0                ! %l0 == calling address
 280
 281         add     %sp, 0x20, %sp          ! cleanup La_sparcv8_regs off
 282                                         ! of the stack.
 283
 284 .end_pltenter:
 285         /*
 286          * If *no* la_pltexit() routines exist we do not need to keep the
 287          * stack frame before we call the actual routine.  Instead we jump to
 288          * it and remove our self from the stack at the same time.
 289          */
 290         ld      [%l7+audit_flags], %l3
 291         ld      [%l3], %l3              ! %l3 = audit_flags
 292         andcc   %l3, AF_PLTEXIT, %g0
 293         beq     .bypass_pltexit
 294         ld      [%fp + -0x4], %l1       ! %l1 = * dyndata
 295         ld      [%l1 + SBFLAGS_OFF], %l2 ! %l2 = sb_flags
 296         andcc   %l2, LA_SYMB_NOPLTEXIT, %g0
 297         bne     .bypass_pltexit
 298         nop
 299
 300         ba      .start_pltexit
 301         nop
 302 .bypass_pltexit:
 303         jmpl    %l0, %g0
 304         restore
 305
 306 .start_pltexit:
 307         /*
 308          * In order to call la_pltexit() we must duplicate the
 309          * arguments from the 'callers' stack on our stack frame.
 310          *
 311          * First we check the size of the callers stack and grow
 312          * our stack to hold any of the arguments.  That need
 313          * duplicating (these are arguments 6->N), because the
 314          * first 6 (0->5) are passed via register windows on sparc.
 315          */
 316
 317         /*
 318          * The first calculation is to determine how large the
 319          * argument passing area might be.  Since there is no
 320          * way to distinquish between 'argument passing' and
 321          * 'local storage' from the previous stack this amount must
 322          * cover both.
 323          */
 324         ld      [%fp + -0x8], %l1       ! %l1 = callers stack size
 325         sub     %l1, 0x58, %l1          ! %l1 = argument space on caller's
 326                                         !       stack
 327         /*
 328          * Next we compare the prev. stack size against the audit_argcnt.
 329          * We copy at most 'audit_argcnt' arguments.
 330          *
 331          * NOTE: on sparc we always copy at least six args since these
 332          *       are in reg-windows and not on the stack.
 333          *
 334          * NOTE: Also note that we multiply (shift really) the arg count
 335          *       by 4 which is the 'word size' to calculate the amount
 336          *       of stack space needed.
 337          */
 338         ld      [%l7 + audit_argcnt], %l2
 339         ld      [%l2], %l2              ! %l2 = audit_arg_count
 340         cmp     %l2, 6
 341         ble     .grow_stack
 342         sub     %l2, 6, %l2
 343         sll     %l2, 2, %l2
 344         cmp     %l1, %l2
 345         ble     .grow_stack
 346         nop
 347         mov     %l2, %l1
 348 .grow_stack:
 349         /*
 350          * When duplicating the stack we skip the first '0x5c' bytes.
 351          * This is the space on the stack reserved for preserving
 352          * the register windows and such and do not need to be duplicated
 353          * on this new stack frame.  We start duplicating at the
 354          * portion of the stack reserved for argument's above 6.
 355          */
 356         sub     %sp, %l1, %sp           ! grow our stack by amount required.
 357         sra     %l1, 0x2, %l1           ! %l1 = %l1 / 4 (words to copy)
 358         mov     0x5c, %l2               ! %l2 = index into stack & frame
 359
 360 1:
 361         cmp     %l1, 0
 362         ble     2f
 363         nop
 364         ld      [%fp + %l2], %l3        ! duplicate args from previous
 365         st      %l3, [%sp + %l2]        ! stack onto current stack
 366         add     %l2, 0x4, %l2
 367         ba      1b
 368         sub     %l1, 0x1, %l1
 369 2:
 370         mov     %i0, %o0                ! copy ins to outs
 371         mov     %i1, %o1
 372         mov     %i2, %o2
 373         mov     %i3, %o3
 374         mov     %i4, %o4
 375         call    %l0                     ! call routine
 376         mov     %i5, %o5
 377         mov     %o1, %l2                ! l2 = second 1/2 of return value
 378                                         ! for those those 64 bit operations
 379                                         ! link div64 - yuck...
 380
 381                                         ! %o0 = retval
 382         ld      [%fp + -0x4], %l1
 383         ld      [%l1 + REFLMP_OFF], %o1 ! %o1 = reflmp
 384         ld      [%l1 + DEFLMP_OFF], %o2 ! %o2 = deflmp
 385         add     %l1, SYMDEF_OFF, %o3    ! %o3 = symp
 386         call    audit_pltexit
 387         ld      [%l1 + SYMNDX_OFF], %o4 ! %o4 = symndx
 388
 389         mov     %o0, %i0                ! pass on return code
 390         mov     %l2, %i1
 391         ret
 392         restore
 393         .size   elf_plt_trace, . - elf_plt_trace
 394
 395 #endif
 396
 397 /*
 398  * After the first call to a plt, elf_bndr() will have determined the true
 399  * address of the function being bound.  The plt is now rewritten so that
 400  * any subsequent calls go directly to the bound function.  If the library
 401  * to which the function belongs is being profiled refer to _plt_cg_write.
 402  *
 403  * the new plt entry is:
 404  *
 405  *      sethi   (.-PLT0), %g1                   ! constant
 406  *      sethi   %hi(function address), %g1      ! patched second
 407  *      jmpl    %g1 + %lo(function address, %g0 ! patched first
 408  */
 409
 410 #if     defined(lint)
 411
 412 void
 413 plt_full_range(uintptr_t pc, uintptr_t symval)
 414 {
 415         uint_t *        plttab = (uint_t *)pc;
 416         plttab[2] = (M_JMPL | ((unsigned long)symval & S_MASK(10)));
 417         plttab[1] = (M_SETHIG1 | ((unsigned long)symval >> (32 - 22)));
 418 }
 419
 420 #else
 421         ENTRY(plt_full_range)
 422
 423         sethi   %hi(M_JMPL), %o3        ! Get jmpl instruction
 424         and     %o1, 0x3ff, %o2         ! Lower part of function address
 425         or      %o3, %o2, %o3           !       is or'ed into instruction
 426         st      %o3, [%o0 + 8]          ! Store instruction in plt[2]
 427         iflush  %o0 + 8
 428         stbar
 429
 430         srl     %o1, 10, %o1            ! Get high part of function address
 431         sethi   %hi(M_SETHIG1), %o3     ! Get sethi instruction
 432         or      %o3, %o1, %o3           ! Add sethi and function address
 433         st      %o3, [%o0 + 4]          ! Store instruction in plt[1]
 434         retl
 435         iflush  %o0 + 4
 436
 437         SET_SIZE(plt_full_range)
 438
 439 #endif  /* defined(lint) */
 440