1 /* ARC-specific support for 32-bit ELF
2 Copyright (C) 1994-2018 Free Software Foundation, Inc.
3 Contributed by Cupertino Miranda (cmiranda@synopsys.com).
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
27 #include "libiberty.h"
28 #include "opcode/arc-func.h"
29 #include "opcode/arc.h"
32 #define FEATURE_LIST_NAME bfd_feature_list
33 #define CONFLICT_LIST bfd_conflict_list
34 #include "opcode/arc-attrs.h"
36 /* #define ARC_ENABLE_DEBUG 1 */
37 #ifdef ARC_ENABLE_DEBUG
39 name_for_global_symbol (struct elf_link_hash_entry
*h
)
41 static char *local_str
= "(local)";
44 return h
->root
.root
.string
;
46 #define ARC_DEBUG(fmt, args...) fprintf (stderr, fmt, ##args)
48 #define ARC_DEBUG(...)
52 #define ADD_RELA(BFD, SECTION, OFFSET, SYM_IDX, TYPE, ADDEND) \
54 struct elf_link_hash_table *_htab = elf_hash_table (info); \
55 Elf_Internal_Rela _rel; \
58 if (_htab->dynamic_sections_created == TRUE) \
60 BFD_ASSERT (_htab->srel##SECTION &&_htab->srel##SECTION->contents); \
61 _loc = _htab->srel##SECTION->contents \
62 + ((_htab->srel##SECTION->reloc_count) \
63 * sizeof (Elf32_External_Rela)); \
64 _htab->srel##SECTION->reloc_count++; \
65 _rel.r_addend = ADDEND; \
66 _rel.r_offset = (_htab->s##SECTION)->output_section->vma \
67 + (_htab->s##SECTION)->output_offset + OFFSET; \
68 BFD_ASSERT ((long) SYM_IDX != -1); \
69 _rel.r_info = ELF32_R_INFO (SYM_IDX, TYPE); \
70 bfd_elf32_swap_reloca_out (BFD, &_rel, _loc); \
75 /* The default symbols representing the init and fini dyn values.
76 TODO: Check what is the relation of those strings with arclinux.em
78 #define INIT_SYM_STRING "_init"
79 #define FINI_SYM_STRING "_fini"
81 char * init_str
= INIT_SYM_STRING
;
82 char * fini_str
= FINI_SYM_STRING
;
84 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
89 static ATTRIBUTE_UNUSED
const char *
90 reloc_type_to_name (unsigned int type
)
94 #include "elf/arc-reloc.def"
102 #undef ARC_RELOC_HOWTO
104 /* Try to minimize the amount of space occupied by relocation tables
105 on the ROM (not that the ROM won't be swamped by other ELF overhead). */
109 static ATTRIBUTE_UNUSED bfd_boolean
110 is_reloc_PC_relative (reloc_howto_type
*howto
)
112 return (strstr (howto
->name
, "PC") != NULL
) ? TRUE
: FALSE
;
116 is_reloc_SDA_relative (reloc_howto_type
*howto
)
118 return (strstr (howto
->name
, "SDA") != NULL
) ? TRUE
: FALSE
;
122 is_reloc_for_GOT (reloc_howto_type
* howto
)
124 if (strstr (howto
->name
, "TLS") != NULL
)
126 return (strstr (howto
->name
, "GOT") != NULL
) ? TRUE
: FALSE
;
130 is_reloc_for_PLT (reloc_howto_type
* howto
)
132 return (strstr (howto
->name
, "PLT") != NULL
) ? TRUE
: FALSE
;
136 is_reloc_for_TLS (reloc_howto_type
*howto
)
138 return (strstr (howto
->name
, "TLS") != NULL
) ? TRUE
: FALSE
;
141 struct arc_relocation_data
143 bfd_signed_vma reloc_offset
;
144 bfd_signed_vma reloc_addend
;
145 bfd_signed_vma got_offset_value
;
147 bfd_signed_vma sym_value
;
148 asection
* sym_section
;
150 reloc_howto_type
*howto
;
152 asection
* input_section
;
154 bfd_signed_vma sdata_begin_symbol_vma
;
155 bfd_boolean sdata_begin_symbol_vma_set
;
156 bfd_signed_vma got_symbol_vma
;
158 bfd_boolean should_relocate
;
160 const char * symbol_name
;
163 /* ARC ELF linker hash entry. */
164 struct elf_arc_link_hash_entry
166 struct elf_link_hash_entry root
;
168 /* Track dynamic relocs copied for this symbol. */
169 struct elf_dyn_relocs
*dyn_relocs
;
171 struct got_entry
*got_ents
;
175 /* Should be included at this location due to static declarations
176 defined before this point. */
179 #define arc_bfd_get_8(A,B,C) bfd_get_8(A,B)
180 #define arc_bfd_get_16(A,B,C) bfd_get_16(A,B)
181 #define arc_bfd_get_32(A,B,C) bfd_get_32(A,B)
182 #define arc_bfd_put_8(A,B,C,D) bfd_put_8(A,B,C)
183 #define arc_bfd_put_16(A,B,C,D) bfd_put_16(A,B,C)
184 #define arc_bfd_put_32(A,B,C,D) bfd_put_32(A,B,C)
187 static bfd_reloc_status_type
188 arc_elf_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
189 arelent
*reloc_entry
,
191 void *data ATTRIBUTE_UNUSED
,
192 asection
*input_section
,
194 char ** error_message ATTRIBUTE_UNUSED
)
196 if (output_bfd
!= NULL
)
198 reloc_entry
->address
+= input_section
->output_offset
;
200 /* In case of relocateable link and if the reloc is against a
201 section symbol, the addend needs to be adjusted according to
202 where the section symbol winds up in the output section. */
203 if ((symbol_in
->flags
& BSF_SECTION_SYM
) && symbol_in
->section
)
204 reloc_entry
->addend
+= symbol_in
->section
->output_offset
;
209 return bfd_reloc_continue
;
213 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
218 #include "elf/arc-reloc.def"
222 #undef ARC_RELOC_HOWTO
224 #define ARC_RELOC_HOWTO(TYPE, VALUE, RSIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
225 [TYPE] = HOWTO (R_##TYPE, 0, RSIZE, BITSIZE, FALSE, 0, \
226 complain_overflow_##OVERFLOW, arc_elf_reloc, \
227 "R_" #TYPE, FALSE, 0, 0, FALSE),
229 static struct reloc_howto_struct elf_arc_howto_table
[] =
231 #include "elf/arc-reloc.def"
232 /* Example of what is generated by the preprocessor. Currently kept as an
234 HOWTO (R_ARC_NONE, // Type.
236 2, // Size (0 = byte, 1 = short, 2 = long).
238 FALSE, // PC_relative.
240 complain_overflow_bitfield, // Complain_on_overflow.
241 bfd_elf_generic_reloc, // Special_function.
242 "R_ARC_NONE", // Name.
243 TRUE, // Partial_inplace.
246 FALSE), // PCrel_offset.
249 #undef ARC_RELOC_HOWTO
252 arc_elf_howto_init (void)
254 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
255 elf_arc_howto_table[TYPE].pc_relative = \
256 (strstr (#FORMULA, " P ") != NULL || strstr (#FORMULA, " PDATA ") != NULL); \
257 elf_arc_howto_table[TYPE].dst_mask = RELOC_FUNCTION(0, ~0); \
258 /* Only 32 bit data relocations should be marked as ME. */ \
259 if (strstr (#FORMULA, " ME ") != NULL) \
261 BFD_ASSERT (SIZE == 2); \
264 #include "elf/arc-reloc.def"
267 #undef ARC_RELOC_HOWTO
270 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
273 const int howto_table_lookup
[] =
275 #include "elf/arc-reloc.def"
278 #undef ARC_RELOC_HOWTO
280 static reloc_howto_type
*
281 arc_elf_howto (unsigned int r_type
)
283 if (elf_arc_howto_table
[R_ARC_32
].dst_mask
== 0)
284 arc_elf_howto_init ();
285 return &elf_arc_howto_table
[r_type
];
288 /* Map BFD reloc types to ARC ELF reloc types. */
292 bfd_reloc_code_real_type bfd_reloc_val
;
293 unsigned char elf_reloc_val
;
296 /* ARC ELF linker hash table. */
297 struct elf_arc_link_hash_table
299 struct elf_link_hash_table elf
;
302 static struct bfd_hash_entry
*
303 elf_arc_link_hash_newfunc (struct bfd_hash_entry
*entry
,
304 struct bfd_hash_table
*table
,
307 struct elf_arc_link_hash_entry
* ret
=
308 (struct elf_arc_link_hash_entry
*) entry
;
310 /* Allocate the structure if it has not already been allocated by a
313 ret
= (struct elf_arc_link_hash_entry
*)
314 bfd_hash_allocate (table
, sizeof (struct elf_arc_link_hash_entry
));
316 return (struct bfd_hash_entry
*) ret
;
318 /* Call the allocation method of the superclass. */
319 ret
= ((struct elf_arc_link_hash_entry
*)
320 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
324 ret
->dyn_relocs
= NULL
;
325 ret
->got_ents
= NULL
;
328 return (struct bfd_hash_entry
*) ret
;
331 /* Destroy an ARC ELF linker hash table. */
333 elf_arc_link_hash_table_free (bfd
*obfd
)
335 _bfd_elf_link_hash_table_free (obfd
);
338 /* Create an ARC ELF linker hash table. */
340 static struct bfd_link_hash_table
*
341 arc_elf_link_hash_table_create (bfd
*abfd
)
343 struct elf_arc_link_hash_table
*ret
;
345 ret
= (struct elf_arc_link_hash_table
*) bfd_zmalloc (sizeof (*ret
));
349 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
350 elf_arc_link_hash_newfunc
,
351 sizeof (struct elf_arc_link_hash_entry
),
358 ret
->elf
.root
.hash_table_free
= elf_arc_link_hash_table_free
;
360 return &ret
->elf
.root
;
363 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
364 { BFD_RELOC_##TYPE, R_##TYPE },
366 static const struct arc_reloc_map arc_reloc_map
[] =
368 #include "elf/arc-reloc.def"
370 {BFD_RELOC_NONE
, R_ARC_NONE
},
371 {BFD_RELOC_8
, R_ARC_8
},
372 {BFD_RELOC_16
, R_ARC_16
},
373 {BFD_RELOC_24
, R_ARC_24
},
374 {BFD_RELOC_32
, R_ARC_32
},
377 #undef ARC_RELOC_HOWTO
379 typedef ATTRIBUTE_UNUSED
bfd_vma (*replace_func
) (unsigned, int ATTRIBUTE_UNUSED
);
381 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
383 func = (void *) RELOC_FUNCTION; \
387 get_replace_function (bfd
*abfd
, unsigned int r_type
)
393 #include "elf/arc-reloc.def"
396 if (func
== replace_bits24
&& bfd_big_endian (abfd
))
397 func
= replace_bits24_be
;
399 return (replace_func
) func
;
401 #undef ARC_RELOC_HOWTO
403 static reloc_howto_type
*
404 arc_elf32_bfd_reloc_type_lookup (bfd
* abfd ATTRIBUTE_UNUSED
,
405 bfd_reloc_code_real_type code
)
409 for (i
= ARRAY_SIZE (arc_reloc_map
); i
--;)
411 if (arc_reloc_map
[i
].bfd_reloc_val
== code
)
412 return arc_elf_howto (arc_reloc_map
[i
].elf_reloc_val
);
418 /* Function to set the ELF flag bits. */
420 arc_elf_set_private_flags (bfd
*abfd
, flagword flags
)
422 elf_elfheader (abfd
)->e_flags
= flags
;
423 elf_flags_init (abfd
) = TRUE
;
427 /* Print private flags. */
429 arc_elf_print_private_bfd_data (bfd
*abfd
, void * ptr
)
431 FILE *file
= (FILE *) ptr
;
434 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
436 /* Print normal ELF private data. */
437 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
439 flags
= elf_elfheader (abfd
)->e_flags
;
440 fprintf (file
, _("private flags = 0x%lx:"), (unsigned long) flags
);
442 switch (flags
& EF_ARC_MACH_MSK
)
444 case EF_ARC_CPU_ARCV2HS
: fprintf (file
, " -mcpu=ARCv2HS"); break;
445 case EF_ARC_CPU_ARCV2EM
: fprintf (file
, " -mcpu=ARCv2EM"); break;
446 case E_ARC_MACH_ARC600
: fprintf (file
, " -mcpu=ARC600"); break;
447 case E_ARC_MACH_ARC601
: fprintf (file
, " -mcpu=ARC601"); break;
448 case E_ARC_MACH_ARC700
: fprintf (file
, " -mcpu=ARC700"); break;
450 fprintf (file
, "-mcpu=unknown");
454 switch (flags
& EF_ARC_OSABI_MSK
)
456 case E_ARC_OSABI_ORIG
: fprintf (file
, " (ABI:legacy)"); break;
457 case E_ARC_OSABI_V2
: fprintf (file
, " (ABI:v2)"); break;
458 case E_ARC_OSABI_V3
: fprintf (file
, " (ABI:v3)"); break;
459 case E_ARC_OSABI_V4
: fprintf (file
, " (ABI:v4)"); break;
461 fprintf (file
, " (ABI:unknown)");
469 /* Copy backend specific data from one object module to another. */
472 arc_elf_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
474 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
475 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
478 BFD_ASSERT (!elf_flags_init (obfd
)
479 || elf_elfheader (obfd
)->e_flags
== elf_elfheader (ibfd
)->e_flags
);
481 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
482 elf_flags_init (obfd
) = TRUE
;
484 /* Copy object attributes. */
485 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
487 return _bfd_elf_copy_private_bfd_data (ibfd
, obfd
);
490 static reloc_howto_type
*
491 bfd_elf32_bfd_reloc_name_lookup (bfd
* abfd ATTRIBUTE_UNUSED
,
496 for (i
= 0; i
< ARRAY_SIZE (elf_arc_howto_table
); i
++)
497 if (elf_arc_howto_table
[i
].name
!= NULL
498 && strcasecmp (elf_arc_howto_table
[i
].name
, r_name
) == 0)
499 return arc_elf_howto (i
);
504 /* Set the howto pointer for an ARC ELF reloc. */
507 arc_info_to_howto_rel (bfd
* abfd
,
509 Elf_Internal_Rela
* dst
)
513 r_type
= ELF32_R_TYPE (dst
->r_info
);
514 if (r_type
>= (unsigned int) R_ARC_max
)
516 /* xgettext:c-format */
517 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
519 bfd_set_error (bfd_error_bad_value
);
523 cache_ptr
->howto
= arc_elf_howto (r_type
);
527 /* Extract CPU features from an NTBS. */
530 arc_extract_features (const char *p
)
537 for (i
= 0; i
< ARRAY_SIZE (bfd_feature_list
); i
++)
539 char *t
= strstr (p
, bfd_feature_list
[i
].attr
);
540 unsigned l
= strlen (bfd_feature_list
[i
].attr
);
544 r
|= bfd_feature_list
[i
].feature
;
550 /* Concatenate two strings. s1 can be NULL but not
554 arc_stralloc (char * s1
, const char * s2
)
558 /* Only s1 can be null. */
561 p
= s1
? concat (s1
, ",", s2
, NULL
) : (char *)s2
;
566 /* Merge ARC object attributes from IBFD into OBFD. Raise an error if
567 there are conflicting attributes. */
570 arc_elf_merge_attributes (bfd
*ibfd
, struct bfd_link_info
*info
)
572 bfd
*obfd
= info
->output_bfd
;
573 obj_attribute
*in_attr
;
574 obj_attribute
*out_attr
;
576 bfd_boolean result
= TRUE
;
577 const char *sec_name
= get_elf_backend_data (ibfd
)->obj_attrs_section
;
578 char *tagname
= NULL
;
580 /* Skip the linker stubs file. This preserves previous behavior
581 of accepting unknown attributes in the first input file - but
583 if (ibfd
->flags
& BFD_LINKER_CREATED
)
586 /* Skip any input that hasn't attribute section.
587 This enables to link object files without attribute section with
589 if (bfd_get_section_by_name (ibfd
, sec_name
) == NULL
)
592 if (!elf_known_obj_attributes_proc (obfd
)[0].i
)
594 /* This is the first object. Copy the attributes. */
595 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
597 out_attr
= elf_known_obj_attributes_proc (obfd
);
599 /* Use the Tag_null value to indicate the attributes have been
606 in_attr
= elf_known_obj_attributes_proc (ibfd
);
607 out_attr
= elf_known_obj_attributes_proc (obfd
);
609 for (i
= LEAST_KNOWN_OBJ_ATTRIBUTE
; i
< NUM_KNOWN_OBJ_ATTRIBUTES
; i
++)
611 /* Merge this attribute with existing attributes. */
614 case Tag_ARC_PCS_config
:
615 if (out_attr
[i
].i
== 0)
616 out_attr
[i
].i
= in_attr
[i
].i
;
617 else if (in_attr
[i
].i
!= 0 && out_attr
[i
].i
!= in_attr
[i
].i
)
619 const char *tagval
[] = { "Absent", "Bare-metal/mwdt",
620 "Bare-metal/newlib", "Linux/uclibc",
622 BFD_ASSERT (in_attr
[i
].i
< 5);
623 BFD_ASSERT (out_attr
[i
].i
< 5);
624 /* It's sometimes ok to mix different configs, so this is only
627 (_("warning: %pB: conflicting platform configuration "
629 tagval
[in_attr
[i
].i
],
630 tagval
[out_attr
[i
].i
]);
634 case Tag_ARC_CPU_base
:
635 if (out_attr
[i
].i
== 0)
636 out_attr
[i
].i
= in_attr
[i
].i
;
637 else if (in_attr
[i
].i
!= 0 && out_attr
[i
].i
!= in_attr
[i
].i
638 && ((out_attr
[i
].i
+ in_attr
[i
].i
) < 6))
640 const char *tagval
[] = { "Absent", "ARC6xx", "ARC7xx",
642 BFD_ASSERT (in_attr
[i
].i
< 5);
643 BFD_ASSERT (out_attr
[i
].i
< 5);
644 /* We cannot mix code for different CPUs. */
646 (_("error: %pB: unable to merge CPU base attributes "
649 tagval
[in_attr
[i
].i
],
650 tagval
[out_attr
[i
].i
]);
656 /* The CPUs may be different, check if we can still mix
657 the objects against the output choosen CPU. */
658 unsigned in_feature
= 0;
659 unsigned out_feature
= 0;
660 char *p1
= in_attr
[Tag_ARC_ISA_config
].s
;
661 char *p2
= out_attr
[Tag_ARC_ISA_config
].s
;
664 unsigned opcode_map
[] = {0, ARC_OPCODE_ARC600
, ARC_OPCODE_ARC700
,
665 ARC_OPCODE_ARCv2EM
, ARC_OPCODE_ARCv2HS
};
667 BFD_ASSERT (in_attr
[i
].i
< (sizeof (opcode_map
)
668 / sizeof (unsigned)));
669 BFD_ASSERT (out_attr
[i
].i
< (sizeof (opcode_map
)
670 / sizeof (unsigned)));
671 cpu_out
= opcode_map
[out_attr
[i
].i
];
673 in_feature
= arc_extract_features (p1
);
674 out_feature
= arc_extract_features (p2
);
676 /* First, check if a feature is compatible with the
677 output object chosen CPU. */
678 for (j
= 0; j
< ARRAY_SIZE (bfd_feature_list
); j
++)
679 if (((in_feature
| out_feature
) & bfd_feature_list
[j
].feature
)
680 && (!(cpu_out
& bfd_feature_list
[j
].cpus
)))
683 (_("error: %pB: unable to merge ISA extension attributes "
685 obfd
, bfd_feature_list
[j
].name
);
689 /* Second, if we have compatible features with the
690 chosen CPU, check if they are compatible among
692 for (j
= 0; j
< ARRAY_SIZE (bfd_conflict_list
); j
++)
693 if (((in_feature
| out_feature
) & bfd_conflict_list
[j
])
694 == bfd_conflict_list
[j
])
697 for (k
= 0; k
< ARRAY_SIZE (bfd_feature_list
); k
++)
699 if (in_feature
& bfd_feature_list
[k
].feature
700 & bfd_conflict_list
[j
])
701 p1
= (char *) bfd_feature_list
[k
].name
;
702 if (out_feature
& bfd_feature_list
[k
].feature
703 & bfd_conflict_list
[j
])
704 p2
= (char *) bfd_feature_list
[k
].name
;
707 (_("error: %pB: conflicting ISA extension attributes "
713 /* Everithing is alright. */
714 out_feature
|= in_feature
;
716 for (j
= 0; j
< ARRAY_SIZE (bfd_feature_list
); j
++)
717 if (out_feature
& bfd_feature_list
[j
].feature
)
718 p1
= arc_stralloc (p1
, bfd_feature_list
[j
].attr
);
720 out_attr
[Tag_ARC_ISA_config
].s
=
721 _bfd_elf_attr_strdup (obfd
, p1
);
724 case Tag_ARC_CPU_variation
:
725 case Tag_ARC_ISA_mpy_option
:
726 case Tag_ARC_ABI_osver
:
727 /* Use the largest value specified. */
728 if (in_attr
[i
].i
> out_attr
[i
].i
)
729 out_attr
[i
].i
= in_attr
[i
].i
;
732 /* The CPU name is given by the vendor, just choose an
733 existing one if missing or different. There are no fail
734 criteria if they different or both missing. */
735 case Tag_ARC_CPU_name
:
736 if (!out_attr
[i
].s
&& in_attr
[i
].s
)
737 out_attr
[i
].s
= _bfd_elf_attr_strdup (obfd
, in_attr
[i
].s
);
740 case Tag_ARC_ABI_rf16
:
741 if (out_attr
[i
].i
== 0)
742 out_attr
[i
].i
= in_attr
[i
].i
;
743 else if (out_attr
[i
].i
!= in_attr
[i
].i
)
745 /* We cannot mix code with rf16 and without. */
747 (_("error: %pB: cannot mix rf16 with full register set %pB"),
753 case Tag_ARC_ABI_pic
:
756 case Tag_ARC_ABI_sda
:
760 case Tag_ARC_ABI_tls
:
762 const char *tagval
[] = { "Absent", "MWDT", "GNU" };
767 BFD_ASSERT (in_attr
[i
].i
< 3);
768 BFD_ASSERT (out_attr
[i
].i
< 3);
769 if (out_attr
[i
].i
== 0)
770 out_attr
[i
].i
= in_attr
[i
].i
;
771 else if (out_attr
[i
].i
!= 0 && in_attr
[i
].i
!= 0
772 && out_attr
[i
].i
!= in_attr
[i
].i
)
775 (_("error: %pB: conflicting attributes %s: %s with %s"),
777 tagval
[in_attr
[i
].i
],
778 tagval
[out_attr
[i
].i
]);
785 case Tag_ARC_ABI_double_size
:
786 tagname
= "Double size";
788 case Tag_ARC_ABI_enumsize
:
790 tagname
= "Enum size";
792 case Tag_ARC_ABI_exceptions
:
794 tagname
= "ABI exceptions";
796 if (out_attr
[i
].i
== 0)
797 out_attr
[i
].i
= in_attr
[i
].i
;
798 else if (out_attr
[i
].i
!= 0 && in_attr
[i
].i
!= 0
799 && out_attr
[i
].i
!= in_attr
[i
].i
)
802 (_("error: %pB: conflicting attributes %s"),
808 case Tag_ARC_ISA_apex
:
809 break; /* Do nothing for APEX attributes. */
811 case Tag_ARC_ISA_config
:
812 /* It is handled in Tag_ARC_CPU_base. */
815 case Tag_ARC_ATR_version
:
816 if (out_attr
[i
].i
== 0)
817 out_attr
[i
].i
= in_attr
[i
].i
;
822 = result
&& _bfd_elf_merge_unknown_attribute_low (ibfd
, obfd
, i
);
825 /* If out_attr was copied from in_attr then it won't have a type yet. */
826 if (in_attr
[i
].type
&& !out_attr
[i
].type
)
827 out_attr
[i
].type
= in_attr
[i
].type
;
830 /* Merge Tag_compatibility attributes and any common GNU ones. */
831 if (!_bfd_elf_merge_object_attributes (ibfd
, info
))
834 /* Check for any attributes not known on ARC. */
835 result
&= _bfd_elf_merge_unknown_attribute_list (ibfd
, obfd
);
840 /* Merge backend specific data from an object file to the output
841 object file when linking. */
844 arc_elf_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
846 bfd
*obfd
= info
->output_bfd
;
847 unsigned short mach_ibfd
;
848 static unsigned short mach_obfd
= EM_NONE
;
853 /* Check if we have the same endianess. */
854 if (! _bfd_generic_verify_endian_match (ibfd
, info
))
857 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
858 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
861 /* Collect ELF flags. */
862 in_flags
= elf_elfheader (ibfd
)->e_flags
& EF_ARC_MACH_MSK
;
863 out_flags
= elf_elfheader (obfd
)->e_flags
& EF_ARC_MACH_MSK
;
865 if (!elf_flags_init (obfd
)) /* First call, no flags set. */
867 elf_flags_init (obfd
) = TRUE
;
868 out_flags
= in_flags
;
871 if (!arc_elf_merge_attributes (ibfd
, info
))
874 /* Check to see if the input BFD actually contains any sections. Do
875 not short-circuit dynamic objects; their section list may be
876 emptied by elf_link_add_object_symbols. */
877 if (!(ibfd
->flags
& DYNAMIC
))
879 bfd_boolean null_input_bfd
= TRUE
;
880 bfd_boolean only_data_sections
= TRUE
;
882 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
884 if ((bfd_get_section_flags (ibfd
, sec
)
885 & (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
886 == (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
887 only_data_sections
= FALSE
;
889 null_input_bfd
= FALSE
;
892 if (null_input_bfd
|| only_data_sections
)
896 /* Complain about various flag/architecture mismatches. */
897 mach_ibfd
= elf_elfheader (ibfd
)->e_machine
;
898 if (mach_obfd
== EM_NONE
)
900 mach_obfd
= mach_ibfd
;
904 if (mach_ibfd
!= mach_obfd
)
906 /* xgettext:c-format */
907 _bfd_error_handler (_("error: attempting to link %pB "
908 "with a binary %pB of different architecture"),
912 else if ((in_flags
!= out_flags
)
913 /* If we have object attributes, then we already
914 checked the objects compatibility, skip it. */
915 && !bfd_elf_get_obj_attr_int (ibfd
, OBJ_ATTR_PROC
,
918 if (in_flags
&& out_flags
)
920 /* Warn if different flags. */
922 /* xgettext:c-format */
923 (_("%pB: uses different e_flags (%#x) fields than "
924 "previous modules (%#x)"),
925 ibfd
, in_flags
, out_flags
);
928 /* MWDT doesnt set the eflags hence make sure we choose the
929 eflags set by gcc. */
930 in_flags
= in_flags
> out_flags
? in_flags
: out_flags
;
934 /* Everything is correct; don't change the output flags. */
935 in_flags
= out_flags
;
939 /* Update the flags. */
940 elf_elfheader (obfd
)->e_flags
= in_flags
;
942 if (bfd_get_mach (obfd
) < bfd_get_mach (ibfd
))
944 return bfd_set_arch_mach (obfd
, bfd_arch_arc
, bfd_get_mach (ibfd
));
950 /* Return a best guess for the machine number based on the attributes. */
953 bfd_arc_get_mach_from_attributes (bfd
* abfd
)
955 int arch
= bfd_elf_get_obj_attr_int (abfd
, OBJ_ATTR_PROC
, Tag_ARC_CPU_base
);
956 unsigned e_machine
= elf_elfheader (abfd
)->e_machine
;
961 return bfd_mach_arc_arc600
;
963 return bfd_mach_arc_arc700
;
966 return bfd_mach_arc_arcv2
;
970 return (e_machine
== EM_ARC_COMPACT
)
971 ? bfd_mach_arc_arc700
: bfd_mach_arc_arcv2
;
974 /* Set the right machine number for an ARC ELF file. */
976 arc_elf_object_p (bfd
* abfd
)
978 /* Make sure this is initialised, or you'll have the potential of passing
979 garbage---or misleading values---into the call to
980 bfd_default_set_arch_mach (). */
981 unsigned int mach
= bfd_mach_arc_arc700
;
982 unsigned long arch
= elf_elfheader (abfd
)->e_flags
& EF_ARC_MACH_MSK
;
983 unsigned e_machine
= elf_elfheader (abfd
)->e_machine
;
985 if (e_machine
== EM_ARC_COMPACT
|| e_machine
== EM_ARC_COMPACT2
)
989 case E_ARC_MACH_ARC600
:
990 mach
= bfd_mach_arc_arc600
;
992 case E_ARC_MACH_ARC601
:
993 mach
= bfd_mach_arc_arc601
;
995 case E_ARC_MACH_ARC700
:
996 mach
= bfd_mach_arc_arc700
;
998 case EF_ARC_CPU_ARCV2HS
:
999 case EF_ARC_CPU_ARCV2EM
:
1000 mach
= bfd_mach_arc_arcv2
;
1003 mach
= bfd_arc_get_mach_from_attributes (abfd
);
1009 if (e_machine
== EM_ARC
)
1012 (_("error: the ARC4 architecture is no longer supported"));
1018 (_("warning: unset or old architecture flags; "
1019 "use default machine"));
1023 return bfd_default_set_arch_mach (abfd
, bfd_arch_arc
, mach
);
1026 /* The final processing done just before writing out an ARC ELF object file.
1027 This gets the ARC architecture right based on the machine number. */
1030 arc_elf_final_write_processing (bfd
* abfd
,
1031 bfd_boolean linker ATTRIBUTE_UNUSED
)
1034 int osver
= bfd_elf_get_obj_attr_int (abfd
, OBJ_ATTR_PROC
,
1036 flagword e_flags
= elf_elfheader (abfd
)->e_flags
& ~EF_ARC_OSABI_MSK
;
1038 switch (bfd_get_mach (abfd
))
1040 case bfd_mach_arc_arc600
:
1041 emf
= EM_ARC_COMPACT
;
1043 case bfd_mach_arc_arc601
:
1044 emf
= EM_ARC_COMPACT
;
1046 case bfd_mach_arc_arc700
:
1047 emf
= EM_ARC_COMPACT
;
1049 case bfd_mach_arc_arcv2
:
1050 emf
= EM_ARC_COMPACT2
;
1056 elf_elfheader (abfd
)->e_machine
= emf
;
1058 /* Record whatever is the current syscall ABI version. */
1060 e_flags
|= ((osver
& 0x0f) << 8);
1062 e_flags
|= E_ARC_OSABI_V3
;
1064 elf_elfheader (abfd
)->e_flags
|= e_flags
;
1067 #ifdef ARC_ENABLE_DEBUG
1068 #define DEBUG_ARC_RELOC(A) debug_arc_reloc (A)
1071 debug_arc_reloc (struct arc_relocation_data reloc_data
)
1073 ARC_DEBUG ("Reloc type=%s, should_relocate = %s\n",
1074 reloc_data
.howto
->name
,
1075 reloc_data
.should_relocate
? "true" : "false");
1076 ARC_DEBUG (" offset = 0x%x, addend = 0x%x\n",
1077 (unsigned int) reloc_data
.reloc_offset
,
1078 (unsigned int) reloc_data
.reloc_addend
);
1079 ARC_DEBUG (" Symbol:\n");
1080 ARC_DEBUG (" value = 0x%08x\n",
1081 (unsigned int) reloc_data
.sym_value
);
1082 if (reloc_data
.sym_section
!= NULL
)
1084 ARC_DEBUG (" Symbol Section:\n");
1085 ARC_DEBUG (" section name = %s, output_offset 0x%08x",
1086 reloc_data
.sym_section
->name
,
1087 (unsigned int) reloc_data
.sym_section
->output_offset
);
1088 if (reloc_data
.sym_section
->output_section
!= NULL
)
1089 ARC_DEBUG (", output_section->vma = 0x%08x",
1090 ((unsigned int) reloc_data
.sym_section
->output_section
->vma
));
1092 if (reloc_data
.sym_section
->owner
&& reloc_data
.sym_section
->owner
->filename
)
1093 ARC_DEBUG (" file: %s\n", reloc_data
.sym_section
->owner
->filename
);
1097 ARC_DEBUG (" symbol section is NULL\n");
1100 ARC_DEBUG (" Input_section:\n");
1101 if (reloc_data
.input_section
!= NULL
)
1103 ARC_DEBUG (" section name = %s, output_offset 0x%08x, output_section->vma = 0x%08x\n",
1104 reloc_data
.input_section
->name
,
1105 (unsigned int) reloc_data
.input_section
->output_offset
,
1106 (unsigned int) reloc_data
.input_section
->output_section
->vma
);
1107 ARC_DEBUG (" changed_address = 0x%08x\n",
1108 (unsigned int) (reloc_data
.input_section
->output_section
->vma
1109 + reloc_data
.input_section
->output_offset
1110 + reloc_data
.reloc_offset
));
1111 ARC_DEBUG (" file: %s\n", reloc_data
.input_section
->owner
->filename
);
1115 ARC_DEBUG (" input section is NULL\n");
1119 #define DEBUG_ARC_RELOC(A)
1120 #endif /* ARC_ENABLE_DEBUG */
1123 middle_endian_convert (bfd_vma insn
, bfd_boolean do_it
)
1128 = ((insn
& 0xffff0000) >> 16)
1129 | ((insn
& 0xffff) << 16);
1134 /* This function is called for relocations that are otherwise marked as NOT
1135 requiring overflow checks. In here we perform non-standard checks of
1136 the relocation value. */
1138 static inline bfd_reloc_status_type
1139 arc_special_overflow_checks (const struct arc_relocation_data reloc_data
,
1140 bfd_signed_vma relocation
,
1141 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1143 switch (reloc_data
.howto
->type
)
1145 case R_ARC_NPS_CMEM16
:
1146 if (((relocation
>> 16) & 0xffff) != NPS_CMEM_HIGH_VALUE
)
1148 if (reloc_data
.reloc_addend
== 0)
1150 /* xgettext:c-format */
1151 (_("%pB(%pA+%#" PRIx64
"): CMEM relocation to `%s' is invalid, "
1152 "16 MSB should be %#x (value is %#" PRIx64
")"),
1153 reloc_data
.input_section
->owner
,
1154 reloc_data
.input_section
,
1155 (uint64_t) reloc_data
.reloc_offset
,
1156 reloc_data
.symbol_name
,
1157 NPS_CMEM_HIGH_VALUE
,
1158 (uint64_t) relocation
);
1161 /* xgettext:c-format */
1162 (_("%pB(%pA+%#" PRIx64
"): CMEM relocation to `%s+%#" PRIx64
1163 "' is invalid, 16 MSB should be %#x (value is %#" PRIx64
")"),
1164 reloc_data
.input_section
->owner
,
1165 reloc_data
.input_section
,
1166 (uint64_t) reloc_data
.reloc_offset
,
1167 reloc_data
.symbol_name
,
1168 (uint64_t) reloc_data
.reloc_addend
,
1169 NPS_CMEM_HIGH_VALUE
,
1170 (uint64_t) relocation
);
1171 return bfd_reloc_overflow
;
1179 return bfd_reloc_ok
;
1182 #define ME(reloc) (reloc)
1184 #define IS_ME(FORMULA,BFD) ((strstr (FORMULA, "ME") != NULL) \
1185 && (!bfd_big_endian (BFD)))
1187 #define S ((bfd_signed_vma) (reloc_data.sym_value \
1188 + (reloc_data.sym_section->output_section != NULL ? \
1189 (reloc_data.sym_section->output_offset \
1190 + reloc_data.sym_section->output_section->vma) : 0)))
1191 #define L ((bfd_signed_vma) (reloc_data.sym_value \
1192 + (reloc_data.sym_section->output_section != NULL ? \
1193 (reloc_data.sym_section->output_offset \
1194 + reloc_data.sym_section->output_section->vma) : 0)))
1195 #define A (reloc_data.reloc_addend)
1197 #define G (reloc_data.got_offset_value)
1198 #define GOT (reloc_data.got_symbol_vma)
1199 #define GOT_BEGIN (htab->sgot->output_section->vma)
1202 /* P: relative offset to PCL The offset should be to the
1203 current location aligned to 32 bits. */
1204 #define P ((bfd_signed_vma) ( \
1206 (reloc_data.input_section->output_section != NULL ? \
1207 reloc_data.input_section->output_section->vma : 0) \
1208 + reloc_data.input_section->output_offset \
1209 + (reloc_data.reloc_offset - (bitsize >= 32 ? 4 : 0))) \
1211 #define PDATA ((bfd_signed_vma) ( \
1212 (reloc_data.input_section->output_section->vma \
1213 + reloc_data.input_section->output_offset \
1214 + (reloc_data.reloc_offset))))
1215 #define SECTSTART (bfd_signed_vma) (reloc_data.sym_section->output_section->vma \
1216 + reloc_data.sym_section->output_offset)
1217 #define JLI (bfd_signed_vma) (reloc_data.sym_section->output_section->vma)
1218 #define _SDA_BASE_ (bfd_signed_vma) (reloc_data.sdata_begin_symbol_vma)
1219 #define TLS_REL (bfd_signed_vma) \
1220 ((elf_hash_table (info))->tls_sec->output_section->vma)
1221 #define TLS_TBSS (align_power(TCB_SIZE, \
1222 reloc_data.sym_section->alignment_power))
1226 #ifdef ARC_ENABLE_DEBUG
1227 #define PRINT_DEBUG_RELOC_INFO_BEFORE(FORMULA, TYPE) \
1230 asection *sym_section = reloc_data.sym_section; \
1231 asection *input_section = reloc_data.input_section; \
1232 ARC_DEBUG ("RELOC_TYPE = " TYPE "\n"); \
1233 ARC_DEBUG ("FORMULA = " FORMULA "\n"); \
1234 ARC_DEBUG ("S = %#lx\n", S); \
1235 ARC_DEBUG ("A = %#lx\n", A); \
1236 ARC_DEBUG ("L = %lx\n", L); \
1237 if (sym_section->output_section != NULL) \
1238 ARC_DEBUG ("symbol_section->vma = %#lx\n", \
1239 sym_section->output_section->vma \
1240 + sym_section->output_offset); \
1242 ARC_DEBUG ("symbol_section->vma = NULL\n"); \
1243 if (input_section->output_section != NULL) \
1244 ARC_DEBUG ("symbol_section->vma = %#lx\n", \
1245 input_section->output_section->vma \
1246 + input_section->output_offset); \
1248 ARC_DEBUG ("symbol_section->vma = NULL\n"); \
1249 ARC_DEBUG ("PCL = %#lx\n", P); \
1250 ARC_DEBUG ("P = %#lx\n", P); \
1251 ARC_DEBUG ("G = %#lx\n", G); \
1252 ARC_DEBUG ("SDA_OFFSET = %#lx\n", _SDA_BASE_); \
1253 ARC_DEBUG ("SDA_SET = %d\n", reloc_data.sdata_begin_symbol_vma_set); \
1254 ARC_DEBUG ("GOT_OFFSET = %#lx\n", GOT); \
1255 ARC_DEBUG ("relocation = %#08lx\n", relocation); \
1256 ARC_DEBUG ("before = %#08x\n", (unsigned) insn); \
1257 ARC_DEBUG ("data = %08x (%u) (%d)\n", (unsigned) relocation, \
1258 (unsigned) relocation, (int) relocation); \
1262 #define PRINT_DEBUG_RELOC_INFO_AFTER \
1265 ARC_DEBUG ("after = 0x%08x\n", (unsigned int) insn); \
1271 #define PRINT_DEBUG_RELOC_INFO_BEFORE(...)
1272 #define PRINT_DEBUG_RELOC_INFO_AFTER
1274 #endif /* ARC_ENABLE_DEBUG */
1276 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
1279 bfd_signed_vma bitsize ATTRIBUTE_UNUSED = BITSIZE; \
1280 relocation = FORMULA ; \
1281 PRINT_DEBUG_RELOC_INFO_BEFORE (#FORMULA, #TYPE); \
1282 insn = middle_endian_convert (insn, IS_ME (#FORMULA, abfd)); \
1283 insn = (* get_replace_function (abfd, TYPE)) (insn, relocation); \
1284 insn = middle_endian_convert (insn, IS_ME (#FORMULA, abfd)); \
1285 PRINT_DEBUG_RELOC_INFO_AFTER; \
1289 static bfd_reloc_status_type
1290 arc_do_relocation (bfd_byte
* contents
,
1291 struct arc_relocation_data reloc_data
,
1292 struct bfd_link_info
*info
)
1294 bfd_signed_vma relocation
= 0;
1296 bfd_vma orig_insn ATTRIBUTE_UNUSED
;
1297 bfd
* abfd
= reloc_data
.input_section
->owner
;
1298 struct elf_link_hash_table
*htab ATTRIBUTE_UNUSED
= elf_hash_table (info
);
1299 bfd_reloc_status_type flag
;
1301 if (!reloc_data
.should_relocate
)
1302 return bfd_reloc_ok
;
1304 switch (reloc_data
.howto
->size
)
1307 insn
= arc_bfd_get_32 (abfd
,
1308 contents
+ reloc_data
.reloc_offset
,
1309 reloc_data
.input_section
);
1312 insn
= arc_bfd_get_16 (abfd
,
1313 contents
+ reloc_data
.reloc_offset
,
1314 reloc_data
.input_section
);
1317 insn
= arc_bfd_get_8 (abfd
,
1318 contents
+ reloc_data
.reloc_offset
,
1319 reloc_data
.input_section
);
1329 switch (reloc_data
.howto
->type
)
1331 #include "elf/arc-reloc.def"
1338 /* Check for relocation overflow. */
1339 if (reloc_data
.howto
->complain_on_overflow
!= complain_overflow_dont
)
1340 flag
= bfd_check_overflow (reloc_data
.howto
->complain_on_overflow
,
1341 reloc_data
.howto
->bitsize
,
1342 reloc_data
.howto
->rightshift
,
1343 bfd_arch_bits_per_address (abfd
),
1346 flag
= arc_special_overflow_checks (reloc_data
, relocation
, info
);
1348 if (flag
!= bfd_reloc_ok
)
1350 ARC_DEBUG ("Relocation overflows !\n");
1351 DEBUG_ARC_RELOC (reloc_data
);
1352 ARC_DEBUG ("Relocation value = signed -> %d, unsigned -> %u"
1353 ", hex -> (0x%08x)\n",
1354 (int) relocation
, (unsigned) relocation
, (int) relocation
);
1359 /* Write updated instruction back to memory. */
1360 switch (reloc_data
.howto
->size
)
1363 arc_bfd_put_32 (abfd
, insn
,
1364 contents
+ reloc_data
.reloc_offset
,
1365 reloc_data
.input_section
);
1368 arc_bfd_put_16 (abfd
, insn
,
1369 contents
+ reloc_data
.reloc_offset
,
1370 reloc_data
.input_section
);
1373 arc_bfd_put_8 (abfd
, insn
,
1374 contents
+ reloc_data
.reloc_offset
,
1375 reloc_data
.input_section
);
1378 ARC_DEBUG ("size = %d\n", reloc_data
.howto
->size
);
1383 return bfd_reloc_ok
;
1399 #undef ARC_RELOC_HOWTO
1402 /* Relocate an arc ELF section.
1403 Function : elf_arc_relocate_section
1404 Brief : Relocate an arc section, by handling all the relocations
1405 appearing in that section.
1406 Args : output_bfd : The bfd being written to.
1407 info : Link information.
1408 input_bfd : The input bfd.
1409 input_section : The section being relocated.
1410 contents : contents of the section being relocated.
1411 relocs : List of relocations in the section.
1412 local_syms : is a pointer to the swapped in local symbols.
1413 local_section : is an array giving the section in the input file
1414 corresponding to the st_shndx field of each
1417 elf_arc_relocate_section (bfd
* output_bfd
,
1418 struct bfd_link_info
* info
,
1420 asection
* input_section
,
1421 bfd_byte
* contents
,
1422 Elf_Internal_Rela
* relocs
,
1423 Elf_Internal_Sym
* local_syms
,
1424 asection
** local_sections
)
1426 Elf_Internal_Shdr
* symtab_hdr
;
1427 struct elf_link_hash_entry
** sym_hashes
;
1428 Elf_Internal_Rela
* rel
;
1429 Elf_Internal_Rela
* wrel
;
1430 Elf_Internal_Rela
* relend
;
1431 struct elf_link_hash_table
* htab
= elf_hash_table (info
);
1433 symtab_hdr
= &((elf_tdata (input_bfd
))->symtab_hdr
);
1434 sym_hashes
= elf_sym_hashes (input_bfd
);
1436 rel
= wrel
= relocs
;
1437 relend
= relocs
+ input_section
->reloc_count
;
1438 for (; rel
< relend
; wrel
++, rel
++)
1440 enum elf_arc_reloc_type r_type
;
1441 reloc_howto_type
* howto
;
1442 unsigned long r_symndx
;
1443 struct elf_link_hash_entry
* h
;
1444 Elf_Internal_Sym
* sym
;
1446 struct elf_link_hash_entry
* h2
;
1448 bfd_boolean unresolved_reloc
= FALSE
;
1450 struct arc_relocation_data reloc_data
=
1454 .got_offset_value
= 0,
1456 .sym_section
= NULL
,
1458 .input_section
= NULL
,
1459 .sdata_begin_symbol_vma
= 0,
1460 .sdata_begin_symbol_vma_set
= FALSE
,
1461 .got_symbol_vma
= 0,
1462 .should_relocate
= FALSE
1465 r_type
= ELF32_R_TYPE (rel
->r_info
);
1467 if (r_type
>= (int) R_ARC_max
)
1469 bfd_set_error (bfd_error_bad_value
);
1472 howto
= arc_elf_howto (r_type
);
1474 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1476 /* If we are generating another .o file and the symbol in not
1477 local, skip this relocation. */
1478 if (bfd_link_relocatable (info
))
1480 /* This is a relocateable link. We don't have to change
1481 anything, unless the reloc is against a section symbol,
1482 in which case we have to adjust according to where the
1483 section symbol winds up in the output section. */
1485 /* Checks if this is a local symbol and thus the reloc
1486 might (will??) be against a section symbol. */
1487 if (r_symndx
< symtab_hdr
->sh_info
)
1489 sym
= local_syms
+ r_symndx
;
1490 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1492 sec
= local_sections
[r_symndx
];
1494 /* For RELA relocs. Just adjust the addend
1495 value in the relocation entry. */
1496 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
1498 ARC_DEBUG ("local symbols reloc (section=%d %s) seen in %s\n",
1499 (int) r_symndx
, local_sections
[r_symndx
]->name
,
1500 __PRETTY_FUNCTION__
);
1505 h2
= elf_link_hash_lookup (elf_hash_table (info
), "__SDATA_BEGIN__",
1506 FALSE
, FALSE
, TRUE
);
1508 if (!reloc_data
.sdata_begin_symbol_vma_set
1509 && h2
!= NULL
&& h2
->root
.type
!= bfd_link_hash_undefined
1510 && h2
->root
.u
.def
.section
->output_section
!= NULL
)
1511 /* TODO: Verify this condition. */
1513 reloc_data
.sdata_begin_symbol_vma
=
1514 (h2
->root
.u
.def
.value
1515 + h2
->root
.u
.def
.section
->output_section
->vma
);
1516 reloc_data
.sdata_begin_symbol_vma_set
= TRUE
;
1519 reloc_data
.input_section
= input_section
;
1520 reloc_data
.howto
= howto
;
1521 reloc_data
.reloc_offset
= rel
->r_offset
;
1522 reloc_data
.reloc_addend
= rel
->r_addend
;
1524 /* This is a final link. */
1529 if (r_symndx
< symtab_hdr
->sh_info
) /* A local symbol. */
1531 sym
= local_syms
+ r_symndx
;
1532 sec
= local_sections
[r_symndx
];
1536 bfd_boolean warned
, ignored
;
1537 bfd_vma relocation ATTRIBUTE_UNUSED
;
1539 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
1540 r_symndx
, symtab_hdr
, sym_hashes
,
1542 unresolved_reloc
, warned
, ignored
);
1544 /* TODO: This code is repeated from below. We should
1545 clean it and remove duplications.
1546 Sec is used check for discarded sections.
1547 Need to redesign code below. */
1549 /* Get the symbol's entry in the symtab. */
1550 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1552 while (h
->root
.type
== bfd_link_hash_indirect
1553 || h
->root
.type
== bfd_link_hash_warning
)
1554 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1556 /* If we have encountered a definition for this symbol. */
1557 if (h
->root
.type
== bfd_link_hash_defined
1558 || h
->root
.type
== bfd_link_hash_defweak
)
1560 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1561 sec
= h
->root
.u
.def
.section
;
1565 /* Clean relocs for symbols in discarded sections. */
1566 if (sec
!= NULL
&& discarded_section (sec
))
1568 _bfd_clear_contents (howto
, input_bfd
, input_section
,
1569 contents
+ rel
->r_offset
);
1573 /* For ld -r, remove relocations in debug sections against
1574 sections defined in discarded sections. Not done for
1575 eh_frame editing code expects to be present. */
1576 if (bfd_link_relocatable (info
)
1577 && (input_section
->flags
& SEC_DEBUGGING
))
1583 if (bfd_link_relocatable (info
))
1590 if (r_symndx
< symtab_hdr
->sh_info
) /* A local symbol. */
1592 reloc_data
.sym_value
= sym
->st_value
;
1593 reloc_data
.sym_section
= sec
;
1594 reloc_data
.symbol_name
=
1595 bfd_elf_string_from_elf_section (input_bfd
,
1596 symtab_hdr
->sh_link
,
1599 /* Mergeable section handling. */
1600 if ((sec
->flags
& SEC_MERGE
)
1601 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1605 rel
->r_addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
,
1606 &msec
, rel
->r_addend
);
1607 rel
->r_addend
-= (sec
->output_section
->vma
1608 + sec
->output_offset
1610 rel
->r_addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
1612 reloc_data
.reloc_addend
= rel
->r_addend
;
1615 BFD_ASSERT (htab
->sgot
!= NULL
|| !is_reloc_for_GOT (howto
));
1616 if (htab
->sgot
!= NULL
)
1617 reloc_data
.got_symbol_vma
= htab
->sgot
->output_section
->vma
1618 + htab
->sgot
->output_offset
;
1620 reloc_data
.should_relocate
= TRUE
;
1622 else /* Global symbol. */
1624 /* FIXME: We should use the RELOC_FOR_GLOBAL_SYMBOL macro
1625 (defined in elf-bfd.h) here. */
1627 /* Get the symbol's entry in the symtab. */
1628 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1630 while (h
->root
.type
== bfd_link_hash_indirect
1631 || h
->root
.type
== bfd_link_hash_warning
)
1633 struct elf_arc_link_hash_entry
*ah_old
=
1634 (struct elf_arc_link_hash_entry
*) h
;
1635 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1636 struct elf_arc_link_hash_entry
*ah
=
1637 (struct elf_arc_link_hash_entry
*) h
;
1639 if (ah
->got_ents
== 0 && ah_old
->got_ents
!= ah
->got_ents
)
1640 ah
->got_ents
= ah_old
->got_ents
;
1643 /* TODO: Need to validate what was the intention. */
1644 /* BFD_ASSERT ((h->dynindx == -1) || (h->forced_local != 0)); */
1645 reloc_data
.symbol_name
= h
->root
.root
.string
;
1647 /* If we have encountered a definition for this symbol. */
1648 if (h
->root
.type
== bfd_link_hash_defined
1649 || h
->root
.type
== bfd_link_hash_defweak
)
1651 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1652 reloc_data
.sym_section
= h
->root
.u
.def
.section
;
1654 reloc_data
.should_relocate
= TRUE
;
1656 if (is_reloc_for_GOT (howto
) && !bfd_link_pic (info
))
1658 struct elf_arc_link_hash_entry
*ah
=
1659 (struct elf_arc_link_hash_entry
*) h
;
1660 /* TODO: Change it to use arc_do_relocation with
1661 ARC_32 reloc. Try to use ADD_RELA macro. */
1662 bfd_vma relocation
=
1663 reloc_data
.sym_value
+ reloc_data
.reloc_addend
1664 + (reloc_data
.sym_section
->output_section
!= NULL
?
1665 (reloc_data
.sym_section
->output_offset
1666 + reloc_data
.sym_section
->output_section
->vma
)
1669 BFD_ASSERT (ah
->got_ents
);
1670 bfd_vma got_offset
= ah
->got_ents
->offset
;
1671 bfd_put_32 (output_bfd
, relocation
,
1672 htab
->sgot
->contents
+ got_offset
);
1674 if (is_reloc_for_PLT (howto
) && h
->plt
.offset
!= (bfd_vma
) -1)
1676 /* TODO: This is repeated up here. */
1677 reloc_data
.sym_value
= h
->plt
.offset
;
1678 reloc_data
.sym_section
= htab
->splt
;
1681 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1683 /* Is weak symbol and has no definition. */
1684 if (is_reloc_for_GOT (howto
))
1686 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1687 reloc_data
.sym_section
= htab
->sgot
;
1688 reloc_data
.should_relocate
= TRUE
;
1690 else if (is_reloc_for_PLT (howto
)
1691 && h
->plt
.offset
!= (bfd_vma
) -1)
1693 /* TODO: This is repeated up here. */
1694 reloc_data
.sym_value
= h
->plt
.offset
;
1695 reloc_data
.sym_section
= htab
->splt
;
1696 reloc_data
.should_relocate
= TRUE
;
1703 if (is_reloc_for_GOT (howto
))
1705 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1706 reloc_data
.sym_section
= htab
->sgot
;
1708 reloc_data
.should_relocate
= TRUE
;
1710 else if (is_reloc_for_PLT (howto
))
1712 /* Fail if it is linking for PIE and the symbol is
1714 if (bfd_link_executable (info
))
1715 (*info
->callbacks
->undefined_symbol
)
1716 (info
, h
->root
.root
.string
, input_bfd
, input_section
,
1717 rel
->r_offset
, TRUE
);
1718 reloc_data
.sym_value
= h
->plt
.offset
;
1719 reloc_data
.sym_section
= htab
->splt
;
1721 reloc_data
.should_relocate
= TRUE
;
1723 else if (!bfd_link_pic (info
) || bfd_link_executable (info
))
1724 (*info
->callbacks
->undefined_symbol
)
1725 (info
, h
->root
.root
.string
, input_bfd
, input_section
,
1726 rel
->r_offset
, TRUE
);
1729 BFD_ASSERT (htab
->sgot
!= NULL
|| !is_reloc_for_GOT (howto
));
1730 if (htab
->sgot
!= NULL
)
1731 reloc_data
.got_symbol_vma
= htab
->sgot
->output_section
->vma
1732 + htab
->sgot
->output_offset
;
1735 if ((is_reloc_for_GOT (howto
)
1736 || is_reloc_for_TLS (howto
)))
1738 reloc_data
.should_relocate
= TRUE
;
1740 struct got_entry
**list
1741 = get_got_entry_list_for_symbol (output_bfd
, r_symndx
, h
);
1743 reloc_data
.got_offset_value
1744 = relocate_fix_got_relocs_for_got_info (list
,
1745 tls_type_for_reloc (howto
),
1756 create_got_dynrelocs_for_single_entry (
1757 got_entry_for_type (list
,
1758 arc_got_entry_type_for_reloc (howto
)),
1759 output_bfd
, info
, NULL
);
1764 #define IS_ARC_PCREL_TYPE(TYPE) \
1765 ( (TYPE == R_ARC_PC32) \
1766 || (TYPE == R_ARC_32_PCREL))
1773 case R_ARC_32_PCREL
:
1774 if (bfd_link_pic (info
)
1775 && (!IS_ARC_PCREL_TYPE (r_type
)
1779 && (!info
->symbolic
|| !h
->def_regular
))))
1781 Elf_Internal_Rela outrel
;
1783 bfd_boolean skip
= FALSE
;
1784 bfd_boolean relocate
= FALSE
;
1785 asection
*sreloc
= _bfd_elf_get_dynamic_reloc_section
1786 (input_bfd
, input_section
,
1789 BFD_ASSERT (sreloc
!= NULL
);
1791 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
1796 if (outrel
.r_offset
== (bfd_vma
) -1)
1799 outrel
.r_addend
= rel
->r_addend
;
1800 outrel
.r_offset
+= (input_section
->output_section
->vma
1801 + input_section
->output_offset
);
1805 memset (&outrel
, 0, sizeof outrel
);
1810 && (IS_ARC_PCREL_TYPE (r_type
)
1811 || !(bfd_link_executable (info
)
1812 || SYMBOLIC_BIND (info
, h
))
1813 || ! h
->def_regular
))
1815 BFD_ASSERT (h
!= NULL
);
1816 if ((input_section
->flags
& SEC_ALLOC
) != 0)
1821 BFD_ASSERT (h
->dynindx
!= -1);
1822 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
1826 /* Handle local symbols, they either do not have a
1827 global hash table entry (h == NULL), or are
1828 forced local due to a version script
1829 (h->forced_local), or the third condition is
1830 legacy, it appears to say something like, for
1831 links where we are pre-binding the symbols, or
1832 there's not an entry for this symbol in the
1833 dynamic symbol table, and it's a regular symbol
1834 not defined in a shared object, then treat the
1835 symbol as local, resolve it now. */
1837 /* outrel.r_addend = 0; */
1838 outrel
.r_info
= ELF32_R_INFO (0, R_ARC_RELATIVE
);
1841 BFD_ASSERT (sreloc
->contents
!= 0);
1843 loc
= sreloc
->contents
;
1844 loc
+= sreloc
->reloc_count
* sizeof (Elf32_External_Rela
);
1845 sreloc
->reloc_count
+= 1;
1847 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
1857 if (is_reloc_SDA_relative (howto
)
1858 && !reloc_data
.sdata_begin_symbol_vma_set
)
1861 ("error: linker symbol __SDATA_BEGIN__ not found");
1862 bfd_set_error (bfd_error_bad_value
);
1866 DEBUG_ARC_RELOC (reloc_data
);
1868 /* Make sure we have with a dynamic linker. In case of GOT and PLT
1869 the sym_section should point to .got or .plt respectively. */
1870 if ((is_reloc_for_GOT (howto
) || is_reloc_for_PLT (howto
))
1871 && reloc_data
.sym_section
== NULL
)
1874 (_("GOT and PLT relocations cannot be fixed with a non dynamic linker"));
1875 bfd_set_error (bfd_error_bad_value
);
1880 switch (arc_do_relocation (contents
, reloc_data
, info
))
1883 continue; /* The reloc processing loop. */
1885 case bfd_reloc_overflow
:
1886 (*info
->callbacks
->reloc_overflow
)
1887 (info
, (h
? &h
->root
: NULL
), reloc_data
.symbol_name
, howto
->name
, (bfd_vma
) 0,
1888 input_bfd
, input_section
, rel
->r_offset
);
1891 case bfd_reloc_undefined
:
1892 (*info
->callbacks
->undefined_symbol
)
1893 (info
, reloc_data
.symbol_name
, input_bfd
, input_section
, rel
->r_offset
, TRUE
);
1896 case bfd_reloc_other
:
1897 /* xgettext:c-format */
1898 msg
= _("%pB(%pA): warning: unaligned access to symbol '%s' in the small data area");
1901 case bfd_reloc_outofrange
:
1902 /* xgettext:c-format */
1903 msg
= _("%pB(%pA): internal error: out of range error");
1906 case bfd_reloc_notsupported
:
1907 /* xgettext:c-format */
1908 msg
= _("%pB(%pA): internal error: unsupported relocation error");
1911 case bfd_reloc_dangerous
:
1912 /* xgettext:c-format */
1913 msg
= _("%pB(%pA): internal error: dangerous relocation");
1917 /* xgettext:c-format */
1918 msg
= _("%pB(%pA): internal error: unknown error");
1923 _bfd_error_handler (msg
, input_bfd
, input_section
, reloc_data
.symbol_name
);
1930 #define elf_arc_hash_table(p) \
1931 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
1932 == ARC_ELF_DATA ? ((struct elf_arc_link_hash_table *) ((p)->hash)) : NULL)
1935 elf_arc_check_relocs (bfd
* abfd
,
1936 struct bfd_link_info
* info
,
1938 const Elf_Internal_Rela
* relocs
)
1940 Elf_Internal_Shdr
* symtab_hdr
;
1941 struct elf_link_hash_entry
** sym_hashes
;
1942 const Elf_Internal_Rela
* rel
;
1943 const Elf_Internal_Rela
* rel_end
;
1945 asection
* sreloc
= NULL
;
1946 struct elf_link_hash_table
* htab
= elf_hash_table (info
);
1948 if (bfd_link_relocatable (info
))
1951 if (htab
->dynobj
== NULL
)
1952 htab
->dynobj
= abfd
;
1954 dynobj
= (elf_hash_table (info
))->dynobj
;
1955 symtab_hdr
= &((elf_tdata (abfd
))->symtab_hdr
);
1956 sym_hashes
= elf_sym_hashes (abfd
);
1958 rel_end
= relocs
+ sec
->reloc_count
;
1959 for (rel
= relocs
; rel
< rel_end
; rel
++)
1961 enum elf_arc_reloc_type r_type
;
1962 reloc_howto_type
*howto
;
1963 unsigned long r_symndx
;
1964 struct elf_link_hash_entry
*h
;
1966 r_type
= ELF32_R_TYPE (rel
->r_info
);
1968 if (r_type
>= (int) R_ARC_max
)
1970 bfd_set_error (bfd_error_bad_value
);
1973 howto
= arc_elf_howto (r_type
);
1975 /* Load symbol information. */
1976 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1977 if (r_symndx
< symtab_hdr
->sh_info
) /* Is a local symbol. */
1979 else /* Global one. */
1981 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1982 while (h
->root
.type
== bfd_link_hash_indirect
1983 || h
->root
.type
== bfd_link_hash_warning
)
1984 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1992 /* During shared library creation, these relocs should not
1993 appear in a shared library (as memory will be read only
1994 and the dynamic linker can not resolve these. However
1995 the error should not occur for e.g. debugging or
1996 non-readonly sections. */
1998 && (bfd_link_dll (info
) && !bfd_link_pie (info
))
1999 && (sec
->flags
& SEC_ALLOC
) != 0
2000 && (sec
->flags
& SEC_READONLY
) != 0
2001 && ((sec
->flags
& SEC_CODE
) != 0
2002 || (sec
->flags
& SEC_DEBUGGING
) != 0))
2006 name
= h
->root
.root
.string
;
2008 /* bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL); */
2011 /* xgettext:c-format */
2012 (_("%pB: relocation %s against `%s' can not be used"
2013 " when making a shared object; recompile with -fPIC"),
2015 arc_elf_howto (r_type
)->name
,
2017 bfd_set_error (bfd_error_bad_value
);
2021 /* In some cases we are not setting the 'non_got_ref'
2022 flag, even though the relocations don't require a GOT
2023 access. We should extend the testing in this area to
2024 ensure that no significant cases are being missed. */
2029 case R_ARC_32_PCREL
:
2030 if ((bfd_link_pic (info
))
2031 && ((r_type
!= R_ARC_PC32
&& r_type
!= R_ARC_32_PCREL
)
2033 && (!info
->symbolic
|| !h
->def_regular
))))
2038 && ! htab
->dynamic_sections_created
2039 && ! _bfd_elf_link_create_dynamic_sections (abfd
, info
))
2041 sreloc
= _bfd_elf_make_dynamic_reloc_section (sec
, dynobj
,
2049 sreloc
->size
+= sizeof (Elf32_External_Rela
);
2056 if (is_reloc_for_PLT (howto
))
2061 if (h
->forced_local
== 0)
2065 /* Add info to the symbol got_entry_list. */
2066 if (is_reloc_for_GOT (howto
)
2067 || is_reloc_for_TLS (howto
))
2069 if (! _bfd_elf_create_got_section (dynobj
, info
))
2072 arc_fill_got_info_for_reloc (
2073 arc_got_entry_type_for_reloc (howto
),
2074 get_got_entry_list_for_symbol (abfd
, r_symndx
, h
),
2083 #define ELF_DYNAMIC_INTERPRETER "/sbin/ld-uClibc.so"
2085 static struct plt_version_t
*
2086 arc_get_plt_version (struct bfd_link_info
*info
)
2090 for (i
= 0; i
< 1; i
++)
2092 ARC_DEBUG ("%d: size1 = %d, size2 = %d\n", i
,
2093 (int) plt_versions
[i
].entry_size
,
2094 (int) plt_versions
[i
].elem_size
);
2097 if (bfd_get_mach (info
->output_bfd
) == bfd_mach_arc_arcv2
)
2099 if (bfd_link_pic (info
))
2100 return &(plt_versions
[ELF_ARCV2_PIC
]);
2102 return &(plt_versions
[ELF_ARCV2_ABS
]);
2106 if (bfd_link_pic (info
))
2107 return &(plt_versions
[ELF_ARC_PIC
]);
2109 return &(plt_versions
[ELF_ARC_ABS
]);
2114 add_symbol_to_plt (struct bfd_link_info
*info
)
2116 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2119 struct plt_version_t
*plt_data
= arc_get_plt_version (info
);
2121 /* If this is the first .plt entry, make room for the special first
2123 if (htab
->splt
->size
== 0)
2124 htab
->splt
->size
+= plt_data
->entry_size
;
2126 ret
= htab
->splt
->size
;
2128 htab
->splt
->size
+= plt_data
->elem_size
;
2129 ARC_DEBUG ("PLT_SIZE = %d\n", (int) htab
->splt
->size
);
2131 htab
->sgotplt
->size
+= 4;
2132 htab
->srelplt
->size
+= sizeof (Elf32_External_Rela
);
2137 #define PLT_DO_RELOCS_FOR_ENTRY(ABFD, DS, RELOCS) \
2138 plt_do_relocs_for_symbol (ABFD, DS, RELOCS, 0, 0)
2141 plt_do_relocs_for_symbol (bfd
*abfd
,
2142 struct elf_link_hash_table
*htab
,
2143 const struct plt_reloc
*reloc
,
2145 bfd_vma symbol_got_offset
)
2147 while (SYM_ONLY (reloc
->symbol
) != LAST_RELOC
)
2149 bfd_vma relocation
= 0;
2151 switch (SYM_ONLY (reloc
->symbol
))
2155 = htab
->sgotplt
->output_section
->vma
2156 + htab
->sgotplt
->output_offset
+ symbol_got_offset
;
2159 relocation
+= reloc
->addend
;
2161 if (IS_RELATIVE (reloc
->symbol
))
2163 bfd_vma reloc_offset
= reloc
->offset
;
2164 reloc_offset
-= (IS_INSN_32 (reloc
->symbol
)) ? 4 : 0;
2165 reloc_offset
-= (IS_INSN_24 (reloc
->symbol
)) ? 2 : 0;
2167 relocation
-= htab
->splt
->output_section
->vma
2168 + htab
->splt
->output_offset
2169 + plt_offset
+ reloc_offset
;
2172 /* TODO: being ME is not a property of the relocation but of the
2173 section of which is applying the relocation. */
2174 if (IS_MIDDLE_ENDIAN (reloc
->symbol
) && !bfd_big_endian (abfd
))
2177 = ((relocation
& 0xffff0000) >> 16)
2178 | ((relocation
& 0xffff) << 16);
2181 switch (reloc
->size
)
2184 bfd_put_32 (htab
->splt
->output_section
->owner
,
2186 htab
->splt
->contents
+ plt_offset
+ reloc
->offset
);
2190 reloc
= &(reloc
[1]); /* Jump to next relocation. */
2195 relocate_plt_for_symbol (bfd
*output_bfd
,
2196 struct bfd_link_info
*info
,
2197 struct elf_link_hash_entry
*h
)
2199 struct plt_version_t
*plt_data
= arc_get_plt_version (info
);
2200 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2202 bfd_vma plt_index
= (h
->plt
.offset
- plt_data
->entry_size
)
2203 / plt_data
->elem_size
;
2204 bfd_vma got_offset
= (plt_index
+ 3) * 4;
2206 ARC_DEBUG ("arc_info: PLT_OFFSET = %#lx, PLT_ENTRY_VMA = %#lx, \
2207 GOT_ENTRY_OFFSET = %#lx, GOT_ENTRY_VMA = %#lx, for symbol %s\n",
2208 (long) h
->plt
.offset
,
2209 (long) (htab
->splt
->output_section
->vma
2210 + htab
->splt
->output_offset
2213 (long) (htab
->sgotplt
->output_section
->vma
2214 + htab
->sgotplt
->output_offset
2216 h
->root
.root
.string
);
2220 uint16_t *ptr
= (uint16_t *) plt_data
->elem
;
2222 for (i
= 0; i
< plt_data
->elem_size
/2; i
++)
2224 uint16_t data
= ptr
[i
];
2225 bfd_put_16 (output_bfd
,
2227 htab
->splt
->contents
+ h
->plt
.offset
+ (i
*2));
2231 plt_do_relocs_for_symbol (output_bfd
, htab
,
2232 plt_data
->elem_relocs
,
2236 /* Fill in the entry in the global offset table. */
2237 bfd_put_32 (output_bfd
,
2238 (bfd_vma
) (htab
->splt
->output_section
->vma
2239 + htab
->splt
->output_offset
),
2240 htab
->sgotplt
->contents
+ got_offset
);
2242 /* TODO: Fill in the entry in the .rela.plt section. */
2244 Elf_Internal_Rela rel
;
2247 rel
.r_offset
= (htab
->sgotplt
->output_section
->vma
2248 + htab
->sgotplt
->output_offset
2252 BFD_ASSERT (h
->dynindx
!= -1);
2253 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARC_JMP_SLOT
);
2255 loc
= htab
->srelplt
->contents
;
2256 loc
+= plt_index
* sizeof (Elf32_External_Rela
); /* relA */
2257 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
2262 relocate_plt_for_entry (bfd
*abfd
,
2263 struct bfd_link_info
*info
)
2265 struct plt_version_t
*plt_data
= arc_get_plt_version (info
);
2266 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2270 uint16_t *ptr
= (uint16_t *) plt_data
->entry
;
2271 for (i
= 0; i
< plt_data
->entry_size
/2; i
++)
2273 uint16_t data
= ptr
[i
];
2276 htab
->splt
->contents
+ (i
*2));
2279 PLT_DO_RELOCS_FOR_ENTRY (abfd
, htab
, plt_data
->entry_relocs
);
2282 /* Desc : Adjust a symbol defined by a dynamic object and referenced
2283 by a regular object. The current definition is in some section of
2284 the dynamic object, but we're not including those sections. We
2285 have to change the definition to something the rest of the link can
2289 elf_arc_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2290 struct elf_link_hash_entry
*h
)
2293 bfd
*dynobj
= (elf_hash_table (info
))->dynobj
;
2294 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2296 if (h
->type
== STT_FUNC
2297 || h
->type
== STT_GNU_IFUNC
2298 || h
->needs_plt
== 1)
2300 if (!bfd_link_pic (info
) && !h
->def_dynamic
&& !h
->ref_dynamic
)
2302 /* This case can occur if we saw a PLT32 reloc in an input
2303 file, but the symbol was never referred to by a dynamic
2304 object. In such a case, we don't actually need to build
2305 a procedure linkage table, and we can just do a PC32
2307 BFD_ASSERT (h
->needs_plt
);
2311 /* Make sure this symbol is output as a dynamic symbol. */
2312 if (h
->dynindx
== -1 && !h
->forced_local
2313 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
2316 if (bfd_link_pic (info
)
2317 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2319 bfd_vma loc
= add_symbol_to_plt (info
);
2321 if (bfd_link_executable (info
) && !h
->def_regular
)
2323 h
->root
.u
.def
.section
= htab
->splt
;
2324 h
->root
.u
.def
.value
= loc
;
2326 h
->plt
.offset
= loc
;
2330 h
->plt
.offset
= (bfd_vma
) -1;
2336 /* If this is a weak symbol, and there is a real definition, the
2337 processor independent code will have arranged for us to see the
2338 real definition first, and we can just use the same value. */
2339 if (h
->is_weakalias
)
2341 struct elf_link_hash_entry
*def
= weakdef (h
);
2342 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
2343 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
2344 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
2348 /* This is a reference to a symbol defined by a dynamic object which
2349 is not a function. */
2351 /* If we are creating a shared library, we must presume that the
2352 only references to the symbol are via the global offset table.
2353 For such cases we need not do anything here; the relocations will
2354 be handled correctly by relocate_section. */
2355 if (!bfd_link_executable (info
))
2358 /* If there are no non-GOT references, we do not need a copy
2360 if (!h
->non_got_ref
)
2363 /* If -z nocopyreloc was given, we won't generate them either. */
2364 if (info
->nocopyreloc
)
2370 /* We must allocate the symbol in our .dynbss section, which will
2371 become part of the .bss section of the executable. There will be
2372 an entry for this symbol in the .dynsym section. The dynamic
2373 object will contain position independent code, so all references
2374 from the dynamic object to this symbol will go through the global
2375 offset table. The dynamic linker will use the .dynsym entry to
2376 determine the address it must put in the global offset table, so
2377 both the dynamic object and the regular object will refer to the
2378 same memory location for the variable. */
2383 /* We must generate a R_ARC_COPY reloc to tell the dynamic linker to
2384 copy the initial value out of the dynamic object and into the
2385 runtime process image. We need to remember the offset into the
2386 .rela.bss section we are going to use. */
2387 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
2389 struct elf_arc_link_hash_table
*arc_htab
= elf_arc_hash_table (info
);
2391 BFD_ASSERT (arc_htab
->elf
.srelbss
!= NULL
);
2392 arc_htab
->elf
.srelbss
->size
+= sizeof (Elf32_External_Rela
);
2396 /* TODO: Move this also to arc_hash_table. */
2397 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
2398 BFD_ASSERT (s
!= NULL
);
2400 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2403 /* Function : elf_arc_finish_dynamic_symbol
2404 Brief : Finish up dynamic symbol handling. We set the
2405 contents of various dynamic sections here.
2410 Returns : True/False as the return status. */
2413 elf_arc_finish_dynamic_symbol (bfd
* output_bfd
,
2414 struct bfd_link_info
*info
,
2415 struct elf_link_hash_entry
*h
,
2416 Elf_Internal_Sym
* sym
)
2418 if (h
->plt
.offset
!= (bfd_vma
) -1)
2420 relocate_plt_for_symbol (output_bfd
, info
, h
);
2422 if (!h
->def_regular
)
2424 /* Mark the symbol as undefined, rather than as defined in
2425 the .plt section. Leave the value alone. */
2426 sym
->st_shndx
= SHN_UNDEF
;
2431 /* This function traverses list of GOT entries and
2432 create respective dynamic relocs. */
2433 /* TODO: Make function to get list and not access the list directly. */
2434 /* TODO: Move function to relocate_section create this relocs eagerly. */
2435 struct elf_arc_link_hash_entry
*ah
=
2436 (struct elf_arc_link_hash_entry
*) h
;
2437 create_got_dynrelocs_for_got_info (&ah
->got_ents
,
2444 struct elf_arc_link_hash_table
*arc_htab
= elf_arc_hash_table (info
);
2446 if (arc_htab
== NULL
)
2449 if (h
->dynindx
== -1
2450 || (h
->root
.type
!= bfd_link_hash_defined
2451 && h
->root
.type
!= bfd_link_hash_defweak
)
2452 || arc_htab
->elf
.srelbss
== NULL
)
2455 bfd_vma rel_offset
= (h
->root
.u
.def
.value
2456 + h
->root
.u
.def
.section
->output_section
->vma
2457 + h
->root
.u
.def
.section
->output_offset
);
2459 bfd_byte
* loc
= arc_htab
->elf
.srelbss
->contents
2460 + (arc_htab
->elf
.srelbss
->reloc_count
* sizeof (Elf32_External_Rela
));
2461 arc_htab
->elf
.srelbss
->reloc_count
++;
2463 Elf_Internal_Rela rel
;
2465 rel
.r_offset
= rel_offset
;
2467 BFD_ASSERT (h
->dynindx
!= -1);
2468 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARC_COPY
);
2470 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
2473 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2474 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2475 || strcmp (h
->root
.root
.string
, "__DYNAMIC") == 0
2476 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
2477 sym
->st_shndx
= SHN_ABS
;
2482 #define GET_SYMBOL_OR_SECTION(TAG, SYMBOL, SECTION) \
2484 if (SYMBOL != NULL) \
2485 h = elf_link_hash_lookup (elf_hash_table (info), \
2486 SYMBOL, FALSE, FALSE, TRUE); \
2487 else if (SECTION != NULL) \
2488 s = bfd_get_linker_section (dynobj, SECTION); \
2491 /* Function : elf_arc_finish_dynamic_sections
2492 Brief : Finish up the dynamic sections handling.
2497 Returns : True/False as the return status. */
2500 elf_arc_finish_dynamic_sections (bfd
* output_bfd
,
2501 struct bfd_link_info
*info
)
2503 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2504 bfd
*dynobj
= (elf_hash_table (info
))->dynobj
;
2505 asection
*sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
2509 Elf32_External_Dyn
*dyncon
, *dynconend
;
2511 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
2513 = (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
2514 for (; dyncon
< dynconend
; dyncon
++)
2516 Elf_Internal_Dyn internal_dyn
;
2517 bfd_boolean do_it
= FALSE
;
2519 struct elf_link_hash_entry
*h
= NULL
;
2522 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &internal_dyn
);
2524 switch (internal_dyn
.d_tag
)
2526 GET_SYMBOL_OR_SECTION (DT_INIT
, info
->init_function
, NULL
)
2527 GET_SYMBOL_OR_SECTION (DT_FINI
, info
->fini_function
, NULL
)
2528 GET_SYMBOL_OR_SECTION (DT_PLTGOT
, NULL
, ".plt")
2529 GET_SYMBOL_OR_SECTION (DT_JMPREL
, NULL
, ".rela.plt")
2530 GET_SYMBOL_OR_SECTION (DT_PLTRELSZ
, NULL
, ".rela.plt")
2531 GET_SYMBOL_OR_SECTION (DT_VERSYM
, NULL
, ".gnu.version")
2532 GET_SYMBOL_OR_SECTION (DT_VERDEF
, NULL
, ".gnu.version_d")
2533 GET_SYMBOL_OR_SECTION (DT_VERNEED
, NULL
, ".gnu.version_r")
2538 /* In case the dynamic symbols should be updated with a symbol. */
2540 && (h
->root
.type
== bfd_link_hash_defined
2541 || h
->root
.type
== bfd_link_hash_defweak
))
2545 internal_dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
2546 asec_ptr
= h
->root
.u
.def
.section
;
2547 if (asec_ptr
->output_section
!= NULL
)
2549 internal_dyn
.d_un
.d_val
+=
2550 (asec_ptr
->output_section
->vma
2551 + asec_ptr
->output_offset
);
2555 /* The symbol is imported from another shared
2556 library and does not apply to this one. */
2557 internal_dyn
.d_un
.d_val
= 0;
2561 else if (s
!= NULL
) /* With a section information. */
2563 switch (internal_dyn
.d_tag
)
2570 internal_dyn
.d_un
.d_ptr
= (s
->output_section
->vma
2571 + s
->output_offset
);
2576 internal_dyn
.d_un
.d_val
= s
->size
;
2586 bfd_elf32_swap_dyn_out (output_bfd
, &internal_dyn
, dyncon
);
2589 if (htab
->splt
->size
> 0)
2591 relocate_plt_for_entry (output_bfd
, info
);
2594 /* TODO: Validate this. */
2595 if (htab
->srelplt
->output_section
!= bfd_abs_section_ptr
)
2596 elf_section_data (htab
->srelplt
->output_section
)
2597 ->this_hdr
.sh_entsize
= 12;
2600 /* Fill in the first three entries in the global offset table. */
2603 struct elf_link_hash_entry
*h
;
2604 h
= elf_link_hash_lookup (elf_hash_table (info
), "_GLOBAL_OFFSET_TABLE_",
2605 FALSE
, FALSE
, TRUE
);
2607 if (h
!= NULL
&& h
->root
.type
!= bfd_link_hash_undefined
2608 && h
->root
.u
.def
.section
!= NULL
)
2610 asection
*sec
= h
->root
.u
.def
.section
;
2613 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
2616 bfd_put_32 (output_bfd
,
2617 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
2619 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sec
->contents
+ 4);
2620 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sec
->contents
+ 8);
2627 #define ADD_DYNAMIC_SYMBOL(NAME, TAG) \
2628 h = elf_link_hash_lookup (elf_hash_table (info), \
2629 NAME, FALSE, FALSE, FALSE); \
2630 if ((h != NULL && (h->ref_regular || h->def_regular))) \
2631 if (! _bfd_elf_add_dynamic_entry (info, TAG, 0)) \
2634 /* Set the sizes of the dynamic sections. */
2636 elf_arc_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
2637 struct bfd_link_info
*info
)
2641 bfd_boolean relocs_exist
= FALSE
;
2642 bfd_boolean reltext_exist
= FALSE
;
2643 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2645 dynobj
= htab
->dynobj
;
2646 BFD_ASSERT (dynobj
!= NULL
);
2648 if (htab
->dynamic_sections_created
)
2650 struct elf_link_hash_entry
*h
;
2652 /* Set the contents of the .interp section to the
2654 if (bfd_link_executable (info
) && !info
->nointerp
)
2656 s
= bfd_get_section_by_name (dynobj
, ".interp");
2657 BFD_ASSERT (s
!= NULL
);
2658 s
->size
= sizeof (ELF_DYNAMIC_INTERPRETER
);
2659 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2662 /* Add some entries to the .dynamic section. We fill in some of
2663 the values later, in elf_bfd_final_link, but we must add the
2664 entries now so that we know the final size of the .dynamic
2665 section. Checking if the .init section is present. We also
2666 create DT_INIT and DT_FINI entries if the init_str has been
2667 changed by the user. */
2668 ADD_DYNAMIC_SYMBOL (info
->init_function
, DT_INIT
);
2669 ADD_DYNAMIC_SYMBOL (info
->fini_function
, DT_FINI
);
2673 /* We may have created entries in the .rela.got section.
2674 However, if we are not creating the dynamic sections, we will
2675 not actually use these entries. Reset the size of .rela.got,
2676 which will cause it to get stripped from the output file
2678 if (htab
->srelgot
!= NULL
)
2679 htab
->srelgot
->size
= 0;
2682 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2684 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2689 || s
== htab
->sgotplt
2690 || s
== htab
->sdynbss
)
2692 /* Strip this section if we don't need it. */
2694 else if (strncmp (s
->name
, ".rela", 5) == 0)
2696 if (s
->size
!= 0 && s
!= htab
->srelplt
)
2700 const char *name
= s
->name
+ 5;
2702 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
2703 if (bfd_get_flavour (ibfd
) == bfd_target_elf_flavour
2704 && ibfd
->flags
& DYNAMIC
)
2706 asection
*target
= bfd_get_section_by_name (ibfd
, name
);
2708 && elf_section_data (target
)->sreloc
== s
2709 && ((target
->output_section
->flags
2710 & (SEC_READONLY
| SEC_ALLOC
))
2711 == (SEC_READONLY
| SEC_ALLOC
)))
2713 reltext_exist
= TRUE
;
2718 relocs_exist
= TRUE
;
2721 /* We use the reloc_count field as a counter if we need to
2722 copy relocs into the output file. */
2727 /* It's not one of our sections, so don't allocate space. */
2733 s
->flags
|= SEC_EXCLUDE
;
2737 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
2740 /* Allocate memory for the section contents. */
2741 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
2742 if (s
->contents
== NULL
)
2746 if (htab
->dynamic_sections_created
)
2748 /* TODO: Check if this is needed. */
2749 if (!bfd_link_pic (info
))
2750 if (!_bfd_elf_add_dynamic_entry (info
, DT_DEBUG
, 0))
2753 if (htab
->splt
&& (htab
->splt
->flags
& SEC_EXCLUDE
) == 0)
2754 if (!_bfd_elf_add_dynamic_entry (info
, DT_PLTGOT
, 0)
2755 || !_bfd_elf_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
2756 || !_bfd_elf_add_dynamic_entry (info
, DT_PLTREL
, DT_RELA
)
2757 || !_bfd_elf_add_dynamic_entry (info
, DT_JMPREL
, 0))
2761 if (!_bfd_elf_add_dynamic_entry (info
, DT_RELA
, 0)
2762 || !_bfd_elf_add_dynamic_entry (info
, DT_RELASZ
, 0)
2763 || !_bfd_elf_add_dynamic_entry (info
, DT_RELAENT
,
2764 sizeof (Elf32_External_Rela
)))
2768 if (!_bfd_elf_add_dynamic_entry (info
, DT_TEXTREL
, 0))
2776 /* Classify dynamic relocs such that -z combreloc can reorder and combine
2778 static enum elf_reloc_type_class
2779 elf32_arc_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2780 const asection
*rel_sec ATTRIBUTE_UNUSED
,
2781 const Elf_Internal_Rela
*rela
)
2783 switch ((int) ELF32_R_TYPE (rela
->r_info
))
2785 case R_ARC_RELATIVE
:
2786 return reloc_class_relative
;
2787 case R_ARC_JMP_SLOT
:
2788 return reloc_class_plt
;
2790 return reloc_class_copy
;
2791 /* TODO: Needed in future to support ifunc. */
2793 case R_ARC_IRELATIVE:
2794 return reloc_class_ifunc;
2797 return reloc_class_normal
;
2801 const struct elf_size_info arc_elf32_size_info
=
2803 sizeof (Elf32_External_Ehdr
),
2804 sizeof (Elf32_External_Phdr
),
2805 sizeof (Elf32_External_Shdr
),
2806 sizeof (Elf32_External_Rel
),
2807 sizeof (Elf32_External_Rela
),
2808 sizeof (Elf32_External_Sym
),
2809 sizeof (Elf32_External_Dyn
),
2810 sizeof (Elf_External_Note
),
2814 ELFCLASS32
, EV_CURRENT
,
2815 bfd_elf32_write_out_phdrs
,
2816 bfd_elf32_write_shdrs_and_ehdr
,
2817 bfd_elf32_checksum_contents
,
2818 bfd_elf32_write_relocs
,
2819 bfd_elf32_swap_symbol_in
,
2820 bfd_elf32_swap_symbol_out
,
2821 bfd_elf32_slurp_reloc_table
,
2822 bfd_elf32_slurp_symbol_table
,
2823 bfd_elf32_swap_dyn_in
,
2824 bfd_elf32_swap_dyn_out
,
2825 bfd_elf32_swap_reloc_in
,
2826 bfd_elf32_swap_reloc_out
,
2827 bfd_elf32_swap_reloca_in
,
2828 bfd_elf32_swap_reloca_out
2831 #define elf_backend_size_info arc_elf32_size_info
2833 /* GDB expects general purpose registers to be in section .reg. However Linux
2834 kernel doesn't create this section and instead writes registers to NOTE
2835 section. It is up to the binutils to create a pseudo-section .reg from the
2836 contents of NOTE. Also BFD will read pid and signal number from NOTE. This
2837 function relies on offsets inside elf_prstatus structure in Linux to be
2841 elf32_arc_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
2846 switch (note
->descsz
)
2851 case 236: /* sizeof (struct elf_prstatus) on Linux/arc. */
2853 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
2855 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
2858 size
= (40 * 4); /* There are 40 registers in user_regs_struct. */
2861 /* Make a ".reg/999" section. */
2862 return _bfd_elfcore_make_pseudosection (abfd
, ".reg", size
,
2863 note
->descpos
+ offset
);
2866 /* Determine whether an object attribute tag takes an integer, a
2870 elf32_arc_obj_attrs_arg_type (int tag
)
2872 if (tag
== Tag_ARC_CPU_name
2873 || tag
== Tag_ARC_ISA_config
2874 || tag
== Tag_ARC_ISA_apex
)
2875 return ATTR_TYPE_FLAG_STR_VAL
;
2876 else if (tag
< (Tag_ARC_ISA_mpy_option
+ 1))
2877 return ATTR_TYPE_FLAG_INT_VAL
;
2879 return (tag
& 1) != 0 ? ATTR_TYPE_FLAG_STR_VAL
: ATTR_TYPE_FLAG_INT_VAL
;
2882 /* Attribute numbers >=14 can be safely ignored. */
2885 elf32_arc_obj_attrs_handle_unknown (bfd
*abfd
, int tag
)
2887 if ((tag
& 127) < (Tag_ARC_ISA_mpy_option
+ 1))
2890 (_("%pB: unknown mandatory ARC object attribute %d"),
2892 bfd_set_error (bfd_error_bad_value
);
2898 (_("warning: %pB: unknown ARC object attribute %d"),
2904 /* Handle an ARC specific section when reading an object file. This is
2905 called when bfd_section_from_shdr finds a section with an unknown
2909 elf32_arc_section_from_shdr (bfd
*abfd
,
2910 Elf_Internal_Shdr
* hdr
,
2914 switch (hdr
->sh_type
)
2916 case 0x0c: /* MWDT specific section, don't complain about it. */
2917 case SHT_ARC_ATTRIBUTES
:
2924 if (!_bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2930 #define TARGET_LITTLE_SYM arc_elf32_le_vec
2931 #define TARGET_LITTLE_NAME "elf32-littlearc"
2932 #define TARGET_BIG_SYM arc_elf32_be_vec
2933 #define TARGET_BIG_NAME "elf32-bigarc"
2934 #define ELF_ARCH bfd_arch_arc
2935 #define ELF_TARGET_ID ARC_ELF_DATA
2936 #define ELF_MACHINE_CODE EM_ARC_COMPACT
2937 #define ELF_MACHINE_ALT1 EM_ARC_COMPACT2
2938 #define ELF_MAXPAGESIZE 0x2000
2940 #define bfd_elf32_bfd_link_hash_table_create arc_elf_link_hash_table_create
2942 #define bfd_elf32_bfd_merge_private_bfd_data arc_elf_merge_private_bfd_data
2943 #define bfd_elf32_bfd_reloc_type_lookup arc_elf32_bfd_reloc_type_lookup
2944 #define bfd_elf32_bfd_set_private_flags arc_elf_set_private_flags
2945 #define bfd_elf32_bfd_print_private_bfd_data arc_elf_print_private_bfd_data
2946 #define bfd_elf32_bfd_copy_private_bfd_data arc_elf_copy_private_bfd_data
2948 #define elf_info_to_howto_rel arc_info_to_howto_rel
2949 #define elf_backend_object_p arc_elf_object_p
2950 #define elf_backend_final_write_processing arc_elf_final_write_processing
2952 #define elf_backend_relocate_section elf_arc_relocate_section
2953 #define elf_backend_check_relocs elf_arc_check_relocs
2954 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
2956 #define elf_backend_reloc_type_class elf32_arc_reloc_type_class
2958 #define elf_backend_adjust_dynamic_symbol elf_arc_adjust_dynamic_symbol
2959 #define elf_backend_finish_dynamic_symbol elf_arc_finish_dynamic_symbol
2961 #define elf_backend_finish_dynamic_sections elf_arc_finish_dynamic_sections
2962 #define elf_backend_size_dynamic_sections elf_arc_size_dynamic_sections
2964 #define elf_backend_can_gc_sections 1
2965 #define elf_backend_want_got_plt 1
2966 #define elf_backend_plt_readonly 1
2967 #define elf_backend_rela_plts_and_copies_p 1
2968 #define elf_backend_want_plt_sym 0
2969 #define elf_backend_got_header_size 12
2970 #define elf_backend_dtrel_excludes_plt 1
2972 #define elf_backend_may_use_rel_p 0
2973 #define elf_backend_may_use_rela_p 1
2974 #define elf_backend_default_use_rela_p 1
2976 #define elf_backend_grok_prstatus elf32_arc_grok_prstatus
2978 #define elf_backend_default_execstack 0
2980 #undef elf_backend_obj_attrs_vendor
2981 #define elf_backend_obj_attrs_vendor "ARC"
2982 #undef elf_backend_obj_attrs_section
2983 #define elf_backend_obj_attrs_section ".ARC.attributes"
2984 #undef elf_backend_obj_attrs_arg_type
2985 #define elf_backend_obj_attrs_arg_type elf32_arc_obj_attrs_arg_type
2986 #undef elf_backend_obj_attrs_section_type
2987 #define elf_backend_obj_attrs_section_type SHT_ARC_ATTRIBUTES
2988 #define elf_backend_obj_attrs_handle_unknown elf32_arc_obj_attrs_handle_unknown
2990 #define elf_backend_section_from_shdr elf32_arc_section_from_shdr
2992 #include "elf32-target.h"