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 /* ARC ELF linker hash entry. */
164 struct elf_arc_link_hash_entry
166 struct elf_link_hash_entry root
;
168 /* Track dynamic relocs copied for this symbol. */
169 struct elf_dyn_relocs
*dyn_relocs
;
171 struct got_entry
*got_ents
;
175 /* Should be included at this location due to static declarations
176 defined before this point. */
179 #define arc_bfd_get_8(A,B,C) bfd_get_8(A,B)
180 #define arc_bfd_get_16(A,B,C) bfd_get_16(A,B)
181 #define arc_bfd_get_32(A,B,C) bfd_get_32(A,B)
182 #define arc_bfd_put_8(A,B,C,D) bfd_put_8(A,B,C)
183 #define arc_bfd_put_16(A,B,C,D) bfd_put_16(A,B,C)
184 #define arc_bfd_put_32(A,B,C,D) bfd_put_32(A,B,C)
187 static bfd_reloc_status_type
188 arc_elf_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
189 arelent
*reloc_entry
,
191 void *data ATTRIBUTE_UNUSED
,
192 asection
*input_section
,
194 char ** error_message ATTRIBUTE_UNUSED
)
196 if (output_bfd
!= NULL
)
198 reloc_entry
->address
+= input_section
->output_offset
;
200 /* In case of relocateable link and if the reloc is against a
201 section symbol, the addend needs to be adjusted according to
202 where the section symbol winds up in the output section. */
203 if ((symbol_in
->flags
& BSF_SECTION_SYM
) && symbol_in
->section
)
204 reloc_entry
->addend
+= symbol_in
->section
->output_offset
;
209 return bfd_reloc_continue
;
213 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
218 #include "elf/arc-reloc.def"
222 #undef ARC_RELOC_HOWTO
224 #define ARC_RELOC_HOWTO(TYPE, VALUE, RSIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
225 [TYPE] = HOWTO (R_##TYPE, 0, RSIZE, BITSIZE, FALSE, 0, \
226 complain_overflow_##OVERFLOW, arc_elf_reloc, \
227 "R_" #TYPE, FALSE, 0, 0, FALSE),
229 static struct reloc_howto_struct elf_arc_howto_table
[] =
231 #include "elf/arc-reloc.def"
232 /* Example of what is generated by the preprocessor. Currently kept as an
234 HOWTO (R_ARC_NONE, // Type.
236 2, // Size (0 = byte, 1 = short, 2 = long).
238 FALSE, // PC_relative.
240 complain_overflow_bitfield, // Complain_on_overflow.
241 bfd_elf_generic_reloc, // Special_function.
242 "R_ARC_NONE", // Name.
243 TRUE, // Partial_inplace.
246 FALSE), // PCrel_offset.
249 #undef ARC_RELOC_HOWTO
252 arc_elf_howto_init (void)
254 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
255 elf_arc_howto_table[TYPE].pc_relative = \
256 (strstr (#FORMULA, " P ") != NULL || strstr (#FORMULA, " PDATA ") != NULL); \
257 elf_arc_howto_table[TYPE].dst_mask = RELOC_FUNCTION(0, ~0); \
258 /* Only 32 bit data relocations should be marked as ME. */ \
259 if (strstr (#FORMULA, " ME ") != NULL) \
261 BFD_ASSERT (SIZE == 2); \
264 #include "elf/arc-reloc.def"
267 #undef ARC_RELOC_HOWTO
270 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
273 const int howto_table_lookup
[] =
275 #include "elf/arc-reloc.def"
278 #undef ARC_RELOC_HOWTO
280 static reloc_howto_type
*
281 arc_elf_howto (unsigned int r_type
)
283 if (elf_arc_howto_table
[R_ARC_32
].dst_mask
== 0)
284 arc_elf_howto_init ();
285 return &elf_arc_howto_table
[r_type
];
288 /* Map BFD reloc types to ARC ELF reloc types. */
292 bfd_reloc_code_real_type bfd_reloc_val
;
293 unsigned char elf_reloc_val
;
296 /* ARC ELF linker hash table. */
297 struct elf_arc_link_hash_table
299 struct elf_link_hash_table elf
;
302 static struct bfd_hash_entry
*
303 elf_arc_link_hash_newfunc (struct bfd_hash_entry
*entry
,
304 struct bfd_hash_table
*table
,
307 struct elf_arc_link_hash_entry
* ret
=
308 (struct elf_arc_link_hash_entry
*) entry
;
310 /* Allocate the structure if it has not already been allocated by a
313 ret
= (struct elf_arc_link_hash_entry
*)
314 bfd_hash_allocate (table
, sizeof (struct elf_arc_link_hash_entry
));
316 return (struct bfd_hash_entry
*) ret
;
318 /* Call the allocation method of the superclass. */
319 ret
= ((struct elf_arc_link_hash_entry
*)
320 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
324 ret
->dyn_relocs
= NULL
;
325 ret
->got_ents
= NULL
;
328 return (struct bfd_hash_entry
*) ret
;
331 /* Destroy an ARC ELF linker hash table. */
333 elf_arc_link_hash_table_free (bfd
*obfd
)
335 _bfd_elf_link_hash_table_free (obfd
);
338 /* Create an ARC ELF linker hash table. */
340 static struct bfd_link_hash_table
*
341 arc_elf_link_hash_table_create (bfd
*abfd
)
343 struct elf_arc_link_hash_table
*ret
;
345 ret
= (struct elf_arc_link_hash_table
*) bfd_zmalloc (sizeof (*ret
));
349 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
350 elf_arc_link_hash_newfunc
,
351 sizeof (struct elf_arc_link_hash_entry
),
358 ret
->elf
.root
.hash_table_free
= elf_arc_link_hash_table_free
;
360 return &ret
->elf
.root
;
363 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
364 { BFD_RELOC_##TYPE, R_##TYPE },
366 static const struct arc_reloc_map arc_reloc_map
[] =
368 #include "elf/arc-reloc.def"
370 {BFD_RELOC_NONE
, R_ARC_NONE
},
371 {BFD_RELOC_8
, R_ARC_8
},
372 {BFD_RELOC_16
, R_ARC_16
},
373 {BFD_RELOC_24
, R_ARC_24
},
374 {BFD_RELOC_32
, R_ARC_32
},
377 #undef ARC_RELOC_HOWTO
379 typedef ATTRIBUTE_UNUSED
bfd_vma (*replace_func
) (unsigned, int ATTRIBUTE_UNUSED
);
381 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
383 func = (void *) RELOC_FUNCTION; \
387 get_replace_function (bfd
*abfd
, unsigned int r_type
)
393 #include "elf/arc-reloc.def"
396 if (func
== replace_bits24
&& bfd_big_endian (abfd
))
397 func
= replace_bits24_be
;
399 return (replace_func
) func
;
401 #undef ARC_RELOC_HOWTO
403 static reloc_howto_type
*
404 arc_elf32_bfd_reloc_type_lookup (bfd
* abfd ATTRIBUTE_UNUSED
,
405 bfd_reloc_code_real_type code
)
409 for (i
= ARRAY_SIZE (arc_reloc_map
); i
--;)
411 if (arc_reloc_map
[i
].bfd_reloc_val
== code
)
412 return arc_elf_howto (arc_reloc_map
[i
].elf_reloc_val
);
418 /* Function to set the ELF flag bits. */
420 arc_elf_set_private_flags (bfd
*abfd
, flagword flags
)
422 elf_elfheader (abfd
)->e_flags
= flags
;
423 elf_flags_init (abfd
) = TRUE
;
427 /* Print private flags. */
429 arc_elf_print_private_bfd_data (bfd
*abfd
, void * ptr
)
431 FILE *file
= (FILE *) ptr
;
434 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
436 /* Print normal ELF private data. */
437 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
439 flags
= elf_elfheader (abfd
)->e_flags
;
440 fprintf (file
, _("private flags = 0x%lx:"), (unsigned long) flags
);
442 switch (flags
& EF_ARC_MACH_MSK
)
444 case EF_ARC_CPU_ARCV2HS
: fprintf (file
, " -mcpu=ARCv2HS"); break;
445 case EF_ARC_CPU_ARCV2EM
: fprintf (file
, " -mcpu=ARCv2EM"); break;
446 case E_ARC_MACH_ARC600
: fprintf (file
, " -mcpu=ARC600"); break;
447 case E_ARC_MACH_ARC601
: fprintf (file
, " -mcpu=ARC601"); break;
448 case E_ARC_MACH_ARC700
: fprintf (file
, " -mcpu=ARC700"); break;
450 fprintf (file
, "-mcpu=unknown");
454 switch (flags
& EF_ARC_OSABI_MSK
)
456 case E_ARC_OSABI_ORIG
: fprintf (file
, " (ABI:legacy)"); break;
457 case E_ARC_OSABI_V2
: fprintf (file
, " (ABI:v2)"); break;
458 case E_ARC_OSABI_V3
: fprintf (file
, " (ABI:v3)"); break;
459 case E_ARC_OSABI_V4
: fprintf (file
, " (ABI:v4)"); break;
461 fprintf (file
, " (ABI:unknown)");
469 /* Copy backend specific data from one object module to another. */
472 arc_elf_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
474 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
475 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
478 BFD_ASSERT (!elf_flags_init (obfd
)
479 || elf_elfheader (obfd
)->e_flags
== elf_elfheader (ibfd
)->e_flags
);
481 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
482 elf_flags_init (obfd
) = TRUE
;
484 /* Copy object attributes. */
485 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
487 return _bfd_elf_copy_private_bfd_data (ibfd
, obfd
);
490 static reloc_howto_type
*
491 bfd_elf32_bfd_reloc_name_lookup (bfd
* abfd ATTRIBUTE_UNUSED
,
496 for (i
= 0; i
< ARRAY_SIZE (elf_arc_howto_table
); i
++)
497 if (elf_arc_howto_table
[i
].name
!= NULL
498 && strcasecmp (elf_arc_howto_table
[i
].name
, r_name
) == 0)
499 return arc_elf_howto (i
);
504 /* Set the howto pointer for an ARC ELF reloc. */
507 arc_info_to_howto_rel (bfd
* abfd
,
509 Elf_Internal_Rela
* dst
)
513 r_type
= ELF32_R_TYPE (dst
->r_info
);
514 if (r_type
>= (unsigned int) R_ARC_max
)
516 /* xgettext:c-format */
517 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
519 bfd_set_error (bfd_error_bad_value
);
523 cache_ptr
->howto
= arc_elf_howto (r_type
);
527 /* Extract CPU features from an NTBS. */
530 arc_extract_features (const char *p
)
537 for (i
= 0; i
< ARRAY_SIZE (bfd_feature_list
); i
++)
539 char *t
= strstr (p
, bfd_feature_list
[i
].attr
);
540 unsigned l
= strlen (bfd_feature_list
[i
].attr
);
544 r
|= bfd_feature_list
[i
].feature
;
550 /* Concatenate two strings. s1 can be NULL but not
554 arc_stralloc (char * s1
, const char * s2
)
558 /* Only s1 can be null. */
561 p
= s1
? concat (s1
, ",", s2
, NULL
) : (char *)s2
;
566 /* Merge ARC object attributes from IBFD into OBFD. Raise an error if
567 there are conflicting attributes. */
570 arc_elf_merge_attributes (bfd
*ibfd
, struct bfd_link_info
*info
)
572 bfd
*obfd
= info
->output_bfd
;
573 obj_attribute
*in_attr
;
574 obj_attribute
*out_attr
;
576 bfd_boolean result
= TRUE
;
577 const char *sec_name
= get_elf_backend_data (ibfd
)->obj_attrs_section
;
578 char *tagname
= NULL
;
580 /* Skip the linker stubs file. This preserves previous behavior
581 of accepting unknown attributes in the first input file - but
583 if (ibfd
->flags
& BFD_LINKER_CREATED
)
586 /* Skip any input that hasn't attribute section.
587 This enables to link object files without attribute section with
589 if (bfd_get_section_by_name (ibfd
, sec_name
) == NULL
)
592 if (!elf_known_obj_attributes_proc (obfd
)[0].i
)
594 /* This is the first object. Copy the attributes. */
595 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
597 out_attr
= elf_known_obj_attributes_proc (obfd
);
599 /* Use the Tag_null value to indicate the attributes have been
606 in_attr
= elf_known_obj_attributes_proc (ibfd
);
607 out_attr
= elf_known_obj_attributes_proc (obfd
);
609 for (i
= LEAST_KNOWN_OBJ_ATTRIBUTE
; i
< NUM_KNOWN_OBJ_ATTRIBUTES
; i
++)
611 /* Merge this attribute with existing attributes. */
614 case Tag_ARC_PCS_config
:
615 if (out_attr
[i
].i
== 0)
616 out_attr
[i
].i
= in_attr
[i
].i
;
617 else if (in_attr
[i
].i
!= 0 && out_attr
[i
].i
!= in_attr
[i
].i
)
619 const char *tagval
[] = { "Absent", "Bare-metal/mwdt",
620 "Bare-metal/newlib", "Linux/uclibc",
622 BFD_ASSERT (in_attr
[i
].i
< 5);
623 BFD_ASSERT (out_attr
[i
].i
< 5);
624 /* It's sometimes ok to mix different configs, so this is only
627 (_("warning: %pB: conflicting platform configuration "
629 tagval
[in_attr
[i
].i
],
630 tagval
[out_attr
[i
].i
]);
634 case Tag_ARC_CPU_base
:
635 if (out_attr
[i
].i
== 0)
636 out_attr
[i
].i
= in_attr
[i
].i
;
637 else if (in_attr
[i
].i
!= 0 && out_attr
[i
].i
!= in_attr
[i
].i
638 && ((out_attr
[i
].i
+ in_attr
[i
].i
) < 6))
640 const char *tagval
[] = { "Absent", "ARC6xx", "ARC7xx",
642 BFD_ASSERT (in_attr
[i
].i
< 5);
643 BFD_ASSERT (out_attr
[i
].i
< 5);
644 /* We cannot mix code for different CPUs. */
646 (_("error: %pB: unable to merge CPU base attributes "
649 tagval
[in_attr
[i
].i
],
650 tagval
[out_attr
[i
].i
]);
656 /* The CPUs may be different, check if we can still mix
657 the objects against the output choosen CPU. */
658 unsigned in_feature
= 0;
659 unsigned out_feature
= 0;
660 char *p1
= in_attr
[Tag_ARC_ISA_config
].s
;
661 char *p2
= out_attr
[Tag_ARC_ISA_config
].s
;
664 unsigned opcode_map
[] = {0, ARC_OPCODE_ARC600
, ARC_OPCODE_ARC700
,
665 ARC_OPCODE_ARCv2EM
, ARC_OPCODE_ARCv2HS
};
667 BFD_ASSERT (in_attr
[i
].i
< (sizeof (opcode_map
)
668 / sizeof (unsigned)));
669 BFD_ASSERT (out_attr
[i
].i
< (sizeof (opcode_map
)
670 / sizeof (unsigned)));
671 cpu_out
= opcode_map
[out_attr
[i
].i
];
673 in_feature
= arc_extract_features (p1
);
674 out_feature
= arc_extract_features (p2
);
676 /* First, check if a feature is compatible with the
677 output object chosen CPU. */
678 for (j
= 0; j
< ARRAY_SIZE (bfd_feature_list
); j
++)
679 if (((in_feature
| out_feature
) & bfd_feature_list
[j
].feature
)
680 && (!(cpu_out
& bfd_feature_list
[j
].cpus
)))
683 (_("error: %pB: unable to merge ISA extension attributes "
685 obfd
, bfd_feature_list
[j
].name
);
689 /* Second, if we have compatible features with the
690 chosen CPU, check if they are compatible among
692 for (j
= 0; j
< ARRAY_SIZE (bfd_conflict_list
); j
++)
693 if (((in_feature
| out_feature
) & bfd_conflict_list
[j
])
694 == bfd_conflict_list
[j
])
697 for (k
= 0; k
< ARRAY_SIZE (bfd_feature_list
); k
++)
699 if (in_feature
& bfd_feature_list
[k
].feature
700 & bfd_conflict_list
[j
])
701 p1
= (char *) bfd_feature_list
[k
].name
;
702 if (out_feature
& bfd_feature_list
[k
].feature
703 & bfd_conflict_list
[j
])
704 p2
= (char *) bfd_feature_list
[k
].name
;
707 (_("error: %pB: conflicting ISA extension attributes "
713 /* Everithing is alright. */
714 out_feature
|= in_feature
;
716 for (j
= 0; j
< ARRAY_SIZE (bfd_feature_list
); j
++)
717 if (out_feature
& bfd_feature_list
[j
].feature
)
718 p1
= arc_stralloc (p1
, bfd_feature_list
[j
].attr
);
720 out_attr
[Tag_ARC_ISA_config
].s
=
721 _bfd_elf_attr_strdup (obfd
, p1
);
724 case Tag_ARC_CPU_variation
:
725 case Tag_ARC_ISA_mpy_option
:
726 case Tag_ARC_ABI_osver
:
727 /* Use the largest value specified. */
728 if (in_attr
[i
].i
> out_attr
[i
].i
)
729 out_attr
[i
].i
= in_attr
[i
].i
;
732 case Tag_ARC_CPU_name
:
735 case Tag_ARC_ABI_rf16
:
736 if (out_attr
[i
].i
== 0)
737 out_attr
[i
].i
= in_attr
[i
].i
;
738 else if (out_attr
[i
].i
!= in_attr
[i
].i
)
740 /* We cannot mix code with rf16 and without. */
742 (_("error: %pB: cannot mix rf16 with full register set %pB"),
748 case Tag_ARC_ABI_pic
:
751 case Tag_ARC_ABI_sda
:
755 case Tag_ARC_ABI_tls
:
757 const char *tagval
[] = { "Absent", "MWDT", "GNU" };
762 BFD_ASSERT (in_attr
[i
].i
< 3);
763 BFD_ASSERT (out_attr
[i
].i
< 3);
764 if (out_attr
[i
].i
!= 0 && in_attr
[i
].i
!= 0
765 && out_attr
[i
].i
!= in_attr
[i
].i
)
768 (_("error: %pB: conflicting attributes %s: %s with %s"),
770 tagval
[in_attr
[i
].i
],
771 tagval
[out_attr
[i
].i
]);
778 case Tag_ARC_ABI_double_size
:
779 tagname
= "Double size";
781 case Tag_ARC_ABI_enumsize
:
783 tagname
= "Enum size";
785 case Tag_ARC_ABI_exceptions
:
787 tagname
= "ABI exceptions";
789 if (out_attr
[i
].i
!= 0 && in_attr
[i
].i
!= 0
790 && out_attr
[i
].i
!= in_attr
[i
].i
)
793 (_("error: %pB: conflicting attributes %s"),
799 case Tag_ARC_ISA_apex
:
800 break; /* Do nothing for APEX attributes. */
802 case Tag_ARC_ISA_config
:
803 /* It is handled in Tag_ARC_CPU_base. */
808 = result
&& _bfd_elf_merge_unknown_attribute_low (ibfd
, obfd
, i
);
811 /* If out_attr was copied from in_attr then it won't have a type yet. */
812 if (in_attr
[i
].type
&& !out_attr
[i
].type
)
813 out_attr
[i
].type
= in_attr
[i
].type
;
816 /* Merge Tag_compatibility attributes and any common GNU ones. */
817 if (!_bfd_elf_merge_object_attributes (ibfd
, info
))
820 /* Check for any attributes not known on ARC. */
821 result
&= _bfd_elf_merge_unknown_attribute_list (ibfd
, obfd
);
826 /* Merge backend specific data from an object file to the output
827 object file when linking. */
830 arc_elf_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
832 bfd
*obfd
= info
->output_bfd
;
833 unsigned short mach_ibfd
;
834 static unsigned short mach_obfd
= EM_NONE
;
839 /* Check if we have the same endianess. */
840 if (! _bfd_generic_verify_endian_match (ibfd
, info
))
843 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
844 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
847 /* Collect ELF flags. */
848 in_flags
= elf_elfheader (ibfd
)->e_flags
& EF_ARC_MACH_MSK
;
849 out_flags
= elf_elfheader (obfd
)->e_flags
& EF_ARC_MACH_MSK
;
851 if (!elf_flags_init (obfd
)) /* First call, no flags set. */
853 elf_flags_init (obfd
) = TRUE
;
854 out_flags
= in_flags
;
857 if (!arc_elf_merge_attributes (ibfd
, info
))
860 /* Check to see if the input BFD actually contains any sections. Do
861 not short-circuit dynamic objects; their section list may be
862 emptied by elf_link_add_object_symbols. */
863 if (!(ibfd
->flags
& DYNAMIC
))
865 bfd_boolean null_input_bfd
= TRUE
;
866 bfd_boolean only_data_sections
= TRUE
;
868 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
870 if ((bfd_get_section_flags (ibfd
, sec
)
871 & (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
872 == (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
873 only_data_sections
= FALSE
;
875 null_input_bfd
= FALSE
;
878 if (null_input_bfd
|| only_data_sections
)
882 /* Complain about various flag/architecture mismatches. */
883 mach_ibfd
= elf_elfheader (ibfd
)->e_machine
;
884 if (mach_obfd
== EM_NONE
)
886 mach_obfd
= mach_ibfd
;
890 if (mach_ibfd
!= mach_obfd
)
892 /* xgettext:c-format */
893 _bfd_error_handler (_("error: attempting to link %pB "
894 "with a binary %pB of different architecture"),
898 else if ((in_flags
!= out_flags
)
899 /* If we have object attributes, then we already
900 checked the objects compatibility, skip it. */
901 && !bfd_elf_get_obj_attr_int (ibfd
, OBJ_ATTR_PROC
,
904 /* Warn if different flags. */
906 /* xgettext:c-format */
907 (_("%pB: uses different e_flags (%#x) fields than "
908 "previous modules (%#x)"),
909 ibfd
, in_flags
, out_flags
);
910 if (in_flags
&& out_flags
)
912 /* MWDT doesnt set the eflags hence make sure we choose the
913 eflags set by gcc. */
914 in_flags
= in_flags
> out_flags
? in_flags
: out_flags
;
918 /* Everything is correct; don't change the output flags. */
919 in_flags
= out_flags
;
923 /* Update the flags. */
924 elf_elfheader (obfd
)->e_flags
= in_flags
;
926 if (bfd_get_mach (obfd
) < bfd_get_mach (ibfd
))
928 return bfd_set_arch_mach (obfd
, bfd_arch_arc
, bfd_get_mach (ibfd
));
934 /* Return a best guess for the machine number based on the attributes. */
937 bfd_arc_get_mach_from_attributes (bfd
* abfd
)
939 int arch
= bfd_elf_get_obj_attr_int (abfd
, OBJ_ATTR_PROC
, Tag_ARC_CPU_base
);
940 unsigned e_machine
= elf_elfheader (abfd
)->e_machine
;
945 return bfd_mach_arc_arc600
;
947 return bfd_mach_arc_arc700
;
950 return bfd_mach_arc_arcv2
;
954 return (e_machine
== EM_ARC_COMPACT
)
955 ? bfd_mach_arc_arc700
: bfd_mach_arc_arcv2
;
958 /* Set the right machine number for an ARC ELF file. */
960 arc_elf_object_p (bfd
* abfd
)
962 /* Make sure this is initialised, or you'll have the potential of passing
963 garbage---or misleading values---into the call to
964 bfd_default_set_arch_mach (). */
965 unsigned int mach
= bfd_mach_arc_arc700
;
966 unsigned long arch
= elf_elfheader (abfd
)->e_flags
& EF_ARC_MACH_MSK
;
967 unsigned e_machine
= elf_elfheader (abfd
)->e_machine
;
969 if (e_machine
== EM_ARC_COMPACT
|| e_machine
== EM_ARC_COMPACT2
)
973 case E_ARC_MACH_ARC600
:
974 mach
= bfd_mach_arc_arc600
;
976 case E_ARC_MACH_ARC601
:
977 mach
= bfd_mach_arc_arc601
;
979 case E_ARC_MACH_ARC700
:
980 mach
= bfd_mach_arc_arc700
;
982 case EF_ARC_CPU_ARCV2HS
:
983 case EF_ARC_CPU_ARCV2EM
:
984 mach
= bfd_mach_arc_arcv2
;
987 mach
= bfd_arc_get_mach_from_attributes (abfd
);
993 if (e_machine
== EM_ARC
)
996 (_("error: the ARC4 architecture is no longer supported"));
1002 (_("warning: unset or old architecture flags; "
1003 "use default machine"));
1007 return bfd_default_set_arch_mach (abfd
, bfd_arch_arc
, mach
);
1010 /* The final processing done just before writing out an ARC ELF object file.
1011 This gets the ARC architecture right based on the machine number. */
1014 arc_elf_final_write_processing (bfd
* abfd
,
1015 bfd_boolean linker ATTRIBUTE_UNUSED
)
1018 int osver
= bfd_elf_get_obj_attr_int (abfd
, OBJ_ATTR_PROC
,
1020 flagword e_flags
= elf_elfheader (abfd
)->e_flags
& ~EF_ARC_OSABI_MSK
;
1022 switch (bfd_get_mach (abfd
))
1024 case bfd_mach_arc_arc600
:
1025 emf
= EM_ARC_COMPACT
;
1027 case bfd_mach_arc_arc601
:
1028 emf
= EM_ARC_COMPACT
;
1030 case bfd_mach_arc_arc700
:
1031 emf
= EM_ARC_COMPACT
;
1033 case bfd_mach_arc_arcv2
:
1034 emf
= EM_ARC_COMPACT2
;
1040 elf_elfheader (abfd
)->e_machine
= emf
;
1042 /* Record whatever is the current syscall ABI version. */
1044 e_flags
|= ((osver
& 0x0f) << 8);
1046 e_flags
|= E_ARC_OSABI_V3
;
1048 elf_elfheader (abfd
)->e_flags
|= e_flags
;
1051 #ifdef ARC_ENABLE_DEBUG
1052 #define DEBUG_ARC_RELOC(A) debug_arc_reloc (A)
1055 debug_arc_reloc (struct arc_relocation_data reloc_data
)
1057 ARC_DEBUG ("Reloc type=%s, should_relocate = %s\n",
1058 reloc_data
.howto
->name
,
1059 reloc_data
.should_relocate
? "true" : "false");
1060 ARC_DEBUG (" offset = 0x%x, addend = 0x%x\n",
1061 (unsigned int) reloc_data
.reloc_offset
,
1062 (unsigned int) reloc_data
.reloc_addend
);
1063 ARC_DEBUG (" Symbol:\n");
1064 ARC_DEBUG (" value = 0x%08x\n",
1065 (unsigned int) reloc_data
.sym_value
);
1066 if (reloc_data
.sym_section
!= NULL
)
1068 ARC_DEBUG (" Symbol Section:\n");
1069 ARC_DEBUG (" section name = %s, output_offset 0x%08x",
1070 reloc_data
.sym_section
->name
,
1071 (unsigned int) reloc_data
.sym_section
->output_offset
);
1072 if (reloc_data
.sym_section
->output_section
!= NULL
)
1073 ARC_DEBUG (", output_section->vma = 0x%08x",
1074 ((unsigned int) reloc_data
.sym_section
->output_section
->vma
));
1076 if (reloc_data
.sym_section
->owner
&& reloc_data
.sym_section
->owner
->filename
)
1077 ARC_DEBUG (" file: %s\n", reloc_data
.sym_section
->owner
->filename
);
1081 ARC_DEBUG (" symbol section is NULL\n");
1084 ARC_DEBUG (" Input_section:\n");
1085 if (reloc_data
.input_section
!= NULL
)
1087 ARC_DEBUG (" section name = %s, output_offset 0x%08x, output_section->vma = 0x%08x\n",
1088 reloc_data
.input_section
->name
,
1089 (unsigned int) reloc_data
.input_section
->output_offset
,
1090 (unsigned int) reloc_data
.input_section
->output_section
->vma
);
1091 ARC_DEBUG (" changed_address = 0x%08x\n",
1092 (unsigned int) (reloc_data
.input_section
->output_section
->vma
1093 + reloc_data
.input_section
->output_offset
1094 + reloc_data
.reloc_offset
));
1095 ARC_DEBUG (" file: %s\n", reloc_data
.input_section
->owner
->filename
);
1099 ARC_DEBUG (" input section is NULL\n");
1103 #define DEBUG_ARC_RELOC(A)
1104 #endif /* ARC_ENABLE_DEBUG */
1107 middle_endian_convert (bfd_vma insn
, bfd_boolean do_it
)
1112 = ((insn
& 0xffff0000) >> 16)
1113 | ((insn
& 0xffff) << 16);
1118 /* This function is called for relocations that are otherwise marked as NOT
1119 requiring overflow checks. In here we perform non-standard checks of
1120 the relocation value. */
1122 static inline bfd_reloc_status_type
1123 arc_special_overflow_checks (const struct arc_relocation_data reloc_data
,
1124 bfd_signed_vma relocation
,
1125 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1127 switch (reloc_data
.howto
->type
)
1129 case R_ARC_NPS_CMEM16
:
1130 if (((relocation
>> 16) & 0xffff) != NPS_CMEM_HIGH_VALUE
)
1132 if (reloc_data
.reloc_addend
== 0)
1134 /* xgettext:c-format */
1135 (_("%pB(%pA+%#" PRIx64
"): CMEM relocation to `%s' is invalid, "
1136 "16 MSB should be %#x (value is %#" PRIx64
")"),
1137 reloc_data
.input_section
->owner
,
1138 reloc_data
.input_section
,
1139 (uint64_t) reloc_data
.reloc_offset
,
1140 reloc_data
.symbol_name
,
1141 NPS_CMEM_HIGH_VALUE
,
1142 (uint64_t) relocation
);
1145 /* xgettext:c-format */
1146 (_("%pB(%pA+%#" PRIx64
"): CMEM relocation to `%s+%#" PRIx64
1147 "' is invalid, 16 MSB should be %#x (value is %#" PRIx64
")"),
1148 reloc_data
.input_section
->owner
,
1149 reloc_data
.input_section
,
1150 (uint64_t) reloc_data
.reloc_offset
,
1151 reloc_data
.symbol_name
,
1152 (uint64_t) reloc_data
.reloc_addend
,
1153 NPS_CMEM_HIGH_VALUE
,
1154 (uint64_t) relocation
);
1155 return bfd_reloc_overflow
;
1163 return bfd_reloc_ok
;
1166 #define ME(reloc) (reloc)
1168 #define IS_ME(FORMULA,BFD) ((strstr (FORMULA, "ME") != NULL) \
1169 && (!bfd_big_endian (BFD)))
1171 #define S ((bfd_signed_vma) (reloc_data.sym_value \
1172 + (reloc_data.sym_section->output_section != NULL ? \
1173 (reloc_data.sym_section->output_offset \
1174 + reloc_data.sym_section->output_section->vma) : 0)))
1175 #define L ((bfd_signed_vma) (reloc_data.sym_value \
1176 + (reloc_data.sym_section->output_section != NULL ? \
1177 (reloc_data.sym_section->output_offset \
1178 + reloc_data.sym_section->output_section->vma) : 0)))
1179 #define A (reloc_data.reloc_addend)
1181 #define G (reloc_data.got_offset_value)
1182 #define GOT (reloc_data.got_symbol_vma)
1183 #define GOT_BEGIN (htab->sgot->output_section->vma)
1186 /* P: relative offset to PCL The offset should be to the
1187 current location aligned to 32 bits. */
1188 #define P ((bfd_signed_vma) ( \
1190 (reloc_data.input_section->output_section != NULL ? \
1191 reloc_data.input_section->output_section->vma : 0) \
1192 + reloc_data.input_section->output_offset \
1193 + (reloc_data.reloc_offset - (bitsize >= 32 ? 4 : 0))) \
1195 #define PDATA ((bfd_signed_vma) ( \
1196 (reloc_data.input_section->output_section->vma \
1197 + reloc_data.input_section->output_offset \
1198 + (reloc_data.reloc_offset))))
1199 #define SECTSTART (bfd_signed_vma) (reloc_data.sym_section->output_section->vma \
1200 + reloc_data.sym_section->output_offset)
1201 #define JLI (bfd_signed_vma) (reloc_data.sym_section->output_section->vma)
1202 #define _SDA_BASE_ (bfd_signed_vma) (reloc_data.sdata_begin_symbol_vma)
1203 #define TLS_REL (bfd_signed_vma) \
1204 ((elf_hash_table (info))->tls_sec->output_section->vma)
1205 #define TLS_TBSS (8)
1209 #ifdef ARC_ENABLE_DEBUG
1210 #define PRINT_DEBUG_RELOC_INFO_BEFORE(FORMULA, TYPE) \
1213 asection *sym_section = reloc_data.sym_section; \
1214 asection *input_section = reloc_data.input_section; \
1215 ARC_DEBUG ("RELOC_TYPE = " TYPE "\n"); \
1216 ARC_DEBUG ("FORMULA = " FORMULA "\n"); \
1217 ARC_DEBUG ("S = %#lx\n", S); \
1218 ARC_DEBUG ("A = %#lx\n", A); \
1219 ARC_DEBUG ("L = %lx\n", L); \
1220 if (sym_section->output_section != NULL) \
1221 ARC_DEBUG ("symbol_section->vma = %#lx\n", \
1222 sym_section->output_section->vma \
1223 + sym_section->output_offset); \
1225 ARC_DEBUG ("symbol_section->vma = NULL\n"); \
1226 if (input_section->output_section != NULL) \
1227 ARC_DEBUG ("symbol_section->vma = %#lx\n", \
1228 input_section->output_section->vma \
1229 + input_section->output_offset); \
1231 ARC_DEBUG ("symbol_section->vma = NULL\n"); \
1232 ARC_DEBUG ("PCL = %#lx\n", P); \
1233 ARC_DEBUG ("P = %#lx\n", P); \
1234 ARC_DEBUG ("G = %#lx\n", G); \
1235 ARC_DEBUG ("SDA_OFFSET = %#lx\n", _SDA_BASE_); \
1236 ARC_DEBUG ("SDA_SET = %d\n", reloc_data.sdata_begin_symbol_vma_set); \
1237 ARC_DEBUG ("GOT_OFFSET = %#lx\n", GOT); \
1238 ARC_DEBUG ("relocation = %#08lx\n", relocation); \
1239 ARC_DEBUG ("before = %#08x\n", (unsigned) insn); \
1240 ARC_DEBUG ("data = %08x (%u) (%d)\n", (unsigned) relocation, \
1241 (unsigned) relocation, (int) relocation); \
1245 #define PRINT_DEBUG_RELOC_INFO_AFTER \
1248 ARC_DEBUG ("after = 0x%08x\n", (unsigned int) insn); \
1254 #define PRINT_DEBUG_RELOC_INFO_BEFORE(...)
1255 #define PRINT_DEBUG_RELOC_INFO_AFTER
1257 #endif /* ARC_ENABLE_DEBUG */
1259 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
1262 bfd_signed_vma bitsize ATTRIBUTE_UNUSED = BITSIZE; \
1263 relocation = FORMULA ; \
1264 PRINT_DEBUG_RELOC_INFO_BEFORE (#FORMULA, #TYPE); \
1265 insn = middle_endian_convert (insn, IS_ME (#FORMULA, abfd)); \
1266 insn = (* get_replace_function (abfd, TYPE)) (insn, relocation); \
1267 insn = middle_endian_convert (insn, IS_ME (#FORMULA, abfd)); \
1268 PRINT_DEBUG_RELOC_INFO_AFTER; \
1272 static bfd_reloc_status_type
1273 arc_do_relocation (bfd_byte
* contents
,
1274 struct arc_relocation_data reloc_data
,
1275 struct bfd_link_info
*info
)
1277 bfd_signed_vma relocation
= 0;
1279 bfd_vma orig_insn ATTRIBUTE_UNUSED
;
1280 bfd
* abfd
= reloc_data
.input_section
->owner
;
1281 struct elf_link_hash_table
*htab ATTRIBUTE_UNUSED
= elf_hash_table (info
);
1282 bfd_reloc_status_type flag
;
1284 if (!reloc_data
.should_relocate
)
1285 return bfd_reloc_ok
;
1287 switch (reloc_data
.howto
->size
)
1290 insn
= arc_bfd_get_32 (abfd
,
1291 contents
+ reloc_data
.reloc_offset
,
1292 reloc_data
.input_section
);
1295 insn
= arc_bfd_get_16 (abfd
,
1296 contents
+ reloc_data
.reloc_offset
,
1297 reloc_data
.input_section
);
1300 insn
= arc_bfd_get_8 (abfd
,
1301 contents
+ reloc_data
.reloc_offset
,
1302 reloc_data
.input_section
);
1312 switch (reloc_data
.howto
->type
)
1314 #include "elf/arc-reloc.def"
1321 /* Check for relocation overflow. */
1322 if (reloc_data
.howto
->complain_on_overflow
!= complain_overflow_dont
)
1323 flag
= bfd_check_overflow (reloc_data
.howto
->complain_on_overflow
,
1324 reloc_data
.howto
->bitsize
,
1325 reloc_data
.howto
->rightshift
,
1326 bfd_arch_bits_per_address (abfd
),
1329 flag
= arc_special_overflow_checks (reloc_data
, relocation
, info
);
1331 if (flag
!= bfd_reloc_ok
)
1333 ARC_DEBUG ("Relocation overflows !\n");
1334 DEBUG_ARC_RELOC (reloc_data
);
1335 ARC_DEBUG ("Relocation value = signed -> %d, unsigned -> %u"
1336 ", hex -> (0x%08x)\n",
1337 (int) relocation
, (unsigned) relocation
, (int) relocation
);
1342 /* Write updated instruction back to memory. */
1343 switch (reloc_data
.howto
->size
)
1346 arc_bfd_put_32 (abfd
, insn
,
1347 contents
+ reloc_data
.reloc_offset
,
1348 reloc_data
.input_section
);
1351 arc_bfd_put_16 (abfd
, insn
,
1352 contents
+ reloc_data
.reloc_offset
,
1353 reloc_data
.input_section
);
1356 arc_bfd_put_8 (abfd
, insn
,
1357 contents
+ reloc_data
.reloc_offset
,
1358 reloc_data
.input_section
);
1361 ARC_DEBUG ("size = %d\n", reloc_data
.howto
->size
);
1366 return bfd_reloc_ok
;
1382 #undef ARC_RELOC_HOWTO
1385 /* Relocate an arc ELF section.
1386 Function : elf_arc_relocate_section
1387 Brief : Relocate an arc section, by handling all the relocations
1388 appearing in that section.
1389 Args : output_bfd : The bfd being written to.
1390 info : Link information.
1391 input_bfd : The input bfd.
1392 input_section : The section being relocated.
1393 contents : contents of the section being relocated.
1394 relocs : List of relocations in the section.
1395 local_syms : is a pointer to the swapped in local symbols.
1396 local_section : is an array giving the section in the input file
1397 corresponding to the st_shndx field of each
1400 elf_arc_relocate_section (bfd
* output_bfd
,
1401 struct bfd_link_info
* info
,
1403 asection
* input_section
,
1404 bfd_byte
* contents
,
1405 Elf_Internal_Rela
* relocs
,
1406 Elf_Internal_Sym
* local_syms
,
1407 asection
** local_sections
)
1409 Elf_Internal_Shdr
* symtab_hdr
;
1410 struct elf_link_hash_entry
** sym_hashes
;
1411 Elf_Internal_Rela
* rel
;
1412 Elf_Internal_Rela
* wrel
;
1413 Elf_Internal_Rela
* relend
;
1414 struct elf_link_hash_table
* htab
= elf_hash_table (info
);
1416 symtab_hdr
= &((elf_tdata (input_bfd
))->symtab_hdr
);
1417 sym_hashes
= elf_sym_hashes (input_bfd
);
1419 rel
= wrel
= relocs
;
1420 relend
= relocs
+ input_section
->reloc_count
;
1421 for (; rel
< relend
; wrel
++, rel
++)
1423 enum elf_arc_reloc_type r_type
;
1424 reloc_howto_type
* howto
;
1425 unsigned long r_symndx
;
1426 struct elf_link_hash_entry
* h
;
1427 Elf_Internal_Sym
* sym
;
1429 struct elf_link_hash_entry
* h2
;
1431 bfd_boolean unresolved_reloc
= FALSE
;
1433 struct arc_relocation_data reloc_data
=
1437 .got_offset_value
= 0,
1439 .sym_section
= NULL
,
1441 .input_section
= NULL
,
1442 .sdata_begin_symbol_vma
= 0,
1443 .sdata_begin_symbol_vma_set
= FALSE
,
1444 .got_symbol_vma
= 0,
1445 .should_relocate
= FALSE
1448 r_type
= ELF32_R_TYPE (rel
->r_info
);
1450 if (r_type
>= (int) R_ARC_max
)
1452 bfd_set_error (bfd_error_bad_value
);
1455 howto
= arc_elf_howto (r_type
);
1457 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1459 /* If we are generating another .o file and the symbol in not
1460 local, skip this relocation. */
1461 if (bfd_link_relocatable (info
))
1463 /* This is a relocateable link. We don't have to change
1464 anything, unless the reloc is against a section symbol,
1465 in which case we have to adjust according to where the
1466 section symbol winds up in the output section. */
1468 /* Checks if this is a local symbol and thus the reloc
1469 might (will??) be against a section symbol. */
1470 if (r_symndx
< symtab_hdr
->sh_info
)
1472 sym
= local_syms
+ r_symndx
;
1473 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1475 sec
= local_sections
[r_symndx
];
1477 /* For RELA relocs. Just adjust the addend
1478 value in the relocation entry. */
1479 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
1481 ARC_DEBUG ("local symbols reloc (section=%d %s) seen in %s\n",
1482 (int) r_symndx
, local_sections
[r_symndx
]->name
,
1483 __PRETTY_FUNCTION__
);
1488 h2
= elf_link_hash_lookup (elf_hash_table (info
), "__SDATA_BEGIN__",
1489 FALSE
, FALSE
, TRUE
);
1491 if (!reloc_data
.sdata_begin_symbol_vma_set
1492 && h2
!= NULL
&& h2
->root
.type
!= bfd_link_hash_undefined
1493 && h2
->root
.u
.def
.section
->output_section
!= NULL
)
1494 /* TODO: Verify this condition. */
1496 reloc_data
.sdata_begin_symbol_vma
=
1497 (h2
->root
.u
.def
.value
1498 + h2
->root
.u
.def
.section
->output_section
->vma
);
1499 reloc_data
.sdata_begin_symbol_vma_set
= TRUE
;
1502 reloc_data
.input_section
= input_section
;
1503 reloc_data
.howto
= howto
;
1504 reloc_data
.reloc_offset
= rel
->r_offset
;
1505 reloc_data
.reloc_addend
= rel
->r_addend
;
1507 /* This is a final link. */
1512 if (r_symndx
< symtab_hdr
->sh_info
) /* A local symbol. */
1514 sym
= local_syms
+ r_symndx
;
1515 sec
= local_sections
[r_symndx
];
1519 bfd_boolean warned
, ignored
;
1520 bfd_vma relocation ATTRIBUTE_UNUSED
;
1522 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
1523 r_symndx
, symtab_hdr
, sym_hashes
,
1525 unresolved_reloc
, warned
, ignored
);
1527 /* TODO: This code is repeated from below. We should
1528 clean it and remove duplications.
1529 Sec is used check for discarded sections.
1530 Need to redesign code below. */
1532 /* Get the symbol's entry in the symtab. */
1533 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1535 while (h
->root
.type
== bfd_link_hash_indirect
1536 || h
->root
.type
== bfd_link_hash_warning
)
1537 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1539 /* If we have encountered a definition for this symbol. */
1540 if (h
->root
.type
== bfd_link_hash_defined
1541 || h
->root
.type
== bfd_link_hash_defweak
)
1543 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1544 sec
= h
->root
.u
.def
.section
;
1548 /* Clean relocs for symbols in discarded sections. */
1549 if (sec
!= NULL
&& discarded_section (sec
))
1551 _bfd_clear_contents (howto
, input_bfd
, input_section
,
1552 contents
+ rel
->r_offset
);
1556 /* For ld -r, remove relocations in debug sections against
1557 sections defined in discarded sections. Not done for
1558 eh_frame editing code expects to be present. */
1559 if (bfd_link_relocatable (info
)
1560 && (input_section
->flags
& SEC_DEBUGGING
))
1566 if (bfd_link_relocatable (info
))
1573 if (r_symndx
< symtab_hdr
->sh_info
) /* A local symbol. */
1575 reloc_data
.sym_value
= sym
->st_value
;
1576 reloc_data
.sym_section
= sec
;
1577 reloc_data
.symbol_name
=
1578 bfd_elf_string_from_elf_section (input_bfd
,
1579 symtab_hdr
->sh_link
,
1582 /* Mergeable section handling. */
1583 if ((sec
->flags
& SEC_MERGE
)
1584 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1588 rel
->r_addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
,
1589 &msec
, rel
->r_addend
);
1590 rel
->r_addend
-= (sec
->output_section
->vma
1591 + sec
->output_offset
1593 rel
->r_addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
1595 reloc_data
.reloc_addend
= rel
->r_addend
;
1598 BFD_ASSERT (htab
->sgot
!= NULL
|| !is_reloc_for_GOT (howto
));
1599 if (htab
->sgot
!= NULL
)
1600 reloc_data
.got_symbol_vma
= htab
->sgot
->output_section
->vma
1601 + htab
->sgot
->output_offset
;
1603 reloc_data
.should_relocate
= TRUE
;
1605 else /* Global symbol. */
1607 /* FIXME: We should use the RELOC_FOR_GLOBAL_SYMBOL macro
1608 (defined in elf-bfd.h) here. */
1610 /* Get the symbol's entry in the symtab. */
1611 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1613 while (h
->root
.type
== bfd_link_hash_indirect
1614 || h
->root
.type
== bfd_link_hash_warning
)
1616 struct elf_arc_link_hash_entry
*ah_old
=
1617 (struct elf_arc_link_hash_entry
*) h
;
1618 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1619 struct elf_arc_link_hash_entry
*ah
=
1620 (struct elf_arc_link_hash_entry
*) h
;
1622 if (ah
->got_ents
== 0 && ah_old
->got_ents
!= ah
->got_ents
)
1623 ah
->got_ents
= ah_old
->got_ents
;
1626 /* TODO: Need to validate what was the intention. */
1627 /* BFD_ASSERT ((h->dynindx == -1) || (h->forced_local != 0)); */
1628 reloc_data
.symbol_name
= h
->root
.root
.string
;
1630 /* If we have encountered a definition for this symbol. */
1631 if (h
->root
.type
== bfd_link_hash_defined
1632 || h
->root
.type
== bfd_link_hash_defweak
)
1634 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1635 reloc_data
.sym_section
= h
->root
.u
.def
.section
;
1637 reloc_data
.should_relocate
= TRUE
;
1639 if (is_reloc_for_GOT (howto
) && !bfd_link_pic (info
))
1641 struct elf_arc_link_hash_entry
*ah
=
1642 (struct elf_arc_link_hash_entry
*) h
;
1643 /* TODO: Change it to use arc_do_relocation with
1644 ARC_32 reloc. Try to use ADD_RELA macro. */
1645 bfd_vma relocation
=
1646 reloc_data
.sym_value
+ reloc_data
.reloc_addend
1647 + (reloc_data
.sym_section
->output_section
!= NULL
?
1648 (reloc_data
.sym_section
->output_offset
1649 + reloc_data
.sym_section
->output_section
->vma
)
1652 BFD_ASSERT (ah
->got_ents
);
1653 bfd_vma got_offset
= ah
->got_ents
->offset
;
1654 bfd_put_32 (output_bfd
, relocation
,
1655 htab
->sgot
->contents
+ got_offset
);
1657 if (is_reloc_for_PLT (howto
) && h
->plt
.offset
!= (bfd_vma
) -1)
1659 /* TODO: This is repeated up here. */
1660 reloc_data
.sym_value
= h
->plt
.offset
;
1661 reloc_data
.sym_section
= htab
->splt
;
1664 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1666 /* Is weak symbol and has no definition. */
1667 if (is_reloc_for_GOT (howto
))
1669 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1670 reloc_data
.sym_section
= htab
->sgot
;
1671 reloc_data
.should_relocate
= TRUE
;
1673 else if (is_reloc_for_PLT (howto
)
1674 && h
->plt
.offset
!= (bfd_vma
) -1)
1676 /* TODO: This is repeated up here. */
1677 reloc_data
.sym_value
= h
->plt
.offset
;
1678 reloc_data
.sym_section
= htab
->splt
;
1679 reloc_data
.should_relocate
= TRUE
;
1686 if (is_reloc_for_GOT (howto
))
1688 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1689 reloc_data
.sym_section
= htab
->sgot
;
1691 reloc_data
.should_relocate
= TRUE
;
1693 else if (is_reloc_for_PLT (howto
))
1695 /* Fail if it is linking for PIE and the symbol is
1697 if (bfd_link_executable (info
))
1698 (*info
->callbacks
->undefined_symbol
)
1699 (info
, h
->root
.root
.string
, input_bfd
, input_section
,
1700 rel
->r_offset
, TRUE
);
1701 reloc_data
.sym_value
= h
->plt
.offset
;
1702 reloc_data
.sym_section
= htab
->splt
;
1704 reloc_data
.should_relocate
= TRUE
;
1706 else if (!bfd_link_pic (info
) || bfd_link_executable (info
))
1707 (*info
->callbacks
->undefined_symbol
)
1708 (info
, h
->root
.root
.string
, input_bfd
, input_section
,
1709 rel
->r_offset
, TRUE
);
1712 BFD_ASSERT (htab
->sgot
!= NULL
|| !is_reloc_for_GOT (howto
));
1713 if (htab
->sgot
!= NULL
)
1714 reloc_data
.got_symbol_vma
= htab
->sgot
->output_section
->vma
1715 + htab
->sgot
->output_offset
;
1718 if ((is_reloc_for_GOT (howto
)
1719 || is_reloc_for_TLS (howto
)))
1721 reloc_data
.should_relocate
= TRUE
;
1723 struct got_entry
**list
1724 = get_got_entry_list_for_symbol (output_bfd
, r_symndx
, h
);
1726 reloc_data
.got_offset_value
1727 = relocate_fix_got_relocs_for_got_info (list
,
1728 tls_type_for_reloc (howto
),
1739 create_got_dynrelocs_for_single_entry (
1740 got_entry_for_type (list
,
1741 arc_got_entry_type_for_reloc (howto
)),
1742 output_bfd
, info
, NULL
);
1747 #define IS_ARC_PCREL_TYPE(TYPE) \
1748 ( (TYPE == R_ARC_PC32) \
1749 || (TYPE == R_ARC_32_PCREL))
1756 case R_ARC_32_PCREL
:
1757 if (bfd_link_pic (info
)
1758 && (!IS_ARC_PCREL_TYPE (r_type
)
1762 && (!info
->symbolic
|| !h
->def_regular
))))
1764 Elf_Internal_Rela outrel
;
1766 bfd_boolean skip
= FALSE
;
1767 bfd_boolean relocate
= FALSE
;
1768 asection
*sreloc
= _bfd_elf_get_dynamic_reloc_section
1769 (input_bfd
, input_section
,
1772 BFD_ASSERT (sreloc
!= NULL
);
1774 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
1779 if (outrel
.r_offset
== (bfd_vma
) -1)
1782 outrel
.r_addend
= rel
->r_addend
;
1783 outrel
.r_offset
+= (input_section
->output_section
->vma
1784 + input_section
->output_offset
);
1788 memset (&outrel
, 0, sizeof outrel
);
1793 && (IS_ARC_PCREL_TYPE (r_type
)
1794 || !(bfd_link_executable (info
)
1795 || SYMBOLIC_BIND (info
, h
))
1796 || ! h
->def_regular
))
1798 BFD_ASSERT (h
!= NULL
);
1799 if ((input_section
->flags
& SEC_ALLOC
) != 0)
1804 BFD_ASSERT (h
->dynindx
!= -1);
1805 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
1809 /* Handle local symbols, they either do not have a
1810 global hash table entry (h == NULL), or are
1811 forced local due to a version script
1812 (h->forced_local), or the third condition is
1813 legacy, it appears to say something like, for
1814 links where we are pre-binding the symbols, or
1815 there's not an entry for this symbol in the
1816 dynamic symbol table, and it's a regular symbol
1817 not defined in a shared object, then treat the
1818 symbol as local, resolve it now. */
1820 /* outrel.r_addend = 0; */
1821 outrel
.r_info
= ELF32_R_INFO (0, R_ARC_RELATIVE
);
1824 BFD_ASSERT (sreloc
->contents
!= 0);
1826 loc
= sreloc
->contents
;
1827 loc
+= sreloc
->reloc_count
* sizeof (Elf32_External_Rela
);
1828 sreloc
->reloc_count
+= 1;
1830 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
1840 if (is_reloc_SDA_relative (howto
)
1841 && !reloc_data
.sdata_begin_symbol_vma_set
)
1844 ("error: linker symbol __SDATA_BEGIN__ not found");
1845 bfd_set_error (bfd_error_bad_value
);
1849 DEBUG_ARC_RELOC (reloc_data
);
1851 /* Make sure we have with a dynamic linker. In case of GOT and PLT
1852 the sym_section should point to .got or .plt respectively. */
1853 if ((is_reloc_for_GOT (howto
) || is_reloc_for_PLT (howto
))
1854 && reloc_data
.sym_section
== NULL
)
1857 (_("GOT and PLT relocations cannot be fixed with a non dynamic linker"));
1858 bfd_set_error (bfd_error_bad_value
);
1863 switch (arc_do_relocation (contents
, reloc_data
, info
))
1866 continue; /* The reloc processing loop. */
1868 case bfd_reloc_overflow
:
1869 (*info
->callbacks
->reloc_overflow
)
1870 (info
, (h
? &h
->root
: NULL
), reloc_data
.symbol_name
, howto
->name
, (bfd_vma
) 0,
1871 input_bfd
, input_section
, rel
->r_offset
);
1874 case bfd_reloc_undefined
:
1875 (*info
->callbacks
->undefined_symbol
)
1876 (info
, reloc_data
.symbol_name
, input_bfd
, input_section
, rel
->r_offset
, TRUE
);
1879 case bfd_reloc_other
:
1880 /* xgettext:c-format */
1881 msg
= _("%pB(%pA): warning: unaligned access to symbol '%s' in the small data area");
1884 case bfd_reloc_outofrange
:
1885 /* xgettext:c-format */
1886 msg
= _("%pB(%pA): internal error: out of range error");
1889 case bfd_reloc_notsupported
:
1890 /* xgettext:c-format */
1891 msg
= _("%pB(%pA): internal error: unsupported relocation error");
1894 case bfd_reloc_dangerous
:
1895 /* xgettext:c-format */
1896 msg
= _("%pB(%pA): internal error: dangerous relocation");
1900 /* xgettext:c-format */
1901 msg
= _("%pB(%pA): internal error: unknown error");
1906 _bfd_error_handler (msg
, input_bfd
, input_section
, reloc_data
.symbol_name
);
1913 #define elf_arc_hash_table(p) \
1914 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
1915 == ARC_ELF_DATA ? ((struct elf_arc_link_hash_table *) ((p)->hash)) : NULL)
1918 elf_arc_check_relocs (bfd
* abfd
,
1919 struct bfd_link_info
* info
,
1921 const Elf_Internal_Rela
* relocs
)
1923 Elf_Internal_Shdr
* symtab_hdr
;
1924 struct elf_link_hash_entry
** sym_hashes
;
1925 const Elf_Internal_Rela
* rel
;
1926 const Elf_Internal_Rela
* rel_end
;
1928 asection
* sreloc
= NULL
;
1929 struct elf_link_hash_table
* htab
= elf_hash_table (info
);
1931 if (bfd_link_relocatable (info
))
1934 if (htab
->dynobj
== NULL
)
1935 htab
->dynobj
= abfd
;
1937 dynobj
= (elf_hash_table (info
))->dynobj
;
1938 symtab_hdr
= &((elf_tdata (abfd
))->symtab_hdr
);
1939 sym_hashes
= elf_sym_hashes (abfd
);
1941 rel_end
= relocs
+ sec
->reloc_count
;
1942 for (rel
= relocs
; rel
< rel_end
; rel
++)
1944 enum elf_arc_reloc_type r_type
;
1945 reloc_howto_type
*howto
;
1946 unsigned long r_symndx
;
1947 struct elf_link_hash_entry
*h
;
1949 r_type
= ELF32_R_TYPE (rel
->r_info
);
1951 if (r_type
>= (int) R_ARC_max
)
1953 bfd_set_error (bfd_error_bad_value
);
1956 howto
= arc_elf_howto (r_type
);
1958 /* Load symbol information. */
1959 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1960 if (r_symndx
< symtab_hdr
->sh_info
) /* Is a local symbol. */
1962 else /* Global one. */
1963 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1970 /* During shared library creation, these relocs should not
1971 appear in a shared library (as memory will be read only
1972 and the dynamic linker can not resolve these. However
1973 the error should not occur for e.g. debugging or
1974 non-readonly sections. */
1976 && (bfd_link_dll (info
) && !bfd_link_pie (info
))
1977 && (sec
->flags
& SEC_ALLOC
) != 0
1978 && (sec
->flags
& SEC_READONLY
) != 0
1979 && ((sec
->flags
& SEC_CODE
) != 0
1980 || (sec
->flags
& SEC_DEBUGGING
) != 0))
1984 name
= h
->root
.root
.string
;
1986 /* bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL); */
1989 /* xgettext:c-format */
1990 (_("%pB: relocation %s against `%s' can not be used"
1991 " when making a shared object; recompile with -fPIC"),
1993 arc_elf_howto (r_type
)->name
,
1995 bfd_set_error (bfd_error_bad_value
);
1999 /* In some cases we are not setting the 'non_got_ref'
2000 flag, even though the relocations don't require a GOT
2001 access. We should extend the testing in this area to
2002 ensure that no significant cases are being missed. */
2007 case R_ARC_32_PCREL
:
2008 if ((bfd_link_pic (info
))
2009 && ((r_type
!= R_ARC_PC32
&& r_type
!= R_ARC_32_PCREL
)
2011 && (!info
->symbolic
|| !h
->def_regular
))))
2016 && ! htab
->dynamic_sections_created
2017 && ! _bfd_elf_link_create_dynamic_sections (abfd
, info
))
2019 sreloc
= _bfd_elf_make_dynamic_reloc_section (sec
, dynobj
,
2027 sreloc
->size
+= sizeof (Elf32_External_Rela
);
2034 if (is_reloc_for_PLT (howto
))
2042 /* Add info to the symbol got_entry_list. */
2043 if (is_reloc_for_GOT (howto
)
2044 || is_reloc_for_TLS (howto
))
2046 if (! _bfd_elf_create_got_section (dynobj
, info
))
2049 arc_fill_got_info_for_reloc (
2050 arc_got_entry_type_for_reloc (howto
),
2051 get_got_entry_list_for_symbol (abfd
, r_symndx
, h
),
2060 #define ELF_DYNAMIC_INTERPRETER "/sbin/ld-uClibc.so"
2062 static struct plt_version_t
*
2063 arc_get_plt_version (struct bfd_link_info
*info
)
2067 for (i
= 0; i
< 1; i
++)
2069 ARC_DEBUG ("%d: size1 = %d, size2 = %d\n", i
,
2070 (int) plt_versions
[i
].entry_size
,
2071 (int) plt_versions
[i
].elem_size
);
2074 if (bfd_get_mach (info
->output_bfd
) == bfd_mach_arc_arcv2
)
2076 if (bfd_link_pic (info
))
2077 return &(plt_versions
[ELF_ARCV2_PIC
]);
2079 return &(plt_versions
[ELF_ARCV2_ABS
]);
2083 if (bfd_link_pic (info
))
2084 return &(plt_versions
[ELF_ARC_PIC
]);
2086 return &(plt_versions
[ELF_ARC_ABS
]);
2091 add_symbol_to_plt (struct bfd_link_info
*info
)
2093 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2096 struct plt_version_t
*plt_data
= arc_get_plt_version (info
);
2098 /* If this is the first .plt entry, make room for the special first
2100 if (htab
->splt
->size
== 0)
2101 htab
->splt
->size
+= plt_data
->entry_size
;
2103 ret
= htab
->splt
->size
;
2105 htab
->splt
->size
+= plt_data
->elem_size
;
2106 ARC_DEBUG ("PLT_SIZE = %d\n", (int) htab
->splt
->size
);
2108 htab
->sgotplt
->size
+= 4;
2109 htab
->srelplt
->size
+= sizeof (Elf32_External_Rela
);
2114 #define PLT_DO_RELOCS_FOR_ENTRY(ABFD, DS, RELOCS) \
2115 plt_do_relocs_for_symbol (ABFD, DS, RELOCS, 0, 0)
2118 plt_do_relocs_for_symbol (bfd
*abfd
,
2119 struct elf_link_hash_table
*htab
,
2120 const struct plt_reloc
*reloc
,
2122 bfd_vma symbol_got_offset
)
2124 while (SYM_ONLY (reloc
->symbol
) != LAST_RELOC
)
2126 bfd_vma relocation
= 0;
2128 switch (SYM_ONLY (reloc
->symbol
))
2132 = htab
->sgotplt
->output_section
->vma
2133 + htab
->sgotplt
->output_offset
+ symbol_got_offset
;
2136 relocation
+= reloc
->addend
;
2138 if (IS_RELATIVE (reloc
->symbol
))
2140 bfd_vma reloc_offset
= reloc
->offset
;
2141 reloc_offset
-= (IS_INSN_32 (reloc
->symbol
)) ? 4 : 0;
2142 reloc_offset
-= (IS_INSN_24 (reloc
->symbol
)) ? 2 : 0;
2144 relocation
-= htab
->splt
->output_section
->vma
2145 + htab
->splt
->output_offset
2146 + plt_offset
+ reloc_offset
;
2149 /* TODO: being ME is not a property of the relocation but of the
2150 section of which is applying the relocation. */
2151 if (IS_MIDDLE_ENDIAN (reloc
->symbol
) && !bfd_big_endian (abfd
))
2154 = ((relocation
& 0xffff0000) >> 16)
2155 | ((relocation
& 0xffff) << 16);
2158 switch (reloc
->size
)
2161 bfd_put_32 (htab
->splt
->output_section
->owner
,
2163 htab
->splt
->contents
+ plt_offset
+ reloc
->offset
);
2167 reloc
= &(reloc
[1]); /* Jump to next relocation. */
2172 relocate_plt_for_symbol (bfd
*output_bfd
,
2173 struct bfd_link_info
*info
,
2174 struct elf_link_hash_entry
*h
)
2176 struct plt_version_t
*plt_data
= arc_get_plt_version (info
);
2177 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2179 bfd_vma plt_index
= (h
->plt
.offset
- plt_data
->entry_size
)
2180 / plt_data
->elem_size
;
2181 bfd_vma got_offset
= (plt_index
+ 3) * 4;
2183 ARC_DEBUG ("arc_info: PLT_OFFSET = %#lx, PLT_ENTRY_VMA = %#lx, \
2184 GOT_ENTRY_OFFSET = %#lx, GOT_ENTRY_VMA = %#lx, for symbol %s\n",
2185 (long) h
->plt
.offset
,
2186 (long) (htab
->splt
->output_section
->vma
2187 + htab
->splt
->output_offset
2190 (long) (htab
->sgotplt
->output_section
->vma
2191 + htab
->sgotplt
->output_offset
2193 h
->root
.root
.string
);
2197 uint16_t *ptr
= (uint16_t *) plt_data
->elem
;
2199 for (i
= 0; i
< plt_data
->elem_size
/2; i
++)
2201 uint16_t data
= ptr
[i
];
2202 bfd_put_16 (output_bfd
,
2204 htab
->splt
->contents
+ h
->plt
.offset
+ (i
*2));
2208 plt_do_relocs_for_symbol (output_bfd
, htab
,
2209 plt_data
->elem_relocs
,
2213 /* Fill in the entry in the global offset table. */
2214 bfd_put_32 (output_bfd
,
2215 (bfd_vma
) (htab
->splt
->output_section
->vma
2216 + htab
->splt
->output_offset
),
2217 htab
->sgotplt
->contents
+ got_offset
);
2219 /* TODO: Fill in the entry in the .rela.plt section. */
2221 Elf_Internal_Rela rel
;
2224 rel
.r_offset
= (htab
->sgotplt
->output_section
->vma
2225 + htab
->sgotplt
->output_offset
2229 BFD_ASSERT (h
->dynindx
!= -1);
2230 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARC_JMP_SLOT
);
2232 loc
= htab
->srelplt
->contents
;
2233 loc
+= plt_index
* sizeof (Elf32_External_Rela
); /* relA */
2234 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
2239 relocate_plt_for_entry (bfd
*abfd
,
2240 struct bfd_link_info
*info
)
2242 struct plt_version_t
*plt_data
= arc_get_plt_version (info
);
2243 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2247 uint16_t *ptr
= (uint16_t *) plt_data
->entry
;
2248 for (i
= 0; i
< plt_data
->entry_size
/2; i
++)
2250 uint16_t data
= ptr
[i
];
2253 htab
->splt
->contents
+ (i
*2));
2256 PLT_DO_RELOCS_FOR_ENTRY (abfd
, htab
, plt_data
->entry_relocs
);
2259 /* Desc : Adjust a symbol defined by a dynamic object and referenced
2260 by a regular object. The current definition is in some section of
2261 the dynamic object, but we're not including those sections. We
2262 have to change the definition to something the rest of the link can
2266 elf_arc_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2267 struct elf_link_hash_entry
*h
)
2270 bfd
*dynobj
= (elf_hash_table (info
))->dynobj
;
2271 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2273 if (h
->type
== STT_FUNC
2274 || h
->type
== STT_GNU_IFUNC
2275 || h
->needs_plt
== 1)
2277 if (!bfd_link_pic (info
) && !h
->def_dynamic
&& !h
->ref_dynamic
)
2279 /* This case can occur if we saw a PLT32 reloc in an input
2280 file, but the symbol was never referred to by a dynamic
2281 object. In such a case, we don't actually need to build
2282 a procedure linkage table, and we can just do a PC32
2284 BFD_ASSERT (h
->needs_plt
);
2288 /* Make sure this symbol is output as a dynamic symbol. */
2289 if (h
->dynindx
== -1 && !h
->forced_local
2290 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
2293 if (bfd_link_pic (info
)
2294 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2296 bfd_vma loc
= add_symbol_to_plt (info
);
2298 if (bfd_link_executable (info
) && !h
->def_regular
)
2300 h
->root
.u
.def
.section
= htab
->splt
;
2301 h
->root
.u
.def
.value
= loc
;
2303 h
->plt
.offset
= loc
;
2307 h
->plt
.offset
= (bfd_vma
) -1;
2313 /* If this is a weak symbol, and there is a real definition, the
2314 processor independent code will have arranged for us to see the
2315 real definition first, and we can just use the same value. */
2316 if (h
->is_weakalias
)
2318 struct elf_link_hash_entry
*def
= weakdef (h
);
2319 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
2320 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
2321 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
2325 /* This is a reference to a symbol defined by a dynamic object which
2326 is not a function. */
2328 /* If we are creating a shared library, we must presume that the
2329 only references to the symbol are via the global offset table.
2330 For such cases we need not do anything here; the relocations will
2331 be handled correctly by relocate_section. */
2332 if (!bfd_link_executable (info
))
2335 /* If there are no non-GOT references, we do not need a copy
2337 if (!h
->non_got_ref
)
2340 /* If -z nocopyreloc was given, we won't generate them either. */
2341 if (info
->nocopyreloc
)
2347 /* We must allocate the symbol in our .dynbss section, which will
2348 become part of the .bss section of the executable. There will be
2349 an entry for this symbol in the .dynsym section. The dynamic
2350 object will contain position independent code, so all references
2351 from the dynamic object to this symbol will go through the global
2352 offset table. The dynamic linker will use the .dynsym entry to
2353 determine the address it must put in the global offset table, so
2354 both the dynamic object and the regular object will refer to the
2355 same memory location for the variable. */
2360 /* We must generate a R_ARC_COPY reloc to tell the dynamic linker to
2361 copy the initial value out of the dynamic object and into the
2362 runtime process image. We need to remember the offset into the
2363 .rela.bss section we are going to use. */
2364 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
2366 struct elf_arc_link_hash_table
*arc_htab
= elf_arc_hash_table (info
);
2368 BFD_ASSERT (arc_htab
->elf
.srelbss
!= NULL
);
2369 arc_htab
->elf
.srelbss
->size
+= sizeof (Elf32_External_Rela
);
2373 /* TODO: Move this also to arc_hash_table. */
2374 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
2375 BFD_ASSERT (s
!= NULL
);
2377 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2380 /* Function : elf_arc_finish_dynamic_symbol
2381 Brief : Finish up dynamic symbol handling. We set the
2382 contents of various dynamic sections here.
2387 Returns : True/False as the return status. */
2390 elf_arc_finish_dynamic_symbol (bfd
* output_bfd
,
2391 struct bfd_link_info
*info
,
2392 struct elf_link_hash_entry
*h
,
2393 Elf_Internal_Sym
* sym
)
2395 if (h
->plt
.offset
!= (bfd_vma
) -1)
2397 relocate_plt_for_symbol (output_bfd
, info
, h
);
2399 if (!h
->def_regular
)
2401 /* Mark the symbol as undefined, rather than as defined in
2402 the .plt section. Leave the value alone. */
2403 sym
->st_shndx
= SHN_UNDEF
;
2408 /* This function traverses list of GOT entries and
2409 create respective dynamic relocs. */
2410 /* TODO: Make function to get list and not access the list directly. */
2411 /* TODO: Move function to relocate_section create this relocs eagerly. */
2412 struct elf_arc_link_hash_entry
*ah
=
2413 (struct elf_arc_link_hash_entry
*) h
;
2414 create_got_dynrelocs_for_got_info (&ah
->got_ents
,
2421 struct elf_arc_link_hash_table
*arc_htab
= elf_arc_hash_table (info
);
2423 if (arc_htab
== NULL
)
2426 if (h
->dynindx
== -1
2427 || (h
->root
.type
!= bfd_link_hash_defined
2428 && h
->root
.type
!= bfd_link_hash_defweak
)
2429 || arc_htab
->elf
.srelbss
== NULL
)
2432 bfd_vma rel_offset
= (h
->root
.u
.def
.value
2433 + h
->root
.u
.def
.section
->output_section
->vma
2434 + h
->root
.u
.def
.section
->output_offset
);
2436 bfd_byte
* loc
= arc_htab
->elf
.srelbss
->contents
2437 + (arc_htab
->elf
.srelbss
->reloc_count
* sizeof (Elf32_External_Rela
));
2438 arc_htab
->elf
.srelbss
->reloc_count
++;
2440 Elf_Internal_Rela rel
;
2442 rel
.r_offset
= rel_offset
;
2444 BFD_ASSERT (h
->dynindx
!= -1);
2445 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARC_COPY
);
2447 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
2450 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2451 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2452 || strcmp (h
->root
.root
.string
, "__DYNAMIC") == 0
2453 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
2454 sym
->st_shndx
= SHN_ABS
;
2459 #define GET_SYMBOL_OR_SECTION(TAG, SYMBOL, SECTION) \
2461 if (SYMBOL != NULL) \
2462 h = elf_link_hash_lookup (elf_hash_table (info), \
2463 SYMBOL, FALSE, FALSE, TRUE); \
2464 else if (SECTION != NULL) \
2465 s = bfd_get_linker_section (dynobj, SECTION); \
2468 /* Function : elf_arc_finish_dynamic_sections
2469 Brief : Finish up the dynamic sections handling.
2474 Returns : True/False as the return status. */
2477 elf_arc_finish_dynamic_sections (bfd
* output_bfd
,
2478 struct bfd_link_info
*info
)
2480 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2481 bfd
*dynobj
= (elf_hash_table (info
))->dynobj
;
2482 asection
*sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
2486 Elf32_External_Dyn
*dyncon
, *dynconend
;
2488 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
2490 = (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
2491 for (; dyncon
< dynconend
; dyncon
++)
2493 Elf_Internal_Dyn internal_dyn
;
2494 bfd_boolean do_it
= FALSE
;
2496 struct elf_link_hash_entry
*h
= NULL
;
2499 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &internal_dyn
);
2501 switch (internal_dyn
.d_tag
)
2503 GET_SYMBOL_OR_SECTION (DT_INIT
, info
->init_function
, NULL
)
2504 GET_SYMBOL_OR_SECTION (DT_FINI
, info
->fini_function
, NULL
)
2505 GET_SYMBOL_OR_SECTION (DT_PLTGOT
, NULL
, ".plt")
2506 GET_SYMBOL_OR_SECTION (DT_JMPREL
, NULL
, ".rela.plt")
2507 GET_SYMBOL_OR_SECTION (DT_PLTRELSZ
, NULL
, ".rela.plt")
2508 GET_SYMBOL_OR_SECTION (DT_VERSYM
, NULL
, ".gnu.version")
2509 GET_SYMBOL_OR_SECTION (DT_VERDEF
, NULL
, ".gnu.version_d")
2510 GET_SYMBOL_OR_SECTION (DT_VERNEED
, NULL
, ".gnu.version_r")
2515 /* In case the dynamic symbols should be updated with a symbol. */
2517 && (h
->root
.type
== bfd_link_hash_defined
2518 || h
->root
.type
== bfd_link_hash_defweak
))
2522 internal_dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
2523 asec_ptr
= h
->root
.u
.def
.section
;
2524 if (asec_ptr
->output_section
!= NULL
)
2526 internal_dyn
.d_un
.d_val
+=
2527 (asec_ptr
->output_section
->vma
2528 + asec_ptr
->output_offset
);
2532 /* The symbol is imported from another shared
2533 library and does not apply to this one. */
2534 internal_dyn
.d_un
.d_val
= 0;
2538 else if (s
!= NULL
) /* With a section information. */
2540 switch (internal_dyn
.d_tag
)
2547 internal_dyn
.d_un
.d_ptr
= (s
->output_section
->vma
2548 + s
->output_offset
);
2553 internal_dyn
.d_un
.d_val
= s
->size
;
2563 bfd_elf32_swap_dyn_out (output_bfd
, &internal_dyn
, dyncon
);
2566 if (htab
->splt
->size
> 0)
2568 relocate_plt_for_entry (output_bfd
, info
);
2571 /* TODO: Validate this. */
2572 if (htab
->srelplt
->output_section
!= bfd_abs_section_ptr
)
2573 elf_section_data (htab
->srelplt
->output_section
)
2574 ->this_hdr
.sh_entsize
= 12;
2577 /* Fill in the first three entries in the global offset table. */
2580 struct elf_link_hash_entry
*h
;
2581 h
= elf_link_hash_lookup (elf_hash_table (info
), "_GLOBAL_OFFSET_TABLE_",
2582 FALSE
, FALSE
, TRUE
);
2584 if (h
!= NULL
&& h
->root
.type
!= bfd_link_hash_undefined
2585 && h
->root
.u
.def
.section
!= NULL
)
2587 asection
*sec
= h
->root
.u
.def
.section
;
2590 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
2593 bfd_put_32 (output_bfd
,
2594 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
2596 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sec
->contents
+ 4);
2597 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sec
->contents
+ 8);
2604 #define ADD_DYNAMIC_SYMBOL(NAME, TAG) \
2605 h = elf_link_hash_lookup (elf_hash_table (info), \
2606 NAME, FALSE, FALSE, FALSE); \
2607 if ((h != NULL && (h->ref_regular || h->def_regular))) \
2608 if (! _bfd_elf_add_dynamic_entry (info, TAG, 0)) \
2611 /* Set the sizes of the dynamic sections. */
2613 elf_arc_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
2614 struct bfd_link_info
*info
)
2618 bfd_boolean relocs_exist
= FALSE
;
2619 bfd_boolean reltext_exist
= FALSE
;
2620 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2622 dynobj
= htab
->dynobj
;
2623 BFD_ASSERT (dynobj
!= NULL
);
2625 if (htab
->dynamic_sections_created
)
2627 struct elf_link_hash_entry
*h
;
2629 /* Set the contents of the .interp section to the
2631 if (bfd_link_executable (info
) && !info
->nointerp
)
2633 s
= bfd_get_section_by_name (dynobj
, ".interp");
2634 BFD_ASSERT (s
!= NULL
);
2635 s
->size
= sizeof (ELF_DYNAMIC_INTERPRETER
);
2636 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2639 /* Add some entries to the .dynamic section. We fill in some of
2640 the values later, in elf_bfd_final_link, but we must add the
2641 entries now so that we know the final size of the .dynamic
2642 section. Checking if the .init section is present. We also
2643 create DT_INIT and DT_FINI entries if the init_str has been
2644 changed by the user. */
2645 ADD_DYNAMIC_SYMBOL (info
->init_function
, DT_INIT
);
2646 ADD_DYNAMIC_SYMBOL (info
->fini_function
, DT_FINI
);
2650 /* We may have created entries in the .rela.got section.
2651 However, if we are not creating the dynamic sections, we will
2652 not actually use these entries. Reset the size of .rela.got,
2653 which will cause it to get stripped from the output file
2655 if (htab
->srelgot
!= NULL
)
2656 htab
->srelgot
->size
= 0;
2659 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2661 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2666 || s
== htab
->sgotplt
2667 || s
== htab
->sdynbss
)
2669 /* Strip this section if we don't need it. */
2671 else if (strncmp (s
->name
, ".rela", 5) == 0)
2673 if (s
->size
!= 0 && s
!= htab
->srelplt
)
2677 const char *name
= s
->name
+ 5;
2679 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
2680 if (bfd_get_flavour (ibfd
) == bfd_target_elf_flavour
2681 && ibfd
->flags
& DYNAMIC
)
2683 asection
*target
= bfd_get_section_by_name (ibfd
, name
);
2685 && elf_section_data (target
)->sreloc
== s
2686 && ((target
->output_section
->flags
2687 & (SEC_READONLY
| SEC_ALLOC
))
2688 == (SEC_READONLY
| SEC_ALLOC
)))
2690 reltext_exist
= TRUE
;
2695 relocs_exist
= TRUE
;
2698 /* We use the reloc_count field as a counter if we need to
2699 copy relocs into the output file. */
2704 /* It's not one of our sections, so don't allocate space. */
2710 s
->flags
|= SEC_EXCLUDE
;
2714 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
2717 /* Allocate memory for the section contents. */
2718 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
2719 if (s
->contents
== NULL
)
2723 if (htab
->dynamic_sections_created
)
2725 /* TODO: Check if this is needed. */
2726 if (!bfd_link_pic (info
))
2727 if (!_bfd_elf_add_dynamic_entry (info
, DT_DEBUG
, 0))
2730 if (htab
->splt
&& (htab
->splt
->flags
& SEC_EXCLUDE
) == 0)
2731 if (!_bfd_elf_add_dynamic_entry (info
, DT_PLTGOT
, 0)
2732 || !_bfd_elf_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
2733 || !_bfd_elf_add_dynamic_entry (info
, DT_PLTREL
, DT_RELA
)
2734 || !_bfd_elf_add_dynamic_entry (info
, DT_JMPREL
, 0))
2738 if (!_bfd_elf_add_dynamic_entry (info
, DT_RELA
, 0)
2739 || !_bfd_elf_add_dynamic_entry (info
, DT_RELASZ
, 0)
2740 || !_bfd_elf_add_dynamic_entry (info
, DT_RELAENT
,
2741 sizeof (Elf32_External_Rela
)))
2745 if (!_bfd_elf_add_dynamic_entry (info
, DT_TEXTREL
, 0))
2753 /* Classify dynamic relocs such that -z combreloc can reorder and combine
2755 static enum elf_reloc_type_class
2756 elf32_arc_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2757 const asection
*rel_sec ATTRIBUTE_UNUSED
,
2758 const Elf_Internal_Rela
*rela
)
2760 switch ((int) ELF32_R_TYPE (rela
->r_info
))
2762 case R_ARC_RELATIVE
:
2763 return reloc_class_relative
;
2764 case R_ARC_JMP_SLOT
:
2765 return reloc_class_plt
;
2767 return reloc_class_copy
;
2768 /* TODO: Needed in future to support ifunc. */
2770 case R_ARC_IRELATIVE:
2771 return reloc_class_ifunc;
2774 return reloc_class_normal
;
2778 const struct elf_size_info arc_elf32_size_info
=
2780 sizeof (Elf32_External_Ehdr
),
2781 sizeof (Elf32_External_Phdr
),
2782 sizeof (Elf32_External_Shdr
),
2783 sizeof (Elf32_External_Rel
),
2784 sizeof (Elf32_External_Rela
),
2785 sizeof (Elf32_External_Sym
),
2786 sizeof (Elf32_External_Dyn
),
2787 sizeof (Elf_External_Note
),
2791 ELFCLASS32
, EV_CURRENT
,
2792 bfd_elf32_write_out_phdrs
,
2793 bfd_elf32_write_shdrs_and_ehdr
,
2794 bfd_elf32_checksum_contents
,
2795 bfd_elf32_write_relocs
,
2796 bfd_elf32_swap_symbol_in
,
2797 bfd_elf32_swap_symbol_out
,
2798 bfd_elf32_slurp_reloc_table
,
2799 bfd_elf32_slurp_symbol_table
,
2800 bfd_elf32_swap_dyn_in
,
2801 bfd_elf32_swap_dyn_out
,
2802 bfd_elf32_swap_reloc_in
,
2803 bfd_elf32_swap_reloc_out
,
2804 bfd_elf32_swap_reloca_in
,
2805 bfd_elf32_swap_reloca_out
2808 #define elf_backend_size_info arc_elf32_size_info
2810 /* GDB expects general purpose registers to be in section .reg. However Linux
2811 kernel doesn't create this section and instead writes registers to NOTE
2812 section. It is up to the binutils to create a pseudo-section .reg from the
2813 contents of NOTE. Also BFD will read pid and signal number from NOTE. This
2814 function relies on offsets inside elf_prstatus structure in Linux to be
2818 elf32_arc_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
2823 switch (note
->descsz
)
2828 case 236: /* sizeof (struct elf_prstatus) on Linux/arc. */
2830 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
2832 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
2835 size
= (40 * 4); /* There are 40 registers in user_regs_struct. */
2838 /* Make a ".reg/999" section. */
2839 return _bfd_elfcore_make_pseudosection (abfd
, ".reg", size
,
2840 note
->descpos
+ offset
);
2843 /* Determine whether an object attribute tag takes an integer, a
2847 elf32_arc_obj_attrs_arg_type (int tag
)
2849 if (tag
== Tag_ARC_CPU_name
2850 || tag
== Tag_ARC_ISA_config
2851 || tag
== Tag_ARC_ISA_apex
)
2852 return ATTR_TYPE_FLAG_STR_VAL
;
2853 else if (tag
< (Tag_ARC_ISA_mpy_option
+ 1))
2854 return ATTR_TYPE_FLAG_INT_VAL
;
2856 return (tag
& 1) != 0 ? ATTR_TYPE_FLAG_STR_VAL
: ATTR_TYPE_FLAG_INT_VAL
;
2859 /* Attribute numbers >=14 can be safely ignored. */
2862 elf32_arc_obj_attrs_handle_unknown (bfd
*abfd
, int tag
)
2864 if ((tag
& 127) < (Tag_ARC_ISA_mpy_option
+ 1))
2867 (_("%pB: unknown mandatory ARC object attribute %d"),
2869 bfd_set_error (bfd_error_bad_value
);
2875 (_("warning: %pB: unknown ARC object attribute %d"),
2881 /* Handle an ARC specific section when reading an object file. This is
2882 called when bfd_section_from_shdr finds a section with an unknown
2886 elf32_arc_section_from_shdr (bfd
*abfd
,
2887 Elf_Internal_Shdr
* hdr
,
2891 switch (hdr
->sh_type
)
2893 case SHT_ARC_ATTRIBUTES
:
2900 if (!_bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2906 #define TARGET_LITTLE_SYM arc_elf32_le_vec
2907 #define TARGET_LITTLE_NAME "elf32-littlearc"
2908 #define TARGET_BIG_SYM arc_elf32_be_vec
2909 #define TARGET_BIG_NAME "elf32-bigarc"
2910 #define ELF_ARCH bfd_arch_arc
2911 #define ELF_TARGET_ID ARC_ELF_DATA
2912 #define ELF_MACHINE_CODE EM_ARC_COMPACT
2913 #define ELF_MACHINE_ALT1 EM_ARC_COMPACT2
2914 #define ELF_MAXPAGESIZE 0x2000
2916 #define bfd_elf32_bfd_link_hash_table_create arc_elf_link_hash_table_create
2918 #define bfd_elf32_bfd_merge_private_bfd_data arc_elf_merge_private_bfd_data
2919 #define bfd_elf32_bfd_reloc_type_lookup arc_elf32_bfd_reloc_type_lookup
2920 #define bfd_elf32_bfd_set_private_flags arc_elf_set_private_flags
2921 #define bfd_elf32_bfd_print_private_bfd_data arc_elf_print_private_bfd_data
2922 #define bfd_elf32_bfd_copy_private_bfd_data arc_elf_copy_private_bfd_data
2924 #define elf_info_to_howto_rel arc_info_to_howto_rel
2925 #define elf_backend_object_p arc_elf_object_p
2926 #define elf_backend_final_write_processing arc_elf_final_write_processing
2928 #define elf_backend_relocate_section elf_arc_relocate_section
2929 #define elf_backend_check_relocs elf_arc_check_relocs
2930 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
2932 #define elf_backend_reloc_type_class elf32_arc_reloc_type_class
2934 #define elf_backend_adjust_dynamic_symbol elf_arc_adjust_dynamic_symbol
2935 #define elf_backend_finish_dynamic_symbol elf_arc_finish_dynamic_symbol
2937 #define elf_backend_finish_dynamic_sections elf_arc_finish_dynamic_sections
2938 #define elf_backend_size_dynamic_sections elf_arc_size_dynamic_sections
2940 #define elf_backend_can_gc_sections 1
2941 #define elf_backend_want_got_plt 1
2942 #define elf_backend_plt_readonly 1
2943 #define elf_backend_rela_plts_and_copies_p 1
2944 #define elf_backend_want_plt_sym 0
2945 #define elf_backend_got_header_size 12
2946 #define elf_backend_dtrel_excludes_plt 1
2948 #define elf_backend_may_use_rel_p 0
2949 #define elf_backend_may_use_rela_p 1
2950 #define elf_backend_default_use_rela_p 1
2952 #define elf_backend_grok_prstatus elf32_arc_grok_prstatus
2954 #define elf_backend_default_execstack 0
2956 #undef elf_backend_obj_attrs_vendor
2957 #define elf_backend_obj_attrs_vendor "ARC"
2958 #undef elf_backend_obj_attrs_section
2959 #define elf_backend_obj_attrs_section ".ARC.attributes"
2960 #undef elf_backend_obj_attrs_arg_type
2961 #define elf_backend_obj_attrs_arg_type elf32_arc_obj_attrs_arg_type
2962 #undef elf_backend_obj_attrs_section_type
2963 #define elf_backend_obj_attrs_section_type SHT_ARC_ATTRIBUTES
2964 #define elf_backend_obj_attrs_handle_unknown elf32_arc_obj_attrs_handle_unknown
2966 #define elf_backend_section_from_shdr elf32_arc_section_from_shdr
2968 #include "elf32-target.h"