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"
32 # define PR_DEBUG(fmt, args...) fprintf (stderr, fmt, ##args)
34 # define PR_DEBUG(fmt, args...)
37 /* #define ARC_ENABLE_DEBUG 1 */
38 #ifndef ARC_ENABLE_DEBUG
39 #define ARC_DEBUG(...)
42 name_for_global_symbol (struct elf_link_hash_entry
*h
)
44 static char *local_str
= "(local)";
48 return h
->root
.root
.string
;
50 #define ARC_DEBUG(args...) fprintf (stderr, ##args)
54 #define ADD_RELA(BFD, SECTION, OFFSET, SYM_IDX, TYPE, ADDEND) \
56 struct elf_link_hash_table *_htab = elf_hash_table (info); \
57 Elf_Internal_Rela _rel; \
60 _loc = _htab->srel##SECTION->contents \
61 + ((_htab->srel##SECTION->reloc_count) \
62 * sizeof (Elf32_External_Rela)); \
63 _htab->srel##SECTION->reloc_count++; \
64 _rel.r_addend = ADDEND; \
65 _rel.r_offset = (_htab->s##SECTION)->output_section->vma \
66 + (_htab->s##SECTION)->output_offset + OFFSET; \
67 _rel.r_info = ELF32_R_INFO (SYM_IDX, TYPE); \
68 bfd_elf32_swap_reloca_out (BFD, &_rel, _loc); \
73 bfd_vma sdata_begin_symbol_vma
;
74 asection
* sdata_output_section
;
75 bfd_vma got_symbol_vma
;
78 struct arc_local_data global_arc_data
=
80 .sdata_begin_symbol_vma
= 0,
81 .sdata_output_section
= NULL
,
85 struct dynamic_sections
87 bfd_boolean initialized
;
91 asection
* srelgotplt
;
97 enum dyn_section_types
105 DYN_SECTION_TYPES_END
108 const char * dyn_section_names
[DYN_SECTION_TYPES_END
] =
137 struct got_entry
*next
;
138 enum tls_type_e type
;
140 bfd_boolean processed
;
141 bfd_boolean created_dyn_relocation
;
142 enum tls_got_entries existing_entries
;
146 new_got_entry_to_list (struct got_entry
**list
,
147 enum tls_type_e type
,
149 enum tls_got_entries existing_entries
)
151 /* Find list end. Avoid having multiple entries of the same
153 struct got_entry
**p
= list
;
156 if ((*p
)->type
== type
)
161 struct got_entry
*entry
=
162 (struct got_entry
*) malloc (sizeof(struct got_entry
));
165 entry
->offset
= offset
;
167 entry
->processed
= FALSE
;
168 entry
->created_dyn_relocation
= FALSE
;
169 entry
->existing_entries
= existing_entries
;
171 /* Add the entry to the end of the list. */
176 symbol_has_entry_of_type (struct got_entry
*list
, enum tls_type_e type
)
180 if (list
->type
== type
)
188 /* The default symbols representing the init and fini dyn values.
189 TODO: Check what is the relation of those strings with arclinux.em
191 #define INIT_SYM_STRING "_init"
192 #define FINI_SYM_STRING "_fini"
194 char * init_str
= INIT_SYM_STRING
;
195 char * fini_str
= FINI_SYM_STRING
;
197 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
202 static ATTRIBUTE_UNUSED
const char *
203 reloc_type_to_name (unsigned int type
)
207 #include "elf/arc-reloc.def"
214 #undef ARC_RELOC_HOWTO
216 /* Try to minimize the amount of space occupied by relocation tables
217 on the ROM (not that the ROM won't be swamped by other ELF overhead). */
221 static ATTRIBUTE_UNUSED bfd_boolean
222 is_reloc_PC_relative (reloc_howto_type
*howto
)
224 return (strstr (howto
->name
, "PC") != NULL
) ? TRUE
: FALSE
;
228 is_reloc_SDA_relative (reloc_howto_type
*howto
)
230 return (strstr (howto
->name
, "SDA") != NULL
) ? TRUE
: FALSE
;
234 is_reloc_for_GOT (reloc_howto_type
* howto
)
236 if (strstr (howto
->name
, "TLS") != NULL
)
238 return (strstr (howto
->name
, "GOT") != NULL
) ? TRUE
: FALSE
;
242 is_reloc_for_PLT (reloc_howto_type
* howto
)
244 return (strstr (howto
->name
, "PLT") != NULL
) ? TRUE
: FALSE
;
248 is_reloc_for_TLS (reloc_howto_type
*howto
)
250 return (strstr (howto
->name
, "TLS") != NULL
) ? TRUE
: FALSE
;
253 #define arc_bfd_get_8(A,B,C) bfd_get_8(A,B)
254 #define arc_bfd_get_16(A,B,C) bfd_get_16(A,B)
255 #define arc_bfd_put_8(A,B,C,D) bfd_put_8(A,B,C)
256 #define arc_bfd_put_16(A,B,C,D) bfd_put_16(A,B,C)
259 arc_bfd_get_32 (bfd
* abfd
, void *loc
, asection
* input_section
)
261 long insn
= bfd_get_32 (abfd
, loc
);
263 if (!bfd_big_endian (abfd
)
265 && (input_section
->flags
& SEC_CODE
))
266 insn
= ((0x0000fffff & insn
) << 16) | ((0xffff0000 & insn
) >> 16);
272 arc_bfd_put_32 (bfd
* abfd
, long insn
, void *loc
, asection
* input_section
)
274 if (!bfd_big_endian (abfd
)
276 && (input_section
->flags
& SEC_CODE
))
277 insn
= ((0x0000fffff & insn
) << 16) | ((0xffff0000 & insn
) >> 16);
279 bfd_put_32 (abfd
, insn
, loc
);
282 static bfd_reloc_status_type
283 arc_elf_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
284 arelent
*reloc_entry
,
286 void *data ATTRIBUTE_UNUSED
,
287 asection
*input_section
,
289 char ** error_message ATTRIBUTE_UNUSED
)
291 if (output_bfd
!= NULL
)
293 reloc_entry
->address
+= input_section
->output_offset
;
295 /* In case of relocateable link and if the reloc is against a
296 section symbol, the addend needs to be adjusted according to
297 where the section symbol winds up in the output section. */
298 if ((symbol_in
->flags
& BSF_SECTION_SYM
) && symbol_in
->section
)
299 reloc_entry
->addend
+= symbol_in
->section
->output_offset
;
304 return bfd_reloc_continue
;
308 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
312 #include "elf/arc-reloc.def"
315 #undef ARC_RELOC_HOWTO
317 #define ARC_RELOC_HOWTO(TYPE, VALUE, RSIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
318 [TYPE] = HOWTO (R_##TYPE, 0, RSIZE, BITSIZE, FALSE, 0, complain_overflow_##OVERFLOW, arc_elf_reloc, "R_" #TYPE, FALSE, 0, 0, FALSE),
320 static struct reloc_howto_struct elf_arc_howto_table
[] =
322 #include "elf/arc-reloc.def"
323 /* Example of what is generated by the preprocessor. Currently kept as an
325 HOWTO (R_ARC_NONE, // Type.
327 2, // Size (0 = byte, 1 = short, 2 = long).
329 FALSE, // PC_relative.
331 complain_overflow_bitfield, // Complain_on_overflow.
332 bfd_elf_generic_reloc, // Special_function.
333 "R_ARC_NONE", // Name.
334 TRUE, // Partial_inplace.
337 FALSE), // PCrel_offset.
340 #undef ARC_RELOC_HOWTO
342 static void arc_elf_howto_init (void)
344 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
345 elf_arc_howto_table[TYPE].pc_relative = \
346 (strstr (#FORMULA, " P ") != NULL || strstr (#FORMULA, " PDATA ") != NULL); \
347 elf_arc_howto_table[TYPE].dst_mask = RELOC_FUNCTION(0, ~0);
349 #include "elf/arc-reloc.def"
351 #undef ARC_RELOC_HOWTO
354 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
356 const int howto_table_lookup
[] =
358 #include "elf/arc-reloc.def"
360 #undef ARC_RELOC_HOWTO
362 static reloc_howto_type
*
363 arc_elf_howto (unsigned int r_type
)
365 if (elf_arc_howto_table
[R_ARC_32
].dst_mask
== 0)
366 arc_elf_howto_init ();
367 return &elf_arc_howto_table
[r_type
];
370 /* Map BFD reloc types to ARC ELF reloc types. */
374 bfd_reloc_code_real_type bfd_reloc_val
;
375 unsigned char elf_reloc_val
;
378 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
379 { BFD_RELOC_##TYPE, R_##TYPE },
380 static const struct arc_reloc_map arc_reloc_map
[] =
382 #include "elf/arc-reloc.def"
384 {BFD_RELOC_NONE
, R_ARC_NONE
},
385 {BFD_RELOC_8
, R_ARC_8
},
386 {BFD_RELOC_16
, R_ARC_16
},
387 {BFD_RELOC_24
, R_ARC_24
},
388 {BFD_RELOC_32
, R_ARC_32
},
390 #undef ARC_RELOC_HOWTO
392 static reloc_howto_type
*
393 arc_elf32_bfd_reloc_type_lookup (bfd
* abfd ATTRIBUTE_UNUSED
,
394 bfd_reloc_code_real_type code
)
398 for (i
= ARRAY_SIZE (arc_reloc_map
); i
--;)
400 if (arc_reloc_map
[i
].bfd_reloc_val
== code
)
401 return arc_elf_howto (arc_reloc_map
[i
].elf_reloc_val
);
407 /* Function to set the ELF flag bits. */
409 arc_elf_set_private_flags (bfd
*abfd
, flagword flags
)
411 elf_elfheader (abfd
)->e_flags
= flags
;
412 elf_flags_init (abfd
) = TRUE
;
416 /* Print private flags. */
418 arc_elf_print_private_bfd_data (bfd
*abfd
, void * ptr
)
420 FILE *file
= (FILE *) ptr
;
423 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
425 /* Print normal ELF private data. */
426 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
428 flags
= elf_elfheader (abfd
)->e_flags
;
429 fprintf (file
, _("private flags = 0x%lx:"), (unsigned long) flags
);
431 switch (flags
& EF_ARC_MACH_MSK
)
433 case EF_ARC_CPU_GENERIC
: fprintf (file
, " -mcpu=generic"); break;
434 case EF_ARC_CPU_ARCV2HS
: fprintf (file
, " -mcpu=ARCv2HS"); break;
435 case EF_ARC_CPU_ARCV2EM
: fprintf (file
, " -mcpu=ARCv2EM"); break;
436 case E_ARC_MACH_ARC600
: fprintf (file
, " -mcpu=ARC600"); break;
437 case E_ARC_MACH_ARC601
: fprintf (file
, " -mcpu=ARC601"); break;
438 case E_ARC_MACH_ARC700
: fprintf (file
, " -mcpu=ARC700"); break;
440 fprintf (file
, "-mcpu=unknown");
444 switch (flags
& EF_ARC_OSABI_MSK
)
446 case E_ARC_OSABI_ORIG
: fprintf (file
, " (ABI:legacy)"); break;
447 case E_ARC_OSABI_V2
: fprintf (file
, " (ABI:v2)"); break;
448 case E_ARC_OSABI_V3
: fprintf (file
, " (ABI:v3)"); break;
450 fprintf (file
, "(ABI:unknown)");
458 /* Copy backend specific data from one object module to another. */
461 arc_elf_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
463 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
464 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
467 BFD_ASSERT (!elf_flags_init (obfd
)
468 || elf_elfheader (obfd
)->e_flags
== elf_elfheader (ibfd
)->e_flags
);
470 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
471 elf_flags_init (obfd
) = TRUE
;
473 /* Copy object attributes. */
474 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
476 return _bfd_elf_copy_private_bfd_data (ibfd
, obfd
);
479 static reloc_howto_type
*
480 bfd_elf32_bfd_reloc_name_lookup (bfd
* abfd ATTRIBUTE_UNUSED
,
485 for (i
= 0; i
< ARRAY_SIZE (elf_arc_howto_table
); i
++)
486 if (elf_arc_howto_table
[i
].name
!= NULL
487 && strcasecmp (elf_arc_howto_table
[i
].name
, r_name
) == 0)
488 return arc_elf_howto (i
);
493 /* Set the howto pointer for an ARC ELF reloc. */
496 arc_info_to_howto_rel (bfd
* abfd ATTRIBUTE_UNUSED
,
498 Elf_Internal_Rela
* dst
)
502 r_type
= ELF32_R_TYPE (dst
->r_info
);
503 BFD_ASSERT (r_type
< (unsigned int) R_ARC_max
);
504 cache_ptr
->howto
= arc_elf_howto (r_type
);
507 /* Merge backend specific data from an object file to the output
508 object file when linking. */
511 arc_elf_merge_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
513 unsigned short mach_ibfd
;
514 static unsigned short mach_obfd
= EM_NONE
;
519 /* Check if we have the same endianess. */
520 if (! _bfd_generic_verify_endian_match (ibfd
, obfd
))
522 _bfd_error_handler (_("ERROR: Endian Match failed. Attempting to link "
523 "%B with binary %s of opposite endian-ness"),
524 ibfd
, bfd_get_filename (obfd
));
528 /* Collect ELF flags. */
529 in_flags
= elf_elfheader (ibfd
)->e_flags
& EF_ARC_MACH_MSK
;
530 out_flags
= elf_elfheader (obfd
)->e_flags
& EF_ARC_MACH_MSK
;
532 if (!elf_flags_init (obfd
)) /* First call, no flags set. */
534 elf_flags_init (obfd
) = TRUE
;
535 out_flags
= in_flags
;
538 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
539 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
542 /* Check to see if the input BFD actually contains any sections. Do
543 not short-circuit dynamic objects; their section list may be
544 emptied by elf_link_add_object_symbols. */
545 if (!(ibfd
->flags
& DYNAMIC
))
547 bfd_boolean null_input_bfd
= TRUE
;
548 bfd_boolean only_data_sections
= TRUE
;
550 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
552 if ((bfd_get_section_flags (ibfd
, sec
)
553 & (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
554 == (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
555 only_data_sections
= FALSE
;
557 null_input_bfd
= FALSE
;
560 if (null_input_bfd
|| only_data_sections
)
564 /* Complain about various flag/architecture mismatches. */
565 mach_ibfd
= elf_elfheader (ibfd
)->e_machine
;
566 if (mach_obfd
== EM_NONE
)
568 mach_obfd
= mach_ibfd
;
572 if (mach_ibfd
!= mach_obfd
)
574 _bfd_error_handler (_("ERROR: Attempting to link %B "
575 "with a binary %s of different architecture"),
576 ibfd
, bfd_get_filename (obfd
));
579 else if (in_flags
!= out_flags
)
581 /* Warn if different flags. */
582 (*_bfd_error_handler
)
583 (_("%s: uses different e_flags (0x%lx) fields than "
584 "previous modules (0x%lx)"),
585 bfd_get_filename (ibfd
), (long)in_flags
, (long)out_flags
);
586 if (in_flags
&& out_flags
)
588 /* MWDT doesnt set the eflags hence make sure we choose the
589 eflags set by gcc. */
590 in_flags
= in_flags
> out_flags
? in_flags
: out_flags
;
594 /* Update the flags. */
595 elf_elfheader (obfd
)->e_flags
= in_flags
;
597 if (bfd_get_mach (obfd
) < bfd_get_mach (ibfd
))
599 return bfd_set_arch_mach (obfd
, bfd_arch_arc
, bfd_get_mach (ibfd
));
605 /* Set the right machine number for an ARC ELF file. */
607 arc_elf_object_p (bfd
* abfd
)
609 /* Make sure this is initialised, or you'll have the potential of passing
610 garbage---or misleading values---into the call to
611 bfd_default_set_arch_mach (). */
612 int mach
= bfd_mach_arc_arc700
;
613 unsigned long arch
= elf_elfheader (abfd
)->e_flags
& EF_ARC_MACH_MSK
;
614 unsigned e_machine
= elf_elfheader (abfd
)->e_machine
;
616 if (e_machine
== EM_ARC_COMPACT
|| e_machine
== EM_ARC_COMPACT2
)
620 case E_ARC_MACH_ARC600
:
621 mach
= bfd_mach_arc_arc600
;
623 case E_ARC_MACH_ARC601
:
624 mach
= bfd_mach_arc_arc601
;
626 case E_ARC_MACH_ARC700
:
627 mach
= bfd_mach_arc_arc700
;
629 case EF_ARC_CPU_ARCV2HS
:
630 case EF_ARC_CPU_ARCV2EM
:
631 mach
= bfd_mach_arc_arcv2
;
634 mach
= (e_machine
== EM_ARC_COMPACT
) ?
635 bfd_mach_arc_arc700
: bfd_mach_arc_arcv2
;
641 if (e_machine
== EM_ARC
)
643 (*_bfd_error_handler
)
644 (_("Error: The ARC4 architecture is no longer supported.\n"));
649 (*_bfd_error_handler
)
650 (_("Warning: unset or old architecture flags. \n"
651 " Use default machine.\n"));
655 return bfd_default_set_arch_mach (abfd
, bfd_arch_arc
, mach
);
658 /* The final processing done just before writing out an ARC ELF object file.
659 This gets the ARC architecture right based on the machine number. */
662 arc_elf_final_write_processing (bfd
* abfd
,
663 bfd_boolean linker ATTRIBUTE_UNUSED
)
668 switch (bfd_get_mach (abfd
))
670 case bfd_mach_arc_arc600
:
671 val
= E_ARC_MACH_ARC600
;
672 emf
= EM_ARC_COMPACT
;
674 case bfd_mach_arc_arc601
:
675 val
= E_ARC_MACH_ARC601
;
676 emf
= EM_ARC_COMPACT
;
678 case bfd_mach_arc_arc700
:
679 val
= E_ARC_MACH_ARC700
;
680 emf
= EM_ARC_COMPACT
;
682 case bfd_mach_arc_arcv2
:
683 val
= EF_ARC_CPU_GENERIC
;
684 emf
= EM_ARC_COMPACT2
;
685 /* TODO: Check validity of this. It can also be ARCV2EM here.
686 Previous version sets the e_machine here. */
691 if ((elf_elfheader (abfd
)->e_flags
& EF_ARC_MACH
) == EF_ARC_CPU_GENERIC
)
692 elf_elfheader (abfd
)->e_flags
|= val
;
694 elf_elfheader (abfd
)->e_machine
= emf
;
696 /* Record whatever is the current syscall ABI version. */
697 elf_elfheader (abfd
)->e_flags
|= E_ARC_OSABI_CURRENT
;
700 #define BFD_DEBUG_PIC(...)
702 struct arc_relocation_data
704 bfd_vma reloc_offset
;
705 bfd_vma reloc_addend
;
706 bfd_vma got_offset_value
;
709 asection
* sym_section
;
711 reloc_howto_type
*howto
;
713 asection
* input_section
;
715 bfd_vma sdata_begin_symbol_vma
;
716 bfd_boolean sdata_begin_symbol_vma_set
;
717 bfd_vma got_symbol_vma
;
719 bfd_boolean should_relocate
;
723 debug_arc_reloc (struct arc_relocation_data reloc_data
)
725 PR_DEBUG ("Reloc type=%s, should_relocate = %s\n",
726 reloc_data
.howto
->name
,
727 reloc_data
.should_relocate
? "true" : "false");
728 PR_DEBUG (" offset = 0x%x, addend = 0x%x\n",
729 (unsigned int) reloc_data
.reloc_offset
,
730 (unsigned int) reloc_data
.reloc_addend
);
731 PR_DEBUG (" Symbol:\n");
732 PR_DEBUG (" value = 0x%08x\n",
733 (unsigned int) reloc_data
.sym_value
);
734 if (reloc_data
.sym_section
!= NULL
)
736 PR_DEBUG ("IN IF\n");
738 " section name = %s, output_offset 0x%08x",
739 reloc_data
.sym_section
->name
,
740 (unsigned int) reloc_data
.sym_section
->output_offset
);
741 if (reloc_data
.sym_section
->output_section
!= NULL
)
744 ", output_section->vma = 0x%08x",
745 ((unsigned int) reloc_data
.sym_section
->output_section
->vma
));
752 PR_DEBUG ( " symbol section is NULL\n");
755 PR_DEBUG ( " Input_section:\n");
756 if (reloc_data
.input_section
!= NULL
)
759 " 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 PR_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
));
770 PR_DEBUG ( " input section is NULL\n");
774 static ATTRIBUTE_UNUSED bfd_vma
775 get_middle_endian_relocation (bfd_vma reloc
)
777 bfd_vma ret
= ((reloc
& 0xffff0000) >> 16) |
778 ((reloc
& 0xffff) << 16);
782 #define S (reloc_data.sym_value \
783 + (reloc_data.sym_section->output_section != NULL ? \
784 (reloc_data.sym_section->output_offset \
785 + reloc_data.sym_section->output_section->vma) : 0) \
787 #define L (reloc_data.sym_value \
788 + (reloc_data.sym_section->output_section != NULL ? \
789 (reloc_data.sym_section->output_offset \
790 + reloc_data.sym_section->output_section->vma) : 0) \
792 #define A (reloc_data.reloc_addend)
794 #define G (reloc_data.got_offset_value)
795 #define GOT (reloc_data.got_symbol_vma)
796 #define GOT_BEGIN (htab->sgot->output_section->vma)
799 /* P: relative offset to PCL The offset should be to the
800 current location aligned to 32 bits. */
803 (reloc_data.input_section->output_section != NULL ? \
804 reloc_data.input_section->output_section->vma : 0) \
805 + reloc_data.input_section->output_offset \
806 + (reloc_data.reloc_offset - (bitsize >= 32 ? 4 : 0)) \
809 (reloc_data.input_section->output_section->vma \
810 + reloc_data.input_section->output_offset \
811 + (reloc_data.reloc_offset) \
813 #define SECTSTAR (reloc_data.input_section->output_offset)
814 #define SECTSTART (reloc_data.input_section->output_offset)
815 #define _SDA_BASE_ (reloc_data.sdata_begin_symbol_vma)
816 #define TLS_REL ((elf_hash_table (info))->tls_sec->output_section->vma)
817 #define _SDA_BASE_ (reloc_data.sdata_begin_symbol_vma)
821 #define NON_ME(VALUE) (reverse_me (reloc_data, VALUE))
825 #define PRINT_DEBUG_RELOC_INFO_BEFORE(FORMULA) \
827 asection *sym_section = reloc_data.sym_section; \
828 asection *input_section = reloc_data.input_section; \
829 ARC_DEBUG ("FORMULA = " #FORMULA "\n"); \
830 ARC_DEBUG ("S = 0x%x\n", S); \
831 ARC_DEBUG ("A = 0x%x\n", A); \
832 ARC_DEBUG ("L = 0x%x\n", L); \
833 if (sym_section->output_section != NULL) \
835 ARC_DEBUG ("symbol_section->vma = 0x%x\n", \
836 sym_section->output_section->vma + sym_section->output_offset); \
840 ARC_DEBUG ("symbol_section->vma = NULL\n"); \
842 if (input_section->output_section != NULL) \
844 ARC_DEBUG ("symbol_section->vma = 0x%x\n", \
845 input_section->output_section->vma + input_section->output_offset); \
849 ARC_DEBUG ("symbol_section->vma = NULL\n"); \
851 ARC_DEBUG ("PCL = 0x%x\n", P); \
852 ARC_DEBUG ("P = 0x%x\n", P); \
853 ARC_DEBUG ("G = 0x%x\n", G); \
854 ARC_DEBUG ("SDA_OFFSET = 0x%x\n", _SDA_BASE_); \
855 ARC_DEBUG ("SDA_SET = %d\n", reloc_data.sdata_begin_symbol_vma_set); \
856 ARC_DEBUG ("GOT_OFFSET = 0x%x\n", GOT); \
857 ARC_DEBUG ("relocation = 0x%08x\n", relocation); \
858 ARC_DEBUG ("before = 0x%08x\n", (unsigned int) insn); \
859 ARC_DEBUG ("data = 0x%08x (%u) (%d)\n", (unsigned int) relocation, (unsigned int) relocation, (int) relocation); \
862 #define PRINT_DEBUG_RELOC_INFO_AFTER \
864 ARC_DEBUG ("after = 0x%08x\n", (unsigned int) insn); \
867 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
870 bfd_vma bitsize ATTRIBUTE_UNUSED = BITSIZE; \
871 relocation = FORMULA ; \
872 PRINT_DEBUG_RELOC_INFO_BEFORE(FORMULA) \
873 insn = RELOC_FUNCTION (insn, relocation); \
874 PRINT_DEBUG_RELOC_INFO_AFTER \
879 reverse_me (struct arc_relocation_data reloc_data
, bfd_vma reloc
)
881 if (reloc_data
.input_section
&& reloc_data
.input_section
->flags
& SEC_CODE
)
882 return ((0x0000fffff & reloc
) << 16) | ((0xffff0000 & reloc
) >> 16);
887 static bfd_reloc_status_type
888 arc_do_relocation (bfd_byte
* contents
,
889 struct arc_relocation_data reloc_data
,
890 struct bfd_link_info
*info
)
892 bfd_vma relocation
= 0;
894 bfd_vma orig_insn ATTRIBUTE_UNUSED
;
895 struct elf_link_hash_table
*htab ATTRIBUTE_UNUSED
= elf_hash_table (info
);
897 if (reloc_data
.should_relocate
== FALSE
)
900 switch (reloc_data
.howto
->size
)
903 insn
= arc_bfd_get_32 (reloc_data
.input_section
->owner
,
904 contents
+ reloc_data
.reloc_offset
,
905 reloc_data
.input_section
);
909 insn
= arc_bfd_get_16 (reloc_data
.input_section
->owner
,
910 contents
+ reloc_data
.reloc_offset
,
911 reloc_data
.input_section
);
921 switch (reloc_data
.howto
->type
)
923 #include "elf/arc-reloc.def"
930 /* Check for relocation overflow. */
931 if (reloc_data
.howto
->complain_on_overflow
!= complain_overflow_dont
)
933 bfd_reloc_status_type flag
;
934 flag
= bfd_check_overflow (reloc_data
.howto
->complain_on_overflow
,
935 reloc_data
.howto
->bitsize
,
936 reloc_data
.howto
->rightshift
,
937 bfd_arch_bits_per_address (reloc_data
.input_section
->owner
),
940 #undef DEBUG_ARC_RELOC
941 #define DEBUG_ARC_RELOC(A) debug_arc_reloc (A)
942 if (flag
!= bfd_reloc_ok
)
944 PR_DEBUG ( "Relocation overflows !!!!\n");
946 DEBUG_ARC_RELOC (reloc_data
);
949 "Relocation value = signed -> %d, unsigned -> %u"
950 ", hex -> (0x%08x)\n",
952 (unsigned int) relocation
,
953 (unsigned int) relocation
);
957 #undef DEBUG_ARC_RELOC
958 #define DEBUG_ARC_RELOC(A)
960 switch (reloc_data
.howto
->size
)
963 arc_bfd_put_32 (reloc_data
.input_section
->owner
, insn
,
964 contents
+ reloc_data
.reloc_offset
,
965 reloc_data
.input_section
);
969 arc_bfd_put_16 (reloc_data
.input_section
->owner
, insn
,
970 contents
+ reloc_data
.reloc_offset
,
971 reloc_data
.input_section
);
974 ARC_DEBUG ("size = %d\n", reloc_data
.howto
->size
);
994 #undef ARC_RELOC_HOWTO
996 static struct got_entry
**
997 arc_get_local_got_ents (bfd
* abfd
)
999 static struct got_entry
**local_got_ents
= NULL
;
1001 if (local_got_ents
== NULL
)
1004 Elf_Internal_Shdr
*symtab_hdr
= &((elf_tdata (abfd
))->symtab_hdr
);
1006 size
= symtab_hdr
->sh_info
* sizeof (bfd_vma
);
1007 local_got_ents
= (struct got_entry
**)
1008 bfd_alloc (abfd
, sizeof(struct got_entry
*) * size
);
1009 if (local_got_ents
== NULL
)
1012 memset (local_got_ents
, 0, sizeof(struct got_entry
*) * size
);
1013 elf_local_got_ents (abfd
) = local_got_ents
;
1016 return local_got_ents
;
1019 /* Relocate an arc ELF section.
1020 Function : elf_arc_relocate_section
1021 Brief : Relocate an arc section, by handling all the relocations
1022 appearing in that section.
1023 Args : output_bfd : The bfd being written to.
1024 info : Link information.
1025 input_bfd : The input bfd.
1026 input_section : The section being relocated.
1027 contents : contents of the section being relocated.
1028 relocs : List of relocations in the section.
1029 local_syms : is a pointer to the swapped in local symbols.
1030 local_section : is an array giving the section in the input file
1031 corresponding to the st_shndx field of each
1034 elf_arc_relocate_section (bfd
* output_bfd
,
1035 struct bfd_link_info
* info
,
1037 asection
* input_section
,
1038 bfd_byte
* contents
,
1039 Elf_Internal_Rela
* relocs
,
1040 Elf_Internal_Sym
* local_syms
,
1041 asection
** local_sections
)
1043 Elf_Internal_Shdr
* symtab_hdr
;
1044 struct elf_link_hash_entry
** sym_hashes
;
1045 struct got_entry
** local_got_ents
;
1046 Elf_Internal_Rela
* rel
;
1047 Elf_Internal_Rela
* relend
;
1048 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
1050 symtab_hdr
= &((elf_tdata (input_bfd
))->symtab_hdr
);
1051 sym_hashes
= elf_sym_hashes (input_bfd
);
1054 relend
= relocs
+ input_section
->reloc_count
;
1055 for (; rel
< relend
; rel
++)
1057 enum elf_arc_reloc_type r_type
;
1058 reloc_howto_type
* howto
;
1059 unsigned long r_symndx
;
1060 struct elf_link_hash_entry
* h
;
1061 Elf_Internal_Sym
* sym
;
1063 struct elf_link_hash_entry
*h2
;
1065 struct arc_relocation_data reloc_data
=
1069 .got_offset_value
= 0,
1071 .sym_section
= NULL
,
1073 .input_section
= NULL
,
1074 .sdata_begin_symbol_vma
= 0,
1075 .sdata_begin_symbol_vma_set
= FALSE
,
1076 .got_symbol_vma
= 0,
1077 .should_relocate
= FALSE
1080 r_type
= ELF32_R_TYPE (rel
->r_info
);
1082 if (r_type
>= (int) R_ARC_max
)
1084 bfd_set_error (bfd_error_bad_value
);
1087 howto
= &elf_arc_howto_table
[r_type
];
1089 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1091 /* If we are generating another .o file and the symbol in not
1092 local, skip this relocation. */
1093 if (bfd_link_relocatable (info
))
1095 /* This is a relocateable link. We don't have to change
1096 anything, unless the reloc is against a section symbol,
1097 in which case we have to adjust according to where the
1098 section symbol winds up in the output section. */
1100 /* Checks if this is a local symbol and thus the reloc
1101 might (will??) be against a section symbol. */
1102 if (r_symndx
< symtab_hdr
->sh_info
)
1104 sym
= local_syms
+ r_symndx
;
1105 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1107 sec
= local_sections
[r_symndx
];
1109 /* for RELA relocs.Just adjust the addend
1110 value in the relocation entry. */
1111 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
1114 PR_DEBUG ("local symbols reloc "
1115 "(section=%d %s) seen in %s\n",
1117 local_sections
[r_symndx
]->name
,
1118 __PRETTY_FUNCTION__
)
1126 h2
= elf_link_hash_lookup (elf_hash_table (info
), "__SDATA_BEGIN__",
1127 FALSE
, FALSE
, TRUE
);
1129 if (reloc_data
.sdata_begin_symbol_vma_set
== FALSE
1130 && h2
!= NULL
&& h2
->root
.type
!= bfd_link_hash_undefined
1131 && h2
->root
.u
.def
.section
->output_section
!= NULL
)
1132 /* TODO: Verify this condition. */
1134 reloc_data
.sdata_begin_symbol_vma
=
1135 (h2
->root
.u
.def
.value
+
1136 h2
->root
.u
.def
.section
->output_section
->vma
);
1137 reloc_data
.sdata_begin_symbol_vma_set
= TRUE
;
1140 reloc_data
.input_section
= input_section
;
1141 reloc_data
.howto
= howto
;
1142 reloc_data
.reloc_offset
= rel
->r_offset
;
1143 reloc_data
.reloc_addend
= rel
->r_addend
;
1145 /* This is a final link. */
1150 if (r_symndx
< symtab_hdr
->sh_info
) /* A local symbol. */
1152 local_got_ents
= arc_get_local_got_ents (output_bfd
);
1153 struct got_entry
*entry
= local_got_ents
[r_symndx
];
1155 sym
= local_syms
+ r_symndx
;
1156 sec
= local_sections
[r_symndx
];
1158 reloc_data
.sym_value
= sym
->st_value
;
1159 reloc_data
.sym_section
= sec
;
1161 if ((is_reloc_for_GOT (howto
)
1162 || is_reloc_for_TLS (howto
)) && entry
!= NULL
)
1164 if (is_reloc_for_TLS (howto
))
1165 while (entry
->type
== GOT_NORMAL
&& entry
->next
!= NULL
)
1166 entry
= entry
->next
;
1168 if (is_reloc_for_GOT (howto
))
1169 while (entry
->type
!= GOT_NORMAL
&& entry
->next
!= NULL
)
1170 entry
= entry
->next
;
1172 if (entry
->type
== GOT_TLS_GD
&& entry
->processed
== FALSE
)
1174 bfd_vma sym_vma
= sym
->st_value
1175 + sec
->output_section
->vma
1176 + sec
->output_offset
;
1178 /* Create dynamic relocation for local sym. */
1179 ADD_RELA (output_bfd
, got
, entry
->offset
, 0,
1180 R_ARC_TLS_DTPMOD
, 0);
1181 ADD_RELA (output_bfd
, got
, entry
->offset
+4, 0,
1182 R_ARC_TLS_DTPOFF
, 0);
1184 bfd_vma sec_vma
= sec
->output_section
->vma
1185 + sec
->output_offset
;
1186 bfd_put_32 (output_bfd
, sym_vma
- sec_vma
,
1187 htab
->sgot
->contents
+ entry
->offset
+ 4);
1189 ARC_DEBUG ("arc_info: FIXED -> GOT_TLS_GD value "
1190 "= 0x%x @ 0x%x, for symbol %s\n",
1192 htab
->sgot
->contents
+ entry
->offset
+ 4,
1195 entry
->processed
= TRUE
;
1197 if (entry
->type
== GOT_TLS_IE
&& entry
->processed
== FALSE
)
1199 bfd_vma sym_vma
= sym
->st_value
1200 + sec
->output_section
->vma
1201 + sec
->output_offset
;
1202 bfd_vma sec_vma
= htab
->tls_sec
->output_section
->vma
;
1203 bfd_put_32 (output_bfd
, sym_vma
- sec_vma
,
1204 htab
->sgot
->contents
+ entry
->offset
);
1205 /* TODO: Check if this type of relocs is the cause
1206 for all the ARC_NONE dynamic relocs. */
1208 ARC_DEBUG ("arc_info: FIXED -> GOT_TLS_IE value = "
1209 "0x%x @ 0x%x, for symbol %s\n",
1211 htab
->sgot
->contents
+ entry
->offset
,
1214 entry
->processed
= TRUE
;
1216 if (entry
->type
== GOT_NORMAL
&& entry
->processed
== FALSE
)
1218 bfd_vma sec_vma
= reloc_data
.sym_section
->output_section
->vma
1219 + reloc_data
.sym_section
->output_offset
;
1221 bfd_put_32 (output_bfd
, reloc_data
.sym_value
+ sec_vma
,
1222 htab
->sgot
->contents
+ entry
->offset
);
1224 ARC_DEBUG ("arc_info: PATCHED: 0x%08x @ 0x%08x for "
1225 "sym %s in got offset 0x%x\n",
1226 reloc_data
.sym_value
+ sec_vma
,
1227 htab
->sgot
->output_section
->vma
1228 + htab
->sgot
->output_offset
+ entry
->offset
,
1231 entry
->processed
= TRUE
;
1234 reloc_data
.got_offset_value
= entry
->offset
;
1235 ARC_DEBUG ("arc_info: GOT_ENTRY = %d, offset = 0x%x, "
1236 "vma = 0x%x for symbol %s\n",
1237 entry
->type
, entry
->offset
,
1238 htab
->sgot
->output_section
->vma
1239 + htab
->sgot
->output_offset
+ entry
->offset
,
1243 BFD_ASSERT (htab
->sgot
!= NULL
|| !is_reloc_for_GOT (howto
));
1244 if (htab
->sgot
!= NULL
)
1245 reloc_data
.got_symbol_vma
= htab
->sgot
->output_section
->vma
1246 + htab
->sgot
->output_offset
;
1248 reloc_data
.should_relocate
= TRUE
;
1250 else /* Global symbol. */
1252 /* Get the symbol's entry in the symtab. */
1253 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1255 while (h
->root
.type
== bfd_link_hash_indirect
1256 || h
->root
.type
== bfd_link_hash_warning
)
1257 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1259 BFD_ASSERT ((h
->dynindx
== -1) >= (h
->forced_local
!= 0));
1260 /* If we have encountered a definition for this symbol. */
1261 if (h
->root
.type
== bfd_link_hash_defined
1262 || h
->root
.type
== bfd_link_hash_defweak
)
1264 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1265 reloc_data
.sym_section
= h
->root
.u
.def
.section
;
1267 reloc_data
.should_relocate
= TRUE
;
1269 if (is_reloc_for_GOT (howto
) && !bfd_link_pic (info
))
1271 /* TODO: Change it to use arc_do_relocation with
1272 ARC_32 reloc. Try to use ADD_RELA macro. */
1273 bfd_vma relocation
=
1274 reloc_data
.sym_value
+ reloc_data
.reloc_addend
1275 + (reloc_data
.sym_section
->output_section
!= NULL
?
1276 (reloc_data
.sym_section
->output_offset
1277 + reloc_data
.sym_section
->output_section
->vma
)
1280 BFD_ASSERT (h
->got
.glist
);
1281 bfd_vma got_offset
= h
->got
.glist
->offset
;
1282 bfd_put_32 (output_bfd
, relocation
,
1283 htab
->sgot
->contents
+ got_offset
);
1285 if (is_reloc_for_PLT (howto
) && h
->plt
.offset
!= (bfd_vma
) -1)
1287 /* TODO: This is repeated up here. */
1288 reloc_data
.sym_value
= h
->plt
.offset
;
1289 reloc_data
.sym_section
= htab
->splt
;
1292 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1294 /* Is weak symbol and has no definition. */
1295 if (is_reloc_for_GOT (howto
))
1297 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1298 reloc_data
.sym_section
= htab
->sgot
;
1299 reloc_data
.should_relocate
= TRUE
;
1301 else if (is_reloc_for_PLT (howto
)
1302 && h
->plt
.offset
!= (bfd_vma
) -1)
1304 /* TODO: This is repeated up here. */
1305 reloc_data
.sym_value
= h
->plt
.offset
;
1306 reloc_data
.sym_section
= htab
->splt
;
1307 reloc_data
.should_relocate
= TRUE
;
1314 if (is_reloc_for_GOT (howto
))
1316 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1317 reloc_data
.sym_section
= htab
->sgot
;
1319 reloc_data
.should_relocate
= TRUE
;
1321 else if (is_reloc_for_PLT (howto
))
1323 /* Fail if it is linking for PIE and the symbol is
1325 if (bfd_link_executable (info
)
1326 && !(*info
->callbacks
->undefined_symbol
)
1327 (info
, h
->root
.root
.string
, input_bfd
, input_section
,
1328 rel
->r_offset
, TRUE
))
1332 reloc_data
.sym_value
= h
->plt
.offset
;
1333 reloc_data
.sym_section
= htab
->splt
;
1335 reloc_data
.should_relocate
= TRUE
;
1337 else if (!bfd_link_pic (info
)
1338 && !(*info
->callbacks
->undefined_symbol
)
1339 (info
, h
->root
.root
.string
, input_bfd
, input_section
,
1340 rel
->r_offset
, TRUE
))
1346 if (h
->got
.glist
!= NULL
)
1348 struct got_entry
*entry
= h
->got
.glist
;
1350 if (is_reloc_for_GOT (howto
) || is_reloc_for_TLS (howto
))
1352 if (! elf_hash_table (info
)->dynamic_sections_created
1353 || (bfd_link_pic (info
)
1354 && SYMBOL_REFERENCES_LOCAL (info
, h
)))
1356 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
1357 reloc_data
.sym_section
= h
->root
.u
.def
.section
;
1359 if (is_reloc_for_TLS (howto
))
1360 while (entry
->type
== GOT_NORMAL
&& entry
->next
!= NULL
)
1361 entry
= entry
->next
;
1363 if (entry
->processed
== FALSE
1364 && (entry
->type
== GOT_TLS_GD
1365 || entry
->type
== GOT_TLS_IE
))
1367 bfd_vma sym_value
= h
->root
.u
.def
.value
1368 + h
->root
.u
.def
.section
->output_section
->vma
1369 + h
->root
.u
.def
.section
->output_offset
;
1372 elf_hash_table (info
)->tls_sec
->output_section
->vma
;
1374 bfd_put_32 (output_bfd
,
1375 sym_value
- sec_vma
,
1376 htab
->sgot
->contents
+ entry
->offset
1377 + (entry
->existing_entries
== MOD_AND_OFF
? 4 : 0));
1379 ARC_DEBUG ("arc_info: FIXED -> %s value = 0x%x "
1380 "@ 0x%x, for symbol %s\n",
1381 (entry
->type
== GOT_TLS_GD
? "GOT_TLS_GD" :
1383 sym_value
- sec_vma
,
1384 htab
->sgot
->contents
+ entry
->offset
1385 + (entry
->existing_entries
== MOD_AND_OFF
? 4 : 0),
1386 h
->root
.root
.string
);
1388 entry
->processed
= TRUE
;
1391 if (entry
->type
== GOT_TLS_IE
&& entry
->processed
== FALSE
)
1393 bfd_vma sec_vma
= htab
->tls_sec
->output_section
->vma
;
1394 bfd_put_32 (output_bfd
,
1395 reloc_data
.sym_value
- sec_vma
,
1396 htab
->sgot
->contents
+ entry
->offset
);
1399 if (entry
->type
== GOT_NORMAL
&& entry
->processed
== FALSE
)
1402 reloc_data
.sym_section
->output_section
->vma
1403 + reloc_data
.sym_section
->output_offset
;
1405 if (h
->root
.type
!= bfd_link_hash_undefweak
)
1407 bfd_put_32 (output_bfd
,
1408 reloc_data
.sym_value
+ sec_vma
,
1409 htab
->sgot
->contents
+ entry
->offset
);
1411 ARC_DEBUG ("arc_info: PATCHED: 0x%08x "
1412 "@ 0x%08x for sym %s in got offset 0x%x\n",
1413 reloc_data
.sym_value
+ sec_vma
,
1414 htab
->sgot
->output_section
->vma
1415 + htab
->sgot
->output_offset
+ entry
->offset
,
1416 h
->root
.root
.string
,
1421 ARC_DEBUG ("arc_info: PATCHED: NOT_PATCHED "
1422 "@ 0x%08x for sym %s in got offset 0x%x "
1424 htab
->sgot
->output_section
->vma
1425 + htab
->sgot
->output_offset
+ entry
->offset
,
1426 h
->root
.root
.string
,
1430 entry
->processed
= TRUE
;
1435 reloc_data
.got_offset_value
= entry
->offset
;
1437 ARC_DEBUG ("arc_info: GOT_ENTRY = %d, offset = 0x%x, "
1438 "vma = 0x%x for symbol %s\n",
1439 entry
->type
, entry
->offset
,
1440 htab
->sgot
->output_section
->vma
1441 + htab
->sgot
->output_offset
+ entry
->offset
,
1442 h
->root
.root
.string
);
1445 BFD_ASSERT (htab
->sgot
!= NULL
|| !is_reloc_for_GOT (howto
));
1446 if (htab
->sgot
!= NULL
)
1447 reloc_data
.got_symbol_vma
= htab
->sgot
->output_section
->vma
1448 + htab
->sgot
->output_offset
;
1456 case R_ARC_32_PCREL
:
1457 if (bfd_link_pic (info
) && !bfd_link_pie (info
)
1458 && ((r_type
!= R_ARC_PC32
&& r_type
!= R_ARC_32_PCREL
)
1461 && (!info
->symbolic
|| !h
->def_regular
))))
1463 Elf_Internal_Rela outrel
;
1465 bfd_boolean skip
= FALSE
;
1466 bfd_boolean relocate
= FALSE
;
1467 asection
*sreloc
= _bfd_elf_get_dynamic_reloc_section
1468 (input_bfd
, input_section
,
1471 BFD_ASSERT (sreloc
!= NULL
);
1473 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
1477 if (outrel
.r_offset
== (bfd_vma
) -1)
1480 outrel
.r_addend
= rel
->r_addend
;
1481 outrel
.r_offset
+= (input_section
->output_section
->vma
1482 + input_section
->output_offset
);
1486 memset (&outrel
, 0, sizeof outrel
);
1489 else if (r_type
== R_ARC_PC32
1490 || r_type
== R_ARC_32_PCREL
)
1492 BFD_ASSERT (h
!= NULL
&& h
->dynindx
!= -1);
1493 if ((input_section
->flags
& SEC_ALLOC
) != 0)
1497 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
1501 /* Handle local symbols, they either do not have a
1502 global hash table entry (h == NULL), or are
1503 forced local due to a version script
1504 (h->forced_local), or the third condition is
1505 legacy, it appears to say something like, for
1506 links where we are pre-binding the symbols, or
1507 there's not an entry for this symbol in the
1508 dynamic symbol table, and it's a regular symbol
1509 not defined in a shared object, then treat the
1510 symbol as local, resolve it now. */
1512 || ((info
->symbolic
|| h
->dynindx
== -1)
1517 /* outrel.r_addend = 0; */
1518 outrel
.r_info
= ELF32_R_INFO (0, R_ARC_RELATIVE
);
1522 BFD_ASSERT (h
->dynindx
!= -1);
1524 /* This type of dynamic relocation cannot be created
1525 for code sections. */
1526 BFD_ASSERT ((input_section
->flags
& SEC_CODE
) == 0);
1528 if ((input_section
->flags
& SEC_ALLOC
) != 0)
1532 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARC_32
);
1536 BFD_ASSERT (sreloc
->contents
!= 0);
1538 loc
= sreloc
->contents
;
1539 loc
+= sreloc
->reloc_count
* sizeof (Elf32_External_Rela
);
1540 sreloc
->reloc_count
+= 1;
1542 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
1544 if (relocate
== FALSE
)
1552 if (is_reloc_SDA_relative (howto
)
1553 && (reloc_data
.sdata_begin_symbol_vma_set
== FALSE
))
1555 (*_bfd_error_handler
)
1556 ("Error: Linker symbol __SDATA_BEGIN__ not found");
1557 bfd_set_error (bfd_error_bad_value
);
1561 DEBUG_ARC_RELOC (reloc_data
);
1563 if (arc_do_relocation (contents
, reloc_data
, info
) != bfd_reloc_ok
)
1570 static struct dynamic_sections
1571 arc_create_dynamic_sections (bfd
* abfd
, struct bfd_link_info
*info
)
1573 struct elf_link_hash_table
*htab
;
1575 struct dynamic_sections ds
=
1577 .initialized
= FALSE
,
1587 htab
= elf_hash_table (info
);
1590 /* Create dynamic sections for relocatable executables so that we
1591 can copy relocations. */
1592 if (! htab
->dynamic_sections_created
&& bfd_link_pic (info
))
1594 if (! _bfd_elf_link_create_dynamic_sections (abfd
, info
))
1598 dynobj
= (elf_hash_table (info
))->dynobj
;
1602 ds
.sgot
= htab
->sgot
;
1603 ds
.srelgot
= htab
->srelgot
;
1605 ds
.sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
1606 ds
.srelgotplt
= ds
.srelplt
;
1608 ds
.splt
= bfd_get_section_by_name (dynobj
, ".plt");
1609 ds
.srelplt
= bfd_get_section_by_name (dynobj
, ".rela.plt");
1612 if (htab
->dynamic_sections_created
)
1614 ds
.sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
1617 ds
.initialized
= TRUE
;
1622 #define ADD_SYMBOL_REF_SEC_AND_RELOC(SECNAME, COND_FOR_RELOC, H) \
1623 htab->s##SECNAME->size; \
1625 if (COND_FOR_RELOC) \
1627 htab->srel##SECNAME->size += sizeof (Elf32_External_Rela); \
1628 ARC_DEBUG ("arc_info: Added reloc space in " \
1629 #SECNAME " section at " __FILE__ \
1630 ":%d for symbol\n", \
1631 __LINE__, name_for_global_symbol (H)); \
1634 if (h->dynindx == -1 && !h->forced_local) \
1635 if (! bfd_elf_link_record_dynamic_symbol (info, H)) \
1637 htab->s##SECNAME->size += 4; \
1641 elf_arc_check_relocs (bfd
* abfd
,
1642 struct bfd_link_info
* info
,
1644 const Elf_Internal_Rela
* relocs
)
1646 Elf_Internal_Shdr
* symtab_hdr
;
1647 struct elf_link_hash_entry
** sym_hashes
;
1648 struct got_entry
** local_got_ents
;
1649 const Elf_Internal_Rela
* rel
;
1650 const Elf_Internal_Rela
* rel_end
;
1652 asection
* sreloc
= NULL
;
1653 struct elf_link_hash_table
* htab
= elf_hash_table (info
);
1655 if (bfd_link_relocatable (info
))
1658 dynobj
= (elf_hash_table (info
))->dynobj
;
1659 symtab_hdr
= &((elf_tdata (abfd
))->symtab_hdr
);
1660 sym_hashes
= elf_sym_hashes (abfd
);
1661 local_got_ents
= arc_get_local_got_ents (abfd
);
1663 rel_end
= relocs
+ sec
->reloc_count
;
1664 for (rel
= relocs
; rel
< rel_end
; rel
++)
1666 enum elf_arc_reloc_type r_type
;
1667 reloc_howto_type
*howto
;
1668 unsigned long r_symndx
;
1669 struct elf_link_hash_entry
*h
;
1671 r_type
= ELF32_R_TYPE (rel
->r_info
);
1673 if (r_type
>= (int) R_ARC_max
)
1675 bfd_set_error (bfd_error_bad_value
);
1678 howto
= &elf_arc_howto_table
[r_type
];
1681 && (is_reloc_for_GOT (howto
) == TRUE
1682 || is_reloc_for_TLS (howto
) == TRUE
))
1684 dynobj
= elf_hash_table (info
)->dynobj
= abfd
;
1685 if (! _bfd_elf_create_got_section (abfd
, info
))
1689 /* Load symbol information. */
1690 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1691 if (r_symndx
< symtab_hdr
->sh_info
) /* Is a local symbol. */
1693 else /* Global one. */
1694 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1700 /* During shared library creation, these relocs should not
1701 appear in a shared library (as memory will be read only
1702 and the dynamic linker can not resolve these. However
1703 the error should not occur for e.g. debugging or
1704 non-readonly sections. */
1705 if (bfd_link_dll (info
) && !bfd_link_pie (info
)
1706 && (sec
->flags
& SEC_ALLOC
) != 0
1707 && (sec
->flags
& SEC_READONLY
) != 0)
1711 name
= h
->root
.root
.string
;
1713 /* bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL); */
1715 (*_bfd_error_handler
)
1717 %B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1719 arc_elf_howto (r_type
)->name
,
1721 bfd_set_error (bfd_error_bad_value
);
1725 /* In some cases we are not setting the 'non_got_ref'
1726 flag, even though the relocations don't require a GOT
1727 access. We should extend the testing in this area to
1728 ensure that no significant cases are being missed. */
1733 case R_ARC_32_PCREL
:
1734 if (bfd_link_pic (info
) && !bfd_link_pie (info
)
1735 && ((r_type
!= R_ARC_PC32
&& r_type
!= R_ARC_32_PCREL
)
1738 && (!info
->symbolic
|| !h
->def_regular
))))
1742 sreloc
= _bfd_elf_make_dynamic_reloc_section (sec
, dynobj
,
1750 sreloc
->size
+= sizeof (Elf32_External_Rela
);
1757 if (is_reloc_for_PLT (howto
) == TRUE
)
1765 if (is_reloc_for_GOT (howto
) == TRUE
)
1770 if (local_got_ents
[r_symndx
] == NULL
)
1773 ADD_SYMBOL_REF_SEC_AND_RELOC (got
,
1774 bfd_link_pic (info
),
1776 new_got_entry_to_list (&(local_got_ents
[r_symndx
]),
1777 GOT_NORMAL
, offset
, NONE
);
1782 /* Global symbol. */
1783 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1784 if (h
->got
.glist
== NULL
)
1787 ADD_SYMBOL_REF_SEC_AND_RELOC (got
, TRUE
, h
);
1788 new_got_entry_to_list (&h
->got
.glist
,
1789 GOT_NORMAL
, offset
, NONE
);
1794 if (is_reloc_for_TLS (howto
) == TRUE
)
1796 enum tls_type_e type
= GOT_UNKNOWN
;
1800 case R_ARC_TLS_GD_GOT
:
1803 case R_ARC_TLS_IE_GOT
:
1810 struct got_entry
**list
= NULL
;
1812 list
= &(h
->got
.glist
);
1814 list
= &(local_got_ents
[r_symndx
]);
1816 if (type
!= GOT_UNKNOWN
&& !symbol_has_entry_of_type (*list
, type
))
1818 enum tls_got_entries entries
= NONE
;
1820 ADD_SYMBOL_REF_SEC_AND_RELOC (got
, TRUE
, h
);
1822 if (type
== GOT_TLS_GD
)
1824 bfd_vma ATTRIBUTE_UNUSED notneeded
=
1825 ADD_SYMBOL_REF_SEC_AND_RELOC (got
, TRUE
, h
);
1826 entries
= MOD_AND_OFF
;
1829 if (entries
== NONE
)
1832 new_got_entry_to_list (list
, type
, offset
, entries
);
1840 #define ELF_DYNAMIC_INTERPRETER "/sbin/ld-uClibc.so"
1842 static struct plt_version_t
*
1843 arc_get_plt_version (struct bfd_link_info
*info
)
1847 for (i
= 0; i
< 1; i
++)
1849 ARC_DEBUG ("%d: size1 = %d, size2 = %d\n", i
,
1850 plt_versions
[i
].entry_size
,
1851 plt_versions
[i
].elem_size
);
1854 if (bfd_get_mach (info
->output_bfd
) == bfd_mach_arc_arcv2
)
1856 if (bfd_link_pic (info
))
1857 return &(plt_versions
[ELF_ARCV2_PIC
]);
1859 return &(plt_versions
[ELF_ARCV2_ABS
]);
1863 if (bfd_link_pic (info
))
1864 return &(plt_versions
[ELF_ARC_PIC
]);
1866 return &(plt_versions
[ELF_ARC_ABS
]);
1871 add_symbol_to_plt (struct bfd_link_info
*info
)
1873 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
1876 struct plt_version_t
*plt_data
= arc_get_plt_version (info
);
1878 /* If this is the first .plt entry, make room for the special first
1880 if (htab
->splt
->size
== 0)
1881 htab
->splt
->size
+= plt_data
->entry_size
;
1883 ret
= htab
->splt
->size
;
1885 htab
->splt
->size
+= plt_data
->elem_size
;
1886 ARC_DEBUG ("PLT_SIZE = %d\n", htab
->splt
->size
);
1888 htab
->sgotplt
->size
+= 4;
1889 htab
->srelplt
->size
+= sizeof (Elf32_External_Rela
);
1894 #define PLT_DO_RELOCS_FOR_ENTRY(ABFD, DS, RELOCS) \
1895 plt_do_relocs_for_symbol (ABFD, DS, RELOCS, 0, 0)
1898 plt_do_relocs_for_symbol (bfd
*abfd
,
1899 struct elf_link_hash_table
*htab
,
1900 const struct plt_reloc
*reloc
,
1902 bfd_vma symbol_got_offset
)
1904 while (SYM_ONLY (reloc
->symbol
) != LAST_RELOC
)
1906 bfd_vma relocation
= 0;
1908 switch (SYM_ONLY (reloc
->symbol
))
1912 htab
->sgotplt
->output_section
->vma
+
1913 htab
->sgotplt
->output_offset
+ symbol_got_offset
;
1916 relocation
+= reloc
->addend
;
1918 if (IS_RELATIVE (reloc
->symbol
))
1920 bfd_vma reloc_offset
= reloc
->offset
;
1921 reloc_offset
-= (IS_INSN_32 (reloc
->symbol
)) ? 4 : 0;
1922 reloc_offset
-= (IS_INSN_24 (reloc
->symbol
)) ? 2 : 0;
1924 relocation
-= htab
->splt
->output_section
->vma
1925 + htab
->splt
->output_offset
1926 + plt_offset
+ reloc_offset
;
1929 /* TODO: being ME is not a property of the relocation but of the
1930 section of which is applying the relocation. */
1931 if (IS_MIDDLE_ENDIAN (reloc
->symbol
) || bfd_big_endian (abfd
))
1934 ((relocation
& 0xffff0000) >> 16) |
1935 ((relocation
& 0xffff) << 16);
1938 switch (reloc
->size
)
1941 bfd_put_32 (htab
->splt
->output_section
->owner
,
1943 htab
->splt
->contents
+ plt_offset
+ reloc
->offset
);
1947 reloc
= &(reloc
[1]); /* Jump to next relocation. */
1952 relocate_plt_for_symbol (bfd
*output_bfd
,
1953 struct bfd_link_info
*info
,
1954 struct elf_link_hash_entry
*h
)
1956 struct plt_version_t
*plt_data
= arc_get_plt_version (info
);
1957 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
1959 bfd_vma plt_index
= (h
->plt
.offset
- plt_data
->entry_size
)
1960 / plt_data
->elem_size
;
1961 bfd_vma got_offset
= (plt_index
+ 3) * 4;
1963 ARC_DEBUG ("arc_info: PLT_OFFSET = 0x%x, PLT_ENTRY_VMA = 0x%x, \
1964 GOT_ENTRY_OFFSET = 0x%x, GOT_ENTRY_VMA = 0x%x, for symbol %s\n",
1966 htab
->splt
->output_section
->vma
1967 + htab
->splt
->output_offset
1970 htab
->sgotplt
->output_section
->vma
1971 + htab
->sgotplt
->output_offset
1973 h
->root
.root
.string
);
1975 memcpy (htab
->splt
->contents
+ h
->plt
.offset
,
1977 plt_data
->elem_size
);
1978 plt_do_relocs_for_symbol (output_bfd
, htab
,
1979 plt_data
->elem_relocs
,
1983 /* Fill in the entry in the global offset table. */
1984 bfd_put_32 (output_bfd
,
1985 (bfd_vma
) (htab
->splt
->output_section
->vma
1986 + htab
->splt
->output_offset
),
1987 htab
->sgotplt
->contents
+ got_offset
);
1989 /* TODO: Fill in the entry in the .rela.plt section. */
1991 Elf_Internal_Rela rel
;
1994 rel
.r_offset
= (htab
->sgotplt
->output_section
->vma
1995 + htab
->sgotplt
->output_offset
1998 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARC_JMP_SLOT
);
2000 loc
= htab
->srelplt
->contents
;
2001 loc
+= plt_index
* sizeof (Elf32_External_Rela
); /* relA */
2002 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
2007 relocate_plt_for_entry (bfd
*abfd
,
2008 struct bfd_link_info
*info
)
2010 struct plt_version_t
*plt_data
= arc_get_plt_version (info
);
2011 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2013 memcpy (htab
->splt
->contents
, plt_data
->entry
,
2014 plt_data
->entry_size
);
2015 PLT_DO_RELOCS_FOR_ENTRY (abfd
, htab
, plt_data
->entry_relocs
);
2018 /* Desc : Adjust a symbol defined by a dynamic object and referenced
2019 by a regular object. The current definition is in some section of
2020 the dynamic object, but we're not including those sections. We
2021 have to change the definition to something the rest of the link can
2025 elf_arc_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2026 struct elf_link_hash_entry
*h
)
2029 unsigned int power_of_two
;
2030 bfd
*dynobj
= (elf_hash_table (info
))->dynobj
;
2031 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2033 if (h
->type
== STT_FUNC
2034 || h
->type
== STT_GNU_IFUNC
2035 || h
->needs_plt
== 1)
2037 if (!bfd_link_pic (info
) && !h
->def_dynamic
&& !h
->ref_dynamic
)
2039 /* This case can occur if we saw a PLT32 reloc in an input
2040 file, but the symbol was never referred to by a dynamic
2041 object. In such a case, we don't actually need to build
2042 a procedure linkage table, and we can just do a PC32
2044 BFD_ASSERT (h
->needs_plt
);
2048 /* Make sure this symbol is output as a dynamic symbol. */
2049 if (h
->dynindx
== -1 && !h
->forced_local
2050 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
2053 if (bfd_link_pic (info
)
2054 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2056 bfd_vma loc
= add_symbol_to_plt (info
);
2058 if (!bfd_link_pic (info
) && !h
->def_regular
)
2060 h
->root
.u
.def
.section
= htab
->splt
;
2061 h
->root
.u
.def
.value
= loc
;
2063 h
->plt
.offset
= loc
;
2067 h
->plt
.offset
= (bfd_vma
) -1;
2073 /* If this is a weak symbol, and there is a real definition, the
2074 processor independent code will have arranged for us to see the
2075 real definition first, and we can just use the same value. */
2076 if (h
->u
.weakdef
!= NULL
)
2078 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2079 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2080 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2081 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2085 /* If there are no non-GOT references, we do not need a copy
2087 if (!h
->non_got_ref
)
2090 /* This is a reference to a symbol defined by a dynamic object which
2091 is not a function. */
2093 /* If we are creating a shared library, we must presume that the
2094 only references to the symbol are via the global offset table.
2095 For such cases we need not do anything here; the relocations will
2096 be handled correctly by relocate_section. */
2097 if (bfd_link_pic (info
))
2100 /* We must allocate the symbol in our .dynbss section, which will
2101 become part of the .bss section of the executable. There will be
2102 an entry for this symbol in the .dynsym section. The dynamic
2103 object will contain position independent code, so all references
2104 from the dynamic object to this symbol will go through the global
2105 offset table. The dynamic linker will use the .dynsym entry to
2106 determine the address it must put in the global offset table, so
2107 both the dynamic object and the regular object will refer to the
2108 same memory location for the variable. */
2110 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
2111 BFD_ASSERT (s
!= NULL
);
2113 /* We must generate a R_ARC_COPY reloc to tell the dynamic linker to
2114 copy the initial value out of the dynamic object and into the
2115 runtime process image. We need to remember the offset into the
2116 .rela.bss section we are going to use. */
2117 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
2121 srel
= bfd_get_section_by_name (dynobj
, ".rela.bss");
2122 BFD_ASSERT (srel
!= NULL
);
2123 srel
->size
+= sizeof (Elf32_External_Rela
);
2127 /* We need to figure out the alignment required for this symbol. I
2128 have no idea how ELF linkers handle this. */
2129 power_of_two
= bfd_log2 (h
->size
);
2130 if (power_of_two
> 3)
2133 /* Apply the required alignment. */
2134 s
->size
= BFD_ALIGN (s
->size
, (bfd_size_type
) (1 << power_of_two
));
2135 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
2137 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
2141 /* Define the symbol as being at this point in the section. */
2142 h
->root
.u
.def
.section
= s
;
2143 h
->root
.u
.def
.value
= s
->size
;
2145 /* Increment the section size to make room for the symbol. */
2151 /* Function : elf_arc_finish_dynamic_symbol
2152 Brief : Finish up dynamic symbol handling. We set the
2153 contents of various dynamic sections here.
2158 Returns : True/False as the return status. */
2161 elf_arc_finish_dynamic_symbol (bfd
* output_bfd
,
2162 struct bfd_link_info
*info
,
2163 struct elf_link_hash_entry
*h
,
2164 Elf_Internal_Sym
* sym
)
2166 if (h
->plt
.offset
!= (bfd_vma
) -1)
2168 relocate_plt_for_symbol (output_bfd
, info
, h
);
2170 if (!h
->def_regular
)
2172 /* Mark the symbol as undefined, rather than as defined in
2173 the .plt section. Leave the value alone. */
2174 sym
->st_shndx
= SHN_UNDEF
;
2178 if (h
->got
.glist
!= NULL
)
2180 struct got_entry
*list
= h
->got
.glist
;
2182 /* Traverse the list of got entries for this symbol. */
2185 bfd_vma got_offset
= h
->got
.glist
->offset
;
2187 if (list
->type
== GOT_NORMAL
2188 && list
->created_dyn_relocation
== FALSE
)
2190 if (bfd_link_pic (info
)
2191 && (info
->symbolic
|| h
->dynindx
== -1)
2194 ADD_RELA (output_bfd
, got
, got_offset
, 0, R_ARC_RELATIVE
, 0);
2198 ADD_RELA (output_bfd
, got
, got_offset
, h
->dynindx
,
2201 list
->created_dyn_relocation
= TRUE
;
2203 else if (list
->existing_entries
!= NONE
)
2205 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2206 enum tls_got_entries e
= list
->existing_entries
;
2208 BFD_ASSERT (list
->type
!= GOT_TLS_GD
2209 || list
->existing_entries
== MOD_AND_OFF
);
2211 bfd_vma dynindx
= h
->dynindx
== -1 ? 0 : h
->dynindx
;
2212 if (e
== MOD_AND_OFF
|| e
== MOD
)
2214 ADD_RELA (output_bfd
, got
, got_offset
, dynindx
,
2215 R_ARC_TLS_DTPMOD
, 0);
2216 ARC_DEBUG ("arc_info: TLS_DYNRELOC: type = %d, \
2217 GOT_OFFSET = 0x%x, GOT_VMA = 0x%x, INDEX = %d, ADDEND = 0x%x\n",
2220 htab
->sgot
->output_section
->vma
2221 + htab
->sgot
->output_offset
+ got_offset
,
2224 if (e
== MOD_AND_OFF
|| e
== OFF
)
2227 if (list
->type
== GOT_TLS_IE
)
2228 addend
= bfd_get_32 (output_bfd
,
2229 htab
->sgot
->contents
+ got_offset
);
2231 ADD_RELA (output_bfd
, got
,
2232 got_offset
+ (e
== MOD_AND_OFF
? 4 : 0),
2234 (list
->type
== GOT_TLS_IE
?
2235 R_ARC_TLS_TPOFF
: R_ARC_TLS_DTPOFF
),
2238 ARC_DEBUG ("arc_info: TLS_DYNRELOC: type = %d, \
2239 GOT_OFFSET = 0x%x, GOT_VMA = 0x%x, INDEX = %d, ADDEND = 0x%x\n",
2242 htab
->sgot
->output_section
->vma
2243 + htab
->sgot
->output_offset
+ got_offset
,
2251 h
->got
.glist
= NULL
;
2256 bfd_vma rel_offset
= (h
->root
.u
.def
.value
2257 + h
->root
.u
.def
.section
->output_section
->vma
2258 + h
->root
.u
.def
.section
->output_offset
);
2261 bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
2264 bfd_byte
* loc
= srelbss
->contents
2265 + (srelbss
->reloc_count
* sizeof (Elf32_External_Rela
));
2266 srelbss
->reloc_count
++;
2268 Elf_Internal_Rela rel
;
2270 rel
.r_offset
= rel_offset
;
2271 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARC_COPY
);
2273 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
2276 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2277 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2278 || strcmp (h
->root
.root
.string
, "__DYNAMIC") == 0
2279 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
2280 sym
->st_shndx
= SHN_ABS
;
2285 #define GET_SYMBOL_OR_SECTION(TAG, SYMBOL, SECTION, ASSERT) \
2287 if (SYMBOL != NULL) \
2289 h = elf_link_hash_lookup (elf_hash_table (info), \
2290 SYMBOL, FALSE, FALSE, TRUE); \
2292 else if (SECTION != NULL) \
2294 s = bfd_get_section_by_name (output_bfd, SECTION); \
2295 BFD_ASSERT (s != NULL || !ASSERT); \
2300 /* Function : elf_arc_finish_dynamic_sections
2301 Brief : Finish up the dynamic sections handling.
2306 Returns : True/False as the return status. */
2309 elf_arc_finish_dynamic_sections (bfd
* output_bfd
,
2310 struct bfd_link_info
*info
)
2312 struct dynamic_sections ds
= arc_create_dynamic_sections (output_bfd
, info
);
2313 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2314 bfd
*dynobj
= (elf_hash_table (info
))->dynobj
;
2318 Elf32_External_Dyn
*dyncon
, *dynconend
;
2320 dyncon
= (Elf32_External_Dyn
*) ds
.sdyn
->contents
;
2322 (Elf32_External_Dyn
*) (ds
.sdyn
->contents
+ ds
.sdyn
->size
);
2323 for (; dyncon
< dynconend
; dyncon
++)
2325 Elf_Internal_Dyn internal_dyn
;
2326 bfd_boolean do_it
= FALSE
;
2328 struct elf_link_hash_entry
*h
= NULL
;
2331 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &internal_dyn
);
2333 switch (internal_dyn
.d_tag
)
2335 GET_SYMBOL_OR_SECTION (DT_INIT
, "_init", NULL
, TRUE
)
2336 GET_SYMBOL_OR_SECTION (DT_FINI
, "_fini", NULL
, TRUE
)
2337 GET_SYMBOL_OR_SECTION (DT_PLTGOT
, NULL
, ".plt", TRUE
)
2338 GET_SYMBOL_OR_SECTION (DT_JMPREL
, NULL
, ".rela.plt", TRUE
)
2339 GET_SYMBOL_OR_SECTION (DT_PLTRELSZ
, NULL
, ".rela.plt", TRUE
)
2340 GET_SYMBOL_OR_SECTION (DT_RELASZ
, NULL
, ".rela.plt", FALSE
)
2341 GET_SYMBOL_OR_SECTION (DT_VERSYM
, NULL
, ".gnu.version", TRUE
)
2342 GET_SYMBOL_OR_SECTION (DT_VERDEF
, NULL
, ".gnu.version_d", TRUE
)
2343 GET_SYMBOL_OR_SECTION (DT_VERNEED
, NULL
, ".gnu.version_r", TRUE
)
2348 /* In case the dynamic symbols should be updated with a symbol. */
2350 && (h
->root
.type
== bfd_link_hash_defined
2351 || h
->root
.type
== bfd_link_hash_defweak
))
2355 internal_dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
2356 asec_ptr
= h
->root
.u
.def
.section
;
2357 if (asec_ptr
->output_section
!= NULL
)
2359 internal_dyn
.d_un
.d_val
+=
2360 (asec_ptr
->output_section
->vma
+
2361 asec_ptr
->output_offset
);
2365 /* The symbol is imported from another shared
2366 library and does not apply to this one. */
2367 internal_dyn
.d_un
.d_val
= 0;
2371 else if (s
!= NULL
) /* With a section information. */
2373 switch (internal_dyn
.d_tag
)
2380 internal_dyn
.d_un
.d_ptr
= s
->vma
;
2385 internal_dyn
.d_un
.d_val
= s
->size
;
2391 internal_dyn
.d_un
.d_val
-= s
->size
;
2401 bfd_elf32_swap_dyn_out (output_bfd
, &internal_dyn
, dyncon
);
2404 if (htab
->splt
->size
> 0)
2406 relocate_plt_for_entry (output_bfd
, info
);
2409 /* TODO: Validate this. */
2410 elf_section_data (htab
->srelplt
->output_section
)->this_hdr
.sh_entsize
2414 /* Fill in the first three entries in the global offset table. */
2417 if (htab
->sgot
->size
> 0 || htab
->sgotplt
->size
> 0)
2419 if (ds
.sdyn
== NULL
)
2420 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
2421 htab
->sgotplt
->contents
);
2423 bfd_put_32 (output_bfd
,
2424 ds
.sdyn
->output_section
->vma
+ ds
.sdyn
->output_offset
,
2425 htab
->sgotplt
->contents
);
2426 bfd_put_32 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
+ 4);
2427 bfd_put_32 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
+ 8);
2434 #define ADD_DYNAMIC_SYMBOL(NAME, TAG) \
2435 h = elf_link_hash_lookup (elf_hash_table (info), \
2436 NAME, FALSE, FALSE, FALSE); \
2437 if ((h != NULL && (h->ref_regular || h->def_regular))) \
2438 if (! _bfd_elf_add_dynamic_entry (info, TAG, 0)) \
2441 /* Set the sizes of the dynamic sections. */
2443 elf_arc_size_dynamic_sections (bfd
* output_bfd
,
2444 struct bfd_link_info
*info
)
2448 bfd_boolean relocs_exist
= FALSE
;
2449 bfd_boolean reltext_exist
= FALSE
;
2450 struct dynamic_sections ds
= arc_create_dynamic_sections (output_bfd
, info
);
2451 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2453 dynobj
= (elf_hash_table (info
))->dynobj
;
2454 BFD_ASSERT (dynobj
!= NULL
);
2456 if ((elf_hash_table (info
))->dynamic_sections_created
)
2458 struct elf_link_hash_entry
*h
;
2460 /* Set the contents of the .interp section to the
2462 if (!bfd_link_pic (info
))
2464 s
= bfd_get_section_by_name (dynobj
, ".interp");
2465 BFD_ASSERT (s
!= NULL
);
2466 s
->size
= sizeof (ELF_DYNAMIC_INTERPRETER
);
2467 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2470 /* Add some entries to the .dynamic section. We fill in some of
2471 the values later, in elf_bfd_final_link, but we must add the
2472 entries now so that we know the final size of the .dynamic
2473 section. Checking if the .init section is present. We also
2474 create DT_INIT and DT_FINI entries if the init_str has been
2475 changed by the user. */
2476 ADD_DYNAMIC_SYMBOL ("init", DT_INIT
);
2477 ADD_DYNAMIC_SYMBOL ("fini", DT_FINI
);
2481 /* We may have created entries in the .rela.got section.
2482 However, if we are not creating the dynamic sections, we will
2483 not actually use these entries. Reset the size of .rela.got,
2484 which will cause it to get stripped from the output file
2486 if (htab
->srelgot
!= NULL
)
2487 htab
->srelgot
->size
= 0;
2490 if (htab
->splt
!= NULL
&& htab
->splt
->size
== 0)
2491 htab
->splt
->flags
|= SEC_EXCLUDE
;
2492 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2494 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2497 if (strncmp (s
->name
, ".rela", 5) == 0)
2501 s
->flags
|= SEC_EXCLUDE
;
2505 if (strcmp (s
->name
, ".rela.plt") != 0)
2507 const char *outname
=
2508 bfd_get_section_name (output_bfd
,
2509 htab
->srelplt
->output_section
);
2511 asection
*target
= bfd_get_section_by_name (output_bfd
,
2514 relocs_exist
= TRUE
;
2515 if (target
!= NULL
&& target
->size
!= 0
2516 && (target
->flags
& SEC_READONLY
) != 0
2517 && (target
->flags
& SEC_ALLOC
) != 0)
2518 reltext_exist
= TRUE
;
2522 /* We use the reloc_count field as a counter if we need to
2523 copy relocs into the output file. */
2527 if (strcmp (s
->name
, ".dynamic") == 0)
2531 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
2533 if (s
->contents
== NULL
&& s
->size
!= 0)
2539 /* TODO: Check if this is needed. */
2540 if (!bfd_link_pic (info
))
2541 if (!_bfd_elf_add_dynamic_entry (info
, DT_DEBUG
, 0))
2544 if (htab
->splt
&& (htab
->splt
->flags
& SEC_EXCLUDE
) == 0)
2545 if (!_bfd_elf_add_dynamic_entry (info
, DT_PLTGOT
, 0)
2546 || !_bfd_elf_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
2547 || !_bfd_elf_add_dynamic_entry (info
, DT_PLTREL
, DT_RELA
)
2548 || !_bfd_elf_add_dynamic_entry (info
, DT_JMPREL
, 0)
2552 if (relocs_exist
== TRUE
)
2553 if (!_bfd_elf_add_dynamic_entry (info
, DT_RELA
, 0)
2554 || !_bfd_elf_add_dynamic_entry (info
, DT_RELASZ
, 0)
2555 || !_bfd_elf_add_dynamic_entry (info
, DT_RELENT
,
2556 sizeof (Elf32_External_Rela
))
2560 if (reltext_exist
== TRUE
)
2561 if (!_bfd_elf_add_dynamic_entry (info
, DT_TEXTREL
, 0))
2568 const struct elf_size_info arc_elf32_size_info
=
2570 sizeof (Elf32_External_Ehdr
),
2571 sizeof (Elf32_External_Phdr
),
2572 sizeof (Elf32_External_Shdr
),
2573 sizeof (Elf32_External_Rel
),
2574 sizeof (Elf32_External_Rela
),
2575 sizeof (Elf32_External_Sym
),
2576 sizeof (Elf32_External_Dyn
),
2577 sizeof (Elf_External_Note
),
2581 ELFCLASS32
, EV_CURRENT
,
2582 bfd_elf32_write_out_phdrs
,
2583 bfd_elf32_write_shdrs_and_ehdr
,
2584 bfd_elf32_checksum_contents
,
2585 bfd_elf32_write_relocs
,
2586 bfd_elf32_swap_symbol_in
,
2587 bfd_elf32_swap_symbol_out
,
2588 bfd_elf32_slurp_reloc_table
,
2589 bfd_elf32_slurp_symbol_table
,
2590 bfd_elf32_swap_dyn_in
,
2591 bfd_elf32_swap_dyn_out
,
2592 bfd_elf32_swap_reloc_in
,
2593 bfd_elf32_swap_reloc_out
,
2594 bfd_elf32_swap_reloca_in
,
2595 bfd_elf32_swap_reloca_out
2598 #define elf_backend_size_info arc_elf32_size_info
2600 static struct bfd_link_hash_table
*
2601 arc_elf_link_hash_table_create (bfd
*abfd
)
2603 struct elf_link_hash_table
*htab
;
2605 htab
= bfd_zmalloc (sizeof (*htab
));
2609 if (!_bfd_elf_link_hash_table_init (htab
, abfd
,
2610 _bfd_elf_link_hash_newfunc
,
2611 sizeof (struct elf_link_hash_entry
),
2618 htab
->init_got_refcount
.refcount
= 0;
2619 htab
->init_got_refcount
.glist
= NULL
;
2620 htab
->init_got_offset
.offset
= 0;
2621 htab
->init_got_offset
.glist
= NULL
;
2622 return (struct bfd_link_hash_table
*) htab
;
2625 /* Hook called by the linker routine which adds symbols from an object
2629 elf_arc_add_symbol_hook (bfd
* abfd
,
2630 struct bfd_link_info
* info
,
2631 Elf_Internal_Sym
* sym
,
2632 const char ** namep ATTRIBUTE_UNUSED
,
2633 flagword
* flagsp ATTRIBUTE_UNUSED
,
2634 asection
** secp ATTRIBUTE_UNUSED
,
2635 bfd_vma
* valp ATTRIBUTE_UNUSED
)
2637 if ((ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
2638 || ELF_ST_BIND (sym
->st_info
) == STB_GNU_UNIQUE
)
2639 && (abfd
->flags
& DYNAMIC
) == 0
2640 && bfd_get_flavour (info
->output_bfd
) == bfd_target_elf_flavour
)
2641 elf_tdata (info
->output_bfd
)->has_gnu_symbols
= elf_gnu_symbol_any
;
2646 #define TARGET_LITTLE_SYM arc_elf32_le_vec
2647 #define TARGET_LITTLE_NAME "elf32-littlearc"
2648 #define TARGET_BIG_SYM arc_elf32_be_vec
2649 #define TARGET_BIG_NAME "elf32-bigarc"
2650 #define ELF_ARCH bfd_arch_arc
2651 #define ELF_MACHINE_CODE EM_ARC_COMPACT
2652 #define ELF_MACHINE_ALT1 EM_ARC_COMPACT2
2653 #define ELF_MAXPAGESIZE 0x2000
2655 #define bfd_elf32_bfd_link_hash_table_create arc_elf_link_hash_table_create
2657 #define bfd_elf32_bfd_merge_private_bfd_data arc_elf_merge_private_bfd_data
2658 #define bfd_elf32_bfd_reloc_type_lookup arc_elf32_bfd_reloc_type_lookup
2659 #define bfd_elf32_bfd_set_private_flags arc_elf_set_private_flags
2660 #define bfd_elf32_bfd_print_private_bfd_data arc_elf_print_private_bfd_data
2661 #define bfd_elf32_bfd_copy_private_bfd_data arc_elf_copy_private_bfd_data
2663 #define elf_info_to_howto_rel arc_info_to_howto_rel
2664 #define elf_backend_object_p arc_elf_object_p
2665 #define elf_backend_final_write_processing arc_elf_final_write_processing
2667 #define elf_backend_relocate_section elf_arc_relocate_section
2668 #define elf_backend_check_relocs elf_arc_check_relocs
2669 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
2671 #define elf_backend_adjust_dynamic_symbol elf_arc_adjust_dynamic_symbol
2672 #define elf_backend_finish_dynamic_symbol elf_arc_finish_dynamic_symbol
2674 #define elf_backend_finish_dynamic_sections elf_arc_finish_dynamic_sections
2675 #define elf_backend_size_dynamic_sections elf_arc_size_dynamic_sections
2676 #define elf_backend_add_symbol_hook elf_arc_add_symbol_hook
2678 #define elf_backend_can_gc_sections 1
2679 #define elf_backend_want_got_plt 1
2680 #define elf_backend_plt_readonly 1
2681 #define elf_backend_rela_plts_and_copies_p 1
2682 #define elf_backend_want_plt_sym 0
2683 #define elf_backend_got_header_size 12
2685 #define elf_backend_may_use_rel_p 0
2686 #define elf_backend_may_use_rela_p 1
2687 #define elf_backend_default_use_rela_p 1
2689 #include "elf32-target.h"