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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gdb-7.2/] [bfd/] [elf32-s390.c] - Blame information for rev 841

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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