gcc/config/i386/sol2-gc1.asm

   1 ! gcrt1.s for Solaris 2, x86
   2
   3 !   Copyright (C) 1993 Free Software Foundation, Inc.
   4 !   Written By Fred Fish, Nov 1992
   5 !
   6 ! This file is free software; you can redistribute it and/or modify it
   7 ! under the terms of the GNU General Public License as published by the
   8 ! Free Software Foundation; either version 2, or (at your option) any
   9 ! later version.
  10 !
  11 ! In addition to the permissions in the GNU General Public License, the
  12 ! Free Software Foundation gives you unlimited permission to link the
  13 ! compiled version of this file with other programs, and to distribute
  14 ! those programs without any restriction coming from the use of this
  15 ! file.  (The General Public License restrictions do apply in other
  16 ! respects; for example, they cover modification of the file, and
  17 ! distribution when not linked into another program.)
  18 !
  19 ! This file is distributed in the hope that it will be useful, but
  20 ! WITHOUT ANY WARRANTY; without even the implied warranty of
  21 ! MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  22 ! General Public License for more details.
  23 !
  24 ! You should have received a copy of the GNU General Public License
  25 ! along with this program; see the file COPYING.  If not, write to
  26 ! the Free Software Foundation, 59 Temple Place - Suite 330,
  27 ! Boston, MA 02111-1307, USA.
  28 !
  29 !    As a special exception, if you link this library with files
  30 !    compiled with GCC to produce an executable, this does not cause
  31 !    the resulting executable to be covered by the GNU General Public License.
  32 !    This exception does not however invalidate any other reasons why
  33 !    the executable file might be covered by the GNU General Public License.
  34 !
  35
  36 ! This file takes control of the process from the kernel, as specified
  37 ! in section 3 of the System V Application Binary Interface, Intel386
  38 ! Processor Supplement.  It has been constructed from information obtained
  39 ! from the ABI, information obtained from single stepping existing
  40 ! Solaris executables through their startup code with gdb, and from
  41 ! information obtained by single stepping executables on other i386 SVR4
  42 ! implementations.  This file is the first thing linked into any executable.
  43
  44 ! This is a modified crt1.s by J.W.Hawtin <oolon@ankh.org> 15/8/96,
  45 ! to allow program profiling, by calling monstartup on entry and _mcleanup
  46 ! on exit
  47
  48         .file   "gcrt1.s"
  49         .ident  "GNU C gcrt1.s"
  50         .weak   _DYNAMIC
  51         .text
  52
  53 ! Start creating the initial frame by pushing a NULL value for the return
  54 ! address of the initial frame, and mark the end of the stack frame chain
  55 ! (the innermost stack frame) with a NULL value, per page 3-32 of the ABI.
  56 ! Initialize the first stack frame pointer in %ebp (the contents of which
  57 ! are unspecified at process initialization).
  58
  59         .globl  _start
  60 _start:
  61         pushl   $0x0
  62         pushl   $0x0
  63         movl    %esp,%ebp
  64
  65 ! As specified per page 3-32 of the ABI, %edx contains a function
  66 ! pointer that should be registered with atexit(), for proper
  67 ! shared object termination.  Just push it onto the stack for now
  68 ! to preserve it.  We want to register _cleanup() first.
  69
  70         pushl   %edx
  71
  72 ! Check to see if there is an _cleanup() function linked in, and if
  73 ! so, register it with atexit() as the last thing to be run by
  74 ! atexit().
  75
  76         movl    $_mcleanup,%eax
  77         testl   %eax,%eax
  78         je      .L1
  79         pushl   $_mcleanup
  80         call    atexit
  81         addl    $0x4,%esp
  82 .L1:
  83
  84 ! Now check to see if we have an _DYNAMIC table, and if so then
  85 ! we need to register the function pointer previously in %edx, but
  86 ! now conveniently saved on the stack as the argument to pass to
  87 ! atexit().
  88
  89         movl    $_DYNAMIC,%eax
  90         testl   %eax,%eax
  91         je      .L2
  92         call    atexit
  93 .L2:
  94
  95 ! Register _fini() with atexit().  We will take care of calling _init()
  96 ! directly.
  97
  98         pushl   $_fini
  99         call    atexit
 100
 101 ! Start profiling
 102
 103         pushl %ebp
 104         movl %esp,%ebp
 105         pushl $_etext
 106         pushl $_start
 107         call monstartup
 108         addl $8,%esp
 109         popl %ebp
 110
 111 ! Compute the address of the environment vector on the stack and load
 112 ! it into the global variable _environ.  Currently argc is at 8 off
 113 ! the frame pointer.  Fetch the argument count into %eax, scale by the
 114 ! size of each arg (4 bytes) and compute the address of the environment
 115 ! vector which is 16 bytes (the two zero words we pushed, plus argc,
 116 ! plus the null word terminating the arg vector) further up the stack,
 117 ! off the frame pointer (whew!).
 118
 119         movl    8(%ebp),%eax
 120         leal    16(%ebp,%eax,4),%edx
 121         movl    %edx,_environ
 122
 123 ! Push the environment vector pointer, the argument vector pointer,
 124 ! and the argument count on to the stack to set up the arguments
 125 ! for _init(), _fpstart(), and main().  Note that the environment
 126 ! vector pointer and the arg count were previously loaded into
 127 ! %edx and %eax respectively.  The only new value we need to compute
 128 ! is the argument vector pointer, which is at a fixed address off
 129 ! the initial frame pointer.
 130
 131 !
 132 ! Make sure the stack is properly aligned.
 133 !
 134         andl $0xfffffff0,%esp
 135         subl $4,%esp
 136
 137         pushl   %edx
 138         leal    12(%ebp),%edx
 139         pushl   %edx
 140         pushl   %eax
 141
 142 ! Call _init(argc, argv, environ), _fpstart(argc, argv, environ), and
 143 ! main(argc, argv, environ).
 144
 145         call    _init
 146         call    __fpstart
 147         call    main
 148
 149 ! Pop the argc, argv, and environ arguments off the stack, push the
 150 ! value returned from main(), and call exit().
 151
 152         addl    $12,%esp
 153         pushl   %eax
 154         call    exit
 155
 156 ! An inline equivalent of _exit, as specified in Figure 3-26 of the ABI.
 157
 158         pushl   $0x0
 159         movl    $0x1,%eax
 160         lcall   $7,$0
 161
 162 ! If all else fails, just try a halt!
 163
 164         hlt
 165         .type   _start,@function
 166         .size   _start,.-_start