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