1 /* ARC-specific support for 32-bit ELF
2 Copyright (C) 1994-2019 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); \
74 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
79 static ATTRIBUTE_UNUSED
const char *
80 reloc_type_to_name (unsigned int type
)
84 #include "elf/arc-reloc.def"
92 #undef ARC_RELOC_HOWTO
94 /* Try to minimize the amount of space occupied by relocation tables
95 on the ROM (not that the ROM won't be swamped by other ELF overhead). */
99 static ATTRIBUTE_UNUSED bfd_boolean
100 is_reloc_PC_relative (reloc_howto_type
*howto
)
102 return (strstr (howto
->name
, "PC") != NULL
) ? TRUE
: FALSE
;
106 is_reloc_SDA_relative (reloc_howto_type
*howto
)
108 return (strstr (howto
->name
, "SDA") != NULL
) ? TRUE
: FALSE
;
112 is_reloc_for_GOT (reloc_howto_type
* howto
)
114 if (strstr (howto
->name
, "TLS") != NULL
)
116 return (strstr (howto
->name
, "GOT") != NULL
) ? TRUE
: FALSE
;
120 is_reloc_for_PLT (reloc_howto_type
* howto
)
122 return (strstr (howto
->name
, "PLT") != NULL
) ? TRUE
: FALSE
;
126 is_reloc_for_TLS (reloc_howto_type
*howto
)
128 return (strstr (howto
->name
, "TLS") != NULL
) ? TRUE
: FALSE
;
131 struct arc_relocation_data
133 bfd_signed_vma reloc_offset
;
134 bfd_signed_vma reloc_addend
;
135 bfd_signed_vma got_offset_value
;
137 bfd_signed_vma sym_value
;
138 asection
* sym_section
;
140 reloc_howto_type
*howto
;
142 asection
* input_section
;
144 bfd_signed_vma sdata_begin_symbol_vma
;
145 bfd_boolean sdata_begin_symbol_vma_set
;
146 bfd_signed_vma got_symbol_vma
;
148 bfd_boolean should_relocate
;
150 const char * symbol_name
;
153 /* ARC ELF linker hash entry. */
154 struct elf_arc_link_hash_entry
156 struct elf_link_hash_entry root
;
158 /* Track dynamic relocs copied for this symbol. */
159 struct elf_dyn_relocs
*dyn_relocs
;
161 struct got_entry
*got_ents
;
165 /* Should be included at this location due to static declarations
166 defined before this point. */
169 #define arc_bfd_get_8(A,B,C) bfd_get_8(A,B)
170 #define arc_bfd_get_16(A,B,C) bfd_get_16(A,B)
171 #define arc_bfd_get_32(A,B,C) bfd_get_32(A,B)
172 #define arc_bfd_put_8(A,B,C,D) bfd_put_8(A,B,C)
173 #define arc_bfd_put_16(A,B,C,D) bfd_put_16(A,B,C)
174 #define arc_bfd_put_32(A,B,C,D) bfd_put_32(A,B,C)
177 static bfd_reloc_status_type
178 arc_elf_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
179 arelent
*reloc_entry
,
181 void *data ATTRIBUTE_UNUSED
,
182 asection
*input_section
,
184 char ** error_message ATTRIBUTE_UNUSED
)
186 if (output_bfd
!= NULL
)
188 reloc_entry
->address
+= input_section
->output_offset
;
190 /* In case of relocateable link and if the reloc is against a
191 section symbol, the addend needs to be adjusted according to
192 where the section symbol winds up in the output section. */
193 if ((symbol_in
->flags
& BSF_SECTION_SYM
) && symbol_in
->section
)
194 reloc_entry
->addend
+= symbol_in
->section
->output_offset
;
199 return bfd_reloc_continue
;
203 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
208 #include "elf/arc-reloc.def"
212 #undef ARC_RELOC_HOWTO
214 #define ARC_RELOC_HOWTO(TYPE, VALUE, RSIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
215 [TYPE] = HOWTO (R_##TYPE, 0, RSIZE, BITSIZE, FALSE, 0, \
216 complain_overflow_##OVERFLOW, arc_elf_reloc, \
217 "R_" #TYPE, FALSE, 0, 0, FALSE),
219 static struct reloc_howto_struct elf_arc_howto_table
[] =
221 #include "elf/arc-reloc.def"
222 /* Example of what is generated by the preprocessor. Currently kept as an
224 HOWTO (R_ARC_NONE, // Type.
226 2, // Size (0 = byte, 1 = short, 2 = long).
228 FALSE, // PC_relative.
230 complain_overflow_bitfield, // Complain_on_overflow.
231 bfd_elf_generic_reloc, // Special_function.
232 "R_ARC_NONE", // Name.
233 TRUE, // Partial_inplace.
236 FALSE), // PCrel_offset.
239 #undef ARC_RELOC_HOWTO
242 arc_elf_howto_init (void)
244 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
245 elf_arc_howto_table[TYPE].pc_relative = \
246 (strstr (#FORMULA, " P ") != NULL || strstr (#FORMULA, " PDATA ") != NULL); \
247 elf_arc_howto_table[TYPE].dst_mask = RELOC_FUNCTION(0, ~0); \
248 /* Only 32 bit data relocations should be marked as ME. */ \
249 if (strstr (#FORMULA, " ME ") != NULL) \
251 BFD_ASSERT (SIZE == 2); \
254 #include "elf/arc-reloc.def"
257 #undef ARC_RELOC_HOWTO
260 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
263 const int howto_table_lookup
[] =
265 #include "elf/arc-reloc.def"
268 #undef ARC_RELOC_HOWTO
270 static reloc_howto_type
*
271 arc_elf_howto (unsigned int r_type
)
273 if (elf_arc_howto_table
[R_ARC_32
].dst_mask
== 0)
274 arc_elf_howto_init ();
275 return &elf_arc_howto_table
[r_type
];
278 /* Map BFD reloc types to ARC ELF reloc types. */
282 bfd_reloc_code_real_type bfd_reloc_val
;
283 unsigned char elf_reloc_val
;
286 /* ARC ELF linker hash table. */
287 struct elf_arc_link_hash_table
289 struct elf_link_hash_table elf
;
292 static struct bfd_hash_entry
*
293 elf_arc_link_hash_newfunc (struct bfd_hash_entry
*entry
,
294 struct bfd_hash_table
*table
,
297 struct elf_arc_link_hash_entry
* ret
=
298 (struct elf_arc_link_hash_entry
*) entry
;
300 /* Allocate the structure if it has not already been allocated by a
303 ret
= (struct elf_arc_link_hash_entry
*)
304 bfd_hash_allocate (table
, sizeof (struct elf_arc_link_hash_entry
));
306 return (struct bfd_hash_entry
*) ret
;
308 /* Call the allocation method of the superclass. */
309 ret
= ((struct elf_arc_link_hash_entry
*)
310 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
314 ret
->dyn_relocs
= NULL
;
315 ret
->got_ents
= NULL
;
318 return (struct bfd_hash_entry
*) ret
;
321 /* Destroy an ARC ELF linker hash table. */
323 elf_arc_link_hash_table_free (bfd
*obfd
)
325 _bfd_elf_link_hash_table_free (obfd
);
328 /* Create an ARC ELF linker hash table. */
330 static struct bfd_link_hash_table
*
331 arc_elf_link_hash_table_create (bfd
*abfd
)
333 struct elf_arc_link_hash_table
*ret
;
335 ret
= (struct elf_arc_link_hash_table
*) bfd_zmalloc (sizeof (*ret
));
339 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
340 elf_arc_link_hash_newfunc
,
341 sizeof (struct elf_arc_link_hash_entry
),
348 ret
->elf
.root
.hash_table_free
= elf_arc_link_hash_table_free
;
350 return &ret
->elf
.root
;
353 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
354 { BFD_RELOC_##TYPE, R_##TYPE },
356 static const struct arc_reloc_map arc_reloc_map
[] =
358 #include "elf/arc-reloc.def"
360 {BFD_RELOC_NONE
, R_ARC_NONE
},
361 {BFD_RELOC_8
, R_ARC_8
},
362 {BFD_RELOC_16
, R_ARC_16
},
363 {BFD_RELOC_24
, R_ARC_24
},
364 {BFD_RELOC_32
, R_ARC_32
},
367 #undef ARC_RELOC_HOWTO
369 typedef ATTRIBUTE_UNUSED
bfd_vma (*replace_func
) (unsigned, int ATTRIBUTE_UNUSED
);
371 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
373 func = (void *) RELOC_FUNCTION; \
377 get_replace_function (bfd
*abfd
, unsigned int r_type
)
383 #include "elf/arc-reloc.def"
386 if (func
== replace_bits24
&& bfd_big_endian (abfd
))
387 func
= replace_bits24_be
;
389 return (replace_func
) func
;
391 #undef ARC_RELOC_HOWTO
393 static reloc_howto_type
*
394 arc_elf32_bfd_reloc_type_lookup (bfd
* abfd ATTRIBUTE_UNUSED
,
395 bfd_reloc_code_real_type code
)
399 for (i
= ARRAY_SIZE (arc_reloc_map
); i
--;)
401 if (arc_reloc_map
[i
].bfd_reloc_val
== code
)
402 return arc_elf_howto (arc_reloc_map
[i
].elf_reloc_val
);
408 /* Function to set the ELF flag bits. */
410 arc_elf_set_private_flags (bfd
*abfd
, flagword flags
)
412 elf_elfheader (abfd
)->e_flags
= flags
;
413 elf_flags_init (abfd
) = TRUE
;
417 /* Print private flags. */
419 arc_elf_print_private_bfd_data (bfd
*abfd
, void * ptr
)
421 FILE *file
= (FILE *) ptr
;
424 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
426 /* Print normal ELF private data. */
427 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
429 flags
= elf_elfheader (abfd
)->e_flags
;
430 fprintf (file
, _("private flags = 0x%lx:"), (unsigned long) flags
);
432 switch (flags
& EF_ARC_MACH_MSK
)
434 case EF_ARC_CPU_ARCV2HS
: fprintf (file
, " -mcpu=ARCv2HS"); break;
435 case EF_ARC_CPU_ARCV2EM
: fprintf (file
, " -mcpu=ARCv2EM"); break;
436 case E_ARC_MACH_ARC600
: fprintf (file
, " -mcpu=ARC600"); break;
437 case E_ARC_MACH_ARC601
: fprintf (file
, " -mcpu=ARC601"); break;
438 case E_ARC_MACH_ARC700
: fprintf (file
, " -mcpu=ARC700"); break;
440 fprintf (file
, "-mcpu=unknown");
444 switch (flags
& EF_ARC_OSABI_MSK
)
446 case E_ARC_OSABI_ORIG
: fprintf (file
, " (ABI:legacy)"); break;
447 case E_ARC_OSABI_V2
: fprintf (file
, " (ABI:v2)"); break;
448 case E_ARC_OSABI_V3
: fprintf (file
, " (ABI:v3)"); break;
449 case E_ARC_OSABI_V4
: fprintf (file
, " (ABI:v4)"); break;
451 fprintf (file
, " (ABI:unknown)");
459 /* Copy backend specific data from one object module to another. */
462 arc_elf_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
464 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
465 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
468 BFD_ASSERT (!elf_flags_init (obfd
)
469 || elf_elfheader (obfd
)->e_flags
== elf_elfheader (ibfd
)->e_flags
);
471 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
472 elf_flags_init (obfd
) = TRUE
;
474 /* Copy object attributes. */
475 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
477 return _bfd_elf_copy_private_bfd_data (ibfd
, obfd
);
480 static reloc_howto_type
*
481 bfd_elf32_bfd_reloc_name_lookup (bfd
* abfd ATTRIBUTE_UNUSED
,
486 for (i
= 0; i
< ARRAY_SIZE (elf_arc_howto_table
); i
++)
487 if (elf_arc_howto_table
[i
].name
!= NULL
488 && strcasecmp (elf_arc_howto_table
[i
].name
, r_name
) == 0)
489 return arc_elf_howto (i
);
494 /* Set the howto pointer for an ARC ELF reloc. */
497 arc_info_to_howto_rel (bfd
* abfd
,
499 Elf_Internal_Rela
* dst
)
503 r_type
= ELF32_R_TYPE (dst
->r_info
);
504 if (r_type
>= (unsigned int) R_ARC_max
)
506 /* xgettext:c-format */
507 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
509 bfd_set_error (bfd_error_bad_value
);
513 cache_ptr
->howto
= arc_elf_howto (r_type
);
517 /* Extract CPU features from an NTBS. */
520 arc_extract_features (const char *p
)
527 for (i
= 0; i
< ARRAY_SIZE (bfd_feature_list
); i
++)
529 char *t
= strstr (p
, bfd_feature_list
[i
].attr
);
530 unsigned l
= strlen (bfd_feature_list
[i
].attr
);
534 r
|= bfd_feature_list
[i
].feature
;
540 /* Concatenate two strings. s1 can be NULL but not
544 arc_stralloc (char * s1
, const char * s2
)
548 /* Only s1 can be null. */
551 p
= s1
? concat (s1
, ",", s2
, NULL
) : (char *)s2
;
556 /* Merge ARC object attributes from IBFD into OBFD. Raise an error if
557 there are conflicting attributes. */
560 arc_elf_merge_attributes (bfd
*ibfd
, struct bfd_link_info
*info
)
562 bfd
*obfd
= info
->output_bfd
;
563 obj_attribute
*in_attr
;
564 obj_attribute
*out_attr
;
566 bfd_boolean result
= TRUE
;
567 const char *sec_name
= get_elf_backend_data (ibfd
)->obj_attrs_section
;
568 char *tagname
= NULL
;
570 /* Skip the linker stubs file. This preserves previous behavior
571 of accepting unknown attributes in the first input file - but
573 if (ibfd
->flags
& BFD_LINKER_CREATED
)
576 /* Skip any input that hasn't attribute section.
577 This enables to link object files without attribute section with
579 if (bfd_get_section_by_name (ibfd
, sec_name
) == NULL
)
582 if (!elf_known_obj_attributes_proc (obfd
)[0].i
)
584 /* This is the first object. Copy the attributes. */
585 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
587 out_attr
= elf_known_obj_attributes_proc (obfd
);
589 /* Use the Tag_null value to indicate the attributes have been
596 in_attr
= elf_known_obj_attributes_proc (ibfd
);
597 out_attr
= elf_known_obj_attributes_proc (obfd
);
599 for (i
= LEAST_KNOWN_OBJ_ATTRIBUTE
; i
< NUM_KNOWN_OBJ_ATTRIBUTES
; i
++)
601 /* Merge this attribute with existing attributes. */
604 case Tag_ARC_PCS_config
:
605 if (out_attr
[i
].i
== 0)
606 out_attr
[i
].i
= in_attr
[i
].i
;
607 else if (in_attr
[i
].i
!= 0 && out_attr
[i
].i
!= in_attr
[i
].i
)
609 const char *tagval
[] = { "Absent", "Bare-metal/mwdt",
610 "Bare-metal/newlib", "Linux/uclibc",
612 BFD_ASSERT (in_attr
[i
].i
< 5);
613 BFD_ASSERT (out_attr
[i
].i
< 5);
614 /* It's sometimes ok to mix different configs, so this is only
617 (_("warning: %pB: conflicting platform configuration "
619 tagval
[in_attr
[i
].i
],
620 tagval
[out_attr
[i
].i
]);
624 case Tag_ARC_CPU_base
:
625 if (out_attr
[i
].i
== 0)
626 out_attr
[i
].i
= in_attr
[i
].i
;
627 else if (in_attr
[i
].i
!= 0 && out_attr
[i
].i
!= in_attr
[i
].i
628 && ((out_attr
[i
].i
+ in_attr
[i
].i
) < 6))
630 const char *tagval
[] = { "Absent", "ARC6xx", "ARC7xx",
632 BFD_ASSERT (in_attr
[i
].i
< 5);
633 BFD_ASSERT (out_attr
[i
].i
< 5);
634 /* We cannot mix code for different CPUs. */
636 (_("error: %pB: unable to merge CPU base attributes "
639 tagval
[in_attr
[i
].i
],
640 tagval
[out_attr
[i
].i
]);
646 /* The CPUs may be different, check if we can still mix
647 the objects against the output choosen CPU. */
648 unsigned in_feature
= 0;
649 unsigned out_feature
= 0;
650 char *p1
= in_attr
[Tag_ARC_ISA_config
].s
;
651 char *p2
= out_attr
[Tag_ARC_ISA_config
].s
;
654 unsigned opcode_map
[] = {0, ARC_OPCODE_ARC600
, ARC_OPCODE_ARC700
,
655 ARC_OPCODE_ARCv2EM
, ARC_OPCODE_ARCv2HS
};
657 BFD_ASSERT (in_attr
[i
].i
< (sizeof (opcode_map
)
658 / sizeof (unsigned)));
659 BFD_ASSERT (out_attr
[i
].i
< (sizeof (opcode_map
)
660 / sizeof (unsigned)));
661 cpu_out
= opcode_map
[out_attr
[i
].i
];
663 in_feature
= arc_extract_features (p1
);
664 out_feature
= arc_extract_features (p2
);
666 /* First, check if a feature is compatible with the
667 output object chosen CPU. */
668 for (j
= 0; j
< ARRAY_SIZE (bfd_feature_list
); j
++)
669 if (((in_feature
| out_feature
) & bfd_feature_list
[j
].feature
)
670 && (!(cpu_out
& bfd_feature_list
[j
].cpus
)))
673 (_("error: %pB: unable to merge ISA extension attributes "
675 obfd
, bfd_feature_list
[j
].name
);
679 /* Second, if we have compatible features with the
680 chosen CPU, check if they are compatible among
682 for (j
= 0; j
< ARRAY_SIZE (bfd_conflict_list
); j
++)
683 if (((in_feature
| out_feature
) & bfd_conflict_list
[j
])
684 == bfd_conflict_list
[j
])
687 for (k
= 0; k
< ARRAY_SIZE (bfd_feature_list
); k
++)
689 if (in_feature
& bfd_feature_list
[k
].feature
690 & bfd_conflict_list
[j
])
691 p1
= (char *) bfd_feature_list
[k
].name
;
692 if (out_feature
& bfd_feature_list
[k
].feature
693 & bfd_conflict_list
[j
])
694 p2
= (char *) bfd_feature_list
[k
].name
;
697 (_("error: %pB: conflicting ISA extension attributes "
703 /* Everithing is alright. */
704 out_feature
|= in_feature
;
706 for (j
= 0; j
< ARRAY_SIZE (bfd_feature_list
); j
++)
707 if (out_feature
& bfd_feature_list
[j
].feature
)
708 p1
= arc_stralloc (p1
, bfd_feature_list
[j
].attr
);
710 out_attr
[Tag_ARC_ISA_config
].s
=
711 _bfd_elf_attr_strdup (obfd
, p1
);
714 case Tag_ARC_CPU_variation
:
715 case Tag_ARC_ISA_mpy_option
:
716 case Tag_ARC_ABI_osver
:
717 /* Use the largest value specified. */
718 if (in_attr
[i
].i
> out_attr
[i
].i
)
719 out_attr
[i
].i
= in_attr
[i
].i
;
722 /* The CPU name is given by the vendor, just choose an
723 existing one if missing or different. There are no fail
724 criteria if they different or both missing. */
725 case Tag_ARC_CPU_name
:
726 if (!out_attr
[i
].s
&& in_attr
[i
].s
)
727 out_attr
[i
].s
= _bfd_elf_attr_strdup (obfd
, in_attr
[i
].s
);
730 case Tag_ARC_ABI_rf16
:
731 if (out_attr
[i
].i
== 0)
732 out_attr
[i
].i
= in_attr
[i
].i
;
733 else if (out_attr
[i
].i
!= in_attr
[i
].i
)
735 /* We cannot mix code with rf16 and without. */
737 (_("error: %pB: cannot mix rf16 with full register set %pB"),
743 case Tag_ARC_ABI_pic
:
746 case Tag_ARC_ABI_sda
:
750 case Tag_ARC_ABI_tls
:
752 const char *tagval
[] = { "Absent", "MWDT", "GNU" };
757 BFD_ASSERT (in_attr
[i
].i
< 3);
758 BFD_ASSERT (out_attr
[i
].i
< 3);
759 if (out_attr
[i
].i
== 0)
760 out_attr
[i
].i
= in_attr
[i
].i
;
761 else if (out_attr
[i
].i
!= 0 && in_attr
[i
].i
!= 0
762 && out_attr
[i
].i
!= in_attr
[i
].i
)
765 (_("error: %pB: conflicting attributes %s: %s with %s"),
767 tagval
[in_attr
[i
].i
],
768 tagval
[out_attr
[i
].i
]);
775 case Tag_ARC_ABI_double_size
:
776 tagname
= "Double size";
778 case Tag_ARC_ABI_enumsize
:
780 tagname
= "Enum size";
782 case Tag_ARC_ABI_exceptions
:
784 tagname
= "ABI exceptions";
786 if (out_attr
[i
].i
== 0)
787 out_attr
[i
].i
= in_attr
[i
].i
;
788 else if (out_attr
[i
].i
!= 0 && in_attr
[i
].i
!= 0
789 && out_attr
[i
].i
!= in_attr
[i
].i
)
792 (_("error: %pB: conflicting attributes %s"),
798 case Tag_ARC_ISA_apex
:
799 break; /* Do nothing for APEX attributes. */
801 case Tag_ARC_ISA_config
:
802 /* It is handled in Tag_ARC_CPU_base. */
805 case Tag_ARC_ATR_version
:
806 if (out_attr
[i
].i
== 0)
807 out_attr
[i
].i
= in_attr
[i
].i
;
812 = result
&& _bfd_elf_merge_unknown_attribute_low (ibfd
, obfd
, i
);
815 /* If out_attr was copied from in_attr then it won't have a type yet. */
816 if (in_attr
[i
].type
&& !out_attr
[i
].type
)
817 out_attr
[i
].type
= in_attr
[i
].type
;
820 /* Merge Tag_compatibility attributes and any common GNU ones. */
821 if (!_bfd_elf_merge_object_attributes (ibfd
, info
))
824 /* Check for any attributes not known on ARC. */
825 result
&= _bfd_elf_merge_unknown_attribute_list (ibfd
, obfd
);
830 /* Merge backend specific data from an object file to the output
831 object file when linking. */
834 arc_elf_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
836 bfd
*obfd
= info
->output_bfd
;
837 unsigned short mach_ibfd
;
838 static unsigned short mach_obfd
= EM_NONE
;
843 /* Check if we have the same endianess. */
844 if (! _bfd_generic_verify_endian_match (ibfd
, info
))
847 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
848 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
851 /* Collect ELF flags. */
852 in_flags
= elf_elfheader (ibfd
)->e_flags
& EF_ARC_MACH_MSK
;
853 out_flags
= elf_elfheader (obfd
)->e_flags
& EF_ARC_MACH_MSK
;
855 if (!elf_flags_init (obfd
)) /* First call, no flags set. */
857 elf_flags_init (obfd
) = TRUE
;
858 out_flags
= in_flags
;
861 if (!arc_elf_merge_attributes (ibfd
, info
))
864 /* Check to see if the input BFD actually contains any sections. Do
865 not short-circuit dynamic objects; their section list may be
866 emptied by elf_link_add_object_symbols. */
867 if (!(ibfd
->flags
& DYNAMIC
))
869 bfd_boolean null_input_bfd
= TRUE
;
870 bfd_boolean only_data_sections
= TRUE
;
872 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
874 if ((bfd_get_section_flags (ibfd
, sec
)
875 & (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
876 == (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
877 only_data_sections
= FALSE
;
879 null_input_bfd
= FALSE
;
882 if (null_input_bfd
|| only_data_sections
)
886 /* Complain about various flag/architecture mismatches. */
887 mach_ibfd
= elf_elfheader (ibfd
)->e_machine
;
888 if (mach_obfd
== EM_NONE
)
890 mach_obfd
= mach_ibfd
;
894 if (mach_ibfd
!= mach_obfd
)
896 /* xgettext:c-format */
897 _bfd_error_handler (_("error: attempting to link %pB "
898 "with a binary %pB of different architecture"),
902 else if ((in_flags
!= out_flags
)
903 /* If we have object attributes, then we already
904 checked the objects compatibility, skip it. */
905 && !bfd_elf_get_obj_attr_int (ibfd
, OBJ_ATTR_PROC
,
908 if (in_flags
&& out_flags
)
910 /* Warn if different flags. */
912 /* xgettext:c-format */
913 (_("%pB: uses different e_flags (%#x) fields than "
914 "previous modules (%#x)"),
915 ibfd
, in_flags
, out_flags
);
918 /* MWDT doesnt set the eflags hence make sure we choose the
919 eflags set by gcc. */
920 in_flags
= in_flags
> out_flags
? in_flags
: out_flags
;
924 /* Everything is correct; don't change the output flags. */
925 in_flags
= out_flags
;
929 /* Update the flags. */
930 elf_elfheader (obfd
)->e_flags
= in_flags
;
932 if (bfd_get_mach (obfd
) < bfd_get_mach (ibfd
))
934 return bfd_set_arch_mach (obfd
, bfd_arch_arc
, bfd_get_mach (ibfd
));
940 /* Return a best guess for the machine number based on the attributes. */
943 bfd_arc_get_mach_from_attributes (bfd
* abfd
)
945 int arch
= bfd_elf_get_obj_attr_int (abfd
, OBJ_ATTR_PROC
, Tag_ARC_CPU_base
);
946 unsigned e_machine
= elf_elfheader (abfd
)->e_machine
;
951 return bfd_mach_arc_arc600
;
953 return bfd_mach_arc_arc700
;
956 return bfd_mach_arc_arcv2
;
960 return (e_machine
== EM_ARC_COMPACT
)
961 ? bfd_mach_arc_arc700
: bfd_mach_arc_arcv2
;
964 /* Set the right machine number for an ARC ELF file. */
966 arc_elf_object_p (bfd
* abfd
)
968 /* Make sure this is initialised, or you'll have the potential of passing
969 garbage---or misleading values---into the call to
970 bfd_default_set_arch_mach (). */
971 unsigned int mach
= bfd_mach_arc_arc700
;
972 unsigned long arch
= elf_elfheader (abfd
)->e_flags
& EF_ARC_MACH_MSK
;
973 unsigned e_machine
= elf_elfheader (abfd
)->e_machine
;
975 if (e_machine
== EM_ARC_COMPACT
|| e_machine
== EM_ARC_COMPACT2
)
979 case E_ARC_MACH_ARC600
:
980 mach
= bfd_mach_arc_arc600
;
982 case E_ARC_MACH_ARC601
:
983 mach
= bfd_mach_arc_arc601
;
985 case E_ARC_MACH_ARC700
:
986 mach
= bfd_mach_arc_arc700
;
988 case EF_ARC_CPU_ARCV2HS
:
989 case EF_ARC_CPU_ARCV2EM
:
990 mach
= bfd_mach_arc_arcv2
;
993 mach
= bfd_arc_get_mach_from_attributes (abfd
);
999 if (e_machine
== EM_ARC
)
1002 (_("error: the ARC4 architecture is no longer supported"));
1008 (_("warning: unset or old architecture flags; "
1009 "use default machine"));
1013 return bfd_default_set_arch_mach (abfd
, bfd_arch_arc
, mach
);
1016 /* The final processing done just before writing out an ARC ELF object file.
1017 This gets the ARC architecture right based on the machine number. */
1020 arc_elf_final_write_processing (bfd
*abfd
)
1023 int osver
= bfd_elf_get_obj_attr_int (abfd
, OBJ_ATTR_PROC
,
1025 flagword e_flags
= elf_elfheader (abfd
)->e_flags
& ~EF_ARC_OSABI_MSK
;
1027 switch (bfd_get_mach (abfd
))
1029 case bfd_mach_arc_arcv2
:
1030 emf
= EM_ARC_COMPACT2
;
1033 emf
= EM_ARC_COMPACT
;
1037 elf_elfheader (abfd
)->e_machine
= emf
;
1039 /* Record whatever is the current syscall ABI version. */
1041 e_flags
|= ((osver
& 0x0f) << 8);
1043 e_flags
|= E_ARC_OSABI_V3
;
1045 elf_elfheader (abfd
)->e_flags
|= e_flags
;
1046 return _bfd_elf_final_write_processing (abfd
);
1049 #ifdef ARC_ENABLE_DEBUG
1050 #define DEBUG_ARC_RELOC(A) debug_arc_reloc (A)
1053 debug_arc_reloc (struct arc_relocation_data reloc_data
)
1055 ARC_DEBUG ("Reloc type=%s, should_relocate = %s\n",
1056 reloc_data
.howto
->name
,
1057 reloc_data
.should_relocate
? "true" : "false");
1058 ARC_DEBUG (" offset = 0x%x, addend = 0x%x\n",
1059 (unsigned int) reloc_data
.reloc_offset
,
1060 (unsigned int) reloc_data
.reloc_addend
);
1061 ARC_DEBUG (" Symbol:\n");
1062 ARC_DEBUG (" value = 0x%08x\n",
1063 (unsigned int) reloc_data
.sym_value
);
1064 if (reloc_data
.sym_section
!= NULL
)
1066 ARC_DEBUG (" Symbol Section:\n");
1067 ARC_DEBUG (" section name = %s, output_offset 0x%08x",
1068 reloc_data
.sym_section
->name
,
1069 (unsigned int) reloc_data
.sym_section
->output_offset
);
1070 if (reloc_data
.sym_section
->output_section
!= NULL
)
1071 ARC_DEBUG (", output_section->vma = 0x%08x",
1072 ((unsigned int) reloc_data
.sym_section
->output_section
->vma
));
1074 if (reloc_data
.sym_section
->owner
&& reloc_data
.sym_section
->owner
->filename
)
1075 ARC_DEBUG (" file: %s\n", reloc_data
.sym_section
->owner
->filename
);
1079 ARC_DEBUG (" symbol section is NULL\n");
1082 ARC_DEBUG (" Input_section:\n");
1083 if (reloc_data
.input_section
!= NULL
)
1085 ARC_DEBUG (" section name = %s, output_offset 0x%08x, output_section->vma = 0x%08x\n",
1086 reloc_data
.input_section
->name
,
1087 (unsigned int) reloc_data
.input_section
->output_offset
,
1088 (unsigned int) reloc_data
.input_section
->output_section
->vma
);
1089 ARC_DEBUG (" changed_address = 0x%08x\n",
1090 (unsigned int) (reloc_data
.input_section
->output_section
->vma
1091 + reloc_data
.input_section
->output_offset
1092 + reloc_data
.reloc_offset
));
1093 ARC_DEBUG (" file: %s\n", reloc_data
.input_section
->owner
->filename
);
1097 ARC_DEBUG (" input section is NULL\n");
1101 #define DEBUG_ARC_RELOC(A)
1102 #endif /* ARC_ENABLE_DEBUG */
1105 middle_endian_convert (bfd_vma insn
, bfd_boolean do_it
)
1110 = ((insn
& 0xffff0000) >> 16)
1111 | ((insn
& 0xffff) << 16);
1116 /* This function is called for relocations that are otherwise marked as NOT
1117 requiring overflow checks. In here we perform non-standard checks of
1118 the relocation value. */
1120 static inline bfd_reloc_status_type
1121 arc_special_overflow_checks (const struct arc_relocation_data reloc_data
,
1122 bfd_signed_vma relocation
,
1123 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1125 switch (reloc_data
.howto
->type
)
1127 case R_ARC_NPS_CMEM16
:
1128 if (((relocation
>> 16) & 0xffff) != NPS_CMEM_HIGH_VALUE
)
1130 if (reloc_data
.reloc_addend
== 0)
1132 /* xgettext:c-format */
1133 (_("%pB(%pA+%#" PRIx64
"): CMEM relocation to `%s' is invalid, "
1134 "16 MSB should be %#x (value is %#" PRIx64
")"),
1135 reloc_data
.input_section
->owner
,
1136 reloc_data
.input_section
,
1137 (uint64_t) reloc_data
.reloc_offset
,
1138 reloc_data
.symbol_name
,
1139 NPS_CMEM_HIGH_VALUE
,
1140 (uint64_t) relocation
);
1143 /* xgettext:c-format */
1144 (_("%pB(%pA+%#" PRIx64
"): CMEM relocation to `%s+%#" PRIx64
1145 "' is invalid, 16 MSB should be %#x (value is %#" PRIx64
")"),
1146 reloc_data
.input_section
->owner
,
1147 reloc_data
.input_section
,
1148 (uint64_t) reloc_data
.reloc_offset
,
1149 reloc_data
.symbol_name
,
1150 (uint64_t) reloc_data
.reloc_addend
,
1151 NPS_CMEM_HIGH_VALUE
,
1152 (uint64_t) relocation
);
1153 return bfd_reloc_overflow
;
1161 return bfd_reloc_ok
;
1164 #define ME(reloc) (reloc)
1166 #define IS_ME(FORMULA,BFD) ((strstr (FORMULA, "ME") != NULL) \
1167 && (!bfd_big_endian (BFD)))
1169 #define S ((bfd_signed_vma) (reloc_data.sym_value \
1170 + (reloc_data.sym_section->output_section != NULL ? \
1171 (reloc_data.sym_section->output_offset \
1172 + reloc_data.sym_section->output_section->vma) : 0)))
1173 #define L ((bfd_signed_vma) (reloc_data.sym_value \
1174 + (reloc_data.sym_section->output_section != NULL ? \
1175 (reloc_data.sym_section->output_offset \
1176 + reloc_data.sym_section->output_section->vma) : 0)))
1177 #define A (reloc_data.reloc_addend)
1179 #define G (reloc_data.got_offset_value)
1180 #define GOT (reloc_data.got_symbol_vma)
1181 #define GOT_BEGIN (htab->sgot->output_section->vma)
1184 /* P: relative offset to PCL The offset should be to the
1185 current location aligned to 32 bits. */
1186 #define P ((bfd_signed_vma) ( \
1188 (reloc_data.input_section->output_section != NULL ? \
1189 reloc_data.input_section->output_section->vma : 0) \
1190 + reloc_data.input_section->output_offset \
1191 + (reloc_data.reloc_offset - (bitsize >= 32 ? 4 : 0))) \
1193 #define PDATA ((bfd_signed_vma) ( \
1194 (reloc_data.input_section->output_section->vma \
1195 + reloc_data.input_section->output_offset \
1196 + (reloc_data.reloc_offset))))
1197 #define SECTSTART (bfd_signed_vma) (reloc_data.sym_section->output_section->vma \
1198 + reloc_data.sym_section->output_offset)
1199 #define FINAL_SECTSTART \
1200 (bfd_signed_vma) (reloc_data.sym_section->output_section->vma)
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 (align_power(TCB_SIZE, \
1206 reloc_data.sym_section->alignment_power))
1210 #ifdef ARC_ENABLE_DEBUG
1211 #define PRINT_DEBUG_RELOC_INFO_BEFORE(FORMULA, TYPE) \
1214 asection *sym_section = reloc_data.sym_section; \
1215 asection *input_section = reloc_data.input_section; \
1216 ARC_DEBUG ("RELOC_TYPE = " TYPE "\n"); \
1217 ARC_DEBUG ("FORMULA = " FORMULA "\n"); \
1218 ARC_DEBUG ("S = %#lx\n", S); \
1219 ARC_DEBUG ("A = %#lx\n", A); \
1220 ARC_DEBUG ("L = %lx\n", L); \
1221 if (sym_section->output_section != NULL) \
1222 ARC_DEBUG ("symbol_section->vma = %#lx\n", \
1223 sym_section->output_section->vma \
1224 + sym_section->output_offset); \
1226 ARC_DEBUG ("symbol_section->vma = NULL\n"); \
1227 if (input_section->output_section != NULL) \
1228 ARC_DEBUG ("symbol_section->vma = %#lx\n", \
1229 input_section->output_section->vma \
1230 + input_section->output_offset); \
1232 ARC_DEBUG ("symbol_section->vma = NULL\n"); \
1233 ARC_DEBUG ("PCL = %#lx\n", P); \
1234 ARC_DEBUG ("P = %#lx\n", P); \
1235 ARC_DEBUG ("G = %#lx\n", G); \
1236 ARC_DEBUG ("SDA_OFFSET = %#lx\n", _SDA_BASE_); \
1237 ARC_DEBUG ("SDA_SET = %d\n", reloc_data.sdata_begin_symbol_vma_set); \
1238 ARC_DEBUG ("GOT_OFFSET = %#lx\n", GOT); \
1239 ARC_DEBUG ("relocation = %#08lx\n", relocation); \
1240 ARC_DEBUG ("before = %#08x\n", (unsigned) insn); \
1241 ARC_DEBUG ("data = %08x (%u) (%d)\n", (unsigned) relocation, \
1242 (unsigned) relocation, (int) relocation); \
1246 #define PRINT_DEBUG_RELOC_INFO_AFTER \
1249 ARC_DEBUG ("after = 0x%08x\n", (unsigned int) insn); \
1255 #define PRINT_DEBUG_RELOC_INFO_BEFORE(...)
1256 #define PRINT_DEBUG_RELOC_INFO_AFTER
1258 #endif /* ARC_ENABLE_DEBUG */
1260 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
1263 bfd_signed_vma bitsize ATTRIBUTE_UNUSED = BITSIZE; \
1264 relocation = FORMULA ; \
1265 PRINT_DEBUG_RELOC_INFO_BEFORE (#FORMULA, #TYPE); \
1266 insn = middle_endian_convert (insn, IS_ME (#FORMULA, abfd)); \
1267 insn = (* get_replace_function (abfd, TYPE)) (insn, relocation); \
1268 insn = middle_endian_convert (insn, IS_ME (#FORMULA, abfd)); \
1269 PRINT_DEBUG_RELOC_INFO_AFTER; \
1273 static bfd_reloc_status_type
1274 arc_do_relocation (bfd_byte
* contents
,
1275 struct arc_relocation_data reloc_data
,
1276 struct bfd_link_info
*info
)
1278 bfd_signed_vma relocation
= 0;
1280 bfd_vma orig_insn ATTRIBUTE_UNUSED
;
1281 bfd
* abfd
= reloc_data
.input_section
->owner
;
1282 struct elf_link_hash_table
*htab ATTRIBUTE_UNUSED
= elf_hash_table (info
);
1283 bfd_reloc_status_type flag
;
1285 if (!reloc_data
.should_relocate
)
1286 return bfd_reloc_ok
;
1288 switch (reloc_data
.howto
->size
)
1291 insn
= arc_bfd_get_32 (abfd
,
1292 contents
+ reloc_data
.reloc_offset
,
1293 reloc_data
.input_section
);
1296 insn
= arc_bfd_get_16 (abfd
,
1297 contents
+ reloc_data
.reloc_offset
,
1298 reloc_data
.input_section
);
1301 insn
= arc_bfd_get_8 (abfd
,
1302 contents
+ reloc_data
.reloc_offset
,
1303 reloc_data
.input_section
);
1313 switch (reloc_data
.howto
->type
)
1315 #include "elf/arc-reloc.def"
1322 /* Check for relocation overflow. */
1323 if (reloc_data
.howto
->complain_on_overflow
!= complain_overflow_dont
)
1324 flag
= bfd_check_overflow (reloc_data
.howto
->complain_on_overflow
,
1325 reloc_data
.howto
->bitsize
,
1326 reloc_data
.howto
->rightshift
,
1327 bfd_arch_bits_per_address (abfd
),
1330 flag
= arc_special_overflow_checks (reloc_data
, relocation
, info
);
1332 if (flag
!= bfd_reloc_ok
)
1334 ARC_DEBUG ("Relocation overflows !\n");
1335 DEBUG_ARC_RELOC (reloc_data
);
1336 ARC_DEBUG ("Relocation value = signed -> %d, unsigned -> %u"
1337 ", hex -> (0x%08x)\n",
1338 (int) relocation
, (unsigned) relocation
, (int) relocation
);
1343 /* Write updated instruction back to memory. */
1344 switch (reloc_data
.howto
->size
)
1347 arc_bfd_put_32 (abfd
, insn
,
1348 contents
+ reloc_data
.reloc_offset
,
1349 reloc_data
.input_section
);
1352 arc_bfd_put_16 (abfd
, insn
,
1353 contents
+ reloc_data
.reloc_offset
,
1354 reloc_data
.input_section
);
1357 arc_bfd_put_8 (abfd
, insn
,
1358 contents
+ reloc_data
.reloc_offset
,
1359 reloc_data
.input_section
);
1362 ARC_DEBUG ("size = %d\n", reloc_data
.howto
->size
);
1367 return bfd_reloc_ok
;
1383 #undef ARC_RELOC_HOWTO
1386 /* Relocate an arc ELF section.
1387 Function : elf_arc_relocate_section
1388 Brief : Relocate an arc section, by handling all the relocations
1389 appearing in that section.
1390 Args : output_bfd : The bfd being written to.
1391 info : Link information.
1392 input_bfd : The input bfd.
1393 input_section : The section being relocated.
1394 contents : contents of the section being relocated.
1395 relocs : List of relocations in the section.
1396 local_syms : is a pointer to the swapped in local symbols.
1397 local_section : is an array giving the section in the input file
1398 corresponding to the st_shndx field of each
1401 elf_arc_relocate_section (bfd
* output_bfd
,
1402 struct bfd_link_info
* info
,
1404 asection
* input_section
,
1405 bfd_byte
* contents
,
1406 Elf_Internal_Rela
* relocs
,
1407 Elf_Internal_Sym
* local_syms
,
1408 asection
** local_sections
)
1410 Elf_Internal_Shdr
* symtab_hdr
;
1411 struct elf_link_hash_entry
** sym_hashes
;
1412 Elf_Internal_Rela
* rel
;
1413 Elf_Internal_Rela
* wrel
;
1414 Elf_Internal_Rela
* relend
;
1415 struct elf_link_hash_table
* htab
= elf_hash_table (info
);
1417 symtab_hdr
= &((elf_tdata (input_bfd
))->symtab_hdr
);
1418 sym_hashes
= elf_sym_hashes (input_bfd
);
1420 rel
= wrel
= relocs
;
1421 relend
= relocs
+ input_section
->reloc_count
;
1422 for (; rel
< relend
; wrel
++, rel
++)
1424 enum elf_arc_reloc_type r_type
;
1425 reloc_howto_type
* howto
;
1426 unsigned long r_symndx
;
1427 struct elf_link_hash_entry
* h
;
1428 Elf_Internal_Sym
* sym
;
1430 struct elf_link_hash_entry
* h2
;
1432 bfd_boolean unresolved_reloc
= FALSE
;
1434 struct arc_relocation_data reloc_data
=
1438 .got_offset_value
= 0,
1440 .sym_section
= NULL
,
1442 .input_section
= NULL
,
1443 .sdata_begin_symbol_vma
= 0,
1444 .sdata_begin_symbol_vma_set
= FALSE
,
1445 .got_symbol_vma
= 0,
1446 .should_relocate
= FALSE
1449 r_type
= ELF32_R_TYPE (rel
->r_info
);
1451 if (r_type
>= (int) R_ARC_max
)
1453 bfd_set_error (bfd_error_bad_value
);
1456 howto
= arc_elf_howto (r_type
);
1458 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1460 /* If we are generating another .o file and the symbol in not
1461 local, skip this relocation. */
1462 if (bfd_link_relocatable (info
))
1464 /* This is a relocateable link. We don't have to change
1465 anything, unless the reloc is against a section symbol,
1466 in which case we have to adjust according to where the
1467 section symbol winds up in the output section. */
1469 /* Checks if this is a local symbol and thus the reloc
1470 might (will??) be against a section symbol. */
1471 if (r_symndx
< symtab_hdr
->sh_info
)
1473 sym
= local_syms
+ r_symndx
;
1474 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1476 sec
= local_sections
[r_symndx
];
1478 /* For RELA relocs. Just adjust the addend
1479 value in the relocation entry. */
1480 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
1482 ARC_DEBUG ("local symbols reloc (section=%d %s) seen in %s\n",
1483 (int) r_symndx
, local_sections
[r_symndx
]->name
,
1484 __PRETTY_FUNCTION__
);
1489 h2
= elf_link_hash_lookup (elf_hash_table (info
), "__SDATA_BEGIN__",
1490 FALSE
, FALSE
, TRUE
);
1492 if (!reloc_data
.sdata_begin_symbol_vma_set
1493 && h2
!= NULL
&& h2
->root
.type
!= bfd_link_hash_undefined
1494 && h2
->root
.u
.def
.section
->output_section
!= NULL
)
1495 /* TODO: Verify this condition. */
1497 reloc_data
.sdata_begin_symbol_vma
=
1498 (h2
->root
.u
.def
.value
1499 + h2
->root
.u
.def
.section
->output_section
->vma
);
1500 reloc_data
.sdata_begin_symbol_vma_set
= TRUE
;
1503 reloc_data
.input_section
= input_section
;
1504 reloc_data
.howto
= howto
;
1505 reloc_data
.reloc_offset
= rel
->r_offset
;
1506 reloc_data
.reloc_addend
= rel
->r_addend
;
1508 /* This is a final link. */
1513 if (r_symndx
< symtab_hdr
->sh_info
) /* A local symbol. */
1515 sym
= local_syms
+ r_symndx
;
1516 sec
= local_sections
[r_symndx
];
1520 bfd_boolean warned
, ignored
;
1521 bfd_vma relocation ATTRIBUTE_UNUSED
;
1523 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
1524 r_symndx
, symtab_hdr
, sym_hashes
,
1526 unresolved_reloc
, warned
, ignored
);
1528 /* TODO: This code is repeated from below. We should
1529 clean it and remove duplications.
1530 Sec is used check for discarded sections.
1531 Need to redesign code below. */
1533 /* Get the symbol's entry in the symtab. */
1534 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1536 while (h
->root
.type
== bfd_link_hash_indirect
1537 || h
->root
.type
== bfd_link_hash_warning
)
1538 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1540 /* If we have encountered a definition for this symbol. */
1541 if (h
->root
.type
== bfd_link_hash_defined
1542 || h
->root
.type
== bfd_link_hash_defweak
)
1544 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1545 sec
= h
->root
.u
.def
.section
;
1549 /* Clean relocs for symbols in discarded sections. */
1550 if (sec
!= NULL
&& discarded_section (sec
))
1552 _bfd_clear_contents (howto
, input_bfd
, input_section
,
1553 contents
, rel
->r_offset
);
1557 /* For ld -r, remove relocations in debug sections against
1558 sections defined in discarded sections. Not done for
1559 eh_frame editing code expects to be present. */
1560 if (bfd_link_relocatable (info
)
1561 && (input_section
->flags
& SEC_DEBUGGING
))
1567 if (bfd_link_relocatable (info
))
1574 if (r_symndx
< symtab_hdr
->sh_info
) /* A local symbol. */
1576 reloc_data
.sym_value
= sym
->st_value
;
1577 reloc_data
.sym_section
= sec
;
1578 reloc_data
.symbol_name
=
1579 bfd_elf_string_from_elf_section (input_bfd
,
1580 symtab_hdr
->sh_link
,
1583 /* Mergeable section handling. */
1584 if ((sec
->flags
& SEC_MERGE
)
1585 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1589 rel
->r_addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
,
1590 &msec
, rel
->r_addend
);
1591 rel
->r_addend
-= (sec
->output_section
->vma
1592 + sec
->output_offset
1594 rel
->r_addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
1596 reloc_data
.reloc_addend
= rel
->r_addend
;
1599 BFD_ASSERT (htab
->sgot
!= NULL
|| !is_reloc_for_GOT (howto
));
1600 if (htab
->sgot
!= NULL
)
1601 reloc_data
.got_symbol_vma
= htab
->sgot
->output_section
->vma
1602 + htab
->sgot
->output_offset
;
1604 reloc_data
.should_relocate
= TRUE
;
1606 else /* Global symbol. */
1608 /* FIXME: We should use the RELOC_FOR_GLOBAL_SYMBOL macro
1609 (defined in elf-bfd.h) here. */
1611 /* Get the symbol's entry in the symtab. */
1612 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1614 while (h
->root
.type
== bfd_link_hash_indirect
1615 || h
->root
.type
== bfd_link_hash_warning
)
1617 struct elf_arc_link_hash_entry
*ah_old
=
1618 (struct elf_arc_link_hash_entry
*) h
;
1619 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1620 struct elf_arc_link_hash_entry
*ah
=
1621 (struct elf_arc_link_hash_entry
*) h
;
1623 if (ah
->got_ents
== 0 && ah_old
->got_ents
!= ah
->got_ents
)
1624 ah
->got_ents
= ah_old
->got_ents
;
1627 /* TODO: Need to validate what was the intention. */
1628 /* BFD_ASSERT ((h->dynindx == -1) || (h->forced_local != 0)); */
1629 reloc_data
.symbol_name
= h
->root
.root
.string
;
1631 /* If we have encountered a definition for this symbol. */
1632 if (h
->root
.type
== bfd_link_hash_defined
1633 || h
->root
.type
== bfd_link_hash_defweak
)
1635 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1636 reloc_data
.sym_section
= h
->root
.u
.def
.section
;
1638 reloc_data
.should_relocate
= TRUE
;
1640 if (is_reloc_for_GOT (howto
) && !bfd_link_pic (info
))
1642 struct elf_arc_link_hash_entry
*ah
=
1643 (struct elf_arc_link_hash_entry
*) h
;
1644 /* TODO: Change it to use arc_do_relocation with
1645 ARC_32 reloc. Try to use ADD_RELA macro. */
1646 bfd_vma relocation
=
1647 reloc_data
.sym_value
+ reloc_data
.reloc_addend
1648 + (reloc_data
.sym_section
->output_section
!= NULL
?
1649 (reloc_data
.sym_section
->output_offset
1650 + reloc_data
.sym_section
->output_section
->vma
)
1653 BFD_ASSERT (ah
->got_ents
);
1654 bfd_vma got_offset
= ah
->got_ents
->offset
;
1655 bfd_put_32 (output_bfd
, relocation
,
1656 htab
->sgot
->contents
+ got_offset
);
1658 if (is_reloc_for_PLT (howto
) && h
->plt
.offset
!= (bfd_vma
) -1)
1660 /* TODO: This is repeated up here. */
1661 reloc_data
.sym_value
= h
->plt
.offset
;
1662 reloc_data
.sym_section
= htab
->splt
;
1665 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1667 /* Is weak symbol and has no definition. */
1668 if (is_reloc_for_GOT (howto
))
1670 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1671 reloc_data
.sym_section
= htab
->sgot
;
1672 reloc_data
.should_relocate
= TRUE
;
1674 else if (is_reloc_for_PLT (howto
)
1675 && h
->plt
.offset
!= (bfd_vma
) -1)
1677 /* TODO: This is repeated up here. */
1678 reloc_data
.sym_value
= h
->plt
.offset
;
1679 reloc_data
.sym_section
= htab
->splt
;
1680 reloc_data
.should_relocate
= TRUE
;
1687 if (is_reloc_for_GOT (howto
))
1689 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1690 reloc_data
.sym_section
= htab
->sgot
;
1692 reloc_data
.should_relocate
= TRUE
;
1694 else if (is_reloc_for_PLT (howto
))
1696 /* Fail if it is linking for PIE and the symbol is
1698 if (bfd_link_executable (info
))
1699 (*info
->callbacks
->undefined_symbol
)
1700 (info
, h
->root
.root
.string
, input_bfd
, input_section
,
1701 rel
->r_offset
, TRUE
);
1702 reloc_data
.sym_value
= h
->plt
.offset
;
1703 reloc_data
.sym_section
= htab
->splt
;
1705 reloc_data
.should_relocate
= TRUE
;
1707 else if (!bfd_link_pic (info
) || bfd_link_executable (info
))
1708 (*info
->callbacks
->undefined_symbol
)
1709 (info
, h
->root
.root
.string
, input_bfd
, input_section
,
1710 rel
->r_offset
, TRUE
);
1713 BFD_ASSERT (htab
->sgot
!= NULL
|| !is_reloc_for_GOT (howto
));
1714 if (htab
->sgot
!= NULL
)
1715 reloc_data
.got_symbol_vma
= htab
->sgot
->output_section
->vma
1716 + htab
->sgot
->output_offset
;
1719 if ((is_reloc_for_GOT (howto
)
1720 || is_reloc_for_TLS (howto
)))
1722 reloc_data
.should_relocate
= TRUE
;
1724 struct got_entry
**list
1725 = get_got_entry_list_for_symbol (input_bfd
, r_symndx
, h
);
1727 reloc_data
.got_offset_value
1728 = relocate_fix_got_relocs_for_got_info (list
,
1729 tls_type_for_reloc (howto
),
1740 create_got_dynrelocs_for_single_entry (
1741 got_entry_for_type (list
,
1742 arc_got_entry_type_for_reloc (howto
)),
1743 output_bfd
, info
, NULL
);
1748 #define IS_ARC_PCREL_TYPE(TYPE) \
1749 ( (TYPE == R_ARC_PC32) \
1750 || (TYPE == R_ARC_32_PCREL))
1757 case R_ARC_32_PCREL
:
1758 if (bfd_link_pic (info
)
1759 && (!IS_ARC_PCREL_TYPE (r_type
)
1763 && (!info
->symbolic
|| !h
->def_regular
))))
1765 Elf_Internal_Rela outrel
;
1767 bfd_boolean skip
= FALSE
;
1768 bfd_boolean relocate
= FALSE
;
1769 asection
*sreloc
= _bfd_elf_get_dynamic_reloc_section
1770 (input_bfd
, input_section
,
1773 BFD_ASSERT (sreloc
!= NULL
);
1775 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
1780 if (outrel
.r_offset
== (bfd_vma
) -1)
1783 outrel
.r_addend
= rel
->r_addend
;
1784 outrel
.r_offset
+= (input_section
->output_section
->vma
1785 + input_section
->output_offset
);
1789 memset (&outrel
, 0, sizeof outrel
);
1794 && (IS_ARC_PCREL_TYPE (r_type
)
1795 || !(bfd_link_executable (info
)
1796 || SYMBOLIC_BIND (info
, h
))
1797 || ! h
->def_regular
))
1799 BFD_ASSERT (h
!= NULL
);
1800 if ((input_section
->flags
& SEC_ALLOC
) != 0)
1805 BFD_ASSERT (h
->dynindx
!= -1);
1806 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
1810 /* Handle local symbols, they either do not have a
1811 global hash table entry (h == NULL), or are
1812 forced local due to a version script
1813 (h->forced_local), or the third condition is
1814 legacy, it appears to say something like, for
1815 links where we are pre-binding the symbols, or
1816 there's not an entry for this symbol in the
1817 dynamic symbol table, and it's a regular symbol
1818 not defined in a shared object, then treat the
1819 symbol as local, resolve it now. */
1821 /* outrel.r_addend = 0; */
1822 outrel
.r_info
= ELF32_R_INFO (0, R_ARC_RELATIVE
);
1825 BFD_ASSERT (sreloc
->contents
!= 0);
1827 loc
= sreloc
->contents
;
1828 loc
+= sreloc
->reloc_count
* sizeof (Elf32_External_Rela
);
1829 sreloc
->reloc_count
+= 1;
1831 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
1841 if (is_reloc_SDA_relative (howto
)
1842 && !reloc_data
.sdata_begin_symbol_vma_set
)
1845 ("error: linker symbol __SDATA_BEGIN__ not found");
1846 bfd_set_error (bfd_error_bad_value
);
1850 DEBUG_ARC_RELOC (reloc_data
);
1852 /* Make sure we have with a dynamic linker. In case of GOT and PLT
1853 the sym_section should point to .got or .plt respectively. */
1854 if ((is_reloc_for_GOT (howto
) || is_reloc_for_PLT (howto
))
1855 && reloc_data
.sym_section
== NULL
)
1858 (_("GOT and PLT relocations cannot be fixed with a non dynamic linker"));
1859 bfd_set_error (bfd_error_bad_value
);
1864 switch (arc_do_relocation (contents
, reloc_data
, info
))
1867 continue; /* The reloc processing loop. */
1869 case bfd_reloc_overflow
:
1870 (*info
->callbacks
->reloc_overflow
)
1871 (info
, (h
? &h
->root
: NULL
), reloc_data
.symbol_name
, howto
->name
, (bfd_vma
) 0,
1872 input_bfd
, input_section
, rel
->r_offset
);
1875 case bfd_reloc_undefined
:
1876 (*info
->callbacks
->undefined_symbol
)
1877 (info
, reloc_data
.symbol_name
, input_bfd
, input_section
, rel
->r_offset
, TRUE
);
1880 case bfd_reloc_other
:
1881 /* xgettext:c-format */
1882 msg
= _("%pB(%pA): warning: unaligned access to symbol '%s' in the small data area");
1885 case bfd_reloc_outofrange
:
1886 /* xgettext:c-format */
1887 msg
= _("%pB(%pA): internal error: out of range error");
1890 case bfd_reloc_notsupported
:
1891 /* xgettext:c-format */
1892 msg
= _("%pB(%pA): internal error: unsupported relocation error");
1895 case bfd_reloc_dangerous
:
1896 /* xgettext:c-format */
1897 msg
= _("%pB(%pA): internal error: dangerous relocation");
1901 /* xgettext:c-format */
1902 msg
= _("%pB(%pA): internal error: unknown error");
1907 _bfd_error_handler (msg
, input_bfd
, input_section
, reloc_data
.symbol_name
);
1914 #define elf_arc_hash_table(p) \
1915 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
1916 == ARC_ELF_DATA ? ((struct elf_arc_link_hash_table *) ((p)->hash)) : NULL)
1919 elf_arc_check_relocs (bfd
* abfd
,
1920 struct bfd_link_info
* info
,
1922 const Elf_Internal_Rela
* relocs
)
1924 Elf_Internal_Shdr
* symtab_hdr
;
1925 struct elf_link_hash_entry
** sym_hashes
;
1926 const Elf_Internal_Rela
* rel
;
1927 const Elf_Internal_Rela
* rel_end
;
1929 asection
* sreloc
= NULL
;
1930 struct elf_link_hash_table
* htab
= elf_hash_table (info
);
1932 if (bfd_link_relocatable (info
))
1935 if (htab
->dynobj
== NULL
)
1936 htab
->dynobj
= abfd
;
1938 dynobj
= (elf_hash_table (info
))->dynobj
;
1939 symtab_hdr
= &((elf_tdata (abfd
))->symtab_hdr
);
1940 sym_hashes
= elf_sym_hashes (abfd
);
1942 rel_end
= relocs
+ sec
->reloc_count
;
1943 for (rel
= relocs
; rel
< rel_end
; rel
++)
1945 enum elf_arc_reloc_type r_type
;
1946 reloc_howto_type
*howto
;
1947 unsigned long r_symndx
;
1948 struct elf_link_hash_entry
*h
;
1950 r_type
= ELF32_R_TYPE (rel
->r_info
);
1952 if (r_type
>= (int) R_ARC_max
)
1954 bfd_set_error (bfd_error_bad_value
);
1957 howto
= arc_elf_howto (r_type
);
1959 /* Load symbol information. */
1960 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1961 if (r_symndx
< symtab_hdr
->sh_info
) /* Is a local symbol. */
1963 else /* Global one. */
1965 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1966 while (h
->root
.type
== bfd_link_hash_indirect
1967 || h
->root
.type
== bfd_link_hash_warning
)
1968 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1976 /* During shared library creation, these relocs should not
1977 appear in a shared library (as memory will be read only
1978 and the dynamic linker can not resolve these. However
1979 the error should not occur for e.g. debugging or
1980 non-readonly sections. */
1982 && (bfd_link_dll (info
) && !bfd_link_pie (info
))
1983 && (sec
->flags
& SEC_ALLOC
) != 0
1984 && (sec
->flags
& SEC_READONLY
) != 0
1985 && ((sec
->flags
& SEC_CODE
) != 0
1986 || (sec
->flags
& SEC_DEBUGGING
) != 0))
1990 name
= h
->root
.root
.string
;
1994 /* xgettext:c-format */
1995 (_("%pB: relocation %s against `%s' can not be used"
1996 " when making a shared object; recompile with -fPIC"),
1998 arc_elf_howto (r_type
)->name
,
2000 bfd_set_error (bfd_error_bad_value
);
2004 /* In some cases we are not setting the 'non_got_ref'
2005 flag, even though the relocations don't require a GOT
2006 access. We should extend the testing in this area to
2007 ensure that no significant cases are being missed. */
2012 case R_ARC_32_PCREL
:
2013 if ((bfd_link_pic (info
))
2014 && ((r_type
!= R_ARC_PC32
&& r_type
!= R_ARC_32_PCREL
)
2016 && (!info
->symbolic
|| !h
->def_regular
))))
2021 && ! htab
->dynamic_sections_created
2022 && ! _bfd_elf_link_create_dynamic_sections (abfd
, info
))
2024 sreloc
= _bfd_elf_make_dynamic_reloc_section (sec
, dynobj
,
2032 sreloc
->size
+= sizeof (Elf32_External_Rela
);
2039 if (is_reloc_for_PLT (howto
))
2044 if (h
->forced_local
== 0)
2048 /* Add info to the symbol got_entry_list. */
2049 if (is_reloc_for_GOT (howto
)
2050 || is_reloc_for_TLS (howto
))
2052 if (bfd_link_dll (info
) && !bfd_link_pie (info
)
2053 && (r_type
== R_ARC_TLS_LE_32
|| r_type
== R_ARC_TLS_LE_S9
))
2057 name
= h
->root
.root
.string
;
2059 /* bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL); */
2062 /* xgettext:c-format */
2063 (_("%pB: relocation %s against `%s' can not be used"
2064 " when making a shared object; recompile with -fPIC"),
2066 arc_elf_howto (r_type
)->name
,
2068 bfd_set_error (bfd_error_bad_value
);
2071 if (! _bfd_elf_create_got_section (dynobj
, info
))
2074 arc_fill_got_info_for_reloc (
2075 arc_got_entry_type_for_reloc (howto
),
2076 get_got_entry_list_for_symbol (abfd
, r_symndx
, h
),
2085 #define ELF_DYNAMIC_INTERPRETER "/sbin/ld-uClibc.so"
2087 static struct plt_version_t
*
2088 arc_get_plt_version (struct bfd_link_info
*info
)
2092 for (i
= 0; i
< 1; i
++)
2094 ARC_DEBUG ("%d: size1 = %d, size2 = %d\n", i
,
2095 (int) plt_versions
[i
].entry_size
,
2096 (int) plt_versions
[i
].elem_size
);
2099 if (bfd_get_mach (info
->output_bfd
) == bfd_mach_arc_arcv2
)
2101 if (bfd_link_pic (info
))
2102 return &(plt_versions
[ELF_ARCV2_PIC
]);
2104 return &(plt_versions
[ELF_ARCV2_ABS
]);
2108 if (bfd_link_pic (info
))
2109 return &(plt_versions
[ELF_ARC_PIC
]);
2111 return &(plt_versions
[ELF_ARC_ABS
]);
2116 add_symbol_to_plt (struct bfd_link_info
*info
)
2118 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2121 struct plt_version_t
*plt_data
= arc_get_plt_version (info
);
2123 /* If this is the first .plt entry, make room for the special first
2125 if (htab
->splt
->size
== 0)
2126 htab
->splt
->size
+= plt_data
->entry_size
;
2128 ret
= htab
->splt
->size
;
2130 htab
->splt
->size
+= plt_data
->elem_size
;
2131 ARC_DEBUG ("PLT_SIZE = %d\n", (int) htab
->splt
->size
);
2133 htab
->sgotplt
->size
+= 4;
2134 htab
->srelplt
->size
+= sizeof (Elf32_External_Rela
);
2139 #define PLT_DO_RELOCS_FOR_ENTRY(ABFD, DS, RELOCS) \
2140 plt_do_relocs_for_symbol (ABFD, DS, RELOCS, 0, 0)
2143 plt_do_relocs_for_symbol (bfd
*abfd
,
2144 struct elf_link_hash_table
*htab
,
2145 const struct plt_reloc
*reloc
,
2147 bfd_vma symbol_got_offset
)
2149 while (SYM_ONLY (reloc
->symbol
) != LAST_RELOC
)
2151 bfd_vma relocation
= 0;
2153 switch (SYM_ONLY (reloc
->symbol
))
2157 = htab
->sgotplt
->output_section
->vma
2158 + htab
->sgotplt
->output_offset
+ symbol_got_offset
;
2161 relocation
+= reloc
->addend
;
2163 if (IS_RELATIVE (reloc
->symbol
))
2165 bfd_vma reloc_offset
= reloc
->offset
;
2166 reloc_offset
-= (IS_INSN_32 (reloc
->symbol
)) ? 4 : 0;
2167 reloc_offset
-= (IS_INSN_24 (reloc
->symbol
)) ? 2 : 0;
2169 relocation
-= htab
->splt
->output_section
->vma
2170 + htab
->splt
->output_offset
2171 + plt_offset
+ reloc_offset
;
2174 /* TODO: being ME is not a property of the relocation but of the
2175 section of which is applying the relocation. */
2176 if (IS_MIDDLE_ENDIAN (reloc
->symbol
) && !bfd_big_endian (abfd
))
2179 = ((relocation
& 0xffff0000) >> 16)
2180 | ((relocation
& 0xffff) << 16);
2183 switch (reloc
->size
)
2186 bfd_put_32 (htab
->splt
->output_section
->owner
,
2188 htab
->splt
->contents
+ plt_offset
+ reloc
->offset
);
2192 reloc
= &(reloc
[1]); /* Jump to next relocation. */
2197 relocate_plt_for_symbol (bfd
*output_bfd
,
2198 struct bfd_link_info
*info
,
2199 struct elf_link_hash_entry
*h
)
2201 struct plt_version_t
*plt_data
= arc_get_plt_version (info
);
2202 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2204 bfd_vma plt_index
= (h
->plt
.offset
- plt_data
->entry_size
)
2205 / plt_data
->elem_size
;
2206 bfd_vma got_offset
= (plt_index
+ 3) * 4;
2208 ARC_DEBUG ("arc_info: PLT_OFFSET = %#lx, PLT_ENTRY_VMA = %#lx, \
2209 GOT_ENTRY_OFFSET = %#lx, GOT_ENTRY_VMA = %#lx, for symbol %s\n",
2210 (long) h
->plt
.offset
,
2211 (long) (htab
->splt
->output_section
->vma
2212 + htab
->splt
->output_offset
2215 (long) (htab
->sgotplt
->output_section
->vma
2216 + htab
->sgotplt
->output_offset
2218 h
->root
.root
.string
);
2222 uint16_t *ptr
= (uint16_t *) plt_data
->elem
;
2224 for (i
= 0; i
< plt_data
->elem_size
/2; i
++)
2226 uint16_t data
= ptr
[i
];
2227 bfd_put_16 (output_bfd
,
2229 htab
->splt
->contents
+ h
->plt
.offset
+ (i
*2));
2233 plt_do_relocs_for_symbol (output_bfd
, htab
,
2234 plt_data
->elem_relocs
,
2238 /* Fill in the entry in the global offset table. */
2239 bfd_put_32 (output_bfd
,
2240 (bfd_vma
) (htab
->splt
->output_section
->vma
2241 + htab
->splt
->output_offset
),
2242 htab
->sgotplt
->contents
+ got_offset
);
2244 /* TODO: Fill in the entry in the .rela.plt section. */
2246 Elf_Internal_Rela rel
;
2249 rel
.r_offset
= (htab
->sgotplt
->output_section
->vma
2250 + htab
->sgotplt
->output_offset
2254 BFD_ASSERT (h
->dynindx
!= -1);
2255 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARC_JMP_SLOT
);
2257 loc
= htab
->srelplt
->contents
;
2258 loc
+= plt_index
* sizeof (Elf32_External_Rela
); /* relA */
2259 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
2264 relocate_plt_for_entry (bfd
*abfd
,
2265 struct bfd_link_info
*info
)
2267 struct plt_version_t
*plt_data
= arc_get_plt_version (info
);
2268 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2272 uint16_t *ptr
= (uint16_t *) plt_data
->entry
;
2273 for (i
= 0; i
< plt_data
->entry_size
/2; i
++)
2275 uint16_t data
= ptr
[i
];
2278 htab
->splt
->contents
+ (i
*2));
2281 PLT_DO_RELOCS_FOR_ENTRY (abfd
, htab
, plt_data
->entry_relocs
);
2284 /* Desc : Adjust a symbol defined by a dynamic object and referenced
2285 by a regular object. The current definition is in some section of
2286 the dynamic object, but we're not including those sections. We
2287 have to change the definition to something the rest of the link can
2291 elf_arc_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2292 struct elf_link_hash_entry
*h
)
2295 bfd
*dynobj
= (elf_hash_table (info
))->dynobj
;
2296 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2298 if (h
->type
== STT_FUNC
2299 || h
->type
== STT_GNU_IFUNC
2300 || h
->needs_plt
== 1)
2302 if (!bfd_link_pic (info
) && !h
->def_dynamic
&& !h
->ref_dynamic
)
2304 /* This case can occur if we saw a PLT32 reloc in an input
2305 file, but the symbol was never referred to by a dynamic
2306 object. In such a case, we don't actually need to build
2307 a procedure linkage table, and we can just do a PC32
2309 BFD_ASSERT (h
->needs_plt
);
2313 /* Make sure this symbol is output as a dynamic symbol. */
2314 if (h
->dynindx
== -1 && !h
->forced_local
2315 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
2318 if (bfd_link_pic (info
)
2319 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2321 bfd_vma loc
= add_symbol_to_plt (info
);
2323 if (bfd_link_executable (info
) && !h
->def_regular
)
2325 h
->root
.u
.def
.section
= htab
->splt
;
2326 h
->root
.u
.def
.value
= loc
;
2328 h
->plt
.offset
= loc
;
2332 h
->plt
.offset
= (bfd_vma
) -1;
2338 /* If this is a weak symbol, and there is a real definition, the
2339 processor independent code will have arranged for us to see the
2340 real definition first, and we can just use the same value. */
2341 if (h
->is_weakalias
)
2343 struct elf_link_hash_entry
*def
= weakdef (h
);
2344 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
2345 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
2346 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
2350 /* This is a reference to a symbol defined by a dynamic object which
2351 is not a function. */
2353 /* If we are creating a shared library, we must presume that the
2354 only references to the symbol are via the global offset table.
2355 For such cases we need not do anything here; the relocations will
2356 be handled correctly by relocate_section. */
2357 if (!bfd_link_executable (info
))
2360 /* If there are no non-GOT references, we do not need a copy
2362 if (!h
->non_got_ref
)
2365 /* If -z nocopyreloc was given, we won't generate them either. */
2366 if (info
->nocopyreloc
)
2372 /* We must allocate the symbol in our .dynbss section, which will
2373 become part of the .bss section of the executable. There will be
2374 an entry for this symbol in the .dynsym section. The dynamic
2375 object will contain position independent code, so all references
2376 from the dynamic object to this symbol will go through the global
2377 offset table. The dynamic linker will use the .dynsym entry to
2378 determine the address it must put in the global offset table, so
2379 both the dynamic object and the regular object will refer to the
2380 same memory location for the variable. */
2385 /* We must generate a R_ARC_COPY reloc to tell the dynamic linker to
2386 copy the initial value out of the dynamic object and into the
2387 runtime process image. We need to remember the offset into the
2388 .rela.bss section we are going to use. */
2389 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
2391 struct elf_arc_link_hash_table
*arc_htab
= elf_arc_hash_table (info
);
2393 BFD_ASSERT (arc_htab
->elf
.srelbss
!= NULL
);
2394 arc_htab
->elf
.srelbss
->size
+= sizeof (Elf32_External_Rela
);
2398 /* TODO: Move this also to arc_hash_table. */
2399 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
2400 BFD_ASSERT (s
!= NULL
);
2402 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2405 /* Function : elf_arc_finish_dynamic_symbol
2406 Brief : Finish up dynamic symbol handling. We set the
2407 contents of various dynamic sections here.
2412 Returns : True/False as the return status. */
2415 elf_arc_finish_dynamic_symbol (bfd
* output_bfd
,
2416 struct bfd_link_info
*info
,
2417 struct elf_link_hash_entry
*h
,
2418 Elf_Internal_Sym
* sym
)
2420 if (h
->plt
.offset
!= (bfd_vma
) -1)
2422 relocate_plt_for_symbol (output_bfd
, info
, h
);
2424 if (!h
->def_regular
)
2426 /* Mark the symbol as undefined, rather than as defined in
2427 the .plt section. Leave the value alone. */
2428 sym
->st_shndx
= SHN_UNDEF
;
2433 /* This function traverses list of GOT entries and
2434 create respective dynamic relocs. */
2435 /* TODO: Make function to get list and not access the list directly. */
2436 /* TODO: Move function to relocate_section create this relocs eagerly. */
2437 struct elf_arc_link_hash_entry
*ah
=
2438 (struct elf_arc_link_hash_entry
*) h
;
2439 create_got_dynrelocs_for_got_info (&ah
->got_ents
,
2446 struct elf_arc_link_hash_table
*arc_htab
= elf_arc_hash_table (info
);
2448 if (arc_htab
== NULL
)
2451 if (h
->dynindx
== -1
2452 || (h
->root
.type
!= bfd_link_hash_defined
2453 && h
->root
.type
!= bfd_link_hash_defweak
)
2454 || arc_htab
->elf
.srelbss
== NULL
)
2457 bfd_vma rel_offset
= (h
->root
.u
.def
.value
2458 + h
->root
.u
.def
.section
->output_section
->vma
2459 + h
->root
.u
.def
.section
->output_offset
);
2461 bfd_byte
* loc
= arc_htab
->elf
.srelbss
->contents
2462 + (arc_htab
->elf
.srelbss
->reloc_count
* sizeof (Elf32_External_Rela
));
2463 arc_htab
->elf
.srelbss
->reloc_count
++;
2465 Elf_Internal_Rela rel
;
2467 rel
.r_offset
= rel_offset
;
2469 BFD_ASSERT (h
->dynindx
!= -1);
2470 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARC_COPY
);
2472 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
2475 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2476 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2477 || strcmp (h
->root
.root
.string
, "__DYNAMIC") == 0
2478 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
2479 sym
->st_shndx
= SHN_ABS
;
2484 #define GET_SYMBOL_OR_SECTION(TAG, SYMBOL, SECTION) \
2486 if (SYMBOL != NULL) \
2487 h = elf_link_hash_lookup (elf_hash_table (info), \
2488 SYMBOL, FALSE, FALSE, TRUE); \
2489 else if (SECTION != NULL) \
2490 s = bfd_get_linker_section (dynobj, SECTION); \
2494 struct obfd_info_group
{
2496 struct bfd_link_info
*info
;
2500 arc_create_forced_local_got_entries_for_tls (struct bfd_hash_entry
*bh
,
2503 struct elf_arc_link_hash_entry
* h
=
2504 (struct elf_arc_link_hash_entry
*) bh
;
2505 struct obfd_info_group
*tmp
= (struct obfd_info_group
*) data
;
2507 if (h
->got_ents
!= NULL
)
2511 struct got_entry
*list
= h
->got_ents
;
2513 while (list
!= NULL
)
2515 create_got_dynrelocs_for_single_entry (list
, tmp
->output_bfd
,
2517 (struct elf_link_hash_entry
*) h
);
2526 /* Function : elf_arc_finish_dynamic_sections
2527 Brief : Finish up the dynamic sections handling.
2532 Returns : True/False as the return status. */
2535 elf_arc_finish_dynamic_sections (bfd
* output_bfd
,
2536 struct bfd_link_info
*info
)
2538 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2539 bfd
*dynobj
= (elf_hash_table (info
))->dynobj
;
2540 asection
*sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
2544 Elf32_External_Dyn
*dyncon
, *dynconend
;
2546 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
2548 = (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
2549 for (; dyncon
< dynconend
; dyncon
++)
2551 Elf_Internal_Dyn internal_dyn
;
2552 bfd_boolean do_it
= FALSE
;
2554 struct elf_link_hash_entry
*h
= NULL
;
2557 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &internal_dyn
);
2559 switch (internal_dyn
.d_tag
)
2561 GET_SYMBOL_OR_SECTION (DT_INIT
, info
->init_function
, NULL
)
2562 GET_SYMBOL_OR_SECTION (DT_FINI
, info
->fini_function
, NULL
)
2563 GET_SYMBOL_OR_SECTION (DT_PLTGOT
, NULL
, ".plt")
2564 GET_SYMBOL_OR_SECTION (DT_JMPREL
, NULL
, ".rela.plt")
2565 GET_SYMBOL_OR_SECTION (DT_PLTRELSZ
, NULL
, ".rela.plt")
2566 GET_SYMBOL_OR_SECTION (DT_VERSYM
, NULL
, ".gnu.version")
2567 GET_SYMBOL_OR_SECTION (DT_VERDEF
, NULL
, ".gnu.version_d")
2568 GET_SYMBOL_OR_SECTION (DT_VERNEED
, NULL
, ".gnu.version_r")
2573 /* In case the dynamic symbols should be updated with a symbol. */
2575 && (h
->root
.type
== bfd_link_hash_defined
2576 || h
->root
.type
== bfd_link_hash_defweak
))
2580 internal_dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
2581 asec_ptr
= h
->root
.u
.def
.section
;
2582 if (asec_ptr
->output_section
!= NULL
)
2584 internal_dyn
.d_un
.d_val
+=
2585 (asec_ptr
->output_section
->vma
2586 + asec_ptr
->output_offset
);
2590 /* The symbol is imported from another shared
2591 library and does not apply to this one. */
2592 internal_dyn
.d_un
.d_val
= 0;
2596 else if (s
!= NULL
) /* With a section information. */
2598 switch (internal_dyn
.d_tag
)
2605 internal_dyn
.d_un
.d_ptr
= (s
->output_section
->vma
2606 + s
->output_offset
);
2611 internal_dyn
.d_un
.d_val
= s
->size
;
2621 bfd_elf32_swap_dyn_out (output_bfd
, &internal_dyn
, dyncon
);
2624 if (htab
->splt
->size
> 0)
2626 relocate_plt_for_entry (output_bfd
, info
);
2629 /* TODO: Validate this. */
2630 if (htab
->srelplt
->output_section
!= bfd_abs_section_ptr
)
2631 elf_section_data (htab
->srelplt
->output_section
)
2632 ->this_hdr
.sh_entsize
= 12;
2635 /* Fill in the first three entries in the global offset table. */
2638 struct elf_link_hash_entry
*h
;
2639 h
= elf_link_hash_lookup (elf_hash_table (info
), "_GLOBAL_OFFSET_TABLE_",
2640 FALSE
, FALSE
, TRUE
);
2642 if (h
!= NULL
&& h
->root
.type
!= bfd_link_hash_undefined
2643 && h
->root
.u
.def
.section
!= NULL
)
2645 asection
*sec
= h
->root
.u
.def
.section
;
2648 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
2651 bfd_put_32 (output_bfd
,
2652 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
2654 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sec
->contents
+ 4);
2655 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sec
->contents
+ 8);
2659 struct obfd_info_group group
;
2660 group
.output_bfd
= output_bfd
;
2662 bfd_hash_traverse (&info
->hash
->table
,
2663 arc_create_forced_local_got_entries_for_tls
, &group
);
2668 #define ADD_DYNAMIC_SYMBOL(NAME, TAG) \
2669 h = elf_link_hash_lookup (elf_hash_table (info), \
2670 NAME, FALSE, FALSE, FALSE); \
2671 if ((h != NULL && (h->ref_regular || h->def_regular))) \
2672 if (! _bfd_elf_add_dynamic_entry (info, TAG, 0)) \
2675 /* Set the sizes of the dynamic sections. */
2677 elf_arc_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
2678 struct bfd_link_info
*info
)
2682 bfd_boolean relocs_exist
= FALSE
;
2683 bfd_boolean reltext_exist
= FALSE
;
2684 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2686 dynobj
= htab
->dynobj
;
2687 BFD_ASSERT (dynobj
!= NULL
);
2689 if (htab
->dynamic_sections_created
)
2691 struct elf_link_hash_entry
*h
;
2693 /* Set the contents of the .interp section to the
2695 if (bfd_link_executable (info
) && !info
->nointerp
)
2697 s
= bfd_get_section_by_name (dynobj
, ".interp");
2698 BFD_ASSERT (s
!= NULL
);
2699 s
->size
= sizeof (ELF_DYNAMIC_INTERPRETER
);
2700 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2703 /* Add some entries to the .dynamic section. We fill in some of
2704 the values later, in elf_bfd_final_link, but we must add the
2705 entries now so that we know the final size of the .dynamic
2706 section. Checking if the .init section is present. We also
2707 create DT_INIT and DT_FINI entries if the init_str has been
2708 changed by the user. */
2709 ADD_DYNAMIC_SYMBOL (info
->init_function
, DT_INIT
);
2710 ADD_DYNAMIC_SYMBOL (info
->fini_function
, DT_FINI
);
2714 /* We may have created entries in the .rela.got section.
2715 However, if we are not creating the dynamic sections, we will
2716 not actually use these entries. Reset the size of .rela.got,
2717 which will cause it to get stripped from the output file
2719 if (htab
->srelgot
!= NULL
)
2720 htab
->srelgot
->size
= 0;
2723 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2725 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2730 || s
== htab
->sgotplt
2731 || s
== htab
->sdynbss
)
2733 /* Strip this section if we don't need it. */
2735 else if (strncmp (s
->name
, ".rela", 5) == 0)
2737 if (s
->size
!= 0 && s
!= htab
->srelplt
)
2741 const char *name
= s
->name
+ 5;
2743 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
2744 if (bfd_get_flavour (ibfd
) == bfd_target_elf_flavour
2745 && ibfd
->flags
& DYNAMIC
)
2747 asection
*target
= bfd_get_section_by_name (ibfd
, name
);
2749 && elf_section_data (target
)->sreloc
== s
2750 && ((target
->output_section
->flags
2751 & (SEC_READONLY
| SEC_ALLOC
))
2752 == (SEC_READONLY
| SEC_ALLOC
)))
2754 reltext_exist
= TRUE
;
2759 relocs_exist
= TRUE
;
2762 /* We use the reloc_count field as a counter if we need to
2763 copy relocs into the output file. */
2768 /* It's not one of our sections, so don't allocate space. */
2774 s
->flags
|= SEC_EXCLUDE
;
2778 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
2781 /* Allocate memory for the section contents. */
2782 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
2783 if (s
->contents
== NULL
)
2787 if (htab
->dynamic_sections_created
)
2789 /* TODO: Check if this is needed. */
2790 if (!bfd_link_pic (info
))
2791 if (!_bfd_elf_add_dynamic_entry (info
, DT_DEBUG
, 0))
2794 if (htab
->splt
&& (htab
->splt
->flags
& SEC_EXCLUDE
) == 0)
2795 if (!_bfd_elf_add_dynamic_entry (info
, DT_PLTGOT
, 0)
2796 || !_bfd_elf_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
2797 || !_bfd_elf_add_dynamic_entry (info
, DT_PLTREL
, DT_RELA
)
2798 || !_bfd_elf_add_dynamic_entry (info
, DT_JMPREL
, 0))
2802 if (!_bfd_elf_add_dynamic_entry (info
, DT_RELA
, 0)
2803 || !_bfd_elf_add_dynamic_entry (info
, DT_RELASZ
, 0)
2804 || !_bfd_elf_add_dynamic_entry (info
, DT_RELAENT
,
2805 sizeof (Elf32_External_Rela
)))
2809 if (!_bfd_elf_add_dynamic_entry (info
, DT_TEXTREL
, 0))
2817 /* Classify dynamic relocs such that -z combreloc can reorder and combine
2819 static enum elf_reloc_type_class
2820 elf32_arc_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2821 const asection
*rel_sec ATTRIBUTE_UNUSED
,
2822 const Elf_Internal_Rela
*rela
)
2824 switch ((int) ELF32_R_TYPE (rela
->r_info
))
2826 case R_ARC_RELATIVE
:
2827 return reloc_class_relative
;
2828 case R_ARC_JMP_SLOT
:
2829 return reloc_class_plt
;
2831 return reloc_class_copy
;
2832 /* TODO: Needed in future to support ifunc. */
2834 case R_ARC_IRELATIVE:
2835 return reloc_class_ifunc;
2838 return reloc_class_normal
;
2842 const struct elf_size_info arc_elf32_size_info
=
2844 sizeof (Elf32_External_Ehdr
),
2845 sizeof (Elf32_External_Phdr
),
2846 sizeof (Elf32_External_Shdr
),
2847 sizeof (Elf32_External_Rel
),
2848 sizeof (Elf32_External_Rela
),
2849 sizeof (Elf32_External_Sym
),
2850 sizeof (Elf32_External_Dyn
),
2851 sizeof (Elf_External_Note
),
2855 ELFCLASS32
, EV_CURRENT
,
2856 bfd_elf32_write_out_phdrs
,
2857 bfd_elf32_write_shdrs_and_ehdr
,
2858 bfd_elf32_checksum_contents
,
2859 bfd_elf32_write_relocs
,
2860 bfd_elf32_swap_symbol_in
,
2861 bfd_elf32_swap_symbol_out
,
2862 bfd_elf32_slurp_reloc_table
,
2863 bfd_elf32_slurp_symbol_table
,
2864 bfd_elf32_swap_dyn_in
,
2865 bfd_elf32_swap_dyn_out
,
2866 bfd_elf32_swap_reloc_in
,
2867 bfd_elf32_swap_reloc_out
,
2868 bfd_elf32_swap_reloca_in
,
2869 bfd_elf32_swap_reloca_out
2872 #define elf_backend_size_info arc_elf32_size_info
2874 /* GDB expects general purpose registers to be in section .reg. However Linux
2875 kernel doesn't create this section and instead writes registers to NOTE
2876 section. It is up to the binutils to create a pseudo-section .reg from the
2877 contents of NOTE. Also BFD will read pid and signal number from NOTE. This
2878 function relies on offsets inside elf_prstatus structure in Linux to be
2882 elf32_arc_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
2887 switch (note
->descsz
)
2892 case 236: /* sizeof (struct elf_prstatus) on Linux/arc. */
2894 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
2896 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
2899 size
= (40 * 4); /* There are 40 registers in user_regs_struct. */
2902 /* Make a ".reg/999" section. */
2903 return _bfd_elfcore_make_pseudosection (abfd
, ".reg", size
,
2904 note
->descpos
+ offset
);
2907 /* Determine whether an object attribute tag takes an integer, a
2911 elf32_arc_obj_attrs_arg_type (int tag
)
2913 if (tag
== Tag_ARC_CPU_name
2914 || tag
== Tag_ARC_ISA_config
2915 || tag
== Tag_ARC_ISA_apex
)
2916 return ATTR_TYPE_FLAG_STR_VAL
;
2917 else if (tag
< (Tag_ARC_ISA_mpy_option
+ 1))
2918 return ATTR_TYPE_FLAG_INT_VAL
;
2920 return (tag
& 1) != 0 ? ATTR_TYPE_FLAG_STR_VAL
: ATTR_TYPE_FLAG_INT_VAL
;
2923 /* Attribute numbers >=14 can be safely ignored. */
2926 elf32_arc_obj_attrs_handle_unknown (bfd
*abfd
, int tag
)
2928 if ((tag
& 127) < (Tag_ARC_ISA_mpy_option
+ 1))
2931 (_("%pB: unknown mandatory ARC object attribute %d"),
2933 bfd_set_error (bfd_error_bad_value
);
2939 (_("warning: %pB: unknown ARC object attribute %d"),
2945 /* Handle an ARC specific section when reading an object file. This is
2946 called when bfd_section_from_shdr finds a section with an unknown
2950 elf32_arc_section_from_shdr (bfd
*abfd
,
2951 Elf_Internal_Shdr
* hdr
,
2955 switch (hdr
->sh_type
)
2957 case 0x0c: /* MWDT specific section, don't complain about it. */
2958 case SHT_ARC_ATTRIBUTES
:
2965 if (!_bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2971 #define TARGET_LITTLE_SYM arc_elf32_le_vec
2972 #define TARGET_LITTLE_NAME "elf32-littlearc"
2973 #define TARGET_BIG_SYM arc_elf32_be_vec
2974 #define TARGET_BIG_NAME "elf32-bigarc"
2975 #define ELF_ARCH bfd_arch_arc
2976 #define ELF_TARGET_ID ARC_ELF_DATA
2977 #define ELF_MACHINE_CODE EM_ARC_COMPACT
2978 #define ELF_MACHINE_ALT1 EM_ARC_COMPACT2
2979 #define ELF_MAXPAGESIZE 0x2000
2981 #define bfd_elf32_bfd_link_hash_table_create arc_elf_link_hash_table_create
2983 #define bfd_elf32_bfd_merge_private_bfd_data arc_elf_merge_private_bfd_data
2984 #define bfd_elf32_bfd_reloc_type_lookup arc_elf32_bfd_reloc_type_lookup
2985 #define bfd_elf32_bfd_set_private_flags arc_elf_set_private_flags
2986 #define bfd_elf32_bfd_print_private_bfd_data arc_elf_print_private_bfd_data
2987 #define bfd_elf32_bfd_copy_private_bfd_data arc_elf_copy_private_bfd_data
2989 #define elf_info_to_howto_rel arc_info_to_howto_rel
2990 #define elf_backend_object_p arc_elf_object_p
2991 #define elf_backend_final_write_processing arc_elf_final_write_processing
2993 #define elf_backend_relocate_section elf_arc_relocate_section
2994 #define elf_backend_check_relocs elf_arc_check_relocs
2995 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
2997 #define elf_backend_reloc_type_class elf32_arc_reloc_type_class
2999 #define elf_backend_adjust_dynamic_symbol elf_arc_adjust_dynamic_symbol
3000 #define elf_backend_finish_dynamic_symbol elf_arc_finish_dynamic_symbol
3002 #define elf_backend_finish_dynamic_sections elf_arc_finish_dynamic_sections
3003 #define elf_backend_size_dynamic_sections elf_arc_size_dynamic_sections
3005 #define elf_backend_can_gc_sections 1
3006 #define elf_backend_want_got_plt 1
3007 #define elf_backend_plt_readonly 1
3008 #define elf_backend_rela_plts_and_copies_p 1
3009 #define elf_backend_want_plt_sym 0
3010 #define elf_backend_got_header_size 12
3011 #define elf_backend_dtrel_excludes_plt 1
3013 #define elf_backend_may_use_rel_p 0
3014 #define elf_backend_may_use_rela_p 1
3015 #define elf_backend_default_use_rela_p 1
3017 #define elf_backend_grok_prstatus elf32_arc_grok_prstatus
3019 #define elf_backend_default_execstack 0
3021 #undef elf_backend_obj_attrs_vendor
3022 #define elf_backend_obj_attrs_vendor "ARC"
3023 #undef elf_backend_obj_attrs_section
3024 #define elf_backend_obj_attrs_section ".ARC.attributes"
3025 #undef elf_backend_obj_attrs_arg_type
3026 #define elf_backend_obj_attrs_arg_type elf32_arc_obj_attrs_arg_type
3027 #undef elf_backend_obj_attrs_section_type
3028 #define elf_backend_obj_attrs_section_type SHT_ARC_ATTRIBUTES
3029 #define elf_backend_obj_attrs_handle_unknown elf32_arc_obj_attrs_handle_unknown
3031 #define elf_backend_section_from_shdr elf32_arc_section_from_shdr
3033 #include "elf32-target.h"