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