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 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"
101 #undef ARC_RELOC_HOWTO
103 /* Try to minimize the amount of space occupied by relocation tables
104 on the ROM (not that the ROM won't be swamped by other ELF overhead). */
108 static ATTRIBUTE_UNUSED bfd_boolean
109 is_reloc_PC_relative (reloc_howto_type
*howto
)
111 return (strstr (howto
->name
, "PC") != NULL
) ? TRUE
: FALSE
;
115 is_reloc_SDA_relative (reloc_howto_type
*howto
)
117 return (strstr (howto
->name
, "SDA") != NULL
) ? TRUE
: FALSE
;
121 is_reloc_for_GOT (reloc_howto_type
* howto
)
123 if (strstr (howto
->name
, "TLS") != NULL
)
125 return (strstr (howto
->name
, "GOT") != NULL
) ? TRUE
: FALSE
;
129 is_reloc_for_PLT (reloc_howto_type
* howto
)
131 return (strstr (howto
->name
, "PLT") != NULL
) ? TRUE
: FALSE
;
135 is_reloc_for_TLS (reloc_howto_type
*howto
)
137 return (strstr (howto
->name
, "TLS") != NULL
) ? TRUE
: FALSE
;
140 struct arc_relocation_data
142 bfd_signed_vma reloc_offset
;
143 bfd_signed_vma reloc_addend
;
144 bfd_signed_vma got_offset_value
;
146 bfd_signed_vma sym_value
;
147 asection
* sym_section
;
149 reloc_howto_type
*howto
;
151 asection
* input_section
;
153 bfd_signed_vma sdata_begin_symbol_vma
;
154 bfd_boolean sdata_begin_symbol_vma_set
;
155 bfd_signed_vma got_symbol_vma
;
157 bfd_boolean should_relocate
;
159 const char * symbol_name
;
162 /* Should be included at this location due to static declarations
163 * defined before this point. */
166 #define arc_bfd_get_8(A,B,C) bfd_get_8(A,B)
167 #define arc_bfd_get_16(A,B,C) bfd_get_16(A,B)
168 #define arc_bfd_get_32(A,B,C) bfd_get_32(A,B)
169 #define arc_bfd_put_8(A,B,C,D) bfd_put_8(A,B,C)
170 #define arc_bfd_put_16(A,B,C,D) bfd_put_16(A,B,C)
171 #define arc_bfd_put_32(A,B,C,D) bfd_put_32(A,B,C)
174 static bfd_reloc_status_type
175 arc_elf_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
176 arelent
*reloc_entry
,
178 void *data ATTRIBUTE_UNUSED
,
179 asection
*input_section
,
181 char ** error_message ATTRIBUTE_UNUSED
)
183 if (output_bfd
!= NULL
)
185 reloc_entry
->address
+= input_section
->output_offset
;
187 /* In case of relocateable link and if the reloc is against a
188 section symbol, the addend needs to be adjusted according to
189 where the section symbol winds up in the output section. */
190 if ((symbol_in
->flags
& BSF_SECTION_SYM
) && symbol_in
->section
)
191 reloc_entry
->addend
+= symbol_in
->section
->output_offset
;
196 return bfd_reloc_continue
;
200 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
204 #include "elf/arc-reloc.def"
207 #undef ARC_RELOC_HOWTO
209 #define ARC_RELOC_HOWTO(TYPE, VALUE, RSIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
210 [TYPE] = HOWTO (R_##TYPE, 0, RSIZE, BITSIZE, FALSE, 0, \
211 complain_overflow_##OVERFLOW, arc_elf_reloc, \
212 "R_" #TYPE, FALSE, 0, 0, FALSE),
214 static struct reloc_howto_struct elf_arc_howto_table
[] =
216 #include "elf/arc-reloc.def"
217 /* Example of what is generated by the preprocessor. Currently kept as an
219 HOWTO (R_ARC_NONE, // Type.
221 2, // Size (0 = byte, 1 = short, 2 = long).
223 FALSE, // PC_relative.
225 complain_overflow_bitfield, // Complain_on_overflow.
226 bfd_elf_generic_reloc, // Special_function.
227 "R_ARC_NONE", // Name.
228 TRUE, // Partial_inplace.
231 FALSE), // PCrel_offset.
234 #undef ARC_RELOC_HOWTO
236 static void arc_elf_howto_init (void)
238 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
239 elf_arc_howto_table[TYPE].pc_relative = \
240 (strstr (#FORMULA, " P ") != NULL || strstr (#FORMULA, " PDATA ") != NULL); \
241 elf_arc_howto_table[TYPE].dst_mask = RELOC_FUNCTION(0, ~0); \
242 /* Only 32 bit data relocations should be marked as ME. */ \
243 if (strstr (#FORMULA, " ME ") != NULL) \
245 BFD_ASSERT (SIZE == 2); \
248 #include "elf/arc-reloc.def"
251 #undef ARC_RELOC_HOWTO
254 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
256 const int howto_table_lookup
[] =
258 #include "elf/arc-reloc.def"
260 #undef ARC_RELOC_HOWTO
262 static reloc_howto_type
*
263 arc_elf_howto (unsigned int r_type
)
265 if (elf_arc_howto_table
[R_ARC_32
].dst_mask
== 0)
266 arc_elf_howto_init ();
267 return &elf_arc_howto_table
[r_type
];
270 /* Map BFD reloc types to ARC ELF reloc types. */
274 bfd_reloc_code_real_type bfd_reloc_val
;
275 unsigned char elf_reloc_val
;
278 /* ARC ELF linker hash entry. */
279 struct elf_arc_link_hash_entry
281 struct elf_link_hash_entry root
;
283 /* Track dynamic relocs copied for this symbol. */
284 struct elf_dyn_relocs
*dyn_relocs
;
287 /* ARC ELF linker hash table. */
288 struct elf_arc_link_hash_table
290 struct elf_link_hash_table elf
;
293 static struct bfd_hash_entry
*
294 elf_arc_link_hash_newfunc (struct bfd_hash_entry
*entry
,
295 struct bfd_hash_table
*table
,
298 /* Allocate the structure if it has not already been allocated by a
302 entry
= (struct bfd_hash_entry
*)
303 bfd_hash_allocate (table
,
304 sizeof (struct elf_arc_link_hash_entry
));
309 /* Call the allocation method of the superclass. */
310 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
313 struct elf_arc_link_hash_entry
*eh
;
315 eh
= (struct elf_arc_link_hash_entry
*) entry
;
316 eh
->dyn_relocs
= NULL
;
322 /* Destroy an ARC ELF linker hash table. */
324 elf_arc_link_hash_table_free (bfd
*obfd
)
326 _bfd_elf_link_hash_table_free (obfd
);
329 /* Create an ARC ELF linker hash table. */
331 static struct bfd_link_hash_table
*
332 arc_elf_link_hash_table_create (bfd
*abfd
)
334 struct elf_arc_link_hash_table
*ret
;
336 ret
= (struct elf_arc_link_hash_table
*) bfd_zmalloc (sizeof (*ret
));
340 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
341 elf_arc_link_hash_newfunc
,
342 sizeof (struct elf_arc_link_hash_entry
),
349 ret
->elf
.init_got_refcount
.refcount
= 0;
350 ret
->elf
.init_got_refcount
.glist
= NULL
;
351 ret
->elf
.init_got_offset
.offset
= 0;
352 ret
->elf
.init_got_offset
.glist
= NULL
;
354 ret
->elf
.root
.hash_table_free
= elf_arc_link_hash_table_free
;
356 return &ret
->elf
.root
;
359 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
360 { BFD_RELOC_##TYPE, R_##TYPE },
361 static const struct arc_reloc_map arc_reloc_map
[] =
363 #include "elf/arc-reloc.def"
365 {BFD_RELOC_NONE
, R_ARC_NONE
},
366 {BFD_RELOC_8
, R_ARC_8
},
367 {BFD_RELOC_16
, R_ARC_16
},
368 {BFD_RELOC_24
, R_ARC_24
},
369 {BFD_RELOC_32
, R_ARC_32
},
371 #undef ARC_RELOC_HOWTO
373 typedef ATTRIBUTE_UNUSED
bfd_vma (*replace_func
) (unsigned, int ATTRIBUTE_UNUSED
);
375 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
377 func = (void *) RELOC_FUNCTION; \
380 get_replace_function (bfd
*abfd
, unsigned int r_type
)
386 #include "elf/arc-reloc.def"
389 if (func
== replace_bits24
&& bfd_big_endian (abfd
))
390 return (replace_func
) replace_bits24_be
;
392 return (replace_func
) func
;
394 #undef ARC_RELOC_HOWTO
396 static reloc_howto_type
*
397 arc_elf32_bfd_reloc_type_lookup (bfd
* abfd ATTRIBUTE_UNUSED
,
398 bfd_reloc_code_real_type code
)
402 for (i
= ARRAY_SIZE (arc_reloc_map
); i
--;)
404 if (arc_reloc_map
[i
].bfd_reloc_val
== code
)
405 return arc_elf_howto (arc_reloc_map
[i
].elf_reloc_val
);
411 /* Function to set the ELF flag bits. */
413 arc_elf_set_private_flags (bfd
*abfd
, flagword flags
)
415 elf_elfheader (abfd
)->e_flags
= flags
;
416 elf_flags_init (abfd
) = TRUE
;
420 /* Print private flags. */
422 arc_elf_print_private_bfd_data (bfd
*abfd
, void * ptr
)
424 FILE *file
= (FILE *) ptr
;
427 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
429 /* Print normal ELF private data. */
430 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
432 flags
= elf_elfheader (abfd
)->e_flags
;
433 fprintf (file
, _("private flags = 0x%lx:"), (unsigned long) flags
);
435 switch (flags
& EF_ARC_MACH_MSK
)
437 case EF_ARC_CPU_ARCV2HS
: fprintf (file
, " -mcpu=ARCv2HS"); break;
438 case EF_ARC_CPU_ARCV2EM
: fprintf (file
, " -mcpu=ARCv2EM"); break;
439 case E_ARC_MACH_ARC600
: fprintf (file
, " -mcpu=ARC600"); break;
440 case E_ARC_MACH_ARC601
: fprintf (file
, " -mcpu=ARC601"); break;
441 case E_ARC_MACH_ARC700
: fprintf (file
, " -mcpu=ARC700"); break;
443 fprintf (file
, "-mcpu=unknown");
447 switch (flags
& EF_ARC_OSABI_MSK
)
449 case E_ARC_OSABI_ORIG
: fprintf (file
, " (ABI:legacy)"); break;
450 case E_ARC_OSABI_V2
: fprintf (file
, " (ABI:v2)"); break;
451 case E_ARC_OSABI_V3
: fprintf (file
, " (ABI:v3)"); break;
452 case E_ARC_OSABI_V4
: fprintf (file
, " (ABI:v4)"); break;
454 fprintf (file
, " (ABI:unknown)");
462 /* Copy backend specific data from one object module to another. */
465 arc_elf_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
467 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
468 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
471 BFD_ASSERT (!elf_flags_init (obfd
)
472 || elf_elfheader (obfd
)->e_flags
== elf_elfheader (ibfd
)->e_flags
);
474 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
475 elf_flags_init (obfd
) = TRUE
;
477 /* Copy object attributes. */
478 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
480 return _bfd_elf_copy_private_bfd_data (ibfd
, obfd
);
483 static reloc_howto_type
*
484 bfd_elf32_bfd_reloc_name_lookup (bfd
* abfd ATTRIBUTE_UNUSED
,
489 for (i
= 0; i
< ARRAY_SIZE (elf_arc_howto_table
); i
++)
490 if (elf_arc_howto_table
[i
].name
!= NULL
491 && strcasecmp (elf_arc_howto_table
[i
].name
, r_name
) == 0)
492 return arc_elf_howto (i
);
497 /* Set the howto pointer for an ARC ELF reloc. */
500 arc_info_to_howto_rel (bfd
* abfd ATTRIBUTE_UNUSED
,
502 Elf_Internal_Rela
* dst
)
506 r_type
= ELF32_R_TYPE (dst
->r_info
);
507 BFD_ASSERT (r_type
< (unsigned int) R_ARC_max
);
508 cache_ptr
->howto
= arc_elf_howto (r_type
);
511 /* Extract CPU features from an NTBS. */
514 arc_extract_features (const char *p
)
521 for (i
= 0; i
< ARRAY_SIZE (bfd_feature_list
); i
++)
523 char *t
= strstr (p
, bfd_feature_list
[i
].attr
);
524 unsigned l
= strlen (bfd_feature_list
[i
].attr
);
528 r
|= bfd_feature_list
[i
].feature
;
534 /* Concatenate two strings. s1 can be NULL but not
538 arc_stralloc (char * s1
, const char * s2
)
542 /* Only s1 can be null. */
545 p
= s1
? concat (s1
, ",", s2
, NULL
) : (char *)s2
;
550 /* Merge ARC object attributes from IBFD into OBFD. Raise an error if
551 there are conflicting attributes. */
554 arc_elf_merge_attributes (bfd
*ibfd
, struct bfd_link_info
*info
)
556 bfd
*obfd
= info
->output_bfd
;
557 obj_attribute
*in_attr
;
558 obj_attribute
*out_attr
;
560 bfd_boolean result
= TRUE
;
561 const char *sec_name
= get_elf_backend_data (ibfd
)->obj_attrs_section
;
562 char *tagname
= NULL
;
564 /* Skip the linker stubs file. This preserves previous behavior
565 of accepting unknown attributes in the first input file - but
567 if (ibfd
->flags
& BFD_LINKER_CREATED
)
570 /* Skip any input that hasn't attribute section.
571 This enables to link object files without attribute section with
573 if (bfd_get_section_by_name (ibfd
, sec_name
) == NULL
)
576 if (!elf_known_obj_attributes_proc (obfd
)[0].i
)
578 /* This is the first object. Copy the attributes. */
579 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
581 out_attr
= elf_known_obj_attributes_proc (obfd
);
583 /* Use the Tag_null value to indicate the attributes have been
590 in_attr
= elf_known_obj_attributes_proc (ibfd
);
591 out_attr
= elf_known_obj_attributes_proc (obfd
);
593 for (i
= LEAST_KNOWN_OBJ_ATTRIBUTE
; i
< NUM_KNOWN_OBJ_ATTRIBUTES
; i
++)
595 /* Merge this attribute with existing attributes. */
598 case Tag_ARC_PCS_config
:
599 if (out_attr
[i
].i
== 0)
600 out_attr
[i
].i
= in_attr
[i
].i
;
601 else if (in_attr
[i
].i
!= 0 && out_attr
[i
].i
!= in_attr
[i
].i
)
603 const char *tagval
[] = { "Absent", "Bare-metal/mwdt",
604 "Bare-metal/newlib", "Linux/uclibc",
606 BFD_ASSERT (in_attr
[i
].i
< 5);
607 BFD_ASSERT (out_attr
[i
].i
< 5);
608 /* It's sometimes ok to mix different configs, so this is only
611 (_("Warning: %B: Conflicting platform configuration "
612 "%s with %s.\n"), ibfd
,
613 tagval
[in_attr
[i
].i
],
614 tagval
[out_attr
[i
].i
]);
618 case Tag_ARC_CPU_base
:
619 if (out_attr
[i
].i
== 0)
620 out_attr
[i
].i
= in_attr
[i
].i
;
621 else if (in_attr
[i
].i
!= 0 && out_attr
[i
].i
!= in_attr
[i
].i
622 && ((out_attr
[i
].i
+ in_attr
[i
].i
) < 6))
624 const char *tagval
[] = { "Absent", "ARC6xx", "ARC7xx",
626 BFD_ASSERT (in_attr
[i
].i
< 5);
627 BFD_ASSERT (out_attr
[i
].i
< 5);
628 /* We cannot mix code for different CPUs. */
630 (_("error: %B: unable to merge CPU base attributes "
633 tagval
[in_attr
[i
].i
],
634 tagval
[out_attr
[i
].i
]);
640 /* The CPUs may be different, check if we can still mix
641 the objects against the output choosen CPU. */
642 unsigned in_feature
= 0;
643 unsigned out_feature
= 0;
644 char *p1
= in_attr
[Tag_ARC_ISA_config
].s
;
645 char *p2
= out_attr
[Tag_ARC_ISA_config
].s
;
648 unsigned opcode_map
[] = {0, ARC_OPCODE_ARC600
, ARC_OPCODE_ARC700
,
649 ARC_OPCODE_ARCv2EM
, ARC_OPCODE_ARCv2HS
};
651 BFD_ASSERT (in_attr
[i
].i
< (sizeof (opcode_map
)
652 / sizeof (unsigned)));
653 BFD_ASSERT (out_attr
[i
].i
< (sizeof (opcode_map
)
654 / sizeof (unsigned)));
655 cpu_out
= opcode_map
[out_attr
[i
].i
];
657 in_feature
= arc_extract_features (p1
);
658 out_feature
= arc_extract_features (p2
);
660 /* First, check if a feature is compatible with the
661 output object chosen CPU. */
662 for (j
= 0; j
< ARRAY_SIZE (bfd_feature_list
); j
++)
663 if (((in_feature
| out_feature
) & bfd_feature_list
[j
].feature
)
664 && (!(cpu_out
& bfd_feature_list
[j
].cpus
)))
667 (_("error: %B: unable to merge ISA extension attributes "
669 obfd
, bfd_feature_list
[j
].name
);
673 /* Second, if we have compatible features with the
674 chosen CPU, check if they are compatible among
676 for (j
= 0; j
< ARRAY_SIZE (bfd_conflict_list
); j
++)
677 if (((in_feature
| out_feature
) & bfd_conflict_list
[j
])
678 == bfd_conflict_list
[j
])
681 for (k
= 0; k
< ARRAY_SIZE (bfd_feature_list
); k
++)
683 if (in_feature
& bfd_feature_list
[k
].feature
684 & bfd_conflict_list
[j
])
685 p1
= (char *) bfd_feature_list
[k
].name
;
686 if (out_feature
& bfd_feature_list
[k
].feature
687 & bfd_conflict_list
[j
])
688 p2
= (char *) bfd_feature_list
[k
].name
;
691 (_("error: %B: conflicting ISA extension attributes "
697 /* Everithing is alright. */
698 out_feature
|= in_feature
;
700 for (j
= 0; j
< ARRAY_SIZE (bfd_feature_list
); j
++)
701 if (out_feature
& bfd_feature_list
[j
].feature
)
702 p1
= arc_stralloc (p1
, bfd_feature_list
[j
].attr
);
704 out_attr
[Tag_ARC_ISA_config
].s
=
705 _bfd_elf_attr_strdup (obfd
, p1
);
708 case Tag_ARC_CPU_variation
:
709 case Tag_ARC_ISA_mpy_option
:
710 case Tag_ARC_ABI_osver
:
711 /* Use the largest value specified. */
712 if (in_attr
[i
].i
> out_attr
[i
].i
)
713 out_attr
[i
].i
= in_attr
[i
].i
;
716 case Tag_ARC_CPU_name
:
719 case Tag_ARC_ABI_rf16
:
720 if (out_attr
[i
].i
== 0)
721 out_attr
[i
].i
= in_attr
[i
].i
;
722 else if (out_attr
[i
].i
!= in_attr
[i
].i
)
724 /* We cannot mix code with rf16 and without. */
726 (_("error: %B: cannot mix rf16 with full register set %B.\n"),
732 case Tag_ARC_ABI_pic
:
735 case Tag_ARC_ABI_sda
:
739 case Tag_ARC_ABI_tls
:
741 const char *tagval
[] = { "Absent", "MWDT", "GNU" };
746 BFD_ASSERT (in_attr
[i
].i
< 3);
747 BFD_ASSERT (out_attr
[i
].i
< 3);
748 if (out_attr
[i
].i
!= 0 && in_attr
[i
].i
!= 0
749 && out_attr
[i
].i
!= in_attr
[i
].i
)
752 (_("error: %B: conflicting attributes %s: %s with %s.\n"),
754 tagval
[in_attr
[i
].i
],
755 tagval
[out_attr
[i
].i
]);
762 case Tag_ARC_ABI_double_size
:
763 tagname
= "Double size";
765 case Tag_ARC_ABI_enumsize
:
767 tagname
= "Enum size";
769 case Tag_ARC_ABI_exceptions
:
771 tagname
= "ABI exceptions";
773 if (out_attr
[i
].i
!= 0 && in_attr
[i
].i
!= 0
774 && out_attr
[i
].i
!= in_attr
[i
].i
)
777 (_("error: %B: conflicting attributes %s.\n"),
783 case Tag_ARC_ISA_apex
:
784 break; /* Do nothing for APEX attributes. */
786 case Tag_ARC_ISA_config
:
787 /* It is handled in Tag_ARC_CPU_base. */
792 = result
&& _bfd_elf_merge_unknown_attribute_low (ibfd
, obfd
, i
);
795 /* If out_attr was copied from in_attr then it won't have a type yet. */
796 if (in_attr
[i
].type
&& !out_attr
[i
].type
)
797 out_attr
[i
].type
= in_attr
[i
].type
;
800 /* Merge Tag_compatibility attributes and any common GNU ones. */
801 if (!_bfd_elf_merge_object_attributes (ibfd
, info
))
804 /* Check for any attributes not known on ARC. */
805 result
&= _bfd_elf_merge_unknown_attribute_list (ibfd
, obfd
);
810 /* Merge backend specific data from an object file to the output
811 object file when linking. */
814 arc_elf_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
816 bfd
*obfd
= info
->output_bfd
;
817 unsigned short mach_ibfd
;
818 static unsigned short mach_obfd
= EM_NONE
;
823 /* Check if we have the same endianess. */
824 if (! _bfd_generic_verify_endian_match (ibfd
, info
))
827 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
828 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
831 /* Collect ELF flags. */
832 in_flags
= elf_elfheader (ibfd
)->e_flags
& EF_ARC_MACH_MSK
;
833 out_flags
= elf_elfheader (obfd
)->e_flags
& EF_ARC_MACH_MSK
;
835 if (!elf_flags_init (obfd
)) /* First call, no flags set. */
837 elf_flags_init (obfd
) = TRUE
;
838 out_flags
= in_flags
;
841 if (!arc_elf_merge_attributes (ibfd
, info
))
844 /* Check to see if the input BFD actually contains any sections. Do
845 not short-circuit dynamic objects; their section list may be
846 emptied by elf_link_add_object_symbols. */
847 if (!(ibfd
->flags
& DYNAMIC
))
849 bfd_boolean null_input_bfd
= TRUE
;
850 bfd_boolean only_data_sections
= TRUE
;
852 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
854 if ((bfd_get_section_flags (ibfd
, sec
)
855 & (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
856 == (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
857 only_data_sections
= FALSE
;
859 null_input_bfd
= FALSE
;
862 if (null_input_bfd
|| only_data_sections
)
866 /* Complain about various flag/architecture mismatches. */
867 mach_ibfd
= elf_elfheader (ibfd
)->e_machine
;
868 if (mach_obfd
== EM_NONE
)
870 mach_obfd
= mach_ibfd
;
874 if (mach_ibfd
!= mach_obfd
)
876 /* xgettext:c-format */
877 _bfd_error_handler (_("ERROR: Attempting to link %B "
878 "with a binary %B of different architecture"),
882 else if ((in_flags
!= out_flags
)
883 /* If we have object attributes, then we already
884 checked the objects compatibility, skip it. */
885 && !bfd_elf_get_obj_attr_int (ibfd
, OBJ_ATTR_PROC
,
888 /* Warn if different flags. */
890 /* xgettext:c-format */
891 (_("%B: uses different e_flags (0x%lx) fields than "
892 "previous modules (0x%lx)"),
893 ibfd
, (long) in_flags
, (long) out_flags
);
894 if (in_flags
&& out_flags
)
896 /* MWDT doesnt set the eflags hence make sure we choose the
897 eflags set by gcc. */
898 in_flags
= in_flags
> out_flags
? in_flags
: out_flags
;
902 /* Everything is correct; don't change the output flags. */
903 in_flags
= out_flags
;
907 /* Update the flags. */
908 elf_elfheader (obfd
)->e_flags
= in_flags
;
910 if (bfd_get_mach (obfd
) < bfd_get_mach (ibfd
))
912 return bfd_set_arch_mach (obfd
, bfd_arch_arc
, bfd_get_mach (ibfd
));
918 /* Return a best guess for the machine number based on the attributes. */
921 bfd_arc_get_mach_from_attributes (bfd
* abfd
)
923 int arch
= bfd_elf_get_obj_attr_int (abfd
, OBJ_ATTR_PROC
, Tag_ARC_CPU_base
);
924 unsigned e_machine
= elf_elfheader (abfd
)->e_machine
;
929 return bfd_mach_arc_arc600
;
931 return bfd_mach_arc_arc700
;
934 return bfd_mach_arc_arcv2
;
938 return (e_machine
== EM_ARC_COMPACT
)
939 ? bfd_mach_arc_arc700
: bfd_mach_arc_arcv2
;
942 /* Set the right machine number for an ARC ELF file. */
944 arc_elf_object_p (bfd
* abfd
)
946 /* Make sure this is initialised, or you'll have the potential of passing
947 garbage---or misleading values---into the call to
948 bfd_default_set_arch_mach (). */
949 unsigned int mach
= bfd_mach_arc_arc700
;
950 unsigned long arch
= elf_elfheader (abfd
)->e_flags
& EF_ARC_MACH_MSK
;
951 unsigned e_machine
= elf_elfheader (abfd
)->e_machine
;
953 if (e_machine
== EM_ARC_COMPACT
|| e_machine
== EM_ARC_COMPACT2
)
957 case E_ARC_MACH_ARC600
:
958 mach
= bfd_mach_arc_arc600
;
960 case E_ARC_MACH_ARC601
:
961 mach
= bfd_mach_arc_arc601
;
963 case E_ARC_MACH_ARC700
:
964 mach
= bfd_mach_arc_arc700
;
966 case EF_ARC_CPU_ARCV2HS
:
967 case EF_ARC_CPU_ARCV2EM
:
968 mach
= bfd_mach_arc_arcv2
;
971 mach
= bfd_arc_get_mach_from_attributes (abfd
);
977 if (e_machine
== EM_ARC
)
980 (_("Error: The ARC4 architecture is no longer supported.\n"));
986 (_("Warning: unset or old architecture flags. \n"
987 " Use default machine.\n"));
991 return bfd_default_set_arch_mach (abfd
, bfd_arch_arc
, mach
);
994 /* The final processing done just before writing out an ARC ELF object file.
995 This gets the ARC architecture right based on the machine number. */
998 arc_elf_final_write_processing (bfd
* abfd
,
999 bfd_boolean linker ATTRIBUTE_UNUSED
)
1002 int osver
= bfd_elf_get_obj_attr_int (abfd
, OBJ_ATTR_PROC
,
1004 flagword e_flags
= elf_elfheader (abfd
)->e_flags
& ~EF_ARC_OSABI_MSK
;
1006 switch (bfd_get_mach (abfd
))
1008 case bfd_mach_arc_arc600
:
1009 emf
= EM_ARC_COMPACT
;
1011 case bfd_mach_arc_arc601
:
1012 emf
= EM_ARC_COMPACT
;
1014 case bfd_mach_arc_arc700
:
1015 emf
= EM_ARC_COMPACT
;
1017 case bfd_mach_arc_arcv2
:
1018 emf
= EM_ARC_COMPACT2
;
1024 elf_elfheader (abfd
)->e_machine
= emf
;
1026 /* Record whatever is the current syscall ABI version. */
1028 e_flags
|= ((osver
& 0x0f) << 8);
1030 e_flags
|= E_ARC_OSABI_V3
;
1032 elf_elfheader (abfd
)->e_flags
|= e_flags
;
1035 #ifdef ARC_ENABLE_DEBUG
1036 #define DEBUG_ARC_RELOC(A) debug_arc_reloc (A)
1039 debug_arc_reloc (struct arc_relocation_data reloc_data
)
1041 ARC_DEBUG ("Reloc type=%s, should_relocate = %s\n",
1042 reloc_data
.howto
->name
,
1043 reloc_data
.should_relocate
? "true" : "false");
1044 ARC_DEBUG (" offset = 0x%x, addend = 0x%x\n",
1045 (unsigned int) reloc_data
.reloc_offset
,
1046 (unsigned int) reloc_data
.reloc_addend
);
1047 ARC_DEBUG (" Symbol:\n");
1048 ARC_DEBUG (" value = 0x%08x\n",
1049 (unsigned int) reloc_data
.sym_value
);
1050 if (reloc_data
.sym_section
!= NULL
)
1052 ARC_DEBUG (" Symbol Section:\n");
1053 ARC_DEBUG (" section name = %s, output_offset 0x%08x",
1054 reloc_data
.sym_section
->name
,
1055 (unsigned int) reloc_data
.sym_section
->output_offset
);
1056 if (reloc_data
.sym_section
->output_section
!= NULL
)
1057 ARC_DEBUG (", output_section->vma = 0x%08x",
1058 ((unsigned int) reloc_data
.sym_section
->output_section
->vma
));
1060 if (reloc_data
.sym_section
->owner
&& reloc_data
.sym_section
->owner
->filename
)
1061 ARC_DEBUG (" file: %s\n", reloc_data
.sym_section
->owner
->filename
);
1065 ARC_DEBUG (" symbol section is NULL\n");
1068 ARC_DEBUG (" Input_section:\n");
1069 if (reloc_data
.input_section
!= NULL
)
1071 ARC_DEBUG (" section name = %s, output_offset 0x%08x, output_section->vma = 0x%08x\n",
1072 reloc_data
.input_section
->name
,
1073 (unsigned int) reloc_data
.input_section
->output_offset
,
1074 (unsigned int) reloc_data
.input_section
->output_section
->vma
);
1075 ARC_DEBUG (" changed_address = 0x%08x\n",
1076 (unsigned int) (reloc_data
.input_section
->output_section
->vma
1077 + reloc_data
.input_section
->output_offset
1078 + reloc_data
.reloc_offset
));
1079 ARC_DEBUG (" file: %s\n", reloc_data
.input_section
->owner
->filename
);
1083 ARC_DEBUG (" input section is NULL\n");
1087 #define DEBUG_ARC_RELOC(A)
1088 #endif /* ARC_ENABLE_DEBUG */
1091 middle_endian_convert (bfd_vma insn
, bfd_boolean do_it
)
1096 = ((insn
& 0xffff0000) >> 16)
1097 | ((insn
& 0xffff) << 16);
1102 /* This function is called for relocations that are otherwise marked as NOT
1103 requiring overflow checks. In here we perform non-standard checks of
1104 the relocation value. */
1106 static inline bfd_reloc_status_type
1107 arc_special_overflow_checks (const struct arc_relocation_data reloc_data
,
1108 bfd_signed_vma relocation
,
1109 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1111 switch (reloc_data
.howto
->type
)
1113 case R_ARC_NPS_CMEM16
:
1114 if (((relocation
>> 16) & 0xffff) != NPS_CMEM_HIGH_VALUE
)
1116 if (reloc_data
.reloc_addend
== 0)
1118 /* xgettext:c-format */
1119 (_("%B(%A+0x%lx): CMEM relocation to `%s' is invalid, "
1120 "16 MSB should be 0x%04x (value is 0x%lx)"),
1121 reloc_data
.input_section
->owner
,
1122 reloc_data
.input_section
,
1123 reloc_data
.reloc_offset
,
1124 reloc_data
.symbol_name
,
1125 NPS_CMEM_HIGH_VALUE
,
1129 /* xgettext:c-format */
1130 (_("%B(%A+0x%lx): CMEM relocation to `%s+0x%lx' is invalid, "
1131 "16 MSB should be 0x%04x (value is 0x%lx)"),
1132 reloc_data
.input_section
->owner
,
1133 reloc_data
.input_section
,
1134 reloc_data
.reloc_offset
,
1135 reloc_data
.symbol_name
,
1136 reloc_data
.reloc_addend
,
1137 NPS_CMEM_HIGH_VALUE
,
1139 return bfd_reloc_overflow
;
1147 return bfd_reloc_ok
;
1150 #define ME(reloc) (reloc)
1152 #define IS_ME(FORMULA,BFD) ((strstr (FORMULA, "ME") != NULL) \
1153 && (!bfd_big_endian (BFD)))
1155 #define S ((bfd_signed_vma) (reloc_data.sym_value \
1156 + (reloc_data.sym_section->output_section != NULL ? \
1157 (reloc_data.sym_section->output_offset \
1158 + reloc_data.sym_section->output_section->vma) : 0)))
1159 #define L ((bfd_signed_vma) (reloc_data.sym_value \
1160 + (reloc_data.sym_section->output_section != NULL ? \
1161 (reloc_data.sym_section->output_offset \
1162 + reloc_data.sym_section->output_section->vma) : 0)))
1163 #define A (reloc_data.reloc_addend)
1165 #define G (reloc_data.got_offset_value)
1166 #define GOT (reloc_data.got_symbol_vma)
1167 #define GOT_BEGIN (htab->sgot->output_section->vma)
1170 /* P: relative offset to PCL The offset should be to the
1171 current location aligned to 32 bits. */
1172 #define P ((bfd_signed_vma) ( \
1174 (reloc_data.input_section->output_section != NULL ? \
1175 reloc_data.input_section->output_section->vma : 0) \
1176 + reloc_data.input_section->output_offset \
1177 + (reloc_data.reloc_offset - (bitsize >= 32 ? 4 : 0))) \
1179 #define PDATA ((bfd_signed_vma) ( \
1180 (reloc_data.input_section->output_section->vma \
1181 + reloc_data.input_section->output_offset \
1182 + (reloc_data.reloc_offset))))
1183 #define SECTSTART (bfd_signed_vma) (reloc_data.sym_section->output_section->vma \
1184 + reloc_data.sym_section->output_offset)
1186 #define _SDA_BASE_ (bfd_signed_vma) (reloc_data.sdata_begin_symbol_vma)
1187 #define TLS_REL (bfd_signed_vma) \
1188 ((elf_hash_table (info))->tls_sec->output_section->vma)
1189 #define TLS_TBSS (8)
1190 #define TCB_SIZE (8)
1194 #ifdef ARC_ENABLE_DEBUG
1195 #define PRINT_DEBUG_RELOC_INFO_BEFORE(FORMULA, TYPE) \
1198 asection *sym_section = reloc_data.sym_section; \
1199 asection *input_section = reloc_data.input_section; \
1200 ARC_DEBUG ("RELOC_TYPE = " TYPE "\n"); \
1201 ARC_DEBUG ("FORMULA = " FORMULA "\n"); \
1202 ARC_DEBUG ("S = %#lx\n", S); \
1203 ARC_DEBUG ("A = %#lx\n", A); \
1204 ARC_DEBUG ("L = %lx\n", L); \
1205 if (sym_section->output_section != NULL) \
1206 ARC_DEBUG ("symbol_section->vma = %#lx\n", \
1207 sym_section->output_section->vma \
1208 + sym_section->output_offset); \
1210 ARC_DEBUG ("symbol_section->vma = NULL\n"); \
1211 if (input_section->output_section != NULL) \
1212 ARC_DEBUG ("symbol_section->vma = %#lx\n", \
1213 input_section->output_section->vma \
1214 + input_section->output_offset); \
1216 ARC_DEBUG ("symbol_section->vma = NULL\n"); \
1217 ARC_DEBUG ("PCL = %#lx\n", P); \
1218 ARC_DEBUG ("P = %#lx\n", P); \
1219 ARC_DEBUG ("G = %#lx\n", G); \
1220 ARC_DEBUG ("SDA_OFFSET = %#lx\n", _SDA_BASE_); \
1221 ARC_DEBUG ("SDA_SET = %d\n", reloc_data.sdata_begin_symbol_vma_set); \
1222 ARC_DEBUG ("GOT_OFFSET = %#lx\n", GOT); \
1223 ARC_DEBUG ("relocation = %#08lx\n", relocation); \
1224 ARC_DEBUG ("before = %#08x\n", (unsigned) insn); \
1225 ARC_DEBUG ("data = %08x (%u) (%d)\n", (unsigned) relocation, \
1226 (unsigned) relocation, (int) relocation); \
1230 #define PRINT_DEBUG_RELOC_INFO_AFTER \
1233 ARC_DEBUG ("after = 0x%08x\n", (unsigned int) insn); \
1239 #define PRINT_DEBUG_RELOC_INFO_BEFORE(...)
1240 #define PRINT_DEBUG_RELOC_INFO_AFTER
1242 #endif /* ARC_ENABLE_DEBUG */
1244 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
1247 bfd_signed_vma bitsize ATTRIBUTE_UNUSED = BITSIZE; \
1248 relocation = FORMULA ; \
1249 PRINT_DEBUG_RELOC_INFO_BEFORE (#FORMULA, #TYPE); \
1250 insn = middle_endian_convert (insn, IS_ME (#FORMULA, abfd)); \
1251 insn = (* get_replace_function (abfd, TYPE)) (insn, relocation); \
1252 insn = middle_endian_convert (insn, IS_ME (#FORMULA, abfd)); \
1253 PRINT_DEBUG_RELOC_INFO_AFTER; \
1257 static bfd_reloc_status_type
1258 arc_do_relocation (bfd_byte
* contents
,
1259 struct arc_relocation_data reloc_data
,
1260 struct bfd_link_info
*info
)
1262 bfd_signed_vma relocation
= 0;
1264 bfd_vma orig_insn ATTRIBUTE_UNUSED
;
1265 bfd
* abfd
= reloc_data
.input_section
->owner
;
1266 struct elf_link_hash_table
*htab ATTRIBUTE_UNUSED
= elf_hash_table (info
);
1267 bfd_reloc_status_type flag
;
1269 if (!reloc_data
.should_relocate
)
1270 return bfd_reloc_ok
;
1272 switch (reloc_data
.howto
->size
)
1275 insn
= arc_bfd_get_32 (abfd
,
1276 contents
+ reloc_data
.reloc_offset
,
1277 reloc_data
.input_section
);
1280 insn
= arc_bfd_get_16 (abfd
,
1281 contents
+ reloc_data
.reloc_offset
,
1282 reloc_data
.input_section
);
1285 insn
= arc_bfd_get_8 (abfd
,
1286 contents
+ reloc_data
.reloc_offset
,
1287 reloc_data
.input_section
);
1297 switch (reloc_data
.howto
->type
)
1299 #include "elf/arc-reloc.def"
1306 /* Check for relocation overflow. */
1307 if (reloc_data
.howto
->complain_on_overflow
!= complain_overflow_dont
)
1308 flag
= bfd_check_overflow (reloc_data
.howto
->complain_on_overflow
,
1309 reloc_data
.howto
->bitsize
,
1310 reloc_data
.howto
->rightshift
,
1311 bfd_arch_bits_per_address (abfd
),
1314 flag
= arc_special_overflow_checks (reloc_data
, relocation
, info
);
1316 if (flag
!= bfd_reloc_ok
)
1318 ARC_DEBUG ("Relocation overflows !\n");
1319 DEBUG_ARC_RELOC (reloc_data
);
1320 ARC_DEBUG ("Relocation value = signed -> %d, unsigned -> %u"
1321 ", hex -> (0x%08x)\n",
1322 (int) relocation
, (unsigned) relocation
, (int) relocation
);
1327 /* Write updated instruction back to memory. */
1328 switch (reloc_data
.howto
->size
)
1331 arc_bfd_put_32 (abfd
, insn
,
1332 contents
+ reloc_data
.reloc_offset
,
1333 reloc_data
.input_section
);
1336 arc_bfd_put_16 (abfd
, insn
,
1337 contents
+ reloc_data
.reloc_offset
,
1338 reloc_data
.input_section
);
1341 arc_bfd_put_8 (abfd
, insn
,
1342 contents
+ reloc_data
.reloc_offset
,
1343 reloc_data
.input_section
);
1346 ARC_DEBUG ("size = %d\n", reloc_data
.howto
->size
);
1351 return bfd_reloc_ok
;
1366 #undef ARC_RELOC_HOWTO
1369 /* Relocate an arc ELF section.
1370 Function : elf_arc_relocate_section
1371 Brief : Relocate an arc section, by handling all the relocations
1372 appearing in that section.
1373 Args : output_bfd : The bfd being written to.
1374 info : Link information.
1375 input_bfd : The input bfd.
1376 input_section : The section being relocated.
1377 contents : contents of the section being relocated.
1378 relocs : List of relocations in the section.
1379 local_syms : is a pointer to the swapped in local symbols.
1380 local_section : is an array giving the section in the input file
1381 corresponding to the st_shndx field of each
1384 elf_arc_relocate_section (bfd
* output_bfd
,
1385 struct bfd_link_info
* info
,
1387 asection
* input_section
,
1388 bfd_byte
* contents
,
1389 Elf_Internal_Rela
* relocs
,
1390 Elf_Internal_Sym
* local_syms
,
1391 asection
** local_sections
)
1393 Elf_Internal_Shdr
* symtab_hdr
;
1394 struct elf_link_hash_entry
** sym_hashes
;
1395 Elf_Internal_Rela
* rel
;
1396 Elf_Internal_Rela
* wrel
;
1397 Elf_Internal_Rela
* relend
;
1398 struct elf_link_hash_table
* htab
= elf_hash_table (info
);
1400 symtab_hdr
= &((elf_tdata (input_bfd
))->symtab_hdr
);
1401 sym_hashes
= elf_sym_hashes (input_bfd
);
1403 rel
= wrel
= relocs
;
1404 relend
= relocs
+ input_section
->reloc_count
;
1405 for (; rel
< relend
; wrel
++, rel
++)
1407 enum elf_arc_reloc_type r_type
;
1408 reloc_howto_type
* howto
;
1409 unsigned long r_symndx
;
1410 struct elf_link_hash_entry
* h
;
1411 Elf_Internal_Sym
* sym
;
1413 struct elf_link_hash_entry
* h2
;
1416 struct arc_relocation_data reloc_data
=
1420 .got_offset_value
= 0,
1422 .sym_section
= NULL
,
1424 .input_section
= NULL
,
1425 .sdata_begin_symbol_vma
= 0,
1426 .sdata_begin_symbol_vma_set
= FALSE
,
1427 .got_symbol_vma
= 0,
1428 .should_relocate
= FALSE
1431 r_type
= ELF32_R_TYPE (rel
->r_info
);
1433 if (r_type
>= (int) R_ARC_max
)
1435 bfd_set_error (bfd_error_bad_value
);
1438 howto
= arc_elf_howto (r_type
);
1440 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1442 /* If we are generating another .o file and the symbol in not
1443 local, skip this relocation. */
1444 if (bfd_link_relocatable (info
))
1446 /* This is a relocateable link. We don't have to change
1447 anything, unless the reloc is against a section symbol,
1448 in which case we have to adjust according to where the
1449 section symbol winds up in the output section. */
1451 /* Checks if this is a local symbol and thus the reloc
1452 might (will??) be against a section symbol. */
1453 if (r_symndx
< symtab_hdr
->sh_info
)
1455 sym
= local_syms
+ r_symndx
;
1456 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1458 sec
= local_sections
[r_symndx
];
1460 /* For RELA relocs. Just adjust the addend
1461 value in the relocation entry. */
1462 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
1464 ARC_DEBUG ("local symbols reloc (section=%d %s) seen in %s\n",
1465 (int) r_symndx
, local_sections
[r_symndx
]->name
,
1466 __PRETTY_FUNCTION__
);
1471 h2
= elf_link_hash_lookup (elf_hash_table (info
), "__SDATA_BEGIN__",
1472 FALSE
, FALSE
, TRUE
);
1474 if (!reloc_data
.sdata_begin_symbol_vma_set
1475 && h2
!= NULL
&& h2
->root
.type
!= bfd_link_hash_undefined
1476 && h2
->root
.u
.def
.section
->output_section
!= NULL
)
1477 /* TODO: Verify this condition. */
1479 reloc_data
.sdata_begin_symbol_vma
=
1480 (h2
->root
.u
.def
.value
1481 + h2
->root
.u
.def
.section
->output_section
->vma
);
1482 reloc_data
.sdata_begin_symbol_vma_set
= TRUE
;
1485 reloc_data
.input_section
= input_section
;
1486 reloc_data
.howto
= howto
;
1487 reloc_data
.reloc_offset
= rel
->r_offset
;
1488 reloc_data
.reloc_addend
= rel
->r_addend
;
1490 /* This is a final link. */
1495 if (r_symndx
< symtab_hdr
->sh_info
) /* A local symbol. */
1497 sym
= local_syms
+ r_symndx
;
1498 sec
= local_sections
[r_symndx
];
1502 /* TODO: This code is repeated from below. We should
1503 clean it and remove duplications.
1504 Sec is used check for discarded sections.
1505 Need to redesign code below. */
1507 /* Get the symbol's entry in the symtab. */
1508 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1510 while (h
->root
.type
== bfd_link_hash_indirect
1511 || h
->root
.type
== bfd_link_hash_warning
)
1512 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1514 /* If we have encountered a definition for this symbol. */
1515 if (h
->root
.type
== bfd_link_hash_defined
1516 || h
->root
.type
== bfd_link_hash_defweak
)
1518 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1519 sec
= h
->root
.u
.def
.section
;
1523 /* Clean relocs for symbols in discarded sections. */
1524 if (sec
!= NULL
&& discarded_section (sec
))
1526 _bfd_clear_contents (howto
, input_bfd
, input_section
,
1527 contents
+ rel
->r_offset
);
1528 rel
->r_offset
= rel
->r_offset
;
1532 /* For ld -r, remove relocations in debug sections against
1533 sections defined in discarded sections. Not done for
1534 eh_frame editing code expects to be present. */
1535 if (bfd_link_relocatable (info
)
1536 && (input_section
->flags
& SEC_DEBUGGING
))
1542 if (bfd_link_relocatable (info
))
1549 if (r_symndx
< symtab_hdr
->sh_info
) /* A local symbol. */
1551 reloc_data
.sym_value
= sym
->st_value
;
1552 reloc_data
.sym_section
= sec
;
1553 reloc_data
.symbol_name
=
1554 bfd_elf_string_from_elf_section (input_bfd
,
1555 symtab_hdr
->sh_link
,
1558 /* Mergeable section handling. */
1559 if ((sec
->flags
& SEC_MERGE
)
1560 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1564 rel
->r_addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
,
1565 &msec
, rel
->r_addend
);
1566 rel
->r_addend
-= (sec
->output_section
->vma
1567 + sec
->output_offset
1569 rel
->r_addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
1571 reloc_data
.reloc_addend
= rel
->r_addend
;
1574 BFD_ASSERT (htab
->sgot
!= NULL
|| !is_reloc_for_GOT (howto
));
1575 if (htab
->sgot
!= NULL
)
1576 reloc_data
.got_symbol_vma
= htab
->sgot
->output_section
->vma
1577 + htab
->sgot
->output_offset
;
1579 reloc_data
.should_relocate
= TRUE
;
1581 else /* Global symbol. */
1583 /* FIXME: We should use the RELOC_FOR_GLOBAL_SYMBOL macro
1584 (defined in elf-bfd.h) here. */
1586 /* Get the symbol's entry in the symtab. */
1587 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1589 while (h
->root
.type
== bfd_link_hash_indirect
1590 || h
->root
.type
== bfd_link_hash_warning
)
1592 struct elf_link_hash_entry
*h_old
= h
;
1593 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1594 if (h
->got
.glist
== 0 && h_old
->got
.glist
!= h
->got
.glist
)
1595 h
->got
.glist
= h_old
->got
.glist
;
1598 /* TODO: Need to validate what was the intention. */
1599 /* BFD_ASSERT ((h->dynindx == -1) || (h->forced_local != 0)); */
1600 reloc_data
.symbol_name
= h
->root
.root
.string
;
1602 /* If we have encountered a definition for this symbol. */
1603 if (h
->root
.type
== bfd_link_hash_defined
1604 || h
->root
.type
== bfd_link_hash_defweak
)
1606 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1607 reloc_data
.sym_section
= h
->root
.u
.def
.section
;
1609 reloc_data
.should_relocate
= TRUE
;
1611 if (is_reloc_for_GOT (howto
) && !bfd_link_pic (info
))
1613 /* TODO: Change it to use arc_do_relocation with
1614 ARC_32 reloc. Try to use ADD_RELA macro. */
1615 bfd_vma relocation
=
1616 reloc_data
.sym_value
+ reloc_data
.reloc_addend
1617 + (reloc_data
.sym_section
->output_section
!= NULL
?
1618 (reloc_data
.sym_section
->output_offset
1619 + reloc_data
.sym_section
->output_section
->vma
)
1622 BFD_ASSERT (h
->got
.glist
);
1623 bfd_vma got_offset
= h
->got
.glist
->offset
;
1624 bfd_put_32 (output_bfd
, relocation
,
1625 htab
->sgot
->contents
+ got_offset
);
1627 if (is_reloc_for_PLT (howto
) && h
->plt
.offset
!= (bfd_vma
) -1)
1629 /* TODO: This is repeated up here. */
1630 reloc_data
.sym_value
= h
->plt
.offset
;
1631 reloc_data
.sym_section
= htab
->splt
;
1634 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1636 /* Is weak symbol and has no definition. */
1637 if (is_reloc_for_GOT (howto
))
1639 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1640 reloc_data
.sym_section
= htab
->sgot
;
1641 reloc_data
.should_relocate
= TRUE
;
1643 else if (is_reloc_for_PLT (howto
)
1644 && h
->plt
.offset
!= (bfd_vma
) -1)
1646 /* TODO: This is repeated up here. */
1647 reloc_data
.sym_value
= h
->plt
.offset
;
1648 reloc_data
.sym_section
= htab
->splt
;
1649 reloc_data
.should_relocate
= TRUE
;
1656 if (is_reloc_for_GOT (howto
))
1658 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1659 reloc_data
.sym_section
= htab
->sgot
;
1661 reloc_data
.should_relocate
= TRUE
;
1663 else if (is_reloc_for_PLT (howto
))
1665 /* Fail if it is linking for PIE and the symbol is
1667 if (bfd_link_executable (info
))
1668 (*info
->callbacks
->undefined_symbol
)
1669 (info
, h
->root
.root
.string
, input_bfd
, input_section
,
1670 rel
->r_offset
, TRUE
);
1671 reloc_data
.sym_value
= h
->plt
.offset
;
1672 reloc_data
.sym_section
= htab
->splt
;
1674 reloc_data
.should_relocate
= TRUE
;
1676 else if (!bfd_link_pic (info
) || bfd_link_executable (info
))
1677 (*info
->callbacks
->undefined_symbol
)
1678 (info
, h
->root
.root
.string
, input_bfd
, input_section
,
1679 rel
->r_offset
, TRUE
);
1682 BFD_ASSERT (htab
->sgot
!= NULL
|| !is_reloc_for_GOT (howto
));
1683 if (htab
->sgot
!= NULL
)
1684 reloc_data
.got_symbol_vma
= htab
->sgot
->output_section
->vma
1685 + htab
->sgot
->output_offset
;
1688 if ((is_reloc_for_GOT (howto
)
1689 || is_reloc_for_TLS (howto
)))
1691 reloc_data
.should_relocate
= TRUE
;
1693 struct got_entry
**list
1694 = get_got_entry_list_for_symbol (output_bfd
, r_symndx
, h
);
1696 reloc_data
.got_offset_value
1697 = relocate_fix_got_relocs_for_got_info (list
,
1698 tls_type_for_reloc (howto
),
1709 create_got_dynrelocs_for_single_entry (
1710 got_entry_for_type (list
,
1711 arc_got_entry_type_for_reloc (howto
)),
1712 output_bfd
, info
, NULL
);
1721 case R_ARC_32_PCREL
:
1722 if ((bfd_link_pic (info
))
1723 && ((r_type
!= R_ARC_PC32
&& r_type
!= R_ARC_32_PCREL
)
1726 && (!info
->symbolic
|| !h
->def_regular
))))
1728 Elf_Internal_Rela outrel
;
1730 bfd_boolean skip
= FALSE
;
1731 bfd_boolean relocate
= FALSE
;
1732 asection
*sreloc
= _bfd_elf_get_dynamic_reloc_section
1733 (input_bfd
, input_section
,
1736 BFD_ASSERT (sreloc
!= NULL
);
1738 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
1742 if (outrel
.r_offset
== (bfd_vma
) -1)
1745 outrel
.r_addend
= rel
->r_addend
;
1746 outrel
.r_offset
+= (input_section
->output_section
->vma
1747 + input_section
->output_offset
);
1749 #define IS_ARC_PCREL_TYPE(TYPE) \
1750 ( (TYPE == R_ARC_PC32) \
1751 || (TYPE == R_ARC_32_PCREL))
1755 memset (&outrel
, 0, sizeof outrel
);
1760 && ((IS_ARC_PCREL_TYPE (r_type
))
1761 || !(bfd_link_executable (info
)
1762 || SYMBOLIC_BIND (info
, h
))
1763 || ! h
->def_regular
))
1765 BFD_ASSERT (h
!= NULL
);
1766 if ((input_section
->flags
& SEC_ALLOC
) != 0)
1771 BFD_ASSERT (h
->dynindx
!= -1);
1772 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
1776 /* Handle local symbols, they either do not have a
1777 global hash table entry (h == NULL), or are
1778 forced local due to a version script
1779 (h->forced_local), or the third condition is
1780 legacy, it appears to say something like, for
1781 links where we are pre-binding the symbols, or
1782 there's not an entry for this symbol in the
1783 dynamic symbol table, and it's a regular symbol
1784 not defined in a shared object, then treat the
1785 symbol as local, resolve it now. */
1787 /* outrel.r_addend = 0; */
1788 outrel
.r_info
= ELF32_R_INFO (0, R_ARC_RELATIVE
);
1791 BFD_ASSERT (sreloc
->contents
!= 0);
1793 loc
= sreloc
->contents
;
1794 loc
+= sreloc
->reloc_count
* sizeof (Elf32_External_Rela
);
1795 sreloc
->reloc_count
+= 1;
1797 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
1807 if (is_reloc_SDA_relative (howto
)
1808 && !reloc_data
.sdata_begin_symbol_vma_set
)
1811 ("Error: Linker symbol __SDATA_BEGIN__ not found");
1812 bfd_set_error (bfd_error_bad_value
);
1816 DEBUG_ARC_RELOC (reloc_data
);
1818 /* Make sure we have with a dynamic linker. In case of GOT and PLT
1819 the sym_section should point to .got or .plt respectively. */
1820 if ((is_reloc_for_GOT (howto
) || is_reloc_for_PLT (howto
))
1821 && reloc_data
.sym_section
== NULL
)
1824 (_("GOT and PLT relocations cannot be fixed with a non dynamic linker."));
1825 bfd_set_error (bfd_error_bad_value
);
1830 switch (arc_do_relocation (contents
, reloc_data
, info
))
1833 continue; /* The reloc processing loop. */
1835 case bfd_reloc_overflow
:
1836 (*info
->callbacks
->reloc_overflow
)
1837 (info
, (h
? &h
->root
: NULL
), reloc_data
.symbol_name
, howto
->name
, (bfd_vma
) 0,
1838 input_bfd
, input_section
, rel
->r_offset
);
1841 case bfd_reloc_undefined
:
1842 (*info
->callbacks
->undefined_symbol
)
1843 (info
, reloc_data
.symbol_name
, input_bfd
, input_section
, rel
->r_offset
, TRUE
);
1846 case bfd_reloc_other
:
1847 /* xgettext:c-format */
1848 msg
= _("%B(%A): warning: unaligned access to symbol '%s' in the small data area");
1851 case bfd_reloc_outofrange
:
1852 /* xgettext:c-format */
1853 msg
= _("%B(%A): internal error: out of range error");
1856 case bfd_reloc_notsupported
:
1857 /* xgettext:c-format */
1858 msg
= _("%B(%A): internal error: unsupported relocation error");
1861 case bfd_reloc_dangerous
:
1862 /* xgettext:c-format */
1863 msg
= _("%B(%A): internal error: dangerous relocation");
1867 /* xgettext:c-format */
1868 msg
= _("%B(%A): internal error: unknown error");
1873 _bfd_error_handler (msg
, input_bfd
, input_section
, reloc_data
.symbol_name
);
1880 #define elf_arc_hash_table(p) \
1881 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
1882 == ARC_ELF_DATA ? ((struct elf_arc_link_hash_table *) ((p)->hash)) : NULL)
1885 elf_arc_check_relocs (bfd
* abfd
,
1886 struct bfd_link_info
* info
,
1888 const Elf_Internal_Rela
* relocs
)
1890 Elf_Internal_Shdr
* symtab_hdr
;
1891 struct elf_link_hash_entry
** sym_hashes
;
1892 const Elf_Internal_Rela
* rel
;
1893 const Elf_Internal_Rela
* rel_end
;
1895 asection
* sreloc
= NULL
;
1897 if (bfd_link_relocatable (info
))
1900 dynobj
= (elf_hash_table (info
))->dynobj
;
1901 symtab_hdr
= &((elf_tdata (abfd
))->symtab_hdr
);
1902 sym_hashes
= elf_sym_hashes (abfd
);
1904 rel_end
= relocs
+ sec
->reloc_count
;
1905 for (rel
= relocs
; rel
< rel_end
; rel
++)
1907 enum elf_arc_reloc_type r_type
;
1908 reloc_howto_type
*howto
;
1909 unsigned long r_symndx
;
1910 struct elf_link_hash_entry
*h
;
1912 r_type
= ELF32_R_TYPE (rel
->r_info
);
1914 if (r_type
>= (int) R_ARC_max
)
1916 bfd_set_error (bfd_error_bad_value
);
1919 howto
= arc_elf_howto (r_type
);
1922 && (is_reloc_for_GOT (howto
)
1923 || is_reloc_for_TLS (howto
)))
1925 dynobj
= elf_hash_table (info
)->dynobj
= abfd
;
1926 if (! _bfd_elf_create_got_section (abfd
, info
))
1930 /* Load symbol information. */
1931 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1932 if (r_symndx
< symtab_hdr
->sh_info
) /* Is a local symbol. */
1934 else /* Global one. */
1935 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1941 /* During shared library creation, these relocs should not
1942 appear in a shared library (as memory will be read only
1943 and the dynamic linker can not resolve these. However
1944 the error should not occur for e.g. debugging or
1945 non-readonly sections. */
1947 && (bfd_link_dll (info
) && !bfd_link_pie (info
))
1948 && (sec
->flags
& SEC_ALLOC
) != 0
1949 && (sec
->flags
& SEC_READONLY
) != 0
1950 && ((sec
->flags
& SEC_CODE
) != 0
1951 || (sec
->flags
& SEC_DEBUGGING
) != 0))
1955 name
= h
->root
.root
.string
;
1957 /* bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL); */
1960 /* xgettext:c-format */
1962 %B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1964 arc_elf_howto (r_type
)->name
,
1966 bfd_set_error (bfd_error_bad_value
);
1970 /* In some cases we are not setting the 'non_got_ref'
1971 flag, even though the relocations don't require a GOT
1972 access. We should extend the testing in this area to
1973 ensure that no significant cases are being missed. */
1978 case R_ARC_32_PCREL
:
1979 if ((bfd_link_pic (info
))
1980 && ((r_type
!= R_ARC_PC32
&& r_type
!= R_ARC_32_PCREL
)
1982 && (!info
->symbolic
|| !h
->def_regular
))))
1986 sreloc
= _bfd_elf_make_dynamic_reloc_section (sec
, dynobj
,
1994 sreloc
->size
+= sizeof (Elf32_External_Rela
);
2001 if (is_reloc_for_PLT (howto
))
2009 /* Add info to the symbol got_entry_list. */
2010 if (is_reloc_for_GOT (howto
)
2011 || is_reloc_for_TLS (howto
))
2013 arc_fill_got_info_for_reloc (
2014 arc_got_entry_type_for_reloc (howto
),
2015 get_got_entry_list_for_symbol (abfd
, r_symndx
, h
),
2024 #define ELF_DYNAMIC_INTERPRETER "/sbin/ld-uClibc.so"
2026 static struct plt_version_t
*
2027 arc_get_plt_version (struct bfd_link_info
*info
)
2031 for (i
= 0; i
< 1; i
++)
2033 ARC_DEBUG ("%d: size1 = %d, size2 = %d\n", i
,
2034 (int) plt_versions
[i
].entry_size
,
2035 (int) plt_versions
[i
].elem_size
);
2038 if (bfd_get_mach (info
->output_bfd
) == bfd_mach_arc_arcv2
)
2040 if (bfd_link_pic (info
))
2041 return &(plt_versions
[ELF_ARCV2_PIC
]);
2043 return &(plt_versions
[ELF_ARCV2_ABS
]);
2047 if (bfd_link_pic (info
))
2048 return &(plt_versions
[ELF_ARC_PIC
]);
2050 return &(plt_versions
[ELF_ARC_ABS
]);
2055 add_symbol_to_plt (struct bfd_link_info
*info
)
2057 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2060 struct plt_version_t
*plt_data
= arc_get_plt_version (info
);
2062 /* If this is the first .plt entry, make room for the special first
2064 if (htab
->splt
->size
== 0)
2065 htab
->splt
->size
+= plt_data
->entry_size
;
2067 ret
= htab
->splt
->size
;
2069 htab
->splt
->size
+= plt_data
->elem_size
;
2070 ARC_DEBUG ("PLT_SIZE = %d\n", (int) htab
->splt
->size
);
2072 htab
->sgotplt
->size
+= 4;
2073 htab
->srelplt
->size
+= sizeof (Elf32_External_Rela
);
2078 #define PLT_DO_RELOCS_FOR_ENTRY(ABFD, DS, RELOCS) \
2079 plt_do_relocs_for_symbol (ABFD, DS, RELOCS, 0, 0)
2082 plt_do_relocs_for_symbol (bfd
*abfd
,
2083 struct elf_link_hash_table
*htab
,
2084 const struct plt_reloc
*reloc
,
2086 bfd_vma symbol_got_offset
)
2088 while (SYM_ONLY (reloc
->symbol
) != LAST_RELOC
)
2090 bfd_vma relocation
= 0;
2092 switch (SYM_ONLY (reloc
->symbol
))
2096 = htab
->sgotplt
->output_section
->vma
2097 + htab
->sgotplt
->output_offset
+ symbol_got_offset
;
2100 relocation
+= reloc
->addend
;
2102 if (IS_RELATIVE (reloc
->symbol
))
2104 bfd_vma reloc_offset
= reloc
->offset
;
2105 reloc_offset
-= (IS_INSN_32 (reloc
->symbol
)) ? 4 : 0;
2106 reloc_offset
-= (IS_INSN_24 (reloc
->symbol
)) ? 2 : 0;
2108 relocation
-= htab
->splt
->output_section
->vma
2109 + htab
->splt
->output_offset
2110 + plt_offset
+ reloc_offset
;
2113 /* TODO: being ME is not a property of the relocation but of the
2114 section of which is applying the relocation. */
2115 if (IS_MIDDLE_ENDIAN (reloc
->symbol
) && !bfd_big_endian (abfd
))
2118 = ((relocation
& 0xffff0000) >> 16)
2119 | ((relocation
& 0xffff) << 16);
2122 switch (reloc
->size
)
2125 bfd_put_32 (htab
->splt
->output_section
->owner
,
2127 htab
->splt
->contents
+ plt_offset
+ reloc
->offset
);
2131 reloc
= &(reloc
[1]); /* Jump to next relocation. */
2136 relocate_plt_for_symbol (bfd
*output_bfd
,
2137 struct bfd_link_info
*info
,
2138 struct elf_link_hash_entry
*h
)
2140 struct plt_version_t
*plt_data
= arc_get_plt_version (info
);
2141 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2143 bfd_vma plt_index
= (h
->plt
.offset
- plt_data
->entry_size
)
2144 / plt_data
->elem_size
;
2145 bfd_vma got_offset
= (plt_index
+ 3) * 4;
2147 ARC_DEBUG ("arc_info: PLT_OFFSET = %#lx, PLT_ENTRY_VMA = %#lx, \
2148 GOT_ENTRY_OFFSET = %#lx, GOT_ENTRY_VMA = %#lx, for symbol %s\n",
2149 (long) h
->plt
.offset
,
2150 (long) (htab
->splt
->output_section
->vma
2151 + htab
->splt
->output_offset
2154 (long) (htab
->sgotplt
->output_section
->vma
2155 + htab
->sgotplt
->output_offset
2157 h
->root
.root
.string
);
2161 uint16_t *ptr
= (uint16_t *) plt_data
->elem
;
2163 for (i
= 0; i
< plt_data
->elem_size
/2; i
++)
2165 uint16_t data
= ptr
[i
];
2166 bfd_put_16 (output_bfd
,
2168 htab
->splt
->contents
+ h
->plt
.offset
+ (i
*2));
2172 plt_do_relocs_for_symbol (output_bfd
, htab
,
2173 plt_data
->elem_relocs
,
2177 /* Fill in the entry in the global offset table. */
2178 bfd_put_32 (output_bfd
,
2179 (bfd_vma
) (htab
->splt
->output_section
->vma
2180 + htab
->splt
->output_offset
),
2181 htab
->sgotplt
->contents
+ got_offset
);
2183 /* TODO: Fill in the entry in the .rela.plt section. */
2185 Elf_Internal_Rela rel
;
2188 rel
.r_offset
= (htab
->sgotplt
->output_section
->vma
2189 + htab
->sgotplt
->output_offset
2193 BFD_ASSERT (h
->dynindx
!= -1);
2194 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARC_JMP_SLOT
);
2196 loc
= htab
->srelplt
->contents
;
2197 loc
+= plt_index
* sizeof (Elf32_External_Rela
); /* relA */
2198 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
2203 relocate_plt_for_entry (bfd
*abfd
,
2204 struct bfd_link_info
*info
)
2206 struct plt_version_t
*plt_data
= arc_get_plt_version (info
);
2207 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2211 uint16_t *ptr
= (uint16_t *) plt_data
->entry
;
2212 for (i
= 0; i
< plt_data
->entry_size
/2; i
++)
2214 uint16_t data
= ptr
[i
];
2217 htab
->splt
->contents
+ (i
*2));
2220 PLT_DO_RELOCS_FOR_ENTRY (abfd
, htab
, plt_data
->entry_relocs
);
2223 /* Desc : Adjust a symbol defined by a dynamic object and referenced
2224 by a regular object. The current definition is in some section of
2225 the dynamic object, but we're not including those sections. We
2226 have to change the definition to something the rest of the link can
2230 elf_arc_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2231 struct elf_link_hash_entry
*h
)
2234 bfd
*dynobj
= (elf_hash_table (info
))->dynobj
;
2235 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2237 if (h
->type
== STT_FUNC
2238 || h
->type
== STT_GNU_IFUNC
2239 || h
->needs_plt
== 1)
2241 if (!bfd_link_pic (info
) && !h
->def_dynamic
&& !h
->ref_dynamic
)
2243 /* This case can occur if we saw a PLT32 reloc in an input
2244 file, but the symbol was never referred to by a dynamic
2245 object. In such a case, we don't actually need to build
2246 a procedure linkage table, and we can just do a PC32
2248 BFD_ASSERT (h
->needs_plt
);
2252 /* Make sure this symbol is output as a dynamic symbol. */
2253 if (h
->dynindx
== -1 && !h
->forced_local
2254 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
2257 if (bfd_link_pic (info
)
2258 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2260 bfd_vma loc
= add_symbol_to_plt (info
);
2262 if (bfd_link_executable (info
) && !h
->def_regular
)
2264 h
->root
.u
.def
.section
= htab
->splt
;
2265 h
->root
.u
.def
.value
= loc
;
2267 h
->plt
.offset
= loc
;
2271 h
->plt
.offset
= (bfd_vma
) -1;
2277 /* If this is a weak symbol, and there is a real definition, the
2278 processor independent code will have arranged for us to see the
2279 real definition first, and we can just use the same value. */
2280 if (h
->u
.weakdef
!= NULL
)
2282 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2283 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2284 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2285 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2289 /* This is a reference to a symbol defined by a dynamic object which
2290 is not a function. */
2292 /* If we are creating a shared library, we must presume that the
2293 only references to the symbol are via the global offset table.
2294 For such cases we need not do anything here; the relocations will
2295 be handled correctly by relocate_section. */
2296 if (!bfd_link_executable (info
))
2299 /* If there are no non-GOT references, we do not need a copy
2301 if (!h
->non_got_ref
)
2304 /* If -z nocopyreloc was given, we won't generate them either. */
2305 if (info
->nocopyreloc
)
2311 /* We must allocate the symbol in our .dynbss section, which will
2312 become part of the .bss section of the executable. There will be
2313 an entry for this symbol in the .dynsym section. The dynamic
2314 object will contain position independent code, so all references
2315 from the dynamic object to this symbol will go through the global
2316 offset table. The dynamic linker will use the .dynsym entry to
2317 determine the address it must put in the global offset table, so
2318 both the dynamic object and the regular object will refer to the
2319 same memory location for the variable. */
2324 /* We must generate a R_ARC_COPY reloc to tell the dynamic linker to
2325 copy the initial value out of the dynamic object and into the
2326 runtime process image. We need to remember the offset into the
2327 .rela.bss section we are going to use. */
2328 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
2330 struct elf_arc_link_hash_table
*arc_htab
= elf_arc_hash_table (info
);
2332 BFD_ASSERT (arc_htab
->elf
.srelbss
!= NULL
);
2333 arc_htab
->elf
.srelbss
->size
+= sizeof (Elf32_External_Rela
);
2337 /* TODO: Move this also to arc_hash_table. */
2338 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
2339 BFD_ASSERT (s
!= NULL
);
2341 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2344 /* Function : elf_arc_finish_dynamic_symbol
2345 Brief : Finish up dynamic symbol handling. We set the
2346 contents of various dynamic sections here.
2351 Returns : True/False as the return status. */
2354 elf_arc_finish_dynamic_symbol (bfd
* output_bfd
,
2355 struct bfd_link_info
*info
,
2356 struct elf_link_hash_entry
*h
,
2357 Elf_Internal_Sym
* sym
)
2359 if (h
->plt
.offset
!= (bfd_vma
) -1)
2361 relocate_plt_for_symbol (output_bfd
, info
, h
);
2363 if (!h
->def_regular
)
2365 /* Mark the symbol as undefined, rather than as defined in
2366 the .plt section. Leave the value alone. */
2367 sym
->st_shndx
= SHN_UNDEF
;
2372 /* This function traverses list of GOT entries and
2373 create respective dynamic relocs. */
2374 /* TODO: Make function to get list and not access the list directly. */
2375 /* TODO: Move function to relocate_section create this relocs eagerly. */
2376 create_got_dynrelocs_for_got_info (&h
->got
.glist
,
2383 struct elf_arc_link_hash_table
*arc_htab
= elf_arc_hash_table (info
);
2385 if (h
->dynindx
== -1
2386 || (h
->root
.type
!= bfd_link_hash_defined
2387 && h
->root
.type
!= bfd_link_hash_defweak
)
2388 || arc_htab
->elf
.srelbss
== NULL
)
2391 bfd_vma rel_offset
= (h
->root
.u
.def
.value
2392 + h
->root
.u
.def
.section
->output_section
->vma
2393 + h
->root
.u
.def
.section
->output_offset
);
2395 bfd_byte
* loc
= arc_htab
->elf
.srelbss
->contents
2396 + (arc_htab
->elf
.srelbss
->reloc_count
* sizeof (Elf32_External_Rela
));
2397 arc_htab
->elf
.srelbss
->reloc_count
++;
2399 Elf_Internal_Rela rel
;
2401 rel
.r_offset
= rel_offset
;
2403 BFD_ASSERT (h
->dynindx
!= -1);
2404 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARC_COPY
);
2406 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
2409 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2410 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2411 || strcmp (h
->root
.root
.string
, "__DYNAMIC") == 0
2412 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
2413 sym
->st_shndx
= SHN_ABS
;
2418 #define GET_SYMBOL_OR_SECTION(TAG, SYMBOL, SECTION) \
2420 if (SYMBOL != NULL) \
2421 h = elf_link_hash_lookup (elf_hash_table (info), \
2422 SYMBOL, FALSE, FALSE, TRUE); \
2423 else if (SECTION != NULL) \
2424 s = bfd_get_linker_section (dynobj, SECTION); \
2427 /* Function : elf_arc_finish_dynamic_sections
2428 Brief : Finish up the dynamic sections handling.
2433 Returns : True/False as the return status. */
2436 elf_arc_finish_dynamic_sections (bfd
* output_bfd
,
2437 struct bfd_link_info
*info
)
2439 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2440 bfd
*dynobj
= (elf_hash_table (info
))->dynobj
;
2441 asection
*sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
2445 Elf32_External_Dyn
*dyncon
, *dynconend
;
2447 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
2449 = (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
2450 for (; dyncon
< dynconend
; dyncon
++)
2452 Elf_Internal_Dyn internal_dyn
;
2453 bfd_boolean do_it
= FALSE
;
2455 struct elf_link_hash_entry
*h
= NULL
;
2458 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &internal_dyn
);
2460 switch (internal_dyn
.d_tag
)
2462 GET_SYMBOL_OR_SECTION (DT_INIT
, info
->init_function
, NULL
)
2463 GET_SYMBOL_OR_SECTION (DT_FINI
, info
->fini_function
, NULL
)
2464 GET_SYMBOL_OR_SECTION (DT_PLTGOT
, NULL
, ".plt")
2465 GET_SYMBOL_OR_SECTION (DT_JMPREL
, NULL
, ".rela.plt")
2466 GET_SYMBOL_OR_SECTION (DT_PLTRELSZ
, NULL
, ".rela.plt")
2467 GET_SYMBOL_OR_SECTION (DT_VERSYM
, NULL
, ".gnu.version")
2468 GET_SYMBOL_OR_SECTION (DT_VERDEF
, NULL
, ".gnu.version_d")
2469 GET_SYMBOL_OR_SECTION (DT_VERNEED
, NULL
, ".gnu.version_r")
2474 /* In case the dynamic symbols should be updated with a symbol. */
2476 && (h
->root
.type
== bfd_link_hash_defined
2477 || h
->root
.type
== bfd_link_hash_defweak
))
2481 internal_dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
2482 asec_ptr
= h
->root
.u
.def
.section
;
2483 if (asec_ptr
->output_section
!= NULL
)
2485 internal_dyn
.d_un
.d_val
+=
2486 (asec_ptr
->output_section
->vma
2487 + asec_ptr
->output_offset
);
2491 /* The symbol is imported from another shared
2492 library and does not apply to this one. */
2493 internal_dyn
.d_un
.d_val
= 0;
2497 else if (s
!= NULL
) /* With a section information. */
2499 switch (internal_dyn
.d_tag
)
2506 internal_dyn
.d_un
.d_ptr
= (s
->output_section
->vma
2507 + s
->output_offset
);
2512 internal_dyn
.d_un
.d_val
= s
->size
;
2522 bfd_elf32_swap_dyn_out (output_bfd
, &internal_dyn
, dyncon
);
2525 if (htab
->splt
->size
> 0)
2527 relocate_plt_for_entry (output_bfd
, info
);
2530 /* TODO: Validate this. */
2531 if (htab
->srelplt
->output_section
!= bfd_abs_section_ptr
)
2532 elf_section_data (htab
->srelplt
->output_section
)
2533 ->this_hdr
.sh_entsize
= 12;
2536 /* Fill in the first three entries in the global offset table. */
2539 struct elf_link_hash_entry
*h
;
2540 h
= elf_link_hash_lookup (elf_hash_table (info
), "_GLOBAL_OFFSET_TABLE_",
2541 FALSE
, FALSE
, TRUE
);
2543 if (h
!= NULL
&& h
->root
.type
!= bfd_link_hash_undefined
2544 && h
->root
.u
.def
.section
!= NULL
)
2546 asection
*sec
= h
->root
.u
.def
.section
;
2549 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
2552 bfd_put_32 (output_bfd
,
2553 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
2555 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sec
->contents
+ 4);
2556 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sec
->contents
+ 8);
2563 #define ADD_DYNAMIC_SYMBOL(NAME, TAG) \
2564 h = elf_link_hash_lookup (elf_hash_table (info), \
2565 NAME, FALSE, FALSE, FALSE); \
2566 if ((h != NULL && (h->ref_regular || h->def_regular))) \
2567 if (! _bfd_elf_add_dynamic_entry (info, TAG, 0)) \
2570 /* Set the sizes of the dynamic sections. */
2572 elf_arc_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
2573 struct bfd_link_info
*info
)
2577 bfd_boolean relocs_exist
= FALSE
;
2578 bfd_boolean reltext_exist
= FALSE
;
2579 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2581 dynobj
= htab
->dynobj
;
2582 BFD_ASSERT (dynobj
!= NULL
);
2584 if (htab
->dynamic_sections_created
)
2586 struct elf_link_hash_entry
*h
;
2588 /* Set the contents of the .interp section to the
2590 if (bfd_link_executable (info
) && !info
->nointerp
)
2592 s
= bfd_get_section_by_name (dynobj
, ".interp");
2593 BFD_ASSERT (s
!= NULL
);
2594 s
->size
= sizeof (ELF_DYNAMIC_INTERPRETER
);
2595 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2598 /* Add some entries to the .dynamic section. We fill in some of
2599 the values later, in elf_bfd_final_link, but we must add the
2600 entries now so that we know the final size of the .dynamic
2601 section. Checking if the .init section is present. We also
2602 create DT_INIT and DT_FINI entries if the init_str has been
2603 changed by the user. */
2604 ADD_DYNAMIC_SYMBOL (info
->init_function
, DT_INIT
);
2605 ADD_DYNAMIC_SYMBOL (info
->fini_function
, DT_FINI
);
2609 /* We may have created entries in the .rela.got section.
2610 However, if we are not creating the dynamic sections, we will
2611 not actually use these entries. Reset the size of .rela.got,
2612 which will cause it to get stripped from the output file
2614 if (htab
->srelgot
!= NULL
)
2615 htab
->srelgot
->size
= 0;
2618 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2620 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2625 || s
== htab
->sgotplt
2626 || s
== htab
->sdynbss
)
2628 /* Strip this section if we don't need it. */
2630 else if (strncmp (s
->name
, ".rela", 5) == 0)
2632 if (s
->size
!= 0 && s
!= htab
->srelplt
)
2636 const char *name
= s
->name
+ 5;
2638 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
2639 if (bfd_get_flavour (ibfd
) == bfd_target_elf_flavour
)
2641 asection
*target
= bfd_get_section_by_name (ibfd
, name
);
2643 && elf_section_data (target
)->sreloc
== s
2644 && ((target
->output_section
->flags
2645 & (SEC_READONLY
| SEC_ALLOC
))
2646 == (SEC_READONLY
| SEC_ALLOC
)))
2648 reltext_exist
= TRUE
;
2653 relocs_exist
= TRUE
;
2656 /* We use the reloc_count field as a counter if we need to
2657 copy relocs into the output file. */
2662 /* It's not one of our sections, so don't allocate space. */
2668 s
->flags
|= SEC_EXCLUDE
;
2672 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
2675 /* Allocate memory for the section contents. */
2676 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
2677 if (s
->contents
== NULL
)
2681 if (htab
->dynamic_sections_created
)
2683 /* TODO: Check if this is needed. */
2684 if (!bfd_link_pic (info
))
2685 if (!_bfd_elf_add_dynamic_entry (info
, DT_DEBUG
, 0))
2688 if (htab
->splt
&& (htab
->splt
->flags
& SEC_EXCLUDE
) == 0)
2689 if (!_bfd_elf_add_dynamic_entry (info
, DT_PLTGOT
, 0)
2690 || !_bfd_elf_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
2691 || !_bfd_elf_add_dynamic_entry (info
, DT_PLTREL
, DT_RELA
)
2692 || !_bfd_elf_add_dynamic_entry (info
, DT_JMPREL
, 0))
2696 if (!_bfd_elf_add_dynamic_entry (info
, DT_RELA
, 0)
2697 || !_bfd_elf_add_dynamic_entry (info
, DT_RELASZ
, 0)
2698 || !_bfd_elf_add_dynamic_entry (info
, DT_RELAENT
,
2699 sizeof (Elf32_External_Rela
)))
2703 if (!_bfd_elf_add_dynamic_entry (info
, DT_TEXTREL
, 0))
2711 /* Classify dynamic relocs such that -z combreloc can reorder and combine
2713 static enum elf_reloc_type_class
2714 elf32_arc_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2715 const asection
*rel_sec ATTRIBUTE_UNUSED
,
2716 const Elf_Internal_Rela
*rela
)
2718 switch ((int) ELF32_R_TYPE (rela
->r_info
))
2720 case R_ARC_RELATIVE
:
2721 return reloc_class_relative
;
2722 case R_ARC_JMP_SLOT
:
2723 return reloc_class_plt
;
2725 return reloc_class_copy
;
2726 /* TODO: Needed in future to support ifunc. */
2728 case R_ARC_IRELATIVE:
2729 return reloc_class_ifunc;
2732 return reloc_class_normal
;
2736 const struct elf_size_info arc_elf32_size_info
=
2738 sizeof (Elf32_External_Ehdr
),
2739 sizeof (Elf32_External_Phdr
),
2740 sizeof (Elf32_External_Shdr
),
2741 sizeof (Elf32_External_Rel
),
2742 sizeof (Elf32_External_Rela
),
2743 sizeof (Elf32_External_Sym
),
2744 sizeof (Elf32_External_Dyn
),
2745 sizeof (Elf_External_Note
),
2749 ELFCLASS32
, EV_CURRENT
,
2750 bfd_elf32_write_out_phdrs
,
2751 bfd_elf32_write_shdrs_and_ehdr
,
2752 bfd_elf32_checksum_contents
,
2753 bfd_elf32_write_relocs
,
2754 bfd_elf32_swap_symbol_in
,
2755 bfd_elf32_swap_symbol_out
,
2756 bfd_elf32_slurp_reloc_table
,
2757 bfd_elf32_slurp_symbol_table
,
2758 bfd_elf32_swap_dyn_in
,
2759 bfd_elf32_swap_dyn_out
,
2760 bfd_elf32_swap_reloc_in
,
2761 bfd_elf32_swap_reloc_out
,
2762 bfd_elf32_swap_reloca_in
,
2763 bfd_elf32_swap_reloca_out
2766 #define elf_backend_size_info arc_elf32_size_info
2768 /* Hook called by the linker routine which adds symbols from an object
2772 elf_arc_add_symbol_hook (bfd
* abfd
,
2773 struct bfd_link_info
* info
,
2774 Elf_Internal_Sym
* sym
,
2775 const char ** namep ATTRIBUTE_UNUSED
,
2776 flagword
* flagsp ATTRIBUTE_UNUSED
,
2777 asection
** secp ATTRIBUTE_UNUSED
,
2778 bfd_vma
* valp ATTRIBUTE_UNUSED
)
2780 if (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
2781 && (abfd
->flags
& DYNAMIC
) == 0
2782 && bfd_get_flavour (info
->output_bfd
) == bfd_target_elf_flavour
)
2783 elf_tdata (info
->output_bfd
)->has_gnu_symbols
|= elf_gnu_symbol_ifunc
;
2788 /* GDB expects general purpose registers to be in section .reg. However Linux
2789 kernel doesn't create this section and instead writes registers to NOTE
2790 section. It is up to the binutils to create a pseudo-section .reg from the
2791 contents of NOTE. Also BFD will read pid and signal number from NOTE. This
2792 function relies on offsets inside elf_prstatus structure in Linux to be
2796 elf32_arc_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
2801 switch (note
->descsz
)
2806 case 236: /* sizeof (struct elf_prstatus) on Linux/arc. */
2808 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
2810 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
2813 size
= (40 * 4); /* There are 40 registers in user_regs_struct. */
2816 /* Make a ".reg/999" section. */
2817 return _bfd_elfcore_make_pseudosection (abfd
, ".reg", size
,
2818 note
->descpos
+ offset
);
2821 /* Determine whether an object attribute tag takes an integer, a
2825 elf32_arc_obj_attrs_arg_type (int tag
)
2827 if (tag
== Tag_ARC_CPU_name
2828 || tag
== Tag_ARC_ISA_config
2829 || tag
== Tag_ARC_ISA_apex
)
2830 return ATTR_TYPE_FLAG_STR_VAL
;
2831 else if (tag
< (Tag_ARC_ISA_mpy_option
+ 1))
2832 return ATTR_TYPE_FLAG_INT_VAL
;
2834 return (tag
& 1) != 0 ? ATTR_TYPE_FLAG_STR_VAL
: ATTR_TYPE_FLAG_INT_VAL
;
2837 /* Attribute numbers >=14 can be safely ignored. */
2840 elf32_arc_obj_attrs_handle_unknown (bfd
*abfd
, int tag
)
2842 if ((tag
& 127) < (Tag_ARC_ISA_mpy_option
+ 1))
2845 (_("%B: Unknown mandatory ARC object attribute %d."),
2847 bfd_set_error (bfd_error_bad_value
);
2853 (_("Warning: %B: Unknown ARC object attribute %d."),
2859 /* Handle an ARC specific section when reading an object file. This is
2860 called when bfd_section_from_shdr finds a section with an unknown
2864 elf32_arc_section_from_shdr (bfd
*abfd
,
2865 Elf_Internal_Shdr
* hdr
,
2869 switch (hdr
->sh_type
)
2871 case SHT_ARC_ATTRIBUTES
:
2878 if (!_bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2884 #define TARGET_LITTLE_SYM arc_elf32_le_vec
2885 #define TARGET_LITTLE_NAME "elf32-littlearc"
2886 #define TARGET_BIG_SYM arc_elf32_be_vec
2887 #define TARGET_BIG_NAME "elf32-bigarc"
2888 #define ELF_ARCH bfd_arch_arc
2889 #define ELF_TARGET_ID ARC_ELF_DATA
2890 #define ELF_MACHINE_CODE EM_ARC_COMPACT
2891 #define ELF_MACHINE_ALT1 EM_ARC_COMPACT2
2892 #define ELF_MAXPAGESIZE 0x2000
2894 #define bfd_elf32_bfd_link_hash_table_create arc_elf_link_hash_table_create
2896 #define bfd_elf32_bfd_merge_private_bfd_data arc_elf_merge_private_bfd_data
2897 #define bfd_elf32_bfd_reloc_type_lookup arc_elf32_bfd_reloc_type_lookup
2898 #define bfd_elf32_bfd_set_private_flags arc_elf_set_private_flags
2899 #define bfd_elf32_bfd_print_private_bfd_data arc_elf_print_private_bfd_data
2900 #define bfd_elf32_bfd_copy_private_bfd_data arc_elf_copy_private_bfd_data
2902 #define elf_info_to_howto_rel arc_info_to_howto_rel
2903 #define elf_backend_object_p arc_elf_object_p
2904 #define elf_backend_final_write_processing arc_elf_final_write_processing
2906 #define elf_backend_relocate_section elf_arc_relocate_section
2907 #define elf_backend_check_relocs elf_arc_check_relocs
2908 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
2910 #define elf_backend_reloc_type_class elf32_arc_reloc_type_class
2912 #define elf_backend_adjust_dynamic_symbol elf_arc_adjust_dynamic_symbol
2913 #define elf_backend_finish_dynamic_symbol elf_arc_finish_dynamic_symbol
2915 #define elf_backend_finish_dynamic_sections elf_arc_finish_dynamic_sections
2916 #define elf_backend_size_dynamic_sections elf_arc_size_dynamic_sections
2917 #define elf_backend_add_symbol_hook elf_arc_add_symbol_hook
2919 #define elf_backend_can_gc_sections 1
2920 #define elf_backend_want_got_plt 1
2921 #define elf_backend_plt_readonly 1
2922 #define elf_backend_rela_plts_and_copies_p 1
2923 #define elf_backend_want_plt_sym 0
2924 #define elf_backend_got_header_size 12
2925 #define elf_backend_dtrel_excludes_plt 1
2927 #define elf_backend_may_use_rel_p 0
2928 #define elf_backend_may_use_rela_p 1
2929 #define elf_backend_default_use_rela_p 1
2931 #define elf_backend_grok_prstatus elf32_arc_grok_prstatus
2933 #define elf_backend_default_execstack 0
2935 #undef elf_backend_obj_attrs_vendor
2936 #define elf_backend_obj_attrs_vendor "ARC"
2937 #undef elf_backend_obj_attrs_section
2938 #define elf_backend_obj_attrs_section ".ARC.attributes"
2939 #undef elf_backend_obj_attrs_arg_type
2940 #define elf_backend_obj_attrs_arg_type elf32_arc_obj_attrs_arg_type
2941 #undef elf_backend_obj_attrs_section_type
2942 #define elf_backend_obj_attrs_section_type SHT_ARC_ATTRIBUTES
2943 #define elf_backend_obj_attrs_handle_unknown elf32_arc_obj_attrs_handle_unknown
2945 #define elf_backend_section_from_shdr elf32_arc_section_from_shdr
2947 #include "elf32-target.h"