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