Remove DEC Alpha and PC98 support.
[dragonfly.git] / libexec / rtld-elf / alpha / rtld_start.S
1 /* $FreeBSD: src/libexec/rtld-elf/alpha/rtld_start.S,v 1.3.2.2 2002/09/02 02:10:20 obrien Exp $ */
2 /* $DragonFly: src/libexec/rtld-elf/alpha/Attic/rtld_start.S,v 1.2 2003/06/17 04:27:08 dillon Exp $     */
3 /*      From: NetBSD: rtld_start.S,v 1.1 1996/12/16 20:38:09 cgd Exp    */
4
5 /*
6  * Copyright 1996 Matt Thomas <matt@3am-software.com>
7  * Copyright 2000 John D. Polstra
8  * All rights reserved.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  * 3. The name of the author may not be used to endorse or promote products
19  *    derived from this software without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
22  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
23  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
24  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
25  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
26  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
30  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31  */
32
33 #include <machine/asm.h>
34 #include <machine/pal.h>
35
36 .extern _GLOBAL_OFFSET_TABLE_
37 .extern _GOT_END_
38
39 LEAF(_rtld_start, 0)            /* XXX */
40         .set    noreorder
41         br      pv, $33
42 $33:    LDGP(pv)
43
44         /* save away the stack pointer */
45
46         lda     s0, 0(sp)       /* get argc from stack */
47         lda     sp, -16(sp)     /* space for arguments */
48
49         /* save ps_strings pointer */
50         mov     a3, s1
51
52         /* Step 1 -- Figure out the displacement */
53
54         br      t2, $34         /* get our PC */
55 $34:    ldiq    t3, $34         /* get where the linker thought we were */
56         subq    t2, t3, t8      /* calculate the displacement */
57
58
59         /* Step 2 -- Find bounds of global offset table */
60
61         lda     t5, _GLOBAL_OFFSET_TABLE_
62         addq    t8, t5, t9      /* add the displacement */
63         lda     t4, _GOT_END_
64         addq    t8, t4, t10     /* add the displacement */
65
66         /*
67          * Step 3 -- Every entry in the global offset table needs to
68          * modified for the displacement before any code will work.
69          */
70
71 $35:    ldq     t1, 0(t9)       /* load the value */
72         addq    t8, t1, t1      /* add the displacement */
73         stq     t1, 0(t9)       /* save the new value */
74         lda     t9, 8(t9)       /* point to next entry */
75         cmpult  t9, t10, t1     /* are we done? */
76         bne     t1, $35         /* no, do more */
77
78         /*
79          *  Ya!  Things are far enough so we can do some dynamic linking!
80          */
81
82         lda     a0, 0(s0)       /* initial sp */
83         lda     a1, -16(s0)     /* address for exit proc */
84         lda     a2, -8(s0)      /* address for obj_main */
85         CALL(_rtld)             /* v0 = _rtld(sp, &exit_proc, &obj_main); */
86
87         ldq     a1, -16(s0)     /* our atexit function */
88         ldq     a2, -8(s0)      /* obj_main entry */
89         lda     sp, 16(sp)      /* readjust our stack */
90         mov     s0, a0          /* stack pointer */
91         mov     s1, a3          /* ps_strings pointer */
92         mov     v0, pv
93         jsr     ra, (v0), 0     /* (*_start)(sp, cleanup, obj); */
94         ldgp    gp, 0(ra)
95
96         CALL(exit)
97         halt
98 END(_rtld_start)
99
100 #define RTLD_BIND_START_PROLOGUE                                        \
101         /* at_reg already used by PLT code. */                          \
102         .set    noat                                            ;       \
103                                                                         \
104         /*                                                              \
105          * Allocate stack frame and preserve all registers that the     \
106          * caller would have normally saved themselves.                 \
107          */                                                             \
108         lda     sp, -168(sp)                                    ;       \
109         stq     ra, 0(sp)                                       ;       \
110         stq     v0, 8(sp)                                       ;       \
111         stq     t0, 16(sp)                                      ;       \
112         stq     t1, 24(sp)                                      ;       \
113         stq     t2, 32(sp)                                      ;       \
114         stq     t3, 40(sp)                                      ;       \
115         stq     t4, 48(sp)                                      ;       \
116         stq     t5, 56(sp)                                      ;       \
117         stq     t6, 64(sp)                                      ;       \
118         stq     t7, 72(sp)                                      ;       \
119         stq     a0, 80(sp)                                      ;       \
120         stq     a1, 88(sp)                                      ;       \
121         stq     a2, 96(sp)                                      ;       \
122         stq     a3, 104(sp)                                     ;       \
123         stq     a4, 112(sp)                                     ;       \
124         stq     a5, 120(sp)                                     ;       \
125         stq     t8, 128(sp)                                     ;       \
126         stq     t9, 136(sp)                                     ;       \
127         stq     t10, 144(sp)                                    ;       \
128         stq     t11, 152(sp)                                    ;       \
129         stq     gp, 160(sp)                                     ;       \
130                                                                         \
131         /*                                                              \
132          * Load our global pointer.  Note, can't use pv, since it is    \
133          * already used by the PLT code.                                \
134          */                                                             \
135         br      t0, 1f                                          ;       \
136 1:      LDGP(t0)
137
138 #define RTLD_BIND_START_EPILOGUE                                        \
139         /* Move the destination address into position. */               \
140         mov     v0, pv                                          ;       \
141                                                                         \
142         /* Restore program registers. */                                \
143         ldq     ra, 0(sp)                                       ;       \
144         ldq     v0, 8(sp)                                       ;       \
145         ldq     t0, 16(sp)                                      ;       \
146         ldq     t1, 24(sp)                                      ;       \
147         ldq     t2, 32(sp)                                      ;       \
148         ldq     t3, 40(sp)                                      ;       \
149         ldq     t4, 48(sp)                                      ;       \
150         ldq     t5, 56(sp)                                      ;       \
151         ldq     t6, 64(sp)                                      ;       \
152         ldq     t7, 72(sp)                                      ;       \
153         ldq     a0, 80(sp)                                      ;       \
154         ldq     a1, 88(sp)                                      ;       \
155         ldq     a2, 96(sp)                                      ;       \
156         ldq     a3, 104(sp)                                     ;       \
157         ldq     a4, 112(sp)                                     ;       \
158         ldq     a5, 120(sp)                                     ;       \
159         ldq     t8, 128(sp)                                     ;       \
160         ldq     t9, 136(sp)                                     ;       \
161         ldq     t10, 144(sp)                                    ;       \
162         ldq     t11, 152(sp)                                    ;       \
163         ldq     gp, 160(sp)                                     ;       \
164         /* XXX LDGP? */                                                 \
165                                                                         \
166         /*                                                              \
167          * We've patched the PLT; sync the I-stream.                    \
168          */                                                             \
169         imb                                                     ;       \
170                                                                         \
171         /* Pop the stack frame and turn control to the destination. */  \
172         lda     sp, 168(sp)                                     ;       \
173         jmp     zero, (pv)
174
175
176 /*
177  * Lazy binding entry point, called via PLT.
178  */
179 NESTED_NOPROFILE(_rtld_bind_start, 0, 168, ra, 0, 0)
180
181         RTLD_BIND_START_PROLOGUE
182
183         /* Set up the arguments for _rtld_bind. */
184         subq    at_reg, pv, a1          /* calculate reloc offset */
185         ldq     a0, 8(pv)               /* object structure */
186         subq    a1, 20, a1              /* = (at - t11 - 20) / 12 * 24 */
187         addq    a1, a1, a1
188
189         CALL(_rtld_bind)
190
191         RTLD_BIND_START_EPILOGUE
192
193 END(_rtld_bind_start)
194
195 /*
196  * Lazy binding entry point, called via PLT.  This version is for the
197  * old PLT entry format.
198  */
199 NESTED_NOPROFILE(_rtld_bind_start_old, 0, 168, ra, 0, 0)
200
201         RTLD_BIND_START_PROLOGUE
202
203         /* Set up the arguments for _rtld_bind. */
204         ldq     a0, 8(pv)               /* object structure */
205         mov     at_reg, a1              /* offset of reloc entry */
206
207         CALL(_rtld_bind)
208
209         RTLD_BIND_START_EPILOGUE
210
211 END(_rtld_bind_start_old)
212
213 /*
214  * int cmp0_and_store_int(volatile int *p, int newval);
215  *
216  * If an int holds 0, store newval into it; else do nothing.  Returns
217  * the previous value.
218  */
219 LEAF(cmp0_and_store_int, 2)
220 1:      mov     a1, t0
221         ldl_l   v0, 0(a0)
222         bne     v0, 3f
223         stl_c   t0, 0(a0)
224         beq     t0, 2f
225         mb
226         RET
227 2:      br      1b
228 3:      RET
229 END(cmp0_and_store_int)
230
231 LEAF(atomic_add_int, 2)
232 0:      ldl_l   t0, 0(a0)
233         addq    t0, a1, t0
234         stl_c   t0, 0(a0)
235         beq     t0, 1f
236         mb
237         RET
238 1:      br      0b
239 END(atomic_add_int)
240  
241 /* Atomically increment an int. */
242 LEAF(atomic_incr_int, 1)
243 0:      ldl_l   t0, 0(a0)
244         addq    t0, 1, t0
245         stl_c   t0, 0(a0)
246         beq     t0, 1f
247         mb
248         RET
249 1:      br      0b
250 END(atomic_incr_int)
251
252 /* Atomically decrement an int. */
253 LEAF(atomic_decr_int, 1)
254 0:      ldl_l   t0, 0(a0)
255         subq    t0, 1, t0
256         stl_c   t0, 0(a0)
257         beq     t0, 1f
258         mb
259         RET
260 1:      br      0b
261 END(atomic_decr_int)