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
, struct bfd_link_info
*info
)
547 bfd
*obfd
= info
->output_bfd
;
548 unsigned short mach_ibfd
;
549 static unsigned short mach_obfd
= EM_NONE
;
554 /* Check if we have the same endianess. */
555 if (! _bfd_generic_verify_endian_match (ibfd
, info
))
558 /* Collect ELF flags. */
559 in_flags
= elf_elfheader (ibfd
)->e_flags
& EF_ARC_MACH_MSK
;
560 out_flags
= elf_elfheader (obfd
)->e_flags
& EF_ARC_MACH_MSK
;
562 if (!elf_flags_init (obfd
)) /* First call, no flags set. */
564 elf_flags_init (obfd
) = TRUE
;
565 out_flags
= in_flags
;
568 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
569 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
572 /* Check to see if the input BFD actually contains any sections. Do
573 not short-circuit dynamic objects; their section list may be
574 emptied by elf_link_add_object_symbols. */
575 if (!(ibfd
->flags
& DYNAMIC
))
577 bfd_boolean null_input_bfd
= TRUE
;
578 bfd_boolean only_data_sections
= TRUE
;
580 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
582 if ((bfd_get_section_flags (ibfd
, sec
)
583 & (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
584 == (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
585 only_data_sections
= FALSE
;
587 null_input_bfd
= FALSE
;
590 if (null_input_bfd
|| only_data_sections
)
594 /* Complain about various flag/architecture mismatches. */
595 mach_ibfd
= elf_elfheader (ibfd
)->e_machine
;
596 if (mach_obfd
== EM_NONE
)
598 mach_obfd
= mach_ibfd
;
602 if (mach_ibfd
!= mach_obfd
)
604 _bfd_error_handler (_("ERROR: Attempting to link %B "
605 "with a binary %s of different architecture"),
606 ibfd
, bfd_get_filename (obfd
));
609 else if (in_flags
!= out_flags
)
611 /* Warn if different flags. */
613 (_("%s: uses different e_flags (0x%lx) fields than "
614 "previous modules (0x%lx)"),
615 bfd_get_filename (ibfd
), (long)in_flags
, (long)out_flags
);
616 if (in_flags
&& out_flags
)
618 /* MWDT doesnt set the eflags hence make sure we choose the
619 eflags set by gcc. */
620 in_flags
= in_flags
> out_flags
? in_flags
: out_flags
;
624 /* Update the flags. */
625 elf_elfheader (obfd
)->e_flags
= in_flags
;
627 if (bfd_get_mach (obfd
) < bfd_get_mach (ibfd
))
629 return bfd_set_arch_mach (obfd
, bfd_arch_arc
, bfd_get_mach (ibfd
));
635 /* Set the right machine number for an ARC ELF file. */
637 arc_elf_object_p (bfd
* abfd
)
639 /* Make sure this is initialised, or you'll have the potential of passing
640 garbage---or misleading values---into the call to
641 bfd_default_set_arch_mach (). */
642 int mach
= bfd_mach_arc_arc700
;
643 unsigned long arch
= elf_elfheader (abfd
)->e_flags
& EF_ARC_MACH_MSK
;
644 unsigned e_machine
= elf_elfheader (abfd
)->e_machine
;
646 if (e_machine
== EM_ARC_COMPACT
|| e_machine
== EM_ARC_COMPACT2
)
650 case E_ARC_MACH_ARC600
:
651 mach
= bfd_mach_arc_arc600
;
653 case E_ARC_MACH_ARC601
:
654 mach
= bfd_mach_arc_arc601
;
656 case E_ARC_MACH_ARC700
:
657 mach
= bfd_mach_arc_arc700
;
659 case EF_ARC_CPU_ARCV2HS
:
660 case EF_ARC_CPU_ARCV2EM
:
661 mach
= bfd_mach_arc_arcv2
;
664 mach
= (e_machine
== EM_ARC_COMPACT
)
665 ? bfd_mach_arc_arc700
: bfd_mach_arc_arcv2
;
671 if (e_machine
== EM_ARC
)
674 (_("Error: The ARC4 architecture is no longer supported.\n"));
680 (_("Warning: unset or old architecture flags. \n"
681 " Use default machine.\n"));
685 return bfd_default_set_arch_mach (abfd
, bfd_arch_arc
, mach
);
688 /* The final processing done just before writing out an ARC ELF object file.
689 This gets the ARC architecture right based on the machine number. */
692 arc_elf_final_write_processing (bfd
* abfd
,
693 bfd_boolean linker ATTRIBUTE_UNUSED
)
697 switch (bfd_get_mach (abfd
))
699 case bfd_mach_arc_arc600
:
700 emf
= EM_ARC_COMPACT
;
702 case bfd_mach_arc_arc601
:
703 emf
= EM_ARC_COMPACT
;
705 case bfd_mach_arc_arc700
:
706 emf
= EM_ARC_COMPACT
;
708 case bfd_mach_arc_arcv2
:
709 emf
= EM_ARC_COMPACT2
;
715 elf_elfheader (abfd
)->e_machine
= emf
;
717 /* Record whatever is the current syscall ABI version. */
718 elf_elfheader (abfd
)->e_flags
|= E_ARC_OSABI_CURRENT
;
724 #ifdef ARC_ENABLE_DEBUG
725 #define DEBUG_ARC_RELOC(A) debug_arc_reloc (A)
728 debug_arc_reloc (struct arc_relocation_data reloc_data
)
730 ARC_DEBUG ("Reloc type=%s, should_relocate = %s\n",
731 reloc_data
.howto
->name
,
732 reloc_data
.should_relocate
? "true" : "false");
733 ARC_DEBUG (" offset = 0x%x, addend = 0x%x\n",
734 (unsigned int) reloc_data
.reloc_offset
,
735 (unsigned int) reloc_data
.reloc_addend
);
736 ARC_DEBUG (" Symbol:\n");
737 ARC_DEBUG (" value = 0x%08x\n",
738 (unsigned int) reloc_data
.sym_value
);
739 if (reloc_data
.sym_section
!= NULL
)
741 ARC_DEBUG (" Symbol Section:\n");
742 ARC_DEBUG (" section name = %s, output_offset 0x%08x",
743 reloc_data
.sym_section
->name
,
744 (unsigned int) reloc_data
.sym_section
->output_offset
);
745 if (reloc_data
.sym_section
->output_section
!= NULL
)
746 ARC_DEBUG (", output_section->vma = 0x%08x",
747 ((unsigned int) reloc_data
.sym_section
->output_section
->vma
));
749 if (reloc_data
.sym_section
->owner
&& reloc_data
.sym_section
->owner
->filename
)
750 ARC_DEBUG (" file: %s\n", reloc_data
.sym_section
->owner
->filename
);
754 ARC_DEBUG (" symbol section is NULL\n");
757 ARC_DEBUG (" Input_section:\n");
758 if (reloc_data
.input_section
!= NULL
)
760 ARC_DEBUG (" section name = %s, output_offset 0x%08x, output_section->vma = 0x%08x\n",
761 reloc_data
.input_section
->name
,
762 (unsigned int) reloc_data
.input_section
->output_offset
,
763 (unsigned int) reloc_data
.input_section
->output_section
->vma
);
764 ARC_DEBUG (" changed_address = 0x%08x\n",
765 (unsigned int) (reloc_data
.input_section
->output_section
->vma
766 + reloc_data
.input_section
->output_offset
767 + reloc_data
.reloc_offset
));
768 ARC_DEBUG (" file: %s\n", reloc_data
.input_section
->owner
->filename
);
772 ARC_DEBUG (" input section is NULL\n");
776 #define DEBUG_ARC_RELOC(A)
777 #endif /* ARC_ENABLE_DEBUG */
780 middle_endian_convert (bfd_vma insn
, bfd_boolean do_it
)
785 = ((insn
& 0xffff0000) >> 16)
786 | ((insn
& 0xffff) << 16);
791 /* This function is called for relocations that are otherwise marked as NOT
792 requiring overflow checks. In here we perform non-standard checks of
793 the relocation value. */
795 static inline bfd_reloc_status_type
796 arc_special_overflow_checks (const struct arc_relocation_data reloc_data
,
797 bfd_signed_vma relocation
,
798 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
800 switch (reloc_data
.howto
->type
)
802 case R_ARC_NPS_CMEM16
:
803 if (((relocation
>> 16) & 0xffff) != NPS_CMEM_HIGH_VALUE
)
805 if (reloc_data
.reloc_addend
== 0)
807 (_("%B(%A+0x%lx): CMEM relocation to `%s' is invalid, "
808 "16 MSB should be 0x%04x (value is 0x%lx)"),
809 reloc_data
.input_section
->owner
,
810 reloc_data
.input_section
,
811 reloc_data
.reloc_offset
,
812 reloc_data
.symbol_name
,
817 (_("%B(%A+0x%lx): CMEM relocation to `%s+0x%lx' is invalid, "
818 "16 MSB should be 0x%04x (value is 0x%lx)"),
819 reloc_data
.input_section
->owner
,
820 reloc_data
.input_section
,
821 reloc_data
.reloc_offset
,
822 reloc_data
.symbol_name
,
823 reloc_data
.reloc_addend
,
826 return bfd_reloc_overflow
;
837 #define ME(reloc) (reloc)
839 #define IS_ME(FORMULA,BFD) ((strstr (FORMULA, "ME") != NULL) \
840 && (!bfd_big_endian (BFD)))
842 #define S ((bfd_signed_vma) (reloc_data.sym_value \
843 + (reloc_data.sym_section->output_section != NULL ? \
844 (reloc_data.sym_section->output_offset \
845 + reloc_data.sym_section->output_section->vma) : 0)))
846 #define L ((bfd_signed_vma) (reloc_data.sym_value \
847 + (reloc_data.sym_section->output_section != NULL ? \
848 (reloc_data.sym_section->output_offset \
849 + reloc_data.sym_section->output_section->vma) : 0)))
850 #define A (reloc_data.reloc_addend)
852 #define G (reloc_data.got_offset_value)
853 #define GOT (reloc_data.got_symbol_vma)
854 #define GOT_BEGIN (htab->sgot->output_section->vma)
857 /* P: relative offset to PCL The offset should be to the
858 current location aligned to 32 bits. */
859 #define P ((bfd_signed_vma) ( \
861 (reloc_data.input_section->output_section != NULL ? \
862 reloc_data.input_section->output_section->vma : 0) \
863 + reloc_data.input_section->output_offset \
864 + (reloc_data.reloc_offset - (bitsize >= 32 ? 4 : 0))) \
866 #define PDATA ((bfd_signed_vma) ( \
867 (reloc_data.input_section->output_section->vma \
868 + reloc_data.input_section->output_offset \
869 + (reloc_data.reloc_offset))))
870 #define SECTSTART (bfd_signed_vma) (reloc_data.sym_section->output_section->vma \
871 + reloc_data.sym_section->output_offset)
873 #define _SDA_BASE_ (bfd_signed_vma) (reloc_data.sdata_begin_symbol_vma)
874 #define TLS_REL (bfd_signed_vma) \
875 ((elf_hash_table (info))->tls_sec->output_section->vma)
881 #ifdef ARC_ENABLE_DEBUG
882 #define PRINT_DEBUG_RELOC_INFO_BEFORE(FORMULA, TYPE) \
885 asection *sym_section = reloc_data.sym_section; \
886 asection *input_section = reloc_data.input_section; \
887 ARC_DEBUG ("RELOC_TYPE = " TYPE "\n"); \
888 ARC_DEBUG ("FORMULA = " FORMULA "\n"); \
889 ARC_DEBUG ("S = %#lx\n", S); \
890 ARC_DEBUG ("A = %#lx\n", A); \
891 ARC_DEBUG ("L = %lx\n", L); \
892 if (sym_section->output_section != NULL) \
893 ARC_DEBUG ("symbol_section->vma = %#lx\n", \
894 sym_section->output_section->vma \
895 + sym_section->output_offset); \
897 ARC_DEBUG ("symbol_section->vma = NULL\n"); \
898 if (input_section->output_section != NULL) \
899 ARC_DEBUG ("symbol_section->vma = %#lx\n", \
900 input_section->output_section->vma \
901 + input_section->output_offset); \
903 ARC_DEBUG ("symbol_section->vma = NULL\n"); \
904 ARC_DEBUG ("PCL = %#lx\n", P); \
905 ARC_DEBUG ("P = %#lx\n", P); \
906 ARC_DEBUG ("G = %#lx\n", G); \
907 ARC_DEBUG ("SDA_OFFSET = %#lx\n", _SDA_BASE_); \
908 ARC_DEBUG ("SDA_SET = %d\n", reloc_data.sdata_begin_symbol_vma_set); \
909 ARC_DEBUG ("GOT_OFFSET = %#lx\n", GOT); \
910 ARC_DEBUG ("relocation = %#08lx\n", relocation); \
911 ARC_DEBUG ("before = %#08x\n", (unsigned) insn); \
912 ARC_DEBUG ("data = %08x (%u) (%d)\n", (unsigned) relocation, \
913 (unsigned) relocation, (int) relocation); \
917 #define PRINT_DEBUG_RELOC_INFO_AFTER \
920 ARC_DEBUG ("after = 0x%08x\n", (unsigned int) insn); \
926 #define PRINT_DEBUG_RELOC_INFO_BEFORE(...)
927 #define PRINT_DEBUG_RELOC_INFO_AFTER
929 #endif /* ARC_ENABLE_DEBUG */
931 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
934 bfd_signed_vma bitsize ATTRIBUTE_UNUSED = BITSIZE; \
935 relocation = FORMULA ; \
936 PRINT_DEBUG_RELOC_INFO_BEFORE (#FORMULA, #TYPE); \
937 insn = middle_endian_convert (insn, IS_ME (#FORMULA, abfd)); \
938 insn = (* get_replace_function (abfd, TYPE)) (insn, relocation); \
939 insn = middle_endian_convert (insn, IS_ME (#FORMULA, abfd)); \
940 PRINT_DEBUG_RELOC_INFO_AFTER; \
944 static bfd_reloc_status_type
945 arc_do_relocation (bfd_byte
* contents
,
946 struct arc_relocation_data reloc_data
,
947 struct bfd_link_info
*info
)
949 bfd_signed_vma relocation
= 0;
951 bfd_vma orig_insn ATTRIBUTE_UNUSED
;
952 bfd
* abfd
= reloc_data
.input_section
->owner
;
953 struct elf_link_hash_table
*htab ATTRIBUTE_UNUSED
= elf_hash_table (info
);
954 bfd_reloc_status_type flag
;
956 if (reloc_data
.should_relocate
== FALSE
)
959 switch (reloc_data
.howto
->size
)
962 insn
= arc_bfd_get_32 (abfd
,
963 contents
+ reloc_data
.reloc_offset
,
964 reloc_data
.input_section
);
967 insn
= arc_bfd_get_16 (abfd
,
968 contents
+ reloc_data
.reloc_offset
,
969 reloc_data
.input_section
);
972 insn
= arc_bfd_get_8 (abfd
,
973 contents
+ reloc_data
.reloc_offset
,
974 reloc_data
.input_section
);
984 switch (reloc_data
.howto
->type
)
986 #include "elf/arc-reloc.def"
993 /* Check for relocation overflow. */
994 if (reloc_data
.howto
->complain_on_overflow
!= complain_overflow_dont
)
995 flag
= bfd_check_overflow (reloc_data
.howto
->complain_on_overflow
,
996 reloc_data
.howto
->bitsize
,
997 reloc_data
.howto
->rightshift
,
998 bfd_arch_bits_per_address (abfd
),
1001 flag
= arc_special_overflow_checks (reloc_data
, relocation
, info
);
1003 if (flag
!= bfd_reloc_ok
)
1005 ARC_DEBUG ("Relocation overflows !\n");
1006 DEBUG_ARC_RELOC (reloc_data
);
1007 ARC_DEBUG ("Relocation value = signed -> %d, unsigned -> %u"
1008 ", hex -> (0x%08x)\n",
1009 (int) relocation
, (unsigned) relocation
, (int) relocation
);
1014 /* Write updated instruction back to memory. */
1015 switch (reloc_data
.howto
->size
)
1018 arc_bfd_put_32 (abfd
, insn
,
1019 contents
+ reloc_data
.reloc_offset
,
1020 reloc_data
.input_section
);
1023 arc_bfd_put_16 (abfd
, insn
,
1024 contents
+ reloc_data
.reloc_offset
,
1025 reloc_data
.input_section
);
1028 arc_bfd_put_8 (abfd
, insn
,
1029 contents
+ reloc_data
.reloc_offset
,
1030 reloc_data
.input_section
);
1033 ARC_DEBUG ("size = %d\n", reloc_data
.howto
->size
);
1038 return bfd_reloc_ok
;
1053 #undef ARC_RELOC_HOWTO
1056 /* Relocate an arc ELF section.
1057 Function : elf_arc_relocate_section
1058 Brief : Relocate an arc section, by handling all the relocations
1059 appearing in that section.
1060 Args : output_bfd : The bfd being written to.
1061 info : Link information.
1062 input_bfd : The input bfd.
1063 input_section : The section being relocated.
1064 contents : contents of the section being relocated.
1065 relocs : List of relocations in the section.
1066 local_syms : is a pointer to the swapped in local symbols.
1067 local_section : is an array giving the section in the input file
1068 corresponding to the st_shndx field of each
1071 elf_arc_relocate_section (bfd
* output_bfd
,
1072 struct bfd_link_info
* info
,
1074 asection
* input_section
,
1075 bfd_byte
* contents
,
1076 Elf_Internal_Rela
* relocs
,
1077 Elf_Internal_Sym
* local_syms
,
1078 asection
** local_sections
)
1080 Elf_Internal_Shdr
* symtab_hdr
;
1081 struct elf_link_hash_entry
** sym_hashes
;
1082 Elf_Internal_Rela
* rel
;
1083 Elf_Internal_Rela
* wrel
;
1084 Elf_Internal_Rela
* relend
;
1085 struct elf_link_hash_table
* htab
= elf_hash_table (info
);
1087 symtab_hdr
= &((elf_tdata (input_bfd
))->symtab_hdr
);
1088 sym_hashes
= elf_sym_hashes (input_bfd
);
1090 rel
= wrel
= relocs
;
1091 relend
= relocs
+ input_section
->reloc_count
;
1092 for (; rel
< relend
; wrel
++, rel
++)
1094 enum elf_arc_reloc_type r_type
;
1095 reloc_howto_type
* howto
;
1096 unsigned long r_symndx
;
1097 struct elf_link_hash_entry
* h
;
1098 Elf_Internal_Sym
* sym
;
1100 struct elf_link_hash_entry
* h2
;
1103 struct arc_relocation_data reloc_data
=
1107 .got_offset_value
= 0,
1109 .sym_section
= NULL
,
1111 .input_section
= NULL
,
1112 .sdata_begin_symbol_vma
= 0,
1113 .sdata_begin_symbol_vma_set
= FALSE
,
1114 .got_symbol_vma
= 0,
1115 .should_relocate
= FALSE
1118 r_type
= ELF32_R_TYPE (rel
->r_info
);
1120 if (r_type
>= (int) R_ARC_max
)
1122 bfd_set_error (bfd_error_bad_value
);
1125 howto
= arc_elf_howto (r_type
);
1127 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1129 /* If we are generating another .o file and the symbol in not
1130 local, skip this relocation. */
1131 if (bfd_link_relocatable (info
))
1133 /* This is a relocateable link. We don't have to change
1134 anything, unless the reloc is against a section symbol,
1135 in which case we have to adjust according to where the
1136 section symbol winds up in the output section. */
1138 /* Checks if this is a local symbol and thus the reloc
1139 might (will??) be against a section symbol. */
1140 if (r_symndx
< symtab_hdr
->sh_info
)
1142 sym
= local_syms
+ r_symndx
;
1143 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1145 sec
= local_sections
[r_symndx
];
1147 /* For RELA relocs. Just adjust the addend
1148 value in the relocation entry. */
1149 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
1151 ARC_DEBUG ("local symbols reloc (section=%d %s) seen in %s\n",
1152 (int) r_symndx
, local_sections
[r_symndx
]->name
,
1153 __PRETTY_FUNCTION__
);
1158 h2
= elf_link_hash_lookup (elf_hash_table (info
), "__SDATA_BEGIN__",
1159 FALSE
, FALSE
, TRUE
);
1161 if (reloc_data
.sdata_begin_symbol_vma_set
== FALSE
1162 && h2
!= NULL
&& h2
->root
.type
!= bfd_link_hash_undefined
1163 && h2
->root
.u
.def
.section
->output_section
!= NULL
)
1164 /* TODO: Verify this condition. */
1166 reloc_data
.sdata_begin_symbol_vma
=
1167 (h2
->root
.u
.def
.value
1168 + h2
->root
.u
.def
.section
->output_section
->vma
);
1169 reloc_data
.sdata_begin_symbol_vma_set
= TRUE
;
1172 reloc_data
.input_section
= input_section
;
1173 reloc_data
.howto
= howto
;
1174 reloc_data
.reloc_offset
= rel
->r_offset
;
1175 reloc_data
.reloc_addend
= rel
->r_addend
;
1177 /* This is a final link. */
1182 if (r_symndx
< symtab_hdr
->sh_info
) /* A local symbol. */
1184 sym
= local_syms
+ r_symndx
;
1185 sec
= local_sections
[r_symndx
];
1189 /* TODO: This code is repeated from below. We should
1190 clean it and remove duplications.
1191 Sec is used check for discarded sections.
1192 Need to redesign code below. */
1194 /* Get the symbol's entry in the symtab. */
1195 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1197 while (h
->root
.type
== bfd_link_hash_indirect
1198 || h
->root
.type
== bfd_link_hash_warning
)
1199 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1201 /* If we have encountered a definition for this symbol. */
1202 if (h
->root
.type
== bfd_link_hash_defined
1203 || h
->root
.type
== bfd_link_hash_defweak
)
1205 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1206 sec
= h
->root
.u
.def
.section
;
1210 /* Clean relocs for symbols in discarded sections. */
1211 if (sec
!= NULL
&& discarded_section (sec
))
1213 _bfd_clear_contents (howto
, input_bfd
, input_section
,
1214 contents
+ rel
->r_offset
);
1215 rel
->r_offset
= rel
->r_offset
;
1219 /* For ld -r, remove relocations in debug sections against
1220 sections defined in discarded sections. Not done for
1221 eh_frame editing code expects to be present. */
1222 if (bfd_link_relocatable (info
)
1223 && (input_section
->flags
& SEC_DEBUGGING
))
1229 if (bfd_link_relocatable (info
))
1236 if (r_symndx
< symtab_hdr
->sh_info
) /* A local symbol. */
1238 reloc_data
.sym_value
= sym
->st_value
;
1239 reloc_data
.sym_section
= sec
;
1240 reloc_data
.symbol_name
=
1241 bfd_elf_string_from_elf_section (input_bfd
,
1242 symtab_hdr
->sh_link
,
1245 /* Mergeable section handling. */
1246 if ((sec
->flags
& SEC_MERGE
)
1247 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1251 rel
->r_addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
,
1252 &msec
, rel
->r_addend
);
1253 rel
->r_addend
-= (sec
->output_section
->vma
1254 + sec
->output_offset
1256 rel
->r_addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
1258 reloc_data
.reloc_addend
= rel
->r_addend
;
1261 BFD_ASSERT (htab
->sgot
!= NULL
|| !is_reloc_for_GOT (howto
));
1262 if (htab
->sgot
!= NULL
)
1263 reloc_data
.got_symbol_vma
= htab
->sgot
->output_section
->vma
1264 + htab
->sgot
->output_offset
;
1266 reloc_data
.should_relocate
= TRUE
;
1268 else /* Global symbol. */
1270 /* FIXME: We should use the RELOC_FOR_GLOBAL_SYMBOL macro
1271 (defined in elf-bfd.h) here. */
1273 /* Get the symbol's entry in the symtab. */
1274 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1276 while (h
->root
.type
== bfd_link_hash_indirect
1277 || h
->root
.type
== bfd_link_hash_warning
)
1278 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1280 /* TODO: Need to validate what was the intention. */
1281 /* BFD_ASSERT ((h->dynindx == -1) || (h->forced_local != 0)); */
1282 reloc_data
.symbol_name
= h
->root
.root
.string
;
1284 /* If we have encountered a definition for this symbol. */
1285 if (h
->root
.type
== bfd_link_hash_defined
1286 || h
->root
.type
== bfd_link_hash_defweak
)
1288 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1289 reloc_data
.sym_section
= h
->root
.u
.def
.section
;
1291 reloc_data
.should_relocate
= TRUE
;
1293 if (is_reloc_for_GOT (howto
) && !bfd_link_pic (info
))
1295 /* TODO: Change it to use arc_do_relocation with
1296 ARC_32 reloc. Try to use ADD_RELA macro. */
1297 bfd_vma relocation
=
1298 reloc_data
.sym_value
+ reloc_data
.reloc_addend
1299 + (reloc_data
.sym_section
->output_section
!= NULL
?
1300 (reloc_data
.sym_section
->output_offset
1301 + reloc_data
.sym_section
->output_section
->vma
)
1304 BFD_ASSERT (h
->got
.glist
);
1305 bfd_vma got_offset
= h
->got
.glist
->offset
;
1306 bfd_put_32 (output_bfd
, relocation
,
1307 htab
->sgot
->contents
+ got_offset
);
1309 if (is_reloc_for_PLT (howto
) && h
->plt
.offset
!= (bfd_vma
) -1)
1311 /* TODO: This is repeated up here. */
1312 reloc_data
.sym_value
= h
->plt
.offset
;
1313 reloc_data
.sym_section
= htab
->splt
;
1316 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1318 /* Is weak symbol and has no definition. */
1319 if (is_reloc_for_GOT (howto
))
1321 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1322 reloc_data
.sym_section
= htab
->sgot
;
1323 reloc_data
.should_relocate
= TRUE
;
1325 else if (is_reloc_for_PLT (howto
)
1326 && h
->plt
.offset
!= (bfd_vma
) -1)
1328 /* TODO: This is repeated up here. */
1329 reloc_data
.sym_value
= h
->plt
.offset
;
1330 reloc_data
.sym_section
= htab
->splt
;
1331 reloc_data
.should_relocate
= TRUE
;
1338 if (is_reloc_for_GOT (howto
))
1340 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1341 reloc_data
.sym_section
= htab
->sgot
;
1343 reloc_data
.should_relocate
= TRUE
;
1345 else if (is_reloc_for_PLT (howto
))
1347 /* Fail if it is linking for PIE and the symbol is
1349 if (bfd_link_executable (info
))
1350 (*info
->callbacks
->undefined_symbol
)
1351 (info
, h
->root
.root
.string
, input_bfd
, input_section
,
1352 rel
->r_offset
, TRUE
);
1353 reloc_data
.sym_value
= h
->plt
.offset
;
1354 reloc_data
.sym_section
= htab
->splt
;
1356 reloc_data
.should_relocate
= TRUE
;
1358 else if (!bfd_link_pic (info
) || bfd_link_executable (info
))
1359 (*info
->callbacks
->undefined_symbol
)
1360 (info
, h
->root
.root
.string
, input_bfd
, input_section
,
1361 rel
->r_offset
, TRUE
);
1364 BFD_ASSERT (htab
->sgot
!= NULL
|| !is_reloc_for_GOT (howto
));
1365 if (htab
->sgot
!= NULL
)
1366 reloc_data
.got_symbol_vma
= htab
->sgot
->output_section
->vma
1367 + htab
->sgot
->output_offset
;
1370 if ((is_reloc_for_GOT (howto
)
1371 || is_reloc_for_TLS (howto
)))
1373 reloc_data
.should_relocate
= TRUE
;
1375 struct got_entry
**list
1376 = get_got_entry_list_for_symbol (output_bfd
, r_symndx
, h
);
1378 reloc_data
.got_offset_value
1379 = relocate_fix_got_relocs_for_got_info (list
,
1380 tls_type_for_reloc (howto
),
1391 create_got_dynrelocs_for_single_entry (
1392 got_entry_for_type (list
,
1393 arc_got_entry_type_for_reloc (howto
)),
1394 output_bfd
, info
, NULL
);
1403 case R_ARC_32_PCREL
:
1404 if ((bfd_link_pic (info
))
1405 && ((r_type
!= R_ARC_PC32
&& r_type
!= R_ARC_32_PCREL
)
1408 && (!info
->symbolic
|| !h
->def_regular
))))
1410 Elf_Internal_Rela outrel
;
1412 bfd_boolean skip
= FALSE
;
1413 bfd_boolean relocate
= FALSE
;
1414 asection
*sreloc
= _bfd_elf_get_dynamic_reloc_section
1415 (input_bfd
, input_section
,
1418 BFD_ASSERT (sreloc
!= NULL
);
1420 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
1424 if (outrel
.r_offset
== (bfd_vma
) -1)
1427 outrel
.r_addend
= rel
->r_addend
;
1428 outrel
.r_offset
+= (input_section
->output_section
->vma
1429 + input_section
->output_offset
);
1431 #define IS_ARC_PCREL_TYPE(TYPE) \
1432 ( (TYPE == R_ARC_PC32) \
1433 || (TYPE == R_ARC_32_PCREL))
1437 memset (&outrel
, 0, sizeof outrel
);
1442 && ((IS_ARC_PCREL_TYPE (r_type
))
1443 || !(bfd_link_executable (info
)
1444 || SYMBOLIC_BIND (info
, h
))
1445 || ! h
->def_regular
))
1447 BFD_ASSERT (h
!= NULL
);
1448 if ((input_section
->flags
& SEC_ALLOC
) != 0)
1453 BFD_ASSERT (h
->dynindx
!= -1);
1454 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
1458 /* Handle local symbols, they either do not have a
1459 global hash table entry (h == NULL), or are
1460 forced local due to a version script
1461 (h->forced_local), or the third condition is
1462 legacy, it appears to say something like, for
1463 links where we are pre-binding the symbols, or
1464 there's not an entry for this symbol in the
1465 dynamic symbol table, and it's a regular symbol
1466 not defined in a shared object, then treat the
1467 symbol as local, resolve it now. */
1469 /* outrel.r_addend = 0; */
1470 outrel
.r_info
= ELF32_R_INFO (0, R_ARC_RELATIVE
);
1473 BFD_ASSERT (sreloc
->contents
!= 0);
1475 loc
= sreloc
->contents
;
1476 loc
+= sreloc
->reloc_count
* sizeof (Elf32_External_Rela
);
1477 sreloc
->reloc_count
+= 1;
1479 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
1481 if (relocate
== FALSE
)
1489 if (is_reloc_SDA_relative (howto
)
1490 && (reloc_data
.sdata_begin_symbol_vma_set
== FALSE
))
1493 ("Error: Linker symbol __SDATA_BEGIN__ not found");
1494 bfd_set_error (bfd_error_bad_value
);
1498 DEBUG_ARC_RELOC (reloc_data
);
1500 /* Make sure we have with a dynamic linker. In case of GOT and PLT
1501 the sym_section should point to .got or .plt respectively. */
1502 if ((is_reloc_for_GOT (howto
) || is_reloc_for_PLT (howto
))
1503 && reloc_data
.sym_section
== NULL
)
1506 (_("GOT and PLT relocations cannot be fixed with a non dynamic linker."));
1507 bfd_set_error (bfd_error_bad_value
);
1512 switch (arc_do_relocation (contents
, reloc_data
, info
))
1515 continue; /* The reloc processing loop. */
1517 case bfd_reloc_overflow
:
1518 (*info
->callbacks
->reloc_overflow
)
1519 (info
, (h
? &h
->root
: NULL
), reloc_data
.symbol_name
, howto
->name
, (bfd_vma
) 0,
1520 input_bfd
, input_section
, rel
->r_offset
);
1523 case bfd_reloc_undefined
:
1524 (*info
->callbacks
->undefined_symbol
)
1525 (info
, reloc_data
.symbol_name
, input_bfd
, input_section
, rel
->r_offset
, TRUE
);
1528 case bfd_reloc_other
:
1529 msg
= _("%B(%A): warning: unaligned access to symbol '%s' in the small data area");
1532 case bfd_reloc_outofrange
:
1533 msg
= _("%B(%A): internal error: out of range error");
1536 case bfd_reloc_notsupported
:
1537 msg
= _("%B(%A): internal error: unsupported relocation error");
1540 case bfd_reloc_dangerous
:
1541 msg
= _("%B(%A): internal error: dangerous relocation");
1545 msg
= _("%B(%A): internal error: unknown error");
1550 _bfd_error_handler (msg
, input_bfd
, input_section
, reloc_data
.symbol_name
);
1557 #define elf_arc_hash_table(p) \
1558 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
1559 == ARC_ELF_DATA ? ((struct elf_arc_link_hash_table *) ((p)->hash)) : NULL)
1561 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
1562 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
1566 arc_elf_create_dynamic_sections (bfd
*dynobj
,
1567 struct bfd_link_info
*info
)
1569 struct elf_arc_link_hash_table
*htab
;
1571 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
1574 htab
= elf_arc_hash_table (info
);
1578 if (bfd_link_executable (info
))
1580 /* Always allow copy relocs for building executables. */
1581 asection
*s
= bfd_get_linker_section (dynobj
, ".rela.bss");
1584 const struct elf_backend_data
*bed
= get_elf_backend_data (dynobj
);
1585 s
= bfd_make_section_anyway_with_flags (dynobj
,
1587 (bed
->dynamic_sec_flags
1590 || ! bfd_set_section_alignment (dynobj
, s
,
1591 bed
->s
->log_file_align
))
1600 static struct dynamic_sections
1601 arc_create_dynamic_sections (bfd
* abfd
, struct bfd_link_info
*info
)
1603 struct elf_link_hash_table
*htab
;
1605 struct dynamic_sections ds
=
1607 .initialized
= FALSE
,
1617 htab
= elf_hash_table (info
);
1620 /* Create dynamic sections for relocatable executables so that we
1621 can copy relocations. */
1622 if (! htab
->dynamic_sections_created
&& bfd_link_pic (info
))
1624 if (! _bfd_elf_link_create_dynamic_sections (abfd
, info
))
1628 dynobj
= (elf_hash_table (info
))->dynobj
;
1632 ds
.sgot
= htab
->sgot
;
1633 ds
.srelgot
= htab
->srelgot
;
1635 ds
.sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
1636 ds
.srelgotplt
= ds
.srelplt
;
1638 ds
.splt
= bfd_get_section_by_name (dynobj
, ".plt");
1639 ds
.srelplt
= bfd_get_section_by_name (dynobj
, ".rela.plt");
1642 if (htab
->dynamic_sections_created
)
1644 ds
.sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
1647 ds
.initialized
= TRUE
;
1653 elf_arc_check_relocs (bfd
* abfd
,
1654 struct bfd_link_info
* info
,
1656 const Elf_Internal_Rela
* relocs
)
1658 Elf_Internal_Shdr
* symtab_hdr
;
1659 struct elf_link_hash_entry
** sym_hashes
;
1660 const Elf_Internal_Rela
* rel
;
1661 const Elf_Internal_Rela
* rel_end
;
1663 asection
* sreloc
= NULL
;
1665 if (bfd_link_relocatable (info
))
1668 dynobj
= (elf_hash_table (info
))->dynobj
;
1669 symtab_hdr
= &((elf_tdata (abfd
))->symtab_hdr
);
1670 sym_hashes
= elf_sym_hashes (abfd
);
1672 rel_end
= relocs
+ sec
->reloc_count
;
1673 for (rel
= relocs
; rel
< rel_end
; rel
++)
1675 enum elf_arc_reloc_type r_type
;
1676 reloc_howto_type
*howto
;
1677 unsigned long r_symndx
;
1678 struct elf_link_hash_entry
*h
;
1680 r_type
= ELF32_R_TYPE (rel
->r_info
);
1682 if (r_type
>= (int) R_ARC_max
)
1684 bfd_set_error (bfd_error_bad_value
);
1687 howto
= arc_elf_howto (r_type
);
1690 && (is_reloc_for_GOT (howto
) == TRUE
1691 || is_reloc_for_TLS (howto
) == TRUE
))
1693 dynobj
= elf_hash_table (info
)->dynobj
= abfd
;
1694 if (! _bfd_elf_create_got_section (abfd
, info
))
1698 /* Load symbol information. */
1699 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1700 if (r_symndx
< symtab_hdr
->sh_info
) /* Is a local symbol. */
1702 else /* Global one. */
1703 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1709 /* During shared library creation, these relocs should not
1710 appear in a shared library (as memory will be read only
1711 and the dynamic linker can not resolve these. However
1712 the error should not occur for e.g. debugging or
1713 non-readonly sections. */
1714 if ((bfd_link_dll (info
) && !bfd_link_pie (info
))
1715 && (sec
->flags
& SEC_ALLOC
) != 0
1716 && (sec
->flags
& SEC_READONLY
) != 0
1717 && ((sec
->flags
& SEC_CODE
) != 0
1718 || (sec
->flags
& SEC_DEBUGGING
) != 0))
1722 name
= h
->root
.root
.string
;
1724 /* bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL); */
1728 %B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1730 arc_elf_howto (r_type
)->name
,
1732 bfd_set_error (bfd_error_bad_value
);
1736 /* In some cases we are not setting the 'non_got_ref'
1737 flag, even though the relocations don't require a GOT
1738 access. We should extend the testing in this area to
1739 ensure that no significant cases are being missed. */
1744 case R_ARC_32_PCREL
:
1745 if ((bfd_link_pic (info
))
1746 && ((r_type
!= R_ARC_PC32
&& r_type
!= R_ARC_32_PCREL
)
1748 && (!info
->symbolic
|| !h
->def_regular
))))
1752 sreloc
= _bfd_elf_make_dynamic_reloc_section (sec
, dynobj
,
1760 sreloc
->size
+= sizeof (Elf32_External_Rela
);
1767 if (is_reloc_for_PLT (howto
) == TRUE
)
1775 /* Add info to the symbol got_entry_list. */
1776 if (is_reloc_for_GOT (howto
) == TRUE
1777 || is_reloc_for_TLS (howto
) == TRUE
)
1779 arc_fill_got_info_for_reloc (
1780 arc_got_entry_type_for_reloc (howto
),
1781 get_got_entry_list_for_symbol (abfd
, r_symndx
, h
),
1790 #define ELF_DYNAMIC_INTERPRETER "/sbin/ld-uClibc.so"
1792 static struct plt_version_t
*
1793 arc_get_plt_version (struct bfd_link_info
*info
)
1797 for (i
= 0; i
< 1; i
++)
1799 ARC_DEBUG ("%d: size1 = %d, size2 = %d\n", i
,
1800 (int) plt_versions
[i
].entry_size
,
1801 (int) plt_versions
[i
].elem_size
);
1804 if (bfd_get_mach (info
->output_bfd
) == bfd_mach_arc_arcv2
)
1806 if (bfd_link_pic (info
))
1807 return &(plt_versions
[ELF_ARCV2_PIC
]);
1809 return &(plt_versions
[ELF_ARCV2_ABS
]);
1813 if (bfd_link_pic (info
))
1814 return &(plt_versions
[ELF_ARC_PIC
]);
1816 return &(plt_versions
[ELF_ARC_ABS
]);
1821 add_symbol_to_plt (struct bfd_link_info
*info
)
1823 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
1826 struct plt_version_t
*plt_data
= arc_get_plt_version (info
);
1828 /* If this is the first .plt entry, make room for the special first
1830 if (htab
->splt
->size
== 0)
1831 htab
->splt
->size
+= plt_data
->entry_size
;
1833 ret
= htab
->splt
->size
;
1835 htab
->splt
->size
+= plt_data
->elem_size
;
1836 ARC_DEBUG ("PLT_SIZE = %d\n", (int) htab
->splt
->size
);
1838 htab
->sgotplt
->size
+= 4;
1839 htab
->srelplt
->size
+= sizeof (Elf32_External_Rela
);
1844 #define PLT_DO_RELOCS_FOR_ENTRY(ABFD, DS, RELOCS) \
1845 plt_do_relocs_for_symbol (ABFD, DS, RELOCS, 0, 0)
1848 plt_do_relocs_for_symbol (bfd
*abfd
,
1849 struct elf_link_hash_table
*htab
,
1850 const struct plt_reloc
*reloc
,
1852 bfd_vma symbol_got_offset
)
1854 while (SYM_ONLY (reloc
->symbol
) != LAST_RELOC
)
1856 bfd_vma relocation
= 0;
1858 switch (SYM_ONLY (reloc
->symbol
))
1862 = htab
->sgotplt
->output_section
->vma
1863 + htab
->sgotplt
->output_offset
+ symbol_got_offset
;
1866 relocation
+= reloc
->addend
;
1868 if (IS_RELATIVE (reloc
->symbol
))
1870 bfd_vma reloc_offset
= reloc
->offset
;
1871 reloc_offset
-= (IS_INSN_32 (reloc
->symbol
)) ? 4 : 0;
1872 reloc_offset
-= (IS_INSN_24 (reloc
->symbol
)) ? 2 : 0;
1874 relocation
-= htab
->splt
->output_section
->vma
1875 + htab
->splt
->output_offset
1876 + plt_offset
+ reloc_offset
;
1879 /* TODO: being ME is not a property of the relocation but of the
1880 section of which is applying the relocation. */
1881 if (IS_MIDDLE_ENDIAN (reloc
->symbol
) && !bfd_big_endian (abfd
))
1884 = ((relocation
& 0xffff0000) >> 16)
1885 | ((relocation
& 0xffff) << 16);
1888 switch (reloc
->size
)
1891 bfd_put_32 (htab
->splt
->output_section
->owner
,
1893 htab
->splt
->contents
+ plt_offset
+ reloc
->offset
);
1897 reloc
= &(reloc
[1]); /* Jump to next relocation. */
1902 relocate_plt_for_symbol (bfd
*output_bfd
,
1903 struct bfd_link_info
*info
,
1904 struct elf_link_hash_entry
*h
)
1906 struct plt_version_t
*plt_data
= arc_get_plt_version (info
);
1907 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
1909 bfd_vma plt_index
= (h
->plt
.offset
- plt_data
->entry_size
)
1910 / plt_data
->elem_size
;
1911 bfd_vma got_offset
= (plt_index
+ 3) * 4;
1913 ARC_DEBUG ("arc_info: PLT_OFFSET = %#lx, PLT_ENTRY_VMA = %#lx, \
1914 GOT_ENTRY_OFFSET = %#lx, GOT_ENTRY_VMA = %#lx, for symbol %s\n",
1915 (long) h
->plt
.offset
,
1916 (long) (htab
->splt
->output_section
->vma
1917 + htab
->splt
->output_offset
1920 (long) (htab
->sgotplt
->output_section
->vma
1921 + htab
->sgotplt
->output_offset
1923 h
->root
.root
.string
);
1927 uint16_t *ptr
= (uint16_t *) plt_data
->elem
;
1929 for (i
= 0; i
< plt_data
->elem_size
/2; i
++)
1931 uint16_t data
= ptr
[i
];
1932 bfd_put_16 (output_bfd
,
1934 htab
->splt
->contents
+ h
->plt
.offset
+ (i
*2));
1938 plt_do_relocs_for_symbol (output_bfd
, htab
,
1939 plt_data
->elem_relocs
,
1943 /* Fill in the entry in the global offset table. */
1944 bfd_put_32 (output_bfd
,
1945 (bfd_vma
) (htab
->splt
->output_section
->vma
1946 + htab
->splt
->output_offset
),
1947 htab
->sgotplt
->contents
+ got_offset
);
1949 /* TODO: Fill in the entry in the .rela.plt section. */
1951 Elf_Internal_Rela rel
;
1954 rel
.r_offset
= (htab
->sgotplt
->output_section
->vma
1955 + htab
->sgotplt
->output_offset
1959 BFD_ASSERT (h
->dynindx
!= -1);
1960 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARC_JMP_SLOT
);
1962 loc
= htab
->srelplt
->contents
;
1963 loc
+= plt_index
* sizeof (Elf32_External_Rela
); /* relA */
1964 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
1969 relocate_plt_for_entry (bfd
*abfd
,
1970 struct bfd_link_info
*info
)
1972 struct plt_version_t
*plt_data
= arc_get_plt_version (info
);
1973 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
1977 uint16_t *ptr
= (uint16_t *) plt_data
->entry
;
1978 for (i
= 0; i
< plt_data
->entry_size
/2; i
++)
1980 uint16_t data
= ptr
[i
];
1983 htab
->splt
->contents
+ (i
*2));
1986 PLT_DO_RELOCS_FOR_ENTRY (abfd
, htab
, plt_data
->entry_relocs
);
1989 /* Desc : Adjust a symbol defined by a dynamic object and referenced
1990 by a regular object. The current definition is in some section of
1991 the dynamic object, but we're not including those sections. We
1992 have to change the definition to something the rest of the link can
1996 elf_arc_adjust_dynamic_symbol (struct bfd_link_info
*info
,
1997 struct elf_link_hash_entry
*h
)
2000 bfd
*dynobj
= (elf_hash_table (info
))->dynobj
;
2001 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2003 if (h
->type
== STT_FUNC
2004 || h
->type
== STT_GNU_IFUNC
2005 || h
->needs_plt
== 1)
2007 if (!bfd_link_pic (info
) && !h
->def_dynamic
&& !h
->ref_dynamic
)
2009 /* This case can occur if we saw a PLT32 reloc in an input
2010 file, but the symbol was never referred to by a dynamic
2011 object. In such a case, we don't actually need to build
2012 a procedure linkage table, and we can just do a PC32
2014 BFD_ASSERT (h
->needs_plt
);
2018 /* Make sure this symbol is output as a dynamic symbol. */
2019 if (h
->dynindx
== -1 && !h
->forced_local
2020 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
2023 if (bfd_link_pic (info
)
2024 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2026 bfd_vma loc
= add_symbol_to_plt (info
);
2028 if (bfd_link_executable (info
) && !h
->def_regular
)
2030 h
->root
.u
.def
.section
= htab
->splt
;
2031 h
->root
.u
.def
.value
= loc
;
2033 h
->plt
.offset
= loc
;
2037 h
->plt
.offset
= (bfd_vma
) -1;
2043 /* If this is a weak symbol, and there is a real definition, the
2044 processor independent code will have arranged for us to see the
2045 real definition first, and we can just use the same value. */
2046 if (h
->u
.weakdef
!= NULL
)
2048 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2049 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2050 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2051 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2055 /* This is a reference to a symbol defined by a dynamic object which
2056 is not a function. */
2058 /* If we are creating a shared library, we must presume that the
2059 only references to the symbol are via the global offset table.
2060 For such cases we need not do anything here; the relocations will
2061 be handled correctly by relocate_section. */
2062 if (!bfd_link_executable (info
))
2065 /* If there are no non-GOT references, we do not need a copy
2067 if (!h
->non_got_ref
)
2070 /* If -z nocopyreloc was given, we won't generate them either. */
2071 if (info
->nocopyreloc
)
2077 /* We must allocate the symbol in our .dynbss section, which will
2078 become part of the .bss section of the executable. There will be
2079 an entry for this symbol in the .dynsym section. The dynamic
2080 object will contain position independent code, so all references
2081 from the dynamic object to this symbol will go through the global
2082 offset table. The dynamic linker will use the .dynsym entry to
2083 determine the address it must put in the global offset table, so
2084 both the dynamic object and the regular object will refer to the
2085 same memory location for the variable. */
2090 /* We must generate a R_ARC_COPY reloc to tell the dynamic linker to
2091 copy the initial value out of the dynamic object and into the
2092 runtime process image. We need to remember the offset into the
2093 .rela.bss section we are going to use. */
2094 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
2096 struct elf_arc_link_hash_table
*arc_htab
= elf_arc_hash_table (info
);
2098 BFD_ASSERT (arc_htab
->srelbss
!= NULL
);
2099 arc_htab
->srelbss
->size
+= sizeof (Elf32_External_Rela
);
2103 /* TODO: Move this also to arc_hash_table. */
2104 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
2105 BFD_ASSERT (s
!= NULL
);
2107 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2110 /* Function : elf_arc_finish_dynamic_symbol
2111 Brief : Finish up dynamic symbol handling. We set the
2112 contents of various dynamic sections here.
2117 Returns : True/False as the return status. */
2120 elf_arc_finish_dynamic_symbol (bfd
* output_bfd
,
2121 struct bfd_link_info
*info
,
2122 struct elf_link_hash_entry
*h
,
2123 Elf_Internal_Sym
* sym
)
2125 if (h
->plt
.offset
!= (bfd_vma
) -1)
2127 relocate_plt_for_symbol (output_bfd
, info
, h
);
2129 if (!h
->def_regular
)
2131 /* Mark the symbol as undefined, rather than as defined in
2132 the .plt section. Leave the value alone. */
2133 sym
->st_shndx
= SHN_UNDEF
;
2138 /* This function traverses list of GOT entries and
2139 create respective dynamic relocs. */
2140 /* TODO: Make function to get list and not access the list directly. */
2141 /* TODO: Move function to relocate_section create this relocs eagerly. */
2142 create_got_dynrelocs_for_got_info (&h
->got
.glist
,
2149 struct elf_arc_link_hash_table
*arc_htab
= elf_arc_hash_table (info
);
2151 if (h
->dynindx
== -1
2152 || (h
->root
.type
!= bfd_link_hash_defined
2153 && h
->root
.type
!= bfd_link_hash_defweak
)
2154 || arc_htab
->srelbss
== NULL
)
2157 bfd_vma rel_offset
= (h
->root
.u
.def
.value
2158 + h
->root
.u
.def
.section
->output_section
->vma
2159 + h
->root
.u
.def
.section
->output_offset
);
2161 bfd_byte
* loc
= arc_htab
->srelbss
->contents
2162 + (arc_htab
->srelbss
->reloc_count
* sizeof (Elf32_External_Rela
));
2163 arc_htab
->srelbss
->reloc_count
++;
2165 Elf_Internal_Rela rel
;
2167 rel
.r_offset
= rel_offset
;
2169 BFD_ASSERT (h
->dynindx
!= -1);
2170 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARC_COPY
);
2172 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
2175 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2176 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2177 || strcmp (h
->root
.root
.string
, "__DYNAMIC") == 0
2178 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
2179 sym
->st_shndx
= SHN_ABS
;
2184 #define GET_SYMBOL_OR_SECTION(TAG, SYMBOL, SECTION) \
2186 if (SYMBOL != NULL) \
2187 h = elf_link_hash_lookup (elf_hash_table (info), \
2188 SYMBOL, FALSE, FALSE, TRUE); \
2189 else if (SECTION != NULL) \
2190 s = bfd_get_linker_section (dynobj, SECTION); \
2193 /* Function : elf_arc_finish_dynamic_sections
2194 Brief : Finish up the dynamic sections handling.
2199 Returns : True/False as the return status. */
2202 elf_arc_finish_dynamic_sections (bfd
* output_bfd
,
2203 struct bfd_link_info
*info
)
2205 struct dynamic_sections ds
= arc_create_dynamic_sections (output_bfd
, info
);
2206 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2207 bfd
*dynobj
= (elf_hash_table (info
))->dynobj
;
2211 Elf32_External_Dyn
*dyncon
, *dynconend
;
2213 dyncon
= (Elf32_External_Dyn
*) ds
.sdyn
->contents
;
2215 = (Elf32_External_Dyn
*) (ds
.sdyn
->contents
+ ds
.sdyn
->size
);
2216 for (; dyncon
< dynconend
; dyncon
++)
2218 Elf_Internal_Dyn internal_dyn
;
2219 bfd_boolean do_it
= FALSE
;
2221 struct elf_link_hash_entry
*h
= NULL
;
2224 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &internal_dyn
);
2226 switch (internal_dyn
.d_tag
)
2228 GET_SYMBOL_OR_SECTION (DT_INIT
, info
->init_function
, NULL
)
2229 GET_SYMBOL_OR_SECTION (DT_FINI
, info
->fini_function
, NULL
)
2230 GET_SYMBOL_OR_SECTION (DT_PLTGOT
, NULL
, ".plt")
2231 GET_SYMBOL_OR_SECTION (DT_JMPREL
, NULL
, ".rela.plt")
2232 GET_SYMBOL_OR_SECTION (DT_PLTRELSZ
, NULL
, ".rela.plt")
2233 GET_SYMBOL_OR_SECTION (DT_RELASZ
, NULL
, ".rela.plt")
2234 GET_SYMBOL_OR_SECTION (DT_VERSYM
, NULL
, ".gnu.version")
2235 GET_SYMBOL_OR_SECTION (DT_VERDEF
, NULL
, ".gnu.version_d")
2236 GET_SYMBOL_OR_SECTION (DT_VERNEED
, NULL
, ".gnu.version_r")
2241 /* In case the dynamic symbols should be updated with a symbol. */
2243 && (h
->root
.type
== bfd_link_hash_defined
2244 || h
->root
.type
== bfd_link_hash_defweak
))
2248 internal_dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
2249 asec_ptr
= h
->root
.u
.def
.section
;
2250 if (asec_ptr
->output_section
!= NULL
)
2252 internal_dyn
.d_un
.d_val
+=
2253 (asec_ptr
->output_section
->vma
2254 + asec_ptr
->output_offset
);
2258 /* The symbol is imported from another shared
2259 library and does not apply to this one. */
2260 internal_dyn
.d_un
.d_val
= 0;
2264 else if (s
!= NULL
) /* With a section information. */
2266 switch (internal_dyn
.d_tag
)
2273 internal_dyn
.d_un
.d_ptr
= (s
->output_section
->vma
2274 + s
->output_offset
);
2279 internal_dyn
.d_un
.d_val
= s
->size
;
2285 internal_dyn
.d_un
.d_val
-= s
->size
;
2295 bfd_elf32_swap_dyn_out (output_bfd
, &internal_dyn
, dyncon
);
2298 if (htab
->splt
->size
> 0)
2300 relocate_plt_for_entry (output_bfd
, info
);
2303 /* TODO: Validate this. */
2304 elf_section_data (htab
->srelplt
->output_section
)->this_hdr
.sh_entsize
2308 /* Fill in the first three entries in the global offset table. */
2311 struct elf_link_hash_entry
*h
;
2312 h
= elf_link_hash_lookup (elf_hash_table (info
), "_GLOBAL_OFFSET_TABLE_",
2313 FALSE
, FALSE
, TRUE
);
2315 if (h
!= NULL
&& h
->root
.type
!= bfd_link_hash_undefined
2316 && h
->root
.u
.def
.section
!= NULL
)
2318 asection
*sec
= h
->root
.u
.def
.section
;
2320 if (ds
.sdyn
== NULL
)
2321 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
2324 bfd_put_32 (output_bfd
,
2325 ds
.sdyn
->output_section
->vma
+ ds
.sdyn
->output_offset
,
2327 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sec
->contents
+ 4);
2328 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sec
->contents
+ 8);
2335 #define ADD_DYNAMIC_SYMBOL(NAME, TAG) \
2336 h = elf_link_hash_lookup (elf_hash_table (info), \
2337 NAME, FALSE, FALSE, FALSE); \
2338 if ((h != NULL && (h->ref_regular || h->def_regular))) \
2339 if (! _bfd_elf_add_dynamic_entry (info, TAG, 0)) \
2342 /* Set the sizes of the dynamic sections. */
2344 elf_arc_size_dynamic_sections (bfd
* output_bfd
,
2345 struct bfd_link_info
*info
)
2349 bfd_boolean relocs_exist
= FALSE
;
2350 bfd_boolean reltext_exist
= FALSE
;
2351 struct dynamic_sections ds
= arc_create_dynamic_sections (output_bfd
, info
);
2352 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2354 dynobj
= (elf_hash_table (info
))->dynobj
;
2355 BFD_ASSERT (dynobj
!= NULL
);
2357 if ((elf_hash_table (info
))->dynamic_sections_created
)
2359 struct elf_link_hash_entry
*h
;
2361 /* Set the contents of the .interp section to the
2363 if (!bfd_link_pic (info
))
2365 s
= bfd_get_section_by_name (dynobj
, ".interp");
2366 BFD_ASSERT (s
!= NULL
);
2367 s
->size
= sizeof (ELF_DYNAMIC_INTERPRETER
);
2368 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2371 /* Add some entries to the .dynamic section. We fill in some of
2372 the values later, in elf_bfd_final_link, but we must add the
2373 entries now so that we know the final size of the .dynamic
2374 section. Checking if the .init section is present. We also
2375 create DT_INIT and DT_FINI entries if the init_str has been
2376 changed by the user. */
2377 ADD_DYNAMIC_SYMBOL (info
->init_function
, DT_INIT
);
2378 ADD_DYNAMIC_SYMBOL (info
->fini_function
, DT_FINI
);
2382 /* We may have created entries in the .rela.got section.
2383 However, if we are not creating the dynamic sections, we will
2384 not actually use these entries. Reset the size of .rela.got,
2385 which will cause it to get stripped from the output file
2387 if (htab
->srelgot
!= NULL
)
2388 htab
->srelgot
->size
= 0;
2391 if (htab
->splt
!= NULL
&& htab
->splt
->size
== 0)
2392 htab
->splt
->flags
|= SEC_EXCLUDE
;
2393 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2395 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2398 if (strncmp (s
->name
, ".rela", 5) == 0)
2402 s
->flags
|= SEC_EXCLUDE
;
2406 if (strcmp (s
->name
, ".rela.plt") != 0)
2408 const char *outname
=
2409 bfd_get_section_name (output_bfd
,
2410 htab
->srelplt
->output_section
);
2412 asection
*target
= bfd_get_section_by_name (output_bfd
,
2415 relocs_exist
= TRUE
;
2416 if (target
!= NULL
&& target
->size
!= 0
2417 && (target
->flags
& SEC_READONLY
) != 0
2418 && (target
->flags
& SEC_ALLOC
) != 0)
2419 reltext_exist
= TRUE
;
2423 /* We use the reloc_count field as a counter if we need to
2424 copy relocs into the output file. */
2428 if (strcmp (s
->name
, ".dynamic") == 0)
2432 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
2434 if (s
->contents
== NULL
&& s
->size
!= 0)
2440 /* TODO: Check if this is needed. */
2441 if (!bfd_link_pic (info
))
2442 if (!_bfd_elf_add_dynamic_entry (info
, DT_DEBUG
, 0))
2445 if (htab
->splt
&& (htab
->splt
->flags
& SEC_EXCLUDE
) == 0)
2446 if (!_bfd_elf_add_dynamic_entry (info
, DT_PLTGOT
, 0)
2447 || !_bfd_elf_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
2448 || !_bfd_elf_add_dynamic_entry (info
, DT_PLTREL
, DT_RELA
)
2449 || !_bfd_elf_add_dynamic_entry (info
, DT_JMPREL
, 0)
2453 if (relocs_exist
== TRUE
)
2454 if (!_bfd_elf_add_dynamic_entry (info
, DT_RELA
, 0)
2455 || !_bfd_elf_add_dynamic_entry (info
, DT_RELASZ
, 0)
2456 || !_bfd_elf_add_dynamic_entry (info
, DT_RELAENT
,
2457 sizeof (Elf32_External_Rela
))
2461 if (reltext_exist
== TRUE
)
2462 if (!_bfd_elf_add_dynamic_entry (info
, DT_TEXTREL
, 0))
2470 /* Classify dynamic relocs such that -z combreloc can reorder and combine
2472 static enum elf_reloc_type_class
2473 elf32_arc_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2474 const asection
*rel_sec ATTRIBUTE_UNUSED
,
2475 const Elf_Internal_Rela
*rela
)
2477 switch ((int) ELF32_R_TYPE (rela
->r_info
))
2479 case R_ARC_RELATIVE
:
2480 return reloc_class_relative
;
2481 case R_ARC_JMP_SLOT
:
2482 return reloc_class_plt
;
2484 return reloc_class_copy
;
2485 /* TODO: Needed in future to support ifunc. */
2487 case R_ARC_IRELATIVE:
2488 return reloc_class_ifunc;
2491 return reloc_class_normal
;
2495 const struct elf_size_info arc_elf32_size_info
=
2497 sizeof (Elf32_External_Ehdr
),
2498 sizeof (Elf32_External_Phdr
),
2499 sizeof (Elf32_External_Shdr
),
2500 sizeof (Elf32_External_Rel
),
2501 sizeof (Elf32_External_Rela
),
2502 sizeof (Elf32_External_Sym
),
2503 sizeof (Elf32_External_Dyn
),
2504 sizeof (Elf_External_Note
),
2508 ELFCLASS32
, EV_CURRENT
,
2509 bfd_elf32_write_out_phdrs
,
2510 bfd_elf32_write_shdrs_and_ehdr
,
2511 bfd_elf32_checksum_contents
,
2512 bfd_elf32_write_relocs
,
2513 bfd_elf32_swap_symbol_in
,
2514 bfd_elf32_swap_symbol_out
,
2515 bfd_elf32_slurp_reloc_table
,
2516 bfd_elf32_slurp_symbol_table
,
2517 bfd_elf32_swap_dyn_in
,
2518 bfd_elf32_swap_dyn_out
,
2519 bfd_elf32_swap_reloc_in
,
2520 bfd_elf32_swap_reloc_out
,
2521 bfd_elf32_swap_reloca_in
,
2522 bfd_elf32_swap_reloca_out
2525 #define elf_backend_size_info arc_elf32_size_info
2527 /* Hook called by the linker routine which adds symbols from an object
2531 elf_arc_add_symbol_hook (bfd
* abfd
,
2532 struct bfd_link_info
* info
,
2533 Elf_Internal_Sym
* sym
,
2534 const char ** namep ATTRIBUTE_UNUSED
,
2535 flagword
* flagsp ATTRIBUTE_UNUSED
,
2536 asection
** secp ATTRIBUTE_UNUSED
,
2537 bfd_vma
* valp ATTRIBUTE_UNUSED
)
2539 if (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
2540 && (abfd
->flags
& DYNAMIC
) == 0
2541 && bfd_get_flavour (info
->output_bfd
) == bfd_target_elf_flavour
)
2542 elf_tdata (info
->output_bfd
)->has_gnu_symbols
|= elf_gnu_symbol_ifunc
;
2547 /* GDB expects general purpose registers to be in section .reg. However Linux
2548 kernel doesn't create this section and instead writes registers to NOTE
2549 section. It is up to the binutils to create a pseudo-section .reg from the
2550 contents of NOTE. Also BFD will read pid and signal number from NOTE. This
2551 function relies on offsets inside elf_prstatus structure in Linux to be
2555 elf32_arc_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
2560 switch (note
->descsz
)
2565 case 236: /* sizeof (struct elf_prstatus) on Linux/arc. */
2567 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
2569 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
2572 size
= (40 * 4); /* There are 40 registers in user_regs_struct. */
2575 /* Make a ".reg/999" section. */
2576 return _bfd_elfcore_make_pseudosection (abfd
, ".reg", size
,
2577 note
->descpos
+ offset
);
2580 #define TARGET_LITTLE_SYM arc_elf32_le_vec
2581 #define TARGET_LITTLE_NAME "elf32-littlearc"
2582 #define TARGET_BIG_SYM arc_elf32_be_vec
2583 #define TARGET_BIG_NAME "elf32-bigarc"
2584 #define ELF_ARCH bfd_arch_arc
2585 #define ELF_TARGET_ID ARC_ELF_DATA
2586 #define ELF_MACHINE_CODE EM_ARC_COMPACT
2587 #define ELF_MACHINE_ALT1 EM_ARC_COMPACT2
2588 #define ELF_MAXPAGESIZE 0x2000
2590 #define bfd_elf32_bfd_link_hash_table_create arc_elf_link_hash_table_create
2592 #define bfd_elf32_bfd_merge_private_bfd_data arc_elf_merge_private_bfd_data
2593 #define bfd_elf32_bfd_reloc_type_lookup arc_elf32_bfd_reloc_type_lookup
2594 #define bfd_elf32_bfd_set_private_flags arc_elf_set_private_flags
2595 #define bfd_elf32_bfd_print_private_bfd_data arc_elf_print_private_bfd_data
2596 #define bfd_elf32_bfd_copy_private_bfd_data arc_elf_copy_private_bfd_data
2598 #define elf_info_to_howto_rel arc_info_to_howto_rel
2599 #define elf_backend_object_p arc_elf_object_p
2600 #define elf_backend_final_write_processing arc_elf_final_write_processing
2602 #define elf_backend_relocate_section elf_arc_relocate_section
2603 #define elf_backend_check_relocs elf_arc_check_relocs
2604 #define elf_backend_create_dynamic_sections arc_elf_create_dynamic_sections
2606 #define elf_backend_reloc_type_class elf32_arc_reloc_type_class
2608 #define elf_backend_adjust_dynamic_symbol elf_arc_adjust_dynamic_symbol
2609 #define elf_backend_finish_dynamic_symbol elf_arc_finish_dynamic_symbol
2611 #define elf_backend_finish_dynamic_sections elf_arc_finish_dynamic_sections
2612 #define elf_backend_size_dynamic_sections elf_arc_size_dynamic_sections
2613 #define elf_backend_add_symbol_hook elf_arc_add_symbol_hook
2615 #define elf_backend_can_gc_sections 1
2616 #define elf_backend_want_got_plt 1
2617 #define elf_backend_plt_readonly 1
2618 #define elf_backend_rela_plts_and_copies_p 1
2619 #define elf_backend_want_plt_sym 0
2620 #define elf_backend_got_header_size 12
2622 #define elf_backend_may_use_rel_p 0
2623 #define elf_backend_may_use_rela_p 1
2624 #define elf_backend_default_use_rela_p 1
2626 #define elf_backend_grok_prstatus elf32_arc_grok_prstatus
2628 #define elf_backend_default_execstack 0
2630 #include "elf32-target.h"