Update from main archive 961219
[kopensolaris-gnu/glibc.git] / sysdeps / standalone / i386 / start.S
1 /* Copyright (C) 1994 Free Software Foundation, Inc.
2    Contributed by Joel Sherrill (jsherril@redstone-emh2.army.mil),
3      On-Line Applications Research Corporation.
4  
5 This file is part of the GNU C Library.
6  
7 The GNU C Library is free software; you can redistribute it and/or
8 modify it under the terms of the GNU Library General Public License as
9 published by the Free Software Foundation; either version 2 of the
10 License, or (at your option) any later version.
11  
12 The GNU C Library is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15 Library General Public License for more details.
16  
17 You should have received a copy of the GNU Library General Public
18 License along with the GNU C Library; see the file COPYING.LIB.  If
19 not, write to the Free Software Foundation, Inc., 675 Mass Ave,
20 Cambridge, MA 02139, USA.  */
21
22 /*  entry.s
23  *
24  *  This file contains the entry point for the application.
25  *  The name of this entry point is compiler dependent.
26  *  It jumps to the BSP which is responsible for performing
27  *  all initialization.
28  *
29  */
30
31         .data
32         .global  _Do_Load_IDT
33         .global  _Do_Load_GDT
34
35         .text
36               .global  start                  # GNU default entry point
37         .global  _establish_stack
38
39         .global   _bsp_start
40         .global   _load_segments
41         .global   __exit
42
43 start:
44         nop
45         cli                             # DISABLE INTERRUPTS!!!
46 #
47 #  Load the segment registers
48 #
49 #  NOTE: Upon return, gs will contain the segment descriptor for
50 #        a segment which maps directly to all of physical memory.
51 #
52         jmp     _load_segments          # load board dependent segments
53
54 #
55 #  Set up the stack
56 #
57
58 _establish_stack:
59
60         movl    $stack_end,%esp         # set stack pointer
61         movl    $stack_end,%ebp         # set base pointer
62
63 #
64 #  Zero out the BSS segment
65 #
66 zero_bss:
67         cld                             # make direction flag count up
68         movl    $_end,%ecx              # find end of .bss
69         movl    $_bss_start,%edi        # edi = beginning of .bss
70         subl    %edi,%ecx               # ecx = size of .bss in bytes
71         shrl    $2,%ecx                 # size of .bss in longs
72         xorl    %eax,%eax               # value to clear out memory
73         repne                           # while ecx != 0
74         stosl                           #   clear a long in the bss
75
76 #
77 #  Set the C heap information for malloc
78 #
79         movl    $heap_size,___C_heap_size    # set ___C_heap_size
80         movl    $heap_memory,___C_heap_start # set ___C_heap_start
81
82 #
83 #  Copy the Global Descriptor Table to our space
84 #
85
86         sgdt    _Original_GDTR          # save original GDT
87         movzwl  _Original_GDTR_limit,%ecx # size of GDT in bytes; limit 
88                                           #   is 8192 entries * 8 bytes per
89
90         # make ds:esi point to the original GDT
91
92         movl    _Original_GDTR_base,%esi
93         push    %ds                     # save ds
94         movw    %gs,%ax
95         movw    %ax,%ds 
96
97         # make es:edi point to the new (our copy) GDT
98         movl    $_Global_descriptor_table,%edi
99
100         rep
101         movsb                            # copy the GDT (ds:esi -> es:edi)
102
103         pop     %ds                      # restore ds
104       
105         # Build and load new contents of GDTR
106         movw    _Original_GDTR_limit,%ecx # set new limit
107         movw    %cx,_New_GDTR_limit
108
109         push    $_Global_descriptor_table
110         push    %es
111         call    _Logical_to_physical
112         addl    $6,%esp
113         movl    %eax,_New_GDTR_base      # set new base
114
115         cmpb    $0,_Do_Load_GDT          # Should the new GDT be loaded?
116         je      no_gdt_load              # NO, then branch
117         lgdt    _New_GDTR                # load the new GDT
118 no_gdt_load:
119
120 #
121 #  Copy the Interrupt Descriptor Table to our space
122 #
123
124         sidt    _Original_IDTR          # save original IDT
125         movzwl  _Original_IDTR_limit,%ecx # size of IDT in bytes; limit
126                                           #   is 256 entries * 8 bytes per
127  
128
129         # make ds:esi point to the original IDT
130         movl    _Original_IDTR_base,%esi
131
132         push    %ds                     # save ds
133         movw    %gs,%ax
134         movw    %ax,%ds 
135
136         # make es:edi point to the new (our copy) IDT
137         movl    $_Interrupt_descriptor_table,%edi
138
139         rep
140         movsb                            # copy the IDT (ds:esi -> es:edi)
141         pop     %ds                      # restore ds
142
143         # Build and load new contents of IDTR
144         movw    _Original_IDTR_limit,%ecx # set new limit
145         movw    %cx,_New_IDTR_limit
146
147         push    $_Interrupt_descriptor_table
148         push    %es
149         call    _Logical_to_physical
150         addl    $6,%esp
151         movl    %eax,_New_IDTR_base      # set new base
152
153         cmpb    $0,_Do_Load_IDT          # Should the new IDT be loaded?
154         je      no_idt_load              # NO, then branch
155         lidt    _New_IDTR                # load the new IDT
156 no_idt_load:
157
158 #
159 #  Initialize the i387.
160 #
161 #  Using the NO WAIT form of the instruction insures that if
162 #  it is not present the board will not lock up or get an
163 #  exception.
164 #
165
166         fninit                           # MUST USE NO-WAIT FORM
167
168         call    __Board_Initialize       # initialize the board
169
170         pushl   $0                       # envp = NULL 
171         pushl   $0                       # argv = NULL 
172         pushl   $0                       # argc = NULL 
173         call    ___libc_init             # initialize the library and
174                                          #   call main
175         addl    $12,%esp
176  
177         pushl   $0                       # argc = NULL 
178         call    __exit                   # call the Board specific exit
179         addl     $4,%esp
180
181 #
182 #  Clean up
183 #
184
185
186         .global  _Bsp_cleanup
187
188         .global   _return_to_monitor
189
190 _Bsp_cleanup:
191         cmpb    $0,_Do_Load_IDT          # Was the new IDT loaded?
192         je      no_idt_restore           # NO, then branch
193         lidt    _Original_IDTR           # restore the new IDT
194 no_idt_restore:
195
196         cmpb    $0,_Do_Load_GDT          # Was the new GDT loaded?
197         je      no_gdt_restore           # NO, then branch
198         lgdt    _Original_GDTR           # restore the new GDT
199 no_gdt_restore:
200         jmp     _return_to_monitor
201
202 #
203 #  void *Logical_to_physical( 
204 #     rtems_unsigned16  segment,
205 #     void             *address
206 #  );
207 #
208 #  Returns thirty-two bit physical address for segment:address.
209 #
210
211         .global  _Logical_to_physical
212
213 .set SEGMENT_ARG, 4
214 .set ADDRESS_ARG, 8
215
216 _Logical_to_physical:
217
218         xorl    %eax,%eax                # clear eax
219         movzwl  SEGMENT_ARG(%esp),%ecx   # ecx = segment value
220         movl    $_Global_descriptor_table,%edx # edx = address of our GDT
221         addl    %ecx,%edx                # edx = address of desired entry
222         movb    7(%edx),%ah              # ah = base 31:24
223         movb    4(%edx),%al              # al = base 23:16
224         shll    $16,%eax                 # move ax into correct bits
225         movw    2(%edx),%ax              # ax = base 0:15
226         movl    ADDRESS_ARG(%esp),%ecx   # ecx = address to convert
227         addl    %eax,%ecx                # ecx = physical address equivalent
228         movl    %ecx,%eax                # eax = ecx
229         ret
230        
231 #
232 #  void *Physical_to_logical( 
233 #     rtems_unsigned16  segment,
234 #     void             *address
235 #  );
236 #
237 #  Returns thirty-two bit physical address for segment:address.
238 #
239
240         .global  _Physical_to_logical
241
242 #.set SEGMENT_ARG, 4
243 #.set ADDRESS_ARG, 8   -- use sets from above
244
245 _Physical_to_logical:
246
247         xorl    %eax,%eax                # clear eax
248         movzwl  SEGMENT_ARG(%esp),%ecx   # ecx = segment value
249         movl    $_Global_descriptor_table,%edx # edx = address of our GDT
250         addl    %ecx,%edx                # edx = address of desired entry
251         movb    7(%edx),%ah              # ah = base 31:24
252         movb    4(%edx),%al              # al = base 23:16
253         shll    $16,%eax                 # move ax into correct bits
254         movw    2(%edx),%ax              # ax = base 0:15
255         movl    ADDRESS_ARG(%esp),%ecx   # ecx = address to convert
256         subl    %eax,%ecx                # ecx = logical address equivalent
257         movl    %ecx,%eax                # eax = ecx
258         ret
259        
260
261 /*
262  *  Data Declarations.  Start with a macro which helps declare space.
263  */
264
265         .bss
266
267 #define DECLARE_SPACE(_name,_space,_align) \
268           .globl   _name ; \
269           .align   _align ; \
270 _name##:  .space _space
271
272 #define DECLARE_LABEL(_name) \
273           .globl   _name ; \
274 _name##:  
275
276 #define DECLARE_PTR(_name) DECLARE_SPACE(_name,4,2)
277 #define DECLARE_U32(_name) DECLARE_SPACE(_name,4,2)
278 #define DECLARE_U16(_name) DECLARE_SPACE(_name,2,1)
279
280 /*
281  *  Require environment stuff
282  */
283
284 DECLARE_LABEL(_environ)
285 DECLARE_PTR(environ)
286
287 DECLARE_LABEL(_errno)
288 DECLARE_U32(errno)
289
290 /* 
291  *  Miscellaneous Variables used to restore the CPU state.
292  *
293  *  Start with a macro to declare the space for the contents of
294  *  a Descriptor Table register.
295  */
296
297 #define DECLARE_DTR_SPACE(_name) \
298           .global   _name ; \
299           .align    4 ; \
300 _name##:  ; \
301 _name##_limit:  .space 2  ; \
302 _name##_base:   .space 4
303
304 DECLARE_SPACE(_Interrupt_descriptor_table,256*8,4)
305 DECLARE_SPACE(_Global_descriptor_table,8192*8,4)
306
307 DECLARE_DTR_SPACE(_Original_IDTR)
308 DECLARE_DTR_SPACE(_New_IDTR)
309 DECLARE_DTR_SPACE(_Original_GDTR)
310 DECLARE_DTR_SPACE(_New_GDTR)
311
312 DECLARE_SPACE(_Physical_base_of_ds,4,4)
313 DECLARE_SPACE(_Physical_base_of_cs,4,4)
314
315 /*
316  *  Stack Size and Space
317  */
318
319         .set stack_size, 0x20000
320
321 DECLARE_SPACE(stack_memory,stack_size,4)
322 DECLARE_LABEL(stack_end)
323