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

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [bfd/] [elf64-s390.c] - Blame information for rev 163

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

Line No. Rev Author Line
1 14 khays
/* IBM S/390-specific support for 64-bit ELF
2
   Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
3 148 khays
   2010, 2011 Free Software Foundation, Inc.
4 14 khays
   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
  info = (struct bfd_link_info *) inf;
1684
  htab = elf_s390_hash_table (info);
1685
  if (htab == NULL)
1686
    return FALSE;
1687
 
1688
  if (htab->elf.dynamic_sections_created
1689
      && h->plt.refcount > 0)
1690
    {
1691
      /* Make sure this symbol is output as a dynamic symbol.
1692
         Undefined weak syms won't yet be marked as dynamic.  */
1693
      if (h->dynindx == -1
1694
          && !h->forced_local)
1695
        {
1696
          if (! bfd_elf_link_record_dynamic_symbol (info, h))
1697
            return FALSE;
1698
        }
1699
 
1700
      if (info->shared
1701
          || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
1702
        {
1703
          asection *s = htab->splt;
1704
 
1705
          /* If this is the first .plt entry, make room for the special
1706
             first entry.  */
1707
          if (s->size == 0)
1708
            s->size += PLT_FIRST_ENTRY_SIZE;
1709
 
1710
          h->plt.offset = s->size;
1711
 
1712
          /* If this symbol is not defined in a regular file, and we are
1713
             not generating a shared library, then set the symbol to this
1714
             location in the .plt.  This is required to make function
1715
             pointers compare as equal between the normal executable and
1716
             the shared library.  */
1717
          if (! info->shared
1718
              && !h->def_regular)
1719
            {
1720
              h->root.u.def.section = s;
1721
              h->root.u.def.value = h->plt.offset;
1722
            }
1723
 
1724
          /* Make room for this entry.  */
1725
          s->size += PLT_ENTRY_SIZE;
1726
 
1727
          /* We also need to make an entry in the .got.plt section, which
1728
             will be placed in the .got section by the linker script.  */
1729
          htab->sgotplt->size += GOT_ENTRY_SIZE;
1730
 
1731
          /* We also need to make an entry in the .rela.plt section.  */
1732
          htab->srelplt->size += sizeof (Elf64_External_Rela);
1733
        }
1734
      else
1735
        {
1736
          h->plt.offset = (bfd_vma) -1;
1737
          h->needs_plt = 0;
1738
          elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h);
1739
        }
1740
    }
1741
  else
1742
    {
1743
      h->plt.offset = (bfd_vma) -1;
1744
      h->needs_plt = 0;
1745
      elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h);
1746
    }
1747
 
1748
  /* If R_390_TLS_{IE64,GOTIE64,GOTIE12,IEENT} symbol is now local to
1749
     the binary, we can optimize a bit. IE64 and GOTIE64 get converted
1750
     to R_390_TLS_LE64 requiring no TLS entry. For GOTIE12 and IEENT
1751
     we can save the dynamic TLS relocation.  */
1752
  if (h->got.refcount > 0
1753
      && !info->shared
1754
      && h->dynindx == -1
1755
      && elf_s390_hash_entry(h)->tls_type >= GOT_TLS_IE)
1756
    {
1757
      if (elf_s390_hash_entry(h)->tls_type == GOT_TLS_IE_NLT)
1758
        /* For the GOTIE access without a literal pool entry the offset has
1759
           to be stored somewhere. The immediate value in the instruction
1760
           is not bit enough so the value is stored in the got.  */
1761
        {
1762
          h->got.offset = htab->sgot->size;
1763
          htab->sgot->size += GOT_ENTRY_SIZE;
1764
        }
1765
      else
1766
        h->got.offset = (bfd_vma) -1;
1767
    }
1768
  else if (h->got.refcount > 0)
1769
    {
1770
      asection *s;
1771
      bfd_boolean dyn;
1772
      int tls_type = elf_s390_hash_entry(h)->tls_type;
1773
 
1774
      /* Make sure this symbol is output as a dynamic symbol.
1775
         Undefined weak syms won't yet be marked as dynamic.  */
1776
      if (h->dynindx == -1
1777
          && !h->forced_local)
1778
        {
1779
          if (! bfd_elf_link_record_dynamic_symbol (info, h))
1780
            return FALSE;
1781
        }
1782
 
1783
      s = htab->sgot;
1784
      h->got.offset = s->size;
1785
      s->size += GOT_ENTRY_SIZE;
1786
      /* R_390_TLS_GD64 needs 2 consecutive GOT slots.  */
1787
      if (tls_type == GOT_TLS_GD)
1788
        s->size += GOT_ENTRY_SIZE;
1789
      dyn = htab->elf.dynamic_sections_created;
1790
      /* R_390_TLS_IE64 needs one dynamic relocation,
1791
         R_390_TLS_GD64 needs one if local symbol and two if global.  */
1792
      if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
1793
          || tls_type >= GOT_TLS_IE)
1794
        htab->srelgot->size += sizeof (Elf64_External_Rela);
1795
      else if (tls_type == GOT_TLS_GD)
1796
        htab->srelgot->size += 2 * sizeof (Elf64_External_Rela);
1797
      else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1798
                || h->root.type != bfd_link_hash_undefweak)
1799
               && (info->shared
1800
                   || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
1801
        htab->srelgot->size += sizeof (Elf64_External_Rela);
1802
    }
1803
  else
1804
    h->got.offset = (bfd_vma) -1;
1805
 
1806
  eh = (struct elf_s390_link_hash_entry *) h;
1807
  if (eh->dyn_relocs == NULL)
1808
    return TRUE;
1809
 
1810
  /* In the shared -Bsymbolic case, discard space allocated for
1811
     dynamic pc-relative relocs against symbols which turn out to be
1812
     defined in regular objects.  For the normal shared case, discard
1813
     space for pc-relative relocs that have become local due to symbol
1814
     visibility changes.  */
1815
 
1816
  if (info->shared)
1817
    {
1818
      if (SYMBOL_CALLS_LOCAL (info, h))
1819
        {
1820
          struct elf_s390_dyn_relocs **pp;
1821
 
1822
          for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1823
            {
1824
              p->count -= p->pc_count;
1825
              p->pc_count = 0;
1826
              if (p->count == 0)
1827
                *pp = p->next;
1828
              else
1829
                pp = &p->next;
1830
            }
1831
        }
1832
 
1833
      /* Also discard relocs on undefined weak syms with non-default
1834
         visibility.  */
1835
      if (eh->dyn_relocs != NULL
1836
          && h->root.type == bfd_link_hash_undefweak)
1837
        {
1838
          if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1839
            eh->dyn_relocs = NULL;
1840
 
1841
          /* Make sure undefined weak symbols are output as a dynamic
1842
             symbol in PIEs.  */
1843
          else if (h->dynindx == -1
1844
                   && !h->forced_local)
1845
            {
1846
              if (! bfd_elf_link_record_dynamic_symbol (info, h))
1847
                return FALSE;
1848
            }
1849
        }
1850
    }
1851
  else if (ELIMINATE_COPY_RELOCS)
1852
    {
1853
      /* For the non-shared case, discard space for relocs against
1854
         symbols which turn out to need copy relocs or are not
1855
         dynamic.  */
1856
 
1857
      if (!h->non_got_ref
1858
          && ((h->def_dynamic
1859
               && !h->def_regular)
1860
              || (htab->elf.dynamic_sections_created
1861
                  && (h->root.type == bfd_link_hash_undefweak
1862
                      || h->root.type == bfd_link_hash_undefined))))
1863
        {
1864
          /* Make sure this symbol is output as a dynamic symbol.
1865
             Undefined weak syms won't yet be marked as dynamic.  */
1866
          if (h->dynindx == -1
1867
              && !h->forced_local)
1868
            {
1869
              if (! bfd_elf_link_record_dynamic_symbol (info, h))
1870
                return FALSE;
1871
            }
1872
 
1873
          /* If that succeeded, we know we'll be keeping all the
1874
             relocs.  */
1875
          if (h->dynindx != -1)
1876
            goto keep;
1877
        }
1878
 
1879
      eh->dyn_relocs = NULL;
1880
 
1881
    keep: ;
1882
    }
1883
 
1884
  /* Finally, allocate space.  */
1885
  for (p = eh->dyn_relocs; p != NULL; p = p->next)
1886
    {
1887
      asection *sreloc = elf_section_data (p->sec)->sreloc;
1888
      sreloc->size += p->count * sizeof (Elf64_External_Rela);
1889
    }
1890
 
1891
  return TRUE;
1892
}
1893
 
1894
/* Find any dynamic relocs that apply to read-only sections.  */
1895
 
1896
static bfd_boolean
1897
readonly_dynrelocs (h, inf)
1898
     struct elf_link_hash_entry *h;
1899
     PTR inf;
1900
{
1901
  struct elf_s390_link_hash_entry *eh;
1902
  struct elf_s390_dyn_relocs *p;
1903
 
1904
  eh = (struct elf_s390_link_hash_entry *) h;
1905
  for (p = eh->dyn_relocs; p != NULL; p = p->next)
1906
    {
1907
      asection *s = p->sec->output_section;
1908
 
1909
      if (s != NULL && (s->flags & SEC_READONLY) != 0)
1910
        {
1911
          struct bfd_link_info *info = (struct bfd_link_info *) inf;
1912
 
1913
          info->flags |= DF_TEXTREL;
1914
 
1915
          /* Not an error, just cut short the traversal.  */
1916
          return FALSE;
1917
        }
1918
    }
1919
  return TRUE;
1920
}
1921
 
1922
/* Set the sizes of the dynamic sections.  */
1923
 
1924
static bfd_boolean
1925
elf_s390_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1926
                                struct bfd_link_info *info)
1927
{
1928
  struct elf_s390_link_hash_table *htab;
1929
  bfd *dynobj;
1930
  asection *s;
1931
  bfd_boolean relocs;
1932
  bfd *ibfd;
1933
 
1934
  htab = elf_s390_hash_table (info);
1935
  if (htab == NULL)
1936
    return FALSE;
1937
 
1938
  dynobj = htab->elf.dynobj;
1939
  if (dynobj == NULL)
1940
    abort ();
1941
 
1942
  if (htab->elf.dynamic_sections_created)
1943
    {
1944
      /* Set the contents of the .interp section to the interpreter.  */
1945
      if (info->executable)
1946
        {
1947
          s = bfd_get_section_by_name (dynobj, ".interp");
1948
          if (s == NULL)
1949
            abort ();
1950
          s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1951
          s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1952
        }
1953
    }
1954
 
1955
  /* Set up .got offsets for local syms, and space for local dynamic
1956
     relocs.  */
1957
  for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1958
    {
1959
      bfd_signed_vma *local_got;
1960
      bfd_signed_vma *end_local_got;
1961
      char *local_tls_type;
1962
      bfd_size_type locsymcount;
1963
      Elf_Internal_Shdr *symtab_hdr;
1964
      asection *srela;
1965
 
1966
      if (! is_s390_elf (ibfd))
1967
        continue;
1968
 
1969
      for (s = ibfd->sections; s != NULL; s = s->next)
1970
        {
1971
          struct elf_s390_dyn_relocs *p;
1972
 
1973
          for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
1974
            {
1975
              if (!bfd_is_abs_section (p->sec)
1976
                  && bfd_is_abs_section (p->sec->output_section))
1977
                {
1978
                  /* Input section has been discarded, either because
1979
                     it is a copy of a linkonce section or due to
1980
                     linker script /DISCARD/, so we'll be discarding
1981
                     the relocs too.  */
1982
                }
1983
              else if (p->count != 0)
1984
                {
1985
                  srela = elf_section_data (p->sec)->sreloc;
1986
                  srela->size += p->count * sizeof (Elf64_External_Rela);
1987
                  if ((p->sec->output_section->flags & SEC_READONLY) != 0)
1988
                    info->flags |= DF_TEXTREL;
1989
                }
1990
            }
1991
        }
1992
 
1993
      local_got = elf_local_got_refcounts (ibfd);
1994
      if (!local_got)
1995
        continue;
1996
 
1997
      symtab_hdr = &elf_symtab_hdr (ibfd);
1998
      locsymcount = symtab_hdr->sh_info;
1999
      end_local_got = local_got + locsymcount;
2000
      local_tls_type = elf_s390_local_got_tls_type (ibfd);
2001
      s = htab->sgot;
2002
      srela = htab->srelgot;
2003
      for (; local_got < end_local_got; ++local_got, ++local_tls_type)
2004
        {
2005
          if (*local_got > 0)
2006
            {
2007
              *local_got = s->size;
2008
              s->size += GOT_ENTRY_SIZE;
2009
              if (*local_tls_type == GOT_TLS_GD)
2010
                s->size += GOT_ENTRY_SIZE;
2011
              if (info->shared)
2012
                srela->size += sizeof (Elf64_External_Rela);
2013
            }
2014
          else
2015
            *local_got = (bfd_vma) -1;
2016
        }
2017
    }
2018
 
2019
  if (htab->tls_ldm_got.refcount > 0)
2020
    {
2021
      /* Allocate 2 got entries and 1 dynamic reloc for R_390_TLS_LDM64
2022
         relocs.  */
2023
      htab->tls_ldm_got.offset = htab->sgot->size;
2024
      htab->sgot->size += 2 * GOT_ENTRY_SIZE;
2025
      htab->srelgot->size += sizeof (Elf64_External_Rela);
2026
    }
2027
  else
2028
    htab->tls_ldm_got.offset = -1;
2029
 
2030
  /* Allocate global sym .plt and .got entries, and space for global
2031
     sym dynamic relocs.  */
2032
  elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
2033
 
2034
  /* We now have determined the sizes of the various dynamic sections.
2035
     Allocate memory for them.  */
2036
  relocs = FALSE;
2037
  for (s = dynobj->sections; s != NULL; s = s->next)
2038
    {
2039
      if ((s->flags & SEC_LINKER_CREATED) == 0)
2040
        continue;
2041
 
2042
      if (s == htab->splt
2043
          || s == htab->sgot
2044
          || s == htab->sgotplt
2045
          || s == htab->sdynbss)
2046
        {
2047
          /* Strip this section if we don't need it; see the
2048
             comment below.  */
2049
        }
2050
      else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2051
        {
2052
          if (s->size != 0 && s != htab->srelplt)
2053
            relocs = TRUE;
2054
 
2055
          /* We use the reloc_count field as a counter if we need
2056
             to copy relocs into the output file.  */
2057
          s->reloc_count = 0;
2058
        }
2059
      else
2060
        {
2061
          /* It's not one of our sections, so don't allocate space.  */
2062
          continue;
2063
        }
2064
 
2065
      if (s->size == 0)
2066
        {
2067
          /* If we don't need this section, strip it from the
2068
             output file.  This is to handle .rela.bss and
2069
             .rela.plt.  We must create it in
2070
             create_dynamic_sections, because it must be created
2071
             before the linker maps input sections to output
2072
             sections.  The linker does that before
2073
             adjust_dynamic_symbol is called, and it is that
2074
             function which decides whether anything needs to go
2075
             into these sections.  */
2076
 
2077
          s->flags |= SEC_EXCLUDE;
2078
          continue;
2079
        }
2080
 
2081
      if ((s->flags & SEC_HAS_CONTENTS) == 0)
2082
        continue;
2083
 
2084
      /* Allocate memory for the section contents.  We use bfd_zalloc
2085
         here in case unused entries are not reclaimed before the
2086
         section's contents are written out.  This should not happen,
2087
         but this way if it does, we get a R_390_NONE reloc instead
2088
         of garbage.  */
2089
      s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2090
      if (s->contents == NULL)
2091
        return FALSE;
2092
    }
2093
 
2094
  if (htab->elf.dynamic_sections_created)
2095
    {
2096
      /* Add some entries to the .dynamic section.  We fill in the
2097
         values later, in elf_s390_finish_dynamic_sections, but we
2098
         must add the entries now so that we get the correct size for
2099
         the .dynamic section.  The DT_DEBUG entry is filled in by the
2100
         dynamic linker and used by the debugger.  */
2101
#define add_dynamic_entry(TAG, VAL) \
2102
  _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2103
 
2104
      if (info->executable)
2105
        {
2106
          if (!add_dynamic_entry (DT_DEBUG, 0))
2107
            return FALSE;
2108
        }
2109
 
2110
      if (htab->splt->size != 0)
2111
        {
2112
          if (!add_dynamic_entry (DT_PLTGOT, 0)
2113
              || !add_dynamic_entry (DT_PLTRELSZ, 0)
2114
              || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2115
              || !add_dynamic_entry (DT_JMPREL, 0))
2116
            return FALSE;
2117
        }
2118
 
2119
      if (relocs)
2120
        {
2121
          if (!add_dynamic_entry (DT_RELA, 0)
2122
              || !add_dynamic_entry (DT_RELASZ, 0)
2123
              || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
2124
            return FALSE;
2125
 
2126
          /* If any dynamic relocs apply to a read-only section,
2127
             then we need a DT_TEXTREL entry.  */
2128
          if ((info->flags & DF_TEXTREL) == 0)
2129
            elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
2130
                                    (PTR) info);
2131
 
2132
          if ((info->flags & DF_TEXTREL) != 0)
2133
            {
2134
              if (!add_dynamic_entry (DT_TEXTREL, 0))
2135
                return FALSE;
2136
            }
2137
        }
2138
    }
2139
#undef add_dynamic_entry
2140
 
2141
  return TRUE;
2142
}
2143
 
2144
/* Return the base VMA address which should be subtracted from real addresses
2145
   when resolving @dtpoff relocation.
2146
   This is PT_TLS segment p_vaddr.  */
2147
 
2148
static bfd_vma
2149
dtpoff_base (info)
2150
     struct bfd_link_info *info;
2151
{
2152
  /* If tls_sec is NULL, we should have signalled an error already.  */
2153
  if (elf_hash_table (info)->tls_sec == NULL)
2154
    return 0;
2155
  return elf_hash_table (info)->tls_sec->vma;
2156
}
2157
 
2158
/* Return the relocation value for @tpoff relocation
2159
   if STT_TLS virtual address is ADDRESS.  */
2160
 
2161
static bfd_vma
2162
tpoff (info, address)
2163
     struct bfd_link_info *info;
2164
     bfd_vma address;
2165
{
2166
  struct elf_link_hash_table *htab = elf_hash_table (info);
2167
 
2168
  /* If tls_sec is NULL, we should have signalled an error already.  */
2169
  if (htab->tls_sec == NULL)
2170
    return 0;
2171
  return htab->tls_size + htab->tls_sec->vma - address;
2172
}
2173
 
2174
/* Complain if TLS instruction relocation is against an invalid
2175
   instruction.  */
2176
 
2177
static void
2178
invalid_tls_insn (input_bfd, input_section, rel)
2179
     bfd *input_bfd;
2180
     asection *input_section;
2181
     Elf_Internal_Rela *rel;
2182
{
2183
  reloc_howto_type *howto;
2184
 
2185
  howto = elf_howto_table + ELF64_R_TYPE (rel->r_info);
2186
  (*_bfd_error_handler)
2187
    (_("%B(%A+0x%lx): invalid instruction for TLS relocation %s"),
2188
     input_bfd,
2189
     input_section,
2190
     (long) rel->r_offset,
2191
     howto->name);
2192
  bfd_set_error (bfd_error_bad_value);
2193
}
2194
 
2195
/* Relocate a 390 ELF section.  */
2196
 
2197
static bfd_boolean
2198
elf_s390_relocate_section (bfd *output_bfd,
2199
                           struct bfd_link_info *info,
2200
                           bfd *input_bfd,
2201
                           asection *input_section,
2202
                           bfd_byte *contents,
2203
                           Elf_Internal_Rela *relocs,
2204
                           Elf_Internal_Sym *local_syms,
2205
                           asection **local_sections)
2206
{
2207
  struct elf_s390_link_hash_table *htab;
2208
  Elf_Internal_Shdr *symtab_hdr;
2209
  struct elf_link_hash_entry **sym_hashes;
2210
  bfd_vma *local_got_offsets;
2211
  Elf_Internal_Rela *rel;
2212
  Elf_Internal_Rela *relend;
2213
 
2214
  BFD_ASSERT (is_s390_elf (input_bfd));
2215
 
2216
  htab = elf_s390_hash_table (info);
2217
  if (htab == NULL)
2218
    return FALSE;
2219
 
2220
  symtab_hdr = &elf_symtab_hdr (input_bfd);
2221
  sym_hashes = elf_sym_hashes (input_bfd);
2222
  local_got_offsets = elf_local_got_offsets (input_bfd);
2223
 
2224
  rel = relocs;
2225
  relend = relocs + input_section->reloc_count;
2226
  for (; rel < relend; rel++)
2227
    {
2228
      unsigned int r_type;
2229
      reloc_howto_type *howto;
2230
      unsigned long r_symndx;
2231
      struct elf_link_hash_entry *h;
2232
      Elf_Internal_Sym *sym;
2233
      asection *sec;
2234
      bfd_vma off;
2235
      bfd_vma relocation;
2236
      bfd_boolean unresolved_reloc;
2237
      bfd_reloc_status_type r;
2238
      int tls_type;
2239
 
2240
      r_type = ELF64_R_TYPE (rel->r_info);
2241
      if (r_type == (int) R_390_GNU_VTINHERIT
2242
          || r_type == (int) R_390_GNU_VTENTRY)
2243
        continue;
2244
      if (r_type >= (int) R_390_max)
2245
        {
2246
          bfd_set_error (bfd_error_bad_value);
2247
          return FALSE;
2248
        }
2249
 
2250
      howto = elf_howto_table + r_type;
2251
      r_symndx = ELF64_R_SYM (rel->r_info);
2252
 
2253
      h = NULL;
2254
      sym = NULL;
2255
      sec = NULL;
2256
      unresolved_reloc = FALSE;
2257
      if (r_symndx < symtab_hdr->sh_info)
2258
        {
2259
          sym = local_syms + r_symndx;
2260
          sec = local_sections[r_symndx];
2261
          relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2262
        }
2263
      else
2264
        {
2265
          bfd_boolean warned ATTRIBUTE_UNUSED;
2266
 
2267
          RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2268
                                   r_symndx, symtab_hdr, sym_hashes,
2269
                                   h, sec, relocation,
2270
                                   unresolved_reloc, warned);
2271
        }
2272
 
2273
      if (sec != NULL && elf_discarded_section (sec))
2274
        RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
2275
                                         rel, relend, howto, contents);
2276
 
2277
      if (info->relocatable)
2278
        continue;
2279
 
2280
      switch (r_type)
2281
        {
2282
        case R_390_GOTPLT12:
2283
        case R_390_GOTPLT16:
2284
        case R_390_GOTPLT20:
2285
        case R_390_GOTPLT32:
2286
        case R_390_GOTPLT64:
2287
        case R_390_GOTPLTENT:
2288
          /* There are three cases for a GOTPLT relocation. 1) The
2289
             relocation is against the jump slot entry of a plt that
2290
             will get emitted to the output file. 2) The relocation
2291
             is against the jump slot of a plt entry that has been
2292
             removed. elf_s390_adjust_gotplt has created a GOT entry
2293
             as replacement. 3) The relocation is against a local symbol.
2294
             Cases 2) and 3) are the same as the GOT relocation code
2295
             so we just have to test for case 1 and fall through for
2296
             the other two.  */
2297
          if (h != NULL && h->plt.offset != (bfd_vma) -1)
2298
            {
2299
              bfd_vma plt_index;
2300
 
2301
              /* Calc. index no.
2302
                 Current offset - size first entry / entry size.  */
2303
              plt_index = (h->plt.offset - PLT_FIRST_ENTRY_SIZE) /
2304
                PLT_ENTRY_SIZE;
2305
 
2306
              /* Offset in GOT is PLT index plus GOT headers(3) times 4,
2307
                 addr & GOT addr.  */
2308
              relocation = (plt_index + 3) * GOT_ENTRY_SIZE;
2309
              unresolved_reloc = FALSE;
2310
 
2311
              if (r_type == R_390_GOTPLTENT)
2312
                relocation += htab->sgot->output_section->vma;
2313
              break;
2314
            }
2315
          /* Fall through.  */
2316
 
2317
        case R_390_GOT12:
2318
        case R_390_GOT16:
2319
        case R_390_GOT20:
2320
        case R_390_GOT32:
2321
        case R_390_GOT64:
2322
        case R_390_GOTENT:
2323
          /* Relocation is to the entry for this symbol in the global
2324
             offset table.  */
2325
          if (htab->sgot == NULL)
2326
            abort ();
2327
 
2328
          if (h != NULL)
2329
            {
2330
              bfd_boolean dyn;
2331
 
2332
              off = h->got.offset;
2333
              dyn = htab->elf.dynamic_sections_created;
2334
              if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2335
                  || (info->shared
2336
                      && SYMBOL_REFERENCES_LOCAL (info, h))
2337
                  || (ELF_ST_VISIBILITY (h->other)
2338
                      && h->root.type == bfd_link_hash_undefweak))
2339
                {
2340
                  /* This is actually a static link, or it is a
2341
                     -Bsymbolic link and the symbol is defined
2342
                     locally, or the symbol was forced to be local
2343
                     because of a version file.  We must initialize
2344
                     this entry in the global offset table.  Since the
2345
                     offset must always be a multiple of 2, we use the
2346
                     least significant bit to record whether we have
2347
                     initialized it already.
2348
 
2349
                     When doing a dynamic link, we create a .rel.got
2350
                     relocation entry to initialize the value.  This
2351
                     is done in the finish_dynamic_symbol routine.  */
2352
                  if ((off & 1) != 0)
2353
                    off &= ~1;
2354
                  else
2355
                    {
2356
                      bfd_put_64 (output_bfd, relocation,
2357
                                  htab->sgot->contents + off);
2358
                      h->got.offset |= 1;
2359
                    }
2360
                }
2361
              else
2362
                unresolved_reloc = FALSE;
2363
            }
2364
          else
2365
            {
2366
              if (local_got_offsets == NULL)
2367
                abort ();
2368
 
2369
              off = local_got_offsets[r_symndx];
2370
 
2371
              /* The offset must always be a multiple of 8.  We use
2372
                 the least significant bit to record whether we have
2373
                 already generated the necessary reloc.  */
2374
              if ((off & 1) != 0)
2375
                off &= ~1;
2376
              else
2377
                {
2378
                  bfd_put_64 (output_bfd, relocation,
2379
                              htab->sgot->contents + off);
2380
 
2381
                  if (info->shared)
2382
                    {
2383
                      asection *s;
2384
                      Elf_Internal_Rela outrel;
2385
                      bfd_byte *loc;
2386
 
2387
                      s = htab->srelgot;
2388
                      if (s == NULL)
2389
                        abort ();
2390
 
2391
                      outrel.r_offset = (htab->sgot->output_section->vma
2392
                                         + htab->sgot->output_offset
2393
                                         + off);
2394
                      outrel.r_info = ELF64_R_INFO (0, R_390_RELATIVE);
2395
                      outrel.r_addend = relocation;
2396
                      loc = s->contents;
2397
                      loc += s->reloc_count++ * sizeof (Elf64_External_Rela);
2398
                      bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2399
                    }
2400
 
2401
                  local_got_offsets[r_symndx] |= 1;
2402
                }
2403
            }
2404
 
2405
          if (off >= (bfd_vma) -2)
2406
            abort ();
2407
 
2408
          relocation = htab->sgot->output_offset + off;
2409
 
2410
          /* For @GOTENT the relocation is against the offset between
2411
             the instruction and the symbols entry in the GOT and not
2412
             between the start of the GOT and the symbols entry. We
2413
             add the vma of the GOT to get the correct value.  */
2414
          if (   r_type == R_390_GOTENT
2415
              || r_type == R_390_GOTPLTENT)
2416
            relocation += htab->sgot->output_section->vma;
2417
 
2418
          break;
2419
 
2420
        case R_390_GOTOFF16:
2421
        case R_390_GOTOFF32:
2422
        case R_390_GOTOFF64:
2423
          /* Relocation is relative to the start of the global offset
2424
             table.  */
2425
 
2426
          /* Note that sgot->output_offset is not involved in this
2427
             calculation.  We always want the start of .got.  If we
2428
             defined _GLOBAL_OFFSET_TABLE in a different way, as is
2429
             permitted by the ABI, we might have to change this
2430
             calculation.  */
2431
          relocation -= htab->sgot->output_section->vma;
2432
          break;
2433
 
2434
        case R_390_GOTPC:
2435
        case R_390_GOTPCDBL:
2436
          /* Use global offset table as symbol value.  */
2437
          relocation = htab->sgot->output_section->vma;
2438
          unresolved_reloc = FALSE;
2439
          break;
2440
 
2441
        case R_390_PLT16DBL:
2442
        case R_390_PLT32:
2443
        case R_390_PLT32DBL:
2444
        case R_390_PLT64:
2445
          /* Relocation is to the entry for this symbol in the
2446
             procedure linkage table.  */
2447
 
2448
          /* Resolve a PLT32 reloc against a local symbol directly,
2449
             without using the procedure linkage table.  */
2450
          if (h == NULL)
2451
            break;
2452
 
2453
          if (h->plt.offset == (bfd_vma) -1
2454
              || htab->splt == NULL)
2455
            {
2456
              /* We didn't make a PLT entry for this symbol.  This
2457
                 happens when statically linking PIC code, or when
2458
                 using -Bsymbolic.  */
2459
              break;
2460
            }
2461
 
2462
          relocation = (htab->splt->output_section->vma
2463
                        + htab->splt->output_offset
2464
                        + h->plt.offset);
2465
          unresolved_reloc = FALSE;
2466
          break;
2467
 
2468
        case R_390_PLTOFF16:
2469
        case R_390_PLTOFF32:
2470
        case R_390_PLTOFF64:
2471
          /* Relocation is to the entry for this symbol in the
2472
             procedure linkage table relative to the start of the GOT.  */
2473
 
2474
          /* For local symbols or if we didn't make a PLT entry for
2475
             this symbol resolve the symbol directly.  */
2476
          if (   h == NULL
2477
              || h->plt.offset == (bfd_vma) -1
2478
              || htab->splt == NULL)
2479
            {
2480
              relocation -= htab->sgot->output_section->vma;
2481
              break;
2482
            }
2483
 
2484
          relocation = (htab->splt->output_section->vma
2485
                        + htab->splt->output_offset
2486
                        + h->plt.offset
2487
                        - htab->sgot->output_section->vma);
2488
          unresolved_reloc = FALSE;
2489
          break;
2490
 
2491
        case R_390_8:
2492
        case R_390_16:
2493
        case R_390_32:
2494
        case R_390_64:
2495
        case R_390_PC16:
2496
        case R_390_PC16DBL:
2497
        case R_390_PC32:
2498
        case R_390_PC32DBL:
2499
        case R_390_PC64:
2500
          if ((input_section->flags & SEC_ALLOC) == 0)
2501
            break;
2502
 
2503
          if ((info->shared
2504
               && (h == NULL
2505
                   || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2506
                   || h->root.type != bfd_link_hash_undefweak)
2507
               && ((r_type != R_390_PC16
2508
                    && r_type != R_390_PC16DBL
2509
                    && r_type != R_390_PC32
2510
                    && r_type != R_390_PC32DBL
2511
                    && r_type != R_390_PC64)
2512
                   || !SYMBOL_CALLS_LOCAL (info, h)))
2513
              || (ELIMINATE_COPY_RELOCS
2514
                  && !info->shared
2515
                  && h != NULL
2516
                  && h->dynindx != -1
2517
                  && !h->non_got_ref
2518
                  && ((h->def_dynamic
2519
                       && !h->def_regular)
2520
                      || h->root.type == bfd_link_hash_undefweak
2521
                      || h->root.type == bfd_link_hash_undefined)))
2522
            {
2523
              Elf_Internal_Rela outrel;
2524
              bfd_boolean skip, relocate;
2525
              asection *sreloc;
2526
              bfd_byte *loc;
2527
 
2528
              /* When generating a shared object, these relocations
2529
                 are copied into the output file to be resolved at run
2530
                 time.  */
2531
              skip = FALSE;
2532
              relocate = FALSE;
2533
 
2534
              outrel.r_offset =
2535
                _bfd_elf_section_offset (output_bfd, info, input_section,
2536
                                         rel->r_offset);
2537
              if (outrel.r_offset == (bfd_vma) -1)
2538
                skip = TRUE;
2539
              else if (outrel.r_offset == (bfd_vma) -2)
2540
                skip = TRUE, relocate = TRUE;
2541
 
2542
              outrel.r_offset += (input_section->output_section->vma
2543
                                  + input_section->output_offset);
2544
 
2545
              if (skip)
2546
                memset (&outrel, 0, sizeof outrel);
2547
              else if (h != NULL
2548
                       && h->dynindx != -1
2549
                       && (r_type == R_390_PC16
2550
                           || r_type == R_390_PC16DBL
2551
                           || r_type == R_390_PC32
2552
                           || r_type == R_390_PC32DBL
2553
                           || r_type == R_390_PC64
2554
                           || !info->shared
2555
                           || !SYMBOLIC_BIND (info, h)
2556
                           || !h->def_regular))
2557
                {
2558
                  outrel.r_info = ELF64_R_INFO (h->dynindx, r_type);
2559
                  outrel.r_addend = rel->r_addend;
2560
                }
2561
              else
2562
                {
2563
                  /* This symbol is local, or marked to become local.  */
2564
                  outrel.r_addend = relocation + rel->r_addend;
2565
                  if (r_type == R_390_64)
2566
                    {
2567
                      relocate = TRUE;
2568
                      outrel.r_info = ELF64_R_INFO (0, R_390_RELATIVE);
2569
                    }
2570
                  else
2571
                    {
2572
                      long sindx;
2573
 
2574
                      if (bfd_is_abs_section (sec))
2575
                        sindx = 0;
2576
                      else if (sec == NULL || sec->owner == NULL)
2577
                        {
2578
                          bfd_set_error(bfd_error_bad_value);
2579
                          return FALSE;
2580
                        }
2581
                      else
2582
                        {
2583
                          asection *osec;
2584
 
2585
                          osec = sec->output_section;
2586
                          sindx = elf_section_data (osec)->dynindx;
2587
 
2588
                          if (sindx == 0)
2589
                            {
2590
                              osec = htab->elf.text_index_section;
2591
                              sindx = elf_section_data (osec)->dynindx;
2592
                            }
2593
                          BFD_ASSERT (sindx != 0);
2594
 
2595
                          /* We are turning this relocation into one
2596
                             against a section symbol, so subtract out
2597
                             the output section's address but not the
2598
                             offset of the input section in the output
2599
                             section.  */
2600
                          outrel.r_addend -= osec->vma;
2601
                        }
2602
                      outrel.r_info = ELF64_R_INFO (sindx, r_type);
2603
                    }
2604
                }
2605
 
2606
              sreloc = elf_section_data (input_section)->sreloc;
2607
              if (sreloc == NULL)
2608
                abort ();
2609
 
2610
              loc = sreloc->contents;
2611
              loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
2612
              bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2613
 
2614
              /* If this reloc is against an external symbol, we do
2615
                 not want to fiddle with the addend.  Otherwise, we
2616
                 need to include the symbol value so that it becomes
2617
                 an addend for the dynamic reloc.  */
2618
              if (! relocate)
2619
                continue;
2620
            }
2621
 
2622
          break;
2623
 
2624
          /* Relocations for tls literal pool entries.  */
2625
        case R_390_TLS_IE64:
2626
          if (info->shared)
2627
            {
2628
              Elf_Internal_Rela outrel;
2629
              asection *sreloc;
2630
              bfd_byte *loc;
2631
 
2632
              outrel.r_offset = rel->r_offset
2633
                                + input_section->output_section->vma
2634
                                + input_section->output_offset;
2635
              outrel.r_info = ELF64_R_INFO (0, R_390_RELATIVE);
2636
              sreloc = elf_section_data (input_section)->sreloc;
2637
              if (sreloc == NULL)
2638
                abort ();
2639
              loc = sreloc->contents;
2640
              loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
2641
              bfd_elf64_swap_reloc_out (output_bfd, &outrel, loc);
2642
            }
2643
          /* Fall through.  */
2644
 
2645
        case R_390_TLS_GD64:
2646
        case R_390_TLS_GOTIE64:
2647
          r_type = elf_s390_tls_transition (info, r_type, h == NULL);
2648
          tls_type = GOT_UNKNOWN;
2649
          if (h == NULL && local_got_offsets)
2650
            tls_type = elf_s390_local_got_tls_type (input_bfd) [r_symndx];
2651
          else if (h != NULL)
2652
            {
2653
              tls_type = elf_s390_hash_entry(h)->tls_type;
2654
              if (!info->shared && h->dynindx == -1 && tls_type >= GOT_TLS_IE)
2655
                r_type = R_390_TLS_LE64;
2656
            }
2657
          if (r_type == R_390_TLS_GD64 && tls_type >= GOT_TLS_IE)
2658
            r_type = R_390_TLS_IE64;
2659
 
2660
          if (r_type == R_390_TLS_LE64)
2661
            {
2662
              /* This relocation gets optimized away by the local exec
2663
                 access optimization.  */
2664
              BFD_ASSERT (! unresolved_reloc);
2665
              bfd_put_64 (output_bfd, -tpoff (info, relocation),
2666
                          contents + rel->r_offset);
2667
              continue;
2668
            }
2669
 
2670
          if (htab->sgot == NULL)
2671
            abort ();
2672
 
2673
          if (h != NULL)
2674
            off = h->got.offset;
2675
          else
2676
            {
2677
              if (local_got_offsets == NULL)
2678
                abort ();
2679
 
2680
              off = local_got_offsets[r_symndx];
2681
            }
2682
 
2683
        emit_tls_relocs:
2684
 
2685
          if ((off & 1) != 0)
2686
            off &= ~1;
2687
          else
2688
            {
2689
              Elf_Internal_Rela outrel;
2690
              bfd_byte *loc;
2691
              int dr_type, indx;
2692
 
2693
              if (htab->srelgot == NULL)
2694
                abort ();
2695
 
2696
              outrel.r_offset = (htab->sgot->output_section->vma
2697
                                 + htab->sgot->output_offset + off);
2698
 
2699
              indx = h && h->dynindx != -1 ? h->dynindx : 0;
2700
              if (r_type == R_390_TLS_GD64)
2701
                dr_type = R_390_TLS_DTPMOD;
2702
              else
2703
                dr_type = R_390_TLS_TPOFF;
2704
              if (dr_type == R_390_TLS_TPOFF && indx == 0)
2705
                outrel.r_addend = relocation - dtpoff_base (info);
2706
              else
2707
                outrel.r_addend = 0;
2708
              outrel.r_info = ELF64_R_INFO (indx, dr_type);
2709
              loc = htab->srelgot->contents;
2710
              loc += htab->srelgot->reloc_count++
2711
                * sizeof (Elf64_External_Rela);
2712
              bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2713
 
2714
              if (r_type == R_390_TLS_GD64)
2715
                {
2716
                  if (indx == 0)
2717
                    {
2718
                      BFD_ASSERT (! unresolved_reloc);
2719
                      bfd_put_64 (output_bfd,
2720
                                  relocation - dtpoff_base (info),
2721
                                  htab->sgot->contents + off + GOT_ENTRY_SIZE);
2722
                    }
2723
                  else
2724
                    {
2725
                      outrel.r_info = ELF64_R_INFO (indx, R_390_TLS_DTPOFF);
2726
                      outrel.r_offset += GOT_ENTRY_SIZE;
2727
                      outrel.r_addend = 0;
2728
                      htab->srelgot->reloc_count++;
2729
                      loc += sizeof (Elf64_External_Rela);
2730
                      bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2731
                    }
2732
                }
2733
 
2734
              if (h != NULL)
2735
                h->got.offset |= 1;
2736
              else
2737
                local_got_offsets[r_symndx] |= 1;
2738
            }
2739
 
2740
          if (off >= (bfd_vma) -2)
2741
            abort ();
2742
          if (r_type == ELF64_R_TYPE (rel->r_info))
2743
            {
2744
              relocation = htab->sgot->output_offset + off;
2745
              if (r_type == R_390_TLS_IE64 || r_type == R_390_TLS_IEENT)
2746
                relocation += htab->sgot->output_section->vma;
2747
              unresolved_reloc = FALSE;
2748
            }
2749
          else
2750
            {
2751
              bfd_put_64 (output_bfd, htab->sgot->output_offset + off,
2752
                          contents + rel->r_offset);
2753
              continue;
2754
            }
2755
          break;
2756
 
2757
        case R_390_TLS_GOTIE12:
2758
        case R_390_TLS_GOTIE20:
2759
        case R_390_TLS_IEENT:
2760
          if (h == NULL)
2761
            {
2762
              if (local_got_offsets == NULL)
2763
                abort();
2764
              off = local_got_offsets[r_symndx];
2765
              if (info->shared)
2766
                goto emit_tls_relocs;
2767
            }
2768
          else
2769
            {
2770
              off = h->got.offset;
2771
              tls_type = elf_s390_hash_entry(h)->tls_type;
2772
              if (info->shared || h->dynindx != -1 || tls_type < GOT_TLS_IE)
2773
                goto emit_tls_relocs;
2774
            }
2775
 
2776
          if (htab->sgot == NULL)
2777
            abort ();
2778
 
2779
          BFD_ASSERT (! unresolved_reloc);
2780
          bfd_put_64 (output_bfd, -tpoff (info, relocation),
2781
                      htab->sgot->contents + off);
2782
          relocation = htab->sgot->output_offset + off;
2783
          if (r_type == R_390_TLS_IEENT)
2784
            relocation += htab->sgot->output_section->vma;
2785
          unresolved_reloc = FALSE;
2786
          break;
2787
 
2788
        case R_390_TLS_LDM64:
2789
          if (! info->shared)
2790
            /* The literal pool entry this relocation refers to gets ignored
2791
               by the optimized code of the local exec model. Do nothing
2792
               and the value will turn out zero.  */
2793
            continue;
2794
 
2795
          if (htab->sgot == NULL)
2796
            abort ();
2797
 
2798
          off = htab->tls_ldm_got.offset;
2799
          if (off & 1)
2800
            off &= ~1;
2801
          else
2802
            {
2803
              Elf_Internal_Rela outrel;
2804
              bfd_byte *loc;
2805
 
2806
              if (htab->srelgot == NULL)
2807
                abort ();
2808
 
2809
              outrel.r_offset = (htab->sgot->output_section->vma
2810
                                 + htab->sgot->output_offset + off);
2811
 
2812
              bfd_put_64 (output_bfd, 0,
2813
                          htab->sgot->contents + off + GOT_ENTRY_SIZE);
2814
              outrel.r_info = ELF64_R_INFO (0, R_390_TLS_DTPMOD);
2815
              outrel.r_addend = 0;
2816
              loc = htab->srelgot->contents;
2817
              loc += htab->srelgot->reloc_count++
2818
                * sizeof (Elf64_External_Rela);
2819
              bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2820
              htab->tls_ldm_got.offset |= 1;
2821
            }
2822
          relocation = htab->sgot->output_offset + off;
2823
          unresolved_reloc = FALSE;
2824
          break;
2825
 
2826
        case R_390_TLS_LE64:
2827
          if (info->shared)
2828
            {
2829
              /* Linking a shared library with non-fpic code requires
2830
                 a R_390_TLS_TPOFF relocation.  */
2831
              Elf_Internal_Rela outrel;
2832
              asection *sreloc;
2833
              bfd_byte *loc;
2834
              int indx;
2835
 
2836
              outrel.r_offset = rel->r_offset
2837
                                + input_section->output_section->vma
2838
                                + input_section->output_offset;
2839
              if (h != NULL && h->dynindx != -1)
2840
                indx = h->dynindx;
2841
              else
2842
                indx = 0;
2843
              outrel.r_info = ELF64_R_INFO (indx, R_390_TLS_TPOFF);
2844
              if (indx == 0)
2845
                outrel.r_addend = relocation - dtpoff_base (info);
2846
              else
2847
                outrel.r_addend = 0;
2848
              sreloc = elf_section_data (input_section)->sreloc;
2849
              if (sreloc == NULL)
2850
                abort ();
2851
              loc = sreloc->contents;
2852
              loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
2853
              bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2854
            }
2855
          else
2856
            {
2857
              BFD_ASSERT (! unresolved_reloc);
2858
              bfd_put_64 (output_bfd, -tpoff (info, relocation),
2859
                          contents + rel->r_offset);
2860
            }
2861
          continue;
2862
 
2863
        case R_390_TLS_LDO64:
2864
          if (info->shared)
2865
            relocation -= dtpoff_base (info);
2866
          else
2867
            /* When converting LDO to LE, we must negate.  */
2868
            relocation = -tpoff (info, relocation);
2869
          break;
2870
 
2871
          /* Relocations for tls instructions.  */
2872
        case R_390_TLS_LOAD:
2873
        case R_390_TLS_GDCALL:
2874
        case R_390_TLS_LDCALL:
2875
          tls_type = GOT_UNKNOWN;
2876
          if (h == NULL && local_got_offsets)
2877
            tls_type = elf_s390_local_got_tls_type (input_bfd) [r_symndx];
2878
          else if (h != NULL)
2879
            tls_type = elf_s390_hash_entry(h)->tls_type;
2880
 
2881
          if (tls_type == GOT_TLS_GD)
2882
            continue;
2883
 
2884
          if (r_type == R_390_TLS_LOAD)
2885
            {
2886
              if (!info->shared && (h == NULL || h->dynindx == -1))
2887
                {
2888
                  /* IE->LE transition. Four valid cases:
2889
                     lg %rx,(0,%ry)    -> sllg %rx,%ry,0
2890
                     lg %rx,(%ry,0)    -> sllg %rx,%ry,0
2891
                     lg %rx,(%ry,%r12) -> sllg %rx,%ry,0
2892
                     lg %rx,(%r12,%ry) -> sllg %rx,%ry,0  */
2893
                  unsigned int insn0, insn1, ry;
2894
 
2895
                  insn0 = bfd_get_32 (input_bfd, contents + rel->r_offset);
2896
                  insn1 = bfd_get_16 (input_bfd, contents + rel->r_offset + 4);
2897
                  if (insn1 != 0x0004)
2898
                    invalid_tls_insn (input_bfd, input_section, rel);
2899
                  ry = 0;
2900
                  if ((insn0 & 0xff00f000) == 0xe3000000)
2901
                    /* lg %rx,0(%ry,0) -> sllg %rx,%ry,0  */
2902
                    ry = (insn0 & 0x000f0000);
2903
                  else if ((insn0 & 0xff0f0000) == 0xe3000000)
2904
                    /* lg %rx,0(0,%ry) -> sllg %rx,%ry,0  */
2905
                    ry = (insn0 & 0x0000f000) << 4;
2906
                  else if ((insn0 & 0xff00f000) == 0xe300c000)
2907
                    /* lg %rx,0(%ry,%r12) -> sllg %rx,%ry,0  */
2908
                    ry = (insn0 & 0x000f0000);
2909
                  else if ((insn0 & 0xff0f0000) == 0xe30c0000)
2910
                    /* lg %rx,0(%r12,%ry) -> sllg %rx,%ry,0  */
2911
                    ry = (insn0 & 0x0000f000) << 4;
2912
                  else
2913
                    invalid_tls_insn (input_bfd, input_section, rel);
2914
                  insn0 = 0xeb000000 | (insn0 & 0x00f00000) | ry;
2915
                  insn1 = 0x000d;
2916
                  bfd_put_32 (output_bfd, insn0, contents + rel->r_offset);
2917
                  bfd_put_16 (output_bfd, insn1, contents + rel->r_offset + 4);
2918
                }
2919
            }
2920
          else if (r_type == R_390_TLS_GDCALL)
2921
            {
2922
              unsigned int insn0, insn1;
2923
 
2924
              insn0 = bfd_get_32 (input_bfd, contents + rel->r_offset);
2925
              insn1 = bfd_get_16 (input_bfd, contents + rel->r_offset + 4);
2926
              if ((insn0 & 0xffff0000) != 0xc0e50000)
2927
                invalid_tls_insn (input_bfd, input_section, rel);
2928
              if (!info->shared && (h == NULL || h->dynindx == -1))
2929
                {
2930
                  /* GD->LE transition.
2931
                     brasl %r14,__tls_get_addr@plt -> brcl 0,. */
2932
                  insn0 = 0xc0040000;
2933
                  insn1 = 0x0000;
2934
                }
2935
              else
2936
                {
2937
                  /* GD->IE transition.
2938
                     brasl %r14,__tls_get_addr@plt -> lg %r2,0(%r2,%r12)  */
2939
                  insn0 = 0xe322c000;
2940
                  insn1 = 0x0004;
2941
                }
2942
              bfd_put_32 (output_bfd, insn0, contents + rel->r_offset);
2943
              bfd_put_16 (output_bfd, insn1, contents + rel->r_offset + 4);
2944
            }
2945
          else if (r_type == R_390_TLS_LDCALL)
2946
            {
2947
              if (!info->shared)
2948
                {
2949
                  unsigned int insn0, insn1;
2950
 
2951
                  insn0 = bfd_get_32 (input_bfd, contents + rel->r_offset);
2952
                  insn1 = bfd_get_16 (input_bfd, contents + rel->r_offset + 4);
2953
                  if ((insn0 & 0xffff0000) != 0xc0e50000)
2954
                    invalid_tls_insn (input_bfd, input_section, rel);
2955
                  /* LD->LE transition.
2956
                     brasl %r14,__tls_get_addr@plt -> brcl 0,. */
2957
                  insn0 = 0xc0040000;
2958
                  insn1 = 0x0000;
2959
                  bfd_put_32 (output_bfd, insn0, contents + rel->r_offset);
2960
                  bfd_put_16 (output_bfd, insn1, contents + rel->r_offset + 4);
2961
                }
2962
            }
2963
          continue;
2964
 
2965
        default:
2966
          break;
2967
        }
2968
 
2969
      /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2970
         because such sections are not SEC_ALLOC and thus ld.so will
2971
         not process them.  */
2972
      if (unresolved_reloc
2973
          && !((input_section->flags & SEC_DEBUGGING) != 0
2974 163 khays
               && h->def_dynamic)
2975
          && _bfd_elf_section_offset (output_bfd, info, input_section,
2976
                                      rel->r_offset) != (bfd_vma) -1)
2977 14 khays
        (*_bfd_error_handler)
2978
          (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
2979
           input_bfd,
2980
           input_section,
2981
           (long) rel->r_offset,
2982
           howto->name,
2983
           h->root.root.string);
2984
 
2985
      if (r_type == R_390_20
2986
          || r_type == R_390_GOT20
2987
          || r_type == R_390_GOTPLT20
2988
          || r_type == R_390_TLS_GOTIE20)
2989
        {
2990
          relocation += rel->r_addend;
2991
          relocation = (relocation&0xfff) << 8 | (relocation&0xff000) >> 12;
2992
          r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2993
                                        contents, rel->r_offset,
2994
                                        relocation, 0);
2995
        }
2996
      else
2997
        r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2998
                                      contents, rel->r_offset,
2999
                                      relocation, rel->r_addend);
3000
 
3001
      if (r != bfd_reloc_ok)
3002
        {
3003
          const char *name;
3004
 
3005
          if (h != NULL)
3006
            name = h->root.root.string;
3007
          else
3008
            {
3009
              name = bfd_elf_string_from_elf_section (input_bfd,
3010
                                                      symtab_hdr->sh_link,
3011
                                                      sym->st_name);
3012
              if (name == NULL)
3013
                return FALSE;
3014
              if (*name == '\0')
3015
                name = bfd_section_name (input_bfd, sec);
3016
            }
3017
 
3018
          if (r == bfd_reloc_overflow)
3019
            {
3020
 
3021
              if (! ((*info->callbacks->reloc_overflow)
3022
                     (info, (h ? &h->root : NULL), name, howto->name,
3023
                      (bfd_vma) 0, input_bfd, input_section,
3024
                      rel->r_offset)))
3025
                return FALSE;
3026
            }
3027
          else
3028
            {
3029
              (*_bfd_error_handler)
3030
                (_("%B(%A+0x%lx): reloc against `%s': error %d"),
3031
                 input_bfd, input_section,
3032
                 (long) rel->r_offset, name, (int) r);
3033
              return FALSE;
3034
            }
3035
        }
3036
    }
3037
 
3038
  return TRUE;
3039
}
3040
 
3041
/* Finish up dynamic symbol handling.  We set the contents of various
3042
   dynamic sections here.  */
3043
 
3044
static bfd_boolean
3045
elf_s390_finish_dynamic_symbol (bfd *output_bfd,
3046
                                struct bfd_link_info *info,
3047
                                struct elf_link_hash_entry *h,
3048
                                Elf_Internal_Sym *sym)
3049
{
3050
  struct elf_s390_link_hash_table *htab;
3051
 
3052
  htab = elf_s390_hash_table (info);
3053
  if (htab == NULL)
3054
    return FALSE;
3055
 
3056
  if (h->plt.offset != (bfd_vma) -1)
3057
    {
3058
      bfd_vma plt_index;
3059
      bfd_vma got_offset;
3060
      Elf_Internal_Rela rela;
3061
      bfd_byte *loc;
3062
 
3063
      /* This symbol has an entry in the procedure linkage table.  Set
3064
         it up.  */
3065
 
3066
      if (h->dynindx == -1
3067
          || htab->splt == NULL
3068
          || htab->sgotplt == NULL
3069
          || htab->srelplt == NULL)
3070
        abort ();
3071
 
3072
      /* Calc. index no.
3073
         Current offset - size first entry / entry size.  */
3074
      plt_index = (h->plt.offset - PLT_FIRST_ENTRY_SIZE) / PLT_ENTRY_SIZE;
3075
 
3076
      /* Offset in GOT is PLT index plus GOT headers(3) times 8,
3077
         addr & GOT addr.  */
3078
      got_offset = (plt_index + 3) * GOT_ENTRY_SIZE;
3079
 
3080
      /* Fill in the blueprint of a PLT.  */
3081
      bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD0,
3082
                  htab->splt->contents + h->plt.offset);
3083
      bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD1,
3084
                  htab->splt->contents + h->plt.offset + 4);
3085
      bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD2,
3086
                  htab->splt->contents + h->plt.offset + 8);
3087
      bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD3,
3088
                  htab->splt->contents + h->plt.offset + 12);
3089
      bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD4,
3090
                  htab->splt->contents + h->plt.offset + 16);
3091
      bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD5,
3092
                  htab->splt->contents + h->plt.offset + 20);
3093
      bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD6,
3094
                  htab->splt->contents + h->plt.offset + 24);
3095
      bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD7,
3096
                  htab->splt->contents + h->plt.offset + 28);
3097
      /* Fixup the relative address to the GOT entry */
3098
      bfd_put_32 (output_bfd,
3099
                  (htab->sgotplt->output_section->vma +
3100
                   htab->sgotplt->output_offset + got_offset
3101
                   - (htab->splt->output_section->vma + h->plt.offset))/2,
3102
                  htab->splt->contents + h->plt.offset + 2);
3103
      /* Fixup the relative branch to PLT 0 */
3104
      bfd_put_32 (output_bfd, - (PLT_FIRST_ENTRY_SIZE +
3105
                                 (PLT_ENTRY_SIZE * plt_index) + 22)/2,
3106
                  htab->splt->contents + h->plt.offset + 24);
3107
      /* Fixup offset into symbol table */
3108
      bfd_put_32 (output_bfd, plt_index * sizeof (Elf64_External_Rela),
3109
                  htab->splt->contents + h->plt.offset + 28);
3110
 
3111
      /* Fill in the entry in the global offset table.
3112
         Points to instruction after GOT offset.  */
3113
      bfd_put_64 (output_bfd,
3114
                  (htab->splt->output_section->vma
3115
                   + htab->splt->output_offset
3116
                   + h->plt.offset
3117
                   + 14),
3118
                  htab->sgotplt->contents + got_offset);
3119
 
3120
      /* Fill in the entry in the .rela.plt section.  */
3121
      rela.r_offset = (htab->sgotplt->output_section->vma
3122
                       + htab->sgotplt->output_offset
3123
                       + got_offset);
3124
      rela.r_info = ELF64_R_INFO (h->dynindx, R_390_JMP_SLOT);
3125
      rela.r_addend = 0;
3126
      loc = htab->srelplt->contents + plt_index * sizeof (Elf64_External_Rela);
3127
      bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3128
 
3129
      if (!h->def_regular)
3130
        {
3131
          /* Mark the symbol as undefined, rather than as defined in
3132
             the .plt section.  Leave the value alone.  This is a clue
3133
             for the dynamic linker, to make function pointer
3134
             comparisons work between an application and shared
3135
             library.  */
3136
          sym->st_shndx = SHN_UNDEF;
3137
        }
3138
    }
3139
 
3140
  if (h->got.offset != (bfd_vma) -1
3141
      && elf_s390_hash_entry(h)->tls_type != GOT_TLS_GD
3142
      && elf_s390_hash_entry(h)->tls_type != GOT_TLS_IE
3143
      && elf_s390_hash_entry(h)->tls_type != GOT_TLS_IE_NLT)
3144
    {
3145
      Elf_Internal_Rela rela;
3146
      bfd_byte *loc;
3147
 
3148
      /* This symbol has an entry in the global offset table.  Set it
3149
         up.  */
3150
      if (htab->sgot == NULL || htab->srelgot == NULL)
3151
        abort ();
3152
 
3153
      rela.r_offset = (htab->sgot->output_section->vma
3154
                       + htab->sgot->output_offset
3155
                       + (h->got.offset &~ (bfd_vma) 1));
3156
 
3157
      /* If this is a static link, or it is a -Bsymbolic link and the
3158
         symbol is defined locally or was forced to be local because
3159
         of a version file, we just want to emit a RELATIVE reloc.
3160
         The entry in the global offset table will already have been
3161
         initialized in the relocate_section function.  */
3162
      if (info->shared
3163
          && SYMBOL_REFERENCES_LOCAL (info, h))
3164
        {
3165
          if (!h->def_regular)
3166
            return FALSE;
3167
          BFD_ASSERT((h->got.offset & 1) != 0);
3168
          rela.r_info = ELF64_R_INFO (0, R_390_RELATIVE);
3169
          rela.r_addend = (h->root.u.def.value
3170
                           + h->root.u.def.section->output_section->vma
3171
                           + h->root.u.def.section->output_offset);
3172
        }
3173
      else
3174
        {
3175
          BFD_ASSERT((h->got.offset & 1) == 0);
3176
          bfd_put_64 (output_bfd, (bfd_vma) 0, htab->sgot->contents + h->got.offset);
3177
          rela.r_info = ELF64_R_INFO (h->dynindx, R_390_GLOB_DAT);
3178
          rela.r_addend = 0;
3179
        }
3180
 
3181
      loc = htab->srelgot->contents;
3182
      loc += htab->srelgot->reloc_count++ * sizeof (Elf64_External_Rela);
3183
      bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3184
    }
3185
 
3186
  if (h->needs_copy)
3187
    {
3188
      Elf_Internal_Rela rela;
3189
      bfd_byte *loc;
3190
 
3191
      /* This symbols needs a copy reloc.  Set it up.  */
3192
 
3193
      if (h->dynindx == -1
3194
          || (h->root.type != bfd_link_hash_defined
3195
              && h->root.type != bfd_link_hash_defweak)
3196
          || htab->srelbss == NULL)
3197
        abort ();
3198
 
3199
      rela.r_offset = (h->root.u.def.value
3200
                       + h->root.u.def.section->output_section->vma
3201
                       + h->root.u.def.section->output_offset);
3202
      rela.r_info = ELF64_R_INFO (h->dynindx, R_390_COPY);
3203
      rela.r_addend = 0;
3204
      loc = htab->srelbss->contents;
3205
      loc += htab->srelbss->reloc_count++ * sizeof (Elf64_External_Rela);
3206
      bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3207
    }
3208
 
3209
  /* Mark some specially defined symbols as absolute.  */
3210
  if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3211
      || h == htab->elf.hgot
3212
      || h == htab->elf.hplt)
3213
    sym->st_shndx = SHN_ABS;
3214
 
3215
  return TRUE;
3216
}
3217
 
3218
/* Used to decide how to sort relocs in an optimal manner for the
3219
   dynamic linker, before writing them out.  */
3220
 
3221
static enum elf_reloc_type_class
3222
elf_s390_reloc_type_class (rela)
3223
     const Elf_Internal_Rela *rela;
3224
{
3225
  switch ((int) ELF64_R_TYPE (rela->r_info))
3226
    {
3227
    case R_390_RELATIVE:
3228
      return reloc_class_relative;
3229
    case R_390_JMP_SLOT:
3230
      return reloc_class_plt;
3231
    case R_390_COPY:
3232
      return reloc_class_copy;
3233
    default:
3234
      return reloc_class_normal;
3235
    }
3236
}
3237
 
3238
/* Finish up the dynamic sections.  */
3239
 
3240
static bfd_boolean
3241
elf_s390_finish_dynamic_sections (bfd *output_bfd,
3242
                                  struct bfd_link_info *info)
3243
{
3244
  struct elf_s390_link_hash_table *htab;
3245
  bfd *dynobj;
3246
  asection *sdyn;
3247
 
3248
  htab = elf_s390_hash_table (info);
3249
  if (htab == NULL)
3250
    return FALSE;
3251
 
3252
  dynobj = htab->elf.dynobj;
3253
  sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3254
 
3255
  if (htab->elf.dynamic_sections_created)
3256
    {
3257
      Elf64_External_Dyn *dyncon, *dynconend;
3258
 
3259
      if (sdyn == NULL || htab->sgot == NULL)
3260
        abort ();
3261
 
3262
      dyncon = (Elf64_External_Dyn *) sdyn->contents;
3263
      dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
3264
      for (; dyncon < dynconend; dyncon++)
3265
        {
3266
          Elf_Internal_Dyn dyn;
3267
          asection *s;
3268
 
3269
          bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3270
 
3271
          switch (dyn.d_tag)
3272
            {
3273
            default:
3274
              continue;
3275
 
3276
            case DT_PLTGOT:
3277
              dyn.d_un.d_ptr = htab->sgot->output_section->vma;
3278
              break;
3279
 
3280
            case DT_JMPREL:
3281
              dyn.d_un.d_ptr = htab->srelplt->output_section->vma;
3282
              break;
3283
 
3284
            case DT_PLTRELSZ:
3285
              s = htab->srelplt->output_section;
3286
              dyn.d_un.d_val = s->size;
3287
              break;
3288
 
3289
            case DT_RELASZ:
3290
              /* The procedure linkage table relocs (DT_JMPREL) should
3291
                 not be included in the overall relocs (DT_RELA).
3292
                 Therefore, we override the DT_RELASZ entry here to
3293
                 make it not include the JMPREL relocs.  Since the
3294
                 linker script arranges for .rela.plt to follow all
3295
                 other relocation sections, we don't have to worry
3296
                 about changing the DT_RELA entry.  */
3297
              s = htab->srelplt->output_section;
3298
              dyn.d_un.d_val -= s->size;
3299
              break;
3300
            }
3301
 
3302
          bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3303
        }
3304
 
3305
      /* Fill in the special first entry in the procedure linkage table.  */
3306
      if (htab->splt && htab->splt->size > 0)
3307
        {
3308
          /* fill in blueprint for plt 0 entry */
3309
          bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD0,
3310
                      htab->splt->contents );
3311
          bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD1,
3312
                      htab->splt->contents +4 );
3313
          bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD3,
3314
                      htab->splt->contents +12 );
3315
          bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD4,
3316
                      htab->splt->contents +16 );
3317
          bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD5,
3318
                      htab->splt->contents +20 );
3319
          bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD6,
3320
                      htab->splt->contents + 24);
3321
          bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD7,
3322
                      htab->splt->contents + 28 );
3323
          /* Fixup relative address to start of GOT */
3324
          bfd_put_32 (output_bfd,
3325
                      (htab->sgotplt->output_section->vma +
3326
                       htab->sgotplt->output_offset
3327
                       - htab->splt->output_section->vma - 6)/2,
3328
                      htab->splt->contents + 8);
3329
        }
3330
      elf_section_data (htab->splt->output_section)
3331
        ->this_hdr.sh_entsize = PLT_ENTRY_SIZE;
3332
    }
3333
 
3334
  if (htab->sgotplt)
3335
    {
3336
      /* Fill in the first three entries in the global offset table.  */
3337
      if (htab->sgotplt->size > 0)
3338
        {
3339
          bfd_put_64 (output_bfd,
3340
                      (sdyn == NULL ? (bfd_vma) 0
3341
                       : sdyn->output_section->vma + sdyn->output_offset),
3342
                      htab->sgotplt->contents);
3343
          /* One entry for shared object struct ptr.  */
3344
          bfd_put_64 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 8);
3345
          /* One entry for _dl_runtime_resolve.  */
3346
          bfd_put_64 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 12);
3347
        }
3348
 
3349
      elf_section_data (htab->sgot->output_section)
3350
        ->this_hdr.sh_entsize = 8;
3351
    }
3352
  return TRUE;
3353
}
3354
 
3355
/* Return address for Ith PLT stub in section PLT, for relocation REL
3356
   or (bfd_vma) -1 if it should not be included.  */
3357
 
3358
static bfd_vma
3359
elf_s390_plt_sym_val (bfd_vma i, const asection *plt,
3360
                      const arelent *rel ATTRIBUTE_UNUSED)
3361
{
3362
  return plt->vma + PLT_FIRST_ENTRY_SIZE + i * PLT_ENTRY_SIZE;
3363
}
3364
 
3365
 
3366
/* Why was the hash table entry size definition changed from
3367
   ARCH_SIZE/8 to 4? This breaks the 64 bit dynamic linker and
3368
   this is the only reason for the s390_elf64_size_info structure.  */
3369
 
3370
const struct elf_size_info s390_elf64_size_info =
3371
{
3372
  sizeof (Elf64_External_Ehdr),
3373
  sizeof (Elf64_External_Phdr),
3374
  sizeof (Elf64_External_Shdr),
3375
  sizeof (Elf64_External_Rel),
3376
  sizeof (Elf64_External_Rela),
3377
  sizeof (Elf64_External_Sym),
3378
  sizeof (Elf64_External_Dyn),
3379
  sizeof (Elf_External_Note),
3380
  8,            /* hash-table entry size.  */
3381
  1,            /* internal relocations per external relocations.  */
3382
  64,           /* arch_size.  */
3383
  3,            /* log_file_align.  */
3384
  ELFCLASS64, EV_CURRENT,
3385
  bfd_elf64_write_out_phdrs,
3386
  bfd_elf64_write_shdrs_and_ehdr,
3387
  bfd_elf64_checksum_contents,
3388
  bfd_elf64_write_relocs,
3389
  bfd_elf64_swap_symbol_in,
3390
  bfd_elf64_swap_symbol_out,
3391
  bfd_elf64_slurp_reloc_table,
3392
  bfd_elf64_slurp_symbol_table,
3393
  bfd_elf64_swap_dyn_in,
3394
  bfd_elf64_swap_dyn_out,
3395
  bfd_elf64_swap_reloc_in,
3396
  bfd_elf64_swap_reloc_out,
3397
  bfd_elf64_swap_reloca_in,
3398
  bfd_elf64_swap_reloca_out
3399
};
3400
 
3401
#define TARGET_BIG_SYM  bfd_elf64_s390_vec
3402
#define TARGET_BIG_NAME "elf64-s390"
3403
#define ELF_ARCH        bfd_arch_s390
3404
#define ELF_TARGET_ID   S390_ELF_DATA
3405
#define ELF_MACHINE_CODE EM_S390
3406
#define ELF_MACHINE_ALT1 EM_S390_OLD
3407
#define ELF_MAXPAGESIZE 0x1000
3408
 
3409
#define elf_backend_size_info           s390_elf64_size_info
3410
 
3411
#define elf_backend_can_gc_sections     1
3412
#define elf_backend_can_refcount        1
3413
#define elf_backend_want_got_plt        1
3414
#define elf_backend_plt_readonly        1
3415
#define elf_backend_want_plt_sym        0
3416
#define elf_backend_got_header_size     24
3417
#define elf_backend_rela_normal         1
3418
 
3419
#define elf_info_to_howto               elf_s390_info_to_howto
3420
 
3421
#define bfd_elf64_bfd_is_local_label_name     elf_s390_is_local_label_name
3422
#define bfd_elf64_bfd_link_hash_table_create  elf_s390_link_hash_table_create
3423
#define bfd_elf64_bfd_reloc_type_lookup       elf_s390_reloc_type_lookup
3424
#define bfd_elf64_bfd_reloc_name_lookup elf_s390_reloc_name_lookup
3425
 
3426
#define elf_backend_adjust_dynamic_symbol     elf_s390_adjust_dynamic_symbol
3427
#define elf_backend_check_relocs              elf_s390_check_relocs
3428
#define elf_backend_copy_indirect_symbol      elf_s390_copy_indirect_symbol
3429
#define elf_backend_create_dynamic_sections   elf_s390_create_dynamic_sections
3430
#define elf_backend_finish_dynamic_sections   elf_s390_finish_dynamic_sections
3431
#define elf_backend_finish_dynamic_symbol     elf_s390_finish_dynamic_symbol
3432
#define elf_backend_gc_mark_hook              elf_s390_gc_mark_hook
3433
#define elf_backend_gc_sweep_hook             elf_s390_gc_sweep_hook
3434
#define elf_backend_reloc_type_class          elf_s390_reloc_type_class
3435
#define elf_backend_relocate_section          elf_s390_relocate_section
3436
#define elf_backend_size_dynamic_sections     elf_s390_size_dynamic_sections
3437
#define elf_backend_init_index_section        _bfd_elf_init_1_index_section
3438
#define elf_backend_reloc_type_class          elf_s390_reloc_type_class
3439
#define elf_backend_plt_sym_val               elf_s390_plt_sym_val
3440
 
3441
#define bfd_elf64_mkobject              elf_s390_mkobject
3442
#define elf_backend_object_p            elf_s390_object_p
3443
 
3444
#include "elf64-target.h"

powered by: WebSVN 2.1.0

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