]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - bfd/elf32-arm.h
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* config/atof-ieee.c (gen_to_words): Correctly round a
[thirdparty/binutils-gdb.git] / bfd / elf32-arm.h
CommitLineData
252b5132
RH		 1/* 32-bit ELF support for ARM
2 Copyright 1998, 1999 Free Software Foundation, Inc.
3
4 This file is part of BFD, the Binary File Descriptor library.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
19
20
21typedef unsigned long int insn32;
22typedef unsigned short int insn16;
23
24static boolean elf32_arm_set_private_flags
25 PARAMS ((bfd *, flagword));
26static boolean elf32_arm_copy_private_bfd_data
27 PARAMS ((bfd *, bfd *));
28static boolean elf32_arm_merge_private_bfd_data
29 PARAMS ((bfd *, bfd *));
30static boolean elf32_arm_print_private_bfd_data
31 PARAMS ((bfd *, PTR));
32static int elf32_arm_get_symbol_type
33 PARAMS (( Elf_Internal_Sym *, int));
34static struct bfd_link_hash_table *elf32_arm_link_hash_table_create
35 PARAMS ((bfd *));
36static bfd_reloc_status_type elf32_arm_final_link_relocate
37 PARAMS ((reloc_howto_type *, bfd *, bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, bfd_vma, struct bfd_link_info *, asection *, const char *, unsigned char));
38
39static insn32 insert_thumb_branch
40 PARAMS ((insn32, int));
41static struct elf_link_hash_entry *find_thumb_glue
42 PARAMS ((struct bfd_link_info *, CONST char *, bfd *));
43static struct elf_link_hash_entry *find_arm_glue
44 PARAMS ((struct bfd_link_info *, CONST char *, bfd *));
45static void record_arm_to_thumb_glue
46 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
47static void record_thumb_to_arm_glue
48 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
49
50/* The linker script knows the section names for placement.
51 The entry_names are used to do simple name mangling on the stubs.
52 Given a function name, and its type, the stub can be found. The
53 name can be changed. The only requirement is the %s be present.
54 */
55
56#define INTERWORK_FLAG( abfd ) (elf_elfheader (abfd)->e_flags & EF_INTERWORK)
57
58#define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t"
59#define THUMB2ARM_GLUE_ENTRY_NAME "__%s_from_thumb"
60
61#define ARM2THUMB_GLUE_SECTION_NAME ".glue_7"
62#define ARM2THUMB_GLUE_ENTRY_NAME "__%s_from_arm"
63
64/* The name of the dynamic interpreter. This is put in the .interp
65 section. */
66#define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
67
68/* The size in bytes of an entry in the procedure linkage table. */
69
70#define PLT_ENTRY_SIZE 16
71
72/* The first entry in a procedure linkage table looks like
73 this. It is set up so that any shared library function that is
74 called before the relocation has been set up calles the dynamic
75 linker first */
76
77static const bfd_byte elf32_arm_plt0_entry [PLT_ENTRY_SIZE] =
78{
79 0x04, 0xe0, 0x2d, 0xe5, /* str lr, [sp, #-4]! */
80 0x10, 0xe0, 0x9f, 0xe5, /* ldr lr, [pc, #16] */
81 0x0e, 0xe0, 0x8f, 0xe0, /* adr lr, pc, lr */
82 0x08, 0xf0, 0xbe, 0xe5 /* ldr pc, [lr, #-4] */
83};
84
85/* Subsequent entries in a procedure linkage table look like
86 this. */
87
88static const bfd_byte elf32_arm_plt_entry [PLT_ENTRY_SIZE] =
89{
90 0x04, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc, #4] */
91 0x0c, 0xc0, 0x8f, 0xe0, /* add ip, pc, ip */
92 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
93 0x00, 0x00, 0x00, 0x00 /* offset to symbol in got */
94};
95
96
97/* The ARM linker needs to keep track of the number of relocs that it
98 decides to copy in check_relocs for each symbol. This is so that
99 it can discard PC relative relocs if it doesn't need them when
100 linking with -Bsymbolic. We store the information in a field
101 extending the regular ELF linker hash table. */
102
103/* This structure keeps track of the number of PC relative relocs we
104 have copied for a given symbol. */
105
106struct elf32_arm_pcrel_relocs_copied
107{
108 /* Next section. */
109 struct elf32_arm_pcrel_relocs_copied * next;
110 /* A section in dynobj. */
111 asection * section;
112 /* Number of relocs copied in this section. */
113 bfd_size_type count;
114};
115
116/* arm ELF linker hash entry. */
117
118struct elf32_arm_link_hash_entry
119{
120 struct elf_link_hash_entry root;
121
122 /* Number of PC relative relocs copied for this symbol. */
123 struct elf32_arm_pcrel_relocs_copied * pcrel_relocs_copied;
124};
125
126/* Declare this now that the above structures are defined. */
127
128static boolean elf32_arm_discard_copies
129 PARAMS ((struct elf32_arm_link_hash_entry *, PTR));
130
131/* Traverse an arm ELF linker hash table. */
132
133#define elf32_arm_link_hash_traverse(table, func, info) \
134 (elf_link_hash_traverse \
135 (&(table)->root, \
136 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
137 (info)))
138
139/* Get the ARM elf linker hash table from a link_info structure. */
140#define elf32_arm_hash_table(info) \
141 ((struct elf32_arm_link_hash_table *) ((info)->hash))
142
143/* ARM ELF linker hash table */
144struct elf32_arm_link_hash_table
145 {
146 /* The main hash table. */
147 struct elf_link_hash_table root;
148
149 /* The size in bytes of the section containg the Thumb-to-ARM glue. */
150 long int thumb_glue_size;
151
152 /* The size in bytes of the section containg the ARM-to-Thumb glue. */
153 long int arm_glue_size;
154
155 /* An arbitary input BFD chosen to hold the glue sections. */
156 bfd * bfd_of_glue_owner;
157 };
158
159
160/* Create an ARM elf linker hash table */
161
162static struct bfd_link_hash_table *
163elf32_arm_link_hash_table_create (abfd)
164 bfd *abfd;
165{
166 struct elf32_arm_link_hash_table *ret;
167
168 ret = ((struct elf32_arm_link_hash_table *)
169 bfd_alloc (abfd, sizeof (struct elf32_arm_link_hash_table)));
170 if (ret == (struct elf32_arm_link_hash_table *) NULL)
171 return NULL;
172
173 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
174 _bfd_elf_link_hash_newfunc))
175 {
176 bfd_release (abfd, ret);
177 return NULL;
178 }
179
180 ret->thumb_glue_size = 0;
181 ret->arm_glue_size = 0;
182 ret->bfd_of_glue_owner = NULL;
183
184 return &ret->root.root;
185}
186
187static struct elf_link_hash_entry *
188find_thumb_glue (link_info, name, input_bfd)
189 struct bfd_link_info *link_info;
190 CONST char *name;
191 bfd *input_bfd;
192{
193 char *tmp_name;
194 struct elf_link_hash_entry *hash;
195 struct elf32_arm_link_hash_table *hash_table;
196
197 /* We need a pointer to the armelf specific hash table. */
198 hash_table = elf32_arm_hash_table (link_info);
199
200
201 tmp_name = ((char *)
202 bfd_malloc (strlen (name) + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1));
203
204 BFD_ASSERT (tmp_name);
205
206 sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
207
208 hash = elf_link_hash_lookup
209 (&(hash_table)->root, tmp_name, false, false, true);
210
211 if (hash == NULL)
212 /* xgettext:c-format */
213 _bfd_error_handler (_ ("%s: unable to find THUMB glue '%s' for `%s'"),
214 bfd_get_filename (input_bfd), tmp_name, name);
215
216 free (tmp_name);
217
218 return hash;
219}
220
221static struct elf_link_hash_entry *
222find_arm_glue (link_info, name, input_bfd)
223 struct bfd_link_info *link_info;
224 CONST char *name;
225 bfd *input_bfd;
226{
227 char *tmp_name;
228 struct elf_link_hash_entry *myh;
229 struct elf32_arm_link_hash_table *hash_table;
230
231 /* We need a pointer to the elfarm specific hash table. */
232 hash_table = elf32_arm_hash_table (link_info);
233
234 tmp_name = ((char *)
235 bfd_malloc (strlen (name) + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1));
236
237 BFD_ASSERT (tmp_name);
238
239 sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
240
241 myh = elf_link_hash_lookup
242 (&(hash_table)->root, tmp_name, false, false, true);
243
244 if (myh == NULL)
245 /* xgettext:c-format */
246 _bfd_error_handler (_ ("%s: unable to find ARM glue '%s' for `%s'"),
247 bfd_get_filename (input_bfd), tmp_name, name);
248
249 free (tmp_name);
250
251 return myh;
252}
253
254/*
255 ARM->Thumb glue:
256
257 .arm
258 __func_from_arm:
259 ldr r12, __func_addr
260 bx r12
261 __func_addr:
262 .word func @ behave as if you saw a ARM_32 reloc
263 */
264
265#define ARM2THUMB_GLUE_SIZE 12
266static const insn32 a2t1_ldr_insn = 0xe59fc000;
267static const insn32 a2t2_bx_r12_insn = 0xe12fff1c;
268static const insn32 a2t3_func_addr_insn = 0x00000001;
269
270/*
271 Thumb->ARM: Thumb->(non-interworking aware) ARM
272
273 .thumb .thumb
274 .align 2 .align 2
275 __func_from_thumb: __func_from_thumb:
276 bx pc push {r6, lr}
277 nop ldr r6, __func_addr
278 .arm mov lr, pc
279 __func_change_to_arm: bx r6
280 b func .arm
281 __func_back_to_thumb:
282 ldmia r13! {r6, lr}
283 bx lr
284 __func_addr:
285 .word func
286 */
287
288#define THUMB2ARM_GLUE_SIZE 8
289static const insn16 t2a1_bx_pc_insn = 0x4778;
290static const insn16 t2a2_noop_insn = 0x46c0;
291static const insn32 t2a3_b_insn = 0xea000000;
292
293static const insn16 t2a1_push_insn = 0xb540;
294static const insn16 t2a2_ldr_insn = 0x4e03;
295static const insn16 t2a3_mov_insn = 0x46fe;
296static const insn16 t2a4_bx_insn = 0x4730;
297static const insn32 t2a5_pop_insn = 0xe8bd4040;
298static const insn32 t2a6_bx_insn = 0xe12fff1e;
299
300boolean
301bfd_elf32_arm_allocate_interworking_sections (info)
302 struct bfd_link_info * info;
303{
304 asection * s;
305 bfd_byte * foo;
306 struct elf32_arm_link_hash_table * globals;
307
308 globals = elf32_arm_hash_table (info);
309
310 BFD_ASSERT (globals != NULL);
311
312 if (globals->arm_glue_size != 0)
313 {
314 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
315
316 s = bfd_get_section_by_name
317 (globals->bfd_of_glue_owner, ARM2THUMB_GLUE_SECTION_NAME);
318
319 BFD_ASSERT (s != NULL);
320
321 foo = (bfd_byte *) bfd_alloc
322 (globals->bfd_of_glue_owner, globals->arm_glue_size);
323
324 s->_raw_size = s->_cooked_size = globals->arm_glue_size;
325 s->contents = foo;
326 }
327
328 if (globals->thumb_glue_size != 0)
329 {
330 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
331
332 s = bfd_get_section_by_name
333 (globals->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
334
335 BFD_ASSERT (s != NULL);
336
337 foo = (bfd_byte *) bfd_alloc
338 (globals->bfd_of_glue_owner, globals->thumb_glue_size);
339
340 s->_raw_size = s->_cooked_size = globals->thumb_glue_size;
341 s->contents = foo;
342 }
343
344 return true;
345}
346
347static void
348record_arm_to_thumb_glue (link_info, h)
349 struct bfd_link_info * link_info;
350 struct elf_link_hash_entry * h;
351{
352 const char * name = h->root.root.string;
353 register asection * s;
354 char * tmp_name;
355 struct elf_link_hash_entry * myh;
356 struct elf32_arm_link_hash_table * globals;
357
358 globals = elf32_arm_hash_table (link_info);
359
360 BFD_ASSERT (globals != NULL);
361 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
362
363 s = bfd_get_section_by_name
364 (globals->bfd_of_glue_owner, ARM2THUMB_GLUE_SECTION_NAME);
365
366
367 BFD_ASSERT (s != NULL);
368
369 tmp_name = ((char *)
370 bfd_malloc (strlen (name) + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1));
371
372 BFD_ASSERT (tmp_name);
373
374 sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
375
376 myh = elf_link_hash_lookup
377 (&(globals)->root, tmp_name, false, false, true);
378
379 if (myh != NULL)
380 {
381 free (tmp_name);
382 return; /* we've already seen this guy */
383 }
384
385 /* The only trick here is using hash_table->arm_glue_size as the value. Even
386 though the section isn't allocated yet, this is where we will be putting
387 it. */
388
389 _bfd_generic_link_add_one_symbol (link_info, globals->bfd_of_glue_owner, tmp_name,
390 BSF_GLOBAL,
391 s, globals->arm_glue_size + 1,
392 NULL, true, false,
393 (struct bfd_link_hash_entry **) &myh);
394
395 free (tmp_name);
396
397 globals->arm_glue_size += ARM2THUMB_GLUE_SIZE;
398
399 return;
400}
401
402static void
403record_thumb_to_arm_glue (link_info, h)
404 struct bfd_link_info *link_info;
405 struct elf_link_hash_entry *h;
406{
407 const char *name = h->root.root.string;
408 register asection *s;
409 char *tmp_name;
410 struct elf_link_hash_entry *myh;
411 struct elf32_arm_link_hash_table *hash_table;
412 char bind;
413
414 hash_table = elf32_arm_hash_table (link_info);
415
416 BFD_ASSERT (hash_table != NULL);
417 BFD_ASSERT (hash_table->bfd_of_glue_owner != NULL);
418
419 s = bfd_get_section_by_name
420 (hash_table->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
421
422 BFD_ASSERT (s != NULL);
423
424 tmp_name = (char *) bfd_malloc (strlen (name) + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1);
425
426 BFD_ASSERT (tmp_name);
427
428 sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
429
430 myh = elf_link_hash_lookup
431 (&(hash_table)->root, tmp_name, false, false, true);
432
433 if (myh != NULL)
434 {
435 free (tmp_name);
436 return; /* we've already seen this guy */
437 }
438
439 _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner, tmp_name,
440 BSF_GLOBAL, s, hash_table->thumb_glue_size + 1,
441 NULL, true, false,
442 (struct bfd_link_hash_entry **) &myh);
443
444 /* If we mark it 'thumb', the disassembler will do a better job. */
445 bind = ELF_ST_BIND (myh->type);
446 myh->type = ELF_ST_INFO (bind, STT_ARM_TFUNC);
447
448 free (tmp_name);
449
450 /* Allocate another symbol to mark where we switch to arm mode. */
451
452#define CHANGE_TO_ARM "__%s_change_to_arm"
453#define BACK_FROM_ARM "__%s_back_from_arm"
454
455 tmp_name = (char *) bfd_malloc (strlen (name) + strlen (CHANGE_TO_ARM) + 1);
456
457 BFD_ASSERT (tmp_name);
458
459 sprintf (tmp_name, CHANGE_TO_ARM, name);
460
461 myh = NULL;
462
463 _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner, tmp_name,
464 BSF_LOCAL, s, hash_table->thumb_glue_size + 4,
465 NULL, true, false,
466 (struct bfd_link_hash_entry **) &myh);
467
468 free (tmp_name);
469
470 hash_table->thumb_glue_size += THUMB2ARM_GLUE_SIZE;
471
472 return;
473}
474
475/* Select a BFD to be used to hold the sections used by the glue code.
476 This function is called from the linker scripts in ld/emultempl/
477 {armelf/pe}.em */
478boolean
479bfd_elf32_arm_get_bfd_for_interworking (abfd, info)
480 bfd *abfd;
481 struct bfd_link_info *info;
482{
483 struct elf32_arm_link_hash_table *globals;
484 flagword flags;
485 asection *sec;
486
487 /* If we are only performing a partial link do not bother
488 getting a bfd to hold the glue. */
489 if (info->relocateable)
490 return true;
491
492 globals = elf32_arm_hash_table (info);
493
494 BFD_ASSERT (globals != NULL);
495
496 if (globals->bfd_of_glue_owner != NULL)
497 return true;
498
499 sec = bfd_get_section_by_name (abfd, ARM2THUMB_GLUE_SECTION_NAME);
500
501 if (sec == NULL)
502 {
503 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
504
505 sec = bfd_make_section (abfd, ARM2THUMB_GLUE_SECTION_NAME);
506
507 if (sec == NULL
508 || !bfd_set_section_flags (abfd, sec, flags)
509 || !bfd_set_section_alignment (abfd, sec, 2))
510 return false;
511 }
512
513 sec = bfd_get_section_by_name (abfd, THUMB2ARM_GLUE_SECTION_NAME);
514
515 if (sec == NULL)
516 {
517 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
518
519 sec = bfd_make_section (abfd, THUMB2ARM_GLUE_SECTION_NAME);
520
521 if (sec == NULL
522 || !bfd_set_section_flags (abfd, sec, flags)
523 || !bfd_set_section_alignment (abfd, sec, 2))
524 return false;
525 }
526
527 /* Save the bfd for later use. */
528 globals->bfd_of_glue_owner = abfd;
529
530 return true;
531}
532
533boolean
534bfd_elf32_arm_process_before_allocation (abfd, link_info)
535 bfd *abfd;
536 struct bfd_link_info *link_info;
537{
538 Elf_Internal_Shdr *symtab_hdr;
539 Elf_Internal_Rela *free_relocs = NULL;
540 Elf_Internal_Rela *irel, *irelend;
541 bfd_byte *contents = NULL;
542 bfd_byte *free_contents = NULL;
543 Elf32_External_Sym *extsyms = NULL;
544 Elf32_External_Sym *free_extsyms = NULL;
545
546 asection *sec;
547 struct elf32_arm_link_hash_table *globals;
548
549 /* If we are only performing a partial link do not bother
550 to construct any glue. */
551 if (link_info->relocateable)
552 return true;
553
554 /* Here we have a bfd that is to be included on the link. We have a hook
555 to do reloc rummaging, before section sizes are nailed down. */
556
557 globals = elf32_arm_hash_table (link_info);
558
559 BFD_ASSERT (globals != NULL);
560 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
561
562 /* Rummage around all the relocs and map the glue vectors. */
563 sec = abfd->sections;
564
565 if (sec == NULL)
566 return true;
567
568 for (; sec != NULL; sec = sec->next)
569 {
570 if (sec->reloc_count == 0)
571 continue;
572
573 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
574 /* Load the relocs. */
575
576 irel = (_bfd_elf32_link_read_relocs (abfd, sec, (PTR) NULL,
577 (Elf_Internal_Rela *) NULL, false));
578
579 BFD_ASSERT (irel != 0);
580
581 irelend = irel + sec->reloc_count;
582 for (; irel < irelend; irel++)
583 {
584 long r_type;
585 unsigned long r_index;
586 unsigned char code;
587
588 struct elf_link_hash_entry *h;
589
590 r_type = ELF32_R_TYPE (irel->r_info);
591 r_index = ELF32_R_SYM (irel->r_info);
592
593 /* These are the only relocation types we care about */
594 if (r_type != R_ARM_PC24
595 && r_type != R_ARM_THM_PC22)
596 continue;
597
598 /* Get the section contents if we haven't done so already. */
599 if (contents == NULL)
600 {
601 /* Get cached copy if it exists. */
602 if (elf_section_data (sec)->this_hdr.contents != NULL)
603 contents = elf_section_data (sec)->this_hdr.contents;
604 else
605 {
606 /* Go get them off disk. */
607 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
608 if (contents == NULL)
609 goto error_return;
610 free_contents = contents;
611
612 if (!bfd_get_section_contents (abfd, sec, contents,
613 (file_ptr) 0, sec->_raw_size))
614 goto error_return;
615 }
616 }
617
618 /* Read this BFD's symbols if we haven't done so already. */
619 if (extsyms == NULL)
620 {
621 /* Get cached copy if it exists. */
622 if (symtab_hdr->contents != NULL)
623 extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
624 else
625 {
626 /* Go get them off disk. */
627 extsyms = ((Elf32_External_Sym *)
628 bfd_malloc (symtab_hdr->sh_size));
629 if (extsyms == NULL)
630 goto error_return;
631 free_extsyms = extsyms;
632 if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
633 || (bfd_read (extsyms, 1, symtab_hdr->sh_size, abfd)
634 != symtab_hdr->sh_size))
635 goto error_return;
636 }
637 }
638
639 /* If the relocation is not against a symbol it cannot concern us. */
640
641 h = NULL;
642
643 /* We don't care about local symbols */
644 if (r_index < symtab_hdr->sh_info)
645 continue;
646
647 /* This is an external symbol */
648 r_index -= symtab_hdr->sh_info;
649 h = (struct elf_link_hash_entry *)
650 elf_sym_hashes (abfd)[r_index];
651
652 /* If the relocation is against a static symbol it must be within
653 the current section and so cannot be a cross ARM/Thumb relocation. */
654 if (h == NULL)
655 continue;
656
657 switch (r_type)
658 {
659 case R_ARM_PC24:
660 /* This one is a call from arm code. We need to look up
661 the target of the call. If it is a thumb target, we
662 insert glue. */
663
664 if (ELF_ST_TYPE(h->type) == STT_ARM_TFUNC)
665 record_arm_to_thumb_glue (link_info, h);
666 break;
667
668 case R_ARM_THM_PC22:
669 /* This one is a call from thumb code. We look
670 up the target of the call. If it is not a thumb
671 target, we insert glue. */
672
673 if (ELF_ST_TYPE (h->type) != STT_ARM_TFUNC)
674 record_thumb_to_arm_glue (link_info, h);
675 break;
676
677 default:
678 break;
679 }
680 }
681 }
682
683 return true;
684error_return:
685 if (free_relocs != NULL)
686 free (free_relocs);
687 if (free_contents != NULL)
688 free (free_contents);
689 if (free_extsyms != NULL)
690 free (free_extsyms);
691 return false;
692
693}
694
695/* The thumb form of a long branch is a bit finicky, because the offset
696 encoding is split over two fields, each in it's own instruction. They
697 can occur in any order. So given a thumb form of long branch, and an
698 offset, insert the offset into the thumb branch and return finished
699 instruction.
700
701 It takes two thumb instructions to encode the target address. Each has
702 11 bits to invest. The upper 11 bits are stored in one (identifed by
703 H-0.. see below), the lower 11 bits are stored in the other (identified
704 by H-1).
705
706 Combine together and shifted left by 1 (it's a half word address) and
707 there you have it.
708
709 Op: 1111 = F,
710 H-0, upper address-0 = 000
711 Op: 1111 = F,
712 H-1, lower address-0 = 800
713
714 They can be ordered either way, but the arm tools I've seen always put
715 the lower one first. It probably doesn't matter. krk@cygnus.com
716
717 XXX: Actually the order does matter. The second instruction (H-1)
718 moves the computed address into the PC, so it must be the second one
719 in the sequence. The problem, however is that whilst little endian code
720 stores the instructions in HI then LOW order, big endian code does the
721 reverse. nickc@cygnus.com */
722
723#define LOW_HI_ORDER 0xF800F000
724#define HI_LOW_ORDER 0xF000F800
725
726static insn32
727insert_thumb_branch (br_insn, rel_off)
728 insn32 br_insn;
729 int rel_off;
730{
731 unsigned int low_bits;
732 unsigned int high_bits;
733
734
735 BFD_ASSERT ((rel_off & 1) != 1);
736
737 rel_off >>= 1; /* half word aligned address */
738 low_bits = rel_off & 0x000007FF; /* the bottom 11 bits */
739 high_bits = (rel_off >> 11) & 0x000007FF; /* the top 11 bits */
740
741 if ((br_insn & LOW_HI_ORDER) == LOW_HI_ORDER)
742 br_insn = LOW_HI_ORDER | (low_bits << 16) | high_bits;
743 else if ((br_insn & HI_LOW_ORDER) == HI_LOW_ORDER)
744 br_insn = HI_LOW_ORDER | (high_bits << 16) | low_bits;
745 else
746 abort (); /* error - not a valid branch instruction form */
747
748 /* FIXME: abort is probably not the right call. krk@cygnus.com */
749
750 return br_insn;
751}
752
753/* Thumb code calling an ARM function */
754static int
755elf32_thumb_to_arm_stub (info, name, input_bfd, output_bfd, input_section,
756 hit_data, sym_sec, offset, addend, val)
757 struct bfd_link_info *info;
758 char *name;
759 bfd *input_bfd;
760 bfd *output_bfd;
761 asection *input_section;
762 bfd_byte *hit_data;
763 asection *sym_sec;
764 int offset;
765 int addend;
766 bfd_vma val;
767{
768 asection *s = 0;
769 long int my_offset;
770 unsigned long int tmp;
771 long int ret_offset;
772 struct elf_link_hash_entry *myh;
773 struct elf32_arm_link_hash_table *globals;
774
775 myh = find_thumb_glue (info, name, input_bfd);
776 if (myh == NULL)
777 return false;
778
779 globals = elf32_arm_hash_table (info);
780
781 BFD_ASSERT (globals != NULL);
782 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
783
784 my_offset = myh->root.u.def.value;
785
786 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
787 THUMB2ARM_GLUE_SECTION_NAME);
788
789 BFD_ASSERT (s != NULL);
790 BFD_ASSERT (s->contents != NULL);
791 BFD_ASSERT (s->output_section != NULL);
792
793 if ((my_offset & 0x01) == 0x01)
794 {
795 if (sym_sec != NULL
796 && sym_sec->owner != NULL
797 && !INTERWORK_FLAG (sym_sec->owner))
798 {
799 _bfd_error_handler
800 (_ ("%s(%s): warning: interworking not enabled."),
801 bfd_get_filename (sym_sec->owner), name);
802 _bfd_error_handler
803 (_ (" first occurrence: %s: thumb call to arm"),
804 bfd_get_filename (input_bfd));
805
806 return false;
807 }
808
809 --my_offset;
810 myh->root.u.def.value = my_offset;
811
812 bfd_put_16 (output_bfd, t2a1_bx_pc_insn,
813 s->contents + my_offset);
814
815 bfd_put_16 (output_bfd, t2a2_noop_insn,
816 s->contents + my_offset + 2);
817
818 ret_offset =
819 ((bfd_signed_vma) val) /* Address of destination of the stub */
820 - ((bfd_signed_vma)
821 (s->output_offset /* Offset from the start of the current section to the start of the stubs. */
822 + my_offset /* Offset of the start of this stub from the start of the stubs. */
823 + s->output_section->vma) /* Address of the start of the current section. */
824 + 4 /* The branch instruction is 4 bytes into the stub. */
825 + 8); /* ARM branches work from the pc of the instruction + 8. */
826
827 bfd_put_32 (output_bfd,
828 t2a3_b_insn | ((ret_offset >> 2) & 0x00FFFFFF),
829 s->contents + my_offset + 4);
830 }
831
832 BFD_ASSERT (my_offset <= globals->thumb_glue_size);
833
834 /* Now go back and fix up the original BL insn to point
835 to here. */
836 ret_offset =
837 s->output_offset
838 + my_offset
839 - (input_section->output_offset
840 + offset + addend)
841 - 4;
842
843 tmp = bfd_get_32 (input_bfd, hit_data
844 - input_section->vma);
845
846 bfd_put_32 (output_bfd,
847 insert_thumb_branch (tmp, ret_offset),
848 hit_data - input_section->vma);
849
850 return true;
851}
852
853/* Arm code calling a Thumb function */
854static int
855elf32_arm_to_thumb_stub (info, name, input_bfd, output_bfd, input_section,
856 hit_data, sym_sec, offset, addend, val)
857
858 struct bfd_link_info *info;
859 char *name;
860 bfd *input_bfd;
861 bfd *output_bfd;
862 asection *input_section;
863 bfd_byte *hit_data;
864 asection *sym_sec;
865 int offset;
866 int addend;
867 bfd_vma val;
868{
869 unsigned long int tmp;
870 long int my_offset;
871 asection *s;
872 long int ret_offset;
873 struct elf_link_hash_entry *myh;
874 struct elf32_arm_link_hash_table *globals;
875
876 myh = find_arm_glue (info, name, input_bfd);
877 if (myh == NULL)
878 return false;
879
880 globals = elf32_arm_hash_table (info);
881
882 BFD_ASSERT (globals != NULL);
883 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
884
885 my_offset = myh->root.u.def.value;
886 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
887 ARM2THUMB_GLUE_SECTION_NAME);
888 BFD_ASSERT (s != NULL);
889 BFD_ASSERT (s->contents != NULL);
890 BFD_ASSERT (s->output_section != NULL);
891
892 if ((my_offset & 0x01) == 0x01)
893 {
894 if (sym_sec != NULL
895 && sym_sec->owner != NULL
896 && !INTERWORK_FLAG (sym_sec->owner))
897 {
898 _bfd_error_handler
899 (_ ("%s(%s): warning: interworking not enabled."),
900 bfd_get_filename (sym_sec->owner), name);
901 _bfd_error_handler
902 (_ (" first occurrence: %s: arm call to thumb"),
903 bfd_get_filename (input_bfd));
904 }
905 --my_offset;
906 myh->root.u.def.value = my_offset;
907
908 bfd_put_32 (output_bfd, a2t1_ldr_insn,
909 s->contents + my_offset);
910
911 bfd_put_32 (output_bfd, a2t2_bx_r12_insn,
912 s->contents + my_offset + 4);
913
914 /* It's a thumb address. Add the low order bit. */
915 bfd_put_32 (output_bfd, val | a2t3_func_addr_insn,
916 s->contents + my_offset + 8);
917 }
918
919 BFD_ASSERT (my_offset <= globals->arm_glue_size);
920
921 tmp = bfd_get_32 (input_bfd, hit_data);
922 tmp = tmp & 0xFF000000;
923
924 /* Somehow these are both 4 too far, so subtract 8. */
925 ret_offset = s->output_offset
926 + my_offset
927 + s->output_section->vma
928 - (input_section->output_offset
929 + input_section->output_section->vma
930 + offset + addend)
931 - 8;
932
933 tmp = tmp | ((ret_offset >> 2) & 0x00FFFFFF);
934
935 bfd_put_32 (output_bfd, tmp, hit_data
936 - input_section->vma);
937
938
939 return true;
940}
941
942/* Perform a relocation as part of a final link. */
943static bfd_reloc_status_type
944elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
945 input_section, contents, rel, value,
946 info, sym_sec, sym_name, sym_flags)
947 reloc_howto_type * howto;
948 bfd * input_bfd;
949 bfd * output_bfd;
950 asection * input_section;
951 bfd_byte * contents;
952 Elf_Internal_Rela * rel;
953 bfd_vma value;
954 struct bfd_link_info * info;
955 asection * sym_sec;
956 const char * sym_name;
957 unsigned char sym_flags;
958{
959 unsigned long r_type = howto->type;
960 unsigned long r_symndx;
961 bfd_byte * hit_data = contents + rel->r_offset;
962 bfd * dynobj = NULL;
963 Elf_Internal_Shdr * symtab_hdr;
964 struct elf_link_hash_entry ** sym_hashes;
965 bfd_vma * local_got_offsets;
966 asection * sgot = NULL;
967 asection * splt = NULL;
968 asection * sreloc = NULL;
969 struct elf_link_hash_entry * h = NULL;
970 bfd_vma addend;
971
972 dynobj = elf_hash_table (info)->dynobj;
973 if (dynobj)
974 {
975 sgot = bfd_get_section_by_name (dynobj, ".got");
976 splt = bfd_get_section_by_name (dynobj, ".plt");
977 }
978 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
979 sym_hashes = elf_sym_hashes (input_bfd);
980 local_got_offsets = elf_local_got_offsets (input_bfd);
981 r_symndx = ELF32_R_SYM (rel->r_info);
982
983#ifdef USE_REL
984 addend = (bfd_get_32 (input_bfd, hit_data) & howto->src_mask);
985#else
986 addend = rel->r_addend;
987#endif
988
989 switch (r_type)
990 {
991 case R_ARM_NONE:
992 return bfd_reloc_ok;
993
994 case R_ARM_PC24:
995 case R_ARM_ABS32:
996 case R_ARM_REL32:
997 /* When generating a shared object, these relocations are copied
998 into the output file to be resolved at run time. */
999
1000 if (info->shared
1001 && (r_type != R_ARM_PC24
1002 || (h != NULL
1003 && h->dynindx != -1
1004 && (! info->symbolic
1005 || (h->elf_link_hash_flags
1006 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
1007 {
1008 Elf_Internal_Rel outrel;
1009 boolean skip, relocate;
1010
1011 if (sreloc == NULL)
1012 {
1013 const char * name;
1014
1015 name = (bfd_elf_string_from_elf_section
1016 (input_bfd,
1017 elf_elfheader (input_bfd)->e_shstrndx,
1018 elf_section_data (input_section)->rel_hdr.sh_name));
1019 if (name == NULL)
1020 return bfd_reloc_notsupported;
1021
1022 BFD_ASSERT (strncmp (name, ".rel", 4) == 0
1023 && strcmp (bfd_get_section_name (input_bfd,
1024 input_section),
1025 name + 4) == 0);
1026
1027 sreloc = bfd_get_section_by_name (dynobj, name);
1028 BFD_ASSERT (sreloc != NULL);
1029 }
1030
1031 skip = false;
1032
1033 if (elf_section_data (input_section)->stab_info == NULL)
1034 outrel.r_offset = rel->r_offset;
1035 else
1036 {
1037 bfd_vma off;
1038
1039 off = (_bfd_stab_section_offset
1040 (output_bfd, &elf_hash_table (info)->stab_info,
1041 input_section,
1042 & elf_section_data (input_section)->stab_info,
1043 rel->r_offset));
1044 if (off == (bfd_vma) -1)
1045 skip = true;
1046 outrel.r_offset = off;
1047 }
1048
1049 outrel.r_offset += (input_section->output_section->vma
1050 + input_section->output_offset);
1051
1052 if (skip)
1053 {
1054 memset (&outrel, 0, sizeof outrel);
1055 relocate = false;
1056 }
1057 else if (r_type == R_ARM_PC24)
1058 {
1059 BFD_ASSERT (h != NULL && h->dynindx != -1);
1060 if ((input_section->flags & SEC_ALLOC) != 0)
1061 relocate = false;
1062 else
1063 relocate = true;
1064 outrel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_PC24);
1065 }
1066 else
1067 {
1068 if (h == NULL
1069 || ((info->symbolic || h->dynindx == -1)
1070 && (h->elf_link_hash_flags
1071 & ELF_LINK_HASH_DEF_REGULAR) != 0))
1072 {
1073 relocate = true;
1074 outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
1075 }
1076 else
1077 {
1078 BFD_ASSERT (h->dynindx != -1);
1079 if ((input_section->flags & SEC_ALLOC) != 0)
1080 relocate = false;
1081 else
1082 relocate = true;
1083 outrel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_ABS32);
1084 }
1085 }
1086
1087 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1088 (((Elf32_External_Rel *)
1089 sreloc->contents)
1090 + sreloc->reloc_count));
1091 ++sreloc->reloc_count;
1092
1093 /* If this reloc is against an external symbol, we do not want to
1094 fiddle with the addend. Otherwise, we need to include the symbol
1095 value so that it becomes an addend for the dynamic reloc. */
1096 if (! relocate)
1097 return bfd_reloc_ok;
1098
1099 return _bfd_final_link_relocate (howto, input_bfd, input_section,
1100 contents, rel->r_offset, value,
1101 (bfd_vma) 0);
1102 }
1103 else switch (r_type)
1104 {
1105 case R_ARM_PC24:
1106 /* Arm B/BL instruction */
1107
1108 /* Check for arm calling thumb function. */
1109 if (sym_flags == STT_ARM_TFUNC)
1110 {
1111 elf32_arm_to_thumb_stub (info, sym_name, input_bfd, output_bfd,
1112 input_section, hit_data, sym_sec, rel->r_offset, addend, value);
1113 return bfd_reloc_ok;
1114 }
1115
1116 value = value + addend;
1117 value -= (input_section->output_section->vma
1118 + input_section->output_offset + 8);
1119 value -= rel->r_offset;
1120 value = value >> howto->rightshift;
1121
1122 value &= 0xffffff;
1123 value |= (bfd_get_32 (input_bfd, hit_data) & 0xff000000);
1124 break;
1125
1126 case R_ARM_ABS32:
1127 value += addend;
1128 if (sym_flags == STT_ARM_TFUNC)
1129 value |= 1;
1130 break;
1131
1132 case R_ARM_REL32:
1133 value -= (input_section->output_section->vma
1134 + input_section->output_offset);
1135 value += addend;
1136 break;
1137 }
1138
1139 bfd_put_32 (input_bfd, value, hit_data);
1140 return bfd_reloc_ok;
1141
1142 case R_ARM_ABS8:
1143 value += addend;
1144 if ((long) value > 0x7f || (long) value < -0x80)
1145 return bfd_reloc_overflow;
1146
1147 bfd_put_8 (input_bfd, value, hit_data);
1148 return bfd_reloc_ok;
1149
1150 case R_ARM_ABS16:
1151 value += addend;
1152
1153 if ((long) value > 0x7fff || (long) value < -0x8000)
1154 return bfd_reloc_overflow;
1155
1156 bfd_put_16 (input_bfd, value, hit_data);
1157 return bfd_reloc_ok;
1158
1159 case R_ARM_ABS12:
1160 /* Support ldr and str instruction for the arm */
1161 /* Also thumb b (unconditional branch). ??? Really? */
1162 value += addend;
1163
1164 if ((long) value > 0x7ff || (long) value < -0x800)
1165 return bfd_reloc_overflow;
1166
1167 value |= (bfd_get_32 (input_bfd, hit_data) & 0xfffff000);
1168 bfd_put_32 (input_bfd, value, hit_data);
1169 return bfd_reloc_ok;
1170
1171 case R_ARM_THM_ABS5:
1172 /* Support ldr and str instructions for the thumb. */
1173#ifdef USE_REL
1174 /* Need to refetch addend. */
1175 addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
1176 /* ??? Need to determine shift amount from operand size. */
1177 addend >>= howto->rightshift;
1178#endif
1179 value += addend;
1180
1181 /* ??? Isn't value unsigned? */
1182 if ((long) value > 0x1f || (long) value < -0x10)
1183 return bfd_reloc_overflow;
1184
1185 /* ??? Value needs to be properly shifted into place first. */
1186 value |= bfd_get_16 (input_bfd, hit_data) & 0xf83f;
1187 bfd_put_16 (input_bfd, value, hit_data);
1188 return bfd_reloc_ok;
1189
1190 case R_ARM_THM_PC22:
1191 /* Thumb BL (branch long instruction). */
1192 {
1193 bfd_vma relocation;
1194 boolean overflow = false;
1195 bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
1196 bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
1197 bfd_vma src_mask = 0x007FFFFE;
1198 bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
1199 bfd_signed_vma reloc_signed_min = ~reloc_signed_max;
1200 bfd_vma check;
1201 bfd_signed_vma signed_check;
1202 bfd_vma add;
1203 bfd_signed_vma signed_add;
1204
1205#ifdef USE_REL
1206 /* Need to refetch the addend and squish the two 11 bit pieces
1207 together. */
1208 {
1209 bfd_vma upper = bfd_get_16 (input_bfd, hit_data) & 0x7ff;
1210 bfd_vma lower = bfd_get_16 (input_bfd, hit_data + 2) & 0x7ff;
1211 upper = (upper ^ 0x400) - 0x400; /* sign extend */
1212 addend = (upper << 12) | (lower << 1);
1213 }
1214#endif
1215
1216 /* If it's not a call to thumb, assume call to arm */
1217 if (sym_flags != STT_ARM_TFUNC)
1218 {
1219 if (elf32_thumb_to_arm_stub
1220 (info, sym_name, input_bfd, output_bfd, input_section,
1221 hit_data, sym_sec, rel->r_offset, addend, value))
1222 return bfd_reloc_ok;
1223 else
1224 return bfd_reloc_dangerous;
1225 }
1226
1227 /* +4: pc is offset by 4 */
1228 relocation = value + addend + 4;
1229 relocation -= (input_section->output_section->vma
1230 + input_section->output_offset);
1231 relocation -= rel->r_offset;
1232
1233 check = relocation >> howto->rightshift;
1234
1235 /* If this is a signed value, the rightshift just dropped
1236 leading 1 bits (assuming twos complement). */
1237 if ((bfd_signed_vma) relocation >= 0)
1238 signed_check = check;
1239 else
1240 signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
1241
1242 add = ((upper_insn & 0x7ff) << 12) | ((lower_insn & 0x7ff) << 1);
1243 /* sign extend */
1244 signed_add = (add ^ 0x400000) - 0x400000;
1245
1246 /* Add the value from the object file. */
1247 signed_check += signed_add;
1248 relocation += signed_add;
1249
1250 /* Assumes two's complement. */
1251 if (signed_check > reloc_signed_max
1252 || signed_check < reloc_signed_min)
1253 overflow = true;
1254
1255 /* Put RELOCATION back into the insn. */
1256 upper_insn = (upper_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 12) & 0x7ff);
1257 lower_insn = (lower_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 1) & 0x7ff);
1258
1259 /* Put the relocated value back in the object file: */
1260 bfd_put_16 (input_bfd, upper_insn, hit_data);
1261 bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
1262
1263 return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
1264 }
1265 break;
1266
1267 case R_ARM_GNU_VTINHERIT:
1268 case R_ARM_GNU_VTENTRY:
1269 return bfd_reloc_ok;
1270
1271 case R_ARM_COPY:
1272 return bfd_reloc_notsupported;
1273
1274 case R_ARM_GLOB_DAT:
1275 return bfd_reloc_notsupported;
1276
1277 case R_ARM_JUMP_SLOT:
1278 return bfd_reloc_notsupported;
1279
1280 case R_ARM_RELATIVE:
1281 return bfd_reloc_notsupported;
1282
1283 case R_ARM_GOTOFF:
1284 /* Relocation is relative to the start of the
1285 global offset table. */
1286
1287 BFD_ASSERT (sgot != NULL);
1288 if (sgot == NULL)
1289 return bfd_reloc_notsupported;
1290
1291 /* Note that sgot->output_offset is not involved in this
1292 calculation. We always want the start of .got. If we
1293 define _GLOBAL_OFFSET_TABLE in a different way, as is
1294 permitted by the ABI, we might have to change this
1295 calculation. */
1296
1297 value -= sgot->output_section->vma;
1298 return _bfd_final_link_relocate (howto, input_bfd, input_section,
1299 contents, rel->r_offset, value,
1300 (bfd_vma) 0);
1301
1302 case R_ARM_GOTPC:
1303 /* Use global offset table as symbol value. */
1304
1305 BFD_ASSERT (sgot != NULL);
1306
1307 if (sgot == NULL)
1308 return bfd_reloc_notsupported;
1309
1310 value = sgot->output_section->vma;
1311 return _bfd_final_link_relocate (howto, input_bfd, input_section,
1312 contents, rel->r_offset, value,
1313 (bfd_vma) 0);
1314
1315 case R_ARM_GOT32:
1316 /* Relocation is to the entry for this symbol in the
1317 global offset table. */
1318 if (sgot == NULL)
1319 return bfd_reloc_notsupported;
1320
1321 if (h != NULL)
1322 {
1323 bfd_vma off;
1324
1325 off = h->got.offset;
1326 BFD_ASSERT (off != (bfd_vma) -1);
1327
1328 if (!elf_hash_table (info)->dynamic_sections_created ||
1329 (info->shared && (info->symbolic || h->dynindx == -1)
1330 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1331 {
1332 /* This is actually a static link, or it is a -Bsymbolic link
1333 and the symbol is defined locally. We must initialize this
1334 entry in the global offset table. Since the offset must
1335 always be a multiple of 4, we use the least significant bit
1336 to record whether we have initialized it already.
1337
1338 When doing a dynamic link, we create a .rel.got relocation
1339 entry to initialize the value. This is done in the
1340 finish_dynamic_symbol routine. */
1341
1342 if ((off & 1) != 0)
1343 off &= ~1;
1344 else
1345 {
1346 bfd_put_32 (output_bfd, value, sgot->contents + off);
1347 h->got.offset |= 1;
1348 }
1349 }
1350
1351 value = sgot->output_offset + off;
1352 }
1353 else
1354 {
1355 bfd_vma off;
1356
1357 BFD_ASSERT (local_got_offsets != NULL &&
1358 local_got_offsets[r_symndx] != (bfd_vma) -1);
1359
1360 off = local_got_offsets[r_symndx];
1361
1362 /* The offset must always be a multiple of 4. We use the
1363 least significant bit to record whether we have already
1364 generated the necessary reloc. */
1365 if ((off & 1) != 0)
1366 off &= ~1;
1367 else
1368 {
1369 bfd_put_32 (output_bfd, value, sgot->contents + off);
1370
1371 if (info->shared)
1372 {
1373 asection * srelgot;
1374 Elf_Internal_Rel outrel;
1375
1376 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
1377 BFD_ASSERT (srelgot != NULL);
1378
1379 outrel.r_offset = (sgot->output_section->vma
1380 + sgot->output_offset
1381 + off);
1382 outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
1383 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1384 (((Elf32_External_Rel *)
1385 srelgot->contents)
1386 + srelgot->reloc_count));
1387 ++srelgot->reloc_count;
1388 }
1389
1390 local_got_offsets[r_symndx] |= 1;
1391 }
1392
1393 value = sgot->output_offset + off;
1394 }
1395
1396 return _bfd_final_link_relocate (howto, input_bfd, input_section,
1397 contents, rel->r_offset, value,
1398 (bfd_vma) 0);
1399
1400 case R_ARM_PLT32:
1401 /* Relocation is to the entry for this symbol in the
1402 procedure linkage table. */
1403
1404 /* Resolve a PLT32 reloc against a local symbol directly,
1405 without using the procedure linkage table. */
1406 if (h == NULL)
1407 return _bfd_final_link_relocate (howto, input_bfd, input_section,
1408 contents, rel->r_offset, value,
1409 (bfd_vma) 0);
1410
1411 if (h->plt.offset == (bfd_vma) -1)
1412 /* We didn't make a PLT entry for this symbol. This
1413 happens when statically linking PIC code, or when
1414 using -Bsymbolic. */
1415 return _bfd_final_link_relocate (howto, input_bfd, input_section,
1416 contents, rel->r_offset, value,
1417 (bfd_vma) 0);
1418
1419 BFD_ASSERT(splt != NULL);
1420 if (splt == NULL)
1421 return bfd_reloc_notsupported;
1422
1423 value = (splt->output_section->vma
1424 + splt->output_offset
1425 + h->plt.offset);
1426 return _bfd_final_link_relocate (howto, input_bfd, input_section,
1427 contents, rel->r_offset, value,
1428 (bfd_vma) 0);
1429
1430 case R_ARM_SBREL32:
1431 return bfd_reloc_notsupported;
1432
1433 case R_ARM_AMP_VCALL9:
1434 return bfd_reloc_notsupported;
1435
1436 case R_ARM_RSBREL32:
1437 return bfd_reloc_notsupported;
1438
1439 case R_ARM_THM_RPC22:
1440 return bfd_reloc_notsupported;
1441
1442 case R_ARM_RREL32:
1443 return bfd_reloc_notsupported;
1444
1445 case R_ARM_RABS32:
1446 return bfd_reloc_notsupported;
1447
1448 case R_ARM_RPC24:
1449 return bfd_reloc_notsupported;
1450
1451 case R_ARM_RBASE:
1452 return bfd_reloc_notsupported;
1453
1454 default:
1455 return bfd_reloc_notsupported;
1456 }
1457}
1458
1459
1460/* Relocate an ARM ELF section. */
1461static boolean
1462elf32_arm_relocate_section (output_bfd, info, input_bfd, input_section,
1463 contents, relocs, local_syms, local_sections)
1464 bfd * output_bfd;
1465 struct bfd_link_info * info;
1466 bfd * input_bfd;
1467 asection * input_section;
1468 bfd_byte * contents;
1469 Elf_Internal_Rela * relocs;
1470 Elf_Internal_Sym * local_syms;
1471 asection ** local_sections;
1472{
1473 Elf_Internal_Shdr * symtab_hdr;
1474 struct elf_link_hash_entry ** sym_hashes;
1475 Elf_Internal_Rela * rel;
1476 Elf_Internal_Rela * relend;
1477 const char * name;
1478
1479 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1480 sym_hashes = elf_sym_hashes (input_bfd);
1481
1482 rel = relocs;
1483 relend = relocs + input_section->reloc_count;
1484 for (; rel < relend; rel++)
1485 {
1486 int r_type;
1487 reloc_howto_type * howto;
1488 unsigned long r_symndx;
1489 Elf_Internal_Sym * sym;
1490 asection * sec;
1491 struct elf_link_hash_entry * h;
1492 bfd_vma relocation;
1493 bfd_reloc_status_type r;
1494
1495 r_symndx = ELF32_R_SYM (rel->r_info);
1496 r_type = ELF32_R_TYPE (rel->r_info);
1497
1498 if (r_type == R_ARM_GNU_VTENTRY
1499 || r_type == R_ARM_GNU_VTINHERIT )
1500 continue;
1501
1502 /* ScottB: range check r_type here. */
1503
1504 howto = elf32_arm_howto_table + r_type;
1505
1506 if (info->relocateable)
1507 {
1508 /* This is a relocateable link. We don't have to change
1509 anything, unless the reloc is against a section symbol,
1510 in which case we have to adjust according to where the
1511 section symbol winds up in the output section. */
1512 if (r_symndx < symtab_hdr->sh_info)
1513 {
1514 sym = local_syms + r_symndx;
1515 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1516 {
1517 sec = local_sections[r_symndx];
1518#ifdef USE_REL
1519 {
1520 bfd_vma val;
1521 val = bfd_get_32 (input_bfd, contents + rel->r_offset);
1522 val += (sec->output_offset + sym->st_value) >> howto->rightshift;
1523 bfd_put_32 (input_bfd, val, contents + rel->r_offset);
1524 }
1525#else
1526 rel->r_addend += (sec->output_offset + sym->st_value)
1527 >> howto->rightshift;
1528#endif
1529 }
1530 }
1531
1532 continue;
1533 }
1534
1535 /* This is a final link. */
1536 h = NULL;
1537 sym = NULL;
1538 sec = NULL;
1539 if (r_symndx < symtab_hdr->sh_info)
1540 {
1541 sym = local_syms + r_symndx;
1542 sec = local_sections[r_symndx];
1543 relocation = (sec->output_section->vma
1544 + sec->output_offset
1545 + sym->st_value);
1546 }
1547 else
1548 {
1549 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1550 while (h->root.type == bfd_link_hash_indirect
1551 || h->root.type == bfd_link_hash_warning)
1552 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1553 if (h->root.type == bfd_link_hash_defined
1554 || h->root.type == bfd_link_hash_defweak)
1555 {
1556 sec = h->root.u.def.section;
1557
1558 relocation = (h->root.u.def.value
1559 + sec->output_section->vma
1560 + sec->output_offset);
1561
1562 /* In these cases, we don't need the relocation value.
1563 We check specially because in some obscure cases
1564 sec->output_section will be NULL. */
1565 switch (r_type)
1566 {
1567 case R_ARM_PC24:
1568 case R_ARM_ABS32:
1569 if (info->shared
1570 && (
1571 (!info->symbolic && h->dynindx != -1)
1572 || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR == 0)
1573 )
1574 && ((input_section->flags & SEC_ALLOC) != 0)
1575 )
1576 relocation = 0;
1577 break;
1578
1579 case R_ARM_GOTPC:
1580 relocation = 0;
1581 break;
1582
1583 case R_ARM_GOT32:
1584 if (elf_hash_table(info)->dynamic_sections_created
1585 && (!info->shared
1586 || (!info->symbolic && h->dynindx != -1)
1587 || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
1588 )
1589 )
1590 relocation = 0;
1591 break;
1592
1593 case R_ARM_PLT32:
1594 if (h->plt.offset != (bfd_vma)-1)
1595 relocation = 0;
1596 break;
1597
1598 default:
1599 if (sec->output_section == NULL)
1600 {
1601 (*_bfd_error_handler)
1602 (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
1603 bfd_get_filename (input_bfd), h->root.root.string,
1604 bfd_get_section_name (input_bfd, input_section));
1605 relocation = 0;
1606 }
1607 }
1608 }
1609 else if (h->root.type == bfd_link_hash_undefweak)
1610 relocation = 0;
1611 else
1612 {
1613 if (!((*info->callbacks->undefined_symbol)
1614 (info, h->root.root.string, input_bfd,
1615 input_section, rel->r_offset)))
1616 return false;
1617 relocation = 0;
1618 }
1619 }
1620
1621 if (h != NULL)
1622 name = h->root.root.string;
1623 else
1624 {
1625 name = (bfd_elf_string_from_elf_section
1626 (input_bfd, symtab_hdr->sh_link, sym->st_name));
1627 if (name == NULL || *name == '\0')
1628 name = bfd_section_name (input_bfd, sec);
1629 }
1630
1631 r = elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
1632 input_section, contents, rel,
1633 relocation, info, sec, name,
1634 (h ? ELF_ST_TYPE (h->type) :
1635 ELF_ST_TYPE (sym->st_info)));
1636
1637 if (r != bfd_reloc_ok)
1638 {
1639 const char * msg = (const char *) 0;
1640
1641 switch (r)
1642 {
1643 case bfd_reloc_overflow:
1644 if (!((*info->callbacks->reloc_overflow)
1645 (info, name, howto->name, (bfd_vma) 0,
1646 input_bfd, input_section, rel->r_offset)))
1647 return false;
1648 break;
1649
1650 case bfd_reloc_undefined:
1651 if (!((*info->callbacks->undefined_symbol)
1652 (info, name, input_bfd, input_section,
1653 rel->r_offset)))
1654 return false;
1655 break;
1656
1657 case bfd_reloc_outofrange:
1658 msg = _ ("internal error: out of range error");
1659 goto common_error;
1660
1661 case bfd_reloc_notsupported:
1662 msg = _ ("internal error: unsupported relocation error");
1663 goto common_error;
1664
1665 case bfd_reloc_dangerous:
1666 msg = _ ("internal error: dangerous error");
1667 goto common_error;
1668
1669 default:
1670 msg = _ ("internal error: unknown error");
1671 /* fall through */
1672
1673 common_error:
1674 if (!((*info->callbacks->warning)
1675 (info, msg, name, input_bfd, input_section,
1676 rel->r_offset)))
1677 return false;
1678 break;
1679 }
1680 }
1681 }
1682
1683 return true;
1684}
1685
1686/* Function to keep ARM specific flags in the ELF header. */
1687static boolean
1688elf32_arm_set_private_flags (abfd, flags)
1689 bfd *abfd;
1690 flagword flags;
1691{
1692 if (elf_flags_init (abfd)
1693 && elf_elfheader (abfd)->e_flags != flags)
1694 {
1695 if (flags & EF_INTERWORK)
1696 _bfd_error_handler (_ ("\
1697Warning: Not setting interwork flag of %s since it has already been specified as non-interworking"),
1698 bfd_get_filename (abfd));
1699 else
1700 _bfd_error_handler (_ ("\
1701Warning: Clearing the interwork flag of %s due to outside request"),
1702 bfd_get_filename (abfd));
1703 }
1704 else
1705 {
1706 elf_elfheader (abfd)->e_flags = flags;
1707 elf_flags_init (abfd) = true;
1708 }
1709
1710 return true;
1711}
1712
1713/* Copy backend specific data from one object module to another */
1714static boolean
1715elf32_arm_copy_private_bfd_data (ibfd, obfd)
1716 bfd *ibfd;
1717 bfd *obfd;
1718{
1719 flagword in_flags;
1720 flagword out_flags;
1721
1722 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1723 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1724 return true;
1725
1726 in_flags = elf_elfheader (ibfd)->e_flags;
1727 out_flags = elf_elfheader (obfd)->e_flags;
1728
1729 if (elf_flags_init (obfd) && in_flags != out_flags)
1730 {
1731 /* Cannot mix PIC and non-PIC code. */
1732 if ((in_flags & EF_PIC) != (out_flags & EF_PIC))
1733 return false;
1734
1735 /* Cannot mix APCS26 and APCS32 code. */
1736 if ((in_flags & EF_APCS_26) != (out_flags & EF_APCS_26))
1737 return false;
1738
1739 /* Cannot mix float APCS and non-float APCS code. */
1740 if ((in_flags & EF_APCS_FLOAT) != (out_flags & EF_APCS_FLOAT))
1741 return false;
1742
1743 /* If the src and dest have different interworking flags
1744 then turn off the interworking bit. */
1745 if ((in_flags & EF_INTERWORK) != (out_flags & EF_INTERWORK))
1746 {
1747 if (out_flags & EF_INTERWORK)
1748 _bfd_error_handler (_ ("\
1749Warning: Clearing the interwork flag in %s because non-interworking code in %s has been linked with it"),
1750 bfd_get_filename (obfd), bfd_get_filename (ibfd));
1751
1752 in_flags &= ~EF_INTERWORK;
1753 }
1754 }
1755
1756 elf_elfheader (obfd)->e_flags = in_flags;
1757 elf_flags_init (obfd) = true;
1758
1759 return true;
1760}
1761
1762/* Merge backend specific data from an object file to the output
1763 object file when linking. */
1764static boolean
1765elf32_arm_merge_private_bfd_data (ibfd, obfd)
1766 bfd *ibfd;
1767 bfd *obfd;
1768{
1769 flagword out_flags;
1770 flagword in_flags;
1771
1772 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1773 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1774 return true;
1775
1776 /* Check if we have the same endianess */
1777 if ( ibfd->xvec->byteorder != obfd->xvec->byteorder
1778 && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN
1779 && ibfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
1780 {
1781 (*_bfd_error_handler)
1782 (_("%s: compiled for a %s endian system and target is %s endian"),
1783 bfd_get_filename (ibfd),
1784 bfd_big_endian (ibfd) ? "big" : "little",
1785 bfd_big_endian (obfd) ? "big" : "little");
1786
1787 bfd_set_error (bfd_error_wrong_format);
1788 return false;
1789 }
1790
1791 /* The input BFD must have had its flags initialised. */
1792 /* The following seems bogus to me -- The flags are initialized in
1793 the assembler but I don't think an elf_flags_init field is
1794 written into the object */
1795 /* BFD_ASSERT (elf_flags_init (ibfd)); */
1796
1797 in_flags = elf_elfheader (ibfd)->e_flags;
1798 out_flags = elf_elfheader (obfd)->e_flags;
1799
1800 if (!elf_flags_init (obfd))
1801 {
1802 /* If the input is the default architecture then do not
1803 bother setting the flags for the output architecture,
1804 instead allow future merges to do this. If no future
1805 merges ever set these flags then they will retain their
1806 unitialised values, which surprise surprise, correspond
1807 to the default values. */
1808 if (bfd_get_arch_info (ibfd)->the_default)
1809 return true;
1810
1811 elf_flags_init (obfd) = true;
1812 elf_elfheader (obfd)->e_flags = in_flags;
1813
1814 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
1815 && bfd_get_arch_info (obfd)->the_default)
1816 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
1817
1818 return true;
1819 }
1820
1821 /* Check flag compatibility. */
1822 if (in_flags == out_flags)
1823 return true;
1824
1825 /* Complain about various flag mismatches. */
1826
1827 if ((in_flags & EF_APCS_26) != (out_flags & EF_APCS_26))
1828 _bfd_error_handler (_ ("\
1829Error: %s compiled for APCS-%d, whereas %s is compiled for APCS-%d"),
1830 bfd_get_filename (ibfd),
1831 in_flags & EF_APCS_26 ? 26 : 32,
1832 bfd_get_filename (obfd),
1833 out_flags & EF_APCS_26 ? 26 : 32);
1834
1835 if ((in_flags & EF_APCS_FLOAT) != (out_flags & EF_APCS_FLOAT))
1836 _bfd_error_handler (_ ("\
1837Error: %s passes floats in %s registers, whereas %s passes them in %s registers"),
1838 bfd_get_filename (ibfd),
1839 in_flags & EF_APCS_FLOAT ? _ ("float") : _ ("integer"),
1840 bfd_get_filename (obfd),
1841 out_flags & EF_APCS_26 ? _ ("float") : _ ("integer"));
1842
1843 if ((in_flags & EF_PIC) != (out_flags & EF_PIC))
1844 _bfd_error_handler (_ ("\
1845Error: %s is compiled as position %s code, whereas %s is not"),
1846 bfd_get_filename (ibfd),
1847 in_flags & EF_PIC ? _ ("independent") : _ ("dependent"),
1848 bfd_get_filename (obfd));
1849
1850 /* Interworking mismatch is only a warning. */
1851 if ((in_flags & EF_INTERWORK) != (out_flags & EF_INTERWORK))
1852 {
1853 _bfd_error_handler (_ ("\
1854Warning: %s %s interworking, whereas %s %s"),
1855 bfd_get_filename (ibfd),
1856 in_flags & EF_INTERWORK ? _ ("supports") : _ ("does not support"),
1857 bfd_get_filename (obfd),
1858 out_flags & EF_INTERWORK ? _ ("does not") : _ ("does"));
1859 return true;
1860 }
1861
1862 return false;
1863}
1864
1865/* Display the flags field */
1866static boolean
1867elf32_arm_print_private_bfd_data (abfd, ptr)
1868 bfd *abfd;
1869 PTR ptr;
1870{
1871 FILE *file = (FILE *) ptr;
1872
1873 BFD_ASSERT (abfd != NULL && ptr != NULL);
1874
1875 /* Print normal ELF private data. */
1876 _bfd_elf_print_private_bfd_data (abfd, ptr);
1877
1878 /* Ignore init flag - it may not be set, despite the flags field containing valid data. */
1879
1880 /* xgettext:c-format */
1881 fprintf (file, _ ("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
1882
1883 if (elf_elfheader (abfd)->e_flags & EF_INTERWORK)
1884 fprintf (file, _ (" [interworking enabled]"));
1885 else
1886 fprintf (file, _ (" [interworking not enabled]"));
1887
1888 if (elf_elfheader (abfd)->e_flags & EF_APCS_26)
1889 fprintf (file, _ (" [APCS-26]"));
1890 else
1891 fprintf (file, _ (" [APCS-32]"));
1892
1893 if (elf_elfheader (abfd)->e_flags & EF_APCS_FLOAT)
1894 fprintf (file, _ (" [floats passed in float registers]"));
1895 else
1896 fprintf (file, _ (" [floats passed in integer registers]"));
1897
1898 if (elf_elfheader (abfd)->e_flags & EF_PIC)
1899 fprintf (file, _ (" [position independent]"));
1900 else
1901 fprintf (file, _ (" [absolute position]"));
1902
1903 fputc ('\n', file);
1904
1905 return true;
1906}
1907
1908static int
1909elf32_arm_get_symbol_type (elf_sym, type)
1910 Elf_Internal_Sym * elf_sym;
1911 int type;
1912{
1913 if (ELF_ST_TYPE (elf_sym->st_info) == STT_ARM_TFUNC)
1914 return ELF_ST_TYPE (elf_sym->st_info);
1915 else
1916 return type;
1917}
1918
1919static asection *
1920elf32_arm_gc_mark_hook (abfd, info, rel, h, sym)
1921 bfd *abfd;
1922 struct bfd_link_info *info;
1923 Elf_Internal_Rela *rel;
1924 struct elf_link_hash_entry *h;
1925 Elf_Internal_Sym *sym;
1926{
1927 if (h != NULL)
1928 {
1929 switch (ELF32_R_TYPE (rel->r_info))
1930 {
1931 case R_ARM_GNU_VTINHERIT:
1932 case R_ARM_GNU_VTENTRY:
1933 break;
1934
1935 default:
1936 switch (h->root.type)
1937 {
1938 case bfd_link_hash_defined:
1939 case bfd_link_hash_defweak:
1940 return h->root.u.def.section;
1941
1942 case bfd_link_hash_common:
1943 return h->root.u.c.p->section;
1944 }
1945 }
1946 }
1947 else
1948 {
1949 if (!(elf_bad_symtab (abfd)
1950 && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
1951 && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
1952 && sym->st_shndx != SHN_COMMON))
1953 {
1954 return bfd_section_from_elf_index (abfd, sym->st_shndx);
1955 }
1956 }
1957 return NULL;
1958}
1959
1960static boolean
1961elf32_arm_gc_sweep_hook (abfd, info, sec, relocs)
1962 bfd *abfd;
1963 struct bfd_link_info *info;
1964 asection *sec;
1965 const Elf_Internal_Rela *relocs;
1966{
1967 /* we don't use got and plt entries for armelf */
1968 return true;
1969}
1970
1971/* Look through the relocs for a section during the first phase.
1972 Since we don't do .gots or .plts, we just need to consider the
1973 virtual table relocs for gc. */
1974
1975static boolean
1976elf32_arm_check_relocs (abfd, info, sec, relocs)
1977 bfd * abfd;
1978 struct bfd_link_info * info;
1979 asection * sec;
1980 const Elf_Internal_Rela * relocs;
1981{
1982 Elf_Internal_Shdr * symtab_hdr;
1983 struct elf_link_hash_entry ** sym_hashes;
1984 struct elf_link_hash_entry ** sym_hashes_end;
1985 const Elf_Internal_Rela * rel;
1986 const Elf_Internal_Rela * rel_end;
1987 bfd * dynobj;
1988 asection * sgot, *srelgot, *sreloc;
1989 bfd_vma * local_got_offsets;
1990
1991 if (info->relocateable)
1992 return true;
1993
1994 sgot = srelgot = sreloc = NULL;
1995
1996 dynobj = elf_hash_table (info)->dynobj;
1997 local_got_offsets = elf_local_got_offsets (abfd);
1998
1999 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2000 sym_hashes = elf_sym_hashes (abfd);
2001 sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof(Elf32_External_Sym);
2002 if (!elf_bad_symtab (abfd))
2003 sym_hashes_end -= symtab_hdr->sh_info;
2004
2005 rel_end = relocs + sec->reloc_count;
2006 for (rel = relocs; rel < rel_end; rel++)
2007 {
2008 struct elf_link_hash_entry *h;
2009 unsigned long r_symndx;
2010
2011 r_symndx = ELF32_R_SYM (rel->r_info);
2012 if (r_symndx < symtab_hdr->sh_info)
2013 h = NULL;
2014 else
2015 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2016
2017 /* Some relocs require a global offset table. */
2018 if (dynobj == NULL)
2019 {
2020 switch (ELF32_R_TYPE (rel->r_info))
2021 {
2022 case R_ARM_GOT32:
2023 case R_ARM_GOTOFF:
2024 case R_ARM_GOTPC:
2025 elf_hash_table (info)->dynobj = dynobj = abfd;
2026 if (! _bfd_elf_create_got_section (dynobj, info))
2027 return false;
2028 break;
2029
2030 default:
2031 break;
2032 }
2033 }
2034
2035 switch (ELF32_R_TYPE (rel->r_info))
2036 {
2037 case R_ARM_GOT32:
2038 /* This symbol requires a global offset table entry. */
2039 if (sgot == NULL)
2040 {
2041 sgot = bfd_get_section_by_name (dynobj, ".got");
2042 BFD_ASSERT (sgot != NULL);
2043 }
2044
2045 /* Get the got relocation section if necessary. */
2046 if (srelgot == NULL
2047 && (h != NULL || info->shared))
2048 {
2049 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
2050
2051 /* If no got relocation section, make one and initialize. */
2052 if (srelgot == NULL)
2053 {
2054 srelgot = bfd_make_section (dynobj, ".rel.got");
2055 if (srelgot == NULL
2056 || ! bfd_set_section_flags (dynobj, srelgot,
2057 (SEC_ALLOC
2058 | SEC_LOAD
2059 | SEC_HAS_CONTENTS
2060 | SEC_IN_MEMORY
2061 | SEC_LINKER_CREATED
2062 | SEC_READONLY))
2063 || ! bfd_set_section_alignment (dynobj, srelgot, 2))
2064 return false;
2065 }
2066 }
2067
2068 if (h != NULL)
2069 {
2070 if (h->got.offset != (bfd_vma) -1)
2071 /* We have already allocated space in the .got. */
2072 break;
2073
2074 h->got.offset = sgot->_raw_size;
2075
2076 /* Make sure this symbol is output as a dynamic symbol. */
2077 if (h->dynindx == -1)
2078 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2079 return false;
2080
2081 srelgot->_raw_size += sizeof (Elf32_External_Rel);
2082 }
2083 else
2084 {
2085 /* This is a global offset table entry for a local
2086 symbol. */
2087 if (local_got_offsets == NULL)
2088 {
2089 size_t size;
2090 register unsigned int i;
2091
2092 size = symtab_hdr->sh_info * sizeof (bfd_vma);
2093 local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
2094 if (local_got_offsets == NULL)
2095 return false;
2096 elf_local_got_offsets (abfd) = local_got_offsets;
2097 for (i = 0; i < symtab_hdr->sh_info; i++)
2098 local_got_offsets[i] = (bfd_vma) -1;
2099 }
2100
2101 if (local_got_offsets[r_symndx] != (bfd_vma) -1)
2102 /* We have already allocated space in the .got. */
2103 break;
2104
2105 local_got_offsets[r_symndx] = sgot->_raw_size;
2106
2107 if (info->shared)
2108 /* If we are generating a shared object, we need to
2109 output a R_ARM_RELATIVE reloc so that the dynamic
2110 linker can adjust this GOT entry. */
2111 srelgot->_raw_size += sizeof (Elf32_External_Rel);
2112 }
2113
2114 sgot->_raw_size += 4;
2115 break;
2116
2117 case R_ARM_PLT32:
2118 /* This symbol requires a procedure linkage table entry. We
2119 actually build the entry in adjust_dynamic_symbol,
2120 because this might be a case of linking PIC code which is
2121 never referenced by a dynamic object, in which case we
2122 don't need to generate a procedure linkage table entry
2123 after all. */
2124
2125 /* If this is a local symbol, we resolve it directly without
2126 creating a procedure linkage table entry. */
2127 if (h == NULL)
2128 continue;
2129
2130 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2131 break;
2132
2133 case R_ARM_ABS32:
2134 case R_ARM_REL32:
2135 case R_ARM_PC24:
2136 /* If we are creating a shared library, and this is a reloc
2137 against a global symbol, or a non PC relative reloc
2138 against a local symbol, then we need to copy the reloc
2139 into the shared library. However, if we are linking with
2140 -Bsymbolic, we do not need to copy a reloc against a
2141 global symbol which is defined in an object we are
2142 including in the link (i.e., DEF_REGULAR is set). At
2143 this point we have not seen all the input files, so it is
2144 possible that DEF_REGULAR is not set now but will be set
2145 later (it is never cleared). We account for that
2146 possibility below by storing information in the
2147 pcrel_relocs_copied field of the hash table entry. */
2148 if (info->shared
2149 && (ELF32_R_TYPE (rel->r_info) != R_ARM_PC24
2150 || (h != NULL
2151 && (! info->symbolic
2152 || (h->elf_link_hash_flags
2153 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
2154 {
2155 /* When creating a shared object, we must copy these
2156 reloc types into the output file. We create a reloc
2157 section in dynobj and make room for this reloc. */
2158 if (sreloc == NULL)
2159 {
2160 const char * name;
2161
2162 name = (bfd_elf_string_from_elf_section
2163 (abfd,
2164 elf_elfheader (abfd)->e_shstrndx,
2165 elf_section_data (sec)->rel_hdr.sh_name));
2166 if (name == NULL)
2167 return false;
2168
2169 BFD_ASSERT (strncmp (name, ".rel", 4) == 0
2170 && strcmp (bfd_get_section_name (abfd, sec),
2171 name + 4) == 0);
2172
2173 sreloc = bfd_get_section_by_name (dynobj, name);
2174 if (sreloc == NULL)
2175 {
2176 flagword flags;
2177
2178 sreloc = bfd_make_section (dynobj, name);
2179 flags = (SEC_HAS_CONTENTS | SEC_READONLY
2180 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
2181 if ((sec->flags & SEC_ALLOC) != 0)
2182 flags |= SEC_ALLOC | SEC_LOAD;
2183 if (sreloc == NULL
2184 || ! bfd_set_section_flags (dynobj, sreloc, flags)
2185 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
2186 return false;
2187 }
2188 }
2189
2190 sreloc->_raw_size += sizeof (Elf32_External_Rel);
2191 /* If we are linking with -Bsymbolic, and this is a
2192 global symbol, we count the number of PC relative
2193 relocations we have entered for this symbol, so that
2194 we can discard them again if the symbol is later
2195 defined by a regular object. Note that this function
2196 is only called if we are using an elf_i386 linker
2197 hash table, which means that h is really a pointer to
2198 an elf_i386_link_hash_entry. */
2199 if (h != NULL && info->symbolic
2200 && ELF32_R_TYPE (rel->r_info) == R_ARM_PC24)
2201 {
2202 struct elf32_arm_link_hash_entry * eh;
2203 struct elf32_arm_pcrel_relocs_copied * p;
2204
2205 eh = (struct elf32_arm_link_hash_entry *) h;
2206
2207 for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
2208 if (p->section == sreloc)
2209 break;
2210
2211 if (p == NULL)
2212 {
2213 p = ((struct elf32_arm_pcrel_relocs_copied *)
2214 bfd_alloc (dynobj, sizeof * p));
2215
2216 if (p == NULL)
2217 return false;
2218 p->next = eh->pcrel_relocs_copied;
2219 eh->pcrel_relocs_copied = p;
2220 p->section = sreloc;
2221 p->count = 0;
2222 }
2223
2224 ++p->count;
2225 }
2226 }
2227 break;
2228
2229 /* This relocation describes the C++ object vtable hierarchy.
2230 Reconstruct it for later use during GC. */
2231 case R_ARM_GNU_VTINHERIT:
2232 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2233 return false;
2234 break;
2235
2236 /* This relocation describes which C++ vtable entries are actually
2237 used. Record for later use during GC. */
2238 case R_ARM_GNU_VTENTRY:
2239 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2240 return false;
2241 break;
2242 }
2243 }
2244
2245 return true;
2246}
2247
2248
2249/* Find the nearest line to a particular section and offset, for error
2250 reporting. This code is a duplicate of the code in elf.c, except
2251 that it also accepts STT_ARM_TFUNC as a symbol that names a function. */
2252
2253static boolean
2254elf32_arm_find_nearest_line
2255 (abfd, section, symbols, offset, filename_ptr, functionname_ptr, line_ptr)
2256 bfd * abfd;
2257 asection * section;
2258 asymbol ** symbols;
2259 bfd_vma offset;
2260 CONST char ** filename_ptr;
2261 CONST char ** functionname_ptr;
2262 unsigned int * line_ptr;
2263{
2264 boolean found;
2265 const char * filename;
2266 asymbol * func;
2267 bfd_vma low_func;
2268 asymbol ** p;
2269
2270 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
2271 filename_ptr, functionname_ptr,
2272 line_ptr))
2273 return true;
2274
2275 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
2276 &found, filename_ptr,
2277 functionname_ptr, line_ptr,
2278 &elf_tdata (abfd)->line_info))
2279 return false;
2280
2281 if (found)
2282 return true;
2283
2284 if (symbols == NULL)
2285 return false;
2286
2287 filename = NULL;
2288 func = NULL;
2289 low_func = 0;
2290
2291 for (p = symbols; *p != NULL; p++)
2292 {
2293 elf_symbol_type *q;
2294
2295 q = (elf_symbol_type *) *p;
2296
2297 if (bfd_get_section (&q->symbol) != section)
2298 continue;
2299
2300 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
2301 {
2302 default:
2303 break;
2304 case STT_FILE:
2305 filename = bfd_asymbol_name (&q->symbol);
2306 break;
2307 case STT_NOTYPE:
2308 case STT_FUNC:
2309 case STT_ARM_TFUNC:
2310 if (q->symbol.section == section
2311 && q->symbol.value >= low_func
2312 && q->symbol.value <= offset)
2313 {
2314 func = (asymbol *) q;
2315 low_func = q->symbol.value;
2316 }
2317 break;
2318 }
2319 }
2320
2321 if (func == NULL)
2322 return false;
2323
2324 *filename_ptr = filename;
2325 *functionname_ptr = bfd_asymbol_name (func);
2326 *line_ptr = 0;
2327
2328 return true;
2329}
2330
2331/* Adjust a symbol defined by a dynamic object and referenced by a
2332 regular object. The current definition is in some section of the
2333 dynamic object, but we're not including those sections. We have to
2334 change the definition to something the rest of the link can
2335 understand. */
2336
2337static boolean
2338elf32_arm_adjust_dynamic_symbol (info, h)
2339 struct bfd_link_info * info;
2340 struct elf_link_hash_entry * h;
2341{
2342 bfd * dynobj;
2343 asection * s;
2344 unsigned int power_of_two;
2345
2346 dynobj = elf_hash_table (info)->dynobj;
2347
2348 /* Make sure we know what is going on here. */
2349 BFD_ASSERT (dynobj != NULL
2350 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
2351 || h->weakdef != NULL
2352 || ((h->elf_link_hash_flags
2353 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2354 && (h->elf_link_hash_flags
2355 & ELF_LINK_HASH_REF_REGULAR) != 0
2356 && (h->elf_link_hash_flags
2357 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
2358
2359 /* If this is a function, put it in the procedure linkage table. We
2360 will fill in the contents of the procedure linkage table later,
2361 when we know the address of the .got section. */
2362 if (h->type == STT_FUNC
2363 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2364 {
2365 if (! info->shared
2366 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
2367 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0)
2368 {
2369 /* This case can occur if we saw a PLT32 reloc in an input
2370 file, but the symbol was never referred to by a dynamic
2371 object. In such a case, we don't actually need to build
2372 a procedure linkage table, and we can just do a PC32
2373 reloc instead. */
2374 BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
2375 return true;
2376 }
2377
2378 /* Make sure this symbol is output as a dynamic symbol. */
2379 if (h->dynindx == -1)
2380 {
2381 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2382 return false;
2383 }
2384
2385 s = bfd_get_section_by_name (dynobj, ".plt");
2386 BFD_ASSERT (s != NULL);
2387
2388 /* If this is the first .plt entry, make room for the special
2389 first entry. */
2390 if (s->_raw_size == 0)
2391 s->_raw_size += PLT_ENTRY_SIZE;
2392
2393 /* If this symbol is not defined in a regular file, and we are
2394 not generating a shared library, then set the symbol to this
2395 location in the .plt. This is required to make function
2396 pointers compare as equal between the normal executable and
2397 the shared library. */
2398 if (! info->shared
2399 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2400 {
2401 h->root.u.def.section = s;
2402 h->root.u.def.value = s->_raw_size;
2403 }
2404
2405 h->plt.offset = s->_raw_size;
2406
2407 /* Make room for this entry. */
2408 s->_raw_size += PLT_ENTRY_SIZE;
2409
2410 /* We also need to make an entry in the .got.plt section, which
2411 will be placed in the .got section by the linker script. */
2412
2413 s = bfd_get_section_by_name (dynobj, ".got.plt");
2414 BFD_ASSERT (s != NULL);
2415 s->_raw_size += 4;
2416
2417 /* We also need to make an entry in the .rel.plt section. */
2418
2419 s = bfd_get_section_by_name (dynobj, ".rel.plt");
2420 BFD_ASSERT (s != NULL);
2421 s->_raw_size += sizeof (Elf32_External_Rel);
2422
2423 return true;
2424 }
2425
2426 /* If this is a weak symbol, and there is a real definition, the
2427 processor independent code will have arranged for us to see the
2428 real definition first, and we can just use the same value. */
2429 if (h->weakdef != NULL)
2430 {
2431 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2432 || h->weakdef->root.type == bfd_link_hash_defweak);
2433 h->root.u.def.section = h->weakdef->root.u.def.section;
2434 h->root.u.def.value = h->weakdef->root.u.def.value;
2435 return true;
2436 }
2437
2438 /* This is a reference to a symbol defined by a dynamic object which
2439 is not a function. */
2440
2441 /* If we are creating a shared library, we must presume that the
2442 only references to the symbol are via the global offset table.
2443 For such cases we need not do anything here; the relocations will
2444 be handled correctly by relocate_section. */
2445 if (info->shared)
2446 return true;
2447
2448 /* We must allocate the symbol in our .dynbss section, which will
2449 become part of the .bss section of the executable. There will be
2450 an entry for this symbol in the .dynsym section. The dynamic
2451 object will contain position independent code, so all references
2452 from the dynamic object to this symbol will go through the global
2453 offset table. The dynamic linker will use the .dynsym entry to
2454 determine the address it must put in the global offset table, so
2455 both the dynamic object and the regular object will refer to the
2456 same memory location for the variable. */
2457
2458 s = bfd_get_section_by_name (dynobj, ".dynbss");
2459 BFD_ASSERT (s != NULL);
2460
2461 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
2462 copy the initial value out of the dynamic object and into the
2463 runtime process image. We need to remember the offset into the
2464 .rel.bss section we are going to use. */
2465 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
2466 {
2467 asection *srel;
2468
2469 srel = bfd_get_section_by_name (dynobj, ".rel.bss");
2470 BFD_ASSERT (srel != NULL);
2471 srel->_raw_size += sizeof (Elf32_External_Rel);
2472 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
2473 }
2474
2475 /* We need to figure out the alignment required for this symbol. I
2476 have no idea how ELF linkers handle this. */
2477 power_of_two = bfd_log2 (h->size);
2478 if (power_of_two > 3)
2479 power_of_two = 3;
2480
2481 /* Apply the required alignment. */
2482 s->_raw_size = BFD_ALIGN (s->_raw_size,
2483 (bfd_size_type) (1 << power_of_two));
2484 if (power_of_two > bfd_get_section_alignment (dynobj, s))
2485 {
2486 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
2487 return false;
2488 }
2489
2490 /* Define the symbol as being at this point in the section. */
2491 h->root.u.def.section = s;
2492 h->root.u.def.value = s->_raw_size;
2493
2494 /* Increment the section size to make room for the symbol. */
2495 s->_raw_size += h->size;
2496
2497 return true;
2498}
2499
2500/* Set the sizes of the dynamic sections. */
2501
2502static boolean
2503elf32_arm_size_dynamic_sections (output_bfd, info)
2504 bfd * output_bfd;
2505 struct bfd_link_info * info;
2506{
2507 bfd * dynobj;
2508 asection * s;
2509 boolean plt;
2510 boolean relocs;
2511 boolean reltext;
2512
2513 dynobj = elf_hash_table (info)->dynobj;
2514 BFD_ASSERT (dynobj != NULL);
2515
2516 if (elf_hash_table (info)->dynamic_sections_created)
2517 {
2518 /* Set the contents of the .interp section to the interpreter. */
2519 if (! info->shared)
2520 {
2521 s = bfd_get_section_by_name (dynobj, ".interp");
2522 BFD_ASSERT (s != NULL);
2523 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
2524 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2525 }
2526 }
2527 else
2528 {
2529 /* We may have created entries in the .rel.got section.
2530 However, if we are not creating the dynamic sections, we will
2531 not actually use these entries. Reset the size of .rel.got,
2532 which will cause it to get stripped from the output file
2533 below. */
2534 s = bfd_get_section_by_name (dynobj, ".rel.got");
2535 if (s != NULL)
2536 s->_raw_size = 0;
2537 }
2538
2539 /* If this is a -Bsymbolic shared link, then we need to discard all
2540 PC relative relocs against symbols defined in a regular object.
2541 We allocated space for them in the check_relocs routine, but we
2542 will not fill them in in the relocate_section routine. */
2543 if (info->shared && info->symbolic)
2544 elf32_arm_link_hash_traverse (elf32_arm_hash_table (info),
2545 elf32_arm_discard_copies,
2546 (PTR) NULL);
2547
2548 /* The check_relocs and adjust_dynamic_symbol entry points have
2549 determined the sizes of the various dynamic sections. Allocate
2550 memory for them. */
2551 plt = false;
2552 relocs = false;
2553 reltext = false;
2554 for (s = dynobj->sections; s != NULL; s = s->next)
2555 {
2556 const char * name;
2557 boolean strip;
2558
2559 if ((s->flags & SEC_LINKER_CREATED) == 0)
2560 continue;
2561
2562 /* It's OK to base decisions on the section name, because none
2563 of the dynobj section names depend upon the input files. */
2564 name = bfd_get_section_name (dynobj, s);
2565
2566 strip = false;
2567
2568 if (strcmp (name, ".plt") == 0)
2569 {
2570 if (s->_raw_size == 0)
2571 {
2572 /* Strip this section if we don't need it; see the
2573 comment below. */
2574 strip = true;
2575 }
2576 else
2577 {
2578 /* Remember whether there is a PLT. */
2579 plt = true;
2580 }
2581 }
2582 else if (strncmp (name, ".rel", 4) == 0)
2583 {
2584 if (s->_raw_size == 0)
2585 {
2586 /* If we don't need this section, strip it from the
2587 output file. This is mostly to handle .rel.bss and
2588 .rel.plt. We must create both sections in
2589 create_dynamic_sections, because they must be created
2590 before the linker maps input sections to output
2591 sections. The linker does that before
2592 adjust_dynamic_symbol is called, and it is that
2593 function which decides whether anything needs to go
2594 into these sections. */
2595 strip = true;
2596 }
2597 else
2598 {
2599 asection * target;
2600
2601 /* Remember whether there are any reloc sections other
2602 than .rel.plt. */
2603 if (strcmp (name, ".rel.plt") != 0)
2604 {
2605 const char *outname;
2606
2607 relocs = true;
2608
2609 /* If this relocation section applies to a read only
2610 section, then we probably need a DT_TEXTREL
2611 entry. The entries in the .rel.plt section
2612 really apply to the .got section, which we
2613 created ourselves and so know is not readonly. */
2614 outname = bfd_get_section_name (output_bfd,
2615 s->output_section);
2616 target = bfd_get_section_by_name (output_bfd, outname + 4);
2617 if (target != NULL
2618 && (target->flags & SEC_READONLY) != 0
2619 && (target->flags & SEC_ALLOC) != 0)
2620 reltext = true;
2621 }
2622
2623 /* We use the reloc_count field as a counter if we need
2624 to copy relocs into the output file. */
2625 s->reloc_count = 0;
2626 }
2627 }
2628 else if (strncmp (name, ".got", 4) != 0)
2629 {
2630 /* It's not one of our sections, so don't allocate space. */
2631 continue;
2632 }
2633
2634 if (strip)
2635 {
2636 asection ** spp;
2637
2638 for (spp = &s->output_section->owner->sections;
2639 *spp != s->output_section;
2640 spp = &(*spp)->next)
2641 ;
2642 *spp = s->output_section->next;
2643 --s->output_section->owner->section_count;
2644
2645 continue;
2646 }
2647
2648 /* Allocate memory for the section contents. */
2649 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
2650 if (s->contents == NULL && s->_raw_size != 0)
2651 return false;
2652 }
2653
2654 if (elf_hash_table (info)->dynamic_sections_created)
2655 {
2656 /* Add some entries to the .dynamic section. We fill in the
2657 values later, in elf32_arm_finish_dynamic_sections, but we
2658 must add the entries now so that we get the correct size for
2659 the .dynamic section. The DT_DEBUG entry is filled in by the
2660 dynamic linker and used by the debugger. */
2661 if (! info->shared)
2662 {
2663 if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0))
2664 return false;
2665 }
2666
2667 if (plt)
2668 {
2669 if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0)
2670 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
2671 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_REL)
2672 || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
2673 return false;
2674 }
2675
2676 if (relocs)
2677 {
2678 if (! bfd_elf32_add_dynamic_entry (info, DT_REL, 0)
2679 || ! bfd_elf32_add_dynamic_entry (info, DT_RELSZ, 0)
2680 || ! bfd_elf32_add_dynamic_entry (info, DT_RELENT,
2681 sizeof (Elf32_External_Rel)))
2682 return false;
2683 }
2684
2685 if (reltext)
2686 {
2687 if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0))
2688 return false;
2689 }
2690 }
2691
2692 return true;
2693}
2694
2695/* This function is called via elf32_arm_link_hash_traverse if we are
2696 creating a shared object with -Bsymbolic. It discards the space
2697 allocated to copy PC relative relocs against symbols which are
2698 defined in regular objects. We allocated space for them in the
2699 check_relocs routine, but we won't fill them in in the
2700 relocate_section routine. */
2701
2702static boolean
2703elf32_arm_discard_copies (h, ignore)
2704 struct elf32_arm_link_hash_entry * h;
2705 PTR ignore;
2706{
2707 struct elf32_arm_pcrel_relocs_copied * s;
2708
2709 /* We only discard relocs for symbols defined in a regular object. */
2710 if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2711 return true;
2712
2713 for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
2714 s->section->_raw_size -= s->count * sizeof (Elf32_External_Rel);
2715
2716 return true;
2717}
2718
2719/* Finish up dynamic symbol handling. We set the contents of various
2720 dynamic sections here. */
2721
2722static boolean
2723elf32_arm_finish_dynamic_symbol (output_bfd, info, h, sym)
2724 bfd * output_bfd;
2725 struct bfd_link_info * info;
2726 struct elf_link_hash_entry * h;
2727 Elf_Internal_Sym * sym;
2728{
2729 bfd * dynobj;
2730
2731 dynobj = elf_hash_table (info)->dynobj;
2732
2733 if (h->plt.offset != (bfd_vma) -1)
2734 {
2735 asection * splt;
2736 asection * sgot;
2737 asection * srel;
2738 bfd_vma plt_index;
2739 bfd_vma got_offset;
2740 Elf_Internal_Rel rel;
2741
2742 /* This symbol has an entry in the procedure linkage table. Set
2743 it up. */
2744
2745 BFD_ASSERT (h->dynindx != -1);
2746
2747 splt = bfd_get_section_by_name (dynobj, ".plt");
2748 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
2749 srel = bfd_get_section_by_name (dynobj, ".rel.plt");
2750 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
2751
2752 /* Get the index in the procedure linkage table which
2753 corresponds to this symbol. This is the index of this symbol
2754 in all the symbols for which we are making plt entries. The
2755 first entry in the procedure linkage table is reserved. */
2756 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
2757
2758 /* Get the offset into the .got table of the entry that
2759 corresponds to this function. Each .got entry is 4 bytes.
2760 The first three are reserved. */
2761 got_offset = (plt_index + 3) * 4;
2762
2763 /* Fill in the entry in the procedure linkage table. */
2764 memcpy (splt->contents + h->plt.offset,
2765 elf32_arm_plt_entry,
2766 PLT_ENTRY_SIZE);
2767 bfd_put_32 (output_bfd,
2768 (sgot->output_section->vma
2769 + sgot->output_offset
2770 + got_offset
2771 - splt->output_section->vma
2772 - splt->output_offset
2773 - h->plt.offset - 12),
2774 splt->contents + h->plt.offset + 12);
2775
2776 /* Fill in the entry in the global offset table. */
2777 bfd_put_32 (output_bfd,
2778 (splt->output_section->vma
2779 + splt->output_offset),
2780 sgot->contents + got_offset);
2781
2782 /* Fill in the entry in the .rel.plt section. */
2783 rel.r_offset = (sgot->output_section->vma
2784 + sgot->output_offset
2785 + got_offset);
2786 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_JUMP_SLOT);
2787 bfd_elf32_swap_reloc_out (output_bfd, &rel,
2788 ((Elf32_External_Rel *) srel->contents
2789 + plt_index));
2790
2791 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2792 {
2793 /* Mark the symbol as undefined, rather than as defined in
2794 the .plt section. Leave the value alone. */
2795 sym->st_shndx = SHN_UNDEF;
2796 }
2797 }
2798
2799 if (h->got.offset != (bfd_vma) -1)
2800 {
2801 asection * sgot;
2802 asection * srel;
2803 Elf_Internal_Rel rel;
2804
2805 /* This symbol has an entry in the global offset table. Set it
2806 up. */
2807
2808 sgot = bfd_get_section_by_name (dynobj, ".got");
2809 srel = bfd_get_section_by_name (dynobj, ".rel.got");
2810 BFD_ASSERT (sgot != NULL && srel != NULL);
2811
2812 rel.r_offset = (sgot->output_section->vma
2813 + sgot->output_offset
2814 + (h->got.offset &~ 1));
2815
2816 /* If this is a -Bsymbolic link, and the symbol is defined
2817 locally, we just want to emit a RELATIVE reloc. The entry in
2818 the global offset table will already have been initialized in
2819 the relocate_section function. */
2820 if (info->shared
2821 && (info->symbolic || h->dynindx == -1)
2822 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
2823 rel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
2824 else
2825 {
2826 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
2827 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
2828 }
2829
2830 bfd_elf32_swap_reloc_out (output_bfd, &rel,
2831 ((Elf32_External_Rel *) srel->contents
2832 + srel->reloc_count));
2833 ++srel->reloc_count;
2834 }
2835
2836 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
2837 {
2838 asection * s;
2839 Elf_Internal_Rel rel;
2840
2841 /* This symbol needs a copy reloc. Set it up. */
2842
2843 BFD_ASSERT (h->dynindx != -1
2844 && (h->root.type == bfd_link_hash_defined
2845 || h->root.type == bfd_link_hash_defweak));
2846
2847 s = bfd_get_section_by_name (h->root.u.def.section->owner,
2848 ".rel.bss");
2849 BFD_ASSERT (s != NULL);
2850
2851 rel.r_offset = (h->root.u.def.value
2852 + h->root.u.def.section->output_section->vma
2853 + h->root.u.def.section->output_offset);
2854 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_COPY);
2855 bfd_elf32_swap_reloc_out (output_bfd, &rel,
2856 ((Elf32_External_Rel *) s->contents
2857 + s->reloc_count));
2858 ++s->reloc_count;
2859 }
2860
2861 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2862 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2863 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2864 sym->st_shndx = SHN_ABS;
2865
2866 return true;
2867}
2868
2869/* Finish up the dynamic sections. */
2870
2871static boolean
2872elf32_arm_finish_dynamic_sections (output_bfd, info)
2873 bfd * output_bfd;
2874 struct bfd_link_info * info;
2875{
2876 bfd * dynobj;
2877 asection * sgot;
2878 asection * sdyn;
2879
2880 dynobj = elf_hash_table (info)->dynobj;
2881
2882 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
2883 BFD_ASSERT (sgot != NULL);
2884 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2885
2886 if (elf_hash_table (info)->dynamic_sections_created)
2887 {
2888 asection *splt;
2889 Elf32_External_Dyn *dyncon, *dynconend;
2890
2891 splt = bfd_get_section_by_name (dynobj, ".plt");
2892 BFD_ASSERT (splt != NULL && sdyn != NULL);
2893
2894 dyncon = (Elf32_External_Dyn *) sdyn->contents;
2895 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
2896 for (; dyncon < dynconend; dyncon++)
2897 {
2898 Elf_Internal_Dyn dyn;
2899 const char * name;
2900 asection * s;
2901
2902 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
2903
2904 switch (dyn.d_tag)
2905 {
2906 default:
2907 break;
2908
2909 case DT_PLTGOT:
2910 name = ".got";
2911 goto get_vma;
2912 case DT_JMPREL:
2913 name = ".rel.plt";
2914 get_vma:
2915 s = bfd_get_section_by_name (output_bfd, name);
2916 BFD_ASSERT (s != NULL);
2917 dyn.d_un.d_ptr = s->vma;
2918 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2919 break;
2920
2921 case DT_PLTRELSZ:
2922 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
2923 BFD_ASSERT (s != NULL);
2924 if (s->_cooked_size != 0)
2925 dyn.d_un.d_val = s->_cooked_size;
2926 else
2927 dyn.d_un.d_val = s->_raw_size;
2928 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2929 break;
2930
2931 case DT_RELSZ:
2932 /* My reading of the SVR4 ABI indicates that the
2933 procedure linkage table relocs (DT_JMPREL) should be
2934 included in the overall relocs (DT_REL). This is
2935 what Solaris does. However, UnixWare can not handle
2936 that case. Therefore, we override the DT_RELSZ entry
2937 here to make it not include the JMPREL relocs. Since
2938 the linker script arranges for .rel.plt to follow all
2939 other relocation sections, we don't have to worry
2940 about changing the DT_REL entry. */
2941 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
2942 if (s != NULL)
2943 {
2944 if (s->_cooked_size != 0)
2945 dyn.d_un.d_val -= s->_cooked_size;
2946 else
2947 dyn.d_un.d_val -= s->_raw_size;
2948 }
2949 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2950 break;
2951 }
2952 }
2953
2954 /* Fill in the first entry in the procedure linkage table. */
2955 if (splt->_raw_size > 0)
2956 memcpy (splt->contents, elf32_arm_plt0_entry, PLT_ENTRY_SIZE);
2957
2958 /* UnixWare sets the entsize of .plt to 4, although that doesn't
2959 really seem like the right value. */
2960 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
2961 }
2962
2963 /* Fill in the first three entries in the global offset table. */
2964 if (sgot->_raw_size > 0)
2965 {
2966 if (sdyn == NULL)
2967 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
2968 else
2969 bfd_put_32 (output_bfd,
2970 sdyn->output_section->vma + sdyn->output_offset,
2971 sgot->contents);
2972 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
2973 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
2974 }
2975
2976 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
2977
2978 return true;
2979}
2980
2981#define ELF_ARCH bfd_arch_arm
2982#define ELF_MACHINE_CODE EM_ARM
2983#define ELF_MAXPAGE_SIZE 0x8000
2984
2985
2986#define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
2987#define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
2988#define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
2989#define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
2990#define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
2991#define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
2992#define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
2993
2994#define elf_backend_get_symbol_type elf32_arm_get_symbol_type
2995#define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
2996#define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
2997#define elf_backend_check_relocs elf32_arm_check_relocs
2998#define elf_backend_relocate_section elf32_arm_relocate_section
2999#define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
3000#define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
3001#define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
3002#define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
3003#define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
3004
3005#define elf_backend_can_gc_sections 1
3006#define elf_backend_plt_readonly 1
3007#define elf_backend_want_got_plt 1
3008#define elf_backend_want_plt_sym 0
3009
3010#include "elf32-target.h"
A mirror of the official binutils-gdb repository