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

Subversion Repositories openrisc_me

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

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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