1 /* IBM S/390-specific support for 64-bit ELF 2 Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 3 2010, 2011, 2012 Free Software Foundation, Inc. 4 Contributed Martin Schwidefsky (schwidefsky@de.ibm.com). 5 6 This file is part of BFD, the Binary File Descriptor library. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the Free Software 20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 21 02110-1301, USA. */ 22 23 #include "sysdep.h" 24 #include "bfd.h" 25 #include "bfdlink.h" 26 #include "libbfd.h" 27 #include "elf-bfd.h" 28 #include "elf/s390.h" 29 30 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value 31 from smaller values. Start with zero, widen, *then* decrement. */ 32 #define MINUS_ONE (((bfd_vma)0) - 1) 33 34 static bfd_reloc_status_type 35 s390_tls_reloc (bfd *, arelent *, asymbol *, void *, 36 asection *, bfd *, char **); 37 static bfd_reloc_status_type 38 s390_elf_ldisp_reloc (bfd *, arelent *, asymbol *, void *, 39 asection *, bfd *, char **); 40 41 /* The relocation "howto" table. */ 42 static reloc_howto_type elf_howto_table[] = 43 { 44 HOWTO (R_390_NONE, /* type */ 45 0, /* rightshift */ 46 0, /* size (0 = byte, 1 = short, 2 = long) */ 47 0, /* bitsize */ 48 FALSE, /* pc_relative */ 49 0, /* bitpos */ 50 complain_overflow_dont, /* complain_on_overflow */ 51 bfd_elf_generic_reloc, /* special_function */ 52 "R_390_NONE", /* name */ 53 FALSE, /* partial_inplace */ 54 0, /* src_mask */ 55 0, /* dst_mask */ 56 FALSE), /* pcrel_offset */ 57 58 HOWTO(R_390_8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield, 59 bfd_elf_generic_reloc, "R_390_8", FALSE, 0,0x000000ff, FALSE), 60 HOWTO(R_390_12, 0, 1, 12, FALSE, 0, complain_overflow_dont, 61 bfd_elf_generic_reloc, "R_390_12", FALSE, 0,0x00000fff, FALSE), 62 HOWTO(R_390_16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield, 63 bfd_elf_generic_reloc, "R_390_16", FALSE, 0,0x0000ffff, FALSE), 64 HOWTO(R_390_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield, 65 bfd_elf_generic_reloc, "R_390_32", FALSE, 0,0xffffffff, FALSE), 66 HOWTO(R_390_PC32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield, 67 bfd_elf_generic_reloc, "R_390_PC32", FALSE, 0,0xffffffff, TRUE), 68 HOWTO(R_390_GOT12, 0, 1, 12, FALSE, 0, complain_overflow_bitfield, 69 bfd_elf_generic_reloc, "R_390_GOT12", FALSE, 0,0x00000fff, FALSE), 70 HOWTO(R_390_GOT32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield, 71 bfd_elf_generic_reloc, "R_390_GOT32", FALSE, 0,0xffffffff, FALSE), 72 HOWTO(R_390_PLT32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield, 73 bfd_elf_generic_reloc, "R_390_PLT32", FALSE, 0,0xffffffff, TRUE), 74 HOWTO(R_390_COPY, 0, 4, 64, FALSE, 0, complain_overflow_bitfield, 75 bfd_elf_generic_reloc, "R_390_COPY", FALSE, 0,MINUS_ONE, FALSE), 76 HOWTO(R_390_GLOB_DAT, 0, 4, 64, FALSE, 0, complain_overflow_bitfield, 77 bfd_elf_generic_reloc, "R_390_GLOB_DAT", FALSE, 0,MINUS_ONE, FALSE), 78 HOWTO(R_390_JMP_SLOT, 0, 4, 64, FALSE, 0, complain_overflow_bitfield, 79 bfd_elf_generic_reloc, "R_390_JMP_SLOT", FALSE, 0,MINUS_ONE, FALSE), 80 HOWTO(R_390_RELATIVE, 0, 4, 64, TRUE, 0, complain_overflow_bitfield, 81 bfd_elf_generic_reloc, "R_390_RELATIVE", FALSE, 0,MINUS_ONE, FALSE), 82 HOWTO(R_390_GOTOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield, 83 bfd_elf_generic_reloc, "R_390_GOTOFF32", FALSE, 0,MINUS_ONE, FALSE), 84 HOWTO(R_390_GOTPC, 0, 4, 64, TRUE, 0, complain_overflow_bitfield, 85 bfd_elf_generic_reloc, "R_390_GOTPC", FALSE, 0,MINUS_ONE, TRUE), 86 HOWTO(R_390_GOT16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield, 87 bfd_elf_generic_reloc, "R_390_GOT16", FALSE, 0,0x0000ffff, FALSE), 88 HOWTO(R_390_PC16, 0, 1, 16, TRUE, 0, complain_overflow_bitfield, 89 bfd_elf_generic_reloc, "R_390_PC16", FALSE, 0,0x0000ffff, TRUE), 90 HOWTO(R_390_PC16DBL, 1, 1, 16, TRUE, 0, complain_overflow_bitfield, 91 bfd_elf_generic_reloc, "R_390_PC16DBL", FALSE, 0,0x0000ffff, TRUE), 92 HOWTO(R_390_PLT16DBL, 1, 1, 16, TRUE, 0, complain_overflow_bitfield, 93 bfd_elf_generic_reloc, "R_390_PLT16DBL", FALSE, 0,0x0000ffff, TRUE), 94 HOWTO(R_390_PC32DBL, 1, 2, 32, TRUE, 0, complain_overflow_bitfield, 95 bfd_elf_generic_reloc, "R_390_PC32DBL", FALSE, 0,0xffffffff, TRUE), 96 HOWTO(R_390_PLT32DBL, 1, 2, 32, TRUE, 0, complain_overflow_bitfield, 97 bfd_elf_generic_reloc, "R_390_PLT32DBL", FALSE, 0,0xffffffff, TRUE), 98 HOWTO(R_390_GOTPCDBL, 1, 2, 32, TRUE, 0, complain_overflow_bitfield, 99 bfd_elf_generic_reloc, "R_390_GOTPCDBL", FALSE, 0,MINUS_ONE, TRUE), 100 HOWTO(R_390_64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield, 101 bfd_elf_generic_reloc, "R_390_64", FALSE, 0,MINUS_ONE, FALSE), 102 HOWTO(R_390_PC64, 0, 4, 64, TRUE, 0, complain_overflow_bitfield, 103 bfd_elf_generic_reloc, "R_390_PC64", FALSE, 0,MINUS_ONE, TRUE), 104 HOWTO(R_390_GOT64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield, 105 bfd_elf_generic_reloc, "R_390_GOT64", FALSE, 0,MINUS_ONE, FALSE), 106 HOWTO(R_390_PLT64, 0, 4, 64, TRUE, 0, complain_overflow_bitfield, 107 bfd_elf_generic_reloc, "R_390_PLT64", FALSE, 0,MINUS_ONE, TRUE), 108 HOWTO(R_390_GOTENT, 1, 2, 32, TRUE, 0, complain_overflow_bitfield, 109 bfd_elf_generic_reloc, "R_390_GOTENT", FALSE, 0,MINUS_ONE, TRUE), 110 HOWTO(R_390_GOTOFF16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield, 111 bfd_elf_generic_reloc, "R_390_GOTOFF16", FALSE, 0,0x0000ffff, FALSE), 112 HOWTO(R_390_GOTOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield, 113 bfd_elf_generic_reloc, "R_390_GOTOFF64", FALSE, 0,MINUS_ONE, FALSE), 114 HOWTO(R_390_GOTPLT12, 0, 1, 12, FALSE, 0, complain_overflow_dont, 115 bfd_elf_generic_reloc, "R_390_GOTPLT12", FALSE, 0,0x00000fff, FALSE), 116 HOWTO(R_390_GOTPLT16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield, 117 bfd_elf_generic_reloc, "R_390_GOTPLT16", FALSE, 0,0x0000ffff, FALSE), 118 HOWTO(R_390_GOTPLT32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield, 119 bfd_elf_generic_reloc, "R_390_GOTPLT32", FALSE, 0,0xffffffff, FALSE), 120 HOWTO(R_390_GOTPLT64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield, 121 bfd_elf_generic_reloc, "R_390_GOTPLT64", FALSE, 0,MINUS_ONE, FALSE), 122 HOWTO(R_390_GOTPLTENT, 1, 2, 32, TRUE, 0, complain_overflow_bitfield, 123 bfd_elf_generic_reloc, "R_390_GOTPLTENT",FALSE, 0,MINUS_ONE, TRUE), 124 HOWTO(R_390_PLTOFF16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield, 125 bfd_elf_generic_reloc, "R_390_PLTOFF16", FALSE, 0,0x0000ffff, FALSE), 126 HOWTO(R_390_PLTOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield, 127 bfd_elf_generic_reloc, "R_390_PLTOFF32", FALSE, 0,0xffffffff, FALSE), 128 HOWTO(R_390_PLTOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield, 129 bfd_elf_generic_reloc, "R_390_PLTOFF64", FALSE, 0,MINUS_ONE, FALSE), 130 HOWTO(R_390_TLS_LOAD, 0, 0, 0, FALSE, 0, complain_overflow_dont, 131 s390_tls_reloc, "R_390_TLS_LOAD", FALSE, 0, 0, FALSE), 132 HOWTO(R_390_TLS_GDCALL, 0, 0, 0, FALSE, 0, complain_overflow_dont, 133 s390_tls_reloc, "R_390_TLS_GDCALL", FALSE, 0, 0, FALSE), 134 HOWTO(R_390_TLS_LDCALL, 0, 0, 0, FALSE, 0, complain_overflow_dont, 135 s390_tls_reloc, "R_390_TLS_LDCALL", FALSE, 0, 0, FALSE), 136 EMPTY_HOWTO (R_390_TLS_GD32), /* Empty entry for R_390_TLS_GD32. */ 137 HOWTO(R_390_TLS_GD64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield, 138 bfd_elf_generic_reloc, "R_390_TLS_GD64", FALSE, 0, MINUS_ONE, FALSE), 139 HOWTO(R_390_TLS_GOTIE12, 0, 1, 12, FALSE, 0, complain_overflow_dont, 140 bfd_elf_generic_reloc, "R_390_TLS_GOTIE12", FALSE, 0, 0x00000fff, FALSE), 141 EMPTY_HOWTO (R_390_TLS_GOTIE32), /* Empty entry for R_390_TLS_GOTIE32. */ 142 HOWTO(R_390_TLS_GOTIE64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield, 143 bfd_elf_generic_reloc, "R_390_TLS_GOTIE64", FALSE, 0, MINUS_ONE, FALSE), 144 EMPTY_HOWTO (R_390_TLS_LDM32), /* Empty entry for R_390_TLS_LDM32. */ 145 HOWTO(R_390_TLS_LDM64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield, 146 bfd_elf_generic_reloc, "R_390_TLS_LDM64", FALSE, 0, MINUS_ONE, FALSE), 147 EMPTY_HOWTO (R_390_TLS_IE32), /* Empty entry for R_390_TLS_IE32. */ 148 HOWTO(R_390_TLS_IE64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield, 149 bfd_elf_generic_reloc, "R_390_TLS_IE64", FALSE, 0, MINUS_ONE, FALSE), 150 HOWTO(R_390_TLS_IEENT, 1, 2, 32, TRUE, 0, complain_overflow_bitfield, 151 bfd_elf_generic_reloc, "R_390_TLS_IEENT", FALSE, 0, MINUS_ONE, TRUE), 152 EMPTY_HOWTO (R_390_TLS_LE32), /* Empty entry for R_390_TLS_LE32. */ 153 HOWTO(R_390_TLS_LE64, 0, 2, 32, FALSE, 0, complain_overflow_bitfield, 154 bfd_elf_generic_reloc, "R_390_TLS_LE64", FALSE, 0, MINUS_ONE, FALSE), 155 EMPTY_HOWTO (R_390_TLS_LDO32), /* Empty entry for R_390_TLS_LDO32. */ 156 HOWTO(R_390_TLS_LDO64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield, 157 bfd_elf_generic_reloc, "R_390_TLS_LDO64", FALSE, 0, MINUS_ONE, FALSE), 158 HOWTO(R_390_TLS_DTPMOD, 0, 4, 64, FALSE, 0, complain_overflow_bitfield, 159 bfd_elf_generic_reloc, "R_390_TLS_DTPMOD", FALSE, 0, MINUS_ONE, FALSE), 160 HOWTO(R_390_TLS_DTPOFF, 0, 4, 64, FALSE, 0, complain_overflow_bitfield, 161 bfd_elf_generic_reloc, "R_390_TLS_DTPOFF", FALSE, 0, MINUS_ONE, FALSE), 162 HOWTO(R_390_TLS_TPOFF, 0, 4, 64, FALSE, 0, complain_overflow_bitfield, 163 bfd_elf_generic_reloc, "R_390_TLS_TPOFF", FALSE, 0, MINUS_ONE, FALSE), 164 HOWTO(R_390_20, 0, 2, 20, FALSE, 8, complain_overflow_dont, 165 s390_elf_ldisp_reloc, "R_390_20", FALSE, 0,0x0fffff00, FALSE), 166 HOWTO(R_390_GOT20, 0, 2, 20, FALSE, 8, complain_overflow_dont, 167 s390_elf_ldisp_reloc, "R_390_GOT20", FALSE, 0,0x0fffff00, FALSE), 168 HOWTO(R_390_GOTPLT20, 0, 2, 20, FALSE, 8, complain_overflow_dont, 169 s390_elf_ldisp_reloc, "R_390_GOTPLT20", FALSE, 0,0x0fffff00, FALSE), 170 HOWTO(R_390_TLS_GOTIE20, 0, 2, 20, FALSE, 8, complain_overflow_dont, 171 s390_elf_ldisp_reloc, "R_390_TLS_GOTIE20", FALSE, 0,0x0fffff00, FALSE), 172 HOWTO(R_390_IRELATIVE, 0, 4, 64, FALSE, 0, complain_overflow_bitfield, 173 bfd_elf_generic_reloc, "R_390_IRELATIVE", FALSE, 0, MINUS_ONE, FALSE), 174 175 }; 176 177 /* GNU extension to record C++ vtable hierarchy. */ 178 static reloc_howto_type elf64_s390_vtinherit_howto = 179 HOWTO (R_390_GNU_VTINHERIT, 0,4,0,FALSE,0,complain_overflow_dont, NULL, "R_390_GNU_VTINHERIT", FALSE,0, 0, FALSE); 180 static reloc_howto_type elf64_s390_vtentry_howto = 181 HOWTO (R_390_GNU_VTENTRY, 0,4,0,FALSE,0,complain_overflow_dont, _bfd_elf_rel_vtable_reloc_fn,"R_390_GNU_VTENTRY", FALSE,0,0, FALSE); 182 183 static reloc_howto_type * 184 elf_s390_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, 185 bfd_reloc_code_real_type code) 186 { 187 switch (code) 188 { 189 case BFD_RELOC_NONE: 190 return &elf_howto_table[(int) R_390_NONE]; 191 case BFD_RELOC_8: 192 return &elf_howto_table[(int) R_390_8]; 193 case BFD_RELOC_390_12: 194 return &elf_howto_table[(int) R_390_12]; 195 case BFD_RELOC_16: 196 return &elf_howto_table[(int) R_390_16]; 197 case BFD_RELOC_32: 198 return &elf_howto_table[(int) R_390_32]; 199 case BFD_RELOC_CTOR: 200 return &elf_howto_table[(int) R_390_32]; 201 case BFD_RELOC_32_PCREL: 202 return &elf_howto_table[(int) R_390_PC32]; 203 case BFD_RELOC_390_GOT12: 204 return &elf_howto_table[(int) R_390_GOT12]; 205 case BFD_RELOC_32_GOT_PCREL: 206 return &elf_howto_table[(int) R_390_GOT32]; 207 case BFD_RELOC_390_PLT32: 208 return &elf_howto_table[(int) R_390_PLT32]; 209 case BFD_RELOC_390_COPY: 210 return &elf_howto_table[(int) R_390_COPY]; 211 case BFD_RELOC_390_GLOB_DAT: 212 return &elf_howto_table[(int) R_390_GLOB_DAT]; 213 case BFD_RELOC_390_JMP_SLOT: 214 return &elf_howto_table[(int) R_390_JMP_SLOT]; 215 case BFD_RELOC_390_RELATIVE: 216 return &elf_howto_table[(int) R_390_RELATIVE]; 217 case BFD_RELOC_32_GOTOFF: 218 return &elf_howto_table[(int) R_390_GOTOFF32]; 219 case BFD_RELOC_390_GOTPC: 220 return &elf_howto_table[(int) R_390_GOTPC]; 221 case BFD_RELOC_390_GOT16: 222 return &elf_howto_table[(int) R_390_GOT16]; 223 case BFD_RELOC_16_PCREL: 224 return &elf_howto_table[(int) R_390_PC16]; 225 case BFD_RELOC_390_PC16DBL: 226 return &elf_howto_table[(int) R_390_PC16DBL]; 227 case BFD_RELOC_390_PLT16DBL: 228 return &elf_howto_table[(int) R_390_PLT16DBL]; 229 case BFD_RELOC_390_PC32DBL: 230 return &elf_howto_table[(int) R_390_PC32DBL]; 231 case BFD_RELOC_390_PLT32DBL: 232 return &elf_howto_table[(int) R_390_PLT32DBL]; 233 case BFD_RELOC_390_GOTPCDBL: 234 return &elf_howto_table[(int) R_390_GOTPCDBL]; 235 case BFD_RELOC_64: 236 return &elf_howto_table[(int) R_390_64]; 237 case BFD_RELOC_64_PCREL: 238 return &elf_howto_table[(int) R_390_PC64]; 239 case BFD_RELOC_390_GOT64: 240 return &elf_howto_table[(int) R_390_GOT64]; 241 case BFD_RELOC_390_PLT64: 242 return &elf_howto_table[(int) R_390_PLT64]; 243 case BFD_RELOC_390_GOTENT: 244 return &elf_howto_table[(int) R_390_GOTENT]; 245 case BFD_RELOC_16_GOTOFF: 246 return &elf_howto_table[(int) R_390_GOTOFF16]; 247 case BFD_RELOC_390_GOTOFF64: 248 return &elf_howto_table[(int) R_390_GOTOFF64]; 249 case BFD_RELOC_390_GOTPLT12: 250 return &elf_howto_table[(int) R_390_GOTPLT12]; 251 case BFD_RELOC_390_GOTPLT16: 252 return &elf_howto_table[(int) R_390_GOTPLT16]; 253 case BFD_RELOC_390_GOTPLT32: 254 return &elf_howto_table[(int) R_390_GOTPLT32]; 255 case BFD_RELOC_390_GOTPLT64: 256 return &elf_howto_table[(int) R_390_GOTPLT64]; 257 case BFD_RELOC_390_GOTPLTENT: 258 return &elf_howto_table[(int) R_390_GOTPLTENT]; 259 case BFD_RELOC_390_PLTOFF16: 260 return &elf_howto_table[(int) R_390_PLTOFF16]; 261 case BFD_RELOC_390_PLTOFF32: 262 return &elf_howto_table[(int) R_390_PLTOFF32]; 263 case BFD_RELOC_390_PLTOFF64: 264 return &elf_howto_table[(int) R_390_PLTOFF64]; 265 case BFD_RELOC_390_TLS_LOAD: 266 return &elf_howto_table[(int) R_390_TLS_LOAD]; 267 case BFD_RELOC_390_TLS_GDCALL: 268 return &elf_howto_table[(int) R_390_TLS_GDCALL]; 269 case BFD_RELOC_390_TLS_LDCALL: 270 return &elf_howto_table[(int) R_390_TLS_LDCALL]; 271 case BFD_RELOC_390_TLS_GD64: 272 return &elf_howto_table[(int) R_390_TLS_GD64]; 273 case BFD_RELOC_390_TLS_GOTIE12: 274 return &elf_howto_table[(int) R_390_TLS_GOTIE12]; 275 case BFD_RELOC_390_TLS_GOTIE64: 276 return &elf_howto_table[(int) R_390_TLS_GOTIE64]; 277 case BFD_RELOC_390_TLS_LDM64: 278 return &elf_howto_table[(int) R_390_TLS_LDM64]; 279 case BFD_RELOC_390_TLS_IE64: 280 return &elf_howto_table[(int) R_390_TLS_IE64]; 281 case BFD_RELOC_390_TLS_IEENT: 282 return &elf_howto_table[(int) R_390_TLS_IEENT]; 283 case BFD_RELOC_390_TLS_LE64: 284 return &elf_howto_table[(int) R_390_TLS_LE64]; 285 case BFD_RELOC_390_TLS_LDO64: 286 return &elf_howto_table[(int) R_390_TLS_LDO64]; 287 case BFD_RELOC_390_TLS_DTPMOD: 288 return &elf_howto_table[(int) R_390_TLS_DTPMOD]; 289 case BFD_RELOC_390_TLS_DTPOFF: 290 return &elf_howto_table[(int) R_390_TLS_DTPOFF]; 291 case BFD_RELOC_390_TLS_TPOFF: 292 return &elf_howto_table[(int) R_390_TLS_TPOFF]; 293 case BFD_RELOC_390_20: 294 return &elf_howto_table[(int) R_390_20]; 295 case BFD_RELOC_390_GOT20: 296 return &elf_howto_table[(int) R_390_GOT20]; 297 case BFD_RELOC_390_GOTPLT20: 298 return &elf_howto_table[(int) R_390_GOTPLT20]; 299 case BFD_RELOC_390_TLS_GOTIE20: 300 return &elf_howto_table[(int) R_390_TLS_GOTIE20]; 301 case BFD_RELOC_390_IRELATIVE: 302 return &elf_howto_table[(int) R_390_IRELATIVE]; 303 case BFD_RELOC_VTABLE_INHERIT: 304 return &elf64_s390_vtinherit_howto; 305 case BFD_RELOC_VTABLE_ENTRY: 306 return &elf64_s390_vtentry_howto; 307 default: 308 break; 309 } 310 return 0; 311 } 312 313 static reloc_howto_type * 314 elf_s390_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, 315 const char *r_name) 316 { 317 unsigned int i; 318 319 for (i = 0; 320 i < sizeof (elf_howto_table) / sizeof (elf_howto_table[0]); 321 i++) 322 if (elf_howto_table[i].name != NULL 323 && strcasecmp (elf_howto_table[i].name, r_name) == 0) 324 return &elf_howto_table[i]; 325 326 if (strcasecmp (elf64_s390_vtinherit_howto.name, r_name) == 0) 327 return &elf64_s390_vtinherit_howto; 328 if (strcasecmp (elf64_s390_vtentry_howto.name, r_name) == 0) 329 return &elf64_s390_vtentry_howto; 330 331 return NULL; 332 } 333 334 /* We need to use ELF64_R_TYPE so we have our own copy of this function, 335 and elf64-s390.c has its own copy. */ 336 337 static void 338 elf_s390_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, 339 arelent *cache_ptr, 340 Elf_Internal_Rela *dst) 341 { 342 unsigned int r_type = ELF64_R_TYPE(dst->r_info); 343 switch (r_type) 344 { 345 case R_390_GNU_VTINHERIT: 346 cache_ptr->howto = &elf64_s390_vtinherit_howto; 347 break; 348 349 case R_390_GNU_VTENTRY: 350 cache_ptr->howto = &elf64_s390_vtentry_howto; 351 break; 352 353 default: 354 if (r_type >= sizeof (elf_howto_table) / sizeof (elf_howto_table[0])) 355 { 356 (*_bfd_error_handler) (_("%B: invalid relocation type %d"), 357 abfd, (int) r_type); 358 r_type = R_390_NONE; 359 } 360 cache_ptr->howto = &elf_howto_table[r_type]; 361 } 362 } 363 364 /* A relocation function which doesn't do anything. */ 365 static bfd_reloc_status_type 366 s390_tls_reloc (bfd *abfd ATTRIBUTE_UNUSED, 367 arelent *reloc_entry, 368 asymbol *symbol ATTRIBUTE_UNUSED, 369 void * data ATTRIBUTE_UNUSED, 370 asection *input_section, 371 bfd *output_bfd, 372 char **error_message ATTRIBUTE_UNUSED) 373 { 374 if (output_bfd) 375 reloc_entry->address += input_section->output_offset; 376 return bfd_reloc_ok; 377 } 378 379 /* Handle the large displacement relocs. */ 380 static bfd_reloc_status_type 381 s390_elf_ldisp_reloc (bfd *abfd, 382 arelent *reloc_entry, 383 asymbol *symbol, 384 void * data, 385 asection *input_section, 386 bfd *output_bfd, 387 char **error_message ATTRIBUTE_UNUSED) 388 { 389 reloc_howto_type *howto = reloc_entry->howto; 390 bfd_vma relocation; 391 bfd_vma insn; 392 393 if (output_bfd != (bfd *) NULL 394 && (symbol->flags & BSF_SECTION_SYM) == 0 395 && (! howto->partial_inplace 396 || reloc_entry->addend == 0)) 397 { 398 reloc_entry->address += input_section->output_offset; 399 return bfd_reloc_ok; 400 } 401 if (output_bfd != NULL) 402 return bfd_reloc_continue; 403 404 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section)) 405 return bfd_reloc_outofrange; 406 407 relocation = (symbol->value 408 + symbol->section->output_section->vma 409 + symbol->section->output_offset); 410 relocation += reloc_entry->addend; 411 if (howto->pc_relative) 412 { 413 relocation -= (input_section->output_section->vma 414 + input_section->output_offset); 415 relocation -= reloc_entry->address; 416 } 417 418 insn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address); 419 insn |= (relocation & 0xfff) << 16 | (relocation & 0xff000) >> 4; 420 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address); 421 422 if ((bfd_signed_vma) relocation < - 0x80000 423 || (bfd_signed_vma) relocation > 0x7ffff) 424 return bfd_reloc_overflow; 425 else 426 return bfd_reloc_ok; 427 } 428 429 static bfd_boolean 430 elf_s390_is_local_label_name (bfd *abfd, const char *name) 431 { 432 if (name[0] == '.' && (name[1] == 'X' || name[1] == 'L')) 433 return TRUE; 434 435 return _bfd_elf_is_local_label_name (abfd, name); 436 } 437 438 /* Functions for the 390 ELF linker. */ 439 440 /* The name of the dynamic interpreter. This is put in the .interp 441 section. */ 442 443 #define ELF_DYNAMIC_INTERPRETER "/lib/ld64.so.1" 444 445 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid 446 copying dynamic variables from a shared lib into an app's dynbss 447 section, and instead use a dynamic relocation to point into the 448 shared lib. */ 449 #define ELIMINATE_COPY_RELOCS 1 450 451 /* The size in bytes of the first entry in the procedure linkage table. */ 452 #define PLT_FIRST_ENTRY_SIZE 32 453 /* The size in bytes of an entry in the procedure linkage table. */ 454 #define PLT_ENTRY_SIZE 32 455 456 #define GOT_ENTRY_SIZE 8 457 458 #define RELA_ENTRY_SIZE sizeof (Elf64_External_Rela) 459 460 /* The first three entries in a procedure linkage table are reserved, 461 and the initial contents are unimportant (we zero them out). 462 Subsequent entries look like this. See the SVR4 ABI 386 463 supplement to see how this works. */ 464 465 /* For the s390, simple addr offset can only be 0 - 4096. 466 To use the full 16777216 TB address space, several instructions 467 are needed to load an address in a register and execute 468 a branch( or just saving the address) 469 470 Furthermore, only r 0 and 1 are free to use!!! */ 471 472 /* The first 3 words in the GOT are then reserved. 473 Word 0 is the address of the dynamic table. 474 Word 1 is a pointer to a structure describing the object 475 Word 2 is used to point to the loader entry address. 476 477 The code for PLT entries looks like this: 478 479 The GOT holds the address in the PLT to be executed. 480 The loader then gets: 481 24(15) = Pointer to the structure describing the object. 482 28(15) = Offset in symbol table 483 The loader must then find the module where the function is 484 and insert the address in the GOT. 485 486 PLT1: LARL 1,<fn>@GOTENT # 6 bytes Load address of GOT entry in r1 487 LG 1,0(1) # 6 bytes Load address from GOT in r1 488 BCR 15,1 # 2 bytes Jump to address 489 RET1: BASR 1,0 # 2 bytes Return from GOT 1st time 490 LGF 1,12(1) # 6 bytes Load offset in symbl table in r1 491 BRCL 15,-x # 6 bytes Jump to start of PLT 492 .long ? # 4 bytes offset into .rela.plt 493 494 Total = 32 bytes per PLT entry 495 Fixup at offset 2: relative address to GOT entry 496 Fixup at offset 22: relative branch to PLT0 497 Fixup at offset 28: 32 bit offset into .rela.plt 498 499 A 32 bit offset into the symbol table is enough. It allows for 500 .rela.plt sections up to a size of 2 gigabyte. A single dynamic 501 object (the main program, any shared library) is limited to 4GB in 502 size. Having a .rela.plt of 2GB would already make the .plt 503 section bigger than 8GB. */ 504 505 static const bfd_byte elf_s390x_plt_entry[PLT_ENTRY_SIZE] = 506 { 507 0xc0, 0x10, 0x00, 0x00, 0x00, 0x00, /* larl %r1,. */ 508 0xe3, 0x10, 0x10, 0x00, 0x00, 0x04, /* lg %r1,0(%r1) */ 509 0x07, 0xf1, /* br %r1 */ 510 0x0d, 0x10, /* basr %r1,%r0 */ 511 0xe3, 0x10, 0x10, 0x0c, 0x00, 0x14, /* lgf %r1,12(%r1) */ 512 0xc0, 0xf4, 0x00, 0x00, 0x00, 0x00, /* jg first plt */ 513 0x00, 0x00, 0x00, 0x00 /* .long 0x00000000 */ 514 }; 515 516 /* The first PLT entry pushes the offset into the symbol table 517 from R1 onto the stack at 56(15) and the loader object info 518 at 48(15), loads the loader address in R1 and jumps to it. */ 519 520 /* The first entry in the PLT: 521 522 PLT0: 523 STG 1,56(15) # r1 contains the offset into the symbol table 524 LARL 1,_GLOBAL_OFFSET_TABLE # load address of global offset table 525 MVC 48(8,15),8(1) # move loader ino (object struct address) to stack 526 LG 1,16(1) # get entry address of loader 527 BCR 15,1 # jump to loader 528 529 Fixup at offset 8: relative address to start of GOT. */ 530 531 static const bfd_byte elf_s390x_first_plt_entry[PLT_FIRST_ENTRY_SIZE] = 532 { 533 0xe3, 0x10, 0xf0, 0x38, 0x00, 0x24, /* stg %r1,56(%r15) */ 534 0xc0, 0x10, 0x00, 0x00, 0x00, 0x00, /* larl %r1,. */ 535 0xd2, 0x07, 0xf0, 0x30, 0x10, 0x08, /* mvc 48(8,%r15),8(%r1) */ 536 0xe3, 0x10, 0x10, 0x10, 0x00, 0x04, /* lg %r1,16(%r1) */ 537 0x07, 0xf1, /* br %r1 */ 538 0x07, 0x00, /* nopr %r0 */ 539 0x07, 0x00, /* nopr %r0 */ 540 0x07, 0x00 /* nopr %r0 */ 541 }; 542 543 544 /* s390 ELF linker hash entry. */ 545 546 struct elf_s390_link_hash_entry 547 { 548 struct elf_link_hash_entry elf; 549 550 /* Track dynamic relocs copied for this symbol. */ 551 struct elf_dyn_relocs *dyn_relocs; 552 553 /* Number of GOTPLT references for a function. */ 554 bfd_signed_vma gotplt_refcount; 555 556 #define GOT_UNKNOWN 0 557 #define GOT_NORMAL 1 558 #define GOT_TLS_GD 2 559 #define GOT_TLS_IE 3 560 #define GOT_TLS_IE_NLT 3 561 unsigned char tls_type; 562 563 /* For pointer equality reasons we might need to change the symbol 564 type from STT_GNU_IFUNC to STT_FUNC together with its value and 565 section entry. So after alloc_dynrelocs only these values should 566 be used. In order to check whether a symbol is IFUNC use 567 s390_is_ifunc_symbol_p. */ 568 bfd_vma ifunc_resolver_address; 569 asection *ifunc_resolver_section; 570 }; 571 572 #define elf_s390_hash_entry(ent) \ 573 ((struct elf_s390_link_hash_entry *)(ent)) 574 575 /* This structure represents an entry in the local PLT list needed for 576 local IFUNC symbols. */ 577 struct plt_entry 578 { 579 /* The section of the local symbol. 580 Set in relocate_section and used in finish_dynamic_sections. */ 581 asection *sec; 582 583 union 584 { 585 bfd_signed_vma refcount; 586 bfd_vma offset; 587 } plt; 588 }; 589 590 /* NOTE: Keep this structure in sync with 591 the one declared in elf32-s390.c. */ 592 struct elf_s390_obj_tdata 593 { 594 struct elf_obj_tdata root; 595 596 /* A local PLT is needed for ifunc symbols. */ 597 struct plt_entry *local_plt; 598 599 /* TLS type for each local got entry. */ 600 char *local_got_tls_type; 601 }; 602 603 #define elf_s390_tdata(abfd) \ 604 ((struct elf_s390_obj_tdata *) (abfd)->tdata.any) 605 606 #define elf_s390_local_plt(abfd) \ 607 (elf_s390_tdata (abfd)->local_plt) 608 609 #define elf_s390_local_got_tls_type(abfd) \ 610 (elf_s390_tdata (abfd)->local_got_tls_type) 611 612 #define is_s390_elf(bfd) \ 613 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \ 614 && elf_tdata (bfd) != NULL \ 615 && elf_object_id (bfd) == S390_ELF_DATA) 616 617 static bfd_boolean 618 elf_s390_mkobject (bfd *abfd) 619 { 620 return bfd_elf_allocate_object (abfd, sizeof (struct elf_s390_obj_tdata), 621 S390_ELF_DATA); 622 } 623 624 static bfd_boolean 625 elf_s390_object_p (bfd *abfd) 626 { 627 /* Set the right machine number for an s390 elf32 file. */ 628 return bfd_default_set_arch_mach (abfd, bfd_arch_s390, bfd_mach_s390_64); 629 } 630 631 /* s390 ELF linker hash table. */ 632 633 struct elf_s390_link_hash_table 634 { 635 struct elf_link_hash_table elf; 636 637 /* Short-cuts to get to dynamic linker sections. */ 638 asection *sdynbss; 639 asection *srelbss; 640 asection *irelifunc; 641 642 union { 643 bfd_signed_vma refcount; 644 bfd_vma offset; 645 } tls_ldm_got; 646 647 /* Small local sym cache. */ 648 struct sym_cache sym_cache; 649 }; 650 651 /* Get the s390 ELF linker hash table from a link_info structure. */ 652 653 #define elf_s390_hash_table(p) \ 654 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \ 655 == S390_ELF_DATA ? ((struct elf_s390_link_hash_table *) ((p)->hash)) : NULL) 656 657 #define ELF64 1 658 #include "elf-s390-common.c" 659 660 /* Create an entry in an s390 ELF linker hash table. */ 661 662 static struct bfd_hash_entry * 663 link_hash_newfunc (struct bfd_hash_entry *entry, 664 struct bfd_hash_table *table, 665 const char *string) 666 { 667 /* Allocate the structure if it has not already been allocated by a 668 subclass. */ 669 if (entry == NULL) 670 { 671 entry = bfd_hash_allocate (table, 672 sizeof (struct elf_s390_link_hash_entry)); 673 if (entry == NULL) 674 return entry; 675 } 676 677 /* Call the allocation method of the superclass. */ 678 entry = _bfd_elf_link_hash_newfunc (entry, table, string); 679 if (entry != NULL) 680 { 681 struct elf_s390_link_hash_entry *eh; 682 683 eh = (struct elf_s390_link_hash_entry *) entry; 684 eh->dyn_relocs = NULL; 685 eh->gotplt_refcount = 0; 686 eh->tls_type = GOT_UNKNOWN; 687 eh->ifunc_resolver_address = 0; 688 eh->ifunc_resolver_section = NULL; 689 } 690 691 return entry; 692 } 693 694 /* Create an s390 ELF linker hash table. */ 695 696 static struct bfd_link_hash_table * 697 elf_s390_link_hash_table_create (bfd *abfd) 698 { 699 struct elf_s390_link_hash_table *ret; 700 bfd_size_type amt = sizeof (struct elf_s390_link_hash_table); 701 702 ret = (struct elf_s390_link_hash_table *) bfd_malloc (amt); 703 if (ret == NULL) 704 return NULL; 705 706 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc, 707 sizeof (struct elf_s390_link_hash_entry), 708 S390_ELF_DATA)) 709 { 710 free (ret); 711 return NULL; 712 } 713 714 ret->elf.sgot = NULL; 715 ret->elf.sgotplt = NULL; 716 ret->elf.srelgot = NULL; 717 ret->elf.splt = NULL; 718 ret->elf.srelplt = NULL; 719 ret->sdynbss = NULL; 720 ret->srelbss = NULL; 721 ret->tls_ldm_got.refcount = 0; 722 ret->sym_cache.abfd = NULL; 723 724 return &ret->elf.root; 725 } 726 727 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up 728 shortcuts to them in our hash table. */ 729 730 static bfd_boolean 731 create_got_section (bfd *dynobj, 732 struct bfd_link_info *info) 733 { 734 struct elf_s390_link_hash_table *htab; 735 736 if (! _bfd_elf_create_got_section (dynobj, info)) 737 return FALSE; 738 739 htab = elf_s390_hash_table (info); 740 if (htab == NULL) 741 return FALSE; 742 743 htab->elf.sgot = bfd_get_linker_section (dynobj, ".got"); 744 htab->elf.sgotplt = bfd_get_linker_section (dynobj, ".got.plt"); 745 htab->elf.srelgot = bfd_get_linker_section (dynobj, ".rela.got"); 746 if (!htab->elf.sgot || !htab->elf.sgotplt || !htab->elf.srelgot) 747 abort (); 748 return TRUE; 749 } 750 751 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and 752 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our 753 hash table. */ 754 755 static bfd_boolean 756 elf_s390_create_dynamic_sections (bfd *dynobj, 757 struct bfd_link_info *info) 758 { 759 struct elf_s390_link_hash_table *htab; 760 761 htab = elf_s390_hash_table (info); 762 if (htab == NULL) 763 return FALSE; 764 765 if (!htab->elf.sgot && !create_got_section (dynobj, info)) 766 return FALSE; 767 768 if (!_bfd_elf_create_dynamic_sections (dynobj, info)) 769 return FALSE; 770 771 htab->elf.splt = bfd_get_linker_section (dynobj, ".plt"); 772 htab->elf.srelplt = bfd_get_linker_section (dynobj, ".rela.plt"); 773 htab->sdynbss = bfd_get_linker_section (dynobj, ".dynbss"); 774 if (!info->shared) 775 htab->srelbss = bfd_get_linker_section (dynobj, ".rela.bss"); 776 777 if (!htab->elf.splt || !htab->elf.srelplt || !htab->sdynbss 778 || (!info->shared && !htab->srelbss)) 779 abort (); 780 781 return TRUE; 782 } 783 784 /* Copy the extra info we tack onto an elf_link_hash_entry. */ 785 786 static void 787 elf_s390_copy_indirect_symbol (struct bfd_link_info *info, 788 struct elf_link_hash_entry *dir, 789 struct elf_link_hash_entry *ind) 790 { 791 struct elf_s390_link_hash_entry *edir, *eind; 792 793 edir = (struct elf_s390_link_hash_entry *) dir; 794 eind = (struct elf_s390_link_hash_entry *) ind; 795 796 if (eind->dyn_relocs != NULL) 797 { 798 if (edir->dyn_relocs != NULL) 799 { 800 struct elf_dyn_relocs **pp; 801 struct elf_dyn_relocs *p; 802 803 /* Add reloc counts against the indirect sym to the direct sym 804 list. Merge any entries against the same section. */ 805 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; ) 806 { 807 struct elf_dyn_relocs *q; 808 809 for (q = edir->dyn_relocs; q != NULL; q = q->next) 810 if (q->sec == p->sec) 811 { 812 q->pc_count += p->pc_count; 813 q->count += p->count; 814 *pp = p->next; 815 break; 816 } 817 if (q == NULL) 818 pp = &p->next; 819 } 820 *pp = edir->dyn_relocs; 821 } 822 823 edir->dyn_relocs = eind->dyn_relocs; 824 eind->dyn_relocs = NULL; 825 } 826 827 if (ind->root.type == bfd_link_hash_indirect 828 && dir->got.refcount <= 0) 829 { 830 edir->tls_type = eind->tls_type; 831 eind->tls_type = GOT_UNKNOWN; 832 } 833 834 if (ELIMINATE_COPY_RELOCS 835 && ind->root.type != bfd_link_hash_indirect 836 && dir->dynamic_adjusted) 837 { 838 /* If called to transfer flags for a weakdef during processing 839 of elf_adjust_dynamic_symbol, don't copy non_got_ref. 840 We clear it ourselves for ELIMINATE_COPY_RELOCS. */ 841 dir->ref_dynamic |= ind->ref_dynamic; 842 dir->ref_regular |= ind->ref_regular; 843 dir->ref_regular_nonweak |= ind->ref_regular_nonweak; 844 dir->needs_plt |= ind->needs_plt; 845 } 846 else 847 _bfd_elf_link_hash_copy_indirect (info, dir, ind); 848 } 849 850 static int 851 elf_s390_tls_transition (struct bfd_link_info *info, 852 int r_type, 853 int is_local) 854 { 855 if (info->shared) 856 return r_type; 857 858 switch (r_type) 859 { 860 case R_390_TLS_GD64: 861 case R_390_TLS_IE64: 862 if (is_local) 863 return R_390_TLS_LE64; 864 return R_390_TLS_IE64; 865 case R_390_TLS_GOTIE64: 866 if (is_local) 867 return R_390_TLS_LE64; 868 return R_390_TLS_GOTIE64; 869 case R_390_TLS_LDM64: 870 return R_390_TLS_LE64; 871 } 872 873 return r_type; 874 } 875 876 /* Look through the relocs for a section during the first phase, and 877 allocate space in the global offset table or procedure linkage 878 table. */ 879 880 static bfd_boolean 881 elf_s390_check_relocs (bfd *abfd, 882 struct bfd_link_info *info, 883 asection *sec, 884 const Elf_Internal_Rela *relocs) 885 { 886 struct elf_s390_link_hash_table *htab; 887 Elf_Internal_Shdr *symtab_hdr; 888 struct elf_link_hash_entry **sym_hashes; 889 const Elf_Internal_Rela *rel; 890 const Elf_Internal_Rela *rel_end; 891 asection *sreloc; 892 bfd_signed_vma *local_got_refcounts; 893 int tls_type, old_tls_type; 894 895 if (info->relocatable) 896 return TRUE; 897 898 BFD_ASSERT (is_s390_elf (abfd)); 899 900 htab = elf_s390_hash_table (info); 901 if (htab == NULL) 902 return FALSE; 903 904 symtab_hdr = &elf_symtab_hdr (abfd); 905 sym_hashes = elf_sym_hashes (abfd); 906 local_got_refcounts = elf_local_got_refcounts (abfd); 907 908 sreloc = NULL; 909 910 rel_end = relocs + sec->reloc_count; 911 for (rel = relocs; rel < rel_end; rel++) 912 { 913 unsigned int r_type; 914 unsigned long r_symndx; 915 struct elf_link_hash_entry *h; 916 Elf_Internal_Sym *isym; 917 918 r_symndx = ELF64_R_SYM (rel->r_info); 919 920 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr)) 921 { 922 (*_bfd_error_handler) (_("%B: bad symbol index: %d"), 923 abfd, 924 r_symndx); 925 return FALSE; 926 } 927 928 if (r_symndx < symtab_hdr->sh_info) 929 { 930 /* A local symbol. */ 931 isym = bfd_sym_from_r_symndx (&htab->sym_cache, 932 abfd, r_symndx); 933 if (isym == NULL) 934 return FALSE; 935 936 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC) 937 { 938 struct plt_entry *plt; 939 940 if (htab->elf.dynobj == NULL) 941 htab->elf.dynobj = abfd; 942 943 if (!s390_elf_create_ifunc_sections (htab->elf.dynobj, info)) 944 return FALSE; 945 946 if (local_got_refcounts == NULL) 947 { 948 if (!elf_s390_allocate_local_syminfo (abfd, symtab_hdr)) 949 return FALSE; 950 local_got_refcounts = elf_local_got_refcounts (abfd); 951 } 952 plt = elf_s390_local_plt (abfd); 953 plt[r_symndx].plt.refcount++; 954 } 955 h = NULL; 956 } 957 else 958 { 959 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 960 while (h->root.type == bfd_link_hash_indirect 961 || h->root.type == bfd_link_hash_warning) 962 h = (struct elf_link_hash_entry *) h->root.u.i.link; 963 } 964 965 /* Create got section and local_got_refcounts array if they 966 are needed. */ 967 r_type = elf_s390_tls_transition (info, 968 ELF64_R_TYPE (rel->r_info), 969 h == NULL); 970 switch (r_type) 971 { 972 case R_390_GOT12: 973 case R_390_GOT16: 974 case R_390_GOT20: 975 case R_390_GOT32: 976 case R_390_GOT64: 977 case R_390_GOTENT: 978 case R_390_GOTPLT12: 979 case R_390_GOTPLT16: 980 case R_390_GOTPLT20: 981 case R_390_GOTPLT32: 982 case R_390_GOTPLT64: 983 case R_390_GOTPLTENT: 984 case R_390_TLS_GD64: 985 case R_390_TLS_GOTIE12: 986 case R_390_TLS_GOTIE20: 987 case R_390_TLS_GOTIE64: 988 case R_390_TLS_IEENT: 989 case R_390_TLS_IE64: 990 case R_390_TLS_LDM64: 991 if (h == NULL 992 && local_got_refcounts == NULL) 993 { 994 if (!elf_s390_allocate_local_syminfo (abfd, symtab_hdr)) 995 return FALSE; 996 local_got_refcounts = elf_local_got_refcounts (abfd); 997 } 998 999 /* Fall through. */ 1000 case R_390_GOTOFF16: 1001 case R_390_GOTOFF32: 1002 case R_390_GOTOFF64: 1003 case R_390_GOTPC: 1004 case R_390_GOTPCDBL: 1005 if (htab->elf.sgot == NULL) 1006 { 1007 if (htab->elf.dynobj == NULL) 1008 htab->elf.dynobj = abfd; 1009 if (!create_got_section (htab->elf.dynobj, info)) 1010 return FALSE; 1011 } 1012 } 1013 1014 if (h != NULL) 1015 { 1016 if (htab->elf.dynobj == NULL) 1017 htab->elf.dynobj = abfd; 1018 if (!s390_elf_create_ifunc_sections (htab->elf.dynobj, info)) 1019 return FALSE; 1020 1021 /* Make sure an IFUNC symbol defined in a non-shared object 1022 always gets a PLT slot. */ 1023 if (s390_is_ifunc_symbol_p (h) && h->def_regular) 1024 { 1025 /* The symbol is called by the dynamic loader in order 1026 to resolve the relocation. So it is in fact also 1027 referenced. */ 1028 h->ref_regular = 1; 1029 h->needs_plt = 1; 1030 } 1031 } 1032 1033 switch (r_type) 1034 { 1035 case R_390_GOTOFF16: 1036 case R_390_GOTOFF32: 1037 case R_390_GOTOFF64: 1038 case R_390_GOTPC: 1039 case R_390_GOTPCDBL: 1040 /* These relocs do not need a GOT slot. They just load the 1041 GOT pointer itself or address something else relative to 1042 the GOT. Since the GOT pointer has been set up above we 1043 are done. */ 1044 break; 1045 1046 case R_390_PLT16DBL: 1047 case R_390_PLT32: 1048 case R_390_PLT32DBL: 1049 case R_390_PLT64: 1050 case R_390_PLTOFF16: 1051 case R_390_PLTOFF32: 1052 case R_390_PLTOFF64: 1053 /* This symbol requires a procedure linkage table entry. We 1054 actually build the entry in adjust_dynamic_symbol, 1055 because this might be a case of linking PIC code which is 1056 never referenced by a dynamic object, in which case we 1057 don't need to generate a procedure linkage table entry 1058 after all. */ 1059 1060 /* If this is a local symbol, we resolve it directly without 1061 creating a procedure linkage table entry. */ 1062 if (h != NULL) 1063 { 1064 h->needs_plt = 1; 1065 h->plt.refcount += 1; 1066 } 1067 break; 1068 1069 case R_390_GOTPLT12: 1070 case R_390_GOTPLT16: 1071 case R_390_GOTPLT20: 1072 case R_390_GOTPLT32: 1073 case R_390_GOTPLT64: 1074 case R_390_GOTPLTENT: 1075 /* This symbol requires either a procedure linkage table entry 1076 or an entry in the local got. We actually build the entry 1077 in adjust_dynamic_symbol because whether this is really a 1078 global reference can change and with it the fact if we have 1079 to create a plt entry or a local got entry. To be able to 1080 make a once global symbol a local one we have to keep track 1081 of the number of gotplt references that exist for this 1082 symbol. */ 1083 if (h != NULL) 1084 { 1085 ((struct elf_s390_link_hash_entry *) h)->gotplt_refcount++; 1086 h->needs_plt = 1; 1087 h->plt.refcount += 1; 1088 } 1089 else 1090 local_got_refcounts[r_symndx] += 1; 1091 break; 1092 1093 case R_390_TLS_LDM64: 1094 htab->tls_ldm_got.refcount += 1; 1095 break; 1096 1097 case R_390_TLS_IE64: 1098 case R_390_TLS_GOTIE12: 1099 case R_390_TLS_GOTIE20: 1100 case R_390_TLS_GOTIE64: 1101 case R_390_TLS_IEENT: 1102 if (info->shared) 1103 info->flags |= DF_STATIC_TLS; 1104 /* Fall through */ 1105 1106 case R_390_GOT12: 1107 case R_390_GOT16: 1108 case R_390_GOT20: 1109 case R_390_GOT32: 1110 case R_390_GOT64: 1111 case R_390_GOTENT: 1112 case R_390_TLS_GD64: 1113 /* This symbol requires a global offset table entry. */ 1114 switch (r_type) 1115 { 1116 default: 1117 case R_390_GOT12: 1118 case R_390_GOT16: 1119 case R_390_GOT20: 1120 case R_390_GOT32: 1121 case R_390_GOTENT: 1122 tls_type = GOT_NORMAL; 1123 break; 1124 case R_390_TLS_GD64: 1125 tls_type = GOT_TLS_GD; 1126 break; 1127 case R_390_TLS_IE64: 1128 case R_390_TLS_GOTIE64: 1129 tls_type = GOT_TLS_IE; 1130 break; 1131 case R_390_TLS_GOTIE12: 1132 case R_390_TLS_GOTIE20: 1133 case R_390_TLS_IEENT: 1134 tls_type = GOT_TLS_IE_NLT; 1135 break; 1136 } 1137 1138 if (h != NULL) 1139 { 1140 h->got.refcount += 1; 1141 old_tls_type = elf_s390_hash_entry(h)->tls_type; 1142 } 1143 else 1144 { 1145 local_got_refcounts[r_symndx] += 1; 1146 old_tls_type = elf_s390_local_got_tls_type (abfd) [r_symndx]; 1147 } 1148 /* If a TLS symbol is accessed using IE at least once, 1149 there is no point to use dynamic model for it. */ 1150 if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN) 1151 { 1152 if (old_tls_type == GOT_NORMAL || tls_type == GOT_NORMAL) 1153 { 1154 (*_bfd_error_handler) 1155 (_("%B: `%s' accessed both as normal and thread local symbol"), 1156 abfd, h->root.root.string); 1157 return FALSE; 1158 } 1159 if (old_tls_type > tls_type) 1160 tls_type = old_tls_type; 1161 } 1162 1163 if (old_tls_type != tls_type) 1164 { 1165 if (h != NULL) 1166 elf_s390_hash_entry (h)->tls_type = tls_type; 1167 else 1168 elf_s390_local_got_tls_type (abfd) [r_symndx] = tls_type; 1169 } 1170 1171 if (r_type != R_390_TLS_IE64) 1172 break; 1173 /* Fall through */ 1174 1175 case R_390_TLS_LE64: 1176 if (!info->shared) 1177 break; 1178 info->flags |= DF_STATIC_TLS; 1179 /* Fall through */ 1180 1181 case R_390_8: 1182 case R_390_16: 1183 case R_390_32: 1184 case R_390_64: 1185 case R_390_PC16: 1186 case R_390_PC16DBL: 1187 case R_390_PC32: 1188 case R_390_PC32DBL: 1189 case R_390_PC64: 1190 if (h != NULL) 1191 { 1192 /* If this reloc is in a read-only section, we might 1193 need a copy reloc. We can't check reliably at this 1194 stage whether the section is read-only, as input 1195 sections have not yet been mapped to output sections. 1196 Tentatively set the flag for now, and correct in 1197 adjust_dynamic_symbol. */ 1198 h->non_got_ref = 1; 1199 1200 if (!info->shared) 1201 { 1202 /* We may need a .plt entry if the function this reloc 1203 refers to is in a shared lib. */ 1204 h->plt.refcount += 1; 1205 } 1206 } 1207 1208 /* If we are creating a shared library, and this is a reloc 1209 against a global symbol, or a non PC relative reloc 1210 against a local symbol, then we need to copy the reloc 1211 into the shared library. However, if we are linking with 1212 -Bsymbolic, we do not need to copy a reloc against a 1213 global symbol which is defined in an object we are 1214 including in the link (i.e., DEF_REGULAR is set). At 1215 this point we have not seen all the input files, so it is 1216 possible that DEF_REGULAR is not set now but will be set 1217 later (it is never cleared). In case of a weak definition, 1218 DEF_REGULAR may be cleared later by a strong definition in 1219 a shared library. We account for that possibility below by 1220 storing information in the relocs_copied field of the hash 1221 table entry. A similar situation occurs when creating 1222 shared libraries and symbol visibility changes render the 1223 symbol local. 1224 1225 If on the other hand, we are creating an executable, we 1226 may need to keep relocations for symbols satisfied by a 1227 dynamic library if we manage to avoid copy relocs for the 1228 symbol. */ 1229 if ((info->shared 1230 && (sec->flags & SEC_ALLOC) != 0 1231 && ((ELF64_R_TYPE (rel->r_info) != R_390_PC16 1232 && ELF64_R_TYPE (rel->r_info) != R_390_PC16DBL 1233 && ELF64_R_TYPE (rel->r_info) != R_390_PC32 1234 && ELF64_R_TYPE (rel->r_info) != R_390_PC32DBL 1235 && ELF64_R_TYPE (rel->r_info) != R_390_PC64) 1236 || (h != NULL 1237 && (! SYMBOLIC_BIND (info, h) 1238 || h->root.type == bfd_link_hash_defweak 1239 || !h->def_regular)))) 1240 || (ELIMINATE_COPY_RELOCS 1241 && !info->shared 1242 && (sec->flags & SEC_ALLOC) != 0 1243 && h != NULL 1244 && (h->root.type == bfd_link_hash_defweak 1245 || !h->def_regular))) 1246 { 1247 struct elf_dyn_relocs *p; 1248 struct elf_dyn_relocs **head; 1249 1250 /* We must copy these reloc types into the output file. 1251 Create a reloc section in dynobj and make room for 1252 this reloc. */ 1253 if (sreloc == NULL) 1254 { 1255 if (htab->elf.dynobj == NULL) 1256 htab->elf.dynobj = abfd; 1257 1258 sreloc = _bfd_elf_make_dynamic_reloc_section 1259 (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE); 1260 1261 if (sreloc == NULL) 1262 return FALSE; 1263 } 1264 1265 /* If this is a global symbol, we count the number of 1266 relocations we need for this symbol. */ 1267 if (h != NULL) 1268 { 1269 head = &((struct elf_s390_link_hash_entry *) h)->dyn_relocs; 1270 } 1271 else 1272 { 1273 /* Track dynamic relocs needed for local syms too. 1274 We really need local syms available to do this 1275 easily. Oh well. */ 1276 asection *s; 1277 void *vpp; 1278 1279 isym = bfd_sym_from_r_symndx (&htab->sym_cache, 1280 abfd, r_symndx); 1281 if (isym == NULL) 1282 return FALSE; 1283 1284 s = bfd_section_from_elf_index (abfd, isym->st_shndx); 1285 if (s == NULL) 1286 s = sec; 1287 1288 vpp = &elf_section_data (s)->local_dynrel; 1289 head = (struct elf_dyn_relocs **) vpp; 1290 } 1291 1292 p = *head; 1293 if (p == NULL || p->sec != sec) 1294 { 1295 bfd_size_type amt = sizeof *p; 1296 p = ((struct elf_dyn_relocs *) 1297 bfd_alloc (htab->elf.dynobj, amt)); 1298 if (p == NULL) 1299 return FALSE; 1300 p->next = *head; 1301 *head = p; 1302 p->sec = sec; 1303 p->count = 0; 1304 p->pc_count = 0; 1305 } 1306 1307 p->count += 1; 1308 if (ELF64_R_TYPE (rel->r_info) == R_390_PC16 1309 || ELF64_R_TYPE (rel->r_info) == R_390_PC16DBL 1310 || ELF64_R_TYPE (rel->r_info) == R_390_PC32 1311 || ELF64_R_TYPE (rel->r_info) == R_390_PC32DBL 1312 || ELF64_R_TYPE (rel->r_info) == R_390_PC64) 1313 p->pc_count += 1; 1314 } 1315 break; 1316 1317 /* This relocation describes the C++ object vtable hierarchy. 1318 Reconstruct it for later use during GC. */ 1319 case R_390_GNU_VTINHERIT: 1320 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) 1321 return FALSE; 1322 break; 1323 1324 /* This relocation describes which C++ vtable entries are actually 1325 used. Record for later use during GC. */ 1326 case R_390_GNU_VTENTRY: 1327 BFD_ASSERT (h != NULL); 1328 if (h != NULL 1329 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend)) 1330 return FALSE; 1331 break; 1332 1333 default: 1334 break; 1335 } 1336 } 1337 1338 return TRUE; 1339 } 1340 1341 /* Return the section that should be marked against GC for a given 1342 relocation. */ 1343 1344 static asection * 1345 elf_s390_gc_mark_hook (asection *sec, 1346 struct bfd_link_info *info, 1347 Elf_Internal_Rela *rel, 1348 struct elf_link_hash_entry *h, 1349 Elf_Internal_Sym *sym) 1350 { 1351 if (h != NULL) 1352 switch (ELF64_R_TYPE (rel->r_info)) 1353 { 1354 case R_390_GNU_VTINHERIT: 1355 case R_390_GNU_VTENTRY: 1356 return NULL; 1357 } 1358 1359 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym); 1360 } 1361 1362 /* Update the got entry reference counts for the section being removed. */ 1363 1364 static bfd_boolean 1365 elf_s390_gc_sweep_hook (bfd *abfd, 1366 struct bfd_link_info *info, 1367 asection *sec, 1368 const Elf_Internal_Rela *relocs) 1369 { 1370 struct elf_s390_link_hash_table *htab; 1371 Elf_Internal_Shdr *symtab_hdr; 1372 struct elf_link_hash_entry **sym_hashes; 1373 bfd_signed_vma *local_got_refcounts; 1374 const Elf_Internal_Rela *rel, *relend; 1375 1376 if (info->relocatable) 1377 return TRUE; 1378 1379 htab = elf_s390_hash_table (info); 1380 if (htab == NULL) 1381 return FALSE; 1382 1383 elf_section_data (sec)->local_dynrel = NULL; 1384 1385 symtab_hdr = &elf_symtab_hdr (abfd); 1386 sym_hashes = elf_sym_hashes (abfd); 1387 local_got_refcounts = elf_local_got_refcounts (abfd); 1388 1389 relend = relocs + sec->reloc_count; 1390 for (rel = relocs; rel < relend; rel++) 1391 { 1392 unsigned long r_symndx; 1393 unsigned int r_type; 1394 struct elf_link_hash_entry *h = NULL; 1395 1396 r_symndx = ELF64_R_SYM (rel->r_info); 1397 if (r_symndx >= symtab_hdr->sh_info) 1398 { 1399 struct elf_s390_link_hash_entry *eh; 1400 struct elf_dyn_relocs **pp; 1401 struct elf_dyn_relocs *p; 1402 1403 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 1404 while (h->root.type == bfd_link_hash_indirect 1405 || h->root.type == bfd_link_hash_warning) 1406 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1407 eh = (struct elf_s390_link_hash_entry *) h; 1408 1409 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next) 1410 if (p->sec == sec) 1411 { 1412 /* Everything must go for SEC. */ 1413 *pp = p->next; 1414 break; 1415 } 1416 } 1417 else 1418 { 1419 Elf_Internal_Sym *isym; 1420 1421 /* A local symbol. */ 1422 isym = bfd_sym_from_r_symndx (&htab->sym_cache, 1423 abfd, r_symndx); 1424 if (isym == NULL) 1425 return FALSE; 1426 1427 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC) 1428 { 1429 struct plt_entry *plt = elf_s390_local_plt (abfd); 1430 if (plt[r_symndx].plt.refcount > 0) 1431 plt[r_symndx].plt.refcount--; 1432 } 1433 } 1434 1435 r_type = ELF64_R_TYPE (rel->r_info); 1436 r_type = elf_s390_tls_transition (info, r_type, h != NULL); 1437 switch (r_type) 1438 { 1439 case R_390_TLS_LDM64: 1440 if (htab->tls_ldm_got.refcount > 0) 1441 htab->tls_ldm_got.refcount -= 1; 1442 break; 1443 1444 case R_390_TLS_GD64: 1445 case R_390_TLS_IE64: 1446 case R_390_TLS_GOTIE12: 1447 case R_390_TLS_GOTIE20: 1448 case R_390_TLS_GOTIE64: 1449 case R_390_TLS_IEENT: 1450 case R_390_GOT12: 1451 case R_390_GOT16: 1452 case R_390_GOT20: 1453 case R_390_GOT32: 1454 case R_390_GOT64: 1455 case R_390_GOTOFF16: 1456 case R_390_GOTOFF32: 1457 case R_390_GOTOFF64: 1458 case R_390_GOTPC: 1459 case R_390_GOTPCDBL: 1460 case R_390_GOTENT: 1461 if (h != NULL) 1462 { 1463 if (h->got.refcount > 0) 1464 h->got.refcount -= 1; 1465 } 1466 else if (local_got_refcounts != NULL) 1467 { 1468 if (local_got_refcounts[r_symndx] > 0) 1469 local_got_refcounts[r_symndx] -= 1; 1470 } 1471 break; 1472 1473 case R_390_8: 1474 case R_390_12: 1475 case R_390_16: 1476 case R_390_20: 1477 case R_390_32: 1478 case R_390_64: 1479 case R_390_PC16: 1480 case R_390_PC16DBL: 1481 case R_390_PC32: 1482 case R_390_PC32DBL: 1483 case R_390_PC64: 1484 if (info->shared) 1485 break; 1486 /* Fall through */ 1487 1488 case R_390_PLT16DBL: 1489 case R_390_PLT32: 1490 case R_390_PLT32DBL: 1491 case R_390_PLT64: 1492 case R_390_PLTOFF16: 1493 case R_390_PLTOFF32: 1494 case R_390_PLTOFF64: 1495 if (h != NULL) 1496 { 1497 if (h->plt.refcount > 0) 1498 h->plt.refcount -= 1; 1499 } 1500 break; 1501 1502 case R_390_GOTPLT12: 1503 case R_390_GOTPLT16: 1504 case R_390_GOTPLT20: 1505 case R_390_GOTPLT32: 1506 case R_390_GOTPLT64: 1507 case R_390_GOTPLTENT: 1508 if (h != NULL) 1509 { 1510 if (h->plt.refcount > 0) 1511 { 1512 ((struct elf_s390_link_hash_entry *) h)->gotplt_refcount--; 1513 h->plt.refcount -= 1; 1514 } 1515 } 1516 else if (local_got_refcounts != NULL) 1517 { 1518 if (local_got_refcounts[r_symndx] > 0) 1519 local_got_refcounts[r_symndx] -= 1; 1520 } 1521 break; 1522 1523 default: 1524 break; 1525 } 1526 } 1527 1528 return TRUE; 1529 } 1530 1531 /* Make sure we emit a GOT entry if the symbol was supposed to have a PLT 1532 entry but we found we will not create any. Called when we find we will 1533 not have any PLT for this symbol, by for example 1534 elf_s390_adjust_dynamic_symbol when we're doing a proper dynamic link, 1535 or elf_s390_size_dynamic_sections if no dynamic sections will be 1536 created (we're only linking static objects). */ 1537 1538 static void 1539 elf_s390_adjust_gotplt (struct elf_s390_link_hash_entry *h) 1540 { 1541 if (h->elf.root.type == bfd_link_hash_warning) 1542 h = (struct elf_s390_link_hash_entry *) h->elf.root.u.i.link; 1543 1544 if (h->gotplt_refcount <= 0) 1545 return; 1546 1547 /* We simply add the number of gotplt references to the number 1548 * of got references for this symbol. */ 1549 h->elf.got.refcount += h->gotplt_refcount; 1550 h->gotplt_refcount = -1; 1551 } 1552 1553 /* Adjust a symbol defined by a dynamic object and referenced by a 1554 regular object. The current definition is in some section of the 1555 dynamic object, but we're not including those sections. We have to 1556 change the definition to something the rest of the link can 1557 understand. */ 1558 1559 static bfd_boolean 1560 elf_s390_adjust_dynamic_symbol (struct bfd_link_info *info, 1561 struct elf_link_hash_entry *h) 1562 { 1563 struct elf_s390_link_hash_table *htab; 1564 asection *s; 1565 1566 /* STT_GNU_IFUNC symbol must go through PLT. */ 1567 if (s390_is_ifunc_symbol_p (h)) 1568 return TRUE; 1569 1570 /* If this is a function, put it in the procedure linkage table. We 1571 will fill in the contents of the procedure linkage table later 1572 (although we could actually do it here). */ 1573 if (h->type == STT_FUNC 1574 || h->needs_plt) 1575 { 1576 if (h->plt.refcount <= 0 1577 || SYMBOL_CALLS_LOCAL (info, h) 1578 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT 1579 && h->root.type == bfd_link_hash_undefweak)) 1580 { 1581 /* This case can occur if we saw a PLT32 reloc in an input 1582 file, but the symbol was never referred to by a dynamic 1583 object, or if all references were garbage collected. In 1584 such a case, we don't actually need to build a procedure 1585 linkage table, and we can just do a PC32 reloc instead. */ 1586 h->plt.offset = (bfd_vma) -1; 1587 h->needs_plt = 0; 1588 elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h); 1589 } 1590 1591 return TRUE; 1592 } 1593 else 1594 /* It's possible that we incorrectly decided a .plt reloc was 1595 needed for an R_390_PC32 reloc to a non-function sym in 1596 check_relocs. We can't decide accurately between function and 1597 non-function syms in check-relocs; Objects loaded later in 1598 the link may change h->type. So fix it now. */ 1599 h->plt.offset = (bfd_vma) -1; 1600 1601 /* If this is a weak symbol, and there is a real definition, the 1602 processor independent code will have arranged for us to see the 1603 real definition first, and we can just use the same value. */ 1604 if (h->u.weakdef != NULL) 1605 { 1606 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined 1607 || h->u.weakdef->root.type == bfd_link_hash_defweak); 1608 h->root.u.def.section = h->u.weakdef->root.u.def.section; 1609 h->root.u.def.value = h->u.weakdef->root.u.def.value; 1610 if (ELIMINATE_COPY_RELOCS || info->nocopyreloc) 1611 h->non_got_ref = h->u.weakdef->non_got_ref; 1612 return TRUE; 1613 } 1614 1615 /* This is a reference to a symbol defined by a dynamic object which 1616 is not a function. */ 1617 1618 /* If we are creating a shared library, we must presume that the 1619 only references to the symbol are via the global offset table. 1620 For such cases we need not do anything here; the relocations will 1621 be handled correctly by relocate_section. */ 1622 if (info->shared) 1623 return TRUE; 1624 1625 /* If there are no references to this symbol that do not use the 1626 GOT, we don't need to generate a copy reloc. */ 1627 if (!h->non_got_ref) 1628 return TRUE; 1629 1630 /* If -z nocopyreloc was given, we won't generate them either. */ 1631 if (info->nocopyreloc) 1632 { 1633 h->non_got_ref = 0; 1634 return TRUE; 1635 } 1636 1637 if (ELIMINATE_COPY_RELOCS) 1638 { 1639 struct elf_s390_link_hash_entry * eh; 1640 struct elf_dyn_relocs *p; 1641 1642 eh = (struct elf_s390_link_hash_entry *) h; 1643 for (p = eh->dyn_relocs; p != NULL; p = p->next) 1644 { 1645 s = p->sec->output_section; 1646 if (s != NULL && (s->flags & SEC_READONLY) != 0) 1647 break; 1648 } 1649 1650 /* If we didn't find any dynamic relocs in read-only sections, then 1651 we'll be keeping the dynamic relocs and avoiding the copy reloc. */ 1652 if (p == NULL) 1653 { 1654 h->non_got_ref = 0; 1655 return TRUE; 1656 } 1657 } 1658 1659 /* We must allocate the symbol in our .dynbss section, which will 1660 become part of the .bss section of the executable. There will be 1661 an entry for this symbol in the .dynsym section. The dynamic 1662 object will contain position independent code, so all references 1663 from the dynamic object to this symbol will go through the global 1664 offset table. The dynamic linker will use the .dynsym entry to 1665 determine the address it must put in the global offset table, so 1666 both the dynamic object and the regular object will refer to the 1667 same memory location for the variable. */ 1668 1669 htab = elf_s390_hash_table (info); 1670 if (htab == NULL) 1671 return FALSE; 1672 1673 /* We must generate a R_390_COPY reloc to tell the dynamic linker to 1674 copy the initial value out of the dynamic object and into the 1675 runtime process image. */ 1676 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0) 1677 { 1678 htab->srelbss->size += sizeof (Elf64_External_Rela); 1679 h->needs_copy = 1; 1680 } 1681 1682 s = htab->sdynbss; 1683 1684 return _bfd_elf_adjust_dynamic_copy (h, s); 1685 } 1686 1687 /* Allocate space in .plt, .got and associated reloc sections for 1688 dynamic relocs. */ 1689 1690 static bfd_boolean 1691 allocate_dynrelocs (struct elf_link_hash_entry *h, 1692 void * inf) 1693 { 1694 struct bfd_link_info *info; 1695 struct elf_s390_link_hash_table *htab; 1696 struct elf_s390_link_hash_entry *eh = (struct elf_s390_link_hash_entry *)h; 1697 struct elf_dyn_relocs *p; 1698 1699 if (h->root.type == bfd_link_hash_indirect) 1700 return TRUE; 1701 1702 info = (struct bfd_link_info *) inf; 1703 htab = elf_s390_hash_table (info); 1704 if (htab == NULL) 1705 return FALSE; 1706 1707 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it 1708 here if it is defined and referenced in a non-shared object. */ 1709 if (s390_is_ifunc_symbol_p (h) && h->def_regular) 1710 return s390_elf_allocate_ifunc_dyn_relocs (info, h, 1711 &eh->dyn_relocs); 1712 else if (htab->elf.dynamic_sections_created 1713 && h->plt.refcount > 0) 1714 { 1715 /* Make sure this symbol is output as a dynamic symbol. 1716 Undefined weak syms won't yet be marked as dynamic. */ 1717 if (h->dynindx == -1 1718 && !h->forced_local) 1719 { 1720 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 1721 return FALSE; 1722 } 1723 1724 if (info->shared 1725 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h)) 1726 { 1727 asection *s = htab->elf.splt; 1728 1729 /* If this is the first .plt entry, make room for the special 1730 first entry. */ 1731 if (s->size == 0) 1732 s->size += PLT_FIRST_ENTRY_SIZE; 1733 1734 h->plt.offset = s->size; 1735 1736 /* If this symbol is not defined in a regular file, and we are 1737 not generating a shared library, then set the symbol to this 1738 location in the .plt. This is required to make function 1739 pointers compare as equal between the normal executable and 1740 the shared library. */ 1741 if (! info->shared 1742 && !h->def_regular) 1743 { 1744 h->root.u.def.section = s; 1745 h->root.u.def.value = h->plt.offset; 1746 } 1747 1748 /* Make room for this entry. */ 1749 s->size += PLT_ENTRY_SIZE; 1750 1751 /* We also need to make an entry in the .got.plt section, which 1752 will be placed in the .got section by the linker script. */ 1753 htab->elf.sgotplt->size += GOT_ENTRY_SIZE; 1754 1755 /* We also need to make an entry in the .rela.plt section. */ 1756 htab->elf.srelplt->size += sizeof (Elf64_External_Rela); 1757 } 1758 else 1759 { 1760 h->plt.offset = (bfd_vma) -1; 1761 h->needs_plt = 0; 1762 elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h); 1763 } 1764 } 1765 else 1766 { 1767 h->plt.offset = (bfd_vma) -1; 1768 h->needs_plt = 0; 1769 elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h); 1770 } 1771 1772 /* If R_390_TLS_{IE64,GOTIE64,GOTIE12,IEENT} symbol is now local to 1773 the binary, we can optimize a bit. IE64 and GOTIE64 get converted 1774 to R_390_TLS_LE64 requiring no TLS entry. For GOTIE12 and IEENT 1775 we can save the dynamic TLS relocation. */ 1776 if (h->got.refcount > 0 1777 && !info->shared 1778 && h->dynindx == -1 1779 && elf_s390_hash_entry(h)->tls_type >= GOT_TLS_IE) 1780 { 1781 if (elf_s390_hash_entry(h)->tls_type == GOT_TLS_IE_NLT) 1782 /* For the GOTIE access without a literal pool entry the offset has 1783 to be stored somewhere. The immediate value in the instruction 1784 is not bit enough so the value is stored in the got. */ 1785 { 1786 h->got.offset = htab->elf.sgot->size; 1787 htab->elf.sgot->size += GOT_ENTRY_SIZE; 1788 } 1789 else 1790 h->got.offset = (bfd_vma) -1; 1791 } 1792 else if (h->got.refcount > 0) 1793 { 1794 asection *s; 1795 bfd_boolean dyn; 1796 int tls_type = elf_s390_hash_entry(h)->tls_type; 1797 1798 /* Make sure this symbol is output as a dynamic symbol. 1799 Undefined weak syms won't yet be marked as dynamic. */ 1800 if (h->dynindx == -1 1801 && !h->forced_local) 1802 { 1803 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 1804 return FALSE; 1805 } 1806 1807 s = htab->elf.sgot; 1808 h->got.offset = s->size; 1809 s->size += GOT_ENTRY_SIZE; 1810 /* R_390_TLS_GD64 needs 2 consecutive GOT slots. */ 1811 if (tls_type == GOT_TLS_GD) 1812 s->size += GOT_ENTRY_SIZE; 1813 dyn = htab->elf.dynamic_sections_created; 1814 /* R_390_TLS_IE64 needs one dynamic relocation, 1815 R_390_TLS_GD64 needs one if local symbol and two if global. */ 1816 if ((tls_type == GOT_TLS_GD && h->dynindx == -1) 1817 || tls_type >= GOT_TLS_IE) 1818 htab->elf.srelgot->size += sizeof (Elf64_External_Rela); 1819 else if (tls_type == GOT_TLS_GD) 1820 htab->elf.srelgot->size += 2 * sizeof (Elf64_External_Rela); 1821 else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 1822 || h->root.type != bfd_link_hash_undefweak) 1823 && (info->shared 1824 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))) 1825 htab->elf.srelgot->size += sizeof (Elf64_External_Rela); 1826 } 1827 else 1828 h->got.offset = (bfd_vma) -1; 1829 1830 if (eh->dyn_relocs == NULL) 1831 return TRUE; 1832 1833 /* In the shared -Bsymbolic case, discard space allocated for 1834 dynamic pc-relative relocs against symbols which turn out to be 1835 defined in regular objects. For the normal shared case, discard 1836 space for pc-relative relocs that have become local due to symbol 1837 visibility changes. */ 1838 1839 if (info->shared) 1840 { 1841 if (SYMBOL_CALLS_LOCAL (info, h)) 1842 { 1843 struct elf_dyn_relocs **pp; 1844 1845 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; ) 1846 { 1847 p->count -= p->pc_count; 1848 p->pc_count = 0; 1849 if (p->count == 0) 1850 *pp = p->next; 1851 else 1852 pp = &p->next; 1853 } 1854 } 1855 1856 /* Also discard relocs on undefined weak syms with non-default 1857 visibility. */ 1858 if (eh->dyn_relocs != NULL 1859 && h->root.type == bfd_link_hash_undefweak) 1860 { 1861 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT) 1862 eh->dyn_relocs = NULL; 1863 1864 /* Make sure undefined weak symbols are output as a dynamic 1865 symbol in PIEs. */ 1866 else if (h->dynindx == -1 1867 && !h->forced_local) 1868 { 1869 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 1870 return FALSE; 1871 } 1872 } 1873 } 1874 else if (ELIMINATE_COPY_RELOCS) 1875 { 1876 /* For the non-shared case, discard space for relocs against 1877 symbols which turn out to need copy relocs or are not 1878 dynamic. */ 1879 1880 if (!h->non_got_ref 1881 && ((h->def_dynamic 1882 && !h->def_regular) 1883 || (htab->elf.dynamic_sections_created 1884 && (h->root.type == bfd_link_hash_undefweak 1885 || h->root.type == bfd_link_hash_undefined)))) 1886 { 1887 /* Make sure this symbol is output as a dynamic symbol. 1888 Undefined weak syms won't yet be marked as dynamic. */ 1889 if (h->dynindx == -1 1890 && !h->forced_local) 1891 { 1892 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 1893 return FALSE; 1894 } 1895 1896 /* If that succeeded, we know we'll be keeping all the 1897 relocs. */ 1898 if (h->dynindx != -1) 1899 goto keep; 1900 } 1901 1902 eh->dyn_relocs = NULL; 1903 1904 keep: ; 1905 } 1906 1907 /* Finally, allocate space. */ 1908 for (p = eh->dyn_relocs; p != NULL; p = p->next) 1909 { 1910 asection *sreloc = elf_section_data (p->sec)->sreloc; 1911 sreloc->size += p->count * sizeof (Elf64_External_Rela); 1912 } 1913 1914 return TRUE; 1915 } 1916 1917 /* Find any dynamic relocs that apply to read-only sections. */ 1918 1919 static bfd_boolean 1920 readonly_dynrelocs (struct elf_link_hash_entry *h, void * inf) 1921 { 1922 struct elf_s390_link_hash_entry *eh; 1923 struct elf_dyn_relocs *p; 1924 1925 eh = (struct elf_s390_link_hash_entry *) h; 1926 for (p = eh->dyn_relocs; p != NULL; p = p->next) 1927 { 1928 asection *s = p->sec->output_section; 1929 1930 if (s != NULL && (s->flags & SEC_READONLY) != 0) 1931 { 1932 struct bfd_link_info *info = (struct bfd_link_info *) inf; 1933 1934 info->flags |= DF_TEXTREL; 1935 1936 /* Not an error, just cut short the traversal. */ 1937 return FALSE; 1938 } 1939 } 1940 return TRUE; 1941 } 1942 1943 /* Set the sizes of the dynamic sections. */ 1944 1945 static bfd_boolean 1946 elf_s390_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, 1947 struct bfd_link_info *info) 1948 { 1949 struct elf_s390_link_hash_table *htab; 1950 bfd *dynobj; 1951 asection *s; 1952 bfd_boolean relocs; 1953 bfd *ibfd; 1954 1955 htab = elf_s390_hash_table (info); 1956 if (htab == NULL) 1957 return FALSE; 1958 1959 dynobj = htab->elf.dynobj; 1960 if (dynobj == NULL) 1961 abort (); 1962 1963 if (htab->elf.dynamic_sections_created) 1964 { 1965 /* Set the contents of the .interp section to the interpreter. */ 1966 if (info->executable) 1967 { 1968 s = bfd_get_linker_section (dynobj, ".interp"); 1969 if (s == NULL) 1970 abort (); 1971 s->size = sizeof ELF_DYNAMIC_INTERPRETER; 1972 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; 1973 } 1974 } 1975 1976 /* Set up .got offsets for local syms, and space for local dynamic 1977 relocs. */ 1978 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next) 1979 { 1980 bfd_signed_vma *local_got; 1981 bfd_signed_vma *end_local_got; 1982 char *local_tls_type; 1983 bfd_size_type locsymcount; 1984 Elf_Internal_Shdr *symtab_hdr; 1985 asection *srela; 1986 struct plt_entry *local_plt; 1987 unsigned int i; 1988 1989 if (! is_s390_elf (ibfd)) 1990 continue; 1991 1992 for (s = ibfd->sections; s != NULL; s = s->next) 1993 { 1994 struct elf_dyn_relocs *p; 1995 1996 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next) 1997 { 1998 if (!bfd_is_abs_section (p->sec) 1999 && bfd_is_abs_section (p->sec->output_section)) 2000 { 2001 /* Input section has been discarded, either because 2002 it is a copy of a linkonce section or due to 2003 linker script /DISCARD/, so we'll be discarding 2004 the relocs too. */ 2005 } 2006 else if (p->count != 0) 2007 { 2008 srela = elf_section_data (p->sec)->sreloc; 2009 srela->size += p->count * sizeof (Elf64_External_Rela); 2010 if ((p->sec->output_section->flags & SEC_READONLY) != 0) 2011 info->flags |= DF_TEXTREL; 2012 } 2013 } 2014 } 2015 2016 local_got = elf_local_got_refcounts (ibfd); 2017 if (!local_got) 2018 continue; 2019 2020 symtab_hdr = &elf_symtab_hdr (ibfd); 2021 locsymcount = symtab_hdr->sh_info; 2022 end_local_got = local_got + locsymcount; 2023 local_tls_type = elf_s390_local_got_tls_type (ibfd); 2024 s = htab->elf.sgot; 2025 srela = htab->elf.srelgot; 2026 for (; local_got < end_local_got; ++local_got, ++local_tls_type) 2027 { 2028 if (*local_got > 0) 2029 { 2030 *local_got = s->size; 2031 s->size += GOT_ENTRY_SIZE; 2032 if (*local_tls_type == GOT_TLS_GD) 2033 s->size += GOT_ENTRY_SIZE; 2034 if (info->shared) 2035 srela->size += sizeof (Elf64_External_Rela); 2036 } 2037 else 2038 *local_got = (bfd_vma) -1; 2039 } 2040 2041 local_plt = elf_s390_local_plt (ibfd); 2042 for (i = 0; i < symtab_hdr->sh_info; i++) 2043 { 2044 if (local_plt[i].plt.refcount > 0) 2045 { 2046 local_plt[i].plt.offset = htab->elf.iplt->size; 2047 htab->elf.iplt->size += PLT_ENTRY_SIZE; 2048 htab->elf.igotplt->size += GOT_ENTRY_SIZE; 2049 htab->elf.irelplt->size += sizeof (Elf64_External_Rela); 2050 } 2051 else 2052 local_plt[i].plt.offset = (bfd_vma) -1; 2053 } 2054 } 2055 2056 if (htab->tls_ldm_got.refcount > 0) 2057 { 2058 /* Allocate 2 got entries and 1 dynamic reloc for R_390_TLS_LDM64 2059 relocs. */ 2060 htab->tls_ldm_got.offset = htab->elf.sgot->size; 2061 htab->elf.sgot->size += 2 * GOT_ENTRY_SIZE; 2062 htab->elf.srelgot->size += sizeof (Elf64_External_Rela); 2063 } 2064 else 2065 htab->tls_ldm_got.offset = -1; 2066 2067 /* Allocate global sym .plt and .got entries, and space for global 2068 sym dynamic relocs. */ 2069 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info); 2070 2071 /* We now have determined the sizes of the various dynamic sections. 2072 Allocate memory for them. */ 2073 relocs = FALSE; 2074 for (s = dynobj->sections; s != NULL; s = s->next) 2075 { 2076 if ((s->flags & SEC_LINKER_CREATED) == 0) 2077 continue; 2078 2079 if (s == htab->elf.splt 2080 || s == htab->elf.sgot 2081 || s == htab->elf.sgotplt 2082 || s == htab->sdynbss 2083 || s == htab->elf.iplt 2084 || s == htab->elf.igotplt 2085 || s == htab->irelifunc) 2086 { 2087 /* Strip this section if we don't need it; see the 2088 comment below. */ 2089 } 2090 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela")) 2091 { 2092 if (s->size != 0 && s != htab->elf.srelplt) 2093 relocs = TRUE; 2094 2095 /* We use the reloc_count field as a counter if we need 2096 to copy relocs into the output file. */ 2097 s->reloc_count = 0; 2098 } 2099 else 2100 { 2101 /* It's not one of our sections, so don't allocate space. */ 2102 continue; 2103 } 2104 2105 if (s->size == 0) 2106 { 2107 /* If we don't need this section, strip it from the 2108 output file. This is to handle .rela.bss and 2109 .rela.plt. We must create it in 2110 create_dynamic_sections, because it must be created 2111 before the linker maps input sections to output 2112 sections. The linker does that before 2113 adjust_dynamic_symbol is called, and it is that 2114 function which decides whether anything needs to go 2115 into these sections. */ 2116 2117 s->flags |= SEC_EXCLUDE; 2118 continue; 2119 } 2120 2121 if ((s->flags & SEC_HAS_CONTENTS) == 0) 2122 continue; 2123 2124 /* Allocate memory for the section contents. We use bfd_zalloc 2125 here in case unused entries are not reclaimed before the 2126 section's contents are written out. This should not happen, 2127 but this way if it does, we get a R_390_NONE reloc instead 2128 of garbage. */ 2129 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size); 2130 if (s->contents == NULL) 2131 return FALSE; 2132 } 2133 2134 if (htab->elf.dynamic_sections_created) 2135 { 2136 /* Add some entries to the .dynamic section. We fill in the 2137 values later, in elf_s390_finish_dynamic_sections, but we 2138 must add the entries now so that we get the correct size for 2139 the .dynamic section. The DT_DEBUG entry is filled in by the 2140 dynamic linker and used by the debugger. */ 2141 #define add_dynamic_entry(TAG, VAL) \ 2142 _bfd_elf_add_dynamic_entry (info, TAG, VAL) 2143 2144 if (info->executable) 2145 { 2146 if (!add_dynamic_entry (DT_DEBUG, 0)) 2147 return FALSE; 2148 } 2149 2150 if (htab->elf.splt->size != 0) 2151 { 2152 if (!add_dynamic_entry (DT_PLTGOT, 0) 2153 || !add_dynamic_entry (DT_PLTRELSZ, 0) 2154 || !add_dynamic_entry (DT_PLTREL, DT_RELA) 2155 || !add_dynamic_entry (DT_JMPREL, 0)) 2156 return FALSE; 2157 } 2158 2159 if (relocs) 2160 { 2161 if (!add_dynamic_entry (DT_RELA, 0) 2162 || !add_dynamic_entry (DT_RELASZ, 0) 2163 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela))) 2164 return FALSE; 2165 2166 /* If any dynamic relocs apply to a read-only section, 2167 then we need a DT_TEXTREL entry. */ 2168 if ((info->flags & DF_TEXTREL) == 0) 2169 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, 2170 info); 2171 2172 if ((info->flags & DF_TEXTREL) != 0) 2173 { 2174 if (!add_dynamic_entry (DT_TEXTREL, 0)) 2175 return FALSE; 2176 } 2177 } 2178 } 2179 #undef add_dynamic_entry 2180 2181 return TRUE; 2182 } 2183 2184 /* Return the base VMA address which should be subtracted from real addresses 2185 when resolving @dtpoff relocation. 2186 This is PT_TLS segment p_vaddr. */ 2187 2188 static bfd_vma 2189 dtpoff_base (struct bfd_link_info *info) 2190 { 2191 /* If tls_sec is NULL, we should have signalled an error already. */ 2192 if (elf_hash_table (info)->tls_sec == NULL) 2193 return 0; 2194 return elf_hash_table (info)->tls_sec->vma; 2195 } 2196 2197 /* Return the relocation value for @tpoff relocation 2198 if STT_TLS virtual address is ADDRESS. */ 2199 2200 static bfd_vma 2201 tpoff (struct bfd_link_info *info, bfd_vma address) 2202 { 2203 struct elf_link_hash_table *htab = elf_hash_table (info); 2204 2205 /* If tls_sec is NULL, we should have signalled an error already. */ 2206 if (htab->tls_sec == NULL) 2207 return 0; 2208 return htab->tls_size + htab->tls_sec->vma - address; 2209 } 2210 2211 /* Complain if TLS instruction relocation is against an invalid 2212 instruction. */ 2213 2214 static void 2215 invalid_tls_insn (bfd *input_bfd, 2216 asection *input_section, 2217 Elf_Internal_Rela *rel) 2218 { 2219 reloc_howto_type *howto; 2220 2221 howto = elf_howto_table + ELF64_R_TYPE (rel->r_info); 2222 (*_bfd_error_handler) 2223 (_("%B(%A+0x%lx): invalid instruction for TLS relocation %s"), 2224 input_bfd, 2225 input_section, 2226 (long) rel->r_offset, 2227 howto->name); 2228 bfd_set_error (bfd_error_bad_value); 2229 } 2230 2231 /* Relocate a 390 ELF section. */ 2232 2233 static bfd_boolean 2234 elf_s390_relocate_section (bfd *output_bfd, 2235 struct bfd_link_info *info, 2236 bfd *input_bfd, 2237 asection *input_section, 2238 bfd_byte *contents, 2239 Elf_Internal_Rela *relocs, 2240 Elf_Internal_Sym *local_syms, 2241 asection **local_sections) 2242 { 2243 struct elf_s390_link_hash_table *htab; 2244 Elf_Internal_Shdr *symtab_hdr; 2245 struct elf_link_hash_entry **sym_hashes; 2246 bfd_vma *local_got_offsets; 2247 Elf_Internal_Rela *rel; 2248 Elf_Internal_Rela *relend; 2249 2250 BFD_ASSERT (is_s390_elf (input_bfd)); 2251 2252 htab = elf_s390_hash_table (info); 2253 if (htab == NULL) 2254 return FALSE; 2255 2256 symtab_hdr = &elf_symtab_hdr (input_bfd); 2257 sym_hashes = elf_sym_hashes (input_bfd); 2258 local_got_offsets = elf_local_got_offsets (input_bfd); 2259 2260 rel = relocs; 2261 relend = relocs + input_section->reloc_count; 2262 for (; rel < relend; rel++) 2263 { 2264 unsigned int r_type; 2265 reloc_howto_type *howto; 2266 unsigned long r_symndx; 2267 struct elf_link_hash_entry *h; 2268 Elf_Internal_Sym *sym; 2269 asection *sec; 2270 bfd_vma off; 2271 bfd_vma relocation; 2272 bfd_boolean unresolved_reloc; 2273 bfd_reloc_status_type r; 2274 int tls_type; 2275 asection *base_got = htab->elf.sgot; 2276 2277 r_type = ELF64_R_TYPE (rel->r_info); 2278 if (r_type == (int) R_390_GNU_VTINHERIT 2279 || r_type == (int) R_390_GNU_VTENTRY) 2280 continue; 2281 if (r_type >= (int) R_390_max) 2282 { 2283 bfd_set_error (bfd_error_bad_value); 2284 return FALSE; 2285 } 2286 2287 howto = elf_howto_table + r_type; 2288 r_symndx = ELF64_R_SYM (rel->r_info); 2289 2290 h = NULL; 2291 sym = NULL; 2292 sec = NULL; 2293 unresolved_reloc = FALSE; 2294 if (r_symndx < symtab_hdr->sh_info) 2295 { 2296 sym = local_syms + r_symndx; 2297 sec = local_sections[r_symndx]; 2298 2299 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC) 2300 { 2301 struct plt_entry *local_plt = elf_s390_local_plt (input_bfd); 2302 if (local_plt == NULL) 2303 return FALSE; 2304 2305 /* Address of the PLT slot. */ 2306 relocation = (htab->elf.iplt->output_section->vma 2307 + htab->elf.iplt->output_offset 2308 + local_plt[r_symndx].plt.offset); 2309 2310 switch (r_type) 2311 { 2312 case R_390_GOTPLT12: 2313 case R_390_GOTPLT16: 2314 case R_390_GOTPLT20: 2315 case R_390_GOTPLT32: 2316 case R_390_GOTPLT64: 2317 case R_390_GOTPLTENT: 2318 case R_390_GOT12: 2319 case R_390_GOT16: 2320 case R_390_GOT20: 2321 case R_390_GOT32: 2322 case R_390_GOT64: 2323 case R_390_GOTENT: 2324 { 2325 /* Write the PLT slot address into the GOT slot. */ 2326 bfd_put_64 (output_bfd, relocation, 2327 htab->elf.sgot->contents + 2328 local_got_offsets[r_symndx]); 2329 relocation = (local_got_offsets[r_symndx] + 2330 htab->elf.sgot->output_offset); 2331 2332 if (r_type == R_390_GOTENT || r_type == R_390_GOTPLTENT) 2333 relocation += htab->elf.sgot->output_section->vma; 2334 break; 2335 } 2336 default: 2337 break; 2338 } 2339 /* The output section is needed later in 2340 finish_dynamic_section when creating the dynamic 2341 relocation. */ 2342 local_plt[r_symndx].sec = sec; 2343 goto do_relocation; 2344 } 2345 else 2346 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); 2347 } 2348 else 2349 { 2350 bfd_boolean warned ATTRIBUTE_UNUSED; 2351 2352 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 2353 r_symndx, symtab_hdr, sym_hashes, 2354 h, sec, relocation, 2355 unresolved_reloc, warned); 2356 } 2357 2358 if (sec != NULL && discarded_section (sec)) 2359 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, 2360 rel, 1, relend, howto, 0, contents); 2361 2362 if (info->relocatable) 2363 continue; 2364 2365 switch (r_type) 2366 { 2367 case R_390_GOTPLT12: 2368 case R_390_GOTPLT16: 2369 case R_390_GOTPLT20: 2370 case R_390_GOTPLT32: 2371 case R_390_GOTPLT64: 2372 case R_390_GOTPLTENT: 2373 /* There are three cases for a GOTPLT relocation. 1) The 2374 relocation is against the jump slot entry of a plt that 2375 will get emitted to the output file. 2) The relocation 2376 is against the jump slot of a plt entry that has been 2377 removed. elf_s390_adjust_gotplt has created a GOT entry 2378 as replacement. 3) The relocation is against a local symbol. 2379 Cases 2) and 3) are the same as the GOT relocation code 2380 so we just have to test for case 1 and fall through for 2381 the other two. */ 2382 if (h != NULL && h->plt.offset != (bfd_vma) -1) 2383 { 2384 bfd_vma plt_index; 2385 2386 if (s390_is_ifunc_symbol_p (h)) 2387 { 2388 plt_index = h->plt.offset / PLT_ENTRY_SIZE; 2389 relocation = (plt_index * GOT_ENTRY_SIZE + 2390 htab->elf.igotplt->output_offset); 2391 if (r_type == R_390_GOTPLTENT) 2392 relocation += htab->elf.igotplt->output_section->vma; 2393 } 2394 else 2395 { 2396 /* Calc. index no. 2397 Current offset - size first entry / entry size. */ 2398 plt_index = (h->plt.offset - PLT_FIRST_ENTRY_SIZE) / 2399 PLT_ENTRY_SIZE; 2400 2401 /* Offset in GOT is PLT index plus GOT headers(3) 2402 times 4, addr & GOT addr. */ 2403 relocation = (plt_index + 3) * GOT_ENTRY_SIZE; 2404 if (r_type == R_390_GOTPLTENT) 2405 relocation += htab->elf.sgot->output_section->vma; 2406 } 2407 unresolved_reloc = FALSE; 2408 break; 2409 } 2410 /* Fall through. */ 2411 2412 case R_390_GOT12: 2413 case R_390_GOT16: 2414 case R_390_GOT20: 2415 case R_390_GOT32: 2416 case R_390_GOT64: 2417 case R_390_GOTENT: 2418 /* Relocation is to the entry for this symbol in the global 2419 offset table. */ 2420 if (base_got == NULL) 2421 abort (); 2422 2423 if (h != NULL) 2424 { 2425 bfd_boolean dyn; 2426 2427 off = h->got.offset; 2428 dyn = htab->elf.dynamic_sections_created; 2429 2430 if (s390_is_ifunc_symbol_p (h)) 2431 { 2432 BFD_ASSERT (h->plt.offset != (bfd_vma) -1); 2433 if (off == (bfd_vma)-1) 2434 { 2435 /* No explicit GOT usage so redirect to the 2436 got.iplt slot. */ 2437 base_got = htab->elf.igotplt; 2438 off = h->plt.offset / PLT_ENTRY_SIZE * GOT_ENTRY_SIZE; 2439 } 2440 else 2441 { 2442 /* Explicit GOT slots must contain the address 2443 of the PLT slot. This will be handled in 2444 finish_dynamic_symbol. */ 2445 } 2446 } 2447 else if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h) 2448 || (info->shared 2449 && SYMBOL_REFERENCES_LOCAL (info, h)) 2450 || (ELF_ST_VISIBILITY (h->other) 2451 && h->root.type == bfd_link_hash_undefweak)) 2452 { 2453 /* This is actually a static link, or it is a 2454 -Bsymbolic link and the symbol is defined 2455 locally, or the symbol was forced to be local 2456 because of a version file. We must initialize 2457 this entry in the global offset table. Since the 2458 offset must always be a multiple of 2, we use the 2459 least significant bit to record whether we have 2460 initialized it already. 2461 2462 When doing a dynamic link, we create a .rel.got 2463 relocation entry to initialize the value. This 2464 is done in the finish_dynamic_symbol routine. */ 2465 if ((off & 1) != 0) 2466 off &= ~1; 2467 else 2468 { 2469 bfd_put_64 (output_bfd, relocation, 2470 base_got->contents + off); 2471 h->got.offset |= 1; 2472 } 2473 } 2474 else 2475 unresolved_reloc = FALSE; 2476 } 2477 else 2478 { 2479 if (local_got_offsets == NULL) 2480 abort (); 2481 2482 off = local_got_offsets[r_symndx]; 2483 2484 /* The offset must always be a multiple of 8. We use 2485 the least significant bit to record whether we have 2486 already generated the necessary reloc. */ 2487 if ((off & 1) != 0) 2488 off &= ~1; 2489 else 2490 { 2491 bfd_put_64 (output_bfd, relocation, 2492 htab->elf.sgot->contents + off); 2493 2494 if (info->shared) 2495 { 2496 asection *s; 2497 Elf_Internal_Rela outrel; 2498 bfd_byte *loc; 2499 2500 s = htab->elf.srelgot; 2501 if (s == NULL) 2502 abort (); 2503 2504 outrel.r_offset = (htab->elf.sgot->output_section->vma 2505 + htab->elf.sgot->output_offset 2506 + off); 2507 outrel.r_info = ELF64_R_INFO (0, R_390_RELATIVE); 2508 outrel.r_addend = relocation; 2509 loc = s->contents; 2510 loc += s->reloc_count++ * sizeof (Elf64_External_Rela); 2511 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc); 2512 } 2513 2514 local_got_offsets[r_symndx] |= 1; 2515 } 2516 } 2517 2518 if (off >= (bfd_vma) -2) 2519 abort (); 2520 2521 relocation = base_got->output_offset + off; 2522 2523 /* For @GOTENT the relocation is against the offset between 2524 the instruction and the symbols entry in the GOT and not 2525 between the start of the GOT and the symbols entry. We 2526 add the vma of the GOT to get the correct value. */ 2527 if ( r_type == R_390_GOTENT 2528 || r_type == R_390_GOTPLTENT) 2529 relocation += base_got->output_section->vma; 2530 2531 break; 2532 2533 case R_390_GOTOFF16: 2534 case R_390_GOTOFF32: 2535 case R_390_GOTOFF64: 2536 /* Relocation is relative to the start of the global offset 2537 table. */ 2538 2539 /* Note that sgot->output_offset is not involved in this 2540 calculation. We always want the start of .got. If we 2541 defined _GLOBAL_OFFSET_TABLE in a different way, as is 2542 permitted by the ABI, we might have to change this 2543 calculation. */ 2544 relocation -= htab->elf.sgot->output_section->vma; 2545 break; 2546 2547 case R_390_GOTPC: 2548 case R_390_GOTPCDBL: 2549 /* Use global offset table as symbol value. */ 2550 relocation = htab->elf.sgot->output_section->vma; 2551 unresolved_reloc = FALSE; 2552 break; 2553 2554 case R_390_PLT16DBL: 2555 case R_390_PLT32: 2556 case R_390_PLT32DBL: 2557 case R_390_PLT64: 2558 /* Relocation is to the entry for this symbol in the 2559 procedure linkage table. */ 2560 2561 /* Resolve a PLT32 reloc against a local symbol directly, 2562 without using the procedure linkage table. */ 2563 if (h == NULL) 2564 break; 2565 2566 if (h->plt.offset == (bfd_vma) -1 2567 || (htab->elf.splt == NULL && htab->elf.iplt == NULL)) 2568 { 2569 /* We didn't make a PLT entry for this symbol. This 2570 happens when statically linking PIC code, or when 2571 using -Bsymbolic. */ 2572 break; 2573 } 2574 if (s390_is_ifunc_symbol_p (h)) 2575 relocation = (htab->elf.iplt->output_section->vma 2576 + htab->elf.iplt->output_offset 2577 + h->plt.offset); 2578 else 2579 relocation = (htab->elf.splt->output_section->vma 2580 + htab->elf.splt->output_offset 2581 + h->plt.offset); 2582 unresolved_reloc = FALSE; 2583 break; 2584 2585 case R_390_PLTOFF16: 2586 case R_390_PLTOFF32: 2587 case R_390_PLTOFF64: 2588 /* Relocation is to the entry for this symbol in the 2589 procedure linkage table relative to the start of the GOT. */ 2590 2591 /* For local symbols or if we didn't make a PLT entry for 2592 this symbol resolve the symbol directly. */ 2593 if ( h == NULL 2594 || h->plt.offset == (bfd_vma) -1 2595 || htab->elf.splt == NULL) 2596 { 2597 relocation -= htab->elf.sgot->output_section->vma; 2598 break; 2599 } 2600 2601 if (s390_is_ifunc_symbol_p (h)) 2602 relocation = (htab->elf.iplt->output_section->vma 2603 + htab->elf.iplt->output_offset 2604 + h->plt.offset 2605 - htab->elf.sgot->output_section->vma); 2606 else 2607 relocation = (htab->elf.splt->output_section->vma 2608 + htab->elf.splt->output_offset 2609 + h->plt.offset 2610 - htab->elf.sgot->output_section->vma); 2611 unresolved_reloc = FALSE; 2612 break; 2613 2614 case R_390_8: 2615 case R_390_16: 2616 case R_390_32: 2617 case R_390_64: 2618 case R_390_PC16: 2619 case R_390_PC16DBL: 2620 case R_390_PC32: 2621 case R_390_PC32DBL: 2622 case R_390_PC64: 2623 2624 if (h != NULL 2625 && s390_is_ifunc_symbol_p (h) 2626 && h->def_regular) 2627 { 2628 if (!info->shared || !h->non_got_ref) 2629 { 2630 /* For a non-shared object STT_GNU_IFUNC symbol must 2631 go through PLT. */ 2632 relocation = (htab->elf.iplt->output_section->vma 2633 + htab->elf.iplt->output_offset 2634 + h ->plt.offset); 2635 goto do_relocation; 2636 } 2637 else 2638 { 2639 /* For shared objects a runtime relocation is needed. */ 2640 2641 Elf_Internal_Rela outrel; 2642 asection *sreloc; 2643 2644 /* Need a dynamic relocation to get the real function 2645 address. */ 2646 outrel.r_offset = _bfd_elf_section_offset (output_bfd, 2647 info, 2648 input_section, 2649 rel->r_offset); 2650 if (outrel.r_offset == (bfd_vma) -1 2651 || outrel.r_offset == (bfd_vma) -2) 2652 abort (); 2653 2654 outrel.r_offset += (input_section->output_section->vma 2655 + input_section->output_offset); 2656 2657 if (h->dynindx == -1 2658 || h->forced_local 2659 || info->executable) 2660 { 2661 /* This symbol is resolved locally. */ 2662 outrel.r_info = ELF64_R_INFO (0, R_390_IRELATIVE); 2663 outrel.r_addend = (h->root.u.def.value 2664 + h->root.u.def.section->output_section->vma 2665 + h->root.u.def.section->output_offset); 2666 } 2667 else 2668 { 2669 outrel.r_info = ELF64_R_INFO (h->dynindx, r_type); 2670 outrel.r_addend = 0; 2671 } 2672 2673 sreloc = htab->elf.irelifunc; 2674 elf_append_rela (output_bfd, sreloc, &outrel); 2675 2676 /* If this reloc is against an external symbol, we 2677 do not want to fiddle with the addend. Otherwise, 2678 we need to include the symbol value so that it 2679 becomes an addend for the dynamic reloc. For an 2680 internal symbol, we have updated addend. */ 2681 continue; 2682 } 2683 } 2684 2685 if ((input_section->flags & SEC_ALLOC) == 0) 2686 break; 2687 2688 if ((info->shared 2689 && (h == NULL 2690 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 2691 || h->root.type != bfd_link_hash_undefweak) 2692 && ((r_type != R_390_PC16 2693 && r_type != R_390_PC16DBL 2694 && r_type != R_390_PC32 2695 && r_type != R_390_PC32DBL 2696 && r_type != R_390_PC64) 2697 || !SYMBOL_CALLS_LOCAL (info, h))) 2698 || (ELIMINATE_COPY_RELOCS 2699 && !info->shared 2700 && h != NULL 2701 && h->dynindx != -1 2702 && !h->non_got_ref 2703 && ((h->def_dynamic 2704 && !h->def_regular) 2705 || h->root.type == bfd_link_hash_undefweak 2706 || h->root.type == bfd_link_hash_undefined))) 2707 { 2708 Elf_Internal_Rela outrel; 2709 bfd_boolean skip, relocate; 2710 asection *sreloc; 2711 bfd_byte *loc; 2712 2713 /* When generating a shared object, these relocations 2714 are copied into the output file to be resolved at run 2715 time. */ 2716 skip = FALSE; 2717 relocate = FALSE; 2718 2719 outrel.r_offset = 2720 _bfd_elf_section_offset (output_bfd, info, input_section, 2721 rel->r_offset); 2722 if (outrel.r_offset == (bfd_vma) -1) 2723 skip = TRUE; 2724 else if (outrel.r_offset == (bfd_vma) -2) 2725 skip = TRUE, relocate = TRUE; 2726 2727 outrel.r_offset += (input_section->output_section->vma 2728 + input_section->output_offset); 2729 2730 if (skip) 2731 memset (&outrel, 0, sizeof outrel); 2732 else if (h != NULL 2733 && h->dynindx != -1 2734 && (r_type == R_390_PC16 2735 || r_type == R_390_PC16DBL 2736 || r_type == R_390_PC32 2737 || r_type == R_390_PC32DBL 2738 || r_type == R_390_PC64 2739 || !info->shared 2740 || !SYMBOLIC_BIND (info, h) 2741 || !h->def_regular)) 2742 { 2743 outrel.r_info = ELF64_R_INFO (h->dynindx, r_type); 2744 outrel.r_addend = rel->r_addend; 2745 } 2746 else 2747 { 2748 /* This symbol is local, or marked to become local. */ 2749 outrel.r_addend = relocation + rel->r_addend; 2750 if (r_type == R_390_64) 2751 { 2752 relocate = TRUE; 2753 outrel.r_info = ELF64_R_INFO (0, R_390_RELATIVE); 2754 } 2755 else 2756 { 2757 long sindx; 2758 2759 if (bfd_is_abs_section (sec)) 2760 sindx = 0; 2761 else if (sec == NULL || sec->owner == NULL) 2762 { 2763 bfd_set_error(bfd_error_bad_value); 2764 return FALSE; 2765 } 2766 else 2767 { 2768 asection *osec; 2769 2770 osec = sec->output_section; 2771 sindx = elf_section_data (osec)->dynindx; 2772 2773 if (sindx == 0) 2774 { 2775 osec = htab->elf.text_index_section; 2776 sindx = elf_section_data (osec)->dynindx; 2777 } 2778 BFD_ASSERT (sindx != 0); 2779 2780 /* We are turning this relocation into one 2781 against a section symbol, so subtract out 2782 the output section's address but not the 2783 offset of the input section in the output 2784 section. */ 2785 outrel.r_addend -= osec->vma; 2786 } 2787 outrel.r_info = ELF64_R_INFO (sindx, r_type); 2788 } 2789 } 2790 2791 sreloc = elf_section_data (input_section)->sreloc; 2792 if (sreloc == NULL) 2793 abort (); 2794 2795 loc = sreloc->contents; 2796 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela); 2797 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc); 2798 2799 /* If this reloc is against an external symbol, we do 2800 not want to fiddle with the addend. Otherwise, we 2801 need to include the symbol value so that it becomes 2802 an addend for the dynamic reloc. */ 2803 if (! relocate) 2804 continue; 2805 } 2806 2807 break; 2808 2809 /* Relocations for tls literal pool entries. */ 2810 case R_390_TLS_IE64: 2811 if (info->shared) 2812 { 2813 Elf_Internal_Rela outrel; 2814 asection *sreloc; 2815 bfd_byte *loc; 2816 2817 outrel.r_offset = rel->r_offset 2818 + input_section->output_section->vma 2819 + input_section->output_offset; 2820 outrel.r_info = ELF64_R_INFO (0, R_390_RELATIVE); 2821 sreloc = elf_section_data (input_section)->sreloc; 2822 if (sreloc == NULL) 2823 abort (); 2824 loc = sreloc->contents; 2825 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela); 2826 bfd_elf64_swap_reloc_out (output_bfd, &outrel, loc); 2827 } 2828 /* Fall through. */ 2829 2830 case R_390_TLS_GD64: 2831 case R_390_TLS_GOTIE64: 2832 r_type = elf_s390_tls_transition (info, r_type, h == NULL); 2833 tls_type = GOT_UNKNOWN; 2834 if (h == NULL && local_got_offsets) 2835 tls_type = elf_s390_local_got_tls_type (input_bfd) [r_symndx]; 2836 else if (h != NULL) 2837 { 2838 tls_type = elf_s390_hash_entry(h)->tls_type; 2839 if (!info->shared && h->dynindx == -1 && tls_type >= GOT_TLS_IE) 2840 r_type = R_390_TLS_LE64; 2841 } 2842 if (r_type == R_390_TLS_GD64 && tls_type >= GOT_TLS_IE) 2843 r_type = R_390_TLS_IE64; 2844 2845 if (r_type == R_390_TLS_LE64) 2846 { 2847 /* This relocation gets optimized away by the local exec 2848 access optimization. */ 2849 BFD_ASSERT (! unresolved_reloc); 2850 bfd_put_64 (output_bfd, -tpoff (info, relocation), 2851 contents + rel->r_offset); 2852 continue; 2853 } 2854 2855 if (htab->elf.sgot == NULL) 2856 abort (); 2857 2858 if (h != NULL) 2859 off = h->got.offset; 2860 else 2861 { 2862 if (local_got_offsets == NULL) 2863 abort (); 2864 2865 off = local_got_offsets[r_symndx]; 2866 } 2867 2868 emit_tls_relocs: 2869 2870 if ((off & 1) != 0) 2871 off &= ~1; 2872 else 2873 { 2874 Elf_Internal_Rela outrel; 2875 bfd_byte *loc; 2876 int dr_type, indx; 2877 2878 if (htab->elf.srelgot == NULL) 2879 abort (); 2880 2881 outrel.r_offset = (htab->elf.sgot->output_section->vma 2882 + htab->elf.sgot->output_offset + off); 2883 2884 indx = h && h->dynindx != -1 ? h->dynindx : 0; 2885 if (r_type == R_390_TLS_GD64) 2886 dr_type = R_390_TLS_DTPMOD; 2887 else 2888 dr_type = R_390_TLS_TPOFF; 2889 if (dr_type == R_390_TLS_TPOFF && indx == 0) 2890 outrel.r_addend = relocation - dtpoff_base (info); 2891 else 2892 outrel.r_addend = 0; 2893 outrel.r_info = ELF64_R_INFO (indx, dr_type); 2894 loc = htab->elf.srelgot->contents; 2895 loc += htab->elf.srelgot->reloc_count++ 2896 * sizeof (Elf64_External_Rela); 2897 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc); 2898 2899 if (r_type == R_390_TLS_GD64) 2900 { 2901 if (indx == 0) 2902 { 2903 BFD_ASSERT (! unresolved_reloc); 2904 bfd_put_64 (output_bfd, 2905 relocation - dtpoff_base (info), 2906 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE); 2907 } 2908 else 2909 { 2910 outrel.r_info = ELF64_R_INFO (indx, R_390_TLS_DTPOFF); 2911 outrel.r_offset += GOT_ENTRY_SIZE; 2912 outrel.r_addend = 0; 2913 htab->elf.srelgot->reloc_count++; 2914 loc += sizeof (Elf64_External_Rela); 2915 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc); 2916 } 2917 } 2918 2919 if (h != NULL) 2920 h->got.offset |= 1; 2921 else 2922 local_got_offsets[r_symndx] |= 1; 2923 } 2924 2925 if (off >= (bfd_vma) -2) 2926 abort (); 2927 if (r_type == ELF64_R_TYPE (rel->r_info)) 2928 { 2929 relocation = htab->elf.sgot->output_offset + off; 2930 if (r_type == R_390_TLS_IE64 || r_type == R_390_TLS_IEENT) 2931 relocation += htab->elf.sgot->output_section->vma; 2932 unresolved_reloc = FALSE; 2933 } 2934 else 2935 { 2936 bfd_put_64 (output_bfd, htab->elf.sgot->output_offset + off, 2937 contents + rel->r_offset); 2938 continue; 2939 } 2940 break; 2941 2942 case R_390_TLS_GOTIE12: 2943 case R_390_TLS_GOTIE20: 2944 case R_390_TLS_IEENT: 2945 if (h == NULL) 2946 { 2947 if (local_got_offsets == NULL) 2948 abort(); 2949 off = local_got_offsets[r_symndx]; 2950 if (info->shared) 2951 goto emit_tls_relocs; 2952 } 2953 else 2954 { 2955 off = h->got.offset; 2956 tls_type = elf_s390_hash_entry(h)->tls_type; 2957 if (info->shared || h->dynindx != -1 || tls_type < GOT_TLS_IE) 2958 goto emit_tls_relocs; 2959 } 2960 2961 if (htab->elf.sgot == NULL) 2962 abort (); 2963 2964 BFD_ASSERT (! unresolved_reloc); 2965 bfd_put_64 (output_bfd, -tpoff (info, relocation), 2966 htab->elf.sgot->contents + off); 2967 relocation = htab->elf.sgot->output_offset + off; 2968 if (r_type == R_390_TLS_IEENT) 2969 relocation += htab->elf.sgot->output_section->vma; 2970 unresolved_reloc = FALSE; 2971 break; 2972 2973 case R_390_TLS_LDM64: 2974 if (! info->shared) 2975 /* The literal pool entry this relocation refers to gets ignored 2976 by the optimized code of the local exec model. Do nothing 2977 and the value will turn out zero. */ 2978 continue; 2979 2980 if (htab->elf.sgot == NULL) 2981 abort (); 2982 2983 off = htab->tls_ldm_got.offset; 2984 if (off & 1) 2985 off &= ~1; 2986 else 2987 { 2988 Elf_Internal_Rela outrel; 2989 bfd_byte *loc; 2990 2991 if (htab->elf.srelgot == NULL) 2992 abort (); 2993 2994 outrel.r_offset = (htab->elf.sgot->output_section->vma 2995 + htab->elf.sgot->output_offset + off); 2996 2997 bfd_put_64 (output_bfd, 0, 2998 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE); 2999 outrel.r_info = ELF64_R_INFO (0, R_390_TLS_DTPMOD); 3000 outrel.r_addend = 0; 3001 loc = htab->elf.srelgot->contents; 3002 loc += htab->elf.srelgot->reloc_count++ 3003 * sizeof (Elf64_External_Rela); 3004 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc); 3005 htab->tls_ldm_got.offset |= 1; 3006 } 3007 relocation = htab->elf.sgot->output_offset + off; 3008 unresolved_reloc = FALSE; 3009 break; 3010 3011 case R_390_TLS_LE64: 3012 if (info->shared) 3013 { 3014 /* Linking a shared library with non-fpic code requires 3015 a R_390_TLS_TPOFF relocation. */ 3016 Elf_Internal_Rela outrel; 3017 asection *sreloc; 3018 bfd_byte *loc; 3019 int indx; 3020 3021 outrel.r_offset = rel->r_offset 3022 + input_section->output_section->vma 3023 + input_section->output_offset; 3024 if (h != NULL && h->dynindx != -1) 3025 indx = h->dynindx; 3026 else 3027 indx = 0; 3028 outrel.r_info = ELF64_R_INFO (indx, R_390_TLS_TPOFF); 3029 if (indx == 0) 3030 outrel.r_addend = relocation - dtpoff_base (info); 3031 else 3032 outrel.r_addend = 0; 3033 sreloc = elf_section_data (input_section)->sreloc; 3034 if (sreloc == NULL) 3035 abort (); 3036 loc = sreloc->contents; 3037 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela); 3038 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc); 3039 } 3040 else 3041 { 3042 BFD_ASSERT (! unresolved_reloc); 3043 bfd_put_64 (output_bfd, -tpoff (info, relocation), 3044 contents + rel->r_offset); 3045 } 3046 continue; 3047 3048 case R_390_TLS_LDO64: 3049 if (info->shared || (input_section->flags & SEC_DEBUGGING)) 3050 relocation -= dtpoff_base (info); 3051 else 3052 /* When converting LDO to LE, we must negate. */ 3053 relocation = -tpoff (info, relocation); 3054 break; 3055 3056 /* Relocations for tls instructions. */ 3057 case R_390_TLS_LOAD: 3058 case R_390_TLS_GDCALL: 3059 case R_390_TLS_LDCALL: 3060 tls_type = GOT_UNKNOWN; 3061 if (h == NULL && local_got_offsets) 3062 tls_type = elf_s390_local_got_tls_type (input_bfd) [r_symndx]; 3063 else if (h != NULL) 3064 tls_type = elf_s390_hash_entry(h)->tls_type; 3065 3066 if (tls_type == GOT_TLS_GD) 3067 continue; 3068 3069 if (r_type == R_390_TLS_LOAD) 3070 { 3071 if (!info->shared && (h == NULL || h->dynindx == -1)) 3072 { 3073 /* IE->LE transition. Four valid cases: 3074 lg %rx,(0,%ry) -> sllg %rx,%ry,0 3075 lg %rx,(%ry,0) -> sllg %rx,%ry,0 3076 lg %rx,(%ry,%r12) -> sllg %rx,%ry,0 3077 lg %rx,(%r12,%ry) -> sllg %rx,%ry,0 */ 3078 unsigned int insn0, insn1, ry; 3079 3080 insn0 = bfd_get_32 (input_bfd, contents + rel->r_offset); 3081 insn1 = bfd_get_16 (input_bfd, contents + rel->r_offset + 4); 3082 if (insn1 != 0x0004) 3083 invalid_tls_insn (input_bfd, input_section, rel); 3084 ry = 0; 3085 if ((insn0 & 0xff00f000) == 0xe3000000) 3086 /* lg %rx,0(%ry,0) -> sllg %rx,%ry,0 */ 3087 ry = (insn0 & 0x000f0000); 3088 else if ((insn0 & 0xff0f0000) == 0xe3000000) 3089 /* lg %rx,0(0,%ry) -> sllg %rx,%ry,0 */ 3090 ry = (insn0 & 0x0000f000) << 4; 3091 else if ((insn0 & 0xff00f000) == 0xe300c000) 3092 /* lg %rx,0(%ry,%r12) -> sllg %rx,%ry,0 */ 3093 ry = (insn0 & 0x000f0000); 3094 else if ((insn0 & 0xff0f0000) == 0xe30c0000) 3095 /* lg %rx,0(%r12,%ry) -> sllg %rx,%ry,0 */ 3096 ry = (insn0 & 0x0000f000) << 4; 3097 else 3098 invalid_tls_insn (input_bfd, input_section, rel); 3099 insn0 = 0xeb000000 | (insn0 & 0x00f00000) | ry; 3100 insn1 = 0x000d; 3101 bfd_put_32 (output_bfd, insn0, contents + rel->r_offset); 3102 bfd_put_16 (output_bfd, insn1, contents + rel->r_offset + 4); 3103 } 3104 } 3105 else if (r_type == R_390_TLS_GDCALL) 3106 { 3107 unsigned int insn0, insn1; 3108 3109 insn0 = bfd_get_32 (input_bfd, contents + rel->r_offset); 3110 insn1 = bfd_get_16 (input_bfd, contents + rel->r_offset + 4); 3111 if ((insn0 & 0xffff0000) != 0xc0e50000) 3112 invalid_tls_insn (input_bfd, input_section, rel); 3113 if (!info->shared && (h == NULL || h->dynindx == -1)) 3114 { 3115 /* GD->LE transition. 3116 brasl %r14,__tls_get_addr@plt -> brcl 0,. */ 3117 insn0 = 0xc0040000; 3118 insn1 = 0x0000; 3119 } 3120 else 3121 { 3122 /* GD->IE transition. 3123 brasl %r14,__tls_get_addr@plt -> lg %r2,0(%r2,%r12) */ 3124 insn0 = 0xe322c000; 3125 insn1 = 0x0004; 3126 } 3127 bfd_put_32 (output_bfd, insn0, contents + rel->r_offset); 3128 bfd_put_16 (output_bfd, insn1, contents + rel->r_offset + 4); 3129 } 3130 else if (r_type == R_390_TLS_LDCALL) 3131 { 3132 if (!info->shared) 3133 { 3134 unsigned int insn0, insn1; 3135 3136 insn0 = bfd_get_32 (input_bfd, contents + rel->r_offset); 3137 insn1 = bfd_get_16 (input_bfd, contents + rel->r_offset + 4); 3138 if ((insn0 & 0xffff0000) != 0xc0e50000) 3139 invalid_tls_insn (input_bfd, input_section, rel); 3140 /* LD->LE transition. 3141 brasl %r14,__tls_get_addr@plt -> brcl 0,. */ 3142 insn0 = 0xc0040000; 3143 insn1 = 0x0000; 3144 bfd_put_32 (output_bfd, insn0, contents + rel->r_offset); 3145 bfd_put_16 (output_bfd, insn1, contents + rel->r_offset + 4); 3146 } 3147 } 3148 continue; 3149 3150 default: 3151 break; 3152 } 3153 3154 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections 3155 because such sections are not SEC_ALLOC and thus ld.so will 3156 not process them. */ 3157 if (unresolved_reloc 3158 && !((input_section->flags & SEC_DEBUGGING) != 0 3159 && h->def_dynamic) 3160 && _bfd_elf_section_offset (output_bfd, info, input_section, 3161 rel->r_offset) != (bfd_vma) -1) 3162 (*_bfd_error_handler) 3163 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"), 3164 input_bfd, 3165 input_section, 3166 (long) rel->r_offset, 3167 howto->name, 3168 h->root.root.string); 3169 3170 do_relocation: 3171 3172 if (r_type == R_390_20 3173 || r_type == R_390_GOT20 3174 || r_type == R_390_GOTPLT20 3175 || r_type == R_390_TLS_GOTIE20) 3176 { 3177 relocation += rel->r_addend; 3178 relocation = (relocation&0xfff) << 8 | (relocation&0xff000) >> 12; 3179 r = _bfd_final_link_relocate (howto, input_bfd, input_section, 3180 contents, rel->r_offset, 3181 relocation, 0); 3182 } 3183 else 3184 r = _bfd_final_link_relocate (howto, input_bfd, input_section, 3185 contents, rel->r_offset, 3186 relocation, rel->r_addend); 3187 3188 if (r != bfd_reloc_ok) 3189 { 3190 const char *name; 3191 3192 if (h != NULL) 3193 name = h->root.root.string; 3194 else 3195 { 3196 name = bfd_elf_string_from_elf_section (input_bfd, 3197 symtab_hdr->sh_link, 3198 sym->st_name); 3199 if (name == NULL) 3200 return FALSE; 3201 if (*name == '\0') 3202 name = bfd_section_name (input_bfd, sec); 3203 } 3204 3205 if (r == bfd_reloc_overflow) 3206 { 3207 3208 if (! ((*info->callbacks->reloc_overflow) 3209 (info, (h ? &h->root : NULL), name, howto->name, 3210 (bfd_vma) 0, input_bfd, input_section, 3211 rel->r_offset))) 3212 return FALSE; 3213 } 3214 else 3215 { 3216 (*_bfd_error_handler) 3217 (_("%B(%A+0x%lx): reloc against `%s': error %d"), 3218 input_bfd, input_section, 3219 (long) rel->r_offset, name, (int) r); 3220 return FALSE; 3221 } 3222 } 3223 } 3224 3225 return TRUE; 3226 } 3227 3228 /* Generate the PLT slots together with the dynamic relocations needed 3229 for IFUNC symbols. */ 3230 3231 static void 3232 elf_s390_finish_ifunc_symbol (bfd *output_bfd, 3233 struct bfd_link_info *info, 3234 struct elf_link_hash_entry *h, 3235 struct elf_s390_link_hash_table *htab, 3236 bfd_vma plt_offset, 3237 bfd_vma resolver_address) 3238 { 3239 bfd_vma plt_index; 3240 bfd_vma got_offset; 3241 Elf_Internal_Rela rela; 3242 bfd_byte *loc; 3243 asection *plt, *gotplt, *relplt; 3244 3245 if (htab->elf.iplt == NULL 3246 || htab->elf.igotplt == NULL 3247 || htab->elf.irelplt == NULL) 3248 abort (); 3249 3250 /* Index of the PLT slot within iplt section. */ 3251 plt_index = plt_offset / PLT_ENTRY_SIZE; 3252 plt = htab->elf.iplt; 3253 /* Offset into the igot.plt section. */ 3254 got_offset = plt_index * GOT_ENTRY_SIZE; 3255 gotplt = htab->elf.igotplt; 3256 relplt = htab->elf.irelplt; 3257 3258 /* Fill in the blueprint of a PLT. */ 3259 memcpy (plt->contents + plt_offset, elf_s390x_plt_entry, 3260 PLT_ENTRY_SIZE); 3261 3262 /* Fixup the relative address to the GOT entry */ 3263 bfd_put_32 (output_bfd, 3264 (gotplt->output_section->vma + 3265 gotplt->output_offset + got_offset 3266 - (plt->output_section->vma + 3267 plt->output_offset + 3268 plt_offset))/2, 3269 plt->contents + plt_offset + 2); 3270 /* Fixup the relative branch to PLT 0 */ 3271 bfd_put_32 (output_bfd, - (plt->output_offset + 3272 (PLT_ENTRY_SIZE * plt_index) + 22)/2, 3273 plt->contents + plt_offset + 24); 3274 /* Fixup offset into .rela.plt section. */ 3275 bfd_put_32 (output_bfd, relplt->output_offset + 3276 plt_index * sizeof (Elf64_External_Rela), 3277 plt->contents + plt_offset + 28); 3278 3279 /* Fill in the entry in the global offset table. 3280 Points to instruction after GOT offset. */ 3281 bfd_put_64 (output_bfd, 3282 (plt->output_section->vma 3283 + plt->output_offset 3284 + plt_offset 3285 + 14), 3286 gotplt->contents + got_offset); 3287 3288 /* Fill in the entry in the .rela.plt section. */ 3289 rela.r_offset = (gotplt->output_section->vma 3290 + gotplt->output_offset 3291 + got_offset); 3292 3293 if (!h 3294 || h->dynindx == -1 3295 || ((info->executable 3296 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT) 3297 && h->def_regular)) 3298 { 3299 /* The symbol can be locally resolved. */ 3300 rela.r_info = ELF64_R_INFO (0, R_390_IRELATIVE); 3301 rela.r_addend = resolver_address; 3302 } 3303 else 3304 { 3305 rela.r_info = ELF64_R_INFO (h->dynindx, R_390_JMP_SLOT); 3306 rela.r_addend = 0; 3307 } 3308 3309 loc = relplt->contents + plt_index * sizeof (Elf64_External_Rela); 3310 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc); 3311 } 3312 3313 3314 /* Finish up dynamic symbol handling. We set the contents of various 3315 dynamic sections here. */ 3316 3317 static bfd_boolean 3318 elf_s390_finish_dynamic_symbol (bfd *output_bfd, 3319 struct bfd_link_info *info, 3320 struct elf_link_hash_entry *h, 3321 Elf_Internal_Sym *sym) 3322 { 3323 struct elf_s390_link_hash_table *htab; 3324 struct elf_s390_link_hash_entry *eh = (struct elf_s390_link_hash_entry*)h; 3325 3326 htab = elf_s390_hash_table (info); 3327 if (htab == NULL) 3328 return FALSE; 3329 3330 if (h->plt.offset != (bfd_vma) -1) 3331 { 3332 bfd_vma plt_index; 3333 bfd_vma got_offset; 3334 Elf_Internal_Rela rela; 3335 bfd_byte *loc; 3336 3337 /* This symbol has an entry in the procedure linkage table. Set 3338 it up. */ 3339 if (s390_is_ifunc_symbol_p (h)) 3340 { 3341 /* If we can resolve the IFUNC symbol locally we generate an 3342 IRELATIVE reloc. */ 3343 elf_s390_finish_ifunc_symbol (output_bfd, info, h, htab, h->plt.offset, 3344 eh->ifunc_resolver_address + 3345 eh->ifunc_resolver_section->output_offset + 3346 eh->ifunc_resolver_section->output_section->vma); 3347 ; 3348 /* Fallthrough. Handling of explicit GOT slots of IFUNC 3349 symbols is below. */ 3350 } 3351 else 3352 { 3353 if (h->dynindx == -1 3354 || htab->elf.splt == NULL 3355 || htab->elf.sgotplt == NULL 3356 || htab->elf.srelplt == NULL) 3357 abort (); 3358 3359 /* Calc. index no. 3360 Current offset - size first entry / entry size. */ 3361 plt_index = (h->plt.offset - PLT_FIRST_ENTRY_SIZE) / PLT_ENTRY_SIZE; 3362 3363 /* Offset in GOT is PLT index plus GOT headers(3) times 8, 3364 addr & GOT addr. */ 3365 got_offset = (plt_index + 3) * GOT_ENTRY_SIZE; 3366 3367 /* Fill in the blueprint of a PLT. */ 3368 memcpy (htab->elf.splt->contents + h->plt.offset, elf_s390x_plt_entry, 3369 PLT_ENTRY_SIZE); 3370 3371 /* Fixup the relative address to the GOT entry */ 3372 bfd_put_32 (output_bfd, 3373 (htab->elf.sgotplt->output_section->vma + 3374 htab->elf.sgotplt->output_offset + got_offset 3375 - (htab->elf.splt->output_section->vma + 3376 htab->elf.splt->output_offset + 3377 h->plt.offset))/2, 3378 htab->elf.splt->contents + h->plt.offset + 2); 3379 /* Fixup the relative branch to PLT 0 */ 3380 bfd_put_32 (output_bfd, - (PLT_FIRST_ENTRY_SIZE + 3381 (PLT_ENTRY_SIZE * plt_index) + 22)/2, 3382 htab->elf.splt->contents + h->plt.offset + 24); 3383 /* Fixup offset into .rela.plt section. */ 3384 bfd_put_32 (output_bfd, plt_index * sizeof (Elf64_External_Rela), 3385 htab->elf.splt->contents + h->plt.offset + 28); 3386 3387 /* Fill in the entry in the global offset table. 3388 Points to instruction after GOT offset. */ 3389 bfd_put_64 (output_bfd, 3390 (htab->elf.splt->output_section->vma 3391 + htab->elf.splt->output_offset 3392 + h->plt.offset 3393 + 14), 3394 htab->elf.sgotplt->contents + got_offset); 3395 3396 /* Fill in the entry in the .rela.plt section. */ 3397 rela.r_offset = (htab->elf.sgotplt->output_section->vma 3398 + htab->elf.sgotplt->output_offset 3399 + got_offset); 3400 rela.r_info = ELF64_R_INFO (h->dynindx, R_390_JMP_SLOT); 3401 rela.r_addend = 0; 3402 loc = htab->elf.srelplt->contents + plt_index * 3403 sizeof (Elf64_External_Rela); 3404 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc); 3405 3406 if (!h->def_regular) 3407 { 3408 /* Mark the symbol as undefined, rather than as defined in 3409 the .plt section. Leave the value alone. This is a clue 3410 for the dynamic linker, to make function pointer 3411 comparisons work between an application and shared 3412 library. */ 3413 sym->st_shndx = SHN_UNDEF; 3414 } 3415 } 3416 } 3417 3418 if (h->got.offset != (bfd_vma) -1 3419 && elf_s390_hash_entry(h)->tls_type != GOT_TLS_GD 3420 && elf_s390_hash_entry(h)->tls_type != GOT_TLS_IE 3421 && elf_s390_hash_entry(h)->tls_type != GOT_TLS_IE_NLT) 3422 { 3423 Elf_Internal_Rela rela; 3424 bfd_byte *loc; 3425 3426 /* This symbol has an entry in the global offset table. Set it 3427 up. */ 3428 if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL) 3429 abort (); 3430 3431 rela.r_offset = (htab->elf.sgot->output_section->vma 3432 + htab->elf.sgot->output_offset 3433 + (h->got.offset &~ (bfd_vma) 1)); 3434 3435 if (h->def_regular && s390_is_ifunc_symbol_p (h)) 3436 { 3437 if (info->shared) 3438 { 3439 /* An explicit GOT slot usage needs GLOB_DAT. If the 3440 symbol references local the implicit got.iplt slot 3441 will be used and the IRELATIVE reloc has been created 3442 above. */ 3443 goto do_glob_dat; 3444 } 3445 else 3446 { 3447 /* For non-shared objects explicit GOT slots must be 3448 filled with the PLT slot address for pointer 3449 equality reasons. */ 3450 bfd_put_64 (output_bfd, (htab->elf.iplt->output_section->vma 3451 + htab->elf.iplt->output_offset 3452 + h->plt.offset), 3453 htab->elf.sgot->contents + h->got.offset); 3454 return TRUE; 3455 } 3456 } 3457 else if (info->shared 3458 && SYMBOL_REFERENCES_LOCAL (info, h)) 3459 { 3460 /* If this is a static link, or it is a -Bsymbolic link and 3461 the symbol is defined locally or was forced to be local 3462 because of a version file, we just want to emit a 3463 RELATIVE reloc. The entry in the global offset table 3464 will already have been initialized in the 3465 relocate_section function. */ 3466 if (!h->def_regular) 3467 return FALSE; 3468 BFD_ASSERT((h->got.offset & 1) != 0); 3469 rela.r_info = ELF64_R_INFO (0, R_390_RELATIVE); 3470 rela.r_addend = (h->root.u.def.value 3471 + h->root.u.def.section->output_section->vma 3472 + h->root.u.def.section->output_offset); 3473 } 3474 else 3475 { 3476 BFD_ASSERT((h->got.offset & 1) == 0); 3477 do_glob_dat: 3478 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgot->contents + h->got.offset); 3479 rela.r_info = ELF64_R_INFO (h->dynindx, R_390_GLOB_DAT); 3480 rela.r_addend = 0; 3481 } 3482 3483 loc = htab->elf.srelgot->contents; 3484 loc += htab->elf.srelgot->reloc_count++ * sizeof (Elf64_External_Rela); 3485 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc); 3486 } 3487 3488 if (h->needs_copy) 3489 { 3490 Elf_Internal_Rela rela; 3491 bfd_byte *loc; 3492 3493 /* This symbols needs a copy reloc. Set it up. */ 3494 3495 if (h->dynindx == -1 3496 || (h->root.type != bfd_link_hash_defined 3497 && h->root.type != bfd_link_hash_defweak) 3498 || htab->srelbss == NULL) 3499 abort (); 3500 3501 rela.r_offset = (h->root.u.def.value 3502 + h->root.u.def.section->output_section->vma 3503 + h->root.u.def.section->output_offset); 3504 rela.r_info = ELF64_R_INFO (h->dynindx, R_390_COPY); 3505 rela.r_addend = 0; 3506 loc = htab->srelbss->contents; 3507 loc += htab->srelbss->reloc_count++ * sizeof (Elf64_External_Rela); 3508 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc); 3509 } 3510 3511 /* Mark some specially defined symbols as absolute. */ 3512 if (strcmp (h->root.root.string, "_DYNAMIC") == 0 3513 || h == htab->elf.hgot 3514 || h == htab->elf.hplt) 3515 sym->st_shndx = SHN_ABS; 3516 3517 return TRUE; 3518 } 3519 3520 /* Used to decide how to sort relocs in an optimal manner for the 3521 dynamic linker, before writing them out. */ 3522 3523 static enum elf_reloc_type_class 3524 elf_s390_reloc_type_class (const Elf_Internal_Rela *rela) 3525 { 3526 switch ((int) ELF64_R_TYPE (rela->r_info)) 3527 { 3528 case R_390_RELATIVE: 3529 return reloc_class_relative; 3530 case R_390_JMP_SLOT: 3531 return reloc_class_plt; 3532 case R_390_COPY: 3533 return reloc_class_copy; 3534 default: 3535 return reloc_class_normal; 3536 } 3537 } 3538 3539 /* Finish up the dynamic sections. */ 3540 3541 static bfd_boolean 3542 elf_s390_finish_dynamic_sections (bfd *output_bfd, 3543 struct bfd_link_info *info) 3544 { 3545 struct elf_s390_link_hash_table *htab; 3546 bfd *dynobj; 3547 asection *sdyn; 3548 bfd *ibfd; 3549 unsigned int i; 3550 3551 htab = elf_s390_hash_table (info); 3552 if (htab == NULL) 3553 return FALSE; 3554 3555 dynobj = htab->elf.dynobj; 3556 sdyn = bfd_get_linker_section (dynobj, ".dynamic"); 3557 3558 if (htab->elf.dynamic_sections_created) 3559 { 3560 Elf64_External_Dyn *dyncon, *dynconend; 3561 3562 if (sdyn == NULL || htab->elf.sgot == NULL) 3563 abort (); 3564 3565 dyncon = (Elf64_External_Dyn *) sdyn->contents; 3566 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size); 3567 for (; dyncon < dynconend; dyncon++) 3568 { 3569 Elf_Internal_Dyn dyn; 3570 asection *s; 3571 3572 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn); 3573 3574 switch (dyn.d_tag) 3575 { 3576 default: 3577 continue; 3578 3579 case DT_PLTGOT: 3580 dyn.d_un.d_ptr = htab->elf.sgot->output_section->vma; 3581 break; 3582 3583 case DT_JMPREL: 3584 dyn.d_un.d_ptr = htab->elf.srelplt->output_section->vma; 3585 break; 3586 3587 case DT_PLTRELSZ: 3588 s = htab->elf.srelplt->output_section; 3589 dyn.d_un.d_val = s->size; 3590 break; 3591 3592 case DT_RELASZ: 3593 /* The procedure linkage table relocs (DT_JMPREL) should 3594 not be included in the overall relocs (DT_RELA). 3595 Therefore, we override the DT_RELASZ entry here to 3596 make it not include the JMPREL relocs. Since the 3597 linker script arranges for .rela.plt to follow all 3598 other relocation sections, we don't have to worry 3599 about changing the DT_RELA entry. */ 3600 s = htab->elf.srelplt->output_section; 3601 dyn.d_un.d_val -= s->size; 3602 break; 3603 } 3604 3605 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon); 3606 } 3607 3608 /* Fill in the special first entry in the procedure linkage table. */ 3609 if (htab->elf.splt && htab->elf.splt->size > 0) 3610 { 3611 /* fill in blueprint for plt 0 entry */ 3612 memcpy (htab->elf.splt->contents, elf_s390x_first_plt_entry, 3613 PLT_FIRST_ENTRY_SIZE); 3614 /* Fixup relative address to start of GOT */ 3615 bfd_put_32 (output_bfd, 3616 (htab->elf.sgotplt->output_section->vma + 3617 htab->elf.sgotplt->output_offset 3618 - htab->elf.splt->output_section->vma - 6)/2, 3619 htab->elf.splt->contents + 8); 3620 } 3621 elf_section_data (htab->elf.splt->output_section) 3622 ->this_hdr.sh_entsize = PLT_ENTRY_SIZE; 3623 } 3624 3625 if (htab->elf.sgotplt) 3626 { 3627 /* Fill in the first three entries in the global offset table. */ 3628 if (htab->elf.sgotplt->size > 0) 3629 { 3630 bfd_put_64 (output_bfd, 3631 (sdyn == NULL ? (bfd_vma) 0 3632 : sdyn->output_section->vma + sdyn->output_offset), 3633 htab->elf.sgotplt->contents); 3634 /* One entry for shared object struct ptr. */ 3635 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + 8); 3636 /* One entry for _dl_runtime_resolve. */ 3637 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + 12); 3638 } 3639 3640 elf_section_data (htab->elf.sgot->output_section) 3641 ->this_hdr.sh_entsize = 8; 3642 } 3643 3644 /* Finish dynamic symbol for local IFUNC symbols. */ 3645 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next) 3646 { 3647 struct plt_entry *local_plt; 3648 Elf_Internal_Sym *isym; 3649 Elf_Internal_Shdr *symtab_hdr; 3650 3651 symtab_hdr = &elf_symtab_hdr (ibfd); 3652 3653 local_plt = elf_s390_local_plt (ibfd); 3654 if (local_plt != NULL) 3655 for (i = 0; i < symtab_hdr->sh_info; i++) 3656 { 3657 if (local_plt[i].plt.offset != (bfd_vma) -1) 3658 { 3659 asection *sec = local_plt[i].sec; 3660 isym = bfd_sym_from_r_symndx (&htab->sym_cache, ibfd, i); 3661 if (isym == NULL) 3662 return FALSE; 3663 3664 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC) 3665 elf_s390_finish_ifunc_symbol (output_bfd, info, NULL, htab, 3666 local_plt[i].plt.offset, 3667 isym->st_value 3668 + sec->output_section->vma 3669 + sec->output_offset); 3670 3671 } 3672 } 3673 } 3674 3675 return TRUE; 3676 } 3677 3678 /* Return address for Ith PLT stub in section PLT, for relocation REL 3679 or (bfd_vma) -1 if it should not be included. */ 3680 3681 static bfd_vma 3682 elf_s390_plt_sym_val (bfd_vma i, const asection *plt, 3683 const arelent *rel ATTRIBUTE_UNUSED) 3684 { 3685 return plt->vma + PLT_FIRST_ENTRY_SIZE + i * PLT_ENTRY_SIZE; 3686 } 3687 3688 /* Why was the hash table entry size definition changed from 3689 ARCH_SIZE/8 to 4? This breaks the 64 bit dynamic linker and 3690 this is the only reason for the s390_elf64_size_info structure. */ 3691 3692 const struct elf_size_info s390_elf64_size_info = 3693 { 3694 sizeof (Elf64_External_Ehdr), 3695 sizeof (Elf64_External_Phdr), 3696 sizeof (Elf64_External_Shdr), 3697 sizeof (Elf64_External_Rel), 3698 sizeof (Elf64_External_Rela), 3699 sizeof (Elf64_External_Sym), 3700 sizeof (Elf64_External_Dyn), 3701 sizeof (Elf_External_Note), 3702 8, /* hash-table entry size. */ 3703 1, /* internal relocations per external relocations. */ 3704 64, /* arch_size. */ 3705 3, /* log_file_align. */ 3706 ELFCLASS64, EV_CURRENT, 3707 bfd_elf64_write_out_phdrs, 3708 bfd_elf64_write_shdrs_and_ehdr, 3709 bfd_elf64_checksum_contents, 3710 bfd_elf64_write_relocs, 3711 bfd_elf64_swap_symbol_in, 3712 bfd_elf64_swap_symbol_out, 3713 bfd_elf64_slurp_reloc_table, 3714 bfd_elf64_slurp_symbol_table, 3715 bfd_elf64_swap_dyn_in, 3716 bfd_elf64_swap_dyn_out, 3717 bfd_elf64_swap_reloc_in, 3718 bfd_elf64_swap_reloc_out, 3719 bfd_elf64_swap_reloca_in, 3720 bfd_elf64_swap_reloca_out 3721 }; 3722 3723 #define TARGET_BIG_SYM bfd_elf64_s390_vec 3724 #define TARGET_BIG_NAME "elf64-s390" 3725 #define ELF_ARCH bfd_arch_s390 3726 #define ELF_TARGET_ID S390_ELF_DATA 3727 #define ELF_MACHINE_CODE EM_S390 3728 #define ELF_MACHINE_ALT1 EM_S390_OLD 3729 #define ELF_MAXPAGESIZE 0x1000 3730 3731 #define elf_backend_size_info s390_elf64_size_info 3732 3733 #define elf_backend_can_gc_sections 1 3734 #define elf_backend_can_refcount 1 3735 #define elf_backend_want_got_plt 1 3736 #define elf_backend_plt_readonly 1 3737 #define elf_backend_want_plt_sym 0 3738 #define elf_backend_got_header_size 24 3739 #define elf_backend_rela_normal 1 3740 3741 #define elf_info_to_howto elf_s390_info_to_howto 3742 3743 #define bfd_elf64_bfd_is_local_label_name elf_s390_is_local_label_name 3744 #define bfd_elf64_bfd_link_hash_table_create elf_s390_link_hash_table_create 3745 #define bfd_elf64_bfd_reloc_type_lookup elf_s390_reloc_type_lookup 3746 #define bfd_elf64_bfd_reloc_name_lookup elf_s390_reloc_name_lookup 3747 3748 #define elf_backend_adjust_dynamic_symbol elf_s390_adjust_dynamic_symbol 3749 #define elf_backend_check_relocs elf_s390_check_relocs 3750 #define elf_backend_copy_indirect_symbol elf_s390_copy_indirect_symbol 3751 #define elf_backend_create_dynamic_sections elf_s390_create_dynamic_sections 3752 #define elf_backend_finish_dynamic_sections elf_s390_finish_dynamic_sections 3753 #define elf_backend_finish_dynamic_symbol elf_s390_finish_dynamic_symbol 3754 #define elf_backend_gc_mark_hook elf_s390_gc_mark_hook 3755 #define elf_backend_gc_sweep_hook elf_s390_gc_sweep_hook 3756 #define elf_backend_reloc_type_class elf_s390_reloc_type_class 3757 #define elf_backend_relocate_section elf_s390_relocate_section 3758 #define elf_backend_size_dynamic_sections elf_s390_size_dynamic_sections 3759 #define elf_backend_init_index_section _bfd_elf_init_1_index_section 3760 #define elf_backend_reloc_type_class elf_s390_reloc_type_class 3761 #define elf_backend_plt_sym_val elf_s390_plt_sym_val 3762 #define elf_backend_add_symbol_hook elf_s390_add_symbol_hook 3763 3764 #define bfd_elf64_mkobject elf_s390_mkobject 3765 #define elf_backend_object_p elf_s390_object_p 3766 3767 /* Enable ELF64 archive functions. */ 3768 #define bfd_elf64_archive_functions 3769 extern bfd_boolean bfd_elf64_archive_slurp_armap (bfd *); 3770 extern bfd_boolean bfd_elf64_archive_write_armap (bfd *, unsigned int, struct orl *, unsigned int, int); 3771 3772 #define bfd_elf64_archive_slurp_extended_name_table _bfd_archive_coff_slurp_extended_name_table 3773 #define bfd_elf64_archive_construct_extended_name_table _bfd_archive_coff_construct_extended_name_table 3774 #define bfd_elf64_archive_truncate_arname _bfd_archive_coff_truncate_arname 3775 #define bfd_elf64_archive_read_ar_hdr _bfd_archive_coff_read_ar_hdr 3776 #define bfd_elf64_archive_write_ar_hdr _bfd_archive_coff_write_ar_hdr 3777 #define bfd_elf64_archive_openr_next_archived_file _bfd_archive_coff_openr_next_archived_file 3778 #define bfd_elf64_archive_get_elt_at_index _bfd_archive_coff_get_elt_at_index 3779 #define bfd_elf64_archive_generic_stat_arch_elt _bfd_archive_coff_generic_stat_arch_elt 3780 #define bfd_elf64_archive_update_armap_timestamp _bfd_archive_coff_update_armap_timestamp 3781 3782 #include "elf64-target.h" 3783