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