SAFE public projects git trees. - safe/jmp/linux-2.6/blob - arch/x86/kernel/vmlinux_32.lds.S

   1 SECTIONS
   2 {
   3         . = LOAD_OFFSET + LOAD_PHYSICAL_ADDR;
   4         phys_startup_32 = startup_32 - LOAD_OFFSET;
   5
   6         /* Text and read-only data */
   7         .text.head : AT(ADDR(.text.head) - LOAD_OFFSET) {
   8                 _text = .;
   9                 *(.text.head)
  10         } :text = 0x9090
  11
  12         /* read-only */
  13         .text : AT(ADDR(.text) - LOAD_OFFSET) {
  14                 /* not really needed, already page aligned */
  15                 . = ALIGN(PAGE_SIZE);
  16                 *(.text.page_aligned)
  17                 TEXT_TEXT
  18                 SCHED_TEXT
  19                 LOCK_TEXT
  20                 KPROBES_TEXT
  21                 IRQENTRY_TEXT
  22                 *(.fixup)
  23                 *(.gnu.warning)
  24                 /* End of text section */
  25                 _etext = .;
  26         } :text = 0x9090
  27
  28         NOTES :text :note
  29
  30         /* Exception table */
  31         . = ALIGN(16);
  32         __ex_table : AT(ADDR(__ex_table) - LOAD_OFFSET) {
  33                 __start___ex_table = .;
  34                  *(__ex_table)
  35                 __stop___ex_table = .;
  36         } :text = 0x9090
  37
  38         RODATA
  39
  40         /* writeable */
  41         . = ALIGN(PAGE_SIZE);
  42         /* Data */
  43         .data : AT(ADDR(.data) - LOAD_OFFSET) {
  44                 DATA_DATA
  45                 CONSTRUCTORS
  46         } :data
  47
  48         . = ALIGN(PAGE_SIZE);
  49         .data_nosave : AT(ADDR(.data_nosave) - LOAD_OFFSET) {
  50                 __nosave_begin = .;
  51                 *(.data.nosave)
  52                 . = ALIGN(PAGE_SIZE);
  53                 __nosave_end = .;
  54         }
  55
  56         . = ALIGN(PAGE_SIZE);
  57         .data.page_aligned : AT(ADDR(.data.page_aligned) - LOAD_OFFSET) {
  58                 *(.data.page_aligned)
  59                 *(.data.idt)
  60         }
  61
  62         . = ALIGN(32);
  63         .data.cacheline_aligned :
  64                 AT(ADDR(.data.cacheline_aligned) - LOAD_OFFSET) {
  65                 *(.data.cacheline_aligned)
  66         }
  67
  68         /* rarely changed data like cpu maps */
  69         . = ALIGN(32);
  70         .data.read_mostly : AT(ADDR(.data.read_mostly) - LOAD_OFFSET) {
  71                 *(.data.read_mostly)
  72
  73                 /* End of data section */
  74                 _edata = .;
  75         }
  76
  77         /* init_task */
  78         . = ALIGN(THREAD_SIZE);
  79         .data.init_task : AT(ADDR(.data.init_task) - LOAD_OFFSET) {
  80                 *(.data.init_task)
  81         }
  82
  83         . = ALIGN(PAGE_SIZE);
  84         .smp_locks : AT(ADDR(.smp_locks) - LOAD_OFFSET) {
  85                 /* might get freed after init */
  86                 __smp_locks = .;
  87                 *(.smp_locks)
  88                 __smp_locks_end = .;
  89         }
  90         /* will be freed after init
  91          * Following ALIGN() is required to make sure no other data falls on the
  92          * same page where __smp_alt_end is pointing as that page might be freed
  93          * after boot. Always make sure that ALIGN() directive is present after
  94          * the section which contains __smp_alt_end.
  95          */
  96         . = ALIGN(PAGE_SIZE);
  97
  98         /* Init code and data - will be freed after init */
  99         . = ALIGN(PAGE_SIZE);
 100         .init.text : AT(ADDR(.init.text) - LOAD_OFFSET) {
 101                 __init_begin = .;
 102                 _sinittext = .;
 103                 INIT_TEXT
 104                 _einittext = .;
 105         }
 106
 107         .init.data : AT(ADDR(.init.data) - LOAD_OFFSET) {
 108                 INIT_DATA
 109         }
 110
 111         . = ALIGN(16);
 112         .init.setup : AT(ADDR(.init.setup) - LOAD_OFFSET) {
 113                 __setup_start = .;
 114                 *(.init.setup)
 115                 __setup_end = .;
 116         }
 117         .initcall.init : AT(ADDR(.initcall.init) - LOAD_OFFSET) {
 118                 __initcall_start = .;
 119                 INITCALLS
 120                 __initcall_end = .;
 121         }
 122
 123         .con_initcall.init : AT(ADDR(.con_initcall.init) - LOAD_OFFSET) {
 124                 __con_initcall_start = .;
 125                 *(.con_initcall.init)
 126                 __con_initcall_end = .;
 127         }
 128
 129         .x86_cpu_dev.init : AT(ADDR(.x86_cpu_dev.init) - LOAD_OFFSET) {
 130                 __x86_cpu_dev_start = .;
 131                 *(.x86_cpu_dev.init)
 132                 __x86_cpu_dev_end = .;
 133         }
 134
 135         SECURITY_INIT
 136
 137         . = ALIGN(4);
 138         .altinstructions : AT(ADDR(.altinstructions) - LOAD_OFFSET) {
 139                 __alt_instructions = .;
 140                 *(.altinstructions)
 141                 __alt_instructions_end = .;
 142         }
 143
 144         .altinstr_replacement : AT(ADDR(.altinstr_replacement) - LOAD_OFFSET) {
 145                 *(.altinstr_replacement)
 146         }
 147
 148         . = ALIGN(4);
 149         .parainstructions : AT(ADDR(.parainstructions) - LOAD_OFFSET) {
 150                 __parainstructions = .;
 151                 *(.parainstructions)
 152                 __parainstructions_end = .;
 153         }
 154
 155         /*
 156          * .exit.text is discard at runtime, not link time, to deal with
 157          *  references from .altinstructions and .eh_frame
 158          */
 159         .exit.text : AT(ADDR(.exit.text) - LOAD_OFFSET) {
 160                 EXIT_TEXT
 161         }
 162
 163         .exit.data : AT(ADDR(.exit.data) - LOAD_OFFSET) {
 164                 EXIT_DATA
 165         }
 166
 167 #if defined(CONFIG_BLK_DEV_INITRD)
 168         . = ALIGN(PAGE_SIZE);
 169         .init.ramfs : AT(ADDR(.init.ramfs) - LOAD_OFFSET) {
 170                 __initramfs_start = .;
 171                 *(.init.ramfs)
 172                 __initramfs_end = .;
 173         }
 174 #endif
 175
 176         PERCPU(PAGE_SIZE)
 177
 178         . = ALIGN(PAGE_SIZE);
 179         /* freed after init ends here */
 180
 181         /* BSS */
 182         .bss : AT(ADDR(.bss) - LOAD_OFFSET) {
 183                 __init_end = .;
 184                 __bss_start = .;
 185                 *(.bss.page_aligned)
 186                 *(.bss)
 187                 . = ALIGN(4);
 188                 __bss_stop = .;
 189         }
 190
 191         .brk : AT(ADDR(.brk) - LOAD_OFFSET) {
 192                 . = ALIGN(PAGE_SIZE);
 193                 __brk_base = .;
 194                 . += 64 * 1024;         /* 64k alignment slop space */
 195                 *(.brk_reservation)     /* areas brk users have reserved */
 196                 __brk_limit = .;
 197         }
 198
 199         .end : AT(ADDR(.end) - LOAD_OFFSET) {
 200                 _end = . ;
 201         }
 202
 203         /* Sections to be discarded */
 204         /DISCARD/ : {
 205                 *(.exitcall.exit)
 206                 *(.discard)
 207         }
 208
 209         STABS_DEBUG
 210         DWARF_DEBUG
 211 }