[intelxl] Explicitly request a single queue pair for virtual functions
[ipxe.git] / src / arch / i386 / scripts / i386-kir.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
11 SECTIONS {
12
13     /* All sections in the resulting file have consecutive load
14      * addresses, but may have individual link addresses depending on
15      * the memory model being used.
16      *
17      * The linker symbols _prefix_link_addr, load_addr, and
18      * _max_align may be specified explicitly.  If not specified, they
19      * will default to:
20      *
21      *   _prefix_link_addr      = 0
22      *   _load_addr             = 0
23      *   _max_align             = 16
24      * 
25      * We guarantee alignment of virtual addresses to any alignment
26      * specified by the constituent object files (e.g. via
27      * __attribute__((aligned(x)))).  Load addresses are guaranteed
28      * only up to _max_align.  Provided that all loader and relocation
29      * code honours _max_align, this means that physical addresses are
30      * also guaranteed up to _max_align.
31      *
32      * Note that when using -DKEEP_IT_REAL, the UNDI segments are only
33      * guaranteed to be loaded on a paragraph boundary (i.e. 16-byte
34      * alignment).  Using _max_align>16 will therefore not guarantee
35      * >16-byte alignment of physical addresses when -DKEEP_IT_REAL is
36      * used (though virtual addresses will still be fully aligned).
37      *
38      */
39
40     /*
41      * The prefix
42      */
43
44     _prefix_link_addr = DEFINED ( _prefix_link_addr ) ? _prefix_link_addr : 0;
45     . = _prefix_link_addr;
46     _prefix = .;
47
48     .prefix : AT ( _prefix_load_offset + __prefix ) {
49         __prefix = .;
50         _entry = .;
51         *(.prefix)
52         *(.prefix.*)
53         _eprefix_progbits = .;
54     }
55     
56     _eprefix = .;
57
58     /*
59      * The 16-bit sections
60      */
61
62     _text16_link_addr = 0;
63     . = _text16_link_addr;
64     _text16 = .;
65
66     . += 1;                     /* Prevent NULL being valid */
67
68     .text16 : AT ( _text16_load_offset + __text16 ) {
69         __text16 = .;
70         KEEP(*(.text.null_trap))
71         KEEP(*(.text.null_trap.*))
72         *(.text16)
73         *(.text16.*)
74         *(.text)
75         *(.text.*)
76         _etext16_progbits = .;
77     } = 0x9090
78
79     _etext16 = .;
80
81     _data16_link_addr = 0;
82     . = _data16_link_addr;
83     _data16 = .;
84
85     . += 1;                     /* Prevent NULL being valid */
86
87     .rodata16 : AT ( _data16_load_offset + __rodata16 ) {
88         __rodata16 = .;
89         *(.rodata16)
90         *(.rodata16.*)
91         *(.rodata)
92         *(.rodata.*)
93     }
94     .data16 : AT ( _data16_load_offset + __data16 ) {
95         __data16 = .;
96         *(.data16)
97         *(.data16.*)
98         *(.data)
99         *(.data.*)
100         KEEP(*(SORT(.tbl.*)))   /* Various tables.  See include/tables.h */
101         KEEP(*(.provided))
102         KEEP(*(.provided.*))
103         _edata16_progbits = .;
104     }
105     .bss16 : AT ( _data16_load_offset + __bss16 ) {
106         __bss16 = .;
107         _bss16 = .;
108         *(.bss16)
109         *(.bss16.*)
110         *(.bss)
111         *(.bss.*)
112         *(COMMON)
113         _ebss16 = .;
114     }
115     .stack16 : AT ( _data16_load_offset + __stack16 ) {
116         __stack16 = .;
117         *(.stack16)
118         *(.stack16.*)
119         *(.stack)
120         *(.stack.*)
121     }
122
123     _edata16 = .;
124
125     _end = .;
126
127     /*
128      * Dispose of the comment and note sections to make the link map
129      * easier to read
130      */
131
132     /DISCARD/ : {
133         *(.comment)
134         *(.comment.*)
135         *(.note)
136         *(.note.*)
137         *(.discard)
138         *(.discard.*)
139         *(.sbat)
140         *(.sbat.*)
141     }
142
143     /*
144      * Load address calculations.  The slightly obscure nature of the
145      * calculations is because ALIGN(x) can only operate on the
146      * location counter.
147      */
148
149     _max_align              = DEFINED ( _max_align ) ? _max_align : 16;
150     _load_addr              = DEFINED ( _load_addr ) ? _load_addr : 0;
151
152     .                       = _load_addr;
153
154     .                      -= _prefix_link_addr;
155     _prefix_load_offset     = ALIGN ( _max_align );
156     _prefix_load_addr       = _prefix_link_addr + _prefix_load_offset;
157     _prefix_size            = _eprefix - _prefix;
158     _prefix_progbits_size   = _eprefix_progbits - _prefix;
159     .                       = _prefix_load_addr + _prefix_progbits_size;
160
161     .                      -= _text16_link_addr;
162     _text16_load_offset     = ALIGN ( _max_align );
163     _text16_load_addr       = _text16_link_addr + _text16_load_offset;
164     _text16_size            = _etext16 - _text16;
165     _text16_progbits_size   = _etext16_progbits - _text16;
166     .                       = _text16_load_addr + _text16_progbits_size;
167
168     .                      -= _data16_link_addr;
169     _data16_load_offset     = ALIGN ( _max_align );
170     _data16_load_addr       = _data16_link_addr + _data16_load_offset;
171     _data16_size            = _edata16 - _data16;
172     _data16_progbits_size   = _edata16_progbits - _data16;
173     .                       = _data16_load_addr + _data16_progbits_size;
174
175     .                       = ALIGN ( _max_align );
176
177     _load_size              = . - _load_addr;
178
179     /*
180      * Alignment checks.  ALIGN() can only operate on the location
181      * counter, so we set the location counter to each value we want
182      * to check.
183      */
184
185     . = _prefix_load_addr - _prefix_link_addr;
186     _assert = ASSERT ( ( . == ALIGN ( _max_align ) ),
187                        "_prefix is badly aligned" );
188
189     . = _text16_load_addr - _text16_link_addr;
190     _assert = ASSERT ( ( . == ALIGN ( _max_align ) ),
191                        "_text16 is badly aligned" );
192
193     . = _data16_load_addr - _data16_link_addr;
194     _assert = ASSERT ( ( . == ALIGN ( _max_align ) ),
195                        "_data16 is badly aligned" );
196
197     /*
198      * Values calculated to save code from doing it
199      */
200     _text16_size_pgh    = ( ( _text16_size + 15 ) / 16 );
201     _data16_size_pgh    = ( ( _data16_size + 15 ) / 16 );
202     _load_size_pgh      = ( ( _load_size + 15 ) / 16 );
203     _load_size_sect     = ( ( _load_size + 511 ) / 512 );
204 }