projects / deliverable / binutils-gdb.git / blob
? search:


c2b22ee89a8e7e9a99d293c9436979e92856eae2
[deliverable/binutils-gdb.git] / bfd / elf32-tic6x.c
1 /* 32-bit ELF support for TI C6X
2 Copyright (C) 2010-2016 Free Software Foundation, Inc.
3 Contributed by Joseph Myers <joseph@codesourcery.com>
4 Bernd Schmidt <bernds@codesourcery.com>
5
6 This file is part of BFD, the Binary File Descriptor library.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
22
23 #include "sysdep.h"
24 #include <limits.h>
25 #include "bfd.h"
26 #include "libbfd.h"
27 #include "libiberty.h"
28 #include "elf-bfd.h"
29 #include "elf/tic6x.h"
30 #include "elf32-tic6x.h"
31
32 #define ELF_DYNAMIC_INTERPRETER "/lib/ld-uClibc.so.0"
33
34 /* DSBT binaries have a default 128K stack. */
35 #define DEFAULT_STACK_SIZE 0x20000
36
37 /* The size in bytes of an entry in the procedure linkage table. */
38 #define PLT_ENTRY_SIZE 24
39
40 /* TI C6X ELF linker hash table. */
41
42 struct elf32_tic6x_link_hash_table
43 {
44 struct elf_link_hash_table elf;
45
46 /* C6X specific command line arguments. */
47 struct elf32_tic6x_params params;
48
49 /* Small local sym cache. */
50 struct sym_cache sym_cache;
51
52 /* The output BFD, for convenience. */
53 bfd *obfd;
54
55 /* The .dsbt section. */
56 asection *dsbt;
57 };
58
59 /* Get the TI C6X ELF linker hash table from a link_info structure. */
60
61 #define elf32_tic6x_hash_table(p) \
62 ((struct elf32_tic6x_link_hash_table *) ((p)->hash))
63
64 /* TI C6X ELF linker hash entry. */
65
66 struct elf32_tic6x_link_hash_entry
67 {
68 struct elf_link_hash_entry elf;
69
70 /* Track dynamic relocs copied for this symbol. */
71 struct elf_dyn_relocs *dyn_relocs;
72 };
73
74 typedef enum
75 {
76 DELETE_EXIDX_ENTRY,
77 INSERT_EXIDX_CANTUNWIND_AT_END
78 }
79 tic6x_unwind_edit_type;
80
81 /* A (sorted) list of edits to apply to an unwind table. */
82 typedef struct tic6x_unwind_table_edit
83 {
84 tic6x_unwind_edit_type type;
85 /* Note: we sometimes want to insert an unwind entry corresponding to a
86 section different from the one we're currently writing out, so record the
87 (text) section this edit relates to here. */
88 asection *linked_section;
89 unsigned int index;
90 struct tic6x_unwind_table_edit *next;
91 }
92 tic6x_unwind_table_edit;
93
94 typedef struct _tic6x_elf_section_data
95 {
96 /* Information about mapping symbols. */
97 struct bfd_elf_section_data elf;
98 /* Information about unwind tables. */
99 union
100 {
101 /* Unwind info attached to a text section. */
102 struct
103 {
104 asection *tic6x_exidx_sec;
105 } text;
106
107 /* Unwind info attached to an .c6xabi.exidx section. */
108 struct
109 {
110 tic6x_unwind_table_edit *unwind_edit_list;
111 tic6x_unwind_table_edit *unwind_edit_tail;
112 } exidx;
113 } u;
114 }
115 _tic6x_elf_section_data;
116
117 #define elf32_tic6x_section_data(sec) \
118 ((_tic6x_elf_section_data *) elf_section_data (sec))
119
120 struct elf32_tic6x_obj_tdata
121 {
122 struct elf_obj_tdata root;
123
124 /* Whether to use RELA relocations when generating relocations.
125 This is a per-object flag to allow the assembler to generate REL
126 relocations for use in linker testcases. */
127 bfd_boolean use_rela_p;
128 };
129
130 #define elf32_tic6x_tdata(abfd) \
131 ((struct elf32_tic6x_obj_tdata *) (abfd)->tdata.any)
132
133 #define is_tic6x_elf(bfd) \
134 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
135 && elf_tdata (bfd) != NULL \
136 && elf_object_id (bfd) == TIC6X_ELF_DATA)
137
138 /* C6X ELF uses two common sections. One is the usual one, and the
139 other is for small objects. All the small objects are kept
140 together, and then referenced via the gp pointer, which yields
141 faster assembler code. This is what we use for the small common
142 section. This approach is copied from ecoff.c. */
143 static asection tic6x_elf_scom_section;
144 static asymbol tic6x_elf_scom_symbol;
145 static asymbol *tic6x_elf_scom_symbol_ptr;
146
147 static reloc_howto_type elf32_tic6x_howto_table[] =
148 {
149 HOWTO (R_C6000_NONE, /* type */
150 0, /* rightshift */
151 3, /* size (0 = byte, 1 = short, 2 = long) */
152 0, /* bitsize */
153 FALSE, /* pc_relative */
154 0, /* bitpos */
155 complain_overflow_dont,/* complain_on_overflow */
156 bfd_elf_generic_reloc, /* special_function */
157 "R_C6000_NONE", /* name */
158 FALSE, /* partial_inplace */
159 0, /* src_mask */
160 0, /* dst_mask */
161 FALSE), /* pcrel_offset */
162 HOWTO (R_C6000_ABS32, /* type */
163 0, /* rightshift */
164 2, /* size (0 = byte, 1 = short, 2 = long) */
165 32, /* bitsize */
166 FALSE, /* pc_relative */
167 0, /* bitpos */
168 complain_overflow_dont,/* complain_on_overflow */
169 bfd_elf_generic_reloc, /* special_function */
170 "R_C6000_ABS32", /* name */
171 FALSE, /* partial_inplace */
172 0, /* src_mask */
173 0xffffffff, /* dst_mask */
174 FALSE), /* pcrel_offset */
175 HOWTO (R_C6000_ABS16, /* type */
176 0, /* rightshift */
177 1, /* size (0 = byte, 1 = short, 2 = long) */
178 16, /* bitsize */
179 FALSE, /* pc_relative */
180 0, /* bitpos */
181 complain_overflow_bitfield,/* complain_on_overflow */
182 bfd_elf_generic_reloc, /* special_function */
183 "R_C6000_ABS16", /* name */
184 FALSE, /* partial_inplace */
185 0, /* src_mask */
186 0x0000ffff, /* dst_mask */
187 FALSE), /* pcrel_offset */
188 HOWTO (R_C6000_ABS8, /* type */
189 0, /* rightshift */
190 0, /* size (0 = byte, 1 = short, 2 = long) */
191 8, /* bitsize */
192 FALSE, /* pc_relative */
193 0, /* bitpos */
194 complain_overflow_bitfield,/* complain_on_overflow */
195 bfd_elf_generic_reloc, /* special_function */
196 "R_C6000_ABS8", /* name */
197 FALSE, /* partial_inplace */
198 0, /* src_mask */
199 0x000000ff, /* dst_mask */
200 FALSE), /* pcrel_offset */
201 HOWTO (R_C6000_PCR_S21, /* type */
202 2, /* rightshift */
203 2, /* size (0 = byte, 1 = short, 2 = long) */
204 21, /* bitsize */
205 TRUE, /* pc_relative */
206 7, /* bitpos */
207 complain_overflow_signed,/* complain_on_overflow */
208 bfd_elf_generic_reloc, /* special_function */
209 "R_C6000_PCR_S21", /* name */
210 FALSE, /* partial_inplace */
211 0, /* src_mask */
212 0x0fffff80, /* dst_mask */
213 TRUE), /* pcrel_offset */
214 HOWTO (R_C6000_PCR_S12, /* type */
215 2, /* rightshift */
216 2, /* size (0 = byte, 1 = short, 2 = long) */
217 12, /* bitsize */
218 TRUE, /* pc_relative */
219 16, /* bitpos */
220 complain_overflow_signed,/* complain_on_overflow */
221 bfd_elf_generic_reloc, /* special_function */
222 "R_C6000_PCR_S12", /* name */
223 FALSE, /* partial_inplace */
224 0, /* src_mask */
225 0x0fff0000, /* dst_mask */
226 TRUE), /* pcrel_offset */
227 HOWTO (R_C6000_PCR_S10, /* type */
228 2, /* rightshift */
229 2, /* size (0 = byte, 1 = short, 2 = long) */
230 10, /* bitsize */
231 TRUE, /* pc_relative */
232 13, /* bitpos */
233 complain_overflow_signed,/* complain_on_overflow */
234 bfd_elf_generic_reloc, /* special_function */
235 "R_C6000_PCR_S10", /* name */
236 FALSE, /* partial_inplace */
237 0, /* src_mask */
238 0x007fe000, /* dst_mask */
239 TRUE), /* pcrel_offset */
240 HOWTO (R_C6000_PCR_S7, /* type */
241 2, /* rightshift */
242 2, /* size (0 = byte, 1 = short, 2 = long) */
243 7, /* bitsize */
244 TRUE, /* pc_relative */
245 16, /* bitpos */
246 complain_overflow_signed,/* complain_on_overflow */
247 bfd_elf_generic_reloc, /* special_function */
248 "R_C6000_PCR_S7", /* name */
249 FALSE, /* partial_inplace */
250 0, /* src_mask */
251 0x007f0000, /* dst_mask */
252 TRUE), /* pcrel_offset */
253 HOWTO (R_C6000_ABS_S16, /* type */
254 0, /* rightshift */
255 2, /* size (0 = byte, 1 = short, 2 = long) */
256 16, /* bitsize */
257 FALSE, /* pc_relative */
258 7, /* bitpos */
259 complain_overflow_signed,/* complain_on_overflow */
260 bfd_elf_generic_reloc, /* special_function */
261 "R_C6000_ABS_S16", /* name */
262 FALSE, /* partial_inplace */
263 0, /* src_mask */
264 0x007fff80, /* dst_mask */
265 FALSE), /* pcrel_offset */
266 HOWTO (R_C6000_ABS_L16, /* type */
267 0, /* rightshift */
268 2, /* size (0 = byte, 1 = short, 2 = long) */
269 16, /* bitsize */
270 FALSE, /* pc_relative */
271 7, /* bitpos */
272 complain_overflow_dont,/* complain_on_overflow */
273 bfd_elf_generic_reloc, /* special_function */
274 "R_C6000_ABS_L16", /* name */
275 FALSE, /* partial_inplace */
276 0, /* src_mask */
277 0x007fff80, /* dst_mask */
278 FALSE), /* pcrel_offset */
279 HOWTO (R_C6000_ABS_H16, /* type */
280 16, /* rightshift */
281 2, /* size (0 = byte, 1 = short, 2 = long) */
282 16, /* bitsize */
283 FALSE, /* pc_relative */
284 7, /* bitpos */
285 complain_overflow_dont,/* complain_on_overflow */
286 bfd_elf_generic_reloc, /* special_function */
287 "R_C6000_ABS_H16", /* name */
288 FALSE, /* partial_inplace */
289 0, /* src_mask */
290 0x007fff80, /* dst_mask */
291 FALSE), /* pcrel_offset */
292 HOWTO (R_C6000_SBR_U15_B, /* type */
293 0, /* rightshift */
294 2, /* size (0 = byte, 1 = short, 2 = long) */
295 15, /* bitsize */
296 FALSE, /* pc_relative */
297 8, /* bitpos */
298 complain_overflow_unsigned,/* complain_on_overflow */
299 bfd_elf_generic_reloc, /* special_function */
300 "R_C6000_SBR_U15_B", /* name */
301 FALSE, /* partial_inplace */
302 0, /* src_mask */
303 0x007fff00, /* dst_mask */
304 FALSE), /* pcrel_offset */
305 HOWTO (R_C6000_SBR_U15_H, /* type */
306 1, /* rightshift */
307 2, /* size (0 = byte, 1 = short, 2 = long) */
308 15, /* bitsize */
309 FALSE, /* pc_relative */
310 8, /* bitpos */
311 complain_overflow_unsigned,/* complain_on_overflow */
312 bfd_elf_generic_reloc, /* special_function */
313 "R_C6000_SBR_U15_H", /* name */
314 FALSE, /* partial_inplace */
315 0, /* src_mask */
316 0x007fff00, /* dst_mask */
317 FALSE), /* pcrel_offset */
318 HOWTO (R_C6000_SBR_U15_W, /* type */
319 2, /* rightshift */
320 2, /* size (0 = byte, 1 = short, 2 = long) */
321 15, /* bitsize */
322 FALSE, /* pc_relative */
323 8, /* bitpos */
324 complain_overflow_unsigned,/* complain_on_overflow */
325 bfd_elf_generic_reloc, /* special_function */
326 "R_C6000_SBR_U15_W", /* name */
327 FALSE, /* partial_inplace */
328 0, /* src_mask */
329 0x007fff00, /* dst_mask */
330 FALSE), /* pcrel_offset */
331 HOWTO (R_C6000_SBR_S16, /* type */
332 0, /* rightshift */
333 2, /* size (0 = byte, 1 = short, 2 = long) */
334 16, /* bitsize */
335 FALSE, /* pc_relative */
336 7, /* bitpos */
337 complain_overflow_signed,/* complain_on_overflow */
338 bfd_elf_generic_reloc, /* special_function */
339 "R_C6000_SBR_S16", /* name */
340 FALSE, /* partial_inplace */
341 0, /* src_mask */
342 0x007fff80, /* dst_mask */
343 FALSE), /* pcrel_offset */
344 HOWTO (R_C6000_SBR_L16_B, /* type */
345 0, /* rightshift */
346 2, /* size (0 = byte, 1 = short, 2 = long) */
347 16, /* bitsize */
348 FALSE, /* pc_relative */
349 7, /* bitpos */
350 complain_overflow_dont,/* complain_on_overflow */
351 bfd_elf_generic_reloc, /* special_function */
352 "R_C6000_SBR_L16_B", /* name */
353 FALSE, /* partial_inplace */
354 0, /* src_mask */
355 0x007fff80, /* dst_mask */
356 FALSE), /* pcrel_offset */
357 HOWTO (R_C6000_SBR_L16_H, /* type */
358 1, /* rightshift */
359 2, /* size (0 = byte, 1 = short, 2 = long) */
360 16, /* bitsize */
361 FALSE, /* pc_relative */
362 7, /* bitpos */
363 complain_overflow_dont,/* complain_on_overflow */
364 bfd_elf_generic_reloc, /* special_function */
365 "R_C6000_SBR_L16_H", /* name */
366 FALSE, /* partial_inplace */
367 0, /* src_mask */
368 0x007fff80, /* dst_mask */
369 FALSE), /* pcrel_offset */
370 HOWTO (R_C6000_SBR_L16_W, /* type */
371 2, /* rightshift */
372 2, /* size (0 = byte, 1 = short, 2 = long) */
373 16, /* bitsize */
374 FALSE, /* pc_relative */
375 7, /* bitpos */
376 complain_overflow_dont,/* complain_on_overflow */
377 bfd_elf_generic_reloc, /* special_function */
378 "R_C6000_SBR_L16_W", /* name */
379 FALSE, /* partial_inplace */
380 0, /* src_mask */
381 0x007fff80, /* dst_mask */
382 FALSE), /* pcrel_offset */
383 HOWTO (R_C6000_SBR_H16_B, /* type */
384 16, /* rightshift */
385 2, /* size (0 = byte, 1 = short, 2 = long) */
386 16, /* bitsize */
387 FALSE, /* pc_relative */
388 7, /* bitpos */
389 complain_overflow_dont,/* complain_on_overflow */
390 bfd_elf_generic_reloc, /* special_function */
391 "R_C6000_SBR_H16_B", /* name */
392 FALSE, /* partial_inplace */
393 0, /* src_mask */
394 0x007fff80, /* dst_mask */
395 FALSE), /* pcrel_offset */
396 HOWTO (R_C6000_SBR_H16_H, /* type */
397 17, /* rightshift */
398 2, /* size (0 = byte, 1 = short, 2 = long) */
399 16, /* bitsize */
400 FALSE, /* pc_relative */
401 7, /* bitpos */
402 complain_overflow_dont,/* complain_on_overflow */
403 bfd_elf_generic_reloc, /* special_function */
404 "R_C6000_SBR_H16_H", /* name */
405 FALSE, /* partial_inplace */
406 0, /* src_mask */
407 0x007fff80, /* dst_mask */
408 FALSE), /* pcrel_offset */
409 HOWTO (R_C6000_SBR_H16_W, /* type */
410 18, /* rightshift */
411 2, /* size (0 = byte, 1 = short, 2 = long) */
412 16, /* bitsize */
413 FALSE, /* pc_relative */
414 7, /* bitpos */
415 complain_overflow_dont,/* complain_on_overflow */
416 bfd_elf_generic_reloc, /* special_function */
417 "R_C6000_SBR_H16_W", /* name */
418 FALSE, /* partial_inplace */
419 0, /* src_mask */
420 0x007fff80, /* dst_mask */
421 FALSE), /* pcrel_offset */
422 HOWTO (R_C6000_SBR_GOT_U15_W, /* type */
423 2, /* rightshift */
424 2, /* size (0 = byte, 1 = short, 2 = long) */
425 15, /* bitsize */
426 FALSE, /* pc_relative */
427 8, /* bitpos */
428 complain_overflow_unsigned,/* complain_on_overflow */
429 bfd_elf_generic_reloc, /* special_function */
430 "R_C6000_SBR_GOT_U15_W",/* name */
431 FALSE, /* partial_inplace */
432 0, /* src_mask */
433 0x007fff00, /* dst_mask */
434 FALSE), /* pcrel_offset */
435 HOWTO (R_C6000_SBR_GOT_L16_W, /* type */
436 2, /* rightshift */
437 2, /* size (0 = byte, 1 = short, 2 = long) */
438 16, /* bitsize */
439 FALSE, /* pc_relative */
440 7, /* bitpos */
441 complain_overflow_dont,/* complain_on_overflow */
442 bfd_elf_generic_reloc, /* special_function */
443 "R_C6000_SBR_GOT_L16_W",/* name */
444 FALSE, /* partial_inplace */
445 0, /* src_mask */
446 0x007fff80, /* dst_mask */
447 FALSE), /* pcrel_offset */
448 HOWTO (R_C6000_SBR_GOT_H16_W, /* type */
449 18, /* rightshift */
450 2, /* size (0 = byte, 1 = short, 2 = long) */
451 16, /* bitsize */
452 FALSE, /* pc_relative */
453 7, /* bitpos */
454 complain_overflow_dont,/* complain_on_overflow */
455 bfd_elf_generic_reloc, /* special_function */
456 "R_C6000_SBR_GOT_H16_W",/* name */
457 FALSE, /* partial_inplace */
458 0, /* src_mask */
459 0x007fff80, /* dst_mask */
460 FALSE), /* pcrel_offset */
461 HOWTO (R_C6000_DSBT_INDEX, /* type */
462 0, /* rightshift */
463 2, /* size (0 = byte, 1 = short, 2 = long) */
464 15, /* bitsize */
465 FALSE, /* pc_relative */
466 8, /* bitpos */
467 complain_overflow_unsigned,/* complain_on_overflow */
468 bfd_elf_generic_reloc, /* special_function */
469 "R_C6000_DSBT_INDEX", /* name */
470 FALSE, /* partial_inplace */
471 0, /* src_mask */
472 0x007fff00, /* dst_mask */
473 FALSE), /* pcrel_offset */
474 HOWTO (R_C6000_PREL31, /* type */
475 1, /* rightshift */
476 2, /* size (0 = byte, 1 = short, 2 = long) */
477 31, /* bitsize */
478 TRUE, /* pc_relative */
479 0, /* bitpos */
480 complain_overflow_dont,/* complain_on_overflow */
481 bfd_elf_generic_reloc, /* special_function */
482 "R_C6000_PREL31", /* name */
483 FALSE, /* partial_inplace */
484 0, /* src_mask */
485 0x7fffffff, /* dst_mask */
486 TRUE), /* pcrel_offset */
487 HOWTO (R_C6000_COPY, /* type */
488 0, /* rightshift */
489 2, /* size (0 = byte, 1 = short, 2 = long) */
490 32, /* bitsize */
491 FALSE, /* pc_relative */
492 0, /* bitpos */
493 complain_overflow_dont,/* complain_on_overflow */
494 bfd_elf_generic_reloc, /* special_function */
495 "R_C6000_COPY", /* name */
496 FALSE, /* partial_inplace */
497 0, /* src_mask */
498 0xffffffff, /* dst_mask */
499 FALSE), /* pcrel_offset */
500 HOWTO (R_C6000_JUMP_SLOT, /* type */
501 0, /* rightshift */
502 2, /* size (0 = byte, 1 = short, 2 = long) */
503 32, /* bitsize */
504 FALSE, /* pc_relative */
505 0, /* bitpos */
506 complain_overflow_dont,/* complain_on_overflow */
507 bfd_elf_generic_reloc, /* special_function */
508 "R_C6000_JUMP_SLOT", /* name */
509 FALSE, /* partial_inplace */
510 0, /* src_mask */
511 0xffffffff, /* dst_mask */
512 FALSE), /* pcrel_offset */
513 HOWTO (R_C6000_EHTYPE, /* type */
514 0, /* rightshift */
515 2, /* size (0 = byte, 1 = short, 2 = long) */
516 32, /* bitsize */
517 FALSE, /* pc_relative */
518 0, /* bitpos */
519 complain_overflow_dont,/* complain_on_overflow */
520 bfd_elf_generic_reloc, /* special_function */
521 "R_C6000_EHTYPE", /* name */
522 FALSE, /* partial_inplace */
523 0, /* src_mask */
524 0xffffffff, /* dst_mask */
525 FALSE), /* pcrel_offset */
526 HOWTO (R_C6000_PCR_H16, /* type */
527 16, /* rightshift */
528 2, /* size (0 = byte, 1 = short, 2 = long) */
529 16, /* bitsize */
530 TRUE, /* pc_relative */
531 7, /* bitpos */
532 complain_overflow_dont,/* complain_on_overflow */
533 bfd_elf_generic_reloc, /* special_function */
534 "R_C6000_PCR_H16", /* name */
535 FALSE, /* partial_inplace */
536 0, /* src_mask */
537 0x007fff80, /* dst_mask */
538 TRUE), /* pcrel_offset */
539 HOWTO (R_C6000_PCR_L16, /* type */
540 0, /* rightshift */
541 2, /* size (0 = byte, 1 = short, 2 = long) */
542 16, /* bitsize */
543 TRUE, /* pc_relative */
544 7, /* bitpos */
545 complain_overflow_dont,/* complain_on_overflow */
546 bfd_elf_generic_reloc, /* special_function */
547 "R_C6000_PCR_L16", /* name */
548 FALSE, /* partial_inplace */
549 0, /* src_mask */
550 0x007fff80, /* dst_mask */
551 TRUE), /* pcrel_offset */
552 EMPTY_HOWTO (31),
553 EMPTY_HOWTO (32),
554 EMPTY_HOWTO (33),
555 EMPTY_HOWTO (34),
556 EMPTY_HOWTO (35),
557 EMPTY_HOWTO (36),
558 EMPTY_HOWTO (37),
559 EMPTY_HOWTO (38),
560 EMPTY_HOWTO (39),
561 EMPTY_HOWTO (40),
562 EMPTY_HOWTO (41),
563 EMPTY_HOWTO (42),
564 EMPTY_HOWTO (43),
565 EMPTY_HOWTO (44),
566 EMPTY_HOWTO (45),
567 EMPTY_HOWTO (46),
568 EMPTY_HOWTO (47),
569 EMPTY_HOWTO (48),
570 EMPTY_HOWTO (49),
571 EMPTY_HOWTO (50),
572 EMPTY_HOWTO (51),
573 EMPTY_HOWTO (52),
574 EMPTY_HOWTO (53),
575 EMPTY_HOWTO (54),
576 EMPTY_HOWTO (55),
577 EMPTY_HOWTO (56),
578 EMPTY_HOWTO (57),
579 EMPTY_HOWTO (58),
580 EMPTY_HOWTO (59),
581 EMPTY_HOWTO (60),
582 EMPTY_HOWTO (61),
583 EMPTY_HOWTO (62),
584 EMPTY_HOWTO (63),
585 EMPTY_HOWTO (64),
586 EMPTY_HOWTO (65),
587 EMPTY_HOWTO (66),
588 EMPTY_HOWTO (67),
589 EMPTY_HOWTO (68),
590 EMPTY_HOWTO (69),
591 EMPTY_HOWTO (70),
592 EMPTY_HOWTO (71),
593 EMPTY_HOWTO (72),
594 EMPTY_HOWTO (73),
595 EMPTY_HOWTO (74),
596 EMPTY_HOWTO (75),
597 EMPTY_HOWTO (76),
598 EMPTY_HOWTO (77),
599 EMPTY_HOWTO (78),
600 EMPTY_HOWTO (79),
601 EMPTY_HOWTO (80),
602 EMPTY_HOWTO (81),
603 EMPTY_HOWTO (82),
604 EMPTY_HOWTO (83),
605 EMPTY_HOWTO (84),
606 EMPTY_HOWTO (85),
607 EMPTY_HOWTO (86),
608 EMPTY_HOWTO (87),
609 EMPTY_HOWTO (88),
610 EMPTY_HOWTO (89),
611 EMPTY_HOWTO (90),
612 EMPTY_HOWTO (91),
613 EMPTY_HOWTO (92),
614 EMPTY_HOWTO (93),
615 EMPTY_HOWTO (94),
616 EMPTY_HOWTO (95),
617 EMPTY_HOWTO (96),
618 EMPTY_HOWTO (97),
619 EMPTY_HOWTO (98),
620 EMPTY_HOWTO (99),
621 EMPTY_HOWTO (100),
622 EMPTY_HOWTO (101),
623 EMPTY_HOWTO (102),
624 EMPTY_HOWTO (103),
625 EMPTY_HOWTO (104),
626 EMPTY_HOWTO (105),
627 EMPTY_HOWTO (106),
628 EMPTY_HOWTO (107),
629 EMPTY_HOWTO (108),
630 EMPTY_HOWTO (109),
631 EMPTY_HOWTO (110),
632 EMPTY_HOWTO (111),
633 EMPTY_HOWTO (112),
634 EMPTY_HOWTO (113),
635 EMPTY_HOWTO (114),
636 EMPTY_HOWTO (115),
637 EMPTY_HOWTO (116),
638 EMPTY_HOWTO (117),
639 EMPTY_HOWTO (118),
640 EMPTY_HOWTO (119),
641 EMPTY_HOWTO (120),
642 EMPTY_HOWTO (121),
643 EMPTY_HOWTO (122),
644 EMPTY_HOWTO (123),
645 EMPTY_HOWTO (124),
646 EMPTY_HOWTO (125),
647 EMPTY_HOWTO (126),
648 EMPTY_HOWTO (127),
649 EMPTY_HOWTO (128),
650 EMPTY_HOWTO (129),
651 EMPTY_HOWTO (130),
652 EMPTY_HOWTO (131),
653 EMPTY_HOWTO (132),
654 EMPTY_HOWTO (133),
655 EMPTY_HOWTO (134),
656 EMPTY_HOWTO (135),
657 EMPTY_HOWTO (136),
658 EMPTY_HOWTO (137),
659 EMPTY_HOWTO (138),
660 EMPTY_HOWTO (139),
661 EMPTY_HOWTO (140),
662 EMPTY_HOWTO (141),
663 EMPTY_HOWTO (142),
664 EMPTY_HOWTO (143),
665 EMPTY_HOWTO (144),
666 EMPTY_HOWTO (145),
667 EMPTY_HOWTO (146),
668 EMPTY_HOWTO (147),
669 EMPTY_HOWTO (148),
670 EMPTY_HOWTO (149),
671 EMPTY_HOWTO (150),
672 EMPTY_HOWTO (151),
673 EMPTY_HOWTO (152),
674 EMPTY_HOWTO (153),
675 EMPTY_HOWTO (154),
676 EMPTY_HOWTO (155),
677 EMPTY_HOWTO (156),
678 EMPTY_HOWTO (157),
679 EMPTY_HOWTO (158),
680 EMPTY_HOWTO (159),
681 EMPTY_HOWTO (160),
682 EMPTY_HOWTO (161),
683 EMPTY_HOWTO (162),
684 EMPTY_HOWTO (163),
685 EMPTY_HOWTO (164),
686 EMPTY_HOWTO (165),
687 EMPTY_HOWTO (166),
688 EMPTY_HOWTO (167),
689 EMPTY_HOWTO (168),
690 EMPTY_HOWTO (169),
691 EMPTY_HOWTO (170),
692 EMPTY_HOWTO (171),
693 EMPTY_HOWTO (172),
694 EMPTY_HOWTO (173),
695 EMPTY_HOWTO (174),
696 EMPTY_HOWTO (175),
697 EMPTY_HOWTO (176),
698 EMPTY_HOWTO (177),
699 EMPTY_HOWTO (178),
700 EMPTY_HOWTO (179),
701 EMPTY_HOWTO (180),
702 EMPTY_HOWTO (181),
703 EMPTY_HOWTO (182),
704 EMPTY_HOWTO (183),
705 EMPTY_HOWTO (184),
706 EMPTY_HOWTO (185),
707 EMPTY_HOWTO (186),
708 EMPTY_HOWTO (187),
709 EMPTY_HOWTO (188),
710 EMPTY_HOWTO (189),
711 EMPTY_HOWTO (190),
712 EMPTY_HOWTO (191),
713 EMPTY_HOWTO (192),
714 EMPTY_HOWTO (193),
715 EMPTY_HOWTO (194),
716 EMPTY_HOWTO (195),
717 EMPTY_HOWTO (196),
718 EMPTY_HOWTO (197),
719 EMPTY_HOWTO (198),
720 EMPTY_HOWTO (199),
721 EMPTY_HOWTO (200),
722 EMPTY_HOWTO (201),
723 EMPTY_HOWTO (202),
724 EMPTY_HOWTO (203),
725 EMPTY_HOWTO (204),
726 EMPTY_HOWTO (205),
727 EMPTY_HOWTO (206),
728 EMPTY_HOWTO (207),
729 EMPTY_HOWTO (208),
730 EMPTY_HOWTO (209),
731 EMPTY_HOWTO (210),
732 EMPTY_HOWTO (211),
733 EMPTY_HOWTO (212),
734 EMPTY_HOWTO (213),
735 EMPTY_HOWTO (214),
736 EMPTY_HOWTO (215),
737 EMPTY_HOWTO (216),
738 EMPTY_HOWTO (217),
739 EMPTY_HOWTO (218),
740 EMPTY_HOWTO (219),
741 EMPTY_HOWTO (220),
742 EMPTY_HOWTO (221),
743 EMPTY_HOWTO (222),
744 EMPTY_HOWTO (223),
745 EMPTY_HOWTO (224),
746 EMPTY_HOWTO (225),
747 EMPTY_HOWTO (226),
748 EMPTY_HOWTO (227),
749 EMPTY_HOWTO (228),
750 EMPTY_HOWTO (229),
751 EMPTY_HOWTO (230),
752 EMPTY_HOWTO (231),
753 EMPTY_HOWTO (232),
754 EMPTY_HOWTO (233),
755 EMPTY_HOWTO (234),
756 EMPTY_HOWTO (235),
757 EMPTY_HOWTO (236),
758 EMPTY_HOWTO (237),
759 EMPTY_HOWTO (238),
760 EMPTY_HOWTO (239),
761 EMPTY_HOWTO (240),
762 EMPTY_HOWTO (241),
763 EMPTY_HOWTO (242),
764 EMPTY_HOWTO (243),
765 EMPTY_HOWTO (244),
766 EMPTY_HOWTO (245),
767 EMPTY_HOWTO (246),
768 EMPTY_HOWTO (247),
769 EMPTY_HOWTO (248),
770 EMPTY_HOWTO (249),
771 EMPTY_HOWTO (250),
772 EMPTY_HOWTO (251),
773 EMPTY_HOWTO (252),
774 HOWTO (R_C6000_ALIGN, /* type */
775 0, /* rightshift */
776 0, /* size (0 = byte, 1 = short, 2 = long) */
777 0, /* bitsize */
778 FALSE, /* pc_relative */
779 0, /* bitpos */
780 complain_overflow_dont,/* complain_on_overflow */
781 bfd_elf_generic_reloc, /* special_function */
782 "R_C6000_ALIGN", /* name */
783 FALSE, /* partial_inplace */
784 0, /* src_mask */
785 0, /* dst_mask */
786 FALSE), /* pcrel_offset */
787 HOWTO (R_C6000_FPHEAD, /* type */
788 0, /* rightshift */
789 0, /* size (0 = byte, 1 = short, 2 = long) */
790 0, /* bitsize */
791 FALSE, /* pc_relative */
792 0, /* bitpos */
793 complain_overflow_dont,/* complain_on_overflow */
794 bfd_elf_generic_reloc, /* special_function */
795 "R_C6000_FPHEAD", /* name */
796 FALSE, /* partial_inplace */
797 0, /* src_mask */
798 0, /* dst_mask */
799 FALSE), /* pcrel_offset */
800 HOWTO (R_C6000_NOCMP, /* type */
801 0, /* rightshift */
802 0, /* size (0 = byte, 1 = short, 2 = long) */
803 0, /* bitsize */
804 FALSE, /* pc_relative */
805 0, /* bitpos */
806 complain_overflow_dont,/* complain_on_overflow */
807 bfd_elf_generic_reloc, /* special_function */
808 "R_C6000_NOCMP", /* name */
809 FALSE, /* partial_inplace */
810 0, /* src_mask */
811 0, /* dst_mask */
812 FALSE) /* pcrel_offset */
813 };
814
815 static reloc_howto_type elf32_tic6x_howto_table_rel[] =
816 {
817 HOWTO (R_C6000_NONE, /* type */
818 0, /* rightshift */
819 3, /* size (0 = byte, 1 = short, 2 = long) */
820 0, /* bitsize */
821 FALSE, /* pc_relative */
822 0, /* bitpos */
823 complain_overflow_dont,/* complain_on_overflow */
824 bfd_elf_generic_reloc, /* special_function */
825 "R_C6000_NONE", /* name */
826 TRUE, /* partial_inplace */
827 0, /* src_mask */
828 0, /* dst_mask */
829 FALSE), /* pcrel_offset */
830 HOWTO (R_C6000_ABS32, /* type */
831 0, /* rightshift */
832 2, /* size (0 = byte, 1 = short, 2 = long) */
833 32, /* bitsize */
834 FALSE, /* pc_relative */
835 0, /* bitpos */
836 complain_overflow_dont,/* complain_on_overflow */
837 bfd_elf_generic_reloc, /* special_function */
838 "R_C6000_ABS32", /* name */
839 TRUE, /* partial_inplace */
840 0xffffffff, /* src_mask */
841 0xffffffff, /* dst_mask */
842 FALSE), /* pcrel_offset */
843 HOWTO (R_C6000_ABS16, /* type */
844 0, /* rightshift */
845 1, /* size (0 = byte, 1 = short, 2 = long) */
846 16, /* bitsize */
847 FALSE, /* pc_relative */
848 0, /* bitpos */
849 complain_overflow_bitfield,/* complain_on_overflow */
850 bfd_elf_generic_reloc, /* special_function */
851 "R_C6000_ABS16", /* name */
852 TRUE, /* partial_inplace */
853 0x0000ffff, /* src_mask */
854 0x0000ffff, /* dst_mask */
855 FALSE), /* pcrel_offset */
856 HOWTO (R_C6000_ABS8, /* type */
857 0, /* rightshift */
858 0, /* size (0 = byte, 1 = short, 2 = long) */
859 8, /* bitsize */
860 FALSE, /* pc_relative */
861 0, /* bitpos */
862 complain_overflow_bitfield,/* complain_on_overflow */
863 bfd_elf_generic_reloc, /* special_function */
864 "R_C6000_ABS8", /* name */
865 TRUE, /* partial_inplace */
866 0x000000ff, /* src_mask */
867 0x000000ff, /* dst_mask */
868 FALSE), /* pcrel_offset */
869 HOWTO (R_C6000_PCR_S21, /* type */
870 2, /* rightshift */
871 2, /* size (0 = byte, 1 = short, 2 = long) */
872 21, /* bitsize */
873 TRUE, /* pc_relative */
874 7, /* bitpos */
875 complain_overflow_signed,/* complain_on_overflow */
876 bfd_elf_generic_reloc, /* special_function */
877 "R_C6000_PCR_S21", /* name */
878 TRUE, /* partial_inplace */
879 0x0fffff80, /* src_mask */
880 0x0fffff80, /* dst_mask */
881 TRUE), /* pcrel_offset */
882 HOWTO (R_C6000_PCR_S12, /* type */
883 2, /* rightshift */
884 2, /* size (0 = byte, 1 = short, 2 = long) */
885 12, /* bitsize */
886 TRUE, /* pc_relative */
887 16, /* bitpos */
888 complain_overflow_signed,/* complain_on_overflow */
889 bfd_elf_generic_reloc, /* special_function */
890 "R_C6000_PCR_S12", /* name */
891 TRUE, /* partial_inplace */
892 0x0fff0000, /* src_mask */
893 0x0fff0000, /* dst_mask */
894 TRUE), /* pcrel_offset */
895 HOWTO (R_C6000_PCR_S10, /* type */
896 2, /* rightshift */
897 2, /* size (0 = byte, 1 = short, 2 = long) */
898 10, /* bitsize */
899 TRUE, /* pc_relative */
900 13, /* bitpos */
901 complain_overflow_signed,/* complain_on_overflow */
902 bfd_elf_generic_reloc, /* special_function */
903 "R_C6000_PCR_S10", /* name */
904 TRUE, /* partial_inplace */
905 0x007fe000, /* src_mask */
906 0x007fe000, /* dst_mask */
907 TRUE), /* pcrel_offset */
908 HOWTO (R_C6000_PCR_S7, /* type */
909 2, /* rightshift */
910 2, /* size (0 = byte, 1 = short, 2 = long) */
911 7, /* bitsize */
912 TRUE, /* pc_relative */
913 16, /* bitpos */
914 complain_overflow_signed,/* complain_on_overflow */
915 bfd_elf_generic_reloc, /* special_function */
916 "R_C6000_PCR_S7", /* name */
917 TRUE, /* partial_inplace */
918 0x007f0000, /* src_mask */
919 0x007f0000, /* dst_mask */
920 TRUE), /* pcrel_offset */
921 HOWTO (R_C6000_ABS_S16, /* type */
922 0, /* rightshift */
923 2, /* size (0 = byte, 1 = short, 2 = long) */
924 16, /* bitsize */
925 FALSE, /* pc_relative */
926 7, /* bitpos */
927 complain_overflow_signed,/* complain_on_overflow */
928 bfd_elf_generic_reloc, /* special_function */
929 "R_C6000_ABS_S16", /* name */
930 TRUE, /* partial_inplace */
931 0x007fff80, /* src_mask */
932 0x007fff80, /* dst_mask */
933 FALSE), /* pcrel_offset */
934 HOWTO (R_C6000_ABS_L16, /* type */
935 0, /* rightshift */
936 2, /* size (0 = byte, 1 = short, 2 = long) */
937 16, /* bitsize */
938 FALSE, /* pc_relative */
939 7, /* bitpos */
940 complain_overflow_dont,/* complain_on_overflow */
941 bfd_elf_generic_reloc, /* special_function */
942 "R_C6000_ABS_L16", /* name */
943 TRUE, /* partial_inplace */
944 0x007fff80, /* src_mask */
945 0x007fff80, /* dst_mask */
946 FALSE), /* pcrel_offset */
947 EMPTY_HOWTO (R_C6000_ABS_H16),
948 HOWTO (R_C6000_SBR_U15_B, /* type */
949 0, /* rightshift */
950 2, /* size (0 = byte, 1 = short, 2 = long) */
951 15, /* bitsize */
952 FALSE, /* pc_relative */
953 8, /* bitpos */
954 complain_overflow_unsigned,/* complain_on_overflow */
955 bfd_elf_generic_reloc, /* special_function */
956 "R_C6000_SBR_U15_B", /* name */
957 TRUE, /* partial_inplace */
958 0x007fff00, /* src_mask */
959 0x007fff00, /* dst_mask */
960 FALSE), /* pcrel_offset */
961 HOWTO (R_C6000_SBR_U15_H, /* type */
962 1, /* rightshift */
963 2, /* size (0 = byte, 1 = short, 2 = long) */
964 15, /* bitsize */
965 FALSE, /* pc_relative */
966 8, /* bitpos */
967 complain_overflow_unsigned,/* complain_on_overflow */
968 bfd_elf_generic_reloc, /* special_function */
969 "R_C6000_SBR_U15_H", /* name */
970 TRUE, /* partial_inplace */
971 0x007fff00, /* src_mask */
972 0x007fff00, /* dst_mask */
973 FALSE), /* pcrel_offset */
974 HOWTO (R_C6000_SBR_U15_W, /* type */
975 2, /* rightshift */
976 2, /* size (0 = byte, 1 = short, 2 = long) */
977 15, /* bitsize */
978 FALSE, /* pc_relative */
979 8, /* bitpos */
980 complain_overflow_unsigned,/* complain_on_overflow */
981 bfd_elf_generic_reloc, /* special_function */
982 "R_C6000_SBR_U15_W", /* name */
983 TRUE, /* partial_inplace */
984 0x007fff00, /* src_mask */
985 0x007fff00, /* dst_mask */
986 FALSE), /* pcrel_offset */
987 HOWTO (R_C6000_SBR_S16, /* type */
988 0, /* rightshift */
989 2, /* size (0 = byte, 1 = short, 2 = long) */
990 16, /* bitsize */
991 FALSE, /* pc_relative */
992 7, /* bitpos */
993 complain_overflow_signed,/* complain_on_overflow */
994 bfd_elf_generic_reloc, /* special_function */
995 "R_C6000_SBR_S16", /* name */
996 TRUE, /* partial_inplace */
997 0x007fff80, /* src_mask */
998 0x007fff80, /* dst_mask */
999 FALSE), /* pcrel_offset */
1000 HOWTO (R_C6000_SBR_L16_B, /* type */
1001 0, /* rightshift */
1002 2, /* size (0 = byte, 1 = short, 2 = long) */
1003 16, /* bitsize */
1004 FALSE, /* pc_relative */
1005 7, /* bitpos */
1006 complain_overflow_dont,/* complain_on_overflow */
1007 bfd_elf_generic_reloc, /* special_function */
1008 "R_C6000_SBR_L16_B", /* name */
1009 TRUE, /* partial_inplace */
1010 0x007fff80, /* src_mask */
1011 0x007fff80, /* dst_mask */
1012 FALSE), /* pcrel_offset */
1013 HOWTO (R_C6000_SBR_L16_H, /* type */
1014 1, /* rightshift */
1015 2, /* size (0 = byte, 1 = short, 2 = long) */
1016 16, /* bitsize */
1017 FALSE, /* pc_relative */
1018 7, /* bitpos */
1019 complain_overflow_dont,/* complain_on_overflow */
1020 bfd_elf_generic_reloc, /* special_function */
1021 "R_C6000_SBR_L16_H", /* name */
1022 TRUE, /* partial_inplace */
1023 0x007fff80, /* src_mask */
1024 0x007fff80, /* dst_mask */
1025 FALSE), /* pcrel_offset */
1026 HOWTO (R_C6000_SBR_L16_W, /* type */
1027 2, /* rightshift */
1028 2, /* size (0 = byte, 1 = short, 2 = long) */
1029 16, /* bitsize */
1030 FALSE, /* pc_relative */
1031 7, /* bitpos */
1032 complain_overflow_dont,/* complain_on_overflow */
1033 bfd_elf_generic_reloc, /* special_function */
1034 "R_C6000_SBR_L16_W", /* name */
1035 TRUE, /* partial_inplace */
1036 0x007fff80, /* src_mask */
1037 0x007fff80, /* dst_mask */
1038 FALSE), /* pcrel_offset */
1039 EMPTY_HOWTO (R_C6000_SBR_H16_B),
1040 EMPTY_HOWTO (R_C6000_SBR_H16_H),
1041 EMPTY_HOWTO (R_C6000_SBR_H16_W),
1042 HOWTO (R_C6000_SBR_GOT_U15_W, /* type */
1043 2, /* rightshift */
1044 2, /* size (0 = byte, 1 = short, 2 = long) */
1045 15, /* bitsize */
1046 FALSE, /* pc_relative */
1047 8, /* bitpos */
1048 complain_overflow_unsigned,/* complain_on_overflow */
1049 bfd_elf_generic_reloc, /* special_function */
1050 "R_C6000_SBR_GOT_U15_W",/* name */
1051 TRUE, /* partial_inplace */
1052 0x007fff00, /* src_mask */
1053 0x007fff00, /* dst_mask */
1054 FALSE), /* pcrel_offset */
1055 HOWTO (R_C6000_SBR_GOT_L16_W, /* type */
1056 2, /* rightshift */
1057 2, /* size (0 = byte, 1 = short, 2 = long) */
1058 16, /* bitsize */
1059 FALSE, /* pc_relative */
1060 7, /* bitpos */
1061 complain_overflow_dont,/* complain_on_overflow */
1062 bfd_elf_generic_reloc, /* special_function */
1063 "R_C6000_SBR_GOT_L16_W",/* name */
1064 TRUE, /* partial_inplace */
1065 0x007fff80, /* src_mask */
1066 0x007fff80, /* dst_mask */
1067 FALSE), /* pcrel_offset */
1068 EMPTY_HOWTO (R_C6000_SBR_GOT_H16_W),
1069 HOWTO (R_C6000_DSBT_INDEX, /* type */
1070 0, /* rightshift */
1071 2, /* size (0 = byte, 1 = short, 2 = long) */
1072 15, /* bitsize */
1073 FALSE, /* pc_relative */
1074 8, /* bitpos */
1075 complain_overflow_unsigned,/* complain_on_overflow */
1076 bfd_elf_generic_reloc, /* special_function */
1077 "R_C6000_DSBT_INDEX", /* name */
1078 TRUE, /* partial_inplace */
1079 0, /* src_mask */
1080 0x007fff00, /* dst_mask */
1081 FALSE), /* pcrel_offset */
1082 HOWTO (R_C6000_PREL31, /* type */
1083 1, /* rightshift */
1084 2, /* size (0 = byte, 1 = short, 2 = long) */
1085 31, /* bitsize */
1086 TRUE, /* pc_relative */
1087 0, /* bitpos */
1088 complain_overflow_dont,/* complain_on_overflow */
1089 bfd_elf_generic_reloc, /* special_function */
1090 "R_C6000_PREL31", /* name */
1091 TRUE, /* partial_inplace */
1092 0, /* src_mask */
1093 0x7fffffff, /* dst_mask */
1094 TRUE), /* pcrel_offset */
1095 HOWTO (R_C6000_COPY, /* type */
1096 0, /* rightshift */
1097 2, /* size (0 = byte, 1 = short, 2 = long) */
1098 32, /* bitsize */
1099 FALSE, /* pc_relative */
1100 0, /* bitpos */
1101 complain_overflow_dont,/* complain_on_overflow */
1102 bfd_elf_generic_reloc, /* special_function */
1103 "R_C6000_COPY", /* name */
1104 TRUE, /* partial_inplace */
1105 0, /* src_mask */
1106 0xffffffff, /* dst_mask */
1107 FALSE), /* pcrel_offset */
1108 HOWTO (R_C6000_JUMP_SLOT, /* type */
1109 0, /* rightshift */
1110 2, /* size (0 = byte, 1 = short, 2 = long) */
1111 32, /* bitsize */
1112 FALSE, /* pc_relative */
1113 0, /* bitpos */
1114 complain_overflow_dont,/* complain_on_overflow */
1115 bfd_elf_generic_reloc, /* special_function */
1116 "R_C6000_JUMP_SLOT", /* name */
1117 FALSE, /* partial_inplace */
1118 0, /* src_mask */
1119 0xffffffff, /* dst_mask */
1120 FALSE), /* pcrel_offset */
1121 HOWTO (R_C6000_EHTYPE, /* type */
1122 0, /* rightshift */
1123 2, /* size (0 = byte, 1 = short, 2 = long) */
1124 32, /* bitsize */
1125 FALSE, /* pc_relative */
1126 0, /* bitpos */
1127 complain_overflow_dont,/* complain_on_overflow */
1128 bfd_elf_generic_reloc, /* special_function */
1129 "R_C6000_EHTYPE", /* name */
1130 FALSE, /* partial_inplace */
1131 0, /* src_mask */
1132 0xffffffff, /* dst_mask */
1133 FALSE), /* pcrel_offset */
1134 EMPTY_HOWTO (R_C6000_PCR_H16),
1135 EMPTY_HOWTO (R_C6000_PCR_L16),
1136 EMPTY_HOWTO (31),
1137 EMPTY_HOWTO (32),
1138 EMPTY_HOWTO (33),
1139 EMPTY_HOWTO (34),
1140 EMPTY_HOWTO (35),
1141 EMPTY_HOWTO (36),
1142 EMPTY_HOWTO (37),
1143 EMPTY_HOWTO (38),
1144 EMPTY_HOWTO (39),
1145 EMPTY_HOWTO (40),
1146 EMPTY_HOWTO (41),
1147 EMPTY_HOWTO (42),
1148 EMPTY_HOWTO (43),
1149 EMPTY_HOWTO (44),
1150 EMPTY_HOWTO (45),
1151 EMPTY_HOWTO (46),
1152 EMPTY_HOWTO (47),
1153 EMPTY_HOWTO (48),
1154 EMPTY_HOWTO (49),
1155 EMPTY_HOWTO (50),
1156 EMPTY_HOWTO (51),
1157 EMPTY_HOWTO (52),
1158 EMPTY_HOWTO (53),
1159 EMPTY_HOWTO (54),
1160 EMPTY_HOWTO (55),
1161 EMPTY_HOWTO (56),
1162 EMPTY_HOWTO (57),
1163 EMPTY_HOWTO (58),
1164 EMPTY_HOWTO (59),
1165 EMPTY_HOWTO (60),
1166 EMPTY_HOWTO (61),
1167 EMPTY_HOWTO (62),
1168 EMPTY_HOWTO (63),
1169 EMPTY_HOWTO (64),
1170 EMPTY_HOWTO (65),
1171 EMPTY_HOWTO (66),
1172 EMPTY_HOWTO (67),
1173 EMPTY_HOWTO (68),
1174 EMPTY_HOWTO (69),
1175 EMPTY_HOWTO (70),
1176 EMPTY_HOWTO (71),
1177 EMPTY_HOWTO (72),
1178 EMPTY_HOWTO (73),
1179 EMPTY_HOWTO (74),
1180 EMPTY_HOWTO (75),
1181 EMPTY_HOWTO (76),
1182 EMPTY_HOWTO (77),
1183 EMPTY_HOWTO (78),
1184 EMPTY_HOWTO (79),
1185 EMPTY_HOWTO (80),
1186 EMPTY_HOWTO (81),
1187 EMPTY_HOWTO (82),
1188 EMPTY_HOWTO (83),
1189 EMPTY_HOWTO (84),
1190 EMPTY_HOWTO (85),
1191 EMPTY_HOWTO (86),
1192 EMPTY_HOWTO (87),
1193 EMPTY_HOWTO (88),
1194 EMPTY_HOWTO (89),
1195 EMPTY_HOWTO (90),
1196 EMPTY_HOWTO (91),
1197 EMPTY_HOWTO (92),
1198 EMPTY_HOWTO (93),
1199 EMPTY_HOWTO (94),
1200 EMPTY_HOWTO (95),
1201 EMPTY_HOWTO (96),
1202 EMPTY_HOWTO (97),
1203 EMPTY_HOWTO (98),
1204 EMPTY_HOWTO (99),
1205 EMPTY_HOWTO (100),
1206 EMPTY_HOWTO (101),
1207 EMPTY_HOWTO (102),
1208 EMPTY_HOWTO (103),
1209 EMPTY_HOWTO (104),
1210 EMPTY_HOWTO (105),
1211 EMPTY_HOWTO (106),
1212 EMPTY_HOWTO (107),
1213 EMPTY_HOWTO (108),
1214 EMPTY_HOWTO (109),
1215 EMPTY_HOWTO (110),
1216 EMPTY_HOWTO (111),
1217 EMPTY_HOWTO (112),
1218 EMPTY_HOWTO (113),
1219 EMPTY_HOWTO (114),
1220 EMPTY_HOWTO (115),
1221 EMPTY_HOWTO (116),
1222 EMPTY_HOWTO (117),
1223 EMPTY_HOWTO (118),
1224 EMPTY_HOWTO (119),
1225 EMPTY_HOWTO (120),
1226 EMPTY_HOWTO (121),
1227 EMPTY_HOWTO (122),
1228 EMPTY_HOWTO (123),
1229 EMPTY_HOWTO (124),
1230 EMPTY_HOWTO (125),
1231 EMPTY_HOWTO (126),
1232 EMPTY_HOWTO (127),
1233 EMPTY_HOWTO (128),
1234 EMPTY_HOWTO (129),
1235 EMPTY_HOWTO (130),
1236 EMPTY_HOWTO (131),
1237 EMPTY_HOWTO (132),
1238 EMPTY_HOWTO (133),
1239 EMPTY_HOWTO (134),
1240 EMPTY_HOWTO (135),
1241 EMPTY_HOWTO (136),
1242 EMPTY_HOWTO (137),
1243 EMPTY_HOWTO (138),
1244 EMPTY_HOWTO (139),
1245 EMPTY_HOWTO (140),
1246 EMPTY_HOWTO (141),
1247 EMPTY_HOWTO (142),
1248 EMPTY_HOWTO (143),
1249 EMPTY_HOWTO (144),
1250 EMPTY_HOWTO (145),
1251 EMPTY_HOWTO (146),
1252 EMPTY_HOWTO (147),
1253 EMPTY_HOWTO (148),
1254 EMPTY_HOWTO (149),
1255 EMPTY_HOWTO (150),
1256 EMPTY_HOWTO (151),
1257 EMPTY_HOWTO (152),
1258 EMPTY_HOWTO (153),
1259 EMPTY_HOWTO (154),
1260 EMPTY_HOWTO (155),
1261 EMPTY_HOWTO (156),
1262 EMPTY_HOWTO (157),
1263 EMPTY_HOWTO (158),
1264 EMPTY_HOWTO (159),
1265 EMPTY_HOWTO (160),
1266 EMPTY_HOWTO (161),
1267 EMPTY_HOWTO (162),
1268 EMPTY_HOWTO (163),
1269 EMPTY_HOWTO (164),
1270 EMPTY_HOWTO (165),
1271 EMPTY_HOWTO (166),
1272 EMPTY_HOWTO (167),
1273 EMPTY_HOWTO (168),
1274 EMPTY_HOWTO (169),
1275 EMPTY_HOWTO (170),
1276 EMPTY_HOWTO (171),
1277 EMPTY_HOWTO (172),
1278 EMPTY_HOWTO (173),
1279 EMPTY_HOWTO (174),
1280 EMPTY_HOWTO (175),
1281 EMPTY_HOWTO (176),
1282 EMPTY_HOWTO (177),
1283 EMPTY_HOWTO (178),
1284 EMPTY_HOWTO (179),
1285 EMPTY_HOWTO (180),
1286 EMPTY_HOWTO (181),
1287 EMPTY_HOWTO (182),
1288 EMPTY_HOWTO (183),
1289 EMPTY_HOWTO (184),
1290 EMPTY_HOWTO (185),
1291 EMPTY_HOWTO (186),
1292 EMPTY_HOWTO (187),
1293 EMPTY_HOWTO (188),
1294 EMPTY_HOWTO (189),
1295 EMPTY_HOWTO (190),
1296 EMPTY_HOWTO (191),
1297 EMPTY_HOWTO (192),
1298 EMPTY_HOWTO (193),
1299 EMPTY_HOWTO (194),
1300 EMPTY_HOWTO (195),
1301 EMPTY_HOWTO (196),
1302 EMPTY_HOWTO (197),
1303 EMPTY_HOWTO (198),
1304 EMPTY_HOWTO (199),
1305 EMPTY_HOWTO (200),
1306 EMPTY_HOWTO (201),
1307 EMPTY_HOWTO (202),
1308 EMPTY_HOWTO (203),
1309 EMPTY_HOWTO (204),
1310 EMPTY_HOWTO (205),
1311 EMPTY_HOWTO (206),
1312 EMPTY_HOWTO (207),
1313 EMPTY_HOWTO (208),
1314 EMPTY_HOWTO (209),
1315 EMPTY_HOWTO (210),
1316 EMPTY_HOWTO (211),
1317 EMPTY_HOWTO (212),
1318 EMPTY_HOWTO (213),
1319 EMPTY_HOWTO (214),
1320 EMPTY_HOWTO (215),
1321 EMPTY_HOWTO (216),
1322 EMPTY_HOWTO (217),
1323 EMPTY_HOWTO (218),
1324 EMPTY_HOWTO (219),
1325 EMPTY_HOWTO (220),
1326 EMPTY_HOWTO (221),
1327 EMPTY_HOWTO (222),
1328 EMPTY_HOWTO (223),
1329 EMPTY_HOWTO (224),
1330 EMPTY_HOWTO (225),
1331 EMPTY_HOWTO (226),
1332 EMPTY_HOWTO (227),
1333 EMPTY_HOWTO (228),
1334 EMPTY_HOWTO (229),
1335 EMPTY_HOWTO (230),
1336 EMPTY_HOWTO (231),
1337 EMPTY_HOWTO (232),
1338 EMPTY_HOWTO (233),
1339 EMPTY_HOWTO (234),
1340 EMPTY_HOWTO (235),
1341 EMPTY_HOWTO (236),
1342 EMPTY_HOWTO (237),
1343 EMPTY_HOWTO (238),
1344 EMPTY_HOWTO (239),
1345 EMPTY_HOWTO (240),
1346 EMPTY_HOWTO (241),
1347 EMPTY_HOWTO (242),
1348 EMPTY_HOWTO (243),
1349 EMPTY_HOWTO (244),
1350 EMPTY_HOWTO (245),
1351 EMPTY_HOWTO (246),
1352 EMPTY_HOWTO (247),
1353 EMPTY_HOWTO (248),
1354 EMPTY_HOWTO (249),
1355 EMPTY_HOWTO (250),
1356 EMPTY_HOWTO (251),
1357 EMPTY_HOWTO (252),
1358 HOWTO (R_C6000_ALIGN, /* type */
1359 0, /* rightshift */
1360 0, /* size (0 = byte, 1 = short, 2 = long) */
1361 0, /* bitsize */
1362 FALSE, /* pc_relative */
1363 0, /* bitpos */
1364 complain_overflow_dont,/* complain_on_overflow */
1365 bfd_elf_generic_reloc, /* special_function */
1366 "R_C6000_ALIGN", /* name */
1367 TRUE, /* partial_inplace */
1368 0, /* src_mask */
1369 0, /* dst_mask */
1370 FALSE), /* pcrel_offset */
1371 HOWTO (R_C6000_FPHEAD, /* type */
1372 0, /* rightshift */
1373 0, /* size (0 = byte, 1 = short, 2 = long) */
1374 0, /* bitsize */
1375 FALSE, /* pc_relative */
1376 0, /* bitpos */
1377 complain_overflow_dont,/* complain_on_overflow */
1378 bfd_elf_generic_reloc, /* special_function */
1379 "R_C6000_FPHEAD", /* name */
1380 TRUE, /* partial_inplace */
1381 0, /* src_mask */
1382 0, /* dst_mask */
1383 FALSE), /* pcrel_offset */
1384 HOWTO (R_C6000_NOCMP, /* type */
1385 0, /* rightshift */
1386 0, /* size (0 = byte, 1 = short, 2 = long) */
1387 0, /* bitsize */
1388 FALSE, /* pc_relative */
1389 0, /* bitpos */
1390 complain_overflow_dont,/* complain_on_overflow */
1391 bfd_elf_generic_reloc, /* special_function */
1392 "R_C6000_NOCMP", /* name */
1393 TRUE, /* partial_inplace */
1394 0, /* src_mask */
1395 0, /* dst_mask */
1396 FALSE) /* pcrel_offset */
1397 };
1398
1399 /* Map BFD relocations to ELF relocations. */
1400
1401 typedef struct
1402 {
1403 bfd_reloc_code_real_type bfd_reloc_val;
1404 enum elf_tic6x_reloc_type elf_reloc_val;
1405 } tic6x_reloc_map;
1406
1407 static const tic6x_reloc_map elf32_tic6x_reloc_map[] =
1408 {
1409 { BFD_RELOC_NONE, R_C6000_NONE },
1410 { BFD_RELOC_32, R_C6000_ABS32 },
1411 { BFD_RELOC_16, R_C6000_ABS16 },
1412 { BFD_RELOC_8, R_C6000_ABS8 },
1413 { BFD_RELOC_C6000_PCR_S21, R_C6000_PCR_S21 },
1414 { BFD_RELOC_C6000_PCR_S12, R_C6000_PCR_S12 },
1415 { BFD_RELOC_C6000_PCR_S10, R_C6000_PCR_S10 },
1416 { BFD_RELOC_C6000_PCR_S7, R_C6000_PCR_S7 },
1417 { BFD_RELOC_C6000_ABS_S16, R_C6000_ABS_S16 },
1418 { BFD_RELOC_C6000_ABS_L16, R_C6000_ABS_L16 },
1419 { BFD_RELOC_C6000_ABS_H16, R_C6000_ABS_H16 },
1420 { BFD_RELOC_C6000_SBR_U15_B, R_C6000_SBR_U15_B },
1421 { BFD_RELOC_C6000_SBR_U15_H, R_C6000_SBR_U15_H },
1422 { BFD_RELOC_C6000_SBR_U15_W, R_C6000_SBR_U15_W },
1423 { BFD_RELOC_C6000_SBR_S16, R_C6000_SBR_S16 },
1424 { BFD_RELOC_C6000_SBR_L16_B, R_C6000_SBR_L16_B },
1425 { BFD_RELOC_C6000_SBR_L16_H, R_C6000_SBR_L16_H },
1426 { BFD_RELOC_C6000_SBR_L16_W, R_C6000_SBR_L16_W },
1427 { BFD_RELOC_C6000_SBR_H16_B, R_C6000_SBR_H16_B },
1428 { BFD_RELOC_C6000_SBR_H16_H, R_C6000_SBR_H16_H },
1429 { BFD_RELOC_C6000_SBR_H16_W, R_C6000_SBR_H16_W },
1430 { BFD_RELOC_C6000_SBR_GOT_U15_W, R_C6000_SBR_GOT_U15_W },
1431 { BFD_RELOC_C6000_SBR_GOT_L16_W, R_C6000_SBR_GOT_L16_W },
1432 { BFD_RELOC_C6000_SBR_GOT_H16_W, R_C6000_SBR_GOT_H16_W },
1433 { BFD_RELOC_C6000_DSBT_INDEX, R_C6000_DSBT_INDEX },
1434 { BFD_RELOC_C6000_PREL31, R_C6000_PREL31 },
1435 { BFD_RELOC_C6000_COPY, R_C6000_COPY },
1436 { BFD_RELOC_C6000_JUMP_SLOT, R_C6000_JUMP_SLOT },
1437 { BFD_RELOC_C6000_EHTYPE, R_C6000_EHTYPE },
1438 { BFD_RELOC_C6000_PCR_H16, R_C6000_PCR_H16 },
1439 { BFD_RELOC_C6000_PCR_L16, R_C6000_PCR_L16 },
1440 { BFD_RELOC_C6000_ALIGN, R_C6000_ALIGN },
1441 { BFD_RELOC_C6000_FPHEAD, R_C6000_FPHEAD },
1442 { BFD_RELOC_C6000_NOCMP, R_C6000_NOCMP }
1443 };
1444
1445 static reloc_howto_type *
1446 elf32_tic6x_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code)
1447 {
1448 unsigned int i;
1449
1450 for (i = 0; i < ARRAY_SIZE (elf32_tic6x_reloc_map); i++)
1451 if (elf32_tic6x_reloc_map[i].bfd_reloc_val == code)
1452 {
1453 enum elf_tic6x_reloc_type elf_reloc_val;
1454 reloc_howto_type *howto;
1455
1456 elf_reloc_val = elf32_tic6x_reloc_map[i].elf_reloc_val;
1457 if (elf32_tic6x_tdata (abfd)->use_rela_p)
1458 howto = &elf32_tic6x_howto_table[elf_reloc_val];
1459 else
1460 howto = &elf32_tic6x_howto_table_rel[elf_reloc_val];
1461
1462 /* Some relocations are RELA-only; do not return them for
1463 REL. */
1464 if (howto->name == NULL)
1465 howto = NULL;
1466
1467 return howto;
1468 }
1469
1470 return NULL;
1471 }
1472
1473 static reloc_howto_type *
1474 elf32_tic6x_reloc_name_lookup (bfd *abfd, const char *r_name)
1475 {
1476 if (elf32_tic6x_tdata (abfd)->use_rela_p)
1477 {
1478 unsigned int i;
1479
1480 for (i = 0; i < ARRAY_SIZE (elf32_tic6x_howto_table); i++)
1481 if (elf32_tic6x_howto_table[i].name != NULL
1482 && strcasecmp (elf32_tic6x_howto_table[i].name, r_name) == 0)
1483 return &elf32_tic6x_howto_table[i];
1484 }
1485 else
1486 {
1487 unsigned int i;
1488
1489 for (i = 0; i < ARRAY_SIZE (elf32_tic6x_howto_table_rel); i++)
1490 if (elf32_tic6x_howto_table_rel[i].name != NULL
1491 && strcasecmp (elf32_tic6x_howto_table_rel[i].name, r_name) == 0)
1492 return &elf32_tic6x_howto_table_rel[i];
1493 }
1494
1495 return NULL;
1496 }
1497
1498 static void
1499 elf32_tic6x_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *bfd_reloc,
1500 Elf_Internal_Rela *elf_reloc)
1501 {
1502 unsigned int r_type;
1503
1504 r_type = ELF32_R_TYPE (elf_reloc->r_info);
1505 if (r_type >= ARRAY_SIZE (elf32_tic6x_howto_table))
1506 bfd_reloc->howto = NULL;
1507 else
1508 bfd_reloc->howto = &elf32_tic6x_howto_table[r_type];
1509 }
1510
1511 static void
1512 elf32_tic6x_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED, arelent *bfd_reloc,
1513 Elf_Internal_Rela *elf_reloc)
1514 {
1515 unsigned int r_type;
1516
1517 r_type = ELF32_R_TYPE (elf_reloc->r_info);
1518 if (r_type >= ARRAY_SIZE (elf32_tic6x_howto_table_rel))
1519 bfd_reloc->howto = NULL;
1520 else
1521 bfd_reloc->howto = &elf32_tic6x_howto_table_rel[r_type];
1522 }
1523
1524 void
1525 elf32_tic6x_set_use_rela_p (bfd *abfd, bfd_boolean use_rela_p)
1526 {
1527 elf32_tic6x_tdata (abfd)->use_rela_p = use_rela_p;
1528 }
1529
1530 /* Create an entry in a C6X ELF linker hash table. */
1531
1532 static struct bfd_hash_entry *
1533 elf32_tic6x_link_hash_newfunc (struct bfd_hash_entry *entry,
1534 struct bfd_hash_table *table,
1535 const char *string)
1536 {
1537 /* Allocate the structure if it has not already been allocated by a
1538 subclass. */
1539 if (entry == NULL)
1540 {
1541 entry = bfd_hash_allocate (table,
1542 sizeof (struct elf32_tic6x_link_hash_entry));
1543 if (entry == NULL)
1544 return entry;
1545 }
1546
1547 /* Call the allocation method of the superclass. */
1548 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
1549 if (entry != NULL)
1550 {
1551 struct elf32_tic6x_link_hash_entry *eh;
1552
1553 eh = (struct elf32_tic6x_link_hash_entry *) entry;
1554 eh->dyn_relocs = NULL;
1555 }
1556
1557 return entry;
1558 }
1559
1560 /* Create a C6X ELF linker hash table. */
1561
1562 static struct bfd_link_hash_table *
1563 elf32_tic6x_link_hash_table_create (bfd *abfd)
1564 {
1565 struct elf32_tic6x_link_hash_table *ret;
1566 bfd_size_type amt = sizeof (struct elf32_tic6x_link_hash_table);
1567
1568 ret = bfd_zmalloc (amt);
1569 if (ret == NULL)
1570 return NULL;
1571
1572 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
1573 elf32_tic6x_link_hash_newfunc,
1574 sizeof (struct elf32_tic6x_link_hash_entry),
1575 TIC6X_ELF_DATA))
1576 {
1577 free (ret);
1578 return NULL;
1579 }
1580
1581 ret->obfd = abfd;
1582 ret->elf.is_relocatable_executable = 1;
1583
1584 return &ret->elf.root;
1585 }
1586
1587 static bfd_boolean
1588 elf32_tic6x_final_link (bfd *abfd, struct bfd_link_info *info)
1589 {
1590 if (bfd_link_pic (info))
1591 {
1592 obj_attribute *out_attr;
1593 out_attr = elf_known_obj_attributes_proc (abfd);
1594 if (out_attr[Tag_ABI_PIC].i == 0)
1595 {
1596 _bfd_error_handler (_("warning: generating a shared library "
1597 "containing non-PIC code"));
1598 }
1599 if (out_attr[Tag_ABI_PID].i == 0)
1600 {
1601 _bfd_error_handler (_("warning: generating a shared library "
1602 "containing non-PID code"));
1603 }
1604 }
1605 /* Invoke the regular ELF backend linker to do all the work. */
1606 if (!bfd_elf_final_link (abfd, info))
1607 return FALSE;
1608
1609 return TRUE;
1610 }
1611
1612 /* Called to pass PARAMS to the backend. We store them in the hash table
1613 associated with INFO. */
1614
1615 void
1616 elf32_tic6x_setup (struct bfd_link_info *info,
1617 struct elf32_tic6x_params *params)
1618 {
1619 struct elf32_tic6x_link_hash_table *htab = elf32_tic6x_hash_table (info);
1620 htab->params = *params;
1621 }
1622
1623 /* Determine if we're dealing with a DSBT object. */
1624
1625 static bfd_boolean
1626 elf32_tic6x_using_dsbt (bfd *abfd)
1627 {
1628 return bfd_elf_get_obj_attr_int (abfd, OBJ_ATTR_PROC,
1629 Tag_ABI_DSBT);
1630 }
1631
1632 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got and .dsbt
1633 sections in DYNOBJ, and set up shortcuts to them in our hash
1634 table. */
1635
1636 static bfd_boolean
1637 elf32_tic6x_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
1638 {
1639 struct elf32_tic6x_link_hash_table *htab;
1640 flagword flags;
1641
1642 htab = elf32_tic6x_hash_table (info);
1643 if (htab == NULL)
1644 return FALSE;
1645
1646 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
1647 return FALSE;
1648
1649 /* Create .dsbt */
1650 flags = (SEC_ALLOC | SEC_LOAD
1651 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1652 htab->dsbt = bfd_make_section_anyway_with_flags (dynobj, ".dsbt",
1653 flags);
1654 if (htab->dsbt == NULL
1655 || ! bfd_set_section_alignment (dynobj, htab->dsbt, 2)
1656 || ! bfd_set_section_alignment (dynobj, htab->elf.splt, 5))
1657 return FALSE;
1658
1659 return TRUE;
1660 }
1661
1662 static bfd_boolean
1663 elf32_tic6x_mkobject (bfd *abfd)
1664 {
1665 bfd_boolean ret;
1666
1667 ret = bfd_elf_allocate_object (abfd, sizeof (struct elf32_tic6x_obj_tdata),
1668 TIC6X_ELF_DATA);
1669 if (ret)
1670 elf32_tic6x_set_use_rela_p (abfd, TRUE);
1671 return ret;
1672 }
1673
1674 /* Install relocation RELA into section SRELA, incrementing its
1675 reloc_count. */
1676
1677 static void
1678 elf32_tic6x_install_rela (bfd *output_bfd, asection *srela,
1679 Elf_Internal_Rela *rela)
1680 {
1681 bfd_byte *loc;
1682 bfd_vma off = srela->reloc_count++ * sizeof (Elf32_External_Rela);
1683 loc = srela->contents + off;
1684 BFD_ASSERT (off < srela->size);
1685 bfd_elf32_swap_reloca_out (output_bfd, rela, loc);
1686 }
1687
1688 /* Create a dynamic reloc against the GOT at offset OFFSET. The contents
1689 of the GOT at this offset have been initialized with the relocation. */
1690
1691 static void
1692 elf32_tic6x_make_got_dynreloc (bfd *output_bfd,
1693 struct elf32_tic6x_link_hash_table *htab,
1694 asection *sym_sec, bfd_vma offset)
1695 {
1696 asection *sgot = htab->elf.sgot;
1697 Elf_Internal_Rela outrel;
1698 int dynindx;
1699
1700 outrel.r_offset = sgot->output_section->vma + sgot->output_offset + offset;
1701 outrel.r_addend = bfd_get_32 (output_bfd, sgot->contents + offset);
1702 if (sym_sec && sym_sec->output_section
1703 && ! bfd_is_abs_section (sym_sec->output_section)
1704 && ! bfd_is_und_section (sym_sec->output_section))
1705 {
1706 dynindx = elf_section_data (sym_sec->output_section)->dynindx;
1707 outrel.r_addend -= sym_sec->output_section->vma;
1708 }
1709 else
1710 {
1711 dynindx = 0;
1712 }
1713 outrel.r_info = ELF32_R_INFO (dynindx, R_C6000_ABS32);
1714 elf32_tic6x_install_rela (output_bfd, htab->elf.srelgot, &outrel);
1715 }
1716
1717 /* Finish up dynamic symbol handling. We set the contents of various
1718 dynamic sections here. */
1719
1720 static bfd_boolean
1721 elf32_tic6x_finish_dynamic_symbol (bfd * output_bfd,
1722 struct bfd_link_info *info,
1723 struct elf_link_hash_entry *h,
1724 Elf_Internal_Sym * sym)
1725 {
1726 struct elf32_tic6x_link_hash_table *htab;
1727
1728 htab = elf32_tic6x_hash_table (info);
1729
1730 if (h->plt.offset != (bfd_vma) -1)
1731 {
1732 bfd_vma plt_index;
1733 bfd_vma got_section_offset, got_dp_offset, rela_offset;
1734 Elf_Internal_Rela rela;
1735 bfd_byte *loc;
1736 asection *plt, *gotplt, *relplt;
1737 const struct elf_backend_data *bed;
1738
1739 bed = get_elf_backend_data (output_bfd);
1740
1741 BFD_ASSERT (htab->elf.splt != NULL);
1742 plt = htab->elf.splt;
1743 gotplt = htab->elf.sgotplt;
1744 relplt = htab->elf.srelplt;
1745
1746 /* This symbol has an entry in the procedure linkage table. Set
1747 it up. */
1748
1749 if ((h->dynindx == -1
1750 && !((h->forced_local || bfd_link_executable (info))
1751 && h->def_regular
1752 && h->type == STT_GNU_IFUNC))
1753 || plt == NULL
1754 || gotplt == NULL
1755 || relplt == NULL)
1756 abort ();
1757
1758 /* Get the index in the procedure linkage table which
1759 corresponds to this symbol. This is the index of this symbol
1760 in all the symbols for which we are making plt entries. The
1761 first entry in the procedure linkage table is reserved.
1762
1763 Get the offset into the .got table of the entry that
1764 corresponds to this function. Each .got entry is 4 bytes.
1765 The first three are reserved.
1766
1767 For static executables, we don't reserve anything. */
1768
1769 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1770 got_section_offset = plt_index + bed->got_header_size / 4;
1771 got_dp_offset = got_section_offset + htab->params.dsbt_size;
1772 rela_offset = plt_index * sizeof (Elf32_External_Rela);
1773
1774 got_section_offset *= 4;
1775
1776 /* Fill in the entry in the procedure linkage table. */
1777
1778 /* ldw .d2t2 *+B14($GOT(f)), b2 */
1779 bfd_put_32 (output_bfd, got_dp_offset << 8 | 0x0100006e,
1780 plt->contents + h->plt.offset);
1781 /* mvk .s2 low(rela_offset), b0 */
1782 bfd_put_32 (output_bfd, (rela_offset & 0xffff) << 7 | 0x0000002a,
1783 plt->contents + h->plt.offset + 4);
1784 /* mvkh .s2 high(rela_offset), b0 */
1785 bfd_put_32 (output_bfd, ((rela_offset >> 16) & 0xffff) << 7 | 0x0000006a,
1786 plt->contents + h->plt.offset + 8);
1787 /* nop 2 */
1788 bfd_put_32 (output_bfd, 0x00002000,
1789 plt->contents + h->plt.offset + 12);
1790 /* b .s2 b2 */
1791 bfd_put_32 (output_bfd, 0x00080362,
1792 plt->contents + h->plt.offset + 16);
1793 /* nop 5 */
1794 bfd_put_32 (output_bfd, 0x00008000,
1795 plt->contents + h->plt.offset + 20);
1796
1797 /* Fill in the entry in the global offset table. */
1798 bfd_put_32 (output_bfd,
1799 (plt->output_section->vma + plt->output_offset),
1800 gotplt->contents + got_section_offset);
1801
1802 /* Fill in the entry in the .rel.plt section. */
1803 rela.r_offset = (gotplt->output_section->vma
1804 + gotplt->output_offset
1805 + got_section_offset);
1806 rela.r_info = ELF32_R_INFO (h->dynindx, R_C6000_JUMP_SLOT);
1807 rela.r_addend = 0;
1808 loc = relplt->contents + rela_offset;
1809 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1810
1811 if (!h->def_regular)
1812 {
1813 /* Mark the symbol as undefined, rather than as defined in
1814 the .plt section. */
1815 sym->st_shndx = SHN_UNDEF;
1816 sym->st_value = 0;
1817 }
1818 }
1819
1820 if (h->got.offset != (bfd_vma) -1)
1821 {
1822 asection *sgot;
1823 asection *srela;
1824
1825 /* This symbol has an entry in the global offset table.
1826 Set it up. */
1827
1828 sgot = htab->elf.sgot;
1829 srela = htab->elf.srelgot;
1830 BFD_ASSERT (sgot != NULL && srela != NULL);
1831
1832 /* If this is a -Bsymbolic link, and the symbol is defined
1833 locally, we just want to emit a RELATIVE reloc. Likewise if
1834 the symbol was forced to be local because of a version file.
1835 The entry in the global offset table will already have been
1836 initialized in the relocate_section function. */
1837 if (bfd_link_pic (info)
1838 && (SYMBOLIC_BIND (info, h)
1839 || h->dynindx == -1 || h->forced_local) && h->def_regular)
1840 {
1841 asection *s = h->root.u.def.section;
1842 elf32_tic6x_make_got_dynreloc (output_bfd, htab, s,
1843 h->got.offset & ~(bfd_vma) 1);
1844 }
1845 else
1846 {
1847 Elf_Internal_Rela outrel;
1848 bfd_put_32 (output_bfd, (bfd_vma) 0,
1849 sgot->contents + (h->got.offset & ~(bfd_vma) 1));
1850 outrel.r_offset = (sgot->output_section->vma
1851 + sgot->output_offset
1852 + (h->got.offset & ~(bfd_vma) 1));
1853 outrel.r_info = ELF32_R_INFO (h->dynindx, R_C6000_ABS32);
1854 outrel.r_addend = 0;
1855
1856 elf32_tic6x_install_rela (output_bfd, srela, &outrel);
1857 }
1858 }
1859
1860 if (h->needs_copy)
1861 {
1862 Elf_Internal_Rela rel;
1863
1864 /* This symbol needs a copy reloc. Set it up. */
1865
1866 if (h->dynindx == -1
1867 || (h->root.type != bfd_link_hash_defined
1868 && h->root.type != bfd_link_hash_defweak)
1869 || htab->elf.srelbss == NULL)
1870 abort ();
1871
1872 rel.r_offset = (h->root.u.def.value
1873 + h->root.u.def.section->output_section->vma
1874 + h->root.u.def.section->output_offset);
1875 rel.r_info = ELF32_R_INFO (h->dynindx, R_C6000_COPY);
1876 rel.r_addend = 0;
1877
1878 elf32_tic6x_install_rela (output_bfd, htab->elf.srelbss, &rel);
1879 }
1880
1881 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
1882 if (h == elf_hash_table (info)->hdynamic
1883 || h == elf_hash_table (info)->hgot)
1884 sym->st_shndx = SHN_ABS;
1885
1886 return TRUE;
1887 }
1888
1889 /* Unwinding tables are not referenced directly. This pass marks them as
1890 required if the corresponding code section is marked. */
1891
1892 static bfd_boolean
1893 elf32_tic6x_gc_mark_extra_sections (struct bfd_link_info *info,
1894 elf_gc_mark_hook_fn gc_mark_hook)
1895 {
1896 bfd *sub;
1897 Elf_Internal_Shdr **elf_shdrp;
1898 bfd_boolean again;
1899
1900 _bfd_elf_gc_mark_extra_sections (info, gc_mark_hook);
1901
1902 /* Marking EH data may cause additional code sections to be marked,
1903 requiring multiple passes. */
1904 again = TRUE;
1905 while (again)
1906 {
1907 again = FALSE;
1908 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
1909 {
1910 asection *o;
1911
1912 if (! is_tic6x_elf (sub))
1913 continue;
1914
1915 elf_shdrp = elf_elfsections (sub);
1916 for (o = sub->sections; o != NULL; o = o->next)
1917 {
1918 Elf_Internal_Shdr *hdr;
1919
1920 hdr = &elf_section_data (o)->this_hdr;
1921 if (hdr->sh_type == SHT_C6000_UNWIND
1922 && hdr->sh_link
1923 && hdr->sh_link < elf_numsections (sub)
1924 && !o->gc_mark
1925 && elf_shdrp[hdr->sh_link]->bfd_section->gc_mark)
1926 {
1927 again = TRUE;
1928 if (!_bfd_elf_gc_mark (info, o, gc_mark_hook))
1929 return FALSE;
1930 }
1931 }
1932 }
1933 }
1934
1935 return TRUE;
1936 }
1937
1938 /* Return TRUE if this is an unwinding table index. */
1939
1940 static bfd_boolean
1941 is_tic6x_elf_unwind_section_name (const char *name)
1942 {
1943 return (CONST_STRNEQ (name, ELF_STRING_C6000_unwind)
1944 || CONST_STRNEQ (name, ELF_STRING_C6000_unwind_once));
1945 }
1946
1947
1948 /* Set the type and flags for an unwinding index table. We do this by
1949 the section name, which is a hack, but ought to work. */
1950
1951 static bfd_boolean
1952 elf32_tic6x_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
1953 Elf_Internal_Shdr *hdr, asection *sec)
1954 {
1955 const char * name;
1956
1957 name = bfd_get_section_name (abfd, sec);
1958
1959 if (is_tic6x_elf_unwind_section_name (name))
1960 {
1961 hdr->sh_type = SHT_C6000_UNWIND;
1962 hdr->sh_flags |= SHF_LINK_ORDER;
1963 }
1964
1965 return TRUE;
1966 }
1967
1968 /* Update the got entry reference counts for the section being removed. */
1969
1970 static bfd_boolean
1971 elf32_tic6x_gc_sweep_hook (bfd *abfd,
1972 struct bfd_link_info *info,
1973 asection *sec,
1974 const Elf_Internal_Rela *relocs)
1975 {
1976 struct elf32_tic6x_link_hash_table *htab;
1977 Elf_Internal_Shdr *symtab_hdr;
1978 struct elf_link_hash_entry **sym_hashes;
1979 bfd_signed_vma *local_got_refcounts;
1980 const Elf_Internal_Rela *rel, *relend;
1981
1982 if (bfd_link_relocatable (info))
1983 return TRUE;
1984
1985 htab = elf32_tic6x_hash_table (info);
1986 if (htab == NULL)
1987 return FALSE;
1988
1989 elf_section_data (sec)->local_dynrel = NULL;
1990
1991 symtab_hdr = &elf_symtab_hdr (abfd);
1992 sym_hashes = elf_sym_hashes (abfd);
1993 local_got_refcounts = elf_local_got_refcounts (abfd);
1994
1995 relend = relocs + sec->reloc_count;
1996 for (rel = relocs; rel < relend; rel++)
1997 {
1998 unsigned long r_symndx;
1999 unsigned int r_type;
2000 struct elf_link_hash_entry *h = NULL;
2001
2002 r_symndx = ELF32_R_SYM (rel->r_info);
2003 if (r_symndx >= symtab_hdr->sh_info)
2004 {
2005 struct elf32_tic6x_link_hash_entry *eh;
2006 struct elf_dyn_relocs **pp;
2007 struct elf_dyn_relocs *p;
2008
2009 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2010 while (h->root.type == bfd_link_hash_indirect
2011 || h->root.type == bfd_link_hash_warning)
2012 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2013 eh = (struct elf32_tic6x_link_hash_entry *) h;
2014
2015 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
2016 if (p->sec == sec)
2017 {
2018 /* Everything must go for SEC. */
2019 *pp = p->next;
2020 break;
2021 }
2022 }
2023
2024 r_type = ELF32_R_TYPE (rel->r_info);
2025
2026 switch (r_type)
2027 {
2028 case R_C6000_SBR_GOT_U15_W:
2029 case R_C6000_SBR_GOT_L16_W:
2030 case R_C6000_SBR_GOT_H16_W:
2031 case R_C6000_EHTYPE:
2032 if (h != NULL)
2033 {
2034 if (h->got.refcount > 0)
2035 h->got.refcount -= 1;
2036 }
2037 else if (local_got_refcounts != NULL)
2038 {
2039 if (local_got_refcounts[r_symndx] > 0)
2040 local_got_refcounts[r_symndx] -= 1;
2041 }
2042 break;
2043
2044 default:
2045 break;
2046 }
2047 }
2048
2049 return TRUE;
2050 }
2051
2052 /* Adjust a symbol defined by a dynamic object and referenced by a
2053 regular object. The current definition is in some section of the
2054 dynamic object, but we're not including those sections. We have to
2055 change the definition to something the rest of the link can
2056 understand. */
2057
2058 static bfd_boolean
2059 elf32_tic6x_adjust_dynamic_symbol (struct bfd_link_info *info,
2060 struct elf_link_hash_entry *h)
2061 {
2062 struct elf32_tic6x_link_hash_table *htab;
2063 bfd *dynobj;
2064 asection *s;
2065
2066 dynobj = elf_hash_table (info)->dynobj;
2067
2068 /* Make sure we know what is going on here. */
2069 BFD_ASSERT (dynobj != NULL
2070 && (h->needs_plt
2071 || h->u.weakdef != NULL
2072 || (h->def_dynamic && h->ref_regular && !h->def_regular)));
2073
2074 /* If this is a function, put it in the procedure linkage table. We
2075 will fill in the contents of the procedure linkage table later,
2076 when we know the address of the .got section. */
2077 if (h->type == STT_FUNC
2078 || h->needs_plt)
2079 {
2080 if (h->plt.refcount <= 0
2081 || SYMBOL_CALLS_LOCAL (info, h)
2082 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2083 && h->root.type == bfd_link_hash_undefweak))
2084 {
2085 /* This case can occur if we saw a PLT32 reloc in an input
2086 file, but the symbol was never referred to by a dynamic
2087 object, or if all references were garbage collected. In
2088 such a case, we don't actually need to build a procedure
2089 linkage table, and we can just do a PC32 reloc instead. */
2090 h->plt.offset = (bfd_vma) -1;
2091 h->needs_plt = 0;
2092 }
2093
2094 return TRUE;
2095 }
2096
2097 /* If this is a weak symbol, and there is a real definition, the
2098 processor independent code will have arranged for us to see the
2099 real definition first, and we can just use the same value. */
2100 if (h->u.weakdef != NULL)
2101 {
2102 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2103 || h->u.weakdef->root.type == bfd_link_hash_defweak);
2104 h->root.u.def.section = h->u.weakdef->root.u.def.section;
2105 h->root.u.def.value = h->u.weakdef->root.u.def.value;
2106 h->non_got_ref = h->u.weakdef->non_got_ref;
2107 return TRUE;
2108 }
2109
2110 /* This is a reference to a symbol defined by a dynamic object which
2111 is not a function. */
2112
2113 /* If we are creating a shared library, we must presume that the
2114 only references to the symbol are via the global offset table.
2115 For such cases we need not do anything here; the relocations will
2116 be handled correctly by relocate_section. */
2117 if (bfd_link_pic (info))
2118 return TRUE;
2119
2120 /* If there are no references to this symbol that do not use the
2121 GOT, we don't need to generate a copy reloc. */
2122 if (!h->non_got_ref)
2123 return TRUE;
2124
2125 /* If -z nocopyreloc was given, we won't generate them either. */
2126 if (info->nocopyreloc)
2127 {
2128 h->non_got_ref = 0;
2129 return TRUE;
2130 }
2131
2132 htab = elf32_tic6x_hash_table (info);
2133 if (htab == NULL)
2134 return FALSE;
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_C6000_COPY reloc to tell the dynamic linker to
2147 copy the initial value out of the dynamic object and into the
2148 runtime process image. */
2149 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
2150 {
2151 htab->elf.srelbss->size += sizeof (Elf32_External_Rela);
2152 h->needs_copy = 1;
2153 }
2154
2155 s = htab->elf.sdynbss;
2156
2157 return _bfd_elf_adjust_dynamic_copy (info, h, s);
2158 }
2159
2160 static bfd_boolean
2161 elf32_tic6x_new_section_hook (bfd *abfd, asection *sec)
2162 {
2163 bfd_boolean ret;
2164
2165 /* Allocate target specific section data. */
2166 if (!sec->used_by_bfd)
2167 {
2168 _tic6x_elf_section_data *sdata;
2169 bfd_size_type amt = sizeof (*sdata);
2170
2171 sdata = (_tic6x_elf_section_data *) bfd_zalloc (abfd, amt);
2172 if (sdata == NULL)
2173 return FALSE;
2174 sec->used_by_bfd = sdata;
2175 }
2176
2177 ret = _bfd_elf_new_section_hook (abfd, sec);
2178 sec->use_rela_p = elf32_tic6x_tdata (abfd)->use_rela_p;
2179
2180 return ret;
2181 }
2182
2183 /* Return true if relocation REL against section SEC is a REL rather
2184 than RELA relocation. RELOCS is the first relocation in the
2185 section and ABFD is the bfd that contains SEC. */
2186
2187 static bfd_boolean
2188 elf32_tic6x_rel_relocation_p (bfd *abfd, asection *sec,
2189 const Elf_Internal_Rela *relocs,
2190 const Elf_Internal_Rela *rel)
2191 {
2192 Elf_Internal_Shdr *rel_hdr;
2193 const struct elf_backend_data *bed;
2194
2195 /* To determine which flavor of relocation this is, we depend on the
2196 fact that the INPUT_SECTION's REL_HDR is read before RELA_HDR. */
2197 rel_hdr = elf_section_data (sec)->rel.hdr;
2198 if (rel_hdr == NULL)
2199 return FALSE;
2200 bed = get_elf_backend_data (abfd);
2201 return ((size_t) (rel - relocs)
2202 < NUM_SHDR_ENTRIES (rel_hdr) * bed->s->int_rels_per_ext_rel);
2203 }
2204
2205 /* We need dynamic symbols for every section, since segments can
2206 relocate independently. */
2207 static bfd_boolean
2208 elf32_tic6x_link_omit_section_dynsym (bfd *output_bfd ATTRIBUTE_UNUSED,
2209 struct bfd_link_info *info ATTRIBUTE_UNUSED,
2210 asection *p)
2211 {
2212 switch (elf_section_data (p)->this_hdr.sh_type)
2213 {
2214 case SHT_PROGBITS:
2215 case SHT_NOBITS:
2216 /* If sh_type is yet undecided, assume it could be
2217 SHT_PROGBITS/SHT_NOBITS. */
2218 case SHT_NULL:
2219 return FALSE;
2220
2221 /* There shouldn't be section relative relocations
2222 against any other section. */
2223 default:
2224 return TRUE;
2225 }
2226 }
2227
2228 static bfd_boolean
2229 elf32_tic6x_relocate_section (bfd *output_bfd,
2230 struct bfd_link_info *info,
2231 bfd *input_bfd,
2232 asection *input_section,
2233 bfd_byte *contents,
2234 Elf_Internal_Rela *relocs,
2235 Elf_Internal_Sym *local_syms,
2236 asection **local_sections)
2237 {
2238 struct elf32_tic6x_link_hash_table *htab;
2239 Elf_Internal_Shdr *symtab_hdr;
2240 struct elf_link_hash_entry **sym_hashes;
2241 bfd_vma *local_got_offsets;
2242 Elf_Internal_Rela *rel;
2243 Elf_Internal_Rela *relend;
2244 bfd_boolean ok = TRUE;
2245
2246 htab = elf32_tic6x_hash_table (info);
2247 symtab_hdr = & elf_symtab_hdr (input_bfd);
2248 sym_hashes = elf_sym_hashes (input_bfd);
2249 local_got_offsets = elf_local_got_offsets (input_bfd);
2250
2251 relend = relocs + input_section->reloc_count;
2252
2253 for (rel = relocs; rel < relend; rel ++)
2254 {
2255 int r_type;
2256 unsigned long r_symndx;
2257 arelent bfd_reloc;
2258 reloc_howto_type *howto;
2259 Elf_Internal_Sym *sym;
2260 asection *sec;
2261 struct elf_link_hash_entry *h;
2262 bfd_vma off, off2, relocation;
2263 bfd_boolean unresolved_reloc;
2264 bfd_reloc_status_type r;
2265 struct bfd_link_hash_entry *sbh;
2266 bfd_boolean is_rel;
2267
2268 r_type = ELF32_R_TYPE (rel->r_info);
2269 r_symndx = ELF32_R_SYM (rel->r_info);
2270
2271 is_rel = elf32_tic6x_rel_relocation_p (input_bfd, input_section,
2272 relocs, rel);
2273
2274 if (is_rel)
2275 elf32_tic6x_info_to_howto_rel (input_bfd, &bfd_reloc, rel);
2276 else
2277 elf32_tic6x_info_to_howto (input_bfd, &bfd_reloc, rel);
2278 howto = bfd_reloc.howto;
2279 if (howto == NULL)
2280 {
2281 bfd_set_error (bfd_error_bad_value);
2282 return FALSE;
2283 }
2284
2285 h = NULL;
2286 sym = NULL;
2287 sec = NULL;
2288 unresolved_reloc = FALSE;
2289
2290 if (r_symndx < symtab_hdr->sh_info)
2291 {
2292 sym = local_syms + r_symndx;
2293 sec = local_sections[r_symndx];
2294 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2295 }
2296 else
2297 {
2298 bfd_boolean warned, ignored;
2299
2300 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2301 r_symndx, symtab_hdr, sym_hashes,
2302 h, sec, relocation,
2303 unresolved_reloc, warned, ignored);
2304 }
2305
2306 if (sec != NULL && discarded_section (sec))
2307 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
2308 rel, 1, relend, howto, 0, contents);
2309
2310 if (bfd_link_relocatable (info))
2311 {
2312 if (is_rel
2313 && sym != NULL
2314 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2315 {
2316 rel->r_addend = 0;
2317 relocation = sec->output_offset + sym->st_value;
2318 r = _bfd_relocate_contents (howto, input_bfd, relocation,
2319 contents + rel->r_offset);
2320 goto done_reloc;
2321 }
2322 continue;
2323 }
2324
2325 switch (r_type)
2326 {
2327 case R_C6000_NONE:
2328 case R_C6000_ALIGN:
2329 case R_C6000_FPHEAD:
2330 case R_C6000_NOCMP:
2331 /* No action needed. */
2332 continue;
2333
2334 case R_C6000_PCR_S21:
2335 /* A branch to an undefined weak symbol is turned into a
2336 "b .s2 B3" instruction if the existing insn is of the
2337 form "b .s2 symbol". */
2338 if (h ? h->root.type == bfd_link_hash_undefweak
2339 && (htab->elf.splt == NULL || h->plt.offset == (bfd_vma) -1)
2340 : r_symndx != STN_UNDEF && bfd_is_und_section (sec))
2341 {
2342 unsigned long oldval;
2343 oldval = bfd_get_32 (input_bfd, contents + rel->r_offset);
2344
2345 if ((oldval & 0x7e) == 0x12)
2346 {
2347 oldval &= 0xF0000001;
2348 bfd_put_32 (input_bfd, oldval | 0x000c0362,
2349 contents + rel->r_offset);
2350 r = bfd_reloc_ok;
2351 goto done_reloc;
2352 }
2353 }
2354 /* Fall through. */
2355
2356 case R_C6000_PCR_S12:
2357 case R_C6000_PCR_S10:
2358 case R_C6000_PCR_S7:
2359 if (h != NULL
2360 && h->plt.offset != (bfd_vma) -1
2361 && htab->elf.splt != NULL)
2362 {
2363 relocation = (htab->elf.splt->output_section->vma
2364 + htab->elf.splt->output_offset
2365 + h->plt.offset);
2366 }
2367
2368 /* Generic PC-relative handling produces a value relative to
2369 the exact location of the relocation. Adjust it to be
2370 relative to the start of the fetch packet instead. */
2371 relocation += (input_section->output_section->vma
2372 + input_section->output_offset
2373 + rel->r_offset) & 0x1f;
2374 unresolved_reloc = FALSE;
2375 break;
2376
2377 case R_C6000_PCR_H16:
2378 case R_C6000_PCR_L16:
2379 off = (input_section->output_section->vma
2380 + input_section->output_offset
2381 + rel->r_offset);
2382 /* These must be calculated as R = S - FP(FP(PC) - A).
2383 PC, here, is the value we just computed in OFF. RELOCATION
2384 has the address of S + A. */
2385 relocation -= rel->r_addend;
2386 off2 = ((off & ~(bfd_vma)0x1f) - rel->r_addend) & (bfd_vma)~0x1f;
2387 off2 = relocation - off2;
2388 relocation = off + off2;
2389 break;
2390
2391 case R_C6000_DSBT_INDEX:
2392 relocation = elf32_tic6x_hash_table (info)->params.dsbt_index;
2393 if (!bfd_link_pic (info) || relocation != 0)
2394 break;
2395
2396 /* fall through */
2397 case R_C6000_ABS32:
2398 case R_C6000_ABS16:
2399 case R_C6000_ABS8:
2400 case R_C6000_ABS_S16:
2401 case R_C6000_ABS_L16:
2402 case R_C6000_ABS_H16:
2403 /* When generating a shared object or relocatable executable, these
2404 relocations are copied into the output file to be resolved at
2405 run time. */
2406 if ((bfd_link_pic (info) || elf32_tic6x_using_dsbt (output_bfd))
2407 && (input_section->flags & SEC_ALLOC)
2408 && (h == NULL
2409 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2410 || h->root.type != bfd_link_hash_undefweak))
2411 {
2412 Elf_Internal_Rela outrel;
2413 bfd_boolean skip, relocate;
2414 asection *sreloc;
2415
2416 unresolved_reloc = FALSE;
2417
2418 sreloc = elf_section_data (input_section)->sreloc;
2419 BFD_ASSERT (sreloc != NULL && sreloc->contents != NULL);
2420
2421 skip = FALSE;
2422 relocate = FALSE;
2423
2424 outrel.r_offset =
2425 _bfd_elf_section_offset (output_bfd, info, input_section,
2426 rel->r_offset);
2427 if (outrel.r_offset == (bfd_vma) -1)
2428 skip = TRUE;
2429 else if (outrel.r_offset == (bfd_vma) -2)
2430 skip = TRUE, relocate = TRUE;
2431 outrel.r_offset += (input_section->output_section->vma
2432 + input_section->output_offset);
2433
2434 if (skip)
2435 memset (&outrel, 0, sizeof outrel);
2436 else if (h != NULL
2437 && h->dynindx != -1
2438 && (!bfd_link_pic (info)
2439 || !SYMBOLIC_BIND (info, h)
2440 || !h->def_regular))
2441 {
2442 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2443 outrel.r_addend = rel->r_addend;
2444 }
2445 else
2446 {
2447 long indx;
2448
2449 outrel.r_addend = relocation + rel->r_addend;
2450
2451 if (bfd_is_abs_section (sec))
2452 indx = 0;
2453 else if (sec == NULL || sec->owner == NULL)
2454 {
2455 bfd_set_error (bfd_error_bad_value);
2456 return FALSE;
2457 }
2458 else
2459 {
2460 asection *osec;
2461
2462 osec = sec->output_section;
2463 indx = elf_section_data (osec)->dynindx;
2464 outrel.r_addend -= osec->vma;
2465 BFD_ASSERT (indx != 0);
2466 }
2467
2468 outrel.r_info = ELF32_R_INFO (indx, r_type);
2469 }
2470
2471 elf32_tic6x_install_rela (output_bfd, sreloc, &outrel);
2472
2473 /* If this reloc is against an external symbol, we do not want to
2474 fiddle with the addend. Otherwise, we need to include the symbol
2475 value so that it becomes an addend for the dynamic reloc. */
2476 if (! relocate)
2477 continue;
2478 }
2479
2480 /* Generic logic OK. */
2481 break;
2482
2483 case R_C6000_SBR_U15_B:
2484 case R_C6000_SBR_U15_H:
2485 case R_C6000_SBR_U15_W:
2486 case R_C6000_SBR_S16:
2487 case R_C6000_SBR_L16_B:
2488 case R_C6000_SBR_L16_H:
2489 case R_C6000_SBR_L16_W:
2490 case R_C6000_SBR_H16_B:
2491 case R_C6000_SBR_H16_H:
2492 case R_C6000_SBR_H16_W:
2493 sbh = bfd_link_hash_lookup (info->hash, "__c6xabi_DSBT_BASE",
2494 FALSE, FALSE, TRUE);
2495 if (sbh != NULL
2496 && (sbh->type == bfd_link_hash_defined
2497 || sbh->type == bfd_link_hash_defweak))
2498 {
2499 if (h ? (h->root.type == bfd_link_hash_undefweak
2500 && (htab->elf.splt == NULL
2501 || h->plt.offset == (bfd_vma) -1))
2502 : r_symndx != STN_UNDEF && bfd_is_und_section (sec))
2503 relocation = 0;
2504 else
2505 relocation -= (sbh->u.def.value
2506 + sbh->u.def.section->output_section->vma
2507 + sbh->u.def.section->output_offset);
2508 }
2509 else
2510 {
2511 _bfd_error_handler (_("%B: SB-relative relocation but "
2512 "__c6xabi_DSBT_BASE not defined"),
2513 input_bfd);
2514 ok = FALSE;
2515 continue;
2516 }
2517 break;
2518
2519 case R_C6000_SBR_GOT_U15_W:
2520 case R_C6000_SBR_GOT_L16_W:
2521 case R_C6000_SBR_GOT_H16_W:
2522 case R_C6000_EHTYPE:
2523 /* Relocation is to the entry for this symbol in the global
2524 offset table. */
2525 if (htab->elf.sgot == NULL)
2526 abort ();
2527
2528 if (h != NULL)
2529 {
2530 bfd_boolean dyn;
2531
2532 off = h->got.offset;
2533 dyn = htab->elf.dynamic_sections_created;
2534 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
2535 bfd_link_pic (info),
2536 h)
2537 || (bfd_link_pic (info)
2538 && SYMBOL_REFERENCES_LOCAL (info, h))
2539 || (ELF_ST_VISIBILITY (h->other)
2540 && h->root.type == bfd_link_hash_undefweak))
2541 {
2542 /* This is actually a static link, or it is a
2543 -Bsymbolic link and the symbol is defined
2544 locally, or the symbol was forced to be local
2545 because of a version file. We must initialize
2546 this entry in the global offset table. Since the
2547 offset must always be a multiple of 4, we use the
2548 least significant bit to record whether we have
2549 initialized it already.
2550
2551 When doing a dynamic link, we create a .rel.got
2552 relocation entry to initialize the value. This
2553 is done in the finish_dynamic_symbol routine. */
2554 if ((off & 1) != 0)
2555 off &= ~1;
2556 else
2557 {
2558 bfd_put_32 (output_bfd, relocation,
2559 htab->elf.sgot->contents + off);
2560 h->got.offset |= 1;
2561
2562 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
2563 bfd_link_pic (info),
2564 h)
2565 && !(ELF_ST_VISIBILITY (h->other)
2566 && h->root.type == bfd_link_hash_undefweak))
2567 elf32_tic6x_make_got_dynreloc (output_bfd, htab, sec,
2568 off);
2569 }
2570 }
2571 else
2572 unresolved_reloc = FALSE;
2573 }
2574 else
2575 {
2576 if (local_got_offsets == NULL)
2577 abort ();
2578
2579 off = local_got_offsets[r_symndx];
2580
2581 /* The offset must always be a multiple of 4. We use
2582 the least significant bit to record whether we have
2583 already generated the necessary reloc. */
2584 if ((off & 1) != 0)
2585 off &= ~1;
2586 else
2587 {
2588 bfd_put_32 (output_bfd, relocation,
2589 htab->elf.sgot->contents + off);
2590
2591 if (bfd_link_pic (info) || elf32_tic6x_using_dsbt (output_bfd))
2592 elf32_tic6x_make_got_dynreloc (output_bfd, htab, sec, off);
2593
2594 local_got_offsets[r_symndx] |= 1;
2595 }
2596 }
2597
2598 if (off >= (bfd_vma) -2)
2599 abort ();
2600
2601 if (htab->dsbt)
2602 relocation = (htab->elf.sgot->output_section->vma
2603 + htab->elf.sgot->output_offset + off
2604 - htab->dsbt->output_section->vma
2605 - htab->dsbt->output_offset);
2606 else
2607 relocation = (htab->elf.sgot->output_section->vma
2608 + htab->elf.sgot->output_offset + off
2609 - htab->elf.sgotplt->output_section->vma
2610 - htab->elf.sgotplt->output_offset);
2611
2612 if (rel->r_addend != 0)
2613 {
2614 /* We can't do anything for a relocation which is against
2615 a symbol *plus offset*. GOT holds relocations for
2616 symbols. Make this an error; the compiler isn't
2617 allowed to pass us these kinds of things. */
2618 if (h == NULL)
2619 _bfd_error_handler
2620 /* xgettext:c-format */
2621 (_("%B, section %A: relocation %s with non-zero addend %d"
2622 " against local symbol"),
2623 input_bfd,
2624 input_section,
2625 elf32_tic6x_howto_table[r_type].name,
2626 rel->r_addend);
2627 else
2628 _bfd_error_handler
2629 /* xgettext:c-format */
2630 (_("%B, section %A: relocation %s with non-zero addend %d"
2631 " against symbol `%s'"),
2632 input_bfd,
2633 input_section,
2634 elf32_tic6x_howto_table[r_type].name,
2635 rel->r_addend,
2636 h->root.root.string[0] != '\0' ? h->root.root.string
2637 : _("[whose name is lost]"));
2638
2639 bfd_set_error (bfd_error_bad_value);
2640 return FALSE;
2641 }
2642 break;
2643
2644 case R_C6000_PREL31:
2645 if (h != NULL
2646 && h->plt.offset != (bfd_vma) -1
2647 && htab->elf.splt != NULL)
2648 {
2649 relocation = (htab->elf.splt->output_section->vma
2650 + htab->elf.splt->output_offset
2651 + h->plt.offset);
2652 }
2653 break;
2654
2655 case R_C6000_COPY:
2656 /* Invalid in relocatable object. */
2657 default:
2658 /* Unknown relocation. */
2659 /* xgettext:c-format */
2660 _bfd_error_handler (_("%B: invalid relocation type %d"),
2661 input_bfd, r_type);
2662 ok = FALSE;
2663 continue;
2664 }
2665
2666 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2667 contents, rel->r_offset,
2668 relocation, rel->r_addend);
2669
2670 done_reloc:
2671 if (r == bfd_reloc_ok
2672 && howto->complain_on_overflow == complain_overflow_bitfield)
2673 {
2674 /* Generic overflow handling accepts cases the ABI says
2675 should be rejected for R_C6000_ABS16 and
2676 R_C6000_ABS8. */
2677 bfd_vma value = (relocation + rel->r_addend) & 0xffffffff;
2678 bfd_vma sbit = 1 << (howto->bitsize - 1);
2679 bfd_vma sbits = (-(bfd_vma) sbit) & 0xffffffff;
2680 bfd_vma value_sbits = value & sbits;
2681
2682 if (value_sbits != 0
2683 && value_sbits != sbit
2684 && value_sbits != sbits)
2685 r = bfd_reloc_overflow;
2686 }
2687
2688 if (r != bfd_reloc_ok)
2689 {
2690 const char *name;
2691 const char *error_message;
2692
2693 if (h != NULL)
2694 name = h->root.root.string;
2695 else
2696 {
2697 name = bfd_elf_string_from_elf_section (input_bfd,
2698 symtab_hdr->sh_link,
2699 sym->st_name);
2700 if (name == NULL)
2701 return FALSE;
2702 if (*name == '\0')
2703 name = bfd_section_name (input_bfd, sec);
2704 }
2705
2706 switch (r)
2707 {
2708 case bfd_reloc_overflow:
2709 /* If the overflowing reloc was to an undefined symbol,
2710 we have already printed one error message and there
2711 is no point complaining again. */
2712 if (!h || h->root.type != bfd_link_hash_undefined)
2713 (*info->callbacks->reloc_overflow)
2714 (info, (h ? &h->root : NULL), name, howto->name,
2715 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
2716 break;
2717
2718 case bfd_reloc_undefined:
2719 (*info->callbacks->undefined_symbol) (info, name, input_bfd,
2720 input_section,
2721 rel->r_offset, TRUE);
2722 break;
2723
2724 case bfd_reloc_outofrange:
2725 error_message = _("out of range");
2726 goto common_error;
2727
2728 case bfd_reloc_notsupported:
2729 error_message = _("unsupported relocation");
2730 goto common_error;
2731
2732 case bfd_reloc_dangerous:
2733 error_message = _("dangerous relocation");
2734 goto common_error;
2735
2736 default:
2737 error_message = _("unknown error");
2738 /* Fall through. */
2739
2740 common_error:
2741 BFD_ASSERT (error_message != NULL);
2742 (*info->callbacks->reloc_dangerous)
2743 (info, error_message, input_bfd, input_section, rel->r_offset);
2744 break;
2745 }
2746 }
2747 }
2748
2749 return ok;
2750 }
2751
2752 \f
2753 /* Look through the relocs for a section during the first phase, and
2754 calculate needed space in the global offset table, procedure linkage
2755 table, and dynamic reloc sections. */
2756
2757 static bfd_boolean
2758 elf32_tic6x_check_relocs (bfd *abfd, struct bfd_link_info *info,
2759 asection *sec, const Elf_Internal_Rela *relocs)
2760 {
2761 struct elf32_tic6x_link_hash_table *htab;
2762 Elf_Internal_Shdr *symtab_hdr;
2763 struct elf_link_hash_entry **sym_hashes;
2764 const Elf_Internal_Rela *rel;
2765 const Elf_Internal_Rela *rel_end;
2766 asection *sreloc;
2767
2768 if (bfd_link_relocatable (info))
2769 return TRUE;
2770
2771 htab = elf32_tic6x_hash_table (info);
2772 symtab_hdr = &elf_symtab_hdr (abfd);
2773 sym_hashes = elf_sym_hashes (abfd);
2774
2775 /* Create dynamic sections for relocatable executables so that we can
2776 copy relocations. */
2777 if ((bfd_link_pic (info) || elf32_tic6x_using_dsbt (abfd))
2778 && ! htab->elf.dynamic_sections_created)
2779 {
2780 if (! _bfd_elf_link_create_dynamic_sections (abfd, info))
2781 return FALSE;
2782 }
2783
2784 sreloc = NULL;
2785
2786 rel_end = relocs + sec->reloc_count;
2787 for (rel = relocs; rel < rel_end; rel++)
2788 {
2789 unsigned int r_type;
2790 unsigned long r_symndx;
2791 struct elf_link_hash_entry *h;
2792 Elf_Internal_Sym *isym;
2793
2794 r_symndx = ELF32_R_SYM (rel->r_info);
2795 r_type = ELF32_R_TYPE (rel->r_info);
2796
2797 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
2798 {
2799 /* xgettext:c-format */
2800 _bfd_error_handler (_("%B: bad symbol index: %d"),
2801 abfd, r_symndx);
2802 return FALSE;
2803 }
2804
2805 if (r_symndx < symtab_hdr->sh_info)
2806 {
2807 /* A local symbol. */
2808 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2809 abfd, r_symndx);
2810 if (isym == NULL)
2811 return FALSE;
2812 h = NULL;
2813 }
2814 else
2815 {
2816 isym = NULL;
2817 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2818 while (h->root.type == bfd_link_hash_indirect
2819 || h->root.type == bfd_link_hash_warning)
2820 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2821
2822 /* PR15323, ref flags aren't set for references in the same
2823 object. */
2824 h->root.non_ir_ref = 1;
2825 }
2826
2827 switch (r_type)
2828 {
2829 case R_C6000_PCR_S21:
2830 case R_C6000_PREL31:
2831 /* This symbol requires a procedure linkage table entry. We
2832 actually build the entry in adjust_dynamic_symbol,
2833 because this might be a case of linking PIC code which is
2834 never referenced by a dynamic object, in which case we
2835 don't need to generate a procedure linkage table entry
2836 after all. */
2837
2838 /* If this is a local symbol, we resolve it directly without
2839 creating a procedure linkage table entry. */
2840 if (h == NULL)
2841 continue;
2842
2843 h->needs_plt = 1;
2844 h->plt.refcount += 1;
2845 break;
2846
2847 case R_C6000_SBR_GOT_U15_W:
2848 case R_C6000_SBR_GOT_L16_W:
2849 case R_C6000_SBR_GOT_H16_W:
2850 case R_C6000_EHTYPE:
2851 /* This symbol requires a global offset table entry. */
2852 if (h != NULL)
2853 {
2854 h->got.refcount += 1;
2855 }
2856 else
2857 {
2858 bfd_signed_vma *local_got_refcounts;
2859
2860 /* This is a global offset table entry for a local symbol. */
2861 local_got_refcounts = elf_local_got_refcounts (abfd);
2862 if (local_got_refcounts == NULL)
2863 {
2864 bfd_size_type size;
2865
2866 size = symtab_hdr->sh_info;
2867 size *= (sizeof (bfd_signed_vma)
2868 + sizeof (bfd_vma) + sizeof(char));
2869 local_got_refcounts = bfd_zalloc (abfd, size);
2870 if (local_got_refcounts == NULL)
2871 return FALSE;
2872 elf_local_got_refcounts (abfd) = local_got_refcounts;
2873 }
2874 local_got_refcounts[r_symndx] += 1;
2875 }
2876
2877 if (htab->elf.sgot == NULL)
2878 {
2879 if (htab->elf.dynobj == NULL)
2880 htab->elf.dynobj = abfd;
2881 if (!_bfd_elf_create_got_section (htab->elf.dynobj, info))
2882 return FALSE;
2883 }
2884 break;
2885
2886 case R_C6000_DSBT_INDEX:
2887 /* We'd like to check for nonzero dsbt_index here, but it's
2888 set up only after check_relocs is called. Instead, we
2889 store the number of R_C6000_DSBT_INDEX relocs in the
2890 pc_count field, and potentially discard the extra space
2891 in elf32_tic6x_allocate_dynrelocs. */
2892 if (!bfd_link_pic (info))
2893 break;
2894
2895 /* fall through */
2896 case R_C6000_ABS32:
2897 case R_C6000_ABS16:
2898 case R_C6000_ABS8:
2899 case R_C6000_ABS_S16:
2900 case R_C6000_ABS_L16:
2901 case R_C6000_ABS_H16:
2902 /* If we are creating a shared library, and this is a reloc
2903 against a global symbol, or a non PC relative reloc
2904 against a local symbol, then we need to copy the reloc
2905 into the shared library. However, if we are linking with
2906 -Bsymbolic, we do not need to copy a reloc against a
2907 global symbol which is defined in an object we are
2908 including in the link (i.e., DEF_REGULAR is set). At
2909 this point we have not seen all the input files, so it is
2910 possible that DEF_REGULAR is not set now but will be set
2911 later (it is never cleared). In case of a weak definition,
2912 DEF_REGULAR may be cleared later by a strong definition in
2913 a shared library. We account for that possibility below by
2914 storing information in the relocs_copied field of the hash
2915 table entry. A similar situation occurs when creating
2916 shared libraries and symbol visibility changes render the
2917 symbol local.
2918
2919 If on the other hand, we are creating an executable, we
2920 may need to keep relocations for symbols satisfied by a
2921 dynamic library if we manage to avoid copy relocs for the
2922 symbol. */
2923 if ((bfd_link_pic (info) || elf32_tic6x_using_dsbt (abfd))
2924 && (sec->flags & SEC_ALLOC) != 0)
2925 {
2926 struct elf_dyn_relocs *p;
2927 struct elf_dyn_relocs **head;
2928
2929 /* We must copy these reloc types into the output file.
2930 Create a reloc section in dynobj and make room for
2931 this reloc. */
2932 if (sreloc == NULL)
2933 {
2934 if (htab->elf.dynobj == NULL)
2935 htab->elf.dynobj = abfd;
2936
2937 sreloc = _bfd_elf_make_dynamic_reloc_section
2938 (sec, htab->elf.dynobj, 2, abfd, /*rela? */ TRUE);
2939
2940 if (sreloc == NULL)
2941 return FALSE;
2942 }
2943
2944 /* If this is a global symbol, we count the number of
2945 relocations we need for this symbol. */
2946 if (h != NULL)
2947 {
2948 head = &((struct elf32_tic6x_link_hash_entry *) h)->dyn_relocs;
2949 }
2950 else
2951 {
2952 /* Track dynamic relocs needed for local syms too.
2953 We really need local syms available to do this
2954 easily. Oh well. */
2955 void **vpp;
2956 asection *s;
2957
2958 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
2959 if (s == NULL)
2960 s = sec;
2961
2962 vpp = &elf_section_data (s)->local_dynrel;
2963 head = (struct elf_dyn_relocs **)vpp;
2964 }
2965
2966 p = *head;
2967 if (p == NULL || p->sec != sec)
2968 {
2969 bfd_size_type amt = sizeof *p;
2970 p = bfd_alloc (htab->elf.dynobj, amt);
2971 if (p == NULL)
2972 return FALSE;
2973 p->next = *head;
2974 *head = p;
2975 p->sec = sec;
2976 p->count = 0;
2977 p->pc_count = 0;
2978 }
2979
2980 p->count += 1;
2981 if (r_type == R_C6000_DSBT_INDEX)
2982 p->pc_count += 1;
2983 }
2984 break;
2985
2986 case R_C6000_SBR_U15_B:
2987 case R_C6000_SBR_U15_H:
2988 case R_C6000_SBR_U15_W:
2989 case R_C6000_SBR_S16:
2990 case R_C6000_SBR_L16_B:
2991 case R_C6000_SBR_L16_H:
2992 case R_C6000_SBR_L16_W:
2993 case R_C6000_SBR_H16_B:
2994 case R_C6000_SBR_H16_H:
2995 case R_C6000_SBR_H16_W:
2996 if (h != NULL && bfd_link_executable (info))
2997 {
2998 /* For B14-relative addresses, we might need a copy
2999 reloc. */
3000 h->non_got_ref = 1;
3001 }
3002 break;
3003
3004 default:
3005 break;
3006 }
3007 }
3008
3009 return TRUE;
3010 }
3011
3012 static bfd_boolean
3013 elf32_tic6x_add_symbol_hook (bfd *abfd,
3014 struct bfd_link_info *info ATTRIBUTE_UNUSED,
3015 Elf_Internal_Sym *sym,
3016 const char **namep ATTRIBUTE_UNUSED,
3017 flagword *flagsp ATTRIBUTE_UNUSED,
3018 asection **secp,
3019 bfd_vma *valp)
3020 {
3021 switch (sym->st_shndx)
3022 {
3023 case SHN_TIC6X_SCOMMON:
3024 *secp = bfd_make_section_old_way (abfd, ".scommon");
3025 (*secp)->flags |= SEC_IS_COMMON;
3026 *valp = sym->st_size;
3027 (void) bfd_set_section_alignment (abfd, *secp, bfd_log2 (sym->st_value));
3028 break;
3029 }
3030
3031 return TRUE;
3032 }
3033
3034 static void
3035 elf32_tic6x_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED, asymbol *asym)
3036 {
3037 elf_symbol_type *elfsym;
3038
3039 elfsym = (elf_symbol_type *) asym;
3040 switch (elfsym->internal_elf_sym.st_shndx)
3041 {
3042 case SHN_TIC6X_SCOMMON:
3043 if (tic6x_elf_scom_section.name == NULL)
3044 {
3045 /* Initialize the small common section. */
3046 tic6x_elf_scom_section.name = ".scommon";
3047 tic6x_elf_scom_section.flags = SEC_IS_COMMON;
3048 tic6x_elf_scom_section.output_section = &tic6x_elf_scom_section;
3049 tic6x_elf_scom_section.symbol = &tic6x_elf_scom_symbol;
3050 tic6x_elf_scom_section.symbol_ptr_ptr = &tic6x_elf_scom_symbol_ptr;
3051 tic6x_elf_scom_symbol.name = ".scommon";
3052 tic6x_elf_scom_symbol.flags = BSF_SECTION_SYM;
3053 tic6x_elf_scom_symbol.section = &tic6x_elf_scom_section;
3054 tic6x_elf_scom_symbol_ptr = &tic6x_elf_scom_symbol;
3055 }
3056 asym->section = &tic6x_elf_scom_section;
3057 asym->value = elfsym->internal_elf_sym.st_size;
3058 break;
3059 }
3060 }
3061
3062 static int
3063 elf32_tic6x_link_output_symbol_hook (struct bfd_link_info *info ATTRIBUTE_UNUSED,
3064 const char *name ATTRIBUTE_UNUSED,
3065 Elf_Internal_Sym *sym,
3066 asection *input_sec,
3067 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
3068 {
3069 /* If we see a common symbol, which implies a relocatable link, then
3070 if a symbol was small common in an input file, mark it as small
3071 common in the output file. */
3072 if (sym->st_shndx == SHN_COMMON && strcmp (input_sec->name, ".scommon") == 0)
3073 sym->st_shndx = SHN_TIC6X_SCOMMON;
3074
3075 return 1;
3076 }
3077
3078 static bfd_boolean
3079 elf32_tic6x_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
3080 asection *sec,
3081 int *retval)
3082 {
3083 if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0)
3084 {
3085 *retval = SHN_TIC6X_SCOMMON;
3086 return TRUE;
3087 }
3088
3089 return FALSE;
3090 }
3091
3092 /* Allocate space in .plt, .got and associated reloc sections for
3093 dynamic relocs. */
3094
3095 static bfd_boolean
3096 elf32_tic6x_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
3097 {
3098 struct bfd_link_info *info;
3099 struct elf32_tic6x_link_hash_table *htab;
3100 struct elf32_tic6x_link_hash_entry *eh;
3101 struct elf_dyn_relocs *p;
3102
3103 if (h->root.type == bfd_link_hash_indirect)
3104 return TRUE;
3105
3106 eh = (struct elf32_tic6x_link_hash_entry *) h;
3107 info = (struct bfd_link_info *) inf;
3108 htab = elf32_tic6x_hash_table (info);
3109
3110 if (htab->elf.dynamic_sections_created && h->plt.refcount > 0)
3111 {
3112 /* Make sure this symbol is output as a dynamic symbol.
3113 Undefined weak syms won't yet be marked as dynamic. */
3114 if (h->dynindx == -1 && !h->forced_local)
3115 {
3116 if (! bfd_elf_link_record_dynamic_symbol (info, h))
3117 return FALSE;
3118 }
3119
3120 if (bfd_link_pic (info)
3121 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
3122 {
3123 asection *s = htab->elf.splt;
3124
3125 /* If this is the first .plt entry, make room for the special
3126 first entry. */
3127 if (s->size == 0)
3128 s->size += PLT_ENTRY_SIZE;
3129
3130 h->plt.offset = s->size;
3131
3132 /* If this symbol is not defined in a regular file, and we are
3133 not generating a shared library, then set the symbol to this
3134 location in the .plt. This is required to make function
3135 pointers compare as equal between the normal executable and
3136 the shared library. */
3137 if (! bfd_link_pic (info) && !h->def_regular)
3138 {
3139 h->root.u.def.section = s;
3140 h->root.u.def.value = h->plt.offset;
3141 }
3142
3143 /* Make room for this entry. */
3144 s->size += PLT_ENTRY_SIZE;
3145 /* We also need to make an entry in the .got.plt section, which
3146 will be placed in the .got section by the linker script. */
3147 htab->elf.sgotplt->size += 4;
3148 /* We also need to make an entry in the .rel.plt section. */
3149 htab->elf.srelplt->size += sizeof (Elf32_External_Rela);
3150 }
3151 else
3152 {
3153 h->plt.offset = (bfd_vma) -1;
3154 h->needs_plt = 0;
3155 }
3156 }
3157 else
3158 {
3159 h->plt.offset = (bfd_vma) -1;
3160 h->needs_plt = 0;
3161 }
3162
3163 if (h->got.refcount > 0)
3164 {
3165 asection *s;
3166
3167 /* Make sure this symbol is output as a dynamic symbol.
3168 Undefined weak syms won't yet be marked as dynamic. */
3169 if (h->dynindx == -1
3170 && !h->forced_local)
3171 {
3172 if (! bfd_elf_link_record_dynamic_symbol (info, h))
3173 return FALSE;
3174 }
3175
3176 s = htab->elf.sgot;
3177 h->got.offset = s->size;
3178 s->size += 4;
3179
3180 if (!(ELF_ST_VISIBILITY (h->other)
3181 && h->root.type == bfd_link_hash_undefweak))
3182 htab->elf.srelgot->size += sizeof (Elf32_External_Rela);
3183 }
3184 else
3185 h->got.offset = (bfd_vma) -1;
3186
3187 if (eh->dyn_relocs == NULL)
3188 return TRUE;
3189
3190 /* Discard relocs on undefined weak syms with non-default
3191 visibility. */
3192 if (bfd_link_pic (info) || elf32_tic6x_using_dsbt (htab->obfd))
3193 {
3194 /* We use the pc_count field to hold the number of
3195 R_C6000_DSBT_INDEX relocs. */
3196 if (htab->params.dsbt_index != 0)
3197 {
3198 struct elf_dyn_relocs **pp;
3199
3200 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
3201 {
3202 p->count -= p->pc_count;
3203 p->pc_count = 0;
3204 if (p->count == 0)
3205 *pp = p->next;
3206 else
3207 pp = &p->next;
3208 }
3209 }
3210
3211 if (eh->dyn_relocs != NULL
3212 && h->root.type == bfd_link_hash_undefweak)
3213 {
3214 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
3215 eh->dyn_relocs = NULL;
3216
3217 /* Make sure undefined weak symbols are output as a dynamic
3218 symbol in PIEs. */
3219 else if (h->dynindx == -1
3220 && !h->forced_local)
3221 {
3222 if (! bfd_elf_link_record_dynamic_symbol (info, h))
3223 return FALSE;
3224 }
3225 }
3226 }
3227
3228 /* Finally, allocate space. */
3229 for (p = eh->dyn_relocs; p != NULL; p = p->next)
3230 {
3231 asection *sreloc;
3232
3233 sreloc = elf_section_data (p->sec)->sreloc;
3234
3235 BFD_ASSERT (sreloc != NULL);
3236 sreloc->size += p->count * sizeof (Elf32_External_Rela);
3237 }
3238
3239 return TRUE;
3240 }
3241
3242 /* Find any dynamic relocs that apply to read-only sections. */
3243
3244 static bfd_boolean
3245 elf32_tic6x_readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
3246 {
3247 struct elf32_tic6x_link_hash_entry *eh;
3248 struct elf_dyn_relocs *p;
3249
3250 eh = (struct elf32_tic6x_link_hash_entry *) h;
3251 for (p = eh->dyn_relocs; p != NULL; p = p->next)
3252 {
3253 asection *s = p->sec->output_section;
3254
3255 if (s != NULL && (s->flags & SEC_READONLY) != 0)
3256 {
3257 struct bfd_link_info *info = (struct bfd_link_info *) inf;
3258
3259 info->flags |= DF_TEXTREL;
3260
3261 /* Not an error, just cut short the traversal. */
3262 return FALSE;
3263 }
3264 }
3265 return TRUE;
3266 }
3267
3268 /* Set the sizes of the dynamic sections. */
3269
3270 static bfd_boolean
3271 elf32_tic6x_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
3272 {
3273 struct elf32_tic6x_link_hash_table *htab;
3274 bfd *dynobj;
3275 asection *s;
3276 bfd_boolean relocs;
3277 bfd *ibfd;
3278
3279 htab = elf32_tic6x_hash_table (info);
3280 dynobj = htab->elf.dynobj;
3281 if (dynobj == NULL)
3282 abort ();
3283
3284 if (htab->elf.dynamic_sections_created)
3285 {
3286 /* Set the contents of the .interp section to the interpreter. */
3287 if (bfd_link_executable (info) && !info->nointerp)
3288 {
3289 s = bfd_get_linker_section (dynobj, ".interp");
3290 if (s == NULL)
3291 abort ();
3292 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
3293 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3294 }
3295 }
3296
3297 /* Set up .got offsets for local syms, and space for local dynamic
3298 relocs. */
3299 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
3300 {
3301 bfd_signed_vma *local_got;
3302 bfd_signed_vma *end_local_got;
3303 bfd_size_type locsymcount;
3304 Elf_Internal_Shdr *symtab_hdr;
3305 asection *srel;
3306
3307 for (s = ibfd->sections; s != NULL; s = s->next)
3308 {
3309 struct elf_dyn_relocs *p;
3310
3311 for (p = ((struct elf_dyn_relocs *)
3312 elf_section_data (s)->local_dynrel);
3313 p != NULL;
3314 p = p->next)
3315 {
3316 if (!bfd_is_abs_section (p->sec)
3317 && bfd_is_abs_section (p->sec->output_section))
3318 {
3319 /* Input section has been discarded, either because
3320 it is a copy of a linkonce section or due to
3321 linker script /DISCARD/, so we'll be discarding
3322 the relocs too. */
3323 }
3324 else if (p->count != 0)
3325 {
3326 srel = elf_section_data (p->sec)->sreloc;
3327 srel->size += p->count * sizeof (Elf32_External_Rela);
3328 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
3329 info->flags |= DF_TEXTREL;
3330 }
3331 }
3332 }
3333
3334 local_got = elf_local_got_refcounts (ibfd);
3335 if (!local_got)
3336 continue;
3337
3338 symtab_hdr = &elf_symtab_hdr (ibfd);
3339 locsymcount = symtab_hdr->sh_info;
3340 end_local_got = local_got + locsymcount;
3341 s = htab->elf.sgot;
3342 srel = htab->elf.srelgot;
3343 for (; local_got < end_local_got; ++local_got)
3344 {
3345 if (*local_got > 0)
3346 {
3347 *local_got = s->size;
3348 s->size += 4;
3349
3350 if (bfd_link_pic (info) || elf32_tic6x_using_dsbt (output_bfd))
3351 {
3352 srel->size += sizeof (Elf32_External_Rela);
3353 }
3354 }
3355 else
3356 *local_got = (bfd_vma) -1;
3357 }
3358 }
3359
3360 /* Allocate global sym .plt and .got entries, and space for global
3361 sym dynamic relocs. */
3362 elf_link_hash_traverse (&htab->elf, elf32_tic6x_allocate_dynrelocs, info);
3363
3364 /* We now have determined the sizes of the various dynamic sections.
3365 Allocate memory for them. */
3366 relocs = FALSE;
3367 for (s = dynobj->sections; s != NULL; s = s->next)
3368 {
3369 bfd_boolean strip_section = TRUE;
3370
3371 if ((s->flags & SEC_LINKER_CREATED) == 0)
3372 continue;
3373
3374 if (s == htab->dsbt)
3375 s->size = 4 * htab->params.dsbt_size;
3376 else if (s == htab->elf.splt
3377 || s == htab->elf.sgot
3378 || s == htab->elf.sgotplt
3379 || s == htab->elf.sdynbss)
3380 {
3381 /* Strip this section if we don't need it; see the
3382 comment below. */
3383 /* We'd like to strip these sections if they aren't needed, but if
3384 we've exported dynamic symbols from them we must leave them.
3385 It's too late to tell BFD to get rid of the symbols. */
3386
3387 if (htab->elf.hplt != NULL)
3388 strip_section = FALSE;
3389
3390 /* Round up the size of the PLT section to a multiple of 32. */
3391 if (s == htab->elf.splt && s->size > 0)
3392 s->size = (s->size + 31) & ~(bfd_vma)31;
3393 }
3394 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
3395 {
3396 if (s->size != 0
3397 && s != htab->elf.srelplt)
3398 relocs = TRUE;
3399
3400 /* We use the reloc_count field as a counter if we need
3401 to copy relocs into the output file. */
3402 s->reloc_count = 0;
3403 }
3404 else
3405 {
3406 /* It's not one of our sections, so don't allocate space. */
3407 continue;
3408 }
3409
3410 if (s->size == 0)
3411 {
3412 /* If we don't need this section, strip it from the
3413 output file. This is mostly to handle .rel.bss and
3414 .rel.plt. We must create both sections in
3415 create_dynamic_sections, because they must be created
3416 before the linker maps input sections to output
3417 sections. The linker does that before
3418 adjust_dynamic_symbol is called, and it is that
3419 function which decides whether anything needs to go
3420 into these sections. */
3421 if (strip_section)
3422 s->flags |= SEC_EXCLUDE;
3423 continue;
3424 }
3425
3426 if ((s->flags & SEC_HAS_CONTENTS) == 0)
3427 continue;
3428
3429 /* Allocate memory for the section contents. We use bfd_zalloc
3430 here in case unused entries are not reclaimed before the
3431 section's contents are written out. This should not happen,
3432 but this way if it does, we get a R_C6000_NONE reloc instead
3433 of garbage. */
3434 s->contents = bfd_zalloc (dynobj, s->size);
3435 if (s->contents == NULL)
3436 return FALSE;
3437 }
3438
3439 if (htab->elf.dynamic_sections_created)
3440 {
3441 /* Add some entries to the .dynamic section. We fill in the
3442 values later, in elf32_tic6x_finish_dynamic_sections, but we
3443 must add the entries now so that we get the correct size for
3444 the .dynamic section. The DT_DEBUG entry is filled in by the
3445 dynamic linker and used by the debugger. */
3446 #define add_dynamic_entry(TAG, VAL) \
3447 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3448
3449 if (bfd_link_executable (info))
3450 {
3451 if (!add_dynamic_entry (DT_DEBUG, 0))
3452 return FALSE;
3453 }
3454
3455 if (!add_dynamic_entry (DT_C6000_DSBT_BASE, 0)
3456 || !add_dynamic_entry (DT_C6000_DSBT_SIZE, htab->params.dsbt_size)
3457 || !add_dynamic_entry (DT_C6000_DSBT_INDEX,
3458 htab->params.dsbt_index))
3459 return FALSE;
3460
3461 if (htab->elf.splt->size != 0)
3462 {
3463 if (!add_dynamic_entry (DT_PLTGOT, 0)
3464 || !add_dynamic_entry (DT_PLTRELSZ, 0)
3465 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3466 || !add_dynamic_entry (DT_JMPREL, 0))
3467 return FALSE;
3468 }
3469
3470 if (relocs)
3471 {
3472 if (!add_dynamic_entry (DT_RELA, 0)
3473 || !add_dynamic_entry (DT_RELASZ, 0)
3474 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
3475 return FALSE;
3476
3477 /* If any dynamic relocs apply to a read-only section,
3478 then we need a DT_TEXTREL entry. */
3479 if ((info->flags & DF_TEXTREL) == 0)
3480 elf_link_hash_traverse (&htab->elf,
3481 elf32_tic6x_readonly_dynrelocs, info);
3482
3483 if ((info->flags & DF_TEXTREL) != 0)
3484 {
3485 if (!add_dynamic_entry (DT_TEXTREL, 0))
3486 return FALSE;
3487 }
3488 }
3489 }
3490 #undef add_dynamic_entry
3491
3492 return TRUE;
3493 }
3494
3495 /* This function is called after all the input files have been read,
3496 and the input sections have been assigned to output sections. */
3497
3498 static bfd_boolean
3499 elf32_tic6x_always_size_sections (bfd *output_bfd, struct bfd_link_info *info)
3500 {
3501 if (elf32_tic6x_using_dsbt (output_bfd) && !bfd_link_relocatable (info)
3502 && !bfd_elf_stack_segment_size (output_bfd, info,
3503 "__stacksize", DEFAULT_STACK_SIZE))
3504 return FALSE;
3505
3506 return TRUE;
3507 }
3508
3509 static bfd_boolean
3510 elf32_tic6x_finish_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
3511 struct bfd_link_info *info)
3512 {
3513 struct elf32_tic6x_link_hash_table *htab;
3514 bfd *dynobj;
3515 asection *sdyn;
3516
3517 htab = elf32_tic6x_hash_table (info);
3518 dynobj = htab->elf.dynobj;
3519 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
3520
3521 if (elf_hash_table (info)->dynamic_sections_created)
3522 {
3523 Elf32_External_Dyn * dyncon;
3524 Elf32_External_Dyn * dynconend;
3525
3526 BFD_ASSERT (sdyn != NULL);
3527
3528 dyncon = (Elf32_External_Dyn *) sdyn->contents;
3529 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3530
3531 for (; dyncon < dynconend; dyncon++)
3532 {
3533 Elf_Internal_Dyn dyn;
3534 asection *s;
3535
3536 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3537
3538 switch (dyn.d_tag)
3539 {
3540 default:
3541 break;
3542
3543 case DT_C6000_DSBT_BASE:
3544 s = htab->dsbt;
3545 dyn.d_un.d_ptr = (s->output_section->vma + s->output_offset);
3546 break;
3547
3548 case DT_PLTGOT:
3549 s = htab->elf.sgotplt;
3550 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3551 break;
3552
3553 case DT_JMPREL:
3554 s = htab->elf.srelplt;
3555 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3556 break;
3557
3558 case DT_PLTRELSZ:
3559 s = htab->elf.srelplt;
3560 dyn.d_un.d_val = s->size;
3561 break;
3562 }
3563 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3564 }
3565
3566 /* Fill in the first entry in the procedure linkage table. */
3567 if (htab->elf.splt && htab->elf.splt->size > 0)
3568 {
3569 bfd_vma got_offs = (htab->elf.sgotplt->output_section->vma
3570 + htab->elf.sgotplt->output_offset
3571 - htab->dsbt->output_section->vma
3572 - htab->dsbt->output_offset) / 4;
3573
3574 /* ldw .D2T2 *+b14[$GOT(0)],b2 */
3575 bfd_put_32 (output_bfd, got_offs << 8 | 0x0100006e,
3576 htab->elf.splt->contents);
3577 /* ldw .D2T2 *+b14[$GOT(4)],b1 */
3578 bfd_put_32 (output_bfd, (got_offs + 1) << 8 | 0x0080006e,
3579 htab->elf.splt->contents + 4);
3580 /* nop 3 */
3581 bfd_put_32 (output_bfd, 0x00004000,
3582 htab->elf.splt->contents + 8);
3583 /* b .s2 b2 */
3584 bfd_put_32 (output_bfd, 0x00080362,
3585 htab->elf.splt->contents + 12);
3586 /* nop 5 */
3587 bfd_put_32 (output_bfd, 0x00008000,
3588 htab->elf.splt->contents + 16);
3589
3590 elf_section_data (htab->elf.splt->output_section)
3591 ->this_hdr.sh_entsize = PLT_ENTRY_SIZE;
3592 }
3593 }
3594
3595 return TRUE;
3596 }
3597
3598 /* Return address for Ith PLT stub in section PLT, for relocation REL
3599 or (bfd_vma) -1 if it should not be included. */
3600
3601 static bfd_vma
3602 elf32_tic6x_plt_sym_val (bfd_vma i, const asection *plt,
3603 const arelent *rel ATTRIBUTE_UNUSED)
3604 {
3605 return plt->vma + (i + 1) * PLT_ENTRY_SIZE;
3606 }
3607
3608 static int
3609 elf32_tic6x_obj_attrs_arg_type (int tag)
3610 {
3611 if (tag == Tag_ABI_compatibility)
3612 return ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL;
3613 else if (tag & 1)
3614 return ATTR_TYPE_FLAG_STR_VAL;
3615 else
3616 return ATTR_TYPE_FLAG_INT_VAL;
3617 }
3618
3619 static int
3620 elf32_tic6x_obj_attrs_order (int num)
3621 {
3622 if (num == LEAST_KNOWN_OBJ_ATTRIBUTE)
3623 return Tag_ABI_conformance;
3624 if ((num - 1) < Tag_ABI_conformance)
3625 return num - 1;
3626 return num;
3627 }
3628
3629 static bfd_boolean
3630 elf32_tic6x_obj_attrs_handle_unknown (bfd *abfd, int tag)
3631 {
3632 if ((tag & 127) < 64)
3633 {
3634 _bfd_error_handler
3635 /* xgettext:c-format */
3636 (_("%B: error: unknown mandatory EABI object attribute %d"),
3637 abfd, tag);
3638 bfd_set_error (bfd_error_bad_value);
3639 return FALSE;
3640 }
3641 else
3642 {
3643 _bfd_error_handler
3644 /* xgettext:c-format */
3645 (_("%B: warning: unknown EABI object attribute %d"),
3646 abfd, tag);
3647 return TRUE;
3648 }
3649 }
3650
3651 /* Merge the Tag_ISA attribute values ARCH1 and ARCH2
3652 and return the merged value. At present, all merges succeed, so no
3653 return value for errors is defined. */
3654
3655 int
3656 elf32_tic6x_merge_arch_attributes (int arch1, int arch2)
3657 {
3658 int min_arch, max_arch;
3659
3660 min_arch = (arch1 < arch2 ? arch1 : arch2);
3661 max_arch = (arch1 > arch2 ? arch1 : arch2);
3662
3663 /* In most cases, the numerically greatest value is the correct
3664 merged value, but merging C64 and C67 results in C674X. */
3665 if ((min_arch == C6XABI_Tag_ISA_C67X
3666 || min_arch == C6XABI_Tag_ISA_C67XP)
3667 && (max_arch == C6XABI_Tag_ISA_C64X
3668 || max_arch == C6XABI_Tag_ISA_C64XP))
3669 return C6XABI_Tag_ISA_C674X;
3670
3671 return max_arch;
3672 }
3673
3674 /* Convert a Tag_ABI_array_object_alignment or
3675 Tag_ABI_array_object_align_expected tag value TAG to a
3676 corresponding alignment value; return the alignment, or -1 for an
3677 unknown tag value. */
3678
3679 static int
3680 elf32_tic6x_tag_to_array_alignment (int tag)
3681 {
3682 switch (tag)
3683 {
3684 case 0:
3685 return 8;
3686
3687 case 1:
3688 return 4;
3689
3690 case 2:
3691 return 16;
3692
3693 default:
3694 return -1;
3695 }
3696 }
3697
3698 /* Convert a Tag_ABI_array_object_alignment or
3699 Tag_ABI_array_object_align_expected alignment ALIGN to a
3700 corresponding tag value; return the tag value. */
3701
3702 static int
3703 elf32_tic6x_array_alignment_to_tag (int align)
3704 {
3705 switch (align)
3706 {
3707 case 8:
3708 return 0;
3709
3710 case 4:
3711 return 1;
3712
3713 case 16:
3714 return 2;
3715
3716 default:
3717 abort ();
3718 }
3719 }
3720
3721 /* Merge attributes from IBFD and OBFD, returning TRUE if the merge
3722 succeeded, FALSE otherwise. */
3723
3724 static bfd_boolean
3725 elf32_tic6x_merge_attributes (bfd *ibfd, struct bfd_link_info *info)
3726 {
3727 bfd *obfd = info->output_bfd;
3728 bfd_boolean result = TRUE;
3729 obj_attribute *in_attr;
3730 obj_attribute *out_attr;
3731 int i;
3732 int array_align_in, array_align_out, array_expect_in, array_expect_out;
3733
3734 if (!elf_known_obj_attributes_proc (obfd)[0].i)
3735 {
3736 /* This is the first object. Copy the attributes. */
3737 _bfd_elf_copy_obj_attributes (ibfd, obfd);
3738
3739 out_attr = elf_known_obj_attributes_proc (obfd);
3740
3741 /* Use the Tag_null value to indicate the attributes have been
3742 initialized. */
3743 out_attr[0].i = 1;
3744
3745 return TRUE;
3746 }
3747
3748 in_attr = elf_known_obj_attributes_proc (ibfd);
3749 out_attr = elf_known_obj_attributes_proc (obfd);
3750
3751 /* No specification yet for handling of unknown attributes, so just
3752 ignore them and handle known ones. */
3753
3754 if (out_attr[Tag_ABI_stack_align_preserved].i
3755 < in_attr[Tag_ABI_stack_align_needed].i)
3756 {
3757 _bfd_error_handler
3758 /* xgettext:c-format */
3759 (_("error: %B requires more stack alignment than %B preserves"),
3760 ibfd, obfd);
3761 result = FALSE;
3762 }
3763 if (in_attr[Tag_ABI_stack_align_preserved].i
3764 < out_attr[Tag_ABI_stack_align_needed].i)
3765 {
3766 _bfd_error_handler
3767 /* xgettext:c-format */
3768 (_("error: %B requires more stack alignment than %B preserves"),
3769 obfd, ibfd);
3770 result = FALSE;
3771 }
3772
3773 array_align_in = elf32_tic6x_tag_to_array_alignment
3774 (in_attr[Tag_ABI_array_object_alignment].i);
3775 if (array_align_in == -1)
3776 {
3777 _bfd_error_handler
3778 (_("error: unknown Tag_ABI_array_object_alignment value in %B"),
3779 ibfd);
3780 result = FALSE;
3781 }
3782 array_align_out = elf32_tic6x_tag_to_array_alignment
3783 (out_attr[Tag_ABI_array_object_alignment].i);
3784 if (array_align_out == -1)
3785 {
3786 _bfd_error_handler
3787 (_("error: unknown Tag_ABI_array_object_alignment value in %B"),
3788 obfd);
3789 result = FALSE;
3790 }
3791 array_expect_in = elf32_tic6x_tag_to_array_alignment
3792 (in_attr[Tag_ABI_array_object_align_expected].i);
3793 if (array_expect_in == -1)
3794 {
3795 _bfd_error_handler
3796 (_("error: unknown Tag_ABI_array_object_align_expected value in %B"),
3797 ibfd);
3798 result = FALSE;
3799 }
3800 array_expect_out = elf32_tic6x_tag_to_array_alignment
3801 (out_attr[Tag_ABI_array_object_align_expected].i);
3802 if (array_expect_out == -1)
3803 {
3804 _bfd_error_handler
3805 (_("error: unknown Tag_ABI_array_object_align_expected value in %B"),
3806 obfd);
3807 result = FALSE;
3808 }
3809
3810 if (array_align_out < array_expect_in)
3811 {
3812 _bfd_error_handler
3813 /* xgettext:c-format */
3814 (_("error: %B requires more array alignment than %B preserves"),
3815 ibfd, obfd);
3816 result = FALSE;
3817 }
3818 if (array_align_in < array_expect_out)
3819 {
3820 _bfd_error_handler
3821 /* xgettext:c-format */
3822 (_("error: %B requires more array alignment than %B preserves"),
3823 obfd, ibfd);
3824 result = FALSE;
3825 }
3826
3827 for (i = LEAST_KNOWN_OBJ_ATTRIBUTE; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++)
3828 {
3829 switch (i)
3830 {
3831 case Tag_ISA:
3832 out_attr[i].i = elf32_tic6x_merge_arch_attributes (in_attr[i].i,
3833 out_attr[i].i);
3834 break;
3835
3836 case Tag_ABI_wchar_t:
3837 if (out_attr[i].i == 0)
3838 out_attr[i].i = in_attr[i].i;
3839 if (out_attr[i].i != 0
3840 && in_attr[i].i != 0
3841 && out_attr[i].i != in_attr[i].i)
3842 {
3843 _bfd_error_handler
3844 /* xgettext:c-format */
3845 (_("warning: %B and %B differ in wchar_t size"), obfd, ibfd);
3846 }
3847 break;
3848
3849 case Tag_ABI_stack_align_needed:
3850 if (out_attr[i].i < in_attr[i].i)
3851 out_attr[i].i = in_attr[i].i;
3852 break;
3853
3854 case Tag_ABI_stack_align_preserved:
3855 if (out_attr[i].i > in_attr[i].i)
3856 out_attr[i].i = in_attr[i].i;
3857 break;
3858
3859 case Tag_ABI_DSBT:
3860 if (out_attr[i].i != in_attr[i].i)
3861 {
3862 _bfd_error_handler
3863 /* xgettext:c-format */
3864 (_("warning: %B and %B differ in whether code is "
3865 "compiled for DSBT"),
3866 obfd, ibfd);
3867 }
3868 break;
3869
3870 case Tag_ABI_PIC:
3871 case Tag_ABI_PID:
3872 if (out_attr[i].i > in_attr[i].i)
3873 out_attr[i].i = in_attr[i].i;
3874 break;
3875
3876 case Tag_ABI_array_object_alignment:
3877 if (array_align_out != -1
3878 && array_align_in != -1
3879 && array_align_out > array_align_in)
3880 out_attr[i].i
3881 = elf32_tic6x_array_alignment_to_tag (array_align_in);
3882 break;
3883
3884 case Tag_ABI_array_object_align_expected:
3885 if (array_expect_out != -1
3886 && array_expect_in != -1
3887 && array_expect_out < array_expect_in)
3888 out_attr[i].i
3889 = elf32_tic6x_array_alignment_to_tag (array_expect_in);
3890 break;
3891
3892 case Tag_ABI_conformance:
3893 /* Merging for this attribute is not specified. As on ARM,
3894 treat a missing attribute as no claim to conform and only
3895 merge identical values. */
3896 if (out_attr[i].s == NULL
3897 || in_attr[i].s == NULL
3898 || strcmp (out_attr[i].s,
3899 in_attr[i].s) != 0)
3900 out_attr[i].s = NULL;
3901 break;
3902
3903 case Tag_ABI_compatibility:
3904 /* Merged in _bfd_elf_merge_object_attributes. */
3905 break;
3906
3907 default:
3908 result
3909 = result && _bfd_elf_merge_unknown_attribute_low (ibfd, obfd, i);
3910 break;
3911 }
3912
3913 if (in_attr[i].type && !out_attr[i].type)
3914 out_attr[i].type = in_attr[i].type;
3915 }
3916
3917 /* Merge Tag_ABI_compatibility attributes and any common GNU ones. */
3918 if (!_bfd_elf_merge_object_attributes (ibfd, info))
3919 return FALSE;
3920
3921 result &= _bfd_elf_merge_unknown_attribute_list (ibfd, obfd);
3922
3923 return result;
3924 }
3925
3926 static bfd_boolean
3927 elf32_tic6x_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
3928 {
3929 if (!_bfd_generic_verify_endian_match (ibfd, info))
3930 return FALSE;
3931
3932 if (! is_tic6x_elf (ibfd) || ! is_tic6x_elf (info->output_bfd))
3933 return TRUE;
3934
3935 if (!elf32_tic6x_merge_attributes (ibfd, info))
3936 return FALSE;
3937
3938 return TRUE;
3939 }
3940
3941 /* Add a new unwind edit to the list described by HEAD, TAIL. If TINDEX is zero,
3942 adds the edit to the start of the list. (The list must be built in order of
3943 ascending TINDEX: the function's callers are primarily responsible for
3944 maintaining that condition). */
3945
3946 static void
3947 elf32_tic6x_add_unwind_table_edit (tic6x_unwind_table_edit **head,
3948 tic6x_unwind_table_edit **tail,
3949 tic6x_unwind_edit_type type,
3950 asection *linked_section,
3951 unsigned int tindex)
3952 {
3953 tic6x_unwind_table_edit *new_edit = (tic6x_unwind_table_edit *)
3954 xmalloc (sizeof (tic6x_unwind_table_edit));
3955
3956 new_edit->type = type;
3957 new_edit->linked_section = linked_section;
3958 new_edit->index = tindex;
3959
3960 if (tindex > 0)
3961 {
3962 new_edit->next = NULL;
3963
3964 if (*tail)
3965 (*tail)->next = new_edit;
3966
3967 (*tail) = new_edit;
3968
3969 if (!*head)
3970 (*head) = new_edit;
3971 }
3972 else
3973 {
3974 new_edit->next = *head;
3975
3976 if (!*tail)
3977 *tail = new_edit;
3978
3979 *head = new_edit;
3980 }
3981 }
3982
3983 static _tic6x_elf_section_data *
3984 get_tic6x_elf_section_data (asection * sec)
3985 {
3986 if (sec && sec->owner && is_tic6x_elf (sec->owner))
3987 return elf32_tic6x_section_data (sec);
3988 else
3989 return NULL;
3990 }
3991
3992
3993 /* Increase the size of EXIDX_SEC by ADJUST bytes. ADJUST must be negative. */
3994 static void
3995 elf32_tic6x_adjust_exidx_size (asection *exidx_sec, int adjust)
3996 {
3997 asection *out_sec;
3998
3999 if (!exidx_sec->rawsize)
4000 exidx_sec->rawsize = exidx_sec->size;
4001
4002 bfd_set_section_size (exidx_sec->owner, exidx_sec, exidx_sec->size + adjust);
4003 out_sec = exidx_sec->output_section;
4004 /* Adjust size of output section. */
4005 bfd_set_section_size (out_sec->owner, out_sec, out_sec->size +adjust);
4006 }
4007
4008 /* Insert an EXIDX_CANTUNWIND marker at the end of a section. */
4009 static void
4010 elf32_tic6x_insert_cantunwind_after (asection *text_sec, asection *exidx_sec)
4011 {
4012 struct _tic6x_elf_section_data *exidx_data;
4013
4014 exidx_data = get_tic6x_elf_section_data (exidx_sec);
4015 elf32_tic6x_add_unwind_table_edit (
4016 &exidx_data->u.exidx.unwind_edit_list,
4017 &exidx_data->u.exidx.unwind_edit_tail,
4018 INSERT_EXIDX_CANTUNWIND_AT_END, text_sec, UINT_MAX);
4019
4020 elf32_tic6x_adjust_exidx_size (exidx_sec, 8);
4021 }
4022
4023 /* Scan .cx6abi.exidx tables, and create a list describing edits which
4024 should be made to those tables, such that:
4025
4026 1. Regions without unwind data are marked with EXIDX_CANTUNWIND entries.
4027 2. Duplicate entries are merged together (EXIDX_CANTUNWIND, or unwind
4028 codes which have been inlined into the index).
4029
4030 If MERGE_EXIDX_ENTRIES is false, duplicate entries are not merged.
4031
4032 The edits are applied when the tables are written
4033 (in elf32_tic6x_write_section).
4034 */
4035
4036 bfd_boolean
4037 elf32_tic6x_fix_exidx_coverage (asection **text_section_order,
4038 unsigned int num_text_sections,
4039 struct bfd_link_info *info,
4040 bfd_boolean merge_exidx_entries)
4041 {
4042 bfd *inp;
4043 unsigned int last_second_word = 0, i;
4044 asection *last_exidx_sec = NULL;
4045 asection *last_text_sec = NULL;
4046 int last_unwind_type = -1;
4047
4048 /* Walk over all EXIDX sections, and create backlinks from the corrsponding
4049 text sections. */
4050 for (inp = info->input_bfds; inp != NULL; inp = inp->link.next)
4051 {
4052 asection *sec;
4053
4054 for (sec = inp->sections; sec != NULL; sec = sec->next)
4055 {
4056 struct bfd_elf_section_data *elf_sec = elf_section_data (sec);
4057 Elf_Internal_Shdr *hdr = &elf_sec->this_hdr;
4058
4059 if (!hdr || hdr->sh_type != SHT_C6000_UNWIND)
4060 continue;
4061
4062 if (elf_sec->linked_to)
4063 {
4064 Elf_Internal_Shdr *linked_hdr
4065 = &elf_section_data (elf_sec->linked_to)->this_hdr;
4066 struct _tic6x_elf_section_data *linked_sec_tic6x_data
4067 = get_tic6x_elf_section_data (linked_hdr->bfd_section);
4068
4069 if (linked_sec_tic6x_data == NULL)
4070 continue;
4071
4072 /* Link this .c6xabi.exidx section back from the
4073 text section it describes. */
4074 linked_sec_tic6x_data->u.text.tic6x_exidx_sec = sec;
4075 }
4076 }
4077 }
4078
4079 /* Walk all text sections in order of increasing VMA. Eilminate duplicate
4080 index table entries (EXIDX_CANTUNWIND and inlined unwind opcodes),
4081 and add EXIDX_CANTUNWIND entries for sections with no unwind table data. */
4082
4083 for (i = 0; i < num_text_sections; i++)
4084 {
4085 asection *sec = text_section_order[i];
4086 asection *exidx_sec;
4087 struct _tic6x_elf_section_data *tic6x_data
4088 = get_tic6x_elf_section_data (sec);
4089 struct _tic6x_elf_section_data *exidx_data;
4090 bfd_byte *contents = NULL;
4091 int deleted_exidx_bytes = 0;
4092 bfd_vma j;
4093 tic6x_unwind_table_edit *unwind_edit_head = NULL;
4094 tic6x_unwind_table_edit *unwind_edit_tail = NULL;
4095 Elf_Internal_Shdr *hdr;
4096 bfd *ibfd;
4097
4098 if (tic6x_data == NULL)
4099 continue;
4100
4101 exidx_sec = tic6x_data->u.text.tic6x_exidx_sec;
4102 if (exidx_sec == NULL)
4103 {
4104 /* Section has no unwind data. */
4105 if (last_unwind_type == 0 || !last_exidx_sec)
4106 continue;
4107
4108 /* Ignore zero sized sections. */
4109 if (sec->size == 0)
4110 continue;
4111
4112 elf32_tic6x_insert_cantunwind_after (last_text_sec, last_exidx_sec);
4113 last_unwind_type = 0;
4114 continue;
4115 }
4116
4117 /* Skip /DISCARD/ sections. */
4118 if (bfd_is_abs_section (exidx_sec->output_section))
4119 continue;
4120
4121 hdr = &elf_section_data (exidx_sec)->this_hdr;
4122 if (hdr->sh_type != SHT_C6000_UNWIND)
4123 continue;
4124
4125 exidx_data = get_tic6x_elf_section_data (exidx_sec);
4126 if (exidx_data == NULL)
4127 continue;
4128
4129 ibfd = exidx_sec->owner;
4130
4131 if (hdr->contents != NULL)
4132 contents = hdr->contents;
4133 else if (! bfd_malloc_and_get_section (ibfd, exidx_sec, &contents))
4134 /* An error? */
4135 continue;
4136
4137 for (j = 0; j < hdr->sh_size; j += 8)
4138 {
4139 unsigned int second_word = bfd_get_32 (ibfd, contents + j + 4);
4140 int unwind_type;
4141 int elide = 0;
4142
4143 /* An EXIDX_CANTUNWIND entry. */
4144 if (second_word == 1)
4145 {
4146 if (last_unwind_type == 0)
4147 elide = 1;
4148 unwind_type = 0;
4149 }
4150 /* Inlined unwinding data. Merge if equal to previous. */
4151 else if ((second_word & 0x80000000) != 0)
4152 {
4153 if (merge_exidx_entries
4154 && last_second_word == second_word
4155 && last_unwind_type == 1)
4156 elide = 1;
4157 unwind_type = 1;
4158 last_second_word = second_word;
4159 }
4160 /* Normal table entry. In theory we could merge these too,
4161 but duplicate entries are likely to be much less common. */
4162 else
4163 unwind_type = 2;
4164
4165 if (elide)
4166 {
4167 elf32_tic6x_add_unwind_table_edit (&unwind_edit_head,
4168 &unwind_edit_tail, DELETE_EXIDX_ENTRY, NULL, j / 8);
4169
4170 deleted_exidx_bytes += 8;
4171 }
4172
4173 last_unwind_type = unwind_type;
4174 }
4175
4176 /* Free contents if we allocated it ourselves. */
4177 if (contents != hdr->contents)
4178 free (contents);
4179
4180 /* Record edits to be applied later (in elf32_tic6x_write_section). */
4181 exidx_data->u.exidx.unwind_edit_list = unwind_edit_head;
4182 exidx_data->u.exidx.unwind_edit_tail = unwind_edit_tail;
4183
4184 if (deleted_exidx_bytes > 0)
4185 elf32_tic6x_adjust_exidx_size (exidx_sec, -deleted_exidx_bytes);
4186
4187 last_exidx_sec = exidx_sec;
4188 last_text_sec = sec;
4189 }
4190
4191 /* Add terminating CANTUNWIND entry. */
4192 if (last_exidx_sec && last_unwind_type != 0)
4193 elf32_tic6x_insert_cantunwind_after (last_text_sec, last_exidx_sec);
4194
4195 return TRUE;
4196 }
4197
4198 /* Add ADDEND to lower 31 bits of VAL, leaving other bits unmodified. */
4199
4200 static unsigned long
4201 elf32_tic6x_add_low31 (unsigned long val, bfd_vma addend)
4202 {
4203 return (val & ~0x7ffffffful) | ((val + addend) & 0x7ffffffful);
4204 }
4205
4206 /* Copy an .c6xabi.exidx table entry, adding OFFSET to (applied) PREL31
4207 relocations. OFFSET is in bytes, and will be scaled before encoding. */
4208
4209
4210 static void
4211 elf32_tic6x_copy_exidx_entry (bfd *output_bfd, bfd_byte *to, bfd_byte *from,
4212 bfd_vma offset)
4213 {
4214 unsigned long first_word = bfd_get_32 (output_bfd, from);
4215 unsigned long second_word = bfd_get_32 (output_bfd, from + 4);
4216
4217 offset >>= 1;
4218 /* High bit of first word is supposed to be zero. */
4219 if ((first_word & 0x80000000ul) == 0)
4220 first_word = elf32_tic6x_add_low31 (first_word, offset);
4221
4222 /* If the high bit of the first word is clear, and the bit pattern is not 0x1
4223 (EXIDX_CANTUNWIND), this is an offset to an .c6xabi.extab entry. */
4224 if ((second_word != 0x1) && ((second_word & 0x80000000ul) == 0))
4225 second_word = elf32_tic6x_add_low31 (second_word, offset);
4226
4227 bfd_put_32 (output_bfd, first_word, to);
4228 bfd_put_32 (output_bfd, second_word, to + 4);
4229 }
4230
4231 /* Do the actual mangling of exception index tables. */
4232
4233 static bfd_boolean
4234 elf32_tic6x_write_section (bfd *output_bfd,
4235 struct bfd_link_info *link_info,
4236 asection *sec,
4237 bfd_byte *contents)
4238 {
4239 _tic6x_elf_section_data *tic6x_data;
4240 struct elf32_tic6x_link_hash_table *globals
4241 = elf32_tic6x_hash_table (link_info);
4242 bfd_vma offset = sec->output_section->vma + sec->output_offset;
4243
4244 if (globals == NULL)
4245 return FALSE;
4246
4247 /* If this section has not been allocated an _tic6x_elf_section_data
4248 structure then we cannot record anything. */
4249 tic6x_data = get_tic6x_elf_section_data (sec);
4250 if (tic6x_data == NULL)
4251 return FALSE;
4252
4253 if (tic6x_data->elf.this_hdr.sh_type != SHT_C6000_UNWIND)
4254 return FALSE;
4255
4256 tic6x_unwind_table_edit *edit_node
4257 = tic6x_data->u.exidx.unwind_edit_list;
4258 /* Now, sec->size is the size of the section we will write. The original
4259 size (before we merged duplicate entries and inserted EXIDX_CANTUNWIND
4260 markers) was sec->rawsize. (This isn't the case if we perform no
4261 edits, then rawsize will be zero and we should use size). */
4262 bfd_byte *edited_contents = (bfd_byte *) bfd_malloc (sec->size);
4263 unsigned int input_size = sec->rawsize ? sec->rawsize : sec->size;
4264 unsigned int in_index, out_index;
4265 bfd_vma add_to_offsets = 0;
4266
4267 for (in_index = 0, out_index = 0; in_index * 8 < input_size || edit_node;)
4268 {
4269 if (edit_node)
4270 {
4271 unsigned int edit_index = edit_node->index;
4272
4273 if (in_index < edit_index && in_index * 8 < input_size)
4274 {
4275 elf32_tic6x_copy_exidx_entry (output_bfd,
4276 edited_contents + out_index * 8,
4277 contents + in_index * 8, add_to_offsets);
4278 out_index++;
4279 in_index++;
4280 }
4281 else if (in_index == edit_index
4282 || (in_index * 8 >= input_size
4283 && edit_index == UINT_MAX))
4284 {
4285 switch (edit_node->type)
4286 {
4287 case DELETE_EXIDX_ENTRY:
4288 in_index++;
4289 add_to_offsets += 8;
4290 break;
4291
4292 case INSERT_EXIDX_CANTUNWIND_AT_END:
4293 {
4294 asection *text_sec = edit_node->linked_section;
4295 bfd_vma text_offset = text_sec->output_section->vma
4296 + text_sec->output_offset
4297 + text_sec->size;
4298 bfd_vma exidx_offset = offset + out_index * 8;
4299 unsigned long prel31_offset;
4300
4301 /* Note: this is meant to be equivalent to an
4302 R_C6000_PREL31 relocation. These synthetic
4303 EXIDX_CANTUNWIND markers are not relocated by the
4304 usual BFD method. */
4305 prel31_offset = ((text_offset - exidx_offset) >> 1)
4306 & 0x7ffffffful;
4307
4308 /* First address we can't unwind. */
4309 bfd_put_32 (output_bfd, prel31_offset,
4310 &edited_contents[out_index * 8]);
4311
4312 /* Code for EXIDX_CANTUNWIND. */
4313 bfd_put_32 (output_bfd, 0x1,
4314 &edited_contents[out_index * 8 + 4]);
4315
4316 out_index++;
4317 add_to_offsets -= 8;
4318 }
4319 break;
4320 }
4321
4322 edit_node = edit_node->next;
4323 }
4324 }
4325 else
4326 {
4327 /* No more edits, copy remaining entries verbatim. */
4328 elf32_tic6x_copy_exidx_entry (output_bfd,
4329 edited_contents + out_index * 8,
4330 contents + in_index * 8, add_to_offsets);
4331 out_index++;
4332 in_index++;
4333 }
4334 }
4335
4336 if (!(sec->flags & SEC_EXCLUDE) && !(sec->flags & SEC_NEVER_LOAD))
4337 bfd_set_section_contents (output_bfd, sec->output_section,
4338 edited_contents,
4339 (file_ptr) sec->output_offset, sec->size);
4340
4341 return TRUE;
4342 }
4343
4344 #define TARGET_LITTLE_SYM tic6x_elf32_le_vec
4345 #define TARGET_LITTLE_NAME "elf32-tic6x-le"
4346 #define TARGET_BIG_SYM tic6x_elf32_be_vec
4347 #define TARGET_BIG_NAME "elf32-tic6x-be"
4348 #define ELF_ARCH bfd_arch_tic6x
4349 #define ELF_TARGET_ID TIC6X_ELF_DATA
4350 #define ELF_MACHINE_CODE EM_TI_C6000
4351 #define ELF_MAXPAGESIZE 0x1000
4352 #define bfd_elf32_bfd_reloc_type_lookup elf32_tic6x_reloc_type_lookup
4353 #define bfd_elf32_bfd_reloc_name_lookup elf32_tic6x_reloc_name_lookup
4354 #define bfd_elf32_bfd_merge_private_bfd_data elf32_tic6x_merge_private_bfd_data
4355 #define bfd_elf32_mkobject elf32_tic6x_mkobject
4356 #define bfd_elf32_bfd_link_hash_table_create elf32_tic6x_link_hash_table_create
4357 #define bfd_elf32_new_section_hook elf32_tic6x_new_section_hook
4358 #define elf_backend_stack_align 8
4359 #define elf_backend_can_gc_sections 1
4360 #define elf_backend_default_use_rela_p 1
4361 #define elf_backend_may_use_rel_p 1
4362 #define elf_backend_may_use_rela_p 1
4363 #define elf_backend_obj_attrs_arg_type elf32_tic6x_obj_attrs_arg_type
4364 #define elf_backend_obj_attrs_handle_unknown elf32_tic6x_obj_attrs_handle_unknown
4365 #define elf_backend_obj_attrs_order elf32_tic6x_obj_attrs_order
4366 #define elf_backend_obj_attrs_section ".c6xabi.attributes"
4367 #define elf_backend_obj_attrs_section_type SHT_C6000_ATTRIBUTES
4368 #define elf_backend_obj_attrs_vendor "c6xabi"
4369 #define elf_backend_can_refcount 1
4370 #define elf_backend_want_got_plt 1
4371 #define elf_backend_want_dynbss 1
4372 #define elf_backend_plt_readonly 1
4373 #define elf_backend_rela_normal 1
4374 #define elf_backend_got_header_size 8
4375 #define elf_backend_fake_sections elf32_tic6x_fake_sections
4376 #define elf_backend_gc_sweep_hook elf32_tic6x_gc_sweep_hook
4377 #define elf_backend_gc_mark_extra_sections elf32_tic6x_gc_mark_extra_sections
4378 #define elf_backend_create_dynamic_sections \
4379 elf32_tic6x_create_dynamic_sections
4380 #define elf_backend_adjust_dynamic_symbol \
4381 elf32_tic6x_adjust_dynamic_symbol
4382 #define elf_backend_check_relocs elf32_tic6x_check_relocs
4383 #define elf_backend_add_symbol_hook elf32_tic6x_add_symbol_hook
4384 #define elf_backend_symbol_processing elf32_tic6x_symbol_processing
4385 #define elf_backend_link_output_symbol_hook \
4386 elf32_tic6x_link_output_symbol_hook
4387 #define elf_backend_section_from_bfd_section \
4388 elf32_tic6x_section_from_bfd_section
4389 #define elf_backend_relocate_section elf32_tic6x_relocate_section
4390 #define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
4391 #define elf_backend_finish_dynamic_symbol \
4392 elf32_tic6x_finish_dynamic_symbol
4393 #define elf_backend_always_size_sections \
4394 elf32_tic6x_always_size_sections
4395 #define elf_backend_size_dynamic_sections \
4396 elf32_tic6x_size_dynamic_sections
4397 #define elf_backend_finish_dynamic_sections \
4398 elf32_tic6x_finish_dynamic_sections
4399 #define bfd_elf32_bfd_final_link \
4400 elf32_tic6x_final_link
4401 #define elf_backend_write_section elf32_tic6x_write_section
4402 #define elf_info_to_howto elf32_tic6x_info_to_howto
4403 #define elf_info_to_howto_rel elf32_tic6x_info_to_howto_rel
4404
4405 #undef elf_backend_omit_section_dynsym
4406 #define elf_backend_omit_section_dynsym elf32_tic6x_link_omit_section_dynsym
4407 #define elf_backend_plt_sym_val elf32_tic6x_plt_sym_val
4408
4409 #include "elf32-target.h"
4410
4411 #undef elf32_bed
4412 #define elf32_bed elf32_tic6x_linux_bed
4413
4414 #undef TARGET_LITTLE_SYM
4415 #define TARGET_LITTLE_SYM tic6x_elf32_linux_le_vec
4416 #undef TARGET_LITTLE_NAME
4417 #define TARGET_LITTLE_NAME "elf32-tic6x-linux-le"
4418 #undef TARGET_BIG_SYM
4419 #define TARGET_BIG_SYM tic6x_elf32_linux_be_vec
4420 #undef TARGET_BIG_NAME
4421 #define TARGET_BIG_NAME "elf32-tic6x-linux-be"
4422 #undef ELF_OSABI
4423 #define ELF_OSABI ELFOSABI_C6000_LINUX
4424
4425 #include "elf32-target.h"
4426
4427 #undef elf32_bed
4428 #define elf32_bed elf32_tic6x_elf_bed
4429
4430 #undef TARGET_LITTLE_SYM
4431 #define TARGET_LITTLE_SYM tic6x_elf32_c6000_le_vec
4432 #undef TARGET_LITTLE_NAME
4433 #define TARGET_LITTLE_NAME "elf32-tic6x-elf-le"
4434 #undef TARGET_BIG_SYM
4435 #define TARGET_BIG_SYM tic6x_elf32_c6000_be_vec
4436 #undef TARGET_BIG_NAME
4437 #define TARGET_BIG_NAME "elf32-tic6x-elf-be"
4438 #undef ELF_OSABI
4439 #define ELF_OSABI ELFOSABI_C6000_ELFABI
4440
4441 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.116654 seconds and 3 git commands to generate.