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