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
;
582 /* Skip the linker stubs file. This preserves previous behavior
583 of accepting unknown attributes in the first input file - but
585 if (ibfd
->flags
& BFD_LINKER_CREATED
)
588 /* Skip any input that hasn't attribute section.
589 This enables to link object files without attribute section with
591 if (bfd_get_section_by_name (ibfd
, sec_name
) == NULL
)
594 if (!elf_known_obj_attributes_proc (obfd
)[0].i
)
596 /* This is the first object. Copy the attributes. */
597 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
599 out_attr
= elf_known_obj_attributes_proc (obfd
);
601 /* Use the Tag_null value to indicate the attributes have been
608 in_attr
= elf_known_obj_attributes_proc (ibfd
);
609 out_attr
= elf_known_obj_attributes_proc (obfd
);
611 for (i
= LEAST_KNOWN_OBJ_ATTRIBUTE
; i
< NUM_KNOWN_OBJ_ATTRIBUTES
; i
++)
613 /* Merge this attribute with existing attributes. */
616 case Tag_ARC_PCS_config
:
617 if (out_attr
[i
].i
== 0)
618 out_attr
[i
].i
= in_attr
[i
].i
;
619 else if (in_attr
[i
].i
!= 0 && out_attr
[i
].i
!= in_attr
[i
].i
)
621 const char *tagval
[] = { "Absent", "Bare-metal/mwdt",
622 "Bare-metal/newlib", "Linux/uclibc",
624 BFD_ASSERT (in_attr
[i
].i
< 5);
625 BFD_ASSERT (out_attr
[i
].i
< 5);
626 /* It's sometimes ok to mix different configs, so this is only
629 (_("warning: %pB: conflicting platform configuration "
631 tagval
[in_attr
[i
].i
],
632 tagval
[out_attr
[i
].i
]);
636 case Tag_ARC_CPU_base
:
637 if (out_attr
[i
].i
== 0)
638 out_attr
[i
].i
= in_attr
[i
].i
;
639 else if (in_attr
[i
].i
!= 0 && out_attr
[i
].i
!= in_attr
[i
].i
640 && ((out_attr
[i
].i
+ in_attr
[i
].i
) < 6))
642 const char *tagval
[] = { "Absent", "ARC6xx", "ARC7xx",
644 BFD_ASSERT (in_attr
[i
].i
< 5);
645 BFD_ASSERT (out_attr
[i
].i
< 5);
646 /* We cannot mix code for different CPUs. */
648 (_("error: %pB: unable to merge CPU base attributes "
651 tagval
[in_attr
[i
].i
],
652 tagval
[out_attr
[i
].i
]);
658 /* The CPUs may be different, check if we can still mix
659 the objects against the output choosen CPU. */
660 unsigned in_feature
= 0;
661 unsigned out_feature
= 0;
662 char *p1
= in_attr
[Tag_ARC_ISA_config
].s
;
663 char *p2
= out_attr
[Tag_ARC_ISA_config
].s
;
666 unsigned opcode_map
[] = {0, ARC_OPCODE_ARC600
, ARC_OPCODE_ARC700
,
667 ARC_OPCODE_ARCv2EM
, ARC_OPCODE_ARCv2HS
};
669 BFD_ASSERT (in_attr
[i
].i
< (sizeof (opcode_map
)
670 / sizeof (unsigned)));
671 BFD_ASSERT (out_attr
[i
].i
< (sizeof (opcode_map
)
672 / sizeof (unsigned)));
673 cpu_out
= opcode_map
[out_attr
[i
].i
];
675 in_feature
= arc_extract_features (p1
);
676 out_feature
= arc_extract_features (p2
);
678 /* First, check if a feature is compatible with the
679 output object chosen CPU. */
680 for (j
= 0; j
< ARRAY_SIZE (bfd_feature_list
); j
++)
681 if (((in_feature
| out_feature
) & bfd_feature_list
[j
].feature
)
682 && (!(cpu_out
& bfd_feature_list
[j
].cpus
)))
685 (_("error: %pB: unable to merge ISA extension attributes "
687 obfd
, bfd_feature_list
[j
].name
);
691 /* Second, if we have compatible features with the
692 chosen CPU, check if they are compatible among
694 for (j
= 0; j
< ARRAY_SIZE (bfd_conflict_list
); j
++)
695 if (((in_feature
| out_feature
) & bfd_conflict_list
[j
])
696 == bfd_conflict_list
[j
])
699 for (k
= 0; k
< ARRAY_SIZE (bfd_feature_list
); k
++)
701 if (in_feature
& bfd_feature_list
[k
].feature
702 & bfd_conflict_list
[j
])
703 p1
= (char *) bfd_feature_list
[k
].name
;
704 if (out_feature
& bfd_feature_list
[k
].feature
705 & bfd_conflict_list
[j
])
706 p2
= (char *) bfd_feature_list
[k
].name
;
709 (_("error: %pB: conflicting ISA extension attributes "
715 /* Everithing is alright. */
716 out_feature
|= in_feature
;
718 for (j
= 0; j
< ARRAY_SIZE (bfd_feature_list
); j
++)
719 if (out_feature
& bfd_feature_list
[j
].feature
)
720 p1
= arc_stralloc (p1
, bfd_feature_list
[j
].attr
);
722 out_attr
[Tag_ARC_ISA_config
].s
=
723 _bfd_elf_attr_strdup (obfd
, p1
);
726 case Tag_ARC_CPU_variation
:
727 case Tag_ARC_ISA_mpy_option
:
728 case Tag_ARC_ABI_osver
:
729 /* Use the largest value specified. */
730 if (in_attr
[i
].i
> out_attr
[i
].i
)
731 out_attr
[i
].i
= in_attr
[i
].i
;
734 case Tag_ARC_CPU_name
:
737 case Tag_ARC_ABI_rf16
:
738 if (out_attr
[i
].i
== 0)
739 out_attr
[i
].i
= in_attr
[i
].i
;
740 else if (out_attr
[i
].i
!= in_attr
[i
].i
)
742 /* We cannot mix code with rf16 and without. */
744 (_("error: %pB: cannot mix rf16 with full register set %pB"),
750 case Tag_ARC_ABI_pic
:
753 case Tag_ARC_ABI_sda
:
757 case Tag_ARC_ABI_tls
:
759 const char *tagval
[] = { "Absent", "MWDT", "GNU" };
764 BFD_ASSERT (in_attr
[i
].i
< 3);
765 BFD_ASSERT (out_attr
[i
].i
< 3);
766 if (out_attr
[i
].i
!= 0 && in_attr
[i
].i
!= 0
767 && out_attr
[i
].i
!= in_attr
[i
].i
)
770 (_("error: %pB: conflicting attributes %s: %s with %s"),
772 tagval
[in_attr
[i
].i
],
773 tagval
[out_attr
[i
].i
]);
780 case Tag_ARC_ABI_double_size
:
781 tagname
= "Double size";
783 case Tag_ARC_ABI_enumsize
:
785 tagname
= "Enum size";
787 case Tag_ARC_ABI_exceptions
:
789 tagname
= "ABI exceptions";
791 if (out_attr
[i
].i
!= 0 && in_attr
[i
].i
!= 0
792 && out_attr
[i
].i
!= in_attr
[i
].i
)
795 (_("error: %pB: conflicting attributes %s"),
801 case Tag_ARC_ISA_apex
:
802 break; /* Do nothing for APEX attributes. */
804 case Tag_ARC_ISA_config
:
805 /* It is handled in Tag_ARC_CPU_base. */
810 = result
&& _bfd_elf_merge_unknown_attribute_low (ibfd
, obfd
, i
);
813 /* If out_attr was copied from in_attr then it won't have a type yet. */
814 if (in_attr
[i
].type
&& !out_attr
[i
].type
)
815 out_attr
[i
].type
= in_attr
[i
].type
;
818 /* Merge Tag_compatibility attributes and any common GNU ones. */
819 if (!_bfd_elf_merge_object_attributes (ibfd
, info
))
822 /* Check for any attributes not known on ARC. */
823 result
&= _bfd_elf_merge_unknown_attribute_list (ibfd
, obfd
);
828 /* Merge backend specific data from an object file to the output
829 object file when linking. */
832 arc_elf_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
834 bfd
*obfd
= info
->output_bfd
;
835 unsigned short mach_ibfd
;
836 static unsigned short mach_obfd
= EM_NONE
;
841 /* Check if we have the same endianess. */
842 if (! _bfd_generic_verify_endian_match (ibfd
, info
))
845 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
846 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
849 /* Collect ELF flags. */
850 in_flags
= elf_elfheader (ibfd
)->e_flags
& EF_ARC_MACH_MSK
;
851 out_flags
= elf_elfheader (obfd
)->e_flags
& EF_ARC_MACH_MSK
;
853 if (!elf_flags_init (obfd
)) /* First call, no flags set. */
855 elf_flags_init (obfd
) = TRUE
;
856 out_flags
= in_flags
;
859 if (!arc_elf_merge_attributes (ibfd
, info
))
862 /* Check to see if the input BFD actually contains any sections. Do
863 not short-circuit dynamic objects; their section list may be
864 emptied by elf_link_add_object_symbols. */
865 if (!(ibfd
->flags
& DYNAMIC
))
867 bfd_boolean null_input_bfd
= TRUE
;
868 bfd_boolean only_data_sections
= TRUE
;
870 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
872 if ((bfd_get_section_flags (ibfd
, sec
)
873 & (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
874 == (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
875 only_data_sections
= FALSE
;
877 null_input_bfd
= FALSE
;
880 if (null_input_bfd
|| only_data_sections
)
884 /* Complain about various flag/architecture mismatches. */
885 mach_ibfd
= elf_elfheader (ibfd
)->e_machine
;
886 if (mach_obfd
== EM_NONE
)
888 mach_obfd
= mach_ibfd
;
892 if (mach_ibfd
!= mach_obfd
)
894 /* xgettext:c-format */
895 _bfd_error_handler (_("error: attempting to link %pB "
896 "with a binary %pB of different architecture"),
900 else if ((in_flags
!= out_flags
)
901 /* If we have object attributes, then we already
902 checked the objects compatibility, skip it. */
903 && !bfd_elf_get_obj_attr_int (ibfd
, OBJ_ATTR_PROC
,
906 /* Warn if different flags. */
908 /* xgettext:c-format */
909 (_("%pB: uses different e_flags (%#x) fields than "
910 "previous modules (%#x)"),
911 ibfd
, in_flags
, out_flags
);
912 if (in_flags
&& out_flags
)
914 /* MWDT doesnt set the eflags hence make sure we choose the
915 eflags set by gcc. */
916 in_flags
= in_flags
> out_flags
? in_flags
: out_flags
;
920 /* Everything is correct; don't change the output flags. */
921 in_flags
= out_flags
;
925 /* Update the flags. */
926 elf_elfheader (obfd
)->e_flags
= in_flags
;
928 if (bfd_get_mach (obfd
) < bfd_get_mach (ibfd
))
930 return bfd_set_arch_mach (obfd
, bfd_arch_arc
, bfd_get_mach (ibfd
));
936 /* Return a best guess for the machine number based on the attributes. */
939 bfd_arc_get_mach_from_attributes (bfd
* abfd
)
941 int arch
= bfd_elf_get_obj_attr_int (abfd
, OBJ_ATTR_PROC
, Tag_ARC_CPU_base
);
942 unsigned e_machine
= elf_elfheader (abfd
)->e_machine
;
947 return bfd_mach_arc_arc600
;
949 return bfd_mach_arc_arc700
;
952 return bfd_mach_arc_arcv2
;
956 return (e_machine
== EM_ARC_COMPACT
)
957 ? bfd_mach_arc_arc700
: bfd_mach_arc_arcv2
;
960 /* Set the right machine number for an ARC ELF file. */
962 arc_elf_object_p (bfd
* abfd
)
964 /* Make sure this is initialised, or you'll have the potential of passing
965 garbage---or misleading values---into the call to
966 bfd_default_set_arch_mach (). */
967 unsigned int mach
= bfd_mach_arc_arc700
;
968 unsigned long arch
= elf_elfheader (abfd
)->e_flags
& EF_ARC_MACH_MSK
;
969 unsigned e_machine
= elf_elfheader (abfd
)->e_machine
;
971 if (e_machine
== EM_ARC_COMPACT
|| e_machine
== EM_ARC_COMPACT2
)
975 case E_ARC_MACH_ARC600
:
976 mach
= bfd_mach_arc_arc600
;
978 case E_ARC_MACH_ARC601
:
979 mach
= bfd_mach_arc_arc601
;
981 case E_ARC_MACH_ARC700
:
982 mach
= bfd_mach_arc_arc700
;
984 case EF_ARC_CPU_ARCV2HS
:
985 case EF_ARC_CPU_ARCV2EM
:
986 mach
= bfd_mach_arc_arcv2
;
989 mach
= bfd_arc_get_mach_from_attributes (abfd
);
995 if (e_machine
== EM_ARC
)
998 (_("error: the ARC4 architecture is no longer supported"));
1004 (_("warning: unset or old architecture flags; "
1005 "use default machine"));
1009 return bfd_default_set_arch_mach (abfd
, bfd_arch_arc
, mach
);
1012 /* The final processing done just before writing out an ARC ELF object file.
1013 This gets the ARC architecture right based on the machine number. */
1016 arc_elf_final_write_processing (bfd
* abfd
,
1017 bfd_boolean linker ATTRIBUTE_UNUSED
)
1020 int osver
= bfd_elf_get_obj_attr_int (abfd
, OBJ_ATTR_PROC
,
1022 flagword e_flags
= elf_elfheader (abfd
)->e_flags
& ~EF_ARC_OSABI_MSK
;
1024 switch (bfd_get_mach (abfd
))
1026 case bfd_mach_arc_arc600
:
1027 emf
= EM_ARC_COMPACT
;
1029 case bfd_mach_arc_arc601
:
1030 emf
= EM_ARC_COMPACT
;
1032 case bfd_mach_arc_arc700
:
1033 emf
= EM_ARC_COMPACT
;
1035 case bfd_mach_arc_arcv2
:
1036 emf
= EM_ARC_COMPACT2
;
1042 elf_elfheader (abfd
)->e_machine
= emf
;
1044 /* Record whatever is the current syscall ABI version. */
1046 e_flags
|= ((osver
& 0x0f) << 8);
1048 e_flags
|= E_ARC_OSABI_V3
;
1050 elf_elfheader (abfd
)->e_flags
|= e_flags
;
1053 #ifdef ARC_ENABLE_DEBUG
1054 #define DEBUG_ARC_RELOC(A) debug_arc_reloc (A)
1057 debug_arc_reloc (struct arc_relocation_data reloc_data
)
1059 ARC_DEBUG ("Reloc type=%s, should_relocate = %s\n",
1060 reloc_data
.howto
->name
,
1061 reloc_data
.should_relocate
? "true" : "false");
1062 ARC_DEBUG (" offset = 0x%x, addend = 0x%x\n",
1063 (unsigned int) reloc_data
.reloc_offset
,
1064 (unsigned int) reloc_data
.reloc_addend
);
1065 ARC_DEBUG (" Symbol:\n");
1066 ARC_DEBUG (" value = 0x%08x\n",
1067 (unsigned int) reloc_data
.sym_value
);
1068 if (reloc_data
.sym_section
!= NULL
)
1070 ARC_DEBUG (" Symbol Section:\n");
1071 ARC_DEBUG (" section name = %s, output_offset 0x%08x",
1072 reloc_data
.sym_section
->name
,
1073 (unsigned int) reloc_data
.sym_section
->output_offset
);
1074 if (reloc_data
.sym_section
->output_section
!= NULL
)
1075 ARC_DEBUG (", output_section->vma = 0x%08x",
1076 ((unsigned int) reloc_data
.sym_section
->output_section
->vma
));
1078 if (reloc_data
.sym_section
->owner
&& reloc_data
.sym_section
->owner
->filename
)
1079 ARC_DEBUG (" file: %s\n", reloc_data
.sym_section
->owner
->filename
);
1083 ARC_DEBUG (" symbol section is NULL\n");
1086 ARC_DEBUG (" Input_section:\n");
1087 if (reloc_data
.input_section
!= NULL
)
1089 ARC_DEBUG (" section name = %s, output_offset 0x%08x, output_section->vma = 0x%08x\n",
1090 reloc_data
.input_section
->name
,
1091 (unsigned int) reloc_data
.input_section
->output_offset
,
1092 (unsigned int) reloc_data
.input_section
->output_section
->vma
);
1093 ARC_DEBUG (" changed_address = 0x%08x\n",
1094 (unsigned int) (reloc_data
.input_section
->output_section
->vma
1095 + reloc_data
.input_section
->output_offset
1096 + reloc_data
.reloc_offset
));
1097 ARC_DEBUG (" file: %s\n", reloc_data
.input_section
->owner
->filename
);
1101 ARC_DEBUG (" input section is NULL\n");
1105 #define DEBUG_ARC_RELOC(A)
1106 #endif /* ARC_ENABLE_DEBUG */
1109 middle_endian_convert (bfd_vma insn
, bfd_boolean do_it
)
1114 = ((insn
& 0xffff0000) >> 16)
1115 | ((insn
& 0xffff) << 16);
1120 /* This function is called for relocations that are otherwise marked as NOT
1121 requiring overflow checks. In here we perform non-standard checks of
1122 the relocation value. */
1124 static inline bfd_reloc_status_type
1125 arc_special_overflow_checks (const struct arc_relocation_data reloc_data
,
1126 bfd_signed_vma relocation
,
1127 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1129 switch (reloc_data
.howto
->type
)
1131 case R_ARC_NPS_CMEM16
:
1132 if (((relocation
>> 16) & 0xffff) != NPS_CMEM_HIGH_VALUE
)
1134 if (reloc_data
.reloc_addend
== 0)
1136 /* xgettext:c-format */
1137 (_("%pB(%pA+%#" PRIx64
"): CMEM relocation to `%s' is invalid, "
1138 "16 MSB should be %#x (value is %#" PRIx64
")"),
1139 reloc_data
.input_section
->owner
,
1140 reloc_data
.input_section
,
1141 (uint64_t) reloc_data
.reloc_offset
,
1142 reloc_data
.symbol_name
,
1143 NPS_CMEM_HIGH_VALUE
,
1144 (uint64_t) relocation
);
1147 /* xgettext:c-format */
1148 (_("%pB(%pA+%#" PRIx64
"): CMEM relocation to `%s+%#" PRIx64
1149 "' is invalid, 16 MSB should be %#x (value is %#" PRIx64
")"),
1150 reloc_data
.input_section
->owner
,
1151 reloc_data
.input_section
,
1152 (uint64_t) reloc_data
.reloc_offset
,
1153 reloc_data
.symbol_name
,
1154 (uint64_t) reloc_data
.reloc_addend
,
1155 NPS_CMEM_HIGH_VALUE
,
1156 (uint64_t) relocation
);
1157 return bfd_reloc_overflow
;
1165 return bfd_reloc_ok
;
1168 #define ME(reloc) (reloc)
1170 #define IS_ME(FORMULA,BFD) ((strstr (FORMULA, "ME") != NULL) \
1171 && (!bfd_big_endian (BFD)))
1173 #define S ((bfd_signed_vma) (reloc_data.sym_value \
1174 + (reloc_data.sym_section->output_section != NULL ? \
1175 (reloc_data.sym_section->output_offset \
1176 + reloc_data.sym_section->output_section->vma) : 0)))
1177 #define L ((bfd_signed_vma) (reloc_data.sym_value \
1178 + (reloc_data.sym_section->output_section != NULL ? \
1179 (reloc_data.sym_section->output_offset \
1180 + reloc_data.sym_section->output_section->vma) : 0)))
1181 #define A (reloc_data.reloc_addend)
1183 #define G (reloc_data.got_offset_value)
1184 #define GOT (reloc_data.got_symbol_vma)
1185 #define GOT_BEGIN (htab->sgot->output_section->vma)
1188 /* P: relative offset to PCL The offset should be to the
1189 current location aligned to 32 bits. */
1190 #define P ((bfd_signed_vma) ( \
1192 (reloc_data.input_section->output_section != NULL ? \
1193 reloc_data.input_section->output_section->vma : 0) \
1194 + reloc_data.input_section->output_offset \
1195 + (reloc_data.reloc_offset - (bitsize >= 32 ? 4 : 0))) \
1197 #define PDATA ((bfd_signed_vma) ( \
1198 (reloc_data.input_section->output_section->vma \
1199 + reloc_data.input_section->output_offset \
1200 + (reloc_data.reloc_offset))))
1201 #define SECTSTART (bfd_signed_vma) (reloc_data.sym_section->output_section->vma \
1202 + reloc_data.sym_section->output_offset)
1203 #define JLI (bfd_signed_vma) (reloc_data.sym_section->output_section->vma)
1204 #define _SDA_BASE_ (bfd_signed_vma) (reloc_data.sdata_begin_symbol_vma)
1205 #define TLS_REL (bfd_signed_vma) \
1206 ((elf_hash_table (info))->tls_sec->output_section->vma)
1207 #define TLS_TBSS (8)
1211 #ifdef ARC_ENABLE_DEBUG
1212 #define PRINT_DEBUG_RELOC_INFO_BEFORE(FORMULA, TYPE) \
1215 asection *sym_section = reloc_data.sym_section; \
1216 asection *input_section = reloc_data.input_section; \
1217 ARC_DEBUG ("RELOC_TYPE = " TYPE "\n"); \
1218 ARC_DEBUG ("FORMULA = " FORMULA "\n"); \
1219 ARC_DEBUG ("S = %#lx\n", S); \
1220 ARC_DEBUG ("A = %#lx\n", A); \
1221 ARC_DEBUG ("L = %lx\n", L); \
1222 if (sym_section->output_section != NULL) \
1223 ARC_DEBUG ("symbol_section->vma = %#lx\n", \
1224 sym_section->output_section->vma \
1225 + sym_section->output_offset); \
1227 ARC_DEBUG ("symbol_section->vma = NULL\n"); \
1228 if (input_section->output_section != NULL) \
1229 ARC_DEBUG ("symbol_section->vma = %#lx\n", \
1230 input_section->output_section->vma \
1231 + input_section->output_offset); \
1233 ARC_DEBUG ("symbol_section->vma = NULL\n"); \
1234 ARC_DEBUG ("PCL = %#lx\n", P); \
1235 ARC_DEBUG ("P = %#lx\n", P); \
1236 ARC_DEBUG ("G = %#lx\n", G); \
1237 ARC_DEBUG ("SDA_OFFSET = %#lx\n", _SDA_BASE_); \
1238 ARC_DEBUG ("SDA_SET = %d\n", reloc_data.sdata_begin_symbol_vma_set); \
1239 ARC_DEBUG ("GOT_OFFSET = %#lx\n", GOT); \
1240 ARC_DEBUG ("relocation = %#08lx\n", relocation); \
1241 ARC_DEBUG ("before = %#08x\n", (unsigned) insn); \
1242 ARC_DEBUG ("data = %08x (%u) (%d)\n", (unsigned) relocation, \
1243 (unsigned) relocation, (int) relocation); \
1247 #define PRINT_DEBUG_RELOC_INFO_AFTER \
1250 ARC_DEBUG ("after = 0x%08x\n", (unsigned int) insn); \
1256 #define PRINT_DEBUG_RELOC_INFO_BEFORE(...)
1257 #define PRINT_DEBUG_RELOC_INFO_AFTER
1259 #endif /* ARC_ENABLE_DEBUG */
1261 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
1264 bfd_signed_vma bitsize ATTRIBUTE_UNUSED = BITSIZE; \
1265 relocation = FORMULA ; \
1266 PRINT_DEBUG_RELOC_INFO_BEFORE (#FORMULA, #TYPE); \
1267 insn = middle_endian_convert (insn, IS_ME (#FORMULA, abfd)); \
1268 insn = (* get_replace_function (abfd, TYPE)) (insn, relocation); \
1269 insn = middle_endian_convert (insn, IS_ME (#FORMULA, abfd)); \
1270 PRINT_DEBUG_RELOC_INFO_AFTER; \
1274 static bfd_reloc_status_type
1275 arc_do_relocation (bfd_byte
* contents
,
1276 struct arc_relocation_data reloc_data
,
1277 struct bfd_link_info
*info
)
1279 bfd_signed_vma relocation
= 0;
1281 bfd_vma orig_insn ATTRIBUTE_UNUSED
;
1282 bfd
* abfd
= reloc_data
.input_section
->owner
;
1283 struct elf_link_hash_table
*htab ATTRIBUTE_UNUSED
= elf_hash_table (info
);
1284 bfd_reloc_status_type flag
;
1286 if (!reloc_data
.should_relocate
)
1287 return bfd_reloc_ok
;
1289 switch (reloc_data
.howto
->size
)
1292 insn
= arc_bfd_get_32 (abfd
,
1293 contents
+ reloc_data
.reloc_offset
,
1294 reloc_data
.input_section
);
1297 insn
= arc_bfd_get_16 (abfd
,
1298 contents
+ reloc_data
.reloc_offset
,
1299 reloc_data
.input_section
);
1302 insn
= arc_bfd_get_8 (abfd
,
1303 contents
+ reloc_data
.reloc_offset
,
1304 reloc_data
.input_section
);
1314 switch (reloc_data
.howto
->type
)
1316 #include "elf/arc-reloc.def"
1323 /* Check for relocation overflow. */
1324 if (reloc_data
.howto
->complain_on_overflow
!= complain_overflow_dont
)
1325 flag
= bfd_check_overflow (reloc_data
.howto
->complain_on_overflow
,
1326 reloc_data
.howto
->bitsize
,
1327 reloc_data
.howto
->rightshift
,
1328 bfd_arch_bits_per_address (abfd
),
1331 flag
= arc_special_overflow_checks (reloc_data
, relocation
, info
);
1333 if (flag
!= bfd_reloc_ok
)
1335 ARC_DEBUG ("Relocation overflows !\n");
1336 DEBUG_ARC_RELOC (reloc_data
);
1337 ARC_DEBUG ("Relocation value = signed -> %d, unsigned -> %u"
1338 ", hex -> (0x%08x)\n",
1339 (int) relocation
, (unsigned) relocation
, (int) relocation
);
1344 /* Write updated instruction back to memory. */
1345 switch (reloc_data
.howto
->size
)
1348 arc_bfd_put_32 (abfd
, insn
,
1349 contents
+ reloc_data
.reloc_offset
,
1350 reloc_data
.input_section
);
1353 arc_bfd_put_16 (abfd
, insn
,
1354 contents
+ reloc_data
.reloc_offset
,
1355 reloc_data
.input_section
);
1358 arc_bfd_put_8 (abfd
, insn
,
1359 contents
+ reloc_data
.reloc_offset
,
1360 reloc_data
.input_section
);
1363 ARC_DEBUG ("size = %d\n", reloc_data
.howto
->size
);
1368 return bfd_reloc_ok
;
1384 #undef ARC_RELOC_HOWTO
1387 /* Relocate an arc ELF section.
1388 Function : elf_arc_relocate_section
1389 Brief : Relocate an arc section, by handling all the relocations
1390 appearing in that section.
1391 Args : output_bfd : The bfd being written to.
1392 info : Link information.
1393 input_bfd : The input bfd.
1394 input_section : The section being relocated.
1395 contents : contents of the section being relocated.
1396 relocs : List of relocations in the section.
1397 local_syms : is a pointer to the swapped in local symbols.
1398 local_section : is an array giving the section in the input file
1399 corresponding to the st_shndx field of each
1402 elf_arc_relocate_section (bfd
* output_bfd
,
1403 struct bfd_link_info
* info
,
1405 asection
* input_section
,
1406 bfd_byte
* contents
,
1407 Elf_Internal_Rela
* relocs
,
1408 Elf_Internal_Sym
* local_syms
,
1409 asection
** local_sections
)
1411 Elf_Internal_Shdr
* symtab_hdr
;
1412 struct elf_link_hash_entry
** sym_hashes
;
1413 Elf_Internal_Rela
* rel
;
1414 Elf_Internal_Rela
* wrel
;
1415 Elf_Internal_Rela
* relend
;
1416 struct elf_link_hash_table
* htab
= elf_hash_table (info
);
1418 symtab_hdr
= &((elf_tdata (input_bfd
))->symtab_hdr
);
1419 sym_hashes
= elf_sym_hashes (input_bfd
);
1421 rel
= wrel
= relocs
;
1422 relend
= relocs
+ input_section
->reloc_count
;
1423 for (; rel
< relend
; wrel
++, rel
++)
1425 enum elf_arc_reloc_type r_type
;
1426 reloc_howto_type
* howto
;
1427 unsigned long r_symndx
;
1428 struct elf_link_hash_entry
* h
;
1429 Elf_Internal_Sym
* sym
;
1431 struct elf_link_hash_entry
* h2
;
1433 bfd_boolean unresolved_reloc
= FALSE
;
1435 struct arc_relocation_data reloc_data
=
1439 .got_offset_value
= 0,
1441 .sym_section
= NULL
,
1443 .input_section
= NULL
,
1444 .sdata_begin_symbol_vma
= 0,
1445 .sdata_begin_symbol_vma_set
= FALSE
,
1446 .got_symbol_vma
= 0,
1447 .should_relocate
= FALSE
1450 r_type
= ELF32_R_TYPE (rel
->r_info
);
1452 if (r_type
>= (int) R_ARC_max
)
1454 bfd_set_error (bfd_error_bad_value
);
1457 howto
= arc_elf_howto (r_type
);
1459 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1461 /* If we are generating another .o file and the symbol in not
1462 local, skip this relocation. */
1463 if (bfd_link_relocatable (info
))
1465 /* This is a relocateable link. We don't have to change
1466 anything, unless the reloc is against a section symbol,
1467 in which case we have to adjust according to where the
1468 section symbol winds up in the output section. */
1470 /* Checks if this is a local symbol and thus the reloc
1471 might (will??) be against a section symbol. */
1472 if (r_symndx
< symtab_hdr
->sh_info
)
1474 sym
= local_syms
+ r_symndx
;
1475 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1477 sec
= local_sections
[r_symndx
];
1479 /* For RELA relocs. Just adjust the addend
1480 value in the relocation entry. */
1481 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
1483 ARC_DEBUG ("local symbols reloc (section=%d %s) seen in %s\n",
1484 (int) r_symndx
, local_sections
[r_symndx
]->name
,
1485 __PRETTY_FUNCTION__
);
1490 h2
= elf_link_hash_lookup (elf_hash_table (info
), "__SDATA_BEGIN__",
1491 FALSE
, FALSE
, TRUE
);
1493 if (!reloc_data
.sdata_begin_symbol_vma_set
1494 && h2
!= NULL
&& h2
->root
.type
!= bfd_link_hash_undefined
1495 && h2
->root
.u
.def
.section
->output_section
!= NULL
)
1496 /* TODO: Verify this condition. */
1498 reloc_data
.sdata_begin_symbol_vma
=
1499 (h2
->root
.u
.def
.value
1500 + h2
->root
.u
.def
.section
->output_section
->vma
);
1501 reloc_data
.sdata_begin_symbol_vma_set
= TRUE
;
1504 reloc_data
.input_section
= input_section
;
1505 reloc_data
.howto
= howto
;
1506 reloc_data
.reloc_offset
= rel
->r_offset
;
1507 reloc_data
.reloc_addend
= rel
->r_addend
;
1509 /* This is a final link. */
1514 if (r_symndx
< symtab_hdr
->sh_info
) /* A local symbol. */
1516 sym
= local_syms
+ r_symndx
;
1517 sec
= local_sections
[r_symndx
];
1521 bfd_boolean warned
, ignored
;
1522 bfd_vma relocation ATTRIBUTE_UNUSED
;
1524 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
1525 r_symndx
, symtab_hdr
, sym_hashes
,
1527 unresolved_reloc
, warned
, ignored
);
1529 /* TODO: This code is repeated from below. We should
1530 clean it and remove duplications.
1531 Sec is used check for discarded sections.
1532 Need to redesign code below. */
1534 /* Get the symbol's entry in the symtab. */
1535 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1537 while (h
->root
.type
== bfd_link_hash_indirect
1538 || h
->root
.type
== bfd_link_hash_warning
)
1539 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1541 /* If we have encountered a definition for this symbol. */
1542 if (h
->root
.type
== bfd_link_hash_defined
1543 || h
->root
.type
== bfd_link_hash_defweak
)
1545 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1546 sec
= h
->root
.u
.def
.section
;
1550 /* Clean relocs for symbols in discarded sections. */
1551 if (sec
!= NULL
&& discarded_section (sec
))
1553 _bfd_clear_contents (howto
, input_bfd
, input_section
,
1554 contents
+ rel
->r_offset
);
1558 /* For ld -r, remove relocations in debug sections against
1559 sections defined in discarded sections. Not done for
1560 eh_frame editing code expects to be present. */
1561 if (bfd_link_relocatable (info
)
1562 && (input_section
->flags
& SEC_DEBUGGING
))
1568 if (bfd_link_relocatable (info
))
1575 if (r_symndx
< symtab_hdr
->sh_info
) /* A local symbol. */
1577 reloc_data
.sym_value
= sym
->st_value
;
1578 reloc_data
.sym_section
= sec
;
1579 reloc_data
.symbol_name
=
1580 bfd_elf_string_from_elf_section (input_bfd
,
1581 symtab_hdr
->sh_link
,
1584 /* Mergeable section handling. */
1585 if ((sec
->flags
& SEC_MERGE
)
1586 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1590 rel
->r_addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
,
1591 &msec
, rel
->r_addend
);
1592 rel
->r_addend
-= (sec
->output_section
->vma
1593 + sec
->output_offset
1595 rel
->r_addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
1597 reloc_data
.reloc_addend
= rel
->r_addend
;
1600 BFD_ASSERT (htab
->sgot
!= NULL
|| !is_reloc_for_GOT (howto
));
1601 if (htab
->sgot
!= NULL
)
1602 reloc_data
.got_symbol_vma
= htab
->sgot
->output_section
->vma
1603 + htab
->sgot
->output_offset
;
1605 reloc_data
.should_relocate
= TRUE
;
1607 else /* Global symbol. */
1609 /* FIXME: We should use the RELOC_FOR_GLOBAL_SYMBOL macro
1610 (defined in elf-bfd.h) here. */
1612 /* Get the symbol's entry in the symtab. */
1613 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1615 while (h
->root
.type
== bfd_link_hash_indirect
1616 || h
->root
.type
== bfd_link_hash_warning
)
1618 struct elf_link_hash_entry
*h_old
= h
;
1619 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1620 if (h
->got
.glist
== 0 && h_old
->got
.glist
!= h
->got
.glist
)
1621 h
->got
.glist
= h_old
->got
.glist
;
1624 /* TODO: Need to validate what was the intention. */
1625 /* BFD_ASSERT ((h->dynindx == -1) || (h->forced_local != 0)); */
1626 reloc_data
.symbol_name
= h
->root
.root
.string
;
1628 /* If we have encountered a definition for this symbol. */
1629 if (h
->root
.type
== bfd_link_hash_defined
1630 || h
->root
.type
== bfd_link_hash_defweak
)
1632 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1633 reloc_data
.sym_section
= h
->root
.u
.def
.section
;
1635 reloc_data
.should_relocate
= TRUE
;
1637 if (is_reloc_for_GOT (howto
) && !bfd_link_pic (info
))
1639 /* TODO: Change it to use arc_do_relocation with
1640 ARC_32 reloc. Try to use ADD_RELA macro. */
1641 bfd_vma relocation
=
1642 reloc_data
.sym_value
+ reloc_data
.reloc_addend
1643 + (reloc_data
.sym_section
->output_section
!= NULL
?
1644 (reloc_data
.sym_section
->output_offset
1645 + reloc_data
.sym_section
->output_section
->vma
)
1648 BFD_ASSERT (h
->got
.glist
);
1649 bfd_vma got_offset
= h
->got
.glist
->offset
;
1650 bfd_put_32 (output_bfd
, relocation
,
1651 htab
->sgot
->contents
+ got_offset
);
1653 if (is_reloc_for_PLT (howto
) && h
->plt
.offset
!= (bfd_vma
) -1)
1655 /* TODO: This is repeated up here. */
1656 reloc_data
.sym_value
= h
->plt
.offset
;
1657 reloc_data
.sym_section
= htab
->splt
;
1660 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1662 /* Is weak symbol and has no definition. */
1663 if (is_reloc_for_GOT (howto
))
1665 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1666 reloc_data
.sym_section
= htab
->sgot
;
1667 reloc_data
.should_relocate
= TRUE
;
1669 else if (is_reloc_for_PLT (howto
)
1670 && h
->plt
.offset
!= (bfd_vma
) -1)
1672 /* TODO: This is repeated up here. */
1673 reloc_data
.sym_value
= h
->plt
.offset
;
1674 reloc_data
.sym_section
= htab
->splt
;
1675 reloc_data
.should_relocate
= TRUE
;
1682 if (is_reloc_for_GOT (howto
))
1684 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1685 reloc_data
.sym_section
= htab
->sgot
;
1687 reloc_data
.should_relocate
= TRUE
;
1689 else if (is_reloc_for_PLT (howto
))
1691 /* Fail if it is linking for PIE and the symbol is
1693 if (bfd_link_executable (info
))
1694 (*info
->callbacks
->undefined_symbol
)
1695 (info
, h
->root
.root
.string
, input_bfd
, input_section
,
1696 rel
->r_offset
, TRUE
);
1697 reloc_data
.sym_value
= h
->plt
.offset
;
1698 reloc_data
.sym_section
= htab
->splt
;
1700 reloc_data
.should_relocate
= TRUE
;
1702 else if (!bfd_link_pic (info
) || bfd_link_executable (info
))
1703 (*info
->callbacks
->undefined_symbol
)
1704 (info
, h
->root
.root
.string
, input_bfd
, input_section
,
1705 rel
->r_offset
, TRUE
);
1708 BFD_ASSERT (htab
->sgot
!= NULL
|| !is_reloc_for_GOT (howto
));
1709 if (htab
->sgot
!= NULL
)
1710 reloc_data
.got_symbol_vma
= htab
->sgot
->output_section
->vma
1711 + htab
->sgot
->output_offset
;
1714 if ((is_reloc_for_GOT (howto
)
1715 || is_reloc_for_TLS (howto
)))
1717 reloc_data
.should_relocate
= TRUE
;
1719 struct got_entry
**list
1720 = get_got_entry_list_for_symbol (output_bfd
, r_symndx
, h
);
1722 reloc_data
.got_offset_value
1723 = relocate_fix_got_relocs_for_got_info (list
,
1724 tls_type_for_reloc (howto
),
1735 create_got_dynrelocs_for_single_entry (
1736 got_entry_for_type (list
,
1737 arc_got_entry_type_for_reloc (howto
)),
1738 output_bfd
, info
, NULL
);
1743 #define IS_ARC_PCREL_TYPE(TYPE) \
1744 ( (TYPE == R_ARC_PC32) \
1745 || (TYPE == R_ARC_32_PCREL))
1752 case R_ARC_32_PCREL
:
1753 if (bfd_link_pic (info
)
1754 && (!IS_ARC_PCREL_TYPE (r_type
)
1758 && (!info
->symbolic
|| !h
->def_regular
))))
1760 Elf_Internal_Rela outrel
;
1762 bfd_boolean skip
= FALSE
;
1763 bfd_boolean relocate
= FALSE
;
1764 asection
*sreloc
= _bfd_elf_get_dynamic_reloc_section
1765 (input_bfd
, input_section
,
1768 BFD_ASSERT (sreloc
!= NULL
);
1770 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
1775 if (outrel
.r_offset
== (bfd_vma
) -1)
1778 outrel
.r_addend
= rel
->r_addend
;
1779 outrel
.r_offset
+= (input_section
->output_section
->vma
1780 + input_section
->output_offset
);
1784 memset (&outrel
, 0, sizeof outrel
);
1789 && (IS_ARC_PCREL_TYPE (r_type
)
1790 || !(bfd_link_executable (info
)
1791 || SYMBOLIC_BIND (info
, h
))
1792 || ! h
->def_regular
))
1794 BFD_ASSERT (h
!= NULL
);
1795 if ((input_section
->flags
& SEC_ALLOC
) != 0)
1800 BFD_ASSERT (h
->dynindx
!= -1);
1801 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
1805 /* Handle local symbols, they either do not have a
1806 global hash table entry (h == NULL), or are
1807 forced local due to a version script
1808 (h->forced_local), or the third condition is
1809 legacy, it appears to say something like, for
1810 links where we are pre-binding the symbols, or
1811 there's not an entry for this symbol in the
1812 dynamic symbol table, and it's a regular symbol
1813 not defined in a shared object, then treat the
1814 symbol as local, resolve it now. */
1816 /* outrel.r_addend = 0; */
1817 outrel
.r_info
= ELF32_R_INFO (0, R_ARC_RELATIVE
);
1820 BFD_ASSERT (sreloc
->contents
!= 0);
1822 loc
= sreloc
->contents
;
1823 loc
+= sreloc
->reloc_count
* sizeof (Elf32_External_Rela
);
1824 sreloc
->reloc_count
+= 1;
1826 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
1836 if (is_reloc_SDA_relative (howto
)
1837 && !reloc_data
.sdata_begin_symbol_vma_set
)
1840 ("error: linker symbol __SDATA_BEGIN__ not found");
1841 bfd_set_error (bfd_error_bad_value
);
1845 DEBUG_ARC_RELOC (reloc_data
);
1847 /* Make sure we have with a dynamic linker. In case of GOT and PLT
1848 the sym_section should point to .got or .plt respectively. */
1849 if ((is_reloc_for_GOT (howto
) || is_reloc_for_PLT (howto
))
1850 && reloc_data
.sym_section
== NULL
)
1853 (_("GOT and PLT relocations cannot be fixed with a non dynamic linker"));
1854 bfd_set_error (bfd_error_bad_value
);
1859 switch (arc_do_relocation (contents
, reloc_data
, info
))
1862 continue; /* The reloc processing loop. */
1864 case bfd_reloc_overflow
:
1865 (*info
->callbacks
->reloc_overflow
)
1866 (info
, (h
? &h
->root
: NULL
), reloc_data
.symbol_name
, howto
->name
, (bfd_vma
) 0,
1867 input_bfd
, input_section
, rel
->r_offset
);
1870 case bfd_reloc_undefined
:
1871 (*info
->callbacks
->undefined_symbol
)
1872 (info
, reloc_data
.symbol_name
, input_bfd
, input_section
, rel
->r_offset
, TRUE
);
1875 case bfd_reloc_other
:
1876 /* xgettext:c-format */
1877 msg
= _("%pB(%pA): warning: unaligned access to symbol '%s' in the small data area");
1880 case bfd_reloc_outofrange
:
1881 /* xgettext:c-format */
1882 msg
= _("%pB(%pA): internal error: out of range error");
1885 case bfd_reloc_notsupported
:
1886 /* xgettext:c-format */
1887 msg
= _("%pB(%pA): internal error: unsupported relocation error");
1890 case bfd_reloc_dangerous
:
1891 /* xgettext:c-format */
1892 msg
= _("%pB(%pA): internal error: dangerous relocation");
1896 /* xgettext:c-format */
1897 msg
= _("%pB(%pA): internal error: unknown error");
1902 _bfd_error_handler (msg
, input_bfd
, input_section
, reloc_data
.symbol_name
);
1909 #define elf_arc_hash_table(p) \
1910 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
1911 == ARC_ELF_DATA ? ((struct elf_arc_link_hash_table *) ((p)->hash)) : NULL)
1914 elf_arc_check_relocs (bfd
* abfd
,
1915 struct bfd_link_info
* info
,
1917 const Elf_Internal_Rela
* relocs
)
1919 Elf_Internal_Shdr
* symtab_hdr
;
1920 struct elf_link_hash_entry
** sym_hashes
;
1921 const Elf_Internal_Rela
* rel
;
1922 const Elf_Internal_Rela
* rel_end
;
1924 asection
* sreloc
= NULL
;
1925 struct elf_link_hash_table
* htab
= elf_hash_table (info
);
1927 if (bfd_link_relocatable (info
))
1930 if (htab
->dynobj
== NULL
)
1931 htab
->dynobj
= abfd
;
1933 dynobj
= (elf_hash_table (info
))->dynobj
;
1934 symtab_hdr
= &((elf_tdata (abfd
))->symtab_hdr
);
1935 sym_hashes
= elf_sym_hashes (abfd
);
1937 rel_end
= relocs
+ sec
->reloc_count
;
1938 for (rel
= relocs
; rel
< rel_end
; rel
++)
1940 enum elf_arc_reloc_type r_type
;
1941 reloc_howto_type
*howto
;
1942 unsigned long r_symndx
;
1943 struct elf_link_hash_entry
*h
;
1945 r_type
= ELF32_R_TYPE (rel
->r_info
);
1947 if (r_type
>= (int) R_ARC_max
)
1949 bfd_set_error (bfd_error_bad_value
);
1952 howto
= arc_elf_howto (r_type
);
1954 /* Load symbol information. */
1955 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1956 if (r_symndx
< symtab_hdr
->sh_info
) /* Is a local symbol. */
1958 else /* Global one. */
1959 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1965 /* During shared library creation, these relocs should not
1966 appear in a shared library (as memory will be read only
1967 and the dynamic linker can not resolve these. However
1968 the error should not occur for e.g. debugging or
1969 non-readonly sections. */
1971 && (bfd_link_dll (info
) && !bfd_link_pie (info
))
1972 && (sec
->flags
& SEC_ALLOC
) != 0
1973 && (sec
->flags
& SEC_READONLY
) != 0
1974 && ((sec
->flags
& SEC_CODE
) != 0
1975 || (sec
->flags
& SEC_DEBUGGING
) != 0))
1979 name
= h
->root
.root
.string
;
1981 /* bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL); */
1984 /* xgettext:c-format */
1985 (_("%pB: relocation %s against `%s' can not be used"
1986 " when making a shared object; recompile with -fPIC"),
1988 arc_elf_howto (r_type
)->name
,
1990 bfd_set_error (bfd_error_bad_value
);
1994 /* In some cases we are not setting the 'non_got_ref'
1995 flag, even though the relocations don't require a GOT
1996 access. We should extend the testing in this area to
1997 ensure that no significant cases are being missed. */
2002 case R_ARC_32_PCREL
:
2003 if ((bfd_link_pic (info
))
2004 && ((r_type
!= R_ARC_PC32
&& r_type
!= R_ARC_32_PCREL
)
2006 && (!info
->symbolic
|| !h
->def_regular
))))
2011 && ! htab
->dynamic_sections_created
2012 && ! _bfd_elf_link_create_dynamic_sections (abfd
, info
))
2014 sreloc
= _bfd_elf_make_dynamic_reloc_section (sec
, dynobj
,
2022 sreloc
->size
+= sizeof (Elf32_External_Rela
);
2029 if (is_reloc_for_PLT (howto
))
2037 /* Add info to the symbol got_entry_list. */
2038 if (is_reloc_for_GOT (howto
)
2039 || is_reloc_for_TLS (howto
))
2041 if (! _bfd_elf_create_got_section (dynobj
, info
))
2044 arc_fill_got_info_for_reloc (
2045 arc_got_entry_type_for_reloc (howto
),
2046 get_got_entry_list_for_symbol (abfd
, r_symndx
, h
),
2055 #define ELF_DYNAMIC_INTERPRETER "/sbin/ld-uClibc.so"
2057 static struct plt_version_t
*
2058 arc_get_plt_version (struct bfd_link_info
*info
)
2062 for (i
= 0; i
< 1; i
++)
2064 ARC_DEBUG ("%d: size1 = %d, size2 = %d\n", i
,
2065 (int) plt_versions
[i
].entry_size
,
2066 (int) plt_versions
[i
].elem_size
);
2069 if (bfd_get_mach (info
->output_bfd
) == bfd_mach_arc_arcv2
)
2071 if (bfd_link_pic (info
))
2072 return &(plt_versions
[ELF_ARCV2_PIC
]);
2074 return &(plt_versions
[ELF_ARCV2_ABS
]);
2078 if (bfd_link_pic (info
))
2079 return &(plt_versions
[ELF_ARC_PIC
]);
2081 return &(plt_versions
[ELF_ARC_ABS
]);
2086 add_symbol_to_plt (struct bfd_link_info
*info
)
2088 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2091 struct plt_version_t
*plt_data
= arc_get_plt_version (info
);
2093 /* If this is the first .plt entry, make room for the special first
2095 if (htab
->splt
->size
== 0)
2096 htab
->splt
->size
+= plt_data
->entry_size
;
2098 ret
= htab
->splt
->size
;
2100 htab
->splt
->size
+= plt_data
->elem_size
;
2101 ARC_DEBUG ("PLT_SIZE = %d\n", (int) htab
->splt
->size
);
2103 htab
->sgotplt
->size
+= 4;
2104 htab
->srelplt
->size
+= sizeof (Elf32_External_Rela
);
2109 #define PLT_DO_RELOCS_FOR_ENTRY(ABFD, DS, RELOCS) \
2110 plt_do_relocs_for_symbol (ABFD, DS, RELOCS, 0, 0)
2113 plt_do_relocs_for_symbol (bfd
*abfd
,
2114 struct elf_link_hash_table
*htab
,
2115 const struct plt_reloc
*reloc
,
2117 bfd_vma symbol_got_offset
)
2119 while (SYM_ONLY (reloc
->symbol
) != LAST_RELOC
)
2121 bfd_vma relocation
= 0;
2123 switch (SYM_ONLY (reloc
->symbol
))
2127 = htab
->sgotplt
->output_section
->vma
2128 + htab
->sgotplt
->output_offset
+ symbol_got_offset
;
2131 relocation
+= reloc
->addend
;
2133 if (IS_RELATIVE (reloc
->symbol
))
2135 bfd_vma reloc_offset
= reloc
->offset
;
2136 reloc_offset
-= (IS_INSN_32 (reloc
->symbol
)) ? 4 : 0;
2137 reloc_offset
-= (IS_INSN_24 (reloc
->symbol
)) ? 2 : 0;
2139 relocation
-= htab
->splt
->output_section
->vma
2140 + htab
->splt
->output_offset
2141 + plt_offset
+ reloc_offset
;
2144 /* TODO: being ME is not a property of the relocation but of the
2145 section of which is applying the relocation. */
2146 if (IS_MIDDLE_ENDIAN (reloc
->symbol
) && !bfd_big_endian (abfd
))
2149 = ((relocation
& 0xffff0000) >> 16)
2150 | ((relocation
& 0xffff) << 16);
2153 switch (reloc
->size
)
2156 bfd_put_32 (htab
->splt
->output_section
->owner
,
2158 htab
->splt
->contents
+ plt_offset
+ reloc
->offset
);
2162 reloc
= &(reloc
[1]); /* Jump to next relocation. */
2167 relocate_plt_for_symbol (bfd
*output_bfd
,
2168 struct bfd_link_info
*info
,
2169 struct elf_link_hash_entry
*h
)
2171 struct plt_version_t
*plt_data
= arc_get_plt_version (info
);
2172 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2174 bfd_vma plt_index
= (h
->plt
.offset
- plt_data
->entry_size
)
2175 / plt_data
->elem_size
;
2176 bfd_vma got_offset
= (plt_index
+ 3) * 4;
2178 ARC_DEBUG ("arc_info: PLT_OFFSET = %#lx, PLT_ENTRY_VMA = %#lx, \
2179 GOT_ENTRY_OFFSET = %#lx, GOT_ENTRY_VMA = %#lx, for symbol %s\n",
2180 (long) h
->plt
.offset
,
2181 (long) (htab
->splt
->output_section
->vma
2182 + htab
->splt
->output_offset
2185 (long) (htab
->sgotplt
->output_section
->vma
2186 + htab
->sgotplt
->output_offset
2188 h
->root
.root
.string
);
2192 uint16_t *ptr
= (uint16_t *) plt_data
->elem
;
2194 for (i
= 0; i
< plt_data
->elem_size
/2; i
++)
2196 uint16_t data
= ptr
[i
];
2197 bfd_put_16 (output_bfd
,
2199 htab
->splt
->contents
+ h
->plt
.offset
+ (i
*2));
2203 plt_do_relocs_for_symbol (output_bfd
, htab
,
2204 plt_data
->elem_relocs
,
2208 /* Fill in the entry in the global offset table. */
2209 bfd_put_32 (output_bfd
,
2210 (bfd_vma
) (htab
->splt
->output_section
->vma
2211 + htab
->splt
->output_offset
),
2212 htab
->sgotplt
->contents
+ got_offset
);
2214 /* TODO: Fill in the entry in the .rela.plt section. */
2216 Elf_Internal_Rela rel
;
2219 rel
.r_offset
= (htab
->sgotplt
->output_section
->vma
2220 + htab
->sgotplt
->output_offset
2224 BFD_ASSERT (h
->dynindx
!= -1);
2225 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARC_JMP_SLOT
);
2227 loc
= htab
->srelplt
->contents
;
2228 loc
+= plt_index
* sizeof (Elf32_External_Rela
); /* relA */
2229 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
2234 relocate_plt_for_entry (bfd
*abfd
,
2235 struct bfd_link_info
*info
)
2237 struct plt_version_t
*plt_data
= arc_get_plt_version (info
);
2238 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2242 uint16_t *ptr
= (uint16_t *) plt_data
->entry
;
2243 for (i
= 0; i
< plt_data
->entry_size
/2; i
++)
2245 uint16_t data
= ptr
[i
];
2248 htab
->splt
->contents
+ (i
*2));
2251 PLT_DO_RELOCS_FOR_ENTRY (abfd
, htab
, plt_data
->entry_relocs
);
2254 /* Desc : Adjust a symbol defined by a dynamic object and referenced
2255 by a regular object. The current definition is in some section of
2256 the dynamic object, but we're not including those sections. We
2257 have to change the definition to something the rest of the link can
2261 elf_arc_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2262 struct elf_link_hash_entry
*h
)
2265 bfd
*dynobj
= (elf_hash_table (info
))->dynobj
;
2266 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2268 if (h
->type
== STT_FUNC
2269 || h
->type
== STT_GNU_IFUNC
2270 || h
->needs_plt
== 1)
2272 if (!bfd_link_pic (info
) && !h
->def_dynamic
&& !h
->ref_dynamic
)
2274 /* This case can occur if we saw a PLT32 reloc in an input
2275 file, but the symbol was never referred to by a dynamic
2276 object. In such a case, we don't actually need to build
2277 a procedure linkage table, and we can just do a PC32
2279 BFD_ASSERT (h
->needs_plt
);
2283 /* Make sure this symbol is output as a dynamic symbol. */
2284 if (h
->dynindx
== -1 && !h
->forced_local
2285 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
2288 if (bfd_link_pic (info
)
2289 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2291 bfd_vma loc
= add_symbol_to_plt (info
);
2293 if (bfd_link_executable (info
) && !h
->def_regular
)
2295 h
->root
.u
.def
.section
= htab
->splt
;
2296 h
->root
.u
.def
.value
= loc
;
2298 h
->plt
.offset
= loc
;
2302 h
->plt
.offset
= (bfd_vma
) -1;
2308 /* If this is a weak symbol, and there is a real definition, the
2309 processor independent code will have arranged for us to see the
2310 real definition first, and we can just use the same value. */
2311 if (h
->is_weakalias
)
2313 struct elf_link_hash_entry
*def
= weakdef (h
);
2314 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
2315 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
2316 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
2320 /* This is a reference to a symbol defined by a dynamic object which
2321 is not a function. */
2323 /* If we are creating a shared library, we must presume that the
2324 only references to the symbol are via the global offset table.
2325 For such cases we need not do anything here; the relocations will
2326 be handled correctly by relocate_section. */
2327 if (!bfd_link_executable (info
))
2330 /* If there are no non-GOT references, we do not need a copy
2332 if (!h
->non_got_ref
)
2335 /* If -z nocopyreloc was given, we won't generate them either. */
2336 if (info
->nocopyreloc
)
2342 /* We must allocate the symbol in our .dynbss section, which will
2343 become part of the .bss section of the executable. There will be
2344 an entry for this symbol in the .dynsym section. The dynamic
2345 object will contain position independent code, so all references
2346 from the dynamic object to this symbol will go through the global
2347 offset table. The dynamic linker will use the .dynsym entry to
2348 determine the address it must put in the global offset table, so
2349 both the dynamic object and the regular object will refer to the
2350 same memory location for the variable. */
2355 /* We must generate a R_ARC_COPY reloc to tell the dynamic linker to
2356 copy the initial value out of the dynamic object and into the
2357 runtime process image. We need to remember the offset into the
2358 .rela.bss section we are going to use. */
2359 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
2361 struct elf_arc_link_hash_table
*arc_htab
= elf_arc_hash_table (info
);
2363 BFD_ASSERT (arc_htab
->elf
.srelbss
!= NULL
);
2364 arc_htab
->elf
.srelbss
->size
+= sizeof (Elf32_External_Rela
);
2368 /* TODO: Move this also to arc_hash_table. */
2369 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
2370 BFD_ASSERT (s
!= NULL
);
2372 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2375 /* Function : elf_arc_finish_dynamic_symbol
2376 Brief : Finish up dynamic symbol handling. We set the
2377 contents of various dynamic sections here.
2382 Returns : True/False as the return status. */
2385 elf_arc_finish_dynamic_symbol (bfd
* output_bfd
,
2386 struct bfd_link_info
*info
,
2387 struct elf_link_hash_entry
*h
,
2388 Elf_Internal_Sym
* sym
)
2390 if (h
->plt
.offset
!= (bfd_vma
) -1)
2392 relocate_plt_for_symbol (output_bfd
, info
, h
);
2394 if (!h
->def_regular
)
2396 /* Mark the symbol as undefined, rather than as defined in
2397 the .plt section. Leave the value alone. */
2398 sym
->st_shndx
= SHN_UNDEF
;
2403 /* This function traverses list of GOT entries and
2404 create respective dynamic relocs. */
2405 /* TODO: Make function to get list and not access the list directly. */
2406 /* TODO: Move function to relocate_section create this relocs eagerly. */
2407 create_got_dynrelocs_for_got_info (&h
->got
.glist
,
2414 struct elf_arc_link_hash_table
*arc_htab
= elf_arc_hash_table (info
);
2416 if (h
->dynindx
== -1
2417 || (h
->root
.type
!= bfd_link_hash_defined
2418 && h
->root
.type
!= bfd_link_hash_defweak
)
2419 || arc_htab
->elf
.srelbss
== NULL
)
2422 bfd_vma rel_offset
= (h
->root
.u
.def
.value
2423 + h
->root
.u
.def
.section
->output_section
->vma
2424 + h
->root
.u
.def
.section
->output_offset
);
2426 bfd_byte
* loc
= arc_htab
->elf
.srelbss
->contents
2427 + (arc_htab
->elf
.srelbss
->reloc_count
* sizeof (Elf32_External_Rela
));
2428 arc_htab
->elf
.srelbss
->reloc_count
++;
2430 Elf_Internal_Rela rel
;
2432 rel
.r_offset
= rel_offset
;
2434 BFD_ASSERT (h
->dynindx
!= -1);
2435 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARC_COPY
);
2437 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
2440 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2441 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2442 || strcmp (h
->root
.root
.string
, "__DYNAMIC") == 0
2443 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
2444 sym
->st_shndx
= SHN_ABS
;
2449 #define GET_SYMBOL_OR_SECTION(TAG, SYMBOL, SECTION) \
2451 if (SYMBOL != NULL) \
2452 h = elf_link_hash_lookup (elf_hash_table (info), \
2453 SYMBOL, FALSE, FALSE, TRUE); \
2454 else if (SECTION != NULL) \
2455 s = bfd_get_linker_section (dynobj, SECTION); \
2458 /* Function : elf_arc_finish_dynamic_sections
2459 Brief : Finish up the dynamic sections handling.
2464 Returns : True/False as the return status. */
2467 elf_arc_finish_dynamic_sections (bfd
* output_bfd
,
2468 struct bfd_link_info
*info
)
2470 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2471 bfd
*dynobj
= (elf_hash_table (info
))->dynobj
;
2472 asection
*sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
2476 Elf32_External_Dyn
*dyncon
, *dynconend
;
2478 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
2480 = (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
2481 for (; dyncon
< dynconend
; dyncon
++)
2483 Elf_Internal_Dyn internal_dyn
;
2484 bfd_boolean do_it
= FALSE
;
2486 struct elf_link_hash_entry
*h
= NULL
;
2489 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &internal_dyn
);
2491 switch (internal_dyn
.d_tag
)
2493 GET_SYMBOL_OR_SECTION (DT_INIT
, info
->init_function
, NULL
)
2494 GET_SYMBOL_OR_SECTION (DT_FINI
, info
->fini_function
, NULL
)
2495 GET_SYMBOL_OR_SECTION (DT_PLTGOT
, NULL
, ".plt")
2496 GET_SYMBOL_OR_SECTION (DT_JMPREL
, NULL
, ".rela.plt")
2497 GET_SYMBOL_OR_SECTION (DT_PLTRELSZ
, NULL
, ".rela.plt")
2498 GET_SYMBOL_OR_SECTION (DT_VERSYM
, NULL
, ".gnu.version")
2499 GET_SYMBOL_OR_SECTION (DT_VERDEF
, NULL
, ".gnu.version_d")
2500 GET_SYMBOL_OR_SECTION (DT_VERNEED
, NULL
, ".gnu.version_r")
2505 /* In case the dynamic symbols should be updated with a symbol. */
2507 && (h
->root
.type
== bfd_link_hash_defined
2508 || h
->root
.type
== bfd_link_hash_defweak
))
2512 internal_dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
2513 asec_ptr
= h
->root
.u
.def
.section
;
2514 if (asec_ptr
->output_section
!= NULL
)
2516 internal_dyn
.d_un
.d_val
+=
2517 (asec_ptr
->output_section
->vma
2518 + asec_ptr
->output_offset
);
2522 /* The symbol is imported from another shared
2523 library and does not apply to this one. */
2524 internal_dyn
.d_un
.d_val
= 0;
2528 else if (s
!= NULL
) /* With a section information. */
2530 switch (internal_dyn
.d_tag
)
2537 internal_dyn
.d_un
.d_ptr
= (s
->output_section
->vma
2538 + s
->output_offset
);
2543 internal_dyn
.d_un
.d_val
= s
->size
;
2553 bfd_elf32_swap_dyn_out (output_bfd
, &internal_dyn
, dyncon
);
2556 if (htab
->splt
->size
> 0)
2558 relocate_plt_for_entry (output_bfd
, info
);
2561 /* TODO: Validate this. */
2562 if (htab
->srelplt
->output_section
!= bfd_abs_section_ptr
)
2563 elf_section_data (htab
->srelplt
->output_section
)
2564 ->this_hdr
.sh_entsize
= 12;
2567 /* Fill in the first three entries in the global offset table. */
2570 struct elf_link_hash_entry
*h
;
2571 h
= elf_link_hash_lookup (elf_hash_table (info
), "_GLOBAL_OFFSET_TABLE_",
2572 FALSE
, FALSE
, TRUE
);
2574 if (h
!= NULL
&& h
->root
.type
!= bfd_link_hash_undefined
2575 && h
->root
.u
.def
.section
!= NULL
)
2577 asection
*sec
= h
->root
.u
.def
.section
;
2580 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
2583 bfd_put_32 (output_bfd
,
2584 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
2586 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sec
->contents
+ 4);
2587 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sec
->contents
+ 8);
2594 #define ADD_DYNAMIC_SYMBOL(NAME, TAG) \
2595 h = elf_link_hash_lookup (elf_hash_table (info), \
2596 NAME, FALSE, FALSE, FALSE); \
2597 if ((h != NULL && (h->ref_regular || h->def_regular))) \
2598 if (! _bfd_elf_add_dynamic_entry (info, TAG, 0)) \
2601 /* Set the sizes of the dynamic sections. */
2603 elf_arc_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
2604 struct bfd_link_info
*info
)
2608 bfd_boolean relocs_exist
= FALSE
;
2609 bfd_boolean reltext_exist
= FALSE
;
2610 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2612 dynobj
= htab
->dynobj
;
2613 BFD_ASSERT (dynobj
!= NULL
);
2615 if (htab
->dynamic_sections_created
)
2617 struct elf_link_hash_entry
*h
;
2619 /* Set the contents of the .interp section to the
2621 if (bfd_link_executable (info
) && !info
->nointerp
)
2623 s
= bfd_get_section_by_name (dynobj
, ".interp");
2624 BFD_ASSERT (s
!= NULL
);
2625 s
->size
= sizeof (ELF_DYNAMIC_INTERPRETER
);
2626 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2629 /* Add some entries to the .dynamic section. We fill in some of
2630 the values later, in elf_bfd_final_link, but we must add the
2631 entries now so that we know the final size of the .dynamic
2632 section. Checking if the .init section is present. We also
2633 create DT_INIT and DT_FINI entries if the init_str has been
2634 changed by the user. */
2635 ADD_DYNAMIC_SYMBOL (info
->init_function
, DT_INIT
);
2636 ADD_DYNAMIC_SYMBOL (info
->fini_function
, DT_FINI
);
2640 /* We may have created entries in the .rela.got section.
2641 However, if we are not creating the dynamic sections, we will
2642 not actually use these entries. Reset the size of .rela.got,
2643 which will cause it to get stripped from the output file
2645 if (htab
->srelgot
!= NULL
)
2646 htab
->srelgot
->size
= 0;
2649 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2651 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2656 || s
== htab
->sgotplt
2657 || s
== htab
->sdynbss
)
2659 /* Strip this section if we don't need it. */
2661 else if (strncmp (s
->name
, ".rela", 5) == 0)
2663 if (s
->size
!= 0 && s
!= htab
->srelplt
)
2667 const char *name
= s
->name
+ 5;
2669 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
2670 if (bfd_get_flavour (ibfd
) == bfd_target_elf_flavour
2671 && ibfd
->flags
& DYNAMIC
)
2673 asection
*target
= bfd_get_section_by_name (ibfd
, name
);
2675 && elf_section_data (target
)->sreloc
== s
2676 && ((target
->output_section
->flags
2677 & (SEC_READONLY
| SEC_ALLOC
))
2678 == (SEC_READONLY
| SEC_ALLOC
)))
2680 reltext_exist
= TRUE
;
2685 relocs_exist
= TRUE
;
2688 /* We use the reloc_count field as a counter if we need to
2689 copy relocs into the output file. */
2694 /* It's not one of our sections, so don't allocate space. */
2700 s
->flags
|= SEC_EXCLUDE
;
2704 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
2707 /* Allocate memory for the section contents. */
2708 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
2709 if (s
->contents
== NULL
)
2713 if (htab
->dynamic_sections_created
)
2715 /* TODO: Check if this is needed. */
2716 if (!bfd_link_pic (info
))
2717 if (!_bfd_elf_add_dynamic_entry (info
, DT_DEBUG
, 0))
2720 if (htab
->splt
&& (htab
->splt
->flags
& SEC_EXCLUDE
) == 0)
2721 if (!_bfd_elf_add_dynamic_entry (info
, DT_PLTGOT
, 0)
2722 || !_bfd_elf_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
2723 || !_bfd_elf_add_dynamic_entry (info
, DT_PLTREL
, DT_RELA
)
2724 || !_bfd_elf_add_dynamic_entry (info
, DT_JMPREL
, 0))
2728 if (!_bfd_elf_add_dynamic_entry (info
, DT_RELA
, 0)
2729 || !_bfd_elf_add_dynamic_entry (info
, DT_RELASZ
, 0)
2730 || !_bfd_elf_add_dynamic_entry (info
, DT_RELAENT
,
2731 sizeof (Elf32_External_Rela
)))
2735 if (!_bfd_elf_add_dynamic_entry (info
, DT_TEXTREL
, 0))
2743 /* Classify dynamic relocs such that -z combreloc can reorder and combine
2745 static enum elf_reloc_type_class
2746 elf32_arc_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2747 const asection
*rel_sec ATTRIBUTE_UNUSED
,
2748 const Elf_Internal_Rela
*rela
)
2750 switch ((int) ELF32_R_TYPE (rela
->r_info
))
2752 case R_ARC_RELATIVE
:
2753 return reloc_class_relative
;
2754 case R_ARC_JMP_SLOT
:
2755 return reloc_class_plt
;
2757 return reloc_class_copy
;
2758 /* TODO: Needed in future to support ifunc. */
2760 case R_ARC_IRELATIVE:
2761 return reloc_class_ifunc;
2764 return reloc_class_normal
;
2768 const struct elf_size_info arc_elf32_size_info
=
2770 sizeof (Elf32_External_Ehdr
),
2771 sizeof (Elf32_External_Phdr
),
2772 sizeof (Elf32_External_Shdr
),
2773 sizeof (Elf32_External_Rel
),
2774 sizeof (Elf32_External_Rela
),
2775 sizeof (Elf32_External_Sym
),
2776 sizeof (Elf32_External_Dyn
),
2777 sizeof (Elf_External_Note
),
2781 ELFCLASS32
, EV_CURRENT
,
2782 bfd_elf32_write_out_phdrs
,
2783 bfd_elf32_write_shdrs_and_ehdr
,
2784 bfd_elf32_checksum_contents
,
2785 bfd_elf32_write_relocs
,
2786 bfd_elf32_swap_symbol_in
,
2787 bfd_elf32_swap_symbol_out
,
2788 bfd_elf32_slurp_reloc_table
,
2789 bfd_elf32_slurp_symbol_table
,
2790 bfd_elf32_swap_dyn_in
,
2791 bfd_elf32_swap_dyn_out
,
2792 bfd_elf32_swap_reloc_in
,
2793 bfd_elf32_swap_reloc_out
,
2794 bfd_elf32_swap_reloca_in
,
2795 bfd_elf32_swap_reloca_out
2798 #define elf_backend_size_info arc_elf32_size_info
2800 /* GDB expects general purpose registers to be in section .reg. However Linux
2801 kernel doesn't create this section and instead writes registers to NOTE
2802 section. It is up to the binutils to create a pseudo-section .reg from the
2803 contents of NOTE. Also BFD will read pid and signal number from NOTE. This
2804 function relies on offsets inside elf_prstatus structure in Linux to be
2808 elf32_arc_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
2813 switch (note
->descsz
)
2818 case 236: /* sizeof (struct elf_prstatus) on Linux/arc. */
2820 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
2822 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
2825 size
= (40 * 4); /* There are 40 registers in user_regs_struct. */
2828 /* Make a ".reg/999" section. */
2829 return _bfd_elfcore_make_pseudosection (abfd
, ".reg", size
,
2830 note
->descpos
+ offset
);
2833 /* Determine whether an object attribute tag takes an integer, a
2837 elf32_arc_obj_attrs_arg_type (int tag
)
2839 if (tag
== Tag_ARC_CPU_name
2840 || tag
== Tag_ARC_ISA_config
2841 || tag
== Tag_ARC_ISA_apex
)
2842 return ATTR_TYPE_FLAG_STR_VAL
;
2843 else if (tag
< (Tag_ARC_ISA_mpy_option
+ 1))
2844 return ATTR_TYPE_FLAG_INT_VAL
;
2846 return (tag
& 1) != 0 ? ATTR_TYPE_FLAG_STR_VAL
: ATTR_TYPE_FLAG_INT_VAL
;
2849 /* Attribute numbers >=14 can be safely ignored. */
2852 elf32_arc_obj_attrs_handle_unknown (bfd
*abfd
, int tag
)
2854 if ((tag
& 127) < (Tag_ARC_ISA_mpy_option
+ 1))
2857 (_("%pB: unknown mandatory ARC object attribute %d"),
2859 bfd_set_error (bfd_error_bad_value
);
2865 (_("warning: %pB: unknown ARC object attribute %d"),
2871 /* Handle an ARC specific section when reading an object file. This is
2872 called when bfd_section_from_shdr finds a section with an unknown
2876 elf32_arc_section_from_shdr (bfd
*abfd
,
2877 Elf_Internal_Shdr
* hdr
,
2881 switch (hdr
->sh_type
)
2883 case SHT_ARC_ATTRIBUTES
:
2890 if (!_bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2896 #define TARGET_LITTLE_SYM arc_elf32_le_vec
2897 #define TARGET_LITTLE_NAME "elf32-littlearc"
2898 #define TARGET_BIG_SYM arc_elf32_be_vec
2899 #define TARGET_BIG_NAME "elf32-bigarc"
2900 #define ELF_ARCH bfd_arch_arc
2901 #define ELF_TARGET_ID ARC_ELF_DATA
2902 #define ELF_MACHINE_CODE EM_ARC_COMPACT
2903 #define ELF_MACHINE_ALT1 EM_ARC_COMPACT2
2904 #define ELF_MAXPAGESIZE 0x2000
2906 #define bfd_elf32_bfd_link_hash_table_create arc_elf_link_hash_table_create
2908 #define bfd_elf32_bfd_merge_private_bfd_data arc_elf_merge_private_bfd_data
2909 #define bfd_elf32_bfd_reloc_type_lookup arc_elf32_bfd_reloc_type_lookup
2910 #define bfd_elf32_bfd_set_private_flags arc_elf_set_private_flags
2911 #define bfd_elf32_bfd_print_private_bfd_data arc_elf_print_private_bfd_data
2912 #define bfd_elf32_bfd_copy_private_bfd_data arc_elf_copy_private_bfd_data
2914 #define elf_info_to_howto_rel arc_info_to_howto_rel
2915 #define elf_backend_object_p arc_elf_object_p
2916 #define elf_backend_final_write_processing arc_elf_final_write_processing
2918 #define elf_backend_relocate_section elf_arc_relocate_section
2919 #define elf_backend_check_relocs elf_arc_check_relocs
2920 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
2922 #define elf_backend_reloc_type_class elf32_arc_reloc_type_class
2924 #define elf_backend_adjust_dynamic_symbol elf_arc_adjust_dynamic_symbol
2925 #define elf_backend_finish_dynamic_symbol elf_arc_finish_dynamic_symbol
2927 #define elf_backend_finish_dynamic_sections elf_arc_finish_dynamic_sections
2928 #define elf_backend_size_dynamic_sections elf_arc_size_dynamic_sections
2930 #define elf_backend_can_gc_sections 1
2931 #define elf_backend_want_got_plt 1
2932 #define elf_backend_plt_readonly 1
2933 #define elf_backend_rela_plts_and_copies_p 1
2934 #define elf_backend_want_plt_sym 0
2935 #define elf_backend_got_header_size 12
2936 #define elf_backend_dtrel_excludes_plt 1
2938 #define elf_backend_may_use_rel_p 0
2939 #define elf_backend_may_use_rela_p 1
2940 #define elf_backend_default_use_rela_p 1
2942 #define elf_backend_grok_prstatus elf32_arc_grok_prstatus
2944 #define elf_backend_default_execstack 0
2946 #undef elf_backend_obj_attrs_vendor
2947 #define elf_backend_obj_attrs_vendor "ARC"
2948 #undef elf_backend_obj_attrs_section
2949 #define elf_backend_obj_attrs_section ".ARC.attributes"
2950 #undef elf_backend_obj_attrs_arg_type
2951 #define elf_backend_obj_attrs_arg_type elf32_arc_obj_attrs_arg_type
2952 #undef elf_backend_obj_attrs_section_type
2953 #define elf_backend_obj_attrs_section_type SHT_ARC_ATTRIBUTES
2954 #define elf_backend_obj_attrs_handle_unknown elf32_arc_obj_attrs_handle_unknown
2956 #define elf_backend_section_from_shdr elf32_arc_section_from_shdr
2958 #include "elf32-target.h"