1 /* 32-bit ELF support for ARM
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004
3 Free Software Foundation, Inc.
4
5 This file is part of BFD, the Binary File Descriptor library.
6
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 2 of the License, or
10 (at your option) any later version.
11
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.
16
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20
21 #ifndef USE_REL
22 #define USE_REL 0
23 #endif
24
25 typedef unsigned long int insn32;
26 typedef unsigned short int insn16;
27
28 static bfd_boolean elf32_arm_set_private_flags
29 PARAMS ((bfd *, flagword));
30 static bfd_boolean elf32_arm_copy_private_bfd_data
31 PARAMS ((bfd *, bfd *));
32 static bfd_boolean elf32_arm_merge_private_bfd_data
33 PARAMS ((bfd *, bfd *));
34 static bfd_boolean elf32_arm_print_private_bfd_data
35 PARAMS ((bfd *, PTR));
36 static int elf32_arm_get_symbol_type
37 PARAMS (( Elf_Internal_Sym *, int));
38 static struct bfd_link_hash_table *elf32_arm_link_hash_table_create
39 PARAMS ((bfd *));
40 static bfd_reloc_status_type elf32_arm_final_link_relocate
41 PARAMS ((reloc_howto_type *, bfd *, bfd *, asection *, bfd_byte *,
42 Elf_Internal_Rela *, bfd_vma, struct bfd_link_info *, asection *,
43 const char *, int, struct elf_link_hash_entry *));
44 static insn32 insert_thumb_branch
45 PARAMS ((insn32, int));
46 static struct elf_link_hash_entry *find_thumb_glue
47 PARAMS ((struct bfd_link_info *, const char *, bfd *));
48 static struct elf_link_hash_entry *find_arm_glue
49 PARAMS ((struct bfd_link_info *, const char *, bfd *));
50 static void elf32_arm_post_process_headers
51 PARAMS ((bfd *, struct bfd_link_info *));
52 static int elf32_arm_to_thumb_stub
53 PARAMS ((struct bfd_link_info *, const char *, bfd *, bfd *, asection *,
54 bfd_byte *, asection *, bfd_vma, bfd_signed_vma, bfd_vma));
55 static int elf32_thumb_to_arm_stub
56 PARAMS ((struct bfd_link_info *, const char *, bfd *, bfd *, asection *,
57 bfd_byte *, asection *, bfd_vma, bfd_signed_vma, bfd_vma));
58 static bfd_boolean elf32_arm_relocate_section
59 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
60 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
61 static asection * elf32_arm_gc_mark_hook
62 PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
63 struct elf_link_hash_entry *, Elf_Internal_Sym *));
64 static bfd_boolean elf32_arm_gc_sweep_hook
65 PARAMS ((bfd *, struct bfd_link_info *, asection *,
66 const Elf_Internal_Rela *));
67 static bfd_boolean elf32_arm_check_relocs
68 PARAMS ((bfd *, struct bfd_link_info *, asection *,
69 const Elf_Internal_Rela *));
70 static bfd_boolean elf32_arm_find_nearest_line
71 PARAMS ((bfd *, asection *, asymbol **, bfd_vma, const char **,
72 const char **, unsigned int *));
73 static bfd_boolean elf32_arm_adjust_dynamic_symbol
74 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
75 static bfd_boolean elf32_arm_size_dynamic_sections
76 PARAMS ((bfd *, struct bfd_link_info *));
77 static bfd_boolean elf32_arm_finish_dynamic_symbol
78 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
79 Elf_Internal_Sym *));
80 static bfd_boolean elf32_arm_finish_dynamic_sections
81 PARAMS ((bfd *, struct bfd_link_info *));
82 static struct bfd_hash_entry * elf32_arm_link_hash_newfunc
83 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
84 #if USE_REL
85 static void arm_add_to_rel
86 PARAMS ((bfd *, bfd_byte *, reloc_howto_type *, bfd_signed_vma));
87 #endif
88 static bfd_boolean allocate_dynrelocs
89 PARAMS ((struct elf_link_hash_entry *h, PTR inf));
90 static bfd_boolean create_got_section
91 PARAMS ((bfd * dynobj, struct bfd_link_info * info));
92 static bfd_boolean elf32_arm_create_dynamic_sections
93 PARAMS ((bfd * dynobj, struct bfd_link_info * info));
94 static enum elf_reloc_type_class elf32_arm_reloc_type_class
95 PARAMS ((const Elf_Internal_Rela *));
96 static bfd_boolean elf32_arm_object_p
97 PARAMS ((bfd *));
98
99 #ifndef ELFARM_NABI_C_INCLUDED
100 static void record_arm_to_thumb_glue
101 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
102 static void record_thumb_to_arm_glue
103 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
104 bfd_boolean bfd_elf32_arm_allocate_interworking_sections
105 PARAMS ((struct bfd_link_info *));
106 bfd_boolean bfd_elf32_arm_get_bfd_for_interworking
107 PARAMS ((bfd *, struct bfd_link_info *));
108 bfd_boolean bfd_elf32_arm_process_before_allocation
109 PARAMS ((bfd *, struct bfd_link_info *, int));
110 #endif
111
112
113 #define INTERWORK_FLAG(abfd) (elf_elfheader (abfd)->e_flags & EF_ARM_INTERWORK)
114
115 /* The linker script knows the section names for placement.
116 The entry_names are used to do simple name mangling on the stubs.
117 Given a function name, and its type, the stub can be found. The
118 name can be changed. The only requirement is the %s be present. */
119 #define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t"
120 #define THUMB2ARM_GLUE_ENTRY_NAME "__%s_from_thumb"
121
122 #define ARM2THUMB_GLUE_SECTION_NAME ".glue_7"
123 #define ARM2THUMB_GLUE_ENTRY_NAME "__%s_from_arm"
124
125 /* The name of the dynamic interpreter. This is put in the .interp
126 section. */
127 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
128
129 #ifdef FOUR_WORD_PLT
130
131 /* The size in bytes of the special first entry in the procedure
132 linkage table. */
133 #define PLT_HEADER_SIZE 16
134
135 /* The size in bytes of an entry in the procedure linkage table. */
136 #define PLT_ENTRY_SIZE 16
137
138 /* The first entry in a procedure linkage table looks like
139 this. It is set up so that any shared library function that is
140 called before the relocation has been set up calls the dynamic
141 linker first. */
142 static const bfd_vma elf32_arm_plt0_entry [PLT_HEADER_SIZE / 4] =
143 {
144 0xe52de004, /* str lr, [sp, #-4]! */
145 0xe59fe010, /* ldr lr, [pc, #16] */
146 0xe08fe00e, /* add lr, pc, lr */
147 0xe5bef008, /* ldr pc, [lr, #8]! */
148 };
149
150 /* Subsequent entries in a procedure linkage table look like
151 this. */
152 static const bfd_vma elf32_arm_plt_entry [PLT_ENTRY_SIZE / 4] =
153 {
154 0xe28fc600, /* add ip, pc, #NN */
155 0xe28cca00, /* add ip, ip, #NN */
156 0xe5bcf000, /* ldr pc, [ip, #NN]! */
157 0x00000000, /* unused */
158 };
159
160 #else
161
162 /* The size in bytes of the special first entry in the procedure
163 linkage table. */
164 #define PLT_HEADER_SIZE 20
165
166 /* The size in bytes of an entry in the procedure linkage table. */
167 #define PLT_ENTRY_SIZE 12
168
169 /* The first entry in a procedure linkage table looks like
170 this. It is set up so that any shared library function that is
171 called before the relocation has been set up calls the dynamic
172 linker first. */
173 static const bfd_vma elf32_arm_plt0_entry [PLT_HEADER_SIZE / 4] =
174 {
175 0xe52de004, /* str lr, [sp, #-4]! */
176 0xe59fe004, /* ldr lr, [pc, #4] */
177 0xe08fe00e, /* add lr, pc, lr */
178 0xe5bef008, /* ldr pc, [lr, #8]! */
179 0x00000000, /* &GOT[0] - . */
180 };
181
182 /* Subsequent entries in a procedure linkage table look like
183 this. */
184 static const bfd_vma elf32_arm_plt_entry [PLT_ENTRY_SIZE / 4] =
185 {
186 0xe28fc600, /* add ip, pc, #0xNN00000 */
187 0xe28cca00, /* add ip, ip, #0xNN000 */
188 0xe5bcf000, /* ldr pc, [ip, #0xNNN]! */
189 };
190
191 #endif
192
193 /* The ARM linker needs to keep track of the number of relocs that it
194 decides to copy in check_relocs for each symbol. This is so that
195 it can discard PC relative relocs if it doesn't need them when
196 linking with -Bsymbolic. We store the information in a field
197 extending the regular ELF linker hash table. */
198
199 /* This structure keeps track of the number of PC relative relocs we
200 have copied for a given symbol. */
201 struct elf32_arm_relocs_copied
202 {
203 /* Next section. */
204 struct elf32_arm_relocs_copied * next;
205 /* A section in dynobj. */
206 asection * section;
207 /* Number of relocs copied in this section. */
208 bfd_size_type count;
209 };
210
211 /* Arm ELF linker hash entry. */
212 struct elf32_arm_link_hash_entry
213 {
214 struct elf_link_hash_entry root;
215
216 /* Number of PC relative relocs copied for this symbol. */
217 struct elf32_arm_relocs_copied * relocs_copied;
218 };
219
220 /* Traverse an arm ELF linker hash table. */
221 #define elf32_arm_link_hash_traverse(table, func, info) \
222 (elf_link_hash_traverse \
223 (&(table)->root, \
224 (bfd_boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
225 (info)))
226
227 /* Get the ARM elf linker hash table from a link_info structure. */
228 #define elf32_arm_hash_table(info) \
229 ((struct elf32_arm_link_hash_table *) ((info)->hash))
230
231 /* ARM ELF linker hash table. */
232 struct elf32_arm_link_hash_table
233 {
234 /* The main hash table. */
235 struct elf_link_hash_table root;
236
237 /* The size in bytes of the section containing the Thumb-to-ARM glue. */
238 bfd_size_type thumb_glue_size;
239
240 /* The size in bytes of the section containing the ARM-to-Thumb glue. */
241 bfd_size_type arm_glue_size;
242
243 /* An arbitrary input BFD chosen to hold the glue sections. */
244 bfd * bfd_of_glue_owner;
245
246 /* A boolean indicating whether knowledge of the ARM's pipeline
247 length should be applied by the linker. */
248 int no_pipeline_knowledge;
249
250 /* Short-cuts to get to dynamic linker sections. */
251 asection *sgot;
252 asection *sgotplt;
253 asection *srelgot;
254 asection *splt;
255 asection *srelplt;
256 asection *sdynbss;
257 asection *srelbss;
258
259 /* Small local sym to section mapping cache. */
260 struct sym_sec_cache sym_sec;
261 };
262
263 /* Create an entry in an ARM ELF linker hash table. */
264
265 static struct bfd_hash_entry *
elf32_arm_link_hash_newfunc(entry,table,string)266 elf32_arm_link_hash_newfunc (entry, table, string)
267 struct bfd_hash_entry * entry;
268 struct bfd_hash_table * table;
269 const char * string;
270 {
271 struct elf32_arm_link_hash_entry * ret =
272 (struct elf32_arm_link_hash_entry *) entry;
273
274 /* Allocate the structure if it has not already been allocated by a
275 subclass. */
276 if (ret == (struct elf32_arm_link_hash_entry *) NULL)
277 ret = ((struct elf32_arm_link_hash_entry *)
278 bfd_hash_allocate (table,
279 sizeof (struct elf32_arm_link_hash_entry)));
280 if (ret == (struct elf32_arm_link_hash_entry *) NULL)
281 return (struct bfd_hash_entry *) ret;
282
283 /* Call the allocation method of the superclass. */
284 ret = ((struct elf32_arm_link_hash_entry *)
285 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
286 table, string));
287 if (ret != (struct elf32_arm_link_hash_entry *) NULL)
288 ret->relocs_copied = NULL;
289
290 return (struct bfd_hash_entry *) ret;
291 }
292
293 /* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
294 shortcuts to them in our hash table. */
295
296 static bfd_boolean
create_got_section(dynobj,info)297 create_got_section (dynobj, info)
298 bfd *dynobj;
299 struct bfd_link_info *info;
300 {
301 struct elf32_arm_link_hash_table *htab;
302
303 if (! _bfd_elf_create_got_section (dynobj, info))
304 return FALSE;
305
306 htab = elf32_arm_hash_table (info);
307 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
308 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
309 if (!htab->sgot || !htab->sgotplt)
310 abort ();
311
312 htab->srelgot = bfd_make_section (dynobj, ".rel.got");
313 if (htab->srelgot == NULL
314 || ! bfd_set_section_flags (dynobj, htab->srelgot,
315 (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
316 | SEC_IN_MEMORY | SEC_LINKER_CREATED
317 | SEC_READONLY))
318 || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
319 return FALSE;
320 return TRUE;
321 }
322
323 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
324 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
325 hash table. */
326
327 static bfd_boolean
elf32_arm_create_dynamic_sections(dynobj,info)328 elf32_arm_create_dynamic_sections (dynobj, info)
329 bfd *dynobj;
330 struct bfd_link_info *info;
331 {
332 struct elf32_arm_link_hash_table *htab;
333
334 htab = elf32_arm_hash_table (info);
335 if (!htab->sgot && !create_got_section (dynobj, info))
336 return FALSE;
337
338 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
339 return FALSE;
340
341 htab->splt = bfd_get_section_by_name (dynobj, ".plt");
342 htab->srelplt = bfd_get_section_by_name (dynobj, ".rel.plt");
343 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
344 if (!info->shared)
345 htab->srelbss = bfd_get_section_by_name (dynobj, ".rel.bss");
346
347 if (!htab->splt || !htab->srelplt || !htab->sdynbss
348 || (!info->shared && !htab->srelbss))
349 abort ();
350
351 return TRUE;
352 }
353
354 /* Copy the extra info we tack onto an elf_link_hash_entry. */
355
356 static void
elf32_arm_copy_indirect_symbol(const struct elf_backend_data * bed,struct elf_link_hash_entry * dir,struct elf_link_hash_entry * ind)357 elf32_arm_copy_indirect_symbol (const struct elf_backend_data *bed,
358 struct elf_link_hash_entry *dir,
359 struct elf_link_hash_entry *ind)
360 {
361 struct elf32_arm_link_hash_entry *edir, *eind;
362
363 edir = (struct elf32_arm_link_hash_entry *) dir;
364 eind = (struct elf32_arm_link_hash_entry *) ind;
365
366 if (eind->relocs_copied != NULL)
367 {
368 if (edir->relocs_copied != NULL)
369 {
370 struct elf32_arm_relocs_copied **pp;
371 struct elf32_arm_relocs_copied *p;
372
373 if (ind->root.type == bfd_link_hash_indirect)
374 abort ();
375
376 /* Add reloc counts against the weak sym to the strong sym
377 list. Merge any entries against the same section. */
378 for (pp = &eind->relocs_copied; (p = *pp) != NULL; )
379 {
380 struct elf32_arm_relocs_copied *q;
381
382 for (q = edir->relocs_copied; q != NULL; q = q->next)
383 if (q->section == p->section)
384 {
385 q->count += p->count;
386 *pp = p->next;
387 break;
388 }
389 if (q == NULL)
390 pp = &p->next;
391 }
392 *pp = edir->relocs_copied;
393 }
394
395 edir->relocs_copied = eind->relocs_copied;
396 eind->relocs_copied = NULL;
397 }
398
399 _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
400 }
401
402 /* Create an ARM elf linker hash table. */
403
404 static struct bfd_link_hash_table *
elf32_arm_link_hash_table_create(abfd)405 elf32_arm_link_hash_table_create (abfd)
406 bfd *abfd;
407 {
408 struct elf32_arm_link_hash_table *ret;
409 bfd_size_type amt = sizeof (struct elf32_arm_link_hash_table);
410
411 ret = (struct elf32_arm_link_hash_table *) bfd_malloc (amt);
412 if (ret == (struct elf32_arm_link_hash_table *) NULL)
413 return NULL;
414
415 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
416 elf32_arm_link_hash_newfunc))
417 {
418 free (ret);
419 return NULL;
420 }
421
422 ret->sgot = NULL;
423 ret->sgotplt = NULL;
424 ret->srelgot = NULL;
425 ret->splt = NULL;
426 ret->srelplt = NULL;
427 ret->sdynbss = NULL;
428 ret->srelbss = NULL;
429 ret->thumb_glue_size = 0;
430 ret->arm_glue_size = 0;
431 ret->bfd_of_glue_owner = NULL;
432 ret->no_pipeline_knowledge = 0;
433 ret->sym_sec.abfd = NULL;
434
435 return &ret->root.root;
436 }
437
438 /* Locate the Thumb encoded calling stub for NAME. */
439
440 static struct elf_link_hash_entry *
find_thumb_glue(link_info,name,input_bfd)441 find_thumb_glue (link_info, name, input_bfd)
442 struct bfd_link_info *link_info;
443 const char *name;
444 bfd *input_bfd;
445 {
446 char *tmp_name;
447 struct elf_link_hash_entry *hash;
448 struct elf32_arm_link_hash_table *hash_table;
449
450 /* We need a pointer to the armelf specific hash table. */
451 hash_table = elf32_arm_hash_table (link_info);
452
453 tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen (name)
454 + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1);
455
456 BFD_ASSERT (tmp_name);
457
458 sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
459
460 hash = elf_link_hash_lookup
461 (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
462
463 if (hash == NULL)
464 /* xgettext:c-format */
465 (*_bfd_error_handler) (_("%s: unable to find THUMB glue '%s' for `%s'"),
466 bfd_archive_filename (input_bfd), tmp_name, name);
467
468 free (tmp_name);
469
470 return hash;
471 }
472
473 /* Locate the ARM encoded calling stub for NAME. */
474
475 static struct elf_link_hash_entry *
find_arm_glue(link_info,name,input_bfd)476 find_arm_glue (link_info, name, input_bfd)
477 struct bfd_link_info *link_info;
478 const char *name;
479 bfd *input_bfd;
480 {
481 char *tmp_name;
482 struct elf_link_hash_entry *myh;
483 struct elf32_arm_link_hash_table *hash_table;
484
485 /* We need a pointer to the elfarm specific hash table. */
486 hash_table = elf32_arm_hash_table (link_info);
487
488 tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen (name)
489 + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
490
491 BFD_ASSERT (tmp_name);
492
493 sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
494
495 myh = elf_link_hash_lookup
496 (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
497
498 if (myh == NULL)
499 /* xgettext:c-format */
500 (*_bfd_error_handler) (_("%s: unable to find ARM glue '%s' for `%s'"),
501 bfd_archive_filename (input_bfd), tmp_name, name);
502
503 free (tmp_name);
504
505 return myh;
506 }
507
508 /* ARM->Thumb glue:
509
510 .arm
511 __func_from_arm:
512 ldr r12, __func_addr
513 bx r12
514 __func_addr:
515 .word func @ behave as if you saw a ARM_32 reloc. */
516
517 #define ARM2THUMB_GLUE_SIZE 12
518 static const insn32 a2t1_ldr_insn = 0xe59fc000;
519 static const insn32 a2t2_bx_r12_insn = 0xe12fff1c;
520 static const insn32 a2t3_func_addr_insn = 0x00000001;
521
522 /* Thumb->ARM: Thumb->(non-interworking aware) ARM
523
524 .thumb .thumb
525 .align 2 .align 2
526 __func_from_thumb: __func_from_thumb:
527 bx pc push {r6, lr}
528 nop ldr r6, __func_addr
529 .arm mov lr, pc
530 __func_change_to_arm: bx r6
531 b func .arm
532 __func_back_to_thumb:
533 ldmia r13! {r6, lr}
534 bx lr
535 __func_addr:
536 .word func */
537
538 #define THUMB2ARM_GLUE_SIZE 8
539 static const insn16 t2a1_bx_pc_insn = 0x4778;
540 static const insn16 t2a2_noop_insn = 0x46c0;
541 static const insn32 t2a3_b_insn = 0xea000000;
542
543 #ifndef ELFARM_NABI_C_INCLUDED
544 bfd_boolean
bfd_elf32_arm_allocate_interworking_sections(info)545 bfd_elf32_arm_allocate_interworking_sections (info)
546 struct bfd_link_info * info;
547 {
548 asection * s;
549 bfd_byte * foo;
550 struct elf32_arm_link_hash_table * globals;
551
552 globals = elf32_arm_hash_table (info);
553
554 BFD_ASSERT (globals != NULL);
555
556 if (globals->arm_glue_size != 0)
557 {
558 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
559
560 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
561 ARM2THUMB_GLUE_SECTION_NAME);
562
563 BFD_ASSERT (s != NULL);
564
565 foo = (bfd_byte *) bfd_alloc (globals->bfd_of_glue_owner,
566 globals->arm_glue_size);
567
568 s->_raw_size = s->_cooked_size = globals->arm_glue_size;
569 s->contents = foo;
570 }
571
572 if (globals->thumb_glue_size != 0)
573 {
574 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
575
576 s = bfd_get_section_by_name
577 (globals->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
578
579 BFD_ASSERT (s != NULL);
580
581 foo = (bfd_byte *) bfd_alloc (globals->bfd_of_glue_owner,
582 globals->thumb_glue_size);
583
584 s->_raw_size = s->_cooked_size = globals->thumb_glue_size;
585 s->contents = foo;
586 }
587
588 return TRUE;
589 }
590
591 static void
record_arm_to_thumb_glue(link_info,h)592 record_arm_to_thumb_glue (link_info, h)
593 struct bfd_link_info * link_info;
594 struct elf_link_hash_entry * h;
595 {
596 const char * name = h->root.root.string;
597 asection * s;
598 char * tmp_name;
599 struct elf_link_hash_entry * myh;
600 struct bfd_link_hash_entry * bh;
601 struct elf32_arm_link_hash_table * globals;
602 bfd_vma val;
603
604 globals = elf32_arm_hash_table (link_info);
605
606 BFD_ASSERT (globals != NULL);
607 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
608
609 s = bfd_get_section_by_name
610 (globals->bfd_of_glue_owner, ARM2THUMB_GLUE_SECTION_NAME);
611
612 BFD_ASSERT (s != NULL);
613
614 tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen (name)
615 + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
616
617 BFD_ASSERT (tmp_name);
618
619 sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
620
621 myh = elf_link_hash_lookup
622 (&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
623
624 if (myh != NULL)
625 {
626 /* We've already seen this guy. */
627 free (tmp_name);
628 return;
629 }
630
631 /* The only trick here is using hash_table->arm_glue_size as the value. Even
632 though the section isn't allocated yet, this is where we will be putting
633 it. */
634 bh = NULL;
635 val = globals->arm_glue_size + 1;
636 _bfd_generic_link_add_one_symbol (link_info, globals->bfd_of_glue_owner,
637 tmp_name, BSF_GLOBAL, s, val,
638 NULL, TRUE, FALSE, &bh);
639
640 free (tmp_name);
641
642 globals->arm_glue_size += ARM2THUMB_GLUE_SIZE;
643
644 return;
645 }
646
647 static void
record_thumb_to_arm_glue(link_info,h)648 record_thumb_to_arm_glue (link_info, h)
649 struct bfd_link_info *link_info;
650 struct elf_link_hash_entry *h;
651 {
652 const char *name = h->root.root.string;
653 asection *s;
654 char *tmp_name;
655 struct elf_link_hash_entry *myh;
656 struct bfd_link_hash_entry *bh;
657 struct elf32_arm_link_hash_table *hash_table;
658 char bind;
659 bfd_vma val;
660
661 hash_table = elf32_arm_hash_table (link_info);
662
663 BFD_ASSERT (hash_table != NULL);
664 BFD_ASSERT (hash_table->bfd_of_glue_owner != NULL);
665
666 s = bfd_get_section_by_name
667 (hash_table->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
668
669 BFD_ASSERT (s != NULL);
670
671 tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen (name)
672 + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1);
673
674 BFD_ASSERT (tmp_name);
675
676 sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
677
678 myh = elf_link_hash_lookup
679 (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
680
681 if (myh != NULL)
682 {
683 /* We've already seen this guy. */
684 free (tmp_name);
685 return;
686 }
687
688 bh = NULL;
689 val = hash_table->thumb_glue_size + 1;
690 _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner,
691 tmp_name, BSF_GLOBAL, s, val,
692 NULL, TRUE, FALSE, &bh);
693
694 /* If we mark it 'Thumb', the disassembler will do a better job. */
695 myh = (struct elf_link_hash_entry *) bh;
696 bind = ELF_ST_BIND (myh->type);
697 myh->type = ELF_ST_INFO (bind, STT_ARM_TFUNC);
698
699 free (tmp_name);
700
701 #define CHANGE_TO_ARM "__%s_change_to_arm"
702 #define BACK_FROM_ARM "__%s_back_from_arm"
703
704 /* Allocate another symbol to mark where we switch to Arm mode. */
705 tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen (name)
706 + strlen (CHANGE_TO_ARM) + 1);
707
708 BFD_ASSERT (tmp_name);
709
710 sprintf (tmp_name, CHANGE_TO_ARM, name);
711
712 bh = NULL;
713 val = hash_table->thumb_glue_size + 4,
714 _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner,
715 tmp_name, BSF_LOCAL, s, val,
716 NULL, TRUE, FALSE, &bh);
717
718 free (tmp_name);
719
720 hash_table->thumb_glue_size += THUMB2ARM_GLUE_SIZE;
721
722 return;
723 }
724
725 /* Add the glue sections to ABFD. This function is called from the
726 linker scripts in ld/emultempl/{armelf}.em. */
727
728 bfd_boolean
bfd_elf32_arm_add_glue_sections_to_bfd(abfd,info)729 bfd_elf32_arm_add_glue_sections_to_bfd (abfd, info)
730 bfd *abfd;
731 struct bfd_link_info *info;
732 {
733 flagword flags;
734 asection *sec;
735
736 /* If we are only performing a partial
737 link do not bother adding the glue. */
738 if (info->relocatable)
739 return TRUE;
740
741 sec = bfd_get_section_by_name (abfd, ARM2THUMB_GLUE_SECTION_NAME);
742
743 if (sec == NULL)
744 {
745 /* Note: we do not include the flag SEC_LINKER_CREATED, as this
746 will prevent elf_link_input_bfd() from processing the contents
747 of this section. */
748 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_CODE | SEC_READONLY;
749
750 sec = bfd_make_section (abfd, ARM2THUMB_GLUE_SECTION_NAME);
751
752 if (sec == NULL
753 || !bfd_set_section_flags (abfd, sec, flags)
754 || !bfd_set_section_alignment (abfd, sec, 2))
755 return FALSE;
756
757 /* Set the gc mark to prevent the section from being removed by garbage
758 collection, despite the fact that no relocs refer to this section. */
759 sec->gc_mark = 1;
760 }
761
762 sec = bfd_get_section_by_name (abfd, THUMB2ARM_GLUE_SECTION_NAME);
763
764 if (sec == NULL)
765 {
766 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_CODE | SEC_READONLY;
767
768 sec = bfd_make_section (abfd, THUMB2ARM_GLUE_SECTION_NAME);
769
770 if (sec == NULL
771 || !bfd_set_section_flags (abfd, sec, flags)
772 || !bfd_set_section_alignment (abfd, sec, 2))
773 return FALSE;
774
775 sec->gc_mark = 1;
776 }
777
778 return TRUE;
779 }
780
781 /* Select a BFD to be used to hold the sections used by the glue code.
782 This function is called from the linker scripts in ld/emultempl/
783 {armelf/pe}.em */
784
785 bfd_boolean
bfd_elf32_arm_get_bfd_for_interworking(abfd,info)786 bfd_elf32_arm_get_bfd_for_interworking (abfd, info)
787 bfd *abfd;
788 struct bfd_link_info *info;
789 {
790 struct elf32_arm_link_hash_table *globals;
791
792 /* If we are only performing a partial link
793 do not bother getting a bfd to hold the glue. */
794 if (info->relocatable)
795 return TRUE;
796
797 globals = elf32_arm_hash_table (info);
798
799 BFD_ASSERT (globals != NULL);
800
801 if (globals->bfd_of_glue_owner != NULL)
802 return TRUE;
803
804 /* Save the bfd for later use. */
805 globals->bfd_of_glue_owner = abfd;
806
807 return TRUE;
808 }
809
810 bfd_boolean
bfd_elf32_arm_process_before_allocation(abfd,link_info,no_pipeline_knowledge)811 bfd_elf32_arm_process_before_allocation (abfd, link_info, no_pipeline_knowledge)
812 bfd *abfd;
813 struct bfd_link_info *link_info;
814 int no_pipeline_knowledge;
815 {
816 Elf_Internal_Shdr *symtab_hdr;
817 Elf_Internal_Rela *internal_relocs = NULL;
818 Elf_Internal_Rela *irel, *irelend;
819 bfd_byte *contents = NULL;
820
821 asection *sec;
822 struct elf32_arm_link_hash_table *globals;
823
824 /* If we are only performing a partial link do not bother
825 to construct any glue. */
826 if (link_info->relocatable)
827 return TRUE;
828
829 /* Here we have a bfd that is to be included on the link. We have a hook
830 to do reloc rummaging, before section sizes are nailed down. */
831 globals = elf32_arm_hash_table (link_info);
832
833 BFD_ASSERT (globals != NULL);
834 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
835
836 globals->no_pipeline_knowledge = no_pipeline_knowledge;
837
838 /* Rummage around all the relocs and map the glue vectors. */
839 sec = abfd->sections;
840
841 if (sec == NULL)
842 return TRUE;
843
844 for (; sec != NULL; sec = sec->next)
845 {
846 if (sec->reloc_count == 0)
847 continue;
848
849 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
850
851 /* Load the relocs. */
852 internal_relocs
853 = _bfd_elf_link_read_relocs (abfd, sec, (PTR) NULL,
854 (Elf_Internal_Rela *) NULL, FALSE);
855
856 if (internal_relocs == NULL)
857 goto error_return;
858
859 irelend = internal_relocs + sec->reloc_count;
860 for (irel = internal_relocs; irel < irelend; irel++)
861 {
862 long r_type;
863 unsigned long r_index;
864
865 struct elf_link_hash_entry *h;
866
867 r_type = ELF32_R_TYPE (irel->r_info);
868 r_index = ELF32_R_SYM (irel->r_info);
869
870 /* These are the only relocation types we care about. */
871 if ( r_type != R_ARM_PC24
872 && r_type != R_ARM_THM_PC22)
873 continue;
874
875 /* Get the section contents if we haven't done so already. */
876 if (contents == NULL)
877 {
878 /* Get cached copy if it exists. */
879 if (elf_section_data (sec)->this_hdr.contents != NULL)
880 contents = elf_section_data (sec)->this_hdr.contents;
881 else
882 {
883 /* Go get them off disk. */
884 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
885 if (contents == NULL)
886 goto error_return;
887
888 if (!bfd_get_section_contents (abfd, sec, contents,
889 (file_ptr) 0, sec->_raw_size))
890 goto error_return;
891 }
892 }
893
894 /* If the relocation is not against a symbol it cannot concern us. */
895 h = NULL;
896
897 /* We don't care about local symbols. */
898 if (r_index < symtab_hdr->sh_info)
899 continue;
900
901 /* This is an external symbol. */
902 r_index -= symtab_hdr->sh_info;
903 h = (struct elf_link_hash_entry *)
904 elf_sym_hashes (abfd)[r_index];
905
906 /* If the relocation is against a static symbol it must be within
907 the current section and so cannot be a cross ARM/Thumb relocation. */
908 if (h == NULL)
909 continue;
910
911 switch (r_type)
912 {
913 case R_ARM_PC24:
914 /* This one is a call from arm code. We need to look up
915 the target of the call. If it is a thumb target, we
916 insert glue. */
917 if (ELF_ST_TYPE(h->type) == STT_ARM_TFUNC)
918 record_arm_to_thumb_glue (link_info, h);
919 break;
920
921 case R_ARM_THM_PC22:
922 /* This one is a call from thumb code. We look
923 up the target of the call. If it is not a thumb
924 target, we insert glue. */
925 if (ELF_ST_TYPE (h->type) != STT_ARM_TFUNC)
926 record_thumb_to_arm_glue (link_info, h);
927 break;
928
929 default:
930 break;
931 }
932 }
933
934 if (contents != NULL
935 && elf_section_data (sec)->this_hdr.contents != contents)
936 free (contents);
937 contents = NULL;
938
939 if (internal_relocs != NULL
940 && elf_section_data (sec)->relocs != internal_relocs)
941 free (internal_relocs);
942 internal_relocs = NULL;
943 }
944
945 return TRUE;
946
947 error_return:
948 if (contents != NULL
949 && elf_section_data (sec)->this_hdr.contents != contents)
950 free (contents);
951 if (internal_relocs != NULL
952 && elf_section_data (sec)->relocs != internal_relocs)
953 free (internal_relocs);
954
955 return FALSE;
956 }
957 #endif
958
959 /* The thumb form of a long branch is a bit finicky, because the offset
960 encoding is split over two fields, each in it's own instruction. They
961 can occur in any order. So given a thumb form of long branch, and an
962 offset, insert the offset into the thumb branch and return finished
963 instruction.
964
965 It takes two thumb instructions to encode the target address. Each has
966 11 bits to invest. The upper 11 bits are stored in one (identified by
967 H-0.. see below), the lower 11 bits are stored in the other (identified
968 by H-1).
969
970 Combine together and shifted left by 1 (it's a half word address) and
971 there you have it.
972
973 Op: 1111 = F,
974 H-0, upper address-0 = 000
975 Op: 1111 = F,
976 H-1, lower address-0 = 800
977
978 They can be ordered either way, but the arm tools I've seen always put
979 the lower one first. It probably doesn't matter. krk@cygnus.com
980
981 XXX: Actually the order does matter. The second instruction (H-1)
982 moves the computed address into the PC, so it must be the second one
983 in the sequence. The problem, however is that whilst little endian code
984 stores the instructions in HI then LOW order, big endian code does the
985 reverse. nickc@cygnus.com. */
986
987 #define LOW_HI_ORDER 0xF800F000
988 #define HI_LOW_ORDER 0xF000F800
989
990 static insn32
insert_thumb_branch(br_insn,rel_off)991 insert_thumb_branch (br_insn, rel_off)
992 insn32 br_insn;
993 int rel_off;
994 {
995 unsigned int low_bits;
996 unsigned int high_bits;
997
998 BFD_ASSERT ((rel_off & 1) != 1);
999
1000 rel_off >>= 1; /* Half word aligned address. */
1001 low_bits = rel_off & 0x000007FF; /* The bottom 11 bits. */
1002 high_bits = (rel_off >> 11) & 0x000007FF; /* The top 11 bits. */
1003
1004 if ((br_insn & LOW_HI_ORDER) == LOW_HI_ORDER)
1005 br_insn = LOW_HI_ORDER | (low_bits << 16) | high_bits;
1006 else if ((br_insn & HI_LOW_ORDER) == HI_LOW_ORDER)
1007 br_insn = HI_LOW_ORDER | (high_bits << 16) | low_bits;
1008 else
1009 /* FIXME: abort is probably not the right call. krk@cygnus.com */
1010 abort (); /* error - not a valid branch instruction form. */
1011
1012 return br_insn;
1013 }
1014
1015 /* Thumb code calling an ARM function. */
1016
1017 static int
elf32_thumb_to_arm_stub(info,name,input_bfd,output_bfd,input_section,hit_data,sym_sec,offset,addend,val)1018 elf32_thumb_to_arm_stub (info, name, input_bfd, output_bfd, input_section,
1019 hit_data, sym_sec, offset, addend, val)
1020 struct bfd_link_info * info;
1021 const char * name;
1022 bfd * input_bfd;
1023 bfd * output_bfd;
1024 asection * input_section;
1025 bfd_byte * hit_data;
1026 asection * sym_sec;
1027 bfd_vma offset;
1028 bfd_signed_vma addend;
1029 bfd_vma val;
1030 {
1031 asection * s = 0;
1032 bfd_vma my_offset;
1033 unsigned long int tmp;
1034 long int ret_offset;
1035 struct elf_link_hash_entry * myh;
1036 struct elf32_arm_link_hash_table * globals;
1037
1038 myh = find_thumb_glue (info, name, input_bfd);
1039 if (myh == NULL)
1040 return FALSE;
1041
1042 globals = elf32_arm_hash_table (info);
1043
1044 BFD_ASSERT (globals != NULL);
1045 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
1046
1047 my_offset = myh->root.u.def.value;
1048
1049 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
1050 THUMB2ARM_GLUE_SECTION_NAME);
1051
1052 BFD_ASSERT (s != NULL);
1053 BFD_ASSERT (s->contents != NULL);
1054 BFD_ASSERT (s->output_section != NULL);
1055
1056 if ((my_offset & 0x01) == 0x01)
1057 {
1058 if (sym_sec != NULL
1059 && sym_sec->owner != NULL
1060 && !INTERWORK_FLAG (sym_sec->owner))
1061 {
1062 (*_bfd_error_handler)
1063 (_("%s(%s): warning: interworking not enabled."),
1064 bfd_archive_filename (sym_sec->owner), name);
1065 (*_bfd_error_handler)
1066 (_(" first occurrence: %s: thumb call to arm"),
1067 bfd_archive_filename (input_bfd));
1068
1069 return FALSE;
1070 }
1071
1072 --my_offset;
1073 myh->root.u.def.value = my_offset;
1074
1075 bfd_put_16 (output_bfd, (bfd_vma) t2a1_bx_pc_insn,
1076 s->contents + my_offset);
1077
1078 bfd_put_16 (output_bfd, (bfd_vma) t2a2_noop_insn,
1079 s->contents + my_offset + 2);
1080
1081 ret_offset =
1082 /* Address of destination of the stub. */
1083 ((bfd_signed_vma) val)
1084 - ((bfd_signed_vma)
1085 /* Offset from the start of the current section to the start of the stubs. */
1086 (s->output_offset
1087 /* Offset of the start of this stub from the start of the stubs. */
1088 + my_offset
1089 /* Address of the start of the current section. */
1090 + s->output_section->vma)
1091 /* The branch instruction is 4 bytes into the stub. */
1092 + 4
1093 /* ARM branches work from the pc of the instruction + 8. */
1094 + 8);
1095
1096 bfd_put_32 (output_bfd,
1097 (bfd_vma) t2a3_b_insn | ((ret_offset >> 2) & 0x00FFFFFF),
1098 s->contents + my_offset + 4);
1099 }
1100
1101 BFD_ASSERT (my_offset <= globals->thumb_glue_size);
1102
1103 /* Now go back and fix up the original BL insn to point to here. */
1104 ret_offset =
1105 /* Address of where the stub is located. */
1106 (s->output_section->vma + s->output_offset + my_offset)
1107 /* Address of where the BL is located. */
1108 - (input_section->output_section->vma + input_section->output_offset + offset)
1109 /* Addend in the relocation. */
1110 - addend
1111 /* Biassing for PC-relative addressing. */
1112 - 8;
1113
1114 tmp = bfd_get_32 (input_bfd, hit_data
1115 - input_section->vma);
1116
1117 bfd_put_32 (output_bfd,
1118 (bfd_vma) insert_thumb_branch (tmp, ret_offset),
1119 hit_data - input_section->vma);
1120
1121 return TRUE;
1122 }
1123
1124 /* Arm code calling a Thumb function. */
1125
1126 static int
elf32_arm_to_thumb_stub(info,name,input_bfd,output_bfd,input_section,hit_data,sym_sec,offset,addend,val)1127 elf32_arm_to_thumb_stub (info, name, input_bfd, output_bfd, input_section,
1128 hit_data, sym_sec, offset, addend, val)
1129 struct bfd_link_info * info;
1130 const char * name;
1131 bfd * input_bfd;
1132 bfd * output_bfd;
1133 asection * input_section;
1134 bfd_byte * hit_data;
1135 asection * sym_sec;
1136 bfd_vma offset;
1137 bfd_signed_vma addend;
1138 bfd_vma val;
1139 {
1140 unsigned long int tmp;
1141 bfd_vma my_offset;
1142 asection * s;
1143 long int ret_offset;
1144 struct elf_link_hash_entry * myh;
1145 struct elf32_arm_link_hash_table * globals;
1146
1147 myh = find_arm_glue (info, name, input_bfd);
1148 if (myh == NULL)
1149 return FALSE;
1150
1151 globals = elf32_arm_hash_table (info);
1152
1153 BFD_ASSERT (globals != NULL);
1154 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
1155
1156 my_offset = myh->root.u.def.value;
1157 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
1158 ARM2THUMB_GLUE_SECTION_NAME);
1159 BFD_ASSERT (s != NULL);
1160 BFD_ASSERT (s->contents != NULL);
1161 BFD_ASSERT (s->output_section != NULL);
1162
1163 if ((my_offset & 0x01) == 0x01)
1164 {
1165 if (sym_sec != NULL
1166 && sym_sec->owner != NULL
1167 && !INTERWORK_FLAG (sym_sec->owner))
1168 {
1169 (*_bfd_error_handler)
1170 (_("%s(%s): warning: interworking not enabled."),
1171 bfd_archive_filename (sym_sec->owner), name);
1172 (*_bfd_error_handler)
1173 (_(" first occurrence: %s: arm call to thumb"),
1174 bfd_archive_filename (input_bfd));
1175 }
1176
1177 --my_offset;
1178 myh->root.u.def.value = my_offset;
1179
1180 bfd_put_32 (output_bfd, (bfd_vma) a2t1_ldr_insn,
1181 s->contents + my_offset);
1182
1183 bfd_put_32 (output_bfd, (bfd_vma) a2t2_bx_r12_insn,
1184 s->contents + my_offset + 4);
1185
1186 /* It's a thumb address. Add the low order bit. */
1187 bfd_put_32 (output_bfd, val | a2t3_func_addr_insn,
1188 s->contents + my_offset + 8);
1189 }
1190
1191 BFD_ASSERT (my_offset <= globals->arm_glue_size);
1192
1193 tmp = bfd_get_32 (input_bfd, hit_data);
1194 tmp = tmp & 0xFF000000;
1195
1196 /* Somehow these are both 4 too far, so subtract 8. */
1197 ret_offset = (s->output_offset
1198 + my_offset
1199 + s->output_section->vma
1200 - (input_section->output_offset
1201 + input_section->output_section->vma
1202 + offset + addend)
1203 - 8);
1204
1205 tmp = tmp | ((ret_offset >> 2) & 0x00FFFFFF);
1206
1207 bfd_put_32 (output_bfd, (bfd_vma) tmp, hit_data - input_section->vma);
1208
1209 return TRUE;
1210 }
1211
1212 /* Perform a relocation as part of a final link. */
1213
1214 static bfd_reloc_status_type
elf32_arm_final_link_relocate(howto,input_bfd,output_bfd,input_section,contents,rel,value,info,sym_sec,sym_name,sym_flags,h)1215 elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
1216 input_section, contents, rel, value,
1217 info, sym_sec, sym_name, sym_flags, h)
1218 reloc_howto_type * howto;
1219 bfd * input_bfd;
1220 bfd * output_bfd;
1221 asection * input_section;
1222 bfd_byte * contents;
1223 Elf_Internal_Rela * rel;
1224 bfd_vma value;
1225 struct bfd_link_info * info;
1226 asection * sym_sec;
1227 const char * sym_name;
1228 int sym_flags;
1229 struct elf_link_hash_entry * h;
1230 {
1231 unsigned long r_type = howto->type;
1232 unsigned long r_symndx;
1233 bfd_byte * hit_data = contents + rel->r_offset;
1234 bfd * dynobj = NULL;
1235 Elf_Internal_Shdr * symtab_hdr;
1236 struct elf_link_hash_entry ** sym_hashes;
1237 bfd_vma * local_got_offsets;
1238 asection * sgot = NULL;
1239 asection * splt = NULL;
1240 asection * sreloc = NULL;
1241 bfd_vma addend;
1242 bfd_signed_vma signed_addend;
1243 struct elf32_arm_link_hash_table * globals;
1244
1245 /* If the start address has been set, then set the EF_ARM_HASENTRY
1246 flag. Setting this more than once is redundant, but the cost is
1247 not too high, and it keeps the code simple.
1248
1249 The test is done here, rather than somewhere else, because the
1250 start address is only set just before the final link commences.
1251
1252 Note - if the user deliberately sets a start address of 0, the
1253 flag will not be set. */
1254 if (bfd_get_start_address (output_bfd) != 0)
1255 elf_elfheader (output_bfd)->e_flags |= EF_ARM_HASENTRY;
1256
1257 globals = elf32_arm_hash_table (info);
1258
1259 dynobj = elf_hash_table (info)->dynobj;
1260 if (dynobj)
1261 {
1262 sgot = bfd_get_section_by_name (dynobj, ".got");
1263 splt = bfd_get_section_by_name (dynobj, ".plt");
1264 }
1265 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1266 sym_hashes = elf_sym_hashes (input_bfd);
1267 local_got_offsets = elf_local_got_offsets (input_bfd);
1268 r_symndx = ELF32_R_SYM (rel->r_info);
1269
1270 #if USE_REL
1271 addend = bfd_get_32 (input_bfd, hit_data) & howto->src_mask;
1272
1273 if (addend & ((howto->src_mask + 1) >> 1))
1274 {
1275 signed_addend = -1;
1276 signed_addend &= ~ howto->src_mask;
1277 signed_addend |= addend;
1278 }
1279 else
1280 signed_addend = addend;
1281 #else
1282 addend = signed_addend = rel->r_addend;
1283 #endif
1284
1285 switch (r_type)
1286 {
1287 case R_ARM_NONE:
1288 return bfd_reloc_ok;
1289
1290 case R_ARM_PC24:
1291 case R_ARM_ABS32:
1292 case R_ARM_REL32:
1293 #ifndef OLD_ARM_ABI
1294 case R_ARM_XPC25:
1295 #endif
1296 case R_ARM_PLT32:
1297 /* r_symndx will be zero only for relocs against symbols
1298 from removed linkonce sections, or sections discarded by
1299 a linker script. */
1300 if (r_symndx == 0)
1301 return bfd_reloc_ok;
1302
1303 /* Handle relocations which should use the PLT entry. ABS32/REL32
1304 will use the symbol's value, which may point to a PLT entry, but we
1305 don't need to handle that here. If we created a PLT entry, all
1306 branches in this object should go to it. */
1307 if ((r_type != R_ARM_ABS32 && r_type != R_ARM_REL32)
1308 && h != NULL
1309 && splt != NULL
1310 && h->plt.offset != (bfd_vma) -1)
1311 {
1312 /* If we've created a .plt section, and assigned a PLT entry to
1313 this function, it should not be known to bind locally. If
1314 it were, we would have cleared the PLT entry. */
1315 BFD_ASSERT (!SYMBOL_CALLS_LOCAL (info, h));
1316
1317 value = (splt->output_section->vma
1318 + splt->output_offset
1319 + h->plt.offset);
1320 return _bfd_final_link_relocate (howto, input_bfd, input_section,
1321 contents, rel->r_offset, value,
1322 (bfd_vma) 0);
1323 }
1324
1325 /* When generating a shared object, these relocations are copied
1326 into the output file to be resolved at run time. */
1327 if (info->shared
1328 && (input_section->flags & SEC_ALLOC)
1329 && (r_type != R_ARM_REL32
1330 || !SYMBOL_CALLS_LOCAL (info, h))
1331 && (h == NULL
1332 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1333 || h->root.type != bfd_link_hash_undefweak)
1334 && r_type != R_ARM_PC24
1335 && r_type != R_ARM_PLT32)
1336 {
1337 Elf_Internal_Rela outrel;
1338 bfd_byte *loc;
1339 bfd_boolean skip, relocate;
1340
1341 if (sreloc == NULL)
1342 {
1343 const char * name;
1344
1345 name = (bfd_elf_string_from_elf_section
1346 (input_bfd,
1347 elf_elfheader (input_bfd)->e_shstrndx,
1348 elf_section_data (input_section)->rel_hdr.sh_name));
1349 if (name == NULL)
1350 return bfd_reloc_notsupported;
1351
1352 BFD_ASSERT (strncmp (name, ".rel", 4) == 0
1353 && strcmp (bfd_get_section_name (input_bfd,
1354 input_section),
1355 name + 4) == 0);
1356
1357 sreloc = bfd_get_section_by_name (dynobj, name);
1358 BFD_ASSERT (sreloc != NULL);
1359 }
1360
1361 skip = FALSE;
1362 relocate = FALSE;
1363
1364 outrel.r_offset =
1365 _bfd_elf_section_offset (output_bfd, info, input_section,
1366 rel->r_offset);
1367 if (outrel.r_offset == (bfd_vma) -1)
1368 skip = TRUE;
1369 else if (outrel.r_offset == (bfd_vma) -2)
1370 skip = TRUE, relocate = TRUE;
1371 outrel.r_offset += (input_section->output_section->vma
1372 + input_section->output_offset);
1373
1374 if (skip)
1375 memset (&outrel, 0, sizeof outrel);
1376 else if (h != NULL
1377 && h->dynindx != -1
1378 && (!info->shared
1379 || !info->symbolic
1380 || (h->elf_link_hash_flags
1381 & ELF_LINK_HASH_DEF_REGULAR) == 0))
1382 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1383 else
1384 {
1385 /* This symbol is local, or marked to become local. */
1386 relocate = TRUE;
1387 outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
1388 }
1389
1390 loc = sreloc->contents;
1391 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
1392 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
1393
1394 /* If this reloc is against an external symbol, we do not want to
1395 fiddle with the addend. Otherwise, we need to include the symbol
1396 value so that it becomes an addend for the dynamic reloc. */
1397 if (! relocate)
1398 return bfd_reloc_ok;
1399
1400 return _bfd_final_link_relocate (howto, input_bfd, input_section,
1401 contents, rel->r_offset, value,
1402 (bfd_vma) 0);
1403 }
1404 else switch (r_type)
1405 {
1406 #ifndef OLD_ARM_ABI
1407 case R_ARM_XPC25: /* Arm BLX instruction. */
1408 #endif
1409 case R_ARM_PC24: /* Arm B/BL instruction */
1410 case R_ARM_PLT32:
1411 #ifndef OLD_ARM_ABI
1412 if (r_type == R_ARM_XPC25)
1413 {
1414 /* Check for Arm calling Arm function. */
1415 /* FIXME: Should we translate the instruction into a BL
1416 instruction instead ? */
1417 if (sym_flags != STT_ARM_TFUNC)
1418 (*_bfd_error_handler) (_("\
1419 %s: Warning: Arm BLX instruction targets Arm function '%s'."),
1420 bfd_archive_filename (input_bfd),
1421 h ? h->root.root.string : "(local)");
1422 }
1423 else
1424 #endif
1425 {
1426 /* Check for Arm calling Thumb function. */
1427 if (sym_flags == STT_ARM_TFUNC)
1428 {
1429 elf32_arm_to_thumb_stub (info, sym_name, input_bfd, output_bfd,
1430 input_section, hit_data, sym_sec, rel->r_offset,
1431 signed_addend, value);
1432 return bfd_reloc_ok;
1433 }
1434 }
1435
1436 if ( strcmp (bfd_get_target (input_bfd), "elf32-littlearm-oabi") == 0
1437 || strcmp (bfd_get_target (input_bfd), "elf32-bigarm-oabi") == 0)
1438 {
1439 /* The old way of doing things. Trearing the addend as a
1440 byte sized field and adding in the pipeline offset. */
1441 value -= (input_section->output_section->vma
1442 + input_section->output_offset);
1443 value -= rel->r_offset;
1444 value += addend;
1445
1446 if (! globals->no_pipeline_knowledge)
1447 value -= 8;
1448 }
1449 else
1450 {
1451 /* The ARM ELF ABI says that this reloc is computed as: S - P + A
1452 where:
1453 S is the address of the symbol in the relocation.
1454 P is address of the instruction being relocated.
1455 A is the addend (extracted from the instruction) in bytes.
1456
1457 S is held in 'value'.
1458 P is the base address of the section containing the instruction
1459 plus the offset of the reloc into that section, ie:
1460 (input_section->output_section->vma +
1461 input_section->output_offset +
1462 rel->r_offset).
1463 A is the addend, converted into bytes, ie:
1464 (signed_addend * 4)
1465
1466 Note: None of these operations have knowledge of the pipeline
1467 size of the processor, thus it is up to the assembler to encode
1468 this information into the addend. */
1469 value -= (input_section->output_section->vma
1470 + input_section->output_offset);
1471 value -= rel->r_offset;
1472 value += (signed_addend << howto->size);
1473
1474 /* Previous versions of this code also used to add in the pipeline
1475 offset here. This is wrong because the linker is not supposed
1476 to know about such things, and one day it might change. In order
1477 to support old binaries that need the old behaviour however, so
1478 we attempt to detect which ABI was used to create the reloc. */
1479 if (! globals->no_pipeline_knowledge)
1480 {
1481 Elf_Internal_Ehdr * i_ehdrp; /* Elf file header, internal form */
1482
1483 i_ehdrp = elf_elfheader (input_bfd);
1484
1485 if (i_ehdrp->e_ident[EI_OSABI] == 0)
1486 value -= 8;
1487 }
1488 }
1489
1490 signed_addend = value;
1491 signed_addend >>= howto->rightshift;
1492
1493 /* It is not an error for an undefined weak reference to be
1494 out of range. Any program that branches to such a symbol
1495 is going to crash anyway, so there is no point worrying
1496 about getting the destination exactly right. */
1497 if (! h || h->root.type != bfd_link_hash_undefweak)
1498 {
1499 /* Perform a signed range check. */
1500 if ( signed_addend > ((bfd_signed_vma) (howto->dst_mask >> 1))
1501 || signed_addend < - ((bfd_signed_vma) ((howto->dst_mask + 1) >> 1)))
1502 return bfd_reloc_overflow;
1503 }
1504
1505 #ifndef OLD_ARM_ABI
1506 /* If necessary set the H bit in the BLX instruction. */
1507 if (r_type == R_ARM_XPC25 && ((value & 2) == 2))
1508 value = (signed_addend & howto->dst_mask)
1509 | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask))
1510 | (1 << 24);
1511 else
1512 #endif
1513 value = (signed_addend & howto->dst_mask)
1514 | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask));
1515 break;
1516
1517 case R_ARM_ABS32:
1518 value += addend;
1519 if (sym_flags == STT_ARM_TFUNC)
1520 value |= 1;
1521 break;
1522
1523 case R_ARM_REL32:
1524 value -= (input_section->output_section->vma
1525 + input_section->output_offset + rel->r_offset);
1526 value += addend;
1527 break;
1528 }
1529
1530 bfd_put_32 (input_bfd, value, hit_data);
1531 return bfd_reloc_ok;
1532
1533 case R_ARM_ABS8:
1534 value += addend;
1535 if ((long) value > 0x7f || (long) value < -0x80)
1536 return bfd_reloc_overflow;
1537
1538 bfd_put_8 (input_bfd, value, hit_data);
1539 return bfd_reloc_ok;
1540
1541 case R_ARM_ABS16:
1542 value += addend;
1543
1544 if ((long) value > 0x7fff || (long) value < -0x8000)
1545 return bfd_reloc_overflow;
1546
1547 bfd_put_16 (input_bfd, value, hit_data);
1548 return bfd_reloc_ok;
1549
1550 case R_ARM_ABS12:
1551 /* Support ldr and str instruction for the arm */
1552 /* Also thumb b (unconditional branch). ??? Really? */
1553 value += addend;
1554
1555 if ((long) value > 0x7ff || (long) value < -0x800)
1556 return bfd_reloc_overflow;
1557
1558 value |= (bfd_get_32 (input_bfd, hit_data) & 0xfffff000);
1559 bfd_put_32 (input_bfd, value, hit_data);
1560 return bfd_reloc_ok;
1561
1562 case R_ARM_THM_ABS5:
1563 /* Support ldr and str instructions for the thumb. */
1564 #if USE_REL
1565 /* Need to refetch addend. */
1566 addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
1567 /* ??? Need to determine shift amount from operand size. */
1568 addend >>= howto->rightshift;
1569 #endif
1570 value += addend;
1571
1572 /* ??? Isn't value unsigned? */
1573 if ((long) value > 0x1f || (long) value < -0x10)
1574 return bfd_reloc_overflow;
1575
1576 /* ??? Value needs to be properly shifted into place first. */
1577 value |= bfd_get_16 (input_bfd, hit_data) & 0xf83f;
1578 bfd_put_16 (input_bfd, value, hit_data);
1579 return bfd_reloc_ok;
1580
1581 #ifndef OLD_ARM_ABI
1582 case R_ARM_THM_XPC22:
1583 #endif
1584 case R_ARM_THM_PC22:
1585 /* Thumb BL (branch long instruction). */
1586 {
1587 bfd_vma relocation;
1588 bfd_boolean overflow = FALSE;
1589 bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
1590 bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
1591 bfd_signed_vma reloc_signed_max = ((1 << (howto->bitsize - 1)) - 1) >> howto->rightshift;
1592 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
1593 bfd_vma check;
1594 bfd_signed_vma signed_check;
1595
1596 #if USE_REL
1597 /* Need to refetch the addend and squish the two 11 bit pieces
1598 together. */
1599 {
1600 bfd_vma upper = upper_insn & 0x7ff;
1601 bfd_vma lower = lower_insn & 0x7ff;
1602 upper = (upper ^ 0x400) - 0x400; /* Sign extend. */
1603 addend = (upper << 12) | (lower << 1);
1604 signed_addend = addend;
1605 }
1606 #endif
1607 #ifndef OLD_ARM_ABI
1608 if (r_type == R_ARM_THM_XPC22)
1609 {
1610 /* Check for Thumb to Thumb call. */
1611 /* FIXME: Should we translate the instruction into a BL
1612 instruction instead ? */
1613 if (sym_flags == STT_ARM_TFUNC)
1614 (*_bfd_error_handler) (_("\
1615 %s: Warning: Thumb BLX instruction targets thumb function '%s'."),
1616 bfd_archive_filename (input_bfd),
1617 h ? h->root.root.string : "(local)");
1618 }
1619 else
1620 #endif
1621 {
1622 /* If it is not a call to Thumb, assume call to Arm.
1623 If it is a call relative to a section name, then it is not a
1624 function call at all, but rather a long jump. */
1625 if (sym_flags != STT_ARM_TFUNC && sym_flags != STT_SECTION)
1626 {
1627 if (elf32_thumb_to_arm_stub
1628 (info, sym_name, input_bfd, output_bfd, input_section,
1629 hit_data, sym_sec, rel->r_offset, signed_addend, value))
1630 return bfd_reloc_ok;
1631 else
1632 return bfd_reloc_dangerous;
1633 }
1634 }
1635
1636 relocation = value + signed_addend;
1637
1638 relocation -= (input_section->output_section->vma
1639 + input_section->output_offset
1640 + rel->r_offset);
1641
1642 if (! globals->no_pipeline_knowledge)
1643 {
1644 Elf_Internal_Ehdr * i_ehdrp; /* Elf file header, internal form. */
1645
1646 i_ehdrp = elf_elfheader (input_bfd);
1647
1648 /* Previous versions of this code also used to add in the pipline
1649 offset here. This is wrong because the linker is not supposed
1650 to know about such things, and one day it might change. In order
1651 to support old binaries that need the old behaviour however, so
1652 we attempt to detect which ABI was used to create the reloc. */
1653 if ( strcmp (bfd_get_target (input_bfd), "elf32-littlearm-oabi") == 0
1654 || strcmp (bfd_get_target (input_bfd), "elf32-bigarm-oabi") == 0
1655 || i_ehdrp->e_ident[EI_OSABI] == 0)
1656 relocation += 4;
1657 }
1658
1659 check = relocation >> howto->rightshift;
1660
1661 /* If this is a signed value, the rightshift just dropped
1662 leading 1 bits (assuming twos complement). */
1663 if ((bfd_signed_vma) relocation >= 0)
1664 signed_check = check;
1665 else
1666 signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
1667
1668 /* Assumes two's complement. */
1669 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
1670 overflow = TRUE;
1671
1672 #ifndef OLD_ARM_ABI
1673 if (r_type == R_ARM_THM_XPC22
1674 && ((lower_insn & 0x1800) == 0x0800))
1675 /* For a BLX instruction, make sure that the relocation is rounded up
1676 to a word boundary. This follows the semantics of the instruction
1677 which specifies that bit 1 of the target address will come from bit
1678 1 of the base address. */
1679 relocation = (relocation + 2) & ~ 3;
1680 #endif
1681 /* Put RELOCATION back into the insn. */
1682 upper_insn = (upper_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 12) & 0x7ff);
1683 lower_insn = (lower_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 1) & 0x7ff);
1684
1685 /* Put the relocated value back in the object file: */
1686 bfd_put_16 (input_bfd, upper_insn, hit_data);
1687 bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
1688
1689 return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
1690 }
1691 break;
1692
1693 case R_ARM_THM_PC11:
1694 /* Thumb B (branch) instruction). */
1695 {
1696 bfd_signed_vma relocation;
1697 bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
1698 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
1699 bfd_signed_vma signed_check;
1700
1701 #if USE_REL
1702 /* Need to refetch addend. */
1703 addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
1704 if (addend & ((howto->src_mask + 1) >> 1))
1705 {
1706 signed_addend = -1;
1707 signed_addend &= ~ howto->src_mask;
1708 signed_addend |= addend;
1709 }
1710 else
1711 signed_addend = addend;
1712 /* The value in the insn has been right shifted. We need to
1713 undo this, so that we can perform the address calculation
1714 in terms of bytes. */
1715 signed_addend <<= howto->rightshift;
1716 #endif
1717 relocation = value + signed_addend;
1718
1719 relocation -= (input_section->output_section->vma
1720 + input_section->output_offset
1721 + rel->r_offset);
1722
1723 relocation >>= howto->rightshift;
1724 signed_check = relocation;
1725 relocation &= howto->dst_mask;
1726 relocation |= (bfd_get_16 (input_bfd, hit_data) & (~ howto->dst_mask));
1727
1728 bfd_put_16 (input_bfd, relocation, hit_data);
1729
1730 /* Assumes two's complement. */
1731 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
1732 return bfd_reloc_overflow;
1733
1734 return bfd_reloc_ok;
1735 }
1736
1737 case R_ARM_GNU_VTINHERIT:
1738 case R_ARM_GNU_VTENTRY:
1739 return bfd_reloc_ok;
1740
1741 case R_ARM_COPY:
1742 return bfd_reloc_notsupported;
1743
1744 case R_ARM_GLOB_DAT:
1745 return bfd_reloc_notsupported;
1746
1747 case R_ARM_JUMP_SLOT:
1748 return bfd_reloc_notsupported;
1749
1750 case R_ARM_RELATIVE:
1751 return bfd_reloc_notsupported;
1752
1753 case R_ARM_GOTOFF:
1754 /* Relocation is relative to the start of the
1755 global offset table. */
1756
1757 BFD_ASSERT (sgot != NULL);
1758 if (sgot == NULL)
1759 return bfd_reloc_notsupported;
1760
1761 /* If we are addressing a Thumb function, we need to adjust the
1762 address by one, so that attempts to call the function pointer will
1763 correctly interpret it as Thumb code. */
1764 if (sym_flags == STT_ARM_TFUNC)
1765 value += 1;
1766
1767 /* Note that sgot->output_offset is not involved in this
1768 calculation. We always want the start of .got. If we
1769 define _GLOBAL_OFFSET_TABLE in a different way, as is
1770 permitted by the ABI, we might have to change this
1771 calculation. */
1772 value -= sgot->output_section->vma;
1773 return _bfd_final_link_relocate (howto, input_bfd, input_section,
1774 contents, rel->r_offset, value,
1775 (bfd_vma) 0);
1776
1777 case R_ARM_GOTPC:
1778 /* Use global offset table as symbol value. */
1779 BFD_ASSERT (sgot != NULL);
1780
1781 if (sgot == NULL)
1782 return bfd_reloc_notsupported;
1783
1784 value = sgot->output_section->vma;
1785 return _bfd_final_link_relocate (howto, input_bfd, input_section,
1786 contents, rel->r_offset, value,
1787 (bfd_vma) 0);
1788
1789 case R_ARM_GOT32:
1790 /* Relocation is to the entry for this symbol in the
1791 global offset table. */
1792 if (sgot == NULL)
1793 return bfd_reloc_notsupported;
1794
1795 if (h != NULL)
1796 {
1797 bfd_vma off;
1798 bfd_boolean dyn;
1799
1800 off = h->got.offset;
1801 BFD_ASSERT (off != (bfd_vma) -1);
1802 dyn = globals->root.dynamic_sections_created;
1803
1804 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
1805 || (info->shared
1806 && SYMBOL_REFERENCES_LOCAL (info, h))
1807 || (ELF_ST_VISIBILITY (h->other)
1808 && h->root.type == bfd_link_hash_undefweak))
1809 {
1810 /* This is actually a static link, or it is a -Bsymbolic link
1811 and the symbol is defined locally. We must initialize this
1812 entry in the global offset table. Since the offset must
1813 always be a multiple of 4, we use the least significant bit
1814 to record whether we have initialized it already.
1815
1816 When doing a dynamic link, we create a .rel.got relocation
1817 entry to initialize the value. This is done in the
1818 finish_dynamic_symbol routine. */
1819 if ((off & 1) != 0)
1820 off &= ~1;
1821 else
1822 {
1823 /* If we are addressing a Thumb function, we need to
1824 adjust the address by one, so that attempts to
1825 call the function pointer will correctly
1826 interpret it as Thumb code. */
1827 if (sym_flags == STT_ARM_TFUNC)
1828 value |= 1;
1829
1830 bfd_put_32 (output_bfd, value, sgot->contents + off);
1831 h->got.offset |= 1;
1832 }
1833 }
1834
1835 value = sgot->output_offset + off;
1836 }
1837 else
1838 {
1839 bfd_vma off;
1840
1841 BFD_ASSERT (local_got_offsets != NULL &&
1842 local_got_offsets[r_symndx] != (bfd_vma) -1);
1843
1844 off = local_got_offsets[r_symndx];
1845
1846 /* The offset must always be a multiple of 4. We use the
1847 least significant bit to record whether we have already
1848 generated the necessary reloc. */
1849 if ((off & 1) != 0)
1850 off &= ~1;
1851 else
1852 {
1853 bfd_put_32 (output_bfd, value, sgot->contents + off);
1854
1855 if (info->shared)
1856 {
1857 asection * srelgot;
1858 Elf_Internal_Rela outrel;
1859 bfd_byte *loc;
1860
1861 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
1862 BFD_ASSERT (srelgot != NULL);
1863
1864 outrel.r_offset = (sgot->output_section->vma
1865 + sgot->output_offset
1866 + off);
1867 outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
1868 loc = srelgot->contents;
1869 loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
1870 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
1871 }
1872
1873 local_got_offsets[r_symndx] |= 1;
1874 }
1875
1876 value = sgot->output_offset + off;
1877 }
1878
1879 return _bfd_final_link_relocate (howto, input_bfd, input_section,
1880 contents, rel->r_offset, value,
1881 (bfd_vma) 0);
1882
1883 case R_ARM_SBREL32:
1884 return bfd_reloc_notsupported;
1885
1886 case R_ARM_AMP_VCALL9:
1887 return bfd_reloc_notsupported;
1888
1889 case R_ARM_RSBREL32:
1890 return bfd_reloc_notsupported;
1891
1892 case R_ARM_THM_RPC22:
1893 return bfd_reloc_notsupported;
1894
1895 case R_ARM_RREL32:
1896 return bfd_reloc_notsupported;
1897
1898 case R_ARM_RABS32:
1899 return bfd_reloc_notsupported;
1900
1901 case R_ARM_RPC24:
1902 return bfd_reloc_notsupported;
1903
1904 case R_ARM_RBASE:
1905 return bfd_reloc_notsupported;
1906
1907 default:
1908 return bfd_reloc_notsupported;
1909 }
1910 }
1911
1912 #if USE_REL
1913 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. */
1914 static void
arm_add_to_rel(abfd,address,howto,increment)1915 arm_add_to_rel (abfd, address, howto, increment)
1916 bfd * abfd;
1917 bfd_byte * address;
1918 reloc_howto_type * howto;
1919 bfd_signed_vma increment;
1920 {
1921 bfd_signed_vma addend;
1922
1923 if (howto->type == R_ARM_THM_PC22)
1924 {
1925 int upper_insn, lower_insn;
1926 int upper, lower;
1927
1928 upper_insn = bfd_get_16 (abfd, address);
1929 lower_insn = bfd_get_16 (abfd, address + 2);
1930 upper = upper_insn & 0x7ff;
1931 lower = lower_insn & 0x7ff;
1932
1933 addend = (upper << 12) | (lower << 1);
1934 addend += increment;
1935 addend >>= 1;
1936
1937 upper_insn = (upper_insn & 0xf800) | ((addend >> 11) & 0x7ff);
1938 lower_insn = (lower_insn & 0xf800) | (addend & 0x7ff);
1939
1940 bfd_put_16 (abfd, (bfd_vma) upper_insn, address);
1941 bfd_put_16 (abfd, (bfd_vma) lower_insn, address + 2);
1942 }
1943 else
1944 {
1945 bfd_vma contents;
1946
1947 contents = bfd_get_32 (abfd, address);
1948
1949 /* Get the (signed) value from the instruction. */
1950 addend = contents & howto->src_mask;
1951 if (addend & ((howto->src_mask + 1) >> 1))
1952 {
1953 bfd_signed_vma mask;
1954
1955 mask = -1;
1956 mask &= ~ howto->src_mask;
1957 addend |= mask;
1958 }
1959
1960 /* Add in the increment, (which is a byte value). */
1961 switch (howto->type)
1962 {
1963 default:
1964 addend += increment;
1965 break;
1966
1967 case R_ARM_PC24:
1968 addend <<= howto->size;
1969 addend += increment;
1970
1971 /* Should we check for overflow here ? */
1972
1973 /* Drop any undesired bits. */
1974 addend >>= howto->rightshift;
1975 break;
1976 }
1977
1978 contents = (contents & ~ howto->dst_mask) | (addend & howto->dst_mask);
1979
1980 bfd_put_32 (abfd, contents, address);
1981 }
1982 }
1983 #endif /* USE_REL */
1984
1985 /* Relocate an ARM ELF section. */
1986 static bfd_boolean
elf32_arm_relocate_section(output_bfd,info,input_bfd,input_section,contents,relocs,local_syms,local_sections)1987 elf32_arm_relocate_section (output_bfd, info, input_bfd, input_section,
1988 contents, relocs, local_syms, local_sections)
1989 bfd *output_bfd;
1990 struct bfd_link_info *info;
1991 bfd *input_bfd;
1992 asection *input_section;
1993 bfd_byte *contents;
1994 Elf_Internal_Rela *relocs;
1995 Elf_Internal_Sym *local_syms;
1996 asection **local_sections;
1997 {
1998 Elf_Internal_Shdr *symtab_hdr;
1999 struct elf_link_hash_entry **sym_hashes;
2000 Elf_Internal_Rela *rel;
2001 Elf_Internal_Rela *relend;
2002 const char *name;
2003
2004 #if !USE_REL
2005 if (info->relocatable)
2006 return TRUE;
2007 #endif
2008
2009 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
2010 sym_hashes = elf_sym_hashes (input_bfd);
2011
2012 rel = relocs;
2013 relend = relocs + input_section->reloc_count;
2014 for (; rel < relend; rel++)
2015 {
2016 int r_type;
2017 reloc_howto_type * howto;
2018 unsigned long r_symndx;
2019 Elf_Internal_Sym * sym;
2020 asection * sec;
2021 struct elf_link_hash_entry * h;
2022 bfd_vma relocation;
2023 bfd_reloc_status_type r;
2024 arelent bfd_reloc;
2025
2026 r_symndx = ELF32_R_SYM (rel->r_info);
2027 r_type = ELF32_R_TYPE (rel->r_info);
2028
2029 if ( r_type == R_ARM_GNU_VTENTRY
2030 || r_type == R_ARM_GNU_VTINHERIT)
2031 continue;
2032
2033 elf32_arm_info_to_howto (input_bfd, & bfd_reloc, rel);
2034 howto = bfd_reloc.howto;
2035
2036 #if USE_REL
2037 if (info->relocatable)
2038 {
2039 /* This is a relocatable link. We don't have to change
2040 anything, unless the reloc is against a section symbol,
2041 in which case we have to adjust according to where the
2042 section symbol winds up in the output section. */
2043 if (r_symndx < symtab_hdr->sh_info)
2044 {
2045 sym = local_syms + r_symndx;
2046 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2047 {
2048 sec = local_sections[r_symndx];
2049 arm_add_to_rel (input_bfd, contents + rel->r_offset,
2050 howto,
2051 (bfd_signed_vma) (sec->output_offset
2052 + sym->st_value));
2053 }
2054 }
2055
2056 continue;
2057 }
2058 #endif
2059
2060 /* This is a final link. */
2061 h = NULL;
2062 sym = NULL;
2063 sec = NULL;
2064
2065 if (r_symndx < symtab_hdr->sh_info)
2066 {
2067 sym = local_syms + r_symndx;
2068 sec = local_sections[r_symndx];
2069 #if USE_REL
2070 relocation = (sec->output_section->vma
2071 + sec->output_offset
2072 + sym->st_value);
2073 if ((sec->flags & SEC_MERGE)
2074 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2075 {
2076 asection *msec;
2077 bfd_vma addend, value;
2078
2079 if (howto->rightshift)
2080 {
2081 (*_bfd_error_handler)
2082 (_("%s(%s+0x%lx): %s relocation against SEC_MERGE section"),
2083 bfd_archive_filename (input_bfd),
2084 bfd_get_section_name (input_bfd, input_section),
2085 (long) rel->r_offset, howto->name);
2086 return FALSE;
2087 }
2088
2089 value = bfd_get_32 (input_bfd, contents + rel->r_offset);
2090
2091 /* Get the (signed) value from the instruction. */
2092 addend = value & howto->src_mask;
2093 if (addend & ((howto->src_mask + 1) >> 1))
2094 {
2095 bfd_signed_vma mask;
2096
2097 mask = -1;
2098 mask &= ~ howto->src_mask;
2099 addend |= mask;
2100 }
2101 msec = sec;
2102 addend =
2103 _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend)
2104 - relocation;
2105 addend += msec->output_section->vma + msec->output_offset;
2106 value = (value & ~ howto->dst_mask) | (addend & howto->dst_mask);
2107 bfd_put_32 (input_bfd, value, contents + rel->r_offset);
2108 }
2109 #else
2110 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2111 #endif
2112 }
2113 else
2114 {
2115 bfd_boolean warned;
2116 bfd_boolean unresolved_reloc;
2117
2118 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2119 r_symndx, symtab_hdr, sym_hashes,
2120 h, sec, relocation,
2121 unresolved_reloc, warned);
2122
2123 if (unresolved_reloc || relocation != 0)
2124 {
2125 /* In these cases, we don't need the relocation value.
2126 We check specially because in some obscure cases
2127 sec->output_section will be NULL. */
2128 switch (r_type)
2129 {
2130 case R_ARM_PC24:
2131 case R_ARM_ABS32:
2132 case R_ARM_THM_PC22:
2133 case R_ARM_PLT32:
2134
2135 if (info->shared
2136 && (
2137 (!info->symbolic && h->dynindx != -1)
2138 || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
2139 )
2140 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2141 && ((input_section->flags & SEC_ALLOC) != 0
2142 /* DWARF will emit R_ARM_ABS32 relocations in its
2143 sections against symbols defined externally
2144 in shared libraries. We can't do anything
2145 with them here. */
2146 || ((input_section->flags & SEC_DEBUGGING) != 0
2147 && (h->elf_link_hash_flags
2148 & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
2149 )
2150 relocation = 0;
2151 break;
2152
2153 case R_ARM_GOTPC:
2154 relocation = 0;
2155 break;
2156
2157 case R_ARM_GOT32:
2158 if ((WILL_CALL_FINISH_DYNAMIC_SYMBOL
2159 (elf_hash_table (info)->dynamic_sections_created,
2160 info->shared, h))
2161 && (!info->shared
2162 || (!info->symbolic && h->dynindx != -1)
2163 || (h->elf_link_hash_flags
2164 & ELF_LINK_HASH_DEF_REGULAR) == 0))
2165 relocation = 0;
2166 break;
2167
2168 default:
2169 if (unresolved_reloc)
2170 _bfd_error_handler
2171 (_("%s: warning: unresolvable relocation %d against symbol `%s' from %s section"),
2172 bfd_archive_filename (input_bfd),
2173 r_type,
2174 h->root.root.string,
2175 bfd_get_section_name (input_bfd, input_section));
2176 break;
2177 }
2178 }
2179 }
2180
2181 if (h != NULL)
2182 name = h->root.root.string;
2183 else
2184 {
2185 name = (bfd_elf_string_from_elf_section
2186 (input_bfd, symtab_hdr->sh_link, sym->st_name));
2187 if (name == NULL || *name == '\0')
2188 name = bfd_section_name (input_bfd, sec);
2189 }
2190
2191 r = elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
2192 input_section, contents, rel,
2193 relocation, info, sec, name,
2194 (h ? ELF_ST_TYPE (h->type) :
2195 ELF_ST_TYPE (sym->st_info)), h);
2196
2197 if (r != bfd_reloc_ok)
2198 {
2199 const char * msg = (const char *) 0;
2200
2201 switch (r)
2202 {
2203 case bfd_reloc_overflow:
2204 /* If the overflowing reloc was to an undefined symbol,
2205 we have already printed one error message and there
2206 is no point complaining again. */
2207 if ((! h ||
2208 h->root.type != bfd_link_hash_undefined)
2209 && (!((*info->callbacks->reloc_overflow)
2210 (info, name, howto->name, (bfd_vma) 0,
2211 input_bfd, input_section, rel->r_offset))))
2212 return FALSE;
2213 break;
2214
2215 case bfd_reloc_undefined:
2216 if (!((*info->callbacks->undefined_symbol)
2217 (info, name, input_bfd, input_section,
2218 rel->r_offset, TRUE)))
2219 return FALSE;
2220 break;
2221
2222 case bfd_reloc_outofrange:
2223 msg = _("internal error: out of range error");
2224 goto common_error;
2225
2226 case bfd_reloc_notsupported:
2227 msg = _("internal error: unsupported relocation error");
2228 goto common_error;
2229
2230 case bfd_reloc_dangerous:
2231 msg = _("internal error: dangerous error");
2232 goto common_error;
2233
2234 default:
2235 msg = _("internal error: unknown error");
2236 /* fall through */
2237
2238 common_error:
2239 if (!((*info->callbacks->warning)
2240 (info, msg, name, input_bfd, input_section,
2241 rel->r_offset)))
2242 return FALSE;
2243 break;
2244 }
2245 }
2246 }
2247
2248 return TRUE;
2249 }
2250
2251 /* Set the right machine number. */
2252
2253 static bfd_boolean
elf32_arm_object_p(abfd)2254 elf32_arm_object_p (abfd)
2255 bfd *abfd;
2256 {
2257 unsigned int mach;
2258
2259 mach = bfd_arm_get_mach_from_notes (abfd, ARM_NOTE_SECTION);
2260
2261 if (mach != bfd_mach_arm_unknown)
2262 bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
2263
2264 else if (elf_elfheader (abfd)->e_flags & EF_ARM_MAVERICK_FLOAT)
2265 bfd_default_set_arch_mach (abfd, bfd_arch_arm, bfd_mach_arm_ep9312);
2266
2267 else
2268 bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
2269
2270 return TRUE;
2271 }
2272
2273 /* Function to keep ARM specific flags in the ELF header. */
2274 static bfd_boolean
elf32_arm_set_private_flags(abfd,flags)2275 elf32_arm_set_private_flags (abfd, flags)
2276 bfd *abfd;
2277 flagword flags;
2278 {
2279 if (elf_flags_init (abfd)
2280 && elf_elfheader (abfd)->e_flags != flags)
2281 {
2282 if (EF_ARM_EABI_VERSION (flags) == EF_ARM_EABI_UNKNOWN)
2283 {
2284 if (flags & EF_ARM_INTERWORK)
2285 (*_bfd_error_handler) (_("\
2286 Warning: Not setting interworking flag of %s since it has already been specified as non-interworking"),
2287 bfd_archive_filename (abfd));
2288 else
2289 _bfd_error_handler (_("\
2290 Warning: Clearing the interworking flag of %s due to outside request"),
2291 bfd_archive_filename (abfd));
2292 }
2293 }
2294 else
2295 {
2296 elf_elfheader (abfd)->e_flags = flags;
2297 elf_flags_init (abfd) = TRUE;
2298 }
2299
2300 return TRUE;
2301 }
2302
2303 /* Copy backend specific data from one object module to another. */
2304
2305 static bfd_boolean
elf32_arm_copy_private_bfd_data(ibfd,obfd)2306 elf32_arm_copy_private_bfd_data (ibfd, obfd)
2307 bfd *ibfd;
2308 bfd *obfd;
2309 {
2310 flagword in_flags;
2311 flagword out_flags;
2312
2313 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2314 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2315 return TRUE;
2316
2317 in_flags = elf_elfheader (ibfd)->e_flags;
2318 out_flags = elf_elfheader (obfd)->e_flags;
2319
2320 if (elf_flags_init (obfd)
2321 && EF_ARM_EABI_VERSION (out_flags) == EF_ARM_EABI_UNKNOWN
2322 && in_flags != out_flags)
2323 {
2324 /* Cannot mix APCS26 and APCS32 code. */
2325 if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
2326 return FALSE;
2327
2328 /* Cannot mix float APCS and non-float APCS code. */
2329 if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
2330 return FALSE;
2331
2332 /* If the src and dest have different interworking flags
2333 then turn off the interworking bit. */
2334 if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
2335 {
2336 if (out_flags & EF_ARM_INTERWORK)
2337 _bfd_error_handler (_("\
2338 Warning: Clearing the interworking flag of %s because non-interworking code in %s has been linked with it"),
2339 bfd_get_filename (obfd),
2340 bfd_archive_filename (ibfd));
2341
2342 in_flags &= ~EF_ARM_INTERWORK;
2343 }
2344
2345 /* Likewise for PIC, though don't warn for this case. */
2346 if ((in_flags & EF_ARM_PIC) != (out_flags & EF_ARM_PIC))
2347 in_flags &= ~EF_ARM_PIC;
2348 }
2349
2350 elf_elfheader (obfd)->e_flags = in_flags;
2351 elf_flags_init (obfd) = TRUE;
2352
2353 return TRUE;
2354 }
2355
2356 /* Merge backend specific data from an object file to the output
2357 object file when linking. */
2358
2359 static bfd_boolean
elf32_arm_merge_private_bfd_data(ibfd,obfd)2360 elf32_arm_merge_private_bfd_data (ibfd, obfd)
2361 bfd * ibfd;
2362 bfd * obfd;
2363 {
2364 flagword out_flags;
2365 flagword in_flags;
2366 bfd_boolean flags_compatible = TRUE;
2367 asection *sec;
2368
2369 /* Check if we have the same endianess. */
2370 if (! _bfd_generic_verify_endian_match (ibfd, obfd))
2371 return FALSE;
2372
2373 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2374 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2375 return TRUE;
2376
2377 /* The input BFD must have had its flags initialised. */
2378 /* The following seems bogus to me -- The flags are initialized in
2379 the assembler but I don't think an elf_flags_init field is
2380 written into the object. */
2381 /* BFD_ASSERT (elf_flags_init (ibfd)); */
2382
2383 in_flags = elf_elfheader (ibfd)->e_flags;
2384 out_flags = elf_elfheader (obfd)->e_flags;
2385
2386 if (!elf_flags_init (obfd))
2387 {
2388 /* If the input is the default architecture and had the default
2389 flags then do not bother setting the flags for the output
2390 architecture, instead allow future merges to do this. If no
2391 future merges ever set these flags then they will retain their
2392 uninitialised values, which surprise surprise, correspond
2393 to the default values. */
2394 if (bfd_get_arch_info (ibfd)->the_default
2395 && elf_elfheader (ibfd)->e_flags == 0)
2396 return TRUE;
2397
2398 elf_flags_init (obfd) = TRUE;
2399 elf_elfheader (obfd)->e_flags = in_flags;
2400
2401 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
2402 && bfd_get_arch_info (obfd)->the_default)
2403 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
2404
2405 return TRUE;
2406 }
2407
2408 /* Determine what should happen if the input ARM architecture
2409 does not match the output ARM architecture. */
2410 if (! bfd_arm_merge_machines (ibfd, obfd))
2411 return FALSE;
2412
2413 /* Identical flags must be compatible. */
2414 if (in_flags == out_flags)
2415 return TRUE;
2416
2417 /* Check to see if the input BFD actually contains any sections. If
2418 not, its flags may not have been initialised either, but it
2419 cannot actually cause any incompatibility. Do not short-circuit
2420 dynamic objects; their section list may be emptied by
2421 elf_link_add_object_symbols.
2422
2423 Also check to see if there are no code sections in the input.
2424 In this case there is no need to check for code specific flags.
2425 XXX - do we need to worry about floating-point format compatability
2426 in data sections ? */
2427 if (!(ibfd->flags & DYNAMIC))
2428 {
2429 bfd_boolean null_input_bfd = TRUE;
2430 bfd_boolean only_data_sections = TRUE;
2431
2432 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
2433 {
2434 /* Ignore synthetic glue sections. */
2435 if (strcmp (sec->name, ".glue_7")
2436 && strcmp (sec->name, ".glue_7t"))
2437 {
2438 if ((bfd_get_section_flags (ibfd, sec)
2439 & (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
2440 == (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
2441 only_data_sections = FALSE;
2442
2443 null_input_bfd = FALSE;
2444 break;
2445 }
2446 }
2447
2448 if (null_input_bfd || only_data_sections)
2449 return TRUE;
2450 }
2451
2452 /* Complain about various flag mismatches. */
2453 if (EF_ARM_EABI_VERSION (in_flags) != EF_ARM_EABI_VERSION (out_flags))
2454 {
2455 _bfd_error_handler (_("\
2456 ERROR: %s is compiled for EABI version %d, whereas %s is compiled for version %d"),
2457 bfd_archive_filename (ibfd),
2458 (in_flags & EF_ARM_EABIMASK) >> 24,
2459 bfd_get_filename (obfd),
2460 (out_flags & EF_ARM_EABIMASK) >> 24);
2461 return FALSE;
2462 }
2463
2464 /* Not sure what needs to be checked for EABI versions >= 1. */
2465 if (EF_ARM_EABI_VERSION (in_flags) == EF_ARM_EABI_UNKNOWN)
2466 {
2467 if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
2468 {
2469 _bfd_error_handler (_("\
2470 ERROR: %s is compiled for APCS-%d, whereas target %s uses APCS-%d"),
2471 bfd_archive_filename (ibfd),
2472 in_flags & EF_ARM_APCS_26 ? 26 : 32,
2473 bfd_get_filename (obfd),
2474 out_flags & EF_ARM_APCS_26 ? 26 : 32);
2475 flags_compatible = FALSE;
2476 }
2477
2478 if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
2479 {
2480 if (in_flags & EF_ARM_APCS_FLOAT)
2481 _bfd_error_handler (_("\
2482 ERROR: %s passes floats in float registers, whereas %s passes them in integer registers"),
2483 bfd_archive_filename (ibfd),
2484 bfd_get_filename (obfd));
2485 else
2486 _bfd_error_handler (_("\
2487 ERROR: %s passes floats in integer registers, whereas %s passes them in float registers"),
2488 bfd_archive_filename (ibfd),
2489 bfd_get_filename (obfd));
2490
2491 flags_compatible = FALSE;
2492 }
2493
2494 if ((in_flags & EF_ARM_VFP_FLOAT) != (out_flags & EF_ARM_VFP_FLOAT))
2495 {
2496 if (in_flags & EF_ARM_VFP_FLOAT)
2497 _bfd_error_handler (_("\
2498 ERROR: %s uses VFP instructions, whereas %s does not"),
2499 bfd_archive_filename (ibfd),
2500 bfd_get_filename (obfd));
2501 else
2502 _bfd_error_handler (_("\
2503 ERROR: %s uses FPA instructions, whereas %s does not"),
2504 bfd_archive_filename (ibfd),
2505 bfd_get_filename (obfd));
2506
2507 flags_compatible = FALSE;
2508 }
2509
2510 if ((in_flags & EF_ARM_MAVERICK_FLOAT) != (out_flags & EF_ARM_MAVERICK_FLOAT))
2511 {
2512 if (in_flags & EF_ARM_MAVERICK_FLOAT)
2513 _bfd_error_handler (_("\
2514 ERROR: %s uses Maverick instructions, whereas %s does not"),
2515 bfd_archive_filename (ibfd),
2516 bfd_get_filename (obfd));
2517 else
2518 _bfd_error_handler (_("\
2519 ERROR: %s does not use Maverick instructions, whereas %s does"),
2520 bfd_archive_filename (ibfd),
2521 bfd_get_filename (obfd));
2522
2523 flags_compatible = FALSE;
2524 }
2525
2526 #ifdef EF_ARM_SOFT_FLOAT
2527 if ((in_flags & EF_ARM_SOFT_FLOAT) != (out_flags & EF_ARM_SOFT_FLOAT))
2528 {
2529 /* We can allow interworking between code that is VFP format
2530 layout, and uses either soft float or integer regs for
2531 passing floating point arguments and results. We already
2532 know that the APCS_FLOAT flags match; similarly for VFP
2533 flags. */
2534 if ((in_flags & EF_ARM_APCS_FLOAT) != 0
2535 || (in_flags & EF_ARM_VFP_FLOAT) == 0)
2536 {
2537 if (in_flags & EF_ARM_SOFT_FLOAT)
2538 _bfd_error_handler (_("\
2539 ERROR: %s uses software FP, whereas %s uses hardware FP"),
2540 bfd_archive_filename (ibfd),
2541 bfd_get_filename (obfd));
2542 else
2543 _bfd_error_handler (_("\
2544 ERROR: %s uses hardware FP, whereas %s uses software FP"),
2545 bfd_archive_filename (ibfd),
2546 bfd_get_filename (obfd));
2547
2548 flags_compatible = FALSE;
2549 }
2550 }
2551 #endif
2552
2553 /* Interworking mismatch is only a warning. */
2554 if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
2555 {
2556 if (in_flags & EF_ARM_INTERWORK)
2557 {
2558 _bfd_error_handler (_("\
2559 Warning: %s supports interworking, whereas %s does not"),
2560 bfd_archive_filename (ibfd),
2561 bfd_get_filename (obfd));
2562 }
2563 else
2564 {
2565 _bfd_error_handler (_("\
2566 Warning: %s does not support interworking, whereas %s does"),
2567 bfd_archive_filename (ibfd),
2568 bfd_get_filename (obfd));
2569 }
2570 }
2571 }
2572
2573 return flags_compatible;
2574 }
2575
2576 /* Display the flags field. */
2577
2578 static bfd_boolean
elf32_arm_print_private_bfd_data(abfd,ptr)2579 elf32_arm_print_private_bfd_data (abfd, ptr)
2580 bfd *abfd;
2581 PTR ptr;
2582 {
2583 FILE * file = (FILE *) ptr;
2584 unsigned long flags;
2585
2586 BFD_ASSERT (abfd != NULL && ptr != NULL);
2587
2588 /* Print normal ELF private data. */
2589 _bfd_elf_print_private_bfd_data (abfd, ptr);
2590
2591 flags = elf_elfheader (abfd)->e_flags;
2592 /* Ignore init flag - it may not be set, despite the flags field
2593 containing valid data. */
2594
2595 /* xgettext:c-format */
2596 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
2597
2598 switch (EF_ARM_EABI_VERSION (flags))
2599 {
2600 case EF_ARM_EABI_UNKNOWN:
2601 /* The following flag bits are GNU extensions and not part of the
2602 official ARM ELF extended ABI. Hence they are only decoded if
2603 the EABI version is not set. */
2604 if (flags & EF_ARM_INTERWORK)
2605 fprintf (file, _(" [interworking enabled]"));
2606
2607 if (flags & EF_ARM_APCS_26)
2608 fprintf (file, " [APCS-26]");
2609 else
2610 fprintf (file, " [APCS-32]");
2611
2612 if (flags & EF_ARM_VFP_FLOAT)
2613 fprintf (file, _(" [VFP float format]"));
2614 else if (flags & EF_ARM_MAVERICK_FLOAT)
2615 fprintf (file, _(" [Maverick float format]"));
2616 else
2617 fprintf (file, _(" [FPA float format]"));
2618
2619 if (flags & EF_ARM_APCS_FLOAT)
2620 fprintf (file, _(" [floats passed in float registers]"));
2621
2622 if (flags & EF_ARM_PIC)
2623 fprintf (file, _(" [position independent]"));
2624
2625 if (flags & EF_ARM_NEW_ABI)
2626 fprintf (file, _(" [new ABI]"));
2627
2628 if (flags & EF_ARM_OLD_ABI)
2629 fprintf (file, _(" [old ABI]"));
2630
2631 if (flags & EF_ARM_SOFT_FLOAT)
2632 fprintf (file, _(" [software FP]"));
2633
2634 flags &= ~(EF_ARM_INTERWORK | EF_ARM_APCS_26 | EF_ARM_APCS_FLOAT
2635 | EF_ARM_PIC | EF_ARM_NEW_ABI | EF_ARM_OLD_ABI
2636 | EF_ARM_SOFT_FLOAT | EF_ARM_VFP_FLOAT
2637 | EF_ARM_MAVERICK_FLOAT);
2638 break;
2639
2640 case EF_ARM_EABI_VER1:
2641 fprintf (file, _(" [Version1 EABI]"));
2642
2643 if (flags & EF_ARM_SYMSARESORTED)
2644 fprintf (file, _(" [sorted symbol table]"));
2645 else
2646 fprintf (file, _(" [unsorted symbol table]"));
2647
2648 flags &= ~ EF_ARM_SYMSARESORTED;
2649 break;
2650
2651 case EF_ARM_EABI_VER2:
2652 fprintf (file, _(" [Version2 EABI]"));
2653
2654 if (flags & EF_ARM_SYMSARESORTED)
2655 fprintf (file, _(" [sorted symbol table]"));
2656 else
2657 fprintf (file, _(" [unsorted symbol table]"));
2658
2659 if (flags & EF_ARM_DYNSYMSUSESEGIDX)
2660 fprintf (file, _(" [dynamic symbols use segment index]"));
2661
2662 if (flags & EF_ARM_MAPSYMSFIRST)
2663 fprintf (file, _(" [mapping symbols precede others]"));
2664
2665 flags &= ~(EF_ARM_SYMSARESORTED | EF_ARM_DYNSYMSUSESEGIDX
2666 | EF_ARM_MAPSYMSFIRST);
2667 break;
2668
2669 default:
2670 fprintf (file, _(" <EABI version unrecognised>"));
2671 break;
2672 }
2673
2674 flags &= ~ EF_ARM_EABIMASK;
2675
2676 if (flags & EF_ARM_RELEXEC)
2677 fprintf (file, _(" [relocatable executable]"));
2678
2679 if (flags & EF_ARM_HASENTRY)
2680 fprintf (file, _(" [has entry point]"));
2681
2682 flags &= ~ (EF_ARM_RELEXEC | EF_ARM_HASENTRY);
2683
2684 if (flags)
2685 fprintf (file, _("<Unrecognised flag bits set>"));
2686
2687 fputc ('\n', file);
2688
2689 return TRUE;
2690 }
2691
2692 static int
elf32_arm_get_symbol_type(elf_sym,type)2693 elf32_arm_get_symbol_type (elf_sym, type)
2694 Elf_Internal_Sym * elf_sym;
2695 int type;
2696 {
2697 switch (ELF_ST_TYPE (elf_sym->st_info))
2698 {
2699 case STT_ARM_TFUNC:
2700 return ELF_ST_TYPE (elf_sym->st_info);
2701
2702 case STT_ARM_16BIT:
2703 /* If the symbol is not an object, return the STT_ARM_16BIT flag.
2704 This allows us to distinguish between data used by Thumb instructions
2705 and non-data (which is probably code) inside Thumb regions of an
2706 executable. */
2707 if (type != STT_OBJECT)
2708 return ELF_ST_TYPE (elf_sym->st_info);
2709 break;
2710
2711 default:
2712 break;
2713 }
2714
2715 return type;
2716 }
2717
2718 static asection *
elf32_arm_gc_mark_hook(sec,info,rel,h,sym)2719 elf32_arm_gc_mark_hook (sec, info, rel, h, sym)
2720 asection *sec;
2721 struct bfd_link_info *info ATTRIBUTE_UNUSED;
2722 Elf_Internal_Rela *rel;
2723 struct elf_link_hash_entry *h;
2724 Elf_Internal_Sym *sym;
2725 {
2726 if (h != NULL)
2727 {
2728 switch (ELF32_R_TYPE (rel->r_info))
2729 {
2730 case R_ARM_GNU_VTINHERIT:
2731 case R_ARM_GNU_VTENTRY:
2732 break;
2733
2734 default:
2735 switch (h->root.type)
2736 {
2737 case bfd_link_hash_defined:
2738 case bfd_link_hash_defweak:
2739 return h->root.u.def.section;
2740
2741 case bfd_link_hash_common:
2742 return h->root.u.c.p->section;
2743
2744 default:
2745 break;
2746 }
2747 }
2748 }
2749 else
2750 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
2751
2752 return NULL;
2753 }
2754
2755 /* Update the got entry reference counts for the section being removed. */
2756
2757 static bfd_boolean
elf32_arm_gc_sweep_hook(abfd,info,sec,relocs)2758 elf32_arm_gc_sweep_hook (abfd, info, sec, relocs)
2759 bfd *abfd ATTRIBUTE_UNUSED;
2760 struct bfd_link_info *info ATTRIBUTE_UNUSED;
2761 asection *sec ATTRIBUTE_UNUSED;
2762 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
2763 {
2764 Elf_Internal_Shdr *symtab_hdr;
2765 struct elf_link_hash_entry **sym_hashes;
2766 bfd_signed_vma *local_got_refcounts;
2767 const Elf_Internal_Rela *rel, *relend;
2768 unsigned long r_symndx;
2769 struct elf_link_hash_entry *h;
2770
2771 elf_section_data (sec)->local_dynrel = NULL;
2772
2773 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2774 sym_hashes = elf_sym_hashes (abfd);
2775 local_got_refcounts = elf_local_got_refcounts (abfd);
2776
2777 relend = relocs + sec->reloc_count;
2778 for (rel = relocs; rel < relend; rel++)
2779 switch (ELF32_R_TYPE (rel->r_info))
2780 {
2781 case R_ARM_GOT32:
2782 r_symndx = ELF32_R_SYM (rel->r_info);
2783 if (r_symndx >= symtab_hdr->sh_info)
2784 {
2785 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2786 if (h->got.refcount > 0)
2787 h->got.refcount -= 1;
2788 }
2789 else if (local_got_refcounts != NULL)
2790 {
2791 if (local_got_refcounts[r_symndx] > 0)
2792 local_got_refcounts[r_symndx] -= 1;
2793 }
2794 break;
2795
2796 case R_ARM_ABS32:
2797 case R_ARM_REL32:
2798 case R_ARM_PC24:
2799 case R_ARM_PLT32:
2800 r_symndx = ELF32_R_SYM (rel->r_info);
2801 if (r_symndx >= symtab_hdr->sh_info)
2802 {
2803 struct elf32_arm_link_hash_entry *eh;
2804 struct elf32_arm_relocs_copied **pp;
2805 struct elf32_arm_relocs_copied *p;
2806
2807 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2808
2809 if (h->plt.refcount > 0)
2810 h->plt.refcount -= 1;
2811
2812 if (ELF32_R_TYPE (rel->r_info) == R_ARM_ABS32
2813 || ELF32_R_TYPE (rel->r_info) == R_ARM_REL32)
2814 {
2815 eh = (struct elf32_arm_link_hash_entry *) h;
2816
2817 for (pp = &eh->relocs_copied; (p = *pp) != NULL;
2818 pp = &p->next)
2819 if (p->section == sec)
2820 {
2821 p->count -= 1;
2822 if (p->count == 0)
2823 *pp = p->next;
2824 break;
2825 }
2826 }
2827 }
2828 break;
2829
2830 default:
2831 break;
2832 }
2833
2834 return TRUE;
2835 }
2836
2837 /* Look through the relocs for a section during the first phase. */
2838
2839 static bfd_boolean
elf32_arm_check_relocs(abfd,info,sec,relocs)2840 elf32_arm_check_relocs (abfd, info, sec, relocs)
2841 bfd *abfd;
2842 struct bfd_link_info *info;
2843 asection *sec;
2844 const Elf_Internal_Rela *relocs;
2845 {
2846 Elf_Internal_Shdr *symtab_hdr;
2847 struct elf_link_hash_entry **sym_hashes;
2848 struct elf_link_hash_entry **sym_hashes_end;
2849 const Elf_Internal_Rela *rel;
2850 const Elf_Internal_Rela *rel_end;
2851 bfd *dynobj;
2852 asection *sreloc;
2853 bfd_vma *local_got_offsets;
2854 struct elf32_arm_link_hash_table *htab;
2855
2856 if (info->relocatable)
2857 return TRUE;
2858
2859 htab = elf32_arm_hash_table (info);
2860 sreloc = NULL;
2861
2862 dynobj = elf_hash_table (info)->dynobj;
2863 local_got_offsets = elf_local_got_offsets (abfd);
2864
2865 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2866 sym_hashes = elf_sym_hashes (abfd);
2867 sym_hashes_end = sym_hashes
2868 + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
2869
2870 if (!elf_bad_symtab (abfd))
2871 sym_hashes_end -= symtab_hdr->sh_info;
2872
2873 rel_end = relocs + sec->reloc_count;
2874 for (rel = relocs; rel < rel_end; rel++)
2875 {
2876 struct elf_link_hash_entry *h;
2877 unsigned long r_symndx;
2878
2879 r_symndx = ELF32_R_SYM (rel->r_info);
2880 if (r_symndx < symtab_hdr->sh_info)
2881 h = NULL;
2882 else
2883 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2884
2885 switch (ELF32_R_TYPE (rel->r_info))
2886 {
2887 case R_ARM_GOT32:
2888 /* This symbol requires a global offset table entry. */
2889 if (h != NULL)
2890 {
2891 h->got.refcount++;
2892 }
2893 else
2894 {
2895 bfd_signed_vma *local_got_refcounts;
2896
2897 /* This is a global offset table entry for a local symbol. */
2898 local_got_refcounts = elf_local_got_refcounts (abfd);
2899 if (local_got_refcounts == NULL)
2900 {
2901 bfd_size_type size;
2902
2903 size = symtab_hdr->sh_info;
2904 size *= (sizeof (bfd_signed_vma) + sizeof(char));
2905 local_got_refcounts = ((bfd_signed_vma *)
2906 bfd_zalloc (abfd, size));
2907 if (local_got_refcounts == NULL)
2908 return FALSE;
2909 elf_local_got_refcounts (abfd) = local_got_refcounts;
2910 }
2911 local_got_refcounts[r_symndx] += 1;
2912 }
2913 break;
2914
2915 case R_ARM_GOTOFF:
2916 case R_ARM_GOTPC:
2917 if (htab->sgot == NULL)
2918 {
2919 if (htab->root.dynobj == NULL)
2920 htab->root.dynobj = abfd;
2921 if (!create_got_section (htab->root.dynobj, info))
2922 return FALSE;
2923 }
2924 break;
2925
2926 case R_ARM_ABS32:
2927 case R_ARM_REL32:
2928 case R_ARM_PC24:
2929 case R_ARM_PLT32:
2930 if (h != NULL)
2931 {
2932 /* If this reloc is in a read-only section, we might
2933 need a copy reloc. We can't check reliably at this
2934 stage whether the section is read-only, as input
2935 sections have not yet been mapped to output sections.
2936 Tentatively set the flag for now, and correct in
2937 adjust_dynamic_symbol. */
2938 if (!info->shared)
2939 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
2940
2941 /* We may need a .plt entry if the function this reloc
2942 refers to is in a different object. We can't tell for
2943 sure yet, because something later might force the
2944 symbol local. */
2945 if (ELF32_R_TYPE (rel->r_info) == R_ARM_PC24
2946 || ELF32_R_TYPE (rel->r_info) == R_ARM_PLT32)
2947 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2948
2949 /* If we create a PLT entry, this relocation will reference
2950 it, even if it's an ABS32 relocation. */
2951 h->plt.refcount += 1;
2952 }
2953
2954 /* If we are creating a shared library, and this is a reloc
2955 against a global symbol, or a non PC relative reloc
2956 against a local symbol, then we need to copy the reloc
2957 into the shared library. However, if we are linking with
2958 -Bsymbolic, we do not need to copy a reloc against a
2959 global symbol which is defined in an object we are
2960 including in the link (i.e., DEF_REGULAR is set). At
2961 this point we have not seen all the input files, so it is
2962 possible that DEF_REGULAR is not set now but will be set
2963 later (it is never cleared). We account for that
2964 possibility below by storing information in the
2965 relocs_copied field of the hash table entry. */
2966 if (info->shared
2967 && (sec->flags & SEC_ALLOC) != 0
2968 && ((ELF32_R_TYPE (rel->r_info) != R_ARM_PC24
2969 && ELF32_R_TYPE (rel->r_info) != R_ARM_PLT32
2970 && ELF32_R_TYPE (rel->r_info) != R_ARM_REL32)
2971 || (h != NULL
2972 && (! info->symbolic
2973 || (h->elf_link_hash_flags
2974 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
2975 {
2976 struct elf32_arm_relocs_copied *p, **head;
2977
2978 /* When creating a shared object, we must copy these
2979 reloc types into the output file. We create a reloc
2980 section in dynobj and make room for this reloc. */
2981 if (sreloc == NULL)
2982 {
2983 const char * name;
2984
2985 name = (bfd_elf_string_from_elf_section
2986 (abfd,
2987 elf_elfheader (abfd)->e_shstrndx,
2988 elf_section_data (sec)->rel_hdr.sh_name));
2989 if (name == NULL)
2990 return FALSE;
2991
2992 BFD_ASSERT (strncmp (name, ".rel", 4) == 0
2993 && strcmp (bfd_get_section_name (abfd, sec),
2994 name + 4) == 0);
2995
2996 sreloc = bfd_get_section_by_name (dynobj, name);
2997 if (sreloc == NULL)
2998 {
2999 flagword flags;
3000
3001 sreloc = bfd_make_section (dynobj, name);
3002 flags = (SEC_HAS_CONTENTS | SEC_READONLY
3003 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3004 if ((sec->flags & SEC_ALLOC) != 0)
3005 flags |= SEC_ALLOC | SEC_LOAD;
3006 if (sreloc == NULL
3007 || ! bfd_set_section_flags (dynobj, sreloc, flags)
3008 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
3009 return FALSE;
3010 }
3011
3012 elf_section_data (sec)->sreloc = sreloc;
3013 }
3014
3015 /* If this is a global symbol, we count the number of
3016 relocations we need for this symbol. */
3017 if (h != NULL)
3018 {
3019 head = &((struct elf32_arm_link_hash_entry *) h)->relocs_copied;
3020 }
3021 else
3022 {
3023 /* Track dynamic relocs needed for local syms too.
3024 We really need local syms available to do this
3025 easily. Oh well. */
3026
3027 asection *s;
3028 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
3029 sec, r_symndx);
3030 if (s == NULL)
3031 return FALSE;
3032
3033 head = ((struct elf32_arm_relocs_copied **)
3034 &elf_section_data (s)->local_dynrel);
3035 }
3036
3037 p = *head;
3038 if (p == NULL || p->section != sec)
3039 {
3040 bfd_size_type amt = sizeof *p;
3041 p = bfd_alloc (htab->root.dynobj, amt);
3042 if (p == NULL)
3043 return FALSE;
3044 p->next = *head;
3045 *head = p;
3046 p->section = sec;
3047 p->count = 0;
3048 }
3049
3050 if (ELF32_R_TYPE (rel->r_info) == R_ARM_ABS32
3051 || ELF32_R_TYPE (rel->r_info) == R_ARM_REL32)
3052 p->count += 1;
3053 }
3054 break;
3055
3056 /* This relocation describes the C++ object vtable hierarchy.
3057 Reconstruct it for later use during GC. */
3058 case R_ARM_GNU_VTINHERIT:
3059 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
3060 return FALSE;
3061 break;
3062
3063 /* This relocation describes which C++ vtable entries are actually
3064 used. Record for later use during GC. */
3065 case R_ARM_GNU_VTENTRY:
3066 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
3067 return FALSE;
3068 break;
3069 }
3070 }
3071
3072 return TRUE;
3073 }
3074
3075 /* Find the nearest line to a particular section and offset, for error
3076 reporting. This code is a duplicate of the code in elf.c, except
3077 that it also accepts STT_ARM_TFUNC as a symbol that names a function. */
3078
3079 static bfd_boolean
elf32_arm_find_nearest_line(abfd,section,symbols,offset,filename_ptr,functionname_ptr,line_ptr)3080 elf32_arm_find_nearest_line
3081 (abfd, section, symbols, offset, filename_ptr, functionname_ptr, line_ptr)
3082 bfd *abfd;
3083 asection *section;
3084 asymbol **symbols;
3085 bfd_vma offset;
3086 const char **filename_ptr;
3087 const char **functionname_ptr;
3088 unsigned int *line_ptr;
3089 {
3090 bfd_boolean found;
3091 const char *filename;
3092 asymbol *func;
3093 bfd_vma low_func;
3094 asymbol **p;
3095 int binding;
3096
3097 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
3098 filename_ptr, functionname_ptr,
3099 line_ptr, 0,
3100 &elf_tdata (abfd)->dwarf2_find_line_info))
3101 return TRUE;
3102
3103 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
3104 &found, filename_ptr,
3105 functionname_ptr, line_ptr,
3106 &elf_tdata (abfd)->line_info))
3107 return FALSE;
3108
3109 if (found)
3110 return TRUE;
3111
3112 if (symbols == NULL)
3113 return FALSE;
3114
3115 filename = NULL;
3116 func = NULL;
3117 low_func = 0;
3118 binding = -1;
3119
3120 for (p = symbols; *p != NULL; p++)
3121 {
3122 elf_symbol_type *q;
3123
3124 q = (elf_symbol_type *) *p;
3125
3126 if (bfd_get_section (&q->symbol) != section)
3127 continue;
3128
3129 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
3130 {
3131 default:
3132 break;
3133 case STT_FILE:
3134 filename = bfd_asymbol_name (&q->symbol);
3135 break;
3136 case STT_NOTYPE:
3137 case STT_FUNC:
3138 case STT_ARM_TFUNC:
3139 if (q->symbol.section == section
3140 && q->symbol.value >= low_func
3141 && q->symbol.value <= offset)
3142 {
3143 /* Prefer a global symbol rather than $a/$d/$t local symbols */
3144 if (ELF_ST_BIND (q->internal_elf_sym.st_info) != STB_LOCAL
3145 || binding == -1)
3146 {
3147 func = (asymbol *) q;
3148 low_func = q->symbol.value;
3149 binding = ELF_ST_BIND (q->internal_elf_sym.st_info);
3150 }
3151 }
3152 break;
3153 }
3154 }
3155
3156 if (func == NULL)
3157 return FALSE;
3158
3159 *filename_ptr = filename;
3160 *functionname_ptr = bfd_asymbol_name (func);
3161 *line_ptr = 0;
3162
3163 return TRUE;
3164 }
3165
3166 /* Adjust a symbol defined by a dynamic object and referenced by a
3167 regular object. The current definition is in some section of the
3168 dynamic object, but we're not including those sections. We have to
3169 change the definition to something the rest of the link can
3170 understand. */
3171
3172 static bfd_boolean
elf32_arm_adjust_dynamic_symbol(info,h)3173 elf32_arm_adjust_dynamic_symbol (info, h)
3174 struct bfd_link_info * info;
3175 struct elf_link_hash_entry * h;
3176 {
3177 bfd * dynobj;
3178 asection * s;
3179 unsigned int power_of_two;
3180
3181 dynobj = elf_hash_table (info)->dynobj;
3182
3183 /* Make sure we know what is going on here. */
3184 BFD_ASSERT (dynobj != NULL
3185 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
3186 || h->weakdef != NULL
3187 || ((h->elf_link_hash_flags
3188 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
3189 && (h->elf_link_hash_flags
3190 & ELF_LINK_HASH_REF_REGULAR) != 0
3191 && (h->elf_link_hash_flags
3192 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
3193
3194 /* If this is a function, put it in the procedure linkage table. We
3195 will fill in the contents of the procedure linkage table later,
3196 when we know the address of the .got section. */
3197 if (h->type == STT_FUNC
3198 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
3199 {
3200 if (h->plt.refcount <= 0
3201 || SYMBOL_CALLS_LOCAL (info, h)
3202 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
3203 && h->root.type == bfd_link_hash_undefweak))
3204 {
3205 /* This case can occur if we saw a PLT32 reloc in an input
3206 file, but the symbol was never referred to by a dynamic
3207 object, or if all references were garbage collected. In
3208 such a case, we don't actually need to build a procedure
3209 linkage table, and we can just do a PC24 reloc instead. */
3210 h->plt.offset = (bfd_vma) -1;
3211 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
3212 }
3213
3214 return TRUE;
3215 }
3216 else
3217 /* It's possible that we incorrectly decided a .plt reloc was
3218 needed for an R_ARM_PC24 reloc to a non-function sym in
3219 check_relocs. We can't decide accurately between function and
3220 non-function syms in check-relocs; Objects loaded later in
3221 the link may change h->type. So fix it now. */
3222 h->plt.offset = (bfd_vma) -1;
3223
3224 /* If this is a weak symbol, and there is a real definition, the
3225 processor independent code will have arranged for us to see the
3226 real definition first, and we can just use the same value. */
3227 if (h->weakdef != NULL)
3228 {
3229 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
3230 || h->weakdef->root.type == bfd_link_hash_defweak);
3231 h->root.u.def.section = h->weakdef->root.u.def.section;
3232 h->root.u.def.value = h->weakdef->root.u.def.value;
3233 return TRUE;
3234 }
3235
3236 /* This is a reference to a symbol defined by a dynamic object which
3237 is not a function. */
3238
3239 /* If we are creating a shared library, we must presume that the
3240 only references to the symbol are via the global offset table.
3241 For such cases we need not do anything here; the relocations will
3242 be handled correctly by relocate_section. */
3243 if (info->shared)
3244 return TRUE;
3245
3246 /* We must allocate the symbol in our .dynbss section, which will
3247 become part of the .bss section of the executable. There will be
3248 an entry for this symbol in the .dynsym section. The dynamic
3249 object will contain position independent code, so all references
3250 from the dynamic object to this symbol will go through the global
3251 offset table. The dynamic linker will use the .dynsym entry to
3252 determine the address it must put in the global offset table, so
3253 both the dynamic object and the regular object will refer to the
3254 same memory location for the variable. */
3255 s = bfd_get_section_by_name (dynobj, ".dynbss");
3256 BFD_ASSERT (s != NULL);
3257
3258 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
3259 copy the initial value out of the dynamic object and into the
3260 runtime process image. We need to remember the offset into the
3261 .rel.bss section we are going to use. */
3262 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
3263 {
3264 asection *srel;
3265
3266 srel = bfd_get_section_by_name (dynobj, ".rel.bss");
3267 BFD_ASSERT (srel != NULL);
3268 srel->_raw_size += sizeof (Elf32_External_Rel);
3269 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
3270 }
3271
3272 /* We need to figure out the alignment required for this symbol. I
3273 have no idea how ELF linkers handle this. */
3274 power_of_two = bfd_log2 (h->size);
3275 if (power_of_two > 3)
3276 power_of_two = 3;
3277
3278 /* Apply the required alignment. */
3279 s->_raw_size = BFD_ALIGN (s->_raw_size,
3280 (bfd_size_type) (1 << power_of_two));
3281 if (power_of_two > bfd_get_section_alignment (dynobj, s))
3282 {
3283 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
3284 return FALSE;
3285 }
3286
3287 /* Define the symbol as being at this point in the section. */
3288 h->root.u.def.section = s;
3289 h->root.u.def.value = s->_raw_size;
3290
3291 /* Increment the section size to make room for the symbol. */
3292 s->_raw_size += h->size;
3293
3294 return TRUE;
3295 }
3296
3297 /* Allocate space in .plt, .got and associated reloc sections for
3298 dynamic relocs. */
3299
3300 static bfd_boolean
allocate_dynrelocs(h,inf)3301 allocate_dynrelocs (h, inf)
3302 struct elf_link_hash_entry *h;
3303 PTR inf;
3304 {
3305 struct bfd_link_info *info;
3306 struct elf32_arm_link_hash_table *htab;
3307 struct elf32_arm_link_hash_entry *eh;
3308 struct elf32_arm_relocs_copied *p;
3309
3310 if (h->root.type == bfd_link_hash_indirect)
3311 return TRUE;
3312
3313 if (h->root.type == bfd_link_hash_warning)
3314 /* When warning symbols are created, they **replace** the "real"
3315 entry in the hash table, thus we never get to see the real
3316 symbol in a hash traversal. So look at it now. */
3317 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3318
3319 info = (struct bfd_link_info *) inf;
3320 htab = elf32_arm_hash_table (info);
3321
3322 if (htab->root.dynamic_sections_created
3323 && h->plt.refcount > 0)
3324 {
3325 /* Make sure this symbol is output as a dynamic symbol.
3326 Undefined weak syms won't yet be marked as dynamic. */
3327 if (h->dynindx == -1
3328 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
3329 {
3330 if (! bfd_elf_link_record_dynamic_symbol (info, h))
3331 return FALSE;
3332 }
3333
3334 if (info->shared
3335 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
3336 {
3337 asection *s = htab->splt;
3338
3339 /* If this is the first .plt entry, make room for the special
3340 first entry. */
3341 if (s->_raw_size == 0)
3342 s->_raw_size += PLT_HEADER_SIZE;
3343
3344 h->plt.offset = s->_raw_size;
3345
3346 /* If this symbol is not defined in a regular file, and we are
3347 not generating a shared library, then set the symbol to this
3348 location in the .plt. This is required to make function
3349 pointers compare as equal between the normal executable and
3350 the shared library. */
3351 if (! info->shared
3352 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3353 {
3354 h->root.u.def.section = s;
3355 h->root.u.def.value = h->plt.offset;
3356 }
3357
3358 /* Make room for this entry. */
3359 s->_raw_size += PLT_ENTRY_SIZE;
3360
3361 /* We also need to make an entry in the .got.plt section, which
3362 will be placed in the .got section by the linker script. */
3363 htab->sgotplt->_raw_size += 4;
3364
3365 /* We also need to make an entry in the .rel.plt section. */
3366 htab->srelplt->_raw_size += sizeof (Elf32_External_Rel);
3367 }
3368 else
3369 {
3370 h->plt.offset = (bfd_vma) -1;
3371 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
3372 }
3373 }
3374 else
3375 {
3376 h->plt.offset = (bfd_vma) -1;
3377 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
3378 }
3379
3380 if (h->got.refcount > 0)
3381 {
3382 asection *s;
3383 bfd_boolean dyn;
3384
3385 /* Make sure this symbol is output as a dynamic symbol.
3386 Undefined weak syms won't yet be marked as dynamic. */
3387 if (h->dynindx == -1
3388 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
3389 {
3390 if (! bfd_elf_link_record_dynamic_symbol (info, h))
3391 return FALSE;
3392 }
3393
3394 s = htab->sgot;
3395 h->got.offset = s->_raw_size;
3396 s->_raw_size += 4;
3397 dyn = htab->root.dynamic_sections_created;
3398 if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3399 || h->root.type != bfd_link_hash_undefweak)
3400 && (info->shared
3401 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
3402 htab->srelgot->_raw_size += sizeof (Elf32_External_Rel);
3403 }
3404 else
3405 h->got.offset = (bfd_vma) -1;
3406
3407 eh = (struct elf32_arm_link_hash_entry *) h;
3408 if (eh->relocs_copied == NULL)
3409 return TRUE;
3410
3411 /* In the shared -Bsymbolic case, discard space allocated for
3412 dynamic pc-relative relocs against symbols which turn out to be
3413 defined in regular objects. For the normal shared case, discard
3414 space for pc-relative relocs that have become local due to symbol
3415 visibility changes. */
3416
3417 if (info->shared)
3418 {
3419 /* Discard relocs on undefined weak syms with non-default
3420 visibility. */
3421 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
3422 && h->root.type == bfd_link_hash_undefweak)
3423 eh->relocs_copied = NULL;
3424 }
3425 else
3426 {
3427 /* For the non-shared case, discard space for relocs against
3428 symbols which turn out to need copy relocs or are not
3429 dynamic. */
3430
3431 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
3432 && (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
3433 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3434 || (htab->root.dynamic_sections_created
3435 && (h->root.type == bfd_link_hash_undefweak
3436 || h->root.type == bfd_link_hash_undefined))))
3437 {
3438 /* Make sure this symbol is output as a dynamic symbol.
3439 Undefined weak syms won't yet be marked as dynamic. */
3440 if (h->dynindx == -1
3441 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
3442 {
3443 if (! bfd_elf_link_record_dynamic_symbol (info, h))
3444 return FALSE;
3445 }
3446
3447 /* If that succeeded, we know we'll be keeping all the
3448 relocs. */
3449 if (h->dynindx != -1)
3450 goto keep;
3451 }
3452
3453 eh->relocs_copied = NULL;
3454
3455 keep: ;
3456 }
3457
3458 /* Finally, allocate space. */
3459 for (p = eh->relocs_copied; p != NULL; p = p->next)
3460 {
3461 asection *sreloc = elf_section_data (p->section)->sreloc;
3462 sreloc->_raw_size += p->count * sizeof (Elf32_External_Rel);
3463 }
3464
3465 return TRUE;
3466 }
3467
3468 /* Set the sizes of the dynamic sections. */
3469
3470 static bfd_boolean
elf32_arm_size_dynamic_sections(output_bfd,info)3471 elf32_arm_size_dynamic_sections (output_bfd, info)
3472 bfd * output_bfd ATTRIBUTE_UNUSED;
3473 struct bfd_link_info * info;
3474 {
3475 bfd * dynobj;
3476 asection * s;
3477 bfd_boolean plt;
3478 bfd_boolean relocs;
3479 bfd *ibfd;
3480 struct elf32_arm_link_hash_table *htab;
3481
3482 htab = elf32_arm_hash_table (info);
3483 dynobj = elf_hash_table (info)->dynobj;
3484 BFD_ASSERT (dynobj != NULL);
3485
3486 if (elf_hash_table (info)->dynamic_sections_created)
3487 {
3488 /* Set the contents of the .interp section to the interpreter. */
3489 if (info->executable)
3490 {
3491 s = bfd_get_section_by_name (dynobj, ".interp");
3492 BFD_ASSERT (s != NULL);
3493 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
3494 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3495 }
3496 }
3497
3498 /* Set up .got offsets for local syms, and space for local dynamic
3499 relocs. */
3500 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
3501 {
3502 bfd_signed_vma *local_got;
3503 bfd_signed_vma *end_local_got;
3504 char *local_tls_type;
3505 bfd_size_type locsymcount;
3506 Elf_Internal_Shdr *symtab_hdr;
3507 asection *srel;
3508
3509 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
3510 continue;
3511
3512 for (s = ibfd->sections; s != NULL; s = s->next)
3513 {
3514 struct elf32_arm_relocs_copied *p;
3515
3516 for (p = *((struct elf32_arm_relocs_copied **)
3517 &elf_section_data (s)->local_dynrel);
3518 p != NULL;
3519 p = p->next)
3520 {
3521 if (!bfd_is_abs_section (p->section)
3522 && bfd_is_abs_section (p->section->output_section))
3523 {
3524 /* Input section has been discarded, either because
3525 it is a copy of a linkonce section or due to
3526 linker script /DISCARD/, so we'll be discarding
3527 the relocs too. */
3528 }
3529 else if (p->count != 0)
3530 {
3531 srel = elf_section_data (p->section)->sreloc;
3532 srel->_raw_size += p->count * sizeof (Elf32_External_Rel);
3533 if ((p->section->output_section->flags & SEC_READONLY) != 0)
3534 info->flags |= DF_TEXTREL;
3535 }
3536 }
3537 }
3538
3539 local_got = elf_local_got_refcounts (ibfd);
3540 if (!local_got)
3541 continue;
3542
3543 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
3544 locsymcount = symtab_hdr->sh_info;
3545 end_local_got = local_got + locsymcount;
3546 s = htab->sgot;
3547 srel = htab->srelgot;
3548 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
3549 {
3550 if (*local_got > 0)
3551 {
3552 *local_got = s->_raw_size;
3553 s->_raw_size += 4;
3554 if (info->shared)
3555 srel->_raw_size += sizeof (Elf32_External_Rel);
3556 }
3557 else
3558 *local_got = (bfd_vma) -1;
3559 }
3560 }
3561
3562 /* Allocate global sym .plt and .got entries, and space for global
3563 sym dynamic relocs. */
3564 elf_link_hash_traverse (&htab->root, allocate_dynrelocs, (PTR) info);
3565
3566 /* The check_relocs and adjust_dynamic_symbol entry points have
3567 determined the sizes of the various dynamic sections. Allocate
3568 memory for them. */
3569 plt = FALSE;
3570 relocs = FALSE;
3571 for (s = dynobj->sections; s != NULL; s = s->next)
3572 {
3573 const char * name;
3574 bfd_boolean strip;
3575
3576 if ((s->flags & SEC_LINKER_CREATED) == 0)
3577 continue;
3578
3579 /* It's OK to base decisions on the section name, because none
3580 of the dynobj section names depend upon the input files. */
3581 name = bfd_get_section_name (dynobj, s);
3582
3583 strip = FALSE;
3584
3585 if (strcmp (name, ".plt") == 0)
3586 {
3587 if (s->_raw_size == 0)
3588 {
3589 /* Strip this section if we don't need it; see the
3590 comment below. */
3591 strip = TRUE;
3592 }
3593 else
3594 {
3595 /* Remember whether there is a PLT. */
3596 plt = TRUE;
3597 }
3598 }
3599 else if (strncmp (name, ".rel", 4) == 0)
3600 {
3601 if (s->_raw_size == 0)
3602 {
3603 /* If we don't need this section, strip it from the
3604 output file. This is mostly to handle .rel.bss and
3605 .rel.plt. We must create both sections in
3606 create_dynamic_sections, because they must be created
3607 before the linker maps input sections to output
3608 sections. The linker does that before
3609 adjust_dynamic_symbol is called, and it is that
3610 function which decides whether anything needs to go
3611 into these sections. */
3612 strip = TRUE;
3613 }
3614 else
3615 {
3616 /* Remember whether there are any reloc sections other
3617 than .rel.plt. */
3618 if (strcmp (name, ".rel.plt") != 0)
3619 relocs = TRUE;
3620
3621 /* We use the reloc_count field as a counter if we need
3622 to copy relocs into the output file. */
3623 s->reloc_count = 0;
3624 }
3625 }
3626 else if (strncmp (name, ".got", 4) != 0)
3627 {
3628 /* It's not one of our sections, so don't allocate space. */
3629 continue;
3630 }
3631
3632 if (strip)
3633 {
3634 _bfd_strip_section_from_output (info, s);
3635 continue;
3636 }
3637
3638 /* Allocate memory for the section contents. */
3639 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
3640 if (s->contents == NULL && s->_raw_size != 0)
3641 return FALSE;
3642 }
3643
3644 if (elf_hash_table (info)->dynamic_sections_created)
3645 {
3646 /* Add some entries to the .dynamic section. We fill in the
3647 values later, in elf32_arm_finish_dynamic_sections, but we
3648 must add the entries now so that we get the correct size for
3649 the .dynamic section. The DT_DEBUG entry is filled in by the
3650 dynamic linker and used by the debugger. */
3651 #define add_dynamic_entry(TAG, VAL) \
3652 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3653
3654 if (!info->shared)
3655 {
3656 if (!add_dynamic_entry (DT_DEBUG, 0))
3657 return FALSE;
3658 }
3659
3660 if (plt)
3661 {
3662 if ( !add_dynamic_entry (DT_PLTGOT, 0)
3663 || !add_dynamic_entry (DT_PLTRELSZ, 0)
3664 || !add_dynamic_entry (DT_PLTREL, DT_REL)
3665 || !add_dynamic_entry (DT_JMPREL, 0))
3666 return FALSE;
3667 }
3668
3669 if (relocs)
3670 {
3671 if ( !add_dynamic_entry (DT_REL, 0)
3672 || !add_dynamic_entry (DT_RELSZ, 0)
3673 || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
3674 return FALSE;
3675 }
3676
3677 if ((info->flags & DF_TEXTREL) != 0)
3678 {
3679 if (!add_dynamic_entry (DT_TEXTREL, 0))
3680 return FALSE;
3681 info->flags |= DF_TEXTREL;
3682 }
3683 }
3684 #undef add_synamic_entry
3685
3686 return TRUE;
3687 }
3688
3689 /* Finish up dynamic symbol handling. We set the contents of various
3690 dynamic sections here. */
3691
3692 static bfd_boolean
elf32_arm_finish_dynamic_symbol(output_bfd,info,h,sym)3693 elf32_arm_finish_dynamic_symbol (output_bfd, info, h, sym)
3694 bfd * output_bfd;
3695 struct bfd_link_info * info;
3696 struct elf_link_hash_entry * h;
3697 Elf_Internal_Sym * sym;
3698 {
3699 bfd * dynobj;
3700
3701 dynobj = elf_hash_table (info)->dynobj;
3702
3703 if (h->plt.offset != (bfd_vma) -1)
3704 {
3705 asection * splt;
3706 asection * sgot;
3707 asection * srel;
3708 bfd_vma plt_index;
3709 bfd_vma got_offset;
3710 Elf_Internal_Rela rel;
3711 bfd_byte *loc;
3712 bfd_vma got_displacement;
3713
3714 /* This symbol has an entry in the procedure linkage table. Set
3715 it up. */
3716
3717 BFD_ASSERT (h->dynindx != -1);
3718
3719 splt = bfd_get_section_by_name (dynobj, ".plt");
3720 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
3721 srel = bfd_get_section_by_name (dynobj, ".rel.plt");
3722 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
3723
3724 /* Get the index in the procedure linkage table which
3725 corresponds to this symbol. This is the index of this symbol
3726 in all the symbols for which we are making plt entries. The
3727 first entry in the procedure linkage table is reserved. */
3728 plt_index = (h->plt.offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
3729
3730 /* Get the offset into the .got table of the entry that
3731 corresponds to this function. Each .got entry is 4 bytes.
3732 The first three are reserved. */
3733 got_offset = (plt_index + 3) * 4;
3734
3735 /* Calculate the displacement between the PLT slot and the
3736 entry in the GOT. */
3737 got_displacement = (sgot->output_section->vma
3738 + sgot->output_offset
3739 + got_offset
3740 - splt->output_section->vma
3741 - splt->output_offset
3742 - h->plt.offset
3743 - 8);
3744
3745 BFD_ASSERT ((got_displacement & 0xf0000000) == 0);
3746
3747 /* Fill in the entry in the procedure linkage table. */
3748 bfd_put_32 (output_bfd, elf32_arm_plt_entry[0] | ((got_displacement & 0x0ff00000) >> 20),
3749 splt->contents + h->plt.offset + 0);
3750 bfd_put_32 (output_bfd, elf32_arm_plt_entry[1] | ((got_displacement & 0x000ff000) >> 12),
3751 splt->contents + h->plt.offset + 4);
3752 bfd_put_32 (output_bfd, elf32_arm_plt_entry[2] | (got_displacement & 0x00000fff),
3753 splt->contents + h->plt.offset + 8);
3754 #ifdef FOUR_WORD_PLT
3755 bfd_put_32 (output_bfd, elf32_arm_plt_entry[3],
3756 splt->contents + h->plt.offset + 12);
3757 #endif
3758
3759 /* Fill in the entry in the global offset table. */
3760 bfd_put_32 (output_bfd,
3761 (splt->output_section->vma
3762 + splt->output_offset),
3763 sgot->contents + got_offset);
3764
3765 /* Fill in the entry in the .rel.plt section. */
3766 rel.r_offset = (sgot->output_section->vma
3767 + sgot->output_offset
3768 + got_offset);
3769 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_JUMP_SLOT);
3770 loc = srel->contents + plt_index * sizeof (Elf32_External_Rel);
3771 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3772
3773 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3774 {
3775 /* Mark the symbol as undefined, rather than as defined in
3776 the .plt section. Leave the value alone. */
3777 sym->st_shndx = SHN_UNDEF;
3778 /* If the symbol is weak, we do need to clear the value.
3779 Otherwise, the PLT entry would provide a definition for
3780 the symbol even if the symbol wasn't defined anywhere,
3781 and so the symbol would never be NULL. */
3782 if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK)
3783 == 0)
3784 sym->st_value = 0;
3785 }
3786 }
3787
3788 if (h->got.offset != (bfd_vma) -1)
3789 {
3790 asection * sgot;
3791 asection * srel;
3792 Elf_Internal_Rela rel;
3793 bfd_byte *loc;
3794
3795 /* This symbol has an entry in the global offset table. Set it
3796 up. */
3797 sgot = bfd_get_section_by_name (dynobj, ".got");
3798 srel = bfd_get_section_by_name (dynobj, ".rel.got");
3799 BFD_ASSERT (sgot != NULL && srel != NULL);
3800
3801 rel.r_offset = (sgot->output_section->vma
3802 + sgot->output_offset
3803 + (h->got.offset &~ (bfd_vma) 1));
3804
3805 /* If this is a static link, or it is a -Bsymbolic link and the
3806 symbol is defined locally or was forced to be local because
3807 of a version file, we just want to emit a RELATIVE reloc.
3808 The entry in the global offset table will already have been
3809 initialized in the relocate_section function. */
3810 if (info->shared
3811 && SYMBOL_REFERENCES_LOCAL (info, h))
3812 {
3813 BFD_ASSERT((h->got.offset & 1) != 0);
3814 rel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
3815 }
3816 else
3817 {
3818 BFD_ASSERT((h->got.offset & 1) == 0);
3819 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
3820 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
3821 }
3822
3823 loc = srel->contents + srel->reloc_count++ * sizeof (Elf32_External_Rel);
3824 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3825 }
3826
3827 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
3828 {
3829 asection * s;
3830 Elf_Internal_Rela rel;
3831 bfd_byte *loc;
3832
3833 /* This symbol needs a copy reloc. Set it up. */
3834 BFD_ASSERT (h->dynindx != -1
3835 && (h->root.type == bfd_link_hash_defined
3836 || h->root.type == bfd_link_hash_defweak));
3837
3838 s = bfd_get_section_by_name (h->root.u.def.section->owner,
3839 ".rel.bss");
3840 BFD_ASSERT (s != NULL);
3841
3842 rel.r_offset = (h->root.u.def.value
3843 + h->root.u.def.section->output_section->vma
3844 + h->root.u.def.section->output_offset);
3845 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_COPY);
3846 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rel);
3847 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3848 }
3849
3850 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3851 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3852 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3853 sym->st_shndx = SHN_ABS;
3854
3855 return TRUE;
3856 }
3857
3858 /* Finish up the dynamic sections. */
3859
3860 static bfd_boolean
elf32_arm_finish_dynamic_sections(output_bfd,info)3861 elf32_arm_finish_dynamic_sections (output_bfd, info)
3862 bfd * output_bfd;
3863 struct bfd_link_info * info;
3864 {
3865 bfd * dynobj;
3866 asection * sgot;
3867 asection * sdyn;
3868
3869 dynobj = elf_hash_table (info)->dynobj;
3870
3871 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
3872 BFD_ASSERT (sgot != NULL);
3873 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3874
3875 if (elf_hash_table (info)->dynamic_sections_created)
3876 {
3877 asection *splt;
3878 Elf32_External_Dyn *dyncon, *dynconend;
3879
3880 splt = bfd_get_section_by_name (dynobj, ".plt");
3881 BFD_ASSERT (splt != NULL && sdyn != NULL);
3882
3883 dyncon = (Elf32_External_Dyn *) sdyn->contents;
3884 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3885
3886 for (; dyncon < dynconend; dyncon++)
3887 {
3888 Elf_Internal_Dyn dyn;
3889 const char * name;
3890 asection * s;
3891
3892 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3893
3894 switch (dyn.d_tag)
3895 {
3896 default:
3897 break;
3898
3899 case DT_PLTGOT:
3900 name = ".got";
3901 goto get_vma;
3902 case DT_JMPREL:
3903 name = ".rel.plt";
3904 get_vma:
3905 s = bfd_get_section_by_name (output_bfd, name);
3906 BFD_ASSERT (s != NULL);
3907 dyn.d_un.d_ptr = s->vma;
3908 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3909 break;
3910
3911 case DT_PLTRELSZ:
3912 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
3913 BFD_ASSERT (s != NULL);
3914 if (s->_cooked_size != 0)
3915 dyn.d_un.d_val = s->_cooked_size;
3916 else
3917 dyn.d_un.d_val = s->_raw_size;
3918 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3919 break;
3920
3921 case DT_RELSZ:
3922 /* My reading of the SVR4 ABI indicates that the
3923 procedure linkage table relocs (DT_JMPREL) should be
3924 included in the overall relocs (DT_REL). This is
3925 what Solaris does. However, UnixWare can not handle
3926 that case. Therefore, we override the DT_RELSZ entry
3927 here to make it not include the JMPREL relocs. Since
3928 the linker script arranges for .rel.plt to follow all
3929 other relocation sections, we don't have to worry
3930 about changing the DT_REL entry. */
3931 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
3932 if (s != NULL)
3933 {
3934 if (s->_cooked_size != 0)
3935 dyn.d_un.d_val -= s->_cooked_size;
3936 else
3937 dyn.d_un.d_val -= s->_raw_size;
3938 }
3939 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3940 break;
3941
3942 /* Set the bottom bit of DT_INIT/FINI if the
3943 corresponding function is Thumb. */
3944 case DT_INIT:
3945 name = info->init_function;
3946 goto get_sym;
3947 case DT_FINI:
3948 name = info->fini_function;
3949 get_sym:
3950 /* If it wasn't set by elf_bfd_final_link
3951 then there is nothing to adjust. */
3952 if (dyn.d_un.d_val != 0)
3953 {
3954 struct elf_link_hash_entry * eh;
3955
3956 eh = elf_link_hash_lookup (elf_hash_table (info), name,
3957 FALSE, FALSE, TRUE);
3958 if (eh != (struct elf_link_hash_entry *) NULL
3959 && ELF_ST_TYPE (eh->type) == STT_ARM_TFUNC)
3960 {
3961 dyn.d_un.d_val |= 1;
3962 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3963 }
3964 }
3965 break;
3966 }
3967 }
3968
3969 /* Fill in the first entry in the procedure linkage table. */
3970 if (splt->_raw_size > 0)
3971 {
3972 bfd_vma got_displacement;
3973
3974 /* Calculate the displacement between the PLT slot and &GOT[0]. */
3975 got_displacement = (sgot->output_section->vma
3976 + sgot->output_offset
3977 - splt->output_section->vma
3978 - splt->output_offset
3979 - 16);
3980
3981 bfd_put_32 (output_bfd, elf32_arm_plt0_entry[0], splt->contents + 0);
3982 bfd_put_32 (output_bfd, elf32_arm_plt0_entry[1], splt->contents + 4);
3983 bfd_put_32 (output_bfd, elf32_arm_plt0_entry[2], splt->contents + 8);
3984 bfd_put_32 (output_bfd, elf32_arm_plt0_entry[3], splt->contents + 12);
3985 #ifdef FOUR_WORD_PLT
3986 /* The displacement value goes in the otherwise-unused last word of
3987 the second entry. */
3988 bfd_put_32 (output_bfd, got_displacement, splt->contents + 28);
3989 #else
3990 bfd_put_32 (output_bfd, got_displacement, splt->contents + 16);
3991 #endif
3992 }
3993
3994 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3995 really seem like the right value. */
3996 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
3997 }
3998
3999 /* Fill in the first three entries in the global offset table. */
4000 if (sgot->_raw_size > 0)
4001 {
4002 if (sdyn == NULL)
4003 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
4004 else
4005 bfd_put_32 (output_bfd,
4006 sdyn->output_section->vma + sdyn->output_offset,
4007 sgot->contents);
4008 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
4009 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
4010 }
4011
4012 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
4013
4014 return TRUE;
4015 }
4016
4017 static void
elf32_arm_post_process_headers(abfd,link_info)4018 elf32_arm_post_process_headers (abfd, link_info)
4019 bfd * abfd;
4020 struct bfd_link_info * link_info ATTRIBUTE_UNUSED;
4021 {
4022 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
4023
4024 i_ehdrp = elf_elfheader (abfd);
4025
4026 i_ehdrp->e_ident[EI_OSABI] = ARM_ELF_OS_ABI_VERSION;
4027 i_ehdrp->e_ident[EI_ABIVERSION] = ARM_ELF_ABI_VERSION;
4028 }
4029
4030 static enum elf_reloc_type_class
elf32_arm_reloc_type_class(rela)4031 elf32_arm_reloc_type_class (rela)
4032 const Elf_Internal_Rela *rela;
4033 {
4034 switch ((int) ELF32_R_TYPE (rela->r_info))
4035 {
4036 case R_ARM_RELATIVE:
4037 return reloc_class_relative;
4038 case R_ARM_JUMP_SLOT:
4039 return reloc_class_plt;
4040 case R_ARM_COPY:
4041 return reloc_class_copy;
4042 default:
4043 return reloc_class_normal;
4044 }
4045 }
4046
4047 static bfd_boolean elf32_arm_section_flags PARAMS ((flagword *, Elf_Internal_Shdr *));
4048 static void elf32_arm_final_write_processing PARAMS ((bfd *, bfd_boolean));
4049
4050 /* Set the right machine number for an Arm ELF file. */
4051
4052 static bfd_boolean
elf32_arm_section_flags(flags,hdr)4053 elf32_arm_section_flags (flags, hdr)
4054 flagword *flags;
4055 Elf_Internal_Shdr *hdr;
4056 {
4057 if (hdr->sh_type == SHT_NOTE)
4058 *flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_CONTENTS;
4059
4060 return TRUE;
4061 }
4062
4063 void
elf32_arm_final_write_processing(abfd,linker)4064 elf32_arm_final_write_processing (abfd, linker)
4065 bfd *abfd;
4066 bfd_boolean linker ATTRIBUTE_UNUSED;
4067 {
4068 bfd_arm_update_notes (abfd, ARM_NOTE_SECTION);
4069 }
4070
4071 #define ELF_ARCH bfd_arch_arm
4072 #define ELF_MACHINE_CODE EM_ARM
4073 #ifdef __QNXTARGET__
4074 #define ELF_MAXPAGESIZE 0x1000
4075 #else
4076 #define ELF_MAXPAGESIZE 0x8000
4077 #endif
4078
4079 #define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
4080 #define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
4081 #define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
4082 #define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
4083 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
4084 #define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
4085 #define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
4086
4087 #define elf_backend_get_symbol_type elf32_arm_get_symbol_type
4088 #define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
4089 #define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
4090 #define elf_backend_check_relocs elf32_arm_check_relocs
4091 #define elf_backend_relocate_section elf32_arm_relocate_section
4092 #define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
4093 #define elf_backend_create_dynamic_sections elf32_arm_create_dynamic_sections
4094 #define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
4095 #define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
4096 #define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
4097 #define elf_backend_post_process_headers elf32_arm_post_process_headers
4098 #define elf_backend_reloc_type_class elf32_arm_reloc_type_class
4099 #define elf_backend_object_p elf32_arm_object_p
4100 #define elf_backend_section_flags elf32_arm_section_flags
4101 #define elf_backend_final_write_processing elf32_arm_final_write_processing
4102 #define elf_backend_copy_indirect_symbol elf32_arm_copy_indirect_symbol
4103
4104 #define elf_backend_can_refcount 1
4105 #define elf_backend_can_gc_sections 1
4106 #define elf_backend_plt_readonly 1
4107 #define elf_backend_want_got_plt 1
4108 #define elf_backend_want_plt_sym 0
4109 #if !USE_REL
4110 #define elf_backend_rela_normal 1
4111 #endif
4112
4113 #define elf_backend_got_header_size 12
4114
4115 #include "elf32-target.h"
4116
4117