Remove the (unused) option to override _prefix_link_addr,
[people/mcb30/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      * We guarantee alignment of virtual addresses to any alignment
19      * specified by the constituent object files (e.g. via
20      * __attribute__((aligned(x)))).  Load addresses are guaranteed
21      * only up to _max_align.  Provided that all loader and relocation
22      * code honours _max_align, this means that physical addresses are
23      * also guaranteed up to _max_align.
24      *
25      * Note that when using -DKEEP_IT_REAL, the UNDI segments are only
26      * guaranteed to be loaded on a paragraph boundary (i.e. 16-byte
27      * alignment).  Using _max_align>16 will therefore not guarantee
28      * >16-byte alignment of physical addresses when -DKEEP_IT_REAL is
29      * used (though virtual addresses will still be fully aligned).
30      *
31      */
32
33     /*
34      * The prefix
35      */
36
37     _prefix_link_addr = 0;
38     . = _prefix_link_addr;
39     _prefix = .;
40
41     .prefix : AT ( _prefix_load_offset + __prefix ) {
42         __prefix = .;
43         _entry = .;
44         *(.prefix)
45         *(.prefix.*)
46         _eprefix_progbits = .;
47     }
48     
49     _eprefix = .;
50
51     /*
52      * The 16-bit sections, if present
53      */
54
55     _text16_link_addr = 0;
56     . = _text16_link_addr;
57     _text16 = .;
58
59     . += 1;                     /* Prevent NULL being valid */
60
61     .text16 : AT ( _text16_load_offset + __text16 ) {
62         __text16 = .;
63         *(.text16)
64         *(.text16.*)
65         _etext16_progbits = .;
66     } = 0x9090
67
68     _etext16 = .;
69
70     _data16_link_addr = 0;
71     . = _data16_link_addr;
72     _data16 = .;
73
74     . += 1;                     /* Prevent NULL being valid */
75
76     .rodata16 : AT ( _data16_load_offset + __rodata16 ) {
77         __rodata16 = .;
78         *(.rodata16)
79         *(.rodata16.*)
80     }
81     .data16 : AT ( _data16_load_offset + __data16 ) {
82         __data16 = .;
83         *(.data16)
84         *(.data16.*)
85         _edata16_progbits = .;
86     }
87     .bss16 : AT ( _data16_load_offset + __bss16 ) {
88         __bss16 = .;
89         _bss16 = .;
90         *(.bss16)
91         *(.bss16.*)
92         _ebss16 = .;
93     }
94     .stack16 : AT ( _data16_load_offset + __stack16 ) {
95         __stack16 = .;
96         *(.stack16)
97         *(.stack16.*)
98     }
99
100     _edata16 = .;
101
102     /*
103      * The 32-bit sections
104      */
105
106     _textdata_link_addr = 0;
107     . = _textdata_link_addr;
108     _textdata = .;
109
110     _text = .;
111
112     . += 1;                     /* Prevent NULL being valid */
113
114     .text : AT ( _textdata_load_offset + __text ) {
115         __text = .;
116         *(.text.null_trap)
117         *(.text)
118         *(.text.*)
119     } = 0x9090
120
121     _etext = .;
122
123     _data = .;
124
125     .rodata : AT ( _textdata_load_offset + __rodata ) {
126         __rodata = .;
127         *(.rodata)
128         *(.rodata.*)
129     }
130     .data : AT ( _textdata_load_offset + __data ) {
131         __data = .;
132         *(.data)
133         *(.data.*)
134         *(SORT(.tbl.*))         /* Various tables.  See include/tables.h */
135         _etextdata_progbits = .;
136     }
137     .bss : AT ( _textdata_load_offset + __bss ) {
138         __bss = .;
139         _bss = .;
140         *(.bss)
141         *(.bss.*)
142         *(COMMON)
143         _ebss = .;
144     }
145     .stack : AT ( _textdata_load_offset + __stack ) {
146         __stack = .;
147         *(.stack)
148         *(.stack.*)
149     }
150
151     _edata = .;
152
153     _etextdata = .;
154
155     _end = .;
156
157     /*
158      * Compressor information block
159      */
160
161     _zinfo_link_addr = 0;
162     . = _zinfo_link_addr;
163     _zinfo = .;
164
165     .zinfo : AT ( _zinfo_load_offset + __zinfo ) {
166         __zinfo = .;
167         _entry = .;
168         *(.zinfo)
169         *(.zinfo.*)
170         _ezinfo_progbits = .;
171     }
172     
173     _ezinfo = .;
174
175     /*
176      * Dispose of the comment and note sections to make the link map
177      * easier to read
178      */
179
180     /DISCARD/ : {
181         *(.comment)
182         *(.note)
183     }
184
185     /*
186      * Load address calculations.  The slightly obscure nature of the
187      * calculations is because ALIGN(x) can only operate on the
188      * location counter.
189      */
190
191     _max_align              = 16;
192     _load_addr              = 0;
193
194     .                       = _load_addr;
195
196     .                      -= _prefix_link_addr;
197     _prefix_load_offset     = ALIGN ( _max_align );
198     _prefix_load_addr       = _prefix_link_addr + _prefix_load_offset;
199     _prefix_size            = _eprefix - _prefix;
200     _prefix_progbits_size   = _eprefix_progbits - _prefix;
201     .                       = _prefix_load_addr + _prefix_progbits_size;
202
203     .                      -= _text16_link_addr;
204     _text16_load_offset     = ALIGN ( _max_align );
205     _text16_load_addr       = _text16_link_addr + _text16_load_offset;
206     _text16_size            = _etext16 - _text16;
207     _text16_progbits_size   = _etext16_progbits - _text16;
208     .                       = _text16_load_addr + _text16_progbits_size;
209
210     .                      -= _data16_link_addr;
211     _data16_load_offset     = ALIGN ( _max_align );
212     _data16_load_addr       = _data16_link_addr + _data16_load_offset;
213     _data16_size            = _edata16 - _data16;
214     _data16_progbits_size   = _edata16_progbits - _data16;
215     .                       = _data16_load_addr + _data16_progbits_size;
216
217     .                      -= _textdata_link_addr;
218     _textdata_load_offset   = ALIGN ( _max_align );
219     _textdata_load_addr     = _textdata_link_addr + _textdata_load_offset;
220     _textdata_size          = _etextdata - _textdata;
221     _textdata_progbits_size = _etextdata_progbits - _textdata;
222     .                       = _textdata_load_addr + _textdata_progbits_size;
223
224     _load_size              = . - _load_addr;
225
226     .                      -= _zinfo_link_addr;
227     _zinfo_load_offset      = ALIGN ( _max_align );
228     _zinfo_load_addr        = _zinfo_link_addr + _zinfo_load_offset;
229     _zinfo_size             = _ezinfo - _zinfo;
230     _zinfo_progbits_size    = _ezinfo_progbits - _zinfo;
231     .                       = _zinfo_load_addr + _zinfo_progbits_size;
232
233     _payload_offset         = _text16_load_offset;
234
235     /*
236      * Alignment checks.  ALIGN() can only operate on the location
237      * counter, so we set the location counter to each value we want
238      * to check.
239      */
240
241     . = _prefix_load_addr - _prefix_link_addr;
242     _assert = ASSERT ( ( . == ALIGN ( _max_align ) ),
243                        "_prefix is badly aligned" );
244
245     . = _text16_load_addr - _text16_link_addr;
246     _assert = ASSERT ( ( . == ALIGN ( _max_align ) ),
247                        "_text16 is badly aligned" );
248
249     . = _data16_load_addr - _data16_link_addr;
250     _assert = ASSERT ( ( . == ALIGN ( _max_align ) ),
251                        "_data16 is badly aligned" );
252
253     . = _textdata_load_addr - _textdata_link_addr;
254     _assert = ASSERT ( ( . == ALIGN ( _max_align ) ),
255                        "_text is badly aligned" );
256
257     /*
258      * Values calculated to save code from doing it
259      */
260     _text16_size_pgh    = ( ( _text16_size + 15 ) / 16 );
261     _data16_size_pgh    = ( ( _data16_size + 15 ) / 16 );
262
263     /*
264      * Load sizes in paragraphs and sectors.  Note that wherever the
265      * _load_size variables are used, there must be a corresponding
266      * .zinfo.fixup section.
267      */
268     _load_size_pgh      = ( ( _load_size + 15 ) / 16 );
269     _load_size_sect     = ( ( _load_size + 511 ) / 512 );
270 }