OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [bfd/] [elf64-s390.c] - Blame information for rev 225

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.