![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to crt0.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / emacs / src|
Return to crt0.c CVS log | Up to [Apple XNU] / GNUtools / emacs / src |
1.1 root 1: /* C code startup routine.
2: Copyright (C) 1985, 1986 Free Software Foundation, Inc.
3:
4: This program is free software; you can redistribute it and/or modify
5: it under the terms of the GNU General Public License as published by
6: the Free Software Foundation; either version 1, or (at your option)
7: any later version.
8:
9: This program is distributed in the hope that it will be useful,
10: but WITHOUT ANY WARRANTY; without even the implied warranty of
11: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12: GNU General Public License for more details.
13:
14: You should have received a copy of the GNU General Public License
15: along with this program; if not, write to the Free Software
16: Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17:
18: In other words, you are welcome to use, share and improve this program.
19: You are forbidden to forbid anyone else to use, share and improve
20: what you give them. Help stamp out software-hoarding! */
21:
22:
23: /* The standard Vax 4.2 Unix crt0.c cannot be used for Emacs
24: because it makes `envron' an initialized variable.
25: It is easiest to have a special crt0.c on all machines
26: though I don't know whether other machines actually need it. */
27:
28: /* On the vax and 68000, in BSD4.2 and USG5.2,
29: this is the data format on startup:
30: (vax) ap and fp are unpredictable as far as I know; don't use them.
31: sp -> word containing argc
32: word pointing to first arg string
33: [word pointing to next arg string]... 0 or more times
34: 0
35: Optionally:
36: [word pointing to environment variable]... 1 or more times
37: ...
38: 0
39: And always:
40: first arg string
41: [next arg string]... 0 or more times
42: */
43:
44: /* On the 16000, at least in the one 4.2 system I know about,
45: the initial data format is
46: sp -> word containing argc
47: word containing argp
48: word pointing to first arg string, and so on as above
49: */
50:
51: #include "config.h"
52:
53: /* ******** WARNING ********
54: Do not insert any data definitions before data_start!
55: Since this is the first file linked, the address of the following
56: variable should correspond to the start of initialized data space.
57: On some systems this is a constant that is independent of the text
58: size for shared executables. On others, it is a function of the
59: text size. In short, this seems to be the most portable way to
60: discover the start of initialized data space dynamically at runtime,
61: for either shared or unshared executables, on either swapping or
62: virtual systems. It only requires that the linker allocate objects
63: in the order encountered, a reasonable model for most Unix systems.
64: Similarly, note that the address of _start() should be the start
65: of text space. Fred Fish, UniSoft Systems Inc. */
66:
67: int data_start = 0;
68:
69: #ifdef NEED_ERRNO
70: int errno;
71: #endif
72:
73: #ifndef DONT_NEED_ENVIRON
74: char **environ;
75: #endif
76:
77: #if defined(orion) || defined(pyramid) || defined(celerity) || defined(ALLIANT) || defined(clipper)
78:
79: #ifdef ALLIANT
80: /* _start must initialize _curbrk and _minbrk on the first startup;
81: when starting up after dumping, it must initialize them to what they were
82: before the dumping, since they are in the shared library and
83: are not dumped. See ADJUST_EXEC_HEADER in m-alliant.h. */
84: extern unsigned char *_curbrk, *_minbrk;
85: extern unsigned char end;
86: unsigned char *_setbrk = &end;
87: #ifdef ALLIANT_2800
88: unsigned char *_end = &end;
89: #endif
90: #endif
91:
92: #ifndef DUMMIES
93: #define DUMMIES
94: #endif
95:
96: _start (DUMMIES argc, argv, envp)
97: int argc;
98: char **argv, **envp;
99: {
100: #ifdef ALLIANT
101: #ifdef ALLIANT_2800
102: _curbrk = _end;
103: _minbrk = _end;
104: #else
105: _curbrk = _setbrk;
106: _minbrk = _setbrk;
107: #endif
108: #endif
109:
110: environ = envp;
111:
112: exit (main (argc, argv, envp));
113: }
114:
115: #endif /* orion or pyramid or celerity or alliant or clipper */
116:
117: #if defined (ns16000) && !defined (sequent) && !defined (UMAX)
118:
119: _start ()
120: {
121: /* On 16000, _start pushes fp onto stack */
122: start1 ();
123: }
124:
125: /* ignore takes care of skipping the fp value pushed in start. */
126: static
127: start1 (ignore, argc, argv)
128: int ignore;
129: int argc;
130: register char **argv;
131: {
132: environ = argv + argc + 1;
133:
134: if (environ == *argv)
135: environ--;
136: exit (main (argc, argv, environ));
137: }
138: #endif /* ns16000, not sequent and not UMAX */
139:
140: #ifdef UMAX
141: _start()
142: {
143: asm(" exit [] # undo enter");
144: asm(" .set exitsc,1");
145: asm(" .set sigcatchall,0x400");
146:
147: asm(" .globl _exit");
148: asm(" .globl start");
149: asm(" .globl __start");
150: asm(" .globl _main");
151: asm(" .globl _environ");
152: asm(" .globl _sigvec");
153: asm(" .globl sigentry");
154:
155: asm("start:");
156: asm(" br .xstart");
157: asm(" .org 0x20");
158: asm(" .double p_glbl,0,0xf00000,0");
159: asm(" .org 0x30");
160: asm(".xstart:");
161: asm(" adjspb $8");
162: asm(" movd 8(sp),0(sp) # argc");
163: asm(" addr 12(sp),r0");
164: asm(" movd r0,4(sp) # argv");
165: asm("L1:");
166: asm(" movd r0,r1");
167: asm(" addqd $4,r0");
168: asm(" cmpqd $0,0(r1) # null args term ?");
169: asm(" bne L1");
170: asm(" cmpd r0,0(4(sp)) # end of 'env' or 'argv' ?");
171: asm(" blt L2");
172: asm(" addqd $-4,r0 # envp's are in list");
173: asm("L2:");
174: asm(" movd r0,8(sp) # env");
175: asm(" movd r0,@_environ # indir is 0 if no env ; not 0 if env");
176: asm(" movqd $0,tos # setup intermediate signal handler");
177: asm(" addr @sv,tos");
178: asm(" movzwd $sigcatchall,tos");
179: asm(" jsr @_sigvec");
180: asm(" adjspb $-12");
181: asm(" jsr @_main");
182: asm(" adjspb $-12");
183: asm(" movd r0,tos");
184: asm(" jsr @_exit");
185: asm(" adjspb $-4");
186: asm(" addr @exitsc,r0");
187: asm(" svc");
188: asm(" .align 4 # sigvec arg");
189: asm("sv:");
190: asm(" .double sigentry");
191: asm(" .double 0");
192: asm(" .double 0");
193:
194: asm(" .comm p_glbl,1");
195: }
196: #endif /* UMAX */
197:
198: #ifdef CRT0_DUMMIES
199:
200: /* Define symbol "start": here; some systems want that symbol. */
201: #ifdef DOT_GLOBAL_START
202: asm(" .text ");
203: asm(" .globl start ");
204: asm(" start: ");
205: #endif /* DOT_GLOBAL_START */
206:
207: #ifdef NODOT_GLOBAL_START
208: asm(" text ");
209: asm(" global start ");
210: asm(" start: ");
211: #endif /* NODOT_GLOBAL_START */
212:
213: static start1 ();
214:
215: _start ()
216: {
217: /* On vax, nothing is pushed here */
218: /* On sequent, bogus fp is pushed here */
219: start1 ();
220: }
221:
222: static
223: start1 (CRT0_DUMMIES argc, xargv)
224: int argc;
225: char *xargv;
226: {
227: register char **argv = &xargv;
228: environ = argv + argc + 1;
229:
230: if ((char *)environ == xargv)
231: environ--;
232: exit (main (argc, argv, environ));
233: }
234: #else /* not CRT0_DUMMIES */
235:
236: /* "m68k" and "m68000" both stand for m68000 processors,
237: but with different program-entry conventions.
238: This is a kludge. Now that the CRT0_DUMMIES mechanism above exists,
239: most of these machines could use the vax code above
240: with some suitable definition of CRT0_DUMMIES.
241: Then the symbol m68k could be flushed.
242: But I don't want to risk breaking these machines
243: in a version 17 patch release, so that change is being put off. */
244:
245: #ifdef m68k /* Can't do it all from C */
246: asm (" global _start");
247: asm (" text");
248: asm ("_start:");
249: #ifndef NU
250: #ifdef STRIDE
251: asm (" comm havefpu%,2");
252: #else /* m68k, not STRIDE */
253: asm (" comm splimit%,4");
254: #endif /* STRIDE */
255: asm (" global exit");
256: asm (" text");
257: #ifdef STRIDE
258: asm (" trap &3");
259: asm (" mov.w %d0,havefpu%");
260: #else /* m68k, not STRIDE */
261: asm (" mov.l %d0,splimit%");
262: #endif /* STRIDE */
263: #endif /* not NU */
264: asm (" jsr start1");
265: asm (" mov.l %d0,(%sp)");
266: asm (" jsr exit");
267: asm (" mov.l &1,%d0"); /* d0 = 1 => exit */
268: asm (" trap &0");
269: #else /* m68000, not m68k */
270:
271: #ifdef m68000
272:
273: #ifdef ISI68K
274: /* Added by ESM Sun May 24 12:44:02 1987 to get new ISI library to work */
275: #ifdef BSD4_3
276: static foo () {
277: #endif
278: asm (" .globl is68020");
279: asm ("is68020:");
280: #ifndef BSD4_3
281: asm (" .long 0x00000000");
282: asm (" .long 0xffffffff");
283: /* End of stuff added by ESM */
284: #endif
285: asm (" .text");
286: asm (" .globl __start");
287: asm ("__start:");
288: asm (" .word 0");
289: asm (" link fp,#0");
290: asm (" jbsr _start1");
291: asm (" unlk fp");
292: asm (" rts");
293: #ifdef BSD4_3
294: }
295: #endif
296: #else /* not ISI68K */
297:
298: _start ()
299: {
300: /* On 68000, _start pushes a6 onto stack */
301: start1 ();
302: }
303: #endif /* not ISI68k */
304: #endif /* m68000 */
305: #endif /* m68k */
306:
307: #if defined(m68k) || defined(m68000)
308: /* ignore takes care of skipping the a6 value pushed in start. */
309: static
310: #if defined(m68k)
311: start1 (argc, xargv)
312: #else
313: start1 (ignore, argc, xargv)
314: #endif
315: int argc;
316: char *xargv;
317: {
318: register char **argv = &xargv;
319: environ = argv + argc + 1;
320:
321: if ((char *)environ == xargv)
322: environ--;
323: exit (main (argc, argv, environ));
324: }
325:
326: #endif /* m68k or m68000 */
327:
328: #endif /* not CRT0_DUMMIES */
329:
330: #ifdef hp9000s300
331: int argc_value;
332: char **argv_value;
333: #ifdef OLD_HP_ASSEMBLER
334: asm(" text");
335: asm(" globl __start");
336: asm(" globl _exit");
337: asm(" globl _main");
338: asm("__start");
339: asm(" dc.l 0");
340: asm(" subq.w #0x1,d0");
341: asm(" move.w d0,float_soft");
342: asm(" move.l 0x4(a7),d0");
343: asm(" beq.s skip_1");
344: asm(" move.l d0,a0");
345: asm(" clr.l -0x4(a0)");
346: asm("skip_1");
347: asm(" move.l a7,a0");
348: asm(" subq.l #0x8,a7");
349: asm(" move.l (a0),(a7)");
350: asm(" move.l (a0),_argc_value");
351: asm(" addq.l #0x4,a0");
352: asm(" move.l a0,0x4(a7)");
353: asm(" move.l a0,_argv_value");
354: asm("incr_loop");
355: asm(" tst.l (a0)+");
356: asm(" bne.s incr_loop");
357: asm(" move.l 0x4(a7),a1");
358: asm(" cmp.l (a1),a0");
359: asm(" blt.s skip_2");
360: asm(" subq.l #0x4,a0");
361: asm("skip_2");
362: asm(" move.l a0,0x8(a7)");
363: asm(" move.l a0,_environ");
364: asm(" jsr _main");
365: asm(" addq.l #0x8,a7");
366: asm(" move.l d0,-(a7)");
367: asm(" jsr _exit");
368: asm(" move.w #0x1,d0");
369: asm(" trap #0x0");
370: asm(" comm float_soft,4");
371: /* float_soft is allocated in this way because C would
372: put an underscore character in its name otherwise. */
373:
374: #else /* new hp assembler */
375:
376: asm(" text");
377: asm(" global float_loc");
378: asm(" set float_loc,0xFFFFB000");
379: asm(" global fpa_loc");
380: asm(" set fpa_loc,0xfff08000");
381: asm(" global __start");
382: asm(" global _exit");
383: asm(" global _main");
384: asm("__start:");
385: asm(" byte 0,0,0,0");
386: asm(" subq.w &1,%d0");
387: asm(" mov.w %d0,float_soft");
388: asm(" mov.w %d1,flag_68881");
389: #ifndef HPUX_68010
390: asm(" beq.b skip_float");
391: asm(" fmov.l &0x7400,%fpcr");
392: /* asm(" fmov.l &0x7480,%fpcr"); */
393: #endif /* HPUX_68010 */
394: asm("skip_float:");
395: asm(" mov.l %a0,%d0");
396: asm(" add.l %d0,%d0");
397: asm(" subx.w %d1,%d1");
398: asm(" mov.w %d1,flag_68010");
399: asm(" add.l %d0,%d0");
400: asm(" subx.w %d1,%d1");
401: asm(" mov.w %d1,flag_fpa");
402: asm(" tst.l %d2");
403: asm(" ble.b skip_3");
404: asm(" lsl flag_68881");
405: asm(" lsl flag_fpa");
406: asm("skip_3:");
407: asm(" mov.l 4(%a7),%d0");
408: asm(" beq.b skip_1");
409: asm(" mov.l %d0,%a0");
410: asm(" clr.l -4(%a0)");
411: asm("skip_1:");
412: asm(" mov.l %a7,%a0");
413: asm(" subq.l &8,%a7");
414: asm(" mov.l (%a0),(%a7)");
415: asm(" mov.l (%a0),_argc_value");
416: asm(" addq.l &4,%a0");
417: asm(" mov.l %a0,4(%a7)");
418: asm(" mov.l %a0,_argv_value");
419: asm("incr_loop:");
420: asm(" tst.l (%a0)+");
421: asm(" bne.b incr_loop");
422: asm(" mov.l 4(%a7),%a1");
423: asm(" cmp.l %a0,(%a1)");
424: asm(" blt.b skip_2");
425: asm(" subq.l &4,%a0");
426: asm("skip_2:");
427: asm(" mov.l %a0,8(%a7)");
428: asm(" mov.l %a0,_environ");
429: asm(" jsr _main");
430: asm(" addq.l &8,%a7");
431: asm(" mov.l %d0,-(%a7)");
432: asm(" jsr _exit");
433: asm(" mov.w &1,%d0");
434: asm(" trap &0");
435: asm(" comm float_soft, 4");
436: asm(" comm flag_68881, 4");
437: asm(" comm flag_68010, 4");
438: asm(" comm flag_fpa, 4");
439:
440: #endif /* new hp assembler */
441: #endif /* hp9000s300 */
442:
443: #ifdef GOULD
444:
445: /* startup code has to be in near text rather
446: than fartext as allocated by the C compiler. */
447: asm(" .text");
448: asm(" .align 2");
449: asm(" .globl __start");
450: asm(" .text");
451: asm("__start:");
452: /* setup base register b1 (function base). */
453: asm(" .using b1,.");
454: asm(" tpcbr b1");
455: /* setup base registers b3 through b7 (data references). */
456: asm(" file basevals,b3");
457: /* setup base register b2 (stack pointer); it should be
458: aligned on a 8-word boundary; but because it is pointing
459: to argc, its value should be remembered (in r5). */
460: asm(" movw b2,r4");
461: asm(" movw b2,r5");
462: asm(" andw #~0x1f,r4");
463: asm(" movw r4,b2");
464: /* allocate stack frame to do some work. */
465: asm(" subea 16w,b2");
466: /* initialize signal catching for UTX/32 1.2; this is
467: necessary to make restart from saved image work. */
468: asm(" movea sigcatch,r1");
469: asm(" movw r1,8w[b2]");
470: asm(" svc #1,#150");
471: /* setup address of argc for start1. */
472: asm(" movw r5,8w[b2]");
473: asm(" func #1,_start1");
474: asm(" halt");
475: /* space for ld to store base register initial values. */
476: asm(" .align 5");
477: asm("basevals:");
478: asm(" .word __base3,__base4,__base5,__base6,__base7");
479:
480: static
481: start1 (xargc)
482: int *xargc;
483: {
484: register int argc;
485: register char **argv;
486:
487: argc = *xargc;
488: argv = (char **)(xargc) + 1;
489: environ = argv + argc + 1;
490:
491: if (environ == argv)
492: environ--;
493: exit (main (argc, argv, environ));
494:
495: }
496:
497: #endif /* GOULD */
498:
499: #ifdef elxsi
500: extern int errno;
501: extern char **environ;
502:
503: _start()
504: {
505: register int r;
506:
507: errno = 0;
508: environ = *(&environ + 8);
509: _stdinit();
510: r = main(*(&environ + 6), *(&environ + 7), environ);
511: exit(r);
512: _exit(r);
513: }
514: #endif /* elxsi */
515:
516:
517: #ifdef sparc
518: asm (".global __start");
519: asm (".text");
520: asm ("__start:");
521: asm (" mov 0, %fp");
522: asm (" ld [%sp + 64], %o0");
523: asm (" add %sp, 68, %o1");
524: asm (" sll %o0, 2, %o2");
525: asm (" add %o2, 4, %o2");
526: asm (" add %o1, %o2, %o2");
527: asm (" sethi %hi(_environ), %o3");
528: asm (" st %o2, [%o3+%lo(_environ)]");
529: asm (" andn %sp, 7, %sp");
530: asm (" call _main");
531: asm (" sub %sp, 24, %sp");
532: asm (" call __exit");
533: asm (" nop");
534:
535: #endif /* sparc */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.