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