isa.c uses the new table infrastructure.
[people/xl0/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         *(SORT(.tbl.*))         /* Various tables.  See include/tables.h */
144         _progbits_end = .;
145     }
146
147     .bss : AT ( _data_load_offset + __bss ) {
148         __bss = .;
149         _bss = .;
150         *(.bss)
151         *(.bss.*)
152         *(COMMON)
153         _ebss = .;
154     }
155
156     .stack : AT ( _data_load_offset + __stack ) {
157         __stack = .;
158         *(.stack)
159         *(.stack.*)
160     }
161
162     _edata = .;
163
164     _end = .;
165
166     /*
167      * Dispose of the comment and note sections to make the link map
168      * easier to read
169      */
170
171     /DISCARD/ : {
172         *(.comment)
173         *(.note)
174     }
175
176     /*
177      * Load address calculations.  The slightly obscure nature of the
178      * calculations is because ALIGN(x) can only operate on the
179      * location counter.
180      */
181
182     _max_align              = DEFINED ( _max_align ) ? _max_align : 16;
183     _load_addr              = DEFINED ( _load_addr ) ? _load_addr : 0;
184
185     .                       = _load_addr;
186
187     .                      -= _prefix_link_addr;
188     _prefix_load_offset     = ALIGN ( _max_align );
189     _prefix_load_addr       = _prefix_link_addr + _prefix_load_offset;
190     _prefix_size            = _eprefix - _prefix;
191     .                       = _prefix_load_addr + _prefix_size;
192
193     .                      -= _decompress_link_addr;
194     _decompress_load_offset = ALIGN ( _max_align );
195     _decompress_load_addr   = _decompress_link_addr + _decompress_load_offset;
196     _decompress_size        = _edecompress - _decompress;
197     .                       = _decompress_load_addr + _decompress_size;
198
199     .                      -= _text_link_addr;
200     _text_load_offset       = ALIGN ( _max_align );
201     _text_load_addr         = _text_link_addr + _text_load_offset;
202     _text_size              = _etext - _text;
203     .                       = _text_load_addr + _text_size;
204
205     .                      -= _data_link_addr;
206     _data_load_offset       = ALIGN ( _max_align );
207     _data_load_addr         = _data_link_addr + _data_load_offset;
208     _data_size              = _edata - _data;
209     .                       = _data_load_addr + _data_size;
210
211     /*
212      * Alignment checks.  ALIGN() can only operate on the location
213      * counter, so we set the location counter to each value we want
214      * to check.
215      */
216
217     . = _prefix_load_addr - _prefix_link_addr;
218     _assert = ASSERT ( ( . == ALIGN ( _max_align ) ),
219                        "_prefix is badly aligned" );
220
221     . = _decompress_load_addr - _prefix_link_addr;
222     _assert = ASSERT ( ( . == ALIGN ( _max_align ) ),
223                        "_decompress is badly aligned" );
224
225     . = _text_load_addr - _text_link_addr;
226     _assert = ASSERT ( ( . == ALIGN ( _max_align ) ),
227                        "_text is badly aligned" );
228
229     . = _data_load_addr - _data_link_addr;
230     _assert = ASSERT ( ( . == ALIGN ( _max_align ) ),
231                        "_data is badly aligned" );
232
233     /*
234      * setup16 needs to know this when KEEP_IT_REAL is used.  There
235      * are no harmful side-effects of calculating it all the time.
236      */
237     _text_load_size_pgh = ( _data_load_addr - _text_load_addr ) / 16 ;
238
239     /*
240      * Useful-to-know values.
241      */
242
243     /* Size of the decompressed runtime image */
244     _runtime_size = _edata - _text;
245     /* Size of the initialised-contents portion of the runtime image */
246     _runtime_progbits_size = _progbits_end - _text;
247     /* Size of the (non-compressed) binary file */
248     _file_size = _prefix_size + _runtime_progbits_size;
249     /* Size of the non-compressed portion of the compressed binary file */
250     _zfile_noncompressed_size = _prefix_size + _decompress_size;
251 }