1/* 2 * Copyright (c) 2014, Linaro Limited 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions are met: 7 * 8 * 1. Redistributions of source code must retain the above copyright notice, 9 * this list of conditions and the following disclaimer. 10 * 11 * 2. Redistributions in binary form must reproduce the above copyright notice, 12 * this list of conditions and the following disclaimer in the documentation 13 * and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 16 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE 19 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 20 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 21 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 22 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 23 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 24 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 25 * POSSIBILITY OF SUCH DAMAGE. 26 */ 27 28/* 29 * Copyright (c) 2008-2010 Travis Geiselbrecht 30 * 31 * Permission is hereby granted, free of charge, to any person obtaining 32 * a copy of this software and associated documentation files 33 * (the "Software"), to deal in the Software without restriction, 34 * including without limitation the rights to use, copy, modify, merge, 35 * publish, distribute, sublicense, and/or sell copies of the Software, 36 * and to permit persons to whom the Software is furnished to do so, 37 * subject to the following conditions: 38 * 39 * The above copyright notice and this permission notice shall be 40 * included in all copies or substantial portions of the Software. 41 * 42 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 43 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 44 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 45 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 46 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 47 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 48 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 49 */ 50 51#include <platform_config.h> 52 53OUTPUT_FORMAT(CFG_KERN_LINKER_FORMAT) 54OUTPUT_ARCH(CFG_KERN_LINKER_ARCH) 55 56ENTRY(_start) 57SECTIONS 58{ 59 . = CFG_TEE_LOAD_ADDR; 60 61 /* text/read-only data */ 62 .text : { 63 __text_start = .; 64 KEEP(*(.text.boot.vectab1)) 65 KEEP(*(.text.boot.vectab2)) 66 KEEP(*(.text.boot)) 67 68 . = ALIGN(8); 69 __initcall_start = .; 70 KEEP(*(.initcall1)) 71 KEEP(*(.initcall2)) 72 KEEP(*(.initcall3)) 73 KEEP(*(.initcall4)) 74 __initcall_end = .; 75 76#ifdef CFG_WITH_PAGER 77 *(.text) 78/* Include list of sections needed for paging */ 79#include <text_unpaged.ld.S> 80#else 81 *(.text .text.*) 82#endif 83 *(.sram.text.glue_7* .gnu.linkonce.t.*) 84 . = ALIGN(8); 85 __text_end = .; 86 } 87 88 .rodata : ALIGN(8) { 89 __rodata_start = .; 90 *(.gnu.linkonce.r.*) 91#ifdef CFG_WITH_PAGER 92 *(.rodata .rodata.__unpaged) 93#include <rodata_unpaged.ld.S> 94#else 95 *(.rodata .rodata.*) 96 97 /* 98 * 8 to avoid unwanted padding between __start_ta_head_section 99 * and the first structure in ta_head_section, in 64-bit 100 * builds 101 */ 102 . = ALIGN(8); 103 __start_ta_head_section = . ; 104 KEEP(*(ta_head_section)) 105 __stop_ta_head_section = . ; 106 . = ALIGN(8); 107 __start_phys_mem_map_section = . ; 108 KEEP(*(phys_mem_map_section)) 109 __end_phys_mem_map_section = . ; 110#endif 111 . = ALIGN(8); 112 __rodata_end = .; 113 } 114 115 .interp : { *(.interp) } 116 .hash : { *(.hash) } 117 .dynsym : { *(.dynsym) } 118 .dynstr : { *(.dynstr) } 119 .rel.text : { *(.rel.text) *(.rel.gnu.linkonce.t*) } 120 .rela.text : { *(.rela.text) *(.rela.gnu.linkonce.t*) } 121 .rel.data : { *(.rel.data) *(.rel.gnu.linkonce.d*) } 122 .rela.data : { *(.rela.data) *(.rela.gnu.linkonce.d*) } 123 .rel.rodata : { *(.rel.rodata) *(.rel.gnu.linkonce.r*) } 124 .rela.rodata : { *(.rela.rodata) *(.rela.gnu.linkonce.r*) } 125 .rel.got : { *(.rel.got) } 126 .rela.got : { *(.rela.got) } 127 .rel.ctors : { *(.rel.ctors) } 128 .rela.ctors : { *(.rela.ctors) } 129 .rel.dtors : { *(.rel.dtors) } 130 .rela.dtors : { *(.rela.dtors) } 131 .rel.init : { *(.rel.init) } 132 .rela.init : { *(.rela.init) } 133 .rel.fini : { *(.rel.fini) } 134 .rela.fini : { *(.rela.fini) } 135 .rel.bss : { *(.rel.bss) } 136 .rela.bss : { *(.rela.bss) } 137 .rel.plt : { *(.rel.plt) } 138 .rela.plt : { *(.rela.plt) } 139 .init : { *(.init) } =0x9090 140 .plt : { *(.plt) } 141 142 /* .ARM.exidx is sorted, so has to go in its own output section. */ 143 .ARM.exidx : { 144 __exidx_start = .; 145 *(.ARM.exidx* .gnu.linkonce.armexidx.*) 146 __exidx_end = .; 147 } 148 149 .ARM.extab : { 150 __extab_start = .; 151 *(.ARM.extab*) 152 __extab_end = .; 153 } 154 155 .data : ALIGN(8) { 156 /* writable data */ 157 __data_start_rom = .; 158 /* in one segment binaries, the rom data address is on top 159 of the ram data address */ 160 __early_bss_start = .; 161 *(.early_bss .early_bss.*) 162 . = ALIGN(8); 163 __early_bss_end = .; 164 __data_start = .; 165 *(.data .data.* .gnu.linkonce.d.*) 166 . = ALIGN(8); 167 } 168 169 .ctors : ALIGN(8) { 170 __ctor_list = .; 171 KEEP(*(.ctors .ctors.* .init_array .init_array.*)) 172 __ctor_end = .; 173 } 174 .dtors : ALIGN(8) { 175 __dtor_list = .; 176 KEEP(*(.dtors .dtors.* .fini_array .fini_array.*)) 177 __dtor_end = .; 178 } 179 .got : { *(.got.plt) *(.got) } 180 .dynamic : { *(.dynamic) } 181 182 __data_end = .; 183 /* unintialized data */ 184 .bss : ALIGN(8) { 185 __bss_start = .; 186 *(.bss .bss.*) 187 *(.gnu.linkonce.b.*) 188 *(COMMON) 189 . = ALIGN(8); 190 __bss_end = .; 191 } 192 193 .heap1 (NOLOAD) : { 194 /* 195 * We're keeping track of the padding added before the 196 * .nozi section so we can do something useful with 197 * this otherwise wasted memory. 198 */ 199 __heap1_start = .; 200#ifndef CFG_WITH_PAGER 201 . += CFG_CORE_HEAP_SIZE; 202#endif 203 . = ALIGN(16 * 1024); 204 __heap1_end = .; 205 } 206 207 /* 208 * Uninitialized data that shouldn't be zero initialized at 209 * runtime. 210 * 211 * L1 mmu table requires 16 KiB alignment 212 */ 213 .nozi (NOLOAD) : ALIGN(16 * 1024) { 214 __nozi_start = .; 215 KEEP(*(.nozi .nozi.*)) 216 . = ALIGN(16); 217 __nozi_end = .; 218 __nozi_stack_start = .; 219 KEEP(*(.nozi_stack)) 220 . = ALIGN(8); 221 __nozi_stack_end = .; 222 } 223 224#ifdef CFG_WITH_PAGER 225 .heap2 (NOLOAD) : { 226 __heap2_start = .; 227 /* 228 * Reserve additional memory for heap, the total should be 229 * at least CFG_CORE_HEAP_SIZE, but count what has already 230 * been reserved in .heap1 231 */ 232 . += CFG_CORE_HEAP_SIZE - (__heap1_end - __heap1_start); 233 . = ALIGN(4 * 1024); 234 __heap2_end = .; 235 } 236 237 .text_init : ALIGN(4 * 1024) { 238 __text_init_start = .; 239/* 240 * Include list of sections needed for boot initialization, this list 241 * overlaps with unpaged.ld.S but since unpaged.ld.S is first all those 242 * sections will go into the unpaged area. 243 */ 244#include <text_init.ld.S> 245 . = ALIGN(8); 246 __text_init_end = .; 247 } 248 249 .rodata_init : ALIGN(8) { 250 __rodata_init_start = .; 251#include <rodata_init.ld.S> 252 . = ALIGN(8); 253 __start_phys_mem_map_section = . ; 254 KEEP(*(phys_mem_map_section)) 255 __end_phys_mem_map_section = . ; 256 . = ALIGN(8); 257 __rodata_init_end = .; 258 } 259 __init_start = __text_init_start; 260 __init_end = .; 261 __init_size = __init_end - __text_init_start; 262 263 .text_pageable : ALIGN(8) { 264 __text_pageable_start = .; 265 *(.text*) 266 . = ALIGN(8); 267 __text_pageable_end = .; 268 } 269 270 .rodata_pageable : ALIGN(8) { 271 __rodata_pageable_start = .; 272 *(.rodata*) 273 /* 274 * 8 to avoid unwanted padding between __start_ta_head_section 275 * and the first structure in ta_head_section, in 64-bit 276 * builds 277 */ 278 . = ALIGN(8); 279 __start_ta_head_section = . ; 280 KEEP(*(ta_head_section)) 281 __stop_ta_head_section = . ; 282 . = ALIGN(4 * 1024); 283 __rodata_pageable_end = .; 284 } 285 286 __pageable_part_start = __rodata_init_end; 287 __pageable_part_end = __rodata_pageable_end; 288 __pageable_start = __text_init_start; 289 __pageable_end = __pageable_part_end; 290 291 /* 292 * Assign a safe spot to store the hashes of the pages before 293 * heap is initialized. 294 */ 295 __tmp_hashes_start = __rodata_init_end; 296 __tmp_hashes_size = ((__pageable_end - __pageable_start) / 297 (4 * 1024)) * 32; 298 __tmp_hashes_end = __tmp_hashes_start + __tmp_hashes_size; 299 300 __init_mem_usage = __tmp_hashes_end - CFG_TEE_LOAD_ADDR; 301 302 ASSERT(CFG_TEE_LOAD_ADDR >= CFG_TEE_RAM_START, 303 "Load address before start of physical memory") 304 ASSERT(CFG_TEE_LOAD_ADDR < (CFG_TEE_RAM_START + CFG_TEE_RAM_PH_SIZE), 305 "Load address after end of physical memory") 306 ASSERT(__tmp_hashes_end < (CFG_TEE_RAM_START + CFG_TEE_RAM_PH_SIZE), 307 "OP-TEE can't fit init part into available physical memory") 308 ASSERT((CFG_TEE_RAM_START + CFG_TEE_RAM_PH_SIZE - __init_end) > 309 1 * 4096, "Too few free pages to initialize paging") 310 311 312#endif /*CFG_WITH_PAGER*/ 313 314#ifdef CFG_CORE_SANITIZE_KADDRESS 315 . = CFG_TEE_RAM_START + (CFG_TEE_RAM_VA_SIZE * 8) / 9 - 8; 316 . = ALIGN(8); 317 .asan_shadow : { 318 __asan_shadow_start = .; 319 . += CFG_TEE_RAM_VA_SIZE / 9; 320 __asan_shadow_end = .; 321 } 322#endif /*CFG_CORE_SANITIZE_KADDRESS*/ 323 324 __end = .; 325 326#ifndef CFG_WITH_PAGER 327 __init_size = __data_end - CFG_TEE_LOAD_ADDR; 328 __init_mem_usage = __end - CFG_TEE_LOAD_ADDR; 329#endif 330 . = CFG_TEE_RAM_START + CFG_TEE_RAM_VA_SIZE; 331 _end_of_ram = .; 332 333 /DISCARD/ : { 334 /* Strip unnecessary stuff */ 335 *(.comment .note .eh_frame) 336 /* Strip meta variables */ 337 *(__keep_meta_vars*) 338 } 339 340} 341