Convert __FreeBSD__ tests to __FreeBSD__ and __DragonFly__ tests
[dragonfly.git] / libexec / rtld-aout / i386 / md.c
1 /*
2  * Copyright (c) 1993 Paul Kranenburg
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *      This product includes software developed by Paul Kranenburg.
16  * 4. The name of the author may not be used to endorse or promote products
17  *    derived from this software without specific prior written permission
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
20  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
21  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
22  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
23  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
24  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
28  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  *
30  * $FreeBSD: src/libexec/rtld-aout/i386/md.c,v 1.17 1999/08/28 00:10:07 peter Exp $
31  * $DragonFly: src/libexec/rtld-aout/i386/Attic/md.c,v 1.3 2004/02/13 03:49:50 dillon Exp $
32  */
33
34 #include <sys/param.h>
35 #include <stddef.h>
36 #include <stdio.h>
37 #include <stdlib.h>
38 #include <sys/types.h>
39 #include <err.h>
40 #include <fcntl.h>
41 #include <a.out.h>
42 #include <stab.h>
43 #include <string.h>
44
45 #include "dynamic.h"
46
47 #if defined(RTLD) && defined(SUN_COMPAT)
48 #define REL_SIZE(r) (2)         /* !!!!! Sun BUG compatible */
49 #else
50 #define REL_SIZE(r) ((r)->r_length)
51 #endif
52
53 /*
54  * Get relocation addend corresponding to relocation record RP
55  * from address ADDR
56  */
57 long
58 md_get_addend(rp, addr)
59 struct relocation_info  *rp;
60 unsigned char           *addr;
61 {
62         switch (REL_SIZE(rp)) {
63         case 0:
64                 return get_byte(addr);
65         case 1:
66                 return get_short(addr);
67         case 2:
68                 return get_long(addr);
69         default:
70                 errx(1, "Unsupported relocation size: %x",
71                     REL_SIZE(rp));
72         }
73 }
74
75 /*
76  * Put RELOCATION at ADDR according to relocation record RP.
77  */
78 void
79 md_relocate(rp, relocation, addr, relocatable_output)
80 struct relocation_info  *rp;
81 long                    relocation;
82 unsigned char           *addr;
83 int                     relocatable_output;
84 {
85         switch (REL_SIZE(rp)) {
86         case 0:
87                 put_byte(addr, relocation);
88                 break;
89         case 1:
90                 put_short(addr, relocation);
91                 break;
92         case 2:
93                 put_long(addr, relocation);
94                 break;
95         default:
96                 errx(1, "Unsupported relocation size: %x",
97                     REL_SIZE(rp));
98         }
99 }
100
101 /*
102  * Machine dependent part of claim_rrs_reloc().
103  * Set RRS relocation type.
104  */
105 int
106 md_make_reloc(rp, r, type)
107 struct relocation_info  *rp, *r;
108 int                     type;
109 {
110         /* Relocation size */
111         r->r_length = rp->r_length;
112
113         if (rp->r_pcrel)
114                 r->r_pcrel = 1;
115
116         if (type & RELTYPE_RELATIVE)
117                 r->r_relative = 1;
118
119         if (type & RELTYPE_COPY)
120                 r->r_copy = 1;
121
122         return 0;
123 }
124
125 /*
126  * Set up a transfer from jmpslot at OFFSET (relative to the PLT table)
127  * to the binder slot (which is at offset 0 of the PLT).
128  */
129 void
130 md_make_jmpslot(sp, offset, index)
131 jmpslot_t       *sp;
132 long            offset;
133 long            index;
134 {
135         /*
136          * i386 PC-relative "fixed point" is located right after the
137          * instruction it pertains to.
138          */
139         u_long  fudge = - (sizeof(sp->opcode) + sizeof(sp->addr) + offset);
140
141         sp->opcode = CALL;
142 #if 0
143         sp->addr =  fudge;
144 #else
145         sp->addr[0] = fudge & 0xffff;
146         sp->addr[1] = fudge >> 16;
147 #endif
148         sp->reloc_index = index;
149 }
150
151 /*
152  * Set up a "direct" transfer (ie. not through the run-time binder) from
153  * jmpslot at OFFSET to ADDR. Used by `ld' when the SYMBOLIC flag is on,
154  * and by `ld.so' after resolving the symbol.
155  * On the i386, we use the JMP instruction which is PC relative, so no
156  * further RRS relocations will be necessary for such a jmpslot.
157  */
158 void
159 md_fix_jmpslot(sp, offset, addr)
160 jmpslot_t       *sp;
161 long            offset;
162 u_long          addr;
163 {
164         u_long  fudge = addr - (sizeof(sp->opcode) + sizeof(sp->addr) + offset);
165
166         sp->opcode = JUMP;
167 #if 0
168         sp->addr = fudge;
169 #else
170         sp->addr[0] = fudge & 0xffff;
171         sp->addr[1] = fudge >> 16;
172 #endif
173         sp->reloc_index = 0;
174 }
175
176 /*
177  * Bind a jmpslot to its target address.  TARGET is where the jmpslot
178  * should jump to, and WHERE is a pointer to the jmpslot's address field.
179  * This is called by the dynamic linker when LD_BIND_NOW is set in the
180  * environment.
181  */
182 void
183 md_bind_jmpslot(target, where)
184 u_long target;
185 caddr_t where;
186 {
187         jmpslot_t       *sp =
188                 (jmpslot_t *) (where - offsetof(jmpslot_t, addr[0]));
189
190         md_fix_jmpslot(sp, (long) sp, target);
191 }
192
193 /*
194  * Update the relocation record for a RRS jmpslot.
195  */
196 void
197 md_make_jmpreloc(rp, r, type)
198 struct relocation_info  *rp, *r;
199 int                     type;
200 {
201         jmpslot_t       *sp;
202
203         /*
204          * Fix relocation address to point to the correct
205          * location within this jmpslot.
206          */
207         r->r_address += sizeof(sp->opcode);
208
209         /* Relocation size */
210         r->r_length = 2;
211
212         /* Set relocation type */
213         r->r_jmptable = 1;
214         if (type & RELTYPE_RELATIVE)
215                 r->r_relative = 1;
216
217 }
218
219 /*
220  * Set relocation type for a RRS GOT relocation.
221  */
222 void
223 md_make_gotreloc(rp, r, type)
224 struct relocation_info  *rp, *r;
225 int                     type;
226 {
227         r->r_baserel = 1;
228         if (type & RELTYPE_RELATIVE)
229                 r->r_relative = 1;
230
231         /* Relocation size */
232         r->r_length = 2;
233 }
234
235 /*
236  * Set relocation type for a RRS copy operation.
237  */
238 void
239 md_make_cpyreloc(rp, r)
240 struct relocation_info  *rp, *r;
241 {
242         /* Relocation size */
243         r->r_length = 2;
244
245         r->r_copy = 1;
246 }
247
248 void
249 md_set_breakpoint(where, savep)
250 long    where;
251 long    *savep;
252 {
253         *savep = *(long *)where;
254         *(char *)where = TRAP;
255 }
256
257 #ifndef RTLD
258
259 #if defined(__DragonFly__) || defined(__FreeBSD__)
260 int     netzmagic;
261 #endif
262
263 /*
264  * Initialize (output) exec header such that useful values are
265  * obtained from subsequent N_*() macro evaluations.
266  */
267 void
268 md_init_header(hp, magic, flags)
269 struct exec     *hp;
270 int             magic, flags;
271 {
272 #ifdef NetBSD
273         if (oldmagic || magic == QMAGIC)
274                 hp->a_midmag = magic;
275         else
276                 N_SETMAGIC((*hp), magic, MID_I386, flags);
277 #endif
278 #if defined(__DragonFly__) || defined(__FreeBSD__)
279         if (oldmagic)
280                 hp->a_midmag = magic;
281         else if (netzmagic)
282                 N_SETMAGIC_NET((*hp), magic, MID_I386, flags);
283         else
284                 N_SETMAGIC((*hp), magic, MID_I386, flags);
285 #endif
286
287         /* TEXT_START depends on the value of outheader.a_entry.  */
288         if (!(link_mode & SHAREABLE))
289                 hp->a_entry = PAGSIZ;
290 }
291 #endif /* RTLD */
292
293
294 #ifdef NEED_SWAP
295 /*
296  * Byte swap routines for cross-linking.
297  */
298
299 void
300 md_swapin_exec_hdr(h)
301 struct exec *h;
302 {
303         int skip = 0;
304
305         if (!N_BADMAG(*h))
306                 skip = 1;
307
308         swap_longs((long *)h + skip, sizeof(*h)/sizeof(long) - skip);
309 }
310
311 void
312 md_swapout_exec_hdr(h)
313 struct exec *h;
314 {
315         /* NetBSD: Always leave magic alone */
316         int skip = 1;
317 #if 0
318         if (N_GETMAGIC(*h) == OMAGIC)
319                 skip = 0;
320 #endif
321
322         swap_longs((long *)h + skip, sizeof(*h)/sizeof(long) - skip);
323 }
324
325
326 void
327 md_swapin_reloc(r, n)
328 struct relocation_info *r;
329 int n;
330 {
331         int     bits;
332
333         for (; n; n--, r++) {
334                 r->r_address = md_swap_long(r->r_address);
335                 bits = ((int *)r)[1];
336                 r->r_symbolnum = md_swap_long(bits) & 0x00ffffff;
337                 r->r_pcrel = (bits & 1);
338                 r->r_length = (bits >> 1) & 3;
339                 r->r_extern = (bits >> 3) & 1;
340                 r->r_baserel = (bits >> 4) & 1;
341                 r->r_jmptable = (bits >> 5) & 1;
342                 r->r_relative = (bits >> 6) & 1;
343 #ifdef N_SIZE
344                 r->r_copy = (bits >> 7) & 1;
345 #endif
346         }
347 }
348
349 void
350 md_swapout_reloc(r, n)
351 struct relocation_info *r;
352 int n;
353 {
354         int     bits;
355
356         for (; n; n--, r++) {
357                 r->r_address = md_swap_long(r->r_address);
358                 bits = md_swap_long(r->r_symbolnum) & 0xffffff00;
359                 bits |= (r->r_pcrel & 1);
360                 bits |= (r->r_length & 3) << 1;
361                 bits |= (r->r_extern & 1) << 3;
362                 bits |= (r->r_baserel & 1) << 4;
363                 bits |= (r->r_jmptable & 1) << 5;
364                 bits |= (r->r_relative & 1) << 6;
365 #ifdef N_SIZE
366                 bits |= (r->r_copy & 1) << 7;
367 #endif
368                 ((int *)r)[1] = bits;
369         }
370 }
371
372 void
373 md_swapout_jmpslot(j, n)
374 jmpslot_t       *j;
375 int             n;
376 {
377         for (; n; n--, j++) {
378                 j->opcode = md_swap_short(j->opcode);
379                 j->addr[0] = md_swap_short(j->addr[0]);
380                 j->addr[1] = md_swap_short(j->addr[1]);
381                 j->reloc_index = md_swap_short(j->reloc_index);
382         }
383 }
384
385 #endif /* NEED_SWAP */