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_get_32(A,B,C) bfd_get_32(A,B)
256 #define arc_bfd_put_8(A,B,C,D) bfd_put_8(A,B,C)
257 #define arc_bfd_put_16(A,B,C,D) bfd_put_16(A,B,C)
258 #define arc_bfd_put_32(A,B,C,D) bfd_put_32(A,B,C)
261 static bfd_reloc_status_type
262 arc_elf_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
263 arelent
*reloc_entry
,
265 void *data ATTRIBUTE_UNUSED
,
266 asection
*input_section
,
268 char ** error_message ATTRIBUTE_UNUSED
)
270 if (output_bfd
!= NULL
)
272 reloc_entry
->address
+= input_section
->output_offset
;
274 /* In case of relocateable link and if the reloc is against a
275 section symbol, the addend needs to be adjusted according to
276 where the section symbol winds up in the output section. */
277 if ((symbol_in
->flags
& BSF_SECTION_SYM
) && symbol_in
->section
)
278 reloc_entry
->addend
+= symbol_in
->section
->output_offset
;
283 return bfd_reloc_continue
;
287 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
291 #include "elf/arc-reloc.def"
294 #undef ARC_RELOC_HOWTO
296 #define ARC_RELOC_HOWTO(TYPE, VALUE, RSIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
297 [TYPE] = HOWTO (R_##TYPE, 0, RSIZE, BITSIZE, FALSE, 0, complain_overflow_##OVERFLOW, arc_elf_reloc, "R_" #TYPE, FALSE, 0, 0, FALSE),
299 static struct reloc_howto_struct elf_arc_howto_table
[] =
301 #include "elf/arc-reloc.def"
302 /* Example of what is generated by the preprocessor. Currently kept as an
304 HOWTO (R_ARC_NONE, // Type.
306 2, // Size (0 = byte, 1 = short, 2 = long).
308 FALSE, // PC_relative.
310 complain_overflow_bitfield, // Complain_on_overflow.
311 bfd_elf_generic_reloc, // Special_function.
312 "R_ARC_NONE", // Name.
313 TRUE, // Partial_inplace.
316 FALSE), // PCrel_offset.
319 #undef ARC_RELOC_HOWTO
321 static void arc_elf_howto_init (void)
323 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
324 elf_arc_howto_table[TYPE].pc_relative = \
325 (strstr (#FORMULA, " P ") != NULL || strstr (#FORMULA, " PDATA ") != NULL); \
326 elf_arc_howto_table[TYPE].dst_mask = RELOC_FUNCTION(0, ~0); \
327 /* Only 32 bit data relocations should be marked as ME. */ \
328 if (strstr (#FORMULA, " ME ") != NULL) \
330 BFD_ASSERT (SIZE == 2); \
333 #include "elf/arc-reloc.def"
336 #undef ARC_RELOC_HOWTO
339 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
341 const int howto_table_lookup
[] =
343 #include "elf/arc-reloc.def"
345 #undef ARC_RELOC_HOWTO
347 static reloc_howto_type
*
348 arc_elf_howto (unsigned int r_type
)
350 if (elf_arc_howto_table
[R_ARC_32
].dst_mask
== 0)
351 arc_elf_howto_init ();
352 return &elf_arc_howto_table
[r_type
];
355 /* Map BFD reloc types to ARC ELF reloc types. */
359 bfd_reloc_code_real_type bfd_reloc_val
;
360 unsigned char elf_reloc_val
;
363 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
364 { BFD_RELOC_##TYPE, R_##TYPE },
365 static const struct arc_reloc_map arc_reloc_map
[] =
367 #include "elf/arc-reloc.def"
369 {BFD_RELOC_NONE
, R_ARC_NONE
},
370 {BFD_RELOC_8
, R_ARC_8
},
371 {BFD_RELOC_16
, R_ARC_16
},
372 {BFD_RELOC_24
, R_ARC_24
},
373 {BFD_RELOC_32
, R_ARC_32
},
375 #undef ARC_RELOC_HOWTO
377 static reloc_howto_type
*
378 arc_elf32_bfd_reloc_type_lookup (bfd
* abfd ATTRIBUTE_UNUSED
,
379 bfd_reloc_code_real_type code
)
383 for (i
= ARRAY_SIZE (arc_reloc_map
); i
--;)
385 if (arc_reloc_map
[i
].bfd_reloc_val
== code
)
386 return arc_elf_howto (arc_reloc_map
[i
].elf_reloc_val
);
392 /* Function to set the ELF flag bits. */
394 arc_elf_set_private_flags (bfd
*abfd
, flagword flags
)
396 elf_elfheader (abfd
)->e_flags
= flags
;
397 elf_flags_init (abfd
) = TRUE
;
401 /* Print private flags. */
403 arc_elf_print_private_bfd_data (bfd
*abfd
, void * ptr
)
405 FILE *file
= (FILE *) ptr
;
408 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
410 /* Print normal ELF private data. */
411 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
413 flags
= elf_elfheader (abfd
)->e_flags
;
414 fprintf (file
, _("private flags = 0x%lx:"), (unsigned long) flags
);
416 switch (flags
& EF_ARC_MACH_MSK
)
418 case EF_ARC_CPU_ARCV2HS
: fprintf (file
, " -mcpu=ARCv2HS"); break;
419 case EF_ARC_CPU_ARCV2EM
: fprintf (file
, " -mcpu=ARCv2EM"); break;
420 case E_ARC_MACH_ARC600
: fprintf (file
, " -mcpu=ARC600"); break;
421 case E_ARC_MACH_ARC601
: fprintf (file
, " -mcpu=ARC601"); break;
422 case E_ARC_MACH_ARC700
: fprintf (file
, " -mcpu=ARC700"); break;
424 fprintf (file
, "-mcpu=unknown");
428 switch (flags
& EF_ARC_OSABI_MSK
)
430 case E_ARC_OSABI_ORIG
: fprintf (file
, " (ABI:legacy)"); break;
431 case E_ARC_OSABI_V2
: fprintf (file
, " (ABI:v2)"); break;
432 case E_ARC_OSABI_V3
: fprintf (file
, " (ABI:v3)"); break;
434 fprintf (file
, "(ABI:unknown)");
442 /* Copy backend specific data from one object module to another. */
445 arc_elf_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
447 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
448 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
451 BFD_ASSERT (!elf_flags_init (obfd
)
452 || elf_elfheader (obfd
)->e_flags
== elf_elfheader (ibfd
)->e_flags
);
454 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
455 elf_flags_init (obfd
) = TRUE
;
457 /* Copy object attributes. */
458 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
460 return _bfd_elf_copy_private_bfd_data (ibfd
, obfd
);
463 static reloc_howto_type
*
464 bfd_elf32_bfd_reloc_name_lookup (bfd
* abfd ATTRIBUTE_UNUSED
,
469 for (i
= 0; i
< ARRAY_SIZE (elf_arc_howto_table
); i
++)
470 if (elf_arc_howto_table
[i
].name
!= NULL
471 && strcasecmp (elf_arc_howto_table
[i
].name
, r_name
) == 0)
472 return arc_elf_howto (i
);
477 /* Set the howto pointer for an ARC ELF reloc. */
480 arc_info_to_howto_rel (bfd
* abfd ATTRIBUTE_UNUSED
,
482 Elf_Internal_Rela
* dst
)
486 r_type
= ELF32_R_TYPE (dst
->r_info
);
487 BFD_ASSERT (r_type
< (unsigned int) R_ARC_max
);
488 cache_ptr
->howto
= arc_elf_howto (r_type
);
491 /* Merge backend specific data from an object file to the output
492 object file when linking. */
495 arc_elf_merge_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
497 unsigned short mach_ibfd
;
498 static unsigned short mach_obfd
= EM_NONE
;
503 /* Check if we have the same endianess. */
504 if (! _bfd_generic_verify_endian_match (ibfd
, obfd
))
506 _bfd_error_handler (_("ERROR: Endian Match failed. Attempting to link "
507 "%B with binary %s of opposite endian-ness"),
508 ibfd
, bfd_get_filename (obfd
));
512 /* Collect ELF flags. */
513 in_flags
= elf_elfheader (ibfd
)->e_flags
& EF_ARC_MACH_MSK
;
514 out_flags
= elf_elfheader (obfd
)->e_flags
& EF_ARC_MACH_MSK
;
516 if (!elf_flags_init (obfd
)) /* First call, no flags set. */
518 elf_flags_init (obfd
) = TRUE
;
519 out_flags
= in_flags
;
522 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
523 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
526 /* Check to see if the input BFD actually contains any sections. Do
527 not short-circuit dynamic objects; their section list may be
528 emptied by elf_link_add_object_symbols. */
529 if (!(ibfd
->flags
& DYNAMIC
))
531 bfd_boolean null_input_bfd
= TRUE
;
532 bfd_boolean only_data_sections
= TRUE
;
534 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
536 if ((bfd_get_section_flags (ibfd
, sec
)
537 & (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
538 == (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
539 only_data_sections
= FALSE
;
541 null_input_bfd
= FALSE
;
544 if (null_input_bfd
|| only_data_sections
)
548 /* Complain about various flag/architecture mismatches. */
549 mach_ibfd
= elf_elfheader (ibfd
)->e_machine
;
550 if (mach_obfd
== EM_NONE
)
552 mach_obfd
= mach_ibfd
;
556 if (mach_ibfd
!= mach_obfd
)
558 _bfd_error_handler (_("ERROR: Attempting to link %B "
559 "with a binary %s of different architecture"),
560 ibfd
, bfd_get_filename (obfd
));
563 else if (in_flags
!= out_flags
)
565 /* Warn if different flags. */
566 (*_bfd_error_handler
)
567 (_("%s: uses different e_flags (0x%lx) fields than "
568 "previous modules (0x%lx)"),
569 bfd_get_filename (ibfd
), (long)in_flags
, (long)out_flags
);
570 if (in_flags
&& out_flags
)
572 /* MWDT doesnt set the eflags hence make sure we choose the
573 eflags set by gcc. */
574 in_flags
= in_flags
> out_flags
? in_flags
: out_flags
;
578 /* Update the flags. */
579 elf_elfheader (obfd
)->e_flags
= in_flags
;
581 if (bfd_get_mach (obfd
) < bfd_get_mach (ibfd
))
583 return bfd_set_arch_mach (obfd
, bfd_arch_arc
, bfd_get_mach (ibfd
));
589 /* Set the right machine number for an ARC ELF file. */
591 arc_elf_object_p (bfd
* abfd
)
593 /* Make sure this is initialised, or you'll have the potential of passing
594 garbage---or misleading values---into the call to
595 bfd_default_set_arch_mach (). */
596 int mach
= bfd_mach_arc_arc700
;
597 unsigned long arch
= elf_elfheader (abfd
)->e_flags
& EF_ARC_MACH_MSK
;
598 unsigned e_machine
= elf_elfheader (abfd
)->e_machine
;
600 if (e_machine
== EM_ARC_COMPACT
|| e_machine
== EM_ARC_COMPACT2
)
604 case E_ARC_MACH_ARC600
:
605 mach
= bfd_mach_arc_arc600
;
607 case E_ARC_MACH_ARC601
:
608 mach
= bfd_mach_arc_arc601
;
610 case E_ARC_MACH_ARC700
:
611 mach
= bfd_mach_arc_arc700
;
613 case EF_ARC_CPU_ARCV2HS
:
614 case EF_ARC_CPU_ARCV2EM
:
615 mach
= bfd_mach_arc_arcv2
;
618 mach
= (e_machine
== EM_ARC_COMPACT
) ?
619 bfd_mach_arc_arc700
: bfd_mach_arc_arcv2
;
625 if (e_machine
== EM_ARC
)
627 (*_bfd_error_handler
)
628 (_("Error: The ARC4 architecture is no longer supported.\n"));
633 (*_bfd_error_handler
)
634 (_("Warning: unset or old architecture flags. \n"
635 " Use default machine.\n"));
639 return bfd_default_set_arch_mach (abfd
, bfd_arch_arc
, mach
);
642 /* The final processing done just before writing out an ARC ELF object file.
643 This gets the ARC architecture right based on the machine number. */
646 arc_elf_final_write_processing (bfd
* abfd
,
647 bfd_boolean linker ATTRIBUTE_UNUSED
)
651 switch (bfd_get_mach (abfd
))
653 case bfd_mach_arc_arc600
:
654 emf
= EM_ARC_COMPACT
;
656 case bfd_mach_arc_arc601
:
657 emf
= EM_ARC_COMPACT
;
659 case bfd_mach_arc_arc700
:
660 emf
= EM_ARC_COMPACT
;
662 case bfd_mach_arc_arcv2
:
663 emf
= EM_ARC_COMPACT2
;
669 elf_elfheader (abfd
)->e_machine
= emf
;
671 /* Record whatever is the current syscall ABI version. */
672 elf_elfheader (abfd
)->e_flags
|= E_ARC_OSABI_CURRENT
;
675 #define BFD_DEBUG_PIC(...)
677 struct arc_relocation_data
679 bfd_vma reloc_offset
;
680 bfd_vma reloc_addend
;
681 bfd_vma got_offset_value
;
684 asection
* sym_section
;
686 reloc_howto_type
*howto
;
688 asection
* input_section
;
690 bfd_vma sdata_begin_symbol_vma
;
691 bfd_boolean sdata_begin_symbol_vma_set
;
692 bfd_vma got_symbol_vma
;
694 bfd_boolean should_relocate
;
698 debug_arc_reloc (struct arc_relocation_data reloc_data
)
700 PR_DEBUG ("Reloc type=%s, should_relocate = %s\n",
701 reloc_data
.howto
->name
,
702 reloc_data
.should_relocate
? "true" : "false");
703 PR_DEBUG (" offset = 0x%x, addend = 0x%x\n",
704 (unsigned int) reloc_data
.reloc_offset
,
705 (unsigned int) reloc_data
.reloc_addend
);
706 PR_DEBUG (" Symbol:\n");
707 PR_DEBUG (" value = 0x%08x\n",
708 (unsigned int) reloc_data
.sym_value
);
709 if (reloc_data
.sym_section
!= NULL
)
711 PR_DEBUG ("IN IF\n");
713 " section name = %s, output_offset 0x%08x",
714 reloc_data
.sym_section
->name
,
715 (unsigned int) reloc_data
.sym_section
->output_offset
);
716 if (reloc_data
.sym_section
->output_section
!= NULL
)
719 ", output_section->vma = 0x%08x",
720 ((unsigned int) reloc_data
.sym_section
->output_section
->vma
));
727 PR_DEBUG ( " symbol section is NULL\n");
730 PR_DEBUG ( " Input_section:\n");
731 if (reloc_data
.input_section
!= NULL
)
734 " section name = %s, output_offset 0x%08x, output_section->vma = 0x%08x\n",
735 reloc_data
.input_section
->name
,
736 (unsigned int) reloc_data
.input_section
->output_offset
,
737 (unsigned int) reloc_data
.input_section
->output_section
->vma
);
738 PR_DEBUG ( " changed_address = 0x%08x\n",
739 (unsigned int) (reloc_data
.input_section
->output_section
->vma
+
740 reloc_data
.input_section
->output_offset
+
741 reloc_data
.reloc_offset
));
745 PR_DEBUG ( " input section is NULL\n");
750 middle_endian_convert (bfd_vma insn
, bfd_boolean do_it
)
755 ((insn
& 0xffff0000) >> 16) |
756 ((insn
& 0xffff) << 16);
761 #define ME(reloc) (reloc)
763 #define IS_ME(FORMULA,BFD) ((strstr (FORMULA, "ME") != NULL) \
764 && (!bfd_big_endian (BFD)))
766 #define S (reloc_data.sym_value \
767 + (reloc_data.sym_section->output_section != NULL ? \
768 (reloc_data.sym_section->output_offset \
769 + reloc_data.sym_section->output_section->vma) : 0) \
771 #define L (reloc_data.sym_value \
772 + (reloc_data.sym_section->output_section != NULL ? \
773 (reloc_data.sym_section->output_offset \
774 + reloc_data.sym_section->output_section->vma) : 0) \
776 #define A (reloc_data.reloc_addend)
778 #define G (reloc_data.got_offset_value)
779 #define GOT (reloc_data.got_symbol_vma)
780 #define GOT_BEGIN (htab->sgot->output_section->vma)
783 /* P: relative offset to PCL The offset should be to the
784 current location aligned to 32 bits. */
787 (reloc_data.input_section->output_section != NULL ? \
788 reloc_data.input_section->output_section->vma : 0) \
789 + reloc_data.input_section->output_offset \
790 + (reloc_data.reloc_offset - (bitsize >= 32 ? 4 : 0)) \
793 (reloc_data.input_section->output_section->vma \
794 + reloc_data.input_section->output_offset \
795 + (reloc_data.reloc_offset) \
797 #define SECTSTAR (reloc_data.input_section->output_offset)
798 #define SECTSTART (reloc_data.input_section->output_offset)
799 #define _SDA_BASE_ (reloc_data.sdata_begin_symbol_vma)
800 #define TLS_REL ((elf_hash_table (info))->tls_sec->output_section->vma)
801 #define _SDA_BASE_ (reloc_data.sdata_begin_symbol_vma)
807 #define PRINT_DEBUG_RELOC_INFO_BEFORE(FORMULA) \
809 asection *sym_section = reloc_data.sym_section; \
810 asection *input_section = reloc_data.input_section; \
811 ARC_DEBUG ("FORMULA = " #FORMULA "\n"); \
812 ARC_DEBUG ("S = 0x%x\n", S); \
813 ARC_DEBUG ("A = 0x%x\n", A); \
814 ARC_DEBUG ("L = 0x%x\n", L); \
815 if (sym_section->output_section != NULL) \
817 ARC_DEBUG ("symbol_section->vma = 0x%x\n", \
818 sym_section->output_section->vma + sym_section->output_offset); \
822 ARC_DEBUG ("symbol_section->vma = NULL\n"); \
824 if (input_section->output_section != NULL) \
826 ARC_DEBUG ("symbol_section->vma = 0x%x\n", \
827 input_section->output_section->vma + input_section->output_offset); \
831 ARC_DEBUG ("symbol_section->vma = NULL\n"); \
833 ARC_DEBUG ("PCL = 0x%x\n", P); \
834 ARC_DEBUG ("P = 0x%x\n", P); \
835 ARC_DEBUG ("G = 0x%x\n", G); \
836 ARC_DEBUG ("SDA_OFFSET = 0x%x\n", _SDA_BASE_); \
837 ARC_DEBUG ("SDA_SET = %d\n", reloc_data.sdata_begin_symbol_vma_set); \
838 ARC_DEBUG ("GOT_OFFSET = 0x%x\n", GOT); \
839 ARC_DEBUG ("relocation = 0x%08x\n", relocation); \
840 ARC_DEBUG ("before = 0x%08x\n", (unsigned int) insn); \
841 ARC_DEBUG ("data = 0x%08x (%u) (%d)\n", (unsigned int) relocation, (unsigned int) relocation, (int) relocation); \
844 #define PRINT_DEBUG_RELOC_INFO_AFTER \
846 ARC_DEBUG ("after = 0x%08x\n", (unsigned int) insn); \
849 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
852 bfd_vma bitsize ATTRIBUTE_UNUSED = BITSIZE; \
853 relocation = FORMULA ; \
854 PRINT_DEBUG_RELOC_INFO_BEFORE(FORMULA) \
855 insn = middle_endian_convert (insn, IS_ME (#FORMULA, abfd)); \
856 insn = RELOC_FUNCTION (insn, relocation); \
857 insn = middle_endian_convert (insn, IS_ME (#FORMULA, abfd)); \
858 PRINT_DEBUG_RELOC_INFO_AFTER \
862 static bfd_reloc_status_type
863 arc_do_relocation (bfd_byte
* contents
,
864 struct arc_relocation_data reloc_data
,
865 struct bfd_link_info
*info
)
867 bfd_vma relocation
= 0;
869 bfd_vma orig_insn ATTRIBUTE_UNUSED
;
870 bfd
* abfd
= reloc_data
.input_section
->owner
;
871 struct elf_link_hash_table
*htab ATTRIBUTE_UNUSED
= elf_hash_table (info
);
873 if (reloc_data
.should_relocate
== FALSE
)
876 switch (reloc_data
.howto
->size
)
879 insn
= arc_bfd_get_32 (abfd
,
880 contents
+ reloc_data
.reloc_offset
,
881 reloc_data
.input_section
);
884 insn
= arc_bfd_get_16 (abfd
,
885 contents
+ reloc_data
.reloc_offset
,
886 reloc_data
.input_section
);
889 insn
= arc_bfd_get_8 (abfd
,
890 contents
+ reloc_data
.reloc_offset
,
891 reloc_data
.input_section
);
901 switch (reloc_data
.howto
->type
)
903 #include "elf/arc-reloc.def"
910 /* Check for relocation overflow. */
911 if (reloc_data
.howto
->complain_on_overflow
!= complain_overflow_dont
)
913 bfd_reloc_status_type flag
;
914 flag
= bfd_check_overflow (reloc_data
.howto
->complain_on_overflow
,
915 reloc_data
.howto
->bitsize
,
916 reloc_data
.howto
->rightshift
,
917 bfd_arch_bits_per_address (abfd
),
920 #undef DEBUG_ARC_RELOC
921 #define DEBUG_ARC_RELOC(A) debug_arc_reloc (A)
922 if (flag
!= bfd_reloc_ok
)
924 PR_DEBUG ( "Relocation overflows !!!!\n");
926 DEBUG_ARC_RELOC (reloc_data
);
929 "Relocation value = signed -> %d, unsigned -> %u"
930 ", hex -> (0x%08x)\n",
932 (unsigned int) relocation
,
933 (unsigned int) relocation
);
937 #undef DEBUG_ARC_RELOC
938 #define DEBUG_ARC_RELOC(A)
940 switch (reloc_data
.howto
->size
)
943 arc_bfd_put_32 (abfd
, insn
,
944 contents
+ reloc_data
.reloc_offset
,
945 reloc_data
.input_section
);
948 arc_bfd_put_16 (abfd
, insn
,
949 contents
+ reloc_data
.reloc_offset
,
950 reloc_data
.input_section
);
953 arc_bfd_put_8 (abfd
, insn
,
954 contents
+ reloc_data
.reloc_offset
,
955 reloc_data
.input_section
);
958 ARC_DEBUG ("size = %d\n", reloc_data
.howto
->size
);
978 #undef ARC_RELOC_HOWTO
980 static struct got_entry
**
981 arc_get_local_got_ents (bfd
* abfd
)
983 static struct got_entry
**local_got_ents
= NULL
;
985 if (local_got_ents
== NULL
)
988 Elf_Internal_Shdr
*symtab_hdr
= &((elf_tdata (abfd
))->symtab_hdr
);
990 size
= symtab_hdr
->sh_info
* sizeof (bfd_vma
);
991 local_got_ents
= (struct got_entry
**)
992 bfd_alloc (abfd
, sizeof(struct got_entry
*) * size
);
993 if (local_got_ents
== NULL
)
996 memset (local_got_ents
, 0, sizeof(struct got_entry
*) * size
);
997 elf_local_got_ents (abfd
) = local_got_ents
;
1000 return local_got_ents
;
1003 /* Relocate an arc ELF section.
1004 Function : elf_arc_relocate_section
1005 Brief : Relocate an arc section, by handling all the relocations
1006 appearing in that section.
1007 Args : output_bfd : The bfd being written to.
1008 info : Link information.
1009 input_bfd : The input bfd.
1010 input_section : The section being relocated.
1011 contents : contents of the section being relocated.
1012 relocs : List of relocations in the section.
1013 local_syms : is a pointer to the swapped in local symbols.
1014 local_section : is an array giving the section in the input file
1015 corresponding to the st_shndx field of each
1018 elf_arc_relocate_section (bfd
* output_bfd
,
1019 struct bfd_link_info
* info
,
1021 asection
* input_section
,
1022 bfd_byte
* contents
,
1023 Elf_Internal_Rela
* relocs
,
1024 Elf_Internal_Sym
* local_syms
,
1025 asection
** local_sections
)
1027 Elf_Internal_Shdr
* symtab_hdr
;
1028 struct elf_link_hash_entry
** sym_hashes
;
1029 struct got_entry
** local_got_ents
;
1030 Elf_Internal_Rela
* rel
;
1031 Elf_Internal_Rela
* relend
;
1032 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
1034 symtab_hdr
= &((elf_tdata (input_bfd
))->symtab_hdr
);
1035 sym_hashes
= elf_sym_hashes (input_bfd
);
1038 relend
= relocs
+ input_section
->reloc_count
;
1039 for (; rel
< relend
; rel
++)
1041 enum elf_arc_reloc_type r_type
;
1042 reloc_howto_type
* howto
;
1043 unsigned long r_symndx
;
1044 struct elf_link_hash_entry
* h
;
1045 Elf_Internal_Sym
* sym
;
1047 struct elf_link_hash_entry
*h2
;
1049 struct arc_relocation_data reloc_data
=
1053 .got_offset_value
= 0,
1055 .sym_section
= NULL
,
1057 .input_section
= NULL
,
1058 .sdata_begin_symbol_vma
= 0,
1059 .sdata_begin_symbol_vma_set
= FALSE
,
1060 .got_symbol_vma
= 0,
1061 .should_relocate
= FALSE
1064 r_type
= ELF32_R_TYPE (rel
->r_info
);
1066 if (r_type
>= (int) R_ARC_max
)
1068 bfd_set_error (bfd_error_bad_value
);
1071 howto
= &elf_arc_howto_table
[r_type
];
1073 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1075 /* If we are generating another .o file and the symbol in not
1076 local, skip this relocation. */
1077 if (bfd_link_relocatable (info
))
1079 /* This is a relocateable link. We don't have to change
1080 anything, unless the reloc is against a section symbol,
1081 in which case we have to adjust according to where the
1082 section symbol winds up in the output section. */
1084 /* Checks if this is a local symbol and thus the reloc
1085 might (will??) be against a section symbol. */
1086 if (r_symndx
< symtab_hdr
->sh_info
)
1088 sym
= local_syms
+ r_symndx
;
1089 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1091 sec
= local_sections
[r_symndx
];
1093 /* for RELA relocs.Just adjust the addend
1094 value in the relocation entry. */
1095 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
1098 PR_DEBUG ("local symbols reloc "
1099 "(section=%d %s) seen in %s\n",
1101 local_sections
[r_symndx
]->name
,
1102 __PRETTY_FUNCTION__
)
1110 h2
= elf_link_hash_lookup (elf_hash_table (info
), "__SDATA_BEGIN__",
1111 FALSE
, FALSE
, TRUE
);
1113 if (reloc_data
.sdata_begin_symbol_vma_set
== FALSE
1114 && h2
!= NULL
&& h2
->root
.type
!= bfd_link_hash_undefined
1115 && h2
->root
.u
.def
.section
->output_section
!= NULL
)
1116 /* TODO: Verify this condition. */
1118 reloc_data
.sdata_begin_symbol_vma
=
1119 (h2
->root
.u
.def
.value
+
1120 h2
->root
.u
.def
.section
->output_section
->vma
);
1121 reloc_data
.sdata_begin_symbol_vma_set
= TRUE
;
1124 reloc_data
.input_section
= input_section
;
1125 reloc_data
.howto
= howto
;
1126 reloc_data
.reloc_offset
= rel
->r_offset
;
1127 reloc_data
.reloc_addend
= rel
->r_addend
;
1129 /* This is a final link. */
1134 if (r_symndx
< symtab_hdr
->sh_info
) /* A local symbol. */
1136 local_got_ents
= arc_get_local_got_ents (output_bfd
);
1137 struct got_entry
*entry
= local_got_ents
[r_symndx
];
1139 sym
= local_syms
+ r_symndx
;
1140 sec
= local_sections
[r_symndx
];
1142 reloc_data
.sym_value
= sym
->st_value
;
1143 reloc_data
.sym_section
= sec
;
1145 /* Mergeable section handling. */
1146 if ((sec
->flags
& SEC_MERGE
)
1147 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1151 rel
->r_addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
,
1152 &msec
, rel
->r_addend
);
1153 rel
->r_addend
-= (sec
->output_section
->vma
1154 + sec
->output_offset
1156 rel
->r_addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
1158 reloc_data
.reloc_addend
= rel
->r_addend
;
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"