1 /* ARC-specific support for 32-bit ELF
2 Copyright (C) 1994-2015 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"
30 #define ARC_DEBUG(...)
31 #define DEBUG(...) printf (__ARGV__)
32 #define DEBUG_ARC_RELOC(A)
36 bfd_vma sdata_begin_symbol_vma
;
37 asection
* sdata_output_section
;
38 bfd_vma got_symbol_vma
;
41 struct arc_local_data global_arc_data
=
43 .sdata_begin_symbol_vma
= 0,
44 .sdata_output_section
= NULL
,
48 struct dynamic_sections
50 bfd_boolean initialized
;
59 static struct dynamic_sections
60 arc_create_dynamic_sections (bfd
* abfd
, struct bfd_link_info
*info
);
62 enum dyn_section_types
73 const char * dyn_section_names
[DYN_SECTION_TYPES_END
] =
83 /* The default symbols representing the init and fini dyn values.
84 TODO: Check what is the relation of those strings with arclinux.em
86 #define INIT_SYM_STRING "_init"
87 #define FINI_SYM_STRING "_fini"
89 char * init_str
= INIT_SYM_STRING
;
90 char * fini_str
= FINI_SYM_STRING
;
93 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
98 static ATTRIBUTE_UNUSED
const char *
99 reloc_type_to_name (unsigned int type
)
103 #include "elf/arc-reloc.def"
110 #undef ARC_RELOC_HOWTO
112 /* Try to minimize the amount of space occupied by relocation tables
113 on the ROM (not that the ROM won't be swamped by other ELF overhead). */
117 static ATTRIBUTE_UNUSED bfd_boolean
118 is_reloc_PC_relative (reloc_howto_type
*howto
)
120 return (strstr (howto
->name
, "PC") != NULL
) ? TRUE
: FALSE
;
124 is_reloc_SDA_relative (reloc_howto_type
*howto
)
126 return (strstr (howto
->name
, "SDA") != NULL
) ? TRUE
: FALSE
;
130 is_reloc_for_GOT (reloc_howto_type
* howto
)
132 return (strstr (howto
->name
, "GOT") != NULL
) ? TRUE
: FALSE
;
136 is_reloc_for_PLT (reloc_howto_type
* howto
)
138 return (strstr (howto
->name
, "PLT") != NULL
) ? TRUE
: FALSE
;
141 #define arc_bfd_get_8(A,B,C) bfd_get_8(A,B)
142 #define arc_bfd_get_16(A,B,C) bfd_get_16(A,B)
143 #define arc_bfd_put_8(A,B,C,D) bfd_put_8(A,B,C)
144 #define arc_bfd_put_16(A,B,C,D) bfd_put_16(A,B,C)
147 arc_bfd_get_32 (bfd
* abfd
, void *loc
, asection
* input_section
)
149 long insn
= bfd_get_32 (abfd
, loc
);
151 if (!bfd_big_endian (abfd
)
153 && (input_section
->flags
& SEC_CODE
))
154 insn
= ((0x0000fffff & insn
) << 16) | ((0xffff0000 & insn
) >> 16);
160 arc_bfd_put_32 (bfd
* abfd
, long insn
, void *loc
, asection
* input_section
)
162 if (!bfd_big_endian (abfd
)
164 && (input_section
->flags
& SEC_CODE
))
165 insn
= ((0x0000fffff & insn
) << 16) | ((0xffff0000 & insn
) >> 16);
167 bfd_put_32 (abfd
, insn
, loc
);
170 static bfd_reloc_status_type
171 arc_elf_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
172 arelent
*reloc_entry
,
174 void *data ATTRIBUTE_UNUSED
,
175 asection
*input_section
,
177 char ** error_message ATTRIBUTE_UNUSED
)
179 if (output_bfd
!= NULL
)
181 reloc_entry
->address
+= input_section
->output_offset
;
183 /* In case of relocateable link and if the reloc is against a
184 section symbol, the addend needs to be adjusted according to
185 where the section symbol winds up in the output section. */
186 if ((symbol_in
->flags
& BSF_SECTION_SYM
) && symbol_in
->section
)
187 reloc_entry
->addend
+= symbol_in
->section
->output_offset
;
192 return bfd_reloc_continue
;
196 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
200 #include "elf/arc-reloc.def"
203 #undef ARC_RELOC_HOWTO
205 #define ARC_RELOC_HOWTO(TYPE, VALUE, RSIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
206 [TYPE] = HOWTO (R_##TYPE, 0, RSIZE, BITSIZE, FALSE, 0, complain_overflow_##OVERFLOW, arc_elf_reloc, #TYPE, FALSE, 0, 0, FALSE),
208 static struct reloc_howto_struct elf_arc_howto_table
[] =
210 #include "elf/arc-reloc.def"
211 /* Example of what is generated by the preprocessor. Currently kept as an example.
212 HOWTO (R_ARC_NONE, // Type.
214 2, // Size (0 = byte, 1 = short, 2 = long).
216 FALSE, // PC_relative.
218 complain_overflow_bitfield, // Complain_on_overflow.
219 bfd_elf_generic_reloc, // Special_function.
220 "R_ARC_NONE", // Name.
221 TRUE, // Partial_inplace.
224 FALSE), // PCrel_offset.
227 #undef ARC_RELOC_HOWTO
229 static void arc_elf_howto_init (void)
231 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
232 elf_arc_howto_table[TYPE].pc_relative = (strstr (#FORMULA, " P ") != NULL);
234 #include "elf/arc-reloc.def"
236 #undef ARC_RELOC_HOWTO
239 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
241 const int howto_table_lookup
[] =
243 #include "elf/arc-reloc.def"
245 #undef ARC_RELOC_HOWTO
247 #define ARC_ELF_HOWTO(r_type) \
248 (&elf_arc_howto_table[r_type])
250 /* Map BFD reloc types to ARC ELF reloc types. */
254 bfd_reloc_code_real_type bfd_reloc_val
;
255 unsigned char elf_reloc_val
;
258 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
259 { BFD_RELOC_##TYPE, R_##TYPE },
260 static const struct arc_reloc_map arc_reloc_map
[] =
262 #include "elf/arc-reloc.def"
263 {BFD_RELOC_NONE
, R_ARC_NONE
},
264 {BFD_RELOC_8
, R_ARC_8
},
265 {BFD_RELOC_16
, R_ARC_16
},
266 {BFD_RELOC_24
, R_ARC_24
},
267 {BFD_RELOC_32
, R_ARC_32
},
269 #undef ARC_RELOC_HOWTO
271 static reloc_howto_type
*
272 bfd_elf32_bfd_reloc_type_lookup (bfd
* abfd ATTRIBUTE_UNUSED
,
273 bfd_reloc_code_real_type code
)
276 static int fully_initialized
= FALSE
;
278 if (fully_initialized
== FALSE
)
280 arc_elf_howto_init ();
281 fully_initialized
= TRUE
; /* TODO: CHECK THIS IF IT STOPS WORKING. */
284 for (i
= ARRAY_SIZE (arc_reloc_map
); i
--;)
286 if (arc_reloc_map
[i
].bfd_reloc_val
== code
)
287 return elf_arc_howto_table
+ arc_reloc_map
[i
].elf_reloc_val
;
293 static reloc_howto_type
*
294 bfd_elf32_bfd_reloc_name_lookup (bfd
* abfd ATTRIBUTE_UNUSED
, const char *r_name
)
298 for (i
= 0; i
< ARRAY_SIZE (elf_arc_howto_table
); i
++)
299 if (elf_arc_howto_table
[i
].name
!= NULL
300 && strcasecmp (elf_arc_howto_table
[i
].name
, r_name
) == 0)
301 return elf_arc_howto_table
+ i
;
307 /* Set the howto pointer for an ARC ELF reloc. */
309 arc_info_to_howto_rel (bfd
* abfd ATTRIBUTE_UNUSED
,
311 Elf_Internal_Rela
* dst
)
315 r_type
= ELF32_R_TYPE (dst
->r_info
);
316 BFD_ASSERT (r_type
< (unsigned int) R_ARC_max
);
317 cache_ptr
->howto
= &elf_arc_howto_table
[r_type
];
320 /* Set the right machine number for an ARC ELF file. */
322 arc_elf_object_p (bfd
* abfd
)
324 /* Make sure this is initialised, or you'll have the potential of passing
325 garbage---or misleading values---into the call to
326 bfd_default_set_arch_mach (). */
327 int mach
= bfd_mach_arc_arc700
;
328 unsigned long arch
= elf_elfheader (abfd
)->e_flags
& EF_ARC_MACH_MSK
;
329 unsigned e_machine
= elf_elfheader (abfd
)->e_machine
;
331 if (e_machine
== EM_ARC_COMPACT
|| e_machine
== EM_ARC_COMPACT2
)
335 case E_ARC_MACH_ARC600
:
336 mach
= bfd_mach_arc_arc600
;
338 case E_ARC_MACH_ARC601
:
339 mach
= bfd_mach_arc_arc601
;
341 case E_ARC_MACH_ARC700
:
342 mach
= bfd_mach_arc_arc700
;
344 case EF_ARC_CPU_ARCV2HS
:
345 case EF_ARC_CPU_ARCV2EM
:
346 mach
= bfd_mach_arc_arcv2
;
349 mach
= (e_machine
== EM_ARC_COMPACT
) ?
350 bfd_mach_arc_arc700
: bfd_mach_arc_arcv2
;
356 if (e_machine
== EM_ARC
)
358 (*_bfd_error_handler
)
359 (_("Error: The ARC4 architecture is no longer supported.\n"));
364 (*_bfd_error_handler
)
365 (_("Warning: unset or old architecture flags. \n"
366 " Use default machine.\n"));
370 return bfd_default_set_arch_mach (abfd
, bfd_arch_arc
, mach
);
373 /* The final processing done just before writing out an ARC ELF object file.
374 This gets the ARC architecture right based on the machine number. */
377 arc_elf_final_write_processing (bfd
* abfd
, bfd_boolean linker ATTRIBUTE_UNUSED
)
382 switch (bfd_get_mach (abfd
))
384 case bfd_mach_arc_arc600
:
385 val
= E_ARC_MACH_ARC600
;
386 emf
= EM_ARC_COMPACT
;
388 case bfd_mach_arc_arc601
:
389 val
= E_ARC_MACH_ARC601
;
390 emf
= EM_ARC_COMPACT
;
392 case bfd_mach_arc_arc700
:
393 val
= E_ARC_MACH_ARC700
;
394 emf
= EM_ARC_COMPACT
;
396 case bfd_mach_arc_arcv2
:
397 val
= EF_ARC_CPU_GENERIC
;
398 emf
= EM_ARC_COMPACT2
;
399 /* TODO: Check validity of this. It can also be ARCV2EM here.
400 Previous version sets the e_machine here. */
405 elf_elfheader (abfd
)->e_flags
&= ~EF_ARC_MACH
;
406 elf_elfheader (abfd
)->e_flags
|= val
;
407 elf_elfheader (abfd
)->e_machine
= emf
;
409 /* Record whatever is the current syscall ABI version. */
410 elf_elfheader (abfd
)->e_flags
|= E_ARC_OSABI_CURRENT
;
413 #define BFD_DEBUG_PIC(...)
415 struct arc_relocation_data
417 bfd_vma reloc_offset
;
418 bfd_vma reloc_addend
;
419 bfd_vma got_offset_value
;
422 asection
* sym_section
;
424 reloc_howto_type
*howto
;
426 asection
* input_section
;
428 bfd_vma sdata_begin_symbol_vma
;
429 bfd_boolean sdata_begin_symbol_vma_set
;
430 bfd_vma got_symbol_vma
;
432 bfd_boolean should_relocate
;
436 debug_arc_reloc (struct arc_relocation_data reloc_data
)
438 fprintf (stderr
, "Reloc type=%s, should_relocate = %s\n",
439 reloc_data
.howto
->name
,
440 reloc_data
.should_relocate
? "true" : "false");
441 fprintf (stderr
, " offset = 0x%x, addend = 0x%x\n",
442 (unsigned int) reloc_data
.reloc_offset
,
443 (unsigned int) reloc_data
.reloc_addend
);
444 fprintf (stderr
, " Symbol:\n");
445 fprintf (stderr
, " value = 0x%08x\n",
446 (unsigned int) reloc_data
.sym_value
);
447 if (reloc_data
.sym_section
!= NULL
)
449 fprintf (stderr
, "IN IF\n");
451 " section name = %s, output_offset 0x%08x, output_section->vma = 0x%08x\n",
452 reloc_data
.sym_section
->name
,
453 (unsigned int) reloc_data
.sym_section
->output_offset
,
454 (unsigned int) reloc_data
.sym_section
->output_section
->vma
);
457 fprintf (stderr
, " symbol section is NULL\n");
459 fprintf (stderr
, " Input_section:\n");
460 if (reloc_data
.input_section
!= NULL
)
463 " section name = %s, output_offset 0x%08x, output_section->vma = 0x%08x\n",
464 reloc_data
.input_section
->name
,
465 (unsigned int) reloc_data
.input_section
->output_offset
,
466 (unsigned int) reloc_data
.input_section
->output_section
->vma
);
467 fprintf (stderr
, " changed_address = 0x%08x\n",
468 (unsigned int) (reloc_data
.input_section
->output_section
->vma
+
469 reloc_data
.input_section
->output_offset
+
470 reloc_data
.reloc_offset
));
473 fprintf (stderr
, " input section is NULL\n");
476 #define S (reloc_data.sym_value \
477 + reloc_data.sym_section->output_offset \
478 + reloc_data.sym_section->output_section->vma)
479 #define A (reloc_data.reloc_addend)
481 #define G (reloc_data.got_offset_value)
482 #define GOT (reloc_data.got_symbol_vma + 12)
483 #define L (reloc_data.sym_value \
484 + reloc_data.sym_section->output_section->vma \
485 + reloc_data.sym_section->output_offset)
487 /* P: relative offset to PCL The offset should be to the current location
488 aligned to 32 bits. */
490 (reloc_data.input_section->output_section->vma \
491 + reloc_data.input_section->output_offset \
492 + (reloc_data.reloc_offset - (bitsize >= 32 ? 4 : 0)) \
494 #define SECTSTAR (reloc_data.input_section->output_offset)
495 #define SECTSTART (reloc_data.input_section->output_offset)
496 #define _SDA_BASE_ (reloc_data.sdata_begin_symbol_vma)
500 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
503 bfd_vma bitsize ATTRIBUTE_UNUSED = BITSIZE; \
504 relocation = FORMULA ; \
505 insn = RELOC_FUNCTION (insn, relocation); \
509 static bfd_reloc_status_type
510 arc_do_relocation (bfd_byte
* contents
, struct arc_relocation_data reloc_data
)
512 bfd_vma relocation
= 0;
514 bfd_vma orig_insn ATTRIBUTE_UNUSED
;
516 if (reloc_data
.should_relocate
== FALSE
)
517 return bfd_reloc_notsupported
;
519 switch (reloc_data
.howto
->size
)
522 insn
= arc_bfd_get_32 (reloc_data
.input_section
->owner
,
523 contents
+ reloc_data
.reloc_offset
,
524 reloc_data
.input_section
);
528 insn
= arc_bfd_get_16 (reloc_data
.input_section
->owner
,
529 contents
+ reloc_data
.reloc_offset
,
530 reloc_data
.input_section
);
540 switch (reloc_data
.howto
->type
)
542 #include "elf/arc-reloc.def"
549 /* Check for relocation overflow. */
550 if (reloc_data
.howto
->complain_on_overflow
!= complain_overflow_dont
)
552 bfd_reloc_status_type flag
;
553 flag
= bfd_check_overflow (reloc_data
.howto
->complain_on_overflow
,
554 reloc_data
.howto
->bitsize
,
555 reloc_data
.howto
->rightshift
,
556 bfd_arch_bits_per_address (reloc_data
.input_section
->owner
),
559 #undef DEBUG_ARC_RELOC
560 #define DEBUG_ARC_RELOC(A) debug_arc_reloc (A)
561 if (flag
!= bfd_reloc_ok
)
563 fprintf (stderr
, "Relocation overflows !!!!\n");
565 DEBUG_ARC_RELOC (reloc_data
);
568 "Relocation value = signed -> %d, unsigned -> %u, hex -> (0x%08x)\n",
570 (unsigned int) relocation
,
571 (unsigned int) relocation
);
575 #undef DEBUG_ARC_RELOC
576 #define DEBUG_ARC_RELOC(A)
578 switch (reloc_data
.howto
->size
)
581 arc_bfd_put_32 (reloc_data
.input_section
->owner
, insn
,
582 contents
+ reloc_data
.reloc_offset
,
583 reloc_data
.input_section
);
587 arc_bfd_put_16 (reloc_data
.input_section
->owner
, insn
,
588 contents
+ reloc_data
.reloc_offset
,
589 reloc_data
.input_section
);
592 ARC_DEBUG ("size = %d\n", reloc_data
.howto
->size
);
612 #undef ARC_RELOC_HOWTO
615 arc_get_local_got_offsets (bfd
* abfd
)
617 static bfd_vma
*local_got_offsets
= NULL
;
619 if (local_got_offsets
== NULL
)
623 Elf_Internal_Shdr
*symtab_hdr
= &((elf_tdata (abfd
))->symtab_hdr
);
625 size
= symtab_hdr
->sh_info
* sizeof (bfd_vma
);
626 local_got_offsets
= (bfd_vma
*) bfd_alloc (abfd
, size
);
627 if (local_got_offsets
== NULL
)
629 elf_local_got_offsets (abfd
) = local_got_offsets
;
630 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
631 local_got_offsets
[i
] = (bfd_vma
) - 1;
634 return local_got_offsets
;
638 /* Relocate an arc ELF section.
639 Function : elf_arc_relocate_section
640 Brief : Relocate an arc section, by handling all the relocations
641 appearing in that section.
642 Args : output_bfd : The bfd being written to.
643 info : Link information.
644 input_bfd : The input bfd.
645 input_section : The section being relocated.
646 contents : contents of the section being relocated.
647 relocs : List of relocations in the section.
648 local_syms : is a pointer to the swapped in local symbols.
649 local_section : is an array giving the section in the input file
650 corresponding to the st_shndx field of each
653 elf_arc_relocate_section (bfd
* output_bfd
,
654 struct bfd_link_info
* info
,
656 asection
* input_section
,
658 Elf_Internal_Rela
* relocs
,
659 Elf_Internal_Sym
* local_syms
,
660 asection
** local_sections
)
662 Elf_Internal_Shdr
* symtab_hdr
;
663 struct elf_link_hash_entry
** sym_hashes
;
664 bfd_vma
* local_got_offsets
;
665 Elf_Internal_Rela
* rel
;
666 Elf_Internal_Rela
* relend
;
668 symtab_hdr
= &((elf_tdata (input_bfd
))->symtab_hdr
);
669 sym_hashes
= elf_sym_hashes (input_bfd
);
672 relend
= relocs
+ input_section
->reloc_count
;
673 for (; rel
< relend
; rel
++)
675 enum elf_arc_reloc_type r_type
;
676 reloc_howto_type
* howto
;
677 unsigned long r_symndx
;
678 struct elf_link_hash_entry
* h
;
679 Elf_Internal_Sym
* sym
;
682 struct arc_relocation_data reloc_data
=
684 .reloc_offset
= 0, /* bfd_vma reloc_offset; */
685 .reloc_addend
= 0, /* bfd_vma reloc_addend; */
686 .got_offset_value
= 0, /* bfd_vma got_offset_value; */
687 .sym_value
= 0, /* bfd_vma sym_value; */
688 .sym_section
= NULL
, /* asection *sym_section; */
689 .howto
= NULL
, /* reloc_howto_type *howto; */
690 .input_section
= NULL
, /* asection *input_section; */
691 .sdata_begin_symbol_vma
= 0, /* bfd_vma sdata_begin_symbol_vma; */
692 .sdata_begin_symbol_vma_set
= FALSE
, /* bfd_vma sdata_begin_symbol_vma_set; */
693 .got_symbol_vma
= 0, /* bfd_vma got_symbol_vma; */
694 .should_relocate
= FALSE
/* bfd_boolean should_relocate; */
697 struct elf_link_hash_entry
*h2
;
699 h2
= elf_link_hash_lookup (elf_hash_table (info
), "__SDATA_BEGIN__",
702 if (reloc_data
.sdata_begin_symbol_vma_set
== FALSE
703 && h2
!= NULL
&& h2
->root
.type
!= bfd_link_hash_undefined
)
705 reloc_data
.sdata_begin_symbol_vma
=
706 (h2
->root
.u
.def
.value
+
707 h2
->root
.u
.def
.section
->output_section
->vma
);
708 reloc_data
.sdata_begin_symbol_vma_set
= TRUE
;
711 h2
= elf_link_hash_lookup (elf_hash_table (info
),
712 "_GLOBAL_OFFSET_TABLE_", FALSE
, FALSE
,
714 if (h2
!= NULL
&& h2
->root
.type
!= bfd_link_hash_undefined
)
716 reloc_data
.got_symbol_vma
=
717 (h2
->root
.u
.def
.value
+
718 h2
->root
.u
.def
.section
->output_section
->vma
);
721 r_type
= ELF32_R_TYPE (rel
->r_info
);
723 if (r_type
>= (int) R_ARC_max
)
725 bfd_set_error (bfd_error_bad_value
);
728 howto
= &elf_arc_howto_table
[r_type
];
730 reloc_data
.input_section
= input_section
;
731 reloc_data
.howto
= howto
;
732 reloc_data
.reloc_offset
= rel
->r_offset
;
733 reloc_data
.reloc_addend
= rel
->r_addend
;
735 r_symndx
= ELF32_R_SYM (rel
->r_info
);
737 /* This is a final link. */
742 if (r_symndx
< symtab_hdr
->sh_info
) /* A local symbol. */
744 sym
= local_syms
+ r_symndx
;
745 sec
= local_sections
[r_symndx
];
747 reloc_data
.sym_value
= sym
->st_value
;
748 reloc_data
.sym_section
= sec
;
750 if (is_reloc_for_GOT (reloc_data
.howto
))
752 local_got_offsets
= arc_get_local_got_offsets (output_bfd
);
753 reloc_data
.got_offset_value
= local_got_offsets
[r_symndx
];
756 reloc_data
.should_relocate
= TRUE
;
758 else /* Global symbol. */
760 /* Get the symbol's entry in the symtab. */
761 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
763 while (h
->root
.type
== bfd_link_hash_indirect
764 || h
->root
.type
== bfd_link_hash_warning
)
765 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
767 BFD_ASSERT ((h
->dynindx
== -1) >= (h
->forced_local
!= 0));
768 /* If we have encountered a definition for this symbol. */
769 if (h
->root
.type
== bfd_link_hash_defined
770 || h
->root
.type
== bfd_link_hash_defweak
)
772 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
773 reloc_data
.sym_section
= h
->root
.u
.def
.section
;
775 reloc_data
.should_relocate
= TRUE
;
777 if (is_reloc_for_GOT (howto
))
779 struct dynamic_sections ds
=
780 arc_create_dynamic_sections (output_bfd
, info
);
782 /* TODO: Change it to use arc_do_relocation with ARC_32
785 reloc_data
.sym_value
+ reloc_data
.reloc_addend
786 + reloc_data
.sym_section
->output_offset
787 + reloc_data
.sym_section
->output_section
->vma
;
789 bfd_put_32 (output_bfd
, relocation
, ds
.sgot
->contents
+ h
->got
.offset
);
793 else if (h
->root
.type
== bfd_link_hash_undefweak
)
795 /* Is weak symbol and has no definition. */
800 if (is_reloc_for_GOT (howto
))
802 struct dynamic_sections ds
=
803 arc_create_dynamic_sections (output_bfd
, info
);
805 reloc_data
.sym_value
= h
->root
.u
.def
.value
;
806 reloc_data
.sym_section
= ds
.sgot
;
808 reloc_data
.should_relocate
= TRUE
;
810 else if (is_reloc_for_PLT (howto
))
812 struct dynamic_sections ds
=
813 arc_create_dynamic_sections (output_bfd
, info
);
815 reloc_data
.sym_value
= h
->plt
.offset
;
816 reloc_data
.sym_section
= ds
.splt
;
818 reloc_data
.should_relocate
= TRUE
;
820 else if (!(*info
->callbacks
->undefined_symbol
)
821 (info
, h
->root
.root
.string
, input_bfd
, input_section
,
822 rel
->r_offset
,!bfd_link_pic (info
)))
828 reloc_data
.got_offset_value
= h
->got
.offset
;
831 if (is_reloc_SDA_relative (howto
) && reloc_data
.sdata_begin_symbol_vma_set
== FALSE
)
833 (*_bfd_error_handler
)
834 ("Error: Linker symbol __SDATA_BEGIN__ not found");
835 bfd_set_error (bfd_error_bad_value
);
839 DEBUG_ARC_RELOC (reloc_data
);
840 if (arc_do_relocation (contents
, reloc_data
) != bfd_reloc_ok
)
847 static struct dynamic_sections
848 arc_create_dynamic_sections (bfd
* abfd
, struct bfd_link_info
*info
)
850 static bfd
* dynobj
= NULL
;
851 struct dynamic_sections ds
=
853 .initialized
= FALSE
,
864 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
865 if (!_bfd_elf_create_got_section (dynobj
, info
))
869 dynobj
= (elf_hash_table (info
))->dynobj
;
871 ds
.sgot
= bfd_get_section_by_name (dynobj
, ".got");
873 ds
.srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
874 if (ds
.srelgot
== NULL
)
876 ds
.srelgot
= bfd_make_section_with_flags (dynobj
, ".rela.got",
883 if (ds
.srelgot
== NULL
884 || !bfd_set_section_alignment (dynobj
, ds
.srelgot
, 2))
888 ds
.sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
890 ds
.sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
891 ds
.splt
= bfd_get_section_by_name (dynobj
, ".plt");
892 ds
.srelplt
= bfd_get_section_by_name (dynobj
, ".rela.plt");
894 ds
.initialized
= TRUE
;
899 #define ADD_SYMBOL_REF_SEC_AND_RELOC(SECNAME, COND_FOR_RELOC, H) \
900 ds.s##SECNAME->size; \
902 if (COND_FOR_RELOC) ds.srel##SECNAME->size += sizeof (Elf32_External_Rela); \
904 if (h->dynindx == -1 && !h->forced_local) \
905 if (! bfd_elf_link_record_dynamic_symbol (info, H)) \
907 ds.s##SECNAME->size += 4; \
911 elf_arc_check_relocs (bfd
* abfd
,
912 struct bfd_link_info
* info
,
914 const Elf_Internal_Rela
* relocs
)
916 Elf_Internal_Shdr
* symtab_hdr
;
917 struct elf_link_hash_entry
** sym_hashes
;
918 bfd_vma
* local_got_offsets
;
919 const Elf_Internal_Rela
* rel
;
920 const Elf_Internal_Rela
* rel_end
;
921 bfd
* dynobj ATTRIBUTE_UNUSED
;
923 dynobj
= (elf_hash_table (info
))->dynobj
;
924 symtab_hdr
= &((elf_tdata (abfd
))->symtab_hdr
);
925 sym_hashes
= elf_sym_hashes (abfd
);
926 local_got_offsets
= arc_get_local_got_offsets (abfd
);
928 struct dynamic_sections ds
= arc_create_dynamic_sections (abfd
, info
);
930 rel_end
= relocs
+ sec
->reloc_count
;
931 for (rel
= relocs
; rel
< rel_end
; rel
++)
933 enum elf_arc_reloc_type r_type
;
934 reloc_howto_type
*howto
;
935 unsigned long r_symndx
;
936 struct elf_link_hash_entry
*h
;
938 r_type
= ELF32_R_TYPE (rel
->r_info
);
940 if (r_type
>= (int) R_ARC_max
)
942 bfd_set_error (bfd_error_bad_value
);
945 howto
= &elf_arc_howto_table
[r_type
];
947 /* Load symbol information. */
948 r_symndx
= ELF32_R_SYM (rel
->r_info
);
949 if (r_symndx
< symtab_hdr
->sh_info
) /* Is a local symbol. */
951 else /* Global one. */
952 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
954 if (is_reloc_for_PLT (howto
) == TRUE
)
962 if (is_reloc_for_GOT (howto
) == TRUE
)
967 local_got_offsets
[r_symndx
] =
968 ADD_SYMBOL_REF_SEC_AND_RELOC (got
, bfd_link_pic (info
), NULL
);
973 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
975 ADD_SYMBOL_REF_SEC_AND_RELOC (got
, TRUE
, h
);
983 #define ELF_DYNAMIC_INTERPRETER "/sbin/ld-uClibc.so"
985 /* Size of one plt entry in bytes. */
986 #define PLT_ENTRY_SIZE 12
987 #define PLT_ENTRY_SIZE_V2 16
989 /* Instructions appear in memory as a sequence of half-words (16 bit);
990 individual half-words are represented on the target in target byte order.
991 We use 'unsigned short' on the host to represent the PLT templates,
992 and translate to target byte order as we copy to the target. */
993 typedef unsigned short insn_hword
;
996 /* TODO: Make this PLT entry code be in a separate object file. */
997 /* TODO: This is a linker BTW, we should be able to link. :) */
999 /* The zeroth entry in the absolute plt entry. */
1000 static const insn_hword elf_arc_abs_plt0_entry
[2 * PLT_ENTRY_SIZE
/ 2] =
1002 0x1600, /* ld %r11, [0] */
1006 0x1600, /* ld %r10, [0] */
1010 0x2020, /* j [%r10] */
1011 0x0280, /* ---"---- */
1016 /* Contents of the subsequent entries in the absolute plt. */
1017 static const insn_hword elf_arc_abs_pltn_entry
[PLT_ENTRY_SIZE
/ 2] =
1019 0x2730, /* ld %r12, [%pc,func@gotpc] */
1020 0x7f8c, /* ------ " " -------------- */
1021 0x0000, /* ------ " " -------------- */
1022 0x0000, /* ------ " " -------------- */
1023 0x7c20, /* j_s.d [%r12] */
1024 0x74ef /* mov_s %r12, %pcl */
1027 /* The zeroth entry in the absolute plt entry for ARCv2. */
1028 static const insn_hword elf_arcV2_abs_plt0_entry
[2 * PLT_ENTRY_SIZE_V2
/ 2] =
1030 0x1600, 0x700b, 0, 0, /* ld %r11, [0] */
1031 0x1600, 0x700a, 0, 0, /* ld %r10, [0] */
1032 0x2020, 0x0280, /* j [%r10] */
1033 0x0000, 0x0000, /* -> RELOCATED TO ABS ADDRESS OF GOT <- */
1040 /* Contents of the subsequent entries in the absolute plt for ARCv2. */
1041 static const insn_hword elf_arcV2_abs_pltn_entry
[PLT_ENTRY_SIZE_V2
/ 2] =
1043 0x2730, /* ld %r12, [%pcl,func@gotpc] */
1044 0x7f8c, /* ------ " " -------------- */
1045 0x0000, /* ------ " " -------------- */
1046 0x0000, /* ------ " " -------------- */
1047 0x2021, /* j.d [%r12] */
1048 0x0300, /* ------ " " -------------- */
1049 0x240a, /* mov %r12, %pcl */
1050 0x1fc0 /* ------ " " -------------- */
1053 /* The zeroth entry in the pic plt entry. */
1054 static const insn_hword elf_arc_pic_plt0_entry
[2 * PLT_ENTRY_SIZE
/ 2] =
1056 0x2730, /* ld %r11, [pcl,0] : 0 to be replaced by
1061 0x2730, /* ld %r10, [pcl,0] : 0 to be replaced by
1066 0x2020, /* j [%r10] */
1067 0x0280, /* ---"---- */
1072 /* Contents of the subsequent entries in the pic plt. */
1073 static const insn_hword elf_arc_pic_pltn_entry
[PLT_ENTRY_SIZE
/ 2] =
1075 0x2730, /* ld %r12, [%pc,func@got] */
1076 0x7f8c, /* ------ " " -------------- */
1077 0x0000, /* ------ " " -------------- */
1078 0x0000, /* ------ " " -------------- */
1079 0x7c20, /* j_s.d [%r12] */
1080 0x74ef, /* mov_s %r12, %pcl */
1083 /* The zeroth entry in the pic plt entry for ARCv2. */
1084 static const insn_hword elf_arcV2_pic_plt0_entry
[2 * PLT_ENTRY_SIZE_V2
/ 2] =
1086 0x2730, /* ld %r11, [pcl,0] : 0 to be replaced by
1091 0x2730, /* ld %r10, [pcl,0] : 0 to be replaced by
1096 0x2020, /* j [%r10] */
1097 0x0280, /* ---"---- */
1106 #define elf_arcV2_pic_PLT0_ENTRY_SIZE (2 * PLT_ENTRY_SIZE_V2/2)
1108 /* Contents of the subsequent entries in the pic plt for ARCv2. */
1109 static const insn_hword elf_arcV2_pic_pltn_entry
[PLT_ENTRY_SIZE_V2
/ 2] =
1111 0x2730, /* ld %r12, [%pc,func@got] */
1112 0x7f8c, /* ------ " " -------------- */
1113 0x0000, /* ------ " " -------------- */
1114 0x0000, /* ------ " " -------------- */
1115 0x2021, /* j.d [%r12] */
1116 0x0300, /* ------ " " -------------- */
1117 0x240a, /* mov %r12, %pcl */
1118 0x1fc0 /* ------ " " -------------- */
1121 #define elf_arcV2_pic_PLTN_ENTRY_SIZE (PLT_ENTRY_SIZE_V2/2)
1123 enum plt_reloc_symbol
1129 RELATIVE
= (1 << 8),
1130 MIDDLE_ENDIAN
= (1 << 9)
1133 #define IS_RELATIVE(S) ((S & RELATIVE) != 0)
1134 #define IS_MIDDLE_ENDIAN(S) ((S & MIDDLE_ENDIAN) != 0)
1135 #define SYM_ONLY(S) (S & 0xFF)
1142 enum plt_reloc_symbol symbol
;
1146 struct plt_version_t
1148 const insn_hword
* entry
;
1149 const bfd_vma entry_size
;
1150 const insn_hword
* elem
;
1151 const bfd_vma elem_size
;
1153 struct plt_reloc entry_relocs
[5];
1154 struct plt_reloc elem_relocs
[5];
1158 #define PLT_DATA(NAME, ...) \
1159 .entry = NAME##_plt0_entry, \
1160 .entry_size = NAME##_PLT0_ENTRY_SIZE, \
1161 .elem = NAME##_pltn_entry, \
1162 .elem_size = NAME##_PLTN_ENTRY_SIZE
1164 struct plt_version_t plt_versions
[] =
1167 PLT_DATA (elf_arcV2_pic
),
1170 {4, 32, 0xFFFFFFFF, SGOT
| RELATIVE
| MIDDLE_ENDIAN
, 4},
1171 {12, 32, 0xFFFFFFFF, SGOT
| RELATIVE
| MIDDLE_ENDIAN
, 8},
1172 {20, 32, 0xFFFFFFFF, SGOT
, 0},
1173 {0, 0, 0, LAST_RELOC
, 0}
1177 {4, 32, 0xFFFFFFFF, SGOT
, 0},
1178 {0, 0, 0, LAST_RELOC
, 0}
1184 static struct plt_version_t
*
1185 arc_get_plt_version (void)
1187 return &(plt_versions
[0]);
1191 add_symbol_to_plt (struct bfd_link_info
*info
)
1193 bfd
*dynobj
= (elf_hash_table (info
))->dynobj
;
1194 struct dynamic_sections ds
= arc_create_dynamic_sections (dynobj
, info
);
1197 /* If this is the first .plt entry, make room for the special first entry. */
1198 if (ds
.splt
->size
== 0)
1199 ds
.splt
->size
+= 2 *
1200 (bfd_get_mach (dynobj
) == bfd_mach_arc_arcv2
1201 ? PLT_ENTRY_SIZE_V2
: PLT_ENTRY_SIZE
);
1203 ret
= ds
.splt
->size
;
1205 ds
.splt
->size
+= (bfd_get_mach (dynobj
) == bfd_mach_arc_arcv2
1209 ds
.sgotplt
->size
+= 4;
1210 ds
.srelplt
->size
+= sizeof (Elf32_External_Rela
);
1215 #define PLT_DO_RELOCS_FOR_ENTRY(DS, RELOCS) \
1216 plt_do_relocs_for_symbol (DS, RELOCS, 0, 0)
1219 plt_do_relocs_for_symbol (struct dynamic_sections
*ds
,
1220 struct plt_reloc
*reloc
,
1222 bfd_vma symbol_got_offset
)
1224 while (SYM_ONLY (reloc
->symbol
) != LAST_RELOC
)
1226 bfd_vma relocation
= 0;
1228 switch (SYM_ONLY (reloc
->symbol
))
1232 ds
->sgotplt
->output_section
->vma
+
1233 ds
->sgotplt
->output_offset
+ symbol_got_offset
;
1236 relocation
+= reloc
->addend
;
1238 relocation
-= (IS_RELATIVE (reloc
->symbol
))
1239 ? ds
->splt
->output_section
->vma
+ ds
->splt
->output_offset
+
1240 plt_offset
+ reloc
->offset
: 0;
1242 if (IS_MIDDLE_ENDIAN (reloc
->symbol
))
1245 ((relocation
& 0xffff0000) >> 16) |
1246 ((relocation
& 0xffff) << 16);
1249 switch (reloc
->size
)
1252 bfd_put_32 (ds
->splt
->output_section
->owner
,
1254 ds
->splt
->contents
+ plt_offset
+ reloc
->offset
);
1258 reloc
= &(reloc
[1]); /* Jump to next relocation. */
1263 relocate_plt_for_symbol (struct bfd_link_info
*info
,
1264 struct elf_link_hash_entry
*h
)
1266 bfd
* dynobj
= elf_hash_table (info
)->dynobj
;
1267 struct plt_version_t
*plt_data
= arc_get_plt_version ();
1268 struct dynamic_sections ds
= arc_create_dynamic_sections (dynobj
, info
);
1270 bfd_vma plt_index
= h
->plt
.offset
/ plt_data
->elem_size
;
1271 bfd_vma got_offset
= (plt_index
+ 3) * 4;
1273 memcpy (ds
.splt
->contents
+ h
->plt
.offset
, plt_data
->elem
,
1274 plt_data
->elem_size
* sizeof (insn_hword
));
1275 plt_do_relocs_for_symbol (&ds
, plt_data
->elem_relocs
, h
->plt
.offset
,
1280 relocate_plt_for_entry (struct bfd_link_info
*info
)
1282 bfd
* dynobj
= (elf_hash_table (info
))->dynobj
;
1283 struct plt_version_t
*plt_data
= arc_get_plt_version ();
1284 struct dynamic_sections ds
= arc_create_dynamic_sections (dynobj
, info
);
1286 memcpy (ds
.splt
->contents
, plt_data
->entry
,
1287 plt_data
->entry_size
* sizeof (insn_hword
));
1288 PLT_DO_RELOCS_FOR_ENTRY (&ds
, plt_data
->entry_relocs
);
1292 /* Desc : Adjust a symbol defined by a dynamic object and referenced by a
1293 regular object. The current definition is in some section of the
1294 dynamic object, but we're not including those sections. We have to
1295 change the definition to something the rest of the link can
1299 elf_arc_adjust_dynamic_symbol (struct bfd_link_info
*info
,
1300 struct elf_link_hash_entry
*h
)
1302 bfd
*dynobj
= (elf_hash_table (info
))->dynobj
;
1303 struct dynamic_sections ds
= arc_create_dynamic_sections (dynobj
, info
);
1305 if (h
->needs_plt
== 1)
1307 if (!bfd_link_pic (info
) && !h
->def_dynamic
&& !h
->ref_dynamic
)
1309 /* This case can occur if we saw a PLT32 reloc in an input
1310 file, but the symbol was never referred to by a dynamic
1311 object. In such a case, we don't actually need to build
1312 a procedure linkage table, and we can just do a PC32
1314 BFD_ASSERT (h
->needs_plt
);
1318 /* Make sure this symbol is output as a dynamic symbol. */
1319 if (h
->dynindx
== -1 && !h
->forced_local
1320 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
1323 if (bfd_link_pic (info
) || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
1325 bfd_vma loc
= add_symbol_to_plt (info
);
1327 if (!bfd_link_pic (info
) && !h
->def_regular
)
1329 h
->root
.u
.def
.section
= ds
.splt
;
1330 h
->root
.u
.def
.value
= loc
;
1332 h
->plt
.offset
= loc
;
1337 h
->plt
.offset
= (bfd_vma
) - 1;
1344 #define ADD_RELA(BFD, SECTION, OFFSET, SYM_IDX, TYPE, ADDEND) \
1346 struct dynamic_sections ds = arc_create_dynamic_sections (output_bfd, info); \
1347 bfd_byte * rloc = ds.srel##SECTION->contents + \
1348 ((ds.srel##SECTION->reloc_count++) * sizeof (Elf32_External_Rela)); \
1349 Elf_Internal_Rela rel; \
1350 bfd_put_32 (output_bfd, (bfd_vma) 0, ds.s##SECTION->contents + OFFSET); \
1351 rel.r_addend = ADDEND; \
1352 rel.r_offset = (ds.s##SECTION)->output_section->vma + (ds.s##SECTION)->output_offset + OFFSET; \
1353 rel.r_info = ELF32_R_INFO (SYM_IDX, TYPE); \
1354 bfd_elf32_swap_reloca_out (BFD, &rel, rloc); \
1357 /* Function : elf_arc_finish_dynamic_symbol
1358 Brief : Finish up dynamic symbol handling. We set the
1359 contents of various dynamic sections here.
1364 Returns : True/False as the return status. */
1366 elf_arc_finish_dynamic_symbol (bfd
* output_bfd
,
1367 struct bfd_link_info
*info
,
1368 struct elf_link_hash_entry
*h
,
1369 Elf_Internal_Sym
* sym
)
1371 if (h
->plt
.offset
!= (bfd_vma
) - 1)
1372 relocate_plt_for_symbol (info
, h
);
1374 if (h
->got
.offset
!= (bfd_vma
) - 1)
1376 if (bfd_link_pic (info
) && (info
->symbolic
|| h
->dynindx
== -1)
1379 ADD_RELA (output_bfd
, got
, h
->got
.offset
, 0, R_ARC_RELATIVE
, 0);
1383 ADD_RELA (output_bfd
, got
, h
->got
.offset
, h
->dynindx
,
1388 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
1389 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
1390 || strcmp (h
->root
.root
.string
, "__DYNAMIC") == 0
1391 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
1392 sym
->st_shndx
= SHN_ABS
;
1397 #define GET_SYMBOL_OR_SECTION(TAG, SYMBOL, SECTION) \
1399 if (SYMBOL != NULL) \
1401 h = elf_link_hash_lookup (elf_hash_table (info), SYMBOL, FALSE, FALSE, TRUE); \
1403 else if (SECTION != NULL) \
1405 s = bfd_get_section_by_name (output_bfd, SECTION); \
1406 BFD_ASSERT (s != NULL); \
1411 /* Function : elf_arc_finish_dynamic_sections
1412 Brief : Finish up the dynamic sections handling.
1417 Returns : True/False as the return status. */
1419 elf_arc_finish_dynamic_sections (bfd
* output_bfd
, struct bfd_link_info
*info
)
1421 struct dynamic_sections ds
= arc_create_dynamic_sections (output_bfd
, info
);
1422 bfd
*dynobj
= (elf_hash_table (info
))->dynobj
;
1426 Elf32_External_Dyn
*dyncon
, *dynconend
;
1428 dyncon
= (Elf32_External_Dyn
*) ds
.sdyn
->contents
;
1430 (Elf32_External_Dyn
*) (ds
.sdyn
->contents
+ ds
.sdyn
->size
);
1431 for (; dyncon
< dynconend
; dyncon
++)
1433 Elf_Internal_Dyn internal_dyn
;
1434 bfd_boolean do_it
= FALSE
;
1436 struct elf_link_hash_entry
*h
= NULL
;
1439 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &internal_dyn
);
1441 switch (internal_dyn
.d_tag
)
1443 GET_SYMBOL_OR_SECTION (DT_INIT
, "_init", NULL
)
1444 GET_SYMBOL_OR_SECTION (DT_FINI
, "_fini", NULL
)
1445 GET_SYMBOL_OR_SECTION (DT_PLTGOT
, NULL
, ".plt")
1446 GET_SYMBOL_OR_SECTION (DT_JMPREL
, NULL
, ".rela.plt")
1447 GET_SYMBOL_OR_SECTION (DT_PLTRELSZ
, NULL
, ".rela.plt")
1448 GET_SYMBOL_OR_SECTION (DT_RELASZ
, NULL
, ".rela.plt")
1453 /* In case the dynamic symbols should be updated with a
1456 && (h
->root
.type
== bfd_link_hash_defined
1457 || h
->root
.type
== bfd_link_hash_defweak
)
1462 internal_dyn
.d_un
.d_val
= h
->root
.u
.def
.value
;
1463 asec_ptr
= h
->root
.u
.def
.section
;
1464 if (asec_ptr
->output_section
!= NULL
)
1466 internal_dyn
.d_un
.d_val
+=
1467 (asec_ptr
->output_section
->vma
+
1468 asec_ptr
->output_offset
);
1472 /* The symbol is imported from another
1473 shared library and does not apply to this
1475 internal_dyn
.d_un
.d_val
= 0;
1479 else if (s
!= NULL
) /* With a section information. */
1481 switch (internal_dyn
.d_tag
)
1485 internal_dyn
.d_un
.d_ptr
= s
->vma
;
1490 internal_dyn
.d_un
.d_val
= s
->size
;
1495 internal_dyn
.d_un
.d_val
-= s
->size
;
1505 bfd_elf32_swap_dyn_out (output_bfd
, &internal_dyn
, dyncon
);
1508 if (ds
.splt
->size
> 0)
1510 relocate_plt_for_entry (info
);
1513 elf_section_data (ds
.srelplt
->output_section
)->this_hdr
.sh_entsize
= 0xc;
1516 /* Fill in the first three entries in the global offset table. */
1519 if (ds
.sgot
->size
> 0)
1521 if (ds
.sdyn
== NULL
)
1522 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
1523 ds
.sgotplt
->contents
);
1525 bfd_put_32 (output_bfd
,
1526 ds
.sdyn
->output_section
->vma
+ ds
.sdyn
->output_offset
,
1527 ds
.sgotplt
->contents
);
1528 bfd_put_32 (output_bfd
, (bfd_vma
) 0, ds
.sgotplt
->contents
+ 4);
1529 bfd_put_32 (output_bfd
, (bfd_vma
) 0, ds
.sgotplt
->contents
+ 8);
1531 elf_section_data (ds
.sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
1536 /* Check that the linker script has not dumped the .srelgot section. */
1537 && ds
.srelgot
->output_section
1538 && elf_section_data (ds
.srelgot
->output_section
))
1540 /* TODO: Make it work even if I remove this. */
1541 elf_section_data (ds
.srelgot
->output_section
)->this_hdr
.sh_entsize
= 0xc;
1547 #define ADD_DYNAMIC_SYMBOL(NAME, TAG) \
1548 h = elf_link_hash_lookup (elf_hash_table (info), NAME, FALSE, FALSE, FALSE); \
1549 if ((h != NULL && (h->ref_regular || h->def_regular))) \
1550 if (! _bfd_elf_add_dynamic_entry (info, TAG, 0)) \
1553 /* Set the sizes of the dynamic sections. */
1555 elf_arc_size_dynamic_sections (bfd
* output_bfd
, struct bfd_link_info
*info
)
1559 bfd_boolean relocs_exist
;
1560 bfd_boolean reltext_exist
;
1561 struct dynamic_sections ds
= arc_create_dynamic_sections (output_bfd
, info
);
1563 dynobj
= (elf_hash_table (info
))->dynobj
;
1564 BFD_ASSERT (dynobj
!= NULL
);
1566 if ((elf_hash_table (info
))->dynamic_sections_created
)
1568 struct elf_link_hash_entry
*h
;
1570 /* Set the contents of the .interp section to the interpreter. */
1571 if (!bfd_link_pic (info
))
1573 s
= bfd_get_section_by_name (dynobj
, ".interp");
1574 BFD_ASSERT (s
!= NULL
);
1575 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1576 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1579 /* Add some entries to the .dynamic section. We fill in some of the
1580 values later, in elf_bfd_final_link, but we must add the entries
1581 now so that we know the final size of the .dynamic section.
1582 Checking if the .init section is present. We also create DT_INIT
1583 and DT_FINI entries if the init_str has been changed by the user. */
1585 ADD_DYNAMIC_SYMBOL ("init", DT_INIT
);
1586 ADD_DYNAMIC_SYMBOL ("fini", DT_FINI
);
1590 /* We may have created entries in the .rela.got section. However, if
1591 we are not creating the dynamic sections, we will not actually
1592 use these entries. Reset the size of .rela.got, which will cause
1593 it to get stripped from the output file below. */
1594 ds
.srelgot
->size
= 0;
1597 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1599 bfd_boolean is_dynamic_section
= FALSE
;
1601 /* Skip any non dynamic section. */
1602 if (strstr (s
->name
, ".plt") != NULL
1603 || strstr (s
->name
, ".got") != NULL
1604 || strstr (s
->name
, ".rel") != NULL
)
1605 is_dynamic_section
= TRUE
;
1607 /* Allocate memory for the section contents. */
1608 if (!is_dynamic_section
)
1611 s
->contents
= (bfd_byte
*) bfd_alloc (dynobj
, s
->size
);
1612 if (s
->contents
== NULL
&& s
->size
!= 0)
1617 s
->flags
|= SEC_EXCLUDE
;
1621 if (strcmp (s
->name
, ".rela.plt") != 0)
1623 const char *outname
= bfd_get_section_name (output_bfd
,
1625 asection
*target
= bfd_get_section_by_name (output_bfd
,
1628 relocs_exist
= TRUE
;
1629 if (target
!= NULL
&& target
->size
!= 0
1630 && (target
->flags
& SEC_READONLY
) != 0
1631 && (target
->flags
& SEC_ALLOC
) != 0)
1632 reltext_exist
= TRUE
;
1638 if (ds
.splt
&& ds
.splt
->size
!= 0)
1639 if (!_bfd_elf_add_dynamic_entry (info
, DT_PLTGOT
, 0)
1640 || !_bfd_elf_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
1641 || !_bfd_elf_add_dynamic_entry (info
, DT_PLTREL
, DT_RELA
)
1642 || !_bfd_elf_add_dynamic_entry (info
, DT_JMPREL
, 0)
1646 if (relocs_exist
== TRUE
)
1647 if (!_bfd_elf_add_dynamic_entry (info
, DT_RELA
, 0)
1648 || !_bfd_elf_add_dynamic_entry (info
, DT_RELASZ
, 0)
1649 || !_bfd_elf_add_dynamic_entry (info
, DT_RELENT
,
1650 sizeof (Elf32_External_Rela
))
1654 if (reltext_exist
== TRUE
)
1655 if (!_bfd_elf_add_dynamic_entry (info
, DT_TEXTREL
, 0))
1663 #define TARGET_LITTLE_SYM arc_elf32_le_vec
1664 #define TARGET_LITTLE_NAME "elf32-littlearc"
1665 #define TARGET_BIG_SYM arc_elf32_be_vec
1666 #define TARGET_BIG_NAME "elf32-bigarc"
1667 #define ELF_ARCH bfd_arch_arc
1668 #define ELF_MACHINE_CODE EM_ARC_COMPACT
1669 #define ELF_MACHINE_ALT1 EM_ARC_COMPACT2
1670 #define ELF_MAXPAGESIZE 0x2000
1672 #define elf_info_to_howto_rel arc_info_to_howto_rel
1673 #define elf_backend_object_p arc_elf_object_p
1674 #define elf_backend_final_write_processing arc_elf_final_write_processing
1676 #define elf_backend_relocate_section elf_arc_relocate_section
1677 #define elf_backend_check_relocs elf_arc_check_relocs
1678 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
1680 #define elf_backend_adjust_dynamic_symbol elf_arc_adjust_dynamic_symbol
1681 #define elf_backend_finish_dynamic_symbol elf_arc_finish_dynamic_symbol
1683 #define elf_backend_finish_dynamic_sections elf_arc_finish_dynamic_sections
1684 #define elf_backend_size_dynamic_sections elf_arc_size_dynamic_sections
1686 #define elf_backend_can_gc_sections 1
1687 #define elf_backend_want_got_plt 1
1688 #define elf_backend_plt_readonly 1
1689 #define elf_backend_want_plt_sym 0
1690 #define elf_backend_got_header_size 12
1692 #define elf_backend_may_use_rel_p 0
1693 #define elf_backend_may_use_rela_p 1
1694 #define elf_backend_default_use_rela_p 1
1696 #include "elf32-target.h"