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 /* Should be included at this location due to static declarations
164 defined before this point. */
167 #define arc_bfd_get_8(A,B,C) bfd_get_8(A,B)
168 #define arc_bfd_get_16(A,B,C) bfd_get_16(A,B)
169 #define arc_bfd_get_32(A,B,C) bfd_get_32(A,B)
170 #define arc_bfd_put_8(A,B,C,D) bfd_put_8(A,B,C)
171 #define arc_bfd_put_16(A,B,C,D) bfd_put_16(A,B,C)
172 #define arc_bfd_put_32(A,B,C,D) bfd_put_32(A,B,C)
175 static bfd_reloc_status_type
176 arc_elf_reloc (bfd *abfd ATTRIBUTE_UNUSED,
177 arelent *reloc_entry,
179 void *data ATTRIBUTE_UNUSED,
180 asection *input_section,
182 char ** error_message ATTRIBUTE_UNUSED)
184 if (output_bfd != NULL)
186 reloc_entry->address += input_section->output_offset;
188 /* In case of relocateable link and if the reloc is against a
189 section symbol, the addend needs to be adjusted according to
190 where the section symbol winds up in the output section. */
191 if ((symbol_in->flags & BSF_SECTION_SYM) && symbol_in->section)
192 reloc_entry->addend += symbol_in->section->output_offset;
197 return bfd_reloc_continue;
201 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
206 #include "elf/arc-reloc.def"
210 #undef ARC_RELOC_HOWTO
212 #define ARC_RELOC_HOWTO(TYPE, VALUE, RSIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
213 [TYPE] = HOWTO (R_##TYPE, 0, RSIZE, BITSIZE, FALSE, 0, \
214 complain_overflow_##OVERFLOW, arc_elf_reloc, \
215 "R_" #TYPE, FALSE, 0, 0, FALSE),
217 static struct reloc_howto_struct elf_arc_howto_table[] =
219 #include "elf/arc-reloc.def"
220 /* Example of what is generated by the preprocessor. Currently kept as an
222 HOWTO (R_ARC_NONE, // Type.
224 2, // Size (0 = byte, 1 = short, 2 = long).
226 FALSE, // PC_relative.
228 complain_overflow_bitfield, // Complain_on_overflow.
229 bfd_elf_generic_reloc, // Special_function.
230 "R_ARC_NONE", // Name.
231 TRUE, // Partial_inplace.
234 FALSE), // PCrel_offset.
237 #undef ARC_RELOC_HOWTO
240 arc_elf_howto_init (void)
242 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
243 elf_arc_howto_table[TYPE].pc_relative = \
244 (strstr (#FORMULA, " P ") != NULL || strstr (#FORMULA, " PDATA ") != NULL); \
245 elf_arc_howto_table[TYPE].dst_mask = RELOC_FUNCTION(0, ~0); \
246 /* Only 32 bit data relocations should be marked as ME. */ \
247 if (strstr (#FORMULA, " ME ") != NULL) \
249 BFD_ASSERT (SIZE == 2); \
252 #include "elf/arc-reloc.def"
255 #undef ARC_RELOC_HOWTO
258 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
261 const int howto_table_lookup[] =
263 #include "elf/arc-reloc.def"
266 #undef ARC_RELOC_HOWTO
268 static reloc_howto_type *
269 arc_elf_howto (unsigned int r_type)
271 if (elf_arc_howto_table[R_ARC_32].dst_mask == 0)
272 arc_elf_howto_init ();
273 return &elf_arc_howto_table[r_type];
276 /* Map BFD reloc types to ARC ELF reloc types. */
280 bfd_reloc_code_real_type bfd_reloc_val;
281 unsigned char elf_reloc_val;
284 /* ARC ELF linker hash entry. */
285 struct elf_arc_link_hash_entry
287 struct elf_link_hash_entry root;
289 /* Track dynamic relocs copied for this symbol. */
290 struct elf_dyn_relocs *dyn_relocs;
293 /* ARC ELF linker hash table. */
294 struct elf_arc_link_hash_table
296 struct elf_link_hash_table elf;
299 static struct bfd_hash_entry *
300 elf_arc_link_hash_newfunc (struct bfd_hash_entry *entry,
301 struct bfd_hash_table *table,
304 /* Allocate the structure if it has not already been allocated by a
308 entry = (struct bfd_hash_entry *)
309 bfd_hash_allocate (table,
310 sizeof (struct elf_arc_link_hash_entry));
315 /* Call the allocation method of the superclass. */
316 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
319 struct elf_arc_link_hash_entry *eh;
321 eh = (struct elf_arc_link_hash_entry *) entry;
322 eh->dyn_relocs = NULL;
328 /* Destroy an ARC ELF linker hash table. */
330 elf_arc_link_hash_table_free (bfd *obfd)
332 _bfd_elf_link_hash_table_free (obfd);
335 /* Create an ARC ELF linker hash table. */
337 static struct bfd_link_hash_table *
338 arc_elf_link_hash_table_create (bfd *abfd)
340 struct elf_arc_link_hash_table *ret;
342 ret = (struct elf_arc_link_hash_table *) bfd_zmalloc (sizeof (*ret));
346 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
347 elf_arc_link_hash_newfunc,
348 sizeof (struct elf_arc_link_hash_entry),
355 ret->elf.init_got_refcount.refcount = 0;
356 ret->elf.init_got_refcount.glist = NULL;
357 ret->elf.init_got_offset.offset = 0;
358 ret->elf.init_got_offset.glist = NULL;
360 ret->elf.root.hash_table_free = elf_arc_link_hash_table_free;
362 return &ret->elf.root;
365 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
366 { BFD_RELOC_##TYPE, R_##TYPE },
368 static const struct arc_reloc_map arc_reloc_map[] =
370 #include "elf/arc-reloc.def"
372 {BFD_RELOC_NONE, R_ARC_NONE},
373 {BFD_RELOC_8, R_ARC_8},
374 {BFD_RELOC_16, R_ARC_16},
375 {BFD_RELOC_24, R_ARC_24},
376 {BFD_RELOC_32, R_ARC_32},
379 #undef ARC_RELOC_HOWTO
381 typedef ATTRIBUTE_UNUSED bfd_vma (*replace_func) (unsigned, int ATTRIBUTE_UNUSED);
383 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
385 func = (void *) RELOC_FUNCTION; \
389 get_replace_function (bfd *abfd, unsigned int r_type)
395 #include "elf/arc-reloc.def"
398 if (func == replace_bits24 && bfd_big_endian (abfd))
399 func = replace_bits24_be;
401 return (replace_func) func;
403 #undef ARC_RELOC_HOWTO
405 static reloc_howto_type *
406 arc_elf32_bfd_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
407 bfd_reloc_code_real_type code)
411 for (i = ARRAY_SIZE (arc_reloc_map); i--;)
413 if (arc_reloc_map[i].bfd_reloc_val == code)
414 return arc_elf_howto (arc_reloc_map[i].elf_reloc_val);
420 /* Function to set the ELF flag bits. */
422 arc_elf_set_private_flags (bfd *abfd, flagword flags)
424 elf_elfheader (abfd)->e_flags = flags;
425 elf_flags_init (abfd) = TRUE;
429 /* Print private flags. */
431 arc_elf_print_private_bfd_data (bfd *abfd, void * ptr)
433 FILE *file = (FILE *) ptr;
436 BFD_ASSERT (abfd != NULL && ptr != NULL);
438 /* Print normal ELF private data. */
439 _bfd_elf_print_private_bfd_data (abfd, ptr);
441 flags = elf_elfheader (abfd)->e_flags;
442 fprintf (file, _("private flags = 0x%lx:"), (unsigned long) flags);
444 switch (flags & EF_ARC_MACH_MSK)
446 case EF_ARC_CPU_ARCV2HS : fprintf (file, " -mcpu=ARCv2HS"); break;
447 case EF_ARC_CPU_ARCV2EM : fprintf (file, " -mcpu=ARCv2EM"); break;
448 case E_ARC_MACH_ARC600 : fprintf (file, " -mcpu=ARC600"); break;
449 case E_ARC_MACH_ARC601 : fprintf (file, " -mcpu=ARC601"); break;
450 case E_ARC_MACH_ARC700 : fprintf (file, " -mcpu=ARC700"); break;
452 fprintf (file, "-mcpu=unknown");
456 switch (flags & EF_ARC_OSABI_MSK)
458 case E_ARC_OSABI_ORIG : fprintf (file, " (ABI:legacy)"); break;
459 case E_ARC_OSABI_V2 : fprintf (file, " (ABI:v2)"); break;
460 case E_ARC_OSABI_V3 : fprintf (file, " (ABI:v3)"); break;
461 case E_ARC_OSABI_V4 : fprintf (file, " (ABI:v4)"); break;
463 fprintf (file, " (ABI:unknown)");
471 /* Copy backend specific data from one object module to another. */
474 arc_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
476 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
477 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
480 BFD_ASSERT (!elf_flags_init (obfd)
481 || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);
483 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
484 elf_flags_init (obfd) = TRUE;
486 /* Copy object attributes. */
487 _bfd_elf_copy_obj_attributes (ibfd, obfd);
489 return _bfd_elf_copy_private_bfd_data (ibfd, obfd);
492 static reloc_howto_type *
493 bfd_elf32_bfd_reloc_name_lookup (bfd * abfd ATTRIBUTE_UNUSED,
498 for (i = 0; i < ARRAY_SIZE (elf_arc_howto_table); i++)
499 if (elf_arc_howto_table[i].name != NULL
500 && strcasecmp (elf_arc_howto_table[i].name, r_name) == 0)
501 return arc_elf_howto (i);
506 /* Set the howto pointer for an ARC ELF reloc. */
509 arc_info_to_howto_rel (bfd * abfd ATTRIBUTE_UNUSED,
511 Elf_Internal_Rela * dst)
515 r_type = ELF32_R_TYPE (dst->r_info);
516 BFD_ASSERT (r_type < (unsigned int) R_ARC_max);
517 cache_ptr->howto = arc_elf_howto (r_type);
520 /* Extract CPU features from an NTBS. */
523 arc_extract_features (const char *p)
530 for (i = 0; i < ARRAY_SIZE (bfd_feature_list); i++)
532 char *t = strstr (p, bfd_feature_list[i].attr);
533 unsigned l = strlen (bfd_feature_list[i].attr);
537 r |= bfd_feature_list[i].feature;
543 /* Concatenate two strings. s1 can be NULL but not
547 arc_stralloc (char * s1, const char * s2)
551 /* Only s1 can be null. */
554 p = s1 ? concat (s1, ",", s2, NULL) : (char *)s2;
559 /* Merge ARC object attributes from IBFD into OBFD. Raise an error if
560 there are conflicting attributes. */
563 arc_elf_merge_attributes (bfd *ibfd, struct bfd_link_info *info)
565 bfd *obfd = info->output_bfd;
566 obj_attribute *in_attr;
567 obj_attribute *out_attr;
569 bfd_boolean result = TRUE;
570 const char *sec_name = get_elf_backend_data (ibfd)->obj_attrs_section;
571 char *tagname = NULL;
573 /* Skip the linker stubs file. This preserves previous behavior
574 of accepting unknown attributes in the first input file - but
576 if (ibfd->flags & BFD_LINKER_CREATED)
579 /* Skip any input that hasn't attribute section.
580 This enables to link object files without attribute section with
582 if (bfd_get_section_by_name (ibfd, sec_name) == NULL)
585 if (!elf_known_obj_attributes_proc (obfd)[0].i)
587 /* This is the first object. Copy the attributes. */
588 _bfd_elf_copy_obj_attributes (ibfd, obfd);
590 out_attr = elf_known_obj_attributes_proc (obfd);
592 /* Use the Tag_null value to indicate the attributes have been
599 in_attr = elf_known_obj_attributes_proc (ibfd);
600 out_attr = elf_known_obj_attributes_proc (obfd);
602 for (i = LEAST_KNOWN_OBJ_ATTRIBUTE; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++)
604 /* Merge this attribute with existing attributes. */
607 case Tag_ARC_PCS_config:
608 if (out_attr[i].i == 0)
609 out_attr[i].i = in_attr[i].i;
610 else if (in_attr[i].i != 0 && out_attr[i].i != in_attr[i].i)
612 const char *tagval[] = { "Absent", "Bare-metal/mwdt",
613 "Bare-metal/newlib", "Linux/uclibc",
615 BFD_ASSERT (in_attr[i].i < 5);
616 BFD_ASSERT (out_attr[i].i < 5);
617 /* It's sometimes ok to mix different configs, so this is only
620 (_("warning: %pB: conflicting platform configuration "
622 tagval[in_attr[i].i],
623 tagval[out_attr[i].i]);
627 case Tag_ARC_CPU_base:
628 if (out_attr[i].i == 0)
629 out_attr[i].i = in_attr[i].i;
630 else if (in_attr[i].i != 0 && out_attr[i].i != in_attr[i].i
631 && ((out_attr[i].i + in_attr[i].i) < 6))
633 const char *tagval[] = { "Absent", "ARC6xx", "ARC7xx",
635 BFD_ASSERT (in_attr[i].i < 5);
636 BFD_ASSERT (out_attr[i].i < 5);
637 /* We cannot mix code for different CPUs. */
639 (_("error: %pB: unable to merge CPU base attributes "
642 tagval[in_attr[i].i],
643 tagval[out_attr[i].i]);
649 /* The CPUs may be different, check if we can still mix
650 the objects against the output choosen CPU. */
651 unsigned in_feature = 0;
652 unsigned out_feature = 0;
653 char *p1 = in_attr[Tag_ARC_ISA_config].s;
654 char *p2 = out_attr[Tag_ARC_ISA_config].s;
657 unsigned opcode_map[] = {0, ARC_OPCODE_ARC600, ARC_OPCODE_ARC700,
658 ARC_OPCODE_ARCv2EM, ARC_OPCODE_ARCv2HS};
660 BFD_ASSERT (in_attr[i].i < (sizeof (opcode_map)
661 / sizeof (unsigned)));
662 BFD_ASSERT (out_attr[i].i < (sizeof (opcode_map)
663 / sizeof (unsigned)));
664 cpu_out = opcode_map[out_attr[i].i];
666 in_feature = arc_extract_features (p1);
667 out_feature = arc_extract_features (p2);
669 /* First, check if a feature is compatible with the
670 output object chosen CPU. */
671 for (j = 0; j < ARRAY_SIZE (bfd_feature_list); j++)
672 if (((in_feature | out_feature) & bfd_feature_list[j].feature)
673 && (!(cpu_out & bfd_feature_list[j].cpus)))
676 (_("error: %pB: unable to merge ISA extension attributes "
678 obfd, bfd_feature_list[j].name);
682 /* Second, if we have compatible features with the
683 chosen CPU, check if they are compatible among
685 for (j = 0; j < ARRAY_SIZE (bfd_conflict_list); j++)
686 if (((in_feature | out_feature) & bfd_conflict_list[j])
687 == bfd_conflict_list[j])
690 for (k = 0; k < ARRAY_SIZE (bfd_feature_list); k++)
692 if (in_feature & bfd_feature_list[k].feature
693 & bfd_conflict_list[j])
694 p1 = (char *) bfd_feature_list[k].name;
695 if (out_feature & bfd_feature_list[k].feature
696 & bfd_conflict_list[j])
697 p2 = (char *) bfd_feature_list[k].name;
700 (_("error: %pB: conflicting ISA extension attributes "
706 /* Everithing is alright. */
707 out_feature |= in_feature;
709 for (j = 0; j < ARRAY_SIZE (bfd_feature_list); j++)
710 if (out_feature & bfd_feature_list[j].feature)
711 p1 = arc_stralloc (p1, bfd_feature_list[j].attr);
713 out_attr[Tag_ARC_ISA_config].s =
714 _bfd_elf_attr_strdup (obfd, p1);
717 case Tag_ARC_CPU_variation:
718 case Tag_ARC_ISA_mpy_option:
719 case Tag_ARC_ABI_osver:
720 /* Use the largest value specified. */
721 if (in_attr[i].i > out_attr[i].i)
722 out_attr[i].i = in_attr[i].i;
725 case Tag_ARC_CPU_name:
728 case Tag_ARC_ABI_rf16:
729 if (out_attr[i].i == 0)
730 out_attr[i].i = in_attr[i].i;
731 else if (out_attr[i].i != in_attr[i].i)
733 /* We cannot mix code with rf16 and without. */
735 (_("error: %pB: cannot mix rf16 with full register set %pB"),
741 case Tag_ARC_ABI_pic:
744 case Tag_ARC_ABI_sda:
748 case Tag_ARC_ABI_tls:
750 const char *tagval[] = { "Absent", "MWDT", "GNU" };
755 BFD_ASSERT (in_attr[i].i < 3);
756 BFD_ASSERT (out_attr[i].i < 3);
757 if (out_attr[i].i != 0 && in_attr[i].i != 0
758 && out_attr[i].i != in_attr[i].i)
761 (_("error: %pB: conflicting attributes %s: %s with %s"),
763 tagval[in_attr[i].i],
764 tagval[out_attr[i].i]);
771 case Tag_ARC_ABI_double_size:
772 tagname = "Double size";
774 case Tag_ARC_ABI_enumsize:
776 tagname = "Enum size";
778 case Tag_ARC_ABI_exceptions:
780 tagname = "ABI exceptions";
782 if (out_attr[i].i != 0 && in_attr[i].i != 0
783 && out_attr[i].i != in_attr[i].i)
786 (_("error: %pB: conflicting attributes %s"),
792 case Tag_ARC_ISA_apex:
793 break; /* Do nothing for APEX attributes. */
795 case Tag_ARC_ISA_config:
796 /* It is handled in Tag_ARC_CPU_base. */
801 = result && _bfd_elf_merge_unknown_attribute_low (ibfd, obfd, i);
804 /* If out_attr was copied from in_attr then it won't have a type yet. */
805 if (in_attr[i].type && !out_attr[i].type)
806 out_attr[i].type = in_attr[i].type;
809 /* Merge Tag_compatibility attributes and any common GNU ones. */
810 if (!_bfd_elf_merge_object_attributes (ibfd, info))
813 /* Check for any attributes not known on ARC. */
814 result &= _bfd_elf_merge_unknown_attribute_list (ibfd, obfd);
819 /* Merge backend specific data from an object file to the output
820 object file when linking. */
823 arc_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
825 bfd *obfd = info->output_bfd;
826 unsigned short mach_ibfd;
827 static unsigned short mach_obfd = EM_NONE;
832 /* Check if we have the same endianess. */
833 if (! _bfd_generic_verify_endian_match (ibfd, info))
836 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
837 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
840 /* Collect ELF flags. */
841 in_flags = elf_elfheader (ibfd)->e_flags & EF_ARC_MACH_MSK;
842 out_flags = elf_elfheader (obfd)->e_flags & EF_ARC_MACH_MSK;
844 if (!elf_flags_init (obfd)) /* First call, no flags set. */
846 elf_flags_init (obfd) = TRUE;
847 out_flags = in_flags;
850 if (!arc_elf_merge_attributes (ibfd, info))
853 /* Check to see if the input BFD actually contains any sections. Do
854 not short-circuit dynamic objects; their section list may be
855 emptied by elf_link_add_object_symbols. */
856 if (!(ibfd->flags & DYNAMIC))
858 bfd_boolean null_input_bfd = TRUE;
859 bfd_boolean only_data_sections = TRUE;
861 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
863 if ((bfd_get_section_flags (ibfd, sec)
864 & (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
865 == (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
866 only_data_sections = FALSE;
868 null_input_bfd = FALSE;
871 if (null_input_bfd || only_data_sections)
875 /* Complain about various flag/architecture mismatches. */
876 mach_ibfd = elf_elfheader (ibfd)->e_machine;
877 if (mach_obfd == EM_NONE)
879 mach_obfd = mach_ibfd;
883 if (mach_ibfd != mach_obfd)
885 /* xgettext:c-format */
886 _bfd_error_handler (_("error: attempting to link %pB "
887 "with a binary %pB of different architecture"),
891 else if ((in_flags != out_flags)
892 /* If we have object attributes, then we already
893 checked the objects compatibility, skip it. */
894 && !bfd_elf_get_obj_attr_int (ibfd, OBJ_ATTR_PROC,
897 /* Warn if different flags. */
899 /* xgettext:c-format */
900 (_("%pB: uses different e_flags (%#x) fields than "
901 "previous modules (%#x)"),
902 ibfd, in_flags, out_flags);
903 if (in_flags && out_flags)
905 /* MWDT doesnt set the eflags hence make sure we choose the
906 eflags set by gcc. */
907 in_flags = in_flags > out_flags ? in_flags : out_flags;
911 /* Everything is correct; don't change the output flags. */
912 in_flags = out_flags;
916 /* Update the flags. */
917 elf_elfheader (obfd)->e_flags = in_flags;
919 if (bfd_get_mach (obfd) < bfd_get_mach (ibfd))
921 return bfd_set_arch_mach (obfd, bfd_arch_arc, bfd_get_mach (ibfd));
927 /* Return a best guess for the machine number based on the attributes. */
930 bfd_arc_get_mach_from_attributes (bfd * abfd)
932 int arch = bfd_elf_get_obj_attr_int (abfd, OBJ_ATTR_PROC, Tag_ARC_CPU_base);
933 unsigned e_machine = elf_elfheader (abfd)->e_machine;
938 return bfd_mach_arc_arc600;
940 return bfd_mach_arc_arc700;
943 return bfd_mach_arc_arcv2;
947 return (e_machine == EM_ARC_COMPACT)
948 ? bfd_mach_arc_arc700 : bfd_mach_arc_arcv2;
951 /* Set the right machine number for an ARC ELF file. */
953 arc_elf_object_p (bfd * abfd)
955 /* Make sure this is initialised, or you'll have the potential of passing
956 garbage---or misleading values---into the call to
957 bfd_default_set_arch_mach (). */
958 unsigned int mach = bfd_mach_arc_arc700;
959 unsigned long arch = elf_elfheader (abfd)->e_flags & EF_ARC_MACH_MSK;
960 unsigned e_machine = elf_elfheader (abfd)->e_machine;
962 if (e_machine == EM_ARC_COMPACT || e_machine == EM_ARC_COMPACT2)
966 case E_ARC_MACH_ARC600:
967 mach = bfd_mach_arc_arc600;
969 case E_ARC_MACH_ARC601:
970 mach = bfd_mach_arc_arc601;
972 case E_ARC_MACH_ARC700:
973 mach = bfd_mach_arc_arc700;
975 case EF_ARC_CPU_ARCV2HS:
976 case EF_ARC_CPU_ARCV2EM:
977 mach = bfd_mach_arc_arcv2;
980 mach = bfd_arc_get_mach_from_attributes (abfd);
986 if (e_machine == EM_ARC)
989 (_("error: the ARC4 architecture is no longer supported"));
995 (_("warning: unset or old architecture flags; "
996 "use default machine"));
1000 return bfd_default_set_arch_mach (abfd, bfd_arch_arc, mach);
1003 /* The final processing done just before writing out an ARC ELF object file.
1004 This gets the ARC architecture right based on the machine number. */
1007 arc_elf_final_write_processing (bfd * abfd,
1008 bfd_boolean linker ATTRIBUTE_UNUSED)
1011 int osver = bfd_elf_get_obj_attr_int (abfd, OBJ_ATTR_PROC,
1013 flagword e_flags = elf_elfheader (abfd)->e_flags & ~EF_ARC_OSABI_MSK;
1015 switch (bfd_get_mach (abfd))
1017 case bfd_mach_arc_arc600:
1018 emf = EM_ARC_COMPACT;
1020 case bfd_mach_arc_arc601:
1021 emf = EM_ARC_COMPACT;
1023 case bfd_mach_arc_arc700:
1024 emf = EM_ARC_COMPACT;
1026 case bfd_mach_arc_arcv2:
1027 emf = EM_ARC_COMPACT2;
1033 elf_elfheader (abfd)->e_machine = emf;
1035 /* Record whatever is the current syscall ABI version. */
1037 e_flags |= ((osver & 0x0f) << 8);
1039 e_flags |= E_ARC_OSABI_V3;
1041 elf_elfheader (abfd)->e_flags |= e_flags;
1044 #ifdef ARC_ENABLE_DEBUG
1045 #define DEBUG_ARC_RELOC(A) debug_arc_reloc (A)
1048 debug_arc_reloc (struct arc_relocation_data reloc_data)
1050 ARC_DEBUG ("Reloc type=%s, should_relocate = %s\n",
1051 reloc_data.howto->name,
1052 reloc_data.should_relocate ? "true" : "false");
1053 ARC_DEBUG (" offset = 0x%x, addend = 0x%x\n",
1054 (unsigned int) reloc_data.reloc_offset,
1055 (unsigned int) reloc_data.reloc_addend);
1056 ARC_DEBUG (" Symbol:\n");
1057 ARC_DEBUG (" value = 0x%08x\n",
1058 (unsigned int) reloc_data.sym_value);
1059 if (reloc_data.sym_section != NULL)
1061 ARC_DEBUG (" Symbol Section:\n");
1062 ARC_DEBUG (" section name = %s, output_offset 0x%08x",
1063 reloc_data.sym_section->name,
1064 (unsigned int) reloc_data.sym_section->output_offset);
1065 if (reloc_data.sym_section->output_section != NULL)
1066 ARC_DEBUG (", output_section->vma = 0x%08x",
1067 ((unsigned int) reloc_data.sym_section->output_section->vma));
1069 if (reloc_data.sym_section->owner && reloc_data.sym_section->owner->filename)
1070 ARC_DEBUG (" file: %s\n", reloc_data.sym_section->owner->filename);
1074 ARC_DEBUG (" symbol section is NULL\n");
1077 ARC_DEBUG (" Input_section:\n");
1078 if (reloc_data.input_section != NULL)
1080 ARC_DEBUG (" section name = %s, output_offset 0x%08x, output_section->vma = 0x%08x\n",
1081 reloc_data.input_section->name,
1082 (unsigned int) reloc_data.input_section->output_offset,
1083 (unsigned int) reloc_data.input_section->output_section->vma);
1084 ARC_DEBUG (" changed_address = 0x%08x\n",
1085 (unsigned int) (reloc_data.input_section->output_section->vma
1086 + reloc_data.input_section->output_offset
1087 + reloc_data.reloc_offset));
1088 ARC_DEBUG (" file: %s\n", reloc_data.input_section->owner->filename);
1092 ARC_DEBUG (" input section is NULL\n");
1096 #define DEBUG_ARC_RELOC(A)
1097 #endif /* ARC_ENABLE_DEBUG */
1100 middle_endian_convert (bfd_vma insn, bfd_boolean do_it)
1105 = ((insn & 0xffff0000) >> 16)
1106 | ((insn & 0xffff) << 16);
1111 /* This function is called for relocations that are otherwise marked as NOT
1112 requiring overflow checks. In here we perform non-standard checks of
1113 the relocation value. */
1115 static inline bfd_reloc_status_type
1116 arc_special_overflow_checks (const struct arc_relocation_data reloc_data,
1117 bfd_signed_vma relocation,
1118 struct bfd_link_info *info ATTRIBUTE_UNUSED)
1120 switch (reloc_data.howto->type)
1122 case R_ARC_NPS_CMEM16:
1123 if (((relocation >> 16) & 0xffff) != NPS_CMEM_HIGH_VALUE)
1125 if (reloc_data.reloc_addend == 0)
1127 /* xgettext:c-format */
1128 (_("%pB(%pA+%#" PRIx64 "): CMEM relocation to `%s' is invalid, "
1129 "16 MSB should be %#x (value is %#" PRIx64 ")"),
1130 reloc_data.input_section->owner,
1131 reloc_data.input_section,
1132 (uint64_t) reloc_data.reloc_offset,
1133 reloc_data.symbol_name,
1134 NPS_CMEM_HIGH_VALUE,
1135 (uint64_t) relocation);
1138 /* xgettext:c-format */
1139 (_("%pB(%pA+%#" PRIx64 "): CMEM relocation to `%s+%#" PRIx64
1140 "' is invalid, 16 MSB should be %#x (value is %#" PRIx64 ")"),
1141 reloc_data.input_section->owner,
1142 reloc_data.input_section,
1143 (uint64_t) reloc_data.reloc_offset,
1144 reloc_data.symbol_name,
1145 (uint64_t) reloc_data.reloc_addend,
1146 NPS_CMEM_HIGH_VALUE,
1147 (uint64_t) relocation);
1148 return bfd_reloc_overflow;
1156 return bfd_reloc_ok;
1159 #define ME(reloc) (reloc)
1161 #define IS_ME(FORMULA,BFD) ((strstr (FORMULA, "ME") != NULL) \
1162 && (!bfd_big_endian (BFD)))
1164 #define S ((bfd_signed_vma) (reloc_data.sym_value \
1165 + (reloc_data.sym_section->output_section != NULL ? \
1166 (reloc_data.sym_section->output_offset \
1167 + reloc_data.sym_section->output_section->vma) : 0)))
1168 #define L ((bfd_signed_vma) (reloc_data.sym_value \
1169 + (reloc_data.sym_section->output_section != NULL ? \
1170 (reloc_data.sym_section->output_offset \
1171 + reloc_data.sym_section->output_section->vma) : 0)))
1172 #define A (reloc_data.reloc_addend)
1174 #define G (reloc_data.got_offset_value)
1175 #define GOT (reloc_data.got_symbol_vma)
1176 #define GOT_BEGIN (htab->sgot->output_section->vma)
1179 /* P: relative offset to PCL The offset should be to the
1180 current location aligned to 32 bits. */
1181 #define P ((bfd_signed_vma) ( \
1183 (reloc_data.input_section->output_section != NULL ? \
1184 reloc_data.input_section->output_section->vma : 0) \
1185 + reloc_data.input_section->output_offset \
1186 + (reloc_data.reloc_offset - (bitsize >= 32 ? 4 : 0))) \
1188 #define PDATA ((bfd_signed_vma) ( \
1189 (reloc_data.input_section->output_section->vma \
1190 + reloc_data.input_section->output_offset \
1191 + (reloc_data.reloc_offset))))
1192 #define SECTSTART (bfd_signed_vma) (reloc_data.sym_section->output_section->vma \
1193 + reloc_data.sym_section->output_offset)
1194 #define JLI (bfd_signed_vma) (reloc_data.sym_section->output_section->vma)
1195 #define _SDA_BASE_ (bfd_signed_vma) (reloc_data.sdata_begin_symbol_vma)
1196 #define TLS_REL (bfd_signed_vma) \
1197 ((elf_hash_table (info))->tls_sec->output_section->vma)
1198 #define TLS_TBSS (8)
1202 #ifdef ARC_ENABLE_DEBUG
1203 #define PRINT_DEBUG_RELOC_INFO_BEFORE(FORMULA, TYPE) \
1206 asection *sym_section = reloc_data.sym_section; \
1207 asection *input_section = reloc_data.input_section; \
1208 ARC_DEBUG ("RELOC_TYPE = " TYPE "\n"); \
1209 ARC_DEBUG ("FORMULA = " FORMULA "\n"); \
1210 ARC_DEBUG ("S = %#lx\n", S); \
1211 ARC_DEBUG ("A = %#lx\n", A); \
1212 ARC_DEBUG ("L = %lx\n", L); \
1213 if (sym_section->output_section != NULL) \
1214 ARC_DEBUG ("symbol_section->vma = %#lx\n", \
1215 sym_section->output_section->vma \
1216 + sym_section->output_offset); \
1218 ARC_DEBUG ("symbol_section->vma = NULL\n"); \
1219 if (input_section->output_section != NULL) \
1220 ARC_DEBUG ("symbol_section->vma = %#lx\n", \
1221 input_section->output_section->vma \
1222 + input_section->output_offset); \
1224 ARC_DEBUG ("symbol_section->vma = NULL\n"); \
1225 ARC_DEBUG ("PCL = %#lx\n", P); \
1226 ARC_DEBUG ("P = %#lx\n", P); \
1227 ARC_DEBUG ("G = %#lx\n", G); \
1228 ARC_DEBUG ("SDA_OFFSET = %#lx\n", _SDA_BASE_); \
1229 ARC_DEBUG ("SDA_SET = %d\n", reloc_data.sdata_begin_symbol_vma_set); \
1230 ARC_DEBUG ("GOT_OFFSET = %#lx\n", GOT); \
1231 ARC_DEBUG ("relocation = %#08lx\n", relocation); \
1232 ARC_DEBUG ("before = %#08x\n", (unsigned) insn); \
1233 ARC_DEBUG ("data = %08x (%u) (%d)\n", (unsigned) relocation, \
1234 (unsigned) relocation, (int) relocation); \
1238 #define PRINT_DEBUG_RELOC_INFO_AFTER \
1241 ARC_DEBUG ("after = 0x%08x\n", (unsigned int) insn); \
1247 #define PRINT_DEBUG_RELOC_INFO_BEFORE(...)
1248 #define PRINT_DEBUG_RELOC_INFO_AFTER
1250 #endif /* ARC_ENABLE_DEBUG */
1252 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
1255 bfd_signed_vma bitsize ATTRIBUTE_UNUSED = BITSIZE; \
1256 relocation = FORMULA ; \
1257 PRINT_DEBUG_RELOC_INFO_BEFORE (#FORMULA, #TYPE); \
1258 insn = middle_endian_convert (insn, IS_ME (#FORMULA, abfd)); \
1259 insn = (* get_replace_function (abfd, TYPE)) (insn, relocation); \
1260 insn = middle_endian_convert (insn, IS_ME (#FORMULA, abfd)); \
1261 PRINT_DEBUG_RELOC_INFO_AFTER; \
1265 static bfd_reloc_status_type
1266 arc_do_relocation (bfd_byte * contents,
1267 struct arc_relocation_data reloc_data,
1268 struct bfd_link_info *info)
1270 bfd_signed_vma relocation = 0;
1272 bfd_vma orig_insn ATTRIBUTE_UNUSED;
1273 bfd * abfd = reloc_data.input_section->owner;
1274 struct elf_link_hash_table *htab ATTRIBUTE_UNUSED = elf_hash_table (info);
1275 bfd_reloc_status_type flag;
1277 if (!reloc_data.should_relocate)
1278 return bfd_reloc_ok;
1280 switch (reloc_data.howto->size)
1283 insn = arc_bfd_get_32 (abfd,
1284 contents + reloc_data.reloc_offset,
1285 reloc_data.input_section);
1288 insn = arc_bfd_get_16 (abfd,
1289 contents + reloc_data.reloc_offset,
1290 reloc_data.input_section);
1293 insn = arc_bfd_get_8 (abfd,
1294 contents + reloc_data.reloc_offset,
1295 reloc_data.input_section);
1305 switch (reloc_data.howto->type)
1307 #include "elf/arc-reloc.def"
1314 /* Check for relocation overflow. */
1315 if (reloc_data.howto->complain_on_overflow != complain_overflow_dont)
1316 flag = bfd_check_overflow (reloc_data.howto->complain_on_overflow,
1317 reloc_data.howto->bitsize,
1318 reloc_data.howto->rightshift,
1319 bfd_arch_bits_per_address (abfd),
1322 flag = arc_special_overflow_checks (reloc_data, relocation, info);
1324 if (flag != bfd_reloc_ok)
1326 ARC_DEBUG ("Relocation overflows !\n");
1327 DEBUG_ARC_RELOC (reloc_data);
1328 ARC_DEBUG ("Relocation value = signed -> %d, unsigned -> %u"
1329 ", hex -> (0x%08x)\n",
1330 (int) relocation, (unsigned) relocation, (int) relocation);
1335 /* Write updated instruction back to memory. */
1336 switch (reloc_data.howto->size)
1339 arc_bfd_put_32 (abfd, insn,
1340 contents + reloc_data.reloc_offset,
1341 reloc_data.input_section);
1344 arc_bfd_put_16 (abfd, insn,
1345 contents + reloc_data.reloc_offset,
1346 reloc_data.input_section);
1349 arc_bfd_put_8 (abfd, insn,
1350 contents + reloc_data.reloc_offset,
1351 reloc_data.input_section);
1354 ARC_DEBUG ("size = %d\n", reloc_data.howto->size);
1359 return bfd_reloc_ok;
1375 #undef ARC_RELOC_HOWTO
1378 /* Relocate an arc ELF section.
1379 Function : elf_arc_relocate_section
1380 Brief : Relocate an arc section, by handling all the relocations
1381 appearing in that section.
1382 Args : output_bfd : The bfd being written to.
1383 info : Link information.
1384 input_bfd : The input bfd.
1385 input_section : The section being relocated.
1386 contents : contents of the section being relocated.
1387 relocs : List of relocations in the section.
1388 local_syms : is a pointer to the swapped in local symbols.
1389 local_section : is an array giving the section in the input file
1390 corresponding to the st_shndx field of each
1393 elf_arc_relocate_section (bfd * output_bfd,
1394 struct bfd_link_info * info,
1396 asection * input_section,
1397 bfd_byte * contents,
1398 Elf_Internal_Rela * relocs,
1399 Elf_Internal_Sym * local_syms,
1400 asection ** local_sections)
1402 Elf_Internal_Shdr * symtab_hdr;
1403 struct elf_link_hash_entry ** sym_hashes;
1404 Elf_Internal_Rela * rel;
1405 Elf_Internal_Rela * wrel;
1406 Elf_Internal_Rela * relend;
1407 struct elf_link_hash_table * htab = elf_hash_table (info);
1409 symtab_hdr = &((elf_tdata (input_bfd))->symtab_hdr);
1410 sym_hashes = elf_sym_hashes (input_bfd);
1412 rel = wrel = relocs;
1413 relend = relocs + input_section->reloc_count;
1414 for (; rel < relend; wrel++, rel++)
1416 enum elf_arc_reloc_type r_type;
1417 reloc_howto_type * howto;
1418 unsigned long r_symndx;
1419 struct elf_link_hash_entry * h;
1420 Elf_Internal_Sym * sym;
1422 struct elf_link_hash_entry * h2;
1424 bfd_boolean unresolved_reloc = FALSE;
1426 struct arc_relocation_data reloc_data =
1430 .got_offset_value = 0,
1432 .sym_section = NULL,
1434 .input_section = NULL,
1435 .sdata_begin_symbol_vma = 0,
1436 .sdata_begin_symbol_vma_set = FALSE,
1437 .got_symbol_vma = 0,
1438 .should_relocate = FALSE
1441 r_type = ELF32_R_TYPE (rel->r_info);
1443 if (r_type >= (int) R_ARC_max)
1445 bfd_set_error (bfd_error_bad_value);
1448 howto = arc_elf_howto (r_type);
1450 r_symndx = ELF32_R_SYM (rel->r_info);
1452 /* If we are generating another .o file and the symbol in not
1453 local, skip this relocation. */
1454 if (bfd_link_relocatable (info))
1456 /* This is a relocateable link. We don't have to change
1457 anything, unless the reloc is against a section symbol,
1458 in which case we have to adjust according to where the
1459 section symbol winds up in the output section. */
1461 /* Checks if this is a local symbol and thus the reloc
1462 might (will??) be against a section symbol. */
1463 if (r_symndx < symtab_hdr->sh_info)
1465 sym = local_syms + r_symndx;
1466 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1468 sec = local_sections[r_symndx];
1470 /* For RELA relocs. Just adjust the addend
1471 value in the relocation entry. */
1472 rel->r_addend += sec->output_offset + sym->st_value;
1474 ARC_DEBUG ("local symbols reloc (section=%d %s) seen in %s\n",
1475 (int) r_symndx, local_sections[r_symndx]->name,
1476 __PRETTY_FUNCTION__);
1481 h2 = elf_link_hash_lookup (elf_hash_table (info), "__SDATA_BEGIN__",
1482 FALSE, FALSE, TRUE);
1484 if (!reloc_data.sdata_begin_symbol_vma_set
1485 && h2 != NULL && h2->root.type != bfd_link_hash_undefined
1486 && h2->root.u.def.section->output_section != NULL)
1487 /* TODO: Verify this condition. */
1489 reloc_data.sdata_begin_symbol_vma =
1490 (h2->root.u.def.value
1491 + h2->root.u.def.section->output_section->vma);
1492 reloc_data.sdata_begin_symbol_vma_set = TRUE;
1495 reloc_data.input_section = input_section;
1496 reloc_data.howto = howto;
1497 reloc_data.reloc_offset = rel->r_offset;
1498 reloc_data.reloc_addend = rel->r_addend;
1500 /* This is a final link. */
1505 if (r_symndx < symtab_hdr->sh_info) /* A local symbol. */
1507 sym = local_syms + r_symndx;
1508 sec = local_sections[r_symndx];
1512 bfd_boolean warned, ignored;
1513 bfd_vma relocation ATTRIBUTE_UNUSED;
1515 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1516 r_symndx, symtab_hdr, sym_hashes,
1518 unresolved_reloc, warned, ignored);
1520 /* TODO: This code is repeated from below. We should
1521 clean it and remove duplications.
1522 Sec is used check for discarded sections.
1523 Need to redesign code below. */
1525 /* Get the symbol's entry in the symtab. */
1526 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1528 while (h->root.type == bfd_link_hash_indirect
1529 || h->root.type == bfd_link_hash_warning)
1530 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1532 /* If we have encountered a definition for this symbol. */
1533 if (h->root.type == bfd_link_hash_defined
1534 || h->root.type == bfd_link_hash_defweak)
1536 reloc_data.sym_value = h->root.u.def.value;
1537 sec = h->root.u.def.section;
1541 /* Clean relocs for symbols in discarded sections. */
1542 if (sec != NULL && discarded_section (sec))
1544 _bfd_clear_contents (howto, input_bfd, input_section,
1545 contents + rel->r_offset);
1549 /* For ld -r, remove relocations in debug sections against
1550 sections defined in discarded sections. Not done for
1551 eh_frame editing code expects to be present. */
1552 if (bfd_link_relocatable (info)
1553 && (input_section->flags & SEC_DEBUGGING))
1559 if (bfd_link_relocatable (info))
1566 if (r_symndx < symtab_hdr->sh_info) /* A local symbol. */
1568 reloc_data.sym_value = sym->st_value;
1569 reloc_data.sym_section = sec;
1570 reloc_data.symbol_name =
1571 bfd_elf_string_from_elf_section (input_bfd,
1572 symtab_hdr->sh_link,
1575 /* Mergeable section handling. */
1576 if ((sec->flags & SEC_MERGE)
1577 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1581 rel->r_addend = _bfd_elf_rel_local_sym (output_bfd, sym,
1582 &msec, rel->r_addend);
1583 rel->r_addend -= (sec->output_section->vma
1584 + sec->output_offset
1586 rel->r_addend += msec->output_section->vma + msec->output_offset;
1588 reloc_data.reloc_addend = rel->r_addend;
1591 BFD_ASSERT (htab->sgot != NULL || !is_reloc_for_GOT (howto));
1592 if (htab->sgot != NULL)
1593 reloc_data.got_symbol_vma = htab->sgot->output_section->vma
1594 + htab->sgot->output_offset;
1596 reloc_data.should_relocate = TRUE;
1598 else /* Global symbol. */
1600 /* FIXME: We should use the RELOC_FOR_GLOBAL_SYMBOL macro
1601 (defined in elf-bfd.h) here. */
1603 /* Get the symbol's entry in the symtab. */
1604 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1606 while (h->root.type == bfd_link_hash_indirect
1607 || h->root.type == bfd_link_hash_warning)
1609 struct elf_link_hash_entry *h_old = h;
1610 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1611 if (h->got.glist == 0 && h_old->got.glist != h->got.glist)
1612 h->got.glist = h_old->got.glist;
1615 /* TODO: Need to validate what was the intention. */
1616 /* BFD_ASSERT ((h->dynindx == -1) || (h->forced_local != 0)); */
1617 reloc_data.symbol_name = h->root.root.string;
1619 /* If we have encountered a definition for this symbol. */
1620 if (h->root.type == bfd_link_hash_defined
1621 || h->root.type == bfd_link_hash_defweak)
1623 reloc_data.sym_value = h->root.u.def.value;
1624 reloc_data.sym_section = h->root.u.def.section;
1626 reloc_data.should_relocate = TRUE;
1628 if (is_reloc_for_GOT (howto) && !bfd_link_pic (info))
1630 /* TODO: Change it to use arc_do_relocation with
1631 ARC_32 reloc. Try to use ADD_RELA macro. */
1632 bfd_vma relocation =
1633 reloc_data.sym_value + reloc_data.reloc_addend
1634 + (reloc_data.sym_section->output_section != NULL ?
1635 (reloc_data.sym_section->output_offset
1636 + reloc_data.sym_section->output_section->vma)
1639 BFD_ASSERT (h->got.glist);
1640 bfd_vma got_offset = h->got.glist->offset;
1641 bfd_put_32 (output_bfd, relocation,
1642 htab->sgot->contents + got_offset);
1644 if (is_reloc_for_PLT (howto) && h->plt.offset != (bfd_vma) -1)
1646 /* TODO: This is repeated up here. */
1647 reloc_data.sym_value = h->plt.offset;
1648 reloc_data.sym_section = htab->splt;
1651 else if (h->root.type == bfd_link_hash_undefweak)
1653 /* Is weak symbol and has no definition. */
1654 if (is_reloc_for_GOT (howto))
1656 reloc_data.sym_value = h->root.u.def.value;
1657 reloc_data.sym_section = htab->sgot;
1658 reloc_data.should_relocate = TRUE;
1660 else if (is_reloc_for_PLT (howto)
1661 && h->plt.offset != (bfd_vma) -1)
1663 /* TODO: This is repeated up here. */
1664 reloc_data.sym_value = h->plt.offset;
1665 reloc_data.sym_section = htab->splt;
1666 reloc_data.should_relocate = TRUE;
1673 if (is_reloc_for_GOT (howto))
1675 reloc_data.sym_value = h->root.u.def.value;
1676 reloc_data.sym_section = htab->sgot;
1678 reloc_data.should_relocate = TRUE;
1680 else if (is_reloc_for_PLT (howto))
1682 /* Fail if it is linking for PIE and the symbol is
1684 if (bfd_link_executable (info))
1685 (*info->callbacks->undefined_symbol)
1686 (info, h->root.root.string, input_bfd, input_section,
1687 rel->r_offset, TRUE);
1688 reloc_data.sym_value = h->plt.offset;
1689 reloc_data.sym_section = htab->splt;
1691 reloc_data.should_relocate = TRUE;
1693 else if (!bfd_link_pic (info) || bfd_link_executable (info))
1694 (*info->callbacks->undefined_symbol)
1695 (info, h->root.root.string, input_bfd, input_section,
1696 rel->r_offset, TRUE);
1699 BFD_ASSERT (htab->sgot != NULL || !is_reloc_for_GOT (howto));
1700 if (htab->sgot != NULL)
1701 reloc_data.got_symbol_vma = htab->sgot->output_section->vma
1702 + htab->sgot->output_offset;
1705 if ((is_reloc_for_GOT (howto)
1706 || is_reloc_for_TLS (howto)))
1708 reloc_data.should_relocate = TRUE;
1710 struct got_entry **list
1711 = get_got_entry_list_for_symbol (output_bfd, r_symndx, h);
1713 reloc_data.got_offset_value
1714 = relocate_fix_got_relocs_for_got_info (list,
1715 tls_type_for_reloc (howto),
1726 create_got_dynrelocs_for_single_entry (
1727 got_entry_for_type (list,
1728 arc_got_entry_type_for_reloc (howto)),
1729 output_bfd, info, NULL);
1734 #define IS_ARC_PCREL_TYPE(TYPE) \
1735 ( (TYPE == R_ARC_PC32) \
1736 || (TYPE == R_ARC_32_PCREL))
1743 case R_ARC_32_PCREL:
1744 if (bfd_link_pic (info)
1745 && (!IS_ARC_PCREL_TYPE (r_type)
1749 && (!info->symbolic || !h->def_regular))))
1751 Elf_Internal_Rela outrel;
1753 bfd_boolean skip = FALSE;
1754 bfd_boolean relocate = FALSE;
1755 asection *sreloc = _bfd_elf_get_dynamic_reloc_section
1756 (input_bfd, input_section,
1759 BFD_ASSERT (sreloc != NULL);
1761 outrel.r_offset = _bfd_elf_section_offset (output_bfd,
1766 if (outrel.r_offset == (bfd_vma) -1)
1769 outrel.r_addend = rel->r_addend;
1770 outrel.r_offset += (input_section->output_section->vma
1771 + input_section->output_offset);
1775 memset (&outrel, 0, sizeof outrel);
1780 && (IS_ARC_PCREL_TYPE (r_type)
1781 || !(bfd_link_executable (info)
1782 || SYMBOLIC_BIND (info, h))
1783 || ! h->def_regular))
1785 BFD_ASSERT (h != NULL);
1786 if ((input_section->flags & SEC_ALLOC) != 0)
1791 BFD_ASSERT (h->dynindx != -1);
1792 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1796 /* Handle local symbols, they either do not have a
1797 global hash table entry (h == NULL), or are
1798 forced local due to a version script
1799 (h->forced_local), or the third condition is
1800 legacy, it appears to say something like, for
1801 links where we are pre-binding the symbols, or
1802 there's not an entry for this symbol in the
1803 dynamic symbol table, and it's a regular symbol
1804 not defined in a shared object, then treat the
1805 symbol as local, resolve it now. */
1807 /* outrel.r_addend = 0; */
1808 outrel.r_info = ELF32_R_INFO (0, R_ARC_RELATIVE);
1811 BFD_ASSERT (sreloc->contents != 0);
1813 loc = sreloc->contents;
1814 loc += sreloc->reloc_count * sizeof (Elf32_External_Rela);
1815 sreloc->reloc_count += 1;
1817 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1827 if (is_reloc_SDA_relative (howto)
1828 && !reloc_data.sdata_begin_symbol_vma_set)
1831 ("error: linker symbol __SDATA_BEGIN__ not found");
1832 bfd_set_error (bfd_error_bad_value);
1836 DEBUG_ARC_RELOC (reloc_data);
1838 /* Make sure we have with a dynamic linker. In case of GOT and PLT
1839 the sym_section should point to .got or .plt respectively. */
1840 if ((is_reloc_for_GOT (howto) || is_reloc_for_PLT (howto))
1841 && reloc_data.sym_section == NULL)
1844 (_("GOT and PLT relocations cannot be fixed with a non dynamic linker"));
1845 bfd_set_error (bfd_error_bad_value);
1850 switch (arc_do_relocation (contents, reloc_data, info))
1853 continue; /* The reloc processing loop. */
1855 case bfd_reloc_overflow:
1856 (*info->callbacks->reloc_overflow)
1857 (info, (h ? &h->root : NULL), reloc_data.symbol_name, howto->name, (bfd_vma) 0,
1858 input_bfd, input_section, rel->r_offset);
1861 case bfd_reloc_undefined:
1862 (*info->callbacks->undefined_symbol)
1863 (info, reloc_data.symbol_name, input_bfd, input_section, rel->r_offset, TRUE);
1866 case bfd_reloc_other:
1867 /* xgettext:c-format */
1868 msg = _("%pB(%pA): warning: unaligned access to symbol '%s' in the small data area");
1871 case bfd_reloc_outofrange:
1872 /* xgettext:c-format */
1873 msg = _("%pB(%pA): internal error: out of range error");
1876 case bfd_reloc_notsupported:
1877 /* xgettext:c-format */
1878 msg = _("%pB(%pA): internal error: unsupported relocation error");
1881 case bfd_reloc_dangerous:
1882 /* xgettext:c-format */
1883 msg = _("%pB(%pA): internal error: dangerous relocation");
1887 /* xgettext:c-format */
1888 msg = _("%pB(%pA): internal error: unknown error");
1893 _bfd_error_handler (msg, input_bfd, input_section, reloc_data.symbol_name);
1900 #define elf_arc_hash_table(p) \
1901 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
1902 == ARC_ELF_DATA ? ((struct elf_arc_link_hash_table *) ((p)->hash)) : NULL)
1905 elf_arc_check_relocs (bfd * abfd,
1906 struct bfd_link_info * info,
1908 const Elf_Internal_Rela * relocs)
1910 Elf_Internal_Shdr * symtab_hdr;
1911 struct elf_link_hash_entry ** sym_hashes;
1912 const Elf_Internal_Rela * rel;
1913 const Elf_Internal_Rela * rel_end;
1915 asection * sreloc = NULL;
1916 struct elf_link_hash_table * htab = elf_hash_table (info);
1918 if (bfd_link_relocatable (info))
1921 if (htab->dynobj == NULL)
1922 htab->dynobj = abfd;
1924 dynobj = (elf_hash_table (info))->dynobj;
1925 symtab_hdr = &((elf_tdata (abfd))->symtab_hdr);
1926 sym_hashes = elf_sym_hashes (abfd);
1928 rel_end = relocs + sec->reloc_count;
1929 for (rel = relocs; rel < rel_end; rel++)
1931 enum elf_arc_reloc_type r_type;
1932 reloc_howto_type *howto;
1933 unsigned long r_symndx;
1934 struct elf_link_hash_entry *h;
1936 r_type = ELF32_R_TYPE (rel->r_info);
1938 if (r_type >= (int) R_ARC_max)
1940 bfd_set_error (bfd_error_bad_value);
1943 howto = arc_elf_howto (r_type);
1945 /* Load symbol information. */
1946 r_symndx = ELF32_R_SYM (rel->r_info);
1947 if (r_symndx < symtab_hdr->sh_info) /* Is a local symbol. */
1949 else /* Global one. */
1950 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1956 /* During shared library creation, these relocs should not
1957 appear in a shared library (as memory will be read only
1958 and the dynamic linker can not resolve these. However
1959 the error should not occur for e.g. debugging or
1960 non-readonly sections. */
1962 && (bfd_link_dll (info) && !bfd_link_pie (info))
1963 && (sec->flags & SEC_ALLOC) != 0
1964 && (sec->flags & SEC_READONLY) != 0
1965 && ((sec->flags & SEC_CODE) != 0
1966 || (sec->flags & SEC_DEBUGGING) != 0))
1970 name = h->root.root.string;
1972 /* bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL); */
1975 /* xgettext:c-format */
1976 (_("%pB: relocation %s against `%s' can not be used"
1977 " when making a shared object; recompile with -fPIC"),
1979 arc_elf_howto (r_type)->name,
1981 bfd_set_error (bfd_error_bad_value);
1985 /* In some cases we are not setting the 'non_got_ref'
1986 flag, even though the relocations don't require a GOT
1987 access. We should extend the testing in this area to
1988 ensure that no significant cases are being missed. */
1993 case R_ARC_32_PCREL:
1994 if ((bfd_link_pic (info))
1995 && ((r_type != R_ARC_PC32 && r_type != R_ARC_32_PCREL)
1997 && (!info->symbolic || !h->def_regular))))
2002 && ! htab->dynamic_sections_created
2003 && ! _bfd_elf_link_create_dynamic_sections (abfd, info))
2005 sreloc = _bfd_elf_make_dynamic_reloc_section (sec, dynobj,
2013 sreloc->size += sizeof (Elf32_External_Rela);
2020 if (is_reloc_for_PLT (howto))
2028 /* Add info to the symbol got_entry_list. */
2029 if (is_reloc_for_GOT (howto)
2030 || is_reloc_for_TLS (howto))
2032 if (! _bfd_elf_create_got_section (dynobj, info))
2035 arc_fill_got_info_for_reloc (
2036 arc_got_entry_type_for_reloc (howto),
2037 get_got_entry_list_for_symbol (abfd, r_symndx, h),
2046 #define ELF_DYNAMIC_INTERPRETER "/sbin/ld-uClibc.so"
2048 static struct plt_version_t *
2049 arc_get_plt_version (struct bfd_link_info *info)
2053 for (i = 0; i < 1; i++)
2055 ARC_DEBUG ("%d: size1 = %d, size2 = %d\n", i,
2056 (int) plt_versions[i].entry_size,
2057 (int) plt_versions[i].elem_size);
2060 if (bfd_get_mach (info->output_bfd) == bfd_mach_arc_arcv2)
2062 if (bfd_link_pic (info))
2063 return &(plt_versions[ELF_ARCV2_PIC]);
2065 return &(plt_versions[ELF_ARCV2_ABS]);
2069 if (bfd_link_pic (info))
2070 return &(plt_versions[ELF_ARC_PIC]);
2072 return &(plt_versions[ELF_ARC_ABS]);
2077 add_symbol_to_plt (struct bfd_link_info *info)
2079 struct elf_link_hash_table *htab = elf_hash_table (info);
2082 struct plt_version_t *plt_data = arc_get_plt_version (info);
2084 /* If this is the first .plt entry, make room for the special first
2086 if (htab->splt->size == 0)
2087 htab->splt->size += plt_data->entry_size;
2089 ret = htab->splt->size;
2091 htab->splt->size += plt_data->elem_size;
2092 ARC_DEBUG ("PLT_SIZE = %d\n", (int) htab->splt->size);
2094 htab->sgotplt->size += 4;
2095 htab->srelplt->size += sizeof (Elf32_External_Rela);
2100 #define PLT_DO_RELOCS_FOR_ENTRY(ABFD, DS, RELOCS) \
2101 plt_do_relocs_for_symbol (ABFD, DS, RELOCS, 0, 0)
2104 plt_do_relocs_for_symbol (bfd *abfd,
2105 struct elf_link_hash_table *htab,
2106 const struct plt_reloc *reloc,
2108 bfd_vma symbol_got_offset)
2110 while (SYM_ONLY (reloc->symbol) != LAST_RELOC)
2112 bfd_vma relocation = 0;
2114 switch (SYM_ONLY (reloc->symbol))
2118 = htab->sgotplt->output_section->vma
2119 + htab->sgotplt->output_offset + symbol_got_offset;
2122 relocation += reloc->addend;
2124 if (IS_RELATIVE (reloc->symbol))
2126 bfd_vma reloc_offset = reloc->offset;
2127 reloc_offset -= (IS_INSN_32 (reloc->symbol)) ? 4 : 0;
2128 reloc_offset -= (IS_INSN_24 (reloc->symbol)) ? 2 : 0;
2130 relocation -= htab->splt->output_section->vma
2131 + htab->splt->output_offset
2132 + plt_offset + reloc_offset;
2135 /* TODO: being ME is not a property of the relocation but of the
2136 section of which is applying the relocation. */
2137 if (IS_MIDDLE_ENDIAN (reloc->symbol) && !bfd_big_endian (abfd))
2140 = ((relocation & 0xffff0000) >> 16)
2141 | ((relocation & 0xffff) << 16);
2144 switch (reloc->size)
2147 bfd_put_32 (htab->splt->output_section->owner,
2149 htab->splt->contents + plt_offset + reloc->offset);
2153 reloc = &(reloc[1]); /* Jump to next relocation. */
2158 relocate_plt_for_symbol (bfd *output_bfd,
2159 struct bfd_link_info *info,
2160 struct elf_link_hash_entry *h)
2162 struct plt_version_t *plt_data = arc_get_plt_version (info);
2163 struct elf_link_hash_table *htab = elf_hash_table (info);
2165 bfd_vma plt_index = (h->plt.offset - plt_data->entry_size)
2166 / plt_data->elem_size;
2167 bfd_vma got_offset = (plt_index + 3) * 4;
2169 ARC_DEBUG ("arc_info: PLT_OFFSET = %#lx, PLT_ENTRY_VMA = %#lx, \
2170 GOT_ENTRY_OFFSET = %#lx, GOT_ENTRY_VMA = %#lx, for symbol %s\n",
2171 (long) h->plt.offset,
2172 (long) (htab->splt->output_section->vma
2173 + htab->splt->output_offset
2176 (long) (htab->sgotplt->output_section->vma
2177 + htab->sgotplt->output_offset
2179 h->root.root.string);
2183 uint16_t *ptr = (uint16_t *) plt_data->elem;
2185 for (i = 0; i < plt_data->elem_size/2; i++)
2187 uint16_t data = ptr[i];
2188 bfd_put_16 (output_bfd,
2190 htab->splt->contents + h->plt.offset + (i*2));
2194 plt_do_relocs_for_symbol (output_bfd, htab,
2195 plt_data->elem_relocs,
2199 /* Fill in the entry in the global offset table. */
2200 bfd_put_32 (output_bfd,
2201 (bfd_vma) (htab->splt->output_section->vma
2202 + htab->splt->output_offset),
2203 htab->sgotplt->contents + got_offset);
2205 /* TODO: Fill in the entry in the .rela.plt section. */
2207 Elf_Internal_Rela rel;
2210 rel.r_offset = (htab->sgotplt->output_section->vma
2211 + htab->sgotplt->output_offset
2215 BFD_ASSERT (h->dynindx != -1);
2216 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARC_JMP_SLOT);
2218 loc = htab->srelplt->contents;
2219 loc += plt_index * sizeof (Elf32_External_Rela); /* relA */
2220 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
2225 relocate_plt_for_entry (bfd *abfd,
2226 struct bfd_link_info *info)
2228 struct plt_version_t *plt_data = arc_get_plt_version (info);
2229 struct elf_link_hash_table *htab = elf_hash_table (info);
2233 uint16_t *ptr = (uint16_t *) plt_data->entry;
2234 for (i = 0; i < plt_data->entry_size/2; i++)
2236 uint16_t data = ptr[i];
2239 htab->splt->contents + (i*2));
2242 PLT_DO_RELOCS_FOR_ENTRY (abfd, htab, plt_data->entry_relocs);
2245 /* Desc : Adjust a symbol defined by a dynamic object and referenced
2246 by a regular object. The current definition is in some section of
2247 the dynamic object, but we're not including those sections. We
2248 have to change the definition to something the rest of the link can
2252 elf_arc_adjust_dynamic_symbol (struct bfd_link_info *info,
2253 struct elf_link_hash_entry *h)
2256 bfd *dynobj = (elf_hash_table (info))->dynobj;
2257 struct elf_link_hash_table *htab = elf_hash_table (info);
2259 if (h->type == STT_FUNC
2260 || h->type == STT_GNU_IFUNC
2261 || h->needs_plt == 1)
2263 if (!bfd_link_pic (info) && !h->def_dynamic && !h->ref_dynamic)
2265 /* This case can occur if we saw a PLT32 reloc in an input
2266 file, but the symbol was never referred to by a dynamic
2267 object. In such a case, we don't actually need to build
2268 a procedure linkage table, and we can just do a PC32
2270 BFD_ASSERT (h->needs_plt);
2274 /* Make sure this symbol is output as a dynamic symbol. */
2275 if (h->dynindx == -1 && !h->forced_local
2276 && !bfd_elf_link_record_dynamic_symbol (info, h))
2279 if (bfd_link_pic (info)
2280 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
2282 bfd_vma loc = add_symbol_to_plt (info);
2284 if (bfd_link_executable (info) && !h->def_regular)
2286 h->root.u.def.section = htab->splt;
2287 h->root.u.def.value = loc;
2289 h->plt.offset = loc;
2293 h->plt.offset = (bfd_vma) -1;
2299 /* If this is a weak symbol, and there is a real definition, the
2300 processor independent code will have arranged for us to see the
2301 real definition first, and we can just use the same value. */
2302 if (h->is_weakalias)
2304 struct elf_link_hash_entry *def = weakdef (h);
2305 BFD_ASSERT (def->root.type == bfd_link_hash_defined);
2306 h->root.u.def.section = def->root.u.def.section;
2307 h->root.u.def.value = def->root.u.def.value;
2311 /* This is a reference to a symbol defined by a dynamic object which
2312 is not a function. */
2314 /* If we are creating a shared library, we must presume that the
2315 only references to the symbol are via the global offset table.
2316 For such cases we need not do anything here; the relocations will
2317 be handled correctly by relocate_section. */
2318 if (!bfd_link_executable (info))
2321 /* If there are no non-GOT references, we do not need a copy
2323 if (!h->non_got_ref)
2326 /* If -z nocopyreloc was given, we won't generate them either. */
2327 if (info->nocopyreloc)
2333 /* We must allocate the symbol in our .dynbss section, which will
2334 become part of the .bss section of the executable. There will be
2335 an entry for this symbol in the .dynsym section. The dynamic
2336 object will contain position independent code, so all references
2337 from the dynamic object to this symbol will go through the global
2338 offset table. The dynamic linker will use the .dynsym entry to
2339 determine the address it must put in the global offset table, so
2340 both the dynamic object and the regular object will refer to the
2341 same memory location for the variable. */
2346 /* We must generate a R_ARC_COPY reloc to tell the dynamic linker to
2347 copy the initial value out of the dynamic object and into the
2348 runtime process image. We need to remember the offset into the
2349 .rela.bss section we are going to use. */
2350 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
2352 struct elf_arc_link_hash_table *arc_htab = elf_arc_hash_table (info);
2354 BFD_ASSERT (arc_htab->elf.srelbss != NULL);
2355 arc_htab->elf.srelbss->size += sizeof (Elf32_External_Rela);
2359 /* TODO: Move this also to arc_hash_table. */
2360 s = bfd_get_section_by_name (dynobj, ".dynbss");
2361 BFD_ASSERT (s != NULL);
2363 return _bfd_elf_adjust_dynamic_copy (info, h, s);
2366 /* Function : elf_arc_finish_dynamic_symbol
2367 Brief : Finish up dynamic symbol handling. We set the
2368 contents of various dynamic sections here.
2373 Returns : True/False as the return status. */
2376 elf_arc_finish_dynamic_symbol (bfd * output_bfd,
2377 struct bfd_link_info *info,
2378 struct elf_link_hash_entry *h,
2379 Elf_Internal_Sym * sym)
2381 if (h->plt.offset != (bfd_vma) -1)
2383 relocate_plt_for_symbol (output_bfd, info, h);
2385 if (!h->def_regular)
2387 /* Mark the symbol as undefined, rather than as defined in
2388 the .plt section. Leave the value alone. */
2389 sym->st_shndx = SHN_UNDEF;
2394 /* This function traverses list of GOT entries and
2395 create respective dynamic relocs. */
2396 /* TODO: Make function to get list and not access the list directly. */
2397 /* TODO: Move function to relocate_section create this relocs eagerly. */
2398 create_got_dynrelocs_for_got_info (&h->got.glist,
2405 struct elf_arc_link_hash_table *arc_htab = elf_arc_hash_table (info);
2407 if (h->dynindx == -1
2408 || (h->root.type != bfd_link_hash_defined
2409 && h->root.type != bfd_link_hash_defweak)
2410 || arc_htab->elf.srelbss == NULL)
2413 bfd_vma rel_offset = (h->root.u.def.value
2414 + h->root.u.def.section->output_section->vma
2415 + h->root.u.def.section->output_offset);
2417 bfd_byte * loc = arc_htab->elf.srelbss->contents
2418 + (arc_htab->elf.srelbss->reloc_count * sizeof (Elf32_External_Rela));
2419 arc_htab->elf.srelbss->reloc_count++;
2421 Elf_Internal_Rela rel;
2423 rel.r_offset = rel_offset;
2425 BFD_ASSERT (h->dynindx != -1);
2426 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARC_COPY);
2428 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
2431 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2432 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2433 || strcmp (h->root.root.string, "__DYNAMIC") == 0
2434 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2435 sym->st_shndx = SHN_ABS;
2440 #define GET_SYMBOL_OR_SECTION(TAG, SYMBOL, SECTION) \
2442 if (SYMBOL != NULL) \
2443 h = elf_link_hash_lookup (elf_hash_table (info), \
2444 SYMBOL, FALSE, FALSE, TRUE); \
2445 else if (SECTION != NULL) \
2446 s = bfd_get_linker_section (dynobj, SECTION); \
2449 /* Function : elf_arc_finish_dynamic_sections
2450 Brief : Finish up the dynamic sections handling.
2455 Returns : True/False as the return status. */
2458 elf_arc_finish_dynamic_sections (bfd * output_bfd,
2459 struct bfd_link_info *info)
2461 struct elf_link_hash_table *htab = elf_hash_table (info);
2462 bfd *dynobj = (elf_hash_table (info))->dynobj;
2463 asection *sdyn = bfd_get_linker_section (dynobj, ".dynamic");
2467 Elf32_External_Dyn *dyncon, *dynconend;
2469 dyncon = (Elf32_External_Dyn *) sdyn->contents;
2471 = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
2472 for (; dyncon < dynconend; dyncon++)
2474 Elf_Internal_Dyn internal_dyn;
2475 bfd_boolean do_it = FALSE;
2477 struct elf_link_hash_entry *h = NULL;
2480 bfd_elf32_swap_dyn_in (dynobj, dyncon, &internal_dyn);
2482 switch (internal_dyn.d_tag)
2484 GET_SYMBOL_OR_SECTION (DT_INIT, info->init_function, NULL)
2485 GET_SYMBOL_OR_SECTION (DT_FINI, info->fini_function, NULL)
2486 GET_SYMBOL_OR_SECTION (DT_PLTGOT, NULL, ".plt")
2487 GET_SYMBOL_OR_SECTION (DT_JMPREL, NULL, ".rela.plt")
2488 GET_SYMBOL_OR_SECTION (DT_PLTRELSZ, NULL, ".rela.plt")
2489 GET_SYMBOL_OR_SECTION (DT_VERSYM, NULL, ".gnu.version")
2490 GET_SYMBOL_OR_SECTION (DT_VERDEF, NULL, ".gnu.version_d")
2491 GET_SYMBOL_OR_SECTION (DT_VERNEED, NULL, ".gnu.version_r")
2496 /* In case the dynamic symbols should be updated with a symbol. */
2498 && (h->root.type == bfd_link_hash_defined
2499 || h->root.type == bfd_link_hash_defweak))
2503 internal_dyn.d_un.d_val = h->root.u.def.value;
2504 asec_ptr = h->root.u.def.section;
2505 if (asec_ptr->output_section != NULL)
2507 internal_dyn.d_un.d_val +=
2508 (asec_ptr->output_section->vma
2509 + asec_ptr->output_offset);
2513 /* The symbol is imported from another shared
2514 library and does not apply to this one. */
2515 internal_dyn.d_un.d_val = 0;
2519 else if (s != NULL) /* With a section information. */
2521 switch (internal_dyn.d_tag)
2528 internal_dyn.d_un.d_ptr = (s->output_section->vma
2529 + s->output_offset);
2534 internal_dyn.d_un.d_val = s->size;
2544 bfd_elf32_swap_dyn_out (output_bfd, &internal_dyn, dyncon);
2547 if (htab->splt->size > 0)
2549 relocate_plt_for_entry (output_bfd, info);
2552 /* TODO: Validate this. */
2553 if (htab->srelplt->output_section != bfd_abs_section_ptr)
2554 elf_section_data (htab->srelplt->output_section)
2555 ->this_hdr.sh_entsize = 12;
2558 /* Fill in the first three entries in the global offset table. */
2561 struct elf_link_hash_entry *h;
2562 h = elf_link_hash_lookup (elf_hash_table (info), "_GLOBAL_OFFSET_TABLE_",
2563 FALSE, FALSE, TRUE);
2565 if (h != NULL && h->root.type != bfd_link_hash_undefined
2566 && h->root.u.def.section != NULL)
2568 asection *sec = h->root.u.def.section;
2571 bfd_put_32 (output_bfd, (bfd_vma) 0,
2574 bfd_put_32 (output_bfd,
2575 sdyn->output_section->vma + sdyn->output_offset,
2577 bfd_put_32 (output_bfd, (bfd_vma) 0, sec->contents + 4);
2578 bfd_put_32 (output_bfd, (bfd_vma) 0, sec->contents + 8);
2585 #define ADD_DYNAMIC_SYMBOL(NAME, TAG) \
2586 h = elf_link_hash_lookup (elf_hash_table (info), \
2587 NAME, FALSE, FALSE, FALSE); \
2588 if ((h != NULL && (h->ref_regular || h->def_regular))) \
2589 if (! _bfd_elf_add_dynamic_entry (info, TAG, 0)) \
2592 /* Set the sizes of the dynamic sections. */
2594 elf_arc_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2595 struct bfd_link_info *info)
2599 bfd_boolean relocs_exist = FALSE;
2600 bfd_boolean reltext_exist = FALSE;
2601 struct elf_link_hash_table *htab = elf_hash_table (info);
2603 dynobj = htab->dynobj;
2604 BFD_ASSERT (dynobj != NULL);
2606 if (htab->dynamic_sections_created)
2608 struct elf_link_hash_entry *h;
2610 /* Set the contents of the .interp section to the
2612 if (bfd_link_executable (info) && !info->nointerp)
2614 s = bfd_get_section_by_name (dynobj, ".interp");
2615 BFD_ASSERT (s != NULL);
2616 s->size = sizeof (ELF_DYNAMIC_INTERPRETER);
2617 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2620 /* Add some entries to the .dynamic section. We fill in some of
2621 the values later, in elf_bfd_final_link, but we must add the
2622 entries now so that we know the final size of the .dynamic
2623 section. Checking if the .init section is present. We also
2624 create DT_INIT and DT_FINI entries if the init_str has been
2625 changed by the user. */
2626 ADD_DYNAMIC_SYMBOL (info->init_function, DT_INIT);
2627 ADD_DYNAMIC_SYMBOL (info->fini_function, DT_FINI);
2631 /* We may have created entries in the .rela.got section.
2632 However, if we are not creating the dynamic sections, we will
2633 not actually use these entries. Reset the size of .rela.got,
2634 which will cause it to get stripped from the output file
2636 if (htab->srelgot != NULL)
2637 htab->srelgot->size = 0;
2640 for (s = dynobj->sections; s != NULL; s = s->next)
2642 if ((s->flags & SEC_LINKER_CREATED) == 0)
2647 || s == htab->sgotplt
2648 || s == htab->sdynbss)
2650 /* Strip this section if we don't need it. */
2652 else if (strncmp (s->name, ".rela", 5) == 0)
2654 if (s->size != 0 && s != htab->srelplt)
2658 const char *name = s->name + 5;
2660 for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link.next)
2661 if (bfd_get_flavour (ibfd) == bfd_target_elf_flavour
2662 && ibfd->flags & DYNAMIC)
2664 asection *target = bfd_get_section_by_name (ibfd, name);
2666 && elf_section_data (target)->sreloc == s
2667 && ((target->output_section->flags
2668 & (SEC_READONLY | SEC_ALLOC))
2669 == (SEC_READONLY | SEC_ALLOC)))
2671 reltext_exist = TRUE;
2676 relocs_exist = TRUE;
2679 /* We use the reloc_count field as a counter if we need to
2680 copy relocs into the output file. */
2685 /* It's not one of our sections, so don't allocate space. */
2691 s->flags |= SEC_EXCLUDE;
2695 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2698 /* Allocate memory for the section contents. */
2699 s->contents = bfd_zalloc (dynobj, s->size);
2700 if (s->contents == NULL)
2704 if (htab->dynamic_sections_created)
2706 /* TODO: Check if this is needed. */
2707 if (!bfd_link_pic (info))
2708 if (!_bfd_elf_add_dynamic_entry (info, DT_DEBUG, 0))
2711 if (htab->splt && (htab->splt->flags & SEC_EXCLUDE) == 0)
2712 if (!_bfd_elf_add_dynamic_entry (info, DT_PLTGOT, 0)
2713 || !_bfd_elf_add_dynamic_entry (info, DT_PLTRELSZ, 0)
2714 || !_bfd_elf_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
2715 || !_bfd_elf_add_dynamic_entry (info, DT_JMPREL, 0))
2719 if (!_bfd_elf_add_dynamic_entry (info, DT_RELA, 0)
2720 || !_bfd_elf_add_dynamic_entry (info, DT_RELASZ, 0)
2721 || !_bfd_elf_add_dynamic_entry (info, DT_RELAENT,
2722 sizeof (Elf32_External_Rela)))
2726 if (!_bfd_elf_add_dynamic_entry (info, DT_TEXTREL, 0))
2734 /* Classify dynamic relocs such that -z combreloc can reorder and combine
2736 static enum elf_reloc_type_class
2737 elf32_arc_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
2738 const asection *rel_sec ATTRIBUTE_UNUSED,
2739 const Elf_Internal_Rela *rela)
2741 switch ((int) ELF32_R_TYPE (rela->r_info))
2743 case R_ARC_RELATIVE:
2744 return reloc_class_relative;
2745 case R_ARC_JMP_SLOT:
2746 return reloc_class_plt;
2748 return reloc_class_copy;
2749 /* TODO: Needed in future to support ifunc. */
2751 case R_ARC_IRELATIVE:
2752 return reloc_class_ifunc;
2755 return reloc_class_normal;
2759 const struct elf_size_info arc_elf32_size_info =
2761 sizeof (Elf32_External_Ehdr),
2762 sizeof (Elf32_External_Phdr),
2763 sizeof (Elf32_External_Shdr),
2764 sizeof (Elf32_External_Rel),
2765 sizeof (Elf32_External_Rela),
2766 sizeof (Elf32_External_Sym),
2767 sizeof (Elf32_External_Dyn),
2768 sizeof (Elf_External_Note),
2772 ELFCLASS32, EV_CURRENT,
2773 bfd_elf32_write_out_phdrs,
2774 bfd_elf32_write_shdrs_and_ehdr,
2775 bfd_elf32_checksum_contents,
2776 bfd_elf32_write_relocs,
2777 bfd_elf32_swap_symbol_in,
2778 bfd_elf32_swap_symbol_out,
2779 bfd_elf32_slurp_reloc_table,
2780 bfd_elf32_slurp_symbol_table,
2781 bfd_elf32_swap_dyn_in,
2782 bfd_elf32_swap_dyn_out,
2783 bfd_elf32_swap_reloc_in,
2784 bfd_elf32_swap_reloc_out,
2785 bfd_elf32_swap_reloca_in,
2786 bfd_elf32_swap_reloca_out
2789 #define elf_backend_size_info arc_elf32_size_info
2791 /* Hook called by the linker routine which adds symbols from an object
2795 elf_arc_add_symbol_hook (bfd * abfd,
2796 struct bfd_link_info * info,
2797 Elf_Internal_Sym * sym,
2798 const char ** namep ATTRIBUTE_UNUSED,
2799 flagword * flagsp ATTRIBUTE_UNUSED,
2800 asection ** secp ATTRIBUTE_UNUSED,
2801 bfd_vma * valp ATTRIBUTE_UNUSED)
2803 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC
2804 && (abfd->flags & DYNAMIC) == 0
2805 && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
2806 elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_ifunc;
2811 /* GDB expects general purpose registers to be in section .reg. However Linux
2812 kernel doesn't create this section and instead writes registers to NOTE
2813 section. It is up to the binutils to create a pseudo-section .reg from the
2814 contents of NOTE. Also BFD will read pid and signal number from NOTE. This
2815 function relies on offsets inside elf_prstatus structure in Linux to be
2819 elf32_arc_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2824 switch (note->descsz)
2829 case 236: /* sizeof (struct elf_prstatus) on Linux/arc. */
2831 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2833 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
2836 size = (40 * 4); /* There are 40 registers in user_regs_struct. */
2839 /* Make a ".reg/999" section. */
2840 return _bfd_elfcore_make_pseudosection (abfd, ".reg", size,
2841 note->descpos + offset);
2844 /* Determine whether an object attribute tag takes an integer, a
2848 elf32_arc_obj_attrs_arg_type (int tag)
2850 if (tag == Tag_ARC_CPU_name
2851 || tag == Tag_ARC_ISA_config
2852 || tag == Tag_ARC_ISA_apex)
2853 return ATTR_TYPE_FLAG_STR_VAL;
2854 else if (tag < (Tag_ARC_ISA_mpy_option + 1))
2855 return ATTR_TYPE_FLAG_INT_VAL;
2857 return (tag & 1) != 0 ? ATTR_TYPE_FLAG_STR_VAL : ATTR_TYPE_FLAG_INT_VAL;
2860 /* Attribute numbers >=14 can be safely ignored. */
2863 elf32_arc_obj_attrs_handle_unknown (bfd *abfd, int tag)
2865 if ((tag & 127) < (Tag_ARC_ISA_mpy_option + 1))
2868 (_("%pB: unknown mandatory ARC object attribute %d"),
2870 bfd_set_error (bfd_error_bad_value);
2876 (_("warning: %pB: unknown ARC object attribute %d"),
2882 /* Handle an ARC specific section when reading an object file. This is
2883 called when bfd_section_from_shdr finds a section with an unknown
2887 elf32_arc_section_from_shdr (bfd *abfd,
2888 Elf_Internal_Shdr * hdr,
2892 switch (hdr->sh_type)
2894 case SHT_ARC_ATTRIBUTES:
2901 if (!_bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
2907 #define TARGET_LITTLE_SYM arc_elf32_le_vec
2908 #define TARGET_LITTLE_NAME "elf32-littlearc"
2909 #define TARGET_BIG_SYM arc_elf32_be_vec
2910 #define TARGET_BIG_NAME "elf32-bigarc"
2911 #define ELF_ARCH bfd_arch_arc
2912 #define ELF_TARGET_ID ARC_ELF_DATA
2913 #define ELF_MACHINE_CODE EM_ARC_COMPACT
2914 #define ELF_MACHINE_ALT1 EM_ARC_COMPACT2
2915 #define ELF_MAXPAGESIZE 0x2000
2917 #define bfd_elf32_bfd_link_hash_table_create arc_elf_link_hash_table_create
2919 #define bfd_elf32_bfd_merge_private_bfd_data arc_elf_merge_private_bfd_data
2920 #define bfd_elf32_bfd_reloc_type_lookup arc_elf32_bfd_reloc_type_lookup
2921 #define bfd_elf32_bfd_set_private_flags arc_elf_set_private_flags
2922 #define bfd_elf32_bfd_print_private_bfd_data arc_elf_print_private_bfd_data
2923 #define bfd_elf32_bfd_copy_private_bfd_data arc_elf_copy_private_bfd_data
2925 #define elf_info_to_howto_rel arc_info_to_howto_rel
2926 #define elf_backend_object_p arc_elf_object_p
2927 #define elf_backend_final_write_processing arc_elf_final_write_processing
2929 #define elf_backend_relocate_section elf_arc_relocate_section
2930 #define elf_backend_check_relocs elf_arc_check_relocs
2931 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
2933 #define elf_backend_reloc_type_class elf32_arc_reloc_type_class
2935 #define elf_backend_adjust_dynamic_symbol elf_arc_adjust_dynamic_symbol
2936 #define elf_backend_finish_dynamic_symbol elf_arc_finish_dynamic_symbol
2938 #define elf_backend_finish_dynamic_sections elf_arc_finish_dynamic_sections
2939 #define elf_backend_size_dynamic_sections elf_arc_size_dynamic_sections
2940 #define elf_backend_add_symbol_hook elf_arc_add_symbol_hook
2942 #define elf_backend_can_gc_sections 1
2943 #define elf_backend_want_got_plt 1
2944 #define elf_backend_plt_readonly 1
2945 #define elf_backend_rela_plts_and_copies_p 1
2946 #define elf_backend_want_plt_sym 0
2947 #define elf_backend_got_header_size 12
2948 #define elf_backend_dtrel_excludes_plt 1
2950 #define elf_backend_may_use_rel_p 0
2951 #define elf_backend_may_use_rela_p 1
2952 #define elf_backend_default_use_rela_p 1
2954 #define elf_backend_grok_prstatus elf32_arc_grok_prstatus
2956 #define elf_backend_default_execstack 0
2958 #undef elf_backend_obj_attrs_vendor
2959 #define elf_backend_obj_attrs_vendor "ARC"
2960 #undef elf_backend_obj_attrs_section
2961 #define elf_backend_obj_attrs_section ".ARC.attributes"
2962 #undef elf_backend_obj_attrs_arg_type
2963 #define elf_backend_obj_attrs_arg_type elf32_arc_obj_attrs_arg_type
2964 #undef elf_backend_obj_attrs_section_type
2965 #define elf_backend_obj_attrs_section_type SHT_ARC_ATTRIBUTES
2966 #define elf_backend_obj_attrs_handle_unknown elf32_arc_obj_attrs_handle_unknown
2968 #define elf_backend_section_from_shdr elf32_arc_section_from_shdr
2970 #include "elf32-target.h"