rsc.io/go@v0.0.0-20150416155037-e040fd465409/src/cmd/internal/ld/elf.go (about) 1 // Copyright 2009 The Go Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style 3 // license that can be found in the LICENSE file. 4 5 package ld 6 7 import ( 8 "encoding/binary" 9 "fmt" 10 "os" 11 ) 12 13 /* 14 * Derived from: 15 * $FreeBSD: src/sys/sys/elf32.h,v 1.8.14.1 2005/12/30 22:13:58 marcel Exp $ 16 * $FreeBSD: src/sys/sys/elf64.h,v 1.10.14.1 2005/12/30 22:13:58 marcel Exp $ 17 * $FreeBSD: src/sys/sys/elf_common.h,v 1.15.8.1 2005/12/30 22:13:58 marcel Exp $ 18 * $FreeBSD: src/sys/alpha/include/elf.h,v 1.14 2003/09/25 01:10:22 peter Exp $ 19 * $FreeBSD: src/sys/amd64/include/elf.h,v 1.18 2004/08/03 08:21:48 dfr Exp $ 20 * $FreeBSD: src/sys/arm/include/elf.h,v 1.5.2.1 2006/06/30 21:42:52 cognet Exp $ 21 * $FreeBSD: src/sys/i386/include/elf.h,v 1.16 2004/08/02 19:12:17 dfr Exp $ 22 * $FreeBSD: src/sys/powerpc/include/elf.h,v 1.7 2004/11/02 09:47:01 ssouhlal Exp $ 23 * $FreeBSD: src/sys/sparc64/include/elf.h,v 1.12 2003/09/25 01:10:26 peter Exp $ 24 * 25 * Copyright (c) 1996-1998 John D. Polstra. All rights reserved. 26 * Copyright (c) 2001 David E. O'Brien 27 * Portions Copyright 2009 The Go Authors. All rights reserved. 28 * 29 * Redistribution and use in source and binary forms, with or without 30 * modification, are permitted provided that the following conditions 31 * are met: 32 * 1. Redistributions of source code must retain the above copyright 33 * notice, this list of conditions and the following disclaimer. 34 * 2. Redistributions in binary form must reproduce the above copyright 35 * notice, this list of conditions and the following disclaimer in the 36 * documentation and/or other materials provided with the distribution. 37 * 38 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 39 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 40 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 41 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 42 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 43 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 44 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 45 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 46 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 47 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 48 * SUCH DAMAGE. 49 * 50 */ 51 52 /* 53 * ELF definitions that are independent of architecture or word size. 54 */ 55 56 /* 57 * Note header. The ".note" section contains an array of notes. Each 58 * begins with this header, aligned to a word boundary. Immediately 59 * following the note header is n_namesz bytes of name, padded to the 60 * next word boundary. Then comes n_descsz bytes of descriptor, again 61 * padded to a word boundary. The values of n_namesz and n_descsz do 62 * not include the padding. 63 */ 64 type Elf_Note struct { 65 n_namesz uint32 66 n_descsz uint32 67 n_type uint32 68 } 69 70 const ( 71 EI_MAG0 = 0 72 EI_MAG1 = 1 73 EI_MAG2 = 2 74 EI_MAG3 = 3 75 EI_CLASS = 4 76 EI_DATA = 5 77 EI_VERSION = 6 78 EI_OSABI = 7 79 EI_ABIVERSION = 8 80 OLD_EI_BRAND = 8 81 EI_PAD = 9 82 EI_NIDENT = 16 83 ELFMAG0 = 0x7f 84 ELFMAG1 = 'E' 85 ELFMAG2 = 'L' 86 ELFMAG3 = 'F' 87 SELFMAG = 4 88 EV_NONE = 0 89 EV_CURRENT = 1 90 ELFCLASSNONE = 0 91 ELFCLASS32 = 1 92 ELFCLASS64 = 2 93 ELFDATANONE = 0 94 ELFDATA2LSB = 1 95 ELFDATA2MSB = 2 96 ELFOSABI_NONE = 0 97 ELFOSABI_HPUX = 1 98 ELFOSABI_NETBSD = 2 99 ELFOSABI_LINUX = 3 100 ELFOSABI_HURD = 4 101 ELFOSABI_86OPEN = 5 102 ELFOSABI_SOLARIS = 6 103 ELFOSABI_AIX = 7 104 ELFOSABI_IRIX = 8 105 ELFOSABI_FREEBSD = 9 106 ELFOSABI_TRU64 = 10 107 ELFOSABI_MODESTO = 11 108 ELFOSABI_OPENBSD = 12 109 ELFOSABI_OPENVMS = 13 110 ELFOSABI_NSK = 14 111 ELFOSABI_ARM = 97 112 ELFOSABI_STANDALONE = 255 113 ELFOSABI_SYSV = ELFOSABI_NONE 114 ELFOSABI_MONTEREY = ELFOSABI_AIX 115 ET_NONE = 0 116 ET_REL = 1 117 ET_EXEC = 2 118 ET_DYN = 3 119 ET_CORE = 4 120 ET_LOOS = 0xfe00 121 ET_HIOS = 0xfeff 122 ET_LOPROC = 0xff00 123 ET_HIPROC = 0xffff 124 EM_NONE = 0 125 EM_M32 = 1 126 EM_SPARC = 2 127 EM_386 = 3 128 EM_68K = 4 129 EM_88K = 5 130 EM_860 = 7 131 EM_MIPS = 8 132 EM_S370 = 9 133 EM_MIPS_RS3_LE = 10 134 EM_PARISC = 15 135 EM_VPP500 = 17 136 EM_SPARC32PLUS = 18 137 EM_960 = 19 138 EM_PPC = 20 139 EM_PPC64 = 21 140 EM_S390 = 22 141 EM_V800 = 36 142 EM_FR20 = 37 143 EM_RH32 = 38 144 EM_RCE = 39 145 EM_ARM = 40 146 EM_SH = 42 147 EM_SPARCV9 = 43 148 EM_TRICORE = 44 149 EM_ARC = 45 150 EM_H8_300 = 46 151 EM_H8_300H = 47 152 EM_H8S = 48 153 EM_H8_500 = 49 154 EM_IA_64 = 50 155 EM_MIPS_X = 51 156 EM_COLDFIRE = 52 157 EM_68HC12 = 53 158 EM_MMA = 54 159 EM_PCP = 55 160 EM_NCPU = 56 161 EM_NDR1 = 57 162 EM_STARCORE = 58 163 EM_ME16 = 59 164 EM_ST100 = 60 165 EM_TINYJ = 61 166 EM_X86_64 = 62 167 EM_AARCH64 = 183 168 EM_486 = 6 169 EM_MIPS_RS4_BE = 10 170 EM_ALPHA_STD = 41 171 EM_ALPHA = 0x9026 172 SHN_UNDEF = 0 173 SHN_LORESERVE = 0xff00 174 SHN_LOPROC = 0xff00 175 SHN_HIPROC = 0xff1f 176 SHN_LOOS = 0xff20 177 SHN_HIOS = 0xff3f 178 SHN_ABS = 0xfff1 179 SHN_COMMON = 0xfff2 180 SHN_XINDEX = 0xffff 181 SHN_HIRESERVE = 0xffff 182 SHT_NULL = 0 183 SHT_PROGBITS = 1 184 SHT_SYMTAB = 2 185 SHT_STRTAB = 3 186 SHT_RELA = 4 187 SHT_HASH = 5 188 SHT_DYNAMIC = 6 189 SHT_NOTE = 7 190 SHT_NOBITS = 8 191 SHT_REL = 9 192 SHT_SHLIB = 10 193 SHT_DYNSYM = 11 194 SHT_INIT_ARRAY = 14 195 SHT_FINI_ARRAY = 15 196 SHT_PREINIT_ARRAY = 16 197 SHT_GROUP = 17 198 SHT_SYMTAB_SHNDX = 18 199 SHT_LOOS = 0x60000000 200 SHT_HIOS = 0x6fffffff 201 SHT_GNU_VERDEF = 0x6ffffffd 202 SHT_GNU_VERNEED = 0x6ffffffe 203 SHT_GNU_VERSYM = 0x6fffffff 204 SHT_LOPROC = 0x70000000 205 SHT_HIPROC = 0x7fffffff 206 SHT_LOUSER = 0x80000000 207 SHT_HIUSER = 0xffffffff 208 SHF_WRITE = 0x1 209 SHF_ALLOC = 0x2 210 SHF_EXECINSTR = 0x4 211 SHF_MERGE = 0x10 212 SHF_STRINGS = 0x20 213 SHF_INFO_LINK = 0x40 214 SHF_LINK_ORDER = 0x80 215 SHF_OS_NONCONFORMING = 0x100 216 SHF_GROUP = 0x200 217 SHF_TLS = 0x400 218 SHF_MASKOS = 0x0ff00000 219 SHF_MASKPROC = 0xf0000000 220 PT_NULL = 0 221 PT_LOAD = 1 222 PT_DYNAMIC = 2 223 PT_INTERP = 3 224 PT_NOTE = 4 225 PT_SHLIB = 5 226 PT_PHDR = 6 227 PT_TLS = 7 228 PT_LOOS = 0x60000000 229 PT_HIOS = 0x6fffffff 230 PT_LOPROC = 0x70000000 231 PT_HIPROC = 0x7fffffff 232 PT_GNU_STACK = 0x6474e551 233 PT_PAX_FLAGS = 0x65041580 234 PF_X = 0x1 235 PF_W = 0x2 236 PF_R = 0x4 237 PF_MASKOS = 0x0ff00000 238 PF_MASKPROC = 0xf0000000 239 DT_NULL = 0 240 DT_NEEDED = 1 241 DT_PLTRELSZ = 2 242 DT_PLTGOT = 3 243 DT_HASH = 4 244 DT_STRTAB = 5 245 DT_SYMTAB = 6 246 DT_RELA = 7 247 DT_RELASZ = 8 248 DT_RELAENT = 9 249 DT_STRSZ = 10 250 DT_SYMENT = 11 251 DT_INIT = 12 252 DT_FINI = 13 253 DT_SONAME = 14 254 DT_RPATH = 15 255 DT_SYMBOLIC = 16 256 DT_REL = 17 257 DT_RELSZ = 18 258 DT_RELENT = 19 259 DT_PLTREL = 20 260 DT_DEBUG = 21 261 DT_TEXTREL = 22 262 DT_JMPREL = 23 263 DT_BIND_NOW = 24 264 DT_INIT_ARRAY = 25 265 DT_FINI_ARRAY = 26 266 DT_INIT_ARRAYSZ = 27 267 DT_FINI_ARRAYSZ = 28 268 DT_RUNPATH = 29 269 DT_FLAGS = 30 270 DT_ENCODING = 32 271 DT_PREINIT_ARRAY = 32 272 DT_PREINIT_ARRAYSZ = 33 273 DT_LOOS = 0x6000000d 274 DT_HIOS = 0x6ffff000 275 DT_LOPROC = 0x70000000 276 DT_HIPROC = 0x7fffffff 277 DT_VERNEED = 0x6ffffffe 278 DT_VERNEEDNUM = 0x6fffffff 279 DT_VERSYM = 0x6ffffff0 280 DT_PPC64_GLINK = DT_LOPROC + 0 281 DT_PPC64_OPT = DT_LOPROC + 3 282 DF_ORIGIN = 0x0001 283 DF_SYMBOLIC = 0x0002 284 DF_TEXTREL = 0x0004 285 DF_BIND_NOW = 0x0008 286 DF_STATIC_TLS = 0x0010 287 NT_PRSTATUS = 1 288 NT_FPREGSET = 2 289 NT_PRPSINFO = 3 290 STB_LOCAL = 0 291 STB_GLOBAL = 1 292 STB_WEAK = 2 293 STB_LOOS = 10 294 STB_HIOS = 12 295 STB_LOPROC = 13 296 STB_HIPROC = 15 297 STT_NOTYPE = 0 298 STT_OBJECT = 1 299 STT_FUNC = 2 300 STT_SECTION = 3 301 STT_FILE = 4 302 STT_COMMON = 5 303 STT_TLS = 6 304 STT_LOOS = 10 305 STT_HIOS = 12 306 STT_LOPROC = 13 307 STT_HIPROC = 15 308 STV_DEFAULT = 0x0 309 STV_INTERNAL = 0x1 310 STV_HIDDEN = 0x2 311 STV_PROTECTED = 0x3 312 STN_UNDEF = 0 313 ) 314 315 /* For accessing the fields of r_info. */ 316 317 /* For constructing r_info from field values. */ 318 319 /* 320 * Relocation types. 321 */ 322 const ( 323 R_X86_64_NONE = 0 324 R_X86_64_64 = 1 325 R_X86_64_PC32 = 2 326 R_X86_64_GOT32 = 3 327 R_X86_64_PLT32 = 4 328 R_X86_64_COPY = 5 329 R_X86_64_GLOB_DAT = 6 330 R_X86_64_JMP_SLOT = 7 331 R_X86_64_RELATIVE = 8 332 R_X86_64_GOTPCREL = 9 333 R_X86_64_32 = 10 334 R_X86_64_32S = 11 335 R_X86_64_16 = 12 336 R_X86_64_PC16 = 13 337 R_X86_64_8 = 14 338 R_X86_64_PC8 = 15 339 R_X86_64_DTPMOD64 = 16 340 R_X86_64_DTPOFF64 = 17 341 R_X86_64_TPOFF64 = 18 342 R_X86_64_TLSGD = 19 343 R_X86_64_TLSLD = 20 344 R_X86_64_DTPOFF32 = 21 345 R_X86_64_GOTTPOFF = 22 346 R_X86_64_TPOFF32 = 23 347 R_X86_64_COUNT = 24 348 R_AARCH64_ABS64 = 257 349 R_AARCH64_ABS32 = 258 350 R_AARCH64_CALL26 = 283 351 R_AARCH64_ADR_PREL_PG_HI21 = 275 352 R_AARCH64_ADD_ABS_LO12_NC = 277 353 R_ALPHA_NONE = 0 354 R_ALPHA_REFLONG = 1 355 R_ALPHA_REFQUAD = 2 356 R_ALPHA_GPREL32 = 3 357 R_ALPHA_LITERAL = 4 358 R_ALPHA_LITUSE = 5 359 R_ALPHA_GPDISP = 6 360 R_ALPHA_BRADDR = 7 361 R_ALPHA_HINT = 8 362 R_ALPHA_SREL16 = 9 363 R_ALPHA_SREL32 = 10 364 R_ALPHA_SREL64 = 11 365 R_ALPHA_OP_PUSH = 12 366 R_ALPHA_OP_STORE = 13 367 R_ALPHA_OP_PSUB = 14 368 R_ALPHA_OP_PRSHIFT = 15 369 R_ALPHA_GPVALUE = 16 370 R_ALPHA_GPRELHIGH = 17 371 R_ALPHA_GPRELLOW = 18 372 R_ALPHA_IMMED_GP_16 = 19 373 R_ALPHA_IMMED_GP_HI32 = 20 374 R_ALPHA_IMMED_SCN_HI32 = 21 375 R_ALPHA_IMMED_BR_HI32 = 22 376 R_ALPHA_IMMED_LO32 = 23 377 R_ALPHA_COPY = 24 378 R_ALPHA_GLOB_DAT = 25 379 R_ALPHA_JMP_SLOT = 26 380 R_ALPHA_RELATIVE = 27 381 R_ALPHA_COUNT = 28 382 R_ARM_NONE = 0 383 R_ARM_PC24 = 1 384 R_ARM_ABS32 = 2 385 R_ARM_REL32 = 3 386 R_ARM_PC13 = 4 387 R_ARM_ABS16 = 5 388 R_ARM_ABS12 = 6 389 R_ARM_THM_ABS5 = 7 390 R_ARM_ABS8 = 8 391 R_ARM_SBREL32 = 9 392 R_ARM_THM_PC22 = 10 393 R_ARM_THM_PC8 = 11 394 R_ARM_AMP_VCALL9 = 12 395 R_ARM_SWI24 = 13 396 R_ARM_THM_SWI8 = 14 397 R_ARM_XPC25 = 15 398 R_ARM_THM_XPC22 = 16 399 R_ARM_COPY = 20 400 R_ARM_GLOB_DAT = 21 401 R_ARM_JUMP_SLOT = 22 402 R_ARM_RELATIVE = 23 403 R_ARM_GOTOFF = 24 404 R_ARM_GOTPC = 25 405 R_ARM_GOT32 = 26 406 R_ARM_PLT32 = 27 407 R_ARM_CALL = 28 408 R_ARM_JUMP24 = 29 409 R_ARM_V4BX = 40 410 R_ARM_GOT_PREL = 96 411 R_ARM_GNU_VTENTRY = 100 412 R_ARM_GNU_VTINHERIT = 101 413 R_ARM_TLS_IE32 = 107 414 R_ARM_TLS_LE32 = 108 415 R_ARM_RSBREL32 = 250 416 R_ARM_THM_RPC22 = 251 417 R_ARM_RREL32 = 252 418 R_ARM_RABS32 = 253 419 R_ARM_RPC24 = 254 420 R_ARM_RBASE = 255 421 R_ARM_COUNT = 38 422 R_386_NONE = 0 423 R_386_32 = 1 424 R_386_PC32 = 2 425 R_386_GOT32 = 3 426 R_386_PLT32 = 4 427 R_386_COPY = 5 428 R_386_GLOB_DAT = 6 429 R_386_JMP_SLOT = 7 430 R_386_RELATIVE = 8 431 R_386_GOTOFF = 9 432 R_386_GOTPC = 10 433 R_386_TLS_TPOFF = 14 434 R_386_TLS_IE = 15 435 R_386_TLS_GOTIE = 16 436 R_386_TLS_LE = 17 437 R_386_TLS_GD = 18 438 R_386_TLS_LDM = 19 439 R_386_TLS_GD_32 = 24 440 R_386_TLS_GD_PUSH = 25 441 R_386_TLS_GD_CALL = 26 442 R_386_TLS_GD_POP = 27 443 R_386_TLS_LDM_32 = 28 444 R_386_TLS_LDM_PUSH = 29 445 R_386_TLS_LDM_CALL = 30 446 R_386_TLS_LDM_POP = 31 447 R_386_TLS_LDO_32 = 32 448 R_386_TLS_IE_32 = 33 449 R_386_TLS_LE_32 = 34 450 R_386_TLS_DTPMOD32 = 35 451 R_386_TLS_DTPOFF32 = 36 452 R_386_TLS_TPOFF32 = 37 453 R_386_COUNT = 38 454 R_PPC_NONE = 0 455 R_PPC_ADDR32 = 1 456 R_PPC_ADDR24 = 2 457 R_PPC_ADDR16 = 3 458 R_PPC_ADDR16_LO = 4 459 R_PPC_ADDR16_HI = 5 460 R_PPC_ADDR16_HA = 6 461 R_PPC_ADDR14 = 7 462 R_PPC_ADDR14_BRTAKEN = 8 463 R_PPC_ADDR14_BRNTAKEN = 9 464 R_PPC_REL24 = 10 465 R_PPC_REL14 = 11 466 R_PPC_REL14_BRTAKEN = 12 467 R_PPC_REL14_BRNTAKEN = 13 468 R_PPC_GOT16 = 14 469 R_PPC_GOT16_LO = 15 470 R_PPC_GOT16_HI = 16 471 R_PPC_GOT16_HA = 17 472 R_PPC_PLTREL24 = 18 473 R_PPC_COPY = 19 474 R_PPC_GLOB_DAT = 20 475 R_PPC_JMP_SLOT = 21 476 R_PPC_RELATIVE = 22 477 R_PPC_LOCAL24PC = 23 478 R_PPC_UADDR32 = 24 479 R_PPC_UADDR16 = 25 480 R_PPC_REL32 = 26 481 R_PPC_PLT32 = 27 482 R_PPC_PLTREL32 = 28 483 R_PPC_PLT16_LO = 29 484 R_PPC_PLT16_HI = 30 485 R_PPC_PLT16_HA = 31 486 R_PPC_SDAREL16 = 32 487 R_PPC_SECTOFF = 33 488 R_PPC_SECTOFF_LO = 34 489 R_PPC_SECTOFF_HI = 35 490 R_PPC_SECTOFF_HA = 36 491 R_PPC_COUNT = 37 492 R_PPC_TLS = 67 493 R_PPC_DTPMOD32 = 68 494 R_PPC_TPREL16 = 69 495 R_PPC_TPREL16_LO = 70 496 R_PPC_TPREL16_HI = 71 497 R_PPC_TPREL16_HA = 72 498 R_PPC_TPREL32 = 73 499 R_PPC_DTPREL16 = 74 500 R_PPC_DTPREL16_LO = 75 501 R_PPC_DTPREL16_HI = 76 502 R_PPC_DTPREL16_HA = 77 503 R_PPC_DTPREL32 = 78 504 R_PPC_GOT_TLSGD16 = 79 505 R_PPC_GOT_TLSGD16_LO = 80 506 R_PPC_GOT_TLSGD16_HI = 81 507 R_PPC_GOT_TLSGD16_HA = 82 508 R_PPC_GOT_TLSLD16 = 83 509 R_PPC_GOT_TLSLD16_LO = 84 510 R_PPC_GOT_TLSLD16_HI = 85 511 R_PPC_GOT_TLSLD16_HA = 86 512 R_PPC_GOT_TPREL16 = 87 513 R_PPC_GOT_TPREL16_LO = 88 514 R_PPC_GOT_TPREL16_HI = 89 515 R_PPC_GOT_TPREL16_HA = 90 516 R_PPC_EMB_NADDR32 = 101 517 R_PPC_EMB_NADDR16 = 102 518 R_PPC_EMB_NADDR16_LO = 103 519 R_PPC_EMB_NADDR16_HI = 104 520 R_PPC_EMB_NADDR16_HA = 105 521 R_PPC_EMB_SDAI16 = 106 522 R_PPC_EMB_SDA2I16 = 107 523 R_PPC_EMB_SDA2REL = 108 524 R_PPC_EMB_SDA21 = 109 525 R_PPC_EMB_MRKREF = 110 526 R_PPC_EMB_RELSEC16 = 111 527 R_PPC_EMB_RELST_LO = 112 528 R_PPC_EMB_RELST_HI = 113 529 R_PPC_EMB_RELST_HA = 114 530 R_PPC_EMB_BIT_FLD = 115 531 R_PPC_EMB_RELSDA = 116 532 R_PPC_EMB_COUNT = R_PPC_EMB_RELSDA - R_PPC_EMB_NADDR32 + 1 533 R_PPC64_REL24 = R_PPC_REL24 534 R_PPC64_JMP_SLOT = R_PPC_JMP_SLOT 535 R_PPC64_ADDR64 = 38 536 R_PPC64_TOC16 = 47 537 R_PPC64_TOC16_LO = 48 538 R_PPC64_TOC16_HI = 49 539 R_PPC64_TOC16_HA = 50 540 R_PPC64_TOC16_DS = 63 541 R_PPC64_TOC16_LO_DS = 64 542 R_PPC64_REL16_LO = 250 543 R_PPC64_REL16_HI = 251 544 R_PPC64_REL16_HA = 252 545 R_SPARC_NONE = 0 546 R_SPARC_8 = 1 547 R_SPARC_16 = 2 548 R_SPARC_32 = 3 549 R_SPARC_DISP8 = 4 550 R_SPARC_DISP16 = 5 551 R_SPARC_DISP32 = 6 552 R_SPARC_WDISP30 = 7 553 R_SPARC_WDISP22 = 8 554 R_SPARC_HI22 = 9 555 R_SPARC_22 = 10 556 R_SPARC_13 = 11 557 R_SPARC_LO10 = 12 558 R_SPARC_GOT10 = 13 559 R_SPARC_GOT13 = 14 560 R_SPARC_GOT22 = 15 561 R_SPARC_PC10 = 16 562 R_SPARC_PC22 = 17 563 R_SPARC_WPLT30 = 18 564 R_SPARC_COPY = 19 565 R_SPARC_GLOB_DAT = 20 566 R_SPARC_JMP_SLOT = 21 567 R_SPARC_RELATIVE = 22 568 R_SPARC_UA32 = 23 569 R_SPARC_PLT32 = 24 570 R_SPARC_HIPLT22 = 25 571 R_SPARC_LOPLT10 = 26 572 R_SPARC_PCPLT32 = 27 573 R_SPARC_PCPLT22 = 28 574 R_SPARC_PCPLT10 = 29 575 R_SPARC_10 = 30 576 R_SPARC_11 = 31 577 R_SPARC_64 = 32 578 R_SPARC_OLO10 = 33 579 R_SPARC_HH22 = 34 580 R_SPARC_HM10 = 35 581 R_SPARC_LM22 = 36 582 R_SPARC_PC_HH22 = 37 583 R_SPARC_PC_HM10 = 38 584 R_SPARC_PC_LM22 = 39 585 R_SPARC_WDISP16 = 40 586 R_SPARC_WDISP19 = 41 587 R_SPARC_GLOB_JMP = 42 588 R_SPARC_7 = 43 589 R_SPARC_5 = 44 590 R_SPARC_6 = 45 591 R_SPARC_DISP64 = 46 592 R_SPARC_PLT64 = 47 593 R_SPARC_HIX22 = 48 594 R_SPARC_LOX10 = 49 595 R_SPARC_H44 = 50 596 R_SPARC_M44 = 51 597 R_SPARC_L44 = 52 598 R_SPARC_REGISTER = 53 599 R_SPARC_UA64 = 54 600 R_SPARC_UA16 = 55 601 ARM_MAGIC_TRAMP_NUMBER = 0x5c000003 602 ) 603 604 /* 605 * Symbol table entries. 606 */ 607 608 /* For accessing the fields of st_info. */ 609 610 /* For constructing st_info from field values. */ 611 612 /* For accessing the fields of st_other. */ 613 614 /* 615 * ELF header. 616 */ 617 type ElfEhdr struct { 618 ident [EI_NIDENT]uint8 619 type_ uint16 620 machine uint16 621 version uint32 622 entry uint64 623 phoff uint64 624 shoff uint64 625 flags uint32 626 ehsize uint16 627 phentsize uint16 628 phnum uint16 629 shentsize uint16 630 shnum uint16 631 shstrndx uint16 632 } 633 634 /* 635 * Section header. 636 */ 637 type ElfShdr struct { 638 name uint32 639 type_ uint32 640 flags uint64 641 addr uint64 642 off uint64 643 size uint64 644 link uint32 645 info uint32 646 addralign uint64 647 entsize uint64 648 shnum int 649 secsym *LSym 650 } 651 652 /* 653 * Program header. 654 */ 655 type ElfPhdr struct { 656 type_ uint32 657 flags uint32 658 off uint64 659 vaddr uint64 660 paddr uint64 661 filesz uint64 662 memsz uint64 663 align uint64 664 } 665 666 /* For accessing the fields of r_info. */ 667 668 /* For constructing r_info from field values. */ 669 670 /* 671 * Symbol table entries. 672 */ 673 674 /* For accessing the fields of st_info. */ 675 676 /* For constructing st_info from field values. */ 677 678 /* For accessing the fields of st_other. */ 679 680 /* 681 * Go linker interface 682 */ 683 const ( 684 ELF64HDRSIZE = 64 685 ELF64PHDRSIZE = 56 686 ELF64SHDRSIZE = 64 687 ELF64RELSIZE = 16 688 ELF64RELASIZE = 24 689 ELF64SYMSIZE = 24 690 ELF32HDRSIZE = 52 691 ELF32PHDRSIZE = 32 692 ELF32SHDRSIZE = 40 693 ELF32SYMSIZE = 16 694 ELF32RELSIZE = 8 695 ) 696 697 /* 698 * The interface uses the 64-bit structures always, 699 * to avoid code duplication. The writers know how to 700 * marshal a 32-bit representation from the 64-bit structure. 701 */ 702 703 var Elfstrdat []byte 704 705 /* 706 * Total amount of space to reserve at the start of the file 707 * for Header, PHeaders, SHeaders, and interp. 708 * May waste some. 709 * On FreeBSD, cannot be larger than a page. 710 */ 711 const ( 712 ELFRESERVE = 3072 713 ) 714 715 /* 716 * We use the 64-bit data structures on both 32- and 64-bit machines 717 * in order to write the code just once. The 64-bit data structure is 718 * written in the 32-bit format on the 32-bit machines. 719 */ 720 const ( 721 NSECT = 48 722 ) 723 724 var Iself bool 725 726 var Nelfsym int = 1 727 728 var elf64 bool 729 730 var ehdr ElfEhdr 731 732 var phdr [NSECT]*ElfPhdr 733 734 var shdr [NSECT]*ElfShdr 735 736 var interp string 737 738 type Elfstring struct { 739 s string 740 off int 741 } 742 743 var elfstr [100]Elfstring 744 745 var nelfstr int 746 747 var buildinfo []byte 748 749 /* 750 Initialize the global variable that describes the ELF header. It will be updated as 751 we write section and prog headers. 752 */ 753 func Elfinit() { 754 Iself = true 755 756 switch Thearch.Thechar { 757 // 64-bit architectures 758 case '9': 759 if Ctxt.Arch.ByteOrder == binary.BigEndian { 760 ehdr.flags = 1 /* Version 1 ABI */ 761 } else { 762 ehdr.flags = 2 /* Version 2 ABI */ 763 } 764 fallthrough 765 766 case '6', '7': 767 elf64 = true 768 769 ehdr.phoff = ELF64HDRSIZE /* Must be be ELF64HDRSIZE: first PHdr must follow ELF header */ 770 ehdr.shoff = ELF64HDRSIZE /* Will move as we add PHeaders */ 771 ehdr.ehsize = ELF64HDRSIZE /* Must be ELF64HDRSIZE */ 772 ehdr.phentsize = ELF64PHDRSIZE /* Must be ELF64PHDRSIZE */ 773 ehdr.shentsize = ELF64SHDRSIZE /* Must be ELF64SHDRSIZE */ 774 775 // we use EABI on both linux/arm and freebsd/arm. 776 // 32-bit architectures 777 case '5': 778 // we use EABI on both linux/arm and freebsd/arm. 779 if HEADTYPE == Hlinux || HEADTYPE == Hfreebsd { 780 ehdr.flags = 0x5000002 // has entry point, Version5 EABI 781 } 782 fallthrough 783 784 // fallthrough 785 default: 786 ehdr.phoff = ELF32HDRSIZE 787 /* Must be be ELF32HDRSIZE: first PHdr must follow ELF header */ 788 ehdr.shoff = ELF32HDRSIZE /* Will move as we add PHeaders */ 789 ehdr.ehsize = ELF32HDRSIZE /* Must be ELF32HDRSIZE */ 790 ehdr.phentsize = ELF32PHDRSIZE /* Must be ELF32PHDRSIZE */ 791 ehdr.shentsize = ELF32SHDRSIZE /* Must be ELF32SHDRSIZE */ 792 } 793 } 794 795 func elf64phdr(e *ElfPhdr) { 796 Thearch.Lput(e.type_) 797 Thearch.Lput(e.flags) 798 Thearch.Vput(e.off) 799 Thearch.Vput(e.vaddr) 800 Thearch.Vput(e.paddr) 801 Thearch.Vput(e.filesz) 802 Thearch.Vput(e.memsz) 803 Thearch.Vput(e.align) 804 } 805 806 func elf32phdr(e *ElfPhdr) { 807 if e.type_ == PT_LOAD { 808 // Correct ELF loaders will do this implicitly, 809 // but buggy ELF loaders like the one in some 810 // versions of QEMU won't. 811 frag := int(e.vaddr & (e.align - 1)) 812 813 e.off -= uint64(frag) 814 e.vaddr -= uint64(frag) 815 e.paddr -= uint64(frag) 816 e.filesz += uint64(frag) 817 e.memsz += uint64(frag) 818 } 819 820 Thearch.Lput(e.type_) 821 Thearch.Lput(uint32(e.off)) 822 Thearch.Lput(uint32(e.vaddr)) 823 Thearch.Lput(uint32(e.paddr)) 824 Thearch.Lput(uint32(e.filesz)) 825 Thearch.Lput(uint32(e.memsz)) 826 Thearch.Lput(e.flags) 827 Thearch.Lput(uint32(e.align)) 828 } 829 830 func elf64shdr(e *ElfShdr) { 831 Thearch.Lput(e.name) 832 Thearch.Lput(e.type_) 833 Thearch.Vput(e.flags) 834 Thearch.Vput(e.addr) 835 Thearch.Vput(e.off) 836 Thearch.Vput(e.size) 837 Thearch.Lput(e.link) 838 Thearch.Lput(e.info) 839 Thearch.Vput(e.addralign) 840 Thearch.Vput(e.entsize) 841 } 842 843 func elf32shdr(e *ElfShdr) { 844 Thearch.Lput(e.name) 845 Thearch.Lput(e.type_) 846 Thearch.Lput(uint32(e.flags)) 847 Thearch.Lput(uint32(e.addr)) 848 Thearch.Lput(uint32(e.off)) 849 Thearch.Lput(uint32(e.size)) 850 Thearch.Lput(e.link) 851 Thearch.Lput(e.info) 852 Thearch.Lput(uint32(e.addralign)) 853 Thearch.Lput(uint32(e.entsize)) 854 } 855 856 func elfwriteshdrs() uint32 { 857 if elf64 { 858 for i := 0; i < int(ehdr.shnum); i++ { 859 elf64shdr(shdr[i]) 860 } 861 return uint32(ehdr.shnum) * ELF64SHDRSIZE 862 } 863 864 for i := 0; i < int(ehdr.shnum); i++ { 865 elf32shdr(shdr[i]) 866 } 867 return uint32(ehdr.shnum) * ELF32SHDRSIZE 868 } 869 870 func elfsetstring(s string, off int) { 871 if nelfstr >= len(elfstr) { 872 Diag("too many elf strings") 873 Errorexit() 874 } 875 876 elfstr[nelfstr].s = s 877 elfstr[nelfstr].off = off 878 nelfstr++ 879 } 880 881 func elfwritephdrs() uint32 { 882 if elf64 { 883 for i := 0; i < int(ehdr.phnum); i++ { 884 elf64phdr(phdr[i]) 885 } 886 return uint32(ehdr.phnum) * ELF64PHDRSIZE 887 } 888 889 for i := 0; i < int(ehdr.phnum); i++ { 890 elf32phdr(phdr[i]) 891 } 892 return uint32(ehdr.phnum) * ELF32PHDRSIZE 893 } 894 895 func newElfPhdr() *ElfPhdr { 896 e := new(ElfPhdr) 897 if ehdr.phnum >= NSECT { 898 Diag("too many phdrs") 899 } else { 900 phdr[ehdr.phnum] = e 901 ehdr.phnum++ 902 } 903 if elf64 { 904 ehdr.shoff += ELF64PHDRSIZE 905 } else { 906 ehdr.shoff += ELF32PHDRSIZE 907 } 908 return e 909 } 910 911 func newElfShdr(name int64) *ElfShdr { 912 e := new(ElfShdr) 913 e.name = uint32(name) 914 e.shnum = int(ehdr.shnum) 915 if ehdr.shnum >= NSECT { 916 Diag("too many shdrs") 917 } else { 918 shdr[ehdr.shnum] = e 919 ehdr.shnum++ 920 } 921 922 return e 923 } 924 925 func getElfEhdr() *ElfEhdr { 926 return &ehdr 927 } 928 929 func elf64writehdr() uint32 { 930 for i := 0; i < EI_NIDENT; i++ { 931 Cput(ehdr.ident[i]) 932 } 933 Thearch.Wput(ehdr.type_) 934 Thearch.Wput(ehdr.machine) 935 Thearch.Lput(ehdr.version) 936 Thearch.Vput(ehdr.entry) 937 Thearch.Vput(ehdr.phoff) 938 Thearch.Vput(ehdr.shoff) 939 Thearch.Lput(ehdr.flags) 940 Thearch.Wput(ehdr.ehsize) 941 Thearch.Wput(ehdr.phentsize) 942 Thearch.Wput(ehdr.phnum) 943 Thearch.Wput(ehdr.shentsize) 944 Thearch.Wput(ehdr.shnum) 945 Thearch.Wput(ehdr.shstrndx) 946 return ELF64HDRSIZE 947 } 948 949 func elf32writehdr() uint32 { 950 for i := 0; i < EI_NIDENT; i++ { 951 Cput(ehdr.ident[i]) 952 } 953 Thearch.Wput(ehdr.type_) 954 Thearch.Wput(ehdr.machine) 955 Thearch.Lput(ehdr.version) 956 Thearch.Lput(uint32(ehdr.entry)) 957 Thearch.Lput(uint32(ehdr.phoff)) 958 Thearch.Lput(uint32(ehdr.shoff)) 959 Thearch.Lput(ehdr.flags) 960 Thearch.Wput(ehdr.ehsize) 961 Thearch.Wput(ehdr.phentsize) 962 Thearch.Wput(ehdr.phnum) 963 Thearch.Wput(ehdr.shentsize) 964 Thearch.Wput(ehdr.shnum) 965 Thearch.Wput(ehdr.shstrndx) 966 return ELF32HDRSIZE 967 } 968 969 func elfwritehdr() uint32 { 970 if elf64 { 971 return elf64writehdr() 972 } 973 return elf32writehdr() 974 } 975 976 /* Taken directly from the definition document for ELF64 */ 977 func elfhash(name []byte) uint32 { 978 var h uint32 = 0 979 var g uint32 980 for len(name) != 0 { 981 h = (h << 4) + uint32(name[0]) 982 name = name[1:] 983 g = h & 0xf0000000 984 if g != 0 { 985 h ^= g >> 24 986 } 987 h &= 0x0fffffff 988 } 989 990 return h 991 } 992 993 func Elfwritedynent(s *LSym, tag int, val uint64) { 994 if elf64 { 995 Adduint64(Ctxt, s, uint64(tag)) 996 Adduint64(Ctxt, s, val) 997 } else { 998 Adduint32(Ctxt, s, uint32(tag)) 999 Adduint32(Ctxt, s, uint32(val)) 1000 } 1001 } 1002 1003 func elfwritedynentsym(s *LSym, tag int, t *LSym) { 1004 Elfwritedynentsymplus(s, tag, t, 0) 1005 } 1006 1007 func Elfwritedynentsymplus(s *LSym, tag int, t *LSym, add int64) { 1008 if elf64 { 1009 Adduint64(Ctxt, s, uint64(tag)) 1010 } else { 1011 Adduint32(Ctxt, s, uint32(tag)) 1012 } 1013 Addaddrplus(Ctxt, s, t, add) 1014 } 1015 1016 func elfwritedynentsymsize(s *LSym, tag int, t *LSym) { 1017 if elf64 { 1018 Adduint64(Ctxt, s, uint64(tag)) 1019 } else { 1020 Adduint32(Ctxt, s, uint32(tag)) 1021 } 1022 addsize(Ctxt, s, t) 1023 } 1024 1025 func elfinterp(sh *ElfShdr, startva uint64, resoff uint64, p string) int { 1026 interp = p 1027 n := len(interp) + 1 1028 sh.addr = startva + resoff - uint64(n) 1029 sh.off = resoff - uint64(n) 1030 sh.size = uint64(n) 1031 1032 return n 1033 } 1034 1035 func elfwriteinterp() int { 1036 sh := elfshname(".interp") 1037 Cseek(int64(sh.off)) 1038 coutbuf.w.WriteString(interp) 1039 Cput(0) 1040 return int(sh.size) 1041 } 1042 1043 func elfnote(sh *ElfShdr, startva uint64, resoff uint64, sz int) int { 1044 n := 3*4 + uint64(sz) + resoff%4 1045 1046 sh.type_ = SHT_NOTE 1047 sh.flags = SHF_ALLOC 1048 sh.addralign = 4 1049 sh.addr = startva + resoff - n 1050 sh.off = resoff - n 1051 sh.size = n - resoff%4 1052 1053 return int(n) 1054 } 1055 1056 func elfwritenotehdr(str string, namesz uint32, descsz uint32, tag uint32) *ElfShdr { 1057 sh := elfshname(str) 1058 1059 // Write Elf_Note header. 1060 Cseek(int64(sh.off)) 1061 1062 Thearch.Lput(namesz) 1063 Thearch.Lput(descsz) 1064 Thearch.Lput(tag) 1065 1066 return sh 1067 } 1068 1069 // NetBSD Signature (as per sys/exec_elf.h) 1070 const ( 1071 ELF_NOTE_NETBSD_NAMESZ = 7 1072 ELF_NOTE_NETBSD_DESCSZ = 4 1073 ELF_NOTE_NETBSD_TAG = 1 1074 ELF_NOTE_NETBSD_VERSION = 599000000 /* NetBSD 5.99 */ 1075 ) 1076 1077 var ELF_NOTE_NETBSD_NAME = []byte("NetBSD\x00") 1078 1079 func elfnetbsdsig(sh *ElfShdr, startva uint64, resoff uint64) int { 1080 n := int(Rnd(ELF_NOTE_NETBSD_NAMESZ, 4) + Rnd(ELF_NOTE_NETBSD_DESCSZ, 4)) 1081 return elfnote(sh, startva, resoff, n) 1082 } 1083 1084 func elfwritenetbsdsig() int { 1085 // Write Elf_Note header. 1086 sh := elfwritenotehdr(".note.netbsd.ident", ELF_NOTE_NETBSD_NAMESZ, ELF_NOTE_NETBSD_DESCSZ, ELF_NOTE_NETBSD_TAG) 1087 1088 if sh == nil { 1089 return 0 1090 } 1091 1092 // Followed by NetBSD string and version. 1093 Cwrite(ELF_NOTE_NETBSD_NAME) 1094 Cput(0) 1095 1096 Thearch.Lput(ELF_NOTE_NETBSD_VERSION) 1097 1098 return int(sh.size) 1099 } 1100 1101 // OpenBSD Signature 1102 const ( 1103 ELF_NOTE_OPENBSD_NAMESZ = 8 1104 ELF_NOTE_OPENBSD_DESCSZ = 4 1105 ELF_NOTE_OPENBSD_TAG = 1 1106 ELF_NOTE_OPENBSD_VERSION = 0 1107 ) 1108 1109 var ELF_NOTE_OPENBSD_NAME = []byte("OpenBSD\x00") 1110 1111 func elfopenbsdsig(sh *ElfShdr, startva uint64, resoff uint64) int { 1112 n := ELF_NOTE_OPENBSD_NAMESZ + ELF_NOTE_OPENBSD_DESCSZ 1113 return elfnote(sh, startva, resoff, n) 1114 } 1115 1116 func elfwriteopenbsdsig() int { 1117 // Write Elf_Note header. 1118 sh := elfwritenotehdr(".note.openbsd.ident", ELF_NOTE_OPENBSD_NAMESZ, ELF_NOTE_OPENBSD_DESCSZ, ELF_NOTE_OPENBSD_TAG) 1119 1120 if sh == nil { 1121 return 0 1122 } 1123 1124 // Followed by OpenBSD string and version. 1125 Cwrite(ELF_NOTE_OPENBSD_NAME) 1126 1127 Thearch.Lput(ELF_NOTE_OPENBSD_VERSION) 1128 1129 return int(sh.size) 1130 } 1131 1132 func addbuildinfo(val string) { 1133 var j int 1134 1135 if val[0] != '0' || val[1] != 'x' { 1136 fmt.Fprintf(os.Stderr, "%s: -B argument must start with 0x: %s\n", os.Args[0], val) 1137 Exit(2) 1138 } 1139 1140 ov := val 1141 val = val[2:] 1142 i := 0 1143 var b int 1144 for val != "" { 1145 if len(val) == 1 { 1146 fmt.Fprintf(os.Stderr, "%s: -B argument must have even number of digits: %s\n", os.Args[0], ov) 1147 Exit(2) 1148 } 1149 1150 b = 0 1151 for j = 0; j < 2; j, val = j+1, val[1:] { 1152 b *= 16 1153 if val[0] >= '0' && val[0] <= '9' { 1154 b += int(val[0]) - '0' 1155 } else if val[0] >= 'a' && val[0] <= 'f' { 1156 b += int(val[0]) - 'a' + 10 1157 } else if val[0] >= 'A' && val[0] <= 'F' { 1158 b += int(val[0]) - 'A' + 10 1159 } else { 1160 fmt.Fprintf(os.Stderr, "%s: -B argument contains invalid hex digit %c: %s\n", os.Args[0], val[0], ov) 1161 Exit(2) 1162 } 1163 } 1164 1165 const maxLen = 32 1166 if i >= maxLen { 1167 fmt.Fprintf(os.Stderr, "%s: -B option too long (max %d digits): %s\n", os.Args[0], maxLen, ov) 1168 Exit(2) 1169 } 1170 1171 buildinfo = append(buildinfo, uint8(b)) 1172 i++ 1173 } 1174 1175 buildinfo = buildinfo[:i] 1176 } 1177 1178 // Build info note 1179 const ( 1180 ELF_NOTE_BUILDINFO_NAMESZ = 4 1181 ELF_NOTE_BUILDINFO_TAG = 3 1182 ) 1183 1184 var ELF_NOTE_BUILDINFO_NAME = []byte("GNU\x00") 1185 1186 func elfbuildinfo(sh *ElfShdr, startva uint64, resoff uint64) int { 1187 n := int(ELF_NOTE_BUILDINFO_NAMESZ + Rnd(int64(len(buildinfo)), 4)) 1188 return elfnote(sh, startva, resoff, n) 1189 } 1190 1191 func elfwritebuildinfo() int { 1192 sh := elfwritenotehdr(".note.gnu.build-id", ELF_NOTE_BUILDINFO_NAMESZ, uint32(len(buildinfo)), ELF_NOTE_BUILDINFO_TAG) 1193 if sh == nil { 1194 return 0 1195 } 1196 1197 Cwrite(ELF_NOTE_BUILDINFO_NAME) 1198 Cwrite(buildinfo) 1199 var zero = make([]byte, 4) 1200 Cwrite(zero[:int(Rnd(int64(len(buildinfo)), 4)-int64(len(buildinfo)))]) 1201 1202 return int(sh.size) 1203 } 1204 1205 var elfverneed int 1206 1207 type Elfaux struct { 1208 next *Elfaux 1209 num int 1210 vers string 1211 } 1212 1213 type Elflib struct { 1214 next *Elflib 1215 aux *Elfaux 1216 file string 1217 } 1218 1219 func addelflib(list **Elflib, file string, vers string) *Elfaux { 1220 var lib *Elflib 1221 1222 for lib = *list; lib != nil; lib = lib.next { 1223 if lib.file == file { 1224 goto havelib 1225 } 1226 } 1227 lib = new(Elflib) 1228 lib.next = *list 1229 lib.file = file 1230 *list = lib 1231 1232 havelib: 1233 for aux := lib.aux; aux != nil; aux = aux.next { 1234 if aux.vers == vers { 1235 return aux 1236 } 1237 } 1238 aux := new(Elfaux) 1239 aux.next = lib.aux 1240 aux.vers = vers 1241 lib.aux = aux 1242 1243 return aux 1244 } 1245 1246 func elfdynhash() { 1247 if !Iself { 1248 return 1249 } 1250 1251 nsym := Nelfsym 1252 s := Linklookup(Ctxt, ".hash", 0) 1253 s.Type = SELFROSECT 1254 s.Reachable = true 1255 1256 i := nsym 1257 nbucket := 1 1258 for i > 0 { 1259 nbucket++ 1260 i >>= 1 1261 } 1262 1263 var needlib *Elflib 1264 need := make([]*Elfaux, nsym) 1265 chain := make([]uint32, nsym) 1266 buckets := make([]uint32, nbucket) 1267 if need == nil || chain == nil || buckets == nil { 1268 Ctxt.Cursym = nil 1269 Diag("out of memory") 1270 Errorexit() 1271 } 1272 1273 for i := 0; i < nsym; i++ { 1274 need[i] = nil 1275 } 1276 for i := 0; i < nsym; i++ { 1277 chain[i] = 0 1278 } 1279 for i := 0; i < nbucket; i++ { 1280 buckets[i] = 0 1281 } 1282 var b int 1283 var hc uint32 1284 var name string 1285 for sy := Ctxt.Allsym; sy != nil; sy = sy.Allsym { 1286 if sy.Dynid <= 0 { 1287 continue 1288 } 1289 1290 if sy.Dynimpvers != "" { 1291 need[sy.Dynid] = addelflib(&needlib, sy.Dynimplib, sy.Dynimpvers) 1292 } 1293 1294 name = sy.Extname 1295 hc = elfhash([]byte(name)) 1296 1297 b = int(hc % uint32(nbucket)) 1298 chain[sy.Dynid] = buckets[b] 1299 buckets[b] = uint32(sy.Dynid) 1300 } 1301 1302 Adduint32(Ctxt, s, uint32(nbucket)) 1303 Adduint32(Ctxt, s, uint32(nsym)) 1304 for i := 0; i < nbucket; i++ { 1305 Adduint32(Ctxt, s, buckets[i]) 1306 } 1307 for i := 0; i < nsym; i++ { 1308 Adduint32(Ctxt, s, chain[i]) 1309 } 1310 1311 // version symbols 1312 dynstr := Linklookup(Ctxt, ".dynstr", 0) 1313 1314 s = Linklookup(Ctxt, ".gnu.version_r", 0) 1315 i = 2 1316 nfile := 0 1317 var j int 1318 var x *Elfaux 1319 for l := needlib; l != nil; l = l.next { 1320 nfile++ 1321 1322 // header 1323 Adduint16(Ctxt, s, 1) // table version 1324 j = 0 1325 for x = l.aux; x != nil; x = x.next { 1326 j++ 1327 } 1328 Adduint16(Ctxt, s, uint16(j)) // aux count 1329 Adduint32(Ctxt, s, uint32(Addstring(dynstr, l.file))) // file string offset 1330 Adduint32(Ctxt, s, 16) // offset from header to first aux 1331 if l.next != nil { 1332 Adduint32(Ctxt, s, 16+uint32(j)*16) // offset from this header to next 1333 } else { 1334 Adduint32(Ctxt, s, 0) 1335 } 1336 1337 for x = l.aux; x != nil; x = x.next { 1338 x.num = i 1339 i++ 1340 1341 // aux struct 1342 Adduint32(Ctxt, s, elfhash([]byte(x.vers))) // hash 1343 Adduint16(Ctxt, s, 0) // flags 1344 Adduint16(Ctxt, s, uint16(x.num)) // other - index we refer to this by 1345 Adduint32(Ctxt, s, uint32(Addstring(dynstr, x.vers))) // version string offset 1346 if x.next != nil { 1347 Adduint32(Ctxt, s, 16) // offset from this aux to next 1348 } else { 1349 Adduint32(Ctxt, s, 0) 1350 } 1351 } 1352 } 1353 1354 // version references 1355 s = Linklookup(Ctxt, ".gnu.version", 0) 1356 1357 for i := 0; i < nsym; i++ { 1358 if i == 0 { 1359 Adduint16(Ctxt, s, 0) // first entry - no symbol 1360 } else if need[i] == nil { 1361 Adduint16(Ctxt, s, 1) // global 1362 } else { 1363 Adduint16(Ctxt, s, uint16(need[i].num)) 1364 } 1365 } 1366 1367 s = Linklookup(Ctxt, ".dynamic", 0) 1368 elfverneed = nfile 1369 if elfverneed != 0 { 1370 elfwritedynentsym(s, DT_VERNEED, Linklookup(Ctxt, ".gnu.version_r", 0)) 1371 Elfwritedynent(s, DT_VERNEEDNUM, uint64(nfile)) 1372 elfwritedynentsym(s, DT_VERSYM, Linklookup(Ctxt, ".gnu.version", 0)) 1373 } 1374 1375 switch Thearch.Thechar { 1376 case '6', '7', '9': 1377 sy := Linklookup(Ctxt, ".rela.plt", 0) 1378 if sy.Size > 0 { 1379 Elfwritedynent(s, DT_PLTREL, DT_RELA) 1380 elfwritedynentsymsize(s, DT_PLTRELSZ, sy) 1381 elfwritedynentsym(s, DT_JMPREL, sy) 1382 } 1383 default: 1384 sy := Linklookup(Ctxt, ".rel.plt", 0) 1385 if sy.Size > 0 { 1386 Elfwritedynent(s, DT_PLTREL, DT_REL) 1387 elfwritedynentsymsize(s, DT_PLTRELSZ, sy) 1388 elfwritedynentsym(s, DT_JMPREL, sy) 1389 } 1390 } 1391 1392 Elfwritedynent(s, DT_NULL, 0) 1393 } 1394 1395 func elfphload(seg *Segment) *ElfPhdr { 1396 ph := newElfPhdr() 1397 ph.type_ = PT_LOAD 1398 if seg.Rwx&4 != 0 { 1399 ph.flags |= PF_R 1400 } 1401 if seg.Rwx&2 != 0 { 1402 ph.flags |= PF_W 1403 } 1404 if seg.Rwx&1 != 0 { 1405 ph.flags |= PF_X 1406 } 1407 ph.vaddr = seg.Vaddr 1408 ph.paddr = seg.Vaddr 1409 ph.memsz = seg.Length 1410 ph.off = seg.Fileoff 1411 ph.filesz = seg.Filelen 1412 ph.align = uint64(INITRND) 1413 1414 return ph 1415 } 1416 1417 func elfshname(name string) *ElfShdr { 1418 var off int 1419 var sh *ElfShdr 1420 1421 for i := 0; i < nelfstr; i++ { 1422 if name == elfstr[i].s { 1423 off = elfstr[i].off 1424 for i = 0; i < int(ehdr.shnum); i++ { 1425 sh = shdr[i] 1426 if sh.name == uint32(off) { 1427 return sh 1428 } 1429 } 1430 1431 sh = newElfShdr(int64(off)) 1432 return sh 1433 } 1434 } 1435 1436 Diag("cannot find elf name %s", name) 1437 Errorexit() 1438 return nil 1439 } 1440 1441 func elfshalloc(sect *Section) *ElfShdr { 1442 sh := elfshname(sect.Name) 1443 sect.Elfsect = sh 1444 return sh 1445 } 1446 1447 func elfshbits(sect *Section) *ElfShdr { 1448 sh := elfshalloc(sect) 1449 if sh.type_ > 0 { 1450 return sh 1451 } 1452 1453 if sect.Vaddr < sect.Seg.Vaddr+sect.Seg.Filelen { 1454 sh.type_ = SHT_PROGBITS 1455 } else { 1456 sh.type_ = SHT_NOBITS 1457 } 1458 sh.flags = SHF_ALLOC 1459 if sect.Rwx&1 != 0 { 1460 sh.flags |= SHF_EXECINSTR 1461 } 1462 if sect.Rwx&2 != 0 { 1463 sh.flags |= SHF_WRITE 1464 } 1465 if sect.Name == ".tbss" { 1466 if goos != "android" { 1467 sh.flags |= SHF_TLS // no TLS on android 1468 } 1469 sh.type_ = SHT_NOBITS 1470 } 1471 1472 if Linkmode != LinkExternal { 1473 sh.addr = sect.Vaddr 1474 } 1475 sh.addralign = uint64(sect.Align) 1476 sh.size = sect.Length 1477 sh.off = sect.Seg.Fileoff + sect.Vaddr - sect.Seg.Vaddr 1478 1479 return sh 1480 } 1481 1482 func elfshreloc(sect *Section) *ElfShdr { 1483 // If main section is SHT_NOBITS, nothing to relocate. 1484 // Also nothing to relocate in .shstrtab. 1485 if sect.Vaddr >= sect.Seg.Vaddr+sect.Seg.Filelen { 1486 return nil 1487 } 1488 if sect.Name == ".shstrtab" || sect.Name == ".tbss" { 1489 return nil 1490 } 1491 1492 var prefix string 1493 var typ int 1494 switch Thearch.Thechar { 1495 case '6', '7', '9': 1496 prefix = ".rela" 1497 typ = SHT_RELA 1498 default: 1499 prefix = ".rel" 1500 typ = SHT_REL 1501 } 1502 1503 buf := fmt.Sprintf("%s%s", prefix, sect.Name) 1504 sh := elfshname(buf) 1505 sh.type_ = uint32(typ) 1506 sh.entsize = uint64(Thearch.Regsize) * 2 1507 if typ == SHT_RELA { 1508 sh.entsize += uint64(Thearch.Regsize) 1509 } 1510 sh.link = uint32(elfshname(".symtab").shnum) 1511 sh.info = uint32((sect.Elfsect.(*ElfShdr)).shnum) 1512 sh.off = sect.Reloff 1513 sh.size = sect.Rellen 1514 sh.addralign = uint64(Thearch.Regsize) 1515 return sh 1516 } 1517 1518 func elfrelocsect(sect *Section, first *LSym) { 1519 // If main section is SHT_NOBITS, nothing to relocate. 1520 // Also nothing to relocate in .shstrtab. 1521 if sect.Vaddr >= sect.Seg.Vaddr+sect.Seg.Filelen { 1522 return 1523 } 1524 if sect.Name == ".shstrtab" { 1525 return 1526 } 1527 1528 sect.Reloff = uint64(Cpos()) 1529 var sym *LSym 1530 for sym = first; sym != nil; sym = sym.Next { 1531 if !sym.Reachable { 1532 continue 1533 } 1534 if uint64(sym.Value) >= sect.Vaddr { 1535 break 1536 } 1537 } 1538 1539 eaddr := int32(sect.Vaddr + sect.Length) 1540 var r *Reloc 1541 var ri int 1542 for ; sym != nil; sym = sym.Next { 1543 if !sym.Reachable { 1544 continue 1545 } 1546 if sym.Value >= int64(eaddr) { 1547 break 1548 } 1549 Ctxt.Cursym = sym 1550 1551 for ri = 0; ri < len(sym.R); ri++ { 1552 r = &sym.R[ri] 1553 if r.Done != 0 { 1554 continue 1555 } 1556 if r.Xsym == nil { 1557 Diag("missing xsym in relocation") 1558 continue 1559 } 1560 1561 if r.Xsym.Elfsym == 0 { 1562 Diag("reloc %d to non-elf symbol %s (outer=%s) %d", r.Type, r.Sym.Name, r.Xsym.Name, r.Sym.Type) 1563 } 1564 if Thearch.Elfreloc1(r, int64(uint64(sym.Value+int64(r.Off))-sect.Vaddr)) < 0 { 1565 Diag("unsupported obj reloc %d/%d to %s", r.Type, r.Siz, r.Sym.Name) 1566 } 1567 } 1568 } 1569 1570 sect.Rellen = uint64(Cpos()) - sect.Reloff 1571 } 1572 1573 func Elfemitreloc() { 1574 for Cpos()&7 != 0 { 1575 Cput(0) 1576 } 1577 1578 elfrelocsect(Segtext.Sect, Ctxt.Textp) 1579 for sect := Segtext.Sect.Next; sect != nil; sect = sect.Next { 1580 elfrelocsect(sect, datap) 1581 } 1582 for sect := Segrodata.Sect; sect != nil; sect = sect.Next { 1583 elfrelocsect(sect, datap) 1584 } 1585 for sect := Segdata.Sect; sect != nil; sect = sect.Next { 1586 elfrelocsect(sect, datap) 1587 } 1588 } 1589 1590 func doelf() { 1591 if !Iself { 1592 return 1593 } 1594 1595 /* predefine strings we need for section headers */ 1596 shstrtab := Linklookup(Ctxt, ".shstrtab", 0) 1597 1598 shstrtab.Type = SELFROSECT 1599 shstrtab.Reachable = true 1600 1601 Addstring(shstrtab, "") 1602 Addstring(shstrtab, ".text") 1603 Addstring(shstrtab, ".noptrdata") 1604 Addstring(shstrtab, ".data") 1605 Addstring(shstrtab, ".bss") 1606 Addstring(shstrtab, ".noptrbss") 1607 1608 // generate .tbss section (except for OpenBSD where it's not supported) 1609 // for dynamic internal linker or external linking, so that various 1610 // binutils could correctly calculate PT_TLS size. 1611 // see http://golang.org/issue/5200. 1612 if HEADTYPE != Hopenbsd { 1613 if Debug['d'] == 0 || Linkmode == LinkExternal { 1614 Addstring(shstrtab, ".tbss") 1615 } 1616 } 1617 if HEADTYPE == Hnetbsd { 1618 Addstring(shstrtab, ".note.netbsd.ident") 1619 } 1620 if HEADTYPE == Hopenbsd { 1621 Addstring(shstrtab, ".note.openbsd.ident") 1622 } 1623 if len(buildinfo) > 0 { 1624 Addstring(shstrtab, ".note.gnu.build-id") 1625 } 1626 Addstring(shstrtab, ".elfdata") 1627 Addstring(shstrtab, ".rodata") 1628 Addstring(shstrtab, ".typelink") 1629 Addstring(shstrtab, ".gosymtab") 1630 Addstring(shstrtab, ".gopclntab") 1631 1632 if Linkmode == LinkExternal { 1633 debug_s = Debug['s'] 1634 Debug['s'] = 0 1635 Debug['d'] = 1 1636 1637 switch Thearch.Thechar { 1638 case '6', '7', '9': 1639 Addstring(shstrtab, ".rela.text") 1640 Addstring(shstrtab, ".rela.rodata") 1641 Addstring(shstrtab, ".rela.typelink") 1642 Addstring(shstrtab, ".rela.gosymtab") 1643 Addstring(shstrtab, ".rela.gopclntab") 1644 Addstring(shstrtab, ".rela.noptrdata") 1645 Addstring(shstrtab, ".rela.data") 1646 1647 default: 1648 Addstring(shstrtab, ".rel.text") 1649 Addstring(shstrtab, ".rel.rodata") 1650 Addstring(shstrtab, ".rel.typelink") 1651 Addstring(shstrtab, ".rel.gosymtab") 1652 Addstring(shstrtab, ".rel.gopclntab") 1653 Addstring(shstrtab, ".rel.noptrdata") 1654 Addstring(shstrtab, ".rel.data") 1655 } 1656 1657 // add a .note.GNU-stack section to mark the stack as non-executable 1658 Addstring(shstrtab, ".note.GNU-stack") 1659 } 1660 1661 hasinitarr := Linkshared 1662 1663 /* shared library initializer */ 1664 switch Buildmode { 1665 case BuildmodeCArchive, BuildmodeCShared, BuildmodeShared: 1666 hasinitarr = true 1667 } 1668 1669 if hasinitarr { 1670 Addstring(shstrtab, ".init_array") 1671 switch Thearch.Thechar { 1672 case '6', '7', '9': 1673 Addstring(shstrtab, ".rela.init_array") 1674 default: 1675 Addstring(shstrtab, ".rel.init_array") 1676 } 1677 } 1678 1679 if Debug['s'] == 0 { 1680 Addstring(shstrtab, ".symtab") 1681 Addstring(shstrtab, ".strtab") 1682 dwarfaddshstrings(shstrtab) 1683 } 1684 1685 Addstring(shstrtab, ".shstrtab") 1686 1687 if Debug['d'] == 0 { /* -d suppresses dynamic loader format */ 1688 Addstring(shstrtab, ".interp") 1689 Addstring(shstrtab, ".hash") 1690 Addstring(shstrtab, ".got") 1691 if Thearch.Thechar == '9' { 1692 Addstring(shstrtab, ".glink") 1693 } 1694 Addstring(shstrtab, ".got.plt") 1695 Addstring(shstrtab, ".dynamic") 1696 Addstring(shstrtab, ".dynsym") 1697 Addstring(shstrtab, ".dynstr") 1698 switch Thearch.Thechar { 1699 case '6', '7', '9': 1700 Addstring(shstrtab, ".rela") 1701 Addstring(shstrtab, ".rela.plt") 1702 default: 1703 Addstring(shstrtab, ".rel") 1704 Addstring(shstrtab, ".rel.plt") 1705 } 1706 1707 Addstring(shstrtab, ".plt") 1708 Addstring(shstrtab, ".gnu.version") 1709 Addstring(shstrtab, ".gnu.version_r") 1710 1711 /* dynamic symbol table - first entry all zeros */ 1712 s := Linklookup(Ctxt, ".dynsym", 0) 1713 1714 s.Type = SELFROSECT 1715 s.Reachable = true 1716 switch Thearch.Thechar { 1717 case '6', '7', '9': 1718 s.Size += ELF64SYMSIZE 1719 default: 1720 s.Size += ELF32SYMSIZE 1721 } 1722 1723 /* dynamic string table */ 1724 s = Linklookup(Ctxt, ".dynstr", 0) 1725 1726 s.Type = SELFROSECT 1727 s.Reachable = true 1728 if s.Size == 0 { 1729 Addstring(s, "") 1730 } 1731 dynstr := s 1732 1733 /* relocation table */ 1734 switch Thearch.Thechar { 1735 case '6', '7', '9': 1736 s = Linklookup(Ctxt, ".rela", 0) 1737 default: 1738 s = Linklookup(Ctxt, ".rel", 0) 1739 } 1740 s.Reachable = true 1741 s.Type = SELFROSECT 1742 1743 /* global offset table */ 1744 s = Linklookup(Ctxt, ".got", 0) 1745 1746 s.Reachable = true 1747 s.Type = SELFGOT // writable 1748 1749 /* ppc64 glink resolver */ 1750 if Thearch.Thechar == '9' { 1751 s := Linklookup(Ctxt, ".glink", 0) 1752 s.Reachable = true 1753 s.Type = SELFRXSECT 1754 } 1755 1756 /* hash */ 1757 s = Linklookup(Ctxt, ".hash", 0) 1758 1759 s.Reachable = true 1760 s.Type = SELFROSECT 1761 1762 s = Linklookup(Ctxt, ".got.plt", 0) 1763 s.Reachable = true 1764 s.Type = SELFSECT // writable 1765 1766 s = Linklookup(Ctxt, ".plt", 0) 1767 1768 s.Reachable = true 1769 if Thearch.Thechar == '9' { 1770 // In the ppc64 ABI, .plt is a data section 1771 // written by the dynamic linker. 1772 s.Type = SELFSECT 1773 } else { 1774 s.Type = SELFRXSECT 1775 } 1776 1777 Thearch.Elfsetupplt() 1778 1779 switch Thearch.Thechar { 1780 case '6', '7', '9': 1781 s = Linklookup(Ctxt, ".rela.plt", 0) 1782 default: 1783 s = Linklookup(Ctxt, ".rel.plt", 0) 1784 } 1785 s.Reachable = true 1786 s.Type = SELFROSECT 1787 1788 s = Linklookup(Ctxt, ".gnu.version", 0) 1789 s.Reachable = true 1790 s.Type = SELFROSECT 1791 1792 s = Linklookup(Ctxt, ".gnu.version_r", 0) 1793 s.Reachable = true 1794 s.Type = SELFROSECT 1795 1796 /* define dynamic elf table */ 1797 s = Linklookup(Ctxt, ".dynamic", 0) 1798 1799 s.Reachable = true 1800 s.Type = SELFSECT // writable 1801 1802 /* 1803 * .dynamic table 1804 */ 1805 elfwritedynentsym(s, DT_HASH, Linklookup(Ctxt, ".hash", 0)) 1806 1807 elfwritedynentsym(s, DT_SYMTAB, Linklookup(Ctxt, ".dynsym", 0)) 1808 switch Thearch.Thechar { 1809 case '6', '7', '9': 1810 Elfwritedynent(s, DT_SYMENT, ELF64SYMSIZE) 1811 default: 1812 Elfwritedynent(s, DT_SYMENT, ELF32SYMSIZE) 1813 } 1814 elfwritedynentsym(s, DT_STRTAB, Linklookup(Ctxt, ".dynstr", 0)) 1815 elfwritedynentsymsize(s, DT_STRSZ, Linklookup(Ctxt, ".dynstr", 0)) 1816 switch Thearch.Thechar { 1817 case '6', '7', '9': 1818 elfwritedynentsym(s, DT_RELA, Linklookup(Ctxt, ".rela", 0)) 1819 elfwritedynentsymsize(s, DT_RELASZ, Linklookup(Ctxt, ".rela", 0)) 1820 Elfwritedynent(s, DT_RELAENT, ELF64RELASIZE) 1821 default: 1822 elfwritedynentsym(s, DT_REL, Linklookup(Ctxt, ".rel", 0)) 1823 elfwritedynentsymsize(s, DT_RELSZ, Linklookup(Ctxt, ".rel", 0)) 1824 Elfwritedynent(s, DT_RELENT, ELF32RELSIZE) 1825 } 1826 1827 if rpath.val != "" { 1828 Elfwritedynent(s, DT_RUNPATH, uint64(Addstring(dynstr, rpath.val))) 1829 } 1830 1831 if Thearch.Thechar == '9' { 1832 elfwritedynentsym(s, DT_PLTGOT, Linklookup(Ctxt, ".plt", 0)) 1833 } else { 1834 elfwritedynentsym(s, DT_PLTGOT, Linklookup(Ctxt, ".got.plt", 0)) 1835 } 1836 1837 if Thearch.Thechar == '9' { 1838 Elfwritedynent(s, DT_PPC64_OPT, 0) 1839 } 1840 1841 // Solaris dynamic linker can't handle an empty .rela.plt if 1842 // DT_JMPREL is emitted so we have to defer generation of DT_PLTREL, 1843 // DT_PLTRELSZ, and DT_JMPREL dynamic entries until after we know the 1844 // size of .rel(a).plt section. 1845 Elfwritedynent(s, DT_DEBUG, 0) 1846 } 1847 } 1848 1849 // Do not write DT_NULL. elfdynhash will finish it. 1850 func shsym(sh *ElfShdr, s *LSym) { 1851 addr := Symaddr(s) 1852 if sh.flags&SHF_ALLOC != 0 { 1853 sh.addr = uint64(addr) 1854 } 1855 sh.off = uint64(datoff(addr)) 1856 sh.size = uint64(s.Size) 1857 } 1858 1859 func phsh(ph *ElfPhdr, sh *ElfShdr) { 1860 ph.vaddr = sh.addr 1861 ph.paddr = ph.vaddr 1862 ph.off = sh.off 1863 ph.filesz = sh.size 1864 ph.memsz = sh.size 1865 ph.align = sh.addralign 1866 } 1867 1868 func Asmbelfsetup() { 1869 /* This null SHdr must appear before all others */ 1870 elfshname("") 1871 1872 for sect := Segtext.Sect; sect != nil; sect = sect.Next { 1873 elfshalloc(sect) 1874 } 1875 for sect := Segrodata.Sect; sect != nil; sect = sect.Next { 1876 elfshalloc(sect) 1877 } 1878 for sect := Segdata.Sect; sect != nil; sect = sect.Next { 1879 elfshalloc(sect) 1880 } 1881 } 1882 1883 func Asmbelf(symo int64) { 1884 eh := getElfEhdr() 1885 switch Thearch.Thechar { 1886 default: 1887 Diag("unknown architecture in asmbelf") 1888 Errorexit() 1889 fallthrough 1890 1891 case '5': 1892 eh.machine = EM_ARM 1893 1894 case '6': 1895 eh.machine = EM_X86_64 1896 1897 case '7': 1898 eh.machine = EM_AARCH64 1899 1900 case '8': 1901 eh.machine = EM_386 1902 1903 case '9': 1904 eh.machine = EM_PPC64 1905 } 1906 1907 startva := INITTEXT - int64(HEADR) 1908 resoff := int64(ELFRESERVE) 1909 1910 var pph *ElfPhdr 1911 var pnote *ElfPhdr 1912 if Linkmode == LinkExternal { 1913 /* skip program headers */ 1914 eh.phoff = 0 1915 1916 eh.phentsize = 0 1917 goto elfobj 1918 } 1919 1920 /* program header info */ 1921 pph = newElfPhdr() 1922 1923 pph.type_ = PT_PHDR 1924 pph.flags = PF_R 1925 pph.off = uint64(eh.ehsize) 1926 pph.vaddr = uint64(INITTEXT) - uint64(HEADR) + pph.off 1927 pph.paddr = uint64(INITTEXT) - uint64(HEADR) + pph.off 1928 pph.align = uint64(INITRND) 1929 1930 /* 1931 * PHDR must be in a loaded segment. Adjust the text 1932 * segment boundaries downwards to include it. 1933 * Except on NaCl where it must not be loaded. 1934 */ 1935 if HEADTYPE != Hnacl { 1936 o := int64(Segtext.Vaddr - pph.vaddr) 1937 Segtext.Vaddr -= uint64(o) 1938 Segtext.Length += uint64(o) 1939 o = int64(Segtext.Fileoff - pph.off) 1940 Segtext.Fileoff -= uint64(o) 1941 Segtext.Filelen += uint64(o) 1942 } 1943 1944 if Debug['d'] == 0 { /* -d suppresses dynamic loader format */ 1945 /* interpreter */ 1946 sh := elfshname(".interp") 1947 1948 sh.type_ = SHT_PROGBITS 1949 sh.flags = SHF_ALLOC 1950 sh.addralign = 1 1951 if interpreter == "" { 1952 switch HEADTYPE { 1953 case Hlinux: 1954 interpreter = Thearch.Linuxdynld 1955 1956 case Hfreebsd: 1957 interpreter = Thearch.Freebsddynld 1958 1959 case Hnetbsd: 1960 interpreter = Thearch.Netbsddynld 1961 1962 case Hopenbsd: 1963 interpreter = Thearch.Openbsddynld 1964 1965 case Hdragonfly: 1966 interpreter = Thearch.Dragonflydynld 1967 1968 case Hsolaris: 1969 interpreter = Thearch.Solarisdynld 1970 } 1971 } 1972 1973 resoff -= int64(elfinterp(sh, uint64(startva), uint64(resoff), interpreter)) 1974 1975 ph := newElfPhdr() 1976 ph.type_ = PT_INTERP 1977 ph.flags = PF_R 1978 phsh(ph, sh) 1979 } 1980 1981 pnote = nil 1982 if HEADTYPE == Hnetbsd || HEADTYPE == Hopenbsd { 1983 var sh *ElfShdr 1984 switch HEADTYPE { 1985 case Hnetbsd: 1986 sh = elfshname(".note.netbsd.ident") 1987 resoff -= int64(elfnetbsdsig(sh, uint64(startva), uint64(resoff))) 1988 1989 case Hopenbsd: 1990 sh = elfshname(".note.openbsd.ident") 1991 resoff -= int64(elfopenbsdsig(sh, uint64(startva), uint64(resoff))) 1992 } 1993 1994 pnote = newElfPhdr() 1995 pnote.type_ = PT_NOTE 1996 pnote.flags = PF_R 1997 phsh(pnote, sh) 1998 } 1999 2000 if len(buildinfo) > 0 { 2001 sh := elfshname(".note.gnu.build-id") 2002 resoff -= int64(elfbuildinfo(sh, uint64(startva), uint64(resoff))) 2003 2004 if pnote == nil { 2005 pnote = newElfPhdr() 2006 pnote.type_ = PT_NOTE 2007 pnote.flags = PF_R 2008 } 2009 2010 phsh(pnote, sh) 2011 } 2012 2013 // Additions to the reserved area must be above this line. 2014 2015 elfphload(&Segtext) 2016 if Segrodata.Sect != nil { 2017 elfphload(&Segrodata) 2018 } 2019 elfphload(&Segdata) 2020 2021 /* Dynamic linking sections */ 2022 if Debug['d'] == 0 { 2023 sh := elfshname(".dynsym") 2024 sh.type_ = SHT_DYNSYM 2025 sh.flags = SHF_ALLOC 2026 if elf64 { 2027 sh.entsize = ELF64SYMSIZE 2028 } else { 2029 sh.entsize = ELF32SYMSIZE 2030 } 2031 sh.addralign = uint64(Thearch.Regsize) 2032 sh.link = uint32(elfshname(".dynstr").shnum) 2033 2034 // sh->info = index of first non-local symbol (number of local symbols) 2035 shsym(sh, Linklookup(Ctxt, ".dynsym", 0)) 2036 2037 sh = elfshname(".dynstr") 2038 sh.type_ = SHT_STRTAB 2039 sh.flags = SHF_ALLOC 2040 sh.addralign = 1 2041 shsym(sh, Linklookup(Ctxt, ".dynstr", 0)) 2042 2043 if elfverneed != 0 { 2044 sh := elfshname(".gnu.version") 2045 sh.type_ = SHT_GNU_VERSYM 2046 sh.flags = SHF_ALLOC 2047 sh.addralign = 2 2048 sh.link = uint32(elfshname(".dynsym").shnum) 2049 sh.entsize = 2 2050 shsym(sh, Linklookup(Ctxt, ".gnu.version", 0)) 2051 2052 sh = elfshname(".gnu.version_r") 2053 sh.type_ = SHT_GNU_VERNEED 2054 sh.flags = SHF_ALLOC 2055 sh.addralign = uint64(Thearch.Regsize) 2056 sh.info = uint32(elfverneed) 2057 sh.link = uint32(elfshname(".dynstr").shnum) 2058 shsym(sh, Linklookup(Ctxt, ".gnu.version_r", 0)) 2059 } 2060 2061 switch eh.machine { 2062 case EM_X86_64, EM_PPC64, EM_AARCH64: 2063 sh := elfshname(".rela.plt") 2064 sh.type_ = SHT_RELA 2065 sh.flags = SHF_ALLOC 2066 sh.entsize = ELF64RELASIZE 2067 sh.addralign = uint64(Thearch.Regsize) 2068 sh.link = uint32(elfshname(".dynsym").shnum) 2069 sh.info = uint32(elfshname(".plt").shnum) 2070 shsym(sh, Linklookup(Ctxt, ".rela.plt", 0)) 2071 2072 sh = elfshname(".rela") 2073 sh.type_ = SHT_RELA 2074 sh.flags = SHF_ALLOC 2075 sh.entsize = ELF64RELASIZE 2076 sh.addralign = 8 2077 sh.link = uint32(elfshname(".dynsym").shnum) 2078 shsym(sh, Linklookup(Ctxt, ".rela", 0)) 2079 2080 default: 2081 sh := elfshname(".rel.plt") 2082 sh.type_ = SHT_REL 2083 sh.flags = SHF_ALLOC 2084 sh.entsize = ELF32RELSIZE 2085 sh.addralign = 4 2086 sh.link = uint32(elfshname(".dynsym").shnum) 2087 shsym(sh, Linklookup(Ctxt, ".rel.plt", 0)) 2088 2089 sh = elfshname(".rel") 2090 sh.type_ = SHT_REL 2091 sh.flags = SHF_ALLOC 2092 sh.entsize = ELF32RELSIZE 2093 sh.addralign = 4 2094 sh.link = uint32(elfshname(".dynsym").shnum) 2095 shsym(sh, Linklookup(Ctxt, ".rel", 0)) 2096 } 2097 2098 if eh.machine == EM_PPC64 { 2099 sh := elfshname(".glink") 2100 sh.type_ = SHT_PROGBITS 2101 sh.flags = SHF_ALLOC + SHF_EXECINSTR 2102 sh.addralign = 4 2103 shsym(sh, Linklookup(Ctxt, ".glink", 0)) 2104 } 2105 2106 sh = elfshname(".plt") 2107 sh.type_ = SHT_PROGBITS 2108 sh.flags = SHF_ALLOC + SHF_EXECINSTR 2109 if eh.machine == EM_X86_64 { 2110 sh.entsize = 16 2111 } else if eh.machine == EM_PPC64 { 2112 // On ppc64, this is just a table of addresses 2113 // filled by the dynamic linker 2114 sh.type_ = SHT_NOBITS 2115 2116 sh.flags = SHF_ALLOC + SHF_WRITE 2117 sh.entsize = 8 2118 } else { 2119 sh.entsize = 4 2120 } 2121 sh.addralign = sh.entsize 2122 shsym(sh, Linklookup(Ctxt, ".plt", 0)) 2123 2124 // On ppc64, .got comes from the input files, so don't 2125 // create it here, and .got.plt is not used. 2126 if eh.machine != EM_PPC64 { 2127 sh := elfshname(".got") 2128 sh.type_ = SHT_PROGBITS 2129 sh.flags = SHF_ALLOC + SHF_WRITE 2130 sh.entsize = uint64(Thearch.Regsize) 2131 sh.addralign = uint64(Thearch.Regsize) 2132 shsym(sh, Linklookup(Ctxt, ".got", 0)) 2133 2134 sh = elfshname(".got.plt") 2135 sh.type_ = SHT_PROGBITS 2136 sh.flags = SHF_ALLOC + SHF_WRITE 2137 sh.entsize = uint64(Thearch.Regsize) 2138 sh.addralign = uint64(Thearch.Regsize) 2139 shsym(sh, Linklookup(Ctxt, ".got.plt", 0)) 2140 } 2141 2142 sh = elfshname(".hash") 2143 sh.type_ = SHT_HASH 2144 sh.flags = SHF_ALLOC 2145 sh.entsize = 4 2146 sh.addralign = uint64(Thearch.Regsize) 2147 sh.link = uint32(elfshname(".dynsym").shnum) 2148 shsym(sh, Linklookup(Ctxt, ".hash", 0)) 2149 2150 /* sh and PT_DYNAMIC for .dynamic section */ 2151 sh = elfshname(".dynamic") 2152 2153 sh.type_ = SHT_DYNAMIC 2154 sh.flags = SHF_ALLOC + SHF_WRITE 2155 sh.entsize = 2 * uint64(Thearch.Regsize) 2156 sh.addralign = uint64(Thearch.Regsize) 2157 sh.link = uint32(elfshname(".dynstr").shnum) 2158 shsym(sh, Linklookup(Ctxt, ".dynamic", 0)) 2159 ph := newElfPhdr() 2160 ph.type_ = PT_DYNAMIC 2161 ph.flags = PF_R + PF_W 2162 phsh(ph, sh) 2163 2164 /* 2165 * Thread-local storage segment (really just size). 2166 */ 2167 // Do not emit PT_TLS for OpenBSD since ld.so(1) does 2168 // not currently support it. This is handled 2169 // appropriately in runtime/cgo. 2170 if Ctxt.Tlsoffset != 0 && HEADTYPE != Hopenbsd { 2171 ph := newElfPhdr() 2172 ph.type_ = PT_TLS 2173 ph.flags = PF_R 2174 ph.memsz = uint64(-Ctxt.Tlsoffset) 2175 ph.align = uint64(Thearch.Regsize) 2176 } 2177 } 2178 2179 if HEADTYPE == Hlinux { 2180 ph := newElfPhdr() 2181 ph.type_ = PT_GNU_STACK 2182 ph.flags = PF_W + PF_R 2183 ph.align = uint64(Thearch.Regsize) 2184 2185 ph = newElfPhdr() 2186 ph.type_ = PT_PAX_FLAGS 2187 ph.flags = 0x2a00 // mprotect, randexec, emutramp disabled 2188 ph.align = uint64(Thearch.Regsize) 2189 } 2190 2191 elfobj: 2192 sh := elfshname(".shstrtab") 2193 sh.type_ = SHT_STRTAB 2194 sh.addralign = 1 2195 shsym(sh, Linklookup(Ctxt, ".shstrtab", 0)) 2196 eh.shstrndx = uint16(sh.shnum) 2197 2198 // put these sections early in the list 2199 if Debug['s'] == 0 { 2200 elfshname(".symtab") 2201 elfshname(".strtab") 2202 } 2203 2204 for sect := Segtext.Sect; sect != nil; sect = sect.Next { 2205 elfshbits(sect) 2206 } 2207 for sect := Segrodata.Sect; sect != nil; sect = sect.Next { 2208 elfshbits(sect) 2209 } 2210 for sect := Segdata.Sect; sect != nil; sect = sect.Next { 2211 elfshbits(sect) 2212 } 2213 2214 if Linkmode == LinkExternal { 2215 for sect := Segtext.Sect; sect != nil; sect = sect.Next { 2216 elfshreloc(sect) 2217 } 2218 for sect := Segrodata.Sect; sect != nil; sect = sect.Next { 2219 elfshreloc(sect) 2220 } 2221 for sect := Segdata.Sect; sect != nil; sect = sect.Next { 2222 elfshreloc(sect) 2223 } 2224 2225 // add a .note.GNU-stack section to mark the stack as non-executable 2226 sh := elfshname(".note.GNU-stack") 2227 2228 sh.type_ = SHT_PROGBITS 2229 sh.addralign = 1 2230 sh.flags = 0 2231 } 2232 2233 // generate .tbss section for dynamic internal linking (except for OpenBSD) 2234 // external linking generates .tbss in data.c 2235 if Linkmode == LinkInternal && Debug['d'] == 0 && HEADTYPE != Hopenbsd { 2236 sh := elfshname(".tbss") 2237 sh.type_ = SHT_NOBITS 2238 sh.addralign = uint64(Thearch.Regsize) 2239 sh.size = uint64(-Ctxt.Tlsoffset) 2240 sh.flags = SHF_ALLOC | SHF_TLS | SHF_WRITE 2241 } 2242 2243 if Debug['s'] == 0 { 2244 sh := elfshname(".symtab") 2245 sh.type_ = SHT_SYMTAB 2246 sh.off = uint64(symo) 2247 sh.size = uint64(Symsize) 2248 sh.addralign = uint64(Thearch.Regsize) 2249 sh.entsize = 8 + 2*uint64(Thearch.Regsize) 2250 sh.link = uint32(elfshname(".strtab").shnum) 2251 sh.info = uint32(elfglobalsymndx) 2252 2253 sh = elfshname(".strtab") 2254 sh.type_ = SHT_STRTAB 2255 sh.off = uint64(symo) + uint64(Symsize) 2256 sh.size = uint64(len(Elfstrdat)) 2257 sh.addralign = 1 2258 2259 dwarfaddelfheaders() 2260 } 2261 2262 /* Main header */ 2263 eh.ident[EI_MAG0] = '\177' 2264 2265 eh.ident[EI_MAG1] = 'E' 2266 eh.ident[EI_MAG2] = 'L' 2267 eh.ident[EI_MAG3] = 'F' 2268 if HEADTYPE == Hfreebsd { 2269 eh.ident[EI_OSABI] = ELFOSABI_FREEBSD 2270 } else if HEADTYPE == Hnetbsd { 2271 eh.ident[EI_OSABI] = ELFOSABI_NETBSD 2272 } else if HEADTYPE == Hopenbsd { 2273 eh.ident[EI_OSABI] = ELFOSABI_OPENBSD 2274 } else if HEADTYPE == Hdragonfly { 2275 eh.ident[EI_OSABI] = ELFOSABI_NONE 2276 } 2277 if elf64 { 2278 eh.ident[EI_CLASS] = ELFCLASS64 2279 } else { 2280 eh.ident[EI_CLASS] = ELFCLASS32 2281 } 2282 if Ctxt.Arch.ByteOrder == binary.BigEndian { 2283 eh.ident[EI_DATA] = ELFDATA2MSB 2284 } else { 2285 eh.ident[EI_DATA] = ELFDATA2LSB 2286 } 2287 eh.ident[EI_VERSION] = EV_CURRENT 2288 2289 if Linkmode == LinkExternal { 2290 eh.type_ = ET_REL 2291 } else { 2292 eh.type_ = ET_EXEC 2293 } 2294 2295 if Linkmode != LinkExternal { 2296 eh.entry = uint64(Entryvalue()) 2297 } 2298 2299 eh.version = EV_CURRENT 2300 2301 if pph != nil { 2302 pph.filesz = uint64(eh.phnum) * uint64(eh.phentsize) 2303 pph.memsz = pph.filesz 2304 } 2305 2306 Cseek(0) 2307 a := int64(0) 2308 a += int64(elfwritehdr()) 2309 a += int64(elfwritephdrs()) 2310 a += int64(elfwriteshdrs()) 2311 if Debug['d'] == 0 { 2312 a += int64(elfwriteinterp()) 2313 } 2314 if Linkmode != LinkExternal { 2315 if HEADTYPE == Hnetbsd { 2316 a += int64(elfwritenetbsdsig()) 2317 } 2318 if HEADTYPE == Hopenbsd { 2319 a += int64(elfwriteopenbsdsig()) 2320 } 2321 if len(buildinfo) > 0 { 2322 a += int64(elfwritebuildinfo()) 2323 } 2324 } 2325 2326 if a > ELFRESERVE { 2327 Diag("ELFRESERVE too small: %d > %d", a, ELFRESERVE) 2328 } 2329 } 2330 2331 func ELF32_R_SYM(info uint32) uint32 { 2332 return info >> 8 2333 } 2334 2335 func ELF32_R_TYPE(info uint32) uint32 { 2336 return uint32(uint8(info)) 2337 } 2338 2339 func ELF32_R_INFO(sym uint32, type_ uint32) uint32 { 2340 return sym<<8 | type_ 2341 } 2342 2343 func ELF32_ST_BIND(info uint8) uint8 { 2344 return info >> 4 2345 } 2346 2347 func ELF32_ST_TYPE(info uint8) uint8 { 2348 return info & 0xf 2349 } 2350 2351 func ELF32_ST_INFO(bind uint8, type_ uint8) uint8 { 2352 return bind<<4 | type_&0xf 2353 } 2354 2355 func ELF32_ST_VISIBILITY(oth uint8) uint8 { 2356 return oth & 3 2357 } 2358 2359 func ELF64_R_SYM(info uint64) uint32 { 2360 return uint32(info >> 32) 2361 } 2362 2363 func ELF64_R_TYPE(info uint64) uint32 { 2364 return uint32(info) 2365 } 2366 2367 func ELF64_R_INFO(sym uint32, type_ uint32) uint64 { 2368 return uint64(sym)<<32 | uint64(type_) 2369 } 2370 2371 func ELF64_ST_BIND(info uint8) uint8 { 2372 return info >> 4 2373 } 2374 2375 func ELF64_ST_TYPE(info uint8) uint8 { 2376 return info & 0xf 2377 } 2378 2379 func ELF64_ST_INFO(bind uint8, type_ uint8) uint8 { 2380 return bind<<4 | type_&0xf 2381 } 2382 2383 func ELF64_ST_VISIBILITY(oth uint8) uint8 { 2384 return oth & 3 2385 }