qemu/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 }