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