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