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
,
511 Elf_Internal_Rela
* dst
)
515 r_type
= ELF32_R_TYPE (dst
->r_info
);
516 if (r_type
>= (unsigned int) R_ARC_max
)
518 /* xgettext:c-format */
519 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
521 bfd_set_error (bfd_error_bad_value
);
525 cache_ptr
->howto
= arc_elf_howto (r_type
);
529 /* Extract CPU features from an NTBS. */
532 arc_extract_features (const char *p
)
539 for (i
= 0; i
< ARRAY_SIZE (bfd_feature_list
); i
++)
541 char *t
= strstr (p
, bfd_feature_list
[i
].attr
);
542 unsigned l
= strlen (bfd_feature_list
[i
].attr
);
546 r
|= bfd_feature_list
[i
].feature
;
552 /* Concatenate two strings. s1 can be NULL but not
556 arc_stralloc (char * s1
, const char * s2
)
560 /* Only s1 can be null. */
563 p
= s1
? concat (s1
, ",", s2
, NULL
) : (char *)s2
;
568 /* Merge ARC object attributes from IBFD into OBFD. Raise an error if
569 there are conflicting attributes. */
572 arc_elf_merge_attributes (bfd
*ibfd
, struct bfd_link_info
*info
)
574 bfd
*obfd
= info
->output_bfd
;
575 obj_attribute
*in_attr
;
576 obj_attribute
*out_attr
;
578 bfd_boolean result
= TRUE
;
579 const char *sec_name
= get_elf_backend_data (ibfd
)->obj_attrs_section
;
580 char *tagname
= NULL
;
583 /* Skip the linker stubs file. This preserves previous behavior
584 of accepting unknown attributes in the first input file - but
586 if (ibfd
->flags
& BFD_LINKER_CREATED
)
589 /* Skip any input that hasn't attribute section.
590 This enables to link object files without attribute section with
592 if (bfd_get_section_by_name (ibfd
, sec_name
) == NULL
)
595 if (!elf_known_obj_attributes_proc (obfd
)[0].i
)
597 /* This is the first object. Copy the attributes. */
598 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
600 out_attr
= elf_known_obj_attributes_proc (obfd
);
602 /* Use the Tag_null value to indicate the attributes have been
609 in_attr
= elf_known_obj_attributes_proc (ibfd
);
610 out_attr
= elf_known_obj_attributes_proc (obfd
);
612 for (i
= LEAST_KNOWN_OBJ_ATTRIBUTE
; i
< NUM_KNOWN_OBJ_ATTRIBUTES
; i
++)
614 /* Merge this attribute with existing attributes. */
617 case Tag_ARC_PCS_config
:
618 if (out_attr
[i
].i
== 0)
619 out_attr
[i
].i
= in_attr
[i
].i
;
620 else if (in_attr
[i
].i
!= 0 && out_attr
[i
].i
!= in_attr
[i
].i
)
622 const char *tagval
[] = { "Absent", "Bare-metal/mwdt",
623 "Bare-metal/newlib", "Linux/uclibc",
625 BFD_ASSERT (in_attr
[i
].i
< 5);
626 BFD_ASSERT (out_attr
[i
].i
< 5);
627 /* It's sometimes ok to mix different configs, so this is only
630 (_("warning: %pB: conflicting platform configuration "
632 tagval
[in_attr
[i
].i
],
633 tagval
[out_attr
[i
].i
]);
637 case Tag_ARC_CPU_base
:
638 if (out_attr
[i
].i
== 0)
639 out_attr
[i
].i
= in_attr
[i
].i
;
640 else if (in_attr
[i
].i
!= 0 && out_attr
[i
].i
!= in_attr
[i
].i
641 && ((out_attr
[i
].i
+ in_attr
[i
].i
) < 6))
643 const char *tagval
[] = { "Absent", "ARC6xx", "ARC7xx",
645 BFD_ASSERT (in_attr
[i
].i
< 5);
646 BFD_ASSERT (out_attr
[i
].i
< 5);
647 /* We cannot mix code for different CPUs. */
649 (_("error: %pB: unable to merge CPU base attributes "
652 tagval
[in_attr
[i
].i
],
653 tagval
[out_attr
[i
].i
]);
659 /* The CPUs may be different, check if we can still mix
660 the objects against the output choosen CPU. */
661 unsigned in_feature
= 0;
662 unsigned out_feature
= 0;
663 char *p1
= in_attr
[Tag_ARC_ISA_config
].s
;
664 char *p2
= out_attr
[Tag_ARC_ISA_config
].s
;
667 unsigned opcode_map
[] = {0, ARC_OPCODE_ARC600
, ARC_OPCODE_ARC700
,
668 ARC_OPCODE_ARCv2EM
, ARC_OPCODE_ARCv2HS
};
670 BFD_ASSERT (in_attr
[i
].i
< (sizeof (opcode_map
)
671 / sizeof (unsigned)));
672 BFD_ASSERT (out_attr
[i
].i
< (sizeof (opcode_map
)
673 / sizeof (unsigned)));
674 cpu_out
= opcode_map
[out_attr
[i
].i
];
676 in_feature
= arc_extract_features (p1
);
677 out_feature
= arc_extract_features (p2
);
679 /* First, check if a feature is compatible with the
680 output object chosen CPU. */
681 for (j
= 0; j
< ARRAY_SIZE (bfd_feature_list
); j
++)
682 if (((in_feature
| out_feature
) & bfd_feature_list
[j
].feature
)
683 && (!(cpu_out
& bfd_feature_list
[j
].cpus
)))
686 (_("error: %pB: unable to merge ISA extension attributes "
688 obfd
, bfd_feature_list
[j
].name
);
692 /* Second, if we have compatible features with the
693 chosen CPU, check if they are compatible among
695 for (j
= 0; j
< ARRAY_SIZE (bfd_conflict_list
); j
++)
696 if (((in_feature
| out_feature
) & bfd_conflict_list
[j
])
697 == bfd_conflict_list
[j
])
700 for (k
= 0; k
< ARRAY_SIZE (bfd_feature_list
); k
++)
702 if (in_feature
& bfd_feature_list
[k
].feature
703 & bfd_conflict_list
[j
])
704 p1
= (char *) bfd_feature_list
[k
].name
;
705 if (out_feature
& bfd_feature_list
[k
].feature
706 & bfd_conflict_list
[j
])
707 p2
= (char *) bfd_feature_list
[k
].name
;
710 (_("error: %pB: conflicting ISA extension attributes "
716 /* Everithing is alright. */
717 out_feature
|= in_feature
;
719 for (j
= 0; j
< ARRAY_SIZE (bfd_feature_list
); j
++)
720 if (out_feature
& bfd_feature_list
[j
].feature
)
721 p1
= arc_stralloc (p1
, bfd_feature_list
[j
].attr
);
723 out_attr
[Tag_ARC_ISA_config
].s
=
724 _bfd_elf_attr_strdup (obfd
, p1
);
727 case Tag_ARC_CPU_variation
:
728 case Tag_ARC_ISA_mpy_option
:
729 case Tag_ARC_ABI_osver
:
730 /* Use the largest value specified. */
731 if (in_attr
[i
].i
> out_attr
[i
].i
)
732 out_attr
[i
].i
= in_attr
[i
].i
;
735 case Tag_ARC_CPU_name
:
738 case Tag_ARC_ABI_rf16
:
739 if (out_attr
[i
].i
== 0)
740 out_attr
[i
].i
= in_attr
[i
].i
;
741 else if (out_attr
[i
].i
!= in_attr
[i
].i
)
743 /* We cannot mix code with rf16 and without. */
745 (_("error: %pB: cannot mix rf16 with full register set %pB"),
751 case Tag_ARC_ABI_pic
:
754 case Tag_ARC_ABI_sda
:
758 case Tag_ARC_ABI_tls
:
760 const char *tagval
[] = { "Absent", "MWDT", "GNU" };
765 BFD_ASSERT (in_attr
[i
].i
< 3);
766 BFD_ASSERT (out_attr
[i
].i
< 3);
767 if (out_attr
[i
].i
!= 0 && in_attr
[i
].i
!= 0
768 && out_attr
[i
].i
!= in_attr
[i
].i
)
771 (_("error: %pB: conflicting attributes %s: %s with %s"),
773 tagval
[in_attr
[i
].i
],
774 tagval
[out_attr
[i
].i
]);
781 case Tag_ARC_ABI_double_size
:
782 tagname
= "Double size";
784 case Tag_ARC_ABI_enumsize
:
786 tagname
= "Enum size";
788 case Tag_ARC_ABI_exceptions
:
790 tagname
= "ABI exceptions";
792 if (out_attr
[i
].i
!= 0 && in_attr
[i
].i
!= 0
793 && out_attr
[i
].i
!= in_attr
[i
].i
)
796 (_("error: %pB: conflicting attributes %s"),
802 case Tag_ARC_ISA_apex
:
803 break; /* Do nothing for APEX attributes. */
805 case Tag_ARC_ISA_config
:
806 /* It is handled in Tag_ARC_CPU_base. */
809 case Tag_ARC_ATR_version
:
810 if (out_attr
[i
].i
== 0)
811 out_attr
[i
].i
= in_attr
[i
].i
;
816 = result
&& _bfd_elf_merge_unknown_attribute_low (ibfd
, obfd
, i
);
819 /* If out_attr was copied from in_attr then it won't have a type yet. */
820 if (in_attr
[i
].type
&& !out_attr
[i
].type
)
821 out_attr
[i
].type
= in_attr
[i
].type
;
824 /* Merge Tag_compatibility attributes and any common GNU ones. */
825 if (!_bfd_elf_merge_object_attributes (ibfd
, info
))
828 /* Check for any attributes not known on ARC. */
829 result
&= _bfd_elf_merge_unknown_attribute_list (ibfd
, obfd
);
834 /* Merge backend specific data from an object file to the output
835 object file when linking. */
838 arc_elf_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
840 bfd
*obfd
= info
->output_bfd
;
841 unsigned short mach_ibfd
;
842 static unsigned short mach_obfd
= EM_NONE
;
847 /* Check if we have the same endianess. */
848 if (! _bfd_generic_verify_endian_match (ibfd
, info
))
851 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
852 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
855 /* Collect ELF flags. */
856 in_flags
= elf_elfheader (ibfd
)->e_flags
& EF_ARC_MACH_MSK
;
857 out_flags
= elf_elfheader (obfd
)->e_flags
& EF_ARC_MACH_MSK
;
859 if (!elf_flags_init (obfd
)) /* First call, no flags set. */
861 elf_flags_init (obfd
) = TRUE
;
862 out_flags
= in_flags
;
865 if (!arc_elf_merge_attributes (ibfd
, info
))
868 /* Check to see if the input BFD actually contains any sections. Do
869 not short-circuit dynamic objects; their section list may be
870 emptied by elf_link_add_object_symbols. */
871 if (!(ibfd
->flags
& DYNAMIC
))
873 bfd_boolean null_input_bfd
= TRUE
;
874 bfd_boolean only_data_sections
= TRUE
;
876 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
878 if ((bfd_get_section_flags (ibfd
, sec
)
879 & (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
880 == (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
881 only_data_sections
= FALSE
;
883 null_input_bfd
= FALSE
;
886 if (null_input_bfd
|| only_data_sections
)
890 /* Complain about various flag/architecture mismatches. */
891 mach_ibfd
= elf_elfheader (ibfd
)->e_machine
;
892 if (mach_obfd
== EM_NONE
)
894 mach_obfd
= mach_ibfd
;
898 if (mach_ibfd
!= mach_obfd
)
900 /* xgettext:c-format */
901 _bfd_error_handler (_("error: attempting to link %pB "
902 "with a binary %pB of different architecture"),
906 else if ((in_flags
!= out_flags
)
907 /* If we have object attributes, then we already
908 checked the objects compatibility, skip it. */
909 && !bfd_elf_get_obj_attr_int (ibfd
, OBJ_ATTR_PROC
,
912 /* Warn if different flags. */
914 /* xgettext:c-format */
915 (_("%pB: uses different e_flags (%#x) fields than "
916 "previous modules (%#x)"),
917 ibfd
, in_flags
, out_flags
);
918 if (in_flags
&& out_flags
)
920 /* MWDT doesnt set the eflags hence make sure we choose the
921 eflags set by gcc. */
922 in_flags
= in_flags
> out_flags
? in_flags
: out_flags
;
926 /* Everything is correct; don't change the output flags. */
927 in_flags
= out_flags
;
931 /* Update the flags. */
932 elf_elfheader (obfd
)->e_flags
= in_flags
;
934 if (bfd_get_mach (obfd
) < bfd_get_mach (ibfd
))
936 return bfd_set_arch_mach (obfd
, bfd_arch_arc
, bfd_get_mach (ibfd
));
942 /* Return a best guess for the machine number based on the attributes. */
945 bfd_arc_get_mach_from_attributes (bfd
* abfd
)
947 int arch
= bfd_elf_get_obj_attr_int (abfd
, OBJ_ATTR_PROC
, Tag_ARC_CPU_base
);
948 unsigned e_machine
= elf_elfheader (abfd
)->e_machine
;
953 return bfd_mach_arc_arc600
;
955 return bfd_mach_arc_arc700
;
958 return bfd_mach_arc_arcv2
;
962 return (e_machine
== EM_ARC_COMPACT
)
963 ? bfd_mach_arc_arc700
: bfd_mach_arc_arcv2
;
966 /* Set the right machine number for an ARC ELF file. */
968 arc_elf_object_p (bfd
* abfd
)
970 /* Make sure this is initialised, or you'll have the potential of passing
971 garbage---or misleading values---into the call to
972 bfd_default_set_arch_mach (). */
973 unsigned int mach
= bfd_mach_arc_arc700
;
974 unsigned long arch
= elf_elfheader (abfd
)->e_flags
& EF_ARC_MACH_MSK
;
975 unsigned e_machine
= elf_elfheader (abfd
)->e_machine
;
977 if (e_machine
== EM_ARC_COMPACT
|| e_machine
== EM_ARC_COMPACT2
)
981 case E_ARC_MACH_ARC600
:
982 mach
= bfd_mach_arc_arc600
;
984 case E_ARC_MACH_ARC601
:
985 mach
= bfd_mach_arc_arc601
;
987 case E_ARC_MACH_ARC700
:
988 mach
= bfd_mach_arc_arc700
;
990 case EF_ARC_CPU_ARCV2HS
:
991 case EF_ARC_CPU_ARCV2EM
:
992 mach
= bfd_mach_arc_arcv2
;
995 mach
= bfd_arc_get_mach_from_attributes (abfd
);
1001 if (e_machine
== EM_ARC
)
1004 (_("error: the ARC4 architecture is no longer supported"));
1010 (_("warning: unset or old architecture flags; "
1011 "use default machine"));
1015 return bfd_default_set_arch_mach (abfd
, bfd_arch_arc
, mach
);
1018 /* The final processing done just before writing out an ARC ELF object file.
1019 This gets the ARC architecture right based on the machine number. */
1022 arc_elf_final_write_processing (bfd
* abfd
,
1023 bfd_boolean linker ATTRIBUTE_UNUSED
)
1026 int osver
= bfd_elf_get_obj_attr_int (abfd
, OBJ_ATTR_PROC
,
1028 flagword e_flags
= elf_elfheader (abfd
)->e_flags
& ~EF_ARC_OSABI_MSK
;
1030 switch (bfd_get_mach (abfd
))
1032 case bfd_mach_arc_arc600
:
1033 emf
= EM_ARC_COMPACT
;
1035 case bfd_mach_arc_arc601
:
1036 emf
= EM_ARC_COMPACT
;
1038 case bfd_mach_arc_arc700
:
1039 emf
= EM_ARC_COMPACT
;
1041 case bfd_mach_arc_arcv2
:
1042 emf
= EM_ARC_COMPACT2
;
1048 elf_elfheader (abfd
)->e_machine
= emf
;
1050 /* Record whatever is the current syscall ABI version. */
1052 e_flags
|= ((osver
& 0x0f) << 8);
1054 e_flags
|= E_ARC_OSABI_V3
;
1056 elf_elfheader (abfd
)->e_flags
|= e_flags
;
1059 #ifdef ARC_ENABLE_DEBUG
1060 #define DEBUG_ARC_RELOC(A) debug_arc_reloc (A)
1063 debug_arc_reloc (struct arc_relocation_data reloc_data
)
1065 ARC_DEBUG ("Reloc type=%s, should_relocate = %s\n",
1066 reloc_data
.howto
->name
,
1067 reloc_data
.should_relocate
? "true" : "false");
1068 ARC_DEBUG (" offset = 0x%x, addend = 0x%x\n",
1069 (unsigned int) reloc_data
.reloc_offset
,
1070 (unsigned int) reloc_data
.reloc_addend
);
1071 ARC_DEBUG (" Symbol:\n");
1072 ARC_DEBUG (" value = 0x%08x\n",
1073 (unsigned int) reloc_data
.sym_value
);
1074 if (reloc_data
.sym_section
!= NULL
)
1076 ARC_DEBUG (" Symbol Section:\n");
1077 ARC_DEBUG (" section name = %s, output_offset 0x%08x",
1078 reloc_data
.sym_section
->name
,
1079 (unsigned int) reloc_data
.sym_section
->output_offset
);
1080 if (reloc_data
.sym_section
->output_section
!= NULL
)
1081 ARC_DEBUG (", output_section->vma = 0x%08x",
1082 ((unsigned int) reloc_data
.sym_section
->output_section
->vma
));
1084 if (reloc_data
.sym_section
->owner
&& reloc_data
.sym_section
->owner
->filename
)
1085 ARC_DEBUG (" file: %s\n", reloc_data
.sym_section
->owner
->filename
);
1089 ARC_DEBUG (" symbol section is NULL\n");
1092 ARC_DEBUG (" Input_section:\n");
1093 if (reloc_data
.input_section
!= NULL
)
1095 ARC_DEBUG (" section name = %s, output_offset 0x%08x, output_section->vma = 0x%08x\n",
1096 reloc_data
.input_section
->name
,
1097 (unsigned int) reloc_data
.input_section
->output_offset
,
1098 (unsigned int) reloc_data
.input_section
->output_section
->vma
);
1099 ARC_DEBUG (" changed_address = 0x%08x\n",
1100 (unsigned int) (reloc_data
.input_section
->output_section
->vma
1101 + reloc_data
.input_section
->output_offset
1102 + reloc_data
.reloc_offset
));
1103 ARC_DEBUG (" file: %s\n", reloc_data
.input_section
->owner
->filename
);
1107 ARC_DEBUG (" input section is NULL\n");
1111 #define DEBUG_ARC_RELOC(A)
1112 #endif /* ARC_ENABLE_DEBUG */
1115 middle_endian_convert (bfd_vma insn
, bfd_boolean do_it
)
1120 = ((insn
& 0xffff0000) >> 16)
1121 | ((insn
& 0xffff) << 16);
1126 /* This function is called for relocations that are otherwise marked as NOT
1127 requiring overflow checks. In here we perform non-standard checks of
1128 the relocation value. */
1130 static inline bfd_reloc_status_type
1131 arc_special_overflow_checks (const struct arc_relocation_data reloc_data
,
1132 bfd_signed_vma relocation
,
1133 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1135 switch (reloc_data
.howto
->type
)
1137 case R_ARC_NPS_CMEM16
:
1138 if (((relocation
>> 16) & 0xffff) != NPS_CMEM_HIGH_VALUE
)
1140 if (reloc_data
.reloc_addend
== 0)
1142 /* xgettext:c-format */
1143 (_("%pB(%pA+%#" PRIx64
"): CMEM relocation to `%s' is invalid, "
1144 "16 MSB should be %#x (value is %#" PRIx64
")"),
1145 reloc_data
.input_section
->owner
,
1146 reloc_data
.input_section
,
1147 (uint64_t) reloc_data
.reloc_offset
,
1148 reloc_data
.symbol_name
,
1149 NPS_CMEM_HIGH_VALUE
,
1150 (uint64_t) relocation
);
1153 /* xgettext:c-format */
1154 (_("%pB(%pA+%#" PRIx64
"): CMEM relocation to `%s+%#" PRIx64
1155 "' is invalid, 16 MSB should be %#x (value is %#" PRIx64
")"),
1156 reloc_data
.input_section
->owner
,
1157 reloc_data
.input_section
,
1158 (uint64_t) reloc_data
.reloc_offset
,
1159 reloc_data
.symbol_name
,
1160 (uint64_t) reloc_data
.reloc_addend
,
1161 NPS_CMEM_HIGH_VALUE
,
1162 (uint64_t) relocation
);
1163 return bfd_reloc_overflow
;
1171 return bfd_reloc_ok
;
1174 #define ME(reloc) (reloc)
1176 #define IS_ME(FORMULA,BFD) ((strstr (FORMULA, "ME") != NULL) \
1177 && (!bfd_big_endian (BFD)))
1179 #define S ((bfd_signed_vma) (reloc_data.sym_value \
1180 + (reloc_data.sym_section->output_section != NULL ? \
1181 (reloc_data.sym_section->output_offset \
1182 + reloc_data.sym_section->output_section->vma) : 0)))
1183 #define L ((bfd_signed_vma) (reloc_data.sym_value \
1184 + (reloc_data.sym_section->output_section != NULL ? \
1185 (reloc_data.sym_section->output_offset \
1186 + reloc_data.sym_section->output_section->vma) : 0)))
1187 #define A (reloc_data.reloc_addend)
1189 #define G (reloc_data.got_offset_value)
1190 #define GOT (reloc_data.got_symbol_vma)
1191 #define GOT_BEGIN (htab->sgot->output_section->vma)
1194 /* P: relative offset to PCL The offset should be to the
1195 current location aligned to 32 bits. */
1196 #define P ((bfd_signed_vma) ( \
1198 (reloc_data.input_section->output_section != NULL ? \
1199 reloc_data.input_section->output_section->vma : 0) \
1200 + reloc_data.input_section->output_offset \
1201 + (reloc_data.reloc_offset - (bitsize >= 32 ? 4 : 0))) \
1203 #define PDATA ((bfd_signed_vma) ( \
1204 (reloc_data.input_section->output_section->vma \
1205 + reloc_data.input_section->output_offset \
1206 + (reloc_data.reloc_offset))))
1207 #define SECTSTART (bfd_signed_vma) (reloc_data.sym_section->output_section->vma \
1208 + reloc_data.sym_section->output_offset)
1209 #define JLI (bfd_signed_vma) (reloc_data.sym_section->output_section->vma)
1210 #define _SDA_BASE_ (bfd_signed_vma) (reloc_data.sdata_begin_symbol_vma)
1211 #define TLS_REL (bfd_signed_vma) \
1212 ((elf_hash_table (info))->tls_sec->output_section->vma)
1213 #define TLS_TBSS (8)
1217 #ifdef ARC_ENABLE_DEBUG
1218 #define PRINT_DEBUG_RELOC_INFO_BEFORE(FORMULA, TYPE) \
1221 asection *sym_section = reloc_data.sym_section; \
1222 asection *input_section = reloc_data.input_section; \
1223 ARC_DEBUG ("RELOC_TYPE = " TYPE "\n"); \
1224 ARC_DEBUG ("FORMULA = " FORMULA "\n"); \
1225 ARC_DEBUG ("S = %#lx\n", S); \
1226 ARC_DEBUG ("A = %#lx\n", A); \
1227 ARC_DEBUG ("L = %lx\n", L); \
1228 if (sym_section->output_section != NULL) \
1229 ARC_DEBUG ("symbol_section->vma = %#lx\n", \
1230 sym_section->output_section->vma \
1231 + sym_section->output_offset); \
1233 ARC_DEBUG ("symbol_section->vma = NULL\n"); \
1234 if (input_section->output_section != NULL) \
1235 ARC_DEBUG ("symbol_section->vma = %#lx\n", \
1236 input_section->output_section->vma \
1237 + input_section->output_offset); \
1239 ARC_DEBUG ("symbol_section->vma = NULL\n"); \
1240 ARC_DEBUG ("PCL = %#lx\n", P); \
1241 ARC_DEBUG ("P = %#lx\n", P); \
1242 ARC_DEBUG ("G = %#lx\n", G); \
1243 ARC_DEBUG ("SDA_OFFSET = %#lx\n", _SDA_BASE_); \
1244 ARC_DEBUG ("SDA_SET = %d\n", reloc_data.sdata_begin_symbol_vma_set); \
1245 ARC_DEBUG ("GOT_OFFSET = %#lx\n", GOT); \
1246 ARC_DEBUG ("relocation = %#08lx\n", relocation); \
1247 ARC_DEBUG ("before = %#08x\n", (unsigned) insn); \
1248 ARC_DEBUG ("data = %08x (%u) (%d)\n", (unsigned) relocation, \
1249 (unsigned) relocation, (int) relocation); \
1253 #define PRINT_DEBUG_RELOC_INFO_AFTER \
1256 ARC_DEBUG ("after = 0x%08x\n", (unsigned int) insn); \
1262 #define PRINT_DEBUG_RELOC_INFO_BEFORE(...)
1263 #define PRINT_DEBUG_RELOC_INFO_AFTER
1265 #endif /* ARC_ENABLE_DEBUG */
1267 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
1270 bfd_signed_vma bitsize ATTRIBUTE_UNUSED = BITSIZE; \
1271 relocation = FORMULA ; \
1272 PRINT_DEBUG_RELOC_INFO_BEFORE (#FORMULA, #TYPE); \
1273 insn = middle_endian_convert (insn, IS_ME (#FORMULA, abfd)); \
1274 insn = (* get_replace_function (abfd, TYPE)) (insn, relocation); \
1275 insn = middle_endian_convert (insn, IS_ME (#FORMULA, abfd)); \
1276 PRINT_DEBUG_RELOC_INFO_AFTER; \
1280 static bfd_reloc_status_type
1281 arc_do_relocation (bfd_byte
* contents
,
1282 struct arc_relocation_data reloc_data
,
1283 struct bfd_link_info
*info
)
1285 bfd_signed_vma relocation
= 0;
1287 bfd_vma orig_insn ATTRIBUTE_UNUSED
;
1288 bfd
* abfd
= reloc_data
.input_section
->owner
;
1289 struct elf_link_hash_table
*htab ATTRIBUTE_UNUSED
= elf_hash_table (info
);
1290 bfd_reloc_status_type flag
;
1292 if (!reloc_data
.should_relocate
)
1293 return bfd_reloc_ok
;
1295 switch (reloc_data
.howto
->size
)
1298 insn
= arc_bfd_get_32 (abfd
,
1299 contents
+ reloc_data
.reloc_offset
,
1300 reloc_data
.input_section
);
1303 insn
= arc_bfd_get_16 (abfd
,
1304 contents
+ reloc_data
.reloc_offset
,
1305 reloc_data
.input_section
);
1308 insn
= arc_bfd_get_8 (abfd
,
1309 contents
+ reloc_data
.reloc_offset
,
1310 reloc_data
.input_section
);
1320 switch (reloc_data
.howto
->type
)
1322 #include "elf/arc-reloc.def"
1329 /* Check for relocation overflow. */
1330 if (reloc_data
.howto
->complain_on_overflow
!= complain_overflow_dont
)
1331 flag
= bfd_check_overflow (reloc_data
.howto
->complain_on_overflow
,
1332 reloc_data
.howto
->bitsize
,
1333 reloc_data
.howto
->rightshift
,
1334 bfd_arch_bits_per_address (abfd
),
1337 flag
= arc_special_overflow_checks (reloc_data
, relocation
, info
);
1339 if (flag
!= bfd_reloc_ok
)
1341 ARC_DEBUG ("Relocation overflows !\n");
1342 DEBUG_ARC_RELOC (reloc_data
);
1343 ARC_DEBUG ("Relocation value = signed -> %d, unsigned -> %u"
1344 ", hex -> (0x%08x)\n",
1345 (int) relocation
, (unsigned) relocation
, (int) relocation
);
1350 /* Write updated instruction back to memory. */
1351 switch (reloc_data
.howto
->size
)
1354 arc_bfd_put_32 (abfd
, insn
,
1355 contents
+ reloc_data
.reloc_offset
,
1356 reloc_data
.input_section
);
1359 arc_bfd_put_16 (abfd
, insn
,
1360 contents
+ reloc_data
.reloc_offset
,
1361 reloc_data
.input_section
);
1364 arc_bfd_put_8 (abfd
, insn
,
1365 contents
+ reloc_data
.reloc_offset
,
1366 reloc_data
.input_section
);
1369 ARC_DEBUG ("size = %d\n", reloc_data
.howto
->size
);
1374 return bfd_reloc_ok
;
1390 #undef ARC_RELOC_HOWTO
1393 /* Relocate an arc ELF section.
1394 Function : elf_arc_relocate_section
1395 Brief : Relocate an arc section, by handling all the relocations
1396 appearing in that section.
1397 Args : output_bfd : The bfd being written to.
1398 info : Link information.
1399 input_bfd : The input bfd.
1400 input_section : The section being relocated.
1401 contents : contents of the section being relocated.
1402 relocs : List of relocations in the section.
1403 local_syms : is a pointer to the swapped in local symbols.
1404 local_section : is an array giving the section in the input file
1405 corresponding to the st_shndx field of each
1408 elf_arc_relocate_section (bfd
* output_bfd
,
1409 struct bfd_link_info
* info
,
1411 asection
* input_section
,
1412 bfd_byte
* contents
,
1413 Elf_Internal_Rela
* relocs
,
1414 Elf_Internal_Sym
* local_syms
,
1415 asection
** local_sections
)
1417 Elf_Internal_Shdr
* symtab_hdr
;
1418 struct elf_link_hash_entry
** sym_hashes
;
1419 Elf_Internal_Rela
* rel
;
1420 Elf_Internal_Rela
* wrel
;
1421 Elf_Internal_Rela
* relend
;
1422 struct elf_link_hash_table
* htab
= elf_hash_table (info
);
1424 symtab_hdr
= &((elf_tdata (input_bfd
))->symtab_hdr
);
1425 sym_hashes
= elf_sym_hashes (input_bfd
);
1427 rel
= wrel
= relocs
;
1428 relend
= relocs
+ input_section
->reloc_count
;
1429 for (; rel
< relend
; wrel
++, rel
++)
1431 enum elf_arc_reloc_type r_type
;
1432 reloc_howto_type
* howto
;
1433 unsigned long r_symndx
;
1434 struct elf_link_hash_entry
* h
;
1435 Elf_Internal_Sym
* sym
;
1437 struct elf_link_hash_entry
* h2
;
1439 bfd_boolean unresolved_reloc
= FALSE
;
1441 struct arc_relocation_data reloc_data
=
1445 .got_offset_value
= 0,
1447 .sym_section
= NULL
,
1449 .input_section
= NULL
,
1450 .sdata_begin_symbol_vma
= 0,
1451 .sdata_begin_symbol_vma_set
= FALSE
,
1452 .got_symbol_vma
= 0,
1453 .should_relocate
= FALSE
1456 r_type
= ELF32_R_TYPE (rel
->r_info
);
1458 if (r_type
>= (int) R_ARC_max
)
1460 bfd_set_error (bfd_error_bad_value
);
1463 howto
= arc_elf_howto (r_type
);
1465 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1467 /* If we are generating another .o file and the symbol in not
1468 local, skip this relocation. */
1469 if (bfd_link_relocatable (info
))
1471 /* This is a relocateable link. We don't have to change
1472 anything, unless the reloc is against a section symbol,
1473 in which case we have to adjust according to where the
1474 section symbol winds up in the output section. */
1476 /* Checks if this is a local symbol and thus the reloc
1477 might (will??) be against a section symbol. */
1478 if (r_symndx
< symtab_hdr
->sh_info
)
1480 sym
= local_syms
+ r_symndx
;
1481 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1483 sec
= local_sections
[r_symndx
];
1485 /* For RELA relocs. Just adjust the addend
1486 value in the relocation entry. */
1487 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
1489 ARC_DEBUG ("local symbols reloc (section=%d %s) seen in %s\n",
1490 (int) r_symndx
, local_sections
[r_symndx
]->name
,
1491 __PRETTY_FUNCTION__
);
1496 h2
= elf_link_hash_lookup (elf_hash_table (info
), "__SDATA_BEGIN__",
1497 FALSE
, FALSE
, TRUE
);
1499 if (!reloc_data
.sdata_begin_symbol_vma_set
1500 && h2
!= NULL
&& h2
->root
.type
!= bfd_link_hash_undefined
1501 && h2
->root
.u
.def
.section
->output_section
!= NULL
)
1502 /* TODO: Verify this condition. */
1504 reloc_data
.sdata_begin_symbol_vma
=
1505 (h2
->root
.u
.def
.value
1506 + h2
->root
.u
.def
.section
->output_section
->vma
);
1507 reloc_data
.sdata_begin_symbol_vma_set
= TRUE
;
1510 reloc_data
.input_section
= input_section
;
1511 reloc_data
.howto
= howto
;
1512 reloc_data
.reloc_offset
= rel
->r_offset
;
1513 reloc_data
.reloc_addend
= rel
->r_addend
;
1515 /* This is a final link. */
1520 if (r_symndx
< symtab_hdr
->sh_info
) /* A local symbol. */
1522 sym
= local_syms
+ r_symndx
;
1523 sec
= local_sections
[r_symndx
];
1527 bfd_boolean warned
, ignored
;
1528 bfd_vma relocation ATTRIBUTE_UNUSED
;
1530 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
1531 r_symndx
, symtab_hdr
, sym_hashes
,
1533 unresolved_reloc
, warned
, ignored
);
1535 /* TODO: This code is repeated from below. We should
1536 clean it and remove duplications.
1537 Sec is used check for discarded sections.
1538 Need to redesign code below. */
1540 /* Get the symbol's entry in the symtab. */
1541 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1543 while (h
->root
.type
== bfd_link_hash_indirect
1544 || h
->root
.type
== bfd_link_hash_warning
)
1545 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1547 /* If we have encountered a definition for this symbol. */
1548 if (h
->root
.type
== bfd_link_hash_defined
1549 || h
->root
.type
== bfd_link_hash_defweak
)
1551 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1552 sec
= h
->root
.u
.def
.section
;
1556 /* Clean relocs for symbols in discarded sections. */
1557 if (sec
!= NULL
&& discarded_section (sec
))
1559 _bfd_clear_contents (howto
, input_bfd
, input_section
,
1560 contents
+ rel
->r_offset
);
1564 /* For ld -r, remove relocations in debug sections against
1565 sections defined in discarded sections. Not done for
1566 eh_frame editing code expects to be present. */
1567 if (bfd_link_relocatable (info
)
1568 && (input_section
->flags
& SEC_DEBUGGING
))
1574 if (bfd_link_relocatable (info
))
1581 if (r_symndx
< symtab_hdr
->sh_info
) /* A local symbol. */
1583 reloc_data
.sym_value
= sym
->st_value
;
1584 reloc_data
.sym_section
= sec
;
1585 reloc_data
.symbol_name
=
1586 bfd_elf_string_from_elf_section (input_bfd
,
1587 symtab_hdr
->sh_link
,
1590 /* Mergeable section handling. */
1591 if ((sec
->flags
& SEC_MERGE
)
1592 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1596 rel
->r_addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
,
1597 &msec
, rel
->r_addend
);
1598 rel
->r_addend
-= (sec
->output_section
->vma
1599 + sec
->output_offset
1601 rel
->r_addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
1603 reloc_data
.reloc_addend
= rel
->r_addend
;
1606 BFD_ASSERT (htab
->sgot
!= NULL
|| !is_reloc_for_GOT (howto
));
1607 if (htab
->sgot
!= NULL
)
1608 reloc_data
.got_symbol_vma
= htab
->sgot
->output_section
->vma
1609 + htab
->sgot
->output_offset
;
1611 reloc_data
.should_relocate
= TRUE
;
1613 else /* Global symbol. */
1615 /* FIXME: We should use the RELOC_FOR_GLOBAL_SYMBOL macro
1616 (defined in elf-bfd.h) here. */
1618 /* Get the symbol's entry in the symtab. */
1619 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1621 while (h
->root
.type
== bfd_link_hash_indirect
1622 || h
->root
.type
== bfd_link_hash_warning
)
1624 struct elf_link_hash_entry
*h_old
= h
;
1625 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1626 if (h
->got
.glist
== 0 && h_old
->got
.glist
!= h
->got
.glist
)
1627 h
->got
.glist
= h_old
->got
.glist
;
1630 /* TODO: Need to validate what was the intention. */
1631 /* BFD_ASSERT ((h->dynindx == -1) || (h->forced_local != 0)); */
1632 reloc_data
.symbol_name
= h
->root
.root
.string
;
1634 /* If we have encountered a definition for this symbol. */
1635 if (h
->root
.type
== bfd_link_hash_defined
1636 || h
->root
.type
== bfd_link_hash_defweak
)
1638 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1639 reloc_data
.sym_section
= h
->root
.u
.def
.section
;
1641 reloc_data
.should_relocate
= TRUE
;
1643 if (is_reloc_for_GOT (howto
) && !bfd_link_pic (info
))
1645 /* TODO: Change it to use arc_do_relocation with
1646 ARC_32 reloc. Try to use ADD_RELA macro. */
1647 bfd_vma relocation
=
1648 reloc_data
.sym_value
+ reloc_data
.reloc_addend
1649 + (reloc_data
.sym_section
->output_section
!= NULL
?
1650 (reloc_data
.sym_section
->output_offset
1651 + reloc_data
.sym_section
->output_section
->vma
)
1654 BFD_ASSERT (h
->got
.glist
);
1655 bfd_vma got_offset
= h
->got
.glist
->offset
;
1656 bfd_put_32 (output_bfd
, relocation
,
1657 htab
->sgot
->contents
+ got_offset
);
1659 if (is_reloc_for_PLT (howto
) && h
->plt
.offset
!= (bfd_vma
) -1)
1661 /* TODO: This is repeated up here. */
1662 reloc_data
.sym_value
= h
->plt
.offset
;
1663 reloc_data
.sym_section
= htab
->splt
;
1666 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1668 /* Is weak symbol and has no definition. */
1669 if (is_reloc_for_GOT (howto
))
1671 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1672 reloc_data
.sym_section
= htab
->sgot
;
1673 reloc_data
.should_relocate
= TRUE
;
1675 else if (is_reloc_for_PLT (howto
)
1676 && h
->plt
.offset
!= (bfd_vma
) -1)
1678 /* TODO: This is repeated up here. */
1679 reloc_data
.sym_value
= h
->plt
.offset
;
1680 reloc_data
.sym_section
= htab
->splt
;
1681 reloc_data
.should_relocate
= TRUE
;
1688 if (is_reloc_for_GOT (howto
))
1690 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1691 reloc_data
.sym_section
= htab
->sgot
;
1693 reloc_data
.should_relocate
= TRUE
;
1695 else if (is_reloc_for_PLT (howto
))
1697 /* Fail if it is linking for PIE and the symbol is
1699 if (bfd_link_executable (info
))
1700 (*info
->callbacks
->undefined_symbol
)
1701 (info
, h
->root
.root
.string
, input_bfd
, input_section
,
1702 rel
->r_offset
, TRUE
);
1703 reloc_data
.sym_value
= h
->plt
.offset
;
1704 reloc_data
.sym_section
= htab
->splt
;
1706 reloc_data
.should_relocate
= TRUE
;
1708 else if (!bfd_link_pic (info
) || bfd_link_executable (info
))
1709 (*info
->callbacks
->undefined_symbol
)
1710 (info
, h
->root
.root
.string
, input_bfd
, input_section
,
1711 rel
->r_offset
, TRUE
);
1714 BFD_ASSERT (htab
->sgot
!= NULL
|| !is_reloc_for_GOT (howto
));
1715 if (htab
->sgot
!= NULL
)
1716 reloc_data
.got_symbol_vma
= htab
->sgot
->output_section
->vma
1717 + htab
->sgot
->output_offset
;
1720 if ((is_reloc_for_GOT (howto
)
1721 || is_reloc_for_TLS (howto
)))
1723 reloc_data
.should_relocate
= TRUE
;
1725 struct got_entry
**list
1726 = get_got_entry_list_for_symbol (output_bfd
, r_symndx
, h
);
1728 reloc_data
.got_offset_value
1729 = relocate_fix_got_relocs_for_got_info (list
,
1730 tls_type_for_reloc (howto
),
1741 create_got_dynrelocs_for_single_entry (
1742 got_entry_for_type (list
,
1743 arc_got_entry_type_for_reloc (howto
)),
1744 output_bfd
, info
, NULL
);
1749 #define IS_ARC_PCREL_TYPE(TYPE) \
1750 ( (TYPE == R_ARC_PC32) \
1751 || (TYPE == R_ARC_32_PCREL))
1758 case R_ARC_32_PCREL
:
1759 if (bfd_link_pic (info
)
1760 && (!IS_ARC_PCREL_TYPE (r_type
)
1764 && (!info
->symbolic
|| !h
->def_regular
))))
1766 Elf_Internal_Rela outrel
;
1768 bfd_boolean skip
= FALSE
;
1769 bfd_boolean relocate
= FALSE
;
1770 asection
*sreloc
= _bfd_elf_get_dynamic_reloc_section
1771 (input_bfd
, input_section
,
1774 BFD_ASSERT (sreloc
!= NULL
);
1776 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
1781 if (outrel
.r_offset
== (bfd_vma
) -1)
1784 outrel
.r_addend
= rel
->r_addend
;
1785 outrel
.r_offset
+= (input_section
->output_section
->vma
1786 + input_section
->output_offset
);
1790 memset (&outrel
, 0, sizeof outrel
);
1795 && (IS_ARC_PCREL_TYPE (r_type
)
1796 || !(bfd_link_executable (info
)
1797 || SYMBOLIC_BIND (info
, h
))
1798 || ! h
->def_regular
))
1800 BFD_ASSERT (h
!= NULL
);
1801 if ((input_section
->flags
& SEC_ALLOC
) != 0)
1806 BFD_ASSERT (h
->dynindx
!= -1);
1807 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
1811 /* Handle local symbols, they either do not have a
1812 global hash table entry (h == NULL), or are
1813 forced local due to a version script
1814 (h->forced_local), or the third condition is
1815 legacy, it appears to say something like, for
1816 links where we are pre-binding the symbols, or
1817 there's not an entry for this symbol in the
1818 dynamic symbol table, and it's a regular symbol
1819 not defined in a shared object, then treat the
1820 symbol as local, resolve it now. */
1822 /* outrel.r_addend = 0; */
1823 outrel
.r_info
= ELF32_R_INFO (0, R_ARC_RELATIVE
);
1826 BFD_ASSERT (sreloc
->contents
!= 0);
1828 loc
= sreloc
->contents
;
1829 loc
+= sreloc
->reloc_count
* sizeof (Elf32_External_Rela
);
1830 sreloc
->reloc_count
+= 1;
1832 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
1842 if (is_reloc_SDA_relative (howto
)
1843 && !reloc_data
.sdata_begin_symbol_vma_set
)
1846 ("error: linker symbol __SDATA_BEGIN__ not found");
1847 bfd_set_error (bfd_error_bad_value
);
1851 DEBUG_ARC_RELOC (reloc_data
);
1853 /* Make sure we have with a dynamic linker. In case of GOT and PLT
1854 the sym_section should point to .got or .plt respectively. */
1855 if ((is_reloc_for_GOT (howto
) || is_reloc_for_PLT (howto
))
1856 && reloc_data
.sym_section
== NULL
)
1859 (_("GOT and PLT relocations cannot be fixed with a non dynamic linker"));
1860 bfd_set_error (bfd_error_bad_value
);
1865 switch (arc_do_relocation (contents
, reloc_data
, info
))
1868 continue; /* The reloc processing loop. */
1870 case bfd_reloc_overflow
:
1871 (*info
->callbacks
->reloc_overflow
)
1872 (info
, (h
? &h
->root
: NULL
), reloc_data
.symbol_name
, howto
->name
, (bfd_vma
) 0,
1873 input_bfd
, input_section
, rel
->r_offset
);
1876 case bfd_reloc_undefined
:
1877 (*info
->callbacks
->undefined_symbol
)
1878 (info
, reloc_data
.symbol_name
, input_bfd
, input_section
, rel
->r_offset
, TRUE
);
1881 case bfd_reloc_other
:
1882 /* xgettext:c-format */
1883 msg
= _("%pB(%pA): warning: unaligned access to symbol '%s' in the small data area");
1886 case bfd_reloc_outofrange
:
1887 /* xgettext:c-format */
1888 msg
= _("%pB(%pA): internal error: out of range error");
1891 case bfd_reloc_notsupported
:
1892 /* xgettext:c-format */
1893 msg
= _("%pB(%pA): internal error: unsupported relocation error");
1896 case bfd_reloc_dangerous
:
1897 /* xgettext:c-format */
1898 msg
= _("%pB(%pA): internal error: dangerous relocation");
1902 /* xgettext:c-format */
1903 msg
= _("%pB(%pA): internal error: unknown error");
1908 _bfd_error_handler (msg
, input_bfd
, input_section
, reloc_data
.symbol_name
);
1915 #define elf_arc_hash_table(p) \
1916 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
1917 == ARC_ELF_DATA ? ((struct elf_arc_link_hash_table *) ((p)->hash)) : NULL)
1920 elf_arc_check_relocs (bfd
* abfd
,
1921 struct bfd_link_info
* info
,
1923 const Elf_Internal_Rela
* relocs
)
1925 Elf_Internal_Shdr
* symtab_hdr
;
1926 struct elf_link_hash_entry
** sym_hashes
;
1927 const Elf_Internal_Rela
* rel
;
1928 const Elf_Internal_Rela
* rel_end
;
1930 asection
* sreloc
= NULL
;
1931 struct elf_link_hash_table
* htab
= elf_hash_table (info
);
1933 if (bfd_link_relocatable (info
))
1936 if (htab
->dynobj
== NULL
)
1937 htab
->dynobj
= abfd
;
1939 dynobj
= (elf_hash_table (info
))->dynobj
;
1940 symtab_hdr
= &((elf_tdata (abfd
))->symtab_hdr
);
1941 sym_hashes
= elf_sym_hashes (abfd
);
1943 rel_end
= relocs
+ sec
->reloc_count
;
1944 for (rel
= relocs
; rel
< rel_end
; rel
++)
1946 enum elf_arc_reloc_type r_type
;
1947 reloc_howto_type
*howto
;
1948 unsigned long r_symndx
;
1949 struct elf_link_hash_entry
*h
;
1951 r_type
= ELF32_R_TYPE (rel
->r_info
);
1953 if (r_type
>= (int) R_ARC_max
)
1955 bfd_set_error (bfd_error_bad_value
);
1958 howto
= arc_elf_howto (r_type
);
1960 /* Load symbol information. */
1961 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1962 if (r_symndx
< symtab_hdr
->sh_info
) /* Is a local symbol. */
1964 else /* Global one. */
1965 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1971 /* During shared library creation, these relocs should not
1972 appear in a shared library (as memory will be read only
1973 and the dynamic linker can not resolve these. However
1974 the error should not occur for e.g. debugging or
1975 non-readonly sections. */
1977 && (bfd_link_dll (info
) && !bfd_link_pie (info
))
1978 && (sec
->flags
& SEC_ALLOC
) != 0
1979 && (sec
->flags
& SEC_READONLY
) != 0
1980 && ((sec
->flags
& SEC_CODE
) != 0
1981 || (sec
->flags
& SEC_DEBUGGING
) != 0))
1985 name
= h
->root
.root
.string
;
1987 /* bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL); */
1990 /* xgettext:c-format */
1991 (_("%pB: relocation %s against `%s' can not be used"
1992 " when making a shared object; recompile with -fPIC"),
1994 arc_elf_howto (r_type
)->name
,
1996 bfd_set_error (bfd_error_bad_value
);
2000 /* In some cases we are not setting the 'non_got_ref'
2001 flag, even though the relocations don't require a GOT
2002 access. We should extend the testing in this area to
2003 ensure that no significant cases are being missed. */
2008 case R_ARC_32_PCREL
:
2009 if ((bfd_link_pic (info
))
2010 && ((r_type
!= R_ARC_PC32
&& r_type
!= R_ARC_32_PCREL
)
2012 && (!info
->symbolic
|| !h
->def_regular
))))
2017 && ! htab
->dynamic_sections_created
2018 && ! _bfd_elf_link_create_dynamic_sections (abfd
, info
))
2020 sreloc
= _bfd_elf_make_dynamic_reloc_section (sec
, dynobj
,
2028 sreloc
->size
+= sizeof (Elf32_External_Rela
);
2035 if (is_reloc_for_PLT (howto
))
2043 /* Add info to the symbol got_entry_list. */
2044 if (is_reloc_for_GOT (howto
)
2045 || is_reloc_for_TLS (howto
))
2047 if (! _bfd_elf_create_got_section (dynobj
, info
))
2050 arc_fill_got_info_for_reloc (
2051 arc_got_entry_type_for_reloc (howto
),
2052 get_got_entry_list_for_symbol (abfd
, r_symndx
, h
),
2061 #define ELF_DYNAMIC_INTERPRETER "/sbin/ld-uClibc.so"
2063 static struct plt_version_t
*
2064 arc_get_plt_version (struct bfd_link_info
*info
)
2068 for (i
= 0; i
< 1; i
++)
2070 ARC_DEBUG ("%d: size1 = %d, size2 = %d\n", i
,
2071 (int) plt_versions
[i
].entry_size
,
2072 (int) plt_versions
[i
].elem_size
);
2075 if (bfd_get_mach (info
->output_bfd
) == bfd_mach_arc_arcv2
)
2077 if (bfd_link_pic (info
))
2078 return &(plt_versions
[ELF_ARCV2_PIC
]);
2080 return &(plt_versions
[ELF_ARCV2_ABS
]);
2084 if (bfd_link_pic (info
))
2085 return &(plt_versions
[ELF_ARC_PIC
]);
2087 return &(plt_versions
[ELF_ARC_ABS
]);
2092 add_symbol_to_plt (struct bfd_link_info
*info
)
2094 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2097 struct plt_version_t
*plt_data
= arc_get_plt_version (info
);
2099 /* If this is the first .plt entry, make room for the special first
2101 if (htab
->splt
->size
== 0)
2102 htab
->splt
->size
+= plt_data
->entry_size
;
2104 ret
= htab
->splt
->size
;
2106 htab
->splt
->size
+= plt_data
->elem_size
;
2107 ARC_DEBUG ("PLT_SIZE = %d\n", (int) htab
->splt
->size
);
2109 htab
->sgotplt
->size
+= 4;
2110 htab
->srelplt
->size
+= sizeof (Elf32_External_Rela
);
2115 #define PLT_DO_RELOCS_FOR_ENTRY(ABFD, DS, RELOCS) \
2116 plt_do_relocs_for_symbol (ABFD, DS, RELOCS, 0, 0)
2119 plt_do_relocs_for_symbol (bfd
*abfd
,
2120 struct elf_link_hash_table
*htab
,
2121 const struct plt_reloc
*reloc
,
2123 bfd_vma symbol_got_offset
)
2125 while (SYM_ONLY (reloc
->symbol
) != LAST_RELOC
)
2127 bfd_vma relocation
= 0;
2129 switch (SYM_ONLY (reloc
->symbol
))
2133 = htab
->sgotplt
->output_section
->vma
2134 + htab
->sgotplt
->output_offset
+ symbol_got_offset
;
2137 relocation
+= reloc
->addend
;
2139 if (IS_RELATIVE (reloc
->symbol
))
2141 bfd_vma reloc_offset
= reloc
->offset
;
2142 reloc_offset
-= (IS_INSN_32 (reloc
->symbol
)) ? 4 : 0;
2143 reloc_offset
-= (IS_INSN_24 (reloc
->symbol
)) ? 2 : 0;
2145 relocation
-= htab
->splt
->output_section
->vma
2146 + htab
->splt
->output_offset
2147 + plt_offset
+ reloc_offset
;
2150 /* TODO: being ME is not a property of the relocation but of the
2151 section of which is applying the relocation. */
2152 if (IS_MIDDLE_ENDIAN (reloc
->symbol
) && !bfd_big_endian (abfd
))
2155 = ((relocation
& 0xffff0000) >> 16)
2156 | ((relocation
& 0xffff) << 16);
2159 switch (reloc
->size
)
2162 bfd_put_32 (htab
->splt
->output_section
->owner
,
2164 htab
->splt
->contents
+ plt_offset
+ reloc
->offset
);
2168 reloc
= &(reloc
[1]); /* Jump to next relocation. */
2173 relocate_plt_for_symbol (bfd
*output_bfd
,
2174 struct bfd_link_info
*info
,
2175 struct elf_link_hash_entry
*h
)
2177 struct plt_version_t
*plt_data
= arc_get_plt_version (info
);
2178 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2180 bfd_vma plt_index
= (h
->plt
.offset
- plt_data
->entry_size
)
2181 / plt_data
->elem_size
;
2182 bfd_vma got_offset
= (plt_index
+ 3) * 4;
2184 ARC_DEBUG ("arc_info: PLT_OFFSET = %#lx, PLT_ENTRY_VMA = %#lx, \
2185 GOT_ENTRY_OFFSET = %#lx, GOT_ENTRY_VMA = %#lx, for symbol %s\n",
2186 (long) h
->plt
.offset
,
2187 (long) (htab
->splt
->output_section
->vma
2188 + htab
->splt
->output_offset
2191 (long) (htab
->sgotplt
->output_section
->vma
2192 + htab
->sgotplt
->output_offset
2194 h
->root
.root
.string
);
2198 uint16_t *ptr
= (uint16_t *) plt_data
->elem
;
2200 for (i
= 0; i
< plt_data
->elem_size
/2; i
++)
2202 uint16_t data
= ptr
[i
];
2203 bfd_put_16 (output_bfd
,
2205 htab
->splt
->contents
+ h
->plt
.offset
+ (i
*2));
2209 plt_do_relocs_for_symbol (output_bfd
, htab
,
2210 plt_data
->elem_relocs
,
2214 /* Fill in the entry in the global offset table. */
2215 bfd_put_32 (output_bfd
,
2216 (bfd_vma
) (htab
->splt
->output_section
->vma
2217 + htab
->splt
->output_offset
),
2218 htab
->sgotplt
->contents
+ got_offset
);
2220 /* TODO: Fill in the entry in the .rela.plt section. */
2222 Elf_Internal_Rela rel
;
2225 rel
.r_offset
= (htab
->sgotplt
->output_section
->vma
2226 + htab
->sgotplt
->output_offset
2230 BFD_ASSERT (h
->dynindx
!= -1);
2231 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARC_JMP_SLOT
);
2233 loc
= htab
->srelplt
->contents
;
2234 loc
+= plt_index
* sizeof (Elf32_External_Rela
); /* relA */
2235 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
2240 relocate_plt_for_entry (bfd
*abfd
,
2241 struct bfd_link_info
*info
)
2243 struct plt_version_t
*plt_data
= arc_get_plt_version (info
);
2244 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2248 uint16_t *ptr
= (uint16_t *) plt_data
->entry
;
2249 for (i
= 0; i
< plt_data
->entry_size
/2; i
++)
2251 uint16_t data
= ptr
[i
];
2254 htab
->splt
->contents
+ (i
*2));
2257 PLT_DO_RELOCS_FOR_ENTRY (abfd
, htab
, plt_data
->entry_relocs
);
2260 /* Desc : Adjust a symbol defined by a dynamic object and referenced
2261 by a regular object. The current definition is in some section of
2262 the dynamic object, but we're not including those sections. We
2263 have to change the definition to something the rest of the link can
2267 elf_arc_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2268 struct elf_link_hash_entry
*h
)
2271 bfd
*dynobj
= (elf_hash_table (info
))->dynobj
;
2272 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2274 if (h
->type
== STT_FUNC
2275 || h
->type
== STT_GNU_IFUNC
2276 || h
->needs_plt
== 1)
2278 if (!bfd_link_pic (info
) && !h
->def_dynamic
&& !h
->ref_dynamic
)
2280 /* This case can occur if we saw a PLT32 reloc in an input
2281 file, but the symbol was never referred to by a dynamic
2282 object. In such a case, we don't actually need to build
2283 a procedure linkage table, and we can just do a PC32
2285 BFD_ASSERT (h
->needs_plt
);
2289 /* Make sure this symbol is output as a dynamic symbol. */
2290 if (h
->dynindx
== -1 && !h
->forced_local
2291 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
2294 if (bfd_link_pic (info
)
2295 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2297 bfd_vma loc
= add_symbol_to_plt (info
);
2299 if (bfd_link_executable (info
) && !h
->def_regular
)
2301 h
->root
.u
.def
.section
= htab
->splt
;
2302 h
->root
.u
.def
.value
= loc
;
2304 h
->plt
.offset
= loc
;
2308 h
->plt
.offset
= (bfd_vma
) -1;
2314 /* If this is a weak symbol, and there is a real definition, the
2315 processor independent code will have arranged for us to see the
2316 real definition first, and we can just use the same value. */
2317 if (h
->is_weakalias
)
2319 struct elf_link_hash_entry
*def
= weakdef (h
);
2320 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
2321 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
2322 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
2326 /* This is a reference to a symbol defined by a dynamic object which
2327 is not a function. */
2329 /* If we are creating a shared library, we must presume that the
2330 only references to the symbol are via the global offset table.
2331 For such cases we need not do anything here; the relocations will
2332 be handled correctly by relocate_section. */
2333 if (!bfd_link_executable (info
))
2336 /* If there are no non-GOT references, we do not need a copy
2338 if (!h
->non_got_ref
)
2341 /* If -z nocopyreloc was given, we won't generate them either. */
2342 if (info
->nocopyreloc
)
2348 /* We must allocate the symbol in our .dynbss section, which will
2349 become part of the .bss section of the executable. There will be
2350 an entry for this symbol in the .dynsym section. The dynamic
2351 object will contain position independent code, so all references
2352 from the dynamic object to this symbol will go through the global
2353 offset table. The dynamic linker will use the .dynsym entry to
2354 determine the address it must put in the global offset table, so
2355 both the dynamic object and the regular object will refer to the
2356 same memory location for the variable. */
2361 /* We must generate a R_ARC_COPY reloc to tell the dynamic linker to
2362 copy the initial value out of the dynamic object and into the
2363 runtime process image. We need to remember the offset into the
2364 .rela.bss section we are going to use. */
2365 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
2367 struct elf_arc_link_hash_table
*arc_htab
= elf_arc_hash_table (info
);
2369 BFD_ASSERT (arc_htab
->elf
.srelbss
!= NULL
);
2370 arc_htab
->elf
.srelbss
->size
+= sizeof (Elf32_External_Rela
);
2374 /* TODO: Move this also to arc_hash_table. */
2375 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
2376 BFD_ASSERT (s
!= NULL
);
2378 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2381 /* Function : elf_arc_finish_dynamic_symbol
2382 Brief : Finish up dynamic symbol handling. We set the
2383 contents of various dynamic sections here.
2388 Returns : True/False as the return status. */
2391 elf_arc_finish_dynamic_symbol (bfd
* output_bfd
,
2392 struct bfd_link_info
*info
,
2393 struct elf_link_hash_entry
*h
,
2394 Elf_Internal_Sym
* sym
)
2396 if (h
->plt
.offset
!= (bfd_vma
) -1)
2398 relocate_plt_for_symbol (output_bfd
, info
, h
);
2400 if (!h
->def_regular
)
2402 /* Mark the symbol as undefined, rather than as defined in
2403 the .plt section. Leave the value alone. */
2404 sym
->st_shndx
= SHN_UNDEF
;
2409 /* This function traverses list of GOT entries and
2410 create respective dynamic relocs. */
2411 /* TODO: Make function to get list and not access the list directly. */
2412 /* TODO: Move function to relocate_section create this relocs eagerly. */
2413 create_got_dynrelocs_for_got_info (&h
->got
.glist
,
2420 struct elf_arc_link_hash_table
*arc_htab
= elf_arc_hash_table (info
);
2422 if (h
->dynindx
== -1
2423 || (h
->root
.type
!= bfd_link_hash_defined
2424 && h
->root
.type
!= bfd_link_hash_defweak
)
2425 || arc_htab
->elf
.srelbss
== NULL
)
2428 bfd_vma rel_offset
= (h
->root
.u
.def
.value
2429 + h
->root
.u
.def
.section
->output_section
->vma
2430 + h
->root
.u
.def
.section
->output_offset
);
2432 bfd_byte
* loc
= arc_htab
->elf
.srelbss
->contents
2433 + (arc_htab
->elf
.srelbss
->reloc_count
* sizeof (Elf32_External_Rela
));
2434 arc_htab
->elf
.srelbss
->reloc_count
++;
2436 Elf_Internal_Rela rel
;
2438 rel
.r_offset
= rel_offset
;
2440 BFD_ASSERT (h
->dynindx
!= -1);
2441 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARC_COPY
);
2443 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
2446 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2447 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2448 || strcmp (h
->root
.root
.string
, "__DYNAMIC") == 0
2449 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
2450 sym
->st_shndx
= SHN_ABS
;
2455 #define GET_SYMBOL_OR_SECTION(TAG, SYMBOL, SECTION) \
2457 if (SYMBOL != NULL) \
2458 h = elf_link_hash_lookup (elf_hash_table (info), \
2459 SYMBOL, FALSE, FALSE, TRUE); \
2460 else if (SECTION != NULL) \
2461 s = bfd_get_linker_section (dynobj, SECTION); \
2464 /* Function : elf_arc_finish_dynamic_sections
2465 Brief : Finish up the dynamic sections handling.
2470 Returns : True/False as the return status. */
2473 elf_arc_finish_dynamic_sections (bfd
* output_bfd
,
2474 struct bfd_link_info
*info
)
2476 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2477 bfd
*dynobj
= (elf_hash_table (info
))->dynobj
;
2478 asection
*sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
2482 Elf32_External_Dyn
*dyncon
, *dynconend
;
2484 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
2486 = (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
2487 for (; dyncon
< dynconend
; dyncon
++)
2489 Elf_Internal_Dyn internal_dyn
;
2490 bfd_boolean do_it
= FALSE
;
2492 struct elf_link_hash_entry
*h
= NULL
;
2495 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &internal_dyn
);
2497 switch (internal_dyn
.d_tag
)
2499 GET_SYMBOL_OR_SECTION (DT_INIT
, info
->init_function
, NULL
)
2500 GET_SYMBOL_OR_SECTION (DT_FINI
, info
->fini_function
, NULL
)
2501 GET_SYMBOL_OR_SECTION (DT_PLTGOT
, NULL
, ".plt")
2502 GET_SYMBOL_OR_SECTION (DT_JMPREL
, NULL
, ".rela.plt")
2503 GET_SYMBOL_OR_SECTION (DT_PLTRELSZ
, NULL
, ".rela.plt")
2504 GET_SYMBOL_OR_SECTION (DT_VERSYM
, NULL
, ".gnu.version")
2505 GET_SYMBOL_OR_SECTION (DT_VERDEF
, NULL
, ".gnu.version_d")
2506 GET_SYMBOL_OR_SECTION (DT_VERNEED
, NULL
, ".gnu.version_r")
2511 /* In case the dynamic symbols should be updated with a symbol. */
2513 && (h
->root
.type
== bfd_link_hash_defined
2514 || h
->root
.type
== bfd_link_hash_defweak
))
2518 internal_dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
2519 asec_ptr
= h
->root
.u
.def
.section
;
2520 if (asec_ptr
->output_section
!= NULL
)
2522 internal_dyn
.d_un
.d_val
+=
2523 (asec_ptr
->output_section
->vma
2524 + asec_ptr
->output_offset
);
2528 /* The symbol is imported from another shared
2529 library and does not apply to this one. */
2530 internal_dyn
.d_un
.d_val
= 0;
2534 else if (s
!= NULL
) /* With a section information. */
2536 switch (internal_dyn
.d_tag
)
2543 internal_dyn
.d_un
.d_ptr
= (s
->output_section
->vma
2544 + s
->output_offset
);
2549 internal_dyn
.d_un
.d_val
= s
->size
;
2559 bfd_elf32_swap_dyn_out (output_bfd
, &internal_dyn
, dyncon
);
2562 if (htab
->splt
->size
> 0)
2564 relocate_plt_for_entry (output_bfd
, info
);
2567 /* TODO: Validate this. */
2568 if (htab
->srelplt
->output_section
!= bfd_abs_section_ptr
)
2569 elf_section_data (htab
->srelplt
->output_section
)
2570 ->this_hdr
.sh_entsize
= 12;
2573 /* Fill in the first three entries in the global offset table. */
2576 struct elf_link_hash_entry
*h
;
2577 h
= elf_link_hash_lookup (elf_hash_table (info
), "_GLOBAL_OFFSET_TABLE_",
2578 FALSE
, FALSE
, TRUE
);
2580 if (h
!= NULL
&& h
->root
.type
!= bfd_link_hash_undefined
2581 && h
->root
.u
.def
.section
!= NULL
)
2583 asection
*sec
= h
->root
.u
.def
.section
;
2586 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
2589 bfd_put_32 (output_bfd
,
2590 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
2592 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sec
->contents
+ 4);
2593 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sec
->contents
+ 8);
2600 #define ADD_DYNAMIC_SYMBOL(NAME, TAG) \
2601 h = elf_link_hash_lookup (elf_hash_table (info), \
2602 NAME, FALSE, FALSE, FALSE); \
2603 if ((h != NULL && (h->ref_regular || h->def_regular))) \
2604 if (! _bfd_elf_add_dynamic_entry (info, TAG, 0)) \
2607 /* Set the sizes of the dynamic sections. */
2609 elf_arc_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
2610 struct bfd_link_info
*info
)
2614 bfd_boolean relocs_exist
= FALSE
;
2615 bfd_boolean reltext_exist
= FALSE
;
2616 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2618 dynobj
= htab
->dynobj
;
2619 BFD_ASSERT (dynobj
!= NULL
);
2621 if (htab
->dynamic_sections_created
)
2623 struct elf_link_hash_entry
*h
;
2625 /* Set the contents of the .interp section to the
2627 if (bfd_link_executable (info
) && !info
->nointerp
)
2629 s
= bfd_get_section_by_name (dynobj
, ".interp");
2630 BFD_ASSERT (s
!= NULL
);
2631 s
->size
= sizeof (ELF_DYNAMIC_INTERPRETER
);
2632 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2635 /* Add some entries to the .dynamic section. We fill in some of
2636 the values later, in elf_bfd_final_link, but we must add the
2637 entries now so that we know the final size of the .dynamic
2638 section. Checking if the .init section is present. We also
2639 create DT_INIT and DT_FINI entries if the init_str has been
2640 changed by the user. */
2641 ADD_DYNAMIC_SYMBOL (info
->init_function
, DT_INIT
);
2642 ADD_DYNAMIC_SYMBOL (info
->fini_function
, DT_FINI
);
2646 /* We may have created entries in the .rela.got section.
2647 However, if we are not creating the dynamic sections, we will
2648 not actually use these entries. Reset the size of .rela.got,
2649 which will cause it to get stripped from the output file
2651 if (htab
->srelgot
!= NULL
)
2652 htab
->srelgot
->size
= 0;
2655 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2657 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2662 || s
== htab
->sgotplt
2663 || s
== htab
->sdynbss
)
2665 /* Strip this section if we don't need it. */
2667 else if (strncmp (s
->name
, ".rela", 5) == 0)
2669 if (s
->size
!= 0 && s
!= htab
->srelplt
)
2673 const char *name
= s
->name
+ 5;
2675 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
2676 if (bfd_get_flavour (ibfd
) == bfd_target_elf_flavour
2677 && ibfd
->flags
& DYNAMIC
)
2679 asection
*target
= bfd_get_section_by_name (ibfd
, name
);
2681 && elf_section_data (target
)->sreloc
== s
2682 && ((target
->output_section
->flags
2683 & (SEC_READONLY
| SEC_ALLOC
))
2684 == (SEC_READONLY
| SEC_ALLOC
)))
2686 reltext_exist
= TRUE
;
2691 relocs_exist
= TRUE
;
2694 /* We use the reloc_count field as a counter if we need to
2695 copy relocs into the output file. */
2700 /* It's not one of our sections, so don't allocate space. */
2706 s
->flags
|= SEC_EXCLUDE
;
2710 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
2713 /* Allocate memory for the section contents. */
2714 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
2715 if (s
->contents
== NULL
)
2719 if (htab
->dynamic_sections_created
)
2721 /* TODO: Check if this is needed. */
2722 if (!bfd_link_pic (info
))
2723 if (!_bfd_elf_add_dynamic_entry (info
, DT_DEBUG
, 0))
2726 if (htab
->splt
&& (htab
->splt
->flags
& SEC_EXCLUDE
) == 0)
2727 if (!_bfd_elf_add_dynamic_entry (info
, DT_PLTGOT
, 0)
2728 || !_bfd_elf_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
2729 || !_bfd_elf_add_dynamic_entry (info
, DT_PLTREL
, DT_RELA
)
2730 || !_bfd_elf_add_dynamic_entry (info
, DT_JMPREL
, 0))
2734 if (!_bfd_elf_add_dynamic_entry (info
, DT_RELA
, 0)
2735 || !_bfd_elf_add_dynamic_entry (info
, DT_RELASZ
, 0)
2736 || !_bfd_elf_add_dynamic_entry (info
, DT_RELAENT
,
2737 sizeof (Elf32_External_Rela
)))
2741 if (!_bfd_elf_add_dynamic_entry (info
, DT_TEXTREL
, 0))
2749 /* Classify dynamic relocs such that -z combreloc can reorder and combine
2751 static enum elf_reloc_type_class
2752 elf32_arc_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2753 const asection
*rel_sec ATTRIBUTE_UNUSED
,
2754 const Elf_Internal_Rela
*rela
)
2756 switch ((int) ELF32_R_TYPE (rela
->r_info
))
2758 case R_ARC_RELATIVE
:
2759 return reloc_class_relative
;
2760 case R_ARC_JMP_SLOT
:
2761 return reloc_class_plt
;
2763 return reloc_class_copy
;
2764 /* TODO: Needed in future to support ifunc. */
2766 case R_ARC_IRELATIVE:
2767 return reloc_class_ifunc;
2770 return reloc_class_normal
;
2774 const struct elf_size_info arc_elf32_size_info
=
2776 sizeof (Elf32_External_Ehdr
),
2777 sizeof (Elf32_External_Phdr
),
2778 sizeof (Elf32_External_Shdr
),
2779 sizeof (Elf32_External_Rel
),
2780 sizeof (Elf32_External_Rela
),
2781 sizeof (Elf32_External_Sym
),
2782 sizeof (Elf32_External_Dyn
),
2783 sizeof (Elf_External_Note
),
2787 ELFCLASS32
, EV_CURRENT
,
2788 bfd_elf32_write_out_phdrs
,
2789 bfd_elf32_write_shdrs_and_ehdr
,
2790 bfd_elf32_checksum_contents
,
2791 bfd_elf32_write_relocs
,
2792 bfd_elf32_swap_symbol_in
,
2793 bfd_elf32_swap_symbol_out
,
2794 bfd_elf32_slurp_reloc_table
,
2795 bfd_elf32_slurp_symbol_table
,
2796 bfd_elf32_swap_dyn_in
,
2797 bfd_elf32_swap_dyn_out
,
2798 bfd_elf32_swap_reloc_in
,
2799 bfd_elf32_swap_reloc_out
,
2800 bfd_elf32_swap_reloca_in
,
2801 bfd_elf32_swap_reloca_out
2804 #define elf_backend_size_info arc_elf32_size_info
2806 /* GDB expects general purpose registers to be in section .reg. However Linux
2807 kernel doesn't create this section and instead writes registers to NOTE
2808 section. It is up to the binutils to create a pseudo-section .reg from the
2809 contents of NOTE. Also BFD will read pid and signal number from NOTE. This
2810 function relies on offsets inside elf_prstatus structure in Linux to be
2814 elf32_arc_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
2819 switch (note
->descsz
)
2824 case 236: /* sizeof (struct elf_prstatus) on Linux/arc. */
2826 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
2828 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
2831 size
= (40 * 4); /* There are 40 registers in user_regs_struct. */
2834 /* Make a ".reg/999" section. */
2835 return _bfd_elfcore_make_pseudosection (abfd
, ".reg", size
,
2836 note
->descpos
+ offset
);
2839 /* Determine whether an object attribute tag takes an integer, a
2843 elf32_arc_obj_attrs_arg_type (int tag
)
2845 if (tag
== Tag_ARC_CPU_name
2846 || tag
== Tag_ARC_ISA_config
2847 || tag
== Tag_ARC_ISA_apex
)
2848 return ATTR_TYPE_FLAG_STR_VAL
;
2849 else if (tag
< (Tag_ARC_ISA_mpy_option
+ 1))
2850 return ATTR_TYPE_FLAG_INT_VAL
;
2852 return (tag
& 1) != 0 ? ATTR_TYPE_FLAG_STR_VAL
: ATTR_TYPE_FLAG_INT_VAL
;
2855 /* Attribute numbers >=14 can be safely ignored. */
2858 elf32_arc_obj_attrs_handle_unknown (bfd
*abfd
, int tag
)
2860 if ((tag
& 127) < (Tag_ARC_ISA_mpy_option
+ 1))
2863 (_("%pB: unknown mandatory ARC object attribute %d"),
2865 bfd_set_error (bfd_error_bad_value
);
2871 (_("warning: %pB: unknown ARC object attribute %d"),
2877 /* Handle an ARC specific section when reading an object file. This is
2878 called when bfd_section_from_shdr finds a section with an unknown
2882 elf32_arc_section_from_shdr (bfd
*abfd
,
2883 Elf_Internal_Shdr
* hdr
,
2887 switch (hdr
->sh_type
)
2889 case SHT_ARC_ATTRIBUTES
:
2896 if (!_bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2902 #define TARGET_LITTLE_SYM arc_elf32_le_vec
2903 #define TARGET_LITTLE_NAME "elf32-littlearc"
2904 #define TARGET_BIG_SYM arc_elf32_be_vec
2905 #define TARGET_BIG_NAME "elf32-bigarc"
2906 #define ELF_ARCH bfd_arch_arc
2907 #define ELF_TARGET_ID ARC_ELF_DATA
2908 #define ELF_MACHINE_CODE EM_ARC_COMPACT
2909 #define ELF_MACHINE_ALT1 EM_ARC_COMPACT2
2910 #define ELF_MAXPAGESIZE 0x2000
2912 #define bfd_elf32_bfd_link_hash_table_create arc_elf_link_hash_table_create
2914 #define bfd_elf32_bfd_merge_private_bfd_data arc_elf_merge_private_bfd_data
2915 #define bfd_elf32_bfd_reloc_type_lookup arc_elf32_bfd_reloc_type_lookup
2916 #define bfd_elf32_bfd_set_private_flags arc_elf_set_private_flags
2917 #define bfd_elf32_bfd_print_private_bfd_data arc_elf_print_private_bfd_data
2918 #define bfd_elf32_bfd_copy_private_bfd_data arc_elf_copy_private_bfd_data
2920 #define elf_info_to_howto_rel arc_info_to_howto_rel
2921 #define elf_backend_object_p arc_elf_object_p
2922 #define elf_backend_final_write_processing arc_elf_final_write_processing
2924 #define elf_backend_relocate_section elf_arc_relocate_section
2925 #define elf_backend_check_relocs elf_arc_check_relocs
2926 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
2928 #define elf_backend_reloc_type_class elf32_arc_reloc_type_class
2930 #define elf_backend_adjust_dynamic_symbol elf_arc_adjust_dynamic_symbol
2931 #define elf_backend_finish_dynamic_symbol elf_arc_finish_dynamic_symbol
2933 #define elf_backend_finish_dynamic_sections elf_arc_finish_dynamic_sections
2934 #define elf_backend_size_dynamic_sections elf_arc_size_dynamic_sections
2936 #define elf_backend_can_gc_sections 1
2937 #define elf_backend_want_got_plt 1
2938 #define elf_backend_plt_readonly 1
2939 #define elf_backend_rela_plts_and_copies_p 1
2940 #define elf_backend_want_plt_sym 0
2941 #define elf_backend_got_header_size 12
2942 #define elf_backend_dtrel_excludes_plt 1
2944 #define elf_backend_may_use_rel_p 0
2945 #define elf_backend_may_use_rela_p 1
2946 #define elf_backend_default_use_rela_p 1
2948 #define elf_backend_grok_prstatus elf32_arc_grok_prstatus
2950 #define elf_backend_default_execstack 0
2952 #undef elf_backend_obj_attrs_vendor
2953 #define elf_backend_obj_attrs_vendor "ARC"
2954 #undef elf_backend_obj_attrs_section
2955 #define elf_backend_obj_attrs_section ".ARC.attributes"
2956 #undef elf_backend_obj_attrs_arg_type
2957 #define elf_backend_obj_attrs_arg_type elf32_arc_obj_attrs_arg_type
2958 #undef elf_backend_obj_attrs_section_type
2959 #define elf_backend_obj_attrs_section_type SHT_ARC_ATTRIBUTES
2960 #define elf_backend_obj_attrs_handle_unknown elf32_arc_obj_attrs_handle_unknown
2962 #define elf_backend_section_from_shdr elf32_arc_section_from_shdr
2964 #include "elf32-target.h"