1 /* ARC-specific support for 32-bit ELF
2 Copyright (C) 1994-2020 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 /* Similar with bfd_get_32 but taking into account the
100 middle-endianess of the ARC CPUs. Only to be used in code
104 bfd_get_32_me (bfd
* abfd
,const unsigned char * data
)
108 if (bfd_big_endian (abfd
))
109 value
= bfd_get_32 (abfd
, data
);
112 value
= ((bfd_get_8 (abfd
, data
) & 255) << 16);
113 value
|= ((bfd_get_8 (abfd
, data
+ 1) & 255) << 24);
114 value
|= (bfd_get_8 (abfd
, data
+ 2) & 255);
115 value
|= ((bfd_get_8 (abfd
, data
+ 3) & 255) << 8);
122 bfd_put_32_me (bfd
*abfd
, bfd_vma value
,unsigned char *data
)
124 bfd_put_16 (abfd
, (value
& 0xffff0000) >> 16, data
);
125 bfd_put_16 (abfd
, value
& 0xffff, data
+ 2);
128 static ATTRIBUTE_UNUSED bfd_boolean
129 is_reloc_PC_relative (reloc_howto_type
*howto
)
131 return (strstr (howto
->name
, "PC") != NULL
) ? TRUE
: FALSE
;
135 is_reloc_SDA_relative (reloc_howto_type
*howto
)
137 return (strstr (howto
->name
, "SDA") != NULL
) ? TRUE
: FALSE
;
141 is_reloc_for_GOT (reloc_howto_type
* howto
)
143 if (strstr (howto
->name
, "TLS") != NULL
)
145 return (strstr (howto
->name
, "GOT") != NULL
) ? TRUE
: FALSE
;
149 is_reloc_for_PLT (reloc_howto_type
* howto
)
151 return (strstr (howto
->name
, "PLT") != NULL
) ? TRUE
: FALSE
;
155 is_reloc_for_TLS (reloc_howto_type
*howto
)
157 return (strstr (howto
->name
, "TLS") != NULL
) ? TRUE
: FALSE
;
160 struct arc_relocation_data
162 bfd_signed_vma reloc_offset
;
163 bfd_signed_vma reloc_addend
;
164 bfd_signed_vma got_offset_value
;
166 bfd_signed_vma sym_value
;
167 asection
* sym_section
;
169 reloc_howto_type
*howto
;
171 asection
* input_section
;
173 bfd_signed_vma sdata_begin_symbol_vma
;
174 bfd_boolean sdata_begin_symbol_vma_set
;
175 bfd_signed_vma got_symbol_vma
;
177 bfd_boolean should_relocate
;
179 const char * symbol_name
;
182 /* ARC ELF linker hash entry. */
183 struct elf_arc_link_hash_entry
185 struct elf_link_hash_entry root
;
187 struct got_entry
*got_ents
;
191 /* Should be included at this location due to static declarations
192 defined before this point. */
195 #define arc_bfd_get_8(A,B,C) bfd_get_8(A,B)
196 #define arc_bfd_get_16(A,B,C) bfd_get_16(A,B)
197 #define arc_bfd_get_32(A,B,C) bfd_get_32(A,B)
198 #define arc_bfd_put_8(A,B,C,D) bfd_put_8(A,B,C)
199 #define arc_bfd_put_16(A,B,C,D) bfd_put_16(A,B,C)
200 #define arc_bfd_put_32(A,B,C,D) bfd_put_32(A,B,C)
203 static bfd_reloc_status_type
204 arc_elf_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
205 arelent
*reloc_entry
,
207 void *data ATTRIBUTE_UNUSED
,
208 asection
*input_section
,
210 char ** error_message ATTRIBUTE_UNUSED
)
212 if (output_bfd
!= NULL
)
214 reloc_entry
->address
+= input_section
->output_offset
;
216 /* In case of relocateable link and if the reloc is against a
217 section symbol, the addend needs to be adjusted according to
218 where the section symbol winds up in the output section. */
219 if ((symbol_in
->flags
& BSF_SECTION_SYM
) && symbol_in
->section
)
220 reloc_entry
->addend
+= symbol_in
->section
->output_offset
;
225 return bfd_reloc_continue
;
229 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
234 #include "elf/arc-reloc.def"
238 #undef ARC_RELOC_HOWTO
240 #define ARC_RELOC_HOWTO(TYPE, VALUE, RSIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
241 [TYPE] = HOWTO (R_##TYPE, 0, RSIZE, BITSIZE, FALSE, 0, \
242 complain_overflow_##OVERFLOW, arc_elf_reloc, \
243 "R_" #TYPE, FALSE, 0, 0, FALSE),
245 static struct reloc_howto_struct elf_arc_howto_table
[] =
247 #include "elf/arc-reloc.def"
248 /* Example of what is generated by the preprocessor. Currently kept as an
250 HOWTO (R_ARC_NONE, // Type.
252 2, // Size (0 = byte, 1 = short, 2 = long).
254 FALSE, // PC_relative.
256 complain_overflow_bitfield, // Complain_on_overflow.
257 bfd_elf_generic_reloc, // Special_function.
258 "R_ARC_NONE", // Name.
259 TRUE, // Partial_inplace.
262 FALSE), // PCrel_offset.
265 #undef ARC_RELOC_HOWTO
268 arc_elf_howto_init (void)
270 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
271 elf_arc_howto_table[TYPE].pc_relative = \
272 (strstr (#FORMULA, " P ") != NULL || strstr (#FORMULA, " PDATA ") != NULL); \
273 elf_arc_howto_table[TYPE].dst_mask = RELOC_FUNCTION(0, ~0); \
274 /* Only 32 bit data relocations should be marked as ME. */ \
275 if (strstr (#FORMULA, " ME ") != NULL) \
277 BFD_ASSERT (SIZE == 2); \
280 #include "elf/arc-reloc.def"
283 #undef ARC_RELOC_HOWTO
286 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
289 const int howto_table_lookup
[] =
291 #include "elf/arc-reloc.def"
294 #undef ARC_RELOC_HOWTO
296 static reloc_howto_type
*
297 arc_elf_howto (unsigned int r_type
)
299 if (elf_arc_howto_table
[R_ARC_32
].dst_mask
== 0)
300 arc_elf_howto_init ();
301 return &elf_arc_howto_table
[r_type
];
304 /* Map BFD reloc types to ARC ELF reloc types. */
308 bfd_reloc_code_real_type bfd_reloc_val
;
309 unsigned char elf_reloc_val
;
312 /* ARC ELF linker hash table. */
313 struct elf_arc_link_hash_table
315 struct elf_link_hash_table elf
;
318 static struct bfd_hash_entry
*
319 elf_arc_link_hash_newfunc (struct bfd_hash_entry
*entry
,
320 struct bfd_hash_table
*table
,
323 struct elf_arc_link_hash_entry
* ret
=
324 (struct elf_arc_link_hash_entry
*) entry
;
326 /* Allocate the structure if it has not already been allocated by a
329 ret
= (struct elf_arc_link_hash_entry
*)
330 bfd_hash_allocate (table
, sizeof (struct elf_arc_link_hash_entry
));
332 return (struct bfd_hash_entry
*) ret
;
334 /* Call the allocation method of the superclass. */
335 ret
= ((struct elf_arc_link_hash_entry
*)
336 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
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_section_flags (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
1100 && reloc_data
.sym_section
->owner
->filename
)
1101 ARC_DEBUG (" file: %s\n", reloc_data
.sym_section
->owner
->filename
);
1105 ARC_DEBUG (" symbol section is NULL\n");
1108 ARC_DEBUG (" Input_section:\n");
1109 if (reloc_data
.input_section
!= NULL
)
1111 ARC_DEBUG (" section name = %s, output_offset 0x%08x, output_section->vma = 0x%08x\n",
1112 reloc_data
.input_section
->name
,
1113 (unsigned int) reloc_data
.input_section
->output_offset
,
1114 (unsigned int) reloc_data
.input_section
->output_section
->vma
);
1115 ARC_DEBUG (" changed_address = 0x%08x\n",
1116 (unsigned int) (reloc_data
.input_section
->output_section
->vma
1117 + reloc_data
.input_section
->output_offset
1118 + reloc_data
.reloc_offset
));
1119 ARC_DEBUG (" file: %s\n", reloc_data
.input_section
->owner
->filename
);
1123 ARC_DEBUG (" input section is NULL\n");
1127 #define DEBUG_ARC_RELOC(A)
1128 #endif /* ARC_ENABLE_DEBUG */
1131 middle_endian_convert (bfd_vma insn
, bfd_boolean do_it
)
1136 = ((insn
& 0xffff0000) >> 16)
1137 | ((insn
& 0xffff) << 16);
1142 /* This function is called for relocations that are otherwise marked as NOT
1143 requiring overflow checks. In here we perform non-standard checks of
1144 the relocation value. */
1146 static inline bfd_reloc_status_type
1147 arc_special_overflow_checks (const struct arc_relocation_data reloc_data
,
1148 bfd_signed_vma relocation
,
1149 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1151 switch (reloc_data
.howto
->type
)
1153 case R_ARC_NPS_CMEM16
:
1154 if (((relocation
>> 16) & 0xffff) != NPS_CMEM_HIGH_VALUE
)
1156 if (reloc_data
.reloc_addend
== 0)
1158 /* xgettext:c-format */
1159 (_("%pB(%pA+%#" PRIx64
"): CMEM relocation to `%s' is invalid, "
1160 "16 MSB should be %#x (value is %#" PRIx64
")"),
1161 reloc_data
.input_section
->owner
,
1162 reloc_data
.input_section
,
1163 (uint64_t) reloc_data
.reloc_offset
,
1164 reloc_data
.symbol_name
,
1165 NPS_CMEM_HIGH_VALUE
,
1166 (uint64_t) relocation
);
1169 /* xgettext:c-format */
1170 (_("%pB(%pA+%#" PRIx64
"): CMEM relocation to `%s+%#" PRIx64
1171 "' is invalid, 16 MSB should be %#x (value is %#" PRIx64
")"),
1172 reloc_data
.input_section
->owner
,
1173 reloc_data
.input_section
,
1174 (uint64_t) reloc_data
.reloc_offset
,
1175 reloc_data
.symbol_name
,
1176 (uint64_t) reloc_data
.reloc_addend
,
1177 NPS_CMEM_HIGH_VALUE
,
1178 (uint64_t) relocation
);
1179 return bfd_reloc_overflow
;
1187 return bfd_reloc_ok
;
1190 #define ME(reloc) (reloc)
1192 #define IS_ME(FORMULA,BFD) ((strstr (FORMULA, "ME") != NULL) \
1193 && (!bfd_big_endian (BFD)))
1195 #define S ((bfd_signed_vma) (reloc_data.sym_value \
1196 + (reloc_data.sym_section->output_section != NULL ? \
1197 (reloc_data.sym_section->output_offset \
1198 + reloc_data.sym_section->output_section->vma) : 0)))
1199 #define L ((bfd_signed_vma) (reloc_data.sym_value \
1200 + (reloc_data.sym_section->output_section != NULL ? \
1201 (reloc_data.sym_section->output_offset \
1202 + reloc_data.sym_section->output_section->vma) : 0)))
1203 #define A (reloc_data.reloc_addend)
1205 #define G (reloc_data.got_offset_value)
1206 #define GOT (reloc_data.got_symbol_vma)
1207 #define GOT_BEGIN (htab->sgot->output_section->vma)
1210 /* P: relative offset to PCL The offset should be to the
1211 current location aligned to 32 bits. */
1212 #define P ((bfd_signed_vma) ( \
1214 (reloc_data.input_section->output_section != NULL ? \
1215 reloc_data.input_section->output_section->vma : 0) \
1216 + reloc_data.input_section->output_offset \
1217 + (reloc_data.reloc_offset - (bitsize >= 32 ? 4 : 0))) \
1219 #define PDATA ((bfd_signed_vma) ( \
1220 (reloc_data.input_section->output_section->vma \
1221 + reloc_data.input_section->output_offset \
1222 + (reloc_data.reloc_offset))))
1223 #define SECTSTART (bfd_signed_vma) (reloc_data.sym_section->output_section->vma \
1224 + reloc_data.sym_section->output_offset)
1225 #define FINAL_SECTSTART \
1226 (bfd_signed_vma) (reloc_data.sym_section->output_section->vma)
1227 #define JLI (bfd_signed_vma) (reloc_data.sym_section->output_section->vma)
1228 #define _SDA_BASE_ (bfd_signed_vma) (reloc_data.sdata_begin_symbol_vma)
1229 #define TLS_REL (bfd_signed_vma) \
1230 ((elf_hash_table (info))->tls_sec->output_section->vma)
1231 #define TLS_TBSS (align_power(TCB_SIZE, \
1232 reloc_data.sym_section->alignment_power))
1236 #ifdef ARC_ENABLE_DEBUG
1237 #define PRINT_DEBUG_RELOC_INFO_BEFORE(FORMULA, TYPE) \
1240 asection *sym_section = reloc_data.sym_section; \
1241 asection *input_section = reloc_data.input_section; \
1242 ARC_DEBUG ("RELOC_TYPE = " TYPE "\n"); \
1243 ARC_DEBUG ("FORMULA = " FORMULA "\n"); \
1244 ARC_DEBUG ("S = %#lx\n", S); \
1245 ARC_DEBUG ("A = %#lx\n", A); \
1246 ARC_DEBUG ("L = %lx\n", L); \
1247 if (sym_section->output_section != NULL) \
1248 ARC_DEBUG ("symbol_section->vma = %#lx\n", \
1249 sym_section->output_section->vma \
1250 + sym_section->output_offset); \
1252 ARC_DEBUG ("symbol_section->vma = NULL\n"); \
1253 if (input_section->output_section != NULL) \
1254 ARC_DEBUG ("input_section->vma = %#lx\n", \
1255 input_section->output_section->vma \
1256 + input_section->output_offset); \
1258 ARC_DEBUG ("input_section->vma = NULL\n"); \
1259 ARC_DEBUG ("PCL = %#lx\n", P); \
1260 ARC_DEBUG ("P = %#lx\n", P); \
1261 ARC_DEBUG ("G = %#lx\n", G); \
1262 ARC_DEBUG ("SDA_OFFSET = %#lx\n", _SDA_BASE_); \
1263 ARC_DEBUG ("SDA_SET = %d\n", reloc_data.sdata_begin_symbol_vma_set); \
1264 ARC_DEBUG ("GOT_OFFSET = %#lx\n", GOT); \
1265 ARC_DEBUG ("relocation = %#08lx\n", relocation); \
1266 ARC_DEBUG ("before = %#08x\n", (unsigned) insn); \
1267 ARC_DEBUG ("data = %08x (%u) (%d)\n", (unsigned) relocation, \
1268 (unsigned) relocation, (int) relocation); \
1272 #define PRINT_DEBUG_RELOC_INFO_AFTER \
1275 ARC_DEBUG ("after = 0x%08x\n", (unsigned int) insn); \
1281 #define PRINT_DEBUG_RELOC_INFO_BEFORE(...)
1282 #define PRINT_DEBUG_RELOC_INFO_AFTER
1284 #endif /* ARC_ENABLE_DEBUG */
1286 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
1289 bfd_signed_vma bitsize ATTRIBUTE_UNUSED = BITSIZE; \
1290 relocation = FORMULA ; \
1291 PRINT_DEBUG_RELOC_INFO_BEFORE (#FORMULA, #TYPE); \
1292 insn = middle_endian_convert (insn, IS_ME (#FORMULA, abfd)); \
1293 insn = (* get_replace_function (abfd, TYPE)) (insn, relocation); \
1294 insn = middle_endian_convert (insn, IS_ME (#FORMULA, abfd)); \
1295 PRINT_DEBUG_RELOC_INFO_AFTER; \
1299 static bfd_reloc_status_type
1300 arc_do_relocation (bfd_byte
* contents
,
1301 struct arc_relocation_data reloc_data
,
1302 struct bfd_link_info
*info
)
1304 bfd_signed_vma relocation
= 0;
1306 bfd_vma orig_insn ATTRIBUTE_UNUSED
;
1307 bfd
* abfd
= reloc_data
.input_section
->owner
;
1308 struct elf_link_hash_table
*htab ATTRIBUTE_UNUSED
= elf_hash_table (info
);
1309 bfd_reloc_status_type flag
;
1311 if (!reloc_data
.should_relocate
)
1312 return bfd_reloc_ok
;
1314 switch (reloc_data
.howto
->size
)
1317 insn
= arc_bfd_get_32 (abfd
,
1318 contents
+ reloc_data
.reloc_offset
,
1319 reloc_data
.input_section
);
1322 insn
= arc_bfd_get_16 (abfd
,
1323 contents
+ reloc_data
.reloc_offset
,
1324 reloc_data
.input_section
);
1327 insn
= arc_bfd_get_8 (abfd
,
1328 contents
+ reloc_data
.reloc_offset
,
1329 reloc_data
.input_section
);
1339 switch (reloc_data
.howto
->type
)
1341 #include "elf/arc-reloc.def"
1348 /* Check for relocation overflow. */
1349 if (reloc_data
.howto
->complain_on_overflow
!= complain_overflow_dont
)
1350 flag
= bfd_check_overflow (reloc_data
.howto
->complain_on_overflow
,
1351 reloc_data
.howto
->bitsize
,
1352 reloc_data
.howto
->rightshift
,
1353 bfd_arch_bits_per_address (abfd
),
1356 flag
= arc_special_overflow_checks (reloc_data
, relocation
, info
);
1358 if (flag
!= bfd_reloc_ok
)
1360 ARC_DEBUG ("Relocation overflows !\n");
1361 DEBUG_ARC_RELOC (reloc_data
);
1362 ARC_DEBUG ("Relocation value = signed -> %d, unsigned -> %u"
1363 ", hex -> (0x%08x)\n",
1364 (int) relocation
, (unsigned) relocation
, (int) relocation
);
1369 /* Write updated instruction back to memory. */
1370 switch (reloc_data
.howto
->size
)
1373 arc_bfd_put_32 (abfd
, insn
,
1374 contents
+ reloc_data
.reloc_offset
,
1375 reloc_data
.input_section
);
1378 arc_bfd_put_16 (abfd
, insn
,
1379 contents
+ reloc_data
.reloc_offset
,
1380 reloc_data
.input_section
);
1383 arc_bfd_put_8 (abfd
, insn
,
1384 contents
+ reloc_data
.reloc_offset
,
1385 reloc_data
.input_section
);
1388 ARC_DEBUG ("size = %d\n", reloc_data
.howto
->size
);
1393 return bfd_reloc_ok
;
1409 #undef ARC_RELOC_HOWTO
1412 /* Relocate an arc ELF section.
1413 Function : elf_arc_relocate_section
1414 Brief : Relocate an arc section, by handling all the relocations
1415 appearing in that section.
1416 Args : output_bfd : The bfd being written to.
1417 info : Link information.
1418 input_bfd : The input bfd.
1419 input_section : The section being relocated.
1420 contents : contents of the section being relocated.
1421 relocs : List of relocations in the section.
1422 local_syms : is a pointer to the swapped in local symbols.
1423 local_section : is an array giving the section in the input file
1424 corresponding to the st_shndx field of each
1427 elf_arc_relocate_section (bfd
* output_bfd
,
1428 struct bfd_link_info
* info
,
1430 asection
* input_section
,
1431 bfd_byte
* contents
,
1432 Elf_Internal_Rela
* relocs
,
1433 Elf_Internal_Sym
* local_syms
,
1434 asection
** local_sections
)
1436 Elf_Internal_Shdr
* symtab_hdr
;
1437 struct elf_link_hash_entry
** sym_hashes
;
1438 Elf_Internal_Rela
* rel
;
1439 Elf_Internal_Rela
* wrel
;
1440 Elf_Internal_Rela
* relend
;
1441 struct elf_link_hash_table
* htab
= elf_hash_table (info
);
1443 symtab_hdr
= &((elf_tdata (input_bfd
))->symtab_hdr
);
1444 sym_hashes
= elf_sym_hashes (input_bfd
);
1446 rel
= wrel
= relocs
;
1447 relend
= relocs
+ input_section
->reloc_count
;
1448 for (; rel
< relend
; wrel
++, rel
++)
1450 enum elf_arc_reloc_type r_type
;
1451 reloc_howto_type
* howto
;
1452 unsigned long r_symndx
;
1453 struct elf_link_hash_entry
* h
;
1454 Elf_Internal_Sym
* sym
;
1456 struct elf_link_hash_entry
* h2
;
1458 bfd_boolean unresolved_reloc
= FALSE
;
1460 struct arc_relocation_data reloc_data
=
1464 .got_offset_value
= 0,
1466 .sym_section
= NULL
,
1468 .input_section
= NULL
,
1469 .sdata_begin_symbol_vma
= 0,
1470 .sdata_begin_symbol_vma_set
= FALSE
,
1471 .got_symbol_vma
= 0,
1472 .should_relocate
= FALSE
1475 r_type
= ELF32_R_TYPE (rel
->r_info
);
1477 if (r_type
>= (int) R_ARC_max
)
1479 bfd_set_error (bfd_error_bad_value
);
1482 howto
= arc_elf_howto (r_type
);
1484 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1486 /* If we are generating another .o file and the symbol in not
1487 local, skip this relocation. */
1488 if (bfd_link_relocatable (info
))
1490 /* This is a relocateable link. We don't have to change
1491 anything, unless the reloc is against a section symbol,
1492 in which case we have to adjust according to where the
1493 section symbol winds up in the output section. */
1495 /* Checks if this is a local symbol and thus the reloc
1496 might (will??) be against a section symbol. */
1497 if (r_symndx
< symtab_hdr
->sh_info
)
1499 sym
= local_syms
+ r_symndx
;
1500 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1502 sec
= local_sections
[r_symndx
];
1504 /* For RELA relocs. Just adjust the addend
1505 value in the relocation entry. */
1506 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
1508 ARC_DEBUG ("local symbols reloc (section=%d %s) seen in %s\n",
1509 (int) r_symndx
, local_sections
[r_symndx
]->name
,
1510 __PRETTY_FUNCTION__
);
1515 h2
= elf_link_hash_lookup (elf_hash_table (info
), "__SDATA_BEGIN__",
1516 FALSE
, FALSE
, TRUE
);
1518 if (!reloc_data
.sdata_begin_symbol_vma_set
1519 && h2
!= NULL
&& h2
->root
.type
!= bfd_link_hash_undefined
1520 && h2
->root
.u
.def
.section
->output_section
!= NULL
)
1521 /* TODO: Verify this condition. */
1523 reloc_data
.sdata_begin_symbol_vma
=
1524 (h2
->root
.u
.def
.value
1525 + h2
->root
.u
.def
.section
->output_section
->vma
);
1526 reloc_data
.sdata_begin_symbol_vma_set
= TRUE
;
1529 reloc_data
.input_section
= input_section
;
1530 reloc_data
.howto
= howto
;
1531 reloc_data
.reloc_offset
= rel
->r_offset
;
1532 reloc_data
.reloc_addend
= rel
->r_addend
;
1534 /* This is a final link. */
1539 if (r_symndx
< symtab_hdr
->sh_info
) /* A local symbol. */
1541 sym
= local_syms
+ r_symndx
;
1542 sec
= local_sections
[r_symndx
];
1546 bfd_boolean warned
, ignored
;
1547 bfd_vma relocation ATTRIBUTE_UNUSED
;
1549 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
1550 r_symndx
, symtab_hdr
, sym_hashes
,
1552 unresolved_reloc
, warned
, ignored
);
1554 /* TODO: This code is repeated from below. We should
1555 clean it and remove duplications.
1556 Sec is used check for discarded sections.
1557 Need to redesign code below. */
1559 /* Get the symbol's entry in the symtab. */
1560 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1562 while (h
->root
.type
== bfd_link_hash_indirect
1563 || h
->root
.type
== bfd_link_hash_warning
)
1564 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1566 /* If we have encountered a definition for this symbol. */
1567 if (h
->root
.type
== bfd_link_hash_defined
1568 || h
->root
.type
== bfd_link_hash_defweak
)
1570 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1571 sec
= h
->root
.u
.def
.section
;
1575 /* Clean relocs for symbols in discarded sections. */
1576 if (sec
!= NULL
&& discarded_section (sec
))
1578 _bfd_clear_contents (howto
, input_bfd
, input_section
,
1579 contents
, rel
->r_offset
);
1583 /* For ld -r, remove relocations in debug sections against
1584 sections defined in discarded sections. Not done for
1585 eh_frame editing code expects to be present. */
1586 if (bfd_link_relocatable (info
)
1587 && (input_section
->flags
& SEC_DEBUGGING
))
1593 if (bfd_link_relocatable (info
))
1600 if (r_symndx
< symtab_hdr
->sh_info
) /* A local symbol. */
1602 reloc_data
.sym_value
= sym
->st_value
;
1603 reloc_data
.sym_section
= sec
;
1604 reloc_data
.symbol_name
=
1605 bfd_elf_string_from_elf_section (input_bfd
,
1606 symtab_hdr
->sh_link
,
1609 /* Mergeable section handling. */
1610 if ((sec
->flags
& SEC_MERGE
)
1611 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1615 rel
->r_addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
,
1616 &msec
, rel
->r_addend
);
1617 rel
->r_addend
-= (sec
->output_section
->vma
1618 + sec
->output_offset
1620 rel
->r_addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
1622 reloc_data
.reloc_addend
= rel
->r_addend
;
1625 BFD_ASSERT (htab
->sgot
!= NULL
|| !is_reloc_for_GOT (howto
));
1626 if (htab
->sgot
!= NULL
)
1627 reloc_data
.got_symbol_vma
= htab
->sgot
->output_section
->vma
1628 + htab
->sgot
->output_offset
;
1630 reloc_data
.should_relocate
= TRUE
;
1632 else /* Global symbol. */
1634 /* FIXME: We should use the RELOC_FOR_GLOBAL_SYMBOL macro
1635 (defined in elf-bfd.h) here. */
1637 /* Get the symbol's entry in the symtab. */
1638 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1640 while (h
->root
.type
== bfd_link_hash_indirect
1641 || h
->root
.type
== bfd_link_hash_warning
)
1643 struct elf_arc_link_hash_entry
*ah_old
=
1644 (struct elf_arc_link_hash_entry
*) h
;
1645 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1646 struct elf_arc_link_hash_entry
*ah
=
1647 (struct elf_arc_link_hash_entry
*) h
;
1649 if (ah
->got_ents
== 0 && ah_old
->got_ents
!= ah
->got_ents
)
1650 ah
->got_ents
= ah_old
->got_ents
;
1653 /* TODO: Need to validate what was the intention. */
1654 /* BFD_ASSERT ((h->dynindx == -1) || (h->forced_local != 0)); */
1655 reloc_data
.symbol_name
= h
->root
.root
.string
;
1657 /* If we have encountered a definition for this symbol. */
1658 if (h
->root
.type
== bfd_link_hash_defined
1659 || h
->root
.type
== bfd_link_hash_defweak
)
1661 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1662 reloc_data
.sym_section
= h
->root
.u
.def
.section
;
1664 reloc_data
.should_relocate
= TRUE
;
1666 if (is_reloc_for_GOT (howto
) && !bfd_link_pic (info
))
1668 struct elf_arc_link_hash_entry
*ah
=
1669 (struct elf_arc_link_hash_entry
*) h
;
1670 /* TODO: Change it to use arc_do_relocation with
1671 ARC_32 reloc. Try to use ADD_RELA macro. */
1672 bfd_vma relocation
=
1673 reloc_data
.sym_value
+ reloc_data
.reloc_addend
1674 + (reloc_data
.sym_section
->output_section
!= NULL
?
1675 (reloc_data
.sym_section
->output_offset
1676 + reloc_data
.sym_section
->output_section
->vma
)
1679 BFD_ASSERT (ah
->got_ents
);
1680 bfd_vma got_offset
= ah
->got_ents
->offset
;
1681 bfd_put_32 (output_bfd
, relocation
,
1682 htab
->sgot
->contents
+ got_offset
);
1684 if (is_reloc_for_PLT (howto
) && h
->plt
.offset
!= (bfd_vma
) -1)
1686 /* TODO: This is repeated up here. */
1687 reloc_data
.sym_value
= h
->plt
.offset
;
1688 reloc_data
.sym_section
= htab
->splt
;
1691 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1693 /* Is weak symbol and has no definition. */
1694 if (is_reloc_for_GOT (howto
))
1696 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1697 reloc_data
.sym_section
= htab
->sgot
;
1698 reloc_data
.should_relocate
= TRUE
;
1700 else if (is_reloc_for_PLT (howto
)
1701 && h
->plt
.offset
!= (bfd_vma
) -1)
1703 /* TODO: This is repeated up here. */
1704 reloc_data
.sym_value
= h
->plt
.offset
;
1705 reloc_data
.sym_section
= htab
->splt
;
1706 reloc_data
.should_relocate
= TRUE
;
1713 if (is_reloc_for_GOT (howto
))
1715 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1716 reloc_data
.sym_section
= htab
->sgot
;
1718 reloc_data
.should_relocate
= TRUE
;
1720 else if (is_reloc_for_PLT (howto
))
1722 /* Fail if it is linking for PIE and the symbol is
1724 if (bfd_link_executable (info
))
1725 (*info
->callbacks
->undefined_symbol
)
1726 (info
, h
->root
.root
.string
, input_bfd
, input_section
,
1727 rel
->r_offset
, TRUE
);
1728 reloc_data
.sym_value
= h
->plt
.offset
;
1729 reloc_data
.sym_section
= htab
->splt
;
1731 reloc_data
.should_relocate
= TRUE
;
1733 else if (!bfd_link_pic (info
) || bfd_link_executable (info
))
1734 (*info
->callbacks
->undefined_symbol
)
1735 (info
, h
->root
.root
.string
, input_bfd
, input_section
,
1736 rel
->r_offset
, TRUE
);
1739 BFD_ASSERT (htab
->sgot
!= NULL
|| !is_reloc_for_GOT (howto
));
1740 if (htab
->sgot
!= NULL
)
1741 reloc_data
.got_symbol_vma
= htab
->sgot
->output_section
->vma
1742 + htab
->sgot
->output_offset
;
1745 if ((is_reloc_for_GOT (howto
)
1746 || is_reloc_for_TLS (howto
)))
1748 reloc_data
.should_relocate
= TRUE
;
1750 struct got_entry
**list
1751 = get_got_entry_list_for_symbol (input_bfd
, r_symndx
, h
);
1753 reloc_data
.got_offset_value
1754 = relocate_fix_got_relocs_for_got_info (list
,
1755 tls_type_for_reloc (howto
),
1766 create_got_dynrelocs_for_single_entry (
1767 got_entry_for_type (list
,
1768 arc_got_entry_type_for_reloc (howto
)),
1769 output_bfd
, info
, NULL
);
1774 #define IS_ARC_PCREL_TYPE(TYPE) \
1775 ( (TYPE == R_ARC_PC32) \
1776 || (TYPE == R_ARC_32_PCREL))
1783 case R_ARC_32_PCREL
:
1784 if (bfd_link_pic (info
)
1785 && (!IS_ARC_PCREL_TYPE (r_type
)
1789 && (!info
->symbolic
|| !h
->def_regular
))))
1791 Elf_Internal_Rela outrel
;
1793 bfd_boolean skip
= FALSE
;
1794 bfd_boolean relocate
= FALSE
;
1795 asection
*sreloc
= _bfd_elf_get_dynamic_reloc_section
1796 (input_bfd
, input_section
,
1799 BFD_ASSERT (sreloc
!= NULL
);
1801 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
1806 if (outrel
.r_offset
== (bfd_vma
) -1)
1809 outrel
.r_addend
= rel
->r_addend
;
1810 outrel
.r_offset
+= (input_section
->output_section
->vma
1811 + input_section
->output_offset
);
1815 memset (&outrel
, 0, sizeof outrel
);
1820 && (IS_ARC_PCREL_TYPE (r_type
)
1821 || !(bfd_link_executable (info
)
1822 || SYMBOLIC_BIND (info
, h
))
1823 || ! h
->def_regular
))
1825 BFD_ASSERT (h
!= NULL
);
1826 if ((input_section
->flags
& SEC_ALLOC
) != 0)
1831 BFD_ASSERT (h
->dynindx
!= -1);
1832 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
1836 /* Handle local symbols, they either do not have a
1837 global hash table entry (h == NULL), or are
1838 forced local due to a version script
1839 (h->forced_local), or the third condition is
1840 legacy, it appears to say something like, for
1841 links where we are pre-binding the symbols, or
1842 there's not an entry for this symbol in the
1843 dynamic symbol table, and it's a regular symbol
1844 not defined in a shared object, then treat the
1845 symbol as local, resolve it now. */
1847 /* outrel.r_addend = 0; */
1848 outrel
.r_info
= ELF32_R_INFO (0, R_ARC_RELATIVE
);
1851 BFD_ASSERT (sreloc
->contents
!= 0);
1853 loc
= sreloc
->contents
;
1854 loc
+= sreloc
->reloc_count
* sizeof (Elf32_External_Rela
);
1855 sreloc
->reloc_count
+= 1;
1857 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
1867 if (is_reloc_SDA_relative (howto
)
1868 && !reloc_data
.sdata_begin_symbol_vma_set
)
1871 ("error: linker symbol __SDATA_BEGIN__ not found");
1872 bfd_set_error (bfd_error_bad_value
);
1876 DEBUG_ARC_RELOC (reloc_data
);
1878 /* Make sure we have with a dynamic linker. In case of GOT and PLT
1879 the sym_section should point to .got or .plt respectively. */
1880 if ((is_reloc_for_GOT (howto
) || is_reloc_for_PLT (howto
))
1881 && reloc_data
.sym_section
== NULL
)
1884 (_("GOT and PLT relocations cannot be fixed with a non dynamic linker"));
1885 bfd_set_error (bfd_error_bad_value
);
1890 switch (arc_do_relocation (contents
, reloc_data
, info
))
1893 continue; /* The reloc processing loop. */
1895 case bfd_reloc_overflow
:
1896 (*info
->callbacks
->reloc_overflow
)
1897 (info
, (h
? &h
->root
: NULL
), reloc_data
.symbol_name
, howto
->name
, (bfd_vma
) 0,
1898 input_bfd
, input_section
, rel
->r_offset
);
1901 case bfd_reloc_undefined
:
1902 (*info
->callbacks
->undefined_symbol
)
1903 (info
, reloc_data
.symbol_name
, input_bfd
, input_section
, rel
->r_offset
, TRUE
);
1906 case bfd_reloc_other
:
1907 /* xgettext:c-format */
1908 msg
= _("%pB(%pA): warning: unaligned access to symbol '%s' in the small data area");
1911 case bfd_reloc_outofrange
:
1912 /* xgettext:c-format */
1913 msg
= _("%pB(%pA): internal error: out of range error");
1916 case bfd_reloc_notsupported
:
1917 /* xgettext:c-format */
1918 msg
= _("%pB(%pA): internal error: unsupported relocation error");
1921 case bfd_reloc_dangerous
:
1922 /* xgettext:c-format */
1923 msg
= _("%pB(%pA): internal error: dangerous relocation");
1927 /* xgettext:c-format */
1928 msg
= _("%pB(%pA): internal error: unknown error");
1933 _bfd_error_handler (msg
, input_bfd
, input_section
, reloc_data
.symbol_name
);
1940 #define elf_arc_hash_table(p) \
1941 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
1942 == ARC_ELF_DATA ? ((struct elf_arc_link_hash_table *) ((p)->hash)) : NULL)
1945 elf_arc_check_relocs (bfd
* abfd
,
1946 struct bfd_link_info
* info
,
1948 const Elf_Internal_Rela
* relocs
)
1950 Elf_Internal_Shdr
* symtab_hdr
;
1951 struct elf_link_hash_entry
** sym_hashes
;
1952 const Elf_Internal_Rela
* rel
;
1953 const Elf_Internal_Rela
* rel_end
;
1955 asection
* sreloc
= NULL
;
1956 struct elf_link_hash_table
* htab
= elf_hash_table (info
);
1958 if (bfd_link_relocatable (info
))
1961 if (htab
->dynobj
== NULL
)
1962 htab
->dynobj
= abfd
;
1964 dynobj
= (elf_hash_table (info
))->dynobj
;
1965 symtab_hdr
= &((elf_tdata (abfd
))->symtab_hdr
);
1966 sym_hashes
= elf_sym_hashes (abfd
);
1968 rel_end
= relocs
+ sec
->reloc_count
;
1969 for (rel
= relocs
; rel
< rel_end
; rel
++)
1971 enum elf_arc_reloc_type r_type
;
1972 reloc_howto_type
*howto
;
1973 unsigned long r_symndx
;
1974 struct elf_link_hash_entry
*h
;
1976 r_type
= ELF32_R_TYPE (rel
->r_info
);
1978 if (r_type
>= (int) R_ARC_max
)
1980 bfd_set_error (bfd_error_bad_value
);
1983 howto
= arc_elf_howto (r_type
);
1985 /* Load symbol information. */
1986 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1987 if (r_symndx
< symtab_hdr
->sh_info
) /* Is a local symbol. */
1989 else /* Global one. */
1991 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1992 while (h
->root
.type
== bfd_link_hash_indirect
1993 || h
->root
.type
== bfd_link_hash_warning
)
1994 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2002 /* During shared library creation, these relocs should not
2003 appear in a shared library (as memory will be read only
2004 and the dynamic linker can not resolve these. However
2005 the error should not occur for e.g. debugging or
2006 non-readonly sections. */
2008 && (bfd_link_dll (info
) && !bfd_link_pie (info
))
2009 && (sec
->flags
& SEC_ALLOC
) != 0
2010 && (sec
->flags
& SEC_READONLY
) != 0
2011 && ((sec
->flags
& SEC_CODE
) != 0
2012 || (sec
->flags
& SEC_DEBUGGING
) != 0))
2016 name
= h
->root
.root
.string
;
2020 /* xgettext:c-format */
2021 (_("%pB: relocation %s against `%s' can not be used"
2022 " when making a shared object; recompile with -fPIC"),
2024 arc_elf_howto (r_type
)->name
,
2026 bfd_set_error (bfd_error_bad_value
);
2030 /* In some cases we are not setting the 'non_got_ref'
2031 flag, even though the relocations don't require a GOT
2032 access. We should extend the testing in this area to
2033 ensure that no significant cases are being missed. */
2038 case R_ARC_32_PCREL
:
2039 if ((bfd_link_pic (info
))
2040 && ((r_type
!= R_ARC_PC32
&& r_type
!= R_ARC_32_PCREL
)
2042 && (!info
->symbolic
|| !h
->def_regular
))))
2047 && ! htab
->dynamic_sections_created
2048 && ! _bfd_elf_link_create_dynamic_sections (abfd
, info
))
2050 sreloc
= _bfd_elf_make_dynamic_reloc_section (sec
, dynobj
,
2058 sreloc
->size
+= sizeof (Elf32_External_Rela
);
2065 if (is_reloc_for_PLT (howto
))
2070 if (h
->forced_local
== 0)
2074 /* Add info to the symbol got_entry_list. */
2075 if (is_reloc_for_GOT (howto
)
2076 || is_reloc_for_TLS (howto
))
2078 if (bfd_link_dll (info
) && !bfd_link_pie (info
)
2079 && (r_type
== R_ARC_TLS_LE_32
|| r_type
== R_ARC_TLS_LE_S9
))
2083 name
= h
->root
.root
.string
;
2085 /* bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL); */
2088 /* xgettext:c-format */
2089 (_("%pB: relocation %s against `%s' can not be used"
2090 " when making a shared object; recompile with -fPIC"),
2092 arc_elf_howto (r_type
)->name
,
2094 bfd_set_error (bfd_error_bad_value
);
2097 if (! _bfd_elf_create_got_section (dynobj
, info
))
2100 arc_fill_got_info_for_reloc (
2101 arc_got_entry_type_for_reloc (howto
),
2102 get_got_entry_list_for_symbol (abfd
, r_symndx
, h
),
2111 #define ELF_DYNAMIC_INTERPRETER "/sbin/ld-uClibc.so"
2113 static struct plt_version_t
*
2114 arc_get_plt_version (struct bfd_link_info
*info
)
2118 for (i
= 0; i
< 1; i
++)
2120 ARC_DEBUG ("%d: size1 = %d, size2 = %d\n", i
,
2121 (int) plt_versions
[i
].entry_size
,
2122 (int) plt_versions
[i
].elem_size
);
2125 if (bfd_get_mach (info
->output_bfd
) == bfd_mach_arc_arcv2
)
2127 if (bfd_link_pic (info
))
2128 return &(plt_versions
[ELF_ARCV2_PIC
]);
2130 return &(plt_versions
[ELF_ARCV2_ABS
]);
2134 if (bfd_link_pic (info
))
2135 return &(plt_versions
[ELF_ARC_PIC
]);
2137 return &(plt_versions
[ELF_ARC_ABS
]);
2142 add_symbol_to_plt (struct bfd_link_info
*info
)
2144 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2147 struct plt_version_t
*plt_data
= arc_get_plt_version (info
);
2149 /* If this is the first .plt entry, make room for the special first
2151 if (htab
->splt
->size
== 0)
2152 htab
->splt
->size
+= plt_data
->entry_size
;
2154 ret
= htab
->splt
->size
;
2156 htab
->splt
->size
+= plt_data
->elem_size
;
2157 ARC_DEBUG ("PLT_SIZE = %d\n", (int) htab
->splt
->size
);
2159 htab
->sgotplt
->size
+= 4;
2160 htab
->srelplt
->size
+= sizeof (Elf32_External_Rela
);
2165 #define PLT_DO_RELOCS_FOR_ENTRY(ABFD, DS, RELOCS) \
2166 plt_do_relocs_for_symbol (ABFD, DS, RELOCS, 0, 0)
2169 plt_do_relocs_for_symbol (bfd
*abfd
,
2170 struct elf_link_hash_table
*htab
,
2171 const struct plt_reloc
*reloc
,
2173 bfd_vma symbol_got_offset
)
2175 while (SYM_ONLY (reloc
->symbol
) != LAST_RELOC
)
2177 bfd_vma relocation
= 0;
2179 switch (SYM_ONLY (reloc
->symbol
))
2183 = htab
->sgotplt
->output_section
->vma
2184 + htab
->sgotplt
->output_offset
+ symbol_got_offset
;
2187 relocation
+= reloc
->addend
;
2189 if (IS_RELATIVE (reloc
->symbol
))
2191 bfd_vma reloc_offset
= reloc
->offset
;
2192 reloc_offset
-= (IS_INSN_32 (reloc
->symbol
)) ? 4 : 0;
2193 reloc_offset
-= (IS_INSN_24 (reloc
->symbol
)) ? 2 : 0;
2195 relocation
-= htab
->splt
->output_section
->vma
2196 + htab
->splt
->output_offset
2197 + plt_offset
+ reloc_offset
;
2200 /* TODO: being ME is not a property of the relocation but of the
2201 section of which is applying the relocation. */
2202 if (IS_MIDDLE_ENDIAN (reloc
->symbol
) && !bfd_big_endian (abfd
))
2205 = ((relocation
& 0xffff0000) >> 16)
2206 | ((relocation
& 0xffff) << 16);
2209 switch (reloc
->size
)
2212 bfd_put_32 (htab
->splt
->output_section
->owner
,
2214 htab
->splt
->contents
+ plt_offset
+ reloc
->offset
);
2218 reloc
= &(reloc
[1]); /* Jump to next relocation. */
2223 relocate_plt_for_symbol (bfd
*output_bfd
,
2224 struct bfd_link_info
*info
,
2225 struct elf_link_hash_entry
*h
)
2227 struct plt_version_t
*plt_data
= arc_get_plt_version (info
);
2228 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2230 bfd_vma plt_index
= (h
->plt
.offset
- plt_data
->entry_size
)
2231 / plt_data
->elem_size
;
2232 bfd_vma got_offset
= (plt_index
+ 3) * 4;
2234 ARC_DEBUG ("arc_info: PLT_OFFSET = %#lx, PLT_ENTRY_VMA = %#lx, \
2235 GOT_ENTRY_OFFSET = %#lx, GOT_ENTRY_VMA = %#lx, for symbol %s\n",
2236 (long) h
->plt
.offset
,
2237 (long) (htab
->splt
->output_section
->vma
2238 + htab
->splt
->output_offset
2241 (long) (htab
->sgotplt
->output_section
->vma
2242 + htab
->sgotplt
->output_offset
2244 h
->root
.root
.string
);
2248 uint16_t *ptr
= (uint16_t *) plt_data
->elem
;
2250 for (i
= 0; i
< plt_data
->elem_size
/2; i
++)
2252 uint16_t data
= ptr
[i
];
2253 bfd_put_16 (output_bfd
,
2255 htab
->splt
->contents
+ h
->plt
.offset
+ (i
*2));
2259 plt_do_relocs_for_symbol (output_bfd
, htab
,
2260 plt_data
->elem_relocs
,
2264 /* Fill in the entry in the global offset table. */
2265 bfd_put_32 (output_bfd
,
2266 (bfd_vma
) (htab
->splt
->output_section
->vma
2267 + htab
->splt
->output_offset
),
2268 htab
->sgotplt
->contents
+ got_offset
);
2270 /* TODO: Fill in the entry in the .rela.plt section. */
2272 Elf_Internal_Rela rel
;
2275 rel
.r_offset
= (htab
->sgotplt
->output_section
->vma
2276 + htab
->sgotplt
->output_offset
2280 BFD_ASSERT (h
->dynindx
!= -1);
2281 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARC_JMP_SLOT
);
2283 loc
= htab
->srelplt
->contents
;
2284 loc
+= plt_index
* sizeof (Elf32_External_Rela
); /* relA */
2285 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
2290 relocate_plt_for_entry (bfd
*abfd
,
2291 struct bfd_link_info
*info
)
2293 struct plt_version_t
*plt_data
= arc_get_plt_version (info
);
2294 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2298 uint16_t *ptr
= (uint16_t *) plt_data
->entry
;
2299 for (i
= 0; i
< plt_data
->entry_size
/2; i
++)
2301 uint16_t data
= ptr
[i
];
2304 htab
->splt
->contents
+ (i
*2));
2307 PLT_DO_RELOCS_FOR_ENTRY (abfd
, htab
, plt_data
->entry_relocs
);
2310 /* Desc : Adjust a symbol defined by a dynamic object and referenced
2311 by a regular object. The current definition is in some section of
2312 the dynamic object, but we're not including those sections. We
2313 have to change the definition to something the rest of the link can
2317 elf_arc_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2318 struct elf_link_hash_entry
*h
)
2321 bfd
*dynobj
= (elf_hash_table (info
))->dynobj
;
2322 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2324 if (h
->type
== STT_FUNC
2325 || h
->type
== STT_GNU_IFUNC
2326 || h
->needs_plt
== 1)
2328 if (!bfd_link_pic (info
) && !h
->def_dynamic
&& !h
->ref_dynamic
)
2330 /* This case can occur if we saw a PLT32 reloc in an input
2331 file, but the symbol was never referred to by a dynamic
2332 object. In such a case, we don't actually need to build
2333 a procedure linkage table, and we can just do a PC32
2335 BFD_ASSERT (h
->needs_plt
);
2339 /* Make sure this symbol is output as a dynamic symbol. */
2340 if (h
->dynindx
== -1 && !h
->forced_local
2341 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
2344 if (bfd_link_pic (info
)
2345 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2347 bfd_vma loc
= add_symbol_to_plt (info
);
2349 if (bfd_link_executable (info
) && !h
->def_regular
)
2351 h
->root
.u
.def
.section
= htab
->splt
;
2352 h
->root
.u
.def
.value
= loc
;
2354 h
->plt
.offset
= loc
;
2358 h
->plt
.offset
= (bfd_vma
) -1;
2364 /* If this is a weak symbol, and there is a real definition, the
2365 processor independent code will have arranged for us to see the
2366 real definition first, and we can just use the same value. */
2367 if (h
->is_weakalias
)
2369 struct elf_link_hash_entry
*def
= weakdef (h
);
2370 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
2371 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
2372 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
2376 /* This is a reference to a symbol defined by a dynamic object which
2377 is not a function. */
2379 /* If we are creating a shared library, we must presume that the
2380 only references to the symbol are via the global offset table.
2381 For such cases we need not do anything here; the relocations will
2382 be handled correctly by relocate_section. */
2383 if (!bfd_link_executable (info
))
2386 /* If there are no non-GOT references, we do not need a copy
2388 if (!h
->non_got_ref
)
2391 /* If -z nocopyreloc was given, we won't generate them either. */
2392 if (info
->nocopyreloc
)
2398 /* We must allocate the symbol in our .dynbss section, which will
2399 become part of the .bss section of the executable. There will be
2400 an entry for this symbol in the .dynsym section. The dynamic
2401 object will contain position independent code, so all references
2402 from the dynamic object to this symbol will go through the global
2403 offset table. The dynamic linker will use the .dynsym entry to
2404 determine the address it must put in the global offset table, so
2405 both the dynamic object and the regular object will refer to the
2406 same memory location for the variable. */
2411 /* We must generate a R_ARC_COPY reloc to tell the dynamic linker to
2412 copy the initial value out of the dynamic object and into the
2413 runtime process image. We need to remember the offset into the
2414 .rela.bss section we are going to use. */
2415 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
2417 struct elf_arc_link_hash_table
*arc_htab
= elf_arc_hash_table (info
);
2419 BFD_ASSERT (arc_htab
->elf
.srelbss
!= NULL
);
2420 arc_htab
->elf
.srelbss
->size
+= sizeof (Elf32_External_Rela
);
2424 /* TODO: Move this also to arc_hash_table. */
2425 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
2426 BFD_ASSERT (s
!= NULL
);
2428 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2431 /* Function : elf_arc_finish_dynamic_symbol
2432 Brief : Finish up dynamic symbol handling. We set the
2433 contents of various dynamic sections here.
2438 Returns : True/False as the return status. */
2441 elf_arc_finish_dynamic_symbol (bfd
* output_bfd
,
2442 struct bfd_link_info
*info
,
2443 struct elf_link_hash_entry
*h
,
2444 Elf_Internal_Sym
* sym
)
2446 if (h
->plt
.offset
!= (bfd_vma
) -1)
2448 relocate_plt_for_symbol (output_bfd
, info
, h
);
2450 if (!h
->def_regular
)
2452 /* Mark the symbol as undefined, rather than as defined in
2453 the .plt section. Leave the value alone. */
2454 sym
->st_shndx
= SHN_UNDEF
;
2459 /* This function traverses list of GOT entries and
2460 create respective dynamic relocs. */
2461 /* TODO: Make function to get list and not access the list directly. */
2462 /* TODO: Move function to relocate_section create this relocs eagerly. */
2463 struct elf_arc_link_hash_entry
*ah
=
2464 (struct elf_arc_link_hash_entry
*) h
;
2465 create_got_dynrelocs_for_got_info (&ah
->got_ents
,
2472 struct elf_arc_link_hash_table
*arc_htab
= elf_arc_hash_table (info
);
2474 if (arc_htab
== NULL
)
2477 if (h
->dynindx
== -1
2478 || (h
->root
.type
!= bfd_link_hash_defined
2479 && h
->root
.type
!= bfd_link_hash_defweak
)
2480 || arc_htab
->elf
.srelbss
== NULL
)
2483 bfd_vma rel_offset
= (h
->root
.u
.def
.value
2484 + h
->root
.u
.def
.section
->output_section
->vma
2485 + h
->root
.u
.def
.section
->output_offset
);
2487 bfd_byte
* loc
= arc_htab
->elf
.srelbss
->contents
2488 + (arc_htab
->elf
.srelbss
->reloc_count
* sizeof (Elf32_External_Rela
));
2489 arc_htab
->elf
.srelbss
->reloc_count
++;
2491 Elf_Internal_Rela rel
;
2493 rel
.r_offset
= rel_offset
;
2495 BFD_ASSERT (h
->dynindx
!= -1);
2496 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARC_COPY
);
2498 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
2501 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2502 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2503 || strcmp (h
->root
.root
.string
, "__DYNAMIC") == 0
2504 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
2505 sym
->st_shndx
= SHN_ABS
;
2510 #define GET_SYMBOL_OR_SECTION(TAG, SYMBOL, SECTION) \
2512 if (SYMBOL != NULL) \
2513 h = elf_link_hash_lookup (elf_hash_table (info), \
2514 SYMBOL, FALSE, FALSE, TRUE); \
2515 else if (SECTION != NULL) \
2516 s = bfd_get_linker_section (dynobj, SECTION); \
2520 struct obfd_info_group
{
2522 struct bfd_link_info
*info
;
2526 arc_create_forced_local_got_entries_for_tls (struct bfd_hash_entry
*bh
,
2529 struct elf_arc_link_hash_entry
* h
=
2530 (struct elf_arc_link_hash_entry
*) bh
;
2531 struct obfd_info_group
*tmp
= (struct obfd_info_group
*) data
;
2533 if (h
->got_ents
!= NULL
)
2537 struct got_entry
*list
= h
->got_ents
;
2539 while (list
!= NULL
)
2541 create_got_dynrelocs_for_single_entry (list
, tmp
->output_bfd
,
2543 (struct elf_link_hash_entry
*) h
);
2552 /* Function : elf_arc_finish_dynamic_sections
2553 Brief : Finish up the dynamic sections handling.
2558 Returns : True/False as the return status. */
2561 elf_arc_finish_dynamic_sections (bfd
* output_bfd
,
2562 struct bfd_link_info
*info
)
2564 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2565 bfd
*dynobj
= (elf_hash_table (info
))->dynobj
;
2566 asection
*sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
2570 Elf32_External_Dyn
*dyncon
, *dynconend
;
2572 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
2574 = (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
2575 for (; dyncon
< dynconend
; dyncon
++)
2577 Elf_Internal_Dyn internal_dyn
;
2578 bfd_boolean do_it
= FALSE
;
2580 struct elf_link_hash_entry
*h
= NULL
;
2583 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &internal_dyn
);
2585 switch (internal_dyn
.d_tag
)
2587 GET_SYMBOL_OR_SECTION (DT_INIT
, info
->init_function
, NULL
)
2588 GET_SYMBOL_OR_SECTION (DT_FINI
, info
->fini_function
, NULL
)
2589 GET_SYMBOL_OR_SECTION (DT_PLTGOT
, NULL
, ".plt")
2590 GET_SYMBOL_OR_SECTION (DT_JMPREL
, NULL
, ".rela.plt")
2591 GET_SYMBOL_OR_SECTION (DT_PLTRELSZ
, NULL
, ".rela.plt")
2592 GET_SYMBOL_OR_SECTION (DT_VERSYM
, NULL
, ".gnu.version")
2593 GET_SYMBOL_OR_SECTION (DT_VERDEF
, NULL
, ".gnu.version_d")
2594 GET_SYMBOL_OR_SECTION (DT_VERNEED
, NULL
, ".gnu.version_r")
2599 /* In case the dynamic symbols should be updated with a symbol. */
2601 && (h
->root
.type
== bfd_link_hash_defined
2602 || h
->root
.type
== bfd_link_hash_defweak
))
2606 internal_dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
2607 asec_ptr
= h
->root
.u
.def
.section
;
2608 if (asec_ptr
->output_section
!= NULL
)
2610 internal_dyn
.d_un
.d_val
+=
2611 (asec_ptr
->output_section
->vma
2612 + asec_ptr
->output_offset
);
2616 /* The symbol is imported from another shared
2617 library and does not apply to this one. */
2618 internal_dyn
.d_un
.d_val
= 0;
2622 else if (s
!= NULL
) /* With a section information. */
2624 switch (internal_dyn
.d_tag
)
2631 internal_dyn
.d_un
.d_ptr
= (s
->output_section
->vma
2632 + s
->output_offset
);
2637 internal_dyn
.d_un
.d_val
= s
->size
;
2647 bfd_elf32_swap_dyn_out (output_bfd
, &internal_dyn
, dyncon
);
2650 if (htab
->splt
->size
> 0)
2652 relocate_plt_for_entry (output_bfd
, info
);
2655 /* TODO: Validate this. */
2656 if (htab
->srelplt
->output_section
!= bfd_abs_section_ptr
)
2657 elf_section_data (htab
->srelplt
->output_section
)
2658 ->this_hdr
.sh_entsize
= 12;
2661 /* Fill in the first three entries in the global offset table. */
2664 struct elf_link_hash_entry
*h
;
2665 h
= elf_link_hash_lookup (elf_hash_table (info
), "_GLOBAL_OFFSET_TABLE_",
2666 FALSE
, FALSE
, TRUE
);
2668 if (h
!= NULL
&& h
->root
.type
!= bfd_link_hash_undefined
2669 && h
->root
.u
.def
.section
!= NULL
)
2671 asection
*sec
= h
->root
.u
.def
.section
;
2674 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
2677 bfd_put_32 (output_bfd
,
2678 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
2680 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sec
->contents
+ 4);
2681 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sec
->contents
+ 8);
2685 struct obfd_info_group group
;
2686 group
.output_bfd
= output_bfd
;
2688 bfd_hash_traverse (&info
->hash
->table
,
2689 arc_create_forced_local_got_entries_for_tls
, &group
);
2694 #define ADD_DYNAMIC_SYMBOL(NAME, TAG) \
2695 h = elf_link_hash_lookup (elf_hash_table (info), \
2696 NAME, FALSE, FALSE, FALSE); \
2697 if ((h != NULL && (h->ref_regular || h->def_regular))) \
2698 if (! _bfd_elf_add_dynamic_entry (info, TAG, 0)) \
2701 /* Set the sizes of the dynamic sections. */
2703 elf_arc_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
2704 struct bfd_link_info
*info
)
2708 bfd_boolean relocs_exist
= FALSE
;
2709 bfd_boolean reltext_exist
= FALSE
;
2710 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2712 dynobj
= htab
->dynobj
;
2713 BFD_ASSERT (dynobj
!= NULL
);
2715 if (htab
->dynamic_sections_created
)
2717 struct elf_link_hash_entry
*h
;
2719 /* Set the contents of the .interp section to the
2721 if (bfd_link_executable (info
) && !info
->nointerp
)
2723 s
= bfd_get_section_by_name (dynobj
, ".interp");
2724 BFD_ASSERT (s
!= NULL
);
2725 s
->size
= sizeof (ELF_DYNAMIC_INTERPRETER
);
2726 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2729 /* Add some entries to the .dynamic section. We fill in some of
2730 the values later, in elf_bfd_final_link, but we must add the
2731 entries now so that we know the final size of the .dynamic
2732 section. Checking if the .init section is present. We also
2733 create DT_INIT and DT_FINI entries if the init_str has been
2734 changed by the user. */
2735 ADD_DYNAMIC_SYMBOL (info
->init_function
, DT_INIT
);
2736 ADD_DYNAMIC_SYMBOL (info
->fini_function
, DT_FINI
);
2740 /* We may have created entries in the .rela.got section.
2741 However, if we are not creating the dynamic sections, we will
2742 not actually use these entries. Reset the size of .rela.got,
2743 which will cause it to get stripped from the output file
2745 if (htab
->srelgot
!= NULL
)
2746 htab
->srelgot
->size
= 0;
2749 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2751 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2756 || s
== htab
->sgotplt
2757 || s
== htab
->sdynbss
)
2759 /* Strip this section if we don't need it. */
2761 else if (strncmp (s
->name
, ".rela", 5) == 0)
2763 if (s
->size
!= 0 && s
!= htab
->srelplt
)
2767 const char *name
= s
->name
+ 5;
2769 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
2770 if (bfd_get_flavour (ibfd
) == bfd_target_elf_flavour
2771 && ibfd
->flags
& DYNAMIC
)
2773 asection
*target
= bfd_get_section_by_name (ibfd
, name
);
2775 && elf_section_data (target
)->sreloc
== s
2776 && ((target
->output_section
->flags
2777 & (SEC_READONLY
| SEC_ALLOC
))
2778 == (SEC_READONLY
| SEC_ALLOC
)))
2780 reltext_exist
= TRUE
;
2785 relocs_exist
= TRUE
;
2788 /* We use the reloc_count field as a counter if we need to
2789 copy relocs into the output file. */
2794 /* It's not one of our sections, so don't allocate space. */
2800 s
->flags
|= SEC_EXCLUDE
;
2804 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
2807 /* Allocate memory for the section contents. */
2808 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
2809 if (s
->contents
== NULL
)
2813 if (htab
->dynamic_sections_created
)
2815 /* TODO: Check if this is needed. */
2816 if (!bfd_link_pic (info
))
2817 if (!_bfd_elf_add_dynamic_entry (info
, DT_DEBUG
, 0))
2820 if (htab
->splt
&& (htab
->splt
->flags
& SEC_EXCLUDE
) == 0)
2821 if (!_bfd_elf_add_dynamic_entry (info
, DT_PLTGOT
, 0)
2822 || !_bfd_elf_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
2823 || !_bfd_elf_add_dynamic_entry (info
, DT_PLTREL
, DT_RELA
)
2824 || !_bfd_elf_add_dynamic_entry (info
, DT_JMPREL
, 0))
2828 if (!_bfd_elf_add_dynamic_entry (info
, DT_RELA
, 0)
2829 || !_bfd_elf_add_dynamic_entry (info
, DT_RELASZ
, 0)
2830 || !_bfd_elf_add_dynamic_entry (info
, DT_RELAENT
,
2831 sizeof (Elf32_External_Rela
)))
2835 if (!_bfd_elf_add_dynamic_entry (info
, DT_TEXTREL
, 0))
2843 /* Classify dynamic relocs such that -z combreloc can reorder and combine
2845 static enum elf_reloc_type_class
2846 elf32_arc_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2847 const asection
*rel_sec ATTRIBUTE_UNUSED
,
2848 const Elf_Internal_Rela
*rela
)
2850 switch ((int) ELF32_R_TYPE (rela
->r_info
))
2852 case R_ARC_RELATIVE
:
2853 return reloc_class_relative
;
2854 case R_ARC_JMP_SLOT
:
2855 return reloc_class_plt
;
2857 return reloc_class_copy
;
2858 /* TODO: Needed in future to support ifunc. */
2860 case R_ARC_IRELATIVE:
2861 return reloc_class_ifunc;
2864 return reloc_class_normal
;
2868 const struct elf_size_info arc_elf32_size_info
=
2870 sizeof (Elf32_External_Ehdr
),
2871 sizeof (Elf32_External_Phdr
),
2872 sizeof (Elf32_External_Shdr
),
2873 sizeof (Elf32_External_Rel
),
2874 sizeof (Elf32_External_Rela
),
2875 sizeof (Elf32_External_Sym
),
2876 sizeof (Elf32_External_Dyn
),
2877 sizeof (Elf_External_Note
),
2881 ELFCLASS32
, EV_CURRENT
,
2882 bfd_elf32_write_out_phdrs
,
2883 bfd_elf32_write_shdrs_and_ehdr
,
2884 bfd_elf32_checksum_contents
,
2885 bfd_elf32_write_relocs
,
2886 bfd_elf32_swap_symbol_in
,
2887 bfd_elf32_swap_symbol_out
,
2888 bfd_elf32_slurp_reloc_table
,
2889 bfd_elf32_slurp_symbol_table
,
2890 bfd_elf32_swap_dyn_in
,
2891 bfd_elf32_swap_dyn_out
,
2892 bfd_elf32_swap_reloc_in
,
2893 bfd_elf32_swap_reloc_out
,
2894 bfd_elf32_swap_reloca_in
,
2895 bfd_elf32_swap_reloca_out
2898 #define elf_backend_size_info arc_elf32_size_info
2900 /* GDB expects general purpose registers to be in section .reg. However Linux
2901 kernel doesn't create this section and instead writes registers to NOTE
2902 section. It is up to the binutils to create a pseudo-section .reg from the
2903 contents of NOTE. Also BFD will read pid and signal number from NOTE. This
2904 function relies on offsets inside elf_prstatus structure in Linux to be
2908 elf32_arc_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
2913 switch (note
->descsz
)
2918 case 236: /* sizeof (struct elf_prstatus) on Linux/arc. */
2920 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
2922 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
2925 size
= (40 * 4); /* There are 40 registers in user_regs_struct. */
2928 /* Make a ".reg/999" section. */
2929 return _bfd_elfcore_make_pseudosection (abfd
, ".reg", size
,
2930 note
->descpos
+ offset
);
2933 /* Determine whether an object attribute tag takes an integer, a
2937 elf32_arc_obj_attrs_arg_type (int tag
)
2939 if (tag
== Tag_ARC_CPU_name
2940 || tag
== Tag_ARC_ISA_config
2941 || tag
== Tag_ARC_ISA_apex
)
2942 return ATTR_TYPE_FLAG_STR_VAL
;
2943 else if (tag
< (Tag_ARC_ISA_mpy_option
+ 1))
2944 return ATTR_TYPE_FLAG_INT_VAL
;
2946 return (tag
& 1) != 0 ? ATTR_TYPE_FLAG_STR_VAL
: ATTR_TYPE_FLAG_INT_VAL
;
2949 /* Attribute numbers >=14 can be safely ignored. */
2952 elf32_arc_obj_attrs_handle_unknown (bfd
*abfd
, int tag
)
2954 if ((tag
& 127) < (Tag_ARC_ISA_mpy_option
+ 1))
2957 (_("%pB: unknown mandatory ARC object attribute %d"),
2959 bfd_set_error (bfd_error_bad_value
);
2965 (_("warning: %pB: unknown ARC object attribute %d"),
2971 /* Handle an ARC specific section when reading an object file. This is
2972 called when bfd_section_from_shdr finds a section with an unknown
2976 elf32_arc_section_from_shdr (bfd
*abfd
,
2977 Elf_Internal_Shdr
* hdr
,
2981 switch (hdr
->sh_type
)
2983 case 0x0c: /* MWDT specific section, don't complain about it. */
2984 case SHT_ARC_ATTRIBUTES
:
2991 if (!_bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2999 These are the current relaxing opportunities available:
3001 * R_ARC_GOTPC32 => R_ARC_PCREL.
3006 arc_elf_relax_section (bfd
*abfd
, asection
*sec
,
3007 struct bfd_link_info
*link_info
, bfd_boolean
*again
)
3009 Elf_Internal_Shdr
*symtab_hdr
;
3010 Elf_Internal_Rela
*internal_relocs
;
3011 Elf_Internal_Rela
*irel
, *irelend
;
3012 bfd_byte
*contents
= NULL
;
3013 Elf_Internal_Sym
*isymbuf
= NULL
;
3015 /* Assume nothing changes. */
3018 /* We don't have to do anything for a relocatable link, if this
3019 section does not have relocs, or if this is not a code
3021 if (bfd_link_relocatable (link_info
)
3022 || (sec
->flags
& SEC_RELOC
) == 0
3023 || sec
->reloc_count
== 0
3024 || (sec
->flags
& SEC_CODE
) == 0)
3027 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3029 /* Get a copy of the native relocations. */
3030 internal_relocs
= _bfd_elf_link_read_relocs (abfd
, sec
, NULL
, NULL
,
3031 link_info
->keep_memory
);
3032 if (internal_relocs
== NULL
)
3035 /* Walk through them looking for relaxing opportunities. */
3036 irelend
= internal_relocs
+ sec
->reloc_count
;
3037 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
3039 /* If this isn't something that can be relaxed, then ignore
3041 if (ELF32_R_TYPE (irel
->r_info
) != (int) R_ARC_GOTPC32
)
3044 /* Get the section contents if we haven't done so already. */
3045 if (contents
== NULL
)
3047 /* Get cached copy if it exists. */
3048 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
3049 contents
= elf_section_data (sec
)->this_hdr
.contents
;
3050 /* Go get them off disk. */
3051 else if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
3055 /* Read this BFD's local symbols if we haven't done so already. */
3056 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
3058 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
3059 if (isymbuf
== NULL
)
3060 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
3061 symtab_hdr
->sh_info
, 0,
3063 if (isymbuf
== NULL
)
3067 struct elf_link_hash_entry
*htop
= NULL
;
3069 if (ELF32_R_SYM (irel
->r_info
) >= symtab_hdr
->sh_info
)
3071 /* An external symbol. */
3072 unsigned int indx
= ELF32_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
3073 htop
= elf_sym_hashes (abfd
)[indx
];
3076 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_ARC_GOTPC32
3077 && SYMBOL_REFERENCES_LOCAL (link_info
, htop
))
3081 /* Get the opcode. */
3082 code
= bfd_get_32_me (abfd
, contents
+ irel
->r_offset
- 4);
3084 /* Note that we've changed the relocs, section contents, etc. */
3085 elf_section_data (sec
)->relocs
= internal_relocs
;
3086 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3087 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
3089 /* Fix the relocation's type. */
3090 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
), R_ARC_PC32
);
3092 /* ld rA,[pcl,symbol@tgot] -> add rA,pcl,symbol@pcl. */
3093 /* 0010 0bbb aa11 0ZZX DBBB 1111 10AA AAAA.
3094 111 00 000 0111 xx xxxx*/
3095 code
&= ~0x27307F80;
3096 BFD_ASSERT (code
<= 62UL);
3099 /* Write back the new instruction. */
3100 bfd_put_32_me (abfd
, code
, contents
+ irel
->r_offset
- 4);
3102 /* The size isn't changed, don't redo. */
3108 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
3110 if (!link_info
->keep_memory
)
3113 /* Cache the symbols for elf_link_input_bfd. */
3114 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
3117 if (contents
!= NULL
3118 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3120 if (!link_info
->keep_memory
)
3123 /* Cache the section contents for elf_link_input_bfd. */
3124 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3127 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
3128 free (internal_relocs
);
3133 if (symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
3135 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3137 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
3138 free (internal_relocs
);
3143 #define TARGET_LITTLE_SYM arc_elf32_le_vec
3144 #define TARGET_LITTLE_NAME "elf32-littlearc"
3145 #define TARGET_BIG_SYM arc_elf32_be_vec
3146 #define TARGET_BIG_NAME "elf32-bigarc"
3147 #define ELF_ARCH bfd_arch_arc
3148 #define ELF_TARGET_ID ARC_ELF_DATA
3149 #define ELF_MACHINE_CODE EM_ARC_COMPACT
3150 #define ELF_MACHINE_ALT1 EM_ARC_COMPACT2
3151 #define ELF_MAXPAGESIZE 0x2000
3153 #define bfd_elf32_bfd_link_hash_table_create arc_elf_link_hash_table_create
3155 #define bfd_elf32_bfd_merge_private_bfd_data arc_elf_merge_private_bfd_data
3156 #define bfd_elf32_bfd_reloc_type_lookup arc_elf32_bfd_reloc_type_lookup
3157 #define bfd_elf32_bfd_set_private_flags arc_elf_set_private_flags
3158 #define bfd_elf32_bfd_print_private_bfd_data arc_elf_print_private_bfd_data
3159 #define bfd_elf32_bfd_copy_private_bfd_data arc_elf_copy_private_bfd_data
3160 #define bfd_elf32_bfd_relax_section arc_elf_relax_section
3162 #define elf_info_to_howto_rel arc_info_to_howto_rel
3163 #define elf_backend_object_p arc_elf_object_p
3164 #define elf_backend_final_write_processing arc_elf_final_write_processing
3166 #define elf_backend_relocate_section elf_arc_relocate_section
3167 #define elf_backend_check_relocs elf_arc_check_relocs
3168 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
3170 #define elf_backend_reloc_type_class elf32_arc_reloc_type_class
3172 #define elf_backend_adjust_dynamic_symbol elf_arc_adjust_dynamic_symbol
3173 #define elf_backend_finish_dynamic_symbol elf_arc_finish_dynamic_symbol
3175 #define elf_backend_finish_dynamic_sections elf_arc_finish_dynamic_sections
3176 #define elf_backend_size_dynamic_sections elf_arc_size_dynamic_sections
3178 #define elf_backend_can_gc_sections 1
3179 #define elf_backend_want_got_plt 1
3180 #define elf_backend_plt_readonly 1
3181 #define elf_backend_rela_plts_and_copies_p 1
3182 #define elf_backend_want_plt_sym 0
3183 #define elf_backend_got_header_size 12
3184 #define elf_backend_dtrel_excludes_plt 1
3186 #define elf_backend_may_use_rel_p 0
3187 #define elf_backend_may_use_rela_p 1
3188 #define elf_backend_default_use_rela_p 1
3190 #define elf_backend_grok_prstatus elf32_arc_grok_prstatus
3192 #define elf_backend_default_execstack 0
3194 #undef elf_backend_obj_attrs_vendor
3195 #define elf_backend_obj_attrs_vendor "ARC"
3196 #undef elf_backend_obj_attrs_section
3197 #define elf_backend_obj_attrs_section ".ARC.attributes"
3198 #undef elf_backend_obj_attrs_arg_type
3199 #define elf_backend_obj_attrs_arg_type elf32_arc_obj_attrs_arg_type
3200 #undef elf_backend_obj_attrs_section_type
3201 #define elf_backend_obj_attrs_section_type SHT_ARC_ATTRIBUTES
3202 #define elf_backend_obj_attrs_handle_unknown elf32_arc_obj_attrs_handle_unknown
3204 #define elf_backend_section_from_shdr elf32_arc_section_from_shdr
3206 #include "elf32-target.h"