a411a1b0e9cf66eee7ad05e65089c255921bc8fa
[kopensolaris-gnu/glibc.git] / sysdeps / mach / hurd / mips / init-first.c
1 /* Initialization code run first thing by the ELF startup code.  For Mips/Hurd.
2    Copyright (C) 1996, 1997 Free Software Foundation, Inc.
3    This file is part of the GNU C Library.
4
5    The GNU C Library is free software; you can redistribute it and/or
6    modify it under the terms of the GNU Library General Public License as
7    published by the Free Software Foundation; either version 2 of the
8    License, or (at your option) any later version.
9
10    The GNU C Library is distributed in the hope that it will be useful,
11    but WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13    Library General Public License for more details.
14
15    You should have received a copy of the GNU Library General Public
16    License along with the GNU C Library; see the file COPYING.LIB.  If not,
17    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18    Boston, MA 02111-1307, USA.  */
19
20 #include <hurd.h>
21 #include <stdio.h>
22 #include <unistd.h>
23 #include <string.h>
24 #include "hurdstartup.h"
25 #include "set-hooks.h"
26 #include "hurdmalloc.h"         /* XXX */
27
28 extern void __mach_init (void);
29 extern void __libc_init (int, char **, char **);
30 extern void __getopt_clean_environment (char **);
31 extern void __libc_global_ctors (void);
32
33 unsigned int __hurd_threadvar_max;
34 unsigned long int __hurd_threadvar_stack_offset;
35 unsigned long int __hurd_threadvar_stack_mask;
36
37 int __libc_multiple_libcs = 1;
38
39 int __libc_argc;
40 char **__libc_argv;
41
42 /* We often need the PID.  Cache this value.  */
43 pid_t __libc_pid;
44
45 void *(*_cthread_init_routine) (void); /* Returns new SP to use.  */
46 void (*_cthread_exit_routine) (int status) __attribute__ ((__noreturn__));
47
48
49 /* Things that want to be run before _hurd_init or much anything else.
50    Importantly, these are called before anything tries to use malloc.  */
51 DEFINE_HOOK (_hurd_preinit_hook, (void));
52
53 static void
54 init1 (int argc, char *arg0, ...)
55 {
56   char **argv = &arg0;
57   char **envp = &argv[argc + 1];
58   struct hurd_startup_data *d;
59
60   __libc_argc = argc;
61   __libc_argv = argv;
62   __environ = envp;
63   while (*envp)
64     ++envp;
65   d = (void *) ++envp;
66
67   /* If we are the bootstrap task started by the kernel,
68      then after the environment pointers there is no Hurd
69      data block; the argument strings start there.  */
70   if ((void *) d != argv[0])
71     {
72       _hurd_init_dtable = d->dtable;
73       _hurd_init_dtablesize = d->dtablesize;
74
75       {
76         /* Check if the stack we are now on is different from
77            the one described by _hurd_stack_{base,size}.  */
78
79         char dummy;
80         const vm_address_t newsp = (vm_address_t) &dummy;
81
82         if (d->stack_size != 0 && (newsp < d->stack_base ||
83                                    newsp - d->stack_base > d->stack_size))
84           /* The new stack pointer does not intersect with the
85              stack the exec server set up for us, so free that stack.  */
86           __vm_deallocate (__mach_task_self (), d->stack_base, d->stack_size);
87       }
88     }
89
90   if (__hurd_threadvar_stack_mask == 0)
91     {
92       /* We are not using cthreads, so we will have just a single allocated
93          area for the per-thread variables of the main user thread.  */
94       unsigned long int i;
95       __hurd_threadvar_stack_offset
96         = (unsigned long int) malloc (__hurd_threadvar_max *
97                                       sizeof (unsigned long int));
98       if (__hurd_threadvar_stack_offset == 0)
99         __libc_fatal ("Can't allocate single-threaded per-thread variables.");
100       for (i = 0; i < __hurd_threadvar_max; ++i)
101         ((unsigned long int *) __hurd_threadvar_stack_offset)[i] = 0;
102     }
103
104   if ((void *) d != argv[0] && (d->portarray || d->intarray))
105     /* Initialize library data structures, start signal processing, etc.  */
106     _hurd_init (d->flags, argv,
107                 d->portarray, d->portarraysize,
108                 d->intarray, d->intarraysize);
109
110   __libc_init (argc, argv, __environ);
111
112   /* This is a hack to make the special getopt in GNU libc working.  */
113   __getopt_clean_environment (envp);
114
115 #ifdef PIC
116   __libc_global_ctors ();
117 #endif
118
119   (void) &init1;
120 }
121
122 static void *
123 __init (int *data)
124 {
125   int argc = *data;
126   char **argv = (void *) (data + 1);
127   char **envp = &argv[argc + 1];
128   struct hurd_startup_data *d;
129
130   __environ = envp;
131   while (*envp)
132     ++envp;
133   d = (void *) ++envp;
134
135   /* The user might have defined a value for this, to get more variables.
136      Otherwise it will be zero on startup.  We must make sure it is set
137      properly before before cthreads initialization, so cthreads can know
138      how much space to leave for thread variables.  */
139   if (__hurd_threadvar_max < _HURD_THREADVAR_MAX)
140     __hurd_threadvar_max = _HURD_THREADVAR_MAX;
141
142
143   /* After possibly switching stacks, call `init1' (above) with the user
144      code as the return address, and the argument data immediately above
145      that on the stack.  */
146
147   if (_cthread_init_routine)
148     {
149       /* Initialize cthreads, which will allocate us a new stack to run on.  */
150       void *newsp = (*_cthread_init_routine) ();
151       struct hurd_startup_data *od;
152
153       /* Copy the argdata from the old stack to the new one.  */
154       newsp = memcpy (newsp - ((char *) &d[1] - (char *) data), data,
155                       (char *) d - (char *) data);
156
157       /* Set up the Hurd startup data block immediately following
158          the argument and environment pointers on the new stack.  */
159       od = (newsp + ((char *) d - (char *) data));
160       if ((void *) argv[0] == d)
161         /* We were started up by the kernel with arguments on the stack.
162            There is no Hurd startup data, so zero the block.  */
163         memset (od, 0, sizeof *od);
164       else
165         /* Copy the Hurd startup data block to the new stack.  */
166         *od = *d;
167
168       /* Push the user code address on the top of the new stack.  It will
169          be the return address for `init1'; we will jump there with NEWSP
170          as the stack pointer.  */
171       return newsp;
172     }
173
174   /* The argument data is just above the stack frame we will unwind by
175      returning.  */
176   return (void *) data;
177
178   (void) &__init;
179 }
180
181 #ifdef PIC
182 /* This function is called to initialize the shared C library.
183    It is called just before the user _start code from mips/elf/start.S,
184    with the stack set up as that code gets it.  */
185
186 /* NOTE!  The linker notices the magical name `_init' and sets the DT_INIT
187    pointer in the dynamic section based solely on that.  It is convention
188    for this function to be in the `.init' section, but the symbol name is
189    the only thing that really matters!!  */
190 /*void _init (int argc, ...) __attribute__ ((unused, section (".init")));*/
191
192 #if __mips64
193 asm ("\
194         .section .init,\"ax\",@progbits\n\
195         .align 3\n\
196         .globl _init\n\
197         .type _init,@function\n\
198         .ent _init\n\
199 _init:\n\
200         .set noreorder\n\
201         .cpload $25\n\
202         .set reorder\n\
203         dsubu $29, 8*8\n\
204         .cprestore 6*8\n\
205         sd $16, 4*8($29)\n\
206         sd $31, 5*8($29)\n\
207         jal preinit\n\
208         sd $28, 6*8($29)\n\
209         move $16, $29 # Save the old stack pointer to s0 ($16)\n\
210         daddu $4, $29, 4*8
211         jal __init\n\
212         # Restore saved registers from the old stack.\n\
213         ld $28, 6*8($16)\n\
214         ld $31, 5*8($16)\n\
215         ld $16, 4*8($16)\n\
216         move $29, $2 # set new sp to SP\n\
217 call_init1:\n\
218         ld $4, 0($29)\n\
219         ld $5, 1*8($29)\n\
220         ld $6, 2*8($29)\n\
221         ld $7, 3*8($29)\n\
222         dla $25, init1\n\
223         jr $25\n\
224         .end _init\n\
225         .text\n\
226 ");
227 #else
228 asm ("\
229         .section .init,\"ax\",@progbits\n\
230         .align 2\n\
231         .globl _init\n\
232         .type _init,@function\n\
233         .ent _init\n\
234 _init:\n\
235         .set noreorder\n\
236         .cpload $25\n\
237         .set reorder\n\
238         subu $29, 32\n\
239         .cprestore 24\n\
240         sw $16, 16($29)\n\
241         sw $31, 20($29)\n\
242         jal preinit\n\
243         sw $28, 24($29)\n\
244         move $16, $29 # Save the old stack pointer to s0 ($16)\n\
245         addu $4, $29, 32
246         jal __init\n\
247         # Restore saved registers from the old stack.\n\
248         lw $28, 24($16)\n\
249         lw $31, 20($16)\n\
250         lw $16, 16($16)\n\
251         move $29, $2 # set new sp to SP\n\
252 call_init1:\n\
253         lw $4, 0($29)\n\
254         lw $5, 4($29)\n\
255         lw $6, 8($29)\n\
256         lw $7, 12($29)\n\
257         la $25, init1\n\
258         jr $25\n\
259         .end _init\n\
260         .text\n\
261 ");
262 #endif
263
264 static void
265 preinit (void)
266 {
267   /* Initialize data structures so we can do RPCs.  */
268   __mach_init ();
269
270   RUN_HOOK (_hurd_preinit_hook, ());
271
272   (void) &preinit;
273 }
274
275 void __libc_init_first (int argc, ...)
276 {
277 }
278 #endif
279
280 #ifndef PIC
281 /* An assembler code wrapping c function __init.  */
282 #ifdef __mips64
283 asm ("\
284         .text\n\
285         .align 3\n\
286 init:\n\
287         dsubu $29, 8*8\n\
288         sd $16, 4*8($29)\n\
289         sd $31, 5*8($29)\n\
290         move $16, $29\n\
291         jal __init\n\
292         ld $31, 5*8($16)\n\
293         ld $16, 4*8($16)\n\
294         move $29, $2 # set new sp to SP\n\
295 call_init1:\n\
296         ld $4, 0($29)\n\
297         ld $5, 1*8($29)\n\
298         ld $6, 2*8($29)\n\
299         ld $7, 3*8($29)\n\
300         dla $25, init1\n\
301         jr $25\n\
302 ");
303 #else
304 asm ("\
305         .text\n\
306         .align 2\n\
307 init:\n\
308         subu $29, 32\n\
309         sw $16, 16($29)\n\
310         sw $31, 20($29)\n\
311         move $16, $29\n\
312         jal __init\n\
313         lw $31, 20($16)\n\
314         lw $16, 16($16)\n\
315         move $29, $2 # set new sp to SP\n\
316 call_init1:\n\
317         lw $4, 0($29)\n\
318         lw $5, 4($29)\n\
319         lw $6, 8($29)\n\
320         lw $7, 12($29)\n\
321         la $25, init1\n\
322         jr $25\n\
323 ");
324 #endif
325
326 /* An assembler code wrapping c function ___libc_init_first.
327    ___libc_init_first does an RPC call to flush cache to put doinit
328    function on the stack, so we should call __mach_init first in
329    this wrap. */
330 #ifdef __mips64
331 asm ("\
332         .text\n\
333         .align 3\n\
334         .globl __libc_init_first\n\
335 __libc_init_first:\n\
336         dsubu $29, 8\n\
337         sd $31, 0($29)
338         jal __mach_init\n\
339         ld $4, 0($29)
340         ld $5, 1*8($29)
341         ld $6, 2*8($29)
342         ld $7, 3*8($29)
343         j ___libc_init_first\n\
344 ");
345 #else
346 asm ("\
347         .text\n\
348         .align 2\n\
349         .globl __libc_init_first\n\
350 __libc_init_first:\n\
351         subu $29, 4\n\
352         sw $31, 0($29)
353         jal __mach_init\n\
354         lw $4, 0($29)
355         lw $5, 4($29)
356         lw $6, 8($29)
357         lw $7, 12($29)
358         j ___libc_init_first\n\
359 ");
360 #endif
361
362 static void
363 ___libc_init_first (int return_addr, int argc, ...)
364 {
365   void doinit (int *data)
366     {
367 #if 0
368       /* This function gets called with the argument data at TOS.  */
369       void doinit1 (int argc, ...)
370         {
371           init (&argc);
372         }
373 #endif
374       extern void init (int *data);
375
376       /* Push the user return address after the argument data, and then
377          jump to `doinit1' (above), so it is as if __libc_init_first's
378          caller had called `init' with the argument data already on the
379          stack.  */
380       *--data = return_addr;
381
382 #ifdef __mips64
383       asm volatile ("ld $31, 0(%0)\n" /* Load the original return address.  */
384                     "daddu $29, %0, 8\n" /* Switch to new outermost stack.  */
385                     "move $4, $29\n"
386                     "jr %1" : : "r" (data), "r" (&init));
387 #else
388       asm volatile ("lw $31, 0(%0)\n" /* Load the original return address.  */
389                     "addu $29, %0, 4\n" /* Switch to new outermost stack.  */
390                     "move $4, $29\n"
391                     "jr %1" : : "r" (data), "r" (&init));
392 #endif
393       /* NOTREACHED */
394     }
395
396 #if 0
397   /* Initialize data structures so we can do RPCs.  */
398   __mach_init ();
399 #endif
400
401   RUN_HOOK (_hurd_preinit_hook, ());
402
403   _hurd_startup ((void **) &argc, &doinit);
404
405   (void) &___libc_init_first;
406 }
407 #endif