1 /* ARC-specific support for 32-bit ELF
2 Copyright (C) 1994-2016 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
;
318 /* Short-cuts to get to dynamic linker sections. */
322 static struct bfd_hash_entry
*
323 elf_arc_link_hash_newfunc (struct bfd_hash_entry
*entry
,
324 struct bfd_hash_table
*table
,
327 /* Allocate the structure if it has not already been allocated by a
331 entry
= (struct bfd_hash_entry
*)
332 bfd_hash_allocate (table
,
333 sizeof (struct elf_arc_link_hash_entry
));
338 /* Call the allocation method of the superclass. */
339 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
342 struct elf_arc_link_hash_entry
*eh
;
344 eh
= (struct elf_arc_link_hash_entry
*) entry
;
345 eh
->dyn_relocs
= NULL
;
351 /* Destroy an ARC ELF linker hash table. */
353 elf_arc_link_hash_table_free (bfd
*obfd
)
355 _bfd_elf_link_hash_table_free (obfd
);
358 /* Create an ARC ELF linker hash table. */
360 static struct bfd_link_hash_table
*
361 arc_elf_link_hash_table_create (bfd
*abfd
)
363 struct elf_arc_link_hash_table
*ret
;
365 ret
= (struct elf_arc_link_hash_table
*) bfd_zmalloc (sizeof (*ret
));
369 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
370 elf_arc_link_hash_newfunc
,
371 sizeof (struct elf_arc_link_hash_entry
),
380 ret
->elf
.init_got_refcount
.refcount
= 0;
381 ret
->elf
.init_got_refcount
.glist
= NULL
;
382 ret
->elf
.init_got_offset
.offset
= 0;
383 ret
->elf
.init_got_offset
.glist
= NULL
;
385 ret
->elf
.root
.hash_table_free
= elf_arc_link_hash_table_free
;
387 return &ret
->elf
.root
;
390 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
391 { BFD_RELOC_##TYPE, R_##TYPE },
392 static const struct arc_reloc_map arc_reloc_map
[] =
394 #include "elf/arc-reloc.def"
396 {BFD_RELOC_NONE
, R_ARC_NONE
},
397 {BFD_RELOC_8
, R_ARC_8
},
398 {BFD_RELOC_16
, R_ARC_16
},
399 {BFD_RELOC_24
, R_ARC_24
},
400 {BFD_RELOC_32
, R_ARC_32
},
402 #undef ARC_RELOC_HOWTO
404 typedef ATTRIBUTE_UNUSED
bfd_vma (*replace_func
) (unsigned, int ATTRIBUTE_UNUSED
);
406 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
408 func = (void *) RELOC_FUNCTION; \
411 get_replace_function (bfd
*abfd
, unsigned int r_type
)
417 #include "elf/arc-reloc.def"
420 if (func
== replace_bits24
&& bfd_big_endian (abfd
))
421 return (replace_func
) replace_bits24_be
;
423 return (replace_func
) func
;
425 #undef ARC_RELOC_HOWTO
427 static reloc_howto_type
*
428 arc_elf32_bfd_reloc_type_lookup (bfd
* abfd ATTRIBUTE_UNUSED
,
429 bfd_reloc_code_real_type code
)
433 for (i
= ARRAY_SIZE (arc_reloc_map
); i
--;)
435 if (arc_reloc_map
[i
].bfd_reloc_val
== code
)
436 return arc_elf_howto (arc_reloc_map
[i
].elf_reloc_val
);
442 /* Function to set the ELF flag bits. */
444 arc_elf_set_private_flags (bfd
*abfd
, flagword flags
)
446 elf_elfheader (abfd
)->e_flags
= flags
;
447 elf_flags_init (abfd
) = TRUE
;
451 /* Print private flags. */
453 arc_elf_print_private_bfd_data (bfd
*abfd
, void * ptr
)
455 FILE *file
= (FILE *) ptr
;
458 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
460 /* Print normal ELF private data. */
461 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
463 flags
= elf_elfheader (abfd
)->e_flags
;
464 fprintf (file
, _("private flags = 0x%lx:"), (unsigned long) flags
);
466 switch (flags
& EF_ARC_MACH_MSK
)
468 case EF_ARC_CPU_ARCV2HS
: fprintf (file
, " -mcpu=ARCv2HS"); break;
469 case EF_ARC_CPU_ARCV2EM
: fprintf (file
, " -mcpu=ARCv2EM"); break;
470 case E_ARC_MACH_ARC600
: fprintf (file
, " -mcpu=ARC600"); break;
471 case E_ARC_MACH_ARC601
: fprintf (file
, " -mcpu=ARC601"); break;
472 case E_ARC_MACH_ARC700
: fprintf (file
, " -mcpu=ARC700"); break;
474 fprintf (file
, "-mcpu=unknown");
478 switch (flags
& EF_ARC_OSABI_MSK
)
480 case E_ARC_OSABI_ORIG
: fprintf (file
, " (ABI:legacy)"); break;
481 case E_ARC_OSABI_V2
: fprintf (file
, " (ABI:v2)"); break;
482 case E_ARC_OSABI_V3
: fprintf (file
, " (ABI:v3)"); break;
484 fprintf (file
, "(ABI:unknown)");
492 /* Copy backend specific data from one object module to another. */
495 arc_elf_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
497 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
498 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
501 BFD_ASSERT (!elf_flags_init (obfd
)
502 || elf_elfheader (obfd
)->e_flags
== elf_elfheader (ibfd
)->e_flags
);
504 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
505 elf_flags_init (obfd
) = TRUE
;
507 /* Copy object attributes. */
508 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
510 return _bfd_elf_copy_private_bfd_data (ibfd
, obfd
);
513 static reloc_howto_type
*
514 bfd_elf32_bfd_reloc_name_lookup (bfd
* abfd ATTRIBUTE_UNUSED
,
519 for (i
= 0; i
< ARRAY_SIZE (elf_arc_howto_table
); i
++)
520 if (elf_arc_howto_table
[i
].name
!= NULL
521 && strcasecmp (elf_arc_howto_table
[i
].name
, r_name
) == 0)
522 return arc_elf_howto (i
);
527 /* Set the howto pointer for an ARC ELF reloc. */
530 arc_info_to_howto_rel (bfd
* abfd ATTRIBUTE_UNUSED
,
532 Elf_Internal_Rela
* dst
)
536 r_type
= ELF32_R_TYPE (dst
->r_info
);
537 BFD_ASSERT (r_type
< (unsigned int) R_ARC_max
);
538 cache_ptr
->howto
= arc_elf_howto (r_type
);
541 /* Merge backend specific data from an object file to the output
542 object file when linking. */
545 arc_elf_merge_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
547 unsigned short mach_ibfd
;
548 static unsigned short mach_obfd
= EM_NONE
;
553 /* Check if we have the same endianess. */
554 if (! _bfd_generic_verify_endian_match (ibfd
, obfd
))
557 /* Collect ELF flags. */
558 in_flags
= elf_elfheader (ibfd
)->e_flags
& EF_ARC_MACH_MSK
;
559 out_flags
= elf_elfheader (obfd
)->e_flags
& EF_ARC_MACH_MSK
;
561 if (!elf_flags_init (obfd
)) /* First call, no flags set. */
563 elf_flags_init (obfd
) = TRUE
;
564 out_flags
= in_flags
;
567 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
568 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
571 /* Check to see if the input BFD actually contains any sections. Do
572 not short-circuit dynamic objects; their section list may be
573 emptied by elf_link_add_object_symbols. */
574 if (!(ibfd
->flags
& DYNAMIC
))
576 bfd_boolean null_input_bfd
= TRUE
;
577 bfd_boolean only_data_sections
= TRUE
;
579 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
581 if ((bfd_get_section_flags (ibfd
, sec
)
582 & (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
583 == (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
584 only_data_sections
= FALSE
;
586 null_input_bfd
= FALSE
;
589 if (null_input_bfd
|| only_data_sections
)
593 /* Complain about various flag/architecture mismatches. */
594 mach_ibfd
= elf_elfheader (ibfd
)->e_machine
;
595 if (mach_obfd
== EM_NONE
)
597 mach_obfd
= mach_ibfd
;
601 if (mach_ibfd
!= mach_obfd
)
603 _bfd_error_handler (_("ERROR: Attempting to link %B "
604 "with a binary %s of different architecture"),
605 ibfd
, bfd_get_filename (obfd
));
608 else if (in_flags
!= out_flags
)
610 /* Warn if different flags. */
612 (_("%s: uses different e_flags (0x%lx) fields than "
613 "previous modules (0x%lx)"),
614 bfd_get_filename (ibfd
), (long)in_flags
, (long)out_flags
);
615 if (in_flags
&& out_flags
)
617 /* MWDT doesnt set the eflags hence make sure we choose the
618 eflags set by gcc. */
619 in_flags
= in_flags
> out_flags
? in_flags
: out_flags
;
623 /* Update the flags. */
624 elf_elfheader (obfd
)->e_flags
= in_flags
;
626 if (bfd_get_mach (obfd
) < bfd_get_mach (ibfd
))
628 return bfd_set_arch_mach (obfd
, bfd_arch_arc
, bfd_get_mach (ibfd
));
634 /* Set the right machine number for an ARC ELF file. */
636 arc_elf_object_p (bfd
* abfd
)
638 /* Make sure this is initialised, or you'll have the potential of passing
639 garbage---or misleading values---into the call to
640 bfd_default_set_arch_mach (). */
641 int mach
= bfd_mach_arc_arc700
;
642 unsigned long arch
= elf_elfheader (abfd
)->e_flags
& EF_ARC_MACH_MSK
;
643 unsigned e_machine
= elf_elfheader (abfd
)->e_machine
;
645 if (e_machine
== EM_ARC_COMPACT
|| e_machine
== EM_ARC_COMPACT2
)
649 case E_ARC_MACH_ARC600
:
650 mach
= bfd_mach_arc_arc600
;
652 case E_ARC_MACH_ARC601
:
653 mach
= bfd_mach_arc_arc601
;
655 case E_ARC_MACH_ARC700
:
656 mach
= bfd_mach_arc_arc700
;
658 case EF_ARC_CPU_ARCV2HS
:
659 case EF_ARC_CPU_ARCV2EM
:
660 mach
= bfd_mach_arc_arcv2
;
663 mach
= (e_machine
== EM_ARC_COMPACT
)
664 ? bfd_mach_arc_arc700
: bfd_mach_arc_arcv2
;
670 if (e_machine
== EM_ARC
)
673 (_("Error: The ARC4 architecture is no longer supported.\n"));
679 (_("Warning: unset or old architecture flags. \n"
680 " Use default machine.\n"));
684 return bfd_default_set_arch_mach (abfd
, bfd_arch_arc
, mach
);
687 /* The final processing done just before writing out an ARC ELF object file.
688 This gets the ARC architecture right based on the machine number. */
691 arc_elf_final_write_processing (bfd
* abfd
,
692 bfd_boolean linker ATTRIBUTE_UNUSED
)
696 switch (bfd_get_mach (abfd
))
698 case bfd_mach_arc_arc600
:
699 emf
= EM_ARC_COMPACT
;
701 case bfd_mach_arc_arc601
:
702 emf
= EM_ARC_COMPACT
;
704 case bfd_mach_arc_arc700
:
705 emf
= EM_ARC_COMPACT
;
707 case bfd_mach_arc_arcv2
:
708 emf
= EM_ARC_COMPACT2
;
714 elf_elfheader (abfd
)->e_machine
= emf
;
716 /* Record whatever is the current syscall ABI version. */
717 elf_elfheader (abfd
)->e_flags
|= E_ARC_OSABI_CURRENT
;
723 #ifdef ARC_ENABLE_DEBUG
724 #define DEBUG_ARC_RELOC(A) debug_arc_reloc (A)
727 debug_arc_reloc (struct arc_relocation_data reloc_data
)
729 ARC_DEBUG ("Reloc type=%s, should_relocate = %s\n",
730 reloc_data
.howto
->name
,
731 reloc_data
.should_relocate
? "true" : "false");
732 ARC_DEBUG (" offset = 0x%x, addend = 0x%x\n",
733 (unsigned int) reloc_data
.reloc_offset
,
734 (unsigned int) reloc_data
.reloc_addend
);
735 ARC_DEBUG (" Symbol:\n");
736 ARC_DEBUG (" value = 0x%08x\n",
737 (unsigned int) reloc_data
.sym_value
);
738 if (reloc_data
.sym_section
!= NULL
)
740 ARC_DEBUG (" Symbol Section:\n");
741 ARC_DEBUG (" section name = %s, output_offset 0x%08x",
742 reloc_data
.sym_section
->name
,
743 (unsigned int) reloc_data
.sym_section
->output_offset
);
744 if (reloc_data
.sym_section
->output_section
!= NULL
)
745 ARC_DEBUG (", output_section->vma = 0x%08x",
746 ((unsigned int) reloc_data
.sym_section
->output_section
->vma
));
748 if (reloc_data
.sym_section
->owner
&& reloc_data
.sym_section
->owner
->filename
)
749 ARC_DEBUG (" file: %s\n", reloc_data
.sym_section
->owner
->filename
);
753 ARC_DEBUG (" symbol section is NULL\n");
756 ARC_DEBUG (" Input_section:\n");
757 if (reloc_data
.input_section
!= NULL
)
759 ARC_DEBUG (" section name = %s, output_offset 0x%08x, output_section->vma = 0x%08x\n",
760 reloc_data
.input_section
->name
,
761 (unsigned int) reloc_data
.input_section
->output_offset
,
762 (unsigned int) reloc_data
.input_section
->output_section
->vma
);
763 ARC_DEBUG (" changed_address = 0x%08x\n",
764 (unsigned int) (reloc_data
.input_section
->output_section
->vma
765 + reloc_data
.input_section
->output_offset
766 + reloc_data
.reloc_offset
));
767 ARC_DEBUG (" file: %s\n", reloc_data
.input_section
->owner
->filename
);
771 ARC_DEBUG (" input section is NULL\n");
775 #define DEBUG_ARC_RELOC(A)
776 #endif /* ARC_ENABLE_DEBUG */
779 middle_endian_convert (bfd_vma insn
, bfd_boolean do_it
)
784 = ((insn
& 0xffff0000) >> 16)
785 | ((insn
& 0xffff) << 16);
790 /* This function is called for relocations that are otherwise marked as NOT
791 requiring overflow checks. In here we perform non-standard checks of
792 the relocation value. */
794 static inline bfd_reloc_status_type
795 arc_special_overflow_checks (const struct arc_relocation_data reloc_data
,
796 bfd_signed_vma relocation
,
797 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
799 switch (reloc_data
.howto
->type
)
801 case R_ARC_NPS_CMEM16
:
802 if (((relocation
>> 16) & 0xffff) != NPS_CMEM_HIGH_VALUE
)
804 if (reloc_data
.reloc_addend
== 0)
806 (_("%B(%A+0x%lx): CMEM relocation to `%s' is invalid, "
807 "16 MSB should be 0x%04x (value is 0x%lx)"),
808 reloc_data
.input_section
->owner
,
809 reloc_data
.input_section
,
810 reloc_data
.reloc_offset
,
811 reloc_data
.symbol_name
,
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 msg
= _("%B(%A): warning: unaligned access to symbol '%s' in the small data area");
1531 case bfd_reloc_outofrange
:
1532 msg
= _("%B(%A): internal error: out of range error");
1535 case bfd_reloc_notsupported
:
1536 msg
= _("%B(%A): internal error: unsupported relocation error");
1539 case bfd_reloc_dangerous
:
1540 msg
= _("%B(%A): internal error: dangerous relocation");
1544 msg
= _("%B(%A): internal error: unknown error");
1549 _bfd_error_handler (msg
, input_bfd
, input_section
, reloc_data
.symbol_name
);
1556 #define elf_arc_hash_table(p) \
1557 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
1558 == ARC_ELF_DATA ? ((struct elf_arc_link_hash_table *) ((p)->hash)) : NULL)
1560 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
1561 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
1565 arc_elf_create_dynamic_sections (bfd
*dynobj
,
1566 struct bfd_link_info
*info
)
1568 struct elf_arc_link_hash_table
*htab
;
1570 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
1573 htab
= elf_arc_hash_table (info
);
1577 if (bfd_link_executable (info
))
1579 /* Always allow copy relocs for building executables. */
1580 asection
*s
= bfd_get_linker_section (dynobj
, ".rela.bss");
1583 const struct elf_backend_data
*bed
= get_elf_backend_data (dynobj
);
1584 s
= bfd_make_section_anyway_with_flags (dynobj
,
1586 (bed
->dynamic_sec_flags
1589 || ! bfd_set_section_alignment (dynobj
, s
,
1590 bed
->s
->log_file_align
))
1599 static struct dynamic_sections
1600 arc_create_dynamic_sections (bfd
* abfd
, struct bfd_link_info
*info
)
1602 struct elf_link_hash_table
*htab
;
1604 struct dynamic_sections ds
=
1606 .initialized
= FALSE
,
1616 htab
= elf_hash_table (info
);
1619 /* Create dynamic sections for relocatable executables so that we
1620 can copy relocations. */
1621 if (! htab
->dynamic_sections_created
&& bfd_link_pic (info
))
1623 if (! _bfd_elf_link_create_dynamic_sections (abfd
, info
))
1627 dynobj
= (elf_hash_table (info
))->dynobj
;
1631 ds
.sgot
= htab
->sgot
;
1632 ds
.srelgot
= htab
->srelgot
;
1634 ds
.sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
1635 ds
.srelgotplt
= ds
.srelplt
;
1637 ds
.splt
= bfd_get_section_by_name (dynobj
, ".plt");
1638 ds
.srelplt
= bfd_get_section_by_name (dynobj
, ".rela.plt");
1641 if (htab
->dynamic_sections_created
)
1643 ds
.sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
1646 ds
.initialized
= TRUE
;
1652 elf_arc_check_relocs (bfd
* abfd
,
1653 struct bfd_link_info
* info
,
1655 const Elf_Internal_Rela
* relocs
)
1657 Elf_Internal_Shdr
* symtab_hdr
;
1658 struct elf_link_hash_entry
** sym_hashes
;
1659 const Elf_Internal_Rela
* rel
;
1660 const Elf_Internal_Rela
* rel_end
;
1662 asection
* sreloc
= NULL
;
1664 if (bfd_link_relocatable (info
))
1667 dynobj
= (elf_hash_table (info
))->dynobj
;
1668 symtab_hdr
= &((elf_tdata (abfd
))->symtab_hdr
);
1669 sym_hashes
= elf_sym_hashes (abfd
);
1671 rel_end
= relocs
+ sec
->reloc_count
;
1672 for (rel
= relocs
; rel
< rel_end
; rel
++)
1674 enum elf_arc_reloc_type r_type
;
1675 reloc_howto_type
*howto
;
1676 unsigned long r_symndx
;
1677 struct elf_link_hash_entry
*h
;
1679 r_type
= ELF32_R_TYPE (rel
->r_info
);
1681 if (r_type
>= (int) R_ARC_max
)
1683 bfd_set_error (bfd_error_bad_value
);
1686 howto
= arc_elf_howto (r_type
);
1689 && (is_reloc_for_GOT (howto
) == TRUE
1690 || is_reloc_for_TLS (howto
) == TRUE
))
1692 dynobj
= elf_hash_table (info
)->dynobj
= abfd
;
1693 if (! _bfd_elf_create_got_section (abfd
, info
))
1697 /* Load symbol information. */
1698 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1699 if (r_symndx
< symtab_hdr
->sh_info
) /* Is a local symbol. */
1701 else /* Global one. */
1702 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1708 /* During shared library creation, these relocs should not
1709 appear in a shared library (as memory will be read only
1710 and the dynamic linker can not resolve these. However
1711 the error should not occur for e.g. debugging or
1712 non-readonly sections. */
1713 if ((bfd_link_dll (info
) && !bfd_link_pie (info
))
1714 && (sec
->flags
& SEC_ALLOC
) != 0
1715 && (sec
->flags
& SEC_READONLY
) != 0
1716 && ((sec
->flags
& SEC_CODE
) != 0
1717 || (sec
->flags
& SEC_DEBUGGING
) != 0))
1721 name
= h
->root
.root
.string
;
1723 /* bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL); */
1727 %B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1729 arc_elf_howto (r_type
)->name
,
1731 bfd_set_error (bfd_error_bad_value
);
1735 /* In some cases we are not setting the 'non_got_ref'
1736 flag, even though the relocations don't require a GOT
1737 access. We should extend the testing in this area to
1738 ensure that no significant cases are being missed. */
1743 case R_ARC_32_PCREL
:
1744 if ((bfd_link_pic (info
))
1745 && ((r_type
!= R_ARC_PC32
&& r_type
!= R_ARC_32_PCREL
)
1747 && (!info
->symbolic
|| !h
->def_regular
))))
1751 sreloc
= _bfd_elf_make_dynamic_reloc_section (sec
, dynobj
,
1759 sreloc
->size
+= sizeof (Elf32_External_Rela
);
1766 if (is_reloc_for_PLT (howto
) == TRUE
)
1774 /* Add info to the symbol got_entry_list. */
1775 if (is_reloc_for_GOT (howto
) == TRUE
1776 || is_reloc_for_TLS (howto
) == TRUE
)
1778 arc_fill_got_info_for_reloc (
1779 arc_got_entry_type_for_reloc (howto
),
1780 get_got_entry_list_for_symbol (abfd
, r_symndx
, h
),
1789 #define ELF_DYNAMIC_INTERPRETER "/sbin/ld-uClibc.so"
1791 static struct plt_version_t
*
1792 arc_get_plt_version (struct bfd_link_info
*info
)
1796 for (i
= 0; i
< 1; i
++)
1798 ARC_DEBUG ("%d: size1 = %d, size2 = %d\n", i
,
1799 (int) plt_versions
[i
].entry_size
,
1800 (int) plt_versions
[i
].elem_size
);
1803 if (bfd_get_mach (info
->output_bfd
) == bfd_mach_arc_arcv2
)
1805 if (bfd_link_pic (info
))
1806 return &(plt_versions
[ELF_ARCV2_PIC
]);
1808 return &(plt_versions
[ELF_ARCV2_ABS
]);
1812 if (bfd_link_pic (info
))
1813 return &(plt_versions
[ELF_ARC_PIC
]);
1815 return &(plt_versions
[ELF_ARC_ABS
]);
1820 add_symbol_to_plt (struct bfd_link_info
*info
)
1822 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
1825 struct plt_version_t
*plt_data
= arc_get_plt_version (info
);
1827 /* If this is the first .plt entry, make room for the special first
1829 if (htab
->splt
->size
== 0)
1830 htab
->splt
->size
+= plt_data
->entry_size
;
1832 ret
= htab
->splt
->size
;
1834 htab
->splt
->size
+= plt_data
->elem_size
;
1835 ARC_DEBUG ("PLT_SIZE = %d\n", (int) htab
->splt
->size
);
1837 htab
->sgotplt
->size
+= 4;
1838 htab
->srelplt
->size
+= sizeof (Elf32_External_Rela
);
1843 #define PLT_DO_RELOCS_FOR_ENTRY(ABFD, DS, RELOCS) \
1844 plt_do_relocs_for_symbol (ABFD, DS, RELOCS, 0, 0)
1847 plt_do_relocs_for_symbol (bfd
*abfd
,
1848 struct elf_link_hash_table
*htab
,
1849 const struct plt_reloc
*reloc
,
1851 bfd_vma symbol_got_offset
)
1853 while (SYM_ONLY (reloc
->symbol
) != LAST_RELOC
)
1855 bfd_vma relocation
= 0;
1857 switch (SYM_ONLY (reloc
->symbol
))
1861 = htab
->sgotplt
->output_section
->vma
1862 + htab
->sgotplt
->output_offset
+ symbol_got_offset
;
1865 relocation
+= reloc
->addend
;
1867 if (IS_RELATIVE (reloc
->symbol
))
1869 bfd_vma reloc_offset
= reloc
->offset
;
1870 reloc_offset
-= (IS_INSN_32 (reloc
->symbol
)) ? 4 : 0;
1871 reloc_offset
-= (IS_INSN_24 (reloc
->symbol
)) ? 2 : 0;
1873 relocation
-= htab
->splt
->output_section
->vma
1874 + htab
->splt
->output_offset
1875 + plt_offset
+ reloc_offset
;
1878 /* TODO: being ME is not a property of the relocation but of the
1879 section of which is applying the relocation. */
1880 if (IS_MIDDLE_ENDIAN (reloc
->symbol
) && !bfd_big_endian (abfd
))
1883 = ((relocation
& 0xffff0000) >> 16)
1884 | ((relocation
& 0xffff) << 16);
1887 switch (reloc
->size
)
1890 bfd_put_32 (htab
->splt
->output_section
->owner
,
1892 htab
->splt
->contents
+ plt_offset
+ reloc
->offset
);
1896 reloc
= &(reloc
[1]); /* Jump to next relocation. */
1901 relocate_plt_for_symbol (bfd
*output_bfd
,
1902 struct bfd_link_info
*info
,
1903 struct elf_link_hash_entry
*h
)
1905 struct plt_version_t
*plt_data
= arc_get_plt_version (info
);
1906 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
1908 bfd_vma plt_index
= (h
->plt
.offset
- plt_data
->entry_size
)
1909 / plt_data
->elem_size
;
1910 bfd_vma got_offset
= (plt_index
+ 3) * 4;
1912 ARC_DEBUG ("arc_info: PLT_OFFSET = %#lx, PLT_ENTRY_VMA = %#lx, \
1913 GOT_ENTRY_OFFSET = %#lx, GOT_ENTRY_VMA = %#lx, for symbol %s\n",
1914 (long) h
->plt
.offset
,
1915 (long) (htab
->splt
->output_section
->vma
1916 + htab
->splt
->output_offset
1919 (long) (htab
->sgotplt
->output_section
->vma
1920 + htab
->sgotplt
->output_offset
1922 h
->root
.root
.string
);
1926 uint16_t *ptr
= (uint16_t *) plt_data
->elem
;
1928 for (i
= 0; i
< plt_data
->elem_size
/2; i
++)
1930 uint16_t data
= ptr
[i
];
1931 bfd_put_16 (output_bfd
,
1933 htab
->splt
->contents
+ h
->plt
.offset
+ (i
*2));
1937 plt_do_relocs_for_symbol (output_bfd
, htab
,
1938 plt_data
->elem_relocs
,
1942 /* Fill in the entry in the global offset table. */
1943 bfd_put_32 (output_bfd
,
1944 (bfd_vma
) (htab
->splt
->output_section
->vma
1945 + htab
->splt
->output_offset
),
1946 htab
->sgotplt
->contents
+ got_offset
);
1948 /* TODO: Fill in the entry in the .rela.plt section. */
1950 Elf_Internal_Rela rel
;
1953 rel
.r_offset
= (htab
->sgotplt
->output_section
->vma
1954 + htab
->sgotplt
->output_offset
1958 BFD_ASSERT (h
->dynindx
!= -1);
1959 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARC_JMP_SLOT
);
1961 loc
= htab
->srelplt
->contents
;
1962 loc
+= plt_index
* sizeof (Elf32_External_Rela
); /* relA */
1963 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
1968 relocate_plt_for_entry (bfd
*abfd
,
1969 struct bfd_link_info
*info
)
1971 struct plt_version_t
*plt_data
= arc_get_plt_version (info
);
1972 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
1976 uint16_t *ptr
= (uint16_t *) plt_data
->entry
;
1977 for (i
= 0; i
< plt_data
->entry_size
/2; i
++)
1979 uint16_t data
= ptr
[i
];
1982 htab
->splt
->contents
+ (i
*2));
1985 PLT_DO_RELOCS_FOR_ENTRY (abfd
, htab
, plt_data
->entry_relocs
);
1988 /* Desc : Adjust a symbol defined by a dynamic object and referenced
1989 by a regular object. The current definition is in some section of
1990 the dynamic object, but we're not including those sections. We
1991 have to change the definition to something the rest of the link can
1995 elf_arc_adjust_dynamic_symbol (struct bfd_link_info
*info
,
1996 struct elf_link_hash_entry
*h
)
1999 bfd
*dynobj
= (elf_hash_table (info
))->dynobj
;
2000 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2002 if (h
->type
== STT_FUNC
2003 || h
->type
== STT_GNU_IFUNC
2004 || h
->needs_plt
== 1)
2006 if (!bfd_link_pic (info
) && !h
->def_dynamic
&& !h
->ref_dynamic
)
2008 /* This case can occur if we saw a PLT32 reloc in an input
2009 file, but the symbol was never referred to by a dynamic
2010 object. In such a case, we don't actually need to build
2011 a procedure linkage table, and we can just do a PC32
2013 BFD_ASSERT (h
->needs_plt
);
2017 /* Make sure this symbol is output as a dynamic symbol. */
2018 if (h
->dynindx
== -1 && !h
->forced_local
2019 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
2022 if (bfd_link_pic (info
)
2023 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2025 bfd_vma loc
= add_symbol_to_plt (info
);
2027 if (bfd_link_executable (info
) && !h
->def_regular
)
2029 h
->root
.u
.def
.section
= htab
->splt
;
2030 h
->root
.u
.def
.value
= loc
;
2032 h
->plt
.offset
= loc
;
2036 h
->plt
.offset
= (bfd_vma
) -1;
2042 /* If this is a weak symbol, and there is a real definition, the
2043 processor independent code will have arranged for us to see the
2044 real definition first, and we can just use the same value. */
2045 if (h
->u
.weakdef
!= NULL
)
2047 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2048 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2049 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2050 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2054 /* This is a reference to a symbol defined by a dynamic object which
2055 is not a function. */
2057 /* If we are creating a shared library, we must presume that the
2058 only references to the symbol are via the global offset table.
2059 For such cases we need not do anything here; the relocations will
2060 be handled correctly by relocate_section. */
2061 if (!bfd_link_executable (info
))
2064 /* If there are no non-GOT references, we do not need a copy
2066 if (!h
->non_got_ref
)
2069 /* If -z nocopyreloc was given, we won't generate them either. */
2070 if (info
->nocopyreloc
)
2076 /* We must allocate the symbol in our .dynbss section, which will
2077 become part of the .bss section of the executable. There will be
2078 an entry for this symbol in the .dynsym section. The dynamic
2079 object will contain position independent code, so all references
2080 from the dynamic object to this symbol will go through the global
2081 offset table. The dynamic linker will use the .dynsym entry to
2082 determine the address it must put in the global offset table, so
2083 both the dynamic object and the regular object will refer to the
2084 same memory location for the variable. */
2089 /* We must generate a R_ARC_COPY reloc to tell the dynamic linker to
2090 copy the initial value out of the dynamic object and into the
2091 runtime process image. We need to remember the offset into the
2092 .rela.bss section we are going to use. */
2093 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
2095 struct elf_arc_link_hash_table
*arc_htab
= elf_arc_hash_table (info
);
2097 BFD_ASSERT (arc_htab
->srelbss
!= NULL
);
2098 arc_htab
->srelbss
->size
+= sizeof (Elf32_External_Rela
);
2102 /* TODO: Move this also to arc_hash_table. */
2103 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
2104 BFD_ASSERT (s
!= NULL
);
2106 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2109 /* Function : elf_arc_finish_dynamic_symbol
2110 Brief : Finish up dynamic symbol handling. We set the
2111 contents of various dynamic sections here.
2116 Returns : True/False as the return status. */
2119 elf_arc_finish_dynamic_symbol (bfd
* output_bfd
,
2120 struct bfd_link_info
*info
,
2121 struct elf_link_hash_entry
*h
,
2122 Elf_Internal_Sym
* sym
)
2124 if (h
->plt
.offset
!= (bfd_vma
) -1)
2126 relocate_plt_for_symbol (output_bfd
, info
, h
);
2128 if (!h
->def_regular
)
2130 /* Mark the symbol as undefined, rather than as defined in
2131 the .plt section. Leave the value alone. */
2132 sym
->st_shndx
= SHN_UNDEF
;
2137 /* This function traverses list of GOT entries and
2138 create respective dynamic relocs. */
2139 /* TODO: Make function to get list and not access the list directly. */
2140 /* TODO: Move function to relocate_section create this relocs eagerly. */
2141 create_got_dynrelocs_for_got_info (&h
->got
.glist
,
2148 struct elf_arc_link_hash_table
*arc_htab
= elf_arc_hash_table (info
);
2150 if (h
->dynindx
== -1
2151 || (h
->root
.type
!= bfd_link_hash_defined
2152 && h
->root
.type
!= bfd_link_hash_defweak
)
2153 || arc_htab
->srelbss
== NULL
)
2156 bfd_vma rel_offset
= (h
->root
.u
.def
.value
2157 + h
->root
.u
.def
.section
->output_section
->vma
2158 + h
->root
.u
.def
.section
->output_offset
);
2160 bfd_byte
* loc
= arc_htab
->srelbss
->contents
2161 + (arc_htab
->srelbss
->reloc_count
* sizeof (Elf32_External_Rela
));
2162 arc_htab
->srelbss
->reloc_count
++;
2164 Elf_Internal_Rela rel
;
2166 rel
.r_offset
= rel_offset
;
2168 BFD_ASSERT (h
->dynindx
!= -1);
2169 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARC_COPY
);
2171 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
2174 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2175 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2176 || strcmp (h
->root
.root
.string
, "__DYNAMIC") == 0
2177 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
2178 sym
->st_shndx
= SHN_ABS
;
2183 #define GET_SYMBOL_OR_SECTION(TAG, SYMBOL, SECTION) \
2185 if (SYMBOL != NULL) \
2186 h = elf_link_hash_lookup (elf_hash_table (info), \
2187 SYMBOL, FALSE, FALSE, TRUE); \
2188 else if (SECTION != NULL) \
2189 s = bfd_get_linker_section (dynobj, SECTION); \
2192 /* Function : elf_arc_finish_dynamic_sections
2193 Brief : Finish up the dynamic sections handling.
2198 Returns : True/False as the return status. */
2201 elf_arc_finish_dynamic_sections (bfd
* output_bfd
,
2202 struct bfd_link_info
*info
)
2204 struct dynamic_sections ds
= arc_create_dynamic_sections (output_bfd
, info
);
2205 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2206 bfd
*dynobj
= (elf_hash_table (info
))->dynobj
;
2210 Elf32_External_Dyn
*dyncon
, *dynconend
;
2212 dyncon
= (Elf32_External_Dyn
*) ds
.sdyn
->contents
;
2214 = (Elf32_External_Dyn
*) (ds
.sdyn
->contents
+ ds
.sdyn
->size
);
2215 for (; dyncon
< dynconend
; dyncon
++)
2217 Elf_Internal_Dyn internal_dyn
;
2218 bfd_boolean do_it
= FALSE
;
2220 struct elf_link_hash_entry
*h
= NULL
;
2223 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &internal_dyn
);
2225 switch (internal_dyn
.d_tag
)
2227 GET_SYMBOL_OR_SECTION (DT_INIT
, info
->init_function
, NULL
)
2228 GET_SYMBOL_OR_SECTION (DT_FINI
, info
->fini_function
, NULL
)
2229 GET_SYMBOL_OR_SECTION (DT_PLTGOT
, NULL
, ".plt")
2230 GET_SYMBOL_OR_SECTION (DT_JMPREL
, NULL
, ".rela.plt")
2231 GET_SYMBOL_OR_SECTION (DT_PLTRELSZ
, NULL
, ".rela.plt")
2232 GET_SYMBOL_OR_SECTION (DT_RELASZ
, NULL
, ".rela.plt")
2233 GET_SYMBOL_OR_SECTION (DT_VERSYM
, NULL
, ".gnu.version")
2234 GET_SYMBOL_OR_SECTION (DT_VERDEF
, NULL
, ".gnu.version_d")
2235 GET_SYMBOL_OR_SECTION (DT_VERNEED
, NULL
, ".gnu.version_r")
2240 /* In case the dynamic symbols should be updated with a symbol. */
2242 && (h
->root
.type
== bfd_link_hash_defined
2243 || h
->root
.type
== bfd_link_hash_defweak
))
2247 internal_dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
2248 asec_ptr
= h
->root
.u
.def
.section
;
2249 if (asec_ptr
->output_section
!= NULL
)
2251 internal_dyn
.d_un
.d_val
+=
2252 (asec_ptr
->output_section
->vma
2253 + asec_ptr
->output_offset
);
2257 /* The symbol is imported from another shared
2258 library and does not apply to this one. */
2259 internal_dyn
.d_un
.d_val
= 0;
2263 else if (s
!= NULL
) /* With a section information. */
2265 switch (internal_dyn
.d_tag
)
2272 internal_dyn
.d_un
.d_ptr
= (s
->output_section
->vma
2273 + s
->output_offset
);
2278 internal_dyn
.d_un
.d_val
= s
->size
;
2284 internal_dyn
.d_un
.d_val
-= s
->size
;
2294 bfd_elf32_swap_dyn_out (output_bfd
, &internal_dyn
, dyncon
);
2297 if (htab
->splt
->size
> 0)
2299 relocate_plt_for_entry (output_bfd
, info
);
2302 /* TODO: Validate this. */
2303 elf_section_data (htab
->srelplt
->output_section
)->this_hdr
.sh_entsize
2307 /* Fill in the first three entries in the global offset table. */
2310 struct elf_link_hash_entry
*h
;
2311 h
= elf_link_hash_lookup (elf_hash_table (info
), "_GLOBAL_OFFSET_TABLE_",
2312 FALSE
, FALSE
, TRUE
);
2314 if (h
!= NULL
&& h
->root
.type
!= bfd_link_hash_undefined
2315 && h
->root
.u
.def
.section
!= NULL
)
2317 asection
*sec
= h
->root
.u
.def
.section
;
2319 if (ds
.sdyn
== NULL
)
2320 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
2323 bfd_put_32 (output_bfd
,
2324 ds
.sdyn
->output_section
->vma
+ ds
.sdyn
->output_offset
,
2326 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sec
->contents
+ 4);
2327 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sec
->contents
+ 8);
2334 #define ADD_DYNAMIC_SYMBOL(NAME, TAG) \
2335 h = elf_link_hash_lookup (elf_hash_table (info), \
2336 NAME, FALSE, FALSE, FALSE); \
2337 if ((h != NULL && (h->ref_regular || h->def_regular))) \
2338 if (! _bfd_elf_add_dynamic_entry (info, TAG, 0)) \
2341 /* Set the sizes of the dynamic sections. */
2343 elf_arc_size_dynamic_sections (bfd
* output_bfd
,
2344 struct bfd_link_info
*info
)
2348 bfd_boolean relocs_exist
= FALSE
;
2349 bfd_boolean reltext_exist
= FALSE
;
2350 struct dynamic_sections ds
= arc_create_dynamic_sections (output_bfd
, info
);
2351 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2353 dynobj
= (elf_hash_table (info
))->dynobj
;
2354 BFD_ASSERT (dynobj
!= NULL
);
2356 if ((elf_hash_table (info
))->dynamic_sections_created
)
2358 struct elf_link_hash_entry
*h
;
2360 /* Set the contents of the .interp section to the
2362 if (!bfd_link_pic (info
))
2364 s
= bfd_get_section_by_name (dynobj
, ".interp");
2365 BFD_ASSERT (s
!= NULL
);
2366 s
->size
= sizeof (ELF_DYNAMIC_INTERPRETER
);
2367 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2370 /* Add some entries to the .dynamic section. We fill in some of
2371 the values later, in elf_bfd_final_link, but we must add the
2372 entries now so that we know the final size of the .dynamic
2373 section. Checking if the .init section is present. We also
2374 create DT_INIT and DT_FINI entries if the init_str has been
2375 changed by the user. */
2376 ADD_DYNAMIC_SYMBOL (info
->init_function
, DT_INIT
);
2377 ADD_DYNAMIC_SYMBOL (info
->fini_function
, DT_FINI
);
2381 /* We may have created entries in the .rela.got section.
2382 However, if we are not creating the dynamic sections, we will
2383 not actually use these entries. Reset the size of .rela.got,
2384 which will cause it to get stripped from the output file
2386 if (htab
->srelgot
!= NULL
)
2387 htab
->srelgot
->size
= 0;
2390 if (htab
->splt
!= NULL
&& htab
->splt
->size
== 0)
2391 htab
->splt
->flags
|= SEC_EXCLUDE
;
2392 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2394 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2397 if (strncmp (s
->name
, ".rela", 5) == 0)
2401 s
->flags
|= SEC_EXCLUDE
;
2405 if (strcmp (s
->name
, ".rela.plt") != 0)
2407 const char *outname
=
2408 bfd_get_section_name (output_bfd
,
2409 htab
->srelplt
->output_section
);
2411 asection
*target
= bfd_get_section_by_name (output_bfd
,
2414 relocs_exist
= TRUE
;
2415 if (target
!= NULL
&& target
->size
!= 0
2416 && (target
->flags
& SEC_READONLY
) != 0
2417 && (target
->flags
& SEC_ALLOC
) != 0)
2418 reltext_exist
= TRUE
;
2422 /* We use the reloc_count field as a counter if we need to
2423 copy relocs into the output file. */
2427 if (strcmp (s
->name
, ".dynamic") == 0)
2431 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
2433 if (s
->contents
== NULL
&& s
->size
!= 0)
2439 /* TODO: Check if this is needed. */
2440 if (!bfd_link_pic (info
))
2441 if (!_bfd_elf_add_dynamic_entry (info
, DT_DEBUG
, 0))
2444 if (htab
->splt
&& (htab
->splt
->flags
& SEC_EXCLUDE
) == 0)
2445 if (!_bfd_elf_add_dynamic_entry (info
, DT_PLTGOT
, 0)
2446 || !_bfd_elf_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
2447 || !_bfd_elf_add_dynamic_entry (info
, DT_PLTREL
, DT_RELA
)
2448 || !_bfd_elf_add_dynamic_entry (info
, DT_JMPREL
, 0)
2452 if (relocs_exist
== TRUE
)
2453 if (!_bfd_elf_add_dynamic_entry (info
, DT_RELA
, 0)
2454 || !_bfd_elf_add_dynamic_entry (info
, DT_RELASZ
, 0)
2455 || !_bfd_elf_add_dynamic_entry (info
, DT_RELAENT
,
2456 sizeof (Elf32_External_Rela
))
2460 if (reltext_exist
== TRUE
)
2461 if (!_bfd_elf_add_dynamic_entry (info
, DT_TEXTREL
, 0))
2469 /* Classify dynamic relocs such that -z combreloc can reorder and combine
2471 static enum elf_reloc_type_class
2472 elf32_arc_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2473 const asection
*rel_sec ATTRIBUTE_UNUSED
,
2474 const Elf_Internal_Rela
*rela
)
2476 switch ((int) ELF32_R_TYPE (rela
->r_info
))
2478 case R_ARC_RELATIVE
:
2479 return reloc_class_relative
;
2480 case R_ARC_JMP_SLOT
:
2481 return reloc_class_plt
;
2483 return reloc_class_copy
;
2484 /* TODO: Needed in future to support ifunc. */
2486 case R_ARC_IRELATIVE:
2487 return reloc_class_ifunc;
2490 return reloc_class_normal
;
2494 const struct elf_size_info arc_elf32_size_info
=
2496 sizeof (Elf32_External_Ehdr
),
2497 sizeof (Elf32_External_Phdr
),
2498 sizeof (Elf32_External_Shdr
),
2499 sizeof (Elf32_External_Rel
),
2500 sizeof (Elf32_External_Rela
),
2501 sizeof (Elf32_External_Sym
),
2502 sizeof (Elf32_External_Dyn
),
2503 sizeof (Elf_External_Note
),
2507 ELFCLASS32
, EV_CURRENT
,
2508 bfd_elf32_write_out_phdrs
,
2509 bfd_elf32_write_shdrs_and_ehdr
,
2510 bfd_elf32_checksum_contents
,
2511 bfd_elf32_write_relocs
,
2512 bfd_elf32_swap_symbol_in
,
2513 bfd_elf32_swap_symbol_out
,
2514 bfd_elf32_slurp_reloc_table
,
2515 bfd_elf32_slurp_symbol_table
,
2516 bfd_elf32_swap_dyn_in
,
2517 bfd_elf32_swap_dyn_out
,
2518 bfd_elf32_swap_reloc_in
,
2519 bfd_elf32_swap_reloc_out
,
2520 bfd_elf32_swap_reloca_in
,
2521 bfd_elf32_swap_reloca_out
2524 #define elf_backend_size_info arc_elf32_size_info
2526 /* Hook called by the linker routine which adds symbols from an object
2530 elf_arc_add_symbol_hook (bfd
* abfd
,
2531 struct bfd_link_info
* info
,
2532 Elf_Internal_Sym
* sym
,
2533 const char ** namep ATTRIBUTE_UNUSED
,
2534 flagword
* flagsp ATTRIBUTE_UNUSED
,
2535 asection
** secp ATTRIBUTE_UNUSED
,
2536 bfd_vma
* valp ATTRIBUTE_UNUSED
)
2538 if (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
2539 && (abfd
->flags
& DYNAMIC
) == 0
2540 && bfd_get_flavour (info
->output_bfd
) == bfd_target_elf_flavour
)
2541 elf_tdata (info
->output_bfd
)->has_gnu_symbols
|= elf_gnu_symbol_ifunc
;
2546 /* GDB expects general purpose registers to be in section .reg. However Linux
2547 kernel doesn't create this section and instead writes registers to NOTE
2548 section. It is up to the binutils to create a pseudo-section .reg from the
2549 contents of NOTE. Also BFD will read pid and signal number from NOTE. This
2550 function relies on offsets inside elf_prstatus structure in Linux to be
2554 elf32_arc_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
2559 switch (note
->descsz
)
2564 case 236: /* sizeof (struct elf_prstatus) on Linux/arc. */
2566 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
2568 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
2571 size
= (40 * 4); /* There are 40 registers in user_regs_struct. */
2574 /* Make a ".reg/999" section. */
2575 return _bfd_elfcore_make_pseudosection (abfd
, ".reg", size
,
2576 note
->descpos
+ offset
);
2579 #define TARGET_LITTLE_SYM arc_elf32_le_vec
2580 #define TARGET_LITTLE_NAME "elf32-littlearc"
2581 #define TARGET_BIG_SYM arc_elf32_be_vec
2582 #define TARGET_BIG_NAME "elf32-bigarc"
2583 #define ELF_ARCH bfd_arch_arc
2584 #define ELF_TARGET_ID ARC_ELF_DATA
2585 #define ELF_MACHINE_CODE EM_ARC_COMPACT
2586 #define ELF_MACHINE_ALT1 EM_ARC_COMPACT2
2587 #define ELF_MAXPAGESIZE 0x2000
2589 #define bfd_elf32_bfd_link_hash_table_create arc_elf_link_hash_table_create
2591 #define bfd_elf32_bfd_merge_private_bfd_data arc_elf_merge_private_bfd_data
2592 #define bfd_elf32_bfd_reloc_type_lookup arc_elf32_bfd_reloc_type_lookup
2593 #define bfd_elf32_bfd_set_private_flags arc_elf_set_private_flags
2594 #define bfd_elf32_bfd_print_private_bfd_data arc_elf_print_private_bfd_data
2595 #define bfd_elf32_bfd_copy_private_bfd_data arc_elf_copy_private_bfd_data
2597 #define elf_info_to_howto_rel arc_info_to_howto_rel
2598 #define elf_backend_object_p arc_elf_object_p
2599 #define elf_backend_final_write_processing arc_elf_final_write_processing
2601 #define elf_backend_relocate_section elf_arc_relocate_section
2602 #define elf_backend_check_relocs elf_arc_check_relocs
2603 #define elf_backend_create_dynamic_sections arc_elf_create_dynamic_sections
2605 #define elf_backend_reloc_type_class elf32_arc_reloc_type_class
2607 #define elf_backend_adjust_dynamic_symbol elf_arc_adjust_dynamic_symbol
2608 #define elf_backend_finish_dynamic_symbol elf_arc_finish_dynamic_symbol
2610 #define elf_backend_finish_dynamic_sections elf_arc_finish_dynamic_sections
2611 #define elf_backend_size_dynamic_sections elf_arc_size_dynamic_sections
2612 #define elf_backend_add_symbol_hook elf_arc_add_symbol_hook
2614 #define elf_backend_can_gc_sections 1
2615 #define elf_backend_want_got_plt 1
2616 #define elf_backend_plt_readonly 1
2617 #define elf_backend_rela_plts_and_copies_p 1
2618 #define elf_backend_want_plt_sym 0
2619 #define elf_backend_got_header_size 12
2621 #define elf_backend_may_use_rel_p 0
2622 #define elf_backend_may_use_rela_p 1
2623 #define elf_backend_default_use_rela_p 1
2625 #define elf_backend_grok_prstatus elf32_arc_grok_prstatus
2627 #define elf_backend_default_execstack 0
2629 #include "elf32-target.h"