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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [bfd/] [elf64-s390.c] - Blame information for rev 842

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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