Context Navigation

syslinux.ld @ e16e8f2

Last change on this file since e16e8f2 was e16e8f2, checked in by Edwin Eefting <edwin@datux.nl>, 3 years ago
bootstuff
Property mode set to `100644`
File size: 10.1 KB

Line
1	/* -----------------------------------------------------------------------
2	*
3	* Copyright 2008-2009 H. Peter Anvin - All Rights Reserved
4	* Copyright 2009 Intel Corporation; author: H. Peter Anvin
5	*
6	* This program is free software; you can redistribute it and/or modify
7	* it under the terms of the GNU General Public License as published by
8	* the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
9	* Boston MA 02110-1301, USA; either version 2 of the License, or
10	* (at your option) any later version; incorporated herein by reference.
11	*
12	* ----------------------------------------------------------------------- */
13
14	/*
15	* Linker script for the SYSLINUX core
16	*/
17
18	OUTPUT_FORMAT("elf32-i386", "elf32-i386", "elf32-i386")
19	OUTPUT_ARCH(i386)
20	EXTERN(_start)
21	ENTRY(_start)
22
23	STACK32_LEN = 65536;
24
25	SECTIONS
26	{
27	/* Prefix structure for the compression program */
28	. = 0;
29	HIDDEN(__module_start = .);
30	.prefix : {
31	*(.prefix)
32	}
33
34	/* "Early" sections (before the load) */
35	. = 0x1000;
36
37	.earlybss (NOLOAD) : {
38	HIDDEN(__earlybss_start = .);
39	*(.earlybss)
40	HIDDEN(__earlybss_end = .);
41	}
42	HIDDEN(__earlybss_len = ABSOLUTE(__earlybss_end) - ABSOLUTE(__earlybss_start));
43	HIDDEN(__earlybss_dwords = (__earlybss_len + 3) >> 2);
44
45	. = ALIGN(4);
46	.bss16 (NOLOAD) : {
47	HIDDEN(__bss16_start = .);
48	*(.bss16)
49	HIDDEN(__bss16_end = .);
50	}
51	HIDDEN(__bss16_len = ABSOLUTE(__bss16_end) - ABSOLUTE(__bss16_start));
52	HIDDEN(__bss16_dwords = (__bss16_len + 3) >> 2);
53
54	. = ALIGN(4);
55	.config : AT (__config_lma) {
56	HIDDEN(__config_start = .);
57	*(.config)
58	HIDDEN(__config_end = .);
59	}
60	HIDDEN(__config_len = ABSOLUTE(__config_end) - ABSOLUTE(__config_start));
61	HIDDEN(__config_dwords = (__config_len + 3) >> 2);
62
63	/* Generated and/or copied code */
64
65	. = ALIGN(128); /* Minimum separation from mutable data */
66	.replacestub : AT (__replacestub_lma) {
67	HIDDEN(__replacestub_start = .);
68	*(.replacestub)
69	HIDDEN(__replacestub_end = .);
70	}
71	HIDDEN(__replacestub_len = ABSOLUTE(__replacestub_end) - ABSOLUTE(__replacestub_start));
72	HIDDEN(__replacestub_dwords = (__replacestub_len + 3) >> 2);
73
74	. = ALIGN(16);
75	HIDDEN(__gentextnr_lma = .);
76	.gentextnr : AT(__gentextnr_lma) {
77	HIDDEN(__gentextnr_start = .);
78	*(.gentextnr)
79	HIDDEN(__gentextnr_end = .);
80	}
81	HIDDEN(__gentextnr_len = ABSOLUTE(__gentextnr_end) - ABSOLUTE(__gentextnr_start));
82	HIDDEN(__gentextnr_dwords = (__gentextnr_len + 3) >> 2);
83
84	. = STACK_BASE;
85	.stack16 : AT(STACK_BASE) {
86	HIDDEN(__stack16_start = .);
87	. += STACK_LEN;
88	HIDDEN(__stack16_end = .);
89	}
90	HIDDEN(__stack16_len = ABSOLUTE(__stack16_end) - ABSOLUTE(__stack16_start));
91	HIDDEN(__stack16_dwords = (__stack16_len + 3) >> 2);
92
93	/* Initialized sections */
94
95	. = 0x7c00;
96	.init : {
97	FILL(0x90909090)
98	HIDDEN(__init_start = .);
99	*(.init)
100	HIDDEN(__init_end = .);
101	}
102	HIDDEN(__init_len = ABSOLUTE(__init_end) - ABSOLUTE(__init_start));
103	HIDDEN(__init_dwords = (__init_len + 3) >> 2);
104
105	.text16 : {
106	FILL(0x90909090)
107	HIDDEN(__text16_start = .);
108	*(.text16)
109	HIDDEN(__text16_end = .);
110	}
111	HIDDEN(__text16_len = ABSOLUTE(__text16_end) - ABSOLUTE(__text16_start));
112	HIDDEN(__text16_dwords = (__text16_len + 3) >> 2);
113
114	/*
115	* .textnr is used for 32-bit code that is used on the code
116	* path to initialize the .text segment
117	*/
118	. = ALIGN(16);
119	.textnr : {
120	FILL(0x90909090)
121	HIDDEN(__textnr_start = .);
122	*(.textnr)
123	HIDDEN(__textnr_end = .);
124	}
125	HIDDEN(__textnr_len = ABSOLUTE(__textnr_end) - ABSOLUTE(__textnr_start));
126	HIDDEN(__textnr_dwords = (__textnr_len + 3) >> 2);
127
128	. = ALIGN(16);
129	HIDDEN(__bcopyxx_start = .);
130
131	.bcopyxx.text : {
132	FILL(0x90909090)
133	HIDDEN(__bcopyxx_text_start = .);
134	*(.bcopyxx.text)
135	HIDDEN(__bcopyxx_text_end = .);
136	}
137	HIDDEN(__bcopyxx_text_len = ABSOLUTE(__bcopyxx_text_end) - ABSOLUTE(__bcopyxx_text_start));
138	HIDDEN(__bcopyxx_text_dwords = (__bcopyxx_text_len + 3) >> 2);
139
140	.bcopyxx.data : {
141	HIDDEN(__bcopyxx_data_start = .);
142	*(.bcopyxx.text)
143	HIDDEN(__bcopyxx_data_end = .);
144	}
145	HIDDEN(__bcopyxx_data_len = ABSOLUTE(__bcopyxx_data_end) - ABSOLUTE(__bcopyxx_data_start));
146	HIDDEN(__bcopyxx_data_dwords = (__bcopyxx_data_len + 3) >> 2);
147
148	HIDDEN(__bcopyxx_end = .);
149	HIDDEN(__bcopyxx_len = ABSOLUTE(__bcopyxx_end) - ABSOLUTE(__bcopyxx_start));
150	HIDDEN(__bcopyxx_dwords = (__bcopyxx_len + 3) >> 2);
151
152	. = ALIGN(4);
153	.data16 : {
154	HIDDEN(__data16_start = .);
155	*(.data16)
156	HIDDEN(__data16_end = .);
157	}
158	HIDDEN(__data16_len = ABSOLUTE(__data16_end) - ABSOLUTE(__data16_start));
159	HIDDEN(__data16_dwords = (__data16_len + 3) >> 2);
160
161	. = ALIGN(4);
162	HIDDEN(__config_lma = .);
163	. += SIZEOF(.config);
164
165	. = ALIGN(4);
166	HIDDEN(__replacestub_lma = .);
167	. += SIZEOF(.replacestub);
168
169	/* The 32-bit code loads above the non-progbits sections */
170
171	. = ALIGN(16);
172	HIDDEN(__pm_code_lma = .);
173
174	HIDDEN(__high_clear_start = .);
175
176	. = ALIGN(512);
177	.adv (NOLOAD) : {
178	HIDDEN(__adv_start = .);
179	*(.adv)
180	HIDDEN(__adv_end = .);
181	}
182	HIDDEN(__adv_len = ABSOLUTE(__adv_end) - ABSOLUTE(__adv_start));
183	HIDDEN(__adv_dwords = (__adv_len + 3) >> 2);
184
185	/* Late uninitialized sections */
186
187	. = ALIGN(4);
188	.uibss (NOLOAD) : {
189	HIDDEN(__uibss_start = .);
190	*(.uibss)
191	HIDDEN(__uibss_end = .);
192	}
193	HIDDEN(__uibss_len = ABSOLUTE(__uibss_end) - ABSOLUTE(__uibss_start));
194	HIDDEN(__uibss_dwords = (__uibss_len + 3) >> 2);
195
196	HIDDEN(_end16 = .);
197	HIDDEN(__assert_end16 = ASSERT(_end16 <= 0x10000, "64K overflow"));
198
199	/*
200	* Special 16-bit segments
201	*/
202
203	. = ALIGN(65536);
204	.real_mode (NOLOAD) : {
205	*(.real_mode)
206	}
207	HIDDEN(real_mode_seg = core_real_mode >> 4);
208
209	. = ALIGN(65536);
210	.xfer_buf (NOLOAD) : {
211	*(.xfer_buf)
212	}
213	HIDDEN(xfer_buf_seg = core_xfer_buf >> 4);
214
215	/*
216	* Used to allocate lowmem buffers from 32-bit code
217	*/
218	.lowmem (NOLOAD) : {
219	HIDDEN(__lowmem_start = .);
220	*(.lowmem)
221	HIDDEN(__lowmem_end = .);
222	}
223	HIDDEN(__lowmem_len = ABSOLUTE(__lowmem_end) - ABSOLUTE(__lowmem_start));
224	HIDDEN(__lowmem_dwords = (__lowmem_len + 3) >> 2);
225
226	HIDDEN(__high_clear_end = .);
227
228	HIDDEN(__high_clear_len = ABSOLUTE(__high_clear_end) - ABSOLUTE(__high_clear_start));
229	HIDDEN(__high_clear_dwords = (__high_clear_len + 3) >> 2);
230
231	/* Start of the lowmem heap */
232	. = ALIGN(16);
233	HIDDEN(__lowmem_heap = .);
234
235	/*
236	* 32-bit code. This is a hack for the moment due to the
237	* real-mode segments also allocated.
238	*/
239
240	. = 0x100000;
241
242	HIDDEN(__pm_code_start = .);
243
244	HIDDEN(__text_vma = .);
245	HIDDEN(__text_lma = __pm_code_lma);
246	.text : AT(__text_lma) {
247	FILL(0x90909090)
248	HIDDEN(__text_start = .);
249	*(.text)
250	(.text.)
251	HIDDEN(__text_end = .);
252	}
253
254	. = ALIGN(16);
255
256	HIDDEN(__rodata_vma = .);
257	HIDDEN(__rodata_lma = __rodata_vma + __text_lma - __text_vma);
258	.rodata : AT(__rodata_lma) {
259	HIDDEN(__rodata_start = .);
260	*(.rodata)
261	(.rodata.)
262	HIDDEN(__rodata_end = .);
263	}
264
265	. = ALIGN(4);
266
267	HIDDEN(__ctors_vma = .);
268	HIDDEN(__ctors_lma = __ctors_vma + __text_lma - __text_vma);
269	.ctors : AT(__ctors_lma) {
270	HIDDEN(__ctors_start = .);
271	KEEP ((SORT(.preinit_array)))
272	KEEP ((SORT(.init_array)))
273	KEEP ((SORT(.ctors)))
274	HIDDEN(__ctors_end = .);
275	}
276
277	HIDDEN(__dtors_vma = .);
278	HIDDEN(__dtors_lma = __dtors_vma + __text_lma - __text_vma);
279	.dtors : AT(__dtors_lma) {
280	HIDDEN(__dtors_start = .);
281	KEEP ((SORT(.fini_array)))
282	KEEP ((SORT(.dtors)))
283	HIDDEN(__dtors_end = .);
284	}
285
286	. = ALIGN(4);
287
288	HIDDEN(__dynsym_vma = .);
289	HIDDEN(__dynsym_lma = __dynsym_vma + __text_lma - __text_vma);
290	.dynsym : AT(__dynsym_lma) {
291	HIDDEN(__dynsym_start = .);
292	*(.dynsym)
293	HIDDEN(__dynsym_end = .);
294	}
295	HIDDEN(__dynsym_len = __dynsym_end - __dynsym_start);
296
297	. = ALIGN(4);
298
299	HIDDEN(__dynstr_vma = .);
300	HIDDEN(__dynstr_lma = __dynstr_vma + __text_lma - __text_vma);
301	.dynstr : AT(__dynstr_lma) {
302	HIDDEN(__dynstr_start = .);
303	*(.dynstr)
304	HIDDEN(__dynstr_end = .);
305	}
306	HIDDEN(__dynstr_len = __dynstr_end - __dynstr_start);
307
308	. = ALIGN(4);
309
310	HIDDEN(__gnu_hash_vma = .);
311	HIDDEN(__gnu_hash_lma = __gnu_hash_vma + __text_lma - __text_vma);
312	.gnu.hash : AT(__gnu_hash_lma) {
313	HIDDEN(__gnu_hash_start = .);
314	*(.gnu.hash)
315	HIDDEN(__gnu_hash_end = .);
316	}
317
318
319	. = ALIGN(4);
320
321	HIDDEN(__dynlink_vma = .);
322	HIDDEN(__dynlink_lma = __dynlink_vma + __text_lma - __text_vma);
323	.dynlink : AT(__dynlink_lma) {
324	HIDDEN(__dynlink_start = .);
325	*(.dynlink)
326	HIDDEN(__dynlink_end = .);
327	}
328
329	. = ALIGN(4);
330
331	HIDDEN(__got_vma = .);
332	HIDDEN(__got_lma = __got_vma + __text_lma - __text_vma);
333	.got : AT(__got_lma) {
334	HIDDEN(__got_start = .);
335	KEEP (*(.got.plt))
336	KEEP (*(.got))
337	HIDDEN(__got_end = .);
338	}
339
340	. = ALIGN(4);
341
342	HIDDEN(__dynamic_vma = .);
343	HIDDEN(__dynamic_lma = __dynamic_vma + __text_lma - __text_vma);
344	.dynamic : AT(__dynamic_lma) {
345	HIDDEN(__dynamic_start = .);
346	*(.dynamic)
347	HIDDEN(__dynamic_end = .);
348	}
349
350	. = ALIGN(16);
351
352	HIDDEN(__data_vma = .);
353	HIDDEN(__data_lma = __data_vma + __text_lma - __text_vma);
354	.data : AT(__data_lma) {
355	HIDDEN(__data_start = .);
356	*(.data)
357	(.data.)
358	HIDDEN(__data_end = .);
359	}
360
361	HIDDEN(__pm_code_end = .);
362	HIDDEN(__pm_code_len = ABSOLUTE(__pm_code_end) - ABSOLUTE(__pm_code_start));
363	HIDDEN(__pm_code_dwords = (__pm_code_len + 3) >> 2);
364
365	. = ALIGN(128);
366
367	HIDDEN(__bss_vma = .);
368	HIDDEN(__bss_lma = .); /* Dummy */
369	.bss (NOLOAD) : AT (__bss_lma) {
370	HIDDEN(__bss_start = .);
371	*(.bss)
372	(.bss.)
373	*(COMMON)
374	HIDDEN(__bss_end = .);
375	}
376	HIDDEN(__bss_len = ABSOLUTE(__bss_end) - ABSOLUTE(__bss_start));
377	HIDDEN(__bss_dwords = (__bss_len + 3) >> 2);
378
379	/* Data saved away before bss initialization */
380	. = ALIGN(128);
381
382	HIDDEN(__savedata_vma = .);
383	HIDDEN(__savedata_lma = .); /* Dummy */
384	.savedata (NOLOAD) : AT (__savedata_lma) {
385	HIDDEN(__savedata_start = .);
386	*(.savedata)
387	(.savedata.)
388	HIDDEN(__savedata_end = .);
389	}
390	HIDDEN(__savedata_len = ABSOLUTE(__savedata_end) - ABSOLUTE(__savedata_start));
391	HIDDEN(__savedata_dwords = (__savedata_len + 3) >> 2);
392
393	/* XXX: This stack should be unified with the COM32 stack */
394	HIDDEN(__stack_vma = .);
395	__stack_lma = .; /* Dummy */
396	.stack (NOLOAD) : AT(__stack_lma) {
397	HIDDEN(__stack_start = .);
398	*(.stack)
399	HIDDEN(__stack_end = .);
400	}
401	HIDDEN(__stack_len = ABSOLUTE(__stack_end) - ABSOLUTE(__stack_start));
402	HIDDEN(__stack_dwords = (__stack_len + 3) >> 2);
403
404	HIDDEN(_end = .);
405
406	/* Heap follows after our own PM code */
407	. = ALIGN(65536);
408	HIDDEN(free_high_memory = .);
409
410	/* Stuff we don't need... */
411	/DISCARD/ : {
412	*(.eh_frame)
413	}
414	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Original Format