1 /* ARC-specific support for 32-bit ELF
2 Copyright (C) 1994-2017 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 ARC_ENABLE_DEBUG 1 */
33 #ifdef ARC_ENABLE_DEBUG
35 name_for_global_symbol (struct elf_link_hash_entry
*h
)
37 static char *local_str
= "(local)";
40 return h
->root
.root
.string
;
42 #define ARC_DEBUG(fmt, args...) fprintf (stderr, fmt, ##args)
44 #define ARC_DEBUG(...)
48 #define ADD_RELA(BFD, SECTION, OFFSET, SYM_IDX, TYPE, ADDEND) \
50 struct elf_link_hash_table *_htab = elf_hash_table (info); \
51 Elf_Internal_Rela _rel; \
54 BFD_ASSERT (_htab->srel##SECTION &&_htab->srel##SECTION->contents); \
55 _loc = _htab->srel##SECTION->contents \
56 + ((_htab->srel##SECTION->reloc_count) \
57 * sizeof (Elf32_External_Rela)); \
58 _htab->srel##SECTION->reloc_count++; \
59 _rel.r_addend = ADDEND; \
60 _rel.r_offset = (_htab->s##SECTION)->output_section->vma \
61 + (_htab->s##SECTION)->output_offset + OFFSET; \
62 BFD_ASSERT ((long) SYM_IDX != -1); \
63 _rel.r_info = ELF32_R_INFO (SYM_IDX, TYPE); \
64 bfd_elf32_swap_reloca_out (BFD, &_rel, _loc); \
67 struct dynamic_sections
69 bfd_boolean initialized
;
73 asection
* srelgotplt
;
79 enum dyn_section_types
90 const char * dyn_section_names
[DYN_SECTION_TYPES_END
] =
101 /* The default symbols representing the init and fini dyn values.
102 TODO: Check what is the relation of those strings with arclinux.em
104 #define INIT_SYM_STRING "_init"
105 #define FINI_SYM_STRING "_fini"
107 char * init_str
= INIT_SYM_STRING
;
108 char * fini_str
= FINI_SYM_STRING
;
110 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
115 static ATTRIBUTE_UNUSED
const char *
116 reloc_type_to_name (unsigned int type
)
120 #include "elf/arc-reloc.def"
127 #undef ARC_RELOC_HOWTO
129 /* Try to minimize the amount of space occupied by relocation tables
130 on the ROM (not that the ROM won't be swamped by other ELF overhead). */
134 static ATTRIBUTE_UNUSED bfd_boolean
135 is_reloc_PC_relative (reloc_howto_type
*howto
)
137 return (strstr (howto
->name
, "PC") != NULL
) ? TRUE
: FALSE
;
141 is_reloc_SDA_relative (reloc_howto_type
*howto
)
143 return (strstr (howto
->name
, "SDA") != NULL
) ? TRUE
: FALSE
;
147 is_reloc_for_GOT (reloc_howto_type
* howto
)
149 if (strstr (howto
->name
, "TLS") != NULL
)
151 return (strstr (howto
->name
, "GOT") != NULL
) ? TRUE
: FALSE
;
155 is_reloc_for_PLT (reloc_howto_type
* howto
)
157 return (strstr (howto
->name
, "PLT") != NULL
) ? TRUE
: FALSE
;
161 is_reloc_for_TLS (reloc_howto_type
*howto
)
163 return (strstr (howto
->name
, "TLS") != NULL
) ? TRUE
: FALSE
;
166 struct arc_relocation_data
168 bfd_signed_vma reloc_offset
;
169 bfd_signed_vma reloc_addend
;
170 bfd_signed_vma got_offset_value
;
172 bfd_signed_vma sym_value
;
173 asection
* sym_section
;
175 reloc_howto_type
*howto
;
177 asection
* input_section
;
179 bfd_signed_vma sdata_begin_symbol_vma
;
180 bfd_boolean sdata_begin_symbol_vma_set
;
181 bfd_signed_vma got_symbol_vma
;
183 bfd_boolean should_relocate
;
185 const char * symbol_name
;
188 /* Should be included at this location due to static declarations
189 * defined before this point. */
192 #define arc_bfd_get_8(A,B,C) bfd_get_8(A,B)
193 #define arc_bfd_get_16(A,B,C) bfd_get_16(A,B)
194 #define arc_bfd_get_32(A,B,C) bfd_get_32(A,B)
195 #define arc_bfd_put_8(A,B,C,D) bfd_put_8(A,B,C)
196 #define arc_bfd_put_16(A,B,C,D) bfd_put_16(A,B,C)
197 #define arc_bfd_put_32(A,B,C,D) bfd_put_32(A,B,C)
200 static bfd_reloc_status_type
201 arc_elf_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
202 arelent
*reloc_entry
,
204 void *data ATTRIBUTE_UNUSED
,
205 asection
*input_section
,
207 char ** error_message ATTRIBUTE_UNUSED
)
209 if (output_bfd
!= NULL
)
211 reloc_entry
->address
+= input_section
->output_offset
;
213 /* In case of relocateable link and if the reloc is against a
214 section symbol, the addend needs to be adjusted according to
215 where the section symbol winds up in the output section. */
216 if ((symbol_in
->flags
& BSF_SECTION_SYM
) && symbol_in
->section
)
217 reloc_entry
->addend
+= symbol_in
->section
->output_offset
;
222 return bfd_reloc_continue
;
226 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
230 #include "elf/arc-reloc.def"
233 #undef ARC_RELOC_HOWTO
235 #define ARC_RELOC_HOWTO(TYPE, VALUE, RSIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
236 [TYPE] = HOWTO (R_##TYPE, 0, RSIZE, BITSIZE, FALSE, 0, \
237 complain_overflow_##OVERFLOW, arc_elf_reloc, \
238 "R_" #TYPE, FALSE, 0, 0, FALSE),
240 static struct reloc_howto_struct elf_arc_howto_table
[] =
242 #include "elf/arc-reloc.def"
243 /* Example of what is generated by the preprocessor. Currently kept as an
245 HOWTO (R_ARC_NONE, // Type.
247 2, // Size (0 = byte, 1 = short, 2 = long).
249 FALSE, // PC_relative.
251 complain_overflow_bitfield, // Complain_on_overflow.
252 bfd_elf_generic_reloc, // Special_function.
253 "R_ARC_NONE", // Name.
254 TRUE, // Partial_inplace.
257 FALSE), // PCrel_offset.
260 #undef ARC_RELOC_HOWTO
262 static void arc_elf_howto_init (void)
264 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
265 elf_arc_howto_table[TYPE].pc_relative = \
266 (strstr (#FORMULA, " P ") != NULL || strstr (#FORMULA, " PDATA ") != NULL); \
267 elf_arc_howto_table[TYPE].dst_mask = RELOC_FUNCTION(0, ~0); \
268 /* Only 32 bit data relocations should be marked as ME. */ \
269 if (strstr (#FORMULA, " ME ") != NULL) \
271 BFD_ASSERT (SIZE == 2); \
274 #include "elf/arc-reloc.def"
277 #undef ARC_RELOC_HOWTO
280 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
282 const int howto_table_lookup
[] =
284 #include "elf/arc-reloc.def"
286 #undef ARC_RELOC_HOWTO
288 static reloc_howto_type
*
289 arc_elf_howto (unsigned int r_type
)
291 if (elf_arc_howto_table
[R_ARC_32
].dst_mask
== 0)
292 arc_elf_howto_init ();
293 return &elf_arc_howto_table
[r_type
];
296 /* Map BFD reloc types to ARC ELF reloc types. */
300 bfd_reloc_code_real_type bfd_reloc_val
;
301 unsigned char elf_reloc_val
;
304 /* ARC ELF linker hash entry. */
305 struct elf_arc_link_hash_entry
307 struct elf_link_hash_entry root
;
309 /* Track dynamic relocs copied for this symbol. */
310 struct elf_dyn_relocs
*dyn_relocs
;
313 /* ARC ELF linker hash table. */
314 struct elf_arc_link_hash_table
316 struct elf_link_hash_table elf
;
319 static struct bfd_hash_entry
*
320 elf_arc_link_hash_newfunc (struct bfd_hash_entry
*entry
,
321 struct bfd_hash_table
*table
,
324 /* Allocate the structure if it has not already been allocated by a
328 entry
= (struct bfd_hash_entry
*)
329 bfd_hash_allocate (table
,
330 sizeof (struct elf_arc_link_hash_entry
));
335 /* Call the allocation method of the superclass. */
336 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
339 struct elf_arc_link_hash_entry
*eh
;
341 eh
= (struct elf_arc_link_hash_entry
*) entry
;
342 eh
->dyn_relocs
= NULL
;
348 /* Destroy an ARC ELF linker hash table. */
350 elf_arc_link_hash_table_free (bfd
*obfd
)
352 _bfd_elf_link_hash_table_free (obfd
);
355 /* Create an ARC ELF linker hash table. */
357 static struct bfd_link_hash_table
*
358 arc_elf_link_hash_table_create (bfd
*abfd
)
360 struct elf_arc_link_hash_table
*ret
;
362 ret
= (struct elf_arc_link_hash_table
*) bfd_zmalloc (sizeof (*ret
));
366 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
367 elf_arc_link_hash_newfunc
,
368 sizeof (struct elf_arc_link_hash_entry
),
375 ret
->elf
.init_got_refcount
.refcount
= 0;
376 ret
->elf
.init_got_refcount
.glist
= NULL
;
377 ret
->elf
.init_got_offset
.offset
= 0;
378 ret
->elf
.init_got_offset
.glist
= NULL
;
380 ret
->elf
.root
.hash_table_free
= elf_arc_link_hash_table_free
;
382 return &ret
->elf
.root
;
385 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
386 { BFD_RELOC_##TYPE, R_##TYPE },
387 static const struct arc_reloc_map arc_reloc_map
[] =
389 #include "elf/arc-reloc.def"
391 {BFD_RELOC_NONE
, R_ARC_NONE
},
392 {BFD_RELOC_8
, R_ARC_8
},
393 {BFD_RELOC_16
, R_ARC_16
},
394 {BFD_RELOC_24
, R_ARC_24
},
395 {BFD_RELOC_32
, R_ARC_32
},
397 #undef ARC_RELOC_HOWTO
399 typedef ATTRIBUTE_UNUSED
bfd_vma (*replace_func
) (unsigned, int ATTRIBUTE_UNUSED
);
401 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
403 func = (void *) RELOC_FUNCTION; \
406 get_replace_function (bfd
*abfd
, unsigned int r_type
)
412 #include "elf/arc-reloc.def"
415 if (func
== replace_bits24
&& bfd_big_endian (abfd
))
416 return (replace_func
) replace_bits24_be
;
418 return (replace_func
) func
;
420 #undef ARC_RELOC_HOWTO
422 static reloc_howto_type
*
423 arc_elf32_bfd_reloc_type_lookup (bfd
* abfd ATTRIBUTE_UNUSED
,
424 bfd_reloc_code_real_type code
)
428 for (i
= ARRAY_SIZE (arc_reloc_map
); i
--;)
430 if (arc_reloc_map
[i
].bfd_reloc_val
== code
)
431 return arc_elf_howto (arc_reloc_map
[i
].elf_reloc_val
);
437 /* Function to set the ELF flag bits. */
439 arc_elf_set_private_flags (bfd
*abfd
, flagword flags
)
441 elf_elfheader (abfd
)->e_flags
= flags
;
442 elf_flags_init (abfd
) = TRUE
;
446 /* Print private flags. */
448 arc_elf_print_private_bfd_data (bfd
*abfd
, void * ptr
)
450 FILE *file
= (FILE *) ptr
;
453 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
455 /* Print normal ELF private data. */
456 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
458 flags
= elf_elfheader (abfd
)->e_flags
;
459 fprintf (file
, _("private flags = 0x%lx:"), (unsigned long) flags
);
461 switch (flags
& EF_ARC_MACH_MSK
)
463 case EF_ARC_CPU_ARCV2HS
: fprintf (file
, " -mcpu=ARCv2HS"); break;
464 case EF_ARC_CPU_ARCV2EM
: fprintf (file
, " -mcpu=ARCv2EM"); break;
465 case E_ARC_MACH_ARC600
: fprintf (file
, " -mcpu=ARC600"); break;
466 case E_ARC_MACH_ARC601
: fprintf (file
, " -mcpu=ARC601"); break;
467 case E_ARC_MACH_ARC700
: fprintf (file
, " -mcpu=ARC700"); break;
469 fprintf (file
, "-mcpu=unknown");
473 switch (flags
& EF_ARC_OSABI_MSK
)
475 case E_ARC_OSABI_ORIG
: fprintf (file
, " (ABI:legacy)"); break;
476 case E_ARC_OSABI_V2
: fprintf (file
, " (ABI:v2)"); break;
477 case E_ARC_OSABI_V3
: fprintf (file
, " (ABI:v3)"); break;
479 fprintf (file
, "(ABI:unknown)");
487 /* Copy backend specific data from one object module to another. */
490 arc_elf_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
492 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
493 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
496 BFD_ASSERT (!elf_flags_init (obfd
)
497 || elf_elfheader (obfd
)->e_flags
== elf_elfheader (ibfd
)->e_flags
);
499 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
500 elf_flags_init (obfd
) = TRUE
;
502 /* Copy object attributes. */
503 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
505 return _bfd_elf_copy_private_bfd_data (ibfd
, obfd
);
508 static reloc_howto_type
*
509 bfd_elf32_bfd_reloc_name_lookup (bfd
* abfd ATTRIBUTE_UNUSED
,
514 for (i
= 0; i
< ARRAY_SIZE (elf_arc_howto_table
); i
++)
515 if (elf_arc_howto_table
[i
].name
!= NULL
516 && strcasecmp (elf_arc_howto_table
[i
].name
, r_name
) == 0)
517 return arc_elf_howto (i
);
522 /* Set the howto pointer for an ARC ELF reloc. */
525 arc_info_to_howto_rel (bfd
* abfd ATTRIBUTE_UNUSED
,
527 Elf_Internal_Rela
* dst
)
531 r_type
= ELF32_R_TYPE (dst
->r_info
);
532 BFD_ASSERT (r_type
< (unsigned int) R_ARC_max
);
533 cache_ptr
->howto
= arc_elf_howto (r_type
);
536 /* Merge backend specific data from an object file to the output
537 object file when linking. */
540 arc_elf_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
542 bfd
*obfd
= info
->output_bfd
;
543 unsigned short mach_ibfd
;
544 static unsigned short mach_obfd
= EM_NONE
;
549 /* Check if we have the same endianess. */
550 if (! _bfd_generic_verify_endian_match (ibfd
, info
))
553 /* Collect ELF flags. */
554 in_flags
= elf_elfheader (ibfd
)->e_flags
& EF_ARC_MACH_MSK
;
555 out_flags
= elf_elfheader (obfd
)->e_flags
& EF_ARC_MACH_MSK
;
557 if (!elf_flags_init (obfd
)) /* First call, no flags set. */
559 elf_flags_init (obfd
) = TRUE
;
560 out_flags
= in_flags
;
563 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
564 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
567 /* Check to see if the input BFD actually contains any sections. Do
568 not short-circuit dynamic objects; their section list may be
569 emptied by elf_link_add_object_symbols. */
570 if (!(ibfd
->flags
& DYNAMIC
))
572 bfd_boolean null_input_bfd
= TRUE
;
573 bfd_boolean only_data_sections
= TRUE
;
575 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
577 if ((bfd_get_section_flags (ibfd
, sec
)
578 & (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
579 == (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
580 only_data_sections
= FALSE
;
582 null_input_bfd
= FALSE
;
585 if (null_input_bfd
|| only_data_sections
)
589 /* Complain about various flag/architecture mismatches. */
590 mach_ibfd
= elf_elfheader (ibfd
)->e_machine
;
591 if (mach_obfd
== EM_NONE
)
593 mach_obfd
= mach_ibfd
;
597 if (mach_ibfd
!= mach_obfd
)
599 /* xgettext:c-format */
600 _bfd_error_handler (_("ERROR: Attempting to link %B "
601 "with a binary %s of different architecture"),
602 ibfd
, bfd_get_filename (obfd
));
605 else if (in_flags
!= out_flags
)
607 /* Warn if different flags. */
609 /* xgettext:c-format */
610 (_("%s: uses different e_flags (0x%lx) fields than "
611 "previous modules (0x%lx)"),
612 bfd_get_filename (ibfd
), (long)in_flags
, (long)out_flags
);
613 if (in_flags
&& out_flags
)
615 /* MWDT doesnt set the eflags hence make sure we choose the
616 eflags set by gcc. */
617 in_flags
= in_flags
> out_flags
? in_flags
: out_flags
;
621 /* Update the flags. */
622 elf_elfheader (obfd
)->e_flags
= in_flags
;
624 if (bfd_get_mach (obfd
) < bfd_get_mach (ibfd
))
626 return bfd_set_arch_mach (obfd
, bfd_arch_arc
, bfd_get_mach (ibfd
));
632 /* Set the right machine number for an ARC ELF file. */
634 arc_elf_object_p (bfd
* abfd
)
636 /* Make sure this is initialised, or you'll have the potential of passing
637 garbage---or misleading values---into the call to
638 bfd_default_set_arch_mach (). */
639 int mach
= bfd_mach_arc_arc700
;
640 unsigned long arch
= elf_elfheader (abfd
)->e_flags
& EF_ARC_MACH_MSK
;
641 unsigned e_machine
= elf_elfheader (abfd
)->e_machine
;
643 if (e_machine
== EM_ARC_COMPACT
|| e_machine
== EM_ARC_COMPACT2
)
647 case E_ARC_MACH_ARC600
:
648 mach
= bfd_mach_arc_arc600
;
650 case E_ARC_MACH_ARC601
:
651 mach
= bfd_mach_arc_arc601
;
653 case E_ARC_MACH_ARC700
:
654 mach
= bfd_mach_arc_arc700
;
656 case EF_ARC_CPU_ARCV2HS
:
657 case EF_ARC_CPU_ARCV2EM
:
658 mach
= bfd_mach_arc_arcv2
;
661 mach
= (e_machine
== EM_ARC_COMPACT
)
662 ? bfd_mach_arc_arc700
: bfd_mach_arc_arcv2
;
668 if (e_machine
== EM_ARC
)
671 (_("Error: The ARC4 architecture is no longer supported.\n"));
677 (_("Warning: unset or old architecture flags. \n"
678 " Use default machine.\n"));
682 return bfd_default_set_arch_mach (abfd
, bfd_arch_arc
, mach
);
685 /* The final processing done just before writing out an ARC ELF object file.
686 This gets the ARC architecture right based on the machine number. */
689 arc_elf_final_write_processing (bfd
* abfd
,
690 bfd_boolean linker ATTRIBUTE_UNUSED
)
694 switch (bfd_get_mach (abfd
))
696 case bfd_mach_arc_arc600
:
697 emf
= EM_ARC_COMPACT
;
699 case bfd_mach_arc_arc601
:
700 emf
= EM_ARC_COMPACT
;
702 case bfd_mach_arc_arc700
:
703 emf
= EM_ARC_COMPACT
;
705 case bfd_mach_arc_arcv2
:
706 emf
= EM_ARC_COMPACT2
;
712 elf_elfheader (abfd
)->e_machine
= emf
;
714 /* Record whatever is the current syscall ABI version. */
715 elf_elfheader (abfd
)->e_flags
|= E_ARC_OSABI_CURRENT
;
721 #ifdef ARC_ENABLE_DEBUG
722 #define DEBUG_ARC_RELOC(A) debug_arc_reloc (A)
725 debug_arc_reloc (struct arc_relocation_data reloc_data
)
727 ARC_DEBUG ("Reloc type=%s, should_relocate = %s\n",
728 reloc_data
.howto
->name
,
729 reloc_data
.should_relocate
? "true" : "false");
730 ARC_DEBUG (" offset = 0x%x, addend = 0x%x\n",
731 (unsigned int) reloc_data
.reloc_offset
,
732 (unsigned int) reloc_data
.reloc_addend
);
733 ARC_DEBUG (" Symbol:\n");
734 ARC_DEBUG (" value = 0x%08x\n",
735 (unsigned int) reloc_data
.sym_value
);
736 if (reloc_data
.sym_section
!= NULL
)
738 ARC_DEBUG (" Symbol Section:\n");
739 ARC_DEBUG (" section name = %s, output_offset 0x%08x",
740 reloc_data
.sym_section
->name
,
741 (unsigned int) reloc_data
.sym_section
->output_offset
);
742 if (reloc_data
.sym_section
->output_section
!= NULL
)
743 ARC_DEBUG (", output_section->vma = 0x%08x",
744 ((unsigned int) reloc_data
.sym_section
->output_section
->vma
));
746 if (reloc_data
.sym_section
->owner
&& reloc_data
.sym_section
->owner
->filename
)
747 ARC_DEBUG (" file: %s\n", reloc_data
.sym_section
->owner
->filename
);
751 ARC_DEBUG (" symbol section is NULL\n");
754 ARC_DEBUG (" Input_section:\n");
755 if (reloc_data
.input_section
!= NULL
)
757 ARC_DEBUG (" section name = %s, output_offset 0x%08x, output_section->vma = 0x%08x\n",
758 reloc_data
.input_section
->name
,
759 (unsigned int) reloc_data
.input_section
->output_offset
,
760 (unsigned int) reloc_data
.input_section
->output_section
->vma
);
761 ARC_DEBUG (" changed_address = 0x%08x\n",
762 (unsigned int) (reloc_data
.input_section
->output_section
->vma
763 + reloc_data
.input_section
->output_offset
764 + reloc_data
.reloc_offset
));
765 ARC_DEBUG (" file: %s\n", reloc_data
.input_section
->owner
->filename
);
769 ARC_DEBUG (" input section is NULL\n");
773 #define DEBUG_ARC_RELOC(A)
774 #endif /* ARC_ENABLE_DEBUG */
777 middle_endian_convert (bfd_vma insn
, bfd_boolean do_it
)
782 = ((insn
& 0xffff0000) >> 16)
783 | ((insn
& 0xffff) << 16);
788 /* This function is called for relocations that are otherwise marked as NOT
789 requiring overflow checks. In here we perform non-standard checks of
790 the relocation value. */
792 static inline bfd_reloc_status_type
793 arc_special_overflow_checks (const struct arc_relocation_data reloc_data
,
794 bfd_signed_vma relocation
,
795 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
797 switch (reloc_data
.howto
->type
)
799 case R_ARC_NPS_CMEM16
:
800 if (((relocation
>> 16) & 0xffff) != NPS_CMEM_HIGH_VALUE
)
802 if (reloc_data
.reloc_addend
== 0)
804 /* xgettext:c-format */
805 (_("%B(%A+0x%lx): CMEM relocation to `%s' is invalid, "
806 "16 MSB should be 0x%04x (value is 0x%lx)"),
807 reloc_data
.input_section
->owner
,
808 reloc_data
.input_section
,
809 reloc_data
.reloc_offset
,
810 reloc_data
.symbol_name
,
815 /* xgettext:c-format */
816 (_("%B(%A+0x%lx): CMEM relocation to `%s+0x%lx' is invalid, "
817 "16 MSB should be 0x%04x (value is 0x%lx)"),
818 reloc_data
.input_section
->owner
,
819 reloc_data
.input_section
,
820 reloc_data
.reloc_offset
,
821 reloc_data
.symbol_name
,
822 reloc_data
.reloc_addend
,
825 return bfd_reloc_overflow
;
836 #define ME(reloc) (reloc)
838 #define IS_ME(FORMULA,BFD) ((strstr (FORMULA, "ME") != NULL) \
839 && (!bfd_big_endian (BFD)))
841 #define S ((bfd_signed_vma) (reloc_data.sym_value \
842 + (reloc_data.sym_section->output_section != NULL ? \
843 (reloc_data.sym_section->output_offset \
844 + reloc_data.sym_section->output_section->vma) : 0)))
845 #define L ((bfd_signed_vma) (reloc_data.sym_value \
846 + (reloc_data.sym_section->output_section != NULL ? \
847 (reloc_data.sym_section->output_offset \
848 + reloc_data.sym_section->output_section->vma) : 0)))
849 #define A (reloc_data.reloc_addend)
851 #define G (reloc_data.got_offset_value)
852 #define GOT (reloc_data.got_symbol_vma)
853 #define GOT_BEGIN (htab->sgot->output_section->vma)
856 /* P: relative offset to PCL The offset should be to the
857 current location aligned to 32 bits. */
858 #define P ((bfd_signed_vma) ( \
860 (reloc_data.input_section->output_section != NULL ? \
861 reloc_data.input_section->output_section->vma : 0) \
862 + reloc_data.input_section->output_offset \
863 + (reloc_data.reloc_offset - (bitsize >= 32 ? 4 : 0))) \
865 #define PDATA ((bfd_signed_vma) ( \
866 (reloc_data.input_section->output_section->vma \
867 + reloc_data.input_section->output_offset \
868 + (reloc_data.reloc_offset))))
869 #define SECTSTART (bfd_signed_vma) (reloc_data.sym_section->output_section->vma \
870 + reloc_data.sym_section->output_offset)
872 #define _SDA_BASE_ (bfd_signed_vma) (reloc_data.sdata_begin_symbol_vma)
873 #define TLS_REL (bfd_signed_vma) \
874 ((elf_hash_table (info))->tls_sec->output_section->vma)
880 #ifdef ARC_ENABLE_DEBUG
881 #define PRINT_DEBUG_RELOC_INFO_BEFORE(FORMULA, TYPE) \
884 asection *sym_section = reloc_data.sym_section; \
885 asection *input_section = reloc_data.input_section; \
886 ARC_DEBUG ("RELOC_TYPE = " TYPE "\n"); \
887 ARC_DEBUG ("FORMULA = " FORMULA "\n"); \
888 ARC_DEBUG ("S = %#lx\n", S); \
889 ARC_DEBUG ("A = %#lx\n", A); \
890 ARC_DEBUG ("L = %lx\n", L); \
891 if (sym_section->output_section != NULL) \
892 ARC_DEBUG ("symbol_section->vma = %#lx\n", \
893 sym_section->output_section->vma \
894 + sym_section->output_offset); \
896 ARC_DEBUG ("symbol_section->vma = NULL\n"); \
897 if (input_section->output_section != NULL) \
898 ARC_DEBUG ("symbol_section->vma = %#lx\n", \
899 input_section->output_section->vma \
900 + input_section->output_offset); \
902 ARC_DEBUG ("symbol_section->vma = NULL\n"); \
903 ARC_DEBUG ("PCL = %#lx\n", P); \
904 ARC_DEBUG ("P = %#lx\n", P); \
905 ARC_DEBUG ("G = %#lx\n", G); \
906 ARC_DEBUG ("SDA_OFFSET = %#lx\n", _SDA_BASE_); \
907 ARC_DEBUG ("SDA_SET = %d\n", reloc_data.sdata_begin_symbol_vma_set); \
908 ARC_DEBUG ("GOT_OFFSET = %#lx\n", GOT); \
909 ARC_DEBUG ("relocation = %#08lx\n", relocation); \
910 ARC_DEBUG ("before = %#08x\n", (unsigned) insn); \
911 ARC_DEBUG ("data = %08x (%u) (%d)\n", (unsigned) relocation, \
912 (unsigned) relocation, (int) relocation); \
916 #define PRINT_DEBUG_RELOC_INFO_AFTER \
919 ARC_DEBUG ("after = 0x%08x\n", (unsigned int) insn); \
925 #define PRINT_DEBUG_RELOC_INFO_BEFORE(...)
926 #define PRINT_DEBUG_RELOC_INFO_AFTER
928 #endif /* ARC_ENABLE_DEBUG */
930 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
933 bfd_signed_vma bitsize ATTRIBUTE_UNUSED = BITSIZE; \
934 relocation = FORMULA ; \
935 PRINT_DEBUG_RELOC_INFO_BEFORE (#FORMULA, #TYPE); \
936 insn = middle_endian_convert (insn, IS_ME (#FORMULA, abfd)); \
937 insn = (* get_replace_function (abfd, TYPE)) (insn, relocation); \
938 insn = middle_endian_convert (insn, IS_ME (#FORMULA, abfd)); \
939 PRINT_DEBUG_RELOC_INFO_AFTER; \
943 static bfd_reloc_status_type
944 arc_do_relocation (bfd_byte
* contents
,
945 struct arc_relocation_data reloc_data
,
946 struct bfd_link_info
*info
)
948 bfd_signed_vma relocation
= 0;
950 bfd_vma orig_insn ATTRIBUTE_UNUSED
;
951 bfd
* abfd
= reloc_data
.input_section
->owner
;
952 struct elf_link_hash_table
*htab ATTRIBUTE_UNUSED
= elf_hash_table (info
);
953 bfd_reloc_status_type flag
;
955 if (reloc_data
.should_relocate
== FALSE
)
958 switch (reloc_data
.howto
->size
)
961 insn
= arc_bfd_get_32 (abfd
,
962 contents
+ reloc_data
.reloc_offset
,
963 reloc_data
.input_section
);
966 insn
= arc_bfd_get_16 (abfd
,
967 contents
+ reloc_data
.reloc_offset
,
968 reloc_data
.input_section
);
971 insn
= arc_bfd_get_8 (abfd
,
972 contents
+ reloc_data
.reloc_offset
,
973 reloc_data
.input_section
);
983 switch (reloc_data
.howto
->type
)
985 #include "elf/arc-reloc.def"
992 /* Check for relocation overflow. */
993 if (reloc_data
.howto
->complain_on_overflow
!= complain_overflow_dont
)
994 flag
= bfd_check_overflow (reloc_data
.howto
->complain_on_overflow
,
995 reloc_data
.howto
->bitsize
,
996 reloc_data
.howto
->rightshift
,
997 bfd_arch_bits_per_address (abfd
),
1000 flag
= arc_special_overflow_checks (reloc_data
, relocation
, info
);
1002 if (flag
!= bfd_reloc_ok
)
1004 ARC_DEBUG ("Relocation overflows !\n");
1005 DEBUG_ARC_RELOC (reloc_data
);
1006 ARC_DEBUG ("Relocation value = signed -> %d, unsigned -> %u"
1007 ", hex -> (0x%08x)\n",
1008 (int) relocation
, (unsigned) relocation
, (int) relocation
);
1013 /* Write updated instruction back to memory. */
1014 switch (reloc_data
.howto
->size
)
1017 arc_bfd_put_32 (abfd
, insn
,
1018 contents
+ reloc_data
.reloc_offset
,
1019 reloc_data
.input_section
);
1022 arc_bfd_put_16 (abfd
, insn
,
1023 contents
+ reloc_data
.reloc_offset
,
1024 reloc_data
.input_section
);
1027 arc_bfd_put_8 (abfd
, insn
,
1028 contents
+ reloc_data
.reloc_offset
,
1029 reloc_data
.input_section
);
1032 ARC_DEBUG ("size = %d\n", reloc_data
.howto
->size
);
1037 return bfd_reloc_ok
;
1052 #undef ARC_RELOC_HOWTO
1055 /* Relocate an arc ELF section.
1056 Function : elf_arc_relocate_section
1057 Brief : Relocate an arc section, by handling all the relocations
1058 appearing in that section.
1059 Args : output_bfd : The bfd being written to.
1060 info : Link information.
1061 input_bfd : The input bfd.
1062 input_section : The section being relocated.
1063 contents : contents of the section being relocated.
1064 relocs : List of relocations in the section.
1065 local_syms : is a pointer to the swapped in local symbols.
1066 local_section : is an array giving the section in the input file
1067 corresponding to the st_shndx field of each
1070 elf_arc_relocate_section (bfd
* output_bfd
,
1071 struct bfd_link_info
* info
,
1073 asection
* input_section
,
1074 bfd_byte
* contents
,
1075 Elf_Internal_Rela
* relocs
,
1076 Elf_Internal_Sym
* local_syms
,
1077 asection
** local_sections
)
1079 Elf_Internal_Shdr
* symtab_hdr
;
1080 struct elf_link_hash_entry
** sym_hashes
;
1081 Elf_Internal_Rela
* rel
;
1082 Elf_Internal_Rela
* wrel
;
1083 Elf_Internal_Rela
* relend
;
1084 struct elf_link_hash_table
* htab
= elf_hash_table (info
);
1086 symtab_hdr
= &((elf_tdata (input_bfd
))->symtab_hdr
);
1087 sym_hashes
= elf_sym_hashes (input_bfd
);
1089 rel
= wrel
= relocs
;
1090 relend
= relocs
+ input_section
->reloc_count
;
1091 for (; rel
< relend
; wrel
++, rel
++)
1093 enum elf_arc_reloc_type r_type
;
1094 reloc_howto_type
* howto
;
1095 unsigned long r_symndx
;
1096 struct elf_link_hash_entry
* h
;
1097 Elf_Internal_Sym
* sym
;
1099 struct elf_link_hash_entry
* h2
;
1102 struct arc_relocation_data reloc_data
=
1106 .got_offset_value
= 0,
1108 .sym_section
= NULL
,
1110 .input_section
= NULL
,
1111 .sdata_begin_symbol_vma
= 0,
1112 .sdata_begin_symbol_vma_set
= FALSE
,
1113 .got_symbol_vma
= 0,
1114 .should_relocate
= FALSE
1117 r_type
= ELF32_R_TYPE (rel
->r_info
);
1119 if (r_type
>= (int) R_ARC_max
)
1121 bfd_set_error (bfd_error_bad_value
);
1124 howto
= arc_elf_howto (r_type
);
1126 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1128 /* If we are generating another .o file and the symbol in not
1129 local, skip this relocation. */
1130 if (bfd_link_relocatable (info
))
1132 /* This is a relocateable link. We don't have to change
1133 anything, unless the reloc is against a section symbol,
1134 in which case we have to adjust according to where the
1135 section symbol winds up in the output section. */
1137 /* Checks if this is a local symbol and thus the reloc
1138 might (will??) be against a section symbol. */
1139 if (r_symndx
< symtab_hdr
->sh_info
)
1141 sym
= local_syms
+ r_symndx
;
1142 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1144 sec
= local_sections
[r_symndx
];
1146 /* For RELA relocs. Just adjust the addend
1147 value in the relocation entry. */
1148 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
1150 ARC_DEBUG ("local symbols reloc (section=%d %s) seen in %s\n",
1151 (int) r_symndx
, local_sections
[r_symndx
]->name
,
1152 __PRETTY_FUNCTION__
);
1157 h2
= elf_link_hash_lookup (elf_hash_table (info
), "__SDATA_BEGIN__",
1158 FALSE
, FALSE
, TRUE
);
1160 if (reloc_data
.sdata_begin_symbol_vma_set
== FALSE
1161 && h2
!= NULL
&& h2
->root
.type
!= bfd_link_hash_undefined
1162 && h2
->root
.u
.def
.section
->output_section
!= NULL
)
1163 /* TODO: Verify this condition. */
1165 reloc_data
.sdata_begin_symbol_vma
=
1166 (h2
->root
.u
.def
.value
1167 + h2
->root
.u
.def
.section
->output_section
->vma
);
1168 reloc_data
.sdata_begin_symbol_vma_set
= TRUE
;
1171 reloc_data
.input_section
= input_section
;
1172 reloc_data
.howto
= howto
;
1173 reloc_data
.reloc_offset
= rel
->r_offset
;
1174 reloc_data
.reloc_addend
= rel
->r_addend
;
1176 /* This is a final link. */
1181 if (r_symndx
< symtab_hdr
->sh_info
) /* A local symbol. */
1183 sym
= local_syms
+ r_symndx
;
1184 sec
= local_sections
[r_symndx
];
1188 /* TODO: This code is repeated from below. We should
1189 clean it and remove duplications.
1190 Sec is used check for discarded sections.
1191 Need to redesign code below. */
1193 /* Get the symbol's entry in the symtab. */
1194 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1196 while (h
->root
.type
== bfd_link_hash_indirect
1197 || h
->root
.type
== bfd_link_hash_warning
)
1198 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1200 /* If we have encountered a definition for this symbol. */
1201 if (h
->root
.type
== bfd_link_hash_defined
1202 || h
->root
.type
== bfd_link_hash_defweak
)
1204 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1205 sec
= h
->root
.u
.def
.section
;
1209 /* Clean relocs for symbols in discarded sections. */
1210 if (sec
!= NULL
&& discarded_section (sec
))
1212 _bfd_clear_contents (howto
, input_bfd
, input_section
,
1213 contents
+ rel
->r_offset
);
1214 rel
->r_offset
= rel
->r_offset
;
1218 /* For ld -r, remove relocations in debug sections against
1219 sections defined in discarded sections. Not done for
1220 eh_frame editing code expects to be present. */
1221 if (bfd_link_relocatable (info
)
1222 && (input_section
->flags
& SEC_DEBUGGING
))
1228 if (bfd_link_relocatable (info
))
1235 if (r_symndx
< symtab_hdr
->sh_info
) /* A local symbol. */
1237 reloc_data
.sym_value
= sym
->st_value
;
1238 reloc_data
.sym_section
= sec
;
1239 reloc_data
.symbol_name
=
1240 bfd_elf_string_from_elf_section (input_bfd
,
1241 symtab_hdr
->sh_link
,
1244 /* Mergeable section handling. */
1245 if ((sec
->flags
& SEC_MERGE
)
1246 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1250 rel
->r_addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
,
1251 &msec
, rel
->r_addend
);
1252 rel
->r_addend
-= (sec
->output_section
->vma
1253 + sec
->output_offset
1255 rel
->r_addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
1257 reloc_data
.reloc_addend
= rel
->r_addend
;
1260 BFD_ASSERT (htab
->sgot
!= NULL
|| !is_reloc_for_GOT (howto
));
1261 if (htab
->sgot
!= NULL
)
1262 reloc_data
.got_symbol_vma
= htab
->sgot
->output_section
->vma
1263 + htab
->sgot
->output_offset
;
1265 reloc_data
.should_relocate
= TRUE
;
1267 else /* Global symbol. */
1269 /* FIXME: We should use the RELOC_FOR_GLOBAL_SYMBOL macro
1270 (defined in elf-bfd.h) here. */
1272 /* Get the symbol's entry in the symtab. */
1273 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1275 while (h
->root
.type
== bfd_link_hash_indirect
1276 || h
->root
.type
== bfd_link_hash_warning
)
1277 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1279 /* TODO: Need to validate what was the intention. */
1280 /* BFD_ASSERT ((h->dynindx == -1) || (h->forced_local != 0)); */
1281 reloc_data
.symbol_name
= h
->root
.root
.string
;
1283 /* If we have encountered a definition for this symbol. */
1284 if (h
->root
.type
== bfd_link_hash_defined
1285 || h
->root
.type
== bfd_link_hash_defweak
)
1287 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1288 reloc_data
.sym_section
= h
->root
.u
.def
.section
;
1290 reloc_data
.should_relocate
= TRUE
;
1292 if (is_reloc_for_GOT (howto
) && !bfd_link_pic (info
))
1294 /* TODO: Change it to use arc_do_relocation with
1295 ARC_32 reloc. Try to use ADD_RELA macro. */
1296 bfd_vma relocation
=
1297 reloc_data
.sym_value
+ reloc_data
.reloc_addend
1298 + (reloc_data
.sym_section
->output_section
!= NULL
?
1299 (reloc_data
.sym_section
->output_offset
1300 + reloc_data
.sym_section
->output_section
->vma
)
1303 BFD_ASSERT (h
->got
.glist
);
1304 bfd_vma got_offset
= h
->got
.glist
->offset
;
1305 bfd_put_32 (output_bfd
, relocation
,
1306 htab
->sgot
->contents
+ got_offset
);
1308 if (is_reloc_for_PLT (howto
) && h
->plt
.offset
!= (bfd_vma
) -1)
1310 /* TODO: This is repeated up here. */
1311 reloc_data
.sym_value
= h
->plt
.offset
;
1312 reloc_data
.sym_section
= htab
->splt
;
1315 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1317 /* Is weak symbol and has no definition. */
1318 if (is_reloc_for_GOT (howto
))
1320 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1321 reloc_data
.sym_section
= htab
->sgot
;
1322 reloc_data
.should_relocate
= TRUE
;
1324 else if (is_reloc_for_PLT (howto
)
1325 && h
->plt
.offset
!= (bfd_vma
) -1)
1327 /* TODO: This is repeated up here. */
1328 reloc_data
.sym_value
= h
->plt
.offset
;
1329 reloc_data
.sym_section
= htab
->splt
;
1330 reloc_data
.should_relocate
= TRUE
;
1337 if (is_reloc_for_GOT (howto
))
1339 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1340 reloc_data
.sym_section
= htab
->sgot
;
1342 reloc_data
.should_relocate
= TRUE
;
1344 else if (is_reloc_for_PLT (howto
))
1346 /* Fail if it is linking for PIE and the symbol is
1348 if (bfd_link_executable (info
))
1349 (*info
->callbacks
->undefined_symbol
)
1350 (info
, h
->root
.root
.string
, input_bfd
, input_section
,
1351 rel
->r_offset
, TRUE
);
1352 reloc_data
.sym_value
= h
->plt
.offset
;
1353 reloc_data
.sym_section
= htab
->splt
;
1355 reloc_data
.should_relocate
= TRUE
;
1357 else if (!bfd_link_pic (info
) || bfd_link_executable (info
))
1358 (*info
->callbacks
->undefined_symbol
)
1359 (info
, h
->root
.root
.string
, input_bfd
, input_section
,
1360 rel
->r_offset
, TRUE
);
1363 BFD_ASSERT (htab
->sgot
!= NULL
|| !is_reloc_for_GOT (howto
));
1364 if (htab
->sgot
!= NULL
)
1365 reloc_data
.got_symbol_vma
= htab
->sgot
->output_section
->vma
1366 + htab
->sgot
->output_offset
;
1369 if ((is_reloc_for_GOT (howto
)
1370 || is_reloc_for_TLS (howto
)))
1372 reloc_data
.should_relocate
= TRUE
;
1374 struct got_entry
**list
1375 = get_got_entry_list_for_symbol (output_bfd
, r_symndx
, h
);
1377 reloc_data
.got_offset_value
1378 = relocate_fix_got_relocs_for_got_info (list
,
1379 tls_type_for_reloc (howto
),
1390 create_got_dynrelocs_for_single_entry (
1391 got_entry_for_type (list
,
1392 arc_got_entry_type_for_reloc (howto
)),
1393 output_bfd
, info
, NULL
);
1402 case R_ARC_32_PCREL
:
1403 if ((bfd_link_pic (info
))
1404 && ((r_type
!= R_ARC_PC32
&& r_type
!= R_ARC_32_PCREL
)
1407 && (!info
->symbolic
|| !h
->def_regular
))))
1409 Elf_Internal_Rela outrel
;
1411 bfd_boolean skip
= FALSE
;
1412 bfd_boolean relocate
= FALSE
;
1413 asection
*sreloc
= _bfd_elf_get_dynamic_reloc_section
1414 (input_bfd
, input_section
,
1417 BFD_ASSERT (sreloc
!= NULL
);
1419 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
1423 if (outrel
.r_offset
== (bfd_vma
) -1)
1426 outrel
.r_addend
= rel
->r_addend
;
1427 outrel
.r_offset
+= (input_section
->output_section
->vma
1428 + input_section
->output_offset
);
1430 #define IS_ARC_PCREL_TYPE(TYPE) \
1431 ( (TYPE == R_ARC_PC32) \
1432 || (TYPE == R_ARC_32_PCREL))
1436 memset (&outrel
, 0, sizeof outrel
);
1441 && ((IS_ARC_PCREL_TYPE (r_type
))
1442 || !(bfd_link_executable (info
)
1443 || SYMBOLIC_BIND (info
, h
))
1444 || ! h
->def_regular
))
1446 BFD_ASSERT (h
!= NULL
);
1447 if ((input_section
->flags
& SEC_ALLOC
) != 0)
1452 BFD_ASSERT (h
->dynindx
!= -1);
1453 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
1457 /* Handle local symbols, they either do not have a
1458 global hash table entry (h == NULL), or are
1459 forced local due to a version script
1460 (h->forced_local), or the third condition is
1461 legacy, it appears to say something like, for
1462 links where we are pre-binding the symbols, or
1463 there's not an entry for this symbol in the
1464 dynamic symbol table, and it's a regular symbol
1465 not defined in a shared object, then treat the
1466 symbol as local, resolve it now. */
1468 /* outrel.r_addend = 0; */
1469 outrel
.r_info
= ELF32_R_INFO (0, R_ARC_RELATIVE
);
1472 BFD_ASSERT (sreloc
->contents
!= 0);
1474 loc
= sreloc
->contents
;
1475 loc
+= sreloc
->reloc_count
* sizeof (Elf32_External_Rela
);
1476 sreloc
->reloc_count
+= 1;
1478 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
1480 if (relocate
== FALSE
)
1488 if (is_reloc_SDA_relative (howto
)
1489 && (reloc_data
.sdata_begin_symbol_vma_set
== FALSE
))
1492 ("Error: Linker symbol __SDATA_BEGIN__ not found");
1493 bfd_set_error (bfd_error_bad_value
);
1497 DEBUG_ARC_RELOC (reloc_data
);
1499 /* Make sure we have with a dynamic linker. In case of GOT and PLT
1500 the sym_section should point to .got or .plt respectively. */
1501 if ((is_reloc_for_GOT (howto
) || is_reloc_for_PLT (howto
))
1502 && reloc_data
.sym_section
== NULL
)
1505 (_("GOT and PLT relocations cannot be fixed with a non dynamic linker."));
1506 bfd_set_error (bfd_error_bad_value
);
1511 switch (arc_do_relocation (contents
, reloc_data
, info
))
1514 continue; /* The reloc processing loop. */
1516 case bfd_reloc_overflow
:
1517 (*info
->callbacks
->reloc_overflow
)
1518 (info
, (h
? &h
->root
: NULL
), reloc_data
.symbol_name
, howto
->name
, (bfd_vma
) 0,
1519 input_bfd
, input_section
, rel
->r_offset
);
1522 case bfd_reloc_undefined
:
1523 (*info
->callbacks
->undefined_symbol
)
1524 (info
, reloc_data
.symbol_name
, input_bfd
, input_section
, rel
->r_offset
, TRUE
);
1527 case bfd_reloc_other
:
1528 /* xgettext:c-format */
1529 msg
= _("%B(%A): warning: unaligned access to symbol '%s' in the small data area");
1532 case bfd_reloc_outofrange
:
1533 /* xgettext:c-format */
1534 msg
= _("%B(%A): internal error: out of range error");
1537 case bfd_reloc_notsupported
:
1538 /* xgettext:c-format */
1539 msg
= _("%B(%A): internal error: unsupported relocation error");
1542 case bfd_reloc_dangerous
:
1543 /* xgettext:c-format */
1544 msg
= _("%B(%A): internal error: dangerous relocation");
1548 /* xgettext:c-format */
1549 msg
= _("%B(%A): internal error: unknown error");
1554 _bfd_error_handler (msg
, input_bfd
, input_section
, reloc_data
.symbol_name
);
1561 #define elf_arc_hash_table(p) \
1562 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
1563 == ARC_ELF_DATA ? ((struct elf_arc_link_hash_table *) ((p)->hash)) : NULL)
1565 static struct dynamic_sections
1566 arc_create_dynamic_sections (bfd
* abfd
, struct bfd_link_info
*info
)
1568 struct elf_link_hash_table
*htab
;
1570 struct dynamic_sections ds
=
1572 .initialized
= FALSE
,
1582 htab
= elf_hash_table (info
);
1585 /* Create dynamic sections for relocatable executables so that we
1586 can copy relocations. */
1587 if (! htab
->dynamic_sections_created
&& bfd_link_pic (info
))
1589 if (! _bfd_elf_link_create_dynamic_sections (abfd
, info
))
1593 dynobj
= (elf_hash_table (info
))->dynobj
;
1597 ds
.sgot
= htab
->sgot
;
1598 ds
.srelgot
= htab
->srelgot
;
1600 ds
.sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
1601 ds
.srelgotplt
= ds
.srelplt
;
1603 ds
.splt
= bfd_get_section_by_name (dynobj
, ".plt");
1604 ds
.srelplt
= bfd_get_section_by_name (dynobj
, ".rela.plt");
1607 if (htab
->dynamic_sections_created
)
1609 ds
.sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
1612 ds
.initialized
= TRUE
;
1618 elf_arc_check_relocs (bfd
* abfd
,
1619 struct bfd_link_info
* info
,
1621 const Elf_Internal_Rela
* relocs
)
1623 Elf_Internal_Shdr
* symtab_hdr
;
1624 struct elf_link_hash_entry
** sym_hashes
;
1625 const Elf_Internal_Rela
* rel
;
1626 const Elf_Internal_Rela
* rel_end
;
1628 asection
* sreloc
= NULL
;
1630 if (bfd_link_relocatable (info
))
1633 dynobj
= (elf_hash_table (info
))->dynobj
;
1634 symtab_hdr
= &((elf_tdata (abfd
))->symtab_hdr
);
1635 sym_hashes
= elf_sym_hashes (abfd
);
1637 rel_end
= relocs
+ sec
->reloc_count
;
1638 for (rel
= relocs
; rel
< rel_end
; rel
++)
1640 enum elf_arc_reloc_type r_type
;
1641 reloc_howto_type
*howto
;
1642 unsigned long r_symndx
;
1643 struct elf_link_hash_entry
*h
;
1645 r_type
= ELF32_R_TYPE (rel
->r_info
);
1647 if (r_type
>= (int) R_ARC_max
)
1649 bfd_set_error (bfd_error_bad_value
);
1652 howto
= arc_elf_howto (r_type
);
1655 && (is_reloc_for_GOT (howto
) == TRUE
1656 || is_reloc_for_TLS (howto
) == TRUE
))
1658 dynobj
= elf_hash_table (info
)->dynobj
= abfd
;
1659 if (! _bfd_elf_create_got_section (abfd
, info
))
1663 /* Load symbol information. */
1664 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1665 if (r_symndx
< symtab_hdr
->sh_info
) /* Is a local symbol. */
1667 else /* Global one. */
1668 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1674 /* During shared library creation, these relocs should not
1675 appear in a shared library (as memory will be read only
1676 and the dynamic linker can not resolve these. However
1677 the error should not occur for e.g. debugging or
1678 non-readonly sections. */
1679 if ((bfd_link_dll (info
) && !bfd_link_pie (info
))
1680 && (sec
->flags
& SEC_ALLOC
) != 0
1681 && (sec
->flags
& SEC_READONLY
) != 0
1682 && ((sec
->flags
& SEC_CODE
) != 0
1683 || (sec
->flags
& SEC_DEBUGGING
) != 0))
1687 name
= h
->root
.root
.string
;
1689 /* bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL); */
1692 /* xgettext:c-format */
1694 %B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1696 arc_elf_howto (r_type
)->name
,
1698 bfd_set_error (bfd_error_bad_value
);
1702 /* In some cases we are not setting the 'non_got_ref'
1703 flag, even though the relocations don't require a GOT
1704 access. We should extend the testing in this area to
1705 ensure that no significant cases are being missed. */
1710 case R_ARC_32_PCREL
:
1711 if ((bfd_link_pic (info
))
1712 && ((r_type
!= R_ARC_PC32
&& r_type
!= R_ARC_32_PCREL
)
1714 && (!info
->symbolic
|| !h
->def_regular
))))
1718 sreloc
= _bfd_elf_make_dynamic_reloc_section (sec
, dynobj
,
1726 sreloc
->size
+= sizeof (Elf32_External_Rela
);
1733 if (is_reloc_for_PLT (howto
) == TRUE
)
1741 /* Add info to the symbol got_entry_list. */
1742 if (is_reloc_for_GOT (howto
) == TRUE
1743 || is_reloc_for_TLS (howto
) == TRUE
)
1745 arc_fill_got_info_for_reloc (
1746 arc_got_entry_type_for_reloc (howto
),
1747 get_got_entry_list_for_symbol (abfd
, r_symndx
, h
),
1756 #define ELF_DYNAMIC_INTERPRETER "/sbin/ld-uClibc.so"
1758 static struct plt_version_t
*
1759 arc_get_plt_version (struct bfd_link_info
*info
)
1763 for (i
= 0; i
< 1; i
++)
1765 ARC_DEBUG ("%d: size1 = %d, size2 = %d\n", i
,
1766 (int) plt_versions
[i
].entry_size
,
1767 (int) plt_versions
[i
].elem_size
);
1770 if (bfd_get_mach (info
->output_bfd
) == bfd_mach_arc_arcv2
)
1772 if (bfd_link_pic (info
))
1773 return &(plt_versions
[ELF_ARCV2_PIC
]);
1775 return &(plt_versions
[ELF_ARCV2_ABS
]);
1779 if (bfd_link_pic (info
))
1780 return &(plt_versions
[ELF_ARC_PIC
]);
1782 return &(plt_versions
[ELF_ARC_ABS
]);
1787 add_symbol_to_plt (struct bfd_link_info
*info
)
1789 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
1792 struct plt_version_t
*plt_data
= arc_get_plt_version (info
);
1794 /* If this is the first .plt entry, make room for the special first
1796 if (htab
->splt
->size
== 0)
1797 htab
->splt
->size
+= plt_data
->entry_size
;
1799 ret
= htab
->splt
->size
;
1801 htab
->splt
->size
+= plt_data
->elem_size
;
1802 ARC_DEBUG ("PLT_SIZE = %d\n", (int) htab
->splt
->size
);
1804 htab
->sgotplt
->size
+= 4;
1805 htab
->srelplt
->size
+= sizeof (Elf32_External_Rela
);
1810 #define PLT_DO_RELOCS_FOR_ENTRY(ABFD, DS, RELOCS) \
1811 plt_do_relocs_for_symbol (ABFD, DS, RELOCS, 0, 0)
1814 plt_do_relocs_for_symbol (bfd
*abfd
,
1815 struct elf_link_hash_table
*htab
,
1816 const struct plt_reloc
*reloc
,
1818 bfd_vma symbol_got_offset
)
1820 while (SYM_ONLY (reloc
->symbol
) != LAST_RELOC
)
1822 bfd_vma relocation
= 0;
1824 switch (SYM_ONLY (reloc
->symbol
))
1828 = htab
->sgotplt
->output_section
->vma
1829 + htab
->sgotplt
->output_offset
+ symbol_got_offset
;
1832 relocation
+= reloc
->addend
;
1834 if (IS_RELATIVE (reloc
->symbol
))
1836 bfd_vma reloc_offset
= reloc
->offset
;
1837 reloc_offset
-= (IS_INSN_32 (reloc
->symbol
)) ? 4 : 0;
1838 reloc_offset
-= (IS_INSN_24 (reloc
->symbol
)) ? 2 : 0;
1840 relocation
-= htab
->splt
->output_section
->vma
1841 + htab
->splt
->output_offset
1842 + plt_offset
+ reloc_offset
;
1845 /* TODO: being ME is not a property of the relocation but of the
1846 section of which is applying the relocation. */
1847 if (IS_MIDDLE_ENDIAN (reloc
->symbol
) && !bfd_big_endian (abfd
))
1850 = ((relocation
& 0xffff0000) >> 16)
1851 | ((relocation
& 0xffff) << 16);
1854 switch (reloc
->size
)
1857 bfd_put_32 (htab
->splt
->output_section
->owner
,
1859 htab
->splt
->contents
+ plt_offset
+ reloc
->offset
);
1863 reloc
= &(reloc
[1]); /* Jump to next relocation. */
1868 relocate_plt_for_symbol (bfd
*output_bfd
,
1869 struct bfd_link_info
*info
,
1870 struct elf_link_hash_entry
*h
)
1872 struct plt_version_t
*plt_data
= arc_get_plt_version (info
);
1873 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
1875 bfd_vma plt_index
= (h
->plt
.offset
- plt_data
->entry_size
)
1876 / plt_data
->elem_size
;
1877 bfd_vma got_offset
= (plt_index
+ 3) * 4;
1879 ARC_DEBUG ("arc_info: PLT_OFFSET = %#lx, PLT_ENTRY_VMA = %#lx, \
1880 GOT_ENTRY_OFFSET = %#lx, GOT_ENTRY_VMA = %#lx, for symbol %s\n",
1881 (long) h
->plt
.offset
,
1882 (long) (htab
->splt
->output_section
->vma
1883 + htab
->splt
->output_offset
1886 (long) (htab
->sgotplt
->output_section
->vma
1887 + htab
->sgotplt
->output_offset
1889 h
->root
.root
.string
);
1893 uint16_t *ptr
= (uint16_t *) plt_data
->elem
;
1895 for (i
= 0; i
< plt_data
->elem_size
/2; i
++)
1897 uint16_t data
= ptr
[i
];
1898 bfd_put_16 (output_bfd
,
1900 htab
->splt
->contents
+ h
->plt
.offset
+ (i
*2));
1904 plt_do_relocs_for_symbol (output_bfd
, htab
,
1905 plt_data
->elem_relocs
,
1909 /* Fill in the entry in the global offset table. */
1910 bfd_put_32 (output_bfd
,
1911 (bfd_vma
) (htab
->splt
->output_section
->vma
1912 + htab
->splt
->output_offset
),
1913 htab
->sgotplt
->contents
+ got_offset
);
1915 /* TODO: Fill in the entry in the .rela.plt section. */
1917 Elf_Internal_Rela rel
;
1920 rel
.r_offset
= (htab
->sgotplt
->output_section
->vma
1921 + htab
->sgotplt
->output_offset
1925 BFD_ASSERT (h
->dynindx
!= -1);
1926 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARC_JMP_SLOT
);
1928 loc
= htab
->srelplt
->contents
;
1929 loc
+= plt_index
* sizeof (Elf32_External_Rela
); /* relA */
1930 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
1935 relocate_plt_for_entry (bfd
*abfd
,
1936 struct bfd_link_info
*info
)
1938 struct plt_version_t
*plt_data
= arc_get_plt_version (info
);
1939 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
1943 uint16_t *ptr
= (uint16_t *) plt_data
->entry
;
1944 for (i
= 0; i
< plt_data
->entry_size
/2; i
++)
1946 uint16_t data
= ptr
[i
];
1949 htab
->splt
->contents
+ (i
*2));
1952 PLT_DO_RELOCS_FOR_ENTRY (abfd
, htab
, plt_data
->entry_relocs
);
1955 /* Desc : Adjust a symbol defined by a dynamic object and referenced
1956 by a regular object. The current definition is in some section of
1957 the dynamic object, but we're not including those sections. We
1958 have to change the definition to something the rest of the link can
1962 elf_arc_adjust_dynamic_symbol (struct bfd_link_info
*info
,
1963 struct elf_link_hash_entry
*h
)
1966 bfd
*dynobj
= (elf_hash_table (info
))->dynobj
;
1967 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
1969 if (h
->type
== STT_FUNC
1970 || h
->type
== STT_GNU_IFUNC
1971 || h
->needs_plt
== 1)
1973 if (!bfd_link_pic (info
) && !h
->def_dynamic
&& !h
->ref_dynamic
)
1975 /* This case can occur if we saw a PLT32 reloc in an input
1976 file, but the symbol was never referred to by a dynamic
1977 object. In such a case, we don't actually need to build
1978 a procedure linkage table, and we can just do a PC32
1980 BFD_ASSERT (h
->needs_plt
);
1984 /* Make sure this symbol is output as a dynamic symbol. */
1985 if (h
->dynindx
== -1 && !h
->forced_local
1986 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
1989 if (bfd_link_pic (info
)
1990 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
1992 bfd_vma loc
= add_symbol_to_plt (info
);
1994 if (bfd_link_executable (info
) && !h
->def_regular
)
1996 h
->root
.u
.def
.section
= htab
->splt
;
1997 h
->root
.u
.def
.value
= loc
;
1999 h
->plt
.offset
= loc
;
2003 h
->plt
.offset
= (bfd_vma
) -1;
2009 /* If this is a weak symbol, and there is a real definition, the
2010 processor independent code will have arranged for us to see the
2011 real definition first, and we can just use the same value. */
2012 if (h
->u
.weakdef
!= NULL
)
2014 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2015 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2016 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2017 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2021 /* This is a reference to a symbol defined by a dynamic object which
2022 is not a function. */
2024 /* If we are creating a shared library, we must presume that the
2025 only references to the symbol are via the global offset table.
2026 For such cases we need not do anything here; the relocations will
2027 be handled correctly by relocate_section. */
2028 if (!bfd_link_executable (info
))
2031 /* If there are no non-GOT references, we do not need a copy
2033 if (!h
->non_got_ref
)
2036 /* If -z nocopyreloc was given, we won't generate them either. */
2037 if (info
->nocopyreloc
)
2043 /* We must allocate the symbol in our .dynbss section, which will
2044 become part of the .bss section of the executable. There will be
2045 an entry for this symbol in the .dynsym section. The dynamic
2046 object will contain position independent code, so all references
2047 from the dynamic object to this symbol will go through the global
2048 offset table. The dynamic linker will use the .dynsym entry to
2049 determine the address it must put in the global offset table, so
2050 both the dynamic object and the regular object will refer to the
2051 same memory location for the variable. */
2056 /* We must generate a R_ARC_COPY reloc to tell the dynamic linker to
2057 copy the initial value out of the dynamic object and into the
2058 runtime process image. We need to remember the offset into the
2059 .rela.bss section we are going to use. */
2060 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
2062 struct elf_arc_link_hash_table
*arc_htab
= elf_arc_hash_table (info
);
2064 BFD_ASSERT (arc_htab
->elf
.srelbss
!= NULL
);
2065 arc_htab
->elf
.srelbss
->size
+= sizeof (Elf32_External_Rela
);
2069 /* TODO: Move this also to arc_hash_table. */
2070 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
2071 BFD_ASSERT (s
!= NULL
);
2073 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2076 /* Function : elf_arc_finish_dynamic_symbol
2077 Brief : Finish up dynamic symbol handling. We set the
2078 contents of various dynamic sections here.
2083 Returns : True/False as the return status. */
2086 elf_arc_finish_dynamic_symbol (bfd
* output_bfd
,
2087 struct bfd_link_info
*info
,
2088 struct elf_link_hash_entry
*h
,
2089 Elf_Internal_Sym
* sym
)
2091 if (h
->plt
.offset
!= (bfd_vma
) -1)
2093 relocate_plt_for_symbol (output_bfd
, info
, h
);
2095 if (!h
->def_regular
)
2097 /* Mark the symbol as undefined, rather than as defined in
2098 the .plt section. Leave the value alone. */
2099 sym
->st_shndx
= SHN_UNDEF
;
2104 /* This function traverses list of GOT entries and
2105 create respective dynamic relocs. */
2106 /* TODO: Make function to get list and not access the list directly. */
2107 /* TODO: Move function to relocate_section create this relocs eagerly. */
2108 create_got_dynrelocs_for_got_info (&h
->got
.glist
,
2115 struct elf_arc_link_hash_table
*arc_htab
= elf_arc_hash_table (info
);
2117 if (h
->dynindx
== -1
2118 || (h
->root
.type
!= bfd_link_hash_defined
2119 && h
->root
.type
!= bfd_link_hash_defweak
)
2120 || arc_htab
->elf
.srelbss
== NULL
)
2123 bfd_vma rel_offset
= (h
->root
.u
.def
.value
2124 + h
->root
.u
.def
.section
->output_section
->vma
2125 + h
->root
.u
.def
.section
->output_offset
);
2127 bfd_byte
* loc
= arc_htab
->elf
.srelbss
->contents
2128 + (arc_htab
->elf
.srelbss
->reloc_count
* sizeof (Elf32_External_Rela
));
2129 arc_htab
->elf
.srelbss
->reloc_count
++;
2131 Elf_Internal_Rela rel
;
2133 rel
.r_offset
= rel_offset
;
2135 BFD_ASSERT (h
->dynindx
!= -1);
2136 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARC_COPY
);
2138 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
2141 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2142 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2143 || strcmp (h
->root
.root
.string
, "__DYNAMIC") == 0
2144 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
2145 sym
->st_shndx
= SHN_ABS
;
2150 #define GET_SYMBOL_OR_SECTION(TAG, SYMBOL, SECTION) \
2152 if (SYMBOL != NULL) \
2153 h = elf_link_hash_lookup (elf_hash_table (info), \
2154 SYMBOL, FALSE, FALSE, TRUE); \
2155 else if (SECTION != NULL) \
2156 s = bfd_get_linker_section (dynobj, SECTION); \
2159 /* Function : elf_arc_finish_dynamic_sections
2160 Brief : Finish up the dynamic sections handling.
2165 Returns : True/False as the return status. */
2168 elf_arc_finish_dynamic_sections (bfd
* output_bfd
,
2169 struct bfd_link_info
*info
)
2171 struct dynamic_sections ds
= arc_create_dynamic_sections (output_bfd
, info
);
2172 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2173 bfd
*dynobj
= (elf_hash_table (info
))->dynobj
;
2177 Elf32_External_Dyn
*dyncon
, *dynconend
;
2179 dyncon
= (Elf32_External_Dyn
*) ds
.sdyn
->contents
;
2181 = (Elf32_External_Dyn
*) (ds
.sdyn
->contents
+ ds
.sdyn
->size
);
2182 for (; dyncon
< dynconend
; dyncon
++)
2184 Elf_Internal_Dyn internal_dyn
;
2185 bfd_boolean do_it
= FALSE
;
2187 struct elf_link_hash_entry
*h
= NULL
;
2190 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &internal_dyn
);
2192 switch (internal_dyn
.d_tag
)
2194 GET_SYMBOL_OR_SECTION (DT_INIT
, info
->init_function
, NULL
)
2195 GET_SYMBOL_OR_SECTION (DT_FINI
, info
->fini_function
, NULL
)
2196 GET_SYMBOL_OR_SECTION (DT_PLTGOT
, NULL
, ".plt")
2197 GET_SYMBOL_OR_SECTION (DT_JMPREL
, NULL
, ".rela.plt")
2198 GET_SYMBOL_OR_SECTION (DT_PLTRELSZ
, NULL
, ".rela.plt")
2199 GET_SYMBOL_OR_SECTION (DT_VERSYM
, NULL
, ".gnu.version")
2200 GET_SYMBOL_OR_SECTION (DT_VERDEF
, NULL
, ".gnu.version_d")
2201 GET_SYMBOL_OR_SECTION (DT_VERNEED
, NULL
, ".gnu.version_r")
2206 /* In case the dynamic symbols should be updated with a symbol. */
2208 && (h
->root
.type
== bfd_link_hash_defined
2209 || h
->root
.type
== bfd_link_hash_defweak
))
2213 internal_dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
2214 asec_ptr
= h
->root
.u
.def
.section
;
2215 if (asec_ptr
->output_section
!= NULL
)
2217 internal_dyn
.d_un
.d_val
+=
2218 (asec_ptr
->output_section
->vma
2219 + asec_ptr
->output_offset
);
2223 /* The symbol is imported from another shared
2224 library and does not apply to this one. */
2225 internal_dyn
.d_un
.d_val
= 0;
2229 else if (s
!= NULL
) /* With a section information. */
2231 switch (internal_dyn
.d_tag
)
2238 internal_dyn
.d_un
.d_ptr
= (s
->output_section
->vma
2239 + s
->output_offset
);
2244 internal_dyn
.d_un
.d_val
= s
->size
;
2254 bfd_elf32_swap_dyn_out (output_bfd
, &internal_dyn
, dyncon
);
2257 if (htab
->splt
->size
> 0)
2259 relocate_plt_for_entry (output_bfd
, info
);
2262 /* TODO: Validate this. */
2263 elf_section_data (htab
->srelplt
->output_section
)->this_hdr
.sh_entsize
2267 /* Fill in the first three entries in the global offset table. */
2270 struct elf_link_hash_entry
*h
;
2271 h
= elf_link_hash_lookup (elf_hash_table (info
), "_GLOBAL_OFFSET_TABLE_",
2272 FALSE
, FALSE
, TRUE
);
2274 if (h
!= NULL
&& h
->root
.type
!= bfd_link_hash_undefined
2275 && h
->root
.u
.def
.section
!= NULL
)
2277 asection
*sec
= h
->root
.u
.def
.section
;
2279 if (ds
.sdyn
== NULL
)
2280 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
2283 bfd_put_32 (output_bfd
,
2284 ds
.sdyn
->output_section
->vma
+ ds
.sdyn
->output_offset
,
2286 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sec
->contents
+ 4);
2287 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sec
->contents
+ 8);
2294 #define ADD_DYNAMIC_SYMBOL(NAME, TAG) \
2295 h = elf_link_hash_lookup (elf_hash_table (info), \
2296 NAME, FALSE, FALSE, FALSE); \
2297 if ((h != NULL && (h->ref_regular || h->def_regular))) \
2298 if (! _bfd_elf_add_dynamic_entry (info, TAG, 0)) \
2301 /* Set the sizes of the dynamic sections. */
2303 elf_arc_size_dynamic_sections (bfd
* output_bfd
,
2304 struct bfd_link_info
*info
)
2308 bfd_boolean relocs_exist
= FALSE
;
2309 bfd_boolean reltext_exist
= FALSE
;
2310 struct dynamic_sections ds
= arc_create_dynamic_sections (output_bfd
, info
);
2311 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2313 dynobj
= (elf_hash_table (info
))->dynobj
;
2314 BFD_ASSERT (dynobj
!= NULL
);
2316 if ((elf_hash_table (info
))->dynamic_sections_created
)
2318 struct elf_link_hash_entry
*h
;
2320 /* Set the contents of the .interp section to the
2322 if (!bfd_link_pic (info
) && !info
->nointerp
)
2324 s
= bfd_get_section_by_name (dynobj
, ".interp");
2325 BFD_ASSERT (s
!= NULL
);
2326 s
->size
= sizeof (ELF_DYNAMIC_INTERPRETER
);
2327 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2330 /* Add some entries to the .dynamic section. We fill in some of
2331 the values later, in elf_bfd_final_link, but we must add the
2332 entries now so that we know the final size of the .dynamic
2333 section. Checking if the .init section is present. We also
2334 create DT_INIT and DT_FINI entries if the init_str has been
2335 changed by the user. */
2336 ADD_DYNAMIC_SYMBOL (info
->init_function
, DT_INIT
);
2337 ADD_DYNAMIC_SYMBOL (info
->fini_function
, DT_FINI
);
2341 /* We may have created entries in the .rela.got section.
2342 However, if we are not creating the dynamic sections, we will
2343 not actually use these entries. Reset the size of .rela.got,
2344 which will cause it to get stripped from the output file
2346 if (htab
->srelgot
!= NULL
)
2347 htab
->srelgot
->size
= 0;
2350 if (htab
->splt
!= NULL
&& htab
->splt
->size
== 0)
2351 htab
->splt
->flags
|= SEC_EXCLUDE
;
2352 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2354 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2357 if (strncmp (s
->name
, ".rela", 5) == 0)
2361 s
->flags
|= SEC_EXCLUDE
;
2365 if (strcmp (s
->name
, ".rela.plt") != 0)
2367 const char *outname
=
2368 bfd_get_section_name (output_bfd
,
2369 htab
->srelplt
->output_section
);
2371 asection
*target
= bfd_get_section_by_name (output_bfd
,
2374 relocs_exist
= TRUE
;
2375 if (target
!= NULL
&& target
->size
!= 0
2376 && (target
->flags
& SEC_READONLY
) != 0
2377 && (target
->flags
& SEC_ALLOC
) != 0)
2378 reltext_exist
= TRUE
;
2382 /* We use the reloc_count field as a counter if we need to
2383 copy relocs into the output file. */
2387 if (strcmp (s
->name
, ".dynamic") == 0)
2391 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
2393 if (s
->contents
== NULL
&& s
->size
!= 0)
2399 /* TODO: Check if this is needed. */
2400 if (!bfd_link_pic (info
))
2401 if (!_bfd_elf_add_dynamic_entry (info
, DT_DEBUG
, 0))
2404 if (htab
->splt
&& (htab
->splt
->flags
& SEC_EXCLUDE
) == 0)
2405 if (!_bfd_elf_add_dynamic_entry (info
, DT_PLTGOT
, 0)
2406 || !_bfd_elf_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
2407 || !_bfd_elf_add_dynamic_entry (info
, DT_PLTREL
, DT_RELA
)
2408 || !_bfd_elf_add_dynamic_entry (info
, DT_JMPREL
, 0)
2412 if (relocs_exist
== TRUE
)
2413 if (!_bfd_elf_add_dynamic_entry (info
, DT_RELA
, 0)
2414 || !_bfd_elf_add_dynamic_entry (info
, DT_RELASZ
, 0)
2415 || !_bfd_elf_add_dynamic_entry (info
, DT_RELAENT
,
2416 sizeof (Elf32_External_Rela
))
2420 if (reltext_exist
== TRUE
)
2421 if (!_bfd_elf_add_dynamic_entry (info
, DT_TEXTREL
, 0))
2429 /* Classify dynamic relocs such that -z combreloc can reorder and combine
2431 static enum elf_reloc_type_class
2432 elf32_arc_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2433 const asection
*rel_sec ATTRIBUTE_UNUSED
,
2434 const Elf_Internal_Rela
*rela
)
2436 switch ((int) ELF32_R_TYPE (rela
->r_info
))
2438 case R_ARC_RELATIVE
:
2439 return reloc_class_relative
;
2440 case R_ARC_JMP_SLOT
:
2441 return reloc_class_plt
;
2443 return reloc_class_copy
;
2444 /* TODO: Needed in future to support ifunc. */
2446 case R_ARC_IRELATIVE:
2447 return reloc_class_ifunc;
2450 return reloc_class_normal
;
2454 const struct elf_size_info arc_elf32_size_info
=
2456 sizeof (Elf32_External_Ehdr
),
2457 sizeof (Elf32_External_Phdr
),
2458 sizeof (Elf32_External_Shdr
),
2459 sizeof (Elf32_External_Rel
),
2460 sizeof (Elf32_External_Rela
),
2461 sizeof (Elf32_External_Sym
),
2462 sizeof (Elf32_External_Dyn
),
2463 sizeof (Elf_External_Note
),
2467 ELFCLASS32
, EV_CURRENT
,
2468 bfd_elf32_write_out_phdrs
,
2469 bfd_elf32_write_shdrs_and_ehdr
,
2470 bfd_elf32_checksum_contents
,
2471 bfd_elf32_write_relocs
,
2472 bfd_elf32_swap_symbol_in
,
2473 bfd_elf32_swap_symbol_out
,
2474 bfd_elf32_slurp_reloc_table
,
2475 bfd_elf32_slurp_symbol_table
,
2476 bfd_elf32_swap_dyn_in
,
2477 bfd_elf32_swap_dyn_out
,
2478 bfd_elf32_swap_reloc_in
,
2479 bfd_elf32_swap_reloc_out
,
2480 bfd_elf32_swap_reloca_in
,
2481 bfd_elf32_swap_reloca_out
2484 #define elf_backend_size_info arc_elf32_size_info
2486 /* Hook called by the linker routine which adds symbols from an object
2490 elf_arc_add_symbol_hook (bfd
* abfd
,
2491 struct bfd_link_info
* info
,
2492 Elf_Internal_Sym
* sym
,
2493 const char ** namep ATTRIBUTE_UNUSED
,
2494 flagword
* flagsp ATTRIBUTE_UNUSED
,
2495 asection
** secp ATTRIBUTE_UNUSED
,
2496 bfd_vma
* valp ATTRIBUTE_UNUSED
)
2498 if (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
2499 && (abfd
->flags
& DYNAMIC
) == 0
2500 && bfd_get_flavour (info
->output_bfd
) == bfd_target_elf_flavour
)
2501 elf_tdata (info
->output_bfd
)->has_gnu_symbols
|= elf_gnu_symbol_ifunc
;
2506 /* GDB expects general purpose registers to be in section .reg. However Linux
2507 kernel doesn't create this section and instead writes registers to NOTE
2508 section. It is up to the binutils to create a pseudo-section .reg from the
2509 contents of NOTE. Also BFD will read pid and signal number from NOTE. This
2510 function relies on offsets inside elf_prstatus structure in Linux to be
2514 elf32_arc_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
2519 switch (note
->descsz
)
2524 case 236: /* sizeof (struct elf_prstatus) on Linux/arc. */
2526 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
2528 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
2531 size
= (40 * 4); /* There are 40 registers in user_regs_struct. */
2534 /* Make a ".reg/999" section. */
2535 return _bfd_elfcore_make_pseudosection (abfd
, ".reg", size
,
2536 note
->descpos
+ offset
);
2539 #define TARGET_LITTLE_SYM arc_elf32_le_vec
2540 #define TARGET_LITTLE_NAME "elf32-littlearc"
2541 #define TARGET_BIG_SYM arc_elf32_be_vec
2542 #define TARGET_BIG_NAME "elf32-bigarc"
2543 #define ELF_ARCH bfd_arch_arc
2544 #define ELF_TARGET_ID ARC_ELF_DATA
2545 #define ELF_MACHINE_CODE EM_ARC_COMPACT
2546 #define ELF_MACHINE_ALT1 EM_ARC_COMPACT2
2547 #define ELF_MAXPAGESIZE 0x2000
2549 #define bfd_elf32_bfd_link_hash_table_create arc_elf_link_hash_table_create
2551 #define bfd_elf32_bfd_merge_private_bfd_data arc_elf_merge_private_bfd_data
2552 #define bfd_elf32_bfd_reloc_type_lookup arc_elf32_bfd_reloc_type_lookup
2553 #define bfd_elf32_bfd_set_private_flags arc_elf_set_private_flags
2554 #define bfd_elf32_bfd_print_private_bfd_data arc_elf_print_private_bfd_data
2555 #define bfd_elf32_bfd_copy_private_bfd_data arc_elf_copy_private_bfd_data
2557 #define elf_info_to_howto_rel arc_info_to_howto_rel
2558 #define elf_backend_object_p arc_elf_object_p
2559 #define elf_backend_final_write_processing arc_elf_final_write_processing
2561 #define elf_backend_relocate_section elf_arc_relocate_section
2562 #define elf_backend_check_relocs elf_arc_check_relocs
2563 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
2565 #define elf_backend_reloc_type_class elf32_arc_reloc_type_class
2567 #define elf_backend_adjust_dynamic_symbol elf_arc_adjust_dynamic_symbol
2568 #define elf_backend_finish_dynamic_symbol elf_arc_finish_dynamic_symbol
2570 #define elf_backend_finish_dynamic_sections elf_arc_finish_dynamic_sections
2571 #define elf_backend_size_dynamic_sections elf_arc_size_dynamic_sections
2572 #define elf_backend_add_symbol_hook elf_arc_add_symbol_hook
2574 #define elf_backend_can_gc_sections 1
2575 #define elf_backend_want_got_plt 1
2576 #define elf_backend_plt_readonly 1
2577 #define elf_backend_rela_plts_and_copies_p 1
2578 #define elf_backend_want_plt_sym 0
2579 #define elf_backend_got_header_size 12
2580 #define elf_backend_dtrel_excludes_plt 1
2582 #define elf_backend_may_use_rel_p 0
2583 #define elf_backend_may_use_rela_p 1
2584 #define elf_backend_default_use_rela_p 1
2586 #define elf_backend_grok_prstatus elf32_arc_grok_prstatus
2588 #define elf_backend_default_execstack 0
2590 #include "elf32-target.h"