?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* elf32-tilepro.c (tilepro_elf_check_relocs): Delete unused local
[binutils.git] / bfd / elf32-tilepro.c
blob154db7596e04c3d68ff2e9f4011fffcb35d9d299
1 /* TILEPro-specific support for 32-bit ELF.
2 Copyright 2011 Free Software Foundation, Inc.
3
4 This file is part of BFD, the Binary File Descriptor library.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
20
21 #include "bfd.h"
22 #include "sysdep.h"
23 #include "libbfd.h"
24 #include "elf-bfd.h"
25 #include "elf/tilepro.h"
26 #include "opcode/tilepro.h"
27 #include "libiberty.h"
28 #include "elf32-tilepro.h"
29
30 #define TILEPRO_BYTES_PER_WORD 4
31
32 static reloc_howto_type tilepro_elf_howto_table [] =
33 {
34 /* This reloc does nothing. */
35 HOWTO (R_TILEPRO_NONE, /* type */
36 0, /* rightshift */
37 2, /* size (0 = byte, 1 = short, 2 = long) */
38 32, /* bitsize */
39 FALSE, /* pc_relative */
40 0, /* bitpos */
41 complain_overflow_bitfield, /* complain_on_overflow */
42 bfd_elf_generic_reloc, /* special_function */
43 "R_TILEPRO_NONE", /* name */
44 FALSE, /* partial_inplace */
45 0, /* src_mask */
46 0, /* dst_mask */
47 FALSE), /* pcrel_offset */
48
49 /* A 32 bit absolute relocation. */
50 HOWTO (R_TILEPRO_32, /* type */
51 0, /* rightshift */
52 2, /* size (0 = byte, 1 = short, 2 = long) */
53 32, /* bitsize */
54 FALSE, /* pc_relative */
55 0, /* bitpos */
56 complain_overflow_dont, /* complain_on_overflow */
57 bfd_elf_generic_reloc, /* special_function */
58 "R_TILEPRO_32", /* name */
59 FALSE, /* partial_inplace */
60 0, /* src_mask */
61 0xffffffff, /* dst_mask */
62 FALSE), /* pcrel_offset */
63
64 /* A 16 bit absolute relocation. */
65 HOWTO (R_TILEPRO_16, /* type */
66 0, /* rightshift */
67 1, /* size (0 = byte, 1 = short, 2 = long) */
68 16, /* bitsize */
69 FALSE, /* pc_relative */
70 0, /* bitpos */
71 complain_overflow_bitfield, /* complain_on_overflow */
72 bfd_elf_generic_reloc, /* special_function */
73 "R_TILEPRO_16", /* name */
74 FALSE, /* partial_inplace */
75 0, /* src_mask */
76 0xffff, /* dst_mask */
77 FALSE), /* pcrel_offset */
78
79 /* An 8 bit absolute relocation. */
80 HOWTO (R_TILEPRO_8, /* type */
81 0, /* rightshift */
82 0, /* size (0 = byte, 1 = short, 2 = long) */
83 8, /* bitsize */
84 FALSE, /* pc_relative */
85 0, /* bitpos */
86 complain_overflow_unsigned, /* complain_on_overflow */
87 bfd_elf_generic_reloc, /* special_function */
88 "R_TILEPRO_8", /* name */
89 FALSE, /* partial_inplace */
90 0, /* src_mask */
91 0xff, /* dst_mask */
92 FALSE), /* pcrel_offset */
93
94 /* A 32 bit pc-relative relocation. */
95 HOWTO (R_TILEPRO_32_PCREL,/* type */
96 0, /* rightshift */
97 2, /* size (0 = byte, 1 = short, 2 = long) */
98 32, /* bitsize */
99 TRUE, /* pc_relative */
100 0, /* bitpos */
101 complain_overflow_dont, /* complain_on_overflow */
102 bfd_elf_generic_reloc, /* special_function */
103 "R_TILEPRO_32_PCREL", /* name */
104 FALSE, /* partial_inplace */
105 0, /* src_mask */
106 0xffffffff, /* dst_mask */
107 TRUE), /* pcrel_offset */
108
109 /* A 16 bit pc-relative relocation. */
110 HOWTO (R_TILEPRO_16_PCREL,/* type */
111 0, /* rightshift */
112 1, /* size (0 = byte, 1 = short, 2 = long) */
113 16, /* bitsize */
114 TRUE, /* pc_relative */
115 0, /* bitpos */
116 complain_overflow_signed, /* complain_on_overflow */
117 bfd_elf_generic_reloc, /* special_function */
118 "R_TILEPRO_16_PCREL", /* name */
119 FALSE, /* partial_inplace */
120 0, /* src_mask */
121 0xffff, /* dst_mask */
122 TRUE), /* pcrel_offset */
123
124 /* An 8 bit pc-relative relocation. */
125 HOWTO (R_TILEPRO_8_PCREL, /* type */
126 0, /* rightshift */
127 0, /* size (0 = byte, 1 = short, 2 = long) */
128 8, /* bitsize */
129 TRUE, /* pc_relative */
130 0, /* bitpos */
131 complain_overflow_signed, /* complain_on_overflow */
132 bfd_elf_generic_reloc, /* special_function */
133 "R_TILEPRO_8_PCREL",/* name */
134 FALSE, /* partial_inplace */
135 0, /* src_mask */
136 0xff, /* dst_mask */
137 TRUE), /* pcrel_offset */
138
139 /* A 16 bit relocation without overflow. */
140 HOWTO (R_TILEPRO_LO16, /* type */
141 0, /* rightshift */
142 1, /* size (0 = byte, 1 = short, 2 = long) */
143 16, /* bitsize */
144 FALSE, /* pc_relative */
145 0, /* bitpos */
146 complain_overflow_dont,/* complain_on_overflow */
147 bfd_elf_generic_reloc, /* special_function */
148 "R_TILEPRO_LO16", /* name */
149 FALSE, /* partial_inplace */
150 0, /* src_mask */
151 0xffff, /* dst_mask */
152 FALSE), /* pcrel_offset */
153
154 /* The high order 16 bits of an address. */
155 HOWTO (R_TILEPRO_HI16, /* type */
156 16, /* rightshift */
157 1, /* size (0 = byte, 1 = short, 2 = long) */
158 16, /* bitsize */
159 FALSE, /* pc_relative */
160 0, /* bitpos */
161 complain_overflow_dont, /* complain_on_overflow */
162 bfd_elf_generic_reloc, /* special_function */
163 "R_TILEPRO_HI16", /* name */
164 FALSE, /* partial_inplace */
165 0, /* src_mask */
166 0xffff, /* dst_mask */
167 FALSE), /* pcrel_offset */
168
169 /* The high order 16 bits of an address, plus 1 if the contents of
170 the low 16 bits, treated as a signed number, is negative. */
171 HOWTO (R_TILEPRO_HA16, /* type */
172 16, /* rightshift */
173 1, /* size (0 = byte, 1 = short, 2 = long) */
174 16, /* bitsize */
175 FALSE, /* pc_relative */
176 0, /* bitpos */
177 complain_overflow_dont, /* complain_on_overflow */
178 bfd_elf_generic_reloc, /* special_function */
179 "R_TILEPRO_HA16", /* name */
180 FALSE, /* partial_inplace */
181 0, /* src_mask */
182 0xffff, /* dst_mask */
183 FALSE), /* pcrel_offset */
184
185 HOWTO (R_TILEPRO_COPY, /* type */
186 0, /* rightshift */
187 0, /* size (0 = byte, 1 = short, 2 = long) */
188 0, /* bitsize */
189 FALSE, /* pc_relative */
190 0, /* bitpos */
191 complain_overflow_dont, /* complain_on_overflow */
192 bfd_elf_generic_reloc, /* special_function */
193 "R_TILEPRO_COPY", /* name */
194 FALSE, /* partial_inplace */
195 0, /* src_mask */
196 0, /* dst_mask */
197 TRUE), /* pcrel_offset */
198
199 HOWTO (R_TILEPRO_GLOB_DAT, /* type */
200 0, /* rightshift */
201 0, /* size (0 = byte, 1 = short, 2 = long) */
202 0, /* bitsize */
203 FALSE, /* pc_relative */
204 0, /* bitpos */
205 complain_overflow_dont, /* complain_on_overflow */
206 bfd_elf_generic_reloc, /* special_function */
207 "R_TILEPRO_GLOB_DAT", /* name */
208 FALSE, /* partial_inplace */
209 0, /* src_mask */
210 0, /* dst_mask */
211 TRUE), /* pcrel_offset */
212
213 HOWTO (R_TILEPRO_JMP_SLOT, /* type */
214 0, /* rightshift */
215 0, /* size (0 = byte, 1 = short, 2 = long) */
216 0, /* bitsize */
217 FALSE, /* pc_relative */
218 0, /* bitpos */
219 complain_overflow_dont, /* complain_on_overflow */
220 bfd_elf_generic_reloc, /* special_function */
221 "R_TILEPRO_JMP_SLOT", /* name */
222 FALSE, /* partial_inplace */
223 0, /* src_mask */
224 0, /* dst_mask */
225 TRUE), /* pcrel_offset */
226
227 HOWTO (R_TILEPRO_RELATIVE, /* type */
228 0, /* rightshift */
229 0, /* size (0 = byte, 1 = short, 2 = long) */
230 0, /* bitsize */
231 FALSE, /* pc_relative */
232 0, /* bitpos */
233 complain_overflow_dont, /* complain_on_overflow */
234 bfd_elf_generic_reloc, /* special_function */
235 "R_TILEPRO_RELATIVE", /* name */
236 FALSE, /* partial_inplace */
237 0, /* src_mask */
238 0, /* dst_mask */
239 TRUE), /* pcrel_offset */
240
241 HOWTO (R_TILEPRO_BROFF_X1, /* type */
242 TILEPRO_LOG2_BUNDLE_ALIGNMENT_IN_BYTES, /* rightshift */
243 2, /* size (0 = byte, 1 = short, 2 = long) */
244 17, /* bitsize */
245 TRUE, /* pc_relative */
246 0, /* bitpos */
247 complain_overflow_signed, /* complain_on_overflow */
248 bfd_elf_generic_reloc, /* special_function */
249 "R_TILEPRO_BROFF_X1", /* name */
250 FALSE, /* partial_inplace */
251 0, /* src_mask */
252 -1, /* dst_mask */
253 TRUE), /* pcrel_offset */
254
255 HOWTO (R_TILEPRO_JOFFLONG_X1, /* type */
256 TILEPRO_LOG2_BUNDLE_ALIGNMENT_IN_BYTES, /* rightshift */
257 2, /* size (0 = byte, 1 = short, 2 = long) */
258 29, /* bitsize */
259 TRUE, /* pc_relative */
260 0, /* bitpos */
261 complain_overflow_signed,/* complain_on_overflow */
262 bfd_elf_generic_reloc, /* special_function */
263 "R_TILEPRO_JOFFLONG_X1", /* name */
264 FALSE, /* partial_inplace */
265 0, /* src_mask */
266 -1, /* dst_mask */
267 TRUE), /* pcrel_offset */
268
269 HOWTO (R_TILEPRO_JOFFLONG_X1_PLT, /* type */
270 TILEPRO_LOG2_BUNDLE_ALIGNMENT_IN_BYTES, /* rightshift */
271 2, /* size (0 = byte, 1 = short, 2 = long) */
272 29, /* bitsize */
273 TRUE, /* pc_relative */
274 0, /* bitpos */
275 complain_overflow_signed,/* complain_on_overflow */
276 bfd_elf_generic_reloc, /* special_function */
277 "R_TILEPRO_JOFFLONG_X1_PLT", /* name */
278 FALSE, /* partial_inplace */
279 0, /* src_mask */
280 -1, /* dst_mask */
281 TRUE), /* pcrel_offset */
282
283 #define TILEPRO_IMM_HOWTO(name, size, bitsize) \
284 HOWTO (name, 0, size, bitsize, FALSE, 0, \
285 complain_overflow_signed, bfd_elf_generic_reloc, \
286 #name, FALSE, 0, -1, FALSE)
287
288 #define TILEPRO_UIMM_HOWTO(name, size, bitsize) \
289 HOWTO (name, 0, size, bitsize, FALSE, 0, \
290 complain_overflow_unsigned, bfd_elf_generic_reloc, \
291 #name, FALSE, 0, -1, FALSE)
292
293 TILEPRO_IMM_HOWTO(R_TILEPRO_IMM8_X0, 0, 8),
294 TILEPRO_IMM_HOWTO(R_TILEPRO_IMM8_Y0, 0, 8),
295 TILEPRO_IMM_HOWTO(R_TILEPRO_IMM8_X1, 0, 8),
296 TILEPRO_IMM_HOWTO(R_TILEPRO_IMM8_Y1, 0, 8),
297 TILEPRO_UIMM_HOWTO(R_TILEPRO_MT_IMM15_X1, 1, 15),
298 TILEPRO_UIMM_HOWTO(R_TILEPRO_MF_IMM15_X1, 1, 15),
299 TILEPRO_IMM_HOWTO(R_TILEPRO_IMM16_X0, 1, 16),
300 TILEPRO_IMM_HOWTO(R_TILEPRO_IMM16_X1, 1, 16),
301
302 #define TILEPRO_IMM16_HOWTO(name, rshift) \
303 HOWTO (name, rshift, 1, 16, FALSE, 0, \
304 complain_overflow_dont, bfd_elf_generic_reloc, \
305 #name, FALSE, 0, 0xffff, FALSE)
306
307 TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X0_LO, 0),
308 TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X1_LO, 0),
309 TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X0_HI, 16),
310 TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X1_HI, 16),
311 TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X0_HA, 16),
312 TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X1_HA, 16),
313
314 /* PC-relative offsets. */
315
316 HOWTO (R_TILEPRO_IMM16_X0_PCREL, /* type */
317 0, /* rightshift */
318 1, /* size (0 = byte, 1 = short, 2 = long) */
319 16, /* bitsize */
320 TRUE, /* pc_relative */
321 0, /* bitpos */
322 complain_overflow_signed, /* complain_on_overflow */
323 bfd_elf_generic_reloc, /* special_function */
324 "R_TILEPRO_IMM16_X0_PCREL",/* name */
325 FALSE, /* partial_inplace */
326 0, /* src_mask */
327 -1, /* dst_mask */
328 TRUE), /* pcrel_offset */
329
330 HOWTO (R_TILEPRO_IMM16_X1_PCREL, /* type */
331 0, /* rightshift */
332 1, /* size (0 = byte, 1 = short, 2 = long) */
333 16, /* bitsize */
334 TRUE, /* pc_relative */
335 0, /* bitpos */
336 complain_overflow_signed, /* complain_on_overflow */
337 bfd_elf_generic_reloc, /* special_function */
338 "R_TILEPRO_IMM16_X1_PCREL",/* name */
339 FALSE, /* partial_inplace */
340 0, /* src_mask */
341 -1, /* dst_mask */
342 TRUE), /* pcrel_offset */
343
344 #define TILEPRO_IMM16_HOWTO_PCREL(name, rshift) \
345 HOWTO (name, rshift, 1, 16, TRUE, 0, \
346 complain_overflow_dont, bfd_elf_generic_reloc, \
347 #name, FALSE, 0, 0xffff, TRUE)
348
349 TILEPRO_IMM16_HOWTO_PCREL (R_TILEPRO_IMM16_X0_LO_PCREL, 0),
350 TILEPRO_IMM16_HOWTO_PCREL (R_TILEPRO_IMM16_X1_LO_PCREL, 0),
351 TILEPRO_IMM16_HOWTO_PCREL (R_TILEPRO_IMM16_X0_HI_PCREL, 16),
352 TILEPRO_IMM16_HOWTO_PCREL (R_TILEPRO_IMM16_X1_HI_PCREL, 16),
353 TILEPRO_IMM16_HOWTO_PCREL (R_TILEPRO_IMM16_X0_HA_PCREL, 16),
354 TILEPRO_IMM16_HOWTO_PCREL (R_TILEPRO_IMM16_X1_HA_PCREL, 16),
355
356 /* Byte offset into GOT for a particular symbol. */
357 TILEPRO_IMM_HOWTO(R_TILEPRO_IMM16_X0_GOT, 1, 16),
358 TILEPRO_IMM_HOWTO(R_TILEPRO_IMM16_X1_GOT, 1, 16),
359 TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X0_GOT_LO, 0),
360 TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X1_GOT_LO, 0),
361 TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X0_GOT_HI, 16),
362 TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X1_GOT_HI, 16),
363 TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X0_GOT_HA, 16),
364 TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X1_GOT_HA, 16),
365
366 TILEPRO_UIMM_HOWTO(R_TILEPRO_MMSTART_X0, 0, 5),
367 TILEPRO_UIMM_HOWTO(R_TILEPRO_MMEND_X0, 0, 5),
368 TILEPRO_UIMM_HOWTO(R_TILEPRO_MMSTART_X1, 0, 5),
369 TILEPRO_UIMM_HOWTO(R_TILEPRO_MMEND_X1, 0, 5),
370
371 TILEPRO_UIMM_HOWTO(R_TILEPRO_SHAMT_X0, 0, 5),
372 TILEPRO_UIMM_HOWTO(R_TILEPRO_SHAMT_X1, 0, 5),
373 TILEPRO_UIMM_HOWTO(R_TILEPRO_SHAMT_Y0, 0, 5),
374 TILEPRO_UIMM_HOWTO(R_TILEPRO_SHAMT_Y1, 0, 5),
375
376 TILEPRO_IMM_HOWTO(R_TILEPRO_DEST_IMM8_X1, 0, 8),
377
378 /* These relocs are currently not defined. */
379 EMPTY_HOWTO (56),
380 EMPTY_HOWTO (57),
381 EMPTY_HOWTO (58),
382 EMPTY_HOWTO (59),
383 EMPTY_HOWTO (60),
384 EMPTY_HOWTO (61),
385 EMPTY_HOWTO (62),
386 EMPTY_HOWTO (63),
387 EMPTY_HOWTO (64),
388 EMPTY_HOWTO (65),
389
390 /* Offsets into the GOT of TLS Descriptors. */
391
392 HOWTO (R_TILEPRO_IMM16_X0_TLS_GD,/* type */
393 0, /* rightshift */
394 1, /* size (0 = byte, 1 = short, 2 = long) */
395 16, /* bitsize */
396 FALSE, /* pc_relative */
397 0, /* bitpos */
398 complain_overflow_signed, /* complain_on_overflow */
399 bfd_elf_generic_reloc, /* special_function */
400 "R_TILEPRO_IMM16_X0_TLS_GD",/* name */
401 FALSE, /* partial_inplace */
402 0, /* src_mask */
403 0xffff, /* dst_mask */
404 FALSE), /* pcrel_offset */
405
406 HOWTO (R_TILEPRO_IMM16_X1_TLS_GD,/* type */
407 0, /* rightshift */
408 1, /* size (0 = byte, 1 = short, 2 = long) */
409 16, /* bitsize */
410 FALSE, /* pc_relative */
411 0, /* bitpos */
412 complain_overflow_signed, /* complain_on_overflow */
413 bfd_elf_generic_reloc, /* special_function */
414 "R_TILEPRO_IMM16_X1_TLS_GD",/* name */
415 FALSE, /* partial_inplace */
416 0, /* src_mask */
417 0xffff, /* dst_mask */
418 FALSE), /* pcrel_offset */
419
420 TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X0_TLS_GD_LO, 0),
421 TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X1_TLS_GD_LO, 0),
422 TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X0_TLS_GD_HI, 16),
423 TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X1_TLS_GD_HI, 16),
424 TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X0_TLS_GD_HA, 16),
425 TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X1_TLS_GD_HA, 16),
426
427 /* Offsets into the GOT of TLS Descriptors. */
428
429 HOWTO (R_TILEPRO_IMM16_X0_TLS_IE,/* type */
430 0, /* rightshift */
431 1, /* size (0 = byte, 1 = short, 2 = long) */
432 16, /* bitsize */
433 FALSE, /* pc_relative */
434 0, /* bitpos */
435 complain_overflow_signed, /* complain_on_overflow */
436 bfd_elf_generic_reloc, /* special_function */
437 "R_TILEPRO_IMM16_X0_TLS_IE",/* name */
438 FALSE, /* partial_inplace */
439 0, /* src_mask */
440 -1, /* dst_mask */
441 TRUE), /* pcrel_offset */
442
443 HOWTO (R_TILEPRO_IMM16_X1_TLS_IE,/* type */
444 0, /* rightshift */
445 1, /* size (0 = byte, 1 = short, 2 = long) */
446 16, /* bitsize */
447 FALSE, /* pc_relative */
448 0, /* bitpos */
449 complain_overflow_signed, /* complain_on_overflow */
450 bfd_elf_generic_reloc, /* special_function */
451 "R_TILEPRO_IMM16_X1_TLS_IE",/* name */
452 FALSE, /* partial_inplace */
453 0, /* src_mask */
454 -1, /* dst_mask */
455 TRUE), /* pcrel_offset */
456
457 #define TILEPRO_IMM16_HOWTO_TLS_IE(name, rshift) \
458 HOWTO (name, rshift, 1, 16, FALSE, 0, \
459 complain_overflow_dont, bfd_elf_generic_reloc, \
460 #name, FALSE, 0, 0xffff, TRUE)
461
462 TILEPRO_IMM16_HOWTO_TLS_IE (R_TILEPRO_IMM16_X0_TLS_IE_LO, 0),
463 TILEPRO_IMM16_HOWTO_TLS_IE (R_TILEPRO_IMM16_X1_TLS_IE_LO, 0),
464 TILEPRO_IMM16_HOWTO_TLS_IE (R_TILEPRO_IMM16_X0_TLS_IE_HI, 16),
465 TILEPRO_IMM16_HOWTO_TLS_IE (R_TILEPRO_IMM16_X1_TLS_IE_HI, 16),
466 TILEPRO_IMM16_HOWTO_TLS_IE (R_TILEPRO_IMM16_X0_TLS_IE_HA, 16),
467 TILEPRO_IMM16_HOWTO_TLS_IE (R_TILEPRO_IMM16_X1_TLS_IE_HA, 16),
468
469 /* These are common with the Solaris TLS implementation. */
470 HOWTO(R_TILEPRO_TLS_DTPMOD32, 0, 0, 0, FALSE, 0, complain_overflow_dont,
471 bfd_elf_generic_reloc, "R_TILEPRO_TLS_DTPMOD32",
472 FALSE, 0, 0, TRUE),
473 HOWTO(R_TILEPRO_TLS_DTPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
474 bfd_elf_generic_reloc, "R_TILEPRO_TLS_DTPOFF32",
475 FALSE, 0, 0xFFFFFFFF, TRUE),
476 HOWTO(R_TILEPRO_TLS_TPOFF32, 0, 0, 0, FALSE, 0, complain_overflow_dont,
477 bfd_elf_generic_reloc, "R_TILEPRO_TLS_TPOFF32",
478 FALSE, 0, 0, TRUE)
479
480 };
481
482 static reloc_howto_type tilepro_elf_howto_table2 [] =
483 {
484 /* GNU extension to record C++ vtable hierarchy */
485 HOWTO (R_TILEPRO_GNU_VTINHERIT, /* type */
486 0, /* rightshift */
487 2, /* size (0 = byte, 1 = short, 2 = long) */
488 0, /* bitsize */
489 FALSE, /* pc_relative */
490 0, /* bitpos */
491 complain_overflow_dont, /* complain_on_overflow */
492 NULL, /* special_function */
493 "R_TILEPRO_GNU_VTINHERIT", /* name */
494 FALSE, /* partial_inplace */
495 0, /* src_mask */
496 0, /* dst_mask */
497 FALSE), /* pcrel_offset */
498
499 /* GNU extension to record C++ vtable member usage */
500 HOWTO (R_TILEPRO_GNU_VTENTRY, /* type */
501 0, /* rightshift */
502 2, /* size (0 = byte, 1 = short, 2 = long) */
503 0, /* bitsize */
504 FALSE, /* pc_relative */
505 0, /* bitpos */
506 complain_overflow_dont, /* complain_on_overflow */
507 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
508 "R_TILEPRO_GNU_VTENTRY", /* name */
509 FALSE, /* partial_inplace */
510 0, /* src_mask */
511 0, /* dst_mask */
512 FALSE), /* pcrel_offset */
513
514 };
515 \f
516 /* Map BFD reloc types to TILEPRO ELF reloc types. */
517
518 typedef struct tilepro_reloc_map
519 {
520 bfd_reloc_code_real_type bfd_reloc_val;
521 unsigned int tilepro_reloc_val;
522 reloc_howto_type * table;
523 } reloc_map;
524
525 static const reloc_map tilepro_reloc_map [] =
526 {
527 #define TH_REMAP(bfd, tilepro) \
528 { bfd, tilepro, tilepro_elf_howto_table },
529
530 /* Standard relocations. */
531 TH_REMAP (BFD_RELOC_NONE, R_TILEPRO_NONE)
532 TH_REMAP (BFD_RELOC_32, R_TILEPRO_32)
533 TH_REMAP (BFD_RELOC_16, R_TILEPRO_16)
534 TH_REMAP (BFD_RELOC_8, R_TILEPRO_8)
535 TH_REMAP (BFD_RELOC_32_PCREL, R_TILEPRO_32_PCREL)
536 TH_REMAP (BFD_RELOC_16_PCREL, R_TILEPRO_16_PCREL)
537 TH_REMAP (BFD_RELOC_8_PCREL, R_TILEPRO_8_PCREL)
538 TH_REMAP (BFD_RELOC_LO16, R_TILEPRO_LO16)
539 TH_REMAP (BFD_RELOC_HI16, R_TILEPRO_HI16)
540 TH_REMAP (BFD_RELOC_HI16_S, R_TILEPRO_HA16)
541
542 /* Custom relocations. */
543 TH_REMAP (BFD_RELOC_TILEPRO_COPY, R_TILEPRO_COPY)
544 TH_REMAP (BFD_RELOC_TILEPRO_GLOB_DAT, R_TILEPRO_GLOB_DAT)
545 TH_REMAP (BFD_RELOC_TILEPRO_JMP_SLOT, R_TILEPRO_JMP_SLOT)
546 TH_REMAP (BFD_RELOC_TILEPRO_RELATIVE, R_TILEPRO_RELATIVE)
547 TH_REMAP (BFD_RELOC_TILEPRO_BROFF_X1, R_TILEPRO_BROFF_X1)
548 TH_REMAP (BFD_RELOC_TILEPRO_JOFFLONG_X1, R_TILEPRO_JOFFLONG_X1)
549 TH_REMAP (BFD_RELOC_TILEPRO_JOFFLONG_X1_PLT, R_TILEPRO_JOFFLONG_X1_PLT)
550 TH_REMAP (BFD_RELOC_TILEPRO_IMM8_X0, R_TILEPRO_IMM8_X0)
551 TH_REMAP (BFD_RELOC_TILEPRO_IMM8_Y0, R_TILEPRO_IMM8_Y0)
552 TH_REMAP (BFD_RELOC_TILEPRO_IMM8_X1, R_TILEPRO_IMM8_X1)
553 TH_REMAP (BFD_RELOC_TILEPRO_IMM8_Y1, R_TILEPRO_IMM8_Y1)
554 TH_REMAP (BFD_RELOC_TILEPRO_DEST_IMM8_X1, R_TILEPRO_DEST_IMM8_X1)
555 TH_REMAP (BFD_RELOC_TILEPRO_MT_IMM15_X1, R_TILEPRO_MT_IMM15_X1)
556 TH_REMAP (BFD_RELOC_TILEPRO_MF_IMM15_X1, R_TILEPRO_MF_IMM15_X1)
557 TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0, R_TILEPRO_IMM16_X0)
558 TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1, R_TILEPRO_IMM16_X1)
559 TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_LO, R_TILEPRO_IMM16_X0_LO)
560 TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_LO, R_TILEPRO_IMM16_X1_LO)
561 TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_HI, R_TILEPRO_IMM16_X0_HI)
562 TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_HI, R_TILEPRO_IMM16_X1_HI)
563 TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_HA, R_TILEPRO_IMM16_X0_HA)
564 TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_HA, R_TILEPRO_IMM16_X1_HA)
565
566 TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_PCREL, R_TILEPRO_IMM16_X0_PCREL)
567 TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_PCREL, R_TILEPRO_IMM16_X1_PCREL)
568 TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_LO_PCREL, R_TILEPRO_IMM16_X0_LO_PCREL)
569 TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_LO_PCREL, R_TILEPRO_IMM16_X1_LO_PCREL)
570 TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_HI_PCREL, R_TILEPRO_IMM16_X0_HI_PCREL)
571 TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_HI_PCREL, R_TILEPRO_IMM16_X1_HI_PCREL)
572 TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_HA_PCREL, R_TILEPRO_IMM16_X0_HA_PCREL)
573 TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_HA_PCREL, R_TILEPRO_IMM16_X1_HA_PCREL)
574
575 TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_GOT, R_TILEPRO_IMM16_X0_GOT)
576 TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_GOT, R_TILEPRO_IMM16_X1_GOT)
577 TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_GOT_LO, R_TILEPRO_IMM16_X0_GOT_LO)
578 TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_GOT_LO, R_TILEPRO_IMM16_X1_GOT_LO)
579 TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_GOT_HI, R_TILEPRO_IMM16_X0_GOT_HI)
580 TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_GOT_HI, R_TILEPRO_IMM16_X1_GOT_HI)
581 TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_GOT_HA, R_TILEPRO_IMM16_X0_GOT_HA)
582 TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_GOT_HA, R_TILEPRO_IMM16_X1_GOT_HA)
583
584 TH_REMAP (BFD_RELOC_TILEPRO_MMSTART_X0, R_TILEPRO_MMSTART_X0)
585 TH_REMAP (BFD_RELOC_TILEPRO_MMEND_X0, R_TILEPRO_MMEND_X0)
586 TH_REMAP (BFD_RELOC_TILEPRO_MMSTART_X1, R_TILEPRO_MMSTART_X1)
587 TH_REMAP (BFD_RELOC_TILEPRO_MMEND_X1, R_TILEPRO_MMEND_X1)
588 TH_REMAP (BFD_RELOC_TILEPRO_SHAMT_X0, R_TILEPRO_SHAMT_X0)
589 TH_REMAP (BFD_RELOC_TILEPRO_SHAMT_X1, R_TILEPRO_SHAMT_X1)
590 TH_REMAP (BFD_RELOC_TILEPRO_SHAMT_Y0, R_TILEPRO_SHAMT_Y0)
591 TH_REMAP (BFD_RELOC_TILEPRO_SHAMT_Y1, R_TILEPRO_SHAMT_Y1)
592
593 TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_TLS_GD, R_TILEPRO_IMM16_X0_TLS_GD)
594 TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_TLS_GD, R_TILEPRO_IMM16_X1_TLS_GD)
595 TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_TLS_GD_LO, R_TILEPRO_IMM16_X0_TLS_GD_LO)
596 TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_TLS_GD_LO, R_TILEPRO_IMM16_X1_TLS_GD_LO)
597 TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_TLS_GD_HI, R_TILEPRO_IMM16_X0_TLS_GD_HI)
598 TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_TLS_GD_HI, R_TILEPRO_IMM16_X1_TLS_GD_HI)
599 TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_TLS_GD_HA, R_TILEPRO_IMM16_X0_TLS_GD_HA)
600 TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_TLS_GD_HA, R_TILEPRO_IMM16_X1_TLS_GD_HA)
601
602 TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_TLS_IE, R_TILEPRO_IMM16_X0_TLS_IE)
603 TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_TLS_IE, R_TILEPRO_IMM16_X1_TLS_IE)
604 TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_TLS_IE_LO, R_TILEPRO_IMM16_X0_TLS_IE_LO)
605 TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_TLS_IE_LO, R_TILEPRO_IMM16_X1_TLS_IE_LO)
606 TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_TLS_IE_HI, R_TILEPRO_IMM16_X0_TLS_IE_HI)
607 TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_TLS_IE_HI, R_TILEPRO_IMM16_X1_TLS_IE_HI)
608 TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_TLS_IE_HA, R_TILEPRO_IMM16_X0_TLS_IE_HA)
609 TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_TLS_IE_HA, R_TILEPRO_IMM16_X1_TLS_IE_HA)
610
611 TH_REMAP (BFD_RELOC_TILEPRO_TLS_DTPMOD32, R_TILEPRO_TLS_DTPMOD32)
612 TH_REMAP (BFD_RELOC_TILEPRO_TLS_DTPOFF32, R_TILEPRO_TLS_DTPOFF32)
613 TH_REMAP (BFD_RELOC_TILEPRO_TLS_TPOFF32, R_TILEPRO_TLS_TPOFF32)
614
615 #undef TH_REMAP
616
617 { BFD_RELOC_VTABLE_INHERIT, R_TILEPRO_GNU_VTINHERIT, tilepro_elf_howto_table2 },
618 { BFD_RELOC_VTABLE_ENTRY, R_TILEPRO_GNU_VTENTRY, tilepro_elf_howto_table2 },
619 };
620
621
622
623 /* The TILEPro linker needs to keep track of the number of relocs that it
624 decides to copy as dynamic relocs in check_relocs for each symbol.
625 This is so that it can later discard them if they are found to be
626 unnecessary. We store the information in a field extending the
627 regular ELF linker hash table. */
628
629 struct tilepro_elf_dyn_relocs
630 {
631 struct tilepro_elf_dyn_relocs *next;
632
633 /* The input section of the reloc. */
634 asection *sec;
635
636 /* Total number of relocs copied for the input section. */
637 bfd_size_type count;
638
639 /* Number of pc-relative relocs copied for the input section. */
640 bfd_size_type pc_count;
641 };
642
643 /* TILEPRO ELF linker hash entry. */
644
645 struct tilepro_elf_link_hash_entry
646 {
647 struct elf_link_hash_entry elf;
648
649 /* Track dynamic relocs copied for this symbol. */
650 struct tilepro_elf_dyn_relocs *dyn_relocs;
651
652 #define GOT_UNKNOWN 0
653 #define GOT_NORMAL 1
654 #define GOT_TLS_GD 2
655 #define GOT_TLS_IE 4
656 unsigned char tls_type;
657 };
658
659 #define tilepro_elf_hash_entry(ent) \
660 ((struct tilepro_elf_link_hash_entry *)(ent))
661
662 struct _bfd_tilepro_elf_obj_tdata
663 {
664 struct elf_obj_tdata root;
665
666 /* tls_type for each local got entry. */
667 char *local_got_tls_type;
668 };
669
670 #define _bfd_tilepro_elf_tdata(abfd) \
671 ((struct _bfd_tilepro_elf_obj_tdata *) (abfd)->tdata.any)
672
673 #define _bfd_tilepro_elf_local_got_tls_type(abfd) \
674 (_bfd_tilepro_elf_tdata (abfd)->local_got_tls_type)
675
676 #define is_tilepro_elf(bfd) \
677 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
678 && elf_tdata (bfd) != NULL \
679 && elf_object_id (bfd) == TILEPRO_ELF_DATA)
680
681 #include "elf/common.h"
682 #include "elf/internal.h"
683
684 struct tilepro_elf_link_hash_table
685 {
686 struct elf_link_hash_table elf;
687
688 /* Short-cuts to get to dynamic linker sections. */
689 asection *sdynbss;
690 asection *srelbss;
691
692 /* Small local sym to section mapping cache. */
693 struct sym_cache sym_cache;
694 };
695
696 /* Get the Tilepro ELF linker hash table from a link_info structure. */
697 #define tilepro_elf_hash_table(p) \
698 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
699 == TILEPRO_ELF_DATA \
700 ? ((struct tilepro_elf_link_hash_table *) ((p)->hash)) : NULL)
701
702 static reloc_howto_type *
703 tilepro_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
704 bfd_reloc_code_real_type code)
705 {
706 unsigned int i;
707
708 for (i = ARRAY_SIZE (tilepro_reloc_map); --i;)
709 {
710 const reloc_map * entry;
711
712 entry = tilepro_reloc_map + i;
713
714 if (entry->bfd_reloc_val == code)
715 return entry->table + (entry->tilepro_reloc_val
716 - entry->table[0].type);
717 }
718
719 return NULL;
720 }
721
722 static reloc_howto_type *
723 tilepro_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
724 const char *r_name)
725 {
726 unsigned int i;
727
728 for (i = 0;
729 i < (sizeof (tilepro_elf_howto_table)
730 / sizeof (tilepro_elf_howto_table[0]));
731 i++)
732 if (tilepro_elf_howto_table[i].name != NULL
733 && strcasecmp (tilepro_elf_howto_table[i].name, r_name) == 0)
734 return &tilepro_elf_howto_table[i];
735
736 return NULL;
737 }
738
739 /* Set the howto pointer for an TILEPro ELF reloc. */
740
741 static void
742 tilepro_info_to_howto_rela (bfd * abfd ATTRIBUTE_UNUSED,
743 arelent * cache_ptr,
744 Elf_Internal_Rela * dst)
745 {
746 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
747
748 if (r_type <= (unsigned int) R_TILEPRO_TLS_TPOFF32)
749 cache_ptr->howto = &tilepro_elf_howto_table [r_type];
750 else if (r_type - R_TILEPRO_GNU_VTINHERIT
751 <= (unsigned int) R_TILEPRO_GNU_VTENTRY)
752 cache_ptr->howto
753 = &tilepro_elf_howto_table2 [r_type - R_TILEPRO_GNU_VTINHERIT];
754 else
755 abort ();
756 }
757
758 typedef tilepro_bundle_bits (*tilepro_create_func)(int);
759
760 static const tilepro_create_func reloc_to_create_func[] =
761 {
762 /* The first fourteen relocation types don't correspond to operands */
763 NULL,
764 NULL,
765 NULL,
766 NULL,
767 NULL,
768 NULL,
769 NULL,
770 NULL,
771 NULL,
772 NULL,
773 NULL,
774 NULL,
775 NULL,
776 NULL,
777
778 /* The remaining relocations are used for immediate operands */
779 create_BrOff_X1,
780 create_JOffLong_X1,
781 create_JOffLong_X1,
782 create_Imm8_X0,
783 create_Imm8_Y0,
784 create_Imm8_X1,
785 create_Imm8_Y1,
786 create_MT_Imm15_X1,
787 create_MF_Imm15_X1,
788 create_Imm16_X0,
789 create_Imm16_X1,
790 create_Imm16_X0,
791 create_Imm16_X1,
792 create_Imm16_X0,
793 create_Imm16_X1,
794 create_Imm16_X0,
795 create_Imm16_X1,
796 create_Imm16_X0,
797 create_Imm16_X1,
798 create_Imm16_X0,
799 create_Imm16_X1,
800 create_Imm16_X0,
801 create_Imm16_X1,
802 create_Imm16_X0,
803 create_Imm16_X1,
804 create_Imm16_X0,
805 create_Imm16_X1,
806 create_Imm16_X0,
807 create_Imm16_X1,
808 create_Imm16_X0,
809 create_Imm16_X1,
810 create_Imm16_X0,
811 create_Imm16_X1,
812 create_MMStart_X0,
813 create_MMEnd_X0,
814 create_MMStart_X1,
815 create_MMEnd_X1,
816 create_ShAmt_X0,
817 create_ShAmt_X1,
818 create_ShAmt_Y0,
819 create_ShAmt_Y1,
820
821 create_Dest_Imm8_X1,
822 NULL,
823 NULL,
824 NULL,
825 NULL,
826 NULL,
827 NULL,
828 NULL,
829 NULL,
830 NULL,
831 NULL,
832
833 create_Imm16_X0,
834 create_Imm16_X1,
835 create_Imm16_X0,
836 create_Imm16_X1,
837 create_Imm16_X0,
838 create_Imm16_X1,
839 create_Imm16_X0,
840 create_Imm16_X1,
841 create_Imm16_X0,
842 create_Imm16_X1,
843 create_Imm16_X0,
844 create_Imm16_X1,
845 create_Imm16_X0,
846 create_Imm16_X1,
847 create_Imm16_X0,
848 create_Imm16_X1
849 };
850
851 #define NELEMS(a) ((int) (sizeof (a) / sizeof ((a)[0])))
852
853 /* Support for core dump NOTE sections. */
854
855 static bfd_boolean
856 tilepro_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
857 {
858 int offset;
859 size_t size;
860
861 if (note->descsz != TILEPRO_PRSTATUS_SIZEOF)
862 return FALSE;
863
864 /* pr_cursig */
865 elf_tdata (abfd)->core_signal =
866 bfd_get_16 (abfd, note->descdata + TILEPRO_PRSTATUS_OFFSET_PR_CURSIG);
867
868 /* pr_pid */
869 elf_tdata (abfd)->core_pid =
870 bfd_get_32 (abfd, note->descdata + TILEPRO_PRSTATUS_OFFSET_PR_PID);
871
872 /* pr_reg */
873 offset = TILEPRO_PRSTATUS_OFFSET_PR_REG;
874 size = TILEPRO_GREGSET_T_SIZE;
875
876 /* Make a ".reg/999" section. */
877 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
878 size, note->descpos + offset);
879 }
880
881 static bfd_boolean
882 tilepro_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
883 {
884 if (note->descsz != TILEPRO_PRPSINFO_SIZEOF)
885 return FALSE;
886
887 elf_tdata (abfd)->core_program
888 = _bfd_elfcore_strndup (abfd,
889 note->descdata + TILEPRO_PRPSINFO_OFFSET_PR_FNAME,
890 16);
891 elf_tdata (abfd)->core_command
892 = _bfd_elfcore_strndup (abfd,
893 note->descdata + TILEPRO_PRPSINFO_OFFSET_PR_PSARGS,
894 ELF_PR_PSARGS_SIZE);
895
896
897 /* Note that for some reason, a spurious space is tacked
898 onto the end of the args in some (at least one anyway)
899 implementations, so strip it off if it exists. */
900 {
901 char *command = elf_tdata (abfd)->core_command;
902 int n = strlen (command);
903
904 if (0 < n && command[n - 1] == ' ')
905 command[n - 1] = '\0';
906 }
907
908 return TRUE;
909 }
910
911
912 static void
913 tilepro_elf_append_rela_32 (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
914 {
915 Elf32_External_Rela *loc32;
916
917 loc32 = (Elf32_External_Rela *) s->contents;
918 loc32 += s->reloc_count++;
919 bfd_elf32_swap_reloca_out (abfd, rel, (bfd_byte *) loc32);
920 }
921
922 /* PLT/GOT stuff */
923
924 /* The procedure linkage table starts with the following header:
925
926 {
927 rli r29, r29, 16
928 lwadd r28, r27, 4
929 }
930 lw r27, r27
931 {
932 info 10 ## SP not offset, return PC in LR
933 jr r27
934 }
935
936 Subsequent entries are the following, jumping to the header at the end:
937
938 lnk r28
939 1:
940 {
941 auli r28, r28, <_GLOBAL_OFFSET_TABLE_ - 1b + MY_GOT_OFFSET>
942 auli r27, r28, <_GLOBAL_OFFSET_TABLE_ - 1b>
943 }
944 {
945 addli r28, r28, <_GLOBAL_OFFSET_TABLE_ - 1b + MY_GOT_OFFSET>
946 addli r27, r27, <_GLOBAL_OFFSET_TABLE_ - 1b>
947 }
948 {
949 auli r29, zero, MY_PLT_INDEX
950 lw r28, r28
951 }
952 {
953 info 10 ## SP not offset, return PC in LR
954 jr r28
955 }
956
957 We initially store MY_PLT_INDEX in the high bits so that we can use the all
958 16 bits as an unsigned offset; if we use the low bits we would get an
959 unwanted sign extension. The PLT header then rotates the index to get the
960 right value, before calling the resolution routine. This computation can
961 fit in unused bundle slots so it's free.
962
963 This code sequence lets the code at at the start of the PLT determine
964 which PLT entry was executed by examining 'r29'.
965
966 Note that MY_PLT_INDEX skips over the header entries, so the first
967 actual jump table entry has index zero.
968 */
969
970 #define PLT_HEADER_SIZE_IN_BUNDLES 3
971 #define PLT_ENTRY_SIZE_IN_BUNDLES 5
972
973 #define PLT_HEADER_SIZE \
974 (PLT_HEADER_SIZE_IN_BUNDLES * TILEPRO_BUNDLE_SIZE_IN_BYTES)
975 #define PLT_ENTRY_SIZE \
976 (PLT_ENTRY_SIZE_IN_BUNDLES * TILEPRO_BUNDLE_SIZE_IN_BYTES)
977
978 /* The size in bytes of an entry in the global offset table. */
979
980 #define GOT_ENTRY_SIZE TILEPRO_BYTES_PER_WORD
981
982 #define GOTPLT_HEADER_SIZE (2 * GOT_ENTRY_SIZE)
983
984
985 static const bfd_byte
986 tilepro_plt0_entry[PLT_HEADER_SIZE] =
987 {
988 0x5d, 0x07, 0x03, 0x70,
989 0x6e, 0x23, 0xd0, 0x30, /* { rli r29, r29, 16 ; lwadd r28, r27, 4 } */
990 0x00, 0x50, 0xba, 0x6d,
991 0x00, 0x08, 0x6d, 0xdc, /* { lw r27, r27 } */
992 0xff, 0xaf, 0x10, 0x50,
993 0x60, 0x03, 0x18, 0x08, /* { info 10 ; jr r27 } */
994 };
995
996 static const bfd_byte
997 tilepro_short_plt_entry[PLT_ENTRY_SIZE] =
998 {
999 0x00, 0x50, 0x16, 0x70,
1000 0x0e, 0x00, 0x1a, 0x08, /* { lnk r28 } */
1001 0x1c, 0x07, 0x00, 0xa0,
1002 0x8d, 0x03, 0x00, 0x18, /* { addli r28, r28, 0 ; addli r27, r28, 0 } */
1003 0xdd, 0x0f, 0x00, 0x30,
1004 0x8e, 0x73, 0x0b, 0x40, /* { auli r29, zero, 0 ; lw r28, r28 } */
1005 0xff, 0xaf, 0x10, 0x50,
1006 0x80, 0x03, 0x18, 0x08, /* { info 10 ; jr r28 } */
1007 0x00, 0x00, 0x00, 0x00,
1008 0x00, 0x00, 0x00, 0x00,
1009 };
1010
1011 static const bfd_byte
1012 tilepro_long_plt_entry[PLT_ENTRY_SIZE] =
1013 {
1014 0x00, 0x50, 0x16, 0x70,
1015 0x0e, 0x00, 0x1a, 0x08, /* { lnk r28 } */
1016 0x1c, 0x07, 0x00, 0xb0,
1017 0x8d, 0x03, 0x00, 0x20, /* { auli r28, r28, 0 ; auli r27, r28, 0 } */
1018 0x1c, 0x07, 0x00, 0xa0,
1019 0x6d, 0x03, 0x00, 0x18, /* { addli r28, r28, 0 ; addli r27, r27, 0 } */
1020 0xdd, 0x0f, 0x00, 0x30,
1021 0x8e, 0x73, 0x0b, 0x40, /* { auli r29, zero, 0 ; lw r28, r28 } */
1022 0xff, 0xaf, 0x10, 0x50,
1023 0x80, 0x03, 0x18, 0x08, /* { info 10 ; jr r28 } */
1024 };
1025
1026 static bfd_vma
1027 tilepro_ha16(bfd_vma vma)
1028 {
1029 return ((vma >> 16) + ((vma >> 15) & 1)) & 0xffff;
1030 }
1031
1032 static int
1033 tilepro_plt_entry_build (asection *splt, asection *sgotplt, bfd_vma offset,
1034 bfd_vma *r_offset)
1035 {
1036 int plt_index = (offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
1037 int got_offset = plt_index * GOT_ENTRY_SIZE + GOTPLT_HEADER_SIZE;
1038 tilepro_bundle_bits *pc;
1039
1040 /* Compute the distance from the got entry to the lnk. */
1041 bfd_signed_vma dist_got_entry = sgotplt->output_section->vma
1042 + sgotplt->output_offset
1043 + got_offset
1044 - splt->output_section->vma
1045 - splt->output_offset
1046 - offset
1047 - TILEPRO_BUNDLE_SIZE_IN_BYTES;
1048
1049 /* Compute the distance to GOTPLT[0]. */
1050 bfd_signed_vma dist_got0 = dist_got_entry - got_offset;
1051
1052 /* Check whether we can use the short plt entry with 16-bit offset. */
1053 bfd_boolean short_plt_entry =
1054 (dist_got_entry <= 0x7fff && dist_got0 >= -0x8000);
1055
1056 /* Copy the plt entry template. */
1057 memcpy (splt->contents + offset,
1058 short_plt_entry ? tilepro_short_plt_entry : tilepro_long_plt_entry,
1059 PLT_ENTRY_SIZE);
1060
1061 /* Write the immediate offsets. */
1062 pc = (tilepro_bundle_bits *)(splt->contents + offset);
1063 pc++;
1064
1065 if (!short_plt_entry)
1066 {
1067 /* { auli r28, r28, &GOTPLT[MY_GOT_INDEX] ; auli r27, r28, &GOTPLT[0] } */
1068 *pc++ |= create_Imm16_X0 (tilepro_ha16 (dist_got_entry))
1069 | create_Imm16_X1 (tilepro_ha16 (dist_got0));
1070 }
1071
1072 /* { addli r28, r28, &GOTPLT[MY_GOT_INDEX] ; addli r27, r28, &GOTPLT[0] } or
1073 { addli r28, r28, &GOTPLT[MY_GOT_INDEX] ; addli r27, r27, &GOTPLT[0] } */
1074 *pc++ |= create_Imm16_X0 (dist_got_entry)
1075 | create_Imm16_X1 (dist_got0);
1076
1077 /* { auli r29, zero, MY_PLT_INDEX ; lw r28, r28 } */
1078 *pc |= create_Imm16_X0 (plt_index);
1079
1080 /* Set the relocation offset. */
1081 *r_offset = got_offset;
1082
1083 return plt_index;
1084 }
1085
1086 #define TILEPRO_ELF_RELA_BYTES (sizeof(Elf32_External_Rela))
1087
1088
1089 /* Create an entry in an TILEPro ELF linker hash table. */
1090
1091 static struct bfd_hash_entry *
1092 link_hash_newfunc (struct bfd_hash_entry *entry,
1093 struct bfd_hash_table *table, const char *string)
1094 {
1095 /* Allocate the structure if it has not already been allocated by a
1096 subclass. */
1097 if (entry == NULL)
1098 {
1099 entry =
1100 bfd_hash_allocate (table,
1101 sizeof (struct tilepro_elf_link_hash_entry));
1102 if (entry == NULL)
1103 return entry;
1104 }
1105
1106 /* Call the allocation method of the superclass. */
1107 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
1108 if (entry != NULL)
1109 {
1110 struct tilepro_elf_link_hash_entry *eh;
1111
1112 eh = (struct tilepro_elf_link_hash_entry *) entry;
1113 eh->dyn_relocs = NULL;
1114 eh->tls_type = GOT_UNKNOWN;
1115 }
1116
1117 return entry;
1118 }
1119
1120 /* Create a TILEPRO ELF linker hash table. */
1121
1122 static struct bfd_link_hash_table *
1123 tilepro_elf_link_hash_table_create (bfd *abfd)
1124 {
1125 struct tilepro_elf_link_hash_table *ret;
1126 bfd_size_type amt = sizeof (struct tilepro_elf_link_hash_table);
1127
1128 ret = (struct tilepro_elf_link_hash_table *) bfd_zmalloc (amt);
1129 if (ret == NULL)
1130 return NULL;
1131
1132 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc,
1133 sizeof (struct tilepro_elf_link_hash_entry),
1134 TILEPRO_ELF_DATA))
1135 {
1136 free (ret);
1137 return NULL;
1138 }
1139
1140 return &ret->elf.root;
1141 }
1142
1143 /* Create the .got section. */
1144
1145 static bfd_boolean
1146 tilepro_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
1147 {
1148 flagword flags;
1149 asection *s, *s_got;
1150 struct elf_link_hash_entry *h;
1151 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1152 struct elf_link_hash_table *htab = elf_hash_table (info);
1153
1154 /* This function may be called more than once. */
1155 s = bfd_get_section_by_name (abfd, ".got");
1156 if (s != NULL && (s->flags & SEC_LINKER_CREATED) != 0)
1157 return TRUE;
1158
1159 flags = bed->dynamic_sec_flags;
1160
1161 s = bfd_make_section_with_flags (abfd,
1162 (bed->rela_plts_and_copies_p
1163 ? ".rela.got" : ".rel.got"),
1164 (bed->dynamic_sec_flags
1165 | SEC_READONLY));
1166 if (s == NULL
1167 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
1168 return FALSE;
1169 htab->srelgot = s;
1170
1171 s = s_got = bfd_make_section_with_flags (abfd, ".got", flags);
1172 if (s == NULL
1173 || !bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
1174 return FALSE;
1175 htab->sgot = s;
1176
1177 /* The first bit of the global offset table is the header. */
1178 s->size += bed->got_header_size;
1179
1180 if (bed->want_got_plt)
1181 {
1182 s = bfd_make_section_with_flags (abfd, ".got.plt", flags);
1183 if (s == NULL
1184 || !bfd_set_section_alignment (abfd, s,
1185 bed->s->log_file_align))
1186 return FALSE;
1187 htab->sgotplt = s;
1188
1189 /* Reserve room for the header. */
1190 s->size += GOTPLT_HEADER_SIZE;
1191 }
1192
1193 if (bed->want_got_sym)
1194 {
1195 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
1196 section. We don't do this in the linker script because we don't want
1197 to define the symbol if we are not creating a global offset
1198 table. */
1199 h = _bfd_elf_define_linkage_sym (abfd, info, s_got,
1200 "_GLOBAL_OFFSET_TABLE_");
1201 elf_hash_table (info)->hgot = h;
1202 if (h == NULL)
1203 return FALSE;
1204 }
1205
1206 return TRUE;
1207 }
1208
1209 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
1210 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
1211 hash table. */
1212
1213 static bfd_boolean
1214 tilepro_elf_create_dynamic_sections (bfd *dynobj,
1215 struct bfd_link_info *info)
1216 {
1217 struct tilepro_elf_link_hash_table *htab;
1218
1219 htab = tilepro_elf_hash_table (info);
1220 BFD_ASSERT (htab != NULL);
1221
1222 if (!tilepro_elf_create_got_section (dynobj, info))
1223 return FALSE;
1224
1225 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
1226 return FALSE;
1227
1228 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
1229 if (!info->shared)
1230 htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss");
1231
1232 if (!htab->elf.splt || !htab->elf.srelplt || !htab->sdynbss
1233 || (!info->shared && !htab->srelbss))
1234 abort ();
1235
1236 return TRUE;
1237 }
1238
1239 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1240
1241 static void
1242 tilepro_elf_copy_indirect_symbol (struct bfd_link_info *info,
1243 struct elf_link_hash_entry *dir,
1244 struct elf_link_hash_entry *ind)
1245 {
1246 struct tilepro_elf_link_hash_entry *edir, *eind;
1247
1248 edir = (struct tilepro_elf_link_hash_entry *) dir;
1249 eind = (struct tilepro_elf_link_hash_entry *) ind;
1250
1251 if (eind->dyn_relocs != NULL)
1252 {
1253 if (edir->dyn_relocs != NULL)
1254 {
1255 struct tilepro_elf_dyn_relocs **pp;
1256 struct tilepro_elf_dyn_relocs *p;
1257
1258 /* Add reloc counts against the indirect sym to the direct sym
1259 list. Merge any entries against the same section. */
1260 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1261 {
1262 struct tilepro_elf_dyn_relocs *q;
1263
1264 for (q = edir->dyn_relocs; q != NULL; q = q->next)
1265 if (q->sec == p->sec)
1266 {
1267 q->pc_count += p->pc_count;
1268 q->count += p->count;
1269 *pp = p->next;
1270 break;
1271 }
1272 if (q == NULL)
1273 pp = &p->next;
1274 }
1275 *pp = edir->dyn_relocs;
1276 }
1277
1278 edir->dyn_relocs = eind->dyn_relocs;
1279 eind->dyn_relocs = NULL;
1280 }
1281
1282 if (ind->root.type == bfd_link_hash_indirect
1283 && dir->got.refcount <= 0)
1284 {
1285 edir->tls_type = eind->tls_type;
1286 eind->tls_type = GOT_UNKNOWN;
1287 }
1288 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1289 }
1290
1291 /* Look through the relocs for a section during the first phase, and
1292 allocate space in the global offset table or procedure linkage
1293 table. */
1294
1295 static bfd_boolean
1296 tilepro_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
1297 asection *sec, const Elf_Internal_Rela *relocs)
1298 {
1299 struct tilepro_elf_link_hash_table *htab;
1300 Elf_Internal_Shdr *symtab_hdr;
1301 struct elf_link_hash_entry **sym_hashes;
1302 const Elf_Internal_Rela *rel;
1303 const Elf_Internal_Rela *rel_end;
1304 asection *sreloc;
1305 int num_relocs;
1306
1307 if (info->relocatable)
1308 return TRUE;
1309
1310 htab = tilepro_elf_hash_table (info);
1311 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1312 sym_hashes = elf_sym_hashes (abfd);
1313
1314 sreloc = NULL;
1315
1316 num_relocs = sec->reloc_count;
1317
1318 BFD_ASSERT (is_tilepro_elf (abfd) || num_relocs == 0);
1319
1320 if (htab->elf.dynobj == NULL)
1321 htab->elf.dynobj = abfd;
1322
1323 rel_end = relocs + num_relocs;
1324 for (rel = relocs; rel < rel_end; rel++)
1325 {
1326 unsigned int r_type;
1327 unsigned long r_symndx;
1328 struct elf_link_hash_entry *h;
1329 int tls_type;
1330
1331 r_symndx = ELF32_R_SYM (rel->r_info);
1332 r_type = ELF32_R_TYPE (rel->r_info);
1333
1334 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1335 {
1336 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1337 abfd, r_symndx);
1338 return FALSE;
1339 }
1340
1341 if (r_symndx < symtab_hdr->sh_info)
1342 h = NULL;
1343 else
1344 {
1345 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1346 while (h->root.type == bfd_link_hash_indirect
1347 || h->root.type == bfd_link_hash_warning)
1348 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1349 }
1350
1351 switch (r_type)
1352 {
1353 case R_TILEPRO_IMM16_X0_TLS_GD:
1354 case R_TILEPRO_IMM16_X1_TLS_GD:
1355 case R_TILEPRO_IMM16_X0_TLS_GD_LO:
1356 case R_TILEPRO_IMM16_X1_TLS_GD_LO:
1357 case R_TILEPRO_IMM16_X0_TLS_GD_HI:
1358 case R_TILEPRO_IMM16_X1_TLS_GD_HI:
1359 case R_TILEPRO_IMM16_X0_TLS_GD_HA:
1360 case R_TILEPRO_IMM16_X1_TLS_GD_HA:
1361 tls_type = GOT_TLS_GD;
1362 goto have_got_reference;
1363
1364 case R_TILEPRO_IMM16_X0_TLS_IE:
1365 case R_TILEPRO_IMM16_X1_TLS_IE:
1366 case R_TILEPRO_IMM16_X0_TLS_IE_LO:
1367 case R_TILEPRO_IMM16_X1_TLS_IE_LO:
1368 case R_TILEPRO_IMM16_X0_TLS_IE_HI:
1369 case R_TILEPRO_IMM16_X1_TLS_IE_HI:
1370 case R_TILEPRO_IMM16_X0_TLS_IE_HA:
1371 case R_TILEPRO_IMM16_X1_TLS_IE_HA:
1372 tls_type = GOT_TLS_IE;
1373 if (info->shared)
1374 info->flags |= DF_STATIC_TLS;
1375 goto have_got_reference;
1376
1377 case R_TILEPRO_IMM16_X0_GOT:
1378 case R_TILEPRO_IMM16_X1_GOT:
1379 case R_TILEPRO_IMM16_X0_GOT_LO:
1380 case R_TILEPRO_IMM16_X1_GOT_LO:
1381 case R_TILEPRO_IMM16_X0_GOT_HI:
1382 case R_TILEPRO_IMM16_X1_GOT_HI:
1383 case R_TILEPRO_IMM16_X0_GOT_HA:
1384 case R_TILEPRO_IMM16_X1_GOT_HA:
1385 tls_type = GOT_NORMAL;
1386 /* Fall Through */
1387
1388 have_got_reference:
1389 /* This symbol requires a global offset table entry. */
1390 {
1391 int old_tls_type;
1392
1393 if (h != NULL)
1394 {
1395 h->got.refcount += 1;
1396 old_tls_type = tilepro_elf_hash_entry(h)->tls_type;
1397 }
1398 else
1399 {
1400 bfd_signed_vma *local_got_refcounts;
1401
1402 /* This is a global offset table entry for a local symbol. */
1403 local_got_refcounts = elf_local_got_refcounts (abfd);
1404 if (local_got_refcounts == NULL)
1405 {
1406 bfd_size_type size;
1407
1408 size = symtab_hdr->sh_info;
1409 size *= (sizeof (bfd_signed_vma) + sizeof(char));
1410 local_got_refcounts = ((bfd_signed_vma *)
1411 bfd_zalloc (abfd, size));
1412 if (local_got_refcounts == NULL)
1413 return FALSE;
1414 elf_local_got_refcounts (abfd) = local_got_refcounts;
1415 _bfd_tilepro_elf_local_got_tls_type (abfd)
1416 = (char *) (local_got_refcounts + symtab_hdr->sh_info);
1417 }
1418 local_got_refcounts[r_symndx] += 1;
1419 old_tls_type =
1420 _bfd_tilepro_elf_local_got_tls_type (abfd) [r_symndx];
1421 }
1422
1423 /* If a TLS symbol is accessed using IE at least once,
1424 there is no point to use dynamic model for it. */
1425 if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1426 && (old_tls_type != GOT_TLS_GD
1427 || tls_type != GOT_TLS_IE))
1428 {
1429 if (old_tls_type == GOT_TLS_IE && tls_type == GOT_TLS_GD)
1430 tls_type = old_tls_type;
1431 else
1432 {
1433 (*_bfd_error_handler)
1434 (_("%B: `%s' accessed both as normal and thread local symbol"),
1435 abfd, h ? h->root.root.string : "<local>");
1436 return FALSE;
1437 }
1438 }
1439
1440 if (old_tls_type != tls_type)
1441 {
1442 if (h != NULL)
1443 tilepro_elf_hash_entry (h)->tls_type = tls_type;
1444 else
1445 _bfd_tilepro_elf_local_got_tls_type (abfd) [r_symndx] =
1446 tls_type;
1447 }
1448 }
1449
1450 if (htab->elf.sgot == NULL)
1451 {
1452 if (!tilepro_elf_create_got_section (htab->elf.dynobj, info))
1453 return FALSE;
1454 }
1455 break;
1456
1457 case R_TILEPRO_JOFFLONG_X1_PLT:
1458 /* This symbol requires a procedure linkage table entry. We
1459 actually build the entry in adjust_dynamic_symbol,
1460 because this might be a case of linking PIC code without
1461 linking in any dynamic objects, in which case we don't
1462 need to generate a procedure linkage table after all. */
1463
1464 if (h != NULL)
1465 {
1466 h->needs_plt = 1;
1467 h->plt.refcount += 1;
1468 }
1469 break;
1470
1471 case R_TILEPRO_32_PCREL:
1472 case R_TILEPRO_16_PCREL:
1473 case R_TILEPRO_8_PCREL:
1474 case R_TILEPRO_IMM16_X0_PCREL:
1475 case R_TILEPRO_IMM16_X1_PCREL:
1476 case R_TILEPRO_IMM16_X0_LO_PCREL:
1477 case R_TILEPRO_IMM16_X1_LO_PCREL:
1478 case R_TILEPRO_IMM16_X0_HI_PCREL:
1479 case R_TILEPRO_IMM16_X1_HI_PCREL:
1480 case R_TILEPRO_IMM16_X0_HA_PCREL:
1481 case R_TILEPRO_IMM16_X1_HA_PCREL:
1482 if (h != NULL)
1483 h->non_got_ref = 1;
1484
1485 if (h != NULL
1486 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1487 break;
1488 /* Fall through. */
1489
1490 case R_TILEPRO_32:
1491 case R_TILEPRO_16:
1492 case R_TILEPRO_8:
1493 case R_TILEPRO_LO16:
1494 case R_TILEPRO_HI16:
1495 case R_TILEPRO_HA16:
1496 case R_TILEPRO_COPY:
1497 case R_TILEPRO_GLOB_DAT:
1498 case R_TILEPRO_JMP_SLOT:
1499 case R_TILEPRO_RELATIVE:
1500 case R_TILEPRO_BROFF_X1:
1501 case R_TILEPRO_JOFFLONG_X1:
1502 case R_TILEPRO_IMM8_X0:
1503 case R_TILEPRO_IMM8_Y0:
1504 case R_TILEPRO_IMM8_X1:
1505 case R_TILEPRO_IMM8_Y1:
1506 case R_TILEPRO_DEST_IMM8_X1:
1507 case R_TILEPRO_MT_IMM15_X1:
1508 case R_TILEPRO_MF_IMM15_X1:
1509 case R_TILEPRO_IMM16_X0:
1510 case R_TILEPRO_IMM16_X1:
1511 case R_TILEPRO_IMM16_X0_LO:
1512 case R_TILEPRO_IMM16_X1_LO:
1513 case R_TILEPRO_IMM16_X0_HI:
1514 case R_TILEPRO_IMM16_X1_HI:
1515 case R_TILEPRO_IMM16_X0_HA:
1516 case R_TILEPRO_IMM16_X1_HA:
1517 case R_TILEPRO_MMSTART_X0:
1518 case R_TILEPRO_MMEND_X0:
1519 case R_TILEPRO_MMSTART_X1:
1520 case R_TILEPRO_MMEND_X1:
1521 case R_TILEPRO_SHAMT_X0:
1522 case R_TILEPRO_SHAMT_X1:
1523 case R_TILEPRO_SHAMT_Y0:
1524 case R_TILEPRO_SHAMT_Y1:
1525 if (h != NULL)
1526 {
1527 h->non_got_ref = 1;
1528
1529 if (!info->shared)
1530 {
1531 /* We may need a .plt entry if the function this reloc
1532 refers to is in a shared lib. */
1533 h->plt.refcount += 1;
1534 }
1535 }
1536
1537 /* If we are creating a shared library, and this is a reloc
1538 against a global symbol, or a non PC relative reloc
1539 against a local symbol, then we need to copy the reloc
1540 into the shared library. However, if we are linking with
1541 -Bsymbolic, we do not need to copy a reloc against a
1542 global symbol which is defined in an object we are
1543 including in the link (i.e., DEF_REGULAR is set). At
1544 this point we have not seen all the input files, so it is
1545 possible that DEF_REGULAR is not set now but will be set
1546 later (it is never cleared). In case of a weak definition,
1547 DEF_REGULAR may be cleared later by a strong definition in
1548 a shared library. We account for that possibility below by
1549 storing information in the relocs_copied field of the hash
1550 table entry. A similar situation occurs when creating
1551 shared libraries and symbol visibility changes render the
1552 symbol local.
1553
1554 If on the other hand, we are creating an executable, we
1555 may need to keep relocations for symbols satisfied by a
1556 dynamic library if we manage to avoid copy relocs for the
1557 symbol. */
1558 if ((info->shared
1559 && (sec->flags & SEC_ALLOC) != 0
1560 && (! tilepro_elf_howto_table[r_type].pc_relative
1561 || (h != NULL
1562 && (! info->symbolic
1563 || h->root.type == bfd_link_hash_defweak
1564 || !h->def_regular))))
1565 || (!info->shared
1566 && (sec->flags & SEC_ALLOC) != 0
1567 && h != NULL
1568 && (h->root.type == bfd_link_hash_defweak
1569 || !h->def_regular)))
1570 {
1571 struct tilepro_elf_dyn_relocs *p;
1572 struct tilepro_elf_dyn_relocs **head;
1573
1574 /* When creating a shared object, we must copy these
1575 relocs into the output file. We create a reloc
1576 section in dynobj and make room for the reloc. */
1577 if (sreloc == NULL)
1578 {
1579 sreloc = _bfd_elf_make_dynamic_reloc_section
1580 (sec, htab->elf.dynobj, 2, abfd, /*rela?*/ TRUE);
1581
1582 if (sreloc == NULL)
1583 return FALSE;
1584 }
1585
1586 /* If this is a global symbol, we count the number of
1587 relocations we need for this symbol. */
1588 if (h != NULL)
1589 head =
1590 &((struct tilepro_elf_link_hash_entry *) h)->dyn_relocs;
1591 else
1592 {
1593 /* Track dynamic relocs needed for local syms too.
1594 We really need local syms available to do this
1595 easily. Oh well. */
1596
1597 asection *s;
1598 void *vpp;
1599 Elf_Internal_Sym *isym;
1600
1601 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1602 abfd, r_symndx);
1603 if (isym == NULL)
1604 return FALSE;
1605
1606 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1607 if (s == NULL)
1608 s = sec;
1609
1610 vpp = &elf_section_data (s)->local_dynrel;
1611 head = (struct tilepro_elf_dyn_relocs **) vpp;
1612 }
1613
1614 p = *head;
1615 if (p == NULL || p->sec != sec)
1616 {
1617 bfd_size_type amt = sizeof *p;
1618 p = ((struct tilepro_elf_dyn_relocs *)
1619 bfd_alloc (htab->elf.dynobj, amt));
1620 if (p == NULL)
1621 return FALSE;
1622 p->next = *head;
1623 *head = p;
1624 p->sec = sec;
1625 p->count = 0;
1626 p->pc_count = 0;
1627 }
1628
1629 p->count += 1;
1630 if (tilepro_elf_howto_table[r_type].pc_relative)
1631 p->pc_count += 1;
1632 }
1633
1634 break;
1635
1636 case R_TILEPRO_GNU_VTINHERIT:
1637 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1638 return FALSE;
1639 break;
1640
1641 case R_TILEPRO_GNU_VTENTRY:
1642 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1643 return FALSE;
1644 break;
1645
1646 default:
1647 break;
1648 }
1649 }
1650
1651 return TRUE;
1652 }
1653
1654 \f
1655 static asection *
1656 tilepro_elf_gc_mark_hook (asection *sec,
1657 struct bfd_link_info *info,
1658 Elf_Internal_Rela *rel,
1659 struct elf_link_hash_entry *h,
1660 Elf_Internal_Sym *sym)
1661 {
1662 if (h != NULL)
1663 {
1664 switch (ELF32_R_TYPE (rel->r_info))
1665 {
1666 case R_TILEPRO_GNU_VTINHERIT:
1667 case R_TILEPRO_GNU_VTENTRY:
1668 break;
1669 }
1670 }
1671
1672 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1673 }
1674
1675 /* Update the got entry reference counts for the section being removed. */
1676 static bfd_boolean
1677 tilepro_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
1678 asection *sec, const Elf_Internal_Rela *relocs)
1679 {
1680 struct tilepro_elf_link_hash_table *htab;
1681 Elf_Internal_Shdr *symtab_hdr;
1682 struct elf_link_hash_entry **sym_hashes;
1683 bfd_signed_vma *local_got_refcounts;
1684 const Elf_Internal_Rela *rel, *relend;
1685
1686 if (info->relocatable)
1687 return TRUE;
1688
1689 BFD_ASSERT (is_tilepro_elf (abfd) || sec->reloc_count == 0);
1690
1691 elf_section_data (sec)->local_dynrel = NULL;
1692
1693 htab = tilepro_elf_hash_table (info);
1694 BFD_ASSERT (htab != NULL);
1695 symtab_hdr = &elf_symtab_hdr (abfd);
1696 sym_hashes = elf_sym_hashes (abfd);
1697 local_got_refcounts = elf_local_got_refcounts (abfd);
1698
1699 relend = relocs + sec->reloc_count;
1700 for (rel = relocs; rel < relend; rel++)
1701 {
1702 unsigned long r_symndx;
1703 unsigned int r_type;
1704 struct elf_link_hash_entry *h = NULL;
1705
1706 r_symndx = ELF32_R_SYM (rel->r_info);
1707 if (r_symndx >= symtab_hdr->sh_info)
1708 {
1709 struct tilepro_elf_link_hash_entry *eh;
1710 struct tilepro_elf_dyn_relocs **pp;
1711 struct tilepro_elf_dyn_relocs *p;
1712
1713 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1714 while (h->root.type == bfd_link_hash_indirect
1715 || h->root.type == bfd_link_hash_warning)
1716 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1717 eh = (struct tilepro_elf_link_hash_entry *) h;
1718 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1719 if (p->sec == sec)
1720 {
1721 /* Everything must go for SEC. */
1722 *pp = p->next;
1723 break;
1724 }
1725 }
1726
1727 r_type = ELF32_R_TYPE (rel->r_info);
1728 switch (r_type)
1729 {
1730 case R_TILEPRO_IMM16_X0_GOT:
1731 case R_TILEPRO_IMM16_X1_GOT:
1732 case R_TILEPRO_IMM16_X0_GOT_LO:
1733 case R_TILEPRO_IMM16_X1_GOT_LO:
1734 case R_TILEPRO_IMM16_X0_GOT_HI:
1735 case R_TILEPRO_IMM16_X1_GOT_HI:
1736 case R_TILEPRO_IMM16_X0_GOT_HA:
1737 case R_TILEPRO_IMM16_X1_GOT_HA:
1738 case R_TILEPRO_IMM16_X0_TLS_GD:
1739 case R_TILEPRO_IMM16_X1_TLS_GD:
1740 case R_TILEPRO_IMM16_X0_TLS_GD_LO:
1741 case R_TILEPRO_IMM16_X1_TLS_GD_LO:
1742 case R_TILEPRO_IMM16_X0_TLS_GD_HI:
1743 case R_TILEPRO_IMM16_X1_TLS_GD_HI:
1744 case R_TILEPRO_IMM16_X0_TLS_GD_HA:
1745 case R_TILEPRO_IMM16_X1_TLS_GD_HA:
1746 case R_TILEPRO_IMM16_X0_TLS_IE:
1747 case R_TILEPRO_IMM16_X1_TLS_IE:
1748 case R_TILEPRO_IMM16_X0_TLS_IE_LO:
1749 case R_TILEPRO_IMM16_X1_TLS_IE_LO:
1750 case R_TILEPRO_IMM16_X0_TLS_IE_HI:
1751 case R_TILEPRO_IMM16_X1_TLS_IE_HI:
1752 case R_TILEPRO_IMM16_X0_TLS_IE_HA:
1753 case R_TILEPRO_IMM16_X1_TLS_IE_HA:
1754 if (h != NULL)
1755 {
1756 if (h->got.refcount > 0)
1757 h->got.refcount--;
1758 }
1759 else
1760 {
1761 if (local_got_refcounts[r_symndx] > 0)
1762 local_got_refcounts[r_symndx]--;
1763 }
1764 break;
1765
1766 case R_TILEPRO_32_PCREL:
1767 case R_TILEPRO_16_PCREL:
1768 case R_TILEPRO_8_PCREL:
1769 case R_TILEPRO_IMM16_X0_PCREL:
1770 case R_TILEPRO_IMM16_X1_PCREL:
1771 case R_TILEPRO_IMM16_X0_LO_PCREL:
1772 case R_TILEPRO_IMM16_X1_LO_PCREL:
1773 case R_TILEPRO_IMM16_X0_HI_PCREL:
1774 case R_TILEPRO_IMM16_X1_HI_PCREL:
1775 case R_TILEPRO_IMM16_X0_HA_PCREL:
1776 case R_TILEPRO_IMM16_X1_HA_PCREL:
1777 if (h != NULL
1778 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1779 break;
1780 /* Fall through. */
1781
1782 case R_TILEPRO_32:
1783 case R_TILEPRO_16:
1784 case R_TILEPRO_8:
1785 case R_TILEPRO_LO16:
1786 case R_TILEPRO_HI16:
1787 case R_TILEPRO_HA16:
1788 case R_TILEPRO_COPY:
1789 case R_TILEPRO_GLOB_DAT:
1790 case R_TILEPRO_JMP_SLOT:
1791 case R_TILEPRO_RELATIVE:
1792 case R_TILEPRO_BROFF_X1:
1793 case R_TILEPRO_JOFFLONG_X1:
1794 case R_TILEPRO_IMM8_X0:
1795 case R_TILEPRO_IMM8_Y0:
1796 case R_TILEPRO_IMM8_X1:
1797 case R_TILEPRO_IMM8_Y1:
1798 case R_TILEPRO_DEST_IMM8_X1:
1799 case R_TILEPRO_MT_IMM15_X1:
1800 case R_TILEPRO_MF_IMM15_X1:
1801 case R_TILEPRO_IMM16_X0:
1802 case R_TILEPRO_IMM16_X1:
1803 case R_TILEPRO_IMM16_X0_LO:
1804 case R_TILEPRO_IMM16_X1_LO:
1805 case R_TILEPRO_IMM16_X0_HI:
1806 case R_TILEPRO_IMM16_X1_HI:
1807 case R_TILEPRO_IMM16_X0_HA:
1808 case R_TILEPRO_IMM16_X1_HA:
1809 case R_TILEPRO_MMSTART_X0:
1810 case R_TILEPRO_MMEND_X0:
1811 case R_TILEPRO_MMSTART_X1:
1812 case R_TILEPRO_MMEND_X1:
1813 case R_TILEPRO_SHAMT_X0:
1814 case R_TILEPRO_SHAMT_X1:
1815 case R_TILEPRO_SHAMT_Y0:
1816 case R_TILEPRO_SHAMT_Y1:
1817 if (info->shared)
1818 break;
1819 /* Fall through. */
1820
1821 case R_TILEPRO_JOFFLONG_X1_PLT:
1822 if (h != NULL)
1823 {
1824 if (h->plt.refcount > 0)
1825 h->plt.refcount--;
1826 }
1827 break;
1828
1829 default:
1830 break;
1831 }
1832 }
1833
1834 return TRUE;
1835 }
1836
1837 /* Adjust a symbol defined by a dynamic object and referenced by a
1838 regular object. The current definition is in some section of the
1839 dynamic object, but we're not including those sections. We have to
1840 change the definition to something the rest of the link can
1841 understand. */
1842
1843 static bfd_boolean
1844 tilepro_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1845 struct elf_link_hash_entry *h)
1846 {
1847 struct tilepro_elf_link_hash_table *htab;
1848 struct tilepro_elf_link_hash_entry * eh;
1849 struct tilepro_elf_dyn_relocs *p;
1850 asection *s;
1851
1852 htab = tilepro_elf_hash_table (info);
1853 BFD_ASSERT (htab != NULL);
1854
1855 /* Make sure we know what is going on here. */
1856 BFD_ASSERT (htab->elf.dynobj != NULL
1857 && (h->needs_plt
1858 || h->u.weakdef != NULL
1859 || (h->def_dynamic
1860 && h->ref_regular
1861 && !h->def_regular)));
1862
1863 /* If this is a function, put it in the procedure linkage table. We
1864 will fill in the contents of the procedure linkage table later
1865 (although we could actually do it here). */
1866 if (h->type == STT_FUNC || h->needs_plt)
1867 {
1868 if (h->plt.refcount <= 0
1869 || SYMBOL_CALLS_LOCAL (info, h)
1870 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1871 && h->root.type == bfd_link_hash_undefweak))
1872 {
1873 /* This case can occur if we saw a R_TILEPRO_JOFFLONG_X1_PLT
1874 reloc in an input file, but the symbol was never referred
1875 to by a dynamic object, or if all references were garbage
1876 collected. In such a case, we don't actually need to build
1877 a procedure linkage table, and we can just do a
1878 R_TILEPRO_JOFFLONG_X1 relocation instead. */
1879 h->plt.offset = (bfd_vma) -1;
1880 h->needs_plt = 0;
1881 }
1882
1883 return TRUE;
1884 }
1885 else
1886 h->plt.offset = (bfd_vma) -1;
1887
1888 /* If this is a weak symbol, and there is a real definition, the
1889 processor independent code will have arranged for us to see the
1890 real definition first, and we can just use the same value. */
1891 if (h->u.weakdef != NULL)
1892 {
1893 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1894 || h->u.weakdef->root.type == bfd_link_hash_defweak);
1895 h->root.u.def.section = h->u.weakdef->root.u.def.section;
1896 h->root.u.def.value = h->u.weakdef->root.u.def.value;
1897 return TRUE;
1898 }
1899
1900 /* This is a reference to a symbol defined by a dynamic object which
1901 is not a function. */
1902
1903 /* If we are creating a shared library, we must presume that the
1904 only references to the symbol are via the global offset table.
1905 For such cases we need not do anything here; the relocations will
1906 be handled correctly by relocate_section. */
1907 if (info->shared)
1908 return TRUE;
1909
1910 /* If there are no references to this symbol that do not use the
1911 GOT, we don't need to generate a copy reloc. */
1912 if (!h->non_got_ref)
1913 return TRUE;
1914
1915 /* If -z nocopyreloc was given, we won't generate them either. */
1916 if (info->nocopyreloc)
1917 {
1918 h->non_got_ref = 0;
1919 return TRUE;
1920 }
1921
1922 eh = (struct tilepro_elf_link_hash_entry *) h;
1923 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1924 {
1925 s = p->sec->output_section;
1926 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1927 break;
1928 }
1929
1930 /* If we didn't find any dynamic relocs in read-only sections, then
1931 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1932 if (p == NULL)
1933 {
1934 h->non_got_ref = 0;
1935 return TRUE;
1936 }
1937
1938 if (h->size == 0)
1939 {
1940 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
1941 h->root.root.string);
1942 return TRUE;
1943 }
1944
1945 /* We must allocate the symbol in our .dynbss section, which will
1946 become part of the .bss section of the executable. There will be
1947 an entry for this symbol in the .dynsym section. The dynamic
1948 object will contain position independent code, so all references
1949 from the dynamic object to this symbol will go through the global
1950 offset table. The dynamic linker will use the .dynsym entry to
1951 determine the address it must put in the global offset table, so
1952 both the dynamic object and the regular object will refer to the
1953 same memory location for the variable. */
1954
1955 /* We must generate a R_TILEPRO_COPY reloc to tell the dynamic linker
1956 to copy the initial value out of the dynamic object and into the
1957 runtime process image. We need to remember the offset into the
1958 .rel.bss section we are going to use. */
1959 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1960 {
1961 htab->srelbss->size += TILEPRO_ELF_RELA_BYTES;
1962 h->needs_copy = 1;
1963 }
1964
1965 return _bfd_elf_adjust_dynamic_copy (h, htab->sdynbss);
1966 }
1967
1968 /* Allocate space in .plt, .got and associated reloc sections for
1969 dynamic relocs. */
1970
1971 static bfd_boolean
1972 allocate_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
1973 {
1974 struct bfd_link_info *info;
1975 struct tilepro_elf_link_hash_table *htab;
1976 struct tilepro_elf_link_hash_entry *eh;
1977 struct tilepro_elf_dyn_relocs *p;
1978
1979 if (h->root.type == bfd_link_hash_indirect)
1980 return TRUE;
1981
1982 if (h->root.type == bfd_link_hash_warning)
1983 /* When warning symbols are created, they **replace** the "real"
1984 entry in the hash table, thus we never get to see the real
1985 symbol in a hash traversal. So look at it now. */
1986 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1987
1988 info = (struct bfd_link_info *) inf;
1989 htab = tilepro_elf_hash_table (info);
1990 BFD_ASSERT (htab != NULL);
1991
1992 if (htab->elf.dynamic_sections_created
1993 && h->plt.refcount > 0)
1994 {
1995 /* Make sure this symbol is output as a dynamic symbol.
1996 Undefined weak syms won't yet be marked as dynamic. */
1997 if (h->dynindx == -1
1998 && !h->forced_local)
1999 {
2000 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2001 return FALSE;
2002 }
2003
2004 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
2005 {
2006 asection *s = htab->elf.splt;
2007
2008 /* Allocate room for the header. */
2009 if (s->size == 0)
2010 {
2011 s->size = PLT_HEADER_SIZE;
2012 }
2013
2014 h->plt.offset = s->size;
2015
2016 /* If this symbol is not defined in a regular file, and we are
2017 not generating a shared library, then set the symbol to this
2018 location in the .plt. This is required to make function
2019 pointers compare as equal between the normal executable and
2020 the shared library. */
2021 if (! info->shared
2022 && !h->def_regular)
2023 {
2024 h->root.u.def.section = s;
2025 h->root.u.def.value = h->plt.offset;
2026 }
2027
2028 /* Make room for this entry. */
2029 s->size += PLT_ENTRY_SIZE;
2030
2031 /* We also need to make an entry in the .got.plt section. */
2032 htab->elf.sgotplt->size += GOT_ENTRY_SIZE;
2033
2034 /* We also need to make an entry in the .rela.plt section. */
2035 htab->elf.srelplt->size += TILEPRO_ELF_RELA_BYTES;
2036 }
2037 else
2038 {
2039 h->plt.offset = (bfd_vma) -1;
2040 h->needs_plt = 0;
2041 }
2042 }
2043 else
2044 {
2045 h->plt.offset = (bfd_vma) -1;
2046 h->needs_plt = 0;
2047 }
2048
2049 if (h->got.refcount > 0)
2050 {
2051 asection *s;
2052 bfd_boolean dyn;
2053 int tls_type = tilepro_elf_hash_entry(h)->tls_type;
2054
2055 /* Make sure this symbol is output as a dynamic symbol.
2056 Undefined weak syms won't yet be marked as dynamic. */
2057 if (h->dynindx == -1
2058 && !h->forced_local)
2059 {
2060 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2061 return FALSE;
2062 }
2063
2064 s = htab->elf.sgot;
2065 h->got.offset = s->size;
2066 s->size += TILEPRO_BYTES_PER_WORD;
2067 /* R_TILEPRO_IMM16_Xn_TLS_GD entries need 2 consecutive GOT slots. */
2068 if (tls_type == GOT_TLS_GD)
2069 s->size += TILEPRO_BYTES_PER_WORD;
2070 dyn = htab->elf.dynamic_sections_created;
2071 /* R_TILEPRO_IMM16_Xn_TLS_IE_xxx needs one dynamic relocation,
2072 R_TILEPRO_IMM16_Xn_TLS_GD_xxx needs two if local symbol and two if
2073 global. */
2074 if (tls_type == GOT_TLS_GD || tls_type == GOT_TLS_IE)
2075 htab->elf.srelgot->size += 2 * TILEPRO_ELF_RELA_BYTES;
2076 else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
2077 htab->elf.srelgot->size += TILEPRO_ELF_RELA_BYTES;
2078 }
2079 else
2080 h->got.offset = (bfd_vma) -1;
2081
2082 eh = (struct tilepro_elf_link_hash_entry *) h;
2083 if (eh->dyn_relocs == NULL)
2084 return TRUE;
2085
2086 /* In the shared -Bsymbolic case, discard space allocated for
2087 dynamic pc-relative relocs against symbols which turn out to be
2088 defined in regular objects. For the normal shared case, discard
2089 space for pc-relative relocs that have become local due to symbol
2090 visibility changes. */
2091
2092 if (info->shared)
2093 {
2094 if (SYMBOL_CALLS_LOCAL (info, h))
2095 {
2096 struct tilepro_elf_dyn_relocs **pp;
2097
2098 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2099 {
2100 p->count -= p->pc_count;
2101 p->pc_count = 0;
2102 if (p->count == 0)
2103 *pp = p->next;
2104 else
2105 pp = &p->next;
2106 }
2107 }
2108
2109 /* Also discard relocs on undefined weak syms with non-default
2110 visibility. */
2111 if (eh->dyn_relocs != NULL
2112 && h->root.type == bfd_link_hash_undefweak)
2113 {
2114 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2115 eh->dyn_relocs = NULL;
2116
2117 /* Make sure undefined weak symbols are output as a dynamic
2118 symbol in PIEs. */
2119 else if (h->dynindx == -1
2120 && !h->forced_local)
2121 {
2122 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2123 return FALSE;
2124 }
2125 }
2126 }
2127 else
2128 {
2129 /* For the non-shared case, discard space for relocs against
2130 symbols which turn out to need copy relocs or are not
2131 dynamic. */
2132
2133 if (!h->non_got_ref
2134 && ((h->def_dynamic
2135 && !h->def_regular)
2136 || (htab->elf.dynamic_sections_created
2137 && (h->root.type == bfd_link_hash_undefweak
2138 || h->root.type == bfd_link_hash_undefined))))
2139 {
2140 /* Make sure this symbol is output as a dynamic symbol.
2141 Undefined weak syms won't yet be marked as dynamic. */
2142 if (h->dynindx == -1
2143 && !h->forced_local)
2144 {
2145 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2146 return FALSE;
2147 }
2148
2149 /* If that succeeded, we know we'll be keeping all the
2150 relocs. */
2151 if (h->dynindx != -1)
2152 goto keep;
2153 }
2154
2155 eh->dyn_relocs = NULL;
2156
2157 keep: ;
2158 }
2159
2160 /* Finally, allocate space. */
2161 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2162 {
2163 asection *sreloc = elf_section_data (p->sec)->sreloc;
2164 sreloc->size += p->count * TILEPRO_ELF_RELA_BYTES;
2165 }
2166
2167 return TRUE;
2168 }
2169
2170 /* Find any dynamic relocs that apply to read-only sections. */
2171
2172 static bfd_boolean
2173 readonly_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
2174 {
2175 struct tilepro_elf_link_hash_entry *eh;
2176 struct tilepro_elf_dyn_relocs *p;
2177
2178 if (h->root.type == bfd_link_hash_warning)
2179 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2180
2181 eh = (struct tilepro_elf_link_hash_entry *) h;
2182 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2183 {
2184 asection *s = p->sec->output_section;
2185
2186 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2187 {
2188 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2189
2190 info->flags |= DF_TEXTREL;
2191
2192 /* Not an error, just cut short the traversal. */
2193 return FALSE;
2194 }
2195 }
2196 return TRUE;
2197 }
2198
2199 /* Return true if the dynamic symbol for a given section should be
2200 omitted when creating a shared library. */
2201
2202 static bfd_boolean
2203 tilepro_elf_omit_section_dynsym (bfd *output_bfd,
2204 struct bfd_link_info *info,
2205 asection *p)
2206 {
2207 /* We keep the .got section symbol so that explicit relocations
2208 against the _GLOBAL_OFFSET_TABLE_ symbol emitted in PIC mode
2209 can be turned into relocations against the .got symbol. */
2210 if (strcmp (p->name, ".got") == 0)
2211 return FALSE;
2212
2213 return _bfd_elf_link_omit_section_dynsym (output_bfd, info, p);
2214 }
2215
2216 /* Set the sizes of the dynamic sections. */
2217
2218 #define ELF32_DYNAMIC_INTERPRETER "/lib/ld.so.1"
2219
2220 static bfd_boolean
2221 tilepro_elf_size_dynamic_sections (bfd *output_bfd,
2222 struct bfd_link_info *info)
2223 {
2224 (void)output_bfd;
2225
2226 struct tilepro_elf_link_hash_table *htab;
2227 bfd *dynobj;
2228 asection *s;
2229 bfd *ibfd;
2230
2231 htab = tilepro_elf_hash_table (info);
2232 BFD_ASSERT (htab != NULL);
2233 dynobj = htab->elf.dynobj;
2234 BFD_ASSERT (dynobj != NULL);
2235
2236 if (elf_hash_table (info)->dynamic_sections_created)
2237 {
2238 /* Set the contents of the .interp section to the interpreter. */
2239 if (info->executable)
2240 {
2241 s = bfd_get_section_by_name (dynobj, ".interp");
2242 BFD_ASSERT (s != NULL);
2243 s->size = sizeof ELF32_DYNAMIC_INTERPRETER;
2244 s->contents = (unsigned char *) ELF32_DYNAMIC_INTERPRETER;
2245 }
2246 }
2247
2248 /* Set up .got offsets for local syms, and space for local dynamic
2249 relocs. */
2250 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2251 {
2252 bfd_signed_vma *local_got;
2253 bfd_signed_vma *end_local_got;
2254 char *local_tls_type;
2255 bfd_size_type locsymcount;
2256 Elf_Internal_Shdr *symtab_hdr;
2257 asection *srel;
2258
2259 if (! is_tilepro_elf (ibfd))
2260 continue;
2261
2262 for (s = ibfd->sections; s != NULL; s = s->next)
2263 {
2264 struct tilepro_elf_dyn_relocs *p;
2265
2266 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
2267 {
2268 if (!bfd_is_abs_section (p->sec)
2269 && bfd_is_abs_section (p->sec->output_section))
2270 {
2271 /* Input section has been discarded, either because
2272 it is a copy of a linkonce section or due to
2273 linker script /DISCARD/, so we'll be discarding
2274 the relocs too. */
2275 }
2276 else if (p->count != 0)
2277 {
2278 srel = elf_section_data (p->sec)->sreloc;
2279 srel->size += p->count * TILEPRO_ELF_RELA_BYTES;
2280 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2281 info->flags |= DF_TEXTREL;
2282 }
2283 }
2284 }
2285
2286 local_got = elf_local_got_refcounts (ibfd);
2287 if (!local_got)
2288 continue;
2289
2290 symtab_hdr = &elf_symtab_hdr (ibfd);
2291 locsymcount = symtab_hdr->sh_info;
2292 end_local_got = local_got + locsymcount;
2293 local_tls_type = _bfd_tilepro_elf_local_got_tls_type (ibfd);
2294 s = htab->elf.sgot;
2295 srel = htab->elf.srelgot;
2296 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
2297 {
2298 if (*local_got > 0)
2299 {
2300 *local_got = s->size;
2301 s->size += TILEPRO_BYTES_PER_WORD;
2302 if (*local_tls_type == GOT_TLS_GD)
2303 s->size += TILEPRO_BYTES_PER_WORD;
2304 if (info->shared
2305 || *local_tls_type == GOT_TLS_GD
2306 || *local_tls_type == GOT_TLS_IE)
2307 srel->size += TILEPRO_ELF_RELA_BYTES;
2308 }
2309 else
2310 *local_got = (bfd_vma) -1;
2311 }
2312 }
2313
2314 /* Allocate global sym .plt and .got entries, and space for global
2315 sym dynamic relocs. */
2316 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
2317
2318 if (elf_hash_table (info)->dynamic_sections_created)
2319 {
2320 /* If the .got section is more than 0x8000 bytes, we add
2321 0x8000 to the value of _GLOBAL_OFFSET_TABLE_, so that 16
2322 bit relocations have a greater chance of working. */
2323 if (htab->elf.sgot->size >= 0x8000
2324 && elf_hash_table (info)->hgot->root.u.def.value == 0)
2325 elf_hash_table (info)->hgot->root.u.def.value = 0x8000;
2326 }
2327
2328 if (htab->elf.sgotplt)
2329 {
2330 struct elf_link_hash_entry *got;
2331 got = elf_link_hash_lookup (elf_hash_table (info),
2332 "_GLOBAL_OFFSET_TABLE_",
2333 FALSE, FALSE, FALSE);
2334
2335 /* Don't allocate .got.plt section if there are no GOT nor PLT
2336 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
2337 if ((got == NULL
2338 || !got->ref_regular_nonweak)
2339 && (htab->elf.sgotplt->size
2340 == GOTPLT_HEADER_SIZE)
2341 && (htab->elf.splt == NULL
2342 || htab->elf.splt->size == 0)
2343 && (htab->elf.sgot == NULL
2344 || (htab->elf.sgot->size
2345 == get_elf_backend_data (output_bfd)->got_header_size)))
2346 htab->elf.sgotplt->size = 0;
2347 }
2348
2349 /* The check_relocs and adjust_dynamic_symbol entry points have
2350 determined the sizes of the various dynamic sections. Allocate
2351 memory for them. */
2352 for (s = dynobj->sections; s != NULL; s = s->next)
2353 {
2354 if ((s->flags & SEC_LINKER_CREATED) == 0)
2355 continue;
2356
2357 if (s == htab->elf.splt
2358 || s == htab->elf.sgot
2359 || s == htab->elf.sgotplt
2360 || s == htab->sdynbss)
2361 {
2362 /* Strip this section if we don't need it; see the
2363 comment below. */
2364 }
2365 else if (strncmp (s->name, ".rela", 5) == 0)
2366 {
2367 if (s->size != 0)
2368 {
2369 /* We use the reloc_count field as a counter if we need
2370 to copy relocs into the output file. */
2371 s->reloc_count = 0;
2372 }
2373 }
2374 else
2375 {
2376 /* It's not one of our sections. */
2377 continue;
2378 }
2379
2380 if (s->size == 0)
2381 {
2382 /* If we don't need this section, strip it from the
2383 output file. This is mostly to handle .rela.bss and
2384 .rela.plt. We must create both sections in
2385 create_dynamic_sections, because they must be created
2386 before the linker maps input sections to output
2387 sections. The linker does that before
2388 adjust_dynamic_symbol is called, and it is that
2389 function which decides whether anything needs to go
2390 into these sections. */
2391 s->flags |= SEC_EXCLUDE;
2392 continue;
2393 }
2394
2395 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2396 continue;
2397
2398 /* Allocate memory for the section contents. Zero the memory
2399 for the benefit of .rela.plt, which has 4 unused entries
2400 at the beginning, and we don't want garbage. */
2401 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2402 if (s->contents == NULL)
2403 return FALSE;
2404 }
2405
2406 if (elf_hash_table (info)->dynamic_sections_created)
2407 {
2408 /* Add some entries to the .dynamic section. We fill in the
2409 values later, in tilepro_elf_finish_dynamic_sections, but we
2410 must add the entries now so that we get the correct size for
2411 the .dynamic section. The DT_DEBUG entry is filled in by the
2412 dynamic linker and used by the debugger. */
2413 #define add_dynamic_entry(TAG, VAL) \
2414 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2415
2416 if (info->executable)
2417 {
2418 if (!add_dynamic_entry (DT_DEBUG, 0))
2419 return FALSE;
2420 }
2421
2422 if (htab->elf.srelplt->size != 0)
2423 {
2424 if (!add_dynamic_entry (DT_PLTGOT, 0)
2425 || !add_dynamic_entry (DT_PLTRELSZ, 0)
2426 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2427 || !add_dynamic_entry (DT_JMPREL, 0))
2428 return FALSE;
2429 }
2430
2431 if (!add_dynamic_entry (DT_RELA, 0)
2432 || !add_dynamic_entry (DT_RELASZ, 0)
2433 || !add_dynamic_entry (DT_RELAENT, TILEPRO_ELF_RELA_BYTES))
2434 return FALSE;
2435
2436 /* If any dynamic relocs apply to a read-only section,
2437 then we need a DT_TEXTREL entry. */
2438 if ((info->flags & DF_TEXTREL) == 0)
2439 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
2440 (PTR) info);
2441
2442 if (info->flags & DF_TEXTREL)
2443 {
2444 if (!add_dynamic_entry (DT_TEXTREL, 0))
2445 return FALSE;
2446 }
2447 }
2448 #undef add_dynamic_entry
2449
2450 return TRUE;
2451 }
2452 \f
2453 /* Return the base VMA address which should be subtracted from real addresses
2454 when resolving @dtpoff relocation.
2455 This is PT_TLS segment p_vaddr. */
2456
2457 static bfd_vma
2458 dtpoff_base (struct bfd_link_info *info)
2459 {
2460 /* If tls_sec is NULL, we should have signalled an error already. */
2461 if (elf_hash_table (info)->tls_sec == NULL)
2462 return 0;
2463 return elf_hash_table (info)->tls_sec->vma;
2464 }
2465
2466 /* Return the relocation value for R_TILEPRO_TLS_TPOFF32. */
2467
2468 static bfd_vma
2469 tpoff (struct bfd_link_info *info, bfd_vma address)
2470 {
2471 struct elf_link_hash_table *htab = elf_hash_table (info);
2472
2473 /* If tls_sec is NULL, we should have signalled an error already. */
2474 if (htab->tls_sec == NULL)
2475 return 0;
2476
2477 return (address - htab->tls_sec->vma);
2478 }
2479
2480 /* Relocate an TILEPRO ELF section.
2481
2482 The RELOCATE_SECTION function is called by the new ELF backend linker
2483 to handle the relocations for a section.
2484
2485 The relocs are always passed as Rela structures.
2486
2487 This function is responsible for adjusting the section contents as
2488 necessary, and (if generating a relocatable output file) adjusting
2489 the reloc addend as necessary.
2490
2491 This function does not have to worry about setting the reloc
2492 address or the reloc symbol index.
2493
2494 LOCAL_SYMS is a pointer to the swapped in local symbols.
2495
2496 LOCAL_SECTIONS is an array giving the section in the input file
2497 corresponding to the st_shndx field of each local symbol.
2498
2499 The global hash table entry for the global symbols can be found
2500 via elf_sym_hashes (input_bfd).
2501
2502 When generating relocatable output, this function must handle
2503 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
2504 going to be the section symbol corresponding to the output
2505 section, which means that the addend must be adjusted
2506 accordingly. */
2507
2508 static bfd_boolean
2509 tilepro_elf_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
2510 bfd *input_bfd, asection *input_section,
2511 bfd_byte *contents, Elf_Internal_Rela *relocs,
2512 Elf_Internal_Sym *local_syms,
2513 asection **local_sections)
2514 {
2515 struct tilepro_elf_link_hash_table *htab;
2516 Elf_Internal_Shdr *symtab_hdr;
2517 struct elf_link_hash_entry **sym_hashes;
2518 bfd_vma *local_got_offsets;
2519 bfd_vma got_base;
2520 asection *sreloc;
2521 Elf_Internal_Rela *rel;
2522 Elf_Internal_Rela *relend;
2523 int num_relocs;
2524
2525 htab = tilepro_elf_hash_table (info);
2526 BFD_ASSERT (htab != NULL);
2527 symtab_hdr = &elf_symtab_hdr (input_bfd);
2528 sym_hashes = elf_sym_hashes (input_bfd);
2529 local_got_offsets = elf_local_got_offsets (input_bfd);
2530
2531 if (elf_hash_table (info)->hgot == NULL)
2532 got_base = 0;
2533 else
2534 got_base = elf_hash_table (info)->hgot->root.u.def.value;
2535
2536 sreloc = elf_section_data (input_section)->sreloc;
2537
2538 rel = relocs;
2539 num_relocs = input_section->reloc_count;
2540 relend = relocs + num_relocs;
2541 for (; rel < relend; rel++)
2542 {
2543 int r_type, tls_type;
2544 reloc_howto_type *howto;
2545 unsigned long r_symndx;
2546 struct elf_link_hash_entry *h;
2547 Elf_Internal_Sym *sym;
2548 tilepro_create_func create_func;
2549 asection *sec;
2550 bfd_vma relocation;
2551 bfd_reloc_status_type r;
2552 const char *name;
2553 bfd_vma off;
2554 bfd_boolean is_plt = FALSE;
2555
2556 bfd_boolean unresolved_reloc;
2557
2558 r_type = ELF32_R_TYPE (rel->r_info);
2559 if (r_type == R_TILEPRO_GNU_VTINHERIT
2560 || r_type == R_TILEPRO_GNU_VTENTRY)
2561 continue;
2562
2563 if ((unsigned int)r_type >= NELEMS(tilepro_elf_howto_table))
2564 {
2565 /* Not clear if we need to check here, but just be paranoid. */
2566 (*_bfd_error_handler)
2567 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
2568 input_bfd, r_type, input_section);
2569 bfd_set_error (bfd_error_bad_value);
2570 return FALSE;
2571 }
2572
2573 howto = tilepro_elf_howto_table + r_type;
2574
2575 /* This is a final link. */
2576 r_symndx = ELF32_R_SYM (rel->r_info);
2577 h = NULL;
2578 sym = NULL;
2579 sec = NULL;
2580 unresolved_reloc = FALSE;
2581 if (r_symndx < symtab_hdr->sh_info)
2582 {
2583 sym = local_syms + r_symndx;
2584 sec = local_sections[r_symndx];
2585 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2586 }
2587 else
2588 {
2589 bfd_boolean warned;
2590
2591 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2592 r_symndx, symtab_hdr, sym_hashes,
2593 h, sec, relocation,
2594 unresolved_reloc, warned);
2595 if (warned)
2596 {
2597 /* To avoid generating warning messages about truncated
2598 relocations, set the relocation's address to be the same as
2599 the start of this section. */
2600 if (input_section->output_section != NULL)
2601 relocation = input_section->output_section->vma;
2602 else
2603 relocation = 0;
2604 }
2605 }
2606
2607 if (sec != NULL && elf_discarded_section (sec))
2608 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
2609 rel, relend, howto, contents);
2610
2611 if (info->relocatable)
2612 continue;
2613
2614 if (h != NULL)
2615 name = h->root.root.string;
2616 else
2617 {
2618 name = (bfd_elf_string_from_elf_section
2619 (input_bfd, symtab_hdr->sh_link, sym->st_name));
2620 if (name == NULL || *name == '\0')
2621 name = bfd_section_name (input_bfd, sec);
2622 }
2623
2624 switch (r_type)
2625 {
2626 case R_TILEPRO_IMM16_X0_GOT:
2627 case R_TILEPRO_IMM16_X1_GOT:
2628 case R_TILEPRO_IMM16_X0_GOT_LO:
2629 case R_TILEPRO_IMM16_X1_GOT_LO:
2630 case R_TILEPRO_IMM16_X0_GOT_HI:
2631 case R_TILEPRO_IMM16_X1_GOT_HI:
2632 case R_TILEPRO_IMM16_X0_GOT_HA:
2633 case R_TILEPRO_IMM16_X1_GOT_HA:
2634 /* Relocation is to the entry for this symbol in the global
2635 offset table. */
2636 if (htab->elf.sgot == NULL)
2637 abort ();
2638
2639 if (h != NULL)
2640 {
2641 bfd_boolean dyn;
2642
2643 off = h->got.offset;
2644 BFD_ASSERT (off != (bfd_vma) -1);
2645 dyn = elf_hash_table (info)->dynamic_sections_created;
2646
2647 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2648 || (info->shared
2649 && SYMBOL_REFERENCES_LOCAL (info, h)))
2650 {
2651 /* This is actually a static link, or it is a
2652 -Bsymbolic link and the symbol is defined
2653 locally, or the symbol was forced to be local
2654 because of a version file. We must initialize
2655 this entry in the global offset table. Since the
2656 offset must always be a multiple
2657 of 4 for 32-bit, we use the least significant bit
2658 to record whether we have initialized it already.
2659
2660 When doing a dynamic link, we create a .rela.got
2661 relocation entry to initialize the value. This
2662 is done in the finish_dynamic_symbol routine. */
2663 if ((off & 1) != 0)
2664 off &= ~1;
2665 else
2666 {
2667 bfd_put_32 (output_bfd, relocation,
2668 htab->elf.sgot->contents + off);
2669 h->got.offset |= 1;
2670 }
2671 }
2672 else
2673 unresolved_reloc = FALSE;
2674 }
2675 else
2676 {
2677 BFD_ASSERT (local_got_offsets != NULL
2678 && local_got_offsets[r_symndx] != (bfd_vma) -1);
2679
2680 off = local_got_offsets[r_symndx];
2681
2682 /* The offset must always be a multiple of 4 on 32-bit.
2683 We use the least significant bit to record
2684 whether we have already processed this entry. */
2685 if ((off & 1) != 0)
2686 off &= ~1;
2687 else
2688 {
2689 if (info->shared)
2690 {
2691 asection *s;
2692 Elf_Internal_Rela outrel;
2693
2694 /* We need to generate a R_TILEPRO_RELATIVE reloc
2695 for the dynamic linker. */
2696 s = htab->elf.srelgot;
2697 BFD_ASSERT (s != NULL);
2698
2699 outrel.r_offset = (htab->elf.sgot->output_section->vma
2700 + htab->elf.sgot->output_offset
2701 + off);
2702 outrel.r_info = ELF32_R_INFO (0, R_TILEPRO_RELATIVE);
2703 outrel.r_addend = relocation;
2704 relocation = 0;
2705 tilepro_elf_append_rela_32 (output_bfd, s, &outrel);
2706 }
2707
2708 bfd_put_32 (output_bfd, relocation,
2709 htab->elf.sgot->contents + off);
2710 local_got_offsets[r_symndx] |= 1;
2711 }
2712 }
2713 relocation = htab->elf.sgot->output_offset + off - got_base;
2714 break;
2715
2716 case R_TILEPRO_JOFFLONG_X1_PLT:
2717 /* Relocation is to the entry for this symbol in the
2718 procedure linkage table. */
2719 BFD_ASSERT (h != NULL);
2720
2721 if (h->plt.offset == (bfd_vma) -1 || htab->elf.splt == NULL)
2722 {
2723 /* We didn't make a PLT entry for this symbol. This
2724 happens when statically linking PIC code, or when
2725 using -Bsymbolic. */
2726 break;
2727 }
2728
2729 relocation = (htab->elf.splt->output_section->vma
2730 + htab->elf.splt->output_offset
2731 + h->plt.offset);
2732 unresolved_reloc = FALSE;
2733 break;
2734
2735 case R_TILEPRO_32_PCREL:
2736 case R_TILEPRO_16_PCREL:
2737 case R_TILEPRO_8_PCREL:
2738 case R_TILEPRO_IMM16_X0_PCREL:
2739 case R_TILEPRO_IMM16_X1_PCREL:
2740 case R_TILEPRO_IMM16_X0_LO_PCREL:
2741 case R_TILEPRO_IMM16_X1_LO_PCREL:
2742 case R_TILEPRO_IMM16_X0_HI_PCREL:
2743 case R_TILEPRO_IMM16_X1_HI_PCREL:
2744 case R_TILEPRO_IMM16_X0_HA_PCREL:
2745 case R_TILEPRO_IMM16_X1_HA_PCREL:
2746 if (h != NULL
2747 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2748 break;
2749 /* Fall through. */
2750 case R_TILEPRO_32:
2751 case R_TILEPRO_16:
2752 case R_TILEPRO_8:
2753 case R_TILEPRO_LO16:
2754 case R_TILEPRO_HI16:
2755 case R_TILEPRO_HA16:
2756 case R_TILEPRO_COPY:
2757 case R_TILEPRO_GLOB_DAT:
2758 case R_TILEPRO_JMP_SLOT:
2759 case R_TILEPRO_RELATIVE:
2760 case R_TILEPRO_BROFF_X1:
2761 case R_TILEPRO_JOFFLONG_X1:
2762 case R_TILEPRO_IMM8_X0:
2763 case R_TILEPRO_IMM8_Y0:
2764 case R_TILEPRO_IMM8_X1:
2765 case R_TILEPRO_IMM8_Y1:
2766 case R_TILEPRO_DEST_IMM8_X1:
2767 case R_TILEPRO_MT_IMM15_X1:
2768 case R_TILEPRO_MF_IMM15_X1:
2769 case R_TILEPRO_IMM16_X0:
2770 case R_TILEPRO_IMM16_X1:
2771 case R_TILEPRO_IMM16_X0_LO:
2772 case R_TILEPRO_IMM16_X1_LO:
2773 case R_TILEPRO_IMM16_X0_HI:
2774 case R_TILEPRO_IMM16_X1_HI:
2775 case R_TILEPRO_IMM16_X0_HA:
2776 case R_TILEPRO_IMM16_X1_HA:
2777 case R_TILEPRO_MMSTART_X0:
2778 case R_TILEPRO_MMEND_X0:
2779 case R_TILEPRO_MMSTART_X1:
2780 case R_TILEPRO_MMEND_X1:
2781 case R_TILEPRO_SHAMT_X0:
2782 case R_TILEPRO_SHAMT_X1:
2783 case R_TILEPRO_SHAMT_Y0:
2784 case R_TILEPRO_SHAMT_Y1:
2785 if ((input_section->flags & SEC_ALLOC) == 0)
2786 break;
2787
2788 if ((info->shared
2789 && (h == NULL
2790 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2791 || h->root.type != bfd_link_hash_undefweak)
2792 && (! howto->pc_relative
2793 || !SYMBOL_CALLS_LOCAL (info, h)))
2794 || (!info->shared
2795 && h != NULL
2796 && h->dynindx != -1
2797 && !h->non_got_ref
2798 && ((h->def_dynamic
2799 && !h->def_regular)
2800 || h->root.type == bfd_link_hash_undefweak
2801 || h->root.type == bfd_link_hash_undefined)))
2802 {
2803 Elf_Internal_Rela outrel;
2804 bfd_boolean skip, relocate = FALSE;
2805
2806 /* When generating a shared object, these relocations
2807 are copied into the output file to be resolved at run
2808 time. */
2809
2810 BFD_ASSERT (sreloc != NULL);
2811
2812 skip = FALSE;
2813
2814 outrel.r_offset =
2815 _bfd_elf_section_offset (output_bfd, info, input_section,
2816 rel->r_offset);
2817 if (outrel.r_offset == (bfd_vma) -1)
2818 skip = TRUE;
2819 else if (outrel.r_offset == (bfd_vma) -2)
2820 skip = TRUE, relocate = TRUE;
2821 outrel.r_offset += (input_section->output_section->vma
2822 + input_section->output_offset);
2823
2824 switch (r_type)
2825 {
2826 case R_TILEPRO_32_PCREL:
2827 case R_TILEPRO_16_PCREL:
2828 case R_TILEPRO_8_PCREL:
2829 /* If the symbol is not dynamic, we should not keep
2830 a dynamic relocation. But an .rela.* slot has been
2831 allocated for it, output R_TILEPRO_NONE.
2832 FIXME: Add code tracking needed dynamic relocs as
2833 e.g. i386 has. */
2834 if (h->dynindx == -1)
2835 skip = TRUE, relocate = TRUE;
2836 break;
2837 }
2838
2839 if (skip)
2840 memset (&outrel, 0, sizeof outrel);
2841 /* h->dynindx may be -1 if the symbol was marked to
2842 become local. */
2843 else if (h != NULL &&
2844 h->dynindx != -1
2845 && (! is_plt
2846 || !info->shared
2847 || !SYMBOLIC_BIND (info, h)
2848 || !h->def_regular))
2849 {
2850 BFD_ASSERT (h->dynindx != -1);
2851 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2852 outrel.r_addend = rel->r_addend;
2853 }
2854 else
2855 {
2856 if (r_type == R_TILEPRO_32)
2857 {
2858 outrel.r_info = ELF32_R_INFO (0, R_TILEPRO_RELATIVE);
2859 outrel.r_addend = relocation + rel->r_addend;
2860 }
2861 else
2862 {
2863 long indx;
2864
2865 outrel.r_addend = relocation + rel->r_addend;
2866
2867 if (is_plt)
2868 sec = htab->elf.splt;
2869
2870 if (bfd_is_abs_section (sec))
2871 indx = 0;
2872 else if (sec == NULL || sec->owner == NULL)
2873 {
2874 bfd_set_error (bfd_error_bad_value);
2875 return FALSE;
2876 }
2877 else
2878 {
2879 asection *osec;
2880
2881 /* We are turning this relocation into one
2882 against a section symbol. It would be
2883 proper to subtract the symbol's value,
2884 osec->vma, from the emitted reloc addend,
2885 but ld.so expects buggy relocs. */
2886 osec = sec->output_section;
2887 indx = elf_section_data (osec)->dynindx;
2888
2889 if (indx == 0)
2890 {
2891 osec = htab->elf.text_index_section;
2892 indx = elf_section_data (osec)->dynindx;
2893 }
2894
2895 /* FIXME: we really should be able to link non-pic
2896 shared libraries. */
2897 if (indx == 0)
2898 {
2899 BFD_FAIL ();
2900 (*_bfd_error_handler)
2901 (_("%B: probably compiled without -fPIC?"),
2902 input_bfd);
2903 bfd_set_error (bfd_error_bad_value);
2904 return FALSE;
2905 }
2906 }
2907
2908 outrel.r_info = ELF32_R_INFO (indx, r_type);
2909 }
2910 }
2911
2912 tilepro_elf_append_rela_32 (output_bfd, sreloc, &outrel);
2913
2914 /* This reloc will be computed at runtime, so there's no
2915 need to do anything now. */
2916 if (! relocate)
2917 continue;
2918 }
2919 break;
2920
2921 case R_TILEPRO_IMM16_X0_TLS_GD:
2922 case R_TILEPRO_IMM16_X1_TLS_GD:
2923 case R_TILEPRO_IMM16_X0_TLS_GD_LO:
2924 case R_TILEPRO_IMM16_X1_TLS_GD_LO:
2925 case R_TILEPRO_IMM16_X0_TLS_GD_HI:
2926 case R_TILEPRO_IMM16_X1_TLS_GD_HI:
2927 case R_TILEPRO_IMM16_X0_TLS_GD_HA:
2928 case R_TILEPRO_IMM16_X1_TLS_GD_HA:
2929 tls_type = GOT_TLS_GD;
2930 goto have_tls_reference;
2931
2932 case R_TILEPRO_IMM16_X0_TLS_IE:
2933 case R_TILEPRO_IMM16_X1_TLS_IE:
2934 case R_TILEPRO_IMM16_X0_TLS_IE_LO:
2935 case R_TILEPRO_IMM16_X1_TLS_IE_LO:
2936 case R_TILEPRO_IMM16_X0_TLS_IE_HI:
2937 case R_TILEPRO_IMM16_X1_TLS_IE_HI:
2938 case R_TILEPRO_IMM16_X0_TLS_IE_HA:
2939 case R_TILEPRO_IMM16_X1_TLS_IE_HA:
2940 tls_type = GOT_TLS_IE;
2941 /* Fall through. */
2942
2943 have_tls_reference:
2944 if (h == NULL && local_got_offsets)
2945 tls_type
2946 = _bfd_tilepro_elf_local_got_tls_type (input_bfd) [r_symndx];
2947 else if (h != NULL)
2948 {
2949 tls_type = tilepro_elf_hash_entry(h)->tls_type;
2950 }
2951 if (tls_type == GOT_TLS_IE)
2952 switch (r_type)
2953 {
2954 case R_TILEPRO_IMM16_X0_TLS_GD:
2955 r_type = R_TILEPRO_IMM16_X0_TLS_IE;
2956 break;
2957 case R_TILEPRO_IMM16_X1_TLS_GD:
2958 r_type = R_TILEPRO_IMM16_X1_TLS_IE;
2959 break;
2960 case R_TILEPRO_IMM16_X0_TLS_GD_LO:
2961 r_type = R_TILEPRO_IMM16_X0_TLS_IE_LO;
2962 break;
2963 case R_TILEPRO_IMM16_X1_TLS_GD_LO:
2964 r_type = R_TILEPRO_IMM16_X1_TLS_IE_LO;
2965 break;
2966 case R_TILEPRO_IMM16_X0_TLS_GD_HI:
2967 r_type = R_TILEPRO_IMM16_X0_TLS_IE_HI;
2968 break;
2969 case R_TILEPRO_IMM16_X1_TLS_GD_HI:
2970 r_type = R_TILEPRO_IMM16_X1_TLS_IE_HI;
2971 break;
2972 case R_TILEPRO_IMM16_X0_TLS_GD_HA:
2973 r_type = R_TILEPRO_IMM16_X0_TLS_IE_HA;
2974 break;
2975 case R_TILEPRO_IMM16_X1_TLS_GD_HA:
2976 r_type = R_TILEPRO_IMM16_X1_TLS_IE_HA;
2977 break;
2978 }
2979
2980 if (h != NULL)
2981 {
2982 off = h->got.offset;
2983 h->got.offset |= 1;
2984 }
2985 else
2986 {
2987 BFD_ASSERT (local_got_offsets != NULL);
2988 off = local_got_offsets[r_symndx];
2989 local_got_offsets[r_symndx] |= 1;
2990 }
2991
2992 if (htab->elf.sgot == NULL)
2993 abort ();
2994
2995 if ((off & 1) != 0)
2996 off &= ~1;
2997 else
2998 {
2999 Elf_Internal_Rela outrel;
3000 int indx = 0;
3001 bfd_boolean need_relocs = FALSE;
3002
3003 if (htab->elf.srelgot == NULL)
3004 abort ();
3005
3006 if (h != NULL)
3007 {
3008 bfd_boolean dyn;
3009 dyn = htab->elf.dynamic_sections_created;
3010
3011 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3012 && (!info->shared
3013 || !SYMBOL_REFERENCES_LOCAL (info, h)))
3014 {
3015 indx = h->dynindx;
3016 }
3017 }
3018
3019 /* The GOT entries have not been initialized yet. Do it
3020 now, and emit any relocations. */
3021 if ((info->shared || indx != 0)
3022 && (h == NULL
3023 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3024 || h->root.type != bfd_link_hash_undefweak))
3025 need_relocs = TRUE;
3026
3027 switch (r_type)
3028 {
3029 case R_TILEPRO_IMM16_X0_TLS_IE:
3030 case R_TILEPRO_IMM16_X1_TLS_IE:
3031 case R_TILEPRO_IMM16_X0_TLS_IE_LO:
3032 case R_TILEPRO_IMM16_X1_TLS_IE_LO:
3033 case R_TILEPRO_IMM16_X0_TLS_IE_HI:
3034 case R_TILEPRO_IMM16_X1_TLS_IE_HI:
3035 case R_TILEPRO_IMM16_X0_TLS_IE_HA:
3036 case R_TILEPRO_IMM16_X1_TLS_IE_HA:
3037 if (need_relocs) {
3038 bfd_put_32 (output_bfd, 0, htab->elf.sgot->contents + off);
3039 outrel.r_offset = (htab->elf.sgot->output_section->vma
3040 + htab->elf.sgot->output_offset + off);
3041 outrel.r_addend = 0;
3042 if (indx == 0)
3043 outrel.r_addend = relocation - dtpoff_base (info);
3044 outrel.r_info = ELF32_R_INFO (indx, R_TILEPRO_TLS_TPOFF32);
3045 tilepro_elf_append_rela_32 (output_bfd, htab->elf.srelgot,
3046 &outrel);
3047 } else {
3048 bfd_put_32 (output_bfd, tpoff (info, relocation),
3049 htab->elf.sgot->contents + off);
3050 }
3051 break;
3052
3053 case R_TILEPRO_IMM16_X0_TLS_GD:
3054 case R_TILEPRO_IMM16_X1_TLS_GD:
3055 case R_TILEPRO_IMM16_X0_TLS_GD_LO:
3056 case R_TILEPRO_IMM16_X1_TLS_GD_LO:
3057 case R_TILEPRO_IMM16_X0_TLS_GD_HI:
3058 case R_TILEPRO_IMM16_X1_TLS_GD_HI:
3059 case R_TILEPRO_IMM16_X0_TLS_GD_HA:
3060 case R_TILEPRO_IMM16_X1_TLS_GD_HA:
3061 if (need_relocs) {
3062 outrel.r_offset = (htab->elf.sgot->output_section->vma
3063 + htab->elf.sgot->output_offset + off);
3064 outrel.r_addend = 0;
3065 outrel.r_info = ELF32_R_INFO (indx, R_TILEPRO_TLS_DTPMOD32);
3066 bfd_put_32 (output_bfd, 0, htab->elf.sgot->contents + off);
3067 tilepro_elf_append_rela_32 (output_bfd, htab->elf.srelgot,
3068 &outrel);
3069 if (indx == 0)
3070 {
3071 BFD_ASSERT (! unresolved_reloc);
3072 bfd_put_32 (output_bfd,
3073 relocation - dtpoff_base (info),
3074 (htab->elf.sgot->contents + off +
3075 TILEPRO_BYTES_PER_WORD));
3076 }
3077 else
3078 {
3079 bfd_put_32 (output_bfd, 0,
3080 (htab->elf.sgot->contents + off +
3081 TILEPRO_BYTES_PER_WORD));
3082 outrel.r_info = ELF32_R_INFO (indx,
3083 R_TILEPRO_TLS_DTPOFF32);
3084 outrel.r_offset += TILEPRO_BYTES_PER_WORD;
3085 tilepro_elf_append_rela_32 (output_bfd,
3086 htab->elf.srelgot, &outrel);
3087 }
3088 }
3089
3090 else {
3091 /* If we are not emitting relocations for a
3092 general dynamic reference, then we must be in a
3093 static link or an executable link with the
3094 symbol binding locally. Mark it as belonging
3095 to module 1, the executable. */
3096 bfd_put_32 (output_bfd, 1,
3097 htab->elf.sgot->contents + off );
3098 bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
3099 htab->elf.sgot->contents + off +
3100 TILEPRO_BYTES_PER_WORD);
3101 }
3102 break;
3103 }
3104 }
3105
3106 if (off >= (bfd_vma) -2)
3107 abort ();
3108
3109 relocation = htab->elf.sgot->output_offset + off - got_base;
3110 unresolved_reloc = FALSE;
3111 howto = tilepro_elf_howto_table + r_type;
3112 break;
3113
3114 default:
3115 break;
3116 }
3117
3118 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3119 because such sections are not SEC_ALLOC and thus ld.so will
3120 not process them. */
3121 if (unresolved_reloc
3122 && !((input_section->flags & SEC_DEBUGGING) != 0
3123 && h->def_dynamic))
3124 (*_bfd_error_handler)
3125 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3126 input_bfd,
3127 input_section,
3128 (long) rel->r_offset,
3129 howto->name,
3130 h->root.root.string);
3131
3132 r = bfd_reloc_continue;
3133
3134 /* For the _HA types, we add 0x8000 so that if bit 15 is set,
3135 * we will increment bit 16. The howto->rightshift takes care
3136 * of the rest for us. */
3137 switch (r_type)
3138 {
3139 case R_TILEPRO_HA16:
3140 case R_TILEPRO_IMM16_X0_HA:
3141 case R_TILEPRO_IMM16_X1_HA:
3142 case R_TILEPRO_IMM16_X0_HA_PCREL:
3143 case R_TILEPRO_IMM16_X1_HA_PCREL:
3144 case R_TILEPRO_IMM16_X0_GOT_HA:
3145 case R_TILEPRO_IMM16_X1_GOT_HA:
3146 case R_TILEPRO_IMM16_X0_TLS_GD_HA:
3147 case R_TILEPRO_IMM16_X1_TLS_GD_HA:
3148 case R_TILEPRO_IMM16_X0_TLS_IE_HA:
3149 case R_TILEPRO_IMM16_X1_TLS_IE_HA:
3150 relocation += 0x8000;
3151 break;
3152 }
3153
3154 /* Get the operand creation function, if any. */
3155 create_func = reloc_to_create_func[r_type];
3156 if (create_func == NULL)
3157 {
3158 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3159 contents, rel->r_offset,
3160 relocation, rel->r_addend);
3161 }
3162 else
3163 {
3164 if (howto->pc_relative)
3165 {
3166 relocation -=
3167 input_section->output_section->vma + input_section->output_offset;
3168 if (howto->pcrel_offset)
3169 relocation -= rel->r_offset;
3170 }
3171
3172 bfd_byte *data;
3173
3174 /* Add the relocation addend if any to the final target value */
3175 relocation += rel->r_addend;
3176
3177 /* Do basic range checking */
3178 r = bfd_check_overflow (howto->complain_on_overflow,
3179 howto->bitsize,
3180 howto->rightshift,
3181 32,
3182 relocation);
3183
3184 /*
3185 * Write the relocated value out into the raw section data.
3186 * Don't put a relocation out in the .rela section.
3187 */
3188 tilepro_bundle_bits mask = create_func(-1);
3189 tilepro_bundle_bits value = create_func(relocation >> howto->rightshift);
3190
3191 /* Only touch bytes while the mask is not 0, so we
3192 don't write to out of bounds memory if this is actually
3193 a 16-bit switch instruction. */
3194 for (data = contents + rel->r_offset; mask != 0; data++)
3195 {
3196 bfd_byte byte_mask = (bfd_byte)mask;
3197 *data = (*data & ~byte_mask) | ((bfd_byte)value & byte_mask);
3198 mask >>= 8;
3199 value >>= 8;
3200 }
3201 }
3202
3203 if (r != bfd_reloc_ok)
3204 {
3205 const char *msg = NULL;
3206
3207 switch (r)
3208 {
3209 case bfd_reloc_overflow:
3210 r = info->callbacks->reloc_overflow
3211 (info, (h ? &h->root : NULL), name, howto->name,
3212 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
3213 break;
3214
3215 case bfd_reloc_undefined:
3216 r = info->callbacks->undefined_symbol
3217 (info, name, input_bfd, input_section, rel->r_offset,
3218 TRUE);
3219 break;
3220
3221 case bfd_reloc_outofrange:
3222 msg = _("internal error: out of range error");
3223 break;
3224
3225 case bfd_reloc_notsupported:
3226 msg = _("internal error: unsupported relocation error");
3227 break;
3228
3229 case bfd_reloc_dangerous:
3230 msg = _("internal error: dangerous relocation");
3231 break;
3232
3233 default:
3234 msg = _("internal error: unknown error");
3235 break;
3236 }
3237
3238 if (msg)
3239 r = info->callbacks->warning
3240 (info, msg, name, input_bfd, input_section, rel->r_offset);
3241
3242 if (! r)
3243 return FALSE;
3244 }
3245 }
3246
3247 return TRUE;
3248 }
3249
3250 /* Finish up dynamic symbol handling. We set the contents of various
3251 dynamic sections here. */
3252
3253 static bfd_boolean
3254 tilepro_elf_finish_dynamic_symbol (bfd *output_bfd,
3255 struct bfd_link_info *info,
3256 struct elf_link_hash_entry *h,
3257 Elf_Internal_Sym *sym)
3258 {
3259 struct tilepro_elf_link_hash_table *htab;
3260
3261 htab = tilepro_elf_hash_table (info);
3262 BFD_ASSERT (htab != NULL);
3263
3264 if (h->plt.offset != (bfd_vma) -1)
3265 {
3266 asection *splt;
3267 asection *srela;
3268 asection *sgotplt;
3269 Elf_Internal_Rela rela;
3270 bfd_byte *loc;
3271 bfd_vma r_offset;
3272
3273 int rela_index;
3274
3275 /* This symbol has an entry in the PLT. Set it up. */
3276
3277 BFD_ASSERT (h->dynindx != -1);
3278
3279 splt = htab->elf.splt;
3280 srela = htab->elf.srelplt;
3281 sgotplt = htab->elf.sgotplt;
3282
3283 if (splt == NULL || srela == NULL)
3284 abort ();
3285
3286 /* Fill in the entry in the procedure linkage table. */
3287 rela_index = tilepro_plt_entry_build (splt, sgotplt, h->plt.offset,
3288 &r_offset);
3289
3290 /* Fill in the entry in the global offset table, which initially points
3291 to the beginning of the plt. */
3292 bfd_put_32 (output_bfd, splt->output_section->vma + splt->output_offset,
3293 sgotplt->contents + r_offset);
3294
3295 /* Fill in the entry in the .rela.plt section. */
3296 rela.r_offset = (sgotplt->output_section->vma
3297 + sgotplt->output_offset
3298 + r_offset);
3299 rela.r_addend = 0;
3300 rela.r_info = ELF32_R_INFO (h->dynindx, R_TILEPRO_JMP_SLOT);
3301
3302 loc = srela->contents + rela_index * sizeof (Elf32_External_Rela);
3303 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3304
3305 if (!h->def_regular)
3306 {
3307 /* Mark the symbol as undefined, rather than as defined in
3308 the .plt section. Leave the value alone. */
3309 sym->st_shndx = SHN_UNDEF;
3310 /* If the symbol is weak, we do need to clear the value.
3311 Otherwise, the PLT entry would provide a definition for
3312 the symbol even if the symbol wasn't defined anywhere,
3313 and so the symbol would never be NULL. */
3314 if (!h->ref_regular_nonweak)
3315 sym->st_value = 0;
3316 }
3317 }
3318
3319 if (h->got.offset != (bfd_vma) -1
3320 && tilepro_elf_hash_entry(h)->tls_type != GOT_TLS_GD
3321 && tilepro_elf_hash_entry(h)->tls_type != GOT_TLS_IE)
3322 {
3323 asection *sgot;
3324 asection *srela;
3325 Elf_Internal_Rela rela;
3326
3327 /* This symbol has an entry in the GOT. Set it up. */
3328
3329 sgot = htab->elf.sgot;
3330 srela = htab->elf.srelgot;
3331 BFD_ASSERT (sgot != NULL && srela != NULL);
3332
3333 rela.r_offset = (sgot->output_section->vma
3334 + sgot->output_offset
3335 + (h->got.offset &~ (bfd_vma) 1));
3336
3337 /* If this is a -Bsymbolic link, and the symbol is defined
3338 locally, we just want to emit a RELATIVE reloc. Likewise if
3339 the symbol was forced to be local because of a version file.
3340 The entry in the global offset table will already have been
3341 initialized in the relocate_section function. */
3342 if (info->shared
3343 && (info->symbolic || h->dynindx == -1)
3344 && h->def_regular)
3345 {
3346 asection *sec = h->root.u.def.section;
3347 rela.r_info = ELF32_R_INFO (0, R_TILEPRO_RELATIVE);
3348 rela.r_addend = (h->root.u.def.value
3349 + sec->output_section->vma
3350 + sec->output_offset);
3351 }
3352 else
3353 {
3354 rela.r_info = ELF32_R_INFO (h->dynindx, R_TILEPRO_GLOB_DAT);
3355 rela.r_addend = 0;
3356 }
3357
3358 bfd_put_32 (output_bfd, 0,
3359 sgot->contents + (h->got.offset & ~(bfd_vma) 1));
3360 tilepro_elf_append_rela_32 (output_bfd, srela, &rela);
3361 }
3362
3363 if (h->needs_copy)
3364 {
3365 asection *s;
3366 Elf_Internal_Rela rela;
3367
3368 /* This symbols needs a copy reloc. Set it up. */
3369 BFD_ASSERT (h->dynindx != -1);
3370
3371 s = bfd_get_section_by_name (h->root.u.def.section->owner,
3372 ".rela.bss");
3373 BFD_ASSERT (s != NULL);
3374
3375 rela.r_offset = (h->root.u.def.value
3376 + h->root.u.def.section->output_section->vma
3377 + h->root.u.def.section->output_offset);
3378 rela.r_info = ELF32_R_INFO (h->dynindx, R_TILEPRO_COPY);
3379 rela.r_addend = 0;
3380 tilepro_elf_append_rela_32 (output_bfd, s, &rela);
3381 }
3382
3383 /* Mark some specially defined symbols as absolute. */
3384 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3385 || (h == htab->elf.hgot || h == htab->elf.hplt))
3386 sym->st_shndx = SHN_ABS;
3387
3388 return TRUE;
3389 }
3390
3391 /* Finish up the dynamic sections. */
3392
3393 static bfd_boolean
3394 tilepro_finish_dyn (bfd *output_bfd, struct bfd_link_info *info,
3395 bfd *dynobj, asection *sdyn,
3396 asection *splt ATTRIBUTE_UNUSED)
3397 {
3398 Elf32_External_Dyn *dyncon, *dynconend;
3399 struct tilepro_elf_link_hash_table *htab;
3400
3401 htab = tilepro_elf_hash_table (info);
3402 BFD_ASSERT (htab != NULL);
3403 dyncon = (Elf32_External_Dyn *) sdyn->contents;
3404 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3405 for (; dyncon < dynconend; dyncon++)
3406 {
3407 Elf_Internal_Dyn dyn;
3408 asection *s;
3409
3410 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3411
3412 switch (dyn.d_tag)
3413 {
3414 case DT_PLTGOT:
3415 s = htab->elf.sgotplt;
3416 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3417 break;
3418 case DT_JMPREL:
3419 s = htab->elf.srelplt;
3420 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3421 break;
3422 case DT_PLTRELSZ:
3423 s = htab->elf.srelplt;
3424 dyn.d_un.d_val = s->size;
3425 break;
3426 default:
3427 continue;
3428 }
3429
3430 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3431 }
3432 return TRUE;
3433 }
3434
3435 static bfd_boolean
3436 tilepro_elf_finish_dynamic_sections (bfd *output_bfd,
3437 struct bfd_link_info *info)
3438 {
3439 bfd *dynobj;
3440 asection *sdyn;
3441 struct tilepro_elf_link_hash_table *htab;
3442
3443 htab = tilepro_elf_hash_table (info);
3444 BFD_ASSERT (htab != NULL);
3445 dynobj = htab->elf.dynobj;
3446
3447 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3448
3449 if (elf_hash_table (info)->dynamic_sections_created)
3450 {
3451 asection *splt;
3452 bfd_boolean ret;
3453
3454 splt = bfd_get_section_by_name (dynobj, ".plt");
3455 BFD_ASSERT (splt != NULL && sdyn != NULL);
3456
3457 ret = tilepro_finish_dyn (output_bfd, info, dynobj, sdyn, splt);
3458
3459 if (ret != TRUE)
3460 return ret;
3461
3462 /* Fill in the first entry in the procedure linkage table. */
3463 if (splt->size > 0)
3464 memcpy (splt->contents, tilepro_plt0_entry, PLT_HEADER_SIZE);
3465
3466 elf_section_data (splt->output_section)->this_hdr.sh_entsize
3467 = PLT_ENTRY_SIZE;
3468 }
3469
3470 if (htab->elf.sgotplt)
3471 {
3472 if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
3473 {
3474 (*_bfd_error_handler)
3475 (_("discarded output section: `%A'"), htab->elf.sgotplt);
3476 return FALSE;
3477 }
3478
3479 if (htab->elf.sgotplt->size > 0)
3480 {
3481 /* Write the first two entries in .got.plt, needed for the dynamic
3482 linker. */
3483 bfd_put_32 (output_bfd, (bfd_vma) -1,
3484 htab->elf.sgotplt->contents);
3485 bfd_put_32 (output_bfd, (bfd_vma) 0,
3486 htab->elf.sgotplt->contents + GOT_ENTRY_SIZE);
3487 }
3488
3489 elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize
3490 = GOT_ENTRY_SIZE;
3491 }
3492
3493 if (htab->elf.sgot)
3494 {
3495 if (htab->elf.sgot->size > 0)
3496 {
3497 /* Set the first entry in the global offset table to the address of
3498 the dynamic section. */
3499 bfd_vma val = (sdyn ?
3500 sdyn->output_section->vma + sdyn->output_offset :
3501 0);
3502 bfd_put_32 (output_bfd, val, htab->elf.sgot->contents);
3503 }
3504
3505 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize
3506 = GOT_ENTRY_SIZE;
3507 }
3508
3509 return TRUE;
3510 }
3511
3512 \f
3513
3514 /* Return address for Ith PLT stub in section PLT, for relocation REL
3515 or (bfd_vma) -1 if it should not be included. */
3516
3517 static bfd_vma
3518 tilepro_elf_plt_sym_val (bfd_vma i, const asection *plt,
3519 const arelent *rel ATTRIBUTE_UNUSED)
3520 {
3521 return plt->vma + PLT_HEADER_SIZE + i * PLT_ENTRY_SIZE;
3522 }
3523
3524 static enum elf_reloc_type_class
3525 tilepro_reloc_type_class (const Elf_Internal_Rela *rela)
3526 {
3527 switch ((int) ELF32_R_TYPE (rela->r_info))
3528 {
3529 case R_TILEPRO_RELATIVE:
3530 return reloc_class_relative;
3531 case R_TILEPRO_JMP_SLOT:
3532 return reloc_class_plt;
3533 case R_TILEPRO_COPY:
3534 return reloc_class_copy;
3535 default:
3536 return reloc_class_normal;
3537 }
3538 }
3539
3540 static int
3541 tilepro_additional_program_headers (bfd *abfd,
3542 struct bfd_link_info *info ATTRIBUTE_UNUSED)
3543 {
3544 /* Each .intrpt section specified by the user adds another PT_LOAD
3545 header since the sections are discontiguous. */
3546 static const char intrpt_sections[4][9] =
3547 {
3548 ".intrpt0", ".intrpt1", ".intrpt2", ".intrpt3"
3549 };
3550 int count = 0;
3551 int i;
3552
3553 for (i = 0; i < 4; i++)
3554 {
3555 asection *sec = bfd_get_section_by_name (abfd, intrpt_sections[i]);
3556 if (sec != NULL && (sec->flags & SEC_LOAD) != 0)
3557 ++count;
3558 }
3559
3560 /* Add four "padding" headers in to leave room in case a custom linker
3561 script does something fancy. Otherwise ld complains that it ran
3562 out of program headers and refuses to link. */
3563 count += 4;
3564
3565 return count;
3566 }
3567
3568 #define ELF_ARCH bfd_arch_tilepro
3569 #define ELF_TARGET_ID TILEPRO_ELF_DATA
3570 #define ELF_MACHINE_CODE EM_TILEPRO
3571 #define ELF_MAXPAGESIZE 0x10000
3572 #define ELF_COMMONPAGESIZE 0x10000
3573
3574 #define TARGET_LITTLE_SYM bfd_elf32_tilepro_vec
3575 #define TARGET_LITTLE_NAME "elf32-tilepro"
3576
3577 #define elf_backend_reloc_type_class tilepro_reloc_type_class
3578
3579 #define bfd_elf32_bfd_reloc_name_lookup tilepro_reloc_name_lookup
3580 #define bfd_elf32_bfd_link_hash_table_create tilepro_elf_link_hash_table_create
3581 #define bfd_elf32_bfd_reloc_type_lookup tilepro_reloc_type_lookup
3582
3583 #define elf_backend_copy_indirect_symbol tilepro_elf_copy_indirect_symbol
3584 #define elf_backend_create_dynamic_sections tilepro_elf_create_dynamic_sections
3585 #define elf_backend_check_relocs tilepro_elf_check_relocs
3586 #define elf_backend_adjust_dynamic_symbol tilepro_elf_adjust_dynamic_symbol
3587 #define elf_backend_omit_section_dynsym tilepro_elf_omit_section_dynsym
3588 #define elf_backend_size_dynamic_sections tilepro_elf_size_dynamic_sections
3589 #define elf_backend_relocate_section tilepro_elf_relocate_section
3590 #define elf_backend_finish_dynamic_symbol tilepro_elf_finish_dynamic_symbol
3591 #define elf_backend_finish_dynamic_sections tilepro_elf_finish_dynamic_sections
3592 #define elf_backend_gc_mark_hook tilepro_elf_gc_mark_hook
3593 #define elf_backend_gc_sweep_hook tilepro_elf_gc_sweep_hook
3594 #define elf_backend_plt_sym_val tilepro_elf_plt_sym_val
3595 #define elf_info_to_howto_rel NULL
3596 #define elf_info_to_howto tilepro_info_to_howto_rela
3597 #define elf_backend_grok_prstatus tilepro_elf_grok_prstatus
3598 #define elf_backend_grok_psinfo tilepro_elf_grok_psinfo
3599 #define elf_backend_additional_program_headers tilepro_additional_program_headers
3600
3601 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
3602
3603 #define elf_backend_can_gc_sections 1
3604 #define elf_backend_can_refcount 1
3605 #define elf_backend_want_got_plt 1
3606 #define elf_backend_plt_readonly 1
3607 /* Align PLT mod 64 byte L2 line size. */
3608 #define elf_backend_plt_alignment 6
3609 #define elf_backend_want_plt_sym 1
3610 #define elf_backend_got_header_size GOT_ENTRY_SIZE
3611 #define elf_backend_rela_normal 1
3612 #define elf_backend_default_execstack 0
3613
3614 #include "elf32-target.h"
git-cvsimport of binutils cvsroot