projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* Makefile.am (ALL_MACHINES): Add cpu-tilegx.lo and cpu-tilepro.lo.
[deliverable/binutils-gdb.git] / bfd / elf32-tilepro.c
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 bfd_vma *local_got_offsets;
1303 const Elf_Internal_Rela *rel;
1304 const Elf_Internal_Rela *rel_end;
1305 asection *sreloc;
1306 int num_relocs;
1307
1308 if (info->relocatable)
1309 return TRUE;
1310
1311 htab = tilepro_elf_hash_table (info);
1312 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1313 sym_hashes = elf_sym_hashes (abfd);
1314 local_got_offsets = elf_local_got_offsets (abfd);
1315
1316 sreloc = NULL;
1317
1318 num_relocs = sec->reloc_count;
1319
1320 BFD_ASSERT (is_tilepro_elf (abfd) || num_relocs == 0);
1321
1322 if (htab->elf.dynobj == NULL)
1323 htab->elf.dynobj = abfd;
1324
1325 rel_end = relocs + num_relocs;
1326 for (rel = relocs; rel < rel_end; rel++)
1327 {
1328 unsigned int r_type;
1329 unsigned long r_symndx;
1330 struct elf_link_hash_entry *h;
1331 int tls_type;
1332
1333 r_symndx = ELF32_R_SYM (rel->r_info);
1334 r_type = ELF32_R_TYPE (rel->r_info);
1335
1336 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1337 {
1338 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1339 abfd, r_symndx);
1340 return FALSE;
1341 }
1342
1343 if (r_symndx < symtab_hdr->sh_info)
1344 h = NULL;
1345 else
1346 {
1347 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1348 while (h->root.type == bfd_link_hash_indirect
1349 || h->root.type == bfd_link_hash_warning)
1350 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1351 }
1352
1353 switch (r_type)
1354 {
1355 case R_TILEPRO_IMM16_X0_TLS_GD:
1356 case R_TILEPRO_IMM16_X1_TLS_GD:
1357 case R_TILEPRO_IMM16_X0_TLS_GD_LO:
1358 case R_TILEPRO_IMM16_X1_TLS_GD_LO:
1359 case R_TILEPRO_IMM16_X0_TLS_GD_HI:
1360 case R_TILEPRO_IMM16_X1_TLS_GD_HI:
1361 case R_TILEPRO_IMM16_X0_TLS_GD_HA:
1362 case R_TILEPRO_IMM16_X1_TLS_GD_HA:
1363 tls_type = GOT_TLS_GD;
1364 goto have_got_reference;
1365
1366 case R_TILEPRO_IMM16_X0_TLS_IE:
1367 case R_TILEPRO_IMM16_X1_TLS_IE:
1368 case R_TILEPRO_IMM16_X0_TLS_IE_LO:
1369 case R_TILEPRO_IMM16_X1_TLS_IE_LO:
1370 case R_TILEPRO_IMM16_X0_TLS_IE_HI:
1371 case R_TILEPRO_IMM16_X1_TLS_IE_HI:
1372 case R_TILEPRO_IMM16_X0_TLS_IE_HA:
1373 case R_TILEPRO_IMM16_X1_TLS_IE_HA:
1374 tls_type = GOT_TLS_IE;
1375 if (info->shared)
1376 info->flags |= DF_STATIC_TLS;
1377 goto have_got_reference;
1378
1379 case R_TILEPRO_IMM16_X0_GOT:
1380 case R_TILEPRO_IMM16_X1_GOT:
1381 case R_TILEPRO_IMM16_X0_GOT_LO:
1382 case R_TILEPRO_IMM16_X1_GOT_LO:
1383 case R_TILEPRO_IMM16_X0_GOT_HI:
1384 case R_TILEPRO_IMM16_X1_GOT_HI:
1385 case R_TILEPRO_IMM16_X0_GOT_HA:
1386 case R_TILEPRO_IMM16_X1_GOT_HA:
1387 tls_type = GOT_NORMAL;
1388 /* Fall Through */
1389
1390 have_got_reference:
1391 /* This symbol requires a global offset table entry. */
1392 {
1393 int old_tls_type;
1394
1395 if (h != NULL)
1396 {
1397 h->got.refcount += 1;
1398 old_tls_type = tilepro_elf_hash_entry(h)->tls_type;
1399 }
1400 else
1401 {
1402 bfd_signed_vma *local_got_refcounts;
1403
1404 /* This is a global offset table entry for a local symbol. */
1405 local_got_refcounts = elf_local_got_refcounts (abfd);
1406 if (local_got_refcounts == NULL)
1407 {
1408 bfd_size_type size;
1409
1410 size = symtab_hdr->sh_info;
1411 size *= (sizeof (bfd_signed_vma) + sizeof(char));
1412 local_got_refcounts = ((bfd_signed_vma *)
1413 bfd_zalloc (abfd, size));
1414 if (local_got_refcounts == NULL)
1415 return FALSE;
1416 elf_local_got_refcounts (abfd) = local_got_refcounts;
1417 _bfd_tilepro_elf_local_got_tls_type (abfd)
1418 = (char *) (local_got_refcounts + symtab_hdr->sh_info);
1419 }
1420 local_got_refcounts[r_symndx] += 1;
1421 old_tls_type =
1422 _bfd_tilepro_elf_local_got_tls_type (abfd) [r_symndx];
1423 }
1424
1425 /* If a TLS symbol is accessed using IE at least once,
1426 there is no point to use dynamic model for it. */
1427 if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1428 && (old_tls_type != GOT_TLS_GD
1429 || tls_type != GOT_TLS_IE))
1430 {
1431 if (old_tls_type == GOT_TLS_IE && tls_type == GOT_TLS_GD)
1432 tls_type = old_tls_type;
1433 else
1434 {
1435 (*_bfd_error_handler)
1436 (_("%B: `%s' accessed both as normal and thread local symbol"),
1437 abfd, h ? h->root.root.string : "<local>");
1438 return FALSE;
1439 }
1440 }
1441
1442 if (old_tls_type != tls_type)
1443 {
1444 if (h != NULL)
1445 tilepro_elf_hash_entry (h)->tls_type = tls_type;
1446 else
1447 _bfd_tilepro_elf_local_got_tls_type (abfd) [r_symndx] =
1448 tls_type;
1449 }
1450 }
1451
1452 if (htab->elf.sgot == NULL)
1453 {
1454 if (!tilepro_elf_create_got_section (htab->elf.dynobj, info))
1455 return FALSE;
1456 }
1457 break;
1458
1459 case R_TILEPRO_JOFFLONG_X1_PLT:
1460 /* This symbol requires a procedure linkage table entry. We
1461 actually build the entry in adjust_dynamic_symbol,
1462 because this might be a case of linking PIC code without
1463 linking in any dynamic objects, in which case we don't
1464 need to generate a procedure linkage table after all. */
1465
1466 if (h != NULL)
1467 {
1468 h->needs_plt = 1;
1469 h->plt.refcount += 1;
1470 }
1471 break;
1472
1473 case R_TILEPRO_32_PCREL:
1474 case R_TILEPRO_16_PCREL:
1475 case R_TILEPRO_8_PCREL:
1476 case R_TILEPRO_IMM16_X0_PCREL:
1477 case R_TILEPRO_IMM16_X1_PCREL:
1478 case R_TILEPRO_IMM16_X0_LO_PCREL:
1479 case R_TILEPRO_IMM16_X1_LO_PCREL:
1480 case R_TILEPRO_IMM16_X0_HI_PCREL:
1481 case R_TILEPRO_IMM16_X1_HI_PCREL:
1482 case R_TILEPRO_IMM16_X0_HA_PCREL:
1483 case R_TILEPRO_IMM16_X1_HA_PCREL:
1484 if (h != NULL)
1485 h->non_got_ref = 1;
1486
1487 if (h != NULL
1488 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1489 break;
1490 /* Fall through. */
1491
1492 case R_TILEPRO_32:
1493 case R_TILEPRO_16:
1494 case R_TILEPRO_8:
1495 case R_TILEPRO_LO16:
1496 case R_TILEPRO_HI16:
1497 case R_TILEPRO_HA16:
1498 case R_TILEPRO_COPY:
1499 case R_TILEPRO_GLOB_DAT:
1500 case R_TILEPRO_JMP_SLOT:
1501 case R_TILEPRO_RELATIVE:
1502 case R_TILEPRO_BROFF_X1:
1503 case R_TILEPRO_JOFFLONG_X1:
1504 case R_TILEPRO_IMM8_X0:
1505 case R_TILEPRO_IMM8_Y0:
1506 case R_TILEPRO_IMM8_X1:
1507 case R_TILEPRO_IMM8_Y1:
1508 case R_TILEPRO_DEST_IMM8_X1:
1509 case R_TILEPRO_MT_IMM15_X1:
1510 case R_TILEPRO_MF_IMM15_X1:
1511 case R_TILEPRO_IMM16_X0:
1512 case R_TILEPRO_IMM16_X1:
1513 case R_TILEPRO_IMM16_X0_LO:
1514 case R_TILEPRO_IMM16_X1_LO:
1515 case R_TILEPRO_IMM16_X0_HI:
1516 case R_TILEPRO_IMM16_X1_HI:
1517 case R_TILEPRO_IMM16_X0_HA:
1518 case R_TILEPRO_IMM16_X1_HA:
1519 case R_TILEPRO_MMSTART_X0:
1520 case R_TILEPRO_MMEND_X0:
1521 case R_TILEPRO_MMSTART_X1:
1522 case R_TILEPRO_MMEND_X1:
1523 case R_TILEPRO_SHAMT_X0:
1524 case R_TILEPRO_SHAMT_X1:
1525 case R_TILEPRO_SHAMT_Y0:
1526 case R_TILEPRO_SHAMT_Y1:
1527 if (h != NULL)
1528 {
1529 h->non_got_ref = 1;
1530
1531 if (!info->shared)
1532 {
1533 /* We may need a .plt entry if the function this reloc
1534 refers to is in a shared lib. */
1535 h->plt.refcount += 1;
1536 }
1537 }
1538
1539 /* If we are creating a shared library, and this is a reloc
1540 against a global symbol, or a non PC relative reloc
1541 against a local symbol, then we need to copy the reloc
1542 into the shared library. However, if we are linking with
1543 -Bsymbolic, we do not need to copy a reloc against a
1544 global symbol which is defined in an object we are
1545 including in the link (i.e., DEF_REGULAR is set). At
1546 this point we have not seen all the input files, so it is
1547 possible that DEF_REGULAR is not set now but will be set
1548 later (it is never cleared). In case of a weak definition,
1549 DEF_REGULAR may be cleared later by a strong definition in
1550 a shared library. We account for that possibility below by
1551 storing information in the relocs_copied field of the hash
1552 table entry. A similar situation occurs when creating
1553 shared libraries and symbol visibility changes render the
1554 symbol local.
1555
1556 If on the other hand, we are creating an executable, we
1557 may need to keep relocations for symbols satisfied by a
1558 dynamic library if we manage to avoid copy relocs for the
1559 symbol. */
1560 if ((info->shared
1561 && (sec->flags & SEC_ALLOC) != 0
1562 && (! tilepro_elf_howto_table[r_type].pc_relative
1563 || (h != NULL
1564 && (! info->symbolic
1565 || h->root.type == bfd_link_hash_defweak
1566 || !h->def_regular))))
1567 || (!info->shared
1568 && (sec->flags & SEC_ALLOC) != 0
1569 && h != NULL
1570 && (h->root.type == bfd_link_hash_defweak
1571 || !h->def_regular)))
1572 {
1573 struct tilepro_elf_dyn_relocs *p;
1574 struct tilepro_elf_dyn_relocs **head;
1575
1576 /* When creating a shared object, we must copy these
1577 relocs into the output file. We create a reloc
1578 section in dynobj and make room for the reloc. */
1579 if (sreloc == NULL)
1580 {
1581 sreloc = _bfd_elf_make_dynamic_reloc_section
1582 (sec, htab->elf.dynobj, 2, abfd, /*rela?*/ TRUE);
1583
1584 if (sreloc == NULL)
1585 return FALSE;
1586 }
1587
1588 /* If this is a global symbol, we count the number of
1589 relocations we need for this symbol. */
1590 if (h != NULL)
1591 head =
1592 &((struct tilepro_elf_link_hash_entry *) h)->dyn_relocs;
1593 else
1594 {
1595 /* Track dynamic relocs needed for local syms too.
1596 We really need local syms available to do this
1597 easily. Oh well. */
1598
1599 asection *s;
1600 void *vpp;
1601 Elf_Internal_Sym *isym;
1602
1603 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1604 abfd, r_symndx);
1605 if (isym == NULL)
1606 return FALSE;
1607
1608 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1609 if (s == NULL)
1610 s = sec;
1611
1612 vpp = &elf_section_data (s)->local_dynrel;
1613 head = (struct tilepro_elf_dyn_relocs **) vpp;
1614 }
1615
1616 p = *head;
1617 if (p == NULL || p->sec != sec)
1618 {
1619 bfd_size_type amt = sizeof *p;
1620 p = ((struct tilepro_elf_dyn_relocs *)
1621 bfd_alloc (htab->elf.dynobj, amt));
1622 if (p == NULL)
1623 return FALSE;
1624 p->next = *head;
1625 *head = p;
1626 p->sec = sec;
1627 p->count = 0;
1628 p->pc_count = 0;
1629 }
1630
1631 p->count += 1;
1632 if (tilepro_elf_howto_table[r_type].pc_relative)
1633 p->pc_count += 1;
1634 }
1635
1636 break;
1637
1638 case R_TILEPRO_GNU_VTINHERIT:
1639 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1640 return FALSE;
1641 break;
1642
1643 case R_TILEPRO_GNU_VTENTRY:
1644 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1645 return FALSE;
1646 break;
1647
1648 default:
1649 break;
1650 }
1651 }
1652
1653 return TRUE;
1654 }
1655
1656 \f
1657 static asection *
1658 tilepro_elf_gc_mark_hook (asection *sec,
1659 struct bfd_link_info *info,
1660 Elf_Internal_Rela *rel,
1661 struct elf_link_hash_entry *h,
1662 Elf_Internal_Sym *sym)
1663 {
1664 if (h != NULL)
1665 {
1666 switch (ELF32_R_TYPE (rel->r_info))
1667 {
1668 case R_TILEPRO_GNU_VTINHERIT:
1669 case R_TILEPRO_GNU_VTENTRY:
1670 break;
1671 }
1672 }
1673
1674 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1675 }
1676
1677 /* Update the got entry reference counts for the section being removed. */
1678 static bfd_boolean
1679 tilepro_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
1680 asection *sec, const Elf_Internal_Rela *relocs)
1681 {
1682 struct tilepro_elf_link_hash_table *htab;
1683 Elf_Internal_Shdr *symtab_hdr;
1684 struct elf_link_hash_entry **sym_hashes;
1685 bfd_signed_vma *local_got_refcounts;
1686 const Elf_Internal_Rela *rel, *relend;
1687
1688 if (info->relocatable)
1689 return TRUE;
1690
1691 BFD_ASSERT (is_tilepro_elf (abfd) || sec->reloc_count == 0);
1692
1693 elf_section_data (sec)->local_dynrel = NULL;
1694
1695 htab = tilepro_elf_hash_table (info);
1696 BFD_ASSERT (htab != NULL);
1697 symtab_hdr = &elf_symtab_hdr (abfd);
1698 sym_hashes = elf_sym_hashes (abfd);
1699 local_got_refcounts = elf_local_got_refcounts (abfd);
1700
1701 relend = relocs + sec->reloc_count;
1702 for (rel = relocs; rel < relend; rel++)
1703 {
1704 unsigned long r_symndx;
1705 unsigned int r_type;
1706 struct elf_link_hash_entry *h = NULL;
1707
1708 r_symndx = ELF32_R_SYM (rel->r_info);
1709 if (r_symndx >= symtab_hdr->sh_info)
1710 {
1711 struct tilepro_elf_link_hash_entry *eh;
1712 struct tilepro_elf_dyn_relocs **pp;
1713 struct tilepro_elf_dyn_relocs *p;
1714
1715 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1716 while (h->root.type == bfd_link_hash_indirect
1717 || h->root.type == bfd_link_hash_warning)
1718 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1719 eh = (struct tilepro_elf_link_hash_entry *) h;
1720 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1721 if (p->sec == sec)
1722 {
1723 /* Everything must go for SEC. */
1724 *pp = p->next;
1725 break;
1726 }
1727 }
1728
1729 r_type = ELF32_R_TYPE (rel->r_info);
1730 switch (r_type)
1731 {
1732 case R_TILEPRO_IMM16_X0_GOT:
1733 case R_TILEPRO_IMM16_X1_GOT:
1734 case R_TILEPRO_IMM16_X0_GOT_LO:
1735 case R_TILEPRO_IMM16_X1_GOT_LO:
1736 case R_TILEPRO_IMM16_X0_GOT_HI:
1737 case R_TILEPRO_IMM16_X1_GOT_HI:
1738 case R_TILEPRO_IMM16_X0_GOT_HA:
1739 case R_TILEPRO_IMM16_X1_GOT_HA:
1740 case R_TILEPRO_IMM16_X0_TLS_GD:
1741 case R_TILEPRO_IMM16_X1_TLS_GD:
1742 case R_TILEPRO_IMM16_X0_TLS_GD_LO:
1743 case R_TILEPRO_IMM16_X1_TLS_GD_LO:
1744 case R_TILEPRO_IMM16_X0_TLS_GD_HI:
1745 case R_TILEPRO_IMM16_X1_TLS_GD_HI:
1746 case R_TILEPRO_IMM16_X0_TLS_GD_HA:
1747 case R_TILEPRO_IMM16_X1_TLS_GD_HA:
1748 case R_TILEPRO_IMM16_X0_TLS_IE:
1749 case R_TILEPRO_IMM16_X1_TLS_IE:
1750 case R_TILEPRO_IMM16_X0_TLS_IE_LO:
1751 case R_TILEPRO_IMM16_X1_TLS_IE_LO:
1752 case R_TILEPRO_IMM16_X0_TLS_IE_HI:
1753 case R_TILEPRO_IMM16_X1_TLS_IE_HI:
1754 case R_TILEPRO_IMM16_X0_TLS_IE_HA:
1755 case R_TILEPRO_IMM16_X1_TLS_IE_HA:
1756 if (h != NULL)
1757 {
1758 if (h->got.refcount > 0)
1759 h->got.refcount--;
1760 }
1761 else
1762 {
1763 if (local_got_refcounts[r_symndx] > 0)
1764 local_got_refcounts[r_symndx]--;
1765 }
1766 break;
1767
1768 case R_TILEPRO_32_PCREL:
1769 case R_TILEPRO_16_PCREL:
1770 case R_TILEPRO_8_PCREL:
1771 case R_TILEPRO_IMM16_X0_PCREL:
1772 case R_TILEPRO_IMM16_X1_PCREL:
1773 case R_TILEPRO_IMM16_X0_LO_PCREL:
1774 case R_TILEPRO_IMM16_X1_LO_PCREL:
1775 case R_TILEPRO_IMM16_X0_HI_PCREL:
1776 case R_TILEPRO_IMM16_X1_HI_PCREL:
1777 case R_TILEPRO_IMM16_X0_HA_PCREL:
1778 case R_TILEPRO_IMM16_X1_HA_PCREL:
1779 if (h != NULL
1780 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1781 break;
1782 /* Fall through. */
1783
1784 case R_TILEPRO_32:
1785 case R_TILEPRO_16:
1786 case R_TILEPRO_8:
1787 case R_TILEPRO_LO16:
1788 case R_TILEPRO_HI16:
1789 case R_TILEPRO_HA16:
1790 case R_TILEPRO_COPY:
1791 case R_TILEPRO_GLOB_DAT:
1792 case R_TILEPRO_JMP_SLOT:
1793 case R_TILEPRO_RELATIVE:
1794 case R_TILEPRO_BROFF_X1:
1795 case R_TILEPRO_JOFFLONG_X1:
1796 case R_TILEPRO_IMM8_X0:
1797 case R_TILEPRO_IMM8_Y0:
1798 case R_TILEPRO_IMM8_X1:
1799 case R_TILEPRO_IMM8_Y1:
1800 case R_TILEPRO_DEST_IMM8_X1:
1801 case R_TILEPRO_MT_IMM15_X1:
1802 case R_TILEPRO_MF_IMM15_X1:
1803 case R_TILEPRO_IMM16_X0:
1804 case R_TILEPRO_IMM16_X1:
1805 case R_TILEPRO_IMM16_X0_LO:
1806 case R_TILEPRO_IMM16_X1_LO:
1807 case R_TILEPRO_IMM16_X0_HI:
1808 case R_TILEPRO_IMM16_X1_HI:
1809 case R_TILEPRO_IMM16_X0_HA:
1810 case R_TILEPRO_IMM16_X1_HA:
1811 case R_TILEPRO_MMSTART_X0:
1812 case R_TILEPRO_MMEND_X0:
1813 case R_TILEPRO_MMSTART_X1:
1814 case R_TILEPRO_MMEND_X1:
1815 case R_TILEPRO_SHAMT_X0:
1816 case R_TILEPRO_SHAMT_X1:
1817 case R_TILEPRO_SHAMT_Y0:
1818 case R_TILEPRO_SHAMT_Y1:
1819 if (info->shared)
1820 break;
1821 /* Fall through. */
1822
1823 case R_TILEPRO_JOFFLONG_X1_PLT:
1824 if (h != NULL)
1825 {
1826 if (h->plt.refcount > 0)
1827 h->plt.refcount--;
1828 }
1829 break;
1830
1831 default:
1832 break;
1833 }
1834 }
1835
1836 return TRUE;
1837 }
1838
1839 /* Adjust a symbol defined by a dynamic object and referenced by a
1840 regular object. The current definition is in some section of the
1841 dynamic object, but we're not including those sections. We have to
1842 change the definition to something the rest of the link can
1843 understand. */
1844
1845 static bfd_boolean
1846 tilepro_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1847 struct elf_link_hash_entry *h)
1848 {
1849 struct tilepro_elf_link_hash_table *htab;
1850 struct tilepro_elf_link_hash_entry * eh;
1851 struct tilepro_elf_dyn_relocs *p;
1852 asection *s;
1853
1854 htab = tilepro_elf_hash_table (info);
1855 BFD_ASSERT (htab != NULL);
1856
1857 /* Make sure we know what is going on here. */
1858 BFD_ASSERT (htab->elf.dynobj != NULL
1859 && (h->needs_plt
1860 || h->u.weakdef != NULL
1861 || (h->def_dynamic
1862 && h->ref_regular
1863 && !h->def_regular)));
1864
1865 /* If this is a function, put it in the procedure linkage table. We
1866 will fill in the contents of the procedure linkage table later
1867 (although we could actually do it here). */
1868 if (h->type == STT_FUNC || h->needs_plt)
1869 {
1870 if (h->plt.refcount <= 0
1871 || SYMBOL_CALLS_LOCAL (info, h)
1872 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1873 && h->root.type == bfd_link_hash_undefweak))
1874 {
1875 /* This case can occur if we saw a R_TILEPRO_JOFFLONG_X1_PLT
1876 reloc in an input file, but the symbol was never referred
1877 to by a dynamic object, or if all references were garbage
1878 collected. In such a case, we don't actually need to build
1879 a procedure linkage table, and we can just do a
1880 R_TILEPRO_JOFFLONG_X1 relocation instead. */
1881 h->plt.offset = (bfd_vma) -1;
1882 h->needs_plt = 0;
1883 }
1884
1885 return TRUE;
1886 }
1887 else
1888 h->plt.offset = (bfd_vma) -1;
1889
1890 /* If this is a weak symbol, and there is a real definition, the
1891 processor independent code will have arranged for us to see the
1892 real definition first, and we can just use the same value. */
1893 if (h->u.weakdef != NULL)
1894 {
1895 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1896 || h->u.weakdef->root.type == bfd_link_hash_defweak);
1897 h->root.u.def.section = h->u.weakdef->root.u.def.section;
1898 h->root.u.def.value = h->u.weakdef->root.u.def.value;
1899 return TRUE;
1900 }
1901
1902 /* This is a reference to a symbol defined by a dynamic object which
1903 is not a function. */
1904
1905 /* If we are creating a shared library, we must presume that the
1906 only references to the symbol are via the global offset table.
1907 For such cases we need not do anything here; the relocations will
1908 be handled correctly by relocate_section. */
1909 if (info->shared)
1910 return TRUE;
1911
1912 /* If there are no references to this symbol that do not use the
1913 GOT, we don't need to generate a copy reloc. */
1914 if (!h->non_got_ref)
1915 return TRUE;
1916
1917 /* If -z nocopyreloc was given, we won't generate them either. */
1918 if (info->nocopyreloc)
1919 {
1920 h->non_got_ref = 0;
1921 return TRUE;
1922 }
1923
1924 eh = (struct tilepro_elf_link_hash_entry *) h;
1925 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1926 {
1927 s = p->sec->output_section;
1928 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1929 break;
1930 }
1931
1932 /* If we didn't find any dynamic relocs in read-only sections, then
1933 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1934 if (p == NULL)
1935 {
1936 h->non_got_ref = 0;
1937 return TRUE;
1938 }
1939
1940 if (h->size == 0)
1941 {
1942 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
1943 h->root.root.string);
1944 return TRUE;
1945 }
1946
1947 /* We must allocate the symbol in our .dynbss section, which will
1948 become part of the .bss section of the executable. There will be
1949 an entry for this symbol in the .dynsym section. The dynamic
1950 object will contain position independent code, so all references
1951 from the dynamic object to this symbol will go through the global
1952 offset table. The dynamic linker will use the .dynsym entry to
1953 determine the address it must put in the global offset table, so
1954 both the dynamic object and the regular object will refer to the
1955 same memory location for the variable. */
1956
1957 /* We must generate a R_TILEPRO_COPY reloc to tell the dynamic linker
1958 to copy the initial value out of the dynamic object and into the
1959 runtime process image. We need to remember the offset into the
1960 .rel.bss section we are going to use. */
1961 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1962 {
1963 htab->srelbss->size += TILEPRO_ELF_RELA_BYTES;
1964 h->needs_copy = 1;
1965 }
1966
1967 return _bfd_elf_adjust_dynamic_copy (h, htab->sdynbss);
1968 }
1969
1970 /* Allocate space in .plt, .got and associated reloc sections for
1971 dynamic relocs. */
1972
1973 static bfd_boolean
1974 allocate_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
1975 {
1976 struct bfd_link_info *info;
1977 struct tilepro_elf_link_hash_table *htab;
1978 struct tilepro_elf_link_hash_entry *eh;
1979 struct tilepro_elf_dyn_relocs *p;
1980
1981 if (h->root.type == bfd_link_hash_indirect)
1982 return TRUE;
1983
1984 if (h->root.type == bfd_link_hash_warning)
1985 /* When warning symbols are created, they **replace** the "real"
1986 entry in the hash table, thus we never get to see the real
1987 symbol in a hash traversal. So look at it now. */
1988 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1989
1990 info = (struct bfd_link_info *) inf;
1991 htab = tilepro_elf_hash_table (info);
1992 BFD_ASSERT (htab != NULL);
1993
1994 if (htab->elf.dynamic_sections_created
1995 && h->plt.refcount > 0)
1996 {
1997 /* Make sure this symbol is output as a dynamic symbol.
1998 Undefined weak syms won't yet be marked as dynamic. */
1999 if (h->dynindx == -1
2000 && !h->forced_local)
2001 {
2002 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2003 return FALSE;
2004 }
2005
2006 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
2007 {
2008 asection *s = htab->elf.splt;
2009
2010 /* Allocate room for the header. */
2011 if (s->size == 0)
2012 {
2013 s->size = PLT_HEADER_SIZE;
2014 }
2015
2016 h->plt.offset = s->size;
2017
2018 /* If this symbol is not defined in a regular file, and we are
2019 not generating a shared library, then set the symbol to this
2020 location in the .plt. This is required to make function
2021 pointers compare as equal between the normal executable and
2022 the shared library. */
2023 if (! info->shared
2024 && !h->def_regular)
2025 {
2026 h->root.u.def.section = s;
2027 h->root.u.def.value = h->plt.offset;
2028 }
2029
2030 /* Make room for this entry. */
2031 s->size += PLT_ENTRY_SIZE;
2032
2033 /* We also need to make an entry in the .got.plt section. */
2034 htab->elf.sgotplt->size += GOT_ENTRY_SIZE;
2035
2036 /* We also need to make an entry in the .rela.plt section. */
2037 htab->elf.srelplt->size += TILEPRO_ELF_RELA_BYTES;
2038 }
2039 else
2040 {
2041 h->plt.offset = (bfd_vma) -1;
2042 h->needs_plt = 0;
2043 }
2044 }
2045 else
2046 {
2047 h->plt.offset = (bfd_vma) -1;
2048 h->needs_plt = 0;
2049 }
2050
2051 if (h->got.refcount > 0)
2052 {
2053 asection *s;
2054 bfd_boolean dyn;
2055 int tls_type = tilepro_elf_hash_entry(h)->tls_type;
2056
2057 /* Make sure this symbol is output as a dynamic symbol.
2058 Undefined weak syms won't yet be marked as dynamic. */
2059 if (h->dynindx == -1
2060 && !h->forced_local)
2061 {
2062 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2063 return FALSE;
2064 }
2065
2066 s = htab->elf.sgot;
2067 h->got.offset = s->size;
2068 s->size += TILEPRO_BYTES_PER_WORD;
2069 /* R_TILEPRO_IMM16_Xn_TLS_GD entries need 2 consecutive GOT slots. */
2070 if (tls_type == GOT_TLS_GD)
2071 s->size += TILEPRO_BYTES_PER_WORD;
2072 dyn = htab->elf.dynamic_sections_created;
2073 /* R_TILEPRO_IMM16_Xn_TLS_IE_xxx needs one dynamic relocation,
2074 R_TILEPRO_IMM16_Xn_TLS_GD_xxx needs two if local symbol and two if
2075 global. */
2076 if (tls_type == GOT_TLS_GD || tls_type == GOT_TLS_IE)
2077 htab->elf.srelgot->size += 2 * TILEPRO_ELF_RELA_BYTES;
2078 else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
2079 htab->elf.srelgot->size += TILEPRO_ELF_RELA_BYTES;
2080 }
2081 else
2082 h->got.offset = (bfd_vma) -1;
2083
2084 eh = (struct tilepro_elf_link_hash_entry *) h;
2085 if (eh->dyn_relocs == NULL)
2086 return TRUE;
2087
2088 /* In the shared -Bsymbolic case, discard space allocated for
2089 dynamic pc-relative relocs against symbols which turn out to be
2090 defined in regular objects. For the normal shared case, discard
2091 space for pc-relative relocs that have become local due to symbol
2092 visibility changes. */
2093
2094 if (info->shared)
2095 {
2096 if (SYMBOL_CALLS_LOCAL (info, h))
2097 {
2098 struct tilepro_elf_dyn_relocs **pp;
2099
2100 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2101 {
2102 p->count -= p->pc_count;
2103 p->pc_count = 0;
2104 if (p->count == 0)
2105 *pp = p->next;
2106 else
2107 pp = &p->next;
2108 }
2109 }
2110
2111 /* Also discard relocs on undefined weak syms with non-default
2112 visibility. */
2113 if (eh->dyn_relocs != NULL
2114 && h->root.type == bfd_link_hash_undefweak)
2115 {
2116 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2117 eh->dyn_relocs = NULL;
2118
2119 /* Make sure undefined weak symbols are output as a dynamic
2120 symbol in PIEs. */
2121 else if (h->dynindx == -1
2122 && !h->forced_local)
2123 {
2124 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2125 return FALSE;
2126 }
2127 }
2128 }
2129 else
2130 {
2131 /* For the non-shared case, discard space for relocs against
2132 symbols which turn out to need copy relocs or are not
2133 dynamic. */
2134
2135 if (!h->non_got_ref
2136 && ((h->def_dynamic
2137 && !h->def_regular)
2138 || (htab->elf.dynamic_sections_created
2139 && (h->root.type == bfd_link_hash_undefweak
2140 || h->root.type == bfd_link_hash_undefined))))
2141 {
2142 /* Make sure this symbol is output as a dynamic symbol.
2143 Undefined weak syms won't yet be marked as dynamic. */
2144 if (h->dynindx == -1
2145 && !h->forced_local)
2146 {
2147 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2148 return FALSE;
2149 }
2150
2151 /* If that succeeded, we know we'll be keeping all the
2152 relocs. */
2153 if (h->dynindx != -1)
2154 goto keep;
2155 }
2156
2157 eh->dyn_relocs = NULL;
2158
2159 keep: ;
2160 }
2161
2162 /* Finally, allocate space. */
2163 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2164 {
2165 asection *sreloc = elf_section_data (p->sec)->sreloc;
2166 sreloc->size += p->count * TILEPRO_ELF_RELA_BYTES;
2167 }
2168
2169 return TRUE;
2170 }
2171
2172 /* Find any dynamic relocs that apply to read-only sections. */
2173
2174 static bfd_boolean
2175 readonly_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
2176 {
2177 struct tilepro_elf_link_hash_entry *eh;
2178 struct tilepro_elf_dyn_relocs *p;
2179
2180 if (h->root.type == bfd_link_hash_warning)
2181 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2182
2183 eh = (struct tilepro_elf_link_hash_entry *) h;
2184 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2185 {
2186 asection *s = p->sec->output_section;
2187
2188 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2189 {
2190 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2191
2192 info->flags |= DF_TEXTREL;
2193
2194 /* Not an error, just cut short the traversal. */
2195 return FALSE;
2196 }
2197 }
2198 return TRUE;
2199 }
2200
2201 /* Return true if the dynamic symbol for a given section should be
2202 omitted when creating a shared library. */
2203
2204 static bfd_boolean
2205 tilepro_elf_omit_section_dynsym (bfd *output_bfd,
2206 struct bfd_link_info *info,
2207 asection *p)
2208 {
2209 /* We keep the .got section symbol so that explicit relocations
2210 against the _GLOBAL_OFFSET_TABLE_ symbol emitted in PIC mode
2211 can be turned into relocations against the .got symbol. */
2212 if (strcmp (p->name, ".got") == 0)
2213 return FALSE;
2214
2215 return _bfd_elf_link_omit_section_dynsym (output_bfd, info, p);
2216 }
2217
2218 /* Set the sizes of the dynamic sections. */
2219
2220 #define ELF32_DYNAMIC_INTERPRETER "/lib/ld.so.1"
2221
2222 static bfd_boolean
2223 tilepro_elf_size_dynamic_sections (bfd *output_bfd,
2224 struct bfd_link_info *info)
2225 {
2226 (void)output_bfd;
2227
2228 struct tilepro_elf_link_hash_table *htab;
2229 bfd *dynobj;
2230 asection *s;
2231 bfd *ibfd;
2232
2233 htab = tilepro_elf_hash_table (info);
2234 BFD_ASSERT (htab != NULL);
2235 dynobj = htab->elf.dynobj;
2236 BFD_ASSERT (dynobj != NULL);
2237
2238 if (elf_hash_table (info)->dynamic_sections_created)
2239 {
2240 /* Set the contents of the .interp section to the interpreter. */
2241 if (info->executable)
2242 {
2243 s = bfd_get_section_by_name (dynobj, ".interp");
2244 BFD_ASSERT (s != NULL);
2245 s->size = sizeof ELF32_DYNAMIC_INTERPRETER;
2246 s->contents = (unsigned char *) ELF32_DYNAMIC_INTERPRETER;
2247 }
2248 }
2249
2250 /* Set up .got offsets for local syms, and space for local dynamic
2251 relocs. */
2252 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2253 {
2254 bfd_signed_vma *local_got;
2255 bfd_signed_vma *end_local_got;
2256 char *local_tls_type;
2257 bfd_size_type locsymcount;
2258 Elf_Internal_Shdr *symtab_hdr;
2259 asection *srel;
2260
2261 if (! is_tilepro_elf (ibfd))
2262 continue;
2263
2264 for (s = ibfd->sections; s != NULL; s = s->next)
2265 {
2266 struct tilepro_elf_dyn_relocs *p;
2267
2268 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
2269 {
2270 if (!bfd_is_abs_section (p->sec)
2271 && bfd_is_abs_section (p->sec->output_section))
2272 {
2273 /* Input section has been discarded, either because
2274 it is a copy of a linkonce section or due to
2275 linker script /DISCARD/, so we'll be discarding
2276 the relocs too. */
2277 }
2278 else if (p->count != 0)
2279 {
2280 srel = elf_section_data (p->sec)->sreloc;
2281 srel->size += p->count * TILEPRO_ELF_RELA_BYTES;
2282 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2283 info->flags |= DF_TEXTREL;
2284 }
2285 }
2286 }
2287
2288 local_got = elf_local_got_refcounts (ibfd);
2289 if (!local_got)
2290 continue;
2291
2292 symtab_hdr = &elf_symtab_hdr (ibfd);
2293 locsymcount = symtab_hdr->sh_info;
2294 end_local_got = local_got + locsymcount;
2295 local_tls_type = _bfd_tilepro_elf_local_got_tls_type (ibfd);
2296 s = htab->elf.sgot;
2297 srel = htab->elf.srelgot;
2298 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
2299 {
2300 if (*local_got > 0)
2301 {
2302 *local_got = s->size;
2303 s->size += TILEPRO_BYTES_PER_WORD;
2304 if (*local_tls_type == GOT_TLS_GD)
2305 s->size += TILEPRO_BYTES_PER_WORD;
2306 if (info->shared
2307 || *local_tls_type == GOT_TLS_GD
2308 || *local_tls_type == GOT_TLS_IE)
2309 srel->size += TILEPRO_ELF_RELA_BYTES;
2310 }
2311 else
2312 *local_got = (bfd_vma) -1;
2313 }
2314 }
2315
2316 /* Allocate global sym .plt and .got entries, and space for global
2317 sym dynamic relocs. */
2318 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
2319
2320 if (elf_hash_table (info)->dynamic_sections_created)
2321 {
2322 /* If the .got section is more than 0x8000 bytes, we add
2323 0x8000 to the value of _GLOBAL_OFFSET_TABLE_, so that 16
2324 bit relocations have a greater chance of working. */
2325 if (htab->elf.sgot->size >= 0x8000
2326 && elf_hash_table (info)->hgot->root.u.def.value == 0)
2327 elf_hash_table (info)->hgot->root.u.def.value = 0x8000;
2328 }
2329
2330 if (htab->elf.sgotplt)
2331 {
2332 struct elf_link_hash_entry *got;
2333 got = elf_link_hash_lookup (elf_hash_table (info),
2334 "_GLOBAL_OFFSET_TABLE_",
2335 FALSE, FALSE, FALSE);
2336
2337 /* Don't allocate .got.plt section if there are no GOT nor PLT
2338 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
2339 if ((got == NULL
2340 || !got->ref_regular_nonweak)
2341 && (htab->elf.sgotplt->size
2342 == GOTPLT_HEADER_SIZE)
2343 && (htab->elf.splt == NULL
2344 || htab->elf.splt->size == 0)
2345 && (htab->elf.sgot == NULL
2346 || (htab->elf.sgot->size
2347 == get_elf_backend_data (output_bfd)->got_header_size)))
2348 htab->elf.sgotplt->size = 0;
2349 }
2350
2351 /* The check_relocs and adjust_dynamic_symbol entry points have
2352 determined the sizes of the various dynamic sections. Allocate
2353 memory for them. */
2354 for (s = dynobj->sections; s != NULL; s = s->next)
2355 {
2356 if ((s->flags & SEC_LINKER_CREATED) == 0)
2357 continue;
2358
2359 if (s == htab->elf.splt
2360 || s == htab->elf.sgot
2361 || s == htab->elf.sgotplt
2362 || s == htab->sdynbss)
2363 {
2364 /* Strip this section if we don't need it; see the
2365 comment below. */
2366 }
2367 else if (strncmp (s->name, ".rela", 5) == 0)
2368 {
2369 if (s->size != 0)
2370 {
2371 /* We use the reloc_count field as a counter if we need
2372 to copy relocs into the output file. */
2373 s->reloc_count = 0;
2374 }
2375 }
2376 else
2377 {
2378 /* It's not one of our sections. */
2379 continue;
2380 }
2381
2382 if (s->size == 0)
2383 {
2384 /* If we don't need this section, strip it from the
2385 output file. This is mostly to handle .rela.bss and
2386 .rela.plt. We must create both sections in
2387 create_dynamic_sections, because they must be created
2388 before the linker maps input sections to output
2389 sections. The linker does that before
2390 adjust_dynamic_symbol is called, and it is that
2391 function which decides whether anything needs to go
2392 into these sections. */
2393 s->flags |= SEC_EXCLUDE;
2394 continue;
2395 }
2396
2397 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2398 continue;
2399
2400 /* Allocate memory for the section contents. Zero the memory
2401 for the benefit of .rela.plt, which has 4 unused entries
2402 at the beginning, and we don't want garbage. */
2403 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2404 if (s->contents == NULL)
2405 return FALSE;
2406 }
2407
2408 if (elf_hash_table (info)->dynamic_sections_created)
2409 {
2410 /* Add some entries to the .dynamic section. We fill in the
2411 values later, in tilepro_elf_finish_dynamic_sections, but we
2412 must add the entries now so that we get the correct size for
2413 the .dynamic section. The DT_DEBUG entry is filled in by the
2414 dynamic linker and used by the debugger. */
2415 #define add_dynamic_entry(TAG, VAL) \
2416 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2417
2418 if (info->executable)
2419 {
2420 if (!add_dynamic_entry (DT_DEBUG, 0))
2421 return FALSE;
2422 }
2423
2424 if (htab->elf.srelplt->size != 0)
2425 {
2426 if (!add_dynamic_entry (DT_PLTGOT, 0)
2427 || !add_dynamic_entry (DT_PLTRELSZ, 0)
2428 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2429 || !add_dynamic_entry (DT_JMPREL, 0))
2430 return FALSE;
2431 }
2432
2433 if (!add_dynamic_entry (DT_RELA, 0)
2434 || !add_dynamic_entry (DT_RELASZ, 0)
2435 || !add_dynamic_entry (DT_RELAENT, TILEPRO_ELF_RELA_BYTES))
2436 return FALSE;
2437
2438 /* If any dynamic relocs apply to a read-only section,
2439 then we need a DT_TEXTREL entry. */
2440 if ((info->flags & DF_TEXTREL) == 0)
2441 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
2442 (PTR) info);
2443
2444 if (info->flags & DF_TEXTREL)
2445 {
2446 if (!add_dynamic_entry (DT_TEXTREL, 0))
2447 return FALSE;
2448 }
2449 }
2450 #undef add_dynamic_entry
2451
2452 return TRUE;
2453 }
2454 \f
2455 /* Return the base VMA address which should be subtracted from real addresses
2456 when resolving @dtpoff relocation.
2457 This is PT_TLS segment p_vaddr. */
2458
2459 static bfd_vma
2460 dtpoff_base (struct bfd_link_info *info)
2461 {
2462 /* If tls_sec is NULL, we should have signalled an error already. */
2463 if (elf_hash_table (info)->tls_sec == NULL)
2464 return 0;
2465 return elf_hash_table (info)->tls_sec->vma;
2466 }
2467
2468 /* Return the relocation value for R_TILEPRO_TLS_TPOFF32. */
2469
2470 static bfd_vma
2471 tpoff (struct bfd_link_info *info, bfd_vma address)
2472 {
2473 struct elf_link_hash_table *htab = elf_hash_table (info);
2474
2475 /* If tls_sec is NULL, we should have signalled an error already. */
2476 if (htab->tls_sec == NULL)
2477 return 0;
2478
2479 return (address - htab->tls_sec->vma);
2480 }
2481
2482 /* Relocate an TILEPRO ELF section.
2483
2484 The RELOCATE_SECTION function is called by the new ELF backend linker
2485 to handle the relocations for a section.
2486
2487 The relocs are always passed as Rela structures.
2488
2489 This function is responsible for adjusting the section contents as
2490 necessary, and (if generating a relocatable output file) adjusting
2491 the reloc addend as necessary.
2492
2493 This function does not have to worry about setting the reloc
2494 address or the reloc symbol index.
2495
2496 LOCAL_SYMS is a pointer to the swapped in local symbols.
2497
2498 LOCAL_SECTIONS is an array giving the section in the input file
2499 corresponding to the st_shndx field of each local symbol.
2500
2501 The global hash table entry for the global symbols can be found
2502 via elf_sym_hashes (input_bfd).
2503
2504 When generating relocatable output, this function must handle
2505 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
2506 going to be the section symbol corresponding to the output
2507 section, which means that the addend must be adjusted
2508 accordingly. */
2509
2510 static bfd_boolean
2511 tilepro_elf_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
2512 bfd *input_bfd, asection *input_section,
2513 bfd_byte *contents, Elf_Internal_Rela *relocs,
2514 Elf_Internal_Sym *local_syms,
2515 asection **local_sections)
2516 {
2517 struct tilepro_elf_link_hash_table *htab;
2518 Elf_Internal_Shdr *symtab_hdr;
2519 struct elf_link_hash_entry **sym_hashes;
2520 bfd_vma *local_got_offsets;
2521 bfd_vma got_base;
2522 asection *sreloc;
2523 Elf_Internal_Rela *rel;
2524 Elf_Internal_Rela *relend;
2525 int num_relocs;
2526
2527 htab = tilepro_elf_hash_table (info);
2528 BFD_ASSERT (htab != NULL);
2529 symtab_hdr = &elf_symtab_hdr (input_bfd);
2530 sym_hashes = elf_sym_hashes (input_bfd);
2531 local_got_offsets = elf_local_got_offsets (input_bfd);
2532
2533 if (elf_hash_table (info)->hgot == NULL)
2534 got_base = 0;
2535 else
2536 got_base = elf_hash_table (info)->hgot->root.u.def.value;
2537
2538 sreloc = elf_section_data (input_section)->sreloc;
2539
2540 rel = relocs;
2541 num_relocs = input_section->reloc_count;
2542 relend = relocs + num_relocs;
2543 for (; rel < relend; rel++)
2544 {
2545 int r_type, tls_type;
2546 reloc_howto_type *howto;
2547 unsigned long r_symndx;
2548 struct elf_link_hash_entry *h;
2549 Elf_Internal_Sym *sym;
2550 tilepro_create_func create_func;
2551 asection *sec;
2552 bfd_vma relocation;
2553 bfd_reloc_status_type r;
2554 const char *name;
2555 bfd_vma off;
2556 bfd_boolean is_plt = FALSE;
2557
2558 bfd_boolean unresolved_reloc;
2559
2560 r_type = ELF32_R_TYPE (rel->r_info);
2561 if (r_type == R_TILEPRO_GNU_VTINHERIT
2562 || r_type == R_TILEPRO_GNU_VTENTRY)
2563 continue;
2564
2565 if ((unsigned int)r_type >= NELEMS(tilepro_elf_howto_table))
2566 {
2567 /* Not clear if we need to check here, but just be paranoid. */
2568 (*_bfd_error_handler)
2569 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
2570 input_bfd, r_type, input_section);
2571 bfd_set_error (bfd_error_bad_value);
2572 return FALSE;
2573 }
2574
2575 howto = tilepro_elf_howto_table + r_type;
2576
2577 /* This is a final link. */
2578 r_symndx = ELF32_R_SYM (rel->r_info);
2579 h = NULL;
2580 sym = NULL;
2581 sec = NULL;
2582 unresolved_reloc = FALSE;
2583 if (r_symndx < symtab_hdr->sh_info)
2584 {
2585 sym = local_syms + r_symndx;
2586 sec = local_sections[r_symndx];
2587 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2588 }
2589 else
2590 {
2591 bfd_boolean warned;
2592
2593 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2594 r_symndx, symtab_hdr, sym_hashes,
2595 h, sec, relocation,
2596 unresolved_reloc, warned);
2597 if (warned)
2598 {
2599 /* To avoid generating warning messages about truncated
2600 relocations, set the relocation's address to be the same as
2601 the start of this section. */
2602 if (input_section->output_section != NULL)
2603 relocation = input_section->output_section->vma;
2604 else
2605 relocation = 0;
2606 }
2607 }
2608
2609 if (sec != NULL && elf_discarded_section (sec))
2610 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
2611 rel, relend, howto, contents);
2612
2613 if (info->relocatable)
2614 continue;
2615
2616 if (h != NULL)
2617 name = h->root.root.string;
2618 else
2619 {
2620 name = (bfd_elf_string_from_elf_section
2621 (input_bfd, symtab_hdr->sh_link, sym->st_name));
2622 if (name == NULL || *name == '\0')
2623 name = bfd_section_name (input_bfd, sec);
2624 }
2625
2626 switch (r_type)
2627 {
2628 case R_TILEPRO_IMM16_X0_GOT:
2629 case R_TILEPRO_IMM16_X1_GOT:
2630 case R_TILEPRO_IMM16_X0_GOT_LO:
2631 case R_TILEPRO_IMM16_X1_GOT_LO:
2632 case R_TILEPRO_IMM16_X0_GOT_HI:
2633 case R_TILEPRO_IMM16_X1_GOT_HI:
2634 case R_TILEPRO_IMM16_X0_GOT_HA:
2635 case R_TILEPRO_IMM16_X1_GOT_HA:
2636 /* Relocation is to the entry for this symbol in the global
2637 offset table. */
2638 if (htab->elf.sgot == NULL)
2639 abort ();
2640
2641 if (h != NULL)
2642 {
2643 bfd_boolean dyn;
2644
2645 off = h->got.offset;
2646 BFD_ASSERT (off != (bfd_vma) -1);
2647 dyn = elf_hash_table (info)->dynamic_sections_created;
2648
2649 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2650 || (info->shared
2651 && SYMBOL_REFERENCES_LOCAL (info, h)))
2652 {
2653 /* This is actually a static link, or it is a
2654 -Bsymbolic link and the symbol is defined
2655 locally, or the symbol was forced to be local
2656 because of a version file. We must initialize
2657 this entry in the global offset table. Since the
2658 offset must always be a multiple
2659 of 4 for 32-bit, we use the least significant bit
2660 to record whether we have initialized it already.
2661
2662 When doing a dynamic link, we create a .rela.got
2663 relocation entry to initialize the value. This
2664 is done in the finish_dynamic_symbol routine. */
2665 if ((off & 1) != 0)
2666 off &= ~1;
2667 else
2668 {
2669 bfd_put_32 (output_bfd, relocation,
2670 htab->elf.sgot->contents + off);
2671 h->got.offset |= 1;
2672 }
2673 }
2674 else
2675 unresolved_reloc = FALSE;
2676 }
2677 else
2678 {
2679 BFD_ASSERT (local_got_offsets != NULL
2680 && local_got_offsets[r_symndx] != (bfd_vma) -1);
2681
2682 off = local_got_offsets[r_symndx];
2683
2684 /* The offset must always be a multiple of 4 on 32-bit.
2685 We use the least significant bit to record
2686 whether we have already processed this entry. */
2687 if ((off & 1) != 0)
2688 off &= ~1;
2689 else
2690 {
2691 if (info->shared)
2692 {
2693 asection *s;
2694 Elf_Internal_Rela outrel;
2695
2696 /* We need to generate a R_TILEPRO_RELATIVE reloc
2697 for the dynamic linker. */
2698 s = htab->elf.srelgot;
2699 BFD_ASSERT (s != NULL);
2700
2701 outrel.r_offset = (htab->elf.sgot->output_section->vma
2702 + htab->elf.sgot->output_offset
2703 + off);
2704 outrel.r_info = ELF32_R_INFO (0, R_TILEPRO_RELATIVE);
2705 outrel.r_addend = relocation;
2706 relocation = 0;
2707 tilepro_elf_append_rela_32 (output_bfd, s, &outrel);
2708 }
2709
2710 bfd_put_32 (output_bfd, relocation,
2711 htab->elf.sgot->contents + off);
2712 local_got_offsets[r_symndx] |= 1;
2713 }
2714 }
2715 relocation = htab->elf.sgot->output_offset + off - got_base;
2716 break;
2717
2718 case R_TILEPRO_JOFFLONG_X1_PLT:
2719 /* Relocation is to the entry for this symbol in the
2720 procedure linkage table. */
2721 BFD_ASSERT (h != NULL);
2722
2723 if (h->plt.offset == (bfd_vma) -1 || htab->elf.splt == NULL)
2724 {
2725 /* We didn't make a PLT entry for this symbol. This
2726 happens when statically linking PIC code, or when
2727 using -Bsymbolic. */
2728 break;
2729 }
2730
2731 relocation = (htab->elf.splt->output_section->vma
2732 + htab->elf.splt->output_offset
2733 + h->plt.offset);
2734 unresolved_reloc = FALSE;
2735 break;
2736
2737 case R_TILEPRO_32_PCREL:
2738 case R_TILEPRO_16_PCREL:
2739 case R_TILEPRO_8_PCREL:
2740 case R_TILEPRO_IMM16_X0_PCREL:
2741 case R_TILEPRO_IMM16_X1_PCREL:
2742 case R_TILEPRO_IMM16_X0_LO_PCREL:
2743 case R_TILEPRO_IMM16_X1_LO_PCREL:
2744 case R_TILEPRO_IMM16_X0_HI_PCREL:
2745 case R_TILEPRO_IMM16_X1_HI_PCREL:
2746 case R_TILEPRO_IMM16_X0_HA_PCREL:
2747 case R_TILEPRO_IMM16_X1_HA_PCREL:
2748 if (h != NULL
2749 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2750 break;
2751 /* Fall through. */
2752 case R_TILEPRO_32:
2753 case R_TILEPRO_16:
2754 case R_TILEPRO_8:
2755 case R_TILEPRO_LO16:
2756 case R_TILEPRO_HI16:
2757 case R_TILEPRO_HA16:
2758 case R_TILEPRO_COPY:
2759 case R_TILEPRO_GLOB_DAT:
2760 case R_TILEPRO_JMP_SLOT:
2761 case R_TILEPRO_RELATIVE:
2762 case R_TILEPRO_BROFF_X1:
2763 case R_TILEPRO_JOFFLONG_X1:
2764 case R_TILEPRO_IMM8_X0:
2765 case R_TILEPRO_IMM8_Y0:
2766 case R_TILEPRO_IMM8_X1:
2767 case R_TILEPRO_IMM8_Y1:
2768 case R_TILEPRO_DEST_IMM8_X1:
2769 case R_TILEPRO_MT_IMM15_X1:
2770 case R_TILEPRO_MF_IMM15_X1:
2771 case R_TILEPRO_IMM16_X0:
2772 case R_TILEPRO_IMM16_X1:
2773 case R_TILEPRO_IMM16_X0_LO:
2774 case R_TILEPRO_IMM16_X1_LO:
2775 case R_TILEPRO_IMM16_X0_HI:
2776 case R_TILEPRO_IMM16_X1_HI:
2777 case R_TILEPRO_IMM16_X0_HA:
2778 case R_TILEPRO_IMM16_X1_HA:
2779 case R_TILEPRO_MMSTART_X0:
2780 case R_TILEPRO_MMEND_X0:
2781 case R_TILEPRO_MMSTART_X1:
2782 case R_TILEPRO_MMEND_X1:
2783 case R_TILEPRO_SHAMT_X0:
2784 case R_TILEPRO_SHAMT_X1:
2785 case R_TILEPRO_SHAMT_Y0:
2786 case R_TILEPRO_SHAMT_Y1:
2787 if ((input_section->flags & SEC_ALLOC) == 0)
2788 break;
2789
2790 if ((info->shared
2791 && (h == NULL
2792 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2793 || h->root.type != bfd_link_hash_undefweak)
2794 && (! howto->pc_relative
2795 || !SYMBOL_CALLS_LOCAL (info, h)))
2796 || (!info->shared
2797 && h != NULL
2798 && h->dynindx != -1
2799 && !h->non_got_ref
2800 && ((h->def_dynamic
2801 && !h->def_regular)
2802 || h->root.type == bfd_link_hash_undefweak
2803 || h->root.type == bfd_link_hash_undefined)))
2804 {
2805 Elf_Internal_Rela outrel;
2806 bfd_boolean skip, relocate = FALSE;
2807
2808 /* When generating a shared object, these relocations
2809 are copied into the output file to be resolved at run
2810 time. */
2811
2812 BFD_ASSERT (sreloc != NULL);
2813
2814 skip = FALSE;
2815
2816 outrel.r_offset =
2817 _bfd_elf_section_offset (output_bfd, info, input_section,
2818 rel->r_offset);
2819 if (outrel.r_offset == (bfd_vma) -1)
2820 skip = TRUE;
2821 else if (outrel.r_offset == (bfd_vma) -2)
2822 skip = TRUE, relocate = TRUE;
2823 outrel.r_offset += (input_section->output_section->vma
2824 + input_section->output_offset);
2825
2826 switch (r_type)
2827 {
2828 case R_TILEPRO_32_PCREL:
2829 case R_TILEPRO_16_PCREL:
2830 case R_TILEPRO_8_PCREL:
2831 /* If the symbol is not dynamic, we should not keep
2832 a dynamic relocation. But an .rela.* slot has been
2833 allocated for it, output R_TILEPRO_NONE.
2834 FIXME: Add code tracking needed dynamic relocs as
2835 e.g. i386 has. */
2836 if (h->dynindx == -1)
2837 skip = TRUE, relocate = TRUE;
2838 break;
2839 }
2840
2841 if (skip)
2842 memset (&outrel, 0, sizeof outrel);
2843 /* h->dynindx may be -1 if the symbol was marked to
2844 become local. */
2845 else if (h != NULL &&
2846 h->dynindx != -1
2847 && (! is_plt
2848 || !info->shared
2849 || !SYMBOLIC_BIND (info, h)
2850 || !h->def_regular))
2851 {
2852 BFD_ASSERT (h->dynindx != -1);
2853 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2854 outrel.r_addend = rel->r_addend;
2855 }
2856 else
2857 {
2858 if (r_type == R_TILEPRO_32)
2859 {
2860 outrel.r_info = ELF32_R_INFO (0, R_TILEPRO_RELATIVE);
2861 outrel.r_addend = relocation + rel->r_addend;
2862 }
2863 else
2864 {
2865 long indx;
2866
2867 outrel.r_addend = relocation + rel->r_addend;
2868
2869 if (is_plt)
2870 sec = htab->elf.splt;
2871
2872 if (bfd_is_abs_section (sec))
2873 indx = 0;
2874 else if (sec == NULL || sec->owner == NULL)
2875 {
2876 bfd_set_error (bfd_error_bad_value);
2877 return FALSE;
2878 }
2879 else
2880 {
2881 asection *osec;
2882
2883 /* We are turning this relocation into one
2884 against a section symbol. It would be
2885 proper to subtract the symbol's value,
2886 osec->vma, from the emitted reloc addend,
2887 but ld.so expects buggy relocs. */
2888 osec = sec->output_section;
2889 indx = elf_section_data (osec)->dynindx;
2890
2891 if (indx == 0)
2892 {
2893 osec = htab->elf.text_index_section;
2894 indx = elf_section_data (osec)->dynindx;
2895 }
2896
2897 /* FIXME: we really should be able to link non-pic
2898 shared libraries. */
2899 if (indx == 0)
2900 {
2901 BFD_FAIL ();
2902 (*_bfd_error_handler)
2903 (_("%B: probably compiled without -fPIC?"),
2904 input_bfd);
2905 bfd_set_error (bfd_error_bad_value);
2906 return FALSE;
2907 }
2908 }
2909
2910 outrel.r_info = ELF32_R_INFO (indx, r_type);
2911 }
2912 }
2913
2914 tilepro_elf_append_rela_32 (output_bfd, sreloc, &outrel);
2915
2916 /* This reloc will be computed at runtime, so there's no
2917 need to do anything now. */
2918 if (! relocate)
2919 continue;
2920 }
2921 break;
2922
2923 case R_TILEPRO_IMM16_X0_TLS_GD:
2924 case R_TILEPRO_IMM16_X1_TLS_GD:
2925 case R_TILEPRO_IMM16_X0_TLS_GD_LO:
2926 case R_TILEPRO_IMM16_X1_TLS_GD_LO:
2927 case R_TILEPRO_IMM16_X0_TLS_GD_HI:
2928 case R_TILEPRO_IMM16_X1_TLS_GD_HI:
2929 case R_TILEPRO_IMM16_X0_TLS_GD_HA:
2930 case R_TILEPRO_IMM16_X1_TLS_GD_HA:
2931 tls_type = GOT_TLS_GD;
2932 goto have_tls_reference;
2933
2934 case R_TILEPRO_IMM16_X0_TLS_IE:
2935 case R_TILEPRO_IMM16_X1_TLS_IE:
2936 case R_TILEPRO_IMM16_X0_TLS_IE_LO:
2937 case R_TILEPRO_IMM16_X1_TLS_IE_LO:
2938 case R_TILEPRO_IMM16_X0_TLS_IE_HI:
2939 case R_TILEPRO_IMM16_X1_TLS_IE_HI:
2940 case R_TILEPRO_IMM16_X0_TLS_IE_HA:
2941 case R_TILEPRO_IMM16_X1_TLS_IE_HA:
2942 tls_type = GOT_TLS_IE;
2943 /* Fall through. */
2944
2945 have_tls_reference:
2946 if (h == NULL && local_got_offsets)
2947 tls_type
2948 = _bfd_tilepro_elf_local_got_tls_type (input_bfd) [r_symndx];
2949 else if (h != NULL)
2950 {
2951 tls_type = tilepro_elf_hash_entry(h)->tls_type;
2952 }
2953 if (tls_type == GOT_TLS_IE)
2954 switch (r_type)
2955 {
2956 case R_TILEPRO_IMM16_X0_TLS_GD:
2957 r_type = R_TILEPRO_IMM16_X0_TLS_IE;
2958 break;
2959 case R_TILEPRO_IMM16_X1_TLS_GD:
2960 r_type = R_TILEPRO_IMM16_X1_TLS_IE;
2961 break;
2962 case R_TILEPRO_IMM16_X0_TLS_GD_LO:
2963 r_type = R_TILEPRO_IMM16_X0_TLS_IE_LO;
2964 break;
2965 case R_TILEPRO_IMM16_X1_TLS_GD_LO:
2966 r_type = R_TILEPRO_IMM16_X1_TLS_IE_LO;
2967 break;
2968 case R_TILEPRO_IMM16_X0_TLS_GD_HI:
2969 r_type = R_TILEPRO_IMM16_X0_TLS_IE_HI;
2970 break;
2971 case R_TILEPRO_IMM16_X1_TLS_GD_HI:
2972 r_type = R_TILEPRO_IMM16_X1_TLS_IE_HI;
2973 break;
2974 case R_TILEPRO_IMM16_X0_TLS_GD_HA:
2975 r_type = R_TILEPRO_IMM16_X0_TLS_IE_HA;
2976 break;
2977 case R_TILEPRO_IMM16_X1_TLS_GD_HA:
2978 r_type = R_TILEPRO_IMM16_X1_TLS_IE_HA;
2979 break;
2980 }
2981
2982 if (h != NULL)
2983 {
2984 off = h->got.offset;
2985 h->got.offset |= 1;
2986 }
2987 else
2988 {
2989 BFD_ASSERT (local_got_offsets != NULL);
2990 off = local_got_offsets[r_symndx];
2991 local_got_offsets[r_symndx] |= 1;
2992 }
2993
2994 if (htab->elf.sgot == NULL)
2995 abort ();
2996
2997 if ((off & 1) != 0)
2998 off &= ~1;
2999 else
3000 {
3001 Elf_Internal_Rela outrel;
3002 int indx = 0;
3003 bfd_boolean need_relocs = FALSE;
3004
3005 if (htab->elf.srelgot == NULL)
3006 abort ();
3007
3008 if (h != NULL)
3009 {
3010 bfd_boolean dyn;
3011 dyn = htab->elf.dynamic_sections_created;
3012
3013 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3014 && (!info->shared
3015 || !SYMBOL_REFERENCES_LOCAL (info, h)))
3016 {
3017 indx = h->dynindx;
3018 }
3019 }
3020
3021 /* The GOT entries have not been initialized yet. Do it
3022 now, and emit any relocations. */
3023 if ((info->shared || indx != 0)
3024 && (h == NULL
3025 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3026 || h->root.type != bfd_link_hash_undefweak))
3027 need_relocs = TRUE;
3028
3029 switch (r_type)
3030 {
3031 case R_TILEPRO_IMM16_X0_TLS_IE:
3032 case R_TILEPRO_IMM16_X1_TLS_IE:
3033 case R_TILEPRO_IMM16_X0_TLS_IE_LO:
3034 case R_TILEPRO_IMM16_X1_TLS_IE_LO:
3035 case R_TILEPRO_IMM16_X0_TLS_IE_HI:
3036 case R_TILEPRO_IMM16_X1_TLS_IE_HI:
3037 case R_TILEPRO_IMM16_X0_TLS_IE_HA:
3038 case R_TILEPRO_IMM16_X1_TLS_IE_HA:
3039 if (need_relocs) {
3040 bfd_put_32 (output_bfd, 0, htab->elf.sgot->contents + off);
3041 outrel.r_offset = (htab->elf.sgot->output_section->vma
3042 + htab->elf.sgot->output_offset + off);
3043 outrel.r_addend = 0;
3044 if (indx == 0)
3045 outrel.r_addend = relocation - dtpoff_base (info);
3046 outrel.r_info = ELF32_R_INFO (indx, R_TILEPRO_TLS_TPOFF32);
3047 tilepro_elf_append_rela_32 (output_bfd, htab->elf.srelgot,
3048 &outrel);
3049 } else {
3050 bfd_put_32 (output_bfd, tpoff (info, relocation),
3051 htab->elf.sgot->contents + off);
3052 }
3053 break;
3054
3055 case R_TILEPRO_IMM16_X0_TLS_GD:
3056 case R_TILEPRO_IMM16_X1_TLS_GD:
3057 case R_TILEPRO_IMM16_X0_TLS_GD_LO:
3058 case R_TILEPRO_IMM16_X1_TLS_GD_LO:
3059 case R_TILEPRO_IMM16_X0_TLS_GD_HI:
3060 case R_TILEPRO_IMM16_X1_TLS_GD_HI:
3061 case R_TILEPRO_IMM16_X0_TLS_GD_HA:
3062 case R_TILEPRO_IMM16_X1_TLS_GD_HA:
3063 if (need_relocs) {
3064 outrel.r_offset = (htab->elf.sgot->output_section->vma
3065 + htab->elf.sgot->output_offset + off);
3066 outrel.r_addend = 0;
3067 outrel.r_info = ELF32_R_INFO (indx, R_TILEPRO_TLS_DTPMOD32);
3068 bfd_put_32 (output_bfd, 0, htab->elf.sgot->contents + off);
3069 tilepro_elf_append_rela_32 (output_bfd, htab->elf.srelgot,
3070 &outrel);
3071 if (indx == 0)
3072 {
3073 BFD_ASSERT (! unresolved_reloc);
3074 bfd_put_32 (output_bfd,
3075 relocation - dtpoff_base (info),
3076 (htab->elf.sgot->contents + off +
3077 TILEPRO_BYTES_PER_WORD));
3078 }
3079 else
3080 {
3081 bfd_put_32 (output_bfd, 0,
3082 (htab->elf.sgot->contents + off +
3083 TILEPRO_BYTES_PER_WORD));
3084 outrel.r_info = ELF32_R_INFO (indx,
3085 R_TILEPRO_TLS_DTPOFF32);
3086 outrel.r_offset += TILEPRO_BYTES_PER_WORD;
3087 tilepro_elf_append_rela_32 (output_bfd,
3088 htab->elf.srelgot, &outrel);
3089 }
3090 }
3091
3092 else {
3093 /* If we are not emitting relocations for a
3094 general dynamic reference, then we must be in a
3095 static link or an executable link with the
3096 symbol binding locally. Mark it as belonging
3097 to module 1, the executable. */
3098 bfd_put_32 (output_bfd, 1,
3099 htab->elf.sgot->contents + off );
3100 bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
3101 htab->elf.sgot->contents + off +
3102 TILEPRO_BYTES_PER_WORD);
3103 }
3104 break;
3105 }
3106 }
3107
3108 if (off >= (bfd_vma) -2)
3109 abort ();
3110
3111 relocation = htab->elf.sgot->output_offset + off - got_base;
3112 unresolved_reloc = FALSE;
3113 howto = tilepro_elf_howto_table + r_type;
3114 break;
3115
3116 default:
3117 break;
3118 }
3119
3120 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3121 because such sections are not SEC_ALLOC and thus ld.so will
3122 not process them. */
3123 if (unresolved_reloc
3124 && !((input_section->flags & SEC_DEBUGGING) != 0
3125 && h->def_dynamic))
3126 (*_bfd_error_handler)
3127 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3128 input_bfd,
3129 input_section,
3130 (long) rel->r_offset,
3131 howto->name,
3132 h->root.root.string);
3133
3134 r = bfd_reloc_continue;
3135
3136 /* For the _HA types, we add 0x8000 so that if bit 15 is set,
3137 * we will increment bit 16. The howto->rightshift takes care
3138 * of the rest for us. */
3139 switch (r_type)
3140 {
3141 case R_TILEPRO_HA16:
3142 case R_TILEPRO_IMM16_X0_HA:
3143 case R_TILEPRO_IMM16_X1_HA:
3144 case R_TILEPRO_IMM16_X0_HA_PCREL:
3145 case R_TILEPRO_IMM16_X1_HA_PCREL:
3146 case R_TILEPRO_IMM16_X0_GOT_HA:
3147 case R_TILEPRO_IMM16_X1_GOT_HA:
3148 case R_TILEPRO_IMM16_X0_TLS_GD_HA:
3149 case R_TILEPRO_IMM16_X1_TLS_GD_HA:
3150 case R_TILEPRO_IMM16_X0_TLS_IE_HA:
3151 case R_TILEPRO_IMM16_X1_TLS_IE_HA:
3152 relocation += 0x8000;
3153 break;
3154 }
3155
3156 /* Get the operand creation function, if any. */
3157 create_func = reloc_to_create_func[r_type];
3158 if (create_func == NULL)
3159 {
3160 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3161 contents, rel->r_offset,
3162 relocation, rel->r_addend);
3163 }
3164 else
3165 {
3166 if (howto->pc_relative)
3167 {
3168 relocation -=
3169 input_section->output_section->vma + input_section->output_offset;
3170 if (howto->pcrel_offset)
3171 relocation -= rel->r_offset;
3172 }
3173
3174 bfd_byte *data;
3175
3176 /* Add the relocation addend if any to the final target value */
3177 relocation += rel->r_addend;
3178
3179 /* Do basic range checking */
3180 r = bfd_check_overflow (howto->complain_on_overflow,
3181 howto->bitsize,
3182 howto->rightshift,
3183 32,
3184 relocation);
3185
3186 /*
3187 * Write the relocated value out into the raw section data.
3188 * Don't put a relocation out in the .rela section.
3189 */
3190 tilepro_bundle_bits mask = create_func(-1);
3191 tilepro_bundle_bits value = create_func(relocation >> howto->rightshift);
3192
3193 /* Only touch bytes while the mask is not 0, so we
3194 don't write to out of bounds memory if this is actually
3195 a 16-bit switch instruction. */
3196 for (data = contents + rel->r_offset; mask != 0; data++)
3197 {
3198 bfd_byte byte_mask = (bfd_byte)mask;
3199 *data = (*data & ~byte_mask) | ((bfd_byte)value & byte_mask);
3200 mask >>= 8;
3201 value >>= 8;
3202 }
3203 }
3204
3205 if (r != bfd_reloc_ok)
3206 {
3207 const char *msg = NULL;
3208
3209 switch (r)
3210 {
3211 case bfd_reloc_overflow:
3212 r = info->callbacks->reloc_overflow
3213 (info, (h ? &h->root : NULL), name, howto->name,
3214 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
3215 break;
3216
3217 case bfd_reloc_undefined:
3218 r = info->callbacks->undefined_symbol
3219 (info, name, input_bfd, input_section, rel->r_offset,
3220 TRUE);
3221 break;
3222
3223 case bfd_reloc_outofrange:
3224 msg = _("internal error: out of range error");
3225 break;
3226
3227 case bfd_reloc_notsupported:
3228 msg = _("internal error: unsupported relocation error");
3229 break;
3230
3231 case bfd_reloc_dangerous:
3232 msg = _("internal error: dangerous relocation");
3233 break;
3234
3235 default:
3236 msg = _("internal error: unknown error");
3237 break;
3238 }
3239
3240 if (msg)
3241 r = info->callbacks->warning
3242 (info, msg, name, input_bfd, input_section, rel->r_offset);
3243
3244 if (! r)
3245 return FALSE;
3246 }
3247 }
3248
3249 return TRUE;
3250 }
3251
3252 /* Finish up dynamic symbol handling. We set the contents of various
3253 dynamic sections here. */
3254
3255 static bfd_boolean
3256 tilepro_elf_finish_dynamic_symbol (bfd *output_bfd,
3257 struct bfd_link_info *info,
3258 struct elf_link_hash_entry *h,
3259 Elf_Internal_Sym *sym)
3260 {
3261 struct tilepro_elf_link_hash_table *htab;
3262
3263 htab = tilepro_elf_hash_table (info);
3264 BFD_ASSERT (htab != NULL);
3265
3266 if (h->plt.offset != (bfd_vma) -1)
3267 {
3268 asection *splt;
3269 asection *srela;
3270 asection *sgotplt;
3271 Elf_Internal_Rela rela;
3272 bfd_byte *loc;
3273 bfd_vma r_offset;
3274
3275 int rela_index;
3276
3277 /* This symbol has an entry in the PLT. Set it up. */
3278
3279 BFD_ASSERT (h->dynindx != -1);
3280
3281 splt = htab->elf.splt;
3282 srela = htab->elf.srelplt;
3283 sgotplt = htab->elf.sgotplt;
3284
3285 if (splt == NULL || srela == NULL)
3286 abort ();
3287
3288 /* Fill in the entry in the procedure linkage table. */
3289 rela_index = tilepro_plt_entry_build (splt, sgotplt, h->plt.offset,
3290 &r_offset);
3291
3292 /* Fill in the entry in the global offset table, which initially points
3293 to the beginning of the plt. */
3294 bfd_put_32 (output_bfd, splt->output_section->vma + splt->output_offset,
3295 sgotplt->contents + r_offset);
3296
3297 /* Fill in the entry in the .rela.plt section. */
3298 rela.r_offset = (sgotplt->output_section->vma
3299 + sgotplt->output_offset
3300 + r_offset);
3301 rela.r_addend = 0;
3302 rela.r_info = ELF32_R_INFO (h->dynindx, R_TILEPRO_JMP_SLOT);
3303
3304 loc = srela->contents + rela_index * sizeof (Elf32_External_Rela);
3305 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3306
3307 if (!h->def_regular)
3308 {
3309 /* Mark the symbol as undefined, rather than as defined in
3310 the .plt section. Leave the value alone. */
3311 sym->st_shndx = SHN_UNDEF;
3312 /* If the symbol is weak, we do need to clear the value.
3313 Otherwise, the PLT entry would provide a definition for
3314 the symbol even if the symbol wasn't defined anywhere,
3315 and so the symbol would never be NULL. */
3316 if (!h->ref_regular_nonweak)
3317 sym->st_value = 0;
3318 }
3319 }
3320
3321 if (h->got.offset != (bfd_vma) -1
3322 && tilepro_elf_hash_entry(h)->tls_type != GOT_TLS_GD
3323 && tilepro_elf_hash_entry(h)->tls_type != GOT_TLS_IE)
3324 {
3325 asection *sgot;
3326 asection *srela;
3327 Elf_Internal_Rela rela;
3328
3329 /* This symbol has an entry in the GOT. Set it up. */
3330
3331 sgot = htab->elf.sgot;
3332 srela = htab->elf.srelgot;
3333 BFD_ASSERT (sgot != NULL && srela != NULL);
3334
3335 rela.r_offset = (sgot->output_section->vma
3336 + sgot->output_offset
3337 + (h->got.offset &~ (bfd_vma) 1));
3338
3339 /* If this is a -Bsymbolic link, and the symbol is defined
3340 locally, we just want to emit a RELATIVE reloc. Likewise if
3341 the symbol was forced to be local because of a version file.
3342 The entry in the global offset table will already have been
3343 initialized in the relocate_section function. */
3344 if (info->shared
3345 && (info->symbolic || h->dynindx == -1)
3346 && h->def_regular)
3347 {
3348 asection *sec = h->root.u.def.section;
3349 rela.r_info = ELF32_R_INFO (0, R_TILEPRO_RELATIVE);
3350 rela.r_addend = (h->root.u.def.value
3351 + sec->output_section->vma
3352 + sec->output_offset);
3353 }
3354 else
3355 {
3356 rela.r_info = ELF32_R_INFO (h->dynindx, R_TILEPRO_GLOB_DAT);
3357 rela.r_addend = 0;
3358 }
3359
3360 bfd_put_32 (output_bfd, 0,
3361 sgot->contents + (h->got.offset & ~(bfd_vma) 1));
3362 tilepro_elf_append_rela_32 (output_bfd, srela, &rela);
3363 }
3364
3365 if (h->needs_copy)
3366 {
3367 asection *s;
3368 Elf_Internal_Rela rela;
3369
3370 /* This symbols needs a copy reloc. Set it up. */
3371 BFD_ASSERT (h->dynindx != -1);
3372
3373 s = bfd_get_section_by_name (h->root.u.def.section->owner,
3374 ".rela.bss");
3375 BFD_ASSERT (s != NULL);
3376
3377 rela.r_offset = (h->root.u.def.value
3378 + h->root.u.def.section->output_section->vma
3379 + h->root.u.def.section->output_offset);
3380 rela.r_info = ELF32_R_INFO (h->dynindx, R_TILEPRO_COPY);
3381 rela.r_addend = 0;
3382 tilepro_elf_append_rela_32 (output_bfd, s, &rela);
3383 }
3384
3385 /* Mark some specially defined symbols as absolute. */
3386 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3387 || (h == htab->elf.hgot || h == htab->elf.hplt))
3388 sym->st_shndx = SHN_ABS;
3389
3390 return TRUE;
3391 }
3392
3393 /* Finish up the dynamic sections. */
3394
3395 static bfd_boolean
3396 tilepro_finish_dyn (bfd *output_bfd, struct bfd_link_info *info,
3397 bfd *dynobj, asection *sdyn,
3398 asection *splt ATTRIBUTE_UNUSED)
3399 {
3400 Elf32_External_Dyn *dyncon, *dynconend;
3401 struct tilepro_elf_link_hash_table *htab;
3402
3403 htab = tilepro_elf_hash_table (info);
3404 BFD_ASSERT (htab != NULL);
3405 dyncon = (Elf32_External_Dyn *) sdyn->contents;
3406 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3407 for (; dyncon < dynconend; dyncon++)
3408 {
3409 Elf_Internal_Dyn dyn;
3410 asection *s;
3411
3412 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3413
3414 switch (dyn.d_tag)
3415 {
3416 case DT_PLTGOT:
3417 s = htab->elf.sgotplt;
3418 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3419 break;
3420 case DT_JMPREL:
3421 s = htab->elf.srelplt;
3422 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3423 break;
3424 case DT_PLTRELSZ:
3425 s = htab->elf.srelplt;
3426 dyn.d_un.d_val = s->size;
3427 break;
3428 default:
3429 continue;
3430 }
3431
3432 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3433 }
3434 return TRUE;
3435 }
3436
3437 static bfd_boolean
3438 tilepro_elf_finish_dynamic_sections (bfd *output_bfd,
3439 struct bfd_link_info *info)
3440 {
3441 bfd *dynobj;
3442 asection *sdyn;
3443 struct tilepro_elf_link_hash_table *htab;
3444
3445 htab = tilepro_elf_hash_table (info);
3446 BFD_ASSERT (htab != NULL);
3447 dynobj = htab->elf.dynobj;
3448
3449 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3450
3451 if (elf_hash_table (info)->dynamic_sections_created)
3452 {
3453 asection *splt;
3454 bfd_boolean ret;
3455
3456 splt = bfd_get_section_by_name (dynobj, ".plt");
3457 BFD_ASSERT (splt != NULL && sdyn != NULL);
3458
3459 ret = tilepro_finish_dyn (output_bfd, info, dynobj, sdyn, splt);
3460
3461 if (ret != TRUE)
3462 return ret;
3463
3464 /* Fill in the first entry in the procedure linkage table. */
3465 if (splt->size > 0)
3466 memcpy (splt->contents, tilepro_plt0_entry, PLT_HEADER_SIZE);
3467
3468 elf_section_data (splt->output_section)->this_hdr.sh_entsize
3469 = PLT_ENTRY_SIZE;
3470 }
3471
3472 if (htab->elf.sgotplt)
3473 {
3474 if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
3475 {
3476 (*_bfd_error_handler)
3477 (_("discarded output section: `%A'"), htab->elf.sgotplt);
3478 return FALSE;
3479 }
3480
3481 if (htab->elf.sgotplt->size > 0)
3482 {
3483 /* Write the first two entries in .got.plt, needed for the dynamic
3484 linker. */
3485 bfd_put_32 (output_bfd, (bfd_vma) -1,
3486 htab->elf.sgotplt->contents);
3487 bfd_put_32 (output_bfd, (bfd_vma) 0,
3488 htab->elf.sgotplt->contents + GOT_ENTRY_SIZE);
3489 }
3490
3491 elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize
3492 = GOT_ENTRY_SIZE;
3493 }
3494
3495 if (htab->elf.sgot)
3496 {
3497 if (htab->elf.sgot->size > 0)
3498 {
3499 /* Set the first entry in the global offset table to the address of
3500 the dynamic section. */
3501 bfd_vma val = (sdyn ?
3502 sdyn->output_section->vma + sdyn->output_offset :
3503 0);
3504 bfd_put_32 (output_bfd, val, htab->elf.sgot->contents);
3505 }
3506
3507 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize
3508 = GOT_ENTRY_SIZE;
3509 }
3510
3511 return TRUE;
3512 }
3513
3514 \f
3515
3516 /* Return address for Ith PLT stub in section PLT, for relocation REL
3517 or (bfd_vma) -1 if it should not be included. */
3518
3519 static bfd_vma
3520 tilepro_elf_plt_sym_val (bfd_vma i, const asection *plt,
3521 const arelent *rel ATTRIBUTE_UNUSED)
3522 {
3523 return plt->vma + PLT_HEADER_SIZE + i * PLT_ENTRY_SIZE;
3524 }
3525
3526 static enum elf_reloc_type_class
3527 tilepro_reloc_type_class (const Elf_Internal_Rela *rela)
3528 {
3529 switch ((int) ELF32_R_TYPE (rela->r_info))
3530 {
3531 case R_TILEPRO_RELATIVE:
3532 return reloc_class_relative;
3533 case R_TILEPRO_JMP_SLOT:
3534 return reloc_class_plt;
3535 case R_TILEPRO_COPY:
3536 return reloc_class_copy;
3537 default:
3538 return reloc_class_normal;
3539 }
3540 }
3541
3542 static int
3543 tilepro_additional_program_headers (bfd *abfd,
3544 struct bfd_link_info *info ATTRIBUTE_UNUSED)
3545 {
3546 /* Each .intrpt section specified by the user adds another PT_LOAD
3547 header since the sections are discontiguous. */
3548 static const char intrpt_sections[4][9] =
3549 {
3550 ".intrpt0", ".intrpt1", ".intrpt2", ".intrpt3"
3551 };
3552 int count = 0;
3553 int i;
3554
3555 for (i = 0; i < 4; i++)
3556 {
3557 asection *sec = bfd_get_section_by_name (abfd, intrpt_sections[i]);
3558 if (sec != NULL && (sec->flags & SEC_LOAD) != 0)
3559 ++count;
3560 }
3561
3562 /* Add four "padding" headers in to leave room in case a custom linker
3563 script does something fancy. Otherwise ld complains that it ran
3564 out of program headers and refuses to link. */
3565 count += 4;
3566
3567 return count;
3568 }
3569
3570 #define ELF_ARCH bfd_arch_tilepro
3571 #define ELF_TARGET_ID TILEPRO_ELF_DATA
3572 #define ELF_MACHINE_CODE EM_TILEPRO
3573 #define ELF_MAXPAGESIZE 0x10000
3574 #define ELF_COMMONPAGESIZE 0x10000
3575
3576 #define TARGET_LITTLE_SYM bfd_elf32_tilepro_vec
3577 #define TARGET_LITTLE_NAME "elf32-tilepro"
3578
3579 #define elf_backend_reloc_type_class tilepro_reloc_type_class
3580
3581 #define bfd_elf32_bfd_reloc_name_lookup tilepro_reloc_name_lookup
3582 #define bfd_elf32_bfd_link_hash_table_create tilepro_elf_link_hash_table_create
3583 #define bfd_elf32_bfd_reloc_type_lookup tilepro_reloc_type_lookup
3584
3585 #define elf_backend_copy_indirect_symbol tilepro_elf_copy_indirect_symbol
3586 #define elf_backend_create_dynamic_sections tilepro_elf_create_dynamic_sections
3587 #define elf_backend_check_relocs tilepro_elf_check_relocs
3588 #define elf_backend_adjust_dynamic_symbol tilepro_elf_adjust_dynamic_symbol
3589 #define elf_backend_omit_section_dynsym tilepro_elf_omit_section_dynsym
3590 #define elf_backend_size_dynamic_sections tilepro_elf_size_dynamic_sections
3591 #define elf_backend_relocate_section tilepro_elf_relocate_section
3592 #define elf_backend_finish_dynamic_symbol tilepro_elf_finish_dynamic_symbol
3593 #define elf_backend_finish_dynamic_sections tilepro_elf_finish_dynamic_sections
3594 #define elf_backend_gc_mark_hook tilepro_elf_gc_mark_hook
3595 #define elf_backend_gc_sweep_hook tilepro_elf_gc_sweep_hook
3596 #define elf_backend_plt_sym_val tilepro_elf_plt_sym_val
3597 #define elf_info_to_howto_rel NULL
3598 #define elf_info_to_howto tilepro_info_to_howto_rela
3599 #define elf_backend_grok_prstatus tilepro_elf_grok_prstatus
3600 #define elf_backend_grok_psinfo tilepro_elf_grok_psinfo
3601 #define elf_backend_additional_program_headers tilepro_additional_program_headers
3602
3603 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
3604
3605 #define elf_backend_can_gc_sections 1
3606 #define elf_backend_can_refcount 1
3607 #define elf_backend_want_got_plt 1
3608 #define elf_backend_plt_readonly 1
3609 /* Align PLT mod 64 byte L2 line size. */
3610 #define elf_backend_plt_alignment 6
3611 #define elf_backend_want_plt_sym 1
3612 #define elf_backend_got_header_size GOT_ENTRY_SIZE
3613 #define elf_backend_rela_normal 1
3614 #define elf_backend_default_execstack 0
3615
3616 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.107008 seconds and 5 git commands to generate.