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