1 /* ARC-specific support for 32-bit ELF
2 Copyright (C) 1994-2018 Free Software Foundation, Inc.
3 Contributed by Cupertino Miranda (cmiranda@synopsys.com).
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
27 #include "libiberty.h"
28 #include "opcode/arc-func.h"
29 #include "opcode/arc.h"
32 #define FEATURE_LIST_NAME bfd_feature_list
33 #define CONFLICT_LIST bfd_conflict_list
34 #include "opcode/arc-attrs.h"
36 /* #define ARC_ENABLE_DEBUG 1 */
37 #ifdef ARC_ENABLE_DEBUG
39 name_for_global_symbol (struct elf_link_hash_entry
*h
)
41 static char *local_str
= "(local)";
44 return h
->root
.root
.string
;
46 #define ARC_DEBUG(fmt, args...) fprintf (stderr, fmt, ##args)
48 #define ARC_DEBUG(...)
52 #define ADD_RELA(BFD, SECTION, OFFSET, SYM_IDX, TYPE, ADDEND) \
54 struct elf_link_hash_table *_htab = elf_hash_table (info); \
55 Elf_Internal_Rela _rel; \
58 if (_htab->dynamic_sections_created == TRUE) \
60 BFD_ASSERT (_htab->srel##SECTION &&_htab->srel##SECTION->contents); \
61 _loc = _htab->srel##SECTION->contents \
62 + ((_htab->srel##SECTION->reloc_count) \
63 * sizeof (Elf32_External_Rela)); \
64 _htab->srel##SECTION->reloc_count++; \
65 _rel.r_addend = ADDEND; \
66 _rel.r_offset = (_htab->s##SECTION)->output_section->vma \
67 + (_htab->s##SECTION)->output_offset + OFFSET; \
68 BFD_ASSERT ((long) SYM_IDX != -1); \
69 _rel.r_info = ELF32_R_INFO (SYM_IDX, TYPE); \
70 bfd_elf32_swap_reloca_out (BFD, &_rel, _loc); \
75 /* The default symbols representing the init and fini dyn values.
76 TODO: Check what is the relation of those strings with arclinux.em
78 #define INIT_SYM_STRING "_init"
79 #define FINI_SYM_STRING "_fini"
81 char * init_str
= INIT_SYM_STRING
;
82 char * fini_str
= FINI_SYM_STRING
;
84 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
89 static ATTRIBUTE_UNUSED
const char *
90 reloc_type_to_name (unsigned int type
)
94 #include "elf/arc-reloc.def"
102 #undef ARC_RELOC_HOWTO
104 /* Try to minimize the amount of space occupied by relocation tables
105 on the ROM (not that the ROM won't be swamped by other ELF overhead). */
109 static ATTRIBUTE_UNUSED bfd_boolean
110 is_reloc_PC_relative (reloc_howto_type
*howto
)
112 return (strstr (howto
->name
, "PC") != NULL
) ? TRUE
: FALSE
;
116 is_reloc_SDA_relative (reloc_howto_type
*howto
)
118 return (strstr (howto
->name
, "SDA") != NULL
) ? TRUE
: FALSE
;
122 is_reloc_for_GOT (reloc_howto_type
* howto
)
124 if (strstr (howto
->name
, "TLS") != NULL
)
126 return (strstr (howto
->name
, "GOT") != NULL
) ? TRUE
: FALSE
;
130 is_reloc_for_PLT (reloc_howto_type
* howto
)
132 return (strstr (howto
->name
, "PLT") != NULL
) ? TRUE
: FALSE
;
136 is_reloc_for_TLS (reloc_howto_type
*howto
)
138 return (strstr (howto
->name
, "TLS") != NULL
) ? TRUE
: FALSE
;
141 struct arc_relocation_data
143 bfd_signed_vma reloc_offset
;
144 bfd_signed_vma reloc_addend
;
145 bfd_signed_vma got_offset_value
;
147 bfd_signed_vma sym_value
;
148 asection
* sym_section
;
150 reloc_howto_type
*howto
;
152 asection
* input_section
;
154 bfd_signed_vma sdata_begin_symbol_vma
;
155 bfd_boolean sdata_begin_symbol_vma_set
;
156 bfd_signed_vma got_symbol_vma
;
158 bfd_boolean should_relocate
;
160 const char * symbol_name
;
163 /* Should be included at this location due to static declarations
164 defined before this point. */
167 #define arc_bfd_get_8(A,B,C) bfd_get_8(A,B)
168 #define arc_bfd_get_16(A,B,C) bfd_get_16(A,B)
169 #define arc_bfd_get_32(A,B,C) bfd_get_32(A,B)
170 #define arc_bfd_put_8(A,B,C,D) bfd_put_8(A,B,C)
171 #define arc_bfd_put_16(A,B,C,D) bfd_put_16(A,B,C)
172 #define arc_bfd_put_32(A,B,C,D) bfd_put_32(A,B,C)
175 static bfd_reloc_status_type
176 arc_elf_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
177 arelent
*reloc_entry
,
179 void *data ATTRIBUTE_UNUSED
,
180 asection
*input_section
,
182 char ** error_message ATTRIBUTE_UNUSED
)
184 if (output_bfd
!= NULL
)
186 reloc_entry
->address
+= input_section
->output_offset
;
188 /* In case of relocateable link and if the reloc is against a
189 section symbol, the addend needs to be adjusted according to
190 where the section symbol winds up in the output section. */
191 if ((symbol_in
->flags
& BSF_SECTION_SYM
) && symbol_in
->section
)
192 reloc_entry
->addend
+= symbol_in
->section
->output_offset
;
197 return bfd_reloc_continue
;
201 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
206 #include "elf/arc-reloc.def"
210 #undef ARC_RELOC_HOWTO
212 #define ARC_RELOC_HOWTO(TYPE, VALUE, RSIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
213 [TYPE] = HOWTO (R_##TYPE, 0, RSIZE, BITSIZE, FALSE, 0, \
214 complain_overflow_##OVERFLOW, arc_elf_reloc, \
215 "R_" #TYPE, FALSE, 0, 0, FALSE),
217 static struct reloc_howto_struct elf_arc_howto_table
[] =
219 #include "elf/arc-reloc.def"
220 /* Example of what is generated by the preprocessor. Currently kept as an
222 HOWTO (R_ARC_NONE, // Type.
224 2, // Size (0 = byte, 1 = short, 2 = long).
226 FALSE, // PC_relative.
228 complain_overflow_bitfield, // Complain_on_overflow.
229 bfd_elf_generic_reloc, // Special_function.
230 "R_ARC_NONE", // Name.
231 TRUE, // Partial_inplace.
234 FALSE), // PCrel_offset.
237 #undef ARC_RELOC_HOWTO
240 arc_elf_howto_init (void)
242 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
243 elf_arc_howto_table[TYPE].pc_relative = \
244 (strstr (#FORMULA, " P ") != NULL || strstr (#FORMULA, " PDATA ") != NULL); \
245 elf_arc_howto_table[TYPE].dst_mask = RELOC_FUNCTION(0, ~0); \
246 /* Only 32 bit data relocations should be marked as ME. */ \
247 if (strstr (#FORMULA, " ME ") != NULL) \
249 BFD_ASSERT (SIZE == 2); \
252 #include "elf/arc-reloc.def"
255 #undef ARC_RELOC_HOWTO
258 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
261 const int howto_table_lookup
[] =
263 #include "elf/arc-reloc.def"
266 #undef ARC_RELOC_HOWTO
268 static reloc_howto_type
*
269 arc_elf_howto (unsigned int r_type
)
271 if (elf_arc_howto_table
[R_ARC_32
].dst_mask
== 0)
272 arc_elf_howto_init ();
273 return &elf_arc_howto_table
[r_type
];
276 /* Map BFD reloc types to ARC ELF reloc types. */
280 bfd_reloc_code_real_type bfd_reloc_val
;
281 unsigned char elf_reloc_val
;
284 /* ARC ELF linker hash entry. */
285 struct elf_arc_link_hash_entry
287 struct elf_link_hash_entry root
;
289 /* Track dynamic relocs copied for this symbol. */
290 struct elf_dyn_relocs
*dyn_relocs
;
293 /* ARC ELF linker hash table. */
294 struct elf_arc_link_hash_table
296 struct elf_link_hash_table elf
;
299 static struct bfd_hash_entry
*
300 elf_arc_link_hash_newfunc (struct bfd_hash_entry
*entry
,
301 struct bfd_hash_table
*table
,
304 /* Allocate the structure if it has not already been allocated by a
308 entry
= (struct bfd_hash_entry
*)
309 bfd_hash_allocate (table
,
310 sizeof (struct elf_arc_link_hash_entry
));
315 /* Call the allocation method of the superclass. */
316 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
319 struct elf_arc_link_hash_entry
*eh
;
321 eh
= (struct elf_arc_link_hash_entry
*) entry
;
322 eh
->dyn_relocs
= NULL
;
328 /* Destroy an ARC ELF linker hash table. */
330 elf_arc_link_hash_table_free (bfd
*obfd
)
332 _bfd_elf_link_hash_table_free (obfd
);
335 /* Create an ARC ELF linker hash table. */
337 static struct bfd_link_hash_table
*
338 arc_elf_link_hash_table_create (bfd
*abfd
)
340 struct elf_arc_link_hash_table
*ret
;
342 ret
= (struct elf_arc_link_hash_table
*) bfd_zmalloc (sizeof (*ret
));
346 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
347 elf_arc_link_hash_newfunc
,
348 sizeof (struct elf_arc_link_hash_entry
),
355 ret
->elf
.init_got_refcount
.refcount
= 0;
356 ret
->elf
.init_got_refcount
.glist
= NULL
;
357 ret
->elf
.init_got_offset
.offset
= 0;
358 ret
->elf
.init_got_offset
.glist
= NULL
;
360 ret
->elf
.root
.hash_table_free
= elf_arc_link_hash_table_free
;
362 return &ret
->elf
.root
;
365 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
366 { BFD_RELOC_##TYPE, R_##TYPE },
368 static const struct arc_reloc_map arc_reloc_map
[] =
370 #include "elf/arc-reloc.def"
372 {BFD_RELOC_NONE
, R_ARC_NONE
},
373 {BFD_RELOC_8
, R_ARC_8
},
374 {BFD_RELOC_16
, R_ARC_16
},
375 {BFD_RELOC_24
, R_ARC_24
},
376 {BFD_RELOC_32
, R_ARC_32
},
379 #undef ARC_RELOC_HOWTO
381 typedef ATTRIBUTE_UNUSED
bfd_vma (*replace_func
) (unsigned, int ATTRIBUTE_UNUSED
);
383 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
385 func = (void *) RELOC_FUNCTION; \
389 get_replace_function (bfd
*abfd
, unsigned int r_type
)
395 #include "elf/arc-reloc.def"
398 if (func
== replace_bits24
&& bfd_big_endian (abfd
))
399 func
= replace_bits24_be
;
401 return (replace_func
) func
;
403 #undef ARC_RELOC_HOWTO
405 static reloc_howto_type
*
406 arc_elf32_bfd_reloc_type_lookup (bfd
* abfd ATTRIBUTE_UNUSED
,
407 bfd_reloc_code_real_type code
)
411 for (i
= ARRAY_SIZE (arc_reloc_map
); i
--;)
413 if (arc_reloc_map
[i
].bfd_reloc_val
== code
)
414 return arc_elf_howto (arc_reloc_map
[i
].elf_reloc_val
);
420 /* Function to set the ELF flag bits. */
422 arc_elf_set_private_flags (bfd
*abfd
, flagword flags
)
424 elf_elfheader (abfd
)->e_flags
= flags
;
425 elf_flags_init (abfd
) = TRUE
;
429 /* Print private flags. */
431 arc_elf_print_private_bfd_data (bfd
*abfd
, void * ptr
)
433 FILE *file
= (FILE *) ptr
;
436 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
438 /* Print normal ELF private data. */
439 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
441 flags
= elf_elfheader (abfd
)->e_flags
;
442 fprintf (file
, _("private flags = 0x%lx:"), (unsigned long) flags
);
444 switch (flags
& EF_ARC_MACH_MSK
)
446 case EF_ARC_CPU_ARCV2HS
: fprintf (file
, " -mcpu=ARCv2HS"); break;
447 case EF_ARC_CPU_ARCV2EM
: fprintf (file
, " -mcpu=ARCv2EM"); break;
448 case E_ARC_MACH_ARC600
: fprintf (file
, " -mcpu=ARC600"); break;
449 case E_ARC_MACH_ARC601
: fprintf (file
, " -mcpu=ARC601"); break;
450 case E_ARC_MACH_ARC700
: fprintf (file
, " -mcpu=ARC700"); break;
452 fprintf (file
, "-mcpu=unknown");
456 switch (flags
& EF_ARC_OSABI_MSK
)
458 case E_ARC_OSABI_ORIG
: fprintf (file
, " (ABI:legacy)"); break;
459 case E_ARC_OSABI_V2
: fprintf (file
, " (ABI:v2)"); break;
460 case E_ARC_OSABI_V3
: fprintf (file
, " (ABI:v3)"); break;
461 case E_ARC_OSABI_V4
: fprintf (file
, " (ABI:v4)"); break;
463 fprintf (file
, " (ABI:unknown)");
471 /* Copy backend specific data from one object module to another. */
474 arc_elf_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
476 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
477 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
480 BFD_ASSERT (!elf_flags_init (obfd
)
481 || elf_elfheader (obfd
)->e_flags
== elf_elfheader (ibfd
)->e_flags
);
483 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
484 elf_flags_init (obfd
) = TRUE
;
486 /* Copy object attributes. */
487 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
489 return _bfd_elf_copy_private_bfd_data (ibfd
, obfd
);
492 static reloc_howto_type
*
493 bfd_elf32_bfd_reloc_name_lookup (bfd
* abfd ATTRIBUTE_UNUSED
,
498 for (i
= 0; i
< ARRAY_SIZE (elf_arc_howto_table
); i
++)
499 if (elf_arc_howto_table
[i
].name
!= NULL
500 && strcasecmp (elf_arc_howto_table
[i
].name
, r_name
) == 0)
501 return arc_elf_howto (i
);
506 /* Set the howto pointer for an ARC ELF reloc. */
509 arc_info_to_howto_rel (bfd
* abfd
,
511 Elf_Internal_Rela
* dst
)
515 r_type
= ELF32_R_TYPE (dst
->r_info
);
516 if (r_type
>= (unsigned int) R_ARC_max
)
518 /* xgettext:c-format */
519 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
521 bfd_set_error (bfd_error_bad_value
);
525 cache_ptr
->howto
= arc_elf_howto (r_type
);
529 /* Extract CPU features from an NTBS. */
532 arc_extract_features (const char *p
)
539 for (i
= 0; i
< ARRAY_SIZE (bfd_feature_list
); i
++)
541 char *t
= strstr (p
, bfd_feature_list
[i
].attr
);
542 unsigned l
= strlen (bfd_feature_list
[i
].attr
);
546 r
|= bfd_feature_list
[i
].feature
;
552 /* Concatenate two strings. s1 can be NULL but not
556 arc_stralloc (char * s1
, const char * s2
)
560 /* Only s1 can be null. */
563 p
= s1
? concat (s1
, ",", s2
, NULL
) : (char *)s2
;
568 /* Merge ARC object attributes from IBFD into OBFD. Raise an error if
569 there are conflicting attributes. */
572 arc_elf_merge_attributes (bfd
*ibfd
, struct bfd_link_info
*info
)
574 bfd
*obfd
= info
->output_bfd
;
575 obj_attribute
*in_attr
;
576 obj_attribute
*out_attr
;
578 bfd_boolean result
= TRUE
;
579 const char *sec_name
= get_elf_backend_data (ibfd
)->obj_attrs_section
;
580 char *tagname
= NULL
;
582 /* Skip the linker stubs file. This preserves previous behavior
583 of accepting unknown attributes in the first input file - but
585 if (ibfd
->flags
& BFD_LINKER_CREATED
)
588 /* Skip any input that hasn't attribute section.
589 This enables to link object files without attribute section with
591 if (bfd_get_section_by_name (ibfd
, sec_name
) == NULL
)
594 if (!elf_known_obj_attributes_proc (obfd
)[0].i
)
596 /* This is the first object. Copy the attributes. */
597 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
599 out_attr
= elf_known_obj_attributes_proc (obfd
);
601 /* Use the Tag_null value to indicate the attributes have been
608 in_attr
= elf_known_obj_attributes_proc (ibfd
);
609 out_attr
= elf_known_obj_attributes_proc (obfd
);
611 for (i
= LEAST_KNOWN_OBJ_ATTRIBUTE
; i
< NUM_KNOWN_OBJ_ATTRIBUTES
; i
++)
613 /* Merge this attribute with existing attributes. */
616 case Tag_ARC_PCS_config
:
617 if (out_attr
[i
].i
== 0)
618 out_attr
[i
].i
= in_attr
[i
].i
;
619 else if (in_attr
[i
].i
!= 0 && out_attr
[i
].i
!= in_attr
[i
].i
)
621 const char *tagval
[] = { "Absent", "Bare-metal/mwdt",
622 "Bare-metal/newlib", "Linux/uclibc",
624 BFD_ASSERT (in_attr
[i
].i
< 5);
625 BFD_ASSERT (out_attr
[i
].i
< 5);
626 /* It's sometimes ok to mix different configs, so this is only
629 (_("warning: %pB: conflicting platform configuration "
631 tagval
[in_attr
[i
].i
],
632 tagval
[out_attr
[i
].i
]);
636 case Tag_ARC_CPU_base
:
637 if (out_attr
[i
].i
== 0)
638 out_attr
[i
].i
= in_attr
[i
].i
;
639 else if (in_attr
[i
].i
!= 0 && out_attr
[i
].i
!= in_attr
[i
].i
640 && ((out_attr
[i
].i
+ in_attr
[i
].i
) < 6))
642 const char *tagval
[] = { "Absent", "ARC6xx", "ARC7xx",
644 BFD_ASSERT (in_attr
[i
].i
< 5);
645 BFD_ASSERT (out_attr
[i
].i
< 5);
646 /* We cannot mix code for different CPUs. */
648 (_("error: %pB: unable to merge CPU base attributes "
651 tagval
[in_attr
[i
].i
],
652 tagval
[out_attr
[i
].i
]);
658 /* The CPUs may be different, check if we can still mix
659 the objects against the output choosen CPU. */
660 unsigned in_feature
= 0;
661 unsigned out_feature
= 0;
662 char *p1
= in_attr
[Tag_ARC_ISA_config
].s
;
663 char *p2
= out_attr
[Tag_ARC_ISA_config
].s
;
666 unsigned opcode_map
[] = {0, ARC_OPCODE_ARC600
, ARC_OPCODE_ARC700
,
667 ARC_OPCODE_ARCv2EM
, ARC_OPCODE_ARCv2HS
};
669 BFD_ASSERT (in_attr
[i
].i
< (sizeof (opcode_map
)
670 / sizeof (unsigned)));
671 BFD_ASSERT (out_attr
[i
].i
< (sizeof (opcode_map
)
672 / sizeof (unsigned)));
673 cpu_out
= opcode_map
[out_attr
[i
].i
];
675 in_feature
= arc_extract_features (p1
);
676 out_feature
= arc_extract_features (p2
);
678 /* First, check if a feature is compatible with the
679 output object chosen CPU. */
680 for (j
= 0; j
< ARRAY_SIZE (bfd_feature_list
); j
++)
681 if (((in_feature
| out_feature
) & bfd_feature_list
[j
].feature
)
682 && (!(cpu_out
& bfd_feature_list
[j
].cpus
)))
685 (_("error: %pB: unable to merge ISA extension attributes "
687 obfd
, bfd_feature_list
[j
].name
);
691 /* Second, if we have compatible features with the
692 chosen CPU, check if they are compatible among
694 for (j
= 0; j
< ARRAY_SIZE (bfd_conflict_list
); j
++)
695 if (((in_feature
| out_feature
) & bfd_conflict_list
[j
])
696 == bfd_conflict_list
[j
])
699 for (k
= 0; k
< ARRAY_SIZE (bfd_feature_list
); k
++)
701 if (in_feature
& bfd_feature_list
[k
].feature
702 & bfd_conflict_list
[j
])
703 p1
= (char *) bfd_feature_list
[k
].name
;
704 if (out_feature
& bfd_feature_list
[k
].feature
705 & bfd_conflict_list
[j
])
706 p2
= (char *) bfd_feature_list
[k
].name
;
709 (_("error: %pB: conflicting ISA extension attributes "
715 /* Everithing is alright. */
716 out_feature
|= in_feature
;
718 for (j
= 0; j
< ARRAY_SIZE (bfd_feature_list
); j
++)
719 if (out_feature
& bfd_feature_list
[j
].feature
)
720 p1
= arc_stralloc (p1
, bfd_feature_list
[j
].attr
);
722 out_attr
[Tag_ARC_ISA_config
].s
=
723 _bfd_elf_attr_strdup (obfd
, p1
);
726 case Tag_ARC_CPU_variation
:
727 case Tag_ARC_ISA_mpy_option
:
728 case Tag_ARC_ABI_osver
:
729 /* Use the largest value specified. */
730 if (in_attr
[i
].i
> out_attr
[i
].i
)
731 out_attr
[i
].i
= in_attr
[i
].i
;
734 /* The CPU name is given by the vendor, just choose an
735 existing one if missing or different. There are no fail
736 criteria if they different or both missing. */
737 case Tag_ARC_CPU_name
:
738 if (!out_attr
[i
].s
&& in_attr
[i
].s
)
739 out_attr
[i
].s
= _bfd_elf_attr_strdup (obfd
, in_attr
[i
].s
);
742 case Tag_ARC_ABI_rf16
:
743 if (out_attr
[i
].i
== 0)
744 out_attr
[i
].i
= in_attr
[i
].i
;
745 else if (out_attr
[i
].i
!= in_attr
[i
].i
)
747 /* We cannot mix code with rf16 and without. */
749 (_("error: %pB: cannot mix rf16 with full register set %pB"),
755 case Tag_ARC_ABI_pic
:
758 case Tag_ARC_ABI_sda
:
762 case Tag_ARC_ABI_tls
:
764 const char *tagval
[] = { "Absent", "MWDT", "GNU" };
769 BFD_ASSERT (in_attr
[i
].i
< 3);
770 BFD_ASSERT (out_attr
[i
].i
< 3);
771 if (out_attr
[i
].i
== 0)
772 out_attr
[i
].i
= in_attr
[i
].i
;
773 else if (out_attr
[i
].i
!= 0 && in_attr
[i
].i
!= 0
774 && out_attr
[i
].i
!= in_attr
[i
].i
)
777 (_("error: %pB: conflicting attributes %s: %s with %s"),
779 tagval
[in_attr
[i
].i
],
780 tagval
[out_attr
[i
].i
]);
787 case Tag_ARC_ABI_double_size
:
788 tagname
= "Double size";
790 case Tag_ARC_ABI_enumsize
:
792 tagname
= "Enum size";
794 case Tag_ARC_ABI_exceptions
:
796 tagname
= "ABI exceptions";
798 if (out_attr
[i
].i
== 0)
799 out_attr
[i
].i
= in_attr
[i
].i
;
800 else if (out_attr
[i
].i
!= 0 && in_attr
[i
].i
!= 0
801 && out_attr
[i
].i
!= in_attr
[i
].i
)
804 (_("error: %pB: conflicting attributes %s"),
810 case Tag_ARC_ISA_apex
:
811 break; /* Do nothing for APEX attributes. */
813 case Tag_ARC_ISA_config
:
814 /* It is handled in Tag_ARC_CPU_base. */
817 case Tag_ARC_ATR_version
:
818 if (out_attr
[i
].i
== 0)
819 out_attr
[i
].i
= in_attr
[i
].i
;
824 = result
&& _bfd_elf_merge_unknown_attribute_low (ibfd
, obfd
, i
);
827 /* If out_attr was copied from in_attr then it won't have a type yet. */
828 if (in_attr
[i
].type
&& !out_attr
[i
].type
)
829 out_attr
[i
].type
= in_attr
[i
].type
;
832 /* Merge Tag_compatibility attributes and any common GNU ones. */
833 if (!_bfd_elf_merge_object_attributes (ibfd
, info
))
836 /* Check for any attributes not known on ARC. */
837 result
&= _bfd_elf_merge_unknown_attribute_list (ibfd
, obfd
);
842 /* Merge backend specific data from an object file to the output
843 object file when linking. */
846 arc_elf_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
848 bfd
*obfd
= info
->output_bfd
;
849 unsigned short mach_ibfd
;
850 static unsigned short mach_obfd
= EM_NONE
;
855 /* Check if we have the same endianess. */
856 if (! _bfd_generic_verify_endian_match (ibfd
, info
))
859 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
860 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
863 /* Collect ELF flags. */
864 in_flags
= elf_elfheader (ibfd
)->e_flags
& EF_ARC_MACH_MSK
;
865 out_flags
= elf_elfheader (obfd
)->e_flags
& EF_ARC_MACH_MSK
;
867 if (!elf_flags_init (obfd
)) /* First call, no flags set. */
869 elf_flags_init (obfd
) = TRUE
;
870 out_flags
= in_flags
;
873 if (!arc_elf_merge_attributes (ibfd
, info
))
876 /* Check to see if the input BFD actually contains any sections. Do
877 not short-circuit dynamic objects; their section list may be
878 emptied by elf_link_add_object_symbols. */
879 if (!(ibfd
->flags
& DYNAMIC
))
881 bfd_boolean null_input_bfd
= TRUE
;
882 bfd_boolean only_data_sections
= TRUE
;
884 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
886 if ((bfd_get_section_flags (ibfd
, sec
)
887 & (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
888 == (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
889 only_data_sections
= FALSE
;
891 null_input_bfd
= FALSE
;
894 if (null_input_bfd
|| only_data_sections
)
898 /* Complain about various flag/architecture mismatches. */
899 mach_ibfd
= elf_elfheader (ibfd
)->e_machine
;
900 if (mach_obfd
== EM_NONE
)
902 mach_obfd
= mach_ibfd
;
906 if (mach_ibfd
!= mach_obfd
)
908 /* xgettext:c-format */
909 _bfd_error_handler (_("error: attempting to link %pB "
910 "with a binary %pB of different architecture"),
914 else if ((in_flags
!= out_flags
)
915 /* If we have object attributes, then we already
916 checked the objects compatibility, skip it. */
917 && !bfd_elf_get_obj_attr_int (ibfd
, OBJ_ATTR_PROC
,
920 /* Warn if different flags. */
922 /* xgettext:c-format */
923 (_("%pB: uses different e_flags (%#x) fields than "
924 "previous modules (%#x)"),
925 ibfd
, in_flags
, out_flags
);
926 if (in_flags
&& out_flags
)
928 /* MWDT doesnt set the eflags hence make sure we choose the
929 eflags set by gcc. */
930 in_flags
= in_flags
> out_flags
? in_flags
: out_flags
;
934 /* Everything is correct; don't change the output flags. */
935 in_flags
= out_flags
;
939 /* Update the flags. */
940 elf_elfheader (obfd
)->e_flags
= in_flags
;
942 if (bfd_get_mach (obfd
) < bfd_get_mach (ibfd
))
944 return bfd_set_arch_mach (obfd
, bfd_arch_arc
, bfd_get_mach (ibfd
));
950 /* Return a best guess for the machine number based on the attributes. */
953 bfd_arc_get_mach_from_attributes (bfd
* abfd
)
955 int arch
= bfd_elf_get_obj_attr_int (abfd
, OBJ_ATTR_PROC
, Tag_ARC_CPU_base
);
956 unsigned e_machine
= elf_elfheader (abfd
)->e_machine
;
961 return bfd_mach_arc_arc600
;
963 return bfd_mach_arc_arc700
;
966 return bfd_mach_arc_arcv2
;
970 return (e_machine
== EM_ARC_COMPACT
)
971 ? bfd_mach_arc_arc700
: bfd_mach_arc_arcv2
;
974 /* Set the right machine number for an ARC ELF file. */
976 arc_elf_object_p (bfd
* abfd
)
978 /* Make sure this is initialised, or you'll have the potential of passing
979 garbage---or misleading values---into the call to
980 bfd_default_set_arch_mach (). */
981 unsigned int mach
= bfd_mach_arc_arc700
;
982 unsigned long arch
= elf_elfheader (abfd
)->e_flags
& EF_ARC_MACH_MSK
;
983 unsigned e_machine
= elf_elfheader (abfd
)->e_machine
;
985 if (e_machine
== EM_ARC_COMPACT
|| e_machine
== EM_ARC_COMPACT2
)
989 case E_ARC_MACH_ARC600
:
990 mach
= bfd_mach_arc_arc600
;
992 case E_ARC_MACH_ARC601
:
993 mach
= bfd_mach_arc_arc601
;
995 case E_ARC_MACH_ARC700
:
996 mach
= bfd_mach_arc_arc700
;
998 case EF_ARC_CPU_ARCV2HS
:
999 case EF_ARC_CPU_ARCV2EM
:
1000 mach
= bfd_mach_arc_arcv2
;
1003 mach
= bfd_arc_get_mach_from_attributes (abfd
);
1009 if (e_machine
== EM_ARC
)
1012 (_("error: the ARC4 architecture is no longer supported"));
1018 (_("warning: unset or old architecture flags; "
1019 "use default machine"));
1023 return bfd_default_set_arch_mach (abfd
, bfd_arch_arc
, mach
);
1026 /* The final processing done just before writing out an ARC ELF object file.
1027 This gets the ARC architecture right based on the machine number. */
1030 arc_elf_final_write_processing (bfd
* abfd
,
1031 bfd_boolean linker ATTRIBUTE_UNUSED
)
1034 int osver
= bfd_elf_get_obj_attr_int (abfd
, OBJ_ATTR_PROC
,
1036 flagword e_flags
= elf_elfheader (abfd
)->e_flags
& ~EF_ARC_OSABI_MSK
;
1038 switch (bfd_get_mach (abfd
))
1040 case bfd_mach_arc_arc600
:
1041 emf
= EM_ARC_COMPACT
;
1043 case bfd_mach_arc_arc601
:
1044 emf
= EM_ARC_COMPACT
;
1046 case bfd_mach_arc_arc700
:
1047 emf
= EM_ARC_COMPACT
;
1049 case bfd_mach_arc_arcv2
:
1050 emf
= EM_ARC_COMPACT2
;
1056 elf_elfheader (abfd
)->e_machine
= emf
;
1058 /* Record whatever is the current syscall ABI version. */
1060 e_flags
|= ((osver
& 0x0f) << 8);
1062 e_flags
|= E_ARC_OSABI_V3
;
1064 elf_elfheader (abfd
)->e_flags
|= e_flags
;
1067 #ifdef ARC_ENABLE_DEBUG
1068 #define DEBUG_ARC_RELOC(A) debug_arc_reloc (A)
1071 debug_arc_reloc (struct arc_relocation_data reloc_data
)
1073 ARC_DEBUG ("Reloc type=%s, should_relocate = %s\n",
1074 reloc_data
.howto
->name
,
1075 reloc_data
.should_relocate
? "true" : "false");
1076 ARC_DEBUG (" offset = 0x%x, addend = 0x%x\n",
1077 (unsigned int) reloc_data
.reloc_offset
,
1078 (unsigned int) reloc_data
.reloc_addend
);
1079 ARC_DEBUG (" Symbol:\n");
1080 ARC_DEBUG (" value = 0x%08x\n",
1081 (unsigned int) reloc_data
.sym_value
);
1082 if (reloc_data
.sym_section
!= NULL
)
1084 ARC_DEBUG (" Symbol Section:\n");
1085 ARC_DEBUG (" section name = %s, output_offset 0x%08x",
1086 reloc_data
.sym_section
->name
,
1087 (unsigned int) reloc_data
.sym_section
->output_offset
);
1088 if (reloc_data
.sym_section
->output_section
!= NULL
)
1089 ARC_DEBUG (", output_section->vma = 0x%08x",
1090 ((unsigned int) reloc_data
.sym_section
->output_section
->vma
));
1092 if (reloc_data
.sym_section
->owner
&& reloc_data
.sym_section
->owner
->filename
)
1093 ARC_DEBUG (" file: %s\n", reloc_data
.sym_section
->owner
->filename
);
1097 ARC_DEBUG (" symbol section is NULL\n");
1100 ARC_DEBUG (" Input_section:\n");
1101 if (reloc_data
.input_section
!= NULL
)
1103 ARC_DEBUG (" section name = %s, output_offset 0x%08x, output_section->vma = 0x%08x\n",
1104 reloc_data
.input_section
->name
,
1105 (unsigned int) reloc_data
.input_section
->output_offset
,
1106 (unsigned int) reloc_data
.input_section
->output_section
->vma
);
1107 ARC_DEBUG (" changed_address = 0x%08x\n",
1108 (unsigned int) (reloc_data
.input_section
->output_section
->vma
1109 + reloc_data
.input_section
->output_offset
1110 + reloc_data
.reloc_offset
));
1111 ARC_DEBUG (" file: %s\n", reloc_data
.input_section
->owner
->filename
);
1115 ARC_DEBUG (" input section is NULL\n");
1119 #define DEBUG_ARC_RELOC(A)
1120 #endif /* ARC_ENABLE_DEBUG */
1123 middle_endian_convert (bfd_vma insn
, bfd_boolean do_it
)
1128 = ((insn
& 0xffff0000) >> 16)
1129 | ((insn
& 0xffff) << 16);
1134 /* This function is called for relocations that are otherwise marked as NOT
1135 requiring overflow checks. In here we perform non-standard checks of
1136 the relocation value. */
1138 static inline bfd_reloc_status_type
1139 arc_special_overflow_checks (const struct arc_relocation_data reloc_data
,
1140 bfd_signed_vma relocation
,
1141 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1143 switch (reloc_data
.howto
->type
)
1145 case R_ARC_NPS_CMEM16
:
1146 if (((relocation
>> 16) & 0xffff) != NPS_CMEM_HIGH_VALUE
)
1148 if (reloc_data
.reloc_addend
== 0)
1150 /* xgettext:c-format */
1151 (_("%pB(%pA+%#" PRIx64
"): CMEM relocation to `%s' is invalid, "
1152 "16 MSB should be %#x (value is %#" PRIx64
")"),
1153 reloc_data
.input_section
->owner
,
1154 reloc_data
.input_section
,
1155 (uint64_t) reloc_data
.reloc_offset
,
1156 reloc_data
.symbol_name
,
1157 NPS_CMEM_HIGH_VALUE
,
1158 (uint64_t) relocation
);
1161 /* xgettext:c-format */
1162 (_("%pB(%pA+%#" PRIx64
"): CMEM relocation to `%s+%#" PRIx64
1163 "' is invalid, 16 MSB should be %#x (value is %#" PRIx64
")"),
1164 reloc_data
.input_section
->owner
,
1165 reloc_data
.input_section
,
1166 (uint64_t) reloc_data
.reloc_offset
,
1167 reloc_data
.symbol_name
,
1168 (uint64_t) reloc_data
.reloc_addend
,
1169 NPS_CMEM_HIGH_VALUE
,
1170 (uint64_t) relocation
);
1171 return bfd_reloc_overflow
;
1179 return bfd_reloc_ok
;
1182 #define ME(reloc) (reloc)
1184 #define IS_ME(FORMULA,BFD) ((strstr (FORMULA, "ME") != NULL) \
1185 && (!bfd_big_endian (BFD)))
1187 #define S ((bfd_signed_vma) (reloc_data.sym_value \
1188 + (reloc_data.sym_section->output_section != NULL ? \
1189 (reloc_data.sym_section->output_offset \
1190 + reloc_data.sym_section->output_section->vma) : 0)))
1191 #define L ((bfd_signed_vma) (reloc_data.sym_value \
1192 + (reloc_data.sym_section->output_section != NULL ? \
1193 (reloc_data.sym_section->output_offset \
1194 + reloc_data.sym_section->output_section->vma) : 0)))
1195 #define A (reloc_data.reloc_addend)
1197 #define G (reloc_data.got_offset_value)
1198 #define GOT (reloc_data.got_symbol_vma)
1199 #define GOT_BEGIN (htab->sgot->output_section->vma)
1202 /* P: relative offset to PCL The offset should be to the
1203 current location aligned to 32 bits. */
1204 #define P ((bfd_signed_vma) ( \
1206 (reloc_data.input_section->output_section != NULL ? \
1207 reloc_data.input_section->output_section->vma : 0) \
1208 + reloc_data.input_section->output_offset \
1209 + (reloc_data.reloc_offset - (bitsize >= 32 ? 4 : 0))) \
1211 #define PDATA ((bfd_signed_vma) ( \
1212 (reloc_data.input_section->output_section->vma \
1213 + reloc_data.input_section->output_offset \
1214 + (reloc_data.reloc_offset))))
1215 #define SECTSTART (bfd_signed_vma) (reloc_data.sym_section->output_section->vma \
1216 + reloc_data.sym_section->output_offset)
1217 #define JLI (bfd_signed_vma) (reloc_data.sym_section->output_section->vma)
1218 #define _SDA_BASE_ (bfd_signed_vma) (reloc_data.sdata_begin_symbol_vma)
1219 #define TLS_REL (bfd_signed_vma) \
1220 ((elf_hash_table (info))->tls_sec->output_section->vma)
1221 #define TLS_TBSS (8)
1225 #ifdef ARC_ENABLE_DEBUG
1226 #define PRINT_DEBUG_RELOC_INFO_BEFORE(FORMULA, TYPE) \
1229 asection *sym_section = reloc_data.sym_section; \
1230 asection *input_section = reloc_data.input_section; \
1231 ARC_DEBUG ("RELOC_TYPE = " TYPE "\n"); \
1232 ARC_DEBUG ("FORMULA = " FORMULA "\n"); \
1233 ARC_DEBUG ("S = %#lx\n", S); \
1234 ARC_DEBUG ("A = %#lx\n", A); \
1235 ARC_DEBUG ("L = %lx\n", L); \
1236 if (sym_section->output_section != NULL) \
1237 ARC_DEBUG ("symbol_section->vma = %#lx\n", \
1238 sym_section->output_section->vma \
1239 + sym_section->output_offset); \
1241 ARC_DEBUG ("symbol_section->vma = NULL\n"); \
1242 if (input_section->output_section != NULL) \
1243 ARC_DEBUG ("symbol_section->vma = %#lx\n", \
1244 input_section->output_section->vma \
1245 + input_section->output_offset); \
1247 ARC_DEBUG ("symbol_section->vma = NULL\n"); \
1248 ARC_DEBUG ("PCL = %#lx\n", P); \
1249 ARC_DEBUG ("P = %#lx\n", P); \
1250 ARC_DEBUG ("G = %#lx\n", G); \
1251 ARC_DEBUG ("SDA_OFFSET = %#lx\n", _SDA_BASE_); \
1252 ARC_DEBUG ("SDA_SET = %d\n", reloc_data.sdata_begin_symbol_vma_set); \
1253 ARC_DEBUG ("GOT_OFFSET = %#lx\n", GOT); \
1254 ARC_DEBUG ("relocation = %#08lx\n", relocation); \
1255 ARC_DEBUG ("before = %#08x\n", (unsigned) insn); \
1256 ARC_DEBUG ("data = %08x (%u) (%d)\n", (unsigned) relocation, \
1257 (unsigned) relocation, (int) relocation); \
1261 #define PRINT_DEBUG_RELOC_INFO_AFTER \
1264 ARC_DEBUG ("after = 0x%08x\n", (unsigned int) insn); \
1270 #define PRINT_DEBUG_RELOC_INFO_BEFORE(...)
1271 #define PRINT_DEBUG_RELOC_INFO_AFTER
1273 #endif /* ARC_ENABLE_DEBUG */
1275 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
1278 bfd_signed_vma bitsize ATTRIBUTE_UNUSED = BITSIZE; \
1279 relocation = FORMULA ; \
1280 PRINT_DEBUG_RELOC_INFO_BEFORE (#FORMULA, #TYPE); \
1281 insn = middle_endian_convert (insn, IS_ME (#FORMULA, abfd)); \
1282 insn = (* get_replace_function (abfd, TYPE)) (insn, relocation); \
1283 insn = middle_endian_convert (insn, IS_ME (#FORMULA, abfd)); \
1284 PRINT_DEBUG_RELOC_INFO_AFTER; \
1288 static bfd_reloc_status_type
1289 arc_do_relocation (bfd_byte
* contents
,
1290 struct arc_relocation_data reloc_data
,
1291 struct bfd_link_info
*info
)
1293 bfd_signed_vma relocation
= 0;
1295 bfd_vma orig_insn ATTRIBUTE_UNUSED
;
1296 bfd
* abfd
= reloc_data
.input_section
->owner
;
1297 struct elf_link_hash_table
*htab ATTRIBUTE_UNUSED
= elf_hash_table (info
);
1298 bfd_reloc_status_type flag
;
1300 if (!reloc_data
.should_relocate
)
1301 return bfd_reloc_ok
;
1303 switch (reloc_data
.howto
->size
)
1306 insn
= arc_bfd_get_32 (abfd
,
1307 contents
+ reloc_data
.reloc_offset
,
1308 reloc_data
.input_section
);
1311 insn
= arc_bfd_get_16 (abfd
,
1312 contents
+ reloc_data
.reloc_offset
,
1313 reloc_data
.input_section
);
1316 insn
= arc_bfd_get_8 (abfd
,
1317 contents
+ reloc_data
.reloc_offset
,
1318 reloc_data
.input_section
);
1328 switch (reloc_data
.howto
->type
)
1330 #include "elf/arc-reloc.def"
1337 /* Check for relocation overflow. */
1338 if (reloc_data
.howto
->complain_on_overflow
!= complain_overflow_dont
)
1339 flag
= bfd_check_overflow (reloc_data
.howto
->complain_on_overflow
,
1340 reloc_data
.howto
->bitsize
,
1341 reloc_data
.howto
->rightshift
,
1342 bfd_arch_bits_per_address (abfd
),
1345 flag
= arc_special_overflow_checks (reloc_data
, relocation
, info
);
1347 if (flag
!= bfd_reloc_ok
)
1349 ARC_DEBUG ("Relocation overflows !\n");
1350 DEBUG_ARC_RELOC (reloc_data
);
1351 ARC_DEBUG ("Relocation value = signed -> %d, unsigned -> %u"
1352 ", hex -> (0x%08x)\n",
1353 (int) relocation
, (unsigned) relocation
, (int) relocation
);
1358 /* Write updated instruction back to memory. */
1359 switch (reloc_data
.howto
->size
)
1362 arc_bfd_put_32 (abfd
, insn
,
1363 contents
+ reloc_data
.reloc_offset
,
1364 reloc_data
.input_section
);
1367 arc_bfd_put_16 (abfd
, insn
,
1368 contents
+ reloc_data
.reloc_offset
,
1369 reloc_data
.input_section
);
1372 arc_bfd_put_8 (abfd
, insn
,
1373 contents
+ reloc_data
.reloc_offset
,
1374 reloc_data
.input_section
);
1377 ARC_DEBUG ("size = %d\n", reloc_data
.howto
->size
);
1382 return bfd_reloc_ok
;
1398 #undef ARC_RELOC_HOWTO
1401 /* Relocate an arc ELF section.
1402 Function : elf_arc_relocate_section
1403 Brief : Relocate an arc section, by handling all the relocations
1404 appearing in that section.
1405 Args : output_bfd : The bfd being written to.
1406 info : Link information.
1407 input_bfd : The input bfd.
1408 input_section : The section being relocated.
1409 contents : contents of the section being relocated.
1410 relocs : List of relocations in the section.
1411 local_syms : is a pointer to the swapped in local symbols.
1412 local_section : is an array giving the section in the input file
1413 corresponding to the st_shndx field of each
1416 elf_arc_relocate_section (bfd
* output_bfd
,
1417 struct bfd_link_info
* info
,
1419 asection
* input_section
,
1420 bfd_byte
* contents
,
1421 Elf_Internal_Rela
* relocs
,
1422 Elf_Internal_Sym
* local_syms
,
1423 asection
** local_sections
)
1425 Elf_Internal_Shdr
* symtab_hdr
;
1426 struct elf_link_hash_entry
** sym_hashes
;
1427 Elf_Internal_Rela
* rel
;
1428 Elf_Internal_Rela
* wrel
;
1429 Elf_Internal_Rela
* relend
;
1430 struct elf_link_hash_table
* htab
= elf_hash_table (info
);
1432 symtab_hdr
= &((elf_tdata (input_bfd
))->symtab_hdr
);
1433 sym_hashes
= elf_sym_hashes (input_bfd
);
1435 rel
= wrel
= relocs
;
1436 relend
= relocs
+ input_section
->reloc_count
;
1437 for (; rel
< relend
; wrel
++, rel
++)
1439 enum elf_arc_reloc_type r_type
;
1440 reloc_howto_type
* howto
;
1441 unsigned long r_symndx
;
1442 struct elf_link_hash_entry
* h
;
1443 Elf_Internal_Sym
* sym
;
1445 struct elf_link_hash_entry
* h2
;
1447 bfd_boolean unresolved_reloc
= FALSE
;
1449 struct arc_relocation_data reloc_data
=
1453 .got_offset_value
= 0,
1455 .sym_section
= NULL
,
1457 .input_section
= NULL
,
1458 .sdata_begin_symbol_vma
= 0,
1459 .sdata_begin_symbol_vma_set
= FALSE
,
1460 .got_symbol_vma
= 0,
1461 .should_relocate
= FALSE
1464 r_type
= ELF32_R_TYPE (rel
->r_info
);
1466 if (r_type
>= (int) R_ARC_max
)
1468 bfd_set_error (bfd_error_bad_value
);
1471 howto
= arc_elf_howto (r_type
);
1473 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1475 /* If we are generating another .o file and the symbol in not
1476 local, skip this relocation. */
1477 if (bfd_link_relocatable (info
))
1479 /* This is a relocateable link. We don't have to change
1480 anything, unless the reloc is against a section symbol,
1481 in which case we have to adjust according to where the
1482 section symbol winds up in the output section. */
1484 /* Checks if this is a local symbol and thus the reloc
1485 might (will??) be against a section symbol. */
1486 if (r_symndx
< symtab_hdr
->sh_info
)
1488 sym
= local_syms
+ r_symndx
;
1489 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1491 sec
= local_sections
[r_symndx
];
1493 /* For RELA relocs. Just adjust the addend
1494 value in the relocation entry. */
1495 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
1497 ARC_DEBUG ("local symbols reloc (section=%d %s) seen in %s\n",
1498 (int) r_symndx
, local_sections
[r_symndx
]->name
,
1499 __PRETTY_FUNCTION__
);
1504 h2
= elf_link_hash_lookup (elf_hash_table (info
), "__SDATA_BEGIN__",
1505 FALSE
, FALSE
, TRUE
);
1507 if (!reloc_data
.sdata_begin_symbol_vma_set
1508 && h2
!= NULL
&& h2
->root
.type
!= bfd_link_hash_undefined
1509 && h2
->root
.u
.def
.section
->output_section
!= NULL
)
1510 /* TODO: Verify this condition. */
1512 reloc_data
.sdata_begin_symbol_vma
=
1513 (h2
->root
.u
.def
.value
1514 + h2
->root
.u
.def
.section
->output_section
->vma
);
1515 reloc_data
.sdata_begin_symbol_vma_set
= TRUE
;
1518 reloc_data
.input_section
= input_section
;
1519 reloc_data
.howto
= howto
;
1520 reloc_data
.reloc_offset
= rel
->r_offset
;
1521 reloc_data
.reloc_addend
= rel
->r_addend
;
1523 /* This is a final link. */
1528 if (r_symndx
< symtab_hdr
->sh_info
) /* A local symbol. */
1530 sym
= local_syms
+ r_symndx
;
1531 sec
= local_sections
[r_symndx
];
1535 bfd_boolean warned
, ignored
;
1536 bfd_vma relocation ATTRIBUTE_UNUSED
;
1538 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
1539 r_symndx
, symtab_hdr
, sym_hashes
,
1541 unresolved_reloc
, warned
, ignored
);
1543 /* TODO: This code is repeated from below. We should
1544 clean it and remove duplications.
1545 Sec is used check for discarded sections.
1546 Need to redesign code below. */
1548 /* Get the symbol's entry in the symtab. */
1549 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1551 while (h
->root
.type
== bfd_link_hash_indirect
1552 || h
->root
.type
== bfd_link_hash_warning
)
1553 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1555 /* If we have encountered a definition for this symbol. */
1556 if (h
->root
.type
== bfd_link_hash_defined
1557 || h
->root
.type
== bfd_link_hash_defweak
)
1559 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1560 sec
= h
->root
.u
.def
.section
;
1564 /* Clean relocs for symbols in discarded sections. */
1565 if (sec
!= NULL
&& discarded_section (sec
))
1567 _bfd_clear_contents (howto
, input_bfd
, input_section
,
1568 contents
+ rel
->r_offset
);
1572 /* For ld -r, remove relocations in debug sections against
1573 sections defined in discarded sections. Not done for
1574 eh_frame editing code expects to be present. */
1575 if (bfd_link_relocatable (info
)
1576 && (input_section
->flags
& SEC_DEBUGGING
))
1582 if (bfd_link_relocatable (info
))
1589 if (r_symndx
< symtab_hdr
->sh_info
) /* A local symbol. */
1591 reloc_data
.sym_value
= sym
->st_value
;
1592 reloc_data
.sym_section
= sec
;
1593 reloc_data
.symbol_name
=
1594 bfd_elf_string_from_elf_section (input_bfd
,
1595 symtab_hdr
->sh_link
,
1598 /* Mergeable section handling. */
1599 if ((sec
->flags
& SEC_MERGE
)
1600 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1604 rel
->r_addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
,
1605 &msec
, rel
->r_addend
);
1606 rel
->r_addend
-= (sec
->output_section
->vma
1607 + sec
->output_offset
1609 rel
->r_addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
1611 reloc_data
.reloc_addend
= rel
->r_addend
;
1614 BFD_ASSERT (htab
->sgot
!= NULL
|| !is_reloc_for_GOT (howto
));
1615 if (htab
->sgot
!= NULL
)
1616 reloc_data
.got_symbol_vma
= htab
->sgot
->output_section
->vma
1617 + htab
->sgot
->output_offset
;
1619 reloc_data
.should_relocate
= TRUE
;
1621 else /* Global symbol. */
1623 /* FIXME: We should use the RELOC_FOR_GLOBAL_SYMBOL macro
1624 (defined in elf-bfd.h) here. */
1626 /* Get the symbol's entry in the symtab. */
1627 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1629 while (h
->root
.type
== bfd_link_hash_indirect
1630 || h
->root
.type
== bfd_link_hash_warning
)
1632 struct elf_link_hash_entry
*h_old
= h
;
1633 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1634 if (h
->got
.glist
== 0 && h_old
->got
.glist
!= h
->got
.glist
)
1635 h
->got
.glist
= h_old
->got
.glist
;
1638 /* TODO: Need to validate what was the intention. */
1639 /* BFD_ASSERT ((h->dynindx == -1) || (h->forced_local != 0)); */
1640 reloc_data
.symbol_name
= h
->root
.root
.string
;
1642 /* If we have encountered a definition for this symbol. */
1643 if (h
->root
.type
== bfd_link_hash_defined
1644 || h
->root
.type
== bfd_link_hash_defweak
)
1646 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1647 reloc_data
.sym_section
= h
->root
.u
.def
.section
;
1649 reloc_data
.should_relocate
= TRUE
;
1651 if (is_reloc_for_GOT (howto
) && !bfd_link_pic (info
))
1653 /* TODO: Change it to use arc_do_relocation with
1654 ARC_32 reloc. Try to use ADD_RELA macro. */
1655 bfd_vma relocation
=
1656 reloc_data
.sym_value
+ reloc_data
.reloc_addend
1657 + (reloc_data
.sym_section
->output_section
!= NULL
?
1658 (reloc_data
.sym_section
->output_offset
1659 + reloc_data
.sym_section
->output_section
->vma
)
1662 BFD_ASSERT (h
->got
.glist
);
1663 bfd_vma got_offset
= h
->got
.glist
->offset
;
1664 bfd_put_32 (output_bfd
, relocation
,
1665 htab
->sgot
->contents
+ got_offset
);
1667 if (is_reloc_for_PLT (howto
) && h
->plt
.offset
!= (bfd_vma
) -1)
1669 /* TODO: This is repeated up here. */
1670 reloc_data
.sym_value
= h
->plt
.offset
;
1671 reloc_data
.sym_section
= htab
->splt
;
1674 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1676 /* Is weak symbol and has no definition. */
1677 if (is_reloc_for_GOT (howto
))
1679 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1680 reloc_data
.sym_section
= htab
->sgot
;
1681 reloc_data
.should_relocate
= TRUE
;
1683 else if (is_reloc_for_PLT (howto
)
1684 && h
->plt
.offset
!= (bfd_vma
) -1)
1686 /* TODO: This is repeated up here. */
1687 reloc_data
.sym_value
= h
->plt
.offset
;
1688 reloc_data
.sym_section
= htab
->splt
;
1689 reloc_data
.should_relocate
= TRUE
;
1696 if (is_reloc_for_GOT (howto
))
1698 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1699 reloc_data
.sym_section
= htab
->sgot
;
1701 reloc_data
.should_relocate
= TRUE
;
1703 else if (is_reloc_for_PLT (howto
))
1705 /* Fail if it is linking for PIE and the symbol is
1707 if (bfd_link_executable (info
))
1708 (*info
->callbacks
->undefined_symbol
)
1709 (info
, h
->root
.root
.string
, input_bfd
, input_section
,
1710 rel
->r_offset
, TRUE
);
1711 reloc_data
.sym_value
= h
->plt
.offset
;
1712 reloc_data
.sym_section
= htab
->splt
;
1714 reloc_data
.should_relocate
= TRUE
;
1716 else if (!bfd_link_pic (info
) || bfd_link_executable (info
))
1717 (*info
->callbacks
->undefined_symbol
)
1718 (info
, h
->root
.root
.string
, input_bfd
, input_section
,
1719 rel
->r_offset
, TRUE
);
1722 BFD_ASSERT (htab
->sgot
!= NULL
|| !is_reloc_for_GOT (howto
));
1723 if (htab
->sgot
!= NULL
)
1724 reloc_data
.got_symbol_vma
= htab
->sgot
->output_section
->vma
1725 + htab
->sgot
->output_offset
;
1728 if ((is_reloc_for_GOT (howto
)
1729 || is_reloc_for_TLS (howto
)))
1731 reloc_data
.should_relocate
= TRUE
;
1733 struct got_entry
**list
1734 = get_got_entry_list_for_symbol (output_bfd
, r_symndx
, h
);
1736 reloc_data
.got_offset_value
1737 = relocate_fix_got_relocs_for_got_info (list
,
1738 tls_type_for_reloc (howto
),
1749 create_got_dynrelocs_for_single_entry (
1750 got_entry_for_type (list
,
1751 arc_got_entry_type_for_reloc (howto
)),
1752 output_bfd
, info
, NULL
);
1757 #define IS_ARC_PCREL_TYPE(TYPE) \
1758 ( (TYPE == R_ARC_PC32) \
1759 || (TYPE == R_ARC_32_PCREL))
1766 case R_ARC_32_PCREL
:
1767 if (bfd_link_pic (info
)
1768 && (!IS_ARC_PCREL_TYPE (r_type
)
1772 && (!info
->symbolic
|| !h
->def_regular
))))
1774 Elf_Internal_Rela outrel
;
1776 bfd_boolean skip
= FALSE
;
1777 bfd_boolean relocate
= FALSE
;
1778 asection
*sreloc
= _bfd_elf_get_dynamic_reloc_section
1779 (input_bfd
, input_section
,
1782 BFD_ASSERT (sreloc
!= NULL
);
1784 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
1789 if (outrel
.r_offset
== (bfd_vma
) -1)
1792 outrel
.r_addend
= rel
->r_addend
;
1793 outrel
.r_offset
+= (input_section
->output_section
->vma
1794 + input_section
->output_offset
);
1798 memset (&outrel
, 0, sizeof outrel
);
1803 && (IS_ARC_PCREL_TYPE (r_type
)
1804 || !(bfd_link_executable (info
)
1805 || SYMBOLIC_BIND (info
, h
))
1806 || ! h
->def_regular
))
1808 BFD_ASSERT (h
!= NULL
);
1809 if ((input_section
->flags
& SEC_ALLOC
) != 0)
1814 BFD_ASSERT (h
->dynindx
!= -1);
1815 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
1819 /* Handle local symbols, they either do not have a
1820 global hash table entry (h == NULL), or are
1821 forced local due to a version script
1822 (h->forced_local), or the third condition is
1823 legacy, it appears to say something like, for
1824 links where we are pre-binding the symbols, or
1825 there's not an entry for this symbol in the
1826 dynamic symbol table, and it's a regular symbol
1827 not defined in a shared object, then treat the
1828 symbol as local, resolve it now. */
1830 /* outrel.r_addend = 0; */
1831 outrel
.r_info
= ELF32_R_INFO (0, R_ARC_RELATIVE
);
1834 BFD_ASSERT (sreloc
->contents
!= 0);
1836 loc
= sreloc
->contents
;
1837 loc
+= sreloc
->reloc_count
* sizeof (Elf32_External_Rela
);
1838 sreloc
->reloc_count
+= 1;
1840 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
1850 if (is_reloc_SDA_relative (howto
)
1851 && !reloc_data
.sdata_begin_symbol_vma_set
)
1854 ("error: linker symbol __SDATA_BEGIN__ not found");
1855 bfd_set_error (bfd_error_bad_value
);
1859 DEBUG_ARC_RELOC (reloc_data
);
1861 /* Make sure we have with a dynamic linker. In case of GOT and PLT
1862 the sym_section should point to .got or .plt respectively. */
1863 if ((is_reloc_for_GOT (howto
) || is_reloc_for_PLT (howto
))
1864 && reloc_data
.sym_section
== NULL
)
1867 (_("GOT and PLT relocations cannot be fixed with a non dynamic linker"));
1868 bfd_set_error (bfd_error_bad_value
);
1873 switch (arc_do_relocation (contents
, reloc_data
, info
))
1876 continue; /* The reloc processing loop. */
1878 case bfd_reloc_overflow
:
1879 (*info
->callbacks
->reloc_overflow
)
1880 (info
, (h
? &h
->root
: NULL
), reloc_data
.symbol_name
, howto
->name
, (bfd_vma
) 0,
1881 input_bfd
, input_section
, rel
->r_offset
);
1884 case bfd_reloc_undefined
:
1885 (*info
->callbacks
->undefined_symbol
)
1886 (info
, reloc_data
.symbol_name
, input_bfd
, input_section
, rel
->r_offset
, TRUE
);
1889 case bfd_reloc_other
:
1890 /* xgettext:c-format */
1891 msg
= _("%pB(%pA): warning: unaligned access to symbol '%s' in the small data area");
1894 case bfd_reloc_outofrange
:
1895 /* xgettext:c-format */
1896 msg
= _("%pB(%pA): internal error: out of range error");
1899 case bfd_reloc_notsupported
:
1900 /* xgettext:c-format */
1901 msg
= _("%pB(%pA): internal error: unsupported relocation error");
1904 case bfd_reloc_dangerous
:
1905 /* xgettext:c-format */
1906 msg
= _("%pB(%pA): internal error: dangerous relocation");
1910 /* xgettext:c-format */
1911 msg
= _("%pB(%pA): internal error: unknown error");
1916 _bfd_error_handler (msg
, input_bfd
, input_section
, reloc_data
.symbol_name
);
1923 #define elf_arc_hash_table(p) \
1924 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
1925 == ARC_ELF_DATA ? ((struct elf_arc_link_hash_table *) ((p)->hash)) : NULL)
1928 elf_arc_check_relocs (bfd
* abfd
,
1929 struct bfd_link_info
* info
,
1931 const Elf_Internal_Rela
* relocs
)
1933 Elf_Internal_Shdr
* symtab_hdr
;
1934 struct elf_link_hash_entry
** sym_hashes
;
1935 const Elf_Internal_Rela
* rel
;
1936 const Elf_Internal_Rela
* rel_end
;
1938 asection
* sreloc
= NULL
;
1939 struct elf_link_hash_table
* htab
= elf_hash_table (info
);
1941 if (bfd_link_relocatable (info
))
1944 if (htab
->dynobj
== NULL
)
1945 htab
->dynobj
= abfd
;
1947 dynobj
= (elf_hash_table (info
))->dynobj
;
1948 symtab_hdr
= &((elf_tdata (abfd
))->symtab_hdr
);
1949 sym_hashes
= elf_sym_hashes (abfd
);
1951 rel_end
= relocs
+ sec
->reloc_count
;
1952 for (rel
= relocs
; rel
< rel_end
; rel
++)
1954 enum elf_arc_reloc_type r_type
;
1955 reloc_howto_type
*howto
;
1956 unsigned long r_symndx
;
1957 struct elf_link_hash_entry
*h
;
1959 r_type
= ELF32_R_TYPE (rel
->r_info
);
1961 if (r_type
>= (int) R_ARC_max
)
1963 bfd_set_error (bfd_error_bad_value
);
1966 howto
= arc_elf_howto (r_type
);
1968 /* Load symbol information. */
1969 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1970 if (r_symndx
< symtab_hdr
->sh_info
) /* Is a local symbol. */
1972 else /* Global one. */
1973 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1979 /* During shared library creation, these relocs should not
1980 appear in a shared library (as memory will be read only
1981 and the dynamic linker can not resolve these. However
1982 the error should not occur for e.g. debugging or
1983 non-readonly sections. */
1985 && (bfd_link_dll (info
) && !bfd_link_pie (info
))
1986 && (sec
->flags
& SEC_ALLOC
) != 0
1987 && (sec
->flags
& SEC_READONLY
) != 0
1988 && ((sec
->flags
& SEC_CODE
) != 0
1989 || (sec
->flags
& SEC_DEBUGGING
) != 0))
1993 name
= h
->root
.root
.string
;
1995 /* bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL); */
1998 /* xgettext:c-format */
1999 (_("%pB: relocation %s against `%s' can not be used"
2000 " when making a shared object; recompile with -fPIC"),
2002 arc_elf_howto (r_type
)->name
,
2004 bfd_set_error (bfd_error_bad_value
);
2008 /* In some cases we are not setting the 'non_got_ref'
2009 flag, even though the relocations don't require a GOT
2010 access. We should extend the testing in this area to
2011 ensure that no significant cases are being missed. */
2016 case R_ARC_32_PCREL
:
2017 if ((bfd_link_pic (info
))
2018 && ((r_type
!= R_ARC_PC32
&& r_type
!= R_ARC_32_PCREL
)
2020 && (!info
->symbolic
|| !h
->def_regular
))))
2025 && ! htab
->dynamic_sections_created
2026 && ! _bfd_elf_link_create_dynamic_sections (abfd
, info
))
2028 sreloc
= _bfd_elf_make_dynamic_reloc_section (sec
, dynobj
,
2036 sreloc
->size
+= sizeof (Elf32_External_Rela
);
2043 if (is_reloc_for_PLT (howto
))
2051 /* Add info to the symbol got_entry_list. */
2052 if (is_reloc_for_GOT (howto
)
2053 || is_reloc_for_TLS (howto
))
2055 if (! _bfd_elf_create_got_section (dynobj
, info
))
2058 arc_fill_got_info_for_reloc (
2059 arc_got_entry_type_for_reloc (howto
),
2060 get_got_entry_list_for_symbol (abfd
, r_symndx
, h
),
2069 #define ELF_DYNAMIC_INTERPRETER "/sbin/ld-uClibc.so"
2071 static struct plt_version_t
*
2072 arc_get_plt_version (struct bfd_link_info
*info
)
2076 for (i
= 0; i
< 1; i
++)
2078 ARC_DEBUG ("%d: size1 = %d, size2 = %d\n", i
,
2079 (int) plt_versions
[i
].entry_size
,
2080 (int) plt_versions
[i
].elem_size
);
2083 if (bfd_get_mach (info
->output_bfd
) == bfd_mach_arc_arcv2
)
2085 if (bfd_link_pic (info
))
2086 return &(plt_versions
[ELF_ARCV2_PIC
]);
2088 return &(plt_versions
[ELF_ARCV2_ABS
]);
2092 if (bfd_link_pic (info
))
2093 return &(plt_versions
[ELF_ARC_PIC
]);
2095 return &(plt_versions
[ELF_ARC_ABS
]);
2100 add_symbol_to_plt (struct bfd_link_info
*info
)
2102 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2105 struct plt_version_t
*plt_data
= arc_get_plt_version (info
);
2107 /* If this is the first .plt entry, make room for the special first
2109 if (htab
->splt
->size
== 0)
2110 htab
->splt
->size
+= plt_data
->entry_size
;
2112 ret
= htab
->splt
->size
;
2114 htab
->splt
->size
+= plt_data
->elem_size
;
2115 ARC_DEBUG ("PLT_SIZE = %d\n", (int) htab
->splt
->size
);
2117 htab
->sgotplt
->size
+= 4;
2118 htab
->srelplt
->size
+= sizeof (Elf32_External_Rela
);
2123 #define PLT_DO_RELOCS_FOR_ENTRY(ABFD, DS, RELOCS) \
2124 plt_do_relocs_for_symbol (ABFD, DS, RELOCS, 0, 0)
2127 plt_do_relocs_for_symbol (bfd
*abfd
,
2128 struct elf_link_hash_table
*htab
,
2129 const struct plt_reloc
*reloc
,
2131 bfd_vma symbol_got_offset
)
2133 while (SYM_ONLY (reloc
->symbol
) != LAST_RELOC
)
2135 bfd_vma relocation
= 0;
2137 switch (SYM_ONLY (reloc
->symbol
))
2141 = htab
->sgotplt
->output_section
->vma
2142 + htab
->sgotplt
->output_offset
+ symbol_got_offset
;
2145 relocation
+= reloc
->addend
;
2147 if (IS_RELATIVE (reloc
->symbol
))
2149 bfd_vma reloc_offset
= reloc
->offset
;
2150 reloc_offset
-= (IS_INSN_32 (reloc
->symbol
)) ? 4 : 0;
2151 reloc_offset
-= (IS_INSN_24 (reloc
->symbol
)) ? 2 : 0;
2153 relocation
-= htab
->splt
->output_section
->vma
2154 + htab
->splt
->output_offset
2155 + plt_offset
+ reloc_offset
;
2158 /* TODO: being ME is not a property of the relocation but of the
2159 section of which is applying the relocation. */
2160 if (IS_MIDDLE_ENDIAN (reloc
->symbol
) && !bfd_big_endian (abfd
))
2163 = ((relocation
& 0xffff0000) >> 16)
2164 | ((relocation
& 0xffff) << 16);
2167 switch (reloc
->size
)
2170 bfd_put_32 (htab
->splt
->output_section
->owner
,
2172 htab
->splt
->contents
+ plt_offset
+ reloc
->offset
);
2176 reloc
= &(reloc
[1]); /* Jump to next relocation. */
2181 relocate_plt_for_symbol (bfd
*output_bfd
,
2182 struct bfd_link_info
*info
,
2183 struct elf_link_hash_entry
*h
)
2185 struct plt_version_t
*plt_data
= arc_get_plt_version (info
);
2186 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2188 bfd_vma plt_index
= (h
->plt
.offset
- plt_data
->entry_size
)
2189 / plt_data
->elem_size
;
2190 bfd_vma got_offset
= (plt_index
+ 3) * 4;
2192 ARC_DEBUG ("arc_info: PLT_OFFSET = %#lx, PLT_ENTRY_VMA = %#lx, \
2193 GOT_ENTRY_OFFSET = %#lx, GOT_ENTRY_VMA = %#lx, for symbol %s\n",
2194 (long) h
->plt
.offset
,
2195 (long) (htab
->splt
->output_section
->vma
2196 + htab
->splt
->output_offset
2199 (long) (htab
->sgotplt
->output_section
->vma
2200 + htab
->sgotplt
->output_offset
2202 h
->root
.root
.string
);
2206 uint16_t *ptr
= (uint16_t *) plt_data
->elem
;
2208 for (i
= 0; i
< plt_data
->elem_size
/2; i
++)
2210 uint16_t data
= ptr
[i
];
2211 bfd_put_16 (output_bfd
,
2213 htab
->splt
->contents
+ h
->plt
.offset
+ (i
*2));
2217 plt_do_relocs_for_symbol (output_bfd
, htab
,
2218 plt_data
->elem_relocs
,
2222 /* Fill in the entry in the global offset table. */
2223 bfd_put_32 (output_bfd
,
2224 (bfd_vma
) (htab
->splt
->output_section
->vma
2225 + htab
->splt
->output_offset
),
2226 htab
->sgotplt
->contents
+ got_offset
);
2228 /* TODO: Fill in the entry in the .rela.plt section. */
2230 Elf_Internal_Rela rel
;
2233 rel
.r_offset
= (htab
->sgotplt
->output_section
->vma
2234 + htab
->sgotplt
->output_offset
2238 BFD_ASSERT (h
->dynindx
!= -1);
2239 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARC_JMP_SLOT
);
2241 loc
= htab
->srelplt
->contents
;
2242 loc
+= plt_index
* sizeof (Elf32_External_Rela
); /* relA */
2243 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
2248 relocate_plt_for_entry (bfd
*abfd
,
2249 struct bfd_link_info
*info
)
2251 struct plt_version_t
*plt_data
= arc_get_plt_version (info
);
2252 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2256 uint16_t *ptr
= (uint16_t *) plt_data
->entry
;
2257 for (i
= 0; i
< plt_data
->entry_size
/2; i
++)
2259 uint16_t data
= ptr
[i
];
2262 htab
->splt
->contents
+ (i
*2));
2265 PLT_DO_RELOCS_FOR_ENTRY (abfd
, htab
, plt_data
->entry_relocs
);
2268 /* Desc : Adjust a symbol defined by a dynamic object and referenced
2269 by a regular object. The current definition is in some section of
2270 the dynamic object, but we're not including those sections. We
2271 have to change the definition to something the rest of the link can
2275 elf_arc_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2276 struct elf_link_hash_entry
*h
)
2279 bfd
*dynobj
= (elf_hash_table (info
))->dynobj
;
2280 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2282 if (h
->type
== STT_FUNC
2283 || h
->type
== STT_GNU_IFUNC
2284 || h
->needs_plt
== 1)
2286 if (!bfd_link_pic (info
) && !h
->def_dynamic
&& !h
->ref_dynamic
)
2288 /* This case can occur if we saw a PLT32 reloc in an input
2289 file, but the symbol was never referred to by a dynamic
2290 object. In such a case, we don't actually need to build
2291 a procedure linkage table, and we can just do a PC32
2293 BFD_ASSERT (h
->needs_plt
);
2297 /* Make sure this symbol is output as a dynamic symbol. */
2298 if (h
->dynindx
== -1 && !h
->forced_local
2299 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
2302 if (bfd_link_pic (info
)
2303 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2305 bfd_vma loc
= add_symbol_to_plt (info
);
2307 if (bfd_link_executable (info
) && !h
->def_regular
)
2309 h
->root
.u
.def
.section
= htab
->splt
;
2310 h
->root
.u
.def
.value
= loc
;
2312 h
->plt
.offset
= loc
;
2316 h
->plt
.offset
= (bfd_vma
) -1;
2322 /* If this is a weak symbol, and there is a real definition, the
2323 processor independent code will have arranged for us to see the
2324 real definition first, and we can just use the same value. */
2325 if (h
->is_weakalias
)
2327 struct elf_link_hash_entry
*def
= weakdef (h
);
2328 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
2329 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
2330 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
2334 /* This is a reference to a symbol defined by a dynamic object which
2335 is not a function. */
2337 /* If we are creating a shared library, we must presume that the
2338 only references to the symbol are via the global offset table.
2339 For such cases we need not do anything here; the relocations will
2340 be handled correctly by relocate_section. */
2341 if (!bfd_link_executable (info
))
2344 /* If there are no non-GOT references, we do not need a copy
2346 if (!h
->non_got_ref
)
2349 /* If -z nocopyreloc was given, we won't generate them either. */
2350 if (info
->nocopyreloc
)
2356 /* We must allocate the symbol in our .dynbss section, which will
2357 become part of the .bss section of the executable. There will be
2358 an entry for this symbol in the .dynsym section. The dynamic
2359 object will contain position independent code, so all references
2360 from the dynamic object to this symbol will go through the global
2361 offset table. The dynamic linker will use the .dynsym entry to
2362 determine the address it must put in the global offset table, so
2363 both the dynamic object and the regular object will refer to the
2364 same memory location for the variable. */
2369 /* We must generate a R_ARC_COPY reloc to tell the dynamic linker to
2370 copy the initial value out of the dynamic object and into the
2371 runtime process image. We need to remember the offset into the
2372 .rela.bss section we are going to use. */
2373 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
2375 struct elf_arc_link_hash_table
*arc_htab
= elf_arc_hash_table (info
);
2377 BFD_ASSERT (arc_htab
->elf
.srelbss
!= NULL
);
2378 arc_htab
->elf
.srelbss
->size
+= sizeof (Elf32_External_Rela
);
2382 /* TODO: Move this also to arc_hash_table. */
2383 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
2384 BFD_ASSERT (s
!= NULL
);
2386 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2389 /* Function : elf_arc_finish_dynamic_symbol
2390 Brief : Finish up dynamic symbol handling. We set the
2391 contents of various dynamic sections here.
2396 Returns : True/False as the return status. */
2399 elf_arc_finish_dynamic_symbol (bfd
* output_bfd
,
2400 struct bfd_link_info
*info
,
2401 struct elf_link_hash_entry
*h
,
2402 Elf_Internal_Sym
* sym
)
2404 if (h
->plt
.offset
!= (bfd_vma
) -1)
2406 relocate_plt_for_symbol (output_bfd
, info
, h
);
2408 if (!h
->def_regular
)
2410 /* Mark the symbol as undefined, rather than as defined in
2411 the .plt section. Leave the value alone. */
2412 sym
->st_shndx
= SHN_UNDEF
;
2417 /* This function traverses list of GOT entries and
2418 create respective dynamic relocs. */
2419 /* TODO: Make function to get list and not access the list directly. */
2420 /* TODO: Move function to relocate_section create this relocs eagerly. */
2421 create_got_dynrelocs_for_got_info (&h
->got
.glist
,
2428 struct elf_arc_link_hash_table
*arc_htab
= elf_arc_hash_table (info
);
2430 if (h
->dynindx
== -1
2431 || (h
->root
.type
!= bfd_link_hash_defined
2432 && h
->root
.type
!= bfd_link_hash_defweak
)
2433 || arc_htab
->elf
.srelbss
== NULL
)
2436 bfd_vma rel_offset
= (h
->root
.u
.def
.value
2437 + h
->root
.u
.def
.section
->output_section
->vma
2438 + h
->root
.u
.def
.section
->output_offset
);
2440 bfd_byte
* loc
= arc_htab
->elf
.srelbss
->contents
2441 + (arc_htab
->elf
.srelbss
->reloc_count
* sizeof (Elf32_External_Rela
));
2442 arc_htab
->elf
.srelbss
->reloc_count
++;
2444 Elf_Internal_Rela rel
;
2446 rel
.r_offset
= rel_offset
;
2448 BFD_ASSERT (h
->dynindx
!= -1);
2449 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARC_COPY
);
2451 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
2454 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2455 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2456 || strcmp (h
->root
.root
.string
, "__DYNAMIC") == 0
2457 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
2458 sym
->st_shndx
= SHN_ABS
;
2463 #define GET_SYMBOL_OR_SECTION(TAG, SYMBOL, SECTION) \
2465 if (SYMBOL != NULL) \
2466 h = elf_link_hash_lookup (elf_hash_table (info), \
2467 SYMBOL, FALSE, FALSE, TRUE); \
2468 else if (SECTION != NULL) \
2469 s = bfd_get_linker_section (dynobj, SECTION); \
2472 /* Function : elf_arc_finish_dynamic_sections
2473 Brief : Finish up the dynamic sections handling.
2478 Returns : True/False as the return status. */
2481 elf_arc_finish_dynamic_sections (bfd
* output_bfd
,
2482 struct bfd_link_info
*info
)
2484 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2485 bfd
*dynobj
= (elf_hash_table (info
))->dynobj
;
2486 asection
*sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
2490 Elf32_External_Dyn
*dyncon
, *dynconend
;
2492 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
2494 = (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
2495 for (; dyncon
< dynconend
; dyncon
++)
2497 Elf_Internal_Dyn internal_dyn
;
2498 bfd_boolean do_it
= FALSE
;
2500 struct elf_link_hash_entry
*h
= NULL
;
2503 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &internal_dyn
);
2505 switch (internal_dyn
.d_tag
)
2507 GET_SYMBOL_OR_SECTION (DT_INIT
, info
->init_function
, NULL
)
2508 GET_SYMBOL_OR_SECTION (DT_FINI
, info
->fini_function
, NULL
)
2509 GET_SYMBOL_OR_SECTION (DT_PLTGOT
, NULL
, ".plt")
2510 GET_SYMBOL_OR_SECTION (DT_JMPREL
, NULL
, ".rela.plt")
2511 GET_SYMBOL_OR_SECTION (DT_PLTRELSZ
, NULL
, ".rela.plt")
2512 GET_SYMBOL_OR_SECTION (DT_VERSYM
, NULL
, ".gnu.version")
2513 GET_SYMBOL_OR_SECTION (DT_VERDEF
, NULL
, ".gnu.version_d")
2514 GET_SYMBOL_OR_SECTION (DT_VERNEED
, NULL
, ".gnu.version_r")
2519 /* In case the dynamic symbols should be updated with a symbol. */
2521 && (h
->root
.type
== bfd_link_hash_defined
2522 || h
->root
.type
== bfd_link_hash_defweak
))
2526 internal_dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
2527 asec_ptr
= h
->root
.u
.def
.section
;
2528 if (asec_ptr
->output_section
!= NULL
)
2530 internal_dyn
.d_un
.d_val
+=
2531 (asec_ptr
->output_section
->vma
2532 + asec_ptr
->output_offset
);
2536 /* The symbol is imported from another shared
2537 library and does not apply to this one. */
2538 internal_dyn
.d_un
.d_val
= 0;
2542 else if (s
!= NULL
) /* With a section information. */
2544 switch (internal_dyn
.d_tag
)
2551 internal_dyn
.d_un
.d_ptr
= (s
->output_section
->vma
2552 + s
->output_offset
);
2557 internal_dyn
.d_un
.d_val
= s
->size
;
2567 bfd_elf32_swap_dyn_out (output_bfd
, &internal_dyn
, dyncon
);
2570 if (htab
->splt
->size
> 0)
2572 relocate_plt_for_entry (output_bfd
, info
);
2575 /* TODO: Validate this. */
2576 if (htab
->srelplt
->output_section
!= bfd_abs_section_ptr
)
2577 elf_section_data (htab
->srelplt
->output_section
)
2578 ->this_hdr
.sh_entsize
= 12;
2581 /* Fill in the first three entries in the global offset table. */
2584 struct elf_link_hash_entry
*h
;
2585 h
= elf_link_hash_lookup (elf_hash_table (info
), "_GLOBAL_OFFSET_TABLE_",
2586 FALSE
, FALSE
, TRUE
);
2588 if (h
!= NULL
&& h
->root
.type
!= bfd_link_hash_undefined
2589 && h
->root
.u
.def
.section
!= NULL
)
2591 asection
*sec
= h
->root
.u
.def
.section
;
2594 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
2597 bfd_put_32 (output_bfd
,
2598 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
2600 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sec
->contents
+ 4);
2601 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sec
->contents
+ 8);
2608 #define ADD_DYNAMIC_SYMBOL(NAME, TAG) \
2609 h = elf_link_hash_lookup (elf_hash_table (info), \
2610 NAME, FALSE, FALSE, FALSE); \
2611 if ((h != NULL && (h->ref_regular || h->def_regular))) \
2612 if (! _bfd_elf_add_dynamic_entry (info, TAG, 0)) \
2615 /* Set the sizes of the dynamic sections. */
2617 elf_arc_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
2618 struct bfd_link_info
*info
)
2622 bfd_boolean relocs_exist
= FALSE
;
2623 bfd_boolean reltext_exist
= FALSE
;
2624 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2626 dynobj
= htab
->dynobj
;
2627 BFD_ASSERT (dynobj
!= NULL
);
2629 if (htab
->dynamic_sections_created
)
2631 struct elf_link_hash_entry
*h
;
2633 /* Set the contents of the .interp section to the
2635 if (bfd_link_executable (info
) && !info
->nointerp
)
2637 s
= bfd_get_section_by_name (dynobj
, ".interp");
2638 BFD_ASSERT (s
!= NULL
);
2639 s
->size
= sizeof (ELF_DYNAMIC_INTERPRETER
);
2640 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2643 /* Add some entries to the .dynamic section. We fill in some of
2644 the values later, in elf_bfd_final_link, but we must add the
2645 entries now so that we know the final size of the .dynamic
2646 section. Checking if the .init section is present. We also
2647 create DT_INIT and DT_FINI entries if the init_str has been
2648 changed by the user. */
2649 ADD_DYNAMIC_SYMBOL (info
->init_function
, DT_INIT
);
2650 ADD_DYNAMIC_SYMBOL (info
->fini_function
, DT_FINI
);
2654 /* We may have created entries in the .rela.got section.
2655 However, if we are not creating the dynamic sections, we will
2656 not actually use these entries. Reset the size of .rela.got,
2657 which will cause it to get stripped from the output file
2659 if (htab
->srelgot
!= NULL
)
2660 htab
->srelgot
->size
= 0;
2663 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2665 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2670 || s
== htab
->sgotplt
2671 || s
== htab
->sdynbss
)
2673 /* Strip this section if we don't need it. */
2675 else if (strncmp (s
->name
, ".rela", 5) == 0)
2677 if (s
->size
!= 0 && s
!= htab
->srelplt
)
2681 const char *name
= s
->name
+ 5;
2683 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
2684 if (bfd_get_flavour (ibfd
) == bfd_target_elf_flavour
2685 && ibfd
->flags
& DYNAMIC
)
2687 asection
*target
= bfd_get_section_by_name (ibfd
, name
);
2689 && elf_section_data (target
)->sreloc
== s
2690 && ((target
->output_section
->flags
2691 & (SEC_READONLY
| SEC_ALLOC
))
2692 == (SEC_READONLY
| SEC_ALLOC
)))
2694 reltext_exist
= TRUE
;
2699 relocs_exist
= TRUE
;
2702 /* We use the reloc_count field as a counter if we need to
2703 copy relocs into the output file. */
2708 /* It's not one of our sections, so don't allocate space. */
2714 s
->flags
|= SEC_EXCLUDE
;
2718 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
2721 /* Allocate memory for the section contents. */
2722 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
2723 if (s
->contents
== NULL
)
2727 if (htab
->dynamic_sections_created
)
2729 /* TODO: Check if this is needed. */
2730 if (!bfd_link_pic (info
))
2731 if (!_bfd_elf_add_dynamic_entry (info
, DT_DEBUG
, 0))
2734 if (htab
->splt
&& (htab
->splt
->flags
& SEC_EXCLUDE
) == 0)
2735 if (!_bfd_elf_add_dynamic_entry (info
, DT_PLTGOT
, 0)
2736 || !_bfd_elf_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
2737 || !_bfd_elf_add_dynamic_entry (info
, DT_PLTREL
, DT_RELA
)
2738 || !_bfd_elf_add_dynamic_entry (info
, DT_JMPREL
, 0))
2742 if (!_bfd_elf_add_dynamic_entry (info
, DT_RELA
, 0)
2743 || !_bfd_elf_add_dynamic_entry (info
, DT_RELASZ
, 0)
2744 || !_bfd_elf_add_dynamic_entry (info
, DT_RELAENT
,
2745 sizeof (Elf32_External_Rela
)))
2749 if (!_bfd_elf_add_dynamic_entry (info
, DT_TEXTREL
, 0))
2757 /* Classify dynamic relocs such that -z combreloc can reorder and combine
2759 static enum elf_reloc_type_class
2760 elf32_arc_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2761 const asection
*rel_sec ATTRIBUTE_UNUSED
,
2762 const Elf_Internal_Rela
*rela
)
2764 switch ((int) ELF32_R_TYPE (rela
->r_info
))
2766 case R_ARC_RELATIVE
:
2767 return reloc_class_relative
;
2768 case R_ARC_JMP_SLOT
:
2769 return reloc_class_plt
;
2771 return reloc_class_copy
;
2772 /* TODO: Needed in future to support ifunc. */
2774 case R_ARC_IRELATIVE:
2775 return reloc_class_ifunc;
2778 return reloc_class_normal
;
2782 const struct elf_size_info arc_elf32_size_info
=
2784 sizeof (Elf32_External_Ehdr
),
2785 sizeof (Elf32_External_Phdr
),
2786 sizeof (Elf32_External_Shdr
),
2787 sizeof (Elf32_External_Rel
),
2788 sizeof (Elf32_External_Rela
),
2789 sizeof (Elf32_External_Sym
),
2790 sizeof (Elf32_External_Dyn
),
2791 sizeof (Elf_External_Note
),
2795 ELFCLASS32
, EV_CURRENT
,
2796 bfd_elf32_write_out_phdrs
,
2797 bfd_elf32_write_shdrs_and_ehdr
,
2798 bfd_elf32_checksum_contents
,
2799 bfd_elf32_write_relocs
,
2800 bfd_elf32_swap_symbol_in
,
2801 bfd_elf32_swap_symbol_out
,
2802 bfd_elf32_slurp_reloc_table
,
2803 bfd_elf32_slurp_symbol_table
,
2804 bfd_elf32_swap_dyn_in
,
2805 bfd_elf32_swap_dyn_out
,
2806 bfd_elf32_swap_reloc_in
,
2807 bfd_elf32_swap_reloc_out
,
2808 bfd_elf32_swap_reloca_in
,
2809 bfd_elf32_swap_reloca_out
2812 #define elf_backend_size_info arc_elf32_size_info
2814 /* GDB expects general purpose registers to be in section .reg. However Linux
2815 kernel doesn't create this section and instead writes registers to NOTE
2816 section. It is up to the binutils to create a pseudo-section .reg from the
2817 contents of NOTE. Also BFD will read pid and signal number from NOTE. This
2818 function relies on offsets inside elf_prstatus structure in Linux to be
2822 elf32_arc_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
2827 switch (note
->descsz
)
2832 case 236: /* sizeof (struct elf_prstatus) on Linux/arc. */
2834 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
2836 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
2839 size
= (40 * 4); /* There are 40 registers in user_regs_struct. */
2842 /* Make a ".reg/999" section. */
2843 return _bfd_elfcore_make_pseudosection (abfd
, ".reg", size
,
2844 note
->descpos
+ offset
);
2847 /* Determine whether an object attribute tag takes an integer, a
2851 elf32_arc_obj_attrs_arg_type (int tag
)
2853 if (tag
== Tag_ARC_CPU_name
2854 || tag
== Tag_ARC_ISA_config
2855 || tag
== Tag_ARC_ISA_apex
)
2856 return ATTR_TYPE_FLAG_STR_VAL
;
2857 else if (tag
< (Tag_ARC_ISA_mpy_option
+ 1))
2858 return ATTR_TYPE_FLAG_INT_VAL
;
2860 return (tag
& 1) != 0 ? ATTR_TYPE_FLAG_STR_VAL
: ATTR_TYPE_FLAG_INT_VAL
;
2863 /* Attribute numbers >=14 can be safely ignored. */
2866 elf32_arc_obj_attrs_handle_unknown (bfd
*abfd
, int tag
)
2868 if ((tag
& 127) < (Tag_ARC_ISA_mpy_option
+ 1))
2871 (_("%pB: unknown mandatory ARC object attribute %d"),
2873 bfd_set_error (bfd_error_bad_value
);
2879 (_("warning: %pB: unknown ARC object attribute %d"),
2885 /* Handle an ARC specific section when reading an object file. This is
2886 called when bfd_section_from_shdr finds a section with an unknown
2890 elf32_arc_section_from_shdr (bfd
*abfd
,
2891 Elf_Internal_Shdr
* hdr
,
2895 switch (hdr
->sh_type
)
2897 case SHT_ARC_ATTRIBUTES
:
2904 if (!_bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2910 #define TARGET_LITTLE_SYM arc_elf32_le_vec
2911 #define TARGET_LITTLE_NAME "elf32-littlearc"
2912 #define TARGET_BIG_SYM arc_elf32_be_vec
2913 #define TARGET_BIG_NAME "elf32-bigarc"
2914 #define ELF_ARCH bfd_arch_arc
2915 #define ELF_TARGET_ID ARC_ELF_DATA
2916 #define ELF_MACHINE_CODE EM_ARC_COMPACT
2917 #define ELF_MACHINE_ALT1 EM_ARC_COMPACT2
2918 #define ELF_MAXPAGESIZE 0x2000
2920 #define bfd_elf32_bfd_link_hash_table_create arc_elf_link_hash_table_create
2922 #define bfd_elf32_bfd_merge_private_bfd_data arc_elf_merge_private_bfd_data
2923 #define bfd_elf32_bfd_reloc_type_lookup arc_elf32_bfd_reloc_type_lookup
2924 #define bfd_elf32_bfd_set_private_flags arc_elf_set_private_flags
2925 #define bfd_elf32_bfd_print_private_bfd_data arc_elf_print_private_bfd_data
2926 #define bfd_elf32_bfd_copy_private_bfd_data arc_elf_copy_private_bfd_data
2928 #define elf_info_to_howto_rel arc_info_to_howto_rel
2929 #define elf_backend_object_p arc_elf_object_p
2930 #define elf_backend_final_write_processing arc_elf_final_write_processing
2932 #define elf_backend_relocate_section elf_arc_relocate_section
2933 #define elf_backend_check_relocs elf_arc_check_relocs
2934 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
2936 #define elf_backend_reloc_type_class elf32_arc_reloc_type_class
2938 #define elf_backend_adjust_dynamic_symbol elf_arc_adjust_dynamic_symbol
2939 #define elf_backend_finish_dynamic_symbol elf_arc_finish_dynamic_symbol
2941 #define elf_backend_finish_dynamic_sections elf_arc_finish_dynamic_sections
2942 #define elf_backend_size_dynamic_sections elf_arc_size_dynamic_sections
2944 #define elf_backend_can_gc_sections 1
2945 #define elf_backend_want_got_plt 1
2946 #define elf_backend_plt_readonly 1
2947 #define elf_backend_rela_plts_and_copies_p 1
2948 #define elf_backend_want_plt_sym 0
2949 #define elf_backend_got_header_size 12
2950 #define elf_backend_dtrel_excludes_plt 1
2952 #define elf_backend_may_use_rel_p 0
2953 #define elf_backend_may_use_rela_p 1
2954 #define elf_backend_default_use_rela_p 1
2956 #define elf_backend_grok_prstatus elf32_arc_grok_prstatus
2958 #define elf_backend_default_execstack 0
2960 #undef elf_backend_obj_attrs_vendor
2961 #define elf_backend_obj_attrs_vendor "ARC"
2962 #undef elf_backend_obj_attrs_section
2963 #define elf_backend_obj_attrs_section ".ARC.attributes"
2964 #undef elf_backend_obj_attrs_arg_type
2965 #define elf_backend_obj_attrs_arg_type elf32_arc_obj_attrs_arg_type
2966 #undef elf_backend_obj_attrs_section_type
2967 #define elf_backend_obj_attrs_section_type SHT_ARC_ATTRIBUTES
2968 #define elf_backend_obj_attrs_handle_unknown elf32_arc_obj_attrs_handle_unknown
2970 #define elf_backend_section_from_shdr elf32_arc_section_from_shdr
2972 #include "elf32-target.h"