* elf-bfd.h (RELOC_FOR_GLOBAL_SYMBOL): Add input_bfd, input_section
[deliverable/binutils-gdb.git] / bfd / elf32-arm.h
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 *
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
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
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
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 *
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 *
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 *
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
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
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
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
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
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
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
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
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
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 /* This is the condition under which elf32_arm_finish_dynamic_symbol
1213 will be called from elflink.h. If elflink.h doesn't call our
1214 finish_dynamic_symbol routine, we'll need to do something about
1215 initializing any .plt and .got entries in elf32_arm_relocate_section
1216 and elf32_arm_final_link_relocate. */
1217 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, SHARED, H) \
1218 ((DYN) \
1219 && ((SHARED) \
1220 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
1221 && ((H)->dynindx != -1 \
1222 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1223
1224 /* Perform a relocation as part of a final link. */
1225
1226 static bfd_reloc_status_type
1227 elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
1228 input_section, contents, rel, value,
1229 info, sym_sec, sym_name, sym_flags, h)
1230 reloc_howto_type * howto;
1231 bfd * input_bfd;
1232 bfd * output_bfd;
1233 asection * input_section;
1234 bfd_byte * contents;
1235 Elf_Internal_Rela * rel;
1236 bfd_vma value;
1237 struct bfd_link_info * info;
1238 asection * sym_sec;
1239 const char * sym_name;
1240 int sym_flags;
1241 struct elf_link_hash_entry * h;
1242 {
1243 unsigned long r_type = howto->type;
1244 unsigned long r_symndx;
1245 bfd_byte * hit_data = contents + rel->r_offset;
1246 bfd * dynobj = NULL;
1247 Elf_Internal_Shdr * symtab_hdr;
1248 struct elf_link_hash_entry ** sym_hashes;
1249 bfd_vma * local_got_offsets;
1250 asection * sgot = NULL;
1251 asection * splt = NULL;
1252 asection * sreloc = NULL;
1253 bfd_vma addend;
1254 bfd_signed_vma signed_addend;
1255 struct elf32_arm_link_hash_table * globals;
1256
1257 /* If the start address has been set, then set the EF_ARM_HASENTRY
1258 flag. Setting this more than once is redundant, but the cost is
1259 not too high, and it keeps the code simple.
1260
1261 The test is done here, rather than somewhere else, because the
1262 start address is only set just before the final link commences.
1263
1264 Note - if the user deliberately sets a start address of 0, the
1265 flag will not be set. */
1266 if (bfd_get_start_address (output_bfd) != 0)
1267 elf_elfheader (output_bfd)->e_flags |= EF_ARM_HASENTRY;
1268
1269 globals = elf32_arm_hash_table (info);
1270
1271 dynobj = elf_hash_table (info)->dynobj;
1272 if (dynobj)
1273 {
1274 sgot = bfd_get_section_by_name (dynobj, ".got");
1275 splt = bfd_get_section_by_name (dynobj, ".plt");
1276 }
1277 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1278 sym_hashes = elf_sym_hashes (input_bfd);
1279 local_got_offsets = elf_local_got_offsets (input_bfd);
1280 r_symndx = ELF32_R_SYM (rel->r_info);
1281
1282 #if USE_REL
1283 addend = bfd_get_32 (input_bfd, hit_data) & howto->src_mask;
1284
1285 if (addend & ((howto->src_mask + 1) >> 1))
1286 {
1287 signed_addend = -1;
1288 signed_addend &= ~ howto->src_mask;
1289 signed_addend |= addend;
1290 }
1291 else
1292 signed_addend = addend;
1293 #else
1294 addend = signed_addend = rel->r_addend;
1295 #endif
1296
1297 switch (r_type)
1298 {
1299 case R_ARM_NONE:
1300 return bfd_reloc_ok;
1301
1302 case R_ARM_PC24:
1303 case R_ARM_ABS32:
1304 case R_ARM_REL32:
1305 #ifndef OLD_ARM_ABI
1306 case R_ARM_XPC25:
1307 #endif
1308 case R_ARM_PLT32:
1309 /* r_symndx will be zero only for relocs against symbols
1310 from removed linkonce sections, or sections discarded by
1311 a linker script. */
1312 if (r_symndx == 0)
1313 return bfd_reloc_ok;
1314
1315 /* Handle relocations which should use the PLT entry. ABS32/REL32
1316 will use the symbol's value, which may point to a PLT entry, but we
1317 don't need to handle that here. If we created a PLT entry, all
1318 branches in this object should go to it. */
1319 if ((r_type != R_ARM_ABS32 && r_type != R_ARM_REL32)
1320 && h != NULL
1321 && splt != NULL
1322 && h->plt.offset != (bfd_vma) -1)
1323 {
1324 /* If we've created a .plt section, and assigned a PLT entry to
1325 this function, it should not be known to bind locally. If
1326 it were, we would have cleared the PLT entry. */
1327 BFD_ASSERT (!SYMBOL_CALLS_LOCAL (info, h));
1328
1329 value = (splt->output_section->vma
1330 + splt->output_offset
1331 + h->plt.offset);
1332 return _bfd_final_link_relocate (howto, input_bfd, input_section,
1333 contents, rel->r_offset, value,
1334 (bfd_vma) 0);
1335 }
1336
1337 /* When generating a shared object, these relocations are copied
1338 into the output file to be resolved at run time. */
1339 if (info->shared
1340 && (input_section->flags & SEC_ALLOC)
1341 && (h == NULL
1342 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1343 || h->root.type != bfd_link_hash_undefweak)
1344 && r_type != R_ARM_PC24
1345 && r_type != R_ARM_PLT32)
1346 {
1347 Elf_Internal_Rela outrel;
1348 bfd_byte *loc;
1349 bfd_boolean skip, relocate;
1350
1351 if (sreloc == NULL)
1352 {
1353 const char * name;
1354
1355 name = (bfd_elf_string_from_elf_section
1356 (input_bfd,
1357 elf_elfheader (input_bfd)->e_shstrndx,
1358 elf_section_data (input_section)->rel_hdr.sh_name));
1359 if (name == NULL)
1360 return bfd_reloc_notsupported;
1361
1362 BFD_ASSERT (strncmp (name, ".rel", 4) == 0
1363 && strcmp (bfd_get_section_name (input_bfd,
1364 input_section),
1365 name + 4) == 0);
1366
1367 sreloc = bfd_get_section_by_name (dynobj, name);
1368 BFD_ASSERT (sreloc != NULL);
1369 }
1370
1371 skip = FALSE;
1372 relocate = FALSE;
1373
1374 outrel.r_offset =
1375 _bfd_elf_section_offset (output_bfd, info, input_section,
1376 rel->r_offset);
1377 if (outrel.r_offset == (bfd_vma) -1)
1378 skip = TRUE;
1379 else if (outrel.r_offset == (bfd_vma) -2)
1380 skip = TRUE, relocate = TRUE;
1381 outrel.r_offset += (input_section->output_section->vma
1382 + input_section->output_offset);
1383
1384 if (skip)
1385 memset (&outrel, 0, sizeof outrel);
1386 else if (h != NULL
1387 && h->dynindx != -1
1388 && (!info->shared
1389 || !info->symbolic
1390 || (h->elf_link_hash_flags
1391 & ELF_LINK_HASH_DEF_REGULAR) == 0))
1392 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1393 else
1394 {
1395 /* This symbol is local, or marked to become local. */
1396 relocate = TRUE;
1397 outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
1398 }
1399
1400 loc = sreloc->contents;
1401 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
1402 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
1403
1404 /* If this reloc is against an external symbol, we do not want to
1405 fiddle with the addend. Otherwise, we need to include the symbol
1406 value so that it becomes an addend for the dynamic reloc. */
1407 if (! relocate)
1408 return bfd_reloc_ok;
1409
1410 return _bfd_final_link_relocate (howto, input_bfd, input_section,
1411 contents, rel->r_offset, value,
1412 (bfd_vma) 0);
1413 }
1414 else switch (r_type)
1415 {
1416 #ifndef OLD_ARM_ABI
1417 case R_ARM_XPC25: /* Arm BLX instruction. */
1418 #endif
1419 case R_ARM_PC24: /* Arm B/BL instruction */
1420 case R_ARM_PLT32:
1421 #ifndef OLD_ARM_ABI
1422 if (r_type == R_ARM_XPC25)
1423 {
1424 /* Check for Arm calling Arm function. */
1425 /* FIXME: Should we translate the instruction into a BL
1426 instruction instead ? */
1427 if (sym_flags != STT_ARM_TFUNC)
1428 (*_bfd_error_handler) (_("\
1429 %s: Warning: Arm BLX instruction targets Arm function '%s'."),
1430 bfd_archive_filename (input_bfd),
1431 h ? h->root.root.string : "(local)");
1432 }
1433 else
1434 #endif
1435 {
1436 /* Check for Arm calling Thumb function. */
1437 if (sym_flags == STT_ARM_TFUNC)
1438 {
1439 elf32_arm_to_thumb_stub (info, sym_name, input_bfd, output_bfd,
1440 input_section, hit_data, sym_sec, rel->r_offset,
1441 signed_addend, value);
1442 return bfd_reloc_ok;
1443 }
1444 }
1445
1446 if ( strcmp (bfd_get_target (input_bfd), "elf32-littlearm-oabi") == 0
1447 || strcmp (bfd_get_target (input_bfd), "elf32-bigarm-oabi") == 0)
1448 {
1449 /* The old way of doing things. Trearing the addend as a
1450 byte sized field and adding in the pipeline offset. */
1451 value -= (input_section->output_section->vma
1452 + input_section->output_offset);
1453 value -= rel->r_offset;
1454 value += addend;
1455
1456 if (! globals->no_pipeline_knowledge)
1457 value -= 8;
1458 }
1459 else
1460 {
1461 /* The ARM ELF ABI says that this reloc is computed as: S - P + A
1462 where:
1463 S is the address of the symbol in the relocation.
1464 P is address of the instruction being relocated.
1465 A is the addend (extracted from the instruction) in bytes.
1466
1467 S is held in 'value'.
1468 P is the base address of the section containing the instruction
1469 plus the offset of the reloc into that section, ie:
1470 (input_section->output_section->vma +
1471 input_section->output_offset +
1472 rel->r_offset).
1473 A is the addend, converted into bytes, ie:
1474 (signed_addend * 4)
1475
1476 Note: None of these operations have knowledge of the pipeline
1477 size of the processor, thus it is up to the assembler to encode
1478 this information into the addend. */
1479 value -= (input_section->output_section->vma
1480 + input_section->output_offset);
1481 value -= rel->r_offset;
1482 value += (signed_addend << howto->size);
1483
1484 /* Previous versions of this code also used to add in the pipeline
1485 offset here. This is wrong because the linker is not supposed
1486 to know about such things, and one day it might change. In order
1487 to support old binaries that need the old behaviour however, so
1488 we attempt to detect which ABI was used to create the reloc. */
1489 if (! globals->no_pipeline_knowledge)
1490 {
1491 Elf_Internal_Ehdr * i_ehdrp; /* Elf file header, internal form */
1492
1493 i_ehdrp = elf_elfheader (input_bfd);
1494
1495 if (i_ehdrp->e_ident[EI_OSABI] == 0)
1496 value -= 8;
1497 }
1498 }
1499
1500 signed_addend = value;
1501 signed_addend >>= howto->rightshift;
1502
1503 /* It is not an error for an undefined weak reference to be
1504 out of range. Any program that branches to such a symbol
1505 is going to crash anyway, so there is no point worrying
1506 about getting the destination exactly right. */
1507 if (! h || h->root.type != bfd_link_hash_undefweak)
1508 {
1509 /* Perform a signed range check. */
1510 if ( signed_addend > ((bfd_signed_vma) (howto->dst_mask >> 1))
1511 || signed_addend < - ((bfd_signed_vma) ((howto->dst_mask + 1) >> 1)))
1512 return bfd_reloc_overflow;
1513 }
1514
1515 #ifndef OLD_ARM_ABI
1516 /* If necessary set the H bit in the BLX instruction. */
1517 if (r_type == R_ARM_XPC25 && ((value & 2) == 2))
1518 value = (signed_addend & howto->dst_mask)
1519 | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask))
1520 | (1 << 24);
1521 else
1522 #endif
1523 value = (signed_addend & howto->dst_mask)
1524 | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask));
1525 break;
1526
1527 case R_ARM_ABS32:
1528 value += addend;
1529 if (sym_flags == STT_ARM_TFUNC)
1530 value |= 1;
1531 break;
1532
1533 case R_ARM_REL32:
1534 value -= (input_section->output_section->vma
1535 + input_section->output_offset + rel->r_offset);
1536 value += addend;
1537 break;
1538 }
1539
1540 bfd_put_32 (input_bfd, value, hit_data);
1541 return bfd_reloc_ok;
1542
1543 case R_ARM_ABS8:
1544 value += addend;
1545 if ((long) value > 0x7f || (long) value < -0x80)
1546 return bfd_reloc_overflow;
1547
1548 bfd_put_8 (input_bfd, value, hit_data);
1549 return bfd_reloc_ok;
1550
1551 case R_ARM_ABS16:
1552 value += addend;
1553
1554 if ((long) value > 0x7fff || (long) value < -0x8000)
1555 return bfd_reloc_overflow;
1556
1557 bfd_put_16 (input_bfd, value, hit_data);
1558 return bfd_reloc_ok;
1559
1560 case R_ARM_ABS12:
1561 /* Support ldr and str instruction for the arm */
1562 /* Also thumb b (unconditional branch). ??? Really? */
1563 value += addend;
1564
1565 if ((long) value > 0x7ff || (long) value < -0x800)
1566 return bfd_reloc_overflow;
1567
1568 value |= (bfd_get_32 (input_bfd, hit_data) & 0xfffff000);
1569 bfd_put_32 (input_bfd, value, hit_data);
1570 return bfd_reloc_ok;
1571
1572 case R_ARM_THM_ABS5:
1573 /* Support ldr and str instructions for the thumb. */
1574 #if USE_REL
1575 /* Need to refetch addend. */
1576 addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
1577 /* ??? Need to determine shift amount from operand size. */
1578 addend >>= howto->rightshift;
1579 #endif
1580 value += addend;
1581
1582 /* ??? Isn't value unsigned? */
1583 if ((long) value > 0x1f || (long) value < -0x10)
1584 return bfd_reloc_overflow;
1585
1586 /* ??? Value needs to be properly shifted into place first. */
1587 value |= bfd_get_16 (input_bfd, hit_data) & 0xf83f;
1588 bfd_put_16 (input_bfd, value, hit_data);
1589 return bfd_reloc_ok;
1590
1591 #ifndef OLD_ARM_ABI
1592 case R_ARM_THM_XPC22:
1593 #endif
1594 case R_ARM_THM_PC22:
1595 /* Thumb BL (branch long instruction). */
1596 {
1597 bfd_vma relocation;
1598 bfd_boolean overflow = FALSE;
1599 bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
1600 bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
1601 bfd_signed_vma reloc_signed_max = ((1 << (howto->bitsize - 1)) - 1) >> howto->rightshift;
1602 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
1603 bfd_vma check;
1604 bfd_signed_vma signed_check;
1605
1606 #if USE_REL
1607 /* Need to refetch the addend and squish the two 11 bit pieces
1608 together. */
1609 {
1610 bfd_vma upper = upper_insn & 0x7ff;
1611 bfd_vma lower = lower_insn & 0x7ff;
1612 upper = (upper ^ 0x400) - 0x400; /* Sign extend. */
1613 addend = (upper << 12) | (lower << 1);
1614 signed_addend = addend;
1615 }
1616 #endif
1617 #ifndef OLD_ARM_ABI
1618 if (r_type == R_ARM_THM_XPC22)
1619 {
1620 /* Check for Thumb to Thumb call. */
1621 /* FIXME: Should we translate the instruction into a BL
1622 instruction instead ? */
1623 if (sym_flags == STT_ARM_TFUNC)
1624 (*_bfd_error_handler) (_("\
1625 %s: Warning: Thumb BLX instruction targets thumb function '%s'."),
1626 bfd_archive_filename (input_bfd),
1627 h ? h->root.root.string : "(local)");
1628 }
1629 else
1630 #endif
1631 {
1632 /* If it is not a call to Thumb, assume call to Arm.
1633 If it is a call relative to a section name, then it is not a
1634 function call at all, but rather a long jump. */
1635 if (sym_flags != STT_ARM_TFUNC && sym_flags != STT_SECTION)
1636 {
1637 if (elf32_thumb_to_arm_stub
1638 (info, sym_name, input_bfd, output_bfd, input_section,
1639 hit_data, sym_sec, rel->r_offset, signed_addend, value))
1640 return bfd_reloc_ok;
1641 else
1642 return bfd_reloc_dangerous;
1643 }
1644 }
1645
1646 relocation = value + signed_addend;
1647
1648 relocation -= (input_section->output_section->vma
1649 + input_section->output_offset
1650 + rel->r_offset);
1651
1652 if (! globals->no_pipeline_knowledge)
1653 {
1654 Elf_Internal_Ehdr * i_ehdrp; /* Elf file header, internal form. */
1655
1656 i_ehdrp = elf_elfheader (input_bfd);
1657
1658 /* Previous versions of this code also used to add in the pipline
1659 offset here. This is wrong because the linker is not supposed
1660 to know about such things, and one day it might change. In order
1661 to support old binaries that need the old behaviour however, so
1662 we attempt to detect which ABI was used to create the reloc. */
1663 if ( strcmp (bfd_get_target (input_bfd), "elf32-littlearm-oabi") == 0
1664 || strcmp (bfd_get_target (input_bfd), "elf32-bigarm-oabi") == 0
1665 || i_ehdrp->e_ident[EI_OSABI] == 0)
1666 relocation += 4;
1667 }
1668
1669 check = relocation >> howto->rightshift;
1670
1671 /* If this is a signed value, the rightshift just dropped
1672 leading 1 bits (assuming twos complement). */
1673 if ((bfd_signed_vma) relocation >= 0)
1674 signed_check = check;
1675 else
1676 signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
1677
1678 /* Assumes two's complement. */
1679 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
1680 overflow = TRUE;
1681
1682 #ifndef OLD_ARM_ABI
1683 if (r_type == R_ARM_THM_XPC22
1684 && ((lower_insn & 0x1800) == 0x0800))
1685 /* For a BLX instruction, make sure that the relocation is rounded up
1686 to a word boundary. This follows the semantics of the instruction
1687 which specifies that bit 1 of the target address will come from bit
1688 1 of the base address. */
1689 relocation = (relocation + 2) & ~ 3;
1690 #endif
1691 /* Put RELOCATION back into the insn. */
1692 upper_insn = (upper_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 12) & 0x7ff);
1693 lower_insn = (lower_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 1) & 0x7ff);
1694
1695 /* Put the relocated value back in the object file: */
1696 bfd_put_16 (input_bfd, upper_insn, hit_data);
1697 bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
1698
1699 return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
1700 }
1701 break;
1702
1703 case R_ARM_THM_PC11:
1704 /* Thumb B (branch) instruction). */
1705 {
1706 bfd_signed_vma relocation;
1707 bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
1708 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
1709 bfd_signed_vma signed_check;
1710
1711 #if USE_REL
1712 /* Need to refetch addend. */
1713 addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
1714 if (addend & ((howto->src_mask + 1) >> 1))
1715 {
1716 signed_addend = -1;
1717 signed_addend &= ~ howto->src_mask;
1718 signed_addend |= addend;
1719 }
1720 else
1721 signed_addend = addend;
1722 /* The value in the insn has been right shifted. We need to
1723 undo this, so that we can perform the address calculation
1724 in terms of bytes. */
1725 signed_addend <<= howto->rightshift;
1726 #endif
1727 relocation = value + signed_addend;
1728
1729 relocation -= (input_section->output_section->vma
1730 + input_section->output_offset
1731 + rel->r_offset);
1732
1733 relocation >>= howto->rightshift;
1734 signed_check = relocation;
1735 relocation &= howto->dst_mask;
1736 relocation |= (bfd_get_16 (input_bfd, hit_data) & (~ howto->dst_mask));
1737
1738 bfd_put_16 (input_bfd, relocation, hit_data);
1739
1740 /* Assumes two's complement. */
1741 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
1742 return bfd_reloc_overflow;
1743
1744 return bfd_reloc_ok;
1745 }
1746
1747 case R_ARM_GNU_VTINHERIT:
1748 case R_ARM_GNU_VTENTRY:
1749 return bfd_reloc_ok;
1750
1751 case R_ARM_COPY:
1752 return bfd_reloc_notsupported;
1753
1754 case R_ARM_GLOB_DAT:
1755 return bfd_reloc_notsupported;
1756
1757 case R_ARM_JUMP_SLOT:
1758 return bfd_reloc_notsupported;
1759
1760 case R_ARM_RELATIVE:
1761 return bfd_reloc_notsupported;
1762
1763 case R_ARM_GOTOFF:
1764 /* Relocation is relative to the start of the
1765 global offset table. */
1766
1767 BFD_ASSERT (sgot != NULL);
1768 if (sgot == NULL)
1769 return bfd_reloc_notsupported;
1770
1771 /* If we are addressing a Thumb function, we need to adjust the
1772 address by one, so that attempts to call the function pointer will
1773 correctly interpret it as Thumb code. */
1774 if (sym_flags == STT_ARM_TFUNC)
1775 value += 1;
1776
1777 /* Note that sgot->output_offset is not involved in this
1778 calculation. We always want the start of .got. If we
1779 define _GLOBAL_OFFSET_TABLE in a different way, as is
1780 permitted by the ABI, we might have to change this
1781 calculation. */
1782 value -= sgot->output_section->vma;
1783 return _bfd_final_link_relocate (howto, input_bfd, input_section,
1784 contents, rel->r_offset, value,
1785 (bfd_vma) 0);
1786
1787 case R_ARM_GOTPC:
1788 /* Use global offset table as symbol value. */
1789 BFD_ASSERT (sgot != NULL);
1790
1791 if (sgot == NULL)
1792 return bfd_reloc_notsupported;
1793
1794 value = sgot->output_section->vma;
1795 return _bfd_final_link_relocate (howto, input_bfd, input_section,
1796 contents, rel->r_offset, value,
1797 (bfd_vma) 0);
1798
1799 case R_ARM_GOT32:
1800 /* Relocation is to the entry for this symbol in the
1801 global offset table. */
1802 if (sgot == NULL)
1803 return bfd_reloc_notsupported;
1804
1805 if (h != NULL)
1806 {
1807 bfd_vma off;
1808 bfd_boolean dyn;
1809
1810 off = h->got.offset;
1811 BFD_ASSERT (off != (bfd_vma) -1);
1812 dyn = globals->root.dynamic_sections_created;
1813
1814 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
1815 || (info->shared
1816 && SYMBOL_REFERENCES_LOCAL (info, h))
1817 || (ELF_ST_VISIBILITY (h->other)
1818 && h->root.type == bfd_link_hash_undefweak))
1819 {
1820 /* This is actually a static link, or it is a -Bsymbolic link
1821 and the symbol is defined locally. We must initialize this
1822 entry in the global offset table. Since the offset must
1823 always be a multiple of 4, we use the least significant bit
1824 to record whether we have initialized it already.
1825
1826 When doing a dynamic link, we create a .rel.got relocation
1827 entry to initialize the value. This is done in the
1828 finish_dynamic_symbol routine. */
1829 if ((off & 1) != 0)
1830 off &= ~1;
1831 else
1832 {
1833 /* If we are addressing a Thumb function, we need to
1834 adjust the address by one, so that attempts to
1835 call the function pointer will correctly
1836 interpret it as Thumb code. */
1837 if (sym_flags == STT_ARM_TFUNC)
1838 value |= 1;
1839
1840 bfd_put_32 (output_bfd, value, sgot->contents + off);
1841 h->got.offset |= 1;
1842 }
1843 }
1844
1845 value = sgot->output_offset + off;
1846 }
1847 else
1848 {
1849 bfd_vma off;
1850
1851 BFD_ASSERT (local_got_offsets != NULL &&
1852 local_got_offsets[r_symndx] != (bfd_vma) -1);
1853
1854 off = local_got_offsets[r_symndx];
1855
1856 /* The offset must always be a multiple of 4. We use the
1857 least significant bit to record whether we have already
1858 generated the necessary reloc. */
1859 if ((off & 1) != 0)
1860 off &= ~1;
1861 else
1862 {
1863 bfd_put_32 (output_bfd, value, sgot->contents + off);
1864
1865 if (info->shared)
1866 {
1867 asection * srelgot;
1868 Elf_Internal_Rela outrel;
1869 bfd_byte *loc;
1870
1871 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
1872 BFD_ASSERT (srelgot != NULL);
1873
1874 outrel.r_offset = (sgot->output_section->vma
1875 + sgot->output_offset
1876 + off);
1877 outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
1878 loc = srelgot->contents;
1879 loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
1880 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
1881 }
1882
1883 local_got_offsets[r_symndx] |= 1;
1884 }
1885
1886 value = sgot->output_offset + off;
1887 }
1888
1889 return _bfd_final_link_relocate (howto, input_bfd, input_section,
1890 contents, rel->r_offset, value,
1891 (bfd_vma) 0);
1892
1893 case R_ARM_SBREL32:
1894 return bfd_reloc_notsupported;
1895
1896 case R_ARM_AMP_VCALL9:
1897 return bfd_reloc_notsupported;
1898
1899 case R_ARM_RSBREL32:
1900 return bfd_reloc_notsupported;
1901
1902 case R_ARM_THM_RPC22:
1903 return bfd_reloc_notsupported;
1904
1905 case R_ARM_RREL32:
1906 return bfd_reloc_notsupported;
1907
1908 case R_ARM_RABS32:
1909 return bfd_reloc_notsupported;
1910
1911 case R_ARM_RPC24:
1912 return bfd_reloc_notsupported;
1913
1914 case R_ARM_RBASE:
1915 return bfd_reloc_notsupported;
1916
1917 default:
1918 return bfd_reloc_notsupported;
1919 }
1920 }
1921
1922 #if USE_REL
1923 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. */
1924 static void
1925 arm_add_to_rel (abfd, address, howto, increment)
1926 bfd * abfd;
1927 bfd_byte * address;
1928 reloc_howto_type * howto;
1929 bfd_signed_vma increment;
1930 {
1931 bfd_signed_vma addend;
1932
1933 if (howto->type == R_ARM_THM_PC22)
1934 {
1935 int upper_insn, lower_insn;
1936 int upper, lower;
1937
1938 upper_insn = bfd_get_16 (abfd, address);
1939 lower_insn = bfd_get_16 (abfd, address + 2);
1940 upper = upper_insn & 0x7ff;
1941 lower = lower_insn & 0x7ff;
1942
1943 addend = (upper << 12) | (lower << 1);
1944 addend += increment;
1945 addend >>= 1;
1946
1947 upper_insn = (upper_insn & 0xf800) | ((addend >> 11) & 0x7ff);
1948 lower_insn = (lower_insn & 0xf800) | (addend & 0x7ff);
1949
1950 bfd_put_16 (abfd, (bfd_vma) upper_insn, address);
1951 bfd_put_16 (abfd, (bfd_vma) lower_insn, address + 2);
1952 }
1953 else
1954 {
1955 bfd_vma contents;
1956
1957 contents = bfd_get_32 (abfd, address);
1958
1959 /* Get the (signed) value from the instruction. */
1960 addend = contents & howto->src_mask;
1961 if (addend & ((howto->src_mask + 1) >> 1))
1962 {
1963 bfd_signed_vma mask;
1964
1965 mask = -1;
1966 mask &= ~ howto->src_mask;
1967 addend |= mask;
1968 }
1969
1970 /* Add in the increment, (which is a byte value). */
1971 switch (howto->type)
1972 {
1973 default:
1974 addend += increment;
1975 break;
1976
1977 case R_ARM_PC24:
1978 addend <<= howto->size;
1979 addend += increment;
1980
1981 /* Should we check for overflow here ? */
1982
1983 /* Drop any undesired bits. */
1984 addend >>= howto->rightshift;
1985 break;
1986 }
1987
1988 contents = (contents & ~ howto->dst_mask) | (addend & howto->dst_mask);
1989
1990 bfd_put_32 (abfd, contents, address);
1991 }
1992 }
1993 #endif /* USE_REL */
1994
1995 /* Relocate an ARM ELF section. */
1996 static bfd_boolean
1997 elf32_arm_relocate_section (output_bfd, info, input_bfd, input_section,
1998 contents, relocs, local_syms, local_sections)
1999 bfd *output_bfd;
2000 struct bfd_link_info *info;
2001 bfd *input_bfd;
2002 asection *input_section;
2003 bfd_byte *contents;
2004 Elf_Internal_Rela *relocs;
2005 Elf_Internal_Sym *local_syms;
2006 asection **local_sections;
2007 {
2008 Elf_Internal_Shdr *symtab_hdr;
2009 struct elf_link_hash_entry **sym_hashes;
2010 Elf_Internal_Rela *rel;
2011 Elf_Internal_Rela *relend;
2012 const char *name;
2013
2014 #if !USE_REL
2015 if (info->relocatable)
2016 return TRUE;
2017 #endif
2018
2019 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
2020 sym_hashes = elf_sym_hashes (input_bfd);
2021
2022 rel = relocs;
2023 relend = relocs + input_section->reloc_count;
2024 for (; rel < relend; rel++)
2025 {
2026 int r_type;
2027 reloc_howto_type * howto;
2028 unsigned long r_symndx;
2029 Elf_Internal_Sym * sym;
2030 asection * sec;
2031 struct elf_link_hash_entry * h;
2032 bfd_vma relocation;
2033 bfd_reloc_status_type r;
2034 arelent bfd_reloc;
2035
2036 r_symndx = ELF32_R_SYM (rel->r_info);
2037 r_type = ELF32_R_TYPE (rel->r_info);
2038
2039 if ( r_type == R_ARM_GNU_VTENTRY
2040 || r_type == R_ARM_GNU_VTINHERIT)
2041 continue;
2042
2043 elf32_arm_info_to_howto (input_bfd, & bfd_reloc, rel);
2044 howto = bfd_reloc.howto;
2045
2046 #if USE_REL
2047 if (info->relocatable)
2048 {
2049 /* This is a relocatable link. We don't have to change
2050 anything, unless the reloc is against a section symbol,
2051 in which case we have to adjust according to where the
2052 section symbol winds up in the output section. */
2053 if (r_symndx < symtab_hdr->sh_info)
2054 {
2055 sym = local_syms + r_symndx;
2056 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2057 {
2058 sec = local_sections[r_symndx];
2059 arm_add_to_rel (input_bfd, contents + rel->r_offset,
2060 howto,
2061 (bfd_signed_vma) (sec->output_offset
2062 + sym->st_value));
2063 }
2064 }
2065
2066 continue;
2067 }
2068 #endif
2069
2070 /* This is a final link. */
2071 h = NULL;
2072 sym = NULL;
2073 sec = NULL;
2074
2075 if (r_symndx < symtab_hdr->sh_info)
2076 {
2077 sym = local_syms + r_symndx;
2078 sec = local_sections[r_symndx];
2079 #if USE_REL
2080 relocation = (sec->output_section->vma
2081 + sec->output_offset
2082 + sym->st_value);
2083 if ((sec->flags & SEC_MERGE)
2084 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2085 {
2086 asection *msec;
2087 bfd_vma addend, value;
2088
2089 if (howto->rightshift)
2090 {
2091 (*_bfd_error_handler)
2092 (_("%s(%s+0x%lx): %s relocation against SEC_MERGE section"),
2093 bfd_archive_filename (input_bfd),
2094 bfd_get_section_name (input_bfd, input_section),
2095 (long) rel->r_offset, howto->name);
2096 return FALSE;
2097 }
2098
2099 value = bfd_get_32 (input_bfd, contents + rel->r_offset);
2100
2101 /* Get the (signed) value from the instruction. */
2102 addend = value & howto->src_mask;
2103 if (addend & ((howto->src_mask + 1) >> 1))
2104 {
2105 bfd_signed_vma mask;
2106
2107 mask = -1;
2108 mask &= ~ howto->src_mask;
2109 addend |= mask;
2110 }
2111 msec = sec;
2112 addend =
2113 _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend)
2114 - relocation;
2115 addend += msec->output_section->vma + msec->output_offset;
2116 value = (value & ~ howto->dst_mask) | (addend & howto->dst_mask);
2117 bfd_put_32 (input_bfd, value, contents + rel->r_offset);
2118 }
2119 #else
2120 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2121 #endif
2122 }
2123 else
2124 {
2125 bfd_boolean warned;
2126 bfd_boolean unresolved_reloc;
2127
2128 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2129 r_symndx, symtab_hdr, sym_hashes,
2130 h, sec, relocation,
2131 unresolved_reloc, warned);
2132
2133 if (unresolved_reloc || relocation != 0)
2134 {
2135 /* In these cases, we don't need the relocation value.
2136 We check specially because in some obscure cases
2137 sec->output_section will be NULL. */
2138 switch (r_type)
2139 {
2140 case R_ARM_PC24:
2141 case R_ARM_ABS32:
2142 case R_ARM_THM_PC22:
2143 if (info->shared
2144 && (
2145 (!info->symbolic && h->dynindx != -1)
2146 || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
2147 )
2148 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2149 && ((input_section->flags & SEC_ALLOC) != 0
2150 /* DWARF will emit R_ARM_ABS32 relocations in its
2151 sections against symbols defined externally
2152 in shared libraries. We can't do anything
2153 with them here. */
2154 || ((input_section->flags & SEC_DEBUGGING) != 0
2155 && (h->elf_link_hash_flags
2156 & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
2157 )
2158 relocation = 0;
2159 break;
2160
2161 case R_ARM_GOTPC:
2162 relocation = 0;
2163 break;
2164
2165 case R_ARM_GOT32:
2166 if ((WILL_CALL_FINISH_DYNAMIC_SYMBOL
2167 (elf_hash_table (info)->dynamic_sections_created,
2168 info->shared, h))
2169 && (!info->shared
2170 || (!info->symbolic && h->dynindx != -1)
2171 || (h->elf_link_hash_flags
2172 & ELF_LINK_HASH_DEF_REGULAR) == 0))
2173 relocation = 0;
2174 break;
2175
2176 case R_ARM_PLT32:
2177 if (h->plt.offset != (bfd_vma)-1)
2178 relocation = 0;
2179 break;
2180
2181 default:
2182 if (unresolved_reloc)
2183 _bfd_error_handler
2184 (_("%s: warning: unresolvable relocation %d against symbol `%s' from %s section"),
2185 bfd_archive_filename (input_bfd),
2186 r_type,
2187 h->root.root.string,
2188 bfd_get_section_name (input_bfd, input_section));
2189 break;
2190 }
2191 }
2192 }
2193
2194 if (h != NULL)
2195 name = h->root.root.string;
2196 else
2197 {
2198 name = (bfd_elf_string_from_elf_section
2199 (input_bfd, symtab_hdr->sh_link, sym->st_name));
2200 if (name == NULL || *name == '\0')
2201 name = bfd_section_name (input_bfd, sec);
2202 }
2203
2204 r = elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
2205 input_section, contents, rel,
2206 relocation, info, sec, name,
2207 (h ? ELF_ST_TYPE (h->type) :
2208 ELF_ST_TYPE (sym->st_info)), h);
2209
2210 if (r != bfd_reloc_ok)
2211 {
2212 const char * msg = (const char *) 0;
2213
2214 switch (r)
2215 {
2216 case bfd_reloc_overflow:
2217 /* If the overflowing reloc was to an undefined symbol,
2218 we have already printed one error message and there
2219 is no point complaining again. */
2220 if ((! h ||
2221 h->root.type != bfd_link_hash_undefined)
2222 && (!((*info->callbacks->reloc_overflow)
2223 (info, name, howto->name, (bfd_vma) 0,
2224 input_bfd, input_section, rel->r_offset))))
2225 return FALSE;
2226 break;
2227
2228 case bfd_reloc_undefined:
2229 if (!((*info->callbacks->undefined_symbol)
2230 (info, name, input_bfd, input_section,
2231 rel->r_offset, TRUE)))
2232 return FALSE;
2233 break;
2234
2235 case bfd_reloc_outofrange:
2236 msg = _("internal error: out of range error");
2237 goto common_error;
2238
2239 case bfd_reloc_notsupported:
2240 msg = _("internal error: unsupported relocation error");
2241 goto common_error;
2242
2243 case bfd_reloc_dangerous:
2244 msg = _("internal error: dangerous error");
2245 goto common_error;
2246
2247 default:
2248 msg = _("internal error: unknown error");
2249 /* fall through */
2250
2251 common_error:
2252 if (!((*info->callbacks->warning)
2253 (info, msg, name, input_bfd, input_section,
2254 rel->r_offset)))
2255 return FALSE;
2256 break;
2257 }
2258 }
2259 }
2260
2261 return TRUE;
2262 }
2263
2264 /* Set the right machine number. */
2265
2266 static bfd_boolean
2267 elf32_arm_object_p (abfd)
2268 bfd *abfd;
2269 {
2270 unsigned int mach;
2271
2272 mach = bfd_arm_get_mach_from_notes (abfd, ARM_NOTE_SECTION);
2273
2274 if (mach != bfd_mach_arm_unknown)
2275 bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
2276
2277 else if (elf_elfheader (abfd)->e_flags & EF_ARM_MAVERICK_FLOAT)
2278 bfd_default_set_arch_mach (abfd, bfd_arch_arm, bfd_mach_arm_ep9312);
2279
2280 else
2281 bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
2282
2283 return TRUE;
2284 }
2285
2286 /* Function to keep ARM specific flags in the ELF header. */
2287 static bfd_boolean
2288 elf32_arm_set_private_flags (abfd, flags)
2289 bfd *abfd;
2290 flagword flags;
2291 {
2292 if (elf_flags_init (abfd)
2293 && elf_elfheader (abfd)->e_flags != flags)
2294 {
2295 if (EF_ARM_EABI_VERSION (flags) == EF_ARM_EABI_UNKNOWN)
2296 {
2297 if (flags & EF_ARM_INTERWORK)
2298 (*_bfd_error_handler) (_("\
2299 Warning: Not setting interworking flag of %s since it has already been specified as non-interworking"),
2300 bfd_archive_filename (abfd));
2301 else
2302 _bfd_error_handler (_("\
2303 Warning: Clearing the interworking flag of %s due to outside request"),
2304 bfd_archive_filename (abfd));
2305 }
2306 }
2307 else
2308 {
2309 elf_elfheader (abfd)->e_flags = flags;
2310 elf_flags_init (abfd) = TRUE;
2311 }
2312
2313 return TRUE;
2314 }
2315
2316 /* Copy backend specific data from one object module to another. */
2317
2318 static bfd_boolean
2319 elf32_arm_copy_private_bfd_data (ibfd, obfd)
2320 bfd *ibfd;
2321 bfd *obfd;
2322 {
2323 flagword in_flags;
2324 flagword out_flags;
2325
2326 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2327 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2328 return TRUE;
2329
2330 in_flags = elf_elfheader (ibfd)->e_flags;
2331 out_flags = elf_elfheader (obfd)->e_flags;
2332
2333 if (elf_flags_init (obfd)
2334 && EF_ARM_EABI_VERSION (out_flags) == EF_ARM_EABI_UNKNOWN
2335 && in_flags != out_flags)
2336 {
2337 /* Cannot mix APCS26 and APCS32 code. */
2338 if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
2339 return FALSE;
2340
2341 /* Cannot mix float APCS and non-float APCS code. */
2342 if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
2343 return FALSE;
2344
2345 /* If the src and dest have different interworking flags
2346 then turn off the interworking bit. */
2347 if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
2348 {
2349 if (out_flags & EF_ARM_INTERWORK)
2350 _bfd_error_handler (_("\
2351 Warning: Clearing the interworking flag of %s because non-interworking code in %s has been linked with it"),
2352 bfd_get_filename (obfd),
2353 bfd_archive_filename (ibfd));
2354
2355 in_flags &= ~EF_ARM_INTERWORK;
2356 }
2357
2358 /* Likewise for PIC, though don't warn for this case. */
2359 if ((in_flags & EF_ARM_PIC) != (out_flags & EF_ARM_PIC))
2360 in_flags &= ~EF_ARM_PIC;
2361 }
2362
2363 elf_elfheader (obfd)->e_flags = in_flags;
2364 elf_flags_init (obfd) = TRUE;
2365
2366 return TRUE;
2367 }
2368
2369 /* Merge backend specific data from an object file to the output
2370 object file when linking. */
2371
2372 static bfd_boolean
2373 elf32_arm_merge_private_bfd_data (ibfd, obfd)
2374 bfd * ibfd;
2375 bfd * obfd;
2376 {
2377 flagword out_flags;
2378 flagword in_flags;
2379 bfd_boolean flags_compatible = TRUE;
2380 asection *sec;
2381
2382 /* Check if we have the same endianess. */
2383 if (! _bfd_generic_verify_endian_match (ibfd, obfd))
2384 return FALSE;
2385
2386 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2387 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2388 return TRUE;
2389
2390 /* The input BFD must have had its flags initialised. */
2391 /* The following seems bogus to me -- The flags are initialized in
2392 the assembler but I don't think an elf_flags_init field is
2393 written into the object. */
2394 /* BFD_ASSERT (elf_flags_init (ibfd)); */
2395
2396 in_flags = elf_elfheader (ibfd)->e_flags;
2397 out_flags = elf_elfheader (obfd)->e_flags;
2398
2399 if (!elf_flags_init (obfd))
2400 {
2401 /* If the input is the default architecture and had the default
2402 flags then do not bother setting the flags for the output
2403 architecture, instead allow future merges to do this. If no
2404 future merges ever set these flags then they will retain their
2405 uninitialised values, which surprise surprise, correspond
2406 to the default values. */
2407 if (bfd_get_arch_info (ibfd)->the_default
2408 && elf_elfheader (ibfd)->e_flags == 0)
2409 return TRUE;
2410
2411 elf_flags_init (obfd) = TRUE;
2412 elf_elfheader (obfd)->e_flags = in_flags;
2413
2414 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
2415 && bfd_get_arch_info (obfd)->the_default)
2416 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
2417
2418 return TRUE;
2419 }
2420
2421 /* Determine what should happen if the input ARM architecture
2422 does not match the output ARM architecture. */
2423 if (! bfd_arm_merge_machines (ibfd, obfd))
2424 return FALSE;
2425
2426 /* Identical flags must be compatible. */
2427 if (in_flags == out_flags)
2428 return TRUE;
2429
2430 /* Check to see if the input BFD actually contains any sections. If
2431 not, its flags may not have been initialised either, but it
2432 cannot actually cause any incompatibility. Do not short-circuit
2433 dynamic objects; their section list may be emptied by
2434 elf_link_add_object_symbols.
2435
2436 Also check to see if there are no code sections in the input.
2437 In this case there is no need to check for code specific flags.
2438 XXX - do we need to worry about floating-point format compatability
2439 in data sections ? */
2440 if (!(ibfd->flags & DYNAMIC))
2441 {
2442 bfd_boolean null_input_bfd = TRUE;
2443 bfd_boolean only_data_sections = TRUE;
2444
2445 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
2446 {
2447 /* Ignore synthetic glue sections. */
2448 if (strcmp (sec->name, ".glue_7")
2449 && strcmp (sec->name, ".glue_7t"))
2450 {
2451 if ((bfd_get_section_flags (ibfd, sec)
2452 & (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
2453 == (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
2454 only_data_sections = FALSE;
2455
2456 null_input_bfd = FALSE;
2457 break;
2458 }
2459 }
2460
2461 if (null_input_bfd || only_data_sections)
2462 return TRUE;
2463 }
2464
2465 /* Complain about various flag mismatches. */
2466 if (EF_ARM_EABI_VERSION (in_flags) != EF_ARM_EABI_VERSION (out_flags))
2467 {
2468 _bfd_error_handler (_("\
2469 ERROR: %s is compiled for EABI version %d, whereas %s is compiled for version %d"),
2470 bfd_archive_filename (ibfd),
2471 (in_flags & EF_ARM_EABIMASK) >> 24,
2472 bfd_get_filename (obfd),
2473 (out_flags & EF_ARM_EABIMASK) >> 24);
2474 return FALSE;
2475 }
2476
2477 /* Not sure what needs to be checked for EABI versions >= 1. */
2478 if (EF_ARM_EABI_VERSION (in_flags) == EF_ARM_EABI_UNKNOWN)
2479 {
2480 if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
2481 {
2482 _bfd_error_handler (_("\
2483 ERROR: %s is compiled for APCS-%d, whereas target %s uses APCS-%d"),
2484 bfd_archive_filename (ibfd),
2485 in_flags & EF_ARM_APCS_26 ? 26 : 32,
2486 bfd_get_filename (obfd),
2487 out_flags & EF_ARM_APCS_26 ? 26 : 32);
2488 flags_compatible = FALSE;
2489 }
2490
2491 if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
2492 {
2493 if (in_flags & EF_ARM_APCS_FLOAT)
2494 _bfd_error_handler (_("\
2495 ERROR: %s passes floats in float registers, whereas %s passes them in integer registers"),
2496 bfd_archive_filename (ibfd),
2497 bfd_get_filename (obfd));
2498 else
2499 _bfd_error_handler (_("\
2500 ERROR: %s passes floats in integer registers, whereas %s passes them in float registers"),
2501 bfd_archive_filename (ibfd),
2502 bfd_get_filename (obfd));
2503
2504 flags_compatible = FALSE;
2505 }
2506
2507 if ((in_flags & EF_ARM_VFP_FLOAT) != (out_flags & EF_ARM_VFP_FLOAT))
2508 {
2509 if (in_flags & EF_ARM_VFP_FLOAT)
2510 _bfd_error_handler (_("\
2511 ERROR: %s uses VFP instructions, whereas %s does not"),
2512 bfd_archive_filename (ibfd),
2513 bfd_get_filename (obfd));
2514 else
2515 _bfd_error_handler (_("\
2516 ERROR: %s uses FPA instructions, whereas %s does not"),
2517 bfd_archive_filename (ibfd),
2518 bfd_get_filename (obfd));
2519
2520 flags_compatible = FALSE;
2521 }
2522
2523 if ((in_flags & EF_ARM_MAVERICK_FLOAT) != (out_flags & EF_ARM_MAVERICK_FLOAT))
2524 {
2525 if (in_flags & EF_ARM_MAVERICK_FLOAT)
2526 _bfd_error_handler (_("\
2527 ERROR: %s uses Maverick instructions, whereas %s does not"),
2528 bfd_archive_filename (ibfd),
2529 bfd_get_filename (obfd));
2530 else
2531 _bfd_error_handler (_("\
2532 ERROR: %s does not use Maverick instructions, whereas %s does"),
2533 bfd_archive_filename (ibfd),
2534 bfd_get_filename (obfd));
2535
2536 flags_compatible = FALSE;
2537 }
2538
2539 #ifdef EF_ARM_SOFT_FLOAT
2540 if ((in_flags & EF_ARM_SOFT_FLOAT) != (out_flags & EF_ARM_SOFT_FLOAT))
2541 {
2542 /* We can allow interworking between code that is VFP format
2543 layout, and uses either soft float or integer regs for
2544 passing floating point arguments and results. We already
2545 know that the APCS_FLOAT flags match; similarly for VFP
2546 flags. */
2547 if ((in_flags & EF_ARM_APCS_FLOAT) != 0
2548 || (in_flags & EF_ARM_VFP_FLOAT) == 0)
2549 {
2550 if (in_flags & EF_ARM_SOFT_FLOAT)
2551 _bfd_error_handler (_("\
2552 ERROR: %s uses software FP, whereas %s uses hardware FP"),
2553 bfd_archive_filename (ibfd),
2554 bfd_get_filename (obfd));
2555 else
2556 _bfd_error_handler (_("\
2557 ERROR: %s uses hardware FP, whereas %s uses software FP"),
2558 bfd_archive_filename (ibfd),
2559 bfd_get_filename (obfd));
2560
2561 flags_compatible = FALSE;
2562 }
2563 }
2564 #endif
2565
2566 /* Interworking mismatch is only a warning. */
2567 if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
2568 {
2569 if (in_flags & EF_ARM_INTERWORK)
2570 {
2571 _bfd_error_handler (_("\
2572 Warning: %s supports interworking, whereas %s does not"),
2573 bfd_archive_filename (ibfd),
2574 bfd_get_filename (obfd));
2575 }
2576 else
2577 {
2578 _bfd_error_handler (_("\
2579 Warning: %s does not support interworking, whereas %s does"),
2580 bfd_archive_filename (ibfd),
2581 bfd_get_filename (obfd));
2582 }
2583 }
2584 }
2585
2586 return flags_compatible;
2587 }
2588
2589 /* Display the flags field. */
2590
2591 static bfd_boolean
2592 elf32_arm_print_private_bfd_data (abfd, ptr)
2593 bfd *abfd;
2594 PTR ptr;
2595 {
2596 FILE * file = (FILE *) ptr;
2597 unsigned long flags;
2598
2599 BFD_ASSERT (abfd != NULL && ptr != NULL);
2600
2601 /* Print normal ELF private data. */
2602 _bfd_elf_print_private_bfd_data (abfd, ptr);
2603
2604 flags = elf_elfheader (abfd)->e_flags;
2605 /* Ignore init flag - it may not be set, despite the flags field
2606 containing valid data. */
2607
2608 /* xgettext:c-format */
2609 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
2610
2611 switch (EF_ARM_EABI_VERSION (flags))
2612 {
2613 case EF_ARM_EABI_UNKNOWN:
2614 /* The following flag bits are GNU extensions and not part of the
2615 official ARM ELF extended ABI. Hence they are only decoded if
2616 the EABI version is not set. */
2617 if (flags & EF_ARM_INTERWORK)
2618 fprintf (file, _(" [interworking enabled]"));
2619
2620 if (flags & EF_ARM_APCS_26)
2621 fprintf (file, " [APCS-26]");
2622 else
2623 fprintf (file, " [APCS-32]");
2624
2625 if (flags & EF_ARM_VFP_FLOAT)
2626 fprintf (file, _(" [VFP float format]"));
2627 else if (flags & EF_ARM_MAVERICK_FLOAT)
2628 fprintf (file, _(" [Maverick float format]"));
2629 else
2630 fprintf (file, _(" [FPA float format]"));
2631
2632 if (flags & EF_ARM_APCS_FLOAT)
2633 fprintf (file, _(" [floats passed in float registers]"));
2634
2635 if (flags & EF_ARM_PIC)
2636 fprintf (file, _(" [position independent]"));
2637
2638 if (flags & EF_ARM_NEW_ABI)
2639 fprintf (file, _(" [new ABI]"));
2640
2641 if (flags & EF_ARM_OLD_ABI)
2642 fprintf (file, _(" [old ABI]"));
2643
2644 if (flags & EF_ARM_SOFT_FLOAT)
2645 fprintf (file, _(" [software FP]"));
2646
2647 flags &= ~(EF_ARM_INTERWORK | EF_ARM_APCS_26 | EF_ARM_APCS_FLOAT
2648 | EF_ARM_PIC | EF_ARM_NEW_ABI | EF_ARM_OLD_ABI
2649 | EF_ARM_SOFT_FLOAT | EF_ARM_VFP_FLOAT
2650 | EF_ARM_MAVERICK_FLOAT);
2651 break;
2652
2653 case EF_ARM_EABI_VER1:
2654 fprintf (file, _(" [Version1 EABI]"));
2655
2656 if (flags & EF_ARM_SYMSARESORTED)
2657 fprintf (file, _(" [sorted symbol table]"));
2658 else
2659 fprintf (file, _(" [unsorted symbol table]"));
2660
2661 flags &= ~ EF_ARM_SYMSARESORTED;
2662 break;
2663
2664 case EF_ARM_EABI_VER2:
2665 fprintf (file, _(" [Version2 EABI]"));
2666
2667 if (flags & EF_ARM_SYMSARESORTED)
2668 fprintf (file, _(" [sorted symbol table]"));
2669 else
2670 fprintf (file, _(" [unsorted symbol table]"));
2671
2672 if (flags & EF_ARM_DYNSYMSUSESEGIDX)
2673 fprintf (file, _(" [dynamic symbols use segment index]"));
2674
2675 if (flags & EF_ARM_MAPSYMSFIRST)
2676 fprintf (file, _(" [mapping symbols precede others]"));
2677
2678 flags &= ~(EF_ARM_SYMSARESORTED | EF_ARM_DYNSYMSUSESEGIDX
2679 | EF_ARM_MAPSYMSFIRST);
2680 break;
2681
2682 default:
2683 fprintf (file, _(" <EABI version unrecognised>"));
2684 break;
2685 }
2686
2687 flags &= ~ EF_ARM_EABIMASK;
2688
2689 if (flags & EF_ARM_RELEXEC)
2690 fprintf (file, _(" [relocatable executable]"));
2691
2692 if (flags & EF_ARM_HASENTRY)
2693 fprintf (file, _(" [has entry point]"));
2694
2695 flags &= ~ (EF_ARM_RELEXEC | EF_ARM_HASENTRY);
2696
2697 if (flags)
2698 fprintf (file, _("<Unrecognised flag bits set>"));
2699
2700 fputc ('\n', file);
2701
2702 return TRUE;
2703 }
2704
2705 static int
2706 elf32_arm_get_symbol_type (elf_sym, type)
2707 Elf_Internal_Sym * elf_sym;
2708 int type;
2709 {
2710 switch (ELF_ST_TYPE (elf_sym->st_info))
2711 {
2712 case STT_ARM_TFUNC:
2713 return ELF_ST_TYPE (elf_sym->st_info);
2714
2715 case STT_ARM_16BIT:
2716 /* If the symbol is not an object, return the STT_ARM_16BIT flag.
2717 This allows us to distinguish between data used by Thumb instructions
2718 and non-data (which is probably code) inside Thumb regions of an
2719 executable. */
2720 if (type != STT_OBJECT)
2721 return ELF_ST_TYPE (elf_sym->st_info);
2722 break;
2723
2724 default:
2725 break;
2726 }
2727
2728 return type;
2729 }
2730
2731 static asection *
2732 elf32_arm_gc_mark_hook (sec, info, rel, h, sym)
2733 asection *sec;
2734 struct bfd_link_info *info ATTRIBUTE_UNUSED;
2735 Elf_Internal_Rela *rel;
2736 struct elf_link_hash_entry *h;
2737 Elf_Internal_Sym *sym;
2738 {
2739 if (h != NULL)
2740 {
2741 switch (ELF32_R_TYPE (rel->r_info))
2742 {
2743 case R_ARM_GNU_VTINHERIT:
2744 case R_ARM_GNU_VTENTRY:
2745 break;
2746
2747 default:
2748 switch (h->root.type)
2749 {
2750 case bfd_link_hash_defined:
2751 case bfd_link_hash_defweak:
2752 return h->root.u.def.section;
2753
2754 case bfd_link_hash_common:
2755 return h->root.u.c.p->section;
2756
2757 default:
2758 break;
2759 }
2760 }
2761 }
2762 else
2763 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
2764
2765 return NULL;
2766 }
2767
2768 /* Update the got entry reference counts for the section being removed. */
2769
2770 static bfd_boolean
2771 elf32_arm_gc_sweep_hook (abfd, info, sec, relocs)
2772 bfd *abfd ATTRIBUTE_UNUSED;
2773 struct bfd_link_info *info ATTRIBUTE_UNUSED;
2774 asection *sec ATTRIBUTE_UNUSED;
2775 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
2776 {
2777 Elf_Internal_Shdr *symtab_hdr;
2778 struct elf_link_hash_entry **sym_hashes;
2779 bfd_signed_vma *local_got_refcounts;
2780 const Elf_Internal_Rela *rel, *relend;
2781 unsigned long r_symndx;
2782 struct elf_link_hash_entry *h;
2783
2784 elf_section_data (sec)->local_dynrel = NULL;
2785
2786 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2787 sym_hashes = elf_sym_hashes (abfd);
2788 local_got_refcounts = elf_local_got_refcounts (abfd);
2789
2790 relend = relocs + sec->reloc_count;
2791 for (rel = relocs; rel < relend; rel++)
2792 switch (ELF32_R_TYPE (rel->r_info))
2793 {
2794 case R_ARM_GOT32:
2795 r_symndx = ELF32_R_SYM (rel->r_info);
2796 if (r_symndx >= symtab_hdr->sh_info)
2797 {
2798 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2799 if (h->got.refcount > 0)
2800 h->got.refcount -= 1;
2801 }
2802 else if (local_got_refcounts != NULL)
2803 {
2804 if (local_got_refcounts[r_symndx] > 0)
2805 local_got_refcounts[r_symndx] -= 1;
2806 }
2807 break;
2808
2809 case R_ARM_ABS32:
2810 case R_ARM_REL32:
2811 case R_ARM_PC24:
2812 case R_ARM_PLT32:
2813 r_symndx = ELF32_R_SYM (rel->r_info);
2814 if (r_symndx >= symtab_hdr->sh_info)
2815 {
2816 struct elf32_arm_link_hash_entry *eh;
2817 struct elf32_arm_relocs_copied **pp;
2818 struct elf32_arm_relocs_copied *p;
2819
2820 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2821
2822 if (h->plt.refcount > 0)
2823 h->plt.refcount -= 1;
2824
2825 if (ELF32_R_TYPE (rel->r_info) == R_ARM_ABS32
2826 || ELF32_R_TYPE (rel->r_info) == R_ARM_REL32)
2827 {
2828 eh = (struct elf32_arm_link_hash_entry *) h;
2829
2830 for (pp = &eh->relocs_copied; (p = *pp) != NULL;
2831 pp = &p->next)
2832 if (p->section == sec)
2833 {
2834 p->count -= 1;
2835 if (p->count == 0)
2836 *pp = p->next;
2837 break;
2838 }
2839 }
2840 }
2841 break;
2842
2843 default:
2844 break;
2845 }
2846
2847 return TRUE;
2848 }
2849
2850 /* Look through the relocs for a section during the first phase. */
2851
2852 static bfd_boolean
2853 elf32_arm_check_relocs (abfd, info, sec, relocs)
2854 bfd *abfd;
2855 struct bfd_link_info *info;
2856 asection *sec;
2857 const Elf_Internal_Rela *relocs;
2858 {
2859 Elf_Internal_Shdr *symtab_hdr;
2860 struct elf_link_hash_entry **sym_hashes;
2861 struct elf_link_hash_entry **sym_hashes_end;
2862 const Elf_Internal_Rela *rel;
2863 const Elf_Internal_Rela *rel_end;
2864 bfd *dynobj;
2865 asection *sreloc;
2866 bfd_vma *local_got_offsets;
2867 struct elf32_arm_link_hash_table *htab;
2868
2869 if (info->relocatable)
2870 return TRUE;
2871
2872 htab = elf32_arm_hash_table (info);
2873 sreloc = NULL;
2874
2875 dynobj = elf_hash_table (info)->dynobj;
2876 local_got_offsets = elf_local_got_offsets (abfd);
2877
2878 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2879 sym_hashes = elf_sym_hashes (abfd);
2880 sym_hashes_end = sym_hashes
2881 + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
2882
2883 if (!elf_bad_symtab (abfd))
2884 sym_hashes_end -= symtab_hdr->sh_info;
2885
2886 rel_end = relocs + sec->reloc_count;
2887 for (rel = relocs; rel < rel_end; rel++)
2888 {
2889 struct elf_link_hash_entry *h;
2890 unsigned long r_symndx;
2891
2892 r_symndx = ELF32_R_SYM (rel->r_info);
2893 if (r_symndx < symtab_hdr->sh_info)
2894 h = NULL;
2895 else
2896 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2897
2898 switch (ELF32_R_TYPE (rel->r_info))
2899 {
2900 case R_ARM_GOT32:
2901 /* This symbol requires a global offset table entry. */
2902 if (h != NULL)
2903 {
2904 h->got.refcount++;
2905 }
2906 else
2907 {
2908 bfd_signed_vma *local_got_refcounts;
2909
2910 /* This is a global offset table entry for a local symbol. */
2911 local_got_refcounts = elf_local_got_refcounts (abfd);
2912 if (local_got_refcounts == NULL)
2913 {
2914 bfd_size_type size;
2915
2916 size = symtab_hdr->sh_info;
2917 size *= (sizeof (bfd_signed_vma) + sizeof(char));
2918 local_got_refcounts = ((bfd_signed_vma *)
2919 bfd_zalloc (abfd, size));
2920 if (local_got_refcounts == NULL)
2921 return FALSE;
2922 elf_local_got_refcounts (abfd) = local_got_refcounts;
2923 }
2924 local_got_refcounts[r_symndx] += 1;
2925 }
2926 break;
2927
2928 case R_ARM_GOTOFF:
2929 case R_ARM_GOTPC:
2930 if (htab->sgot == NULL)
2931 {
2932 if (htab->root.dynobj == NULL)
2933 htab->root.dynobj = abfd;
2934 if (!create_got_section (htab->root.dynobj, info))
2935 return FALSE;
2936 }
2937 break;
2938
2939 case R_ARM_ABS32:
2940 case R_ARM_REL32:
2941 case R_ARM_PC24:
2942 case R_ARM_PLT32:
2943 if (h != NULL)
2944 {
2945 /* If this reloc is in a read-only section, we might
2946 need a copy reloc. We can't check reliably at this
2947 stage whether the section is read-only, as input
2948 sections have not yet been mapped to output sections.
2949 Tentatively set the flag for now, and correct in
2950 adjust_dynamic_symbol. */
2951 if (!info->shared)
2952 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
2953
2954 /* We may need a .plt entry if the function this reloc
2955 refers to is in a different object. We can't tell for
2956 sure yet, because something later might force the
2957 symbol local. */
2958 if (ELF32_R_TYPE (rel->r_info) == R_ARM_PC24
2959 || ELF32_R_TYPE (rel->r_info) == R_ARM_PLT32)
2960 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2961
2962 /* If we create a PLT entry, this relocation will reference
2963 it, even if it's an ABS32 relocation. */
2964 h->plt.refcount += 1;
2965 }
2966
2967 /* If we are creating a shared library, and this is a reloc
2968 against a global symbol, or a non PC relative reloc
2969 against a local symbol, then we need to copy the reloc
2970 into the shared library. However, if we are linking with
2971 -Bsymbolic, we do not need to copy a reloc against a
2972 global symbol which is defined in an object we are
2973 including in the link (i.e., DEF_REGULAR is set). At
2974 this point we have not seen all the input files, so it is
2975 possible that DEF_REGULAR is not set now but will be set
2976 later (it is never cleared). We account for that
2977 possibility below by storing information in the
2978 relocs_copied field of the hash table entry. */
2979 if (info->shared
2980 && (sec->flags & SEC_ALLOC) != 0
2981 && ((ELF32_R_TYPE (rel->r_info) != R_ARM_PC24
2982 && ELF32_R_TYPE (rel->r_info) != R_ARM_PLT32)
2983 || (h != NULL
2984 && (! info->symbolic
2985 || (h->elf_link_hash_flags
2986 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
2987 {
2988 struct elf32_arm_relocs_copied *p, **head;
2989
2990 /* When creating a shared object, we must copy these
2991 reloc types into the output file. We create a reloc
2992 section in dynobj and make room for this reloc. */
2993 if (sreloc == NULL)
2994 {
2995 const char * name;
2996
2997 name = (bfd_elf_string_from_elf_section
2998 (abfd,
2999 elf_elfheader (abfd)->e_shstrndx,
3000 elf_section_data (sec)->rel_hdr.sh_name));
3001 if (name == NULL)
3002 return FALSE;
3003
3004 BFD_ASSERT (strncmp (name, ".rel", 4) == 0
3005 && strcmp (bfd_get_section_name (abfd, sec),
3006 name + 4) == 0);
3007
3008 sreloc = bfd_get_section_by_name (dynobj, name);
3009 if (sreloc == NULL)
3010 {
3011 flagword flags;
3012
3013 sreloc = bfd_make_section (dynobj, name);
3014 flags = (SEC_HAS_CONTENTS | SEC_READONLY
3015 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3016 if ((sec->flags & SEC_ALLOC) != 0)
3017 flags |= SEC_ALLOC | SEC_LOAD;
3018 if (sreloc == NULL
3019 || ! bfd_set_section_flags (dynobj, sreloc, flags)
3020 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
3021 return FALSE;
3022 }
3023
3024 elf_section_data (sec)->sreloc = sreloc;
3025 }
3026
3027 /* If this is a global symbol, we count the number of
3028 relocations we need for this symbol. */
3029 if (h != NULL)
3030 {
3031 head = &((struct elf32_arm_link_hash_entry *) h)->relocs_copied;
3032 }
3033 else
3034 {
3035 /* Track dynamic relocs needed for local syms too.
3036 We really need local syms available to do this
3037 easily. Oh well. */
3038
3039 asection *s;
3040 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
3041 sec, r_symndx);
3042 if (s == NULL)
3043 return FALSE;
3044
3045 head = ((struct elf32_arm_relocs_copied **)
3046 &elf_section_data (s)->local_dynrel);
3047 }
3048
3049 p = *head;
3050 if (p == NULL || p->section != sec)
3051 {
3052 bfd_size_type amt = sizeof *p;
3053 p = bfd_alloc (htab->root.dynobj, amt);
3054 if (p == NULL)
3055 return FALSE;
3056 p->next = *head;
3057 *head = p;
3058 p->section = sec;
3059 p->count = 0;
3060 }
3061
3062 if (ELF32_R_TYPE (rel->r_info) == R_ARM_ABS32
3063 || ELF32_R_TYPE (rel->r_info) == R_ARM_REL32)
3064 p->count += 1;
3065 }
3066 break;
3067
3068 /* This relocation describes the C++ object vtable hierarchy.
3069 Reconstruct it for later use during GC. */
3070 case R_ARM_GNU_VTINHERIT:
3071 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
3072 return FALSE;
3073 break;
3074
3075 /* This relocation describes which C++ vtable entries are actually
3076 used. Record for later use during GC. */
3077 case R_ARM_GNU_VTENTRY:
3078 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
3079 return FALSE;
3080 break;
3081 }
3082 }
3083
3084 return TRUE;
3085 }
3086
3087 /* Find the nearest line to a particular section and offset, for error
3088 reporting. This code is a duplicate of the code in elf.c, except
3089 that it also accepts STT_ARM_TFUNC as a symbol that names a function. */
3090
3091 static bfd_boolean
3092 elf32_arm_find_nearest_line
3093 (abfd, section, symbols, offset, filename_ptr, functionname_ptr, line_ptr)
3094 bfd *abfd;
3095 asection *section;
3096 asymbol **symbols;
3097 bfd_vma offset;
3098 const char **filename_ptr;
3099 const char **functionname_ptr;
3100 unsigned int *line_ptr;
3101 {
3102 bfd_boolean found;
3103 const char *filename;
3104 asymbol *func;
3105 bfd_vma low_func;
3106 asymbol **p;
3107
3108 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
3109 filename_ptr, functionname_ptr,
3110 line_ptr, 0,
3111 &elf_tdata (abfd)->dwarf2_find_line_info))
3112 return TRUE;
3113
3114 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
3115 &found, filename_ptr,
3116 functionname_ptr, line_ptr,
3117 &elf_tdata (abfd)->line_info))
3118 return FALSE;
3119
3120 if (found)
3121 return TRUE;
3122
3123 if (symbols == NULL)
3124 return FALSE;
3125
3126 filename = NULL;
3127 func = NULL;
3128 low_func = 0;
3129
3130 for (p = symbols; *p != NULL; p++)
3131 {
3132 elf_symbol_type *q;
3133
3134 q = (elf_symbol_type *) *p;
3135
3136 if (bfd_get_section (&q->symbol) != section)
3137 continue;
3138
3139 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
3140 {
3141 default:
3142 break;
3143 case STT_FILE:
3144 filename = bfd_asymbol_name (&q->symbol);
3145 break;
3146 case STT_NOTYPE:
3147 case STT_FUNC:
3148 case STT_ARM_TFUNC:
3149 if (q->symbol.section == section
3150 && q->symbol.value >= low_func
3151 && q->symbol.value <= offset)
3152 {
3153 func = (asymbol *) q;
3154 low_func = q->symbol.value;
3155 }
3156 break;
3157 }
3158 }
3159
3160 if (func == NULL)
3161 return FALSE;
3162
3163 *filename_ptr = filename;
3164 *functionname_ptr = bfd_asymbol_name (func);
3165 *line_ptr = 0;
3166
3167 return TRUE;
3168 }
3169
3170 /* Adjust a symbol defined by a dynamic object and referenced by a
3171 regular object. The current definition is in some section of the
3172 dynamic object, but we're not including those sections. We have to
3173 change the definition to something the rest of the link can
3174 understand. */
3175
3176 static bfd_boolean
3177 elf32_arm_adjust_dynamic_symbol (info, h)
3178 struct bfd_link_info * info;
3179 struct elf_link_hash_entry * h;
3180 {
3181 bfd * dynobj;
3182 asection * s;
3183 unsigned int power_of_two;
3184
3185 dynobj = elf_hash_table (info)->dynobj;
3186
3187 /* Make sure we know what is going on here. */
3188 BFD_ASSERT (dynobj != NULL
3189 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
3190 || h->weakdef != NULL
3191 || ((h->elf_link_hash_flags
3192 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
3193 && (h->elf_link_hash_flags
3194 & ELF_LINK_HASH_REF_REGULAR) != 0
3195 && (h->elf_link_hash_flags
3196 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
3197
3198 /* If this is a function, put it in the procedure linkage table. We
3199 will fill in the contents of the procedure linkage table later,
3200 when we know the address of the .got section. */
3201 if (h->type == STT_FUNC
3202 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
3203 {
3204 if (h->plt.refcount <= 0
3205 || SYMBOL_CALLS_LOCAL (info, h)
3206 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
3207 && h->root.type == bfd_link_hash_undefweak))
3208 {
3209 /* This case can occur if we saw a PLT32 reloc in an input
3210 file, but the symbol was never referred to by a dynamic
3211 object, or if all references were garbage collected. In
3212 such a case, we don't actually need to build a procedure
3213 linkage table, and we can just do a PC24 reloc instead. */
3214 h->plt.offset = (bfd_vma) -1;
3215 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
3216 }
3217
3218 return TRUE;
3219 }
3220 else
3221 /* It's possible that we incorrectly decided a .plt reloc was
3222 needed for an R_ARM_PC24 reloc to a non-function sym in
3223 check_relocs. We can't decide accurately between function and
3224 non-function syms in check-relocs; Objects loaded later in
3225 the link may change h->type. So fix it now. */
3226 h->plt.offset = (bfd_vma) -1;
3227
3228 /* If this is a weak symbol, and there is a real definition, the
3229 processor independent code will have arranged for us to see the
3230 real definition first, and we can just use the same value. */
3231 if (h->weakdef != NULL)
3232 {
3233 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
3234 || h->weakdef->root.type == bfd_link_hash_defweak);
3235 h->root.u.def.section = h->weakdef->root.u.def.section;
3236 h->root.u.def.value = h->weakdef->root.u.def.value;
3237 return TRUE;
3238 }
3239
3240 /* This is a reference to a symbol defined by a dynamic object which
3241 is not a function. */
3242
3243 /* If we are creating a shared library, we must presume that the
3244 only references to the symbol are via the global offset table.
3245 For such cases we need not do anything here; the relocations will
3246 be handled correctly by relocate_section. */
3247 if (info->shared)
3248 return TRUE;
3249
3250 /* We must allocate the symbol in our .dynbss section, which will
3251 become part of the .bss section of the executable. There will be
3252 an entry for this symbol in the .dynsym section. The dynamic
3253 object will contain position independent code, so all references
3254 from the dynamic object to this symbol will go through the global
3255 offset table. The dynamic linker will use the .dynsym entry to
3256 determine the address it must put in the global offset table, so
3257 both the dynamic object and the regular object will refer to the
3258 same memory location for the variable. */
3259 s = bfd_get_section_by_name (dynobj, ".dynbss");
3260 BFD_ASSERT (s != NULL);
3261
3262 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
3263 copy the initial value out of the dynamic object and into the
3264 runtime process image. We need to remember the offset into the
3265 .rel.bss section we are going to use. */
3266 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
3267 {
3268 asection *srel;
3269
3270 srel = bfd_get_section_by_name (dynobj, ".rel.bss");
3271 BFD_ASSERT (srel != NULL);
3272 srel->_raw_size += sizeof (Elf32_External_Rel);
3273 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
3274 }
3275
3276 /* We need to figure out the alignment required for this symbol. I
3277 have no idea how ELF linkers handle this. */
3278 power_of_two = bfd_log2 (h->size);
3279 if (power_of_two > 3)
3280 power_of_two = 3;
3281
3282 /* Apply the required alignment. */
3283 s->_raw_size = BFD_ALIGN (s->_raw_size,
3284 (bfd_size_type) (1 << power_of_two));
3285 if (power_of_two > bfd_get_section_alignment (dynobj, s))
3286 {
3287 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
3288 return FALSE;
3289 }
3290
3291 /* Define the symbol as being at this point in the section. */
3292 h->root.u.def.section = s;
3293 h->root.u.def.value = s->_raw_size;
3294
3295 /* Increment the section size to make room for the symbol. */
3296 s->_raw_size += h->size;
3297
3298 return TRUE;
3299 }
3300
3301 /* Allocate space in .plt, .got and associated reloc sections for
3302 dynamic relocs. */
3303
3304 static bfd_boolean
3305 allocate_dynrelocs (h, inf)
3306 struct elf_link_hash_entry *h;
3307 PTR inf;
3308 {
3309 struct bfd_link_info *info;
3310 struct elf32_arm_link_hash_table *htab;
3311 struct elf32_arm_link_hash_entry *eh;
3312 struct elf32_arm_relocs_copied *p;
3313
3314 if (h->root.type == bfd_link_hash_indirect)
3315 return TRUE;
3316
3317 if (h->root.type == bfd_link_hash_warning)
3318 /* When warning symbols are created, they **replace** the "real"
3319 entry in the hash table, thus we never get to see the real
3320 symbol in a hash traversal. So look at it now. */
3321 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3322
3323 info = (struct bfd_link_info *) inf;
3324 htab = elf32_arm_hash_table (info);
3325
3326 if (htab->root.dynamic_sections_created
3327 && h->plt.refcount > 0)
3328 {
3329 /* Make sure this symbol is output as a dynamic symbol.
3330 Undefined weak syms won't yet be marked as dynamic. */
3331 if (h->dynindx == -1
3332 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
3333 {
3334 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
3335 return FALSE;
3336 }
3337
3338 if (info->shared
3339 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
3340 {
3341 asection *s = htab->splt;
3342
3343 /* If this is the first .plt entry, make room for the special
3344 first entry. */
3345 if (s->_raw_size == 0)
3346 s->_raw_size += PLT_HEADER_SIZE;
3347
3348 h->plt.offset = s->_raw_size;
3349
3350 /* If this symbol is not defined in a regular file, and we are
3351 not generating a shared library, then set the symbol to this
3352 location in the .plt. This is required to make function
3353 pointers compare as equal between the normal executable and
3354 the shared library. */
3355 if (! info->shared
3356 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3357 {
3358 h->root.u.def.section = s;
3359 h->root.u.def.value = h->plt.offset;
3360 }
3361
3362 /* Make room for this entry. */
3363 s->_raw_size += PLT_ENTRY_SIZE;
3364
3365 /* We also need to make an entry in the .got.plt section, which
3366 will be placed in the .got section by the linker script. */
3367 htab->sgotplt->_raw_size += 4;
3368
3369 /* We also need to make an entry in the .rel.plt section. */
3370 htab->srelplt->_raw_size += sizeof (Elf32_External_Rel);
3371 }
3372 else
3373 {
3374 h->plt.offset = (bfd_vma) -1;
3375 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
3376 }
3377 }
3378 else
3379 {
3380 h->plt.offset = (bfd_vma) -1;
3381 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
3382 }
3383
3384 if (h->got.refcount > 0)
3385 {
3386 asection *s;
3387 bfd_boolean dyn;
3388
3389 /* Make sure this symbol is output as a dynamic symbol.
3390 Undefined weak syms won't yet be marked as dynamic. */
3391 if (h->dynindx == -1
3392 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
3393 {
3394 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
3395 return FALSE;
3396 }
3397
3398 s = htab->sgot;
3399 h->got.offset = s->_raw_size;
3400 s->_raw_size += 4;
3401 dyn = htab->root.dynamic_sections_created;
3402 if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3403 || h->root.type != bfd_link_hash_undefweak)
3404 && (info->shared
3405 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
3406 htab->srelgot->_raw_size += sizeof (Elf32_External_Rel);
3407 }
3408 else
3409 h->got.offset = (bfd_vma) -1;
3410
3411 eh = (struct elf32_arm_link_hash_entry *) h;
3412 if (eh->relocs_copied == NULL)
3413 return TRUE;
3414
3415 /* In the shared -Bsymbolic case, discard space allocated for
3416 dynamic pc-relative relocs against symbols which turn out to be
3417 defined in regular objects. For the normal shared case, discard
3418 space for pc-relative relocs that have become local due to symbol
3419 visibility changes. */
3420
3421 if (info->shared)
3422 {
3423 /* Discard relocs on undefined weak syms with non-default
3424 visibility. */
3425 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
3426 && h->root.type == bfd_link_hash_undefweak)
3427 eh->relocs_copied = NULL;
3428 }
3429 else
3430 {
3431 /* For the non-shared case, discard space for relocs against
3432 symbols which turn out to need copy relocs or are not
3433 dynamic. */
3434
3435 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
3436 && (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
3437 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3438 || (htab->root.dynamic_sections_created
3439 && (h->root.type == bfd_link_hash_undefweak
3440 || h->root.type == bfd_link_hash_undefined))))
3441 {
3442 /* Make sure this symbol is output as a dynamic symbol.
3443 Undefined weak syms won't yet be marked as dynamic. */
3444 if (h->dynindx == -1
3445 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
3446 {
3447 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
3448 return FALSE;
3449 }
3450
3451 /* If that succeeded, we know we'll be keeping all the
3452 relocs. */
3453 if (h->dynindx != -1)
3454 goto keep;
3455 }
3456
3457 eh->relocs_copied = NULL;
3458
3459 keep: ;
3460 }
3461
3462 /* Finally, allocate space. */
3463 for (p = eh->relocs_copied; p != NULL; p = p->next)
3464 {
3465 asection *sreloc = elf_section_data (p->section)->sreloc;
3466 sreloc->_raw_size += p->count * sizeof (Elf32_External_Rel);
3467 }
3468
3469 return TRUE;
3470 }
3471
3472 /* Set the sizes of the dynamic sections. */
3473
3474 static bfd_boolean
3475 elf32_arm_size_dynamic_sections (output_bfd, info)
3476 bfd * output_bfd ATTRIBUTE_UNUSED;
3477 struct bfd_link_info * info;
3478 {
3479 bfd * dynobj;
3480 asection * s;
3481 bfd_boolean plt;
3482 bfd_boolean relocs;
3483 bfd *ibfd;
3484 struct elf32_arm_link_hash_table *htab;
3485
3486 htab = elf32_arm_hash_table (info);
3487 dynobj = elf_hash_table (info)->dynobj;
3488 BFD_ASSERT (dynobj != NULL);
3489
3490 if (elf_hash_table (info)->dynamic_sections_created)
3491 {
3492 /* Set the contents of the .interp section to the interpreter. */
3493 if (info->executable)
3494 {
3495 s = bfd_get_section_by_name (dynobj, ".interp");
3496 BFD_ASSERT (s != NULL);
3497 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
3498 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3499 }
3500 }
3501
3502 /* Set up .got offsets for local syms, and space for local dynamic
3503 relocs. */
3504 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
3505 {
3506 bfd_signed_vma *local_got;
3507 bfd_signed_vma *end_local_got;
3508 char *local_tls_type;
3509 bfd_size_type locsymcount;
3510 Elf_Internal_Shdr *symtab_hdr;
3511 asection *srel;
3512
3513 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
3514 continue;
3515
3516 for (s = ibfd->sections; s != NULL; s = s->next)
3517 {
3518 struct elf32_arm_relocs_copied *p;
3519
3520 for (p = *((struct elf32_arm_relocs_copied **)
3521 &elf_section_data (s)->local_dynrel);
3522 p != NULL;
3523 p = p->next)
3524 {
3525 if (!bfd_is_abs_section (p->section)
3526 && bfd_is_abs_section (p->section->output_section))
3527 {
3528 /* Input section has been discarded, either because
3529 it is a copy of a linkonce section or due to
3530 linker script /DISCARD/, so we'll be discarding
3531 the relocs too. */
3532 }
3533 else if (p->count != 0)
3534 {
3535 srel = elf_section_data (p->section)->sreloc;
3536 srel->_raw_size += p->count * sizeof (Elf32_External_Rel);
3537 if ((p->section->output_section->flags & SEC_READONLY) != 0)
3538 info->flags |= DF_TEXTREL;
3539 }
3540 }
3541 }
3542
3543 local_got = elf_local_got_refcounts (ibfd);
3544 if (!local_got)
3545 continue;
3546
3547 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
3548 locsymcount = symtab_hdr->sh_info;
3549 end_local_got = local_got + locsymcount;
3550 s = htab->sgot;
3551 srel = htab->srelgot;
3552 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
3553 {
3554 if (*local_got > 0)
3555 {
3556 *local_got = s->_raw_size;
3557 s->_raw_size += 4;
3558 if (info->shared)
3559 srel->_raw_size += sizeof (Elf32_External_Rel);
3560 }
3561 else
3562 *local_got = (bfd_vma) -1;
3563 }
3564 }
3565
3566 /* Allocate global sym .plt and .got entries, and space for global
3567 sym dynamic relocs. */
3568 elf_link_hash_traverse (&htab->root, allocate_dynrelocs, (PTR) info);
3569
3570 /* The check_relocs and adjust_dynamic_symbol entry points have
3571 determined the sizes of the various dynamic sections. Allocate
3572 memory for them. */
3573 plt = FALSE;
3574 relocs = FALSE;
3575 for (s = dynobj->sections; s != NULL; s = s->next)
3576 {
3577 const char * name;
3578 bfd_boolean strip;
3579
3580 if ((s->flags & SEC_LINKER_CREATED) == 0)
3581 continue;
3582
3583 /* It's OK to base decisions on the section name, because none
3584 of the dynobj section names depend upon the input files. */
3585 name = bfd_get_section_name (dynobj, s);
3586
3587 strip = FALSE;
3588
3589 if (strcmp (name, ".plt") == 0)
3590 {
3591 if (s->_raw_size == 0)
3592 {
3593 /* Strip this section if we don't need it; see the
3594 comment below. */
3595 strip = TRUE;
3596 }
3597 else
3598 {
3599 /* Remember whether there is a PLT. */
3600 plt = TRUE;
3601 }
3602 }
3603 else if (strncmp (name, ".rel", 4) == 0)
3604 {
3605 if (s->_raw_size == 0)
3606 {
3607 /* If we don't need this section, strip it from the
3608 output file. This is mostly to handle .rel.bss and
3609 .rel.plt. We must create both sections in
3610 create_dynamic_sections, because they must be created
3611 before the linker maps input sections to output
3612 sections. The linker does that before
3613 adjust_dynamic_symbol is called, and it is that
3614 function which decides whether anything needs to go
3615 into these sections. */
3616 strip = TRUE;
3617 }
3618 else
3619 {
3620 /* Remember whether there are any reloc sections other
3621 than .rel.plt. */
3622 if (strcmp (name, ".rel.plt") != 0)
3623 relocs = TRUE;
3624
3625 /* We use the reloc_count field as a counter if we need
3626 to copy relocs into the output file. */
3627 s->reloc_count = 0;
3628 }
3629 }
3630 else if (strncmp (name, ".got", 4) != 0)
3631 {
3632 /* It's not one of our sections, so don't allocate space. */
3633 continue;
3634 }
3635
3636 if (strip)
3637 {
3638 _bfd_strip_section_from_output (info, s);
3639 continue;
3640 }
3641
3642 /* Allocate memory for the section contents. */
3643 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
3644 if (s->contents == NULL && s->_raw_size != 0)
3645 return FALSE;
3646 }
3647
3648 if (elf_hash_table (info)->dynamic_sections_created)
3649 {
3650 /* Add some entries to the .dynamic section. We fill in the
3651 values later, in elf32_arm_finish_dynamic_sections, but we
3652 must add the entries now so that we get the correct size for
3653 the .dynamic section. The DT_DEBUG entry is filled in by the
3654 dynamic linker and used by the debugger. */
3655 #define add_dynamic_entry(TAG, VAL) \
3656 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
3657
3658 if (!info->shared)
3659 {
3660 if (!add_dynamic_entry (DT_DEBUG, 0))
3661 return FALSE;
3662 }
3663
3664 if (plt)
3665 {
3666 if ( !add_dynamic_entry (DT_PLTGOT, 0)
3667 || !add_dynamic_entry (DT_PLTRELSZ, 0)
3668 || !add_dynamic_entry (DT_PLTREL, DT_REL)
3669 || !add_dynamic_entry (DT_JMPREL, 0))
3670 return FALSE;
3671 }
3672
3673 if (relocs)
3674 {
3675 if ( !add_dynamic_entry (DT_REL, 0)
3676 || !add_dynamic_entry (DT_RELSZ, 0)
3677 || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
3678 return FALSE;
3679 }
3680
3681 if ((info->flags & DF_TEXTREL) != 0)
3682 {
3683 if (!add_dynamic_entry (DT_TEXTREL, 0))
3684 return FALSE;
3685 info->flags |= DF_TEXTREL;
3686 }
3687 }
3688 #undef add_synamic_entry
3689
3690 return TRUE;
3691 }
3692
3693 /* Finish up dynamic symbol handling. We set the contents of various
3694 dynamic sections here. */
3695
3696 static bfd_boolean
3697 elf32_arm_finish_dynamic_symbol (output_bfd, info, h, sym)
3698 bfd * output_bfd;
3699 struct bfd_link_info * info;
3700 struct elf_link_hash_entry * h;
3701 Elf_Internal_Sym * sym;
3702 {
3703 bfd * dynobj;
3704
3705 dynobj = elf_hash_table (info)->dynobj;
3706
3707 if (h->plt.offset != (bfd_vma) -1)
3708 {
3709 asection * splt;
3710 asection * sgot;
3711 asection * srel;
3712 bfd_vma plt_index;
3713 bfd_vma got_offset;
3714 Elf_Internal_Rela rel;
3715 bfd_byte *loc;
3716 bfd_vma got_displacement;
3717
3718 /* This symbol has an entry in the procedure linkage table. Set
3719 it up. */
3720
3721 BFD_ASSERT (h->dynindx != -1);
3722
3723 splt = bfd_get_section_by_name (dynobj, ".plt");
3724 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
3725 srel = bfd_get_section_by_name (dynobj, ".rel.plt");
3726 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
3727
3728 /* Get the index in the procedure linkage table which
3729 corresponds to this symbol. This is the index of this symbol
3730 in all the symbols for which we are making plt entries. The
3731 first entry in the procedure linkage table is reserved. */
3732 plt_index = (h->plt.offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
3733
3734 /* Get the offset into the .got table of the entry that
3735 corresponds to this function. Each .got entry is 4 bytes.
3736 The first three are reserved. */
3737 got_offset = (plt_index + 3) * 4;
3738
3739 /* Calculate the displacement between the PLT slot and the
3740 entry in the GOT. */
3741 got_displacement = (sgot->output_section->vma
3742 + sgot->output_offset
3743 + got_offset
3744 - splt->output_section->vma
3745 - splt->output_offset
3746 - h->plt.offset
3747 - 8);
3748
3749 BFD_ASSERT ((got_displacement & 0xf0000000) == 0);
3750
3751 /* Fill in the entry in the procedure linkage table. */
3752 bfd_put_32 (output_bfd, elf32_arm_plt_entry[0] | ((got_displacement & 0x0ff00000) >> 20),
3753 splt->contents + h->plt.offset + 0);
3754 bfd_put_32 (output_bfd, elf32_arm_plt_entry[1] | ((got_displacement & 0x000ff000) >> 12),
3755 splt->contents + h->plt.offset + 4);
3756 bfd_put_32 (output_bfd, elf32_arm_plt_entry[2] | (got_displacement & 0x00000fff),
3757 splt->contents + h->plt.offset + 8);
3758 #ifdef FOUR_WORD_PLT
3759 bfd_put_32 (output_bfd, elf32_arm_plt_entry[3],
3760 splt->contents + h->plt.offset + 12);
3761 #endif
3762
3763 /* Fill in the entry in the global offset table. */
3764 bfd_put_32 (output_bfd,
3765 (splt->output_section->vma
3766 + splt->output_offset),
3767 sgot->contents + got_offset);
3768
3769 /* Fill in the entry in the .rel.plt section. */
3770 rel.r_offset = (sgot->output_section->vma
3771 + sgot->output_offset
3772 + got_offset);
3773 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_JUMP_SLOT);
3774 loc = srel->contents + plt_index * sizeof (Elf32_External_Rel);
3775 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3776
3777 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3778 {
3779 /* Mark the symbol as undefined, rather than as defined in
3780 the .plt section. Leave the value alone. */
3781 sym->st_shndx = SHN_UNDEF;
3782 /* If the symbol is weak, we do need to clear the value.
3783 Otherwise, the PLT entry would provide a definition for
3784 the symbol even if the symbol wasn't defined anywhere,
3785 and so the symbol would never be NULL. */
3786 if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK)
3787 == 0)
3788 sym->st_value = 0;
3789 }
3790 }
3791
3792 if (h->got.offset != (bfd_vma) -1)
3793 {
3794 asection * sgot;
3795 asection * srel;
3796 Elf_Internal_Rela rel;
3797 bfd_byte *loc;
3798
3799 /* This symbol has an entry in the global offset table. Set it
3800 up. */
3801 sgot = bfd_get_section_by_name (dynobj, ".got");
3802 srel = bfd_get_section_by_name (dynobj, ".rel.got");
3803 BFD_ASSERT (sgot != NULL && srel != NULL);
3804
3805 rel.r_offset = (sgot->output_section->vma
3806 + sgot->output_offset
3807 + (h->got.offset &~ (bfd_vma) 1));
3808
3809 /* If this is a static link, or it is a -Bsymbolic link and the
3810 symbol is defined locally or was forced to be local because
3811 of a version file, we just want to emit a RELATIVE reloc.
3812 The entry in the global offset table will already have been
3813 initialized in the relocate_section function. */
3814 if (info->shared
3815 && SYMBOL_REFERENCES_LOCAL (info, h))
3816 {
3817 BFD_ASSERT((h->got.offset & 1) != 0);
3818 rel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
3819 }
3820 else
3821 {
3822 BFD_ASSERT((h->got.offset & 1) == 0);
3823 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
3824 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
3825 }
3826
3827 loc = srel->contents + srel->reloc_count++ * sizeof (Elf32_External_Rel);
3828 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3829 }
3830
3831 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
3832 {
3833 asection * s;
3834 Elf_Internal_Rela rel;
3835 bfd_byte *loc;
3836
3837 /* This symbol needs a copy reloc. Set it up. */
3838 BFD_ASSERT (h->dynindx != -1
3839 && (h->root.type == bfd_link_hash_defined
3840 || h->root.type == bfd_link_hash_defweak));
3841
3842 s = bfd_get_section_by_name (h->root.u.def.section->owner,
3843 ".rel.bss");
3844 BFD_ASSERT (s != NULL);
3845
3846 rel.r_offset = (h->root.u.def.value
3847 + h->root.u.def.section->output_section->vma
3848 + h->root.u.def.section->output_offset);
3849 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_COPY);
3850 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rel);
3851 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3852 }
3853
3854 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3855 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3856 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3857 sym->st_shndx = SHN_ABS;
3858
3859 return TRUE;
3860 }
3861
3862 /* Finish up the dynamic sections. */
3863
3864 static bfd_boolean
3865 elf32_arm_finish_dynamic_sections (output_bfd, info)
3866 bfd * output_bfd;
3867 struct bfd_link_info * info;
3868 {
3869 bfd * dynobj;
3870 asection * sgot;
3871 asection * sdyn;
3872
3873 dynobj = elf_hash_table (info)->dynobj;
3874
3875 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
3876 BFD_ASSERT (sgot != NULL);
3877 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3878
3879 if (elf_hash_table (info)->dynamic_sections_created)
3880 {
3881 asection *splt;
3882 Elf32_External_Dyn *dyncon, *dynconend;
3883
3884 splt = bfd_get_section_by_name (dynobj, ".plt");
3885 BFD_ASSERT (splt != NULL && sdyn != NULL);
3886
3887 dyncon = (Elf32_External_Dyn *) sdyn->contents;
3888 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3889
3890 for (; dyncon < dynconend; dyncon++)
3891 {
3892 Elf_Internal_Dyn dyn;
3893 const char * name;
3894 asection * s;
3895
3896 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3897
3898 switch (dyn.d_tag)
3899 {
3900 default:
3901 break;
3902
3903 case DT_PLTGOT:
3904 name = ".got";
3905 goto get_vma;
3906 case DT_JMPREL:
3907 name = ".rel.plt";
3908 get_vma:
3909 s = bfd_get_section_by_name (output_bfd, name);
3910 BFD_ASSERT (s != NULL);
3911 dyn.d_un.d_ptr = s->vma;
3912 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3913 break;
3914
3915 case DT_PLTRELSZ:
3916 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
3917 BFD_ASSERT (s != NULL);
3918 if (s->_cooked_size != 0)
3919 dyn.d_un.d_val = s->_cooked_size;
3920 else
3921 dyn.d_un.d_val = s->_raw_size;
3922 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3923 break;
3924
3925 case DT_RELSZ:
3926 /* My reading of the SVR4 ABI indicates that the
3927 procedure linkage table relocs (DT_JMPREL) should be
3928 included in the overall relocs (DT_REL). This is
3929 what Solaris does. However, UnixWare can not handle
3930 that case. Therefore, we override the DT_RELSZ entry
3931 here to make it not include the JMPREL relocs. Since
3932 the linker script arranges for .rel.plt to follow all
3933 other relocation sections, we don't have to worry
3934 about changing the DT_REL entry. */
3935 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
3936 if (s != NULL)
3937 {
3938 if (s->_cooked_size != 0)
3939 dyn.d_un.d_val -= s->_cooked_size;
3940 else
3941 dyn.d_un.d_val -= s->_raw_size;
3942 }
3943 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3944 break;
3945
3946 /* Set the bottom bit of DT_INIT/FINI if the
3947 corresponding function is Thumb. */
3948 case DT_INIT:
3949 name = info->init_function;
3950 goto get_sym;
3951 case DT_FINI:
3952 name = info->fini_function;
3953 get_sym:
3954 /* If it wasn't set by elf_bfd_final_link
3955 then there is nothing to adjust. */
3956 if (dyn.d_un.d_val != 0)
3957 {
3958 struct elf_link_hash_entry * eh;
3959
3960 eh = elf_link_hash_lookup (elf_hash_table (info), name,
3961 FALSE, FALSE, TRUE);
3962 if (eh != (struct elf_link_hash_entry *) NULL
3963 && ELF_ST_TYPE (eh->type) == STT_ARM_TFUNC)
3964 {
3965 dyn.d_un.d_val |= 1;
3966 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3967 }
3968 }
3969 break;
3970 }
3971 }
3972
3973 /* Fill in the first entry in the procedure linkage table. */
3974 if (splt->_raw_size > 0)
3975 {
3976 bfd_vma got_displacement;
3977
3978 /* Calculate the displacement between the PLT slot and &GOT[0]. */
3979 got_displacement = (sgot->output_section->vma
3980 + sgot->output_offset
3981 - splt->output_section->vma
3982 - splt->output_offset
3983 - 16);
3984
3985 bfd_put_32 (output_bfd, elf32_arm_plt0_entry[0], splt->contents + 0);
3986 bfd_put_32 (output_bfd, elf32_arm_plt0_entry[1], splt->contents + 4);
3987 bfd_put_32 (output_bfd, elf32_arm_plt0_entry[2], splt->contents + 8);
3988 bfd_put_32 (output_bfd, elf32_arm_plt0_entry[3], splt->contents + 12);
3989 #ifdef FOUR_WORD_PLT
3990 /* The displacement value goes in the otherwise-unused last word of
3991 the second entry. */
3992 bfd_put_32 (output_bfd, got_displacement, splt->contents + 28);
3993 #else
3994 bfd_put_32 (output_bfd, got_displacement, splt->contents + 16);
3995 #endif
3996 }
3997
3998 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3999 really seem like the right value. */
4000 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
4001 }
4002
4003 /* Fill in the first three entries in the global offset table. */
4004 if (sgot->_raw_size > 0)
4005 {
4006 if (sdyn == NULL)
4007 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
4008 else
4009 bfd_put_32 (output_bfd,
4010 sdyn->output_section->vma + sdyn->output_offset,
4011 sgot->contents);
4012 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
4013 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
4014 }
4015
4016 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
4017
4018 return TRUE;
4019 }
4020
4021 static void
4022 elf32_arm_post_process_headers (abfd, link_info)
4023 bfd * abfd;
4024 struct bfd_link_info * link_info ATTRIBUTE_UNUSED;
4025 {
4026 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
4027
4028 i_ehdrp = elf_elfheader (abfd);
4029
4030 i_ehdrp->e_ident[EI_OSABI] = ARM_ELF_OS_ABI_VERSION;
4031 i_ehdrp->e_ident[EI_ABIVERSION] = ARM_ELF_ABI_VERSION;
4032 }
4033
4034 static enum elf_reloc_type_class
4035 elf32_arm_reloc_type_class (rela)
4036 const Elf_Internal_Rela *rela;
4037 {
4038 switch ((int) ELF32_R_TYPE (rela->r_info))
4039 {
4040 case R_ARM_RELATIVE:
4041 return reloc_class_relative;
4042 case R_ARM_JUMP_SLOT:
4043 return reloc_class_plt;
4044 case R_ARM_COPY:
4045 return reloc_class_copy;
4046 default:
4047 return reloc_class_normal;
4048 }
4049 }
4050
4051 static bfd_boolean elf32_arm_section_flags PARAMS ((flagword *, Elf_Internal_Shdr *));
4052 static void elf32_arm_final_write_processing PARAMS ((bfd *, bfd_boolean));
4053
4054 /* Set the right machine number for an Arm ELF file. */
4055
4056 static bfd_boolean
4057 elf32_arm_section_flags (flags, hdr)
4058 flagword *flags;
4059 Elf_Internal_Shdr *hdr;
4060 {
4061 if (hdr->sh_type == SHT_NOTE)
4062 *flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_CONTENTS;
4063
4064 return TRUE;
4065 }
4066
4067 void
4068 elf32_arm_final_write_processing (abfd, linker)
4069 bfd *abfd;
4070 bfd_boolean linker ATTRIBUTE_UNUSED;
4071 {
4072 bfd_arm_update_notes (abfd, ARM_NOTE_SECTION);
4073 }
4074
4075 #define ELF_ARCH bfd_arch_arm
4076 #define ELF_MACHINE_CODE EM_ARM
4077 #ifdef __QNXTARGET__
4078 #define ELF_MAXPAGESIZE 0x1000
4079 #else
4080 #define ELF_MAXPAGESIZE 0x8000
4081 #endif
4082
4083 #define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
4084 #define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
4085 #define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
4086 #define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
4087 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
4088 #define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
4089 #define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
4090
4091 #define elf_backend_get_symbol_type elf32_arm_get_symbol_type
4092 #define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
4093 #define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
4094 #define elf_backend_check_relocs elf32_arm_check_relocs
4095 #define elf_backend_relocate_section elf32_arm_relocate_section
4096 #define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
4097 #define elf_backend_create_dynamic_sections elf32_arm_create_dynamic_sections
4098 #define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
4099 #define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
4100 #define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
4101 #define elf_backend_post_process_headers elf32_arm_post_process_headers
4102 #define elf_backend_reloc_type_class elf32_arm_reloc_type_class
4103 #define elf_backend_object_p elf32_arm_object_p
4104 #define elf_backend_section_flags elf32_arm_section_flags
4105 #define elf_backend_final_write_processing elf32_arm_final_write_processing
4106 #define elf_backend_copy_indirect_symbol elf32_arm_copy_indirect_symbol
4107
4108 #define elf_backend_can_refcount 1
4109 #define elf_backend_can_gc_sections 1
4110 #define elf_backend_plt_readonly 1
4111 #define elf_backend_want_got_plt 1
4112 #define elf_backend_want_plt_sym 0
4113 #if !USE_REL
4114 #define elf_backend_rela_normal 1
4115 #endif
4116
4117 #define elf_backend_got_header_size 12
4118
4119 #include "elf32-target.h"
4120
This page took 0.116051 seconds and 4 git commands to generate.