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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [binutils-2.18.50/] [bfd/] [elf64-s390.c] - Blame information for rev 156

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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