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). */
100 bfd_get_32_me (bfd
* abfd
,const unsigned char * data
)
104 if (bfd_big_endian(abfd
)) {
105 value
= bfd_get_32 (abfd
, data
);
108 value
= ((bfd_get_8 (abfd
, data
) & 255) << 16);
109 value
|= ((bfd_get_8 (abfd
, data
+ 1) & 255) << 24);
110 value
|= (bfd_get_8 (abfd
, data
+ 2) & 255);
111 value
|= ((bfd_get_8 (abfd
, data
+ 3) & 255) << 8);
118 bfd_put_32_me (bfd
*abfd
, bfd_vma value
,unsigned char *data
)
120 bfd_put_16 (abfd
, (value
& 0xffff0000) >> 16, data
);
121 bfd_put_16 (abfd
, value
& 0xffff, data
+ 2);
124 static ATTRIBUTE_UNUSED bfd_boolean
125 is_reloc_PC_relative (reloc_howto_type
*howto
)
127 return (strstr (howto
->name
, "PC") != NULL
) ? TRUE
: FALSE
;
131 is_reloc_SDA_relative (reloc_howto_type
*howto
)
133 return (strstr (howto
->name
, "SDA") != NULL
) ? TRUE
: FALSE
;
137 is_reloc_for_GOT (reloc_howto_type
* howto
)
139 if (strstr (howto
->name
, "TLS") != NULL
)
141 return (strstr (howto
->name
, "GOT") != NULL
) ? TRUE
: FALSE
;
145 is_reloc_for_PLT (reloc_howto_type
* howto
)
147 return (strstr (howto
->name
, "PLT") != NULL
) ? TRUE
: FALSE
;
151 is_reloc_for_TLS (reloc_howto_type
*howto
)
153 return (strstr (howto
->name
, "TLS") != NULL
) ? TRUE
: FALSE
;
156 struct arc_relocation_data
158 bfd_signed_vma reloc_offset
;
159 bfd_signed_vma reloc_addend
;
160 bfd_signed_vma got_offset_value
;
162 bfd_signed_vma sym_value
;
163 asection
* sym_section
;
165 reloc_howto_type
*howto
;
167 asection
* input_section
;
169 bfd_signed_vma sdata_begin_symbol_vma
;
170 bfd_boolean sdata_begin_symbol_vma_set
;
171 bfd_signed_vma got_symbol_vma
;
173 bfd_boolean should_relocate
;
175 const char * symbol_name
;
178 /* ARC ELF linker hash entry. */
179 struct elf_arc_link_hash_entry
181 struct elf_link_hash_entry root
;
183 /* Track dynamic relocs copied for this symbol. */
184 struct elf_dyn_relocs
*dyn_relocs
;
186 struct got_entry
*got_ents
;
190 /* Should be included at this location due to static declarations
191 defined before this point. */
194 #define arc_bfd_get_8(A,B,C) bfd_get_8(A,B)
195 #define arc_bfd_get_16(A,B,C) bfd_get_16(A,B)
196 #define arc_bfd_get_32(A,B,C) bfd_get_32(A,B)
197 #define arc_bfd_put_8(A,B,C,D) bfd_put_8(A,B,C)
198 #define arc_bfd_put_16(A,B,C,D) bfd_put_16(A,B,C)
199 #define arc_bfd_put_32(A,B,C,D) bfd_put_32(A,B,C)
202 static bfd_reloc_status_type
203 arc_elf_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
204 arelent
*reloc_entry
,
206 void *data ATTRIBUTE_UNUSED
,
207 asection
*input_section
,
209 char ** error_message ATTRIBUTE_UNUSED
)
211 if (output_bfd
!= NULL
)
213 reloc_entry
->address
+= input_section
->output_offset
;
215 /* In case of relocateable link and if the reloc is against a
216 section symbol, the addend needs to be adjusted according to
217 where the section symbol winds up in the output section. */
218 if ((symbol_in
->flags
& BSF_SECTION_SYM
) && symbol_in
->section
)
219 reloc_entry
->addend
+= symbol_in
->section
->output_offset
;
224 return bfd_reloc_continue
;
228 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
233 #include "elf/arc-reloc.def"
237 #undef ARC_RELOC_HOWTO
239 #define ARC_RELOC_HOWTO(TYPE, VALUE, RSIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
240 [TYPE] = HOWTO (R_##TYPE, 0, RSIZE, BITSIZE, FALSE, 0, \
241 complain_overflow_##OVERFLOW, arc_elf_reloc, \
242 "R_" #TYPE, FALSE, 0, 0, FALSE),
244 static struct reloc_howto_struct elf_arc_howto_table
[] =
246 #include "elf/arc-reloc.def"
247 /* Example of what is generated by the preprocessor. Currently kept as an
249 HOWTO (R_ARC_NONE, // Type.
251 2, // Size (0 = byte, 1 = short, 2 = long).
253 FALSE, // PC_relative.
255 complain_overflow_bitfield, // Complain_on_overflow.
256 bfd_elf_generic_reloc, // Special_function.
257 "R_ARC_NONE", // Name.
258 TRUE, // Partial_inplace.
261 FALSE), // PCrel_offset.
264 #undef ARC_RELOC_HOWTO
267 arc_elf_howto_init (void)
269 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
270 elf_arc_howto_table[TYPE].pc_relative = \
271 (strstr (#FORMULA, " P ") != NULL || strstr (#FORMULA, " PDATA ") != NULL); \
272 elf_arc_howto_table[TYPE].dst_mask = RELOC_FUNCTION(0, ~0); \
273 /* Only 32 bit data relocations should be marked as ME. */ \
274 if (strstr (#FORMULA, " ME ") != NULL) \
276 BFD_ASSERT (SIZE == 2); \
279 #include "elf/arc-reloc.def"
282 #undef ARC_RELOC_HOWTO
285 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
288 const int howto_table_lookup
[] =
290 #include "elf/arc-reloc.def"
293 #undef ARC_RELOC_HOWTO
295 static reloc_howto_type
*
296 arc_elf_howto (unsigned int r_type
)
298 if (elf_arc_howto_table
[R_ARC_32
].dst_mask
== 0)
299 arc_elf_howto_init ();
300 return &elf_arc_howto_table
[r_type
];
303 /* Map BFD reloc types to ARC ELF reloc types. */
307 bfd_reloc_code_real_type bfd_reloc_val
;
308 unsigned char elf_reloc_val
;
311 /* ARC ELF linker hash table. */
312 struct elf_arc_link_hash_table
314 struct elf_link_hash_table elf
;
317 static struct bfd_hash_entry
*
318 elf_arc_link_hash_newfunc (struct bfd_hash_entry
*entry
,
319 struct bfd_hash_table
*table
,
322 struct elf_arc_link_hash_entry
* ret
=
323 (struct elf_arc_link_hash_entry
*) entry
;
325 /* Allocate the structure if it has not already been allocated by a
328 ret
= (struct elf_arc_link_hash_entry
*)
329 bfd_hash_allocate (table
, sizeof (struct elf_arc_link_hash_entry
));
331 return (struct bfd_hash_entry
*) ret
;
333 /* Call the allocation method of the superclass. */
334 ret
= ((struct elf_arc_link_hash_entry
*)
335 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
339 ret
->dyn_relocs
= NULL
;
340 ret
->got_ents
= NULL
;
343 return (struct bfd_hash_entry
*) ret
;
346 /* Destroy an ARC ELF linker hash table. */
348 elf_arc_link_hash_table_free (bfd
*obfd
)
350 _bfd_elf_link_hash_table_free (obfd
);
353 /* Create an ARC ELF linker hash table. */
355 static struct bfd_link_hash_table
*
356 arc_elf_link_hash_table_create (bfd
*abfd
)
358 struct elf_arc_link_hash_table
*ret
;
360 ret
= (struct elf_arc_link_hash_table
*) bfd_zmalloc (sizeof (*ret
));
364 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
365 elf_arc_link_hash_newfunc
,
366 sizeof (struct elf_arc_link_hash_entry
),
373 ret
->elf
.root
.hash_table_free
= elf_arc_link_hash_table_free
;
375 return &ret
->elf
.root
;
378 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
379 { BFD_RELOC_##TYPE, R_##TYPE },
381 static const struct arc_reloc_map arc_reloc_map
[] =
383 #include "elf/arc-reloc.def"
385 {BFD_RELOC_NONE
, R_ARC_NONE
},
386 {BFD_RELOC_8
, R_ARC_8
},
387 {BFD_RELOC_16
, R_ARC_16
},
388 {BFD_RELOC_24
, R_ARC_24
},
389 {BFD_RELOC_32
, R_ARC_32
},
392 #undef ARC_RELOC_HOWTO
394 typedef ATTRIBUTE_UNUSED
bfd_vma (*replace_func
) (unsigned, int ATTRIBUTE_UNUSED
);
396 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
398 func = (void *) RELOC_FUNCTION; \
402 get_replace_function (bfd
*abfd
, unsigned int r_type
)
408 #include "elf/arc-reloc.def"
411 if (func
== replace_bits24
&& bfd_big_endian (abfd
))
412 func
= replace_bits24_be
;
414 return (replace_func
) func
;
416 #undef ARC_RELOC_HOWTO
418 static reloc_howto_type
*
419 arc_elf32_bfd_reloc_type_lookup (bfd
* abfd ATTRIBUTE_UNUSED
,
420 bfd_reloc_code_real_type code
)
424 for (i
= ARRAY_SIZE (arc_reloc_map
); i
--;)
426 if (arc_reloc_map
[i
].bfd_reloc_val
== code
)
427 return arc_elf_howto (arc_reloc_map
[i
].elf_reloc_val
);
433 /* Function to set the ELF flag bits. */
435 arc_elf_set_private_flags (bfd
*abfd
, flagword flags
)
437 elf_elfheader (abfd
)->e_flags
= flags
;
438 elf_flags_init (abfd
) = TRUE
;
442 /* Print private flags. */
444 arc_elf_print_private_bfd_data (bfd
*abfd
, void * ptr
)
446 FILE *file
= (FILE *) ptr
;
449 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
451 /* Print normal ELF private data. */
452 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
454 flags
= elf_elfheader (abfd
)->e_flags
;
455 fprintf (file
, _("private flags = 0x%lx:"), (unsigned long) flags
);
457 switch (flags
& EF_ARC_MACH_MSK
)
459 case EF_ARC_CPU_ARCV2HS
: fprintf (file
, " -mcpu=ARCv2HS"); break;
460 case EF_ARC_CPU_ARCV2EM
: fprintf (file
, " -mcpu=ARCv2EM"); break;
461 case E_ARC_MACH_ARC600
: fprintf (file
, " -mcpu=ARC600"); break;
462 case E_ARC_MACH_ARC601
: fprintf (file
, " -mcpu=ARC601"); break;
463 case E_ARC_MACH_ARC700
: fprintf (file
, " -mcpu=ARC700"); break;
465 fprintf (file
, "-mcpu=unknown");
469 switch (flags
& EF_ARC_OSABI_MSK
)
471 case E_ARC_OSABI_ORIG
: fprintf (file
, " (ABI:legacy)"); break;
472 case E_ARC_OSABI_V2
: fprintf (file
, " (ABI:v2)"); break;
473 case E_ARC_OSABI_V3
: fprintf (file
, " (ABI:v3)"); break;
474 case E_ARC_OSABI_V4
: fprintf (file
, " (ABI:v4)"); break;
476 fprintf (file
, " (ABI:unknown)");
484 /* Copy backend specific data from one object module to another. */
487 arc_elf_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
489 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
490 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
493 BFD_ASSERT (!elf_flags_init (obfd
)
494 || elf_elfheader (obfd
)->e_flags
== elf_elfheader (ibfd
)->e_flags
);
496 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
497 elf_flags_init (obfd
) = TRUE
;
499 /* Copy object attributes. */
500 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
502 return _bfd_elf_copy_private_bfd_data (ibfd
, obfd
);
505 static reloc_howto_type
*
506 bfd_elf32_bfd_reloc_name_lookup (bfd
* abfd ATTRIBUTE_UNUSED
,
511 for (i
= 0; i
< ARRAY_SIZE (elf_arc_howto_table
); i
++)
512 if (elf_arc_howto_table
[i
].name
!= NULL
513 && strcasecmp (elf_arc_howto_table
[i
].name
, r_name
) == 0)
514 return arc_elf_howto (i
);
519 /* Set the howto pointer for an ARC ELF reloc. */
522 arc_info_to_howto_rel (bfd
* abfd
,
524 Elf_Internal_Rela
* dst
)
528 r_type
= ELF32_R_TYPE (dst
->r_info
);
529 if (r_type
>= (unsigned int) R_ARC_max
)
531 /* xgettext:c-format */
532 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
534 bfd_set_error (bfd_error_bad_value
);
538 cache_ptr
->howto
= arc_elf_howto (r_type
);
542 /* Extract CPU features from an NTBS. */
545 arc_extract_features (const char *p
)
552 for (i
= 0; i
< ARRAY_SIZE (bfd_feature_list
); i
++)
554 char *t
= strstr (p
, bfd_feature_list
[i
].attr
);
555 unsigned l
= strlen (bfd_feature_list
[i
].attr
);
559 r
|= bfd_feature_list
[i
].feature
;
565 /* Concatenate two strings. s1 can be NULL but not
569 arc_stralloc (char * s1
, const char * s2
)
573 /* Only s1 can be null. */
576 p
= s1
? concat (s1
, ",", s2
, NULL
) : (char *)s2
;
581 /* Merge ARC object attributes from IBFD into OBFD. Raise an error if
582 there are conflicting attributes. */
585 arc_elf_merge_attributes (bfd
*ibfd
, struct bfd_link_info
*info
)
587 bfd
*obfd
= info
->output_bfd
;
588 obj_attribute
*in_attr
;
589 obj_attribute
*out_attr
;
591 bfd_boolean result
= TRUE
;
592 const char *sec_name
= get_elf_backend_data (ibfd
)->obj_attrs_section
;
593 char *tagname
= NULL
;
595 /* Skip the linker stubs file. This preserves previous behavior
596 of accepting unknown attributes in the first input file - but
598 if (ibfd
->flags
& BFD_LINKER_CREATED
)
601 /* Skip any input that hasn't attribute section.
602 This enables to link object files without attribute section with
604 if (bfd_get_section_by_name (ibfd
, sec_name
) == NULL
)
607 if (!elf_known_obj_attributes_proc (obfd
)[0].i
)
609 /* This is the first object. Copy the attributes. */
610 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
612 out_attr
= elf_known_obj_attributes_proc (obfd
);
614 /* Use the Tag_null value to indicate the attributes have been
621 in_attr
= elf_known_obj_attributes_proc (ibfd
);
622 out_attr
= elf_known_obj_attributes_proc (obfd
);
624 for (i
= LEAST_KNOWN_OBJ_ATTRIBUTE
; i
< NUM_KNOWN_OBJ_ATTRIBUTES
; i
++)
626 /* Merge this attribute with existing attributes. */
629 case Tag_ARC_PCS_config
:
630 if (out_attr
[i
].i
== 0)
631 out_attr
[i
].i
= in_attr
[i
].i
;
632 else if (in_attr
[i
].i
!= 0 && out_attr
[i
].i
!= in_attr
[i
].i
)
634 const char *tagval
[] = { "Absent", "Bare-metal/mwdt",
635 "Bare-metal/newlib", "Linux/uclibc",
637 BFD_ASSERT (in_attr
[i
].i
< 5);
638 BFD_ASSERT (out_attr
[i
].i
< 5);
639 /* It's sometimes ok to mix different configs, so this is only
642 (_("warning: %pB: conflicting platform configuration "
644 tagval
[in_attr
[i
].i
],
645 tagval
[out_attr
[i
].i
]);
649 case Tag_ARC_CPU_base
:
650 if (out_attr
[i
].i
== 0)
651 out_attr
[i
].i
= in_attr
[i
].i
;
652 else if (in_attr
[i
].i
!= 0 && out_attr
[i
].i
!= in_attr
[i
].i
653 && ((out_attr
[i
].i
+ in_attr
[i
].i
) < 6))
655 const char *tagval
[] = { "Absent", "ARC6xx", "ARC7xx",
657 BFD_ASSERT (in_attr
[i
].i
< 5);
658 BFD_ASSERT (out_attr
[i
].i
< 5);
659 /* We cannot mix code for different CPUs. */
661 (_("error: %pB: unable to merge CPU base attributes "
664 tagval
[in_attr
[i
].i
],
665 tagval
[out_attr
[i
].i
]);
671 /* The CPUs may be different, check if we can still mix
672 the objects against the output choosen CPU. */
673 unsigned in_feature
= 0;
674 unsigned out_feature
= 0;
675 char *p1
= in_attr
[Tag_ARC_ISA_config
].s
;
676 char *p2
= out_attr
[Tag_ARC_ISA_config
].s
;
679 unsigned opcode_map
[] = {0, ARC_OPCODE_ARC600
, ARC_OPCODE_ARC700
,
680 ARC_OPCODE_ARCv2EM
, ARC_OPCODE_ARCv2HS
};
682 BFD_ASSERT (in_attr
[i
].i
< (sizeof (opcode_map
)
683 / sizeof (unsigned)));
684 BFD_ASSERT (out_attr
[i
].i
< (sizeof (opcode_map
)
685 / sizeof (unsigned)));
686 cpu_out
= opcode_map
[out_attr
[i
].i
];
688 in_feature
= arc_extract_features (p1
);
689 out_feature
= arc_extract_features (p2
);
691 /* First, check if a feature is compatible with the
692 output object chosen CPU. */
693 for (j
= 0; j
< ARRAY_SIZE (bfd_feature_list
); j
++)
694 if (((in_feature
| out_feature
) & bfd_feature_list
[j
].feature
)
695 && (!(cpu_out
& bfd_feature_list
[j
].cpus
)))
698 (_("error: %pB: unable to merge ISA extension attributes "
700 obfd
, bfd_feature_list
[j
].name
);
704 /* Second, if we have compatible features with the
705 chosen CPU, check if they are compatible among
707 for (j
= 0; j
< ARRAY_SIZE (bfd_conflict_list
); j
++)
708 if (((in_feature
| out_feature
) & bfd_conflict_list
[j
])
709 == bfd_conflict_list
[j
])
712 for (k
= 0; k
< ARRAY_SIZE (bfd_feature_list
); k
++)
714 if (in_feature
& bfd_feature_list
[k
].feature
715 & bfd_conflict_list
[j
])
716 p1
= (char *) bfd_feature_list
[k
].name
;
717 if (out_feature
& bfd_feature_list
[k
].feature
718 & bfd_conflict_list
[j
])
719 p2
= (char *) bfd_feature_list
[k
].name
;
722 (_("error: %pB: conflicting ISA extension attributes "
728 /* Everithing is alright. */
729 out_feature
|= in_feature
;
731 for (j
= 0; j
< ARRAY_SIZE (bfd_feature_list
); j
++)
732 if (out_feature
& bfd_feature_list
[j
].feature
)
733 p1
= arc_stralloc (p1
, bfd_feature_list
[j
].attr
);
735 out_attr
[Tag_ARC_ISA_config
].s
=
736 _bfd_elf_attr_strdup (obfd
, p1
);
739 case Tag_ARC_CPU_variation
:
740 case Tag_ARC_ISA_mpy_option
:
741 case Tag_ARC_ABI_osver
:
742 /* Use the largest value specified. */
743 if (in_attr
[i
].i
> out_attr
[i
].i
)
744 out_attr
[i
].i
= in_attr
[i
].i
;
747 /* The CPU name is given by the vendor, just choose an
748 existing one if missing or different. There are no fail
749 criteria if they different or both missing. */
750 case Tag_ARC_CPU_name
:
751 if (!out_attr
[i
].s
&& in_attr
[i
].s
)
752 out_attr
[i
].s
= _bfd_elf_attr_strdup (obfd
, in_attr
[i
].s
);
755 case Tag_ARC_ABI_rf16
:
756 if (out_attr
[i
].i
== 0)
757 out_attr
[i
].i
= in_attr
[i
].i
;
758 else if (out_attr
[i
].i
!= in_attr
[i
].i
)
760 /* We cannot mix code with rf16 and without. */
762 (_("error: %pB: cannot mix rf16 with full register set %pB"),
768 case Tag_ARC_ABI_pic
:
771 case Tag_ARC_ABI_sda
:
775 case Tag_ARC_ABI_tls
:
777 const char *tagval
[] = { "Absent", "MWDT", "GNU" };
782 BFD_ASSERT (in_attr
[i
].i
< 3);
783 BFD_ASSERT (out_attr
[i
].i
< 3);
784 if (out_attr
[i
].i
== 0)
785 out_attr
[i
].i
= in_attr
[i
].i
;
786 else if (out_attr
[i
].i
!= 0 && in_attr
[i
].i
!= 0
787 && out_attr
[i
].i
!= in_attr
[i
].i
)
790 (_("error: %pB: conflicting attributes %s: %s with %s"),
792 tagval
[in_attr
[i
].i
],
793 tagval
[out_attr
[i
].i
]);
800 case Tag_ARC_ABI_double_size
:
801 tagname
= "Double size";
803 case Tag_ARC_ABI_enumsize
:
805 tagname
= "Enum size";
807 case Tag_ARC_ABI_exceptions
:
809 tagname
= "ABI exceptions";
811 if (out_attr
[i
].i
== 0)
812 out_attr
[i
].i
= in_attr
[i
].i
;
813 else if (out_attr
[i
].i
!= 0 && in_attr
[i
].i
!= 0
814 && out_attr
[i
].i
!= in_attr
[i
].i
)
817 (_("error: %pB: conflicting attributes %s"),
823 case Tag_ARC_ISA_apex
:
824 break; /* Do nothing for APEX attributes. */
826 case Tag_ARC_ISA_config
:
827 /* It is handled in Tag_ARC_CPU_base. */
830 case Tag_ARC_ATR_version
:
831 if (out_attr
[i
].i
== 0)
832 out_attr
[i
].i
= in_attr
[i
].i
;
837 = result
&& _bfd_elf_merge_unknown_attribute_low (ibfd
, obfd
, i
);
840 /* If out_attr was copied from in_attr then it won't have a type yet. */
841 if (in_attr
[i
].type
&& !out_attr
[i
].type
)
842 out_attr
[i
].type
= in_attr
[i
].type
;
845 /* Merge Tag_compatibility attributes and any common GNU ones. */
846 if (!_bfd_elf_merge_object_attributes (ibfd
, info
))
849 /* Check for any attributes not known on ARC. */
850 result
&= _bfd_elf_merge_unknown_attribute_list (ibfd
, obfd
);
855 /* Merge backend specific data from an object file to the output
856 object file when linking. */
859 arc_elf_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
861 bfd
*obfd
= info
->output_bfd
;
862 unsigned short mach_ibfd
;
863 static unsigned short mach_obfd
= EM_NONE
;
868 /* Check if we have the same endianess. */
869 if (! _bfd_generic_verify_endian_match (ibfd
, info
))
872 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
873 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
876 /* Collect ELF flags. */
877 in_flags
= elf_elfheader (ibfd
)->e_flags
& EF_ARC_MACH_MSK
;
878 out_flags
= elf_elfheader (obfd
)->e_flags
& EF_ARC_MACH_MSK
;
880 if (!elf_flags_init (obfd
)) /* First call, no flags set. */
882 elf_flags_init (obfd
) = TRUE
;
883 out_flags
= in_flags
;
886 if (!arc_elf_merge_attributes (ibfd
, info
))
889 /* Check to see if the input BFD actually contains any sections. Do
890 not short-circuit dynamic objects; their section list may be
891 emptied by elf_link_add_object_symbols. */
892 if (!(ibfd
->flags
& DYNAMIC
))
894 bfd_boolean null_input_bfd
= TRUE
;
895 bfd_boolean only_data_sections
= TRUE
;
897 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
899 if ((bfd_get_section_flags (ibfd
, sec
)
900 & (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
901 == (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
902 only_data_sections
= FALSE
;
904 null_input_bfd
= FALSE
;
907 if (null_input_bfd
|| only_data_sections
)
911 /* Complain about various flag/architecture mismatches. */
912 mach_ibfd
= elf_elfheader (ibfd
)->e_machine
;
913 if (mach_obfd
== EM_NONE
)
915 mach_obfd
= mach_ibfd
;
919 if (mach_ibfd
!= mach_obfd
)
921 /* xgettext:c-format */
922 _bfd_error_handler (_("error: attempting to link %pB "
923 "with a binary %pB of different architecture"),
927 else if ((in_flags
!= out_flags
)
928 /* If we have object attributes, then we already
929 checked the objects compatibility, skip it. */
930 && !bfd_elf_get_obj_attr_int (ibfd
, OBJ_ATTR_PROC
,
933 if (in_flags
&& out_flags
)
935 /* Warn if different flags. */
937 /* xgettext:c-format */
938 (_("%pB: uses different e_flags (%#x) fields than "
939 "previous modules (%#x)"),
940 ibfd
, in_flags
, out_flags
);
943 /* MWDT doesnt set the eflags hence make sure we choose the
944 eflags set by gcc. */
945 in_flags
= in_flags
> out_flags
? in_flags
: out_flags
;
949 /* Everything is correct; don't change the output flags. */
950 in_flags
= out_flags
;
954 /* Update the flags. */
955 elf_elfheader (obfd
)->e_flags
= in_flags
;
957 if (bfd_get_mach (obfd
) < bfd_get_mach (ibfd
))
959 return bfd_set_arch_mach (obfd
, bfd_arch_arc
, bfd_get_mach (ibfd
));
965 /* Return a best guess for the machine number based on the attributes. */
968 bfd_arc_get_mach_from_attributes (bfd
* abfd
)
970 int arch
= bfd_elf_get_obj_attr_int (abfd
, OBJ_ATTR_PROC
, Tag_ARC_CPU_base
);
971 unsigned e_machine
= elf_elfheader (abfd
)->e_machine
;
976 return bfd_mach_arc_arc600
;
978 return bfd_mach_arc_arc700
;
981 return bfd_mach_arc_arcv2
;
985 return (e_machine
== EM_ARC_COMPACT
)
986 ? bfd_mach_arc_arc700
: bfd_mach_arc_arcv2
;
989 /* Set the right machine number for an ARC ELF file. */
991 arc_elf_object_p (bfd
* abfd
)
993 /* Make sure this is initialised, or you'll have the potential of passing
994 garbage---or misleading values---into the call to
995 bfd_default_set_arch_mach (). */
996 unsigned int mach
= bfd_mach_arc_arc700
;
997 unsigned long arch
= elf_elfheader (abfd
)->e_flags
& EF_ARC_MACH_MSK
;
998 unsigned e_machine
= elf_elfheader (abfd
)->e_machine
;
1000 if (e_machine
== EM_ARC_COMPACT
|| e_machine
== EM_ARC_COMPACT2
)
1004 case E_ARC_MACH_ARC600
:
1005 mach
= bfd_mach_arc_arc600
;
1007 case E_ARC_MACH_ARC601
:
1008 mach
= bfd_mach_arc_arc601
;
1010 case E_ARC_MACH_ARC700
:
1011 mach
= bfd_mach_arc_arc700
;
1013 case EF_ARC_CPU_ARCV2HS
:
1014 case EF_ARC_CPU_ARCV2EM
:
1015 mach
= bfd_mach_arc_arcv2
;
1018 mach
= bfd_arc_get_mach_from_attributes (abfd
);
1024 if (e_machine
== EM_ARC
)
1027 (_("error: the ARC4 architecture is no longer supported"));
1033 (_("warning: unset or old architecture flags; "
1034 "use default machine"));
1038 return bfd_default_set_arch_mach (abfd
, bfd_arch_arc
, mach
);
1041 /* The final processing done just before writing out an ARC ELF object file.
1042 This gets the ARC architecture right based on the machine number. */
1045 arc_elf_final_write_processing (bfd
*abfd
)
1048 int osver
= bfd_elf_get_obj_attr_int (abfd
, OBJ_ATTR_PROC
,
1050 flagword e_flags
= elf_elfheader (abfd
)->e_flags
& ~EF_ARC_OSABI_MSK
;
1052 switch (bfd_get_mach (abfd
))
1054 case bfd_mach_arc_arcv2
:
1055 emf
= EM_ARC_COMPACT2
;
1058 emf
= EM_ARC_COMPACT
;
1062 elf_elfheader (abfd
)->e_machine
= emf
;
1064 /* Record whatever is the current syscall ABI version. */
1066 e_flags
|= ((osver
& 0x0f) << 8);
1068 e_flags
|= E_ARC_OSABI_V3
;
1070 elf_elfheader (abfd
)->e_flags
|= e_flags
;
1071 return _bfd_elf_final_write_processing (abfd
);
1074 #ifdef ARC_ENABLE_DEBUG
1075 #define DEBUG_ARC_RELOC(A) debug_arc_reloc (A)
1078 debug_arc_reloc (struct arc_relocation_data reloc_data
)
1080 ARC_DEBUG ("Reloc type=%s, should_relocate = %s\n",
1081 reloc_data
.howto
->name
,
1082 reloc_data
.should_relocate
? "true" : "false");
1083 ARC_DEBUG (" offset = 0x%x, addend = 0x%x\n",
1084 (unsigned int) reloc_data
.reloc_offset
,
1085 (unsigned int) reloc_data
.reloc_addend
);
1086 ARC_DEBUG (" Symbol:\n");
1087 ARC_DEBUG (" value = 0x%08x\n",
1088 (unsigned int) reloc_data
.sym_value
);
1089 if (reloc_data
.sym_section
!= NULL
)
1091 ARC_DEBUG (" Symbol Section:\n");
1092 ARC_DEBUG (" section name = %s, output_offset 0x%08x",
1093 reloc_data
.sym_section
->name
,
1094 (unsigned int) reloc_data
.sym_section
->output_offset
);
1095 if (reloc_data
.sym_section
->output_section
!= NULL
)
1096 ARC_DEBUG (", output_section->vma = 0x%08x",
1097 ((unsigned int) reloc_data
.sym_section
->output_section
->vma
));
1099 if (reloc_data
.sym_section
->owner
&& reloc_data
.sym_section
->owner
->filename
)
1100 ARC_DEBUG (" file: %s\n", reloc_data
.sym_section
->owner
->filename
);
1104 ARC_DEBUG (" symbol section is NULL\n");
1107 ARC_DEBUG (" Input_section:\n");
1108 if (reloc_data
.input_section
!= NULL
)
1110 ARC_DEBUG (" section name = %s, output_offset 0x%08x, output_section->vma = 0x%08x\n",
1111 reloc_data
.input_section
->name
,
1112 (unsigned int) reloc_data
.input_section
->output_offset
,
1113 (unsigned int) reloc_data
.input_section
->output_section
->vma
);
1114 ARC_DEBUG (" changed_address = 0x%08x\n",
1115 (unsigned int) (reloc_data
.input_section
->output_section
->vma
1116 + reloc_data
.input_section
->output_offset
1117 + reloc_data
.reloc_offset
));
1118 ARC_DEBUG (" file: %s\n", reloc_data
.input_section
->owner
->filename
);
1122 ARC_DEBUG (" input section is NULL\n");
1126 #define DEBUG_ARC_RELOC(A)
1127 #endif /* ARC_ENABLE_DEBUG */
1130 middle_endian_convert (bfd_vma insn
, bfd_boolean do_it
)
1135 = ((insn
& 0xffff0000) >> 16)
1136 | ((insn
& 0xffff) << 16);
1141 /* This function is called for relocations that are otherwise marked as NOT
1142 requiring overflow checks. In here we perform non-standard checks of
1143 the relocation value. */
1145 static inline bfd_reloc_status_type
1146 arc_special_overflow_checks (const struct arc_relocation_data reloc_data
,
1147 bfd_signed_vma relocation
,
1148 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1150 switch (reloc_data
.howto
->type
)
1152 case R_ARC_NPS_CMEM16
:
1153 if (((relocation
>> 16) & 0xffff) != NPS_CMEM_HIGH_VALUE
)
1155 if (reloc_data
.reloc_addend
== 0)
1157 /* xgettext:c-format */
1158 (_("%pB(%pA+%#" PRIx64
"): CMEM relocation to `%s' is invalid, "
1159 "16 MSB should be %#x (value is %#" PRIx64
")"),
1160 reloc_data
.input_section
->owner
,
1161 reloc_data
.input_section
,
1162 (uint64_t) reloc_data
.reloc_offset
,
1163 reloc_data
.symbol_name
,
1164 NPS_CMEM_HIGH_VALUE
,
1165 (uint64_t) relocation
);
1168 /* xgettext:c-format */
1169 (_("%pB(%pA+%#" PRIx64
"): CMEM relocation to `%s+%#" PRIx64
1170 "' is invalid, 16 MSB should be %#x (value is %#" PRIx64
")"),
1171 reloc_data
.input_section
->owner
,
1172 reloc_data
.input_section
,
1173 (uint64_t) reloc_data
.reloc_offset
,
1174 reloc_data
.symbol_name
,
1175 (uint64_t) reloc_data
.reloc_addend
,
1176 NPS_CMEM_HIGH_VALUE
,
1177 (uint64_t) relocation
);
1178 return bfd_reloc_overflow
;
1186 return bfd_reloc_ok
;
1189 #define ME(reloc) (reloc)
1191 #define IS_ME(FORMULA,BFD) ((strstr (FORMULA, "ME") != NULL) \
1192 && (!bfd_big_endian (BFD)))
1194 #define S ((bfd_signed_vma) (reloc_data.sym_value \
1195 + (reloc_data.sym_section->output_section != NULL ? \
1196 (reloc_data.sym_section->output_offset \
1197 + reloc_data.sym_section->output_section->vma) : 0)))
1198 #define L ((bfd_signed_vma) (reloc_data.sym_value \
1199 + (reloc_data.sym_section->output_section != NULL ? \
1200 (reloc_data.sym_section->output_offset \
1201 + reloc_data.sym_section->output_section->vma) : 0)))
1202 #define A (reloc_data.reloc_addend)
1204 #define G (reloc_data.got_offset_value)
1205 #define GOT (reloc_data.got_symbol_vma)
1206 #define GOT_BEGIN (htab->sgot->output_section->vma)
1209 /* P: relative offset to PCL The offset should be to the
1210 current location aligned to 32 bits. */
1211 #define P ((bfd_signed_vma) ( \
1213 (reloc_data.input_section->output_section != NULL ? \
1214 reloc_data.input_section->output_section->vma : 0) \
1215 + reloc_data.input_section->output_offset \
1216 + (reloc_data.reloc_offset - (bitsize >= 32 ? 4 : 0))) \
1218 #define PDATA ((bfd_signed_vma) ( \
1219 (reloc_data.input_section->output_section->vma \
1220 + reloc_data.input_section->output_offset \
1221 + (reloc_data.reloc_offset))))
1222 #define SECTSTART (bfd_signed_vma) (reloc_data.sym_section->output_section->vma \
1223 + reloc_data.sym_section->output_offset)
1224 #define FINAL_SECTSTART \
1225 (bfd_signed_vma) (reloc_data.sym_section->output_section->vma)
1226 #define JLI (bfd_signed_vma) (reloc_data.sym_section->output_section->vma)
1227 #define _SDA_BASE_ (bfd_signed_vma) (reloc_data.sdata_begin_symbol_vma)
1228 #define TLS_REL (bfd_signed_vma) \
1229 ((elf_hash_table (info))->tls_sec->output_section->vma)
1230 #define TLS_TBSS (align_power(TCB_SIZE, \
1231 reloc_data.sym_section->alignment_power))
1235 #ifdef ARC_ENABLE_DEBUG
1236 #define PRINT_DEBUG_RELOC_INFO_BEFORE(FORMULA, TYPE) \
1239 asection *sym_section = reloc_data.sym_section; \
1240 asection *input_section = reloc_data.input_section; \
1241 ARC_DEBUG ("RELOC_TYPE = " TYPE "\n"); \
1242 ARC_DEBUG ("FORMULA = " FORMULA "\n"); \
1243 ARC_DEBUG ("S = %#lx\n", S); \
1244 ARC_DEBUG ("A = %#lx\n", A); \
1245 ARC_DEBUG ("L = %lx\n", L); \
1246 if (sym_section->output_section != NULL) \
1247 ARC_DEBUG ("symbol_section->vma = %#lx\n", \
1248 sym_section->output_section->vma \
1249 + sym_section->output_offset); \
1251 ARC_DEBUG ("symbol_section->vma = NULL\n"); \
1252 if (input_section->output_section != NULL) \
1253 ARC_DEBUG ("symbol_section->vma = %#lx\n", \
1254 input_section->output_section->vma \
1255 + input_section->output_offset); \
1257 ARC_DEBUG ("symbol_section->vma = NULL\n"); \
1258 ARC_DEBUG ("PCL = %#lx\n", P); \
1259 ARC_DEBUG ("P = %#lx\n", P); \
1260 ARC_DEBUG ("G = %#lx\n", G); \
1261 ARC_DEBUG ("SDA_OFFSET = %#lx\n", _SDA_BASE_); \
1262 ARC_DEBUG ("SDA_SET = %d\n", reloc_data.sdata_begin_symbol_vma_set); \
1263 ARC_DEBUG ("GOT_OFFSET = %#lx\n", GOT); \
1264 ARC_DEBUG ("relocation = %#08lx\n", relocation); \
1265 ARC_DEBUG ("before = %#08x\n", (unsigned) insn); \
1266 ARC_DEBUG ("data = %08x (%u) (%d)\n", (unsigned) relocation, \
1267 (unsigned) relocation, (int) relocation); \
1271 #define PRINT_DEBUG_RELOC_INFO_AFTER \
1274 ARC_DEBUG ("after = 0x%08x\n", (unsigned int) insn); \
1280 #define PRINT_DEBUG_RELOC_INFO_BEFORE(...)
1281 #define PRINT_DEBUG_RELOC_INFO_AFTER
1283 #endif /* ARC_ENABLE_DEBUG */
1285 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
1288 bfd_signed_vma bitsize ATTRIBUTE_UNUSED = BITSIZE; \
1289 relocation = FORMULA ; \
1290 PRINT_DEBUG_RELOC_INFO_BEFORE (#FORMULA, #TYPE); \
1291 insn = middle_endian_convert (insn, IS_ME (#FORMULA, abfd)); \
1292 insn = (* get_replace_function (abfd, TYPE)) (insn, relocation); \
1293 insn = middle_endian_convert (insn, IS_ME (#FORMULA, abfd)); \
1294 PRINT_DEBUG_RELOC_INFO_AFTER; \
1298 static bfd_reloc_status_type
1299 arc_do_relocation (bfd_byte
* contents
,
1300 struct arc_relocation_data reloc_data
,
1301 struct bfd_link_info
*info
)
1303 bfd_signed_vma relocation
= 0;
1305 bfd_vma orig_insn ATTRIBUTE_UNUSED
;
1306 bfd
* abfd
= reloc_data
.input_section
->owner
;
1307 struct elf_link_hash_table
*htab ATTRIBUTE_UNUSED
= elf_hash_table (info
);
1308 bfd_reloc_status_type flag
;
1310 if (!reloc_data
.should_relocate
)
1311 return bfd_reloc_ok
;
1313 switch (reloc_data
.howto
->size
)
1316 insn
= arc_bfd_get_32 (abfd
,
1317 contents
+ reloc_data
.reloc_offset
,
1318 reloc_data
.input_section
);
1321 insn
= arc_bfd_get_16 (abfd
,
1322 contents
+ reloc_data
.reloc_offset
,
1323 reloc_data
.input_section
);
1326 insn
= arc_bfd_get_8 (abfd
,
1327 contents
+ reloc_data
.reloc_offset
,
1328 reloc_data
.input_section
);
1338 switch (reloc_data
.howto
->type
)
1340 #include "elf/arc-reloc.def"
1347 /* Check for relocation overflow. */
1348 if (reloc_data
.howto
->complain_on_overflow
!= complain_overflow_dont
)
1349 flag
= bfd_check_overflow (reloc_data
.howto
->complain_on_overflow
,
1350 reloc_data
.howto
->bitsize
,
1351 reloc_data
.howto
->rightshift
,
1352 bfd_arch_bits_per_address (abfd
),
1355 flag
= arc_special_overflow_checks (reloc_data
, relocation
, info
);
1357 if (flag
!= bfd_reloc_ok
)
1359 ARC_DEBUG ("Relocation overflows !\n");
1360 DEBUG_ARC_RELOC (reloc_data
);
1361 ARC_DEBUG ("Relocation value = signed -> %d, unsigned -> %u"
1362 ", hex -> (0x%08x)\n",
1363 (int) relocation
, (unsigned) relocation
, (int) relocation
);
1368 /* Write updated instruction back to memory. */
1369 switch (reloc_data
.howto
->size
)
1372 arc_bfd_put_32 (abfd
, insn
,
1373 contents
+ reloc_data
.reloc_offset
,
1374 reloc_data
.input_section
);
1377 arc_bfd_put_16 (abfd
, insn
,
1378 contents
+ reloc_data
.reloc_offset
,
1379 reloc_data
.input_section
);
1382 arc_bfd_put_8 (abfd
, insn
,
1383 contents
+ reloc_data
.reloc_offset
,
1384 reloc_data
.input_section
);
1387 ARC_DEBUG ("size = %d\n", reloc_data
.howto
->size
);
1392 return bfd_reloc_ok
;
1408 #undef ARC_RELOC_HOWTO
1411 /* Relocate an arc ELF section.
1412 Function : elf_arc_relocate_section
1413 Brief : Relocate an arc section, by handling all the relocations
1414 appearing in that section.
1415 Args : output_bfd : The bfd being written to.
1416 info : Link information.
1417 input_bfd : The input bfd.
1418 input_section : The section being relocated.
1419 contents : contents of the section being relocated.
1420 relocs : List of relocations in the section.
1421 local_syms : is a pointer to the swapped in local symbols.
1422 local_section : is an array giving the section in the input file
1423 corresponding to the st_shndx field of each
1426 elf_arc_relocate_section (bfd
* output_bfd
,
1427 struct bfd_link_info
* info
,
1429 asection
* input_section
,
1430 bfd_byte
* contents
,
1431 Elf_Internal_Rela
* relocs
,
1432 Elf_Internal_Sym
* local_syms
,
1433 asection
** local_sections
)
1435 Elf_Internal_Shdr
* symtab_hdr
;
1436 struct elf_link_hash_entry
** sym_hashes
;
1437 Elf_Internal_Rela
* rel
;
1438 Elf_Internal_Rela
* wrel
;
1439 Elf_Internal_Rela
* relend
;
1440 struct elf_link_hash_table
* htab
= elf_hash_table (info
);
1442 symtab_hdr
= &((elf_tdata (input_bfd
))->symtab_hdr
);
1443 sym_hashes
= elf_sym_hashes (input_bfd
);
1445 rel
= wrel
= relocs
;
1446 relend
= relocs
+ input_section
->reloc_count
;
1447 for (; rel
< relend
; wrel
++, rel
++)
1449 enum elf_arc_reloc_type r_type
;
1450 reloc_howto_type
* howto
;
1451 unsigned long r_symndx
;
1452 struct elf_link_hash_entry
* h
;
1453 Elf_Internal_Sym
* sym
;
1455 struct elf_link_hash_entry
* h2
;
1457 bfd_boolean unresolved_reloc
= FALSE
;
1459 struct arc_relocation_data reloc_data
=
1463 .got_offset_value
= 0,
1465 .sym_section
= NULL
,
1467 .input_section
= NULL
,
1468 .sdata_begin_symbol_vma
= 0,
1469 .sdata_begin_symbol_vma_set
= FALSE
,
1470 .got_symbol_vma
= 0,
1471 .should_relocate
= FALSE
1474 r_type
= ELF32_R_TYPE (rel
->r_info
);
1476 if (r_type
>= (int) R_ARC_max
)
1478 bfd_set_error (bfd_error_bad_value
);
1481 howto
= arc_elf_howto (r_type
);
1483 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1485 /* If we are generating another .o file and the symbol in not
1486 local, skip this relocation. */
1487 if (bfd_link_relocatable (info
))
1489 /* This is a relocateable link. We don't have to change
1490 anything, unless the reloc is against a section symbol,
1491 in which case we have to adjust according to where the
1492 section symbol winds up in the output section. */
1494 /* Checks if this is a local symbol and thus the reloc
1495 might (will??) be against a section symbol. */
1496 if (r_symndx
< symtab_hdr
->sh_info
)
1498 sym
= local_syms
+ r_symndx
;
1499 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1501 sec
= local_sections
[r_symndx
];
1503 /* For RELA relocs. Just adjust the addend
1504 value in the relocation entry. */
1505 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
1507 ARC_DEBUG ("local symbols reloc (section=%d %s) seen in %s\n",
1508 (int) r_symndx
, local_sections
[r_symndx
]->name
,
1509 __PRETTY_FUNCTION__
);
1514 h2
= elf_link_hash_lookup (elf_hash_table (info
), "__SDATA_BEGIN__",
1515 FALSE
, FALSE
, TRUE
);
1517 if (!reloc_data
.sdata_begin_symbol_vma_set
1518 && h2
!= NULL
&& h2
->root
.type
!= bfd_link_hash_undefined
1519 && h2
->root
.u
.def
.section
->output_section
!= NULL
)
1520 /* TODO: Verify this condition. */
1522 reloc_data
.sdata_begin_symbol_vma
=
1523 (h2
->root
.u
.def
.value
1524 + h2
->root
.u
.def
.section
->output_section
->vma
);
1525 reloc_data
.sdata_begin_symbol_vma_set
= TRUE
;
1528 reloc_data
.input_section
= input_section
;
1529 reloc_data
.howto
= howto
;
1530 reloc_data
.reloc_offset
= rel
->r_offset
;
1531 reloc_data
.reloc_addend
= rel
->r_addend
;
1533 /* This is a final link. */
1538 if (r_symndx
< symtab_hdr
->sh_info
) /* A local symbol. */
1540 sym
= local_syms
+ r_symndx
;
1541 sec
= local_sections
[r_symndx
];
1545 bfd_boolean warned
, ignored
;
1546 bfd_vma relocation ATTRIBUTE_UNUSED
;
1548 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
1549 r_symndx
, symtab_hdr
, sym_hashes
,
1551 unresolved_reloc
, warned
, ignored
);
1553 /* TODO: This code is repeated from below. We should
1554 clean it and remove duplications.
1555 Sec is used check for discarded sections.
1556 Need to redesign code below. */
1558 /* Get the symbol's entry in the symtab. */
1559 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1561 while (h
->root
.type
== bfd_link_hash_indirect
1562 || h
->root
.type
== bfd_link_hash_warning
)
1563 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1565 /* If we have encountered a definition for this symbol. */
1566 if (h
->root
.type
== bfd_link_hash_defined
1567 || h
->root
.type
== bfd_link_hash_defweak
)
1569 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1570 sec
= h
->root
.u
.def
.section
;
1574 /* Clean relocs for symbols in discarded sections. */
1575 if (sec
!= NULL
&& discarded_section (sec
))
1577 _bfd_clear_contents (howto
, input_bfd
, input_section
,
1578 contents
, rel
->r_offset
);
1582 /* For ld -r, remove relocations in debug sections against
1583 sections defined in discarded sections. Not done for
1584 eh_frame editing code expects to be present. */
1585 if (bfd_link_relocatable (info
)
1586 && (input_section
->flags
& SEC_DEBUGGING
))
1592 if (bfd_link_relocatable (info
))
1599 if (r_symndx
< symtab_hdr
->sh_info
) /* A local symbol. */
1601 reloc_data
.sym_value
= sym
->st_value
;
1602 reloc_data
.sym_section
= sec
;
1603 reloc_data
.symbol_name
=
1604 bfd_elf_string_from_elf_section (input_bfd
,
1605 symtab_hdr
->sh_link
,
1608 /* Mergeable section handling. */
1609 if ((sec
->flags
& SEC_MERGE
)
1610 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1614 rel
->r_addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
,
1615 &msec
, rel
->r_addend
);
1616 rel
->r_addend
-= (sec
->output_section
->vma
1617 + sec
->output_offset
1619 rel
->r_addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
1621 reloc_data
.reloc_addend
= rel
->r_addend
;
1624 BFD_ASSERT (htab
->sgot
!= NULL
|| !is_reloc_for_GOT (howto
));
1625 if (htab
->sgot
!= NULL
)
1626 reloc_data
.got_symbol_vma
= htab
->sgot
->output_section
->vma
1627 + htab
->sgot
->output_offset
;
1629 reloc_data
.should_relocate
= TRUE
;
1631 else /* Global symbol. */
1633 /* FIXME: We should use the RELOC_FOR_GLOBAL_SYMBOL macro
1634 (defined in elf-bfd.h) here. */
1636 /* Get the symbol's entry in the symtab. */
1637 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1639 while (h
->root
.type
== bfd_link_hash_indirect
1640 || h
->root
.type
== bfd_link_hash_warning
)
1642 struct elf_arc_link_hash_entry
*ah_old
=
1643 (struct elf_arc_link_hash_entry
*) h
;
1644 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1645 struct elf_arc_link_hash_entry
*ah
=
1646 (struct elf_arc_link_hash_entry
*) h
;
1648 if (ah
->got_ents
== 0 && ah_old
->got_ents
!= ah
->got_ents
)
1649 ah
->got_ents
= ah_old
->got_ents
;
1652 /* TODO: Need to validate what was the intention. */
1653 /* BFD_ASSERT ((h->dynindx == -1) || (h->forced_local != 0)); */
1654 reloc_data
.symbol_name
= h
->root
.root
.string
;
1656 /* If we have encountered a definition for this symbol. */
1657 if (h
->root
.type
== bfd_link_hash_defined
1658 || h
->root
.type
== bfd_link_hash_defweak
)
1660 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1661 reloc_data
.sym_section
= h
->root
.u
.def
.section
;
1663 reloc_data
.should_relocate
= TRUE
;
1665 if (is_reloc_for_GOT (howto
) && !bfd_link_pic (info
))
1667 struct elf_arc_link_hash_entry
*ah
=
1668 (struct elf_arc_link_hash_entry
*) h
;
1669 /* TODO: Change it to use arc_do_relocation with
1670 ARC_32 reloc. Try to use ADD_RELA macro. */
1671 bfd_vma relocation
=
1672 reloc_data
.sym_value
+ reloc_data
.reloc_addend
1673 + (reloc_data
.sym_section
->output_section
!= NULL
?
1674 (reloc_data
.sym_section
->output_offset
1675 + reloc_data
.sym_section
->output_section
->vma
)
1678 BFD_ASSERT (ah
->got_ents
);
1679 bfd_vma got_offset
= ah
->got_ents
->offset
;
1680 bfd_put_32 (output_bfd
, relocation
,
1681 htab
->sgot
->contents
+ got_offset
);
1683 if (is_reloc_for_PLT (howto
) && h
->plt
.offset
!= (bfd_vma
) -1)
1685 /* TODO: This is repeated up here. */
1686 reloc_data
.sym_value
= h
->plt
.offset
;
1687 reloc_data
.sym_section
= htab
->splt
;
1690 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1692 /* Is weak symbol and has no definition. */
1693 if (is_reloc_for_GOT (howto
))
1695 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1696 reloc_data
.sym_section
= htab
->sgot
;
1697 reloc_data
.should_relocate
= TRUE
;
1699 else if (is_reloc_for_PLT (howto
)
1700 && h
->plt
.offset
!= (bfd_vma
) -1)
1702 /* TODO: This is repeated up here. */
1703 reloc_data
.sym_value
= h
->plt
.offset
;
1704 reloc_data
.sym_section
= htab
->splt
;
1705 reloc_data
.should_relocate
= TRUE
;
1712 if (is_reloc_for_GOT (howto
))
1714 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1715 reloc_data
.sym_section
= htab
->sgot
;
1717 reloc_data
.should_relocate
= TRUE
;
1719 else if (is_reloc_for_PLT (howto
))
1721 /* Fail if it is linking for PIE and the symbol is
1723 if (bfd_link_executable (info
))
1724 (*info
->callbacks
->undefined_symbol
)
1725 (info
, h
->root
.root
.string
, input_bfd
, input_section
,
1726 rel
->r_offset
, TRUE
);
1727 reloc_data
.sym_value
= h
->plt
.offset
;
1728 reloc_data
.sym_section
= htab
->splt
;
1730 reloc_data
.should_relocate
= TRUE
;
1732 else if (!bfd_link_pic (info
) || bfd_link_executable (info
))
1733 (*info
->callbacks
->undefined_symbol
)
1734 (info
, h
->root
.root
.string
, input_bfd
, input_section
,
1735 rel
->r_offset
, TRUE
);
1738 BFD_ASSERT (htab
->sgot
!= NULL
|| !is_reloc_for_GOT (howto
));
1739 if (htab
->sgot
!= NULL
)
1740 reloc_data
.got_symbol_vma
= htab
->sgot
->output_section
->vma
1741 + htab
->sgot
->output_offset
;
1744 if ((is_reloc_for_GOT (howto
)
1745 || is_reloc_for_TLS (howto
)))
1747 reloc_data
.should_relocate
= TRUE
;
1749 struct got_entry
**list
1750 = get_got_entry_list_for_symbol (input_bfd
, r_symndx
, h
);
1752 reloc_data
.got_offset_value
1753 = relocate_fix_got_relocs_for_got_info (list
,
1754 tls_type_for_reloc (howto
),
1765 create_got_dynrelocs_for_single_entry (
1766 got_entry_for_type (list
,
1767 arc_got_entry_type_for_reloc (howto
)),
1768 output_bfd
, info
, NULL
);
1773 #define IS_ARC_PCREL_TYPE(TYPE) \
1774 ( (TYPE == R_ARC_PC32) \
1775 || (TYPE == R_ARC_32_PCREL))
1782 case R_ARC_32_PCREL
:
1783 if (bfd_link_pic (info
)
1784 && (!IS_ARC_PCREL_TYPE (r_type
)
1788 && (!info
->symbolic
|| !h
->def_regular
))))
1790 Elf_Internal_Rela outrel
;
1792 bfd_boolean skip
= FALSE
;
1793 bfd_boolean relocate
= FALSE
;
1794 asection
*sreloc
= _bfd_elf_get_dynamic_reloc_section
1795 (input_bfd
, input_section
,
1798 BFD_ASSERT (sreloc
!= NULL
);
1800 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
1805 if (outrel
.r_offset
== (bfd_vma
) -1)
1808 outrel
.r_addend
= rel
->r_addend
;
1809 outrel
.r_offset
+= (input_section
->output_section
->vma
1810 + input_section
->output_offset
);
1814 memset (&outrel
, 0, sizeof outrel
);
1819 && (IS_ARC_PCREL_TYPE (r_type
)
1820 || !(bfd_link_executable (info
)
1821 || SYMBOLIC_BIND (info
, h
))
1822 || ! h
->def_regular
))
1824 BFD_ASSERT (h
!= NULL
);
1825 if ((input_section
->flags
& SEC_ALLOC
) != 0)
1830 BFD_ASSERT (h
->dynindx
!= -1);
1831 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
1835 /* Handle local symbols, they either do not have a
1836 global hash table entry (h == NULL), or are
1837 forced local due to a version script
1838 (h->forced_local), or the third condition is
1839 legacy, it appears to say something like, for
1840 links where we are pre-binding the symbols, or
1841 there's not an entry for this symbol in the
1842 dynamic symbol table, and it's a regular symbol
1843 not defined in a shared object, then treat the
1844 symbol as local, resolve it now. */
1846 /* outrel.r_addend = 0; */
1847 outrel
.r_info
= ELF32_R_INFO (0, R_ARC_RELATIVE
);
1850 BFD_ASSERT (sreloc
->contents
!= 0);
1852 loc
= sreloc
->contents
;
1853 loc
+= sreloc
->reloc_count
* sizeof (Elf32_External_Rela
);
1854 sreloc
->reloc_count
+= 1;
1856 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
1866 if (is_reloc_SDA_relative (howto
)
1867 && !reloc_data
.sdata_begin_symbol_vma_set
)
1870 ("error: linker symbol __SDATA_BEGIN__ not found");
1871 bfd_set_error (bfd_error_bad_value
);
1875 DEBUG_ARC_RELOC (reloc_data
);
1877 /* Make sure we have with a dynamic linker. In case of GOT and PLT
1878 the sym_section should point to .got or .plt respectively. */
1879 if ((is_reloc_for_GOT (howto
) || is_reloc_for_PLT (howto
))
1880 && reloc_data
.sym_section
== NULL
)
1883 (_("GOT and PLT relocations cannot be fixed with a non dynamic linker"));
1884 bfd_set_error (bfd_error_bad_value
);
1889 switch (arc_do_relocation (contents
, reloc_data
, info
))
1892 continue; /* The reloc processing loop. */
1894 case bfd_reloc_overflow
:
1895 (*info
->callbacks
->reloc_overflow
)
1896 (info
, (h
? &h
->root
: NULL
), reloc_data
.symbol_name
, howto
->name
, (bfd_vma
) 0,
1897 input_bfd
, input_section
, rel
->r_offset
);
1900 case bfd_reloc_undefined
:
1901 (*info
->callbacks
->undefined_symbol
)
1902 (info
, reloc_data
.symbol_name
, input_bfd
, input_section
, rel
->r_offset
, TRUE
);
1905 case bfd_reloc_other
:
1906 /* xgettext:c-format */
1907 msg
= _("%pB(%pA): warning: unaligned access to symbol '%s' in the small data area");
1910 case bfd_reloc_outofrange
:
1911 /* xgettext:c-format */
1912 msg
= _("%pB(%pA): internal error: out of range error");
1915 case bfd_reloc_notsupported
:
1916 /* xgettext:c-format */
1917 msg
= _("%pB(%pA): internal error: unsupported relocation error");
1920 case bfd_reloc_dangerous
:
1921 /* xgettext:c-format */
1922 msg
= _("%pB(%pA): internal error: dangerous relocation");
1926 /* xgettext:c-format */
1927 msg
= _("%pB(%pA): internal error: unknown error");
1932 _bfd_error_handler (msg
, input_bfd
, input_section
, reloc_data
.symbol_name
);
1939 #define elf_arc_hash_table(p) \
1940 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
1941 == ARC_ELF_DATA ? ((struct elf_arc_link_hash_table *) ((p)->hash)) : NULL)
1944 elf_arc_check_relocs (bfd
* abfd
,
1945 struct bfd_link_info
* info
,
1947 const Elf_Internal_Rela
* relocs
)
1949 Elf_Internal_Shdr
* symtab_hdr
;
1950 struct elf_link_hash_entry
** sym_hashes
;
1951 const Elf_Internal_Rela
* rel
;
1952 const Elf_Internal_Rela
* rel_end
;
1954 asection
* sreloc
= NULL
;
1955 struct elf_link_hash_table
* htab
= elf_hash_table (info
);
1957 if (bfd_link_relocatable (info
))
1960 if (htab
->dynobj
== NULL
)
1961 htab
->dynobj
= abfd
;
1963 dynobj
= (elf_hash_table (info
))->dynobj
;
1964 symtab_hdr
= &((elf_tdata (abfd
))->symtab_hdr
);
1965 sym_hashes
= elf_sym_hashes (abfd
);
1967 rel_end
= relocs
+ sec
->reloc_count
;
1968 for (rel
= relocs
; rel
< rel_end
; rel
++)
1970 enum elf_arc_reloc_type r_type
;
1971 reloc_howto_type
*howto
;
1972 unsigned long r_symndx
;
1973 struct elf_link_hash_entry
*h
;
1975 r_type
= ELF32_R_TYPE (rel
->r_info
);
1977 if (r_type
>= (int) R_ARC_max
)
1979 bfd_set_error (bfd_error_bad_value
);
1982 howto
= arc_elf_howto (r_type
);
1984 /* Load symbol information. */
1985 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1986 if (r_symndx
< symtab_hdr
->sh_info
) /* Is a local symbol. */
1988 else /* Global one. */
1990 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1991 while (h
->root
.type
== bfd_link_hash_indirect
1992 || h
->root
.type
== bfd_link_hash_warning
)
1993 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2001 /* During shared library creation, these relocs should not
2002 appear in a shared library (as memory will be read only
2003 and the dynamic linker can not resolve these. However
2004 the error should not occur for e.g. debugging or
2005 non-readonly sections. */
2007 && (bfd_link_dll (info
) && !bfd_link_pie (info
))
2008 && (sec
->flags
& SEC_ALLOC
) != 0
2009 && (sec
->flags
& SEC_READONLY
) != 0
2010 && ((sec
->flags
& SEC_CODE
) != 0
2011 || (sec
->flags
& SEC_DEBUGGING
) != 0))
2015 name
= h
->root
.root
.string
;
2019 /* xgettext:c-format */
2020 (_("%pB: relocation %s against `%s' can not be used"
2021 " when making a shared object; recompile with -fPIC"),
2023 arc_elf_howto (r_type
)->name
,
2025 bfd_set_error (bfd_error_bad_value
);
2029 /* In some cases we are not setting the 'non_got_ref'
2030 flag, even though the relocations don't require a GOT
2031 access. We should extend the testing in this area to
2032 ensure that no significant cases are being missed. */
2037 case R_ARC_32_PCREL
:
2038 if ((bfd_link_pic (info
))
2039 && ((r_type
!= R_ARC_PC32
&& r_type
!= R_ARC_32_PCREL
)
2041 && (!info
->symbolic
|| !h
->def_regular
))))
2046 && ! htab
->dynamic_sections_created
2047 && ! _bfd_elf_link_create_dynamic_sections (abfd
, info
))
2049 sreloc
= _bfd_elf_make_dynamic_reloc_section (sec
, dynobj
,
2057 sreloc
->size
+= sizeof (Elf32_External_Rela
);
2064 if (is_reloc_for_PLT (howto
))
2069 if (h
->forced_local
== 0)
2073 /* Add info to the symbol got_entry_list. */
2074 if (is_reloc_for_GOT (howto
)
2075 || is_reloc_for_TLS (howto
))
2077 if (bfd_link_dll (info
) && !bfd_link_pie (info
)
2078 && (r_type
== R_ARC_TLS_LE_32
|| r_type
== R_ARC_TLS_LE_S9
))
2082 name
= h
->root
.root
.string
;
2084 /* bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL); */
2087 /* xgettext:c-format */
2088 (_("%pB: relocation %s against `%s' can not be used"
2089 " when making a shared object; recompile with -fPIC"),
2091 arc_elf_howto (r_type
)->name
,
2093 bfd_set_error (bfd_error_bad_value
);
2096 if (! _bfd_elf_create_got_section (dynobj
, info
))
2099 arc_fill_got_info_for_reloc (
2100 arc_got_entry_type_for_reloc (howto
),
2101 get_got_entry_list_for_symbol (abfd
, r_symndx
, h
),
2110 #define ELF_DYNAMIC_INTERPRETER "/sbin/ld-uClibc.so"
2112 static struct plt_version_t
*
2113 arc_get_plt_version (struct bfd_link_info
*info
)
2117 for (i
= 0; i
< 1; i
++)
2119 ARC_DEBUG ("%d: size1 = %d, size2 = %d\n", i
,
2120 (int) plt_versions
[i
].entry_size
,
2121 (int) plt_versions
[i
].elem_size
);
2124 if (bfd_get_mach (info
->output_bfd
) == bfd_mach_arc_arcv2
)
2126 if (bfd_link_pic (info
))
2127 return &(plt_versions
[ELF_ARCV2_PIC
]);
2129 return &(plt_versions
[ELF_ARCV2_ABS
]);
2133 if (bfd_link_pic (info
))
2134 return &(plt_versions
[ELF_ARC_PIC
]);
2136 return &(plt_versions
[ELF_ARC_ABS
]);
2141 add_symbol_to_plt (struct bfd_link_info
*info
)
2143 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2146 struct plt_version_t
*plt_data
= arc_get_plt_version (info
);
2148 /* If this is the first .plt entry, make room for the special first
2150 if (htab
->splt
->size
== 0)
2151 htab
->splt
->size
+= plt_data
->entry_size
;
2153 ret
= htab
->splt
->size
;
2155 htab
->splt
->size
+= plt_data
->elem_size
;
2156 ARC_DEBUG ("PLT_SIZE = %d\n", (int) htab
->splt
->size
);
2158 htab
->sgotplt
->size
+= 4;
2159 htab
->srelplt
->size
+= sizeof (Elf32_External_Rela
);
2164 #define PLT_DO_RELOCS_FOR_ENTRY(ABFD, DS, RELOCS) \
2165 plt_do_relocs_for_symbol (ABFD, DS, RELOCS, 0, 0)
2168 plt_do_relocs_for_symbol (bfd
*abfd
,
2169 struct elf_link_hash_table
*htab
,
2170 const struct plt_reloc
*reloc
,
2172 bfd_vma symbol_got_offset
)
2174 while (SYM_ONLY (reloc
->symbol
) != LAST_RELOC
)
2176 bfd_vma relocation
= 0;
2178 switch (SYM_ONLY (reloc
->symbol
))
2182 = htab
->sgotplt
->output_section
->vma
2183 + htab
->sgotplt
->output_offset
+ symbol_got_offset
;
2186 relocation
+= reloc
->addend
;
2188 if (IS_RELATIVE (reloc
->symbol
))
2190 bfd_vma reloc_offset
= reloc
->offset
;
2191 reloc_offset
-= (IS_INSN_32 (reloc
->symbol
)) ? 4 : 0;
2192 reloc_offset
-= (IS_INSN_24 (reloc
->symbol
)) ? 2 : 0;
2194 relocation
-= htab
->splt
->output_section
->vma
2195 + htab
->splt
->output_offset
2196 + plt_offset
+ reloc_offset
;
2199 /* TODO: being ME is not a property of the relocation but of the
2200 section of which is applying the relocation. */
2201 if (IS_MIDDLE_ENDIAN (reloc
->symbol
) && !bfd_big_endian (abfd
))
2204 = ((relocation
& 0xffff0000) >> 16)
2205 | ((relocation
& 0xffff) << 16);
2208 switch (reloc
->size
)
2211 bfd_put_32 (htab
->splt
->output_section
->owner
,
2213 htab
->splt
->contents
+ plt_offset
+ reloc
->offset
);
2217 reloc
= &(reloc
[1]); /* Jump to next relocation. */
2222 relocate_plt_for_symbol (bfd
*output_bfd
,
2223 struct bfd_link_info
*info
,
2224 struct elf_link_hash_entry
*h
)
2226 struct plt_version_t
*plt_data
= arc_get_plt_version (info
);
2227 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2229 bfd_vma plt_index
= (h
->plt
.offset
- plt_data
->entry_size
)
2230 / plt_data
->elem_size
;
2231 bfd_vma got_offset
= (plt_index
+ 3) * 4;
2233 ARC_DEBUG ("arc_info: PLT_OFFSET = %#lx, PLT_ENTRY_VMA = %#lx, \
2234 GOT_ENTRY_OFFSET = %#lx, GOT_ENTRY_VMA = %#lx, for symbol %s\n",
2235 (long) h
->plt
.offset
,
2236 (long) (htab
->splt
->output_section
->vma
2237 + htab
->splt
->output_offset
2240 (long) (htab
->sgotplt
->output_section
->vma
2241 + htab
->sgotplt
->output_offset
2243 h
->root
.root
.string
);
2247 uint16_t *ptr
= (uint16_t *) plt_data
->elem
;
2249 for (i
= 0; i
< plt_data
->elem_size
/2; i
++)
2251 uint16_t data
= ptr
[i
];
2252 bfd_put_16 (output_bfd
,
2254 htab
->splt
->contents
+ h
->plt
.offset
+ (i
*2));
2258 plt_do_relocs_for_symbol (output_bfd
, htab
,
2259 plt_data
->elem_relocs
,
2263 /* Fill in the entry in the global offset table. */
2264 bfd_put_32 (output_bfd
,
2265 (bfd_vma
) (htab
->splt
->output_section
->vma
2266 + htab
->splt
->output_offset
),
2267 htab
->sgotplt
->contents
+ got_offset
);
2269 /* TODO: Fill in the entry in the .rela.plt section. */
2271 Elf_Internal_Rela rel
;
2274 rel
.r_offset
= (htab
->sgotplt
->output_section
->vma
2275 + htab
->sgotplt
->output_offset
2279 BFD_ASSERT (h
->dynindx
!= -1);
2280 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARC_JMP_SLOT
);
2282 loc
= htab
->srelplt
->contents
;
2283 loc
+= plt_index
* sizeof (Elf32_External_Rela
); /* relA */
2284 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
2289 relocate_plt_for_entry (bfd
*abfd
,
2290 struct bfd_link_info
*info
)
2292 struct plt_version_t
*plt_data
= arc_get_plt_version (info
);
2293 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2297 uint16_t *ptr
= (uint16_t *) plt_data
->entry
;
2298 for (i
= 0; i
< plt_data
->entry_size
/2; i
++)
2300 uint16_t data
= ptr
[i
];
2303 htab
->splt
->contents
+ (i
*2));
2306 PLT_DO_RELOCS_FOR_ENTRY (abfd
, htab
, plt_data
->entry_relocs
);
2309 /* Desc : Adjust a symbol defined by a dynamic object and referenced
2310 by a regular object. The current definition is in some section of
2311 the dynamic object, but we're not including those sections. We
2312 have to change the definition to something the rest of the link can
2316 elf_arc_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2317 struct elf_link_hash_entry
*h
)
2320 bfd
*dynobj
= (elf_hash_table (info
))->dynobj
;
2321 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2323 if (h
->type
== STT_FUNC
2324 || h
->type
== STT_GNU_IFUNC
2325 || h
->needs_plt
== 1)
2327 if (!bfd_link_pic (info
) && !h
->def_dynamic
&& !h
->ref_dynamic
)
2329 /* This case can occur if we saw a PLT32 reloc in an input
2330 file, but the symbol was never referred to by a dynamic
2331 object. In such a case, we don't actually need to build
2332 a procedure linkage table, and we can just do a PC32
2334 BFD_ASSERT (h
->needs_plt
);
2338 /* Make sure this symbol is output as a dynamic symbol. */
2339 if (h
->dynindx
== -1 && !h
->forced_local
2340 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
2343 if (bfd_link_pic (info
)
2344 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2346 bfd_vma loc
= add_symbol_to_plt (info
);
2348 if (bfd_link_executable (info
) && !h
->def_regular
)
2350 h
->root
.u
.def
.section
= htab
->splt
;
2351 h
->root
.u
.def
.value
= loc
;
2353 h
->plt
.offset
= loc
;
2357 h
->plt
.offset
= (bfd_vma
) -1;
2363 /* If this is a weak symbol, and there is a real definition, the
2364 processor independent code will have arranged for us to see the
2365 real definition first, and we can just use the same value. */
2366 if (h
->is_weakalias
)
2368 struct elf_link_hash_entry
*def
= weakdef (h
);
2369 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
2370 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
2371 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
2375 /* This is a reference to a symbol defined by a dynamic object which
2376 is not a function. */
2378 /* If we are creating a shared library, we must presume that the
2379 only references to the symbol are via the global offset table.
2380 For such cases we need not do anything here; the relocations will
2381 be handled correctly by relocate_section. */
2382 if (!bfd_link_executable (info
))
2385 /* If there are no non-GOT references, we do not need a copy
2387 if (!h
->non_got_ref
)
2390 /* If -z nocopyreloc was given, we won't generate them either. */
2391 if (info
->nocopyreloc
)
2397 /* We must allocate the symbol in our .dynbss section, which will
2398 become part of the .bss section of the executable. There will be
2399 an entry for this symbol in the .dynsym section. The dynamic
2400 object will contain position independent code, so all references
2401 from the dynamic object to this symbol will go through the global
2402 offset table. The dynamic linker will use the .dynsym entry to
2403 determine the address it must put in the global offset table, so
2404 both the dynamic object and the regular object will refer to the
2405 same memory location for the variable. */
2410 /* We must generate a R_ARC_COPY reloc to tell the dynamic linker to
2411 copy the initial value out of the dynamic object and into the
2412 runtime process image. We need to remember the offset into the
2413 .rela.bss section we are going to use. */
2414 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
2416 struct elf_arc_link_hash_table
*arc_htab
= elf_arc_hash_table (info
);
2418 BFD_ASSERT (arc_htab
->elf
.srelbss
!= NULL
);
2419 arc_htab
->elf
.srelbss
->size
+= sizeof (Elf32_External_Rela
);
2423 /* TODO: Move this also to arc_hash_table. */
2424 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
2425 BFD_ASSERT (s
!= NULL
);
2427 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2430 /* Function : elf_arc_finish_dynamic_symbol
2431 Brief : Finish up dynamic symbol handling. We set the
2432 contents of various dynamic sections here.
2437 Returns : True/False as the return status. */
2440 elf_arc_finish_dynamic_symbol (bfd
* output_bfd
,
2441 struct bfd_link_info
*info
,
2442 struct elf_link_hash_entry
*h
,
2443 Elf_Internal_Sym
* sym
)
2445 if (h
->plt
.offset
!= (bfd_vma
) -1)
2447 relocate_plt_for_symbol (output_bfd
, info
, h
);
2449 if (!h
->def_regular
)
2451 /* Mark the symbol as undefined, rather than as defined in
2452 the .plt section. Leave the value alone. */
2453 sym
->st_shndx
= SHN_UNDEF
;
2458 /* This function traverses list of GOT entries and
2459 create respective dynamic relocs. */
2460 /* TODO: Make function to get list and not access the list directly. */
2461 /* TODO: Move function to relocate_section create this relocs eagerly. */
2462 struct elf_arc_link_hash_entry
*ah
=
2463 (struct elf_arc_link_hash_entry
*) h
;
2464 create_got_dynrelocs_for_got_info (&ah
->got_ents
,
2471 struct elf_arc_link_hash_table
*arc_htab
= elf_arc_hash_table (info
);
2473 if (arc_htab
== NULL
)
2476 if (h
->dynindx
== -1
2477 || (h
->root
.type
!= bfd_link_hash_defined
2478 && h
->root
.type
!= bfd_link_hash_defweak
)
2479 || arc_htab
->elf
.srelbss
== NULL
)
2482 bfd_vma rel_offset
= (h
->root
.u
.def
.value
2483 + h
->root
.u
.def
.section
->output_section
->vma
2484 + h
->root
.u
.def
.section
->output_offset
);
2486 bfd_byte
* loc
= arc_htab
->elf
.srelbss
->contents
2487 + (arc_htab
->elf
.srelbss
->reloc_count
* sizeof (Elf32_External_Rela
));
2488 arc_htab
->elf
.srelbss
->reloc_count
++;
2490 Elf_Internal_Rela rel
;
2492 rel
.r_offset
= rel_offset
;
2494 BFD_ASSERT (h
->dynindx
!= -1);
2495 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARC_COPY
);
2497 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
2500 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2501 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2502 || strcmp (h
->root
.root
.string
, "__DYNAMIC") == 0
2503 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
2504 sym
->st_shndx
= SHN_ABS
;
2509 #define GET_SYMBOL_OR_SECTION(TAG, SYMBOL, SECTION) \
2511 if (SYMBOL != NULL) \
2512 h = elf_link_hash_lookup (elf_hash_table (info), \
2513 SYMBOL, FALSE, FALSE, TRUE); \
2514 else if (SECTION != NULL) \
2515 s = bfd_get_linker_section (dynobj, SECTION); \
2519 struct obfd_info_group
{
2521 struct bfd_link_info
*info
;
2525 arc_create_forced_local_got_entries_for_tls (struct bfd_hash_entry
*bh
,
2528 struct elf_arc_link_hash_entry
* h
=
2529 (struct elf_arc_link_hash_entry
*) bh
;
2530 struct obfd_info_group
*tmp
= (struct obfd_info_group
*) data
;
2532 if (h
->got_ents
!= NULL
)
2536 struct got_entry
*list
= h
->got_ents
;
2538 while (list
!= NULL
)
2540 create_got_dynrelocs_for_single_entry (list
, tmp
->output_bfd
,
2542 (struct elf_link_hash_entry
*) h
);
2551 /* Function : elf_arc_finish_dynamic_sections
2552 Brief : Finish up the dynamic sections handling.
2557 Returns : True/False as the return status. */
2560 elf_arc_finish_dynamic_sections (bfd
* output_bfd
,
2561 struct bfd_link_info
*info
)
2563 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2564 bfd
*dynobj
= (elf_hash_table (info
))->dynobj
;
2565 asection
*sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
2569 Elf32_External_Dyn
*dyncon
, *dynconend
;
2571 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
2573 = (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
2574 for (; dyncon
< dynconend
; dyncon
++)
2576 Elf_Internal_Dyn internal_dyn
;
2577 bfd_boolean do_it
= FALSE
;
2579 struct elf_link_hash_entry
*h
= NULL
;
2582 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &internal_dyn
);
2584 switch (internal_dyn
.d_tag
)
2586 GET_SYMBOL_OR_SECTION (DT_INIT
, info
->init_function
, NULL
)
2587 GET_SYMBOL_OR_SECTION (DT_FINI
, info
->fini_function
, NULL
)
2588 GET_SYMBOL_OR_SECTION (DT_PLTGOT
, NULL
, ".plt")
2589 GET_SYMBOL_OR_SECTION (DT_JMPREL
, NULL
, ".rela.plt")
2590 GET_SYMBOL_OR_SECTION (DT_PLTRELSZ
, NULL
, ".rela.plt")
2591 GET_SYMBOL_OR_SECTION (DT_VERSYM
, NULL
, ".gnu.version")
2592 GET_SYMBOL_OR_SECTION (DT_VERDEF
, NULL
, ".gnu.version_d")
2593 GET_SYMBOL_OR_SECTION (DT_VERNEED
, NULL
, ".gnu.version_r")
2598 /* In case the dynamic symbols should be updated with a symbol. */
2600 && (h
->root
.type
== bfd_link_hash_defined
2601 || h
->root
.type
== bfd_link_hash_defweak
))
2605 internal_dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
2606 asec_ptr
= h
->root
.u
.def
.section
;
2607 if (asec_ptr
->output_section
!= NULL
)
2609 internal_dyn
.d_un
.d_val
+=
2610 (asec_ptr
->output_section
->vma
2611 + asec_ptr
->output_offset
);
2615 /* The symbol is imported from another shared
2616 library and does not apply to this one. */
2617 internal_dyn
.d_un
.d_val
= 0;
2621 else if (s
!= NULL
) /* With a section information. */
2623 switch (internal_dyn
.d_tag
)
2630 internal_dyn
.d_un
.d_ptr
= (s
->output_section
->vma
2631 + s
->output_offset
);
2636 internal_dyn
.d_un
.d_val
= s
->size
;
2646 bfd_elf32_swap_dyn_out (output_bfd
, &internal_dyn
, dyncon
);
2649 if (htab
->splt
->size
> 0)
2651 relocate_plt_for_entry (output_bfd
, info
);
2654 /* TODO: Validate this. */
2655 if (htab
->srelplt
->output_section
!= bfd_abs_section_ptr
)
2656 elf_section_data (htab
->srelplt
->output_section
)
2657 ->this_hdr
.sh_entsize
= 12;
2660 /* Fill in the first three entries in the global offset table. */
2663 struct elf_link_hash_entry
*h
;
2664 h
= elf_link_hash_lookup (elf_hash_table (info
), "_GLOBAL_OFFSET_TABLE_",
2665 FALSE
, FALSE
, TRUE
);
2667 if (h
!= NULL
&& h
->root
.type
!= bfd_link_hash_undefined
2668 && h
->root
.u
.def
.section
!= NULL
)
2670 asection
*sec
= h
->root
.u
.def
.section
;
2673 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
2676 bfd_put_32 (output_bfd
,
2677 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
2679 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sec
->contents
+ 4);
2680 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sec
->contents
+ 8);
2684 struct obfd_info_group group
;
2685 group
.output_bfd
= output_bfd
;
2687 bfd_hash_traverse (&info
->hash
->table
,
2688 arc_create_forced_local_got_entries_for_tls
, &group
);
2693 #define ADD_DYNAMIC_SYMBOL(NAME, TAG) \
2694 h = elf_link_hash_lookup (elf_hash_table (info), \
2695 NAME, FALSE, FALSE, FALSE); \
2696 if ((h != NULL && (h->ref_regular || h->def_regular))) \
2697 if (! _bfd_elf_add_dynamic_entry (info, TAG, 0)) \
2700 /* Set the sizes of the dynamic sections. */
2702 elf_arc_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
2703 struct bfd_link_info
*info
)
2707 bfd_boolean relocs_exist
= FALSE
;
2708 bfd_boolean reltext_exist
= FALSE
;
2709 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2711 dynobj
= htab
->dynobj
;
2712 BFD_ASSERT (dynobj
!= NULL
);
2714 if (htab
->dynamic_sections_created
)
2716 struct elf_link_hash_entry
*h
;
2718 /* Set the contents of the .interp section to the
2720 if (bfd_link_executable (info
) && !info
->nointerp
)
2722 s
= bfd_get_section_by_name (dynobj
, ".interp");
2723 BFD_ASSERT (s
!= NULL
);
2724 s
->size
= sizeof (ELF_DYNAMIC_INTERPRETER
);
2725 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2728 /* Add some entries to the .dynamic section. We fill in some of
2729 the values later, in elf_bfd_final_link, but we must add the
2730 entries now so that we know the final size of the .dynamic
2731 section. Checking if the .init section is present. We also
2732 create DT_INIT and DT_FINI entries if the init_str has been
2733 changed by the user. */
2734 ADD_DYNAMIC_SYMBOL (info
->init_function
, DT_INIT
);
2735 ADD_DYNAMIC_SYMBOL (info
->fini_function
, DT_FINI
);
2739 /* We may have created entries in the .rela.got section.
2740 However, if we are not creating the dynamic sections, we will
2741 not actually use these entries. Reset the size of .rela.got,
2742 which will cause it to get stripped from the output file
2744 if (htab
->srelgot
!= NULL
)
2745 htab
->srelgot
->size
= 0;
2748 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2750 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2755 || s
== htab
->sgotplt
2756 || s
== htab
->sdynbss
)
2758 /* Strip this section if we don't need it. */
2760 else if (strncmp (s
->name
, ".rela", 5) == 0)
2762 if (s
->size
!= 0 && s
!= htab
->srelplt
)
2766 const char *name
= s
->name
+ 5;
2768 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
2769 if (bfd_get_flavour (ibfd
) == bfd_target_elf_flavour
2770 && ibfd
->flags
& DYNAMIC
)
2772 asection
*target
= bfd_get_section_by_name (ibfd
, name
);
2774 && elf_section_data (target
)->sreloc
== s
2775 && ((target
->output_section
->flags
2776 & (SEC_READONLY
| SEC_ALLOC
))
2777 == (SEC_READONLY
| SEC_ALLOC
)))
2779 reltext_exist
= TRUE
;
2784 relocs_exist
= TRUE
;
2787 /* We use the reloc_count field as a counter if we need to
2788 copy relocs into the output file. */
2793 /* It's not one of our sections, so don't allocate space. */
2799 s
->flags
|= SEC_EXCLUDE
;
2803 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
2806 /* Allocate memory for the section contents. */
2807 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
2808 if (s
->contents
== NULL
)
2812 if (htab
->dynamic_sections_created
)
2814 /* TODO: Check if this is needed. */
2815 if (!bfd_link_pic (info
))
2816 if (!_bfd_elf_add_dynamic_entry (info
, DT_DEBUG
, 0))
2819 if (htab
->splt
&& (htab
->splt
->flags
& SEC_EXCLUDE
) == 0)
2820 if (!_bfd_elf_add_dynamic_entry (info
, DT_PLTGOT
, 0)
2821 || !_bfd_elf_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
2822 || !_bfd_elf_add_dynamic_entry (info
, DT_PLTREL
, DT_RELA
)
2823 || !_bfd_elf_add_dynamic_entry (info
, DT_JMPREL
, 0))
2827 if (!_bfd_elf_add_dynamic_entry (info
, DT_RELA
, 0)
2828 || !_bfd_elf_add_dynamic_entry (info
, DT_RELASZ
, 0)
2829 || !_bfd_elf_add_dynamic_entry (info
, DT_RELAENT
,
2830 sizeof (Elf32_External_Rela
)))
2834 if (!_bfd_elf_add_dynamic_entry (info
, DT_TEXTREL
, 0))
2842 /* Classify dynamic relocs such that -z combreloc can reorder and combine
2844 static enum elf_reloc_type_class
2845 elf32_arc_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2846 const asection
*rel_sec ATTRIBUTE_UNUSED
,
2847 const Elf_Internal_Rela
*rela
)
2849 switch ((int) ELF32_R_TYPE (rela
->r_info
))
2851 case R_ARC_RELATIVE
:
2852 return reloc_class_relative
;
2853 case R_ARC_JMP_SLOT
:
2854 return reloc_class_plt
;
2856 return reloc_class_copy
;
2857 /* TODO: Needed in future to support ifunc. */
2859 case R_ARC_IRELATIVE:
2860 return reloc_class_ifunc;
2863 return reloc_class_normal
;
2867 const struct elf_size_info arc_elf32_size_info
=
2869 sizeof (Elf32_External_Ehdr
),
2870 sizeof (Elf32_External_Phdr
),
2871 sizeof (Elf32_External_Shdr
),
2872 sizeof (Elf32_External_Rel
),
2873 sizeof (Elf32_External_Rela
),
2874 sizeof (Elf32_External_Sym
),
2875 sizeof (Elf32_External_Dyn
),
2876 sizeof (Elf_External_Note
),
2880 ELFCLASS32
, EV_CURRENT
,
2881 bfd_elf32_write_out_phdrs
,
2882 bfd_elf32_write_shdrs_and_ehdr
,
2883 bfd_elf32_checksum_contents
,
2884 bfd_elf32_write_relocs
,
2885 bfd_elf32_swap_symbol_in
,
2886 bfd_elf32_swap_symbol_out
,
2887 bfd_elf32_slurp_reloc_table
,
2888 bfd_elf32_slurp_symbol_table
,
2889 bfd_elf32_swap_dyn_in
,
2890 bfd_elf32_swap_dyn_out
,
2891 bfd_elf32_swap_reloc_in
,
2892 bfd_elf32_swap_reloc_out
,
2893 bfd_elf32_swap_reloca_in
,
2894 bfd_elf32_swap_reloca_out
2897 #define elf_backend_size_info arc_elf32_size_info
2899 /* GDB expects general purpose registers to be in section .reg. However Linux
2900 kernel doesn't create this section and instead writes registers to NOTE
2901 section. It is up to the binutils to create a pseudo-section .reg from the
2902 contents of NOTE. Also BFD will read pid and signal number from NOTE. This
2903 function relies on offsets inside elf_prstatus structure in Linux to be
2907 elf32_arc_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
2912 switch (note
->descsz
)
2917 case 236: /* sizeof (struct elf_prstatus) on Linux/arc. */
2919 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
2921 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
2924 size
= (40 * 4); /* There are 40 registers in user_regs_struct. */
2927 /* Make a ".reg/999" section. */
2928 return _bfd_elfcore_make_pseudosection (abfd
, ".reg", size
,
2929 note
->descpos
+ offset
);
2932 /* Determine whether an object attribute tag takes an integer, a
2936 elf32_arc_obj_attrs_arg_type (int tag
)
2938 if (tag
== Tag_ARC_CPU_name
2939 || tag
== Tag_ARC_ISA_config
2940 || tag
== Tag_ARC_ISA_apex
)
2941 return ATTR_TYPE_FLAG_STR_VAL
;
2942 else if (tag
< (Tag_ARC_ISA_mpy_option
+ 1))
2943 return ATTR_TYPE_FLAG_INT_VAL
;
2945 return (tag
& 1) != 0 ? ATTR_TYPE_FLAG_STR_VAL
: ATTR_TYPE_FLAG_INT_VAL
;
2948 /* Attribute numbers >=14 can be safely ignored. */
2951 elf32_arc_obj_attrs_handle_unknown (bfd
*abfd
, int tag
)
2953 if ((tag
& 127) < (Tag_ARC_ISA_mpy_option
+ 1))
2956 (_("%pB: unknown mandatory ARC object attribute %d"),
2958 bfd_set_error (bfd_error_bad_value
);
2964 (_("warning: %pB: unknown ARC object attribute %d"),
2970 /* Handle an ARC specific section when reading an object file. This is
2971 called when bfd_section_from_shdr finds a section with an unknown
2975 elf32_arc_section_from_shdr (bfd
*abfd
,
2976 Elf_Internal_Shdr
* hdr
,
2980 switch (hdr
->sh_type
)
2982 case 0x0c: /* MWDT specific section, don't complain about it. */
2983 case SHT_ARC_ATTRIBUTES
:
2990 if (!_bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2998 These are the current relaxing opportunities available:
3000 * R_ARC_GOTPC32 => R_ARC_PCREL.
3005 arc_elf_relax_section (bfd
*abfd
, asection
*sec
,
3006 struct bfd_link_info
*link_info
, bfd_boolean
*again
)
3008 Elf_Internal_Shdr
*symtab_hdr
;
3009 Elf_Internal_Rela
*internal_relocs
;
3010 Elf_Internal_Rela
*irel
, *irelend
;
3011 bfd_byte
*contents
= NULL
;
3012 Elf_Internal_Sym
*isymbuf
= NULL
;
3014 /* Assume nothing changes. */
3017 /* We don't have to do anything for a relocatable link, if this
3018 section does not have relocs, or if this is not a code
3020 if (bfd_link_relocatable (link_info
)
3021 || (sec
->flags
& SEC_RELOC
) == 0
3022 || sec
->reloc_count
== 0
3023 || (sec
->flags
& SEC_CODE
) == 0)
3026 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3028 /* Get a copy of the native relocations. */
3029 internal_relocs
= _bfd_elf_link_read_relocs (abfd
, sec
, NULL
, NULL
,
3030 link_info
->keep_memory
);
3031 if (internal_relocs
== NULL
)
3034 /* Walk through them looking for relaxing opportunities. */
3035 irelend
= internal_relocs
+ sec
->reloc_count
;
3036 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
3038 /* If this isn't something that can be relaxed, then ignore
3040 if (ELF32_R_TYPE (irel
->r_info
) != (int) R_ARC_GOTPC32
)
3043 /* Get the section contents if we haven't done so already. */
3044 if (contents
== NULL
)
3046 /* Get cached copy if it exists. */
3047 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
3048 contents
= elf_section_data (sec
)->this_hdr
.contents
;
3049 /* Go get them off disk. */
3050 else if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
3054 /* Read this BFD's local symbols if we haven't done so already. */
3055 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
3057 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
3058 if (isymbuf
== NULL
)
3059 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
3060 symtab_hdr
->sh_info
, 0,
3062 if (isymbuf
== NULL
)
3066 struct elf_link_hash_entry
*htop
= NULL
;
3068 if (ELF32_R_SYM (irel
->r_info
) >= symtab_hdr
->sh_info
)
3070 /* An external symbol. */
3071 unsigned int indx
= ELF32_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
3072 htop
= elf_sym_hashes (abfd
)[indx
];
3075 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_ARC_GOTPC32
3076 && SYMBOL_REFERENCES_LOCAL (link_info
, htop
))
3080 /* Get the opcode. */
3081 code
= bfd_get_32_me (abfd
, contents
+ irel
->r_offset
- 4);
3083 /* Note that we've changed the relocs, section contents, etc. */
3084 elf_section_data (sec
)->relocs
= internal_relocs
;
3085 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3086 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
3088 /* Fix the relocation's type. */
3089 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
), R_ARC_PC32
);
3091 /* ld rA,[pcl,symbol@tgot] -> add rA,pcl,symbol@pcl. */
3092 /* 0010 0bbb aa11 0ZZX DBBB 1111 10AA AAAA.
3093 111 00 000 0111 xx xxxx*/
3094 code
&= ~0x27307F80;
3095 BFD_ASSERT (code
<= 62UL);
3098 /* Write back the new instruction. */
3099 bfd_put_32_me (abfd
, code
, contents
+ irel
->r_offset
- 4);
3101 /* The size isn't changed, don't redo. */
3107 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
3109 if (!link_info
->keep_memory
)
3112 /* Cache the symbols for elf_link_input_bfd. */
3113 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
3116 if (contents
!= NULL
3117 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3119 if (!link_info
->keep_memory
)
3122 /* Cache the section contents for elf_link_input_bfd. */
3123 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3126 if (internal_relocs
!= NULL
3127 && elf_section_data (sec
)->relocs
!= internal_relocs
)
3128 free (internal_relocs
);
3134 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
3136 if (contents
!= NULL
3137 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3139 if (internal_relocs
!= NULL
3140 && elf_section_data (sec
)->relocs
!= internal_relocs
)
3141 free (internal_relocs
);
3146 #define TARGET_LITTLE_SYM arc_elf32_le_vec
3147 #define TARGET_LITTLE_NAME "elf32-littlearc"
3148 #define TARGET_BIG_SYM arc_elf32_be_vec
3149 #define TARGET_BIG_NAME "elf32-bigarc"
3150 #define ELF_ARCH bfd_arch_arc
3151 #define ELF_TARGET_ID ARC_ELF_DATA
3152 #define ELF_MACHINE_CODE EM_ARC_COMPACT
3153 #define ELF_MACHINE_ALT1 EM_ARC_COMPACT2
3154 #define ELF_MAXPAGESIZE 0x2000
3156 #define bfd_elf32_bfd_link_hash_table_create arc_elf_link_hash_table_create
3158 #define bfd_elf32_bfd_merge_private_bfd_data arc_elf_merge_private_bfd_data
3159 #define bfd_elf32_bfd_reloc_type_lookup arc_elf32_bfd_reloc_type_lookup
3160 #define bfd_elf32_bfd_set_private_flags arc_elf_set_private_flags
3161 #define bfd_elf32_bfd_print_private_bfd_data arc_elf_print_private_bfd_data
3162 #define bfd_elf32_bfd_copy_private_bfd_data arc_elf_copy_private_bfd_data
3163 #define bfd_elf32_bfd_relax_section arc_elf_relax_section
3165 #define elf_info_to_howto_rel arc_info_to_howto_rel
3166 #define elf_backend_object_p arc_elf_object_p
3167 #define elf_backend_final_write_processing arc_elf_final_write_processing
3169 #define elf_backend_relocate_section elf_arc_relocate_section
3170 #define elf_backend_check_relocs elf_arc_check_relocs
3171 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
3173 #define elf_backend_reloc_type_class elf32_arc_reloc_type_class
3175 #define elf_backend_adjust_dynamic_symbol elf_arc_adjust_dynamic_symbol
3176 #define elf_backend_finish_dynamic_symbol elf_arc_finish_dynamic_symbol
3178 #define elf_backend_finish_dynamic_sections elf_arc_finish_dynamic_sections
3179 #define elf_backend_size_dynamic_sections elf_arc_size_dynamic_sections
3181 #define elf_backend_can_gc_sections 1
3182 #define elf_backend_want_got_plt 1
3183 #define elf_backend_plt_readonly 1
3184 #define elf_backend_rela_plts_and_copies_p 1
3185 #define elf_backend_want_plt_sym 0
3186 #define elf_backend_got_header_size 12
3187 #define elf_backend_dtrel_excludes_plt 1
3189 #define elf_backend_may_use_rel_p 0
3190 #define elf_backend_may_use_rela_p 1
3191 #define elf_backend_default_use_rela_p 1
3193 #define elf_backend_grok_prstatus elf32_arc_grok_prstatus
3195 #define elf_backend_default_execstack 0
3197 #undef elf_backend_obj_attrs_vendor
3198 #define elf_backend_obj_attrs_vendor "ARC"
3199 #undef elf_backend_obj_attrs_section
3200 #define elf_backend_obj_attrs_section ".ARC.attributes"
3201 #undef elf_backend_obj_attrs_arg_type
3202 #define elf_backend_obj_attrs_arg_type elf32_arc_obj_attrs_arg_type
3203 #undef elf_backend_obj_attrs_section_type
3204 #define elf_backend_obj_attrs_section_type SHT_ARC_ATTRIBUTES
3205 #define elf_backend_obj_attrs_handle_unknown elf32_arc_obj_attrs_handle_unknown
3207 #define elf_backend_section_from_shdr elf32_arc_section_from_shdr
3209 #include "elf32-target.h"