89d2f62ab18a902240c08d15cd92b436603e3dc9
[people/lynusvaz/gpxe.git] / src / arch / i386 / scripts / i386.lds
1 /* -*- sh -*- */
2
3 /*
4  * Linker script for i386 images
5  *
6  */
7
8 OUTPUT_FORMAT ( "elf32-i386", "elf32-i386", "elf32-i386" )
9 OUTPUT_ARCH ( i386 )
10 ENTRY ( _entry )
11
12 SECTIONS {
13
14     /* All sections in the resulting file have consecutive load
15      * addresses, but may have individual link addresses depending on
16      * the memory model being used.
17      *
18      * The linker symbols {prefix,decompress,text,data}_link_addr,
19      * load_addr, and _max_align may be specified explicitly.  If not
20      * specified, they will default to:
21      *
22      *   _prefix_link_addr      = 0
23      *   _decompress_link_addr  = 0
24      *   _text_link_addr        = 0
25      *   _data_link_addr        = _text_link_addr + sizeof ( text sections )
26      *   _load_addr             = 0
27      *   _max_align             = 16
28      * 
29      * We guarantee alignment of virtual addresses to any alignment
30      * specified by the constituent object files (e.g. via
31      * __attribute__((aligned(x)))).  Load addresses are guaranteed
32      * only up to _max_align.  Provided that all loader and relocation
33      * code honours _max_align, this means that physical addresses are
34      * also guaranteed up to _max_align.
35      *
36      * Note that when using -DKEEP_IT_REAL, the UNDI segments are only
37      * guaranteed to be loaded on a paragraph boundary (i.e. 16-byte
38      * alignment).  Using _max_align>16 will therefore not guarantee
39      * >16-byte alignment of physical addresses when -DKEEP_IT_REAL is
40      * used (though virtual addresses will still be fully aligned).
41      *
42      * The real-mode prefixes rely on _text_link_addr and
43      * _decompress_link_addr being 0, since they issue far calls into
44      * those sections, thus requiring that symbol_value ==
45      * symbol_offset therein.  Using the linker to calculate
46      * e.g. offset_setup16=setup16-_text will not work, since you then
47      * cannot use the reference from the prefix to setup16 to drag in
48      * setup16.o.  Life is hard.
49      *
50      * If librm is included, then it must go at offset 0 within the
51      * text section.  This is because librm is dual-usage: it is
52      * called from setup16 with %cs:0000 pointing to the start of the
53      * text section, and later it will be copied to base memory and
54      * called with %cs:0000 pointing to the start of librm.
55      *
56      * The decompressor is designed to decompress in-place.  After
57      * calling the decompressor, the image will look exactly the same
58      * as the uncompressed image; the compressed data and the
59      * decompressor code itself will have been overwritten.
60      */
61
62     /*
63      * The prefix
64      */
65
66     _prefix_link_addr = DEFINED ( _prefix_link_addr ) ? _prefix_link_addr : 0;
67     . = _prefix_link_addr;
68     _prefix = .;
69
70     .prefix : AT ( _prefix_load_offset + __prefix ) {
71         __prefix = .;
72         _entry = .;
73         *(.prefix)
74         *(.prefix.*)
75     }
76     
77     _eprefix = .;
78
79     /*
80      * The decompressor (may be absent)
81      */
82
83     _decompress_link_addr = DEFINED ( _decompress_link_addr ) ?
84                               _decompress_link_addr : 0;
85     . = _decompress_link_addr;
86     _decompress = .;
87
88     .decompress : AT ( _decompress_load_offset + __decompress ) {
89             __decompress = .;
90             *(.decompress)
91             *(.decompress.*)
92     }
93
94     _edecompress = .;
95
96     /*
97      * The text sections
98      */
99
100     _text_link_addr = DEFINED ( _text_link_addr ) ? _text_link_addr : 0;
101     . = _text_link_addr;
102     _text = .;
103
104     .text16 : AT ( _text_load_offset + __text16 ) {
105         __text16 = .;
106
107         /* librm is a special case; it must go at the start of the
108          * text section if it is included.
109          */
110         _assert = ASSERT ( ( . == _text_link_addr ), "librm cannot go first" );
111         *(.librm)
112
113         *(.text16)
114         *(.text16.*)
115     } = 0x9090
116
117     .text : AT ( _text_load_offset + __text ) {
118         __text = .;
119         *(.text)
120         *(.text.*)
121     } = 0x9090
122
123     _etext = .;
124
125     /*
126      * The data sections
127      */
128
129     _data_link_addr = DEFINED ( _data_link_addr ) ? _data_link_addr : .;
130     . = _data_link_addr;
131     _data = .;
132
133     .rodata : AT ( _data_load_offset + __rodata ) {
134         __rodata = .;
135         *(.rodata)
136         *(.rodata.*)
137     }
138
139     .data : AT ( _data_load_offset + __data ) {
140         __data = .;
141         *(.data)
142         *(.data.*)
143
144         /* Various tables.  See include/tables.h for an explanation. */
145         *(SORT(.tbl.*)) 
146
147
148         device_drivers = .;
149         *(.drivers.device)
150         device_drivers_end = .;
151         isa_drivers = . ;
152         *(.drivers.isa)
153         isa_drivers_end = .;
154         bus_drivers = .;
155         *(.drivers.bus)
156         bus_drivers_end = .;
157         type_drivers = .;
158         *(.drivers.type)
159         type_drivers_end = .;
160         post_reloc_fns = .;
161         *(SORT(.post_reloc_fns.*))
162         post_reloc_fns_end = .;
163
164         _progbits_end = .;
165     }
166
167     .bss : AT ( _data_load_offset + __bss ) {
168         __bss = .;
169         _bss = .;
170         *(.bss)
171         *(.bss.*)
172         *(COMMON)
173         _ebss = .;
174     }
175
176     .stack : AT ( _data_load_offset + __stack ) {
177         __stack = .;
178         *(.stack)
179         *(.stack.*)
180     }
181
182     _edata = .;
183
184     _end = .;
185
186     /*
187      * Dispose of the comment and note sections to make the link map
188      * easier to read
189      */
190
191     /DISCARD/ : {
192         *(.comment)
193         *(.note)
194     }
195
196     /*
197      * Load address calculations.  The slightly obscure nature of the
198      * calculations is because ALIGN(x) can only operate on the
199      * location counter.
200      */
201
202     _max_align              = DEFINED ( _max_align ) ? _max_align : 16;
203     _load_addr              = DEFINED ( _load_addr ) ? _load_addr : 0;
204
205     .                       = _load_addr;
206
207     .                      -= _prefix_link_addr;
208     _prefix_load_offset     = ALIGN ( _max_align );
209     _prefix_load_addr       = _prefix_link_addr + _prefix_load_offset;
210     _prefix_size            = _eprefix - _prefix;
211     .                       = _prefix_load_addr + _prefix_size;
212
213     .                      -= _decompress_link_addr;
214     _decompress_load_offset = ALIGN ( _max_align );
215     _decompress_load_addr   = _decompress_link_addr + _decompress_load_offset;
216     _decompress_size        = _edecompress - _decompress;
217     .                       = _decompress_load_addr + _decompress_size;
218
219     .                      -= _text_link_addr;
220     _text_load_offset       = ALIGN ( _max_align );
221     _text_load_addr         = _text_link_addr + _text_load_offset;
222     _text_size              = _etext - _text;
223     .                       = _text_load_addr + _text_size;
224
225     .                      -= _data_link_addr;
226     _data_load_offset       = ALIGN ( _max_align );
227     _data_load_addr         = _data_link_addr + _data_load_offset;
228     _data_size              = _edata - _data;
229     .                       = _data_load_addr + _data_size;
230
231     /*
232      * Alignment checks.  ALIGN() can only operate on the location
233      * counter, so we set the location counter to each value we want
234      * to check.
235      */
236
237     . = _prefix_load_addr - _prefix_link_addr;
238     _assert = ASSERT ( ( . == ALIGN ( _max_align ) ),
239                        "_prefix is badly aligned" );
240
241     . = _decompress_load_addr - _prefix_link_addr;
242     _assert = ASSERT ( ( . == ALIGN ( _max_align ) ),
243                        "_decompress is badly aligned" );
244
245     . = _text_load_addr - _text_link_addr;
246     _assert = ASSERT ( ( . == ALIGN ( _max_align ) ),
247                        "_text is badly aligned" );
248
249     . = _data_load_addr - _data_link_addr;
250     _assert = ASSERT ( ( . == ALIGN ( _max_align ) ),
251                        "_data is badly aligned" );
252
253     /*
254      * setup16 needs to know this when KEEP_IT_REAL is used.  There
255      * are no harmful side-effects of calculating it all the time.
256      */
257     _text_load_size_pgh = ( _data_load_addr - _text_load_addr ) / 16 ;
258
259     /*
260      * Useful-to-know values.
261      */
262
263     /* Size of the decompressed runtime image */
264     _runtime_size = _edata - _text;
265     /* Size of the initialised-contents portion of the runtime image */
266     _runtime_progbits_size = _progbits_end - _text;
267     /* Size of the (non-compressed) binary file */
268     _file_size = _prefix_size + _runtime_progbits_size;
269     /* Size of the non-compressed portion of the compressed binary file */
270     _zfile_noncompressed_size = _prefix_size + _decompress_size;
271 }