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 }