1 /* ARC-specific support for 32-bit ELF
2 Copyright (C) 1994-2017 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 BFD_ASSERT (_htab->srel##SECTION &&_htab->srel##SECTION->contents); \
59 _loc = _htab->srel##SECTION->contents \
60 + ((_htab->srel##SECTION->reloc_count) \
61 * sizeof (Elf32_External_Rela)); \
62 _htab->srel##SECTION->reloc_count++; \
63 _rel.r_addend = ADDEND; \
64 _rel.r_offset = (_htab->s##SECTION)->output_section->vma \
65 + (_htab->s##SECTION)->output_offset + OFFSET; \
66 BFD_ASSERT ((long) SYM_IDX != -1); \
67 _rel.r_info = ELF32_R_INFO (SYM_IDX, TYPE); \
68 bfd_elf32_swap_reloca_out (BFD, &_rel, _loc); \
72 /* The default symbols representing the init and fini dyn values.
73 TODO: Check what is the relation of those strings with arclinux.em
75 #define INIT_SYM_STRING "_init"
76 #define FINI_SYM_STRING "_fini"
78 char * init_str
= INIT_SYM_STRING
;
79 char * fini_str
= FINI_SYM_STRING
;
81 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
86 static ATTRIBUTE_UNUSED
const char *
87 reloc_type_to_name (unsigned int type
)
91 #include "elf/arc-reloc.def"
98 #undef ARC_RELOC_HOWTO
100 /* Try to minimize the amount of space occupied by relocation tables
101 on the ROM (not that the ROM won't be swamped by other ELF overhead). */
105 static ATTRIBUTE_UNUSED bfd_boolean
106 is_reloc_PC_relative (reloc_howto_type
*howto
)
108 return (strstr (howto
->name
, "PC") != NULL
) ? TRUE
: FALSE
;
112 is_reloc_SDA_relative (reloc_howto_type
*howto
)
114 return (strstr (howto
->name
, "SDA") != NULL
) ? TRUE
: FALSE
;
118 is_reloc_for_GOT (reloc_howto_type
* howto
)
120 if (strstr (howto
->name
, "TLS") != NULL
)
122 return (strstr (howto
->name
, "GOT") != NULL
) ? TRUE
: FALSE
;
126 is_reloc_for_PLT (reloc_howto_type
* howto
)
128 return (strstr (howto
->name
, "PLT") != NULL
) ? TRUE
: FALSE
;
132 is_reloc_for_TLS (reloc_howto_type
*howto
)
134 return (strstr (howto
->name
, "TLS") != NULL
) ? TRUE
: FALSE
;
137 struct arc_relocation_data
139 bfd_signed_vma reloc_offset
;
140 bfd_signed_vma reloc_addend
;
141 bfd_signed_vma got_offset_value
;
143 bfd_signed_vma sym_value
;
144 asection
* sym_section
;
146 reloc_howto_type
*howto
;
148 asection
* input_section
;
150 bfd_signed_vma sdata_begin_symbol_vma
;
151 bfd_boolean sdata_begin_symbol_vma_set
;
152 bfd_signed_vma got_symbol_vma
;
154 bfd_boolean should_relocate
;
156 const char * symbol_name
;
159 /* Should be included at this location due to static declarations
160 * defined before this point. */
163 #define arc_bfd_get_8(A,B,C) bfd_get_8(A,B)
164 #define arc_bfd_get_16(A,B,C) bfd_get_16(A,B)
165 #define arc_bfd_get_32(A,B,C) bfd_get_32(A,B)
166 #define arc_bfd_put_8(A,B,C,D) bfd_put_8(A,B,C)
167 #define arc_bfd_put_16(A,B,C,D) bfd_put_16(A,B,C)
168 #define arc_bfd_put_32(A,B,C,D) bfd_put_32(A,B,C)
171 static bfd_reloc_status_type
172 arc_elf_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
173 arelent
*reloc_entry
,
175 void *data ATTRIBUTE_UNUSED
,
176 asection
*input_section
,
178 char ** error_message ATTRIBUTE_UNUSED
)
180 if (output_bfd
!= NULL
)
182 reloc_entry
->address
+= input_section
->output_offset
;
184 /* In case of relocateable link and if the reloc is against a
185 section symbol, the addend needs to be adjusted according to
186 where the section symbol winds up in the output section. */
187 if ((symbol_in
->flags
& BSF_SECTION_SYM
) && symbol_in
->section
)
188 reloc_entry
->addend
+= symbol_in
->section
->output_offset
;
193 return bfd_reloc_continue
;
197 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
201 #include "elf/arc-reloc.def"
204 #undef ARC_RELOC_HOWTO
206 #define ARC_RELOC_HOWTO(TYPE, VALUE, RSIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
207 [TYPE] = HOWTO (R_##TYPE, 0, RSIZE, BITSIZE, FALSE, 0, \
208 complain_overflow_##OVERFLOW, arc_elf_reloc, \
209 "R_" #TYPE, FALSE, 0, 0, FALSE),
211 static struct reloc_howto_struct elf_arc_howto_table
[] =
213 #include "elf/arc-reloc.def"
214 /* Example of what is generated by the preprocessor. Currently kept as an
216 HOWTO (R_ARC_NONE, // Type.
218 2, // Size (0 = byte, 1 = short, 2 = long).
220 FALSE, // PC_relative.
222 complain_overflow_bitfield, // Complain_on_overflow.
223 bfd_elf_generic_reloc, // Special_function.
224 "R_ARC_NONE", // Name.
225 TRUE, // Partial_inplace.
228 FALSE), // PCrel_offset.
231 #undef ARC_RELOC_HOWTO
233 static void arc_elf_howto_init (void)
235 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
236 elf_arc_howto_table[TYPE].pc_relative = \
237 (strstr (#FORMULA, " P ") != NULL || strstr (#FORMULA, " PDATA ") != NULL); \
238 elf_arc_howto_table[TYPE].dst_mask = RELOC_FUNCTION(0, ~0); \
239 /* Only 32 bit data relocations should be marked as ME. */ \
240 if (strstr (#FORMULA, " ME ") != NULL) \
242 BFD_ASSERT (SIZE == 2); \
245 #include "elf/arc-reloc.def"
248 #undef ARC_RELOC_HOWTO
251 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
253 const int howto_table_lookup
[] =
255 #include "elf/arc-reloc.def"
257 #undef ARC_RELOC_HOWTO
259 static reloc_howto_type
*
260 arc_elf_howto (unsigned int r_type
)
262 if (elf_arc_howto_table
[R_ARC_32
].dst_mask
== 0)
263 arc_elf_howto_init ();
264 return &elf_arc_howto_table
[r_type
];
267 /* Map BFD reloc types to ARC ELF reloc types. */
271 bfd_reloc_code_real_type bfd_reloc_val
;
272 unsigned char elf_reloc_val
;
275 /* ARC ELF linker hash entry. */
276 struct elf_arc_link_hash_entry
278 struct elf_link_hash_entry root
;
280 /* Track dynamic relocs copied for this symbol. */
281 struct elf_dyn_relocs
*dyn_relocs
;
284 /* ARC ELF linker hash table. */
285 struct elf_arc_link_hash_table
287 struct elf_link_hash_table elf
;
290 static struct bfd_hash_entry
*
291 elf_arc_link_hash_newfunc (struct bfd_hash_entry
*entry
,
292 struct bfd_hash_table
*table
,
295 /* Allocate the structure if it has not already been allocated by a
299 entry
= (struct bfd_hash_entry
*)
300 bfd_hash_allocate (table
,
301 sizeof (struct elf_arc_link_hash_entry
));
306 /* Call the allocation method of the superclass. */
307 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
310 struct elf_arc_link_hash_entry
*eh
;
312 eh
= (struct elf_arc_link_hash_entry
*) entry
;
313 eh
->dyn_relocs
= NULL
;
319 /* Destroy an ARC ELF linker hash table. */
321 elf_arc_link_hash_table_free (bfd
*obfd
)
323 _bfd_elf_link_hash_table_free (obfd
);
326 /* Create an ARC ELF linker hash table. */
328 static struct bfd_link_hash_table
*
329 arc_elf_link_hash_table_create (bfd
*abfd
)
331 struct elf_arc_link_hash_table
*ret
;
333 ret
= (struct elf_arc_link_hash_table
*) bfd_zmalloc (sizeof (*ret
));
337 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
338 elf_arc_link_hash_newfunc
,
339 sizeof (struct elf_arc_link_hash_entry
),
346 ret
->elf
.init_got_refcount
.refcount
= 0;
347 ret
->elf
.init_got_refcount
.glist
= NULL
;
348 ret
->elf
.init_got_offset
.offset
= 0;
349 ret
->elf
.init_got_offset
.glist
= NULL
;
351 ret
->elf
.root
.hash_table_free
= elf_arc_link_hash_table_free
;
353 return &ret
->elf
.root
;
356 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
357 { BFD_RELOC_##TYPE, R_##TYPE },
358 static const struct arc_reloc_map arc_reloc_map
[] =
360 #include "elf/arc-reloc.def"
362 {BFD_RELOC_NONE
, R_ARC_NONE
},
363 {BFD_RELOC_8
, R_ARC_8
},
364 {BFD_RELOC_16
, R_ARC_16
},
365 {BFD_RELOC_24
, R_ARC_24
},
366 {BFD_RELOC_32
, R_ARC_32
},
368 #undef ARC_RELOC_HOWTO
370 typedef ATTRIBUTE_UNUSED
bfd_vma (*replace_func
) (unsigned, int ATTRIBUTE_UNUSED
);
372 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
374 func = (void *) RELOC_FUNCTION; \
377 get_replace_function (bfd
*abfd
, unsigned int r_type
)
383 #include "elf/arc-reloc.def"
386 if (func
== replace_bits24
&& bfd_big_endian (abfd
))
387 return (replace_func
) replace_bits24_be
;
389 return (replace_func
) func
;
391 #undef ARC_RELOC_HOWTO
393 static reloc_howto_type
*
394 arc_elf32_bfd_reloc_type_lookup (bfd
* abfd ATTRIBUTE_UNUSED
,
395 bfd_reloc_code_real_type code
)
399 for (i
= ARRAY_SIZE (arc_reloc_map
); i
--;)
401 if (arc_reloc_map
[i
].bfd_reloc_val
== code
)
402 return arc_elf_howto (arc_reloc_map
[i
].elf_reloc_val
);
408 /* Function to set the ELF flag bits. */
410 arc_elf_set_private_flags (bfd
*abfd
, flagword flags
)
412 elf_elfheader (abfd
)->e_flags
= flags
;
413 elf_flags_init (abfd
) = TRUE
;
417 /* Print private flags. */
419 arc_elf_print_private_bfd_data (bfd
*abfd
, void * ptr
)
421 FILE *file
= (FILE *) ptr
;
424 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
426 /* Print normal ELF private data. */
427 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
429 flags
= elf_elfheader (abfd
)->e_flags
;
430 fprintf (file
, _("private flags = 0x%lx:"), (unsigned long) flags
);
432 switch (flags
& EF_ARC_MACH_MSK
)
434 case EF_ARC_CPU_ARCV2HS
: fprintf (file
, " -mcpu=ARCv2HS"); break;
435 case EF_ARC_CPU_ARCV2EM
: fprintf (file
, " -mcpu=ARCv2EM"); break;
436 case E_ARC_MACH_ARC600
: fprintf (file
, " -mcpu=ARC600"); break;
437 case E_ARC_MACH_ARC601
: fprintf (file
, " -mcpu=ARC601"); break;
438 case E_ARC_MACH_ARC700
: fprintf (file
, " -mcpu=ARC700"); break;
440 fprintf (file
, "-mcpu=unknown");
444 switch (flags
& EF_ARC_OSABI_MSK
)
446 case E_ARC_OSABI_ORIG
: fprintf (file
, " (ABI:legacy)"); break;
447 case E_ARC_OSABI_V2
: fprintf (file
, " (ABI:v2)"); break;
448 case E_ARC_OSABI_V3
: fprintf (file
, " (ABI:v3)"); break;
449 case E_ARC_OSABI_V4
: fprintf (file
, " (ABI:v4)"); break;
451 fprintf (file
, " (ABI:unknown)");
459 /* Copy backend specific data from one object module to another. */
462 arc_elf_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
464 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
465 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
468 BFD_ASSERT (!elf_flags_init (obfd
)
469 || elf_elfheader (obfd
)->e_flags
== elf_elfheader (ibfd
)->e_flags
);
471 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
472 elf_flags_init (obfd
) = TRUE
;
474 /* Copy object attributes. */
475 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
477 return _bfd_elf_copy_private_bfd_data (ibfd
, obfd
);
480 static reloc_howto_type
*
481 bfd_elf32_bfd_reloc_name_lookup (bfd
* abfd ATTRIBUTE_UNUSED
,
486 for (i
= 0; i
< ARRAY_SIZE (elf_arc_howto_table
); i
++)
487 if (elf_arc_howto_table
[i
].name
!= NULL
488 && strcasecmp (elf_arc_howto_table
[i
].name
, r_name
) == 0)
489 return arc_elf_howto (i
);
494 /* Set the howto pointer for an ARC ELF reloc. */
497 arc_info_to_howto_rel (bfd
* abfd ATTRIBUTE_UNUSED
,
499 Elf_Internal_Rela
* dst
)
503 r_type
= ELF32_R_TYPE (dst
->r_info
);
504 BFD_ASSERT (r_type
< (unsigned int) R_ARC_max
);
505 cache_ptr
->howto
= arc_elf_howto (r_type
);
508 /* Extract CPU features from an NTBS. */
511 arc_extract_features (const char *p
)
518 for (i
= 0; i
< ARRAY_SIZE (bfd_feature_list
); i
++)
520 char *t
= strstr (p
, bfd_feature_list
[i
].attr
);
521 unsigned l
= strlen (bfd_feature_list
[i
].attr
);
525 r
|= bfd_feature_list
[i
].feature
;
531 /* Concatenate two strings. s1 can be NULL but not
535 arc_stralloc (char * s1
, const char * s2
)
539 /* Only s1 can be null. */
542 p
= s1
? concat (s1
, ",", s2
, NULL
) : (char *)s2
;
547 /* Merge ARC object attributes from IBFD into OBFD. Raise an error if
548 there are conflicting attributes. */
551 arc_elf_merge_attributes (bfd
*ibfd
, struct bfd_link_info
*info
)
553 bfd
*obfd
= info
->output_bfd
;
554 obj_attribute
*in_attr
;
555 obj_attribute
*out_attr
;
557 bfd_boolean result
= TRUE
;
558 const char *sec_name
= get_elf_backend_data (ibfd
)->obj_attrs_section
;
559 char *tagname
= NULL
;
561 /* Skip the linker stubs file. This preserves previous behavior
562 of accepting unknown attributes in the first input file - but
564 if (ibfd
->flags
& BFD_LINKER_CREATED
)
567 /* Skip any input that hasn't attribute section.
568 This enables to link object files without attribute section with
570 if (bfd_get_section_by_name (ibfd
, sec_name
) == NULL
)
573 if (!elf_known_obj_attributes_proc (obfd
)[0].i
)
575 /* This is the first object. Copy the attributes. */
576 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
578 out_attr
= elf_known_obj_attributes_proc (obfd
);
580 /* Use the Tag_null value to indicate the attributes have been
587 in_attr
= elf_known_obj_attributes_proc (ibfd
);
588 out_attr
= elf_known_obj_attributes_proc (obfd
);
590 for (i
= LEAST_KNOWN_OBJ_ATTRIBUTE
; i
< NUM_KNOWN_OBJ_ATTRIBUTES
; i
++)
592 /* Merge this attribute with existing attributes. */
595 case Tag_ARC_PCS_config
:
596 if (out_attr
[i
].i
== 0)
597 out_attr
[i
].i
= in_attr
[i
].i
;
598 else if (in_attr
[i
].i
!= 0 && out_attr
[i
].i
!= in_attr
[i
].i
)
600 const char *tagval
[] = { "Absent", "Bare-metal/mwdt",
601 "Bare-metal/newlib", "Linux/uclibc",
603 BFD_ASSERT (in_attr
[i
].i
< 5);
604 BFD_ASSERT (out_attr
[i
].i
< 5);
605 /* It's sometimes ok to mix different configs, so this is only
608 (_("Warning: %B: Conflicting platform configuration "
609 "%s with %s.\n"), ibfd
,
610 tagval
[in_attr
[i
].i
],
611 tagval
[out_attr
[i
].i
]);
615 case Tag_ARC_CPU_base
:
616 if (out_attr
[i
].i
== 0)
617 out_attr
[i
].i
= in_attr
[i
].i
;
618 else if (in_attr
[i
].i
!= 0 && out_attr
[i
].i
!= in_attr
[i
].i
619 && ((out_attr
[i
].i
+ in_attr
[i
].i
) < 6))
621 const char *tagval
[] = { "Absent", "ARC6xx", "ARC7xx",
623 BFD_ASSERT (in_attr
[i
].i
< 5);
624 BFD_ASSERT (out_attr
[i
].i
< 5);
625 /* We cannot mix code for different CPUs. */
627 (_("error: %B: unable to merge CPU base attributes "
630 tagval
[in_attr
[i
].i
],
631 tagval
[out_attr
[i
].i
]);
637 /* The CPUs may be different, check if we can still mix
638 the objects against the output choosen CPU. */
639 unsigned in_feature
= 0;
640 unsigned out_feature
= 0;
641 char *p1
= in_attr
[Tag_ARC_ISA_config
].s
;
642 char *p2
= out_attr
[Tag_ARC_ISA_config
].s
;
645 unsigned opcode_map
[] = {0, ARC_OPCODE_ARC600
, ARC_OPCODE_ARC700
,
646 ARC_OPCODE_ARCv2EM
, ARC_OPCODE_ARCv2HS
};
648 BFD_ASSERT (in_attr
[i
].i
< (sizeof (opcode_map
)
649 / sizeof (unsigned)));
650 BFD_ASSERT (out_attr
[i
].i
< (sizeof (opcode_map
)
651 / sizeof (unsigned)));
652 cpu_out
= opcode_map
[out_attr
[i
].i
];
654 in_feature
= arc_extract_features (p1
);
655 out_feature
= arc_extract_features (p2
);
657 /* First, check if a feature is compatible with the
658 output object chosen CPU. */
659 for (j
= 0; j
< ARRAY_SIZE (bfd_feature_list
); j
++)
660 if (((in_feature
| out_feature
) & bfd_feature_list
[j
].feature
)
661 && (!(cpu_out
& bfd_feature_list
[j
].cpus
)))
664 (_("error: %B: unable to merge ISA extension attributes "
666 obfd
, bfd_feature_list
[j
].name
);
670 /* Second, if we have compatible features with the
671 chosen CPU, check if they are compatible among
673 for (j
= 0; j
< ARRAY_SIZE (bfd_conflict_list
); j
++)
674 if (((in_feature
| out_feature
) & bfd_conflict_list
[j
])
675 == bfd_conflict_list
[j
])
678 for (k
= 0; k
< ARRAY_SIZE (bfd_feature_list
); k
++)
680 if (in_feature
& bfd_feature_list
[k
].feature
681 & bfd_conflict_list
[j
])
682 p1
= (char *) bfd_feature_list
[k
].name
;
683 if (out_feature
& bfd_feature_list
[k
].feature
684 & bfd_conflict_list
[j
])
685 p2
= (char *) bfd_feature_list
[k
].name
;
688 (_("error: %B: conflicting ISA extension attributes "
694 /* Everithing is alright. */
695 out_feature
|= in_feature
;
697 for (j
= 0; j
< ARRAY_SIZE (bfd_feature_list
); j
++)
698 if (out_feature
& bfd_feature_list
[j
].feature
)
699 p1
= arc_stralloc (p1
, bfd_feature_list
[j
].attr
);
701 out_attr
[Tag_ARC_ISA_config
].s
=
702 _bfd_elf_attr_strdup (obfd
, p1
);
705 case Tag_ARC_CPU_variation
:
706 case Tag_ARC_ISA_mpy_option
:
707 case Tag_ARC_ABI_osver
:
708 /* Use the largest value specified. */
709 if (in_attr
[i
].i
> out_attr
[i
].i
)
710 out_attr
[i
].i
= in_attr
[i
].i
;
713 case Tag_ARC_CPU_name
:
716 case Tag_ARC_ABI_rf16
:
717 if (out_attr
[i
].i
== 0)
718 out_attr
[i
].i
= in_attr
[i
].i
;
719 else if (out_attr
[i
].i
!= in_attr
[i
].i
)
721 /* We cannot mix code with rf16 and without. */
723 (_("error: %B: cannot mix rf16 with full register set %B.\n"),
729 case Tag_ARC_ABI_pic
:
732 case Tag_ARC_ABI_sda
:
736 case Tag_ARC_ABI_tls
:
738 const char *tagval
[] = { "Absent", "MWDT", "GNU" };
743 BFD_ASSERT (in_attr
[i
].i
< 3);
744 BFD_ASSERT (out_attr
[i
].i
< 3);
745 if (out_attr
[i
].i
!= 0 && in_attr
[i
].i
!= 0
746 && out_attr
[i
].i
!= in_attr
[i
].i
)
749 (_("error: %B: conflicting attributes %s: %s with %s.\n"),
751 tagval
[in_attr
[i
].i
],
752 tagval
[out_attr
[i
].i
]);
759 case Tag_ARC_ABI_double_size
:
760 tagname
= "Double size";
762 case Tag_ARC_ABI_enumsize
:
764 tagname
= "Enum size";
766 case Tag_ARC_ABI_exceptions
:
768 tagname
= "ABI exceptions";
770 if (out_attr
[i
].i
!= 0 && in_attr
[i
].i
!= 0
771 && out_attr
[i
].i
!= in_attr
[i
].i
)
774 (_("error: %B: conflicting attributes %s.\n"),
780 case Tag_ARC_ISA_apex
:
781 break; /* Do nothing for APEX attributes. */
783 case Tag_ARC_ISA_config
:
784 /* It is handled in Tag_ARC_CPU_base. */
789 = result
&& _bfd_elf_merge_unknown_attribute_low (ibfd
, obfd
, i
);
792 /* If out_attr was copied from in_attr then it won't have a type yet. */
793 if (in_attr
[i
].type
&& !out_attr
[i
].type
)
794 out_attr
[i
].type
= in_attr
[i
].type
;
797 /* Merge Tag_compatibility attributes and any common GNU ones. */
798 if (!_bfd_elf_merge_object_attributes (ibfd
, info
))
801 /* Check for any attributes not known on ARC. */
802 result
&= _bfd_elf_merge_unknown_attribute_list (ibfd
, obfd
);
807 /* Merge backend specific data from an object file to the output
808 object file when linking. */
811 arc_elf_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
813 bfd
*obfd
= info
->output_bfd
;
814 unsigned short mach_ibfd
;
815 static unsigned short mach_obfd
= EM_NONE
;
820 /* Check if we have the same endianess. */
821 if (! _bfd_generic_verify_endian_match (ibfd
, info
))
824 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
825 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
828 /* Collect ELF flags. */
829 in_flags
= elf_elfheader (ibfd
)->e_flags
& EF_ARC_MACH_MSK
;
830 out_flags
= elf_elfheader (obfd
)->e_flags
& EF_ARC_MACH_MSK
;
832 if (!elf_flags_init (obfd
)) /* First call, no flags set. */
834 elf_flags_init (obfd
) = TRUE
;
835 out_flags
= in_flags
;
838 if (!arc_elf_merge_attributes (ibfd
, info
))
841 /* Check to see if the input BFD actually contains any sections. Do
842 not short-circuit dynamic objects; their section list may be
843 emptied by elf_link_add_object_symbols. */
844 if (!(ibfd
->flags
& DYNAMIC
))
846 bfd_boolean null_input_bfd
= TRUE
;
847 bfd_boolean only_data_sections
= TRUE
;
849 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
851 if ((bfd_get_section_flags (ibfd
, sec
)
852 & (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
853 == (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
854 only_data_sections
= FALSE
;
856 null_input_bfd
= FALSE
;
859 if (null_input_bfd
|| only_data_sections
)
863 /* Complain about various flag/architecture mismatches. */
864 mach_ibfd
= elf_elfheader (ibfd
)->e_machine
;
865 if (mach_obfd
== EM_NONE
)
867 mach_obfd
= mach_ibfd
;
871 if (mach_ibfd
!= mach_obfd
)
873 /* xgettext:c-format */
874 _bfd_error_handler (_("ERROR: Attempting to link %B "
875 "with a binary %B of different architecture"),
879 else if ((in_flags
!= out_flags
)
880 /* If we have object attributes, then we already
881 checked the objects compatibility, skip it. */
882 && !bfd_elf_get_obj_attr_int (ibfd
, OBJ_ATTR_PROC
,
885 /* Warn if different flags. */
887 /* xgettext:c-format */
888 (_("%B: uses different e_flags (0x%lx) fields than "
889 "previous modules (0x%lx)"),
890 ibfd
, (long) in_flags
, (long) out_flags
);
891 if (in_flags
&& out_flags
)
893 /* MWDT doesnt set the eflags hence make sure we choose the
894 eflags set by gcc. */
895 in_flags
= in_flags
> out_flags
? in_flags
: out_flags
;
899 /* Everything is correct; don't change the output flags. */
900 in_flags
= out_flags
;
904 /* Update the flags. */
905 elf_elfheader (obfd
)->e_flags
= in_flags
;
907 if (bfd_get_mach (obfd
) < bfd_get_mach (ibfd
))
909 return bfd_set_arch_mach (obfd
, bfd_arch_arc
, bfd_get_mach (ibfd
));
915 /* Return a best guess for the machine number based on the attributes. */
918 bfd_arc_get_mach_from_attributes (bfd
* abfd
)
920 int arch
= bfd_elf_get_obj_attr_int (abfd
, OBJ_ATTR_PROC
, Tag_ARC_CPU_base
);
921 unsigned e_machine
= elf_elfheader (abfd
)->e_machine
;
926 return bfd_mach_arc_arc600
;
928 return bfd_mach_arc_arc700
;
931 return bfd_mach_arc_arcv2
;
935 return (e_machine
== EM_ARC_COMPACT
)
936 ? bfd_mach_arc_arc700
: bfd_mach_arc_arcv2
;
939 /* Set the right machine number for an ARC ELF file. */
941 arc_elf_object_p (bfd
* abfd
)
943 /* Make sure this is initialised, or you'll have the potential of passing
944 garbage---or misleading values---into the call to
945 bfd_default_set_arch_mach (). */
946 unsigned int mach
= bfd_mach_arc_arc700
;
947 unsigned long arch
= elf_elfheader (abfd
)->e_flags
& EF_ARC_MACH_MSK
;
948 unsigned e_machine
= elf_elfheader (abfd
)->e_machine
;
950 if (e_machine
== EM_ARC_COMPACT
|| e_machine
== EM_ARC_COMPACT2
)
954 case E_ARC_MACH_ARC600
:
955 mach
= bfd_mach_arc_arc600
;
957 case E_ARC_MACH_ARC601
:
958 mach
= bfd_mach_arc_arc601
;
960 case E_ARC_MACH_ARC700
:
961 mach
= bfd_mach_arc_arc700
;
963 case EF_ARC_CPU_ARCV2HS
:
964 case EF_ARC_CPU_ARCV2EM
:
965 mach
= bfd_mach_arc_arcv2
;
968 mach
= bfd_arc_get_mach_from_attributes (abfd
);
974 if (e_machine
== EM_ARC
)
977 (_("Error: The ARC4 architecture is no longer supported.\n"));
983 (_("Warning: unset or old architecture flags. \n"
984 " Use default machine.\n"));
988 return bfd_default_set_arch_mach (abfd
, bfd_arch_arc
, mach
);
991 /* The final processing done just before writing out an ARC ELF object file.
992 This gets the ARC architecture right based on the machine number. */
995 arc_elf_final_write_processing (bfd
* abfd
,
996 bfd_boolean linker ATTRIBUTE_UNUSED
)
999 int osver
= bfd_elf_get_obj_attr_int (abfd
, OBJ_ATTR_PROC
,
1001 flagword e_flags
= elf_elfheader (abfd
)->e_flags
& ~EF_ARC_OSABI_MSK
;
1003 switch (bfd_get_mach (abfd
))
1005 case bfd_mach_arc_arc600
:
1006 emf
= EM_ARC_COMPACT
;
1008 case bfd_mach_arc_arc601
:
1009 emf
= EM_ARC_COMPACT
;
1011 case bfd_mach_arc_arc700
:
1012 emf
= EM_ARC_COMPACT
;
1014 case bfd_mach_arc_arcv2
:
1015 emf
= EM_ARC_COMPACT2
;
1021 elf_elfheader (abfd
)->e_machine
= emf
;
1023 /* Record whatever is the current syscall ABI version. */
1025 e_flags
|= ((osver
& 0x0f) << 8);
1027 e_flags
|= E_ARC_OSABI_V3
;
1029 elf_elfheader (abfd
)->e_flags
|= e_flags
;
1032 #ifdef ARC_ENABLE_DEBUG
1033 #define DEBUG_ARC_RELOC(A) debug_arc_reloc (A)
1036 debug_arc_reloc (struct arc_relocation_data reloc_data
)
1038 ARC_DEBUG ("Reloc type=%s, should_relocate = %s\n",
1039 reloc_data
.howto
->name
,
1040 reloc_data
.should_relocate
? "true" : "false");
1041 ARC_DEBUG (" offset = 0x%x, addend = 0x%x\n",
1042 (unsigned int) reloc_data
.reloc_offset
,
1043 (unsigned int) reloc_data
.reloc_addend
);
1044 ARC_DEBUG (" Symbol:\n");
1045 ARC_DEBUG (" value = 0x%08x\n",
1046 (unsigned int) reloc_data
.sym_value
);
1047 if (reloc_data
.sym_section
!= NULL
)
1049 ARC_DEBUG (" Symbol Section:\n");
1050 ARC_DEBUG (" section name = %s, output_offset 0x%08x",
1051 reloc_data
.sym_section
->name
,
1052 (unsigned int) reloc_data
.sym_section
->output_offset
);
1053 if (reloc_data
.sym_section
->output_section
!= NULL
)
1054 ARC_DEBUG (", output_section->vma = 0x%08x",
1055 ((unsigned int) reloc_data
.sym_section
->output_section
->vma
));
1057 if (reloc_data
.sym_section
->owner
&& reloc_data
.sym_section
->owner
->filename
)
1058 ARC_DEBUG (" file: %s\n", reloc_data
.sym_section
->owner
->filename
);
1062 ARC_DEBUG (" symbol section is NULL\n");
1065 ARC_DEBUG (" Input_section:\n");
1066 if (reloc_data
.input_section
!= NULL
)
1068 ARC_DEBUG (" section name = %s, output_offset 0x%08x, output_section->vma = 0x%08x\n",
1069 reloc_data
.input_section
->name
,
1070 (unsigned int) reloc_data
.input_section
->output_offset
,
1071 (unsigned int) reloc_data
.input_section
->output_section
->vma
);
1072 ARC_DEBUG (" changed_address = 0x%08x\n",
1073 (unsigned int) (reloc_data
.input_section
->output_section
->vma
1074 + reloc_data
.input_section
->output_offset
1075 + reloc_data
.reloc_offset
));
1076 ARC_DEBUG (" file: %s\n", reloc_data
.input_section
->owner
->filename
);
1080 ARC_DEBUG (" input section is NULL\n");
1084 #define DEBUG_ARC_RELOC(A)
1085 #endif /* ARC_ENABLE_DEBUG */
1088 middle_endian_convert (bfd_vma insn
, bfd_boolean do_it
)
1093 = ((insn
& 0xffff0000) >> 16)
1094 | ((insn
& 0xffff) << 16);
1099 /* This function is called for relocations that are otherwise marked as NOT
1100 requiring overflow checks. In here we perform non-standard checks of
1101 the relocation value. */
1103 static inline bfd_reloc_status_type
1104 arc_special_overflow_checks (const struct arc_relocation_data reloc_data
,
1105 bfd_signed_vma relocation
,
1106 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1108 switch (reloc_data
.howto
->type
)
1110 case R_ARC_NPS_CMEM16
:
1111 if (((relocation
>> 16) & 0xffff) != NPS_CMEM_HIGH_VALUE
)
1113 if (reloc_data
.reloc_addend
== 0)
1115 /* xgettext:c-format */
1116 (_("%B(%A+0x%lx): CMEM relocation to `%s' is invalid, "
1117 "16 MSB should be 0x%04x (value is 0x%lx)"),
1118 reloc_data
.input_section
->owner
,
1119 reloc_data
.input_section
,
1120 reloc_data
.reloc_offset
,
1121 reloc_data
.symbol_name
,
1122 NPS_CMEM_HIGH_VALUE
,
1126 /* xgettext:c-format */
1127 (_("%B(%A+0x%lx): CMEM relocation to `%s+0x%lx' is invalid, "
1128 "16 MSB should be 0x%04x (value is 0x%lx)"),
1129 reloc_data
.input_section
->owner
,
1130 reloc_data
.input_section
,
1131 reloc_data
.reloc_offset
,
1132 reloc_data
.symbol_name
,
1133 reloc_data
.reloc_addend
,
1134 NPS_CMEM_HIGH_VALUE
,
1136 return bfd_reloc_overflow
;
1144 return bfd_reloc_ok
;
1147 #define ME(reloc) (reloc)
1149 #define IS_ME(FORMULA,BFD) ((strstr (FORMULA, "ME") != NULL) \
1150 && (!bfd_big_endian (BFD)))
1152 #define S ((bfd_signed_vma) (reloc_data.sym_value \
1153 + (reloc_data.sym_section->output_section != NULL ? \
1154 (reloc_data.sym_section->output_offset \
1155 + reloc_data.sym_section->output_section->vma) : 0)))
1156 #define L ((bfd_signed_vma) (reloc_data.sym_value \
1157 + (reloc_data.sym_section->output_section != NULL ? \
1158 (reloc_data.sym_section->output_offset \
1159 + reloc_data.sym_section->output_section->vma) : 0)))
1160 #define A (reloc_data.reloc_addend)
1162 #define G (reloc_data.got_offset_value)
1163 #define GOT (reloc_data.got_symbol_vma)
1164 #define GOT_BEGIN (htab->sgot->output_section->vma)
1167 /* P: relative offset to PCL The offset should be to the
1168 current location aligned to 32 bits. */
1169 #define P ((bfd_signed_vma) ( \
1171 (reloc_data.input_section->output_section != NULL ? \
1172 reloc_data.input_section->output_section->vma : 0) \
1173 + reloc_data.input_section->output_offset \
1174 + (reloc_data.reloc_offset - (bitsize >= 32 ? 4 : 0))) \
1176 #define PDATA ((bfd_signed_vma) ( \
1177 (reloc_data.input_section->output_section->vma \
1178 + reloc_data.input_section->output_offset \
1179 + (reloc_data.reloc_offset))))
1180 #define SECTSTART (bfd_signed_vma) (reloc_data.sym_section->output_section->vma \
1181 + reloc_data.sym_section->output_offset)
1183 #define _SDA_BASE_ (bfd_signed_vma) (reloc_data.sdata_begin_symbol_vma)
1184 #define TLS_REL (bfd_signed_vma) \
1185 ((elf_hash_table (info))->tls_sec->output_section->vma)
1186 #define TLS_TBSS (8)
1187 #define TCB_SIZE (8)
1191 #ifdef ARC_ENABLE_DEBUG
1192 #define PRINT_DEBUG_RELOC_INFO_BEFORE(FORMULA, TYPE) \
1195 asection *sym_section = reloc_data.sym_section; \
1196 asection *input_section = reloc_data.input_section; \
1197 ARC_DEBUG ("RELOC_TYPE = " TYPE "\n"); \
1198 ARC_DEBUG ("FORMULA = " FORMULA "\n"); \
1199 ARC_DEBUG ("S = %#lx\n", S); \
1200 ARC_DEBUG ("A = %#lx\n", A); \
1201 ARC_DEBUG ("L = %lx\n", L); \
1202 if (sym_section->output_section != NULL) \
1203 ARC_DEBUG ("symbol_section->vma = %#lx\n", \
1204 sym_section->output_section->vma \
1205 + sym_section->output_offset); \
1207 ARC_DEBUG ("symbol_section->vma = NULL\n"); \
1208 if (input_section->output_section != NULL) \
1209 ARC_DEBUG ("symbol_section->vma = %#lx\n", \
1210 input_section->output_section->vma \
1211 + input_section->output_offset); \
1213 ARC_DEBUG ("symbol_section->vma = NULL\n"); \
1214 ARC_DEBUG ("PCL = %#lx\n", P); \
1215 ARC_DEBUG ("P = %#lx\n", P); \
1216 ARC_DEBUG ("G = %#lx\n", G); \
1217 ARC_DEBUG ("SDA_OFFSET = %#lx\n", _SDA_BASE_); \
1218 ARC_DEBUG ("SDA_SET = %d\n", reloc_data.sdata_begin_symbol_vma_set); \
1219 ARC_DEBUG ("GOT_OFFSET = %#lx\n", GOT); \
1220 ARC_DEBUG ("relocation = %#08lx\n", relocation); \
1221 ARC_DEBUG ("before = %#08x\n", (unsigned) insn); \
1222 ARC_DEBUG ("data = %08x (%u) (%d)\n", (unsigned) relocation, \
1223 (unsigned) relocation, (int) relocation); \
1227 #define PRINT_DEBUG_RELOC_INFO_AFTER \
1230 ARC_DEBUG ("after = 0x%08x\n", (unsigned int) insn); \
1236 #define PRINT_DEBUG_RELOC_INFO_BEFORE(...)
1237 #define PRINT_DEBUG_RELOC_INFO_AFTER
1239 #endif /* ARC_ENABLE_DEBUG */
1241 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
1244 bfd_signed_vma bitsize ATTRIBUTE_UNUSED = BITSIZE; \
1245 relocation = FORMULA ; \
1246 PRINT_DEBUG_RELOC_INFO_BEFORE (#FORMULA, #TYPE); \
1247 insn = middle_endian_convert (insn, IS_ME (#FORMULA, abfd)); \
1248 insn = (* get_replace_function (abfd, TYPE)) (insn, relocation); \
1249 insn = middle_endian_convert (insn, IS_ME (#FORMULA, abfd)); \
1250 PRINT_DEBUG_RELOC_INFO_AFTER; \
1254 static bfd_reloc_status_type
1255 arc_do_relocation (bfd_byte
* contents
,
1256 struct arc_relocation_data reloc_data
,
1257 struct bfd_link_info
*info
)
1259 bfd_signed_vma relocation
= 0;
1261 bfd_vma orig_insn ATTRIBUTE_UNUSED
;
1262 bfd
* abfd
= reloc_data
.input_section
->owner
;
1263 struct elf_link_hash_table
*htab ATTRIBUTE_UNUSED
= elf_hash_table (info
);
1264 bfd_reloc_status_type flag
;
1266 if (!reloc_data
.should_relocate
)
1267 return bfd_reloc_ok
;
1269 switch (reloc_data
.howto
->size
)
1272 insn
= arc_bfd_get_32 (abfd
,
1273 contents
+ reloc_data
.reloc_offset
,
1274 reloc_data
.input_section
);
1277 insn
= arc_bfd_get_16 (abfd
,
1278 contents
+ reloc_data
.reloc_offset
,
1279 reloc_data
.input_section
);
1282 insn
= arc_bfd_get_8 (abfd
,
1283 contents
+ reloc_data
.reloc_offset
,
1284 reloc_data
.input_section
);
1294 switch (reloc_data
.howto
->type
)
1296 #include "elf/arc-reloc.def"
1303 /* Check for relocation overflow. */
1304 if (reloc_data
.howto
->complain_on_overflow
!= complain_overflow_dont
)
1305 flag
= bfd_check_overflow (reloc_data
.howto
->complain_on_overflow
,
1306 reloc_data
.howto
->bitsize
,
1307 reloc_data
.howto
->rightshift
,
1308 bfd_arch_bits_per_address (abfd
),
1311 flag
= arc_special_overflow_checks (reloc_data
, relocation
, info
);
1313 if (flag
!= bfd_reloc_ok
)
1315 ARC_DEBUG ("Relocation overflows !\n");
1316 DEBUG_ARC_RELOC (reloc_data
);
1317 ARC_DEBUG ("Relocation value = signed -> %d, unsigned -> %u"
1318 ", hex -> (0x%08x)\n",
1319 (int) relocation
, (unsigned) relocation
, (int) relocation
);
1324 /* Write updated instruction back to memory. */
1325 switch (reloc_data
.howto
->size
)
1328 arc_bfd_put_32 (abfd
, insn
,
1329 contents
+ reloc_data
.reloc_offset
,
1330 reloc_data
.input_section
);
1333 arc_bfd_put_16 (abfd
, insn
,
1334 contents
+ reloc_data
.reloc_offset
,
1335 reloc_data
.input_section
);
1338 arc_bfd_put_8 (abfd
, insn
,
1339 contents
+ reloc_data
.reloc_offset
,
1340 reloc_data
.input_section
);
1343 ARC_DEBUG ("size = %d\n", reloc_data
.howto
->size
);
1348 return bfd_reloc_ok
;
1363 #undef ARC_RELOC_HOWTO
1366 /* Relocate an arc ELF section.
1367 Function : elf_arc_relocate_section
1368 Brief : Relocate an arc section, by handling all the relocations
1369 appearing in that section.
1370 Args : output_bfd : The bfd being written to.
1371 info : Link information.
1372 input_bfd : The input bfd.
1373 input_section : The section being relocated.
1374 contents : contents of the section being relocated.
1375 relocs : List of relocations in the section.
1376 local_syms : is a pointer to the swapped in local symbols.
1377 local_section : is an array giving the section in the input file
1378 corresponding to the st_shndx field of each
1381 elf_arc_relocate_section (bfd
* output_bfd
,
1382 struct bfd_link_info
* info
,
1384 asection
* input_section
,
1385 bfd_byte
* contents
,
1386 Elf_Internal_Rela
* relocs
,
1387 Elf_Internal_Sym
* local_syms
,
1388 asection
** local_sections
)
1390 Elf_Internal_Shdr
* symtab_hdr
;
1391 struct elf_link_hash_entry
** sym_hashes
;
1392 Elf_Internal_Rela
* rel
;
1393 Elf_Internal_Rela
* wrel
;
1394 Elf_Internal_Rela
* relend
;
1395 struct elf_link_hash_table
* htab
= elf_hash_table (info
);
1397 symtab_hdr
= &((elf_tdata (input_bfd
))->symtab_hdr
);
1398 sym_hashes
= elf_sym_hashes (input_bfd
);
1400 rel
= wrel
= relocs
;
1401 relend
= relocs
+ input_section
->reloc_count
;
1402 for (; rel
< relend
; wrel
++, rel
++)
1404 enum elf_arc_reloc_type r_type
;
1405 reloc_howto_type
* howto
;
1406 unsigned long r_symndx
;
1407 struct elf_link_hash_entry
* h
;
1408 Elf_Internal_Sym
* sym
;
1410 struct elf_link_hash_entry
* h2
;
1413 struct arc_relocation_data reloc_data
=
1417 .got_offset_value
= 0,
1419 .sym_section
= NULL
,
1421 .input_section
= NULL
,
1422 .sdata_begin_symbol_vma
= 0,
1423 .sdata_begin_symbol_vma_set
= FALSE
,
1424 .got_symbol_vma
= 0,
1425 .should_relocate
= FALSE
1428 r_type
= ELF32_R_TYPE (rel
->r_info
);
1430 if (r_type
>= (int) R_ARC_max
)
1432 bfd_set_error (bfd_error_bad_value
);
1435 howto
= arc_elf_howto (r_type
);
1437 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1439 /* If we are generating another .o file and the symbol in not
1440 local, skip this relocation. */
1441 if (bfd_link_relocatable (info
))
1443 /* This is a relocateable link. We don't have to change
1444 anything, unless the reloc is against a section symbol,
1445 in which case we have to adjust according to where the
1446 section symbol winds up in the output section. */
1448 /* Checks if this is a local symbol and thus the reloc
1449 might (will??) be against a section symbol. */
1450 if (r_symndx
< symtab_hdr
->sh_info
)
1452 sym
= local_syms
+ r_symndx
;
1453 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1455 sec
= local_sections
[r_symndx
];
1457 /* For RELA relocs. Just adjust the addend
1458 value in the relocation entry. */
1459 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
1461 ARC_DEBUG ("local symbols reloc (section=%d %s) seen in %s\n",
1462 (int) r_symndx
, local_sections
[r_symndx
]->name
,
1463 __PRETTY_FUNCTION__
);
1468 h2
= elf_link_hash_lookup (elf_hash_table (info
), "__SDATA_BEGIN__",
1469 FALSE
, FALSE
, TRUE
);
1471 if (!reloc_data
.sdata_begin_symbol_vma_set
1472 && h2
!= NULL
&& h2
->root
.type
!= bfd_link_hash_undefined
1473 && h2
->root
.u
.def
.section
->output_section
!= NULL
)
1474 /* TODO: Verify this condition. */
1476 reloc_data
.sdata_begin_symbol_vma
=
1477 (h2
->root
.u
.def
.value
1478 + h2
->root
.u
.def
.section
->output_section
->vma
);
1479 reloc_data
.sdata_begin_symbol_vma_set
= TRUE
;
1482 reloc_data
.input_section
= input_section
;
1483 reloc_data
.howto
= howto
;
1484 reloc_data
.reloc_offset
= rel
->r_offset
;
1485 reloc_data
.reloc_addend
= rel
->r_addend
;
1487 /* This is a final link. */
1492 if (r_symndx
< symtab_hdr
->sh_info
) /* A local symbol. */
1494 sym
= local_syms
+ r_symndx
;
1495 sec
= local_sections
[r_symndx
];
1499 /* TODO: This code is repeated from below. We should
1500 clean it and remove duplications.
1501 Sec is used check for discarded sections.
1502 Need to redesign code below. */
1504 /* Get the symbol's entry in the symtab. */
1505 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1507 while (h
->root
.type
== bfd_link_hash_indirect
1508 || h
->root
.type
== bfd_link_hash_warning
)
1509 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1511 /* If we have encountered a definition for this symbol. */
1512 if (h
->root
.type
== bfd_link_hash_defined
1513 || h
->root
.type
== bfd_link_hash_defweak
)
1515 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1516 sec
= h
->root
.u
.def
.section
;
1520 /* Clean relocs for symbols in discarded sections. */
1521 if (sec
!= NULL
&& discarded_section (sec
))
1523 _bfd_clear_contents (howto
, input_bfd
, input_section
,
1524 contents
+ rel
->r_offset
);
1525 rel
->r_offset
= rel
->r_offset
;
1529 /* For ld -r, remove relocations in debug sections against
1530 sections defined in discarded sections. Not done for
1531 eh_frame editing code expects to be present. */
1532 if (bfd_link_relocatable (info
)
1533 && (input_section
->flags
& SEC_DEBUGGING
))
1539 if (bfd_link_relocatable (info
))
1546 if (r_symndx
< symtab_hdr
->sh_info
) /* A local symbol. */
1548 reloc_data
.sym_value
= sym
->st_value
;
1549 reloc_data
.sym_section
= sec
;
1550 reloc_data
.symbol_name
=
1551 bfd_elf_string_from_elf_section (input_bfd
,
1552 symtab_hdr
->sh_link
,
1555 /* Mergeable section handling. */
1556 if ((sec
->flags
& SEC_MERGE
)
1557 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1561 rel
->r_addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
,
1562 &msec
, rel
->r_addend
);
1563 rel
->r_addend
-= (sec
->output_section
->vma
1564 + sec
->output_offset
1566 rel
->r_addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
1568 reloc_data
.reloc_addend
= rel
->r_addend
;
1571 BFD_ASSERT (htab
->sgot
!= NULL
|| !is_reloc_for_GOT (howto
));
1572 if (htab
->sgot
!= NULL
)
1573 reloc_data
.got_symbol_vma
= htab
->sgot
->output_section
->vma
1574 + htab
->sgot
->output_offset
;
1576 reloc_data
.should_relocate
= TRUE
;
1578 else /* Global symbol. */
1580 /* FIXME: We should use the RELOC_FOR_GLOBAL_SYMBOL macro
1581 (defined in elf-bfd.h) here. */
1583 /* Get the symbol's entry in the symtab. */
1584 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1586 while (h
->root
.type
== bfd_link_hash_indirect
1587 || h
->root
.type
== bfd_link_hash_warning
)
1588 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1590 /* TODO: Need to validate what was the intention. */
1591 /* BFD_ASSERT ((h->dynindx == -1) || (h->forced_local != 0)); */
1592 reloc_data
.symbol_name
= h
->root
.root
.string
;
1594 /* If we have encountered a definition for this symbol. */
1595 if (h
->root
.type
== bfd_link_hash_defined
1596 || h
->root
.type
== bfd_link_hash_defweak
)
1598 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1599 reloc_data
.sym_section
= h
->root
.u
.def
.section
;
1601 reloc_data
.should_relocate
= TRUE
;
1603 if (is_reloc_for_GOT (howto
) && !bfd_link_pic (info
))
1605 /* TODO: Change it to use arc_do_relocation with
1606 ARC_32 reloc. Try to use ADD_RELA macro. */
1607 bfd_vma relocation
=
1608 reloc_data
.sym_value
+ reloc_data
.reloc_addend
1609 + (reloc_data
.sym_section
->output_section
!= NULL
?
1610 (reloc_data
.sym_section
->output_offset
1611 + reloc_data
.sym_section
->output_section
->vma
)
1614 BFD_ASSERT (h
->got
.glist
);
1615 bfd_vma got_offset
= h
->got
.glist
->offset
;
1616 bfd_put_32 (output_bfd
, relocation
,
1617 htab
->sgot
->contents
+ got_offset
);
1619 if (is_reloc_for_PLT (howto
) && h
->plt
.offset
!= (bfd_vma
) -1)
1621 /* TODO: This is repeated up here. */
1622 reloc_data
.sym_value
= h
->plt
.offset
;
1623 reloc_data
.sym_section
= htab
->splt
;
1626 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1628 /* Is weak symbol and has no definition. */
1629 if (is_reloc_for_GOT (howto
))
1631 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1632 reloc_data
.sym_section
= htab
->sgot
;
1633 reloc_data
.should_relocate
= TRUE
;
1635 else if (is_reloc_for_PLT (howto
)
1636 && h
->plt
.offset
!= (bfd_vma
) -1)
1638 /* TODO: This is repeated up here. */
1639 reloc_data
.sym_value
= h
->plt
.offset
;
1640 reloc_data
.sym_section
= htab
->splt
;
1641 reloc_data
.should_relocate
= TRUE
;
1648 if (is_reloc_for_GOT (howto
))
1650 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1651 reloc_data
.sym_section
= htab
->sgot
;
1653 reloc_data
.should_relocate
= TRUE
;
1655 else if (is_reloc_for_PLT (howto
))
1657 /* Fail if it is linking for PIE and the symbol is
1659 if (bfd_link_executable (info
))
1660 (*info
->callbacks
->undefined_symbol
)
1661 (info
, h
->root
.root
.string
, input_bfd
, input_section
,
1662 rel
->r_offset
, TRUE
);
1663 reloc_data
.sym_value
= h
->plt
.offset
;
1664 reloc_data
.sym_section
= htab
->splt
;
1666 reloc_data
.should_relocate
= TRUE
;
1668 else if (!bfd_link_pic (info
) || bfd_link_executable (info
))
1669 (*info
->callbacks
->undefined_symbol
)
1670 (info
, h
->root
.root
.string
, input_bfd
, input_section
,
1671 rel
->r_offset
, TRUE
);
1674 BFD_ASSERT (htab
->sgot
!= NULL
|| !is_reloc_for_GOT (howto
));
1675 if (htab
->sgot
!= NULL
)
1676 reloc_data
.got_symbol_vma
= htab
->sgot
->output_section
->vma
1677 + htab
->sgot
->output_offset
;
1680 if ((is_reloc_for_GOT (howto
)
1681 || is_reloc_for_TLS (howto
)))
1683 reloc_data
.should_relocate
= TRUE
;
1685 struct got_entry
**list
1686 = get_got_entry_list_for_symbol (output_bfd
, r_symndx
, h
);
1688 reloc_data
.got_offset_value
1689 = relocate_fix_got_relocs_for_got_info (list
,
1690 tls_type_for_reloc (howto
),
1701 create_got_dynrelocs_for_single_entry (
1702 got_entry_for_type (list
,
1703 arc_got_entry_type_for_reloc (howto
)),
1704 output_bfd
, info
, NULL
);
1713 case R_ARC_32_PCREL
:
1714 if ((bfd_link_pic (info
))
1715 && ((r_type
!= R_ARC_PC32
&& r_type
!= R_ARC_32_PCREL
)
1718 && (!info
->symbolic
|| !h
->def_regular
))))
1720 Elf_Internal_Rela outrel
;
1722 bfd_boolean skip
= FALSE
;
1723 bfd_boolean relocate
= FALSE
;
1724 asection
*sreloc
= _bfd_elf_get_dynamic_reloc_section
1725 (input_bfd
, input_section
,
1728 BFD_ASSERT (sreloc
!= NULL
);
1730 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
1734 if (outrel
.r_offset
== (bfd_vma
) -1)
1737 outrel
.r_addend
= rel
->r_addend
;
1738 outrel
.r_offset
+= (input_section
->output_section
->vma
1739 + input_section
->output_offset
);
1741 #define IS_ARC_PCREL_TYPE(TYPE) \
1742 ( (TYPE == R_ARC_PC32) \
1743 || (TYPE == R_ARC_32_PCREL))
1747 memset (&outrel
, 0, sizeof outrel
);
1752 && ((IS_ARC_PCREL_TYPE (r_type
))
1753 || !(bfd_link_executable (info
)
1754 || SYMBOLIC_BIND (info
, h
))
1755 || ! h
->def_regular
))
1757 BFD_ASSERT (h
!= NULL
);
1758 if ((input_section
->flags
& SEC_ALLOC
) != 0)
1763 BFD_ASSERT (h
->dynindx
!= -1);
1764 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
1768 /* Handle local symbols, they either do not have a
1769 global hash table entry (h == NULL), or are
1770 forced local due to a version script
1771 (h->forced_local), or the third condition is
1772 legacy, it appears to say something like, for
1773 links where we are pre-binding the symbols, or
1774 there's not an entry for this symbol in the
1775 dynamic symbol table, and it's a regular symbol
1776 not defined in a shared object, then treat the
1777 symbol as local, resolve it now. */
1779 /* outrel.r_addend = 0; */
1780 outrel
.r_info
= ELF32_R_INFO (0, R_ARC_RELATIVE
);
1783 BFD_ASSERT (sreloc
->contents
!= 0);
1785 loc
= sreloc
->contents
;
1786 loc
+= sreloc
->reloc_count
* sizeof (Elf32_External_Rela
);
1787 sreloc
->reloc_count
+= 1;
1789 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
1799 if (is_reloc_SDA_relative (howto
)
1800 && !reloc_data
.sdata_begin_symbol_vma_set
)
1803 ("Error: Linker symbol __SDATA_BEGIN__ not found");
1804 bfd_set_error (bfd_error_bad_value
);
1808 DEBUG_ARC_RELOC (reloc_data
);
1810 /* Make sure we have with a dynamic linker. In case of GOT and PLT
1811 the sym_section should point to .got or .plt respectively. */
1812 if ((is_reloc_for_GOT (howto
) || is_reloc_for_PLT (howto
))
1813 && reloc_data
.sym_section
== NULL
)
1816 (_("GOT and PLT relocations cannot be fixed with a non dynamic linker."));
1817 bfd_set_error (bfd_error_bad_value
);
1822 switch (arc_do_relocation (contents
, reloc_data
, info
))
1825 continue; /* The reloc processing loop. */
1827 case bfd_reloc_overflow
:
1828 (*info
->callbacks
->reloc_overflow
)
1829 (info
, (h
? &h
->root
: NULL
), reloc_data
.symbol_name
, howto
->name
, (bfd_vma
) 0,
1830 input_bfd
, input_section
, rel
->r_offset
);
1833 case bfd_reloc_undefined
:
1834 (*info
->callbacks
->undefined_symbol
)
1835 (info
, reloc_data
.symbol_name
, input_bfd
, input_section
, rel
->r_offset
, TRUE
);
1838 case bfd_reloc_other
:
1839 /* xgettext:c-format */
1840 msg
= _("%B(%A): warning: unaligned access to symbol '%s' in the small data area");
1843 case bfd_reloc_outofrange
:
1844 /* xgettext:c-format */
1845 msg
= _("%B(%A): internal error: out of range error");
1848 case bfd_reloc_notsupported
:
1849 /* xgettext:c-format */
1850 msg
= _("%B(%A): internal error: unsupported relocation error");
1853 case bfd_reloc_dangerous
:
1854 /* xgettext:c-format */
1855 msg
= _("%B(%A): internal error: dangerous relocation");
1859 /* xgettext:c-format */
1860 msg
= _("%B(%A): internal error: unknown error");
1865 _bfd_error_handler (msg
, input_bfd
, input_section
, reloc_data
.symbol_name
);
1872 #define elf_arc_hash_table(p) \
1873 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
1874 == ARC_ELF_DATA ? ((struct elf_arc_link_hash_table *) ((p)->hash)) : NULL)
1877 elf_arc_check_relocs (bfd
* abfd
,
1878 struct bfd_link_info
* info
,
1880 const Elf_Internal_Rela
* relocs
)
1882 Elf_Internal_Shdr
* symtab_hdr
;
1883 struct elf_link_hash_entry
** sym_hashes
;
1884 const Elf_Internal_Rela
* rel
;
1885 const Elf_Internal_Rela
* rel_end
;
1887 asection
* sreloc
= NULL
;
1889 if (bfd_link_relocatable (info
))
1892 dynobj
= (elf_hash_table (info
))->dynobj
;
1893 symtab_hdr
= &((elf_tdata (abfd
))->symtab_hdr
);
1894 sym_hashes
= elf_sym_hashes (abfd
);
1896 rel_end
= relocs
+ sec
->reloc_count
;
1897 for (rel
= relocs
; rel
< rel_end
; rel
++)
1899 enum elf_arc_reloc_type r_type
;
1900 reloc_howto_type
*howto
;
1901 unsigned long r_symndx
;
1902 struct elf_link_hash_entry
*h
;
1904 r_type
= ELF32_R_TYPE (rel
->r_info
);
1906 if (r_type
>= (int) R_ARC_max
)
1908 bfd_set_error (bfd_error_bad_value
);
1911 howto
= arc_elf_howto (r_type
);
1914 && (is_reloc_for_GOT (howto
)
1915 || is_reloc_for_TLS (howto
)))
1917 dynobj
= elf_hash_table (info
)->dynobj
= abfd
;
1918 if (! _bfd_elf_create_got_section (abfd
, info
))
1922 /* Load symbol information. */
1923 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1924 if (r_symndx
< symtab_hdr
->sh_info
) /* Is a local symbol. */
1926 else /* Global one. */
1927 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1933 /* During shared library creation, these relocs should not
1934 appear in a shared library (as memory will be read only
1935 and the dynamic linker can not resolve these. However
1936 the error should not occur for e.g. debugging or
1937 non-readonly sections. */
1938 if ((bfd_link_dll (info
) && !bfd_link_pie (info
))
1939 && (sec
->flags
& SEC_ALLOC
) != 0
1940 && (sec
->flags
& SEC_READONLY
) != 0
1941 && ((sec
->flags
& SEC_CODE
) != 0
1942 || (sec
->flags
& SEC_DEBUGGING
) != 0))
1946 name
= h
->root
.root
.string
;
1948 /* bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL); */
1951 /* xgettext:c-format */
1953 %B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1955 arc_elf_howto (r_type
)->name
,
1957 bfd_set_error (bfd_error_bad_value
);
1961 /* In some cases we are not setting the 'non_got_ref'
1962 flag, even though the relocations don't require a GOT
1963 access. We should extend the testing in this area to
1964 ensure that no significant cases are being missed. */
1969 case R_ARC_32_PCREL
:
1970 if ((bfd_link_pic (info
))
1971 && ((r_type
!= R_ARC_PC32
&& r_type
!= R_ARC_32_PCREL
)
1973 && (!info
->symbolic
|| !h
->def_regular
))))
1977 sreloc
= _bfd_elf_make_dynamic_reloc_section (sec
, dynobj
,
1985 sreloc
->size
+= sizeof (Elf32_External_Rela
);
1992 if (is_reloc_for_PLT (howto
))
2000 /* Add info to the symbol got_entry_list. */
2001 if (is_reloc_for_GOT (howto
)
2002 || is_reloc_for_TLS (howto
))
2004 arc_fill_got_info_for_reloc (
2005 arc_got_entry_type_for_reloc (howto
),
2006 get_got_entry_list_for_symbol (abfd
, r_symndx
, h
),
2015 #define ELF_DYNAMIC_INTERPRETER "/sbin/ld-uClibc.so"
2017 static struct plt_version_t
*
2018 arc_get_plt_version (struct bfd_link_info
*info
)
2022 for (i
= 0; i
< 1; i
++)
2024 ARC_DEBUG ("%d: size1 = %d, size2 = %d\n", i
,
2025 (int) plt_versions
[i
].entry_size
,
2026 (int) plt_versions
[i
].elem_size
);
2029 if (bfd_get_mach (info
->output_bfd
) == bfd_mach_arc_arcv2
)
2031 if (bfd_link_pic (info
))
2032 return &(plt_versions
[ELF_ARCV2_PIC
]);
2034 return &(plt_versions
[ELF_ARCV2_ABS
]);
2038 if (bfd_link_pic (info
))
2039 return &(plt_versions
[ELF_ARC_PIC
]);
2041 return &(plt_versions
[ELF_ARC_ABS
]);
2046 add_symbol_to_plt (struct bfd_link_info
*info
)
2048 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2051 struct plt_version_t
*plt_data
= arc_get_plt_version (info
);
2053 /* If this is the first .plt entry, make room for the special first
2055 if (htab
->splt
->size
== 0)
2056 htab
->splt
->size
+= plt_data
->entry_size
;
2058 ret
= htab
->splt
->size
;
2060 htab
->splt
->size
+= plt_data
->elem_size
;
2061 ARC_DEBUG ("PLT_SIZE = %d\n", (int) htab
->splt
->size
);
2063 htab
->sgotplt
->size
+= 4;
2064 htab
->srelplt
->size
+= sizeof (Elf32_External_Rela
);
2069 #define PLT_DO_RELOCS_FOR_ENTRY(ABFD, DS, RELOCS) \
2070 plt_do_relocs_for_symbol (ABFD, DS, RELOCS, 0, 0)
2073 plt_do_relocs_for_symbol (bfd
*abfd
,
2074 struct elf_link_hash_table
*htab
,
2075 const struct plt_reloc
*reloc
,
2077 bfd_vma symbol_got_offset
)
2079 while (SYM_ONLY (reloc
->symbol
) != LAST_RELOC
)
2081 bfd_vma relocation
= 0;
2083 switch (SYM_ONLY (reloc
->symbol
))
2087 = htab
->sgotplt
->output_section
->vma
2088 + htab
->sgotplt
->output_offset
+ symbol_got_offset
;
2091 relocation
+= reloc
->addend
;
2093 if (IS_RELATIVE (reloc
->symbol
))
2095 bfd_vma reloc_offset
= reloc
->offset
;
2096 reloc_offset
-= (IS_INSN_32 (reloc
->symbol
)) ? 4 : 0;
2097 reloc_offset
-= (IS_INSN_24 (reloc
->symbol
)) ? 2 : 0;
2099 relocation
-= htab
->splt
->output_section
->vma
2100 + htab
->splt
->output_offset
2101 + plt_offset
+ reloc_offset
;
2104 /* TODO: being ME is not a property of the relocation but of the
2105 section of which is applying the relocation. */
2106 if (IS_MIDDLE_ENDIAN (reloc
->symbol
) && !bfd_big_endian (abfd
))
2109 = ((relocation
& 0xffff0000) >> 16)
2110 | ((relocation
& 0xffff) << 16);
2113 switch (reloc
->size
)
2116 bfd_put_32 (htab
->splt
->output_section
->owner
,
2118 htab
->splt
->contents
+ plt_offset
+ reloc
->offset
);
2122 reloc
= &(reloc
[1]); /* Jump to next relocation. */
2127 relocate_plt_for_symbol (bfd
*output_bfd
,
2128 struct bfd_link_info
*info
,
2129 struct elf_link_hash_entry
*h
)
2131 struct plt_version_t
*plt_data
= arc_get_plt_version (info
);
2132 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2134 bfd_vma plt_index
= (h
->plt
.offset
- plt_data
->entry_size
)
2135 / plt_data
->elem_size
;
2136 bfd_vma got_offset
= (plt_index
+ 3) * 4;
2138 ARC_DEBUG ("arc_info: PLT_OFFSET = %#lx, PLT_ENTRY_VMA = %#lx, \
2139 GOT_ENTRY_OFFSET = %#lx, GOT_ENTRY_VMA = %#lx, for symbol %s\n",
2140 (long) h
->plt
.offset
,
2141 (long) (htab
->splt
->output_section
->vma
2142 + htab
->splt
->output_offset
2145 (long) (htab
->sgotplt
->output_section
->vma
2146 + htab
->sgotplt
->output_offset
2148 h
->root
.root
.string
);
2152 uint16_t *ptr
= (uint16_t *) plt_data
->elem
;
2154 for (i
= 0; i
< plt_data
->elem_size
/2; i
++)
2156 uint16_t data
= ptr
[i
];
2157 bfd_put_16 (output_bfd
,
2159 htab
->splt
->contents
+ h
->plt
.offset
+ (i
*2));
2163 plt_do_relocs_for_symbol (output_bfd
, htab
,
2164 plt_data
->elem_relocs
,
2168 /* Fill in the entry in the global offset table. */
2169 bfd_put_32 (output_bfd
,
2170 (bfd_vma
) (htab
->splt
->output_section
->vma
2171 + htab
->splt
->output_offset
),
2172 htab
->sgotplt
->contents
+ got_offset
);
2174 /* TODO: Fill in the entry in the .rela.plt section. */
2176 Elf_Internal_Rela rel
;
2179 rel
.r_offset
= (htab
->sgotplt
->output_section
->vma
2180 + htab
->sgotplt
->output_offset
2184 BFD_ASSERT (h
->dynindx
!= -1);
2185 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARC_JMP_SLOT
);
2187 loc
= htab
->srelplt
->contents
;
2188 loc
+= plt_index
* sizeof (Elf32_External_Rela
); /* relA */
2189 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
2194 relocate_plt_for_entry (bfd
*abfd
,
2195 struct bfd_link_info
*info
)
2197 struct plt_version_t
*plt_data
= arc_get_plt_version (info
);
2198 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2202 uint16_t *ptr
= (uint16_t *) plt_data
->entry
;
2203 for (i
= 0; i
< plt_data
->entry_size
/2; i
++)
2205 uint16_t data
= ptr
[i
];
2208 htab
->splt
->contents
+ (i
*2));
2211 PLT_DO_RELOCS_FOR_ENTRY (abfd
, htab
, plt_data
->entry_relocs
);
2214 /* Desc : Adjust a symbol defined by a dynamic object and referenced
2215 by a regular object. The current definition is in some section of
2216 the dynamic object, but we're not including those sections. We
2217 have to change the definition to something the rest of the link can
2221 elf_arc_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2222 struct elf_link_hash_entry
*h
)
2225 bfd
*dynobj
= (elf_hash_table (info
))->dynobj
;
2226 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2228 if (h
->type
== STT_FUNC
2229 || h
->type
== STT_GNU_IFUNC
2230 || h
->needs_plt
== 1)
2232 if (!bfd_link_pic (info
) && !h
->def_dynamic
&& !h
->ref_dynamic
)
2234 /* This case can occur if we saw a PLT32 reloc in an input
2235 file, but the symbol was never referred to by a dynamic
2236 object. In such a case, we don't actually need to build
2237 a procedure linkage table, and we can just do a PC32
2239 BFD_ASSERT (h
->needs_plt
);
2243 /* Make sure this symbol is output as a dynamic symbol. */
2244 if (h
->dynindx
== -1 && !h
->forced_local
2245 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
2248 if (bfd_link_pic (info
)
2249 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2251 bfd_vma loc
= add_symbol_to_plt (info
);
2253 if (bfd_link_executable (info
) && !h
->def_regular
)
2255 h
->root
.u
.def
.section
= htab
->splt
;
2256 h
->root
.u
.def
.value
= loc
;
2258 h
->plt
.offset
= loc
;
2262 h
->plt
.offset
= (bfd_vma
) -1;
2268 /* If this is a weak symbol, and there is a real definition, the
2269 processor independent code will have arranged for us to see the
2270 real definition first, and we can just use the same value. */
2271 if (h
->u
.weakdef
!= NULL
)
2273 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2274 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2275 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2276 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2280 /* This is a reference to a symbol defined by a dynamic object which
2281 is not a function. */
2283 /* If we are creating a shared library, we must presume that the
2284 only references to the symbol are via the global offset table.
2285 For such cases we need not do anything here; the relocations will
2286 be handled correctly by relocate_section. */
2287 if (!bfd_link_executable (info
))
2290 /* If there are no non-GOT references, we do not need a copy
2292 if (!h
->non_got_ref
)
2295 /* If -z nocopyreloc was given, we won't generate them either. */
2296 if (info
->nocopyreloc
)
2302 /* We must allocate the symbol in our .dynbss section, which will
2303 become part of the .bss section of the executable. There will be
2304 an entry for this symbol in the .dynsym section. The dynamic
2305 object will contain position independent code, so all references
2306 from the dynamic object to this symbol will go through the global
2307 offset table. The dynamic linker will use the .dynsym entry to
2308 determine the address it must put in the global offset table, so
2309 both the dynamic object and the regular object will refer to the
2310 same memory location for the variable. */
2315 /* We must generate a R_ARC_COPY reloc to tell the dynamic linker to
2316 copy the initial value out of the dynamic object and into the
2317 runtime process image. We need to remember the offset into the
2318 .rela.bss section we are going to use. */
2319 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
2321 struct elf_arc_link_hash_table
*arc_htab
= elf_arc_hash_table (info
);
2323 BFD_ASSERT (arc_htab
->elf
.srelbss
!= NULL
);
2324 arc_htab
->elf
.srelbss
->size
+= sizeof (Elf32_External_Rela
);
2328 /* TODO: Move this also to arc_hash_table. */
2329 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
2330 BFD_ASSERT (s
!= NULL
);
2332 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2335 /* Function : elf_arc_finish_dynamic_symbol
2336 Brief : Finish up dynamic symbol handling. We set the
2337 contents of various dynamic sections here.
2342 Returns : True/False as the return status. */
2345 elf_arc_finish_dynamic_symbol (bfd
* output_bfd
,
2346 struct bfd_link_info
*info
,
2347 struct elf_link_hash_entry
*h
,
2348 Elf_Internal_Sym
* sym
)
2350 if (h
->plt
.offset
!= (bfd_vma
) -1)
2352 relocate_plt_for_symbol (output_bfd
, info
, h
);
2354 if (!h
->def_regular
)
2356 /* Mark the symbol as undefined, rather than as defined in
2357 the .plt section. Leave the value alone. */
2358 sym
->st_shndx
= SHN_UNDEF
;
2363 /* This function traverses list of GOT entries and
2364 create respective dynamic relocs. */
2365 /* TODO: Make function to get list and not access the list directly. */
2366 /* TODO: Move function to relocate_section create this relocs eagerly. */
2367 create_got_dynrelocs_for_got_info (&h
->got
.glist
,
2374 struct elf_arc_link_hash_table
*arc_htab
= elf_arc_hash_table (info
);
2376 if (h
->dynindx
== -1
2377 || (h
->root
.type
!= bfd_link_hash_defined
2378 && h
->root
.type
!= bfd_link_hash_defweak
)
2379 || arc_htab
->elf
.srelbss
== NULL
)
2382 bfd_vma rel_offset
= (h
->root
.u
.def
.value
2383 + h
->root
.u
.def
.section
->output_section
->vma
2384 + h
->root
.u
.def
.section
->output_offset
);
2386 bfd_byte
* loc
= arc_htab
->elf
.srelbss
->contents
2387 + (arc_htab
->elf
.srelbss
->reloc_count
* sizeof (Elf32_External_Rela
));
2388 arc_htab
->elf
.srelbss
->reloc_count
++;
2390 Elf_Internal_Rela rel
;
2392 rel
.r_offset
= rel_offset
;
2394 BFD_ASSERT (h
->dynindx
!= -1);
2395 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARC_COPY
);
2397 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
2400 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2401 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2402 || strcmp (h
->root
.root
.string
, "__DYNAMIC") == 0
2403 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
2404 sym
->st_shndx
= SHN_ABS
;
2409 #define GET_SYMBOL_OR_SECTION(TAG, SYMBOL, SECTION) \
2411 if (SYMBOL != NULL) \
2412 h = elf_link_hash_lookup (elf_hash_table (info), \
2413 SYMBOL, FALSE, FALSE, TRUE); \
2414 else if (SECTION != NULL) \
2415 s = bfd_get_linker_section (dynobj, SECTION); \
2418 /* Function : elf_arc_finish_dynamic_sections
2419 Brief : Finish up the dynamic sections handling.
2424 Returns : True/False as the return status. */
2427 elf_arc_finish_dynamic_sections (bfd
* output_bfd
,
2428 struct bfd_link_info
*info
)
2430 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2431 bfd
*dynobj
= (elf_hash_table (info
))->dynobj
;
2432 asection
*sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
2436 Elf32_External_Dyn
*dyncon
, *dynconend
;
2438 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
2440 = (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
2441 for (; dyncon
< dynconend
; dyncon
++)
2443 Elf_Internal_Dyn internal_dyn
;
2444 bfd_boolean do_it
= FALSE
;
2446 struct elf_link_hash_entry
*h
= NULL
;
2449 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &internal_dyn
);
2451 switch (internal_dyn
.d_tag
)
2453 GET_SYMBOL_OR_SECTION (DT_INIT
, info
->init_function
, NULL
)
2454 GET_SYMBOL_OR_SECTION (DT_FINI
, info
->fini_function
, NULL
)
2455 GET_SYMBOL_OR_SECTION (DT_PLTGOT
, NULL
, ".plt")
2456 GET_SYMBOL_OR_SECTION (DT_JMPREL
, NULL
, ".rela.plt")
2457 GET_SYMBOL_OR_SECTION (DT_PLTRELSZ
, NULL
, ".rela.plt")
2458 GET_SYMBOL_OR_SECTION (DT_VERSYM
, NULL
, ".gnu.version")
2459 GET_SYMBOL_OR_SECTION (DT_VERDEF
, NULL
, ".gnu.version_d")
2460 GET_SYMBOL_OR_SECTION (DT_VERNEED
, NULL
, ".gnu.version_r")
2465 /* In case the dynamic symbols should be updated with a symbol. */
2467 && (h
->root
.type
== bfd_link_hash_defined
2468 || h
->root
.type
== bfd_link_hash_defweak
))
2472 internal_dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
2473 asec_ptr
= h
->root
.u
.def
.section
;
2474 if (asec_ptr
->output_section
!= NULL
)
2476 internal_dyn
.d_un
.d_val
+=
2477 (asec_ptr
->output_section
->vma
2478 + asec_ptr
->output_offset
);
2482 /* The symbol is imported from another shared
2483 library and does not apply to this one. */
2484 internal_dyn
.d_un
.d_val
= 0;
2488 else if (s
!= NULL
) /* With a section information. */
2490 switch (internal_dyn
.d_tag
)
2497 internal_dyn
.d_un
.d_ptr
= (s
->output_section
->vma
2498 + s
->output_offset
);
2503 internal_dyn
.d_un
.d_val
= s
->size
;
2513 bfd_elf32_swap_dyn_out (output_bfd
, &internal_dyn
, dyncon
);
2516 if (htab
->splt
->size
> 0)
2518 relocate_plt_for_entry (output_bfd
, info
);
2521 /* TODO: Validate this. */
2522 if (htab
->srelplt
->output_section
!= bfd_abs_section_ptr
)
2523 elf_section_data (htab
->srelplt
->output_section
)
2524 ->this_hdr
.sh_entsize
= 12;
2527 /* Fill in the first three entries in the global offset table. */
2530 struct elf_link_hash_entry
*h
;
2531 h
= elf_link_hash_lookup (elf_hash_table (info
), "_GLOBAL_OFFSET_TABLE_",
2532 FALSE
, FALSE
, TRUE
);
2534 if (h
!= NULL
&& h
->root
.type
!= bfd_link_hash_undefined
2535 && h
->root
.u
.def
.section
!= NULL
)
2537 asection
*sec
= h
->root
.u
.def
.section
;
2540 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
2543 bfd_put_32 (output_bfd
,
2544 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
2546 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sec
->contents
+ 4);
2547 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sec
->contents
+ 8);
2554 #define ADD_DYNAMIC_SYMBOL(NAME, TAG) \
2555 h = elf_link_hash_lookup (elf_hash_table (info), \
2556 NAME, FALSE, FALSE, FALSE); \
2557 if ((h != NULL && (h->ref_regular || h->def_regular))) \
2558 if (! _bfd_elf_add_dynamic_entry (info, TAG, 0)) \
2561 /* Set the sizes of the dynamic sections. */
2563 elf_arc_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
2564 struct bfd_link_info
*info
)
2568 bfd_boolean relocs_exist
= FALSE
;
2569 bfd_boolean reltext_exist
= FALSE
;
2570 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2572 dynobj
= htab
->dynobj
;
2573 BFD_ASSERT (dynobj
!= NULL
);
2575 if (htab
->dynamic_sections_created
)
2577 struct elf_link_hash_entry
*h
;
2579 /* Set the contents of the .interp section to the
2581 if (bfd_link_executable (info
) && !info
->nointerp
)
2583 s
= bfd_get_section_by_name (dynobj
, ".interp");
2584 BFD_ASSERT (s
!= NULL
);
2585 s
->size
= sizeof (ELF_DYNAMIC_INTERPRETER
);
2586 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2589 /* Add some entries to the .dynamic section. We fill in some of
2590 the values later, in elf_bfd_final_link, but we must add the
2591 entries now so that we know the final size of the .dynamic
2592 section. Checking if the .init section is present. We also
2593 create DT_INIT and DT_FINI entries if the init_str has been
2594 changed by the user. */
2595 ADD_DYNAMIC_SYMBOL (info
->init_function
, DT_INIT
);
2596 ADD_DYNAMIC_SYMBOL (info
->fini_function
, DT_FINI
);
2600 /* We may have created entries in the .rela.got section.
2601 However, if we are not creating the dynamic sections, we will
2602 not actually use these entries. Reset the size of .rela.got,
2603 which will cause it to get stripped from the output file
2605 if (htab
->srelgot
!= NULL
)
2606 htab
->srelgot
->size
= 0;
2609 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2611 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2616 || s
== htab
->sgotplt
2617 || s
== htab
->sdynbss
)
2619 /* Strip this section if we don't need it. */
2621 else if (strncmp (s
->name
, ".rela", 5) == 0)
2623 if (s
->size
!= 0 && s
!= htab
->srelplt
)
2627 const char *name
= s
->name
+ 5;
2629 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
2630 if (bfd_get_flavour (ibfd
) == bfd_target_elf_flavour
)
2632 asection
*target
= bfd_get_section_by_name (ibfd
, name
);
2634 && elf_section_data (target
)->sreloc
== s
2635 && ((target
->output_section
->flags
2636 & (SEC_READONLY
| SEC_ALLOC
))
2637 == (SEC_READONLY
| SEC_ALLOC
)))
2639 reltext_exist
= TRUE
;
2644 relocs_exist
= TRUE
;
2647 /* We use the reloc_count field as a counter if we need to
2648 copy relocs into the output file. */
2653 /* It's not one of our sections, so don't allocate space. */
2659 s
->flags
|= SEC_EXCLUDE
;
2663 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
2666 /* Allocate memory for the section contents. */
2667 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
2668 if (s
->contents
== NULL
)
2672 if (htab
->dynamic_sections_created
)
2674 /* TODO: Check if this is needed. */
2675 if (!bfd_link_pic (info
))
2676 if (!_bfd_elf_add_dynamic_entry (info
, DT_DEBUG
, 0))
2679 if (htab
->splt
&& (htab
->splt
->flags
& SEC_EXCLUDE
) == 0)
2680 if (!_bfd_elf_add_dynamic_entry (info
, DT_PLTGOT
, 0)
2681 || !_bfd_elf_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
2682 || !_bfd_elf_add_dynamic_entry (info
, DT_PLTREL
, DT_RELA
)
2683 || !_bfd_elf_add_dynamic_entry (info
, DT_JMPREL
, 0))
2687 if (!_bfd_elf_add_dynamic_entry (info
, DT_RELA
, 0)
2688 || !_bfd_elf_add_dynamic_entry (info
, DT_RELASZ
, 0)
2689 || !_bfd_elf_add_dynamic_entry (info
, DT_RELAENT
,
2690 sizeof (Elf32_External_Rela
)))
2694 if (!_bfd_elf_add_dynamic_entry (info
, DT_TEXTREL
, 0))
2702 /* Classify dynamic relocs such that -z combreloc can reorder and combine
2704 static enum elf_reloc_type_class
2705 elf32_arc_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2706 const asection
*rel_sec ATTRIBUTE_UNUSED
,
2707 const Elf_Internal_Rela
*rela
)
2709 switch ((int) ELF32_R_TYPE (rela
->r_info
))
2711 case R_ARC_RELATIVE
:
2712 return reloc_class_relative
;
2713 case R_ARC_JMP_SLOT
:
2714 return reloc_class_plt
;
2716 return reloc_class_copy
;
2717 /* TODO: Needed in future to support ifunc. */
2719 case R_ARC_IRELATIVE:
2720 return reloc_class_ifunc;
2723 return reloc_class_normal
;
2727 const struct elf_size_info arc_elf32_size_info
=
2729 sizeof (Elf32_External_Ehdr
),
2730 sizeof (Elf32_External_Phdr
),
2731 sizeof (Elf32_External_Shdr
),
2732 sizeof (Elf32_External_Rel
),
2733 sizeof (Elf32_External_Rela
),
2734 sizeof (Elf32_External_Sym
),
2735 sizeof (Elf32_External_Dyn
),
2736 sizeof (Elf_External_Note
),
2740 ELFCLASS32
, EV_CURRENT
,
2741 bfd_elf32_write_out_phdrs
,
2742 bfd_elf32_write_shdrs_and_ehdr
,
2743 bfd_elf32_checksum_contents
,
2744 bfd_elf32_write_relocs
,
2745 bfd_elf32_swap_symbol_in
,
2746 bfd_elf32_swap_symbol_out
,
2747 bfd_elf32_slurp_reloc_table
,
2748 bfd_elf32_slurp_symbol_table
,
2749 bfd_elf32_swap_dyn_in
,
2750 bfd_elf32_swap_dyn_out
,
2751 bfd_elf32_swap_reloc_in
,
2752 bfd_elf32_swap_reloc_out
,
2753 bfd_elf32_swap_reloca_in
,
2754 bfd_elf32_swap_reloca_out
2757 #define elf_backend_size_info arc_elf32_size_info
2759 /* Hook called by the linker routine which adds symbols from an object
2763 elf_arc_add_symbol_hook (bfd
* abfd
,
2764 struct bfd_link_info
* info
,
2765 Elf_Internal_Sym
* sym
,
2766 const char ** namep ATTRIBUTE_UNUSED
,
2767 flagword
* flagsp ATTRIBUTE_UNUSED
,
2768 asection
** secp ATTRIBUTE_UNUSED
,
2769 bfd_vma
* valp ATTRIBUTE_UNUSED
)
2771 if (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
2772 && (abfd
->flags
& DYNAMIC
) == 0
2773 && bfd_get_flavour (info
->output_bfd
) == bfd_target_elf_flavour
)
2774 elf_tdata (info
->output_bfd
)->has_gnu_symbols
|= elf_gnu_symbol_ifunc
;
2779 /* GDB expects general purpose registers to be in section .reg. However Linux
2780 kernel doesn't create this section and instead writes registers to NOTE
2781 section. It is up to the binutils to create a pseudo-section .reg from the
2782 contents of NOTE. Also BFD will read pid and signal number from NOTE. This
2783 function relies on offsets inside elf_prstatus structure in Linux to be
2787 elf32_arc_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
2792 switch (note
->descsz
)
2797 case 236: /* sizeof (struct elf_prstatus) on Linux/arc. */
2799 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
2801 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
2804 size
= (40 * 4); /* There are 40 registers in user_regs_struct. */
2807 /* Make a ".reg/999" section. */
2808 return _bfd_elfcore_make_pseudosection (abfd
, ".reg", size
,
2809 note
->descpos
+ offset
);
2812 /* Determine whether an object attribute tag takes an integer, a
2816 elf32_arc_obj_attrs_arg_type (int tag
)
2818 if (tag
== Tag_ARC_CPU_name
2819 || tag
== Tag_ARC_ISA_config
2820 || tag
== Tag_ARC_ISA_apex
)
2821 return ATTR_TYPE_FLAG_STR_VAL
;
2822 else if (tag
< (Tag_ARC_ISA_mpy_option
+ 1))
2823 return ATTR_TYPE_FLAG_INT_VAL
;
2825 return (tag
& 1) != 0 ? ATTR_TYPE_FLAG_STR_VAL
: ATTR_TYPE_FLAG_INT_VAL
;
2828 /* Attribute numbers >=14 can be safely ignored. */
2831 elf32_arc_obj_attrs_handle_unknown (bfd
*abfd
, int tag
)
2833 if ((tag
& 127) < (Tag_ARC_ISA_mpy_option
+ 1))
2836 (_("%B: Unknown mandatory ARC object attribute %d."),
2838 bfd_set_error (bfd_error_bad_value
);
2844 (_("Warning: %B: Unknown ARC object attribute %d."),
2850 /* Handle an ARC specific section when reading an object file. This is
2851 called when bfd_section_from_shdr finds a section with an unknown
2855 elf32_arc_section_from_shdr (bfd
*abfd
,
2856 Elf_Internal_Shdr
* hdr
,
2860 switch (hdr
->sh_type
)
2862 case SHT_ARC_ATTRIBUTES
:
2869 if (!_bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2875 #define TARGET_LITTLE_SYM arc_elf32_le_vec
2876 #define TARGET_LITTLE_NAME "elf32-littlearc"
2877 #define TARGET_BIG_SYM arc_elf32_be_vec
2878 #define TARGET_BIG_NAME "elf32-bigarc"
2879 #define ELF_ARCH bfd_arch_arc
2880 #define ELF_TARGET_ID ARC_ELF_DATA
2881 #define ELF_MACHINE_CODE EM_ARC_COMPACT
2882 #define ELF_MACHINE_ALT1 EM_ARC_COMPACT2
2883 #define ELF_MAXPAGESIZE 0x2000
2885 #define bfd_elf32_bfd_link_hash_table_create arc_elf_link_hash_table_create
2887 #define bfd_elf32_bfd_merge_private_bfd_data arc_elf_merge_private_bfd_data
2888 #define bfd_elf32_bfd_reloc_type_lookup arc_elf32_bfd_reloc_type_lookup
2889 #define bfd_elf32_bfd_set_private_flags arc_elf_set_private_flags
2890 #define bfd_elf32_bfd_print_private_bfd_data arc_elf_print_private_bfd_data
2891 #define bfd_elf32_bfd_copy_private_bfd_data arc_elf_copy_private_bfd_data
2893 #define elf_info_to_howto_rel arc_info_to_howto_rel
2894 #define elf_backend_object_p arc_elf_object_p
2895 #define elf_backend_final_write_processing arc_elf_final_write_processing
2897 #define elf_backend_relocate_section elf_arc_relocate_section
2898 #define elf_backend_check_relocs elf_arc_check_relocs
2899 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
2901 #define elf_backend_reloc_type_class elf32_arc_reloc_type_class
2903 #define elf_backend_adjust_dynamic_symbol elf_arc_adjust_dynamic_symbol
2904 #define elf_backend_finish_dynamic_symbol elf_arc_finish_dynamic_symbol
2906 #define elf_backend_finish_dynamic_sections elf_arc_finish_dynamic_sections
2907 #define elf_backend_size_dynamic_sections elf_arc_size_dynamic_sections
2908 #define elf_backend_add_symbol_hook elf_arc_add_symbol_hook
2910 #define elf_backend_can_gc_sections 1
2911 #define elf_backend_want_got_plt 1
2912 #define elf_backend_plt_readonly 1
2913 #define elf_backend_rela_plts_and_copies_p 1
2914 #define elf_backend_want_plt_sym 0
2915 #define elf_backend_got_header_size 12
2916 #define elf_backend_dtrel_excludes_plt 1
2918 #define elf_backend_may_use_rel_p 0
2919 #define elf_backend_may_use_rela_p 1
2920 #define elf_backend_default_use_rela_p 1
2922 #define elf_backend_grok_prstatus elf32_arc_grok_prstatus
2924 #define elf_backend_default_execstack 0
2926 #undef elf_backend_obj_attrs_vendor
2927 #define elf_backend_obj_attrs_vendor "ARC"
2928 #undef elf_backend_obj_attrs_section
2929 #define elf_backend_obj_attrs_section ".ARC.attributes"
2930 #undef elf_backend_obj_attrs_arg_type
2931 #define elf_backend_obj_attrs_arg_type elf32_arc_obj_attrs_arg_type
2932 #undef elf_backend_obj_attrs_section_type
2933 #define elf_backend_obj_attrs_section_type SHT_ARC_ATTRIBUTES
2934 #define elf_backend_obj_attrs_handle_unknown elf32_arc_obj_attrs_handle_unknown
2936 #define elf_backend_section_from_shdr elf32_arc_section_from_shdr
2938 #include "elf32-target.h"