← Back to branch summary

~pmdj/ubuntu/trusty/qemu/2.9+applesmc+fadtv3

« back to all changes in this revision

Viewing changes to roms/ipxe/src/arch/i386/scripts/i386-kir.lds

  • Committer: Phil Dennis-Jordan
  • Date: 2017-07-21 08:03:43 UTC
  • mfrom: (1.1.1)
  • Revision ID: phil@philjordan.eu-20170721080343-2yr2vdj7713czahv
New upstream release 2.9.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
roms/ipxe/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
    }
 
140
 
 
141
    /*
 
142
     * Load address calculations.  The slightly obscure nature of the
 
143
     * calculations is because ALIGN(x) can only operate on the
 
144
     * location counter.
 
145
     */
 
146
 
 
147
    _max_align              = DEFINED ( _max_align ) ? _max_align : 16;
 
148
    _load_addr              = DEFINED ( _load_addr ) ? _load_addr : 0;
 
149
 
 
150
    .                       = _load_addr;
 
151
 
 
152
    .                      -= _prefix_link_addr;
 
153
    _prefix_load_offset     = ALIGN ( _max_align );
 
154
    _prefix_load_addr       = _prefix_link_addr + _prefix_load_offset;
 
155
    _prefix_size            = _eprefix - _prefix;
 
156
    _prefix_progbits_size   = _eprefix_progbits - _prefix;
 
157
    .                       = _prefix_load_addr + _prefix_progbits_size;
 
158
 
 
159
    .                      -= _text16_link_addr;
 
160
    _text16_load_offset     = ALIGN ( _max_align );
 
161
    _text16_load_addr       = _text16_link_addr + _text16_load_offset;
 
162
    _text16_size            = _etext16 - _text16;
 
163
    _text16_progbits_size   = _etext16_progbits - _text16;
 
164
    .                       = _text16_load_addr + _text16_progbits_size;
 
165
 
 
166
    .                      -= _data16_link_addr;
 
167
    _data16_load_offset     = ALIGN ( _max_align );
 
168
    _data16_load_addr       = _data16_link_addr + _data16_load_offset;
 
169
    _data16_size            = _edata16 - _data16;
 
170
    _data16_progbits_size   = _edata16_progbits - _data16;
 
171
    .                       = _data16_load_addr + _data16_progbits_size;
 
172
 
 
173
    .                       = ALIGN ( _max_align );
 
174
 
 
175
    _load_size              = . - _load_addr;
 
176
 
 
177
    /*
 
178
     * Alignment checks.  ALIGN() can only operate on the location
 
179
     * counter, so we set the location counter to each value we want
 
180
     * to check.
 
181
     */
 
182
 
 
183
    . = _prefix_load_addr - _prefix_link_addr;
 
184
    _assert = ASSERT ( ( . == ALIGN ( _max_align ) ),
 
185
                       "_prefix is badly aligned" );
 
186
 
 
187
    . = _text16_load_addr - _text16_link_addr;
 
188
    _assert = ASSERT ( ( . == ALIGN ( _max_align ) ),
 
189
                       "_text16 is badly aligned" );
 
190
 
 
191
    . = _data16_load_addr - _data16_link_addr;
 
192
    _assert = ASSERT ( ( . == ALIGN ( _max_align ) ),
 
193
                       "_data16 is badly aligned" );
 
194
 
 
195
    /*
 
196
     * Values calculated to save code from doing it
 
197
     */
 
198
    _text16_size_pgh    = ( ( _text16_size + 15 ) / 16 );
 
199
    _data16_size_pgh    = ( ( _data16_size + 15 ) / 16 );
 
200
    _load_size_pgh      = ( ( _load_size + 15 ) / 16 );
 
201
    _load_size_sect     = ( ( _load_size + 511 ) / 512 );
 
202
}