2003-10-10 Kei Sakamoto <sakamoto.kei@renesas.com>
[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. */
1049f94e 567 if (info->relocatable)
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. */
1049f94e 623 if (info->relocatable)
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. */
1049f94e 655 if (link_info->relocatable)
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 681 internal_relocs
45d6a902
AM
682 = _bfd_elf_link_read_relocs (abfd, sec, (PTR) NULL,
683 (Elf_Internal_Rela *) NULL, FALSE);
252b5132 684
6cdc0ccc
AM
685 if (internal_relocs == NULL)
686 goto error_return;
252b5132 687
6cdc0ccc
AM
688 irelend = internal_relocs + sec->reloc_count;
689 for (irel = internal_relocs; irel < irelend; irel++)
252b5132
RH
690 {
691 long r_type;
692 unsigned long r_index;
252b5132
RH
693
694 struct elf_link_hash_entry *h;
695
696 r_type = ELF32_R_TYPE (irel->r_info);
697 r_index = ELF32_R_SYM (irel->r_info);
698
9b485d32 699 /* These are the only relocation types we care about. */
ba96a88f 700 if ( r_type != R_ARM_PC24
252b5132
RH
701 && r_type != R_ARM_THM_PC22)
702 continue;
703
704 /* Get the section contents if we haven't done so already. */
705 if (contents == NULL)
706 {
707 /* Get cached copy if it exists. */
708 if (elf_section_data (sec)->this_hdr.contents != NULL)
709 contents = elf_section_data (sec)->this_hdr.contents;
710 else
711 {
712 /* Go get them off disk. */
713 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
714 if (contents == NULL)
715 goto error_return;
9b485d32 716
252b5132 717 if (!bfd_get_section_contents (abfd, sec, contents,
dc810e39 718 (file_ptr) 0, sec->_raw_size))
252b5132
RH
719 goto error_return;
720 }
721 }
722
a7c10850 723 /* If the relocation is not against a symbol it cannot concern us. */
252b5132
RH
724 h = NULL;
725
9b485d32 726 /* We don't care about local symbols. */
252b5132
RH
727 if (r_index < symtab_hdr->sh_info)
728 continue;
729
9b485d32 730 /* This is an external symbol. */
252b5132
RH
731 r_index -= symtab_hdr->sh_info;
732 h = (struct elf_link_hash_entry *)
733 elf_sym_hashes (abfd)[r_index];
734
735 /* If the relocation is against a static symbol it must be within
736 the current section and so cannot be a cross ARM/Thumb relocation. */
737 if (h == NULL)
738 continue;
739
740 switch (r_type)
741 {
742 case R_ARM_PC24:
743 /* This one is a call from arm code. We need to look up
2f0ca46a 744 the target of the call. If it is a thumb target, we
252b5132 745 insert glue. */
252b5132
RH
746 if (ELF_ST_TYPE(h->type) == STT_ARM_TFUNC)
747 record_arm_to_thumb_glue (link_info, h);
748 break;
749
750 case R_ARM_THM_PC22:
f21f3fe0 751 /* This one is a call from thumb code. We look
2f0ca46a 752 up the target of the call. If it is not a thumb
bcbdc74c 753 target, we insert glue. */
252b5132
RH
754 if (ELF_ST_TYPE (h->type) != STT_ARM_TFUNC)
755 record_thumb_to_arm_glue (link_info, h);
756 break;
757
758 default:
759 break;
760 }
761 }
6cdc0ccc
AM
762
763 if (contents != NULL
764 && elf_section_data (sec)->this_hdr.contents != contents)
765 free (contents);
766 contents = NULL;
767
768 if (internal_relocs != NULL
769 && elf_section_data (sec)->relocs != internal_relocs)
770 free (internal_relocs);
771 internal_relocs = NULL;
252b5132
RH
772 }
773
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
427bfd90
NC
932 /* Now go back and fix up the original BL insn to point to here. */
933 ret_offset =
934 /* Address of where the stub is located. */
935 (s->output_section->vma + s->output_offset + my_offset)
936 /* Address of where the BL is located. */
937 - (input_section->output_section->vma + input_section->output_offset + offset)
938 /* Addend in the relocation. */
939 - addend
940 /* Biassing for PC-relative addressing. */
941 - 8;
252b5132
RH
942
943 tmp = bfd_get_32 (input_bfd, hit_data
944 - input_section->vma);
945
946 bfd_put_32 (output_bfd,
dc810e39 947 (bfd_vma) insert_thumb_branch (tmp, ret_offset),
252b5132
RH
948 hit_data - input_section->vma);
949
b34976b6 950 return TRUE;
252b5132
RH
951}
952
9b485d32
NC
953/* Arm code calling a Thumb function. */
954
252b5132
RH
955static int
956elf32_arm_to_thumb_stub (info, name, input_bfd, output_bfd, input_section,
957 hit_data, sym_sec, offset, addend, val)
bcbdc74c
NC
958 struct bfd_link_info * info;
959 const char * name;
960 bfd * input_bfd;
961 bfd * output_bfd;
962 asection * input_section;
963 bfd_byte * hit_data;
964 asection * sym_sec;
965 bfd_vma offset;
966 bfd_signed_vma addend;
967 bfd_vma val;
252b5132
RH
968{
969 unsigned long int tmp;
dc810e39 970 bfd_vma my_offset;
bcbdc74c 971 asection * s;
252b5132 972 long int ret_offset;
bcbdc74c
NC
973 struct elf_link_hash_entry * myh;
974 struct elf32_arm_link_hash_table * globals;
252b5132
RH
975
976 myh = find_arm_glue (info, name, input_bfd);
977 if (myh == NULL)
b34976b6 978 return FALSE;
252b5132
RH
979
980 globals = elf32_arm_hash_table (info);
981
982 BFD_ASSERT (globals != NULL);
983 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
984
985 my_offset = myh->root.u.def.value;
986 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
987 ARM2THUMB_GLUE_SECTION_NAME);
988 BFD_ASSERT (s != NULL);
989 BFD_ASSERT (s->contents != NULL);
990 BFD_ASSERT (s->output_section != NULL);
991
992 if ((my_offset & 0x01) == 0x01)
993 {
994 if (sym_sec != NULL
995 && sym_sec->owner != NULL
996 && !INTERWORK_FLAG (sym_sec->owner))
997 {
8f615d07 998 (*_bfd_error_handler)
9b485d32 999 (_("%s(%s): warning: interworking not enabled."),
8f615d07
AM
1000 bfd_archive_filename (sym_sec->owner), name);
1001 (*_bfd_error_handler)
9b485d32 1002 (_(" first occurrence: %s: arm call to thumb"),
8f615d07 1003 bfd_archive_filename (input_bfd));
252b5132 1004 }
9b485d32 1005
252b5132
RH
1006 --my_offset;
1007 myh->root.u.def.value = my_offset;
1008
dc810e39 1009 bfd_put_32 (output_bfd, (bfd_vma) a2t1_ldr_insn,
252b5132
RH
1010 s->contents + my_offset);
1011
dc810e39 1012 bfd_put_32 (output_bfd, (bfd_vma) a2t2_bx_r12_insn,
252b5132
RH
1013 s->contents + my_offset + 4);
1014
1015 /* It's a thumb address. Add the low order bit. */
1016 bfd_put_32 (output_bfd, val | a2t3_func_addr_insn,
1017 s->contents + my_offset + 8);
1018 }
1019
1020 BFD_ASSERT (my_offset <= globals->arm_glue_size);
1021
1022 tmp = bfd_get_32 (input_bfd, hit_data);
1023 tmp = tmp & 0xFF000000;
1024
9b485d32 1025 /* Somehow these are both 4 too far, so subtract 8. */
dc810e39
AM
1026 ret_offset = (s->output_offset
1027 + my_offset
1028 + s->output_section->vma
1029 - (input_section->output_offset
1030 + input_section->output_section->vma
1031 + offset + addend)
1032 - 8);
9a5aca8c 1033
252b5132
RH
1034 tmp = tmp | ((ret_offset >> 2) & 0x00FFFFFF);
1035
dc810e39 1036 bfd_put_32 (output_bfd, (bfd_vma) tmp, hit_data - input_section->vma);
252b5132 1037
b34976b6 1038 return TRUE;
252b5132
RH
1039}
1040
50d6c878
DJ
1041/* This is the condition under which elf32_arm_finish_dynamic_symbol
1042 will be called from elflink.h. If elflink.h doesn't call our
1043 finish_dynamic_symbol routine, we'll need to do something about
1044 initializing any .plt and .got entries in elf32_arm_relocate_section
1045 and elf32_arm_final_link_relocate. */
1046#define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, SHARED, H) \
1047 ((DYN) \
1048 && ((SHARED) \
1049 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
1050 && ((H)->dynindx != -1 \
1051 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1052
252b5132 1053/* Perform a relocation as part of a final link. */
9b485d32 1054
252b5132
RH
1055static bfd_reloc_status_type
1056elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
1057 input_section, contents, rel, value,
780a67af 1058 info, sym_sec, sym_name, sym_flags, h)
252b5132
RH
1059 reloc_howto_type * howto;
1060 bfd * input_bfd;
1061 bfd * output_bfd;
1062 asection * input_section;
1063 bfd_byte * contents;
1064 Elf_Internal_Rela * rel;
1065 bfd_vma value;
1066 struct bfd_link_info * info;
1067 asection * sym_sec;
1068 const char * sym_name;
dc810e39 1069 int sym_flags;
780a67af 1070 struct elf_link_hash_entry * h;
252b5132
RH
1071{
1072 unsigned long r_type = howto->type;
1073 unsigned long r_symndx;
1074 bfd_byte * hit_data = contents + rel->r_offset;
1075 bfd * dynobj = NULL;
1076 Elf_Internal_Shdr * symtab_hdr;
1077 struct elf_link_hash_entry ** sym_hashes;
1078 bfd_vma * local_got_offsets;
1079 asection * sgot = NULL;
1080 asection * splt = NULL;
1081 asection * sreloc = NULL;
252b5132 1082 bfd_vma addend;
ba96a88f
NC
1083 bfd_signed_vma signed_addend;
1084 struct elf32_arm_link_hash_table * globals;
f21f3fe0 1085
cac15327
NC
1086 /* If the start address has been set, then set the EF_ARM_HASENTRY
1087 flag. Setting this more than once is redundant, but the cost is
1088 not too high, and it keeps the code simple.
99e4ae17 1089
cac15327
NC
1090 The test is done here, rather than somewhere else, because the
1091 start address is only set just before the final link commences.
1092
1093 Note - if the user deliberately sets a start address of 0, the
1094 flag will not be set. */
1095 if (bfd_get_start_address (output_bfd) != 0)
1096 elf_elfheader (output_bfd)->e_flags |= EF_ARM_HASENTRY;
99e4ae17 1097
ba96a88f 1098 globals = elf32_arm_hash_table (info);
f21f3fe0 1099
252b5132
RH
1100 dynobj = elf_hash_table (info)->dynobj;
1101 if (dynobj)
1102 {
1103 sgot = bfd_get_section_by_name (dynobj, ".got");
1104 splt = bfd_get_section_by_name (dynobj, ".plt");
1105 }
1106 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1107 sym_hashes = elf_sym_hashes (input_bfd);
1108 local_got_offsets = elf_local_got_offsets (input_bfd);
1109 r_symndx = ELF32_R_SYM (rel->r_info);
1110
acf8aed4 1111#if USE_REL
ba96a88f
NC
1112 addend = bfd_get_32 (input_bfd, hit_data) & howto->src_mask;
1113
1114 if (addend & ((howto->src_mask + 1) >> 1))
1115 {
1116 signed_addend = -1;
1117 signed_addend &= ~ howto->src_mask;
1118 signed_addend |= addend;
1119 }
1120 else
1121 signed_addend = addend;
252b5132 1122#else
ba96a88f 1123 addend = signed_addend = rel->r_addend;
252b5132 1124#endif
f21f3fe0 1125
252b5132
RH
1126 switch (r_type)
1127 {
1128 case R_ARM_NONE:
1129 return bfd_reloc_ok;
1130
1131 case R_ARM_PC24:
1132 case R_ARM_ABS32:
1133 case R_ARM_REL32:
dfc5f959
NC
1134#ifndef OLD_ARM_ABI
1135 case R_ARM_XPC25:
1136#endif
252b5132 1137 /* When generating a shared object, these relocations are copied
9b485d32 1138 into the output file to be resolved at run time. */
252b5132 1139 if (info->shared
ec338859 1140 && r_symndx != 0
252b5132 1141 && (r_type != R_ARM_PC24
99e4ae17 1142 || (h != NULL
252b5132
RH
1143 && h->dynindx != -1
1144 && (! info->symbolic
1145 || (h->elf_link_hash_flags
1146 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
1147 {
947216bf
AM
1148 Elf_Internal_Rela outrel;
1149 bfd_byte *loc;
b34976b6 1150 bfd_boolean skip, relocate;
f21f3fe0 1151
252b5132
RH
1152 if (sreloc == NULL)
1153 {
1154 const char * name;
f21f3fe0 1155
252b5132
RH
1156 name = (bfd_elf_string_from_elf_section
1157 (input_bfd,
1158 elf_elfheader (input_bfd)->e_shstrndx,
1159 elf_section_data (input_section)->rel_hdr.sh_name));
1160 if (name == NULL)
1161 return bfd_reloc_notsupported;
f21f3fe0 1162
252b5132
RH
1163 BFD_ASSERT (strncmp (name, ".rel", 4) == 0
1164 && strcmp (bfd_get_section_name (input_bfd,
1165 input_section),
1166 name + 4) == 0);
f21f3fe0 1167
252b5132
RH
1168 sreloc = bfd_get_section_by_name (dynobj, name);
1169 BFD_ASSERT (sreloc != NULL);
1170 }
f21f3fe0 1171
b34976b6
AM
1172 skip = FALSE;
1173 relocate = FALSE;
f21f3fe0 1174
c629eae0
JJ
1175 outrel.r_offset =
1176 _bfd_elf_section_offset (output_bfd, info, input_section,
1177 rel->r_offset);
1178 if (outrel.r_offset == (bfd_vma) -1)
b34976b6 1179 skip = TRUE;
0bb2d96a 1180 else if (outrel.r_offset == (bfd_vma) -2)
b34976b6 1181 skip = TRUE, relocate = TRUE;
252b5132
RH
1182 outrel.r_offset += (input_section->output_section->vma
1183 + input_section->output_offset);
f21f3fe0 1184
252b5132 1185 if (skip)
0bb2d96a 1186 memset (&outrel, 0, sizeof outrel);
252b5132
RH
1187 else if (r_type == R_ARM_PC24)
1188 {
1189 BFD_ASSERT (h != NULL && h->dynindx != -1);
0bb2d96a 1190 if ((input_section->flags & SEC_ALLOC) == 0)
b34976b6 1191 relocate = TRUE;
252b5132
RH
1192 outrel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_PC24);
1193 }
1194 else
1195 {
1196 if (h == NULL
1197 || ((info->symbolic || h->dynindx == -1)
1198 && (h->elf_link_hash_flags
1199 & ELF_LINK_HASH_DEF_REGULAR) != 0))
1200 {
b34976b6 1201 relocate = TRUE;
252b5132
RH
1202 outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
1203 }
1204 else
1205 {
1206 BFD_ASSERT (h->dynindx != -1);
0bb2d96a 1207 if ((input_section->flags & SEC_ALLOC) == 0)
b34976b6 1208 relocate = TRUE;
252b5132
RH
1209 outrel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_ABS32);
1210 }
1211 }
f21f3fe0 1212
947216bf
AM
1213 loc = sreloc->contents;
1214 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
1215 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
9a5aca8c 1216
f21f3fe0 1217 /* If this reloc is against an external symbol, we do not want to
252b5132 1218 fiddle with the addend. Otherwise, we need to include the symbol
9b485d32 1219 value so that it becomes an addend for the dynamic reloc. */
252b5132
RH
1220 if (! relocate)
1221 return bfd_reloc_ok;
9a5aca8c 1222
f21f3fe0 1223 return _bfd_final_link_relocate (howto, input_bfd, input_section,
252b5132
RH
1224 contents, rel->r_offset, value,
1225 (bfd_vma) 0);
1226 }
1227 else switch (r_type)
1228 {
dfc5f959
NC
1229#ifndef OLD_ARM_ABI
1230 case R_ARM_XPC25: /* Arm BLX instruction. */
1231#endif
1232 case R_ARM_PC24: /* Arm B/BL instruction */
1233#ifndef OLD_ARM_ABI
1234 if (r_type == R_ARM_XPC25)
252b5132 1235 {
dfc5f959
NC
1236 /* Check for Arm calling Arm function. */
1237 /* FIXME: Should we translate the instruction into a BL
1238 instruction instead ? */
1239 if (sym_flags != STT_ARM_TFUNC)
8f615d07 1240 (*_bfd_error_handler) (_("\
dfc5f959 1241%s: Warning: Arm BLX instruction targets Arm function '%s'."),
8f615d07
AM
1242 bfd_archive_filename (input_bfd),
1243 h ? h->root.root.string : "(local)");
dfc5f959
NC
1244 }
1245 else
1246#endif
1247 {
1248 /* Check for Arm calling Thumb function. */
1249 if (sym_flags == STT_ARM_TFUNC)
1250 {
1251 elf32_arm_to_thumb_stub (info, sym_name, input_bfd, output_bfd,
1252 input_section, hit_data, sym_sec, rel->r_offset,
1253 signed_addend, value);
1254 return bfd_reloc_ok;
1255 }
252b5132 1256 }
ba96a88f
NC
1257
1258 if ( strcmp (bfd_get_target (input_bfd), "elf32-littlearm-oabi") == 0
1259 || strcmp (bfd_get_target (input_bfd), "elf32-bigarm-oabi") == 0)
1260 {
1261 /* The old way of doing things. Trearing the addend as a
1262 byte sized field and adding in the pipeline offset. */
ba96a88f
NC
1263 value -= (input_section->output_section->vma
1264 + input_section->output_offset);
1265 value -= rel->r_offset;
1266 value += addend;
f21f3fe0 1267
ba96a88f
NC
1268 if (! globals->no_pipeline_knowledge)
1269 value -= 8;
1270 }
1271 else
1272 {
1273 /* The ARM ELF ABI says that this reloc is computed as: S - P + A
1274 where:
1275 S is the address of the symbol in the relocation.
1276 P is address of the instruction being relocated.
1277 A is the addend (extracted from the instruction) in bytes.
f21f3fe0 1278
ba96a88f
NC
1279 S is held in 'value'.
1280 P is the base address of the section containing the instruction
1281 plus the offset of the reloc into that section, ie:
1282 (input_section->output_section->vma +
1283 input_section->output_offset +
1284 rel->r_offset).
1285 A is the addend, converted into bytes, ie:
1286 (signed_addend * 4)
1287
1288 Note: None of these operations have knowledge of the pipeline
1289 size of the processor, thus it is up to the assembler to encode
1290 this information into the addend. */
ba96a88f
NC
1291 value -= (input_section->output_section->vma
1292 + input_section->output_offset);
1293 value -= rel->r_offset;
1294 value += (signed_addend << howto->size);
f21f3fe0 1295
ba96a88f
NC
1296 /* Previous versions of this code also used to add in the pipeline
1297 offset here. This is wrong because the linker is not supposed
1298 to know about such things, and one day it might change. In order
1299 to support old binaries that need the old behaviour however, so
1300 we attempt to detect which ABI was used to create the reloc. */
1301 if (! globals->no_pipeline_knowledge)
f21f3fe0 1302 {
ba96a88f 1303 Elf_Internal_Ehdr * i_ehdrp; /* Elf file header, internal form */
f21f3fe0 1304
ba96a88f 1305 i_ehdrp = elf_elfheader (input_bfd);
f21f3fe0 1306
ba96a88f
NC
1307 if (i_ehdrp->e_ident[EI_OSABI] == 0)
1308 value -= 8;
1309 }
1310 }
23080146 1311
dcb5e6e6
NC
1312 signed_addend = value;
1313 signed_addend >>= howto->rightshift;
9a5aca8c 1314
59f2c4e7
NC
1315 /* It is not an error for an undefined weak reference to be
1316 out of range. Any program that branches to such a symbol
9a5aca8c
AM
1317 is going to crash anyway, so there is no point worrying
1318 about getting the destination exactly right. */
59f2c4e7
NC
1319 if (! h || h->root.type != bfd_link_hash_undefweak)
1320 {
9b485d32 1321 /* Perform a signed range check. */
dcb5e6e6 1322 if ( signed_addend > ((bfd_signed_vma) (howto->dst_mask >> 1))
59f2c4e7
NC
1323 || signed_addend < - ((bfd_signed_vma) ((howto->dst_mask + 1) >> 1)))
1324 return bfd_reloc_overflow;
1325 }
9a5aca8c 1326
dcb5e6e6
NC
1327#ifndef OLD_ARM_ABI
1328 /* If necessary set the H bit in the BLX instruction. */
1329 if (r_type == R_ARM_XPC25 && ((value & 2) == 2))
1330 value = (signed_addend & howto->dst_mask)
1331 | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask))
1332 | (1 << 24);
1333 else
1334#endif
1335 value = (signed_addend & howto->dst_mask)
1336 | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask));
252b5132 1337 break;
f21f3fe0 1338
252b5132
RH
1339 case R_ARM_ABS32:
1340 value += addend;
1341 if (sym_flags == STT_ARM_TFUNC)
1342 value |= 1;
1343 break;
f21f3fe0 1344
252b5132
RH
1345 case R_ARM_REL32:
1346 value -= (input_section->output_section->vma
62efb346 1347 + input_section->output_offset + rel->r_offset);
252b5132
RH
1348 value += addend;
1349 break;
1350 }
f21f3fe0 1351
252b5132
RH
1352 bfd_put_32 (input_bfd, value, hit_data);
1353 return bfd_reloc_ok;
1354
1355 case R_ARM_ABS8:
1356 value += addend;
1357 if ((long) value > 0x7f || (long) value < -0x80)
1358 return bfd_reloc_overflow;
1359
1360 bfd_put_8 (input_bfd, value, hit_data);
1361 return bfd_reloc_ok;
1362
1363 case R_ARM_ABS16:
1364 value += addend;
1365
1366 if ((long) value > 0x7fff || (long) value < -0x8000)
1367 return bfd_reloc_overflow;
1368
1369 bfd_put_16 (input_bfd, value, hit_data);
1370 return bfd_reloc_ok;
1371
1372 case R_ARM_ABS12:
1373 /* Support ldr and str instruction for the arm */
1374 /* Also thumb b (unconditional branch). ??? Really? */
1375 value += addend;
1376
1377 if ((long) value > 0x7ff || (long) value < -0x800)
1378 return bfd_reloc_overflow;
1379
1380 value |= (bfd_get_32 (input_bfd, hit_data) & 0xfffff000);
1381 bfd_put_32 (input_bfd, value, hit_data);
1382 return bfd_reloc_ok;
1383
1384 case R_ARM_THM_ABS5:
9b485d32 1385 /* Support ldr and str instructions for the thumb. */
acf8aed4 1386#if USE_REL
252b5132
RH
1387 /* Need to refetch addend. */
1388 addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
1389 /* ??? Need to determine shift amount from operand size. */
1390 addend >>= howto->rightshift;
1391#endif
1392 value += addend;
1393
1394 /* ??? Isn't value unsigned? */
1395 if ((long) value > 0x1f || (long) value < -0x10)
1396 return bfd_reloc_overflow;
1397
1398 /* ??? Value needs to be properly shifted into place first. */
1399 value |= bfd_get_16 (input_bfd, hit_data) & 0xf83f;
1400 bfd_put_16 (input_bfd, value, hit_data);
1401 return bfd_reloc_ok;
1402
dfc5f959
NC
1403#ifndef OLD_ARM_ABI
1404 case R_ARM_THM_XPC22:
1405#endif
252b5132 1406 case R_ARM_THM_PC22:
dfc5f959 1407 /* Thumb BL (branch long instruction). */
252b5132 1408 {
b34976b6
AM
1409 bfd_vma relocation;
1410 bfd_boolean overflow = FALSE;
1411 bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
1412 bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
df212a7e 1413 bfd_signed_vma reloc_signed_max = ((1 << (howto->bitsize - 1)) - 1) >> howto->rightshift;
ba96a88f 1414 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
b34976b6 1415 bfd_vma check;
252b5132 1416 bfd_signed_vma signed_check;
252b5132 1417
acf8aed4 1418#if USE_REL
252b5132
RH
1419 /* Need to refetch the addend and squish the two 11 bit pieces
1420 together. */
1421 {
ba96a88f
NC
1422 bfd_vma upper = upper_insn & 0x7ff;
1423 bfd_vma lower = lower_insn & 0x7ff;
9b485d32 1424 upper = (upper ^ 0x400) - 0x400; /* Sign extend. */
252b5132 1425 addend = (upper << 12) | (lower << 1);
ba96a88f 1426 signed_addend = addend;
252b5132
RH
1427 }
1428#endif
dfc5f959
NC
1429#ifndef OLD_ARM_ABI
1430 if (r_type == R_ARM_THM_XPC22)
1431 {
1432 /* Check for Thumb to Thumb call. */
1433 /* FIXME: Should we translate the instruction into a BL
1434 instruction instead ? */
1435 if (sym_flags == STT_ARM_TFUNC)
8f615d07 1436 (*_bfd_error_handler) (_("\
dfc5f959 1437%s: Warning: Thumb BLX instruction targets thumb function '%s'."),
8f615d07
AM
1438 bfd_archive_filename (input_bfd),
1439 h ? h->root.root.string : "(local)");
dfc5f959
NC
1440 }
1441 else
1442#endif
252b5132 1443 {
dfc5f959
NC
1444 /* If it is not a call to Thumb, assume call to Arm.
1445 If it is a call relative to a section name, then it is not a
1446 function call at all, but rather a long jump. */
1447 if (sym_flags != STT_ARM_TFUNC && sym_flags != STT_SECTION)
1448 {
1449 if (elf32_thumb_to_arm_stub
1450 (info, sym_name, input_bfd, output_bfd, input_section,
1451 hit_data, sym_sec, rel->r_offset, signed_addend, value))
1452 return bfd_reloc_ok;
1453 else
1454 return bfd_reloc_dangerous;
1455 }
252b5132 1456 }
f21f3fe0 1457
ba96a88f 1458 relocation = value + signed_addend;
f21f3fe0 1459
252b5132 1460 relocation -= (input_section->output_section->vma
ba96a88f
NC
1461 + input_section->output_offset
1462 + rel->r_offset);
9a5aca8c 1463
ba96a88f
NC
1464 if (! globals->no_pipeline_knowledge)
1465 {
9b485d32 1466 Elf_Internal_Ehdr * i_ehdrp; /* Elf file header, internal form. */
9a5aca8c 1467
ba96a88f 1468 i_ehdrp = elf_elfheader (input_bfd);
f21f3fe0 1469
ba96a88f
NC
1470 /* Previous versions of this code also used to add in the pipline
1471 offset here. This is wrong because the linker is not supposed
1472 to know about such things, and one day it might change. In order
1473 to support old binaries that need the old behaviour however, so
1474 we attempt to detect which ABI was used to create the reloc. */
1475 if ( strcmp (bfd_get_target (input_bfd), "elf32-littlearm-oabi") == 0
1476 || strcmp (bfd_get_target (input_bfd), "elf32-bigarm-oabi") == 0
1477 || i_ehdrp->e_ident[EI_OSABI] == 0)
1478 relocation += 4;
1479 }
f21f3fe0 1480
252b5132
RH
1481 check = relocation >> howto->rightshift;
1482
1483 /* If this is a signed value, the rightshift just dropped
1484 leading 1 bits (assuming twos complement). */
1485 if ((bfd_signed_vma) relocation >= 0)
1486 signed_check = check;
1487 else
1488 signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
1489
252b5132 1490 /* Assumes two's complement. */
ba96a88f 1491 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
b34976b6 1492 overflow = TRUE;
252b5132 1493
df425bc0 1494#ifndef OLD_ARM_ABI
4f3c3dbb
NC
1495 if (r_type == R_ARM_THM_XPC22
1496 && ((lower_insn & 0x1800) == 0x0800))
c62e1cc3
NC
1497 /* For a BLX instruction, make sure that the relocation is rounded up
1498 to a word boundary. This follows the semantics of the instruction
1499 which specifies that bit 1 of the target address will come from bit
1500 1 of the base address. */
1501 relocation = (relocation + 2) & ~ 3;
99e4ae17 1502#endif
c62e1cc3
NC
1503 /* Put RELOCATION back into the insn. */
1504 upper_insn = (upper_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 12) & 0x7ff);
1505 lower_insn = (lower_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 1) & 0x7ff);
1506
252b5132
RH
1507 /* Put the relocated value back in the object file: */
1508 bfd_put_16 (input_bfd, upper_insn, hit_data);
1509 bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
1510
1511 return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
1512 }
1513 break;
1514
51c5503b
NC
1515 case R_ARM_THM_PC11:
1516 /* Thumb B (branch) instruction). */
1517 {
6cf9e9fe 1518 bfd_signed_vma relocation;
51c5503b
NC
1519 bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
1520 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
51c5503b
NC
1521 bfd_signed_vma signed_check;
1522
acf8aed4 1523#if USE_REL
51c5503b
NC
1524 /* Need to refetch addend. */
1525 addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
6cf9e9fe
NC
1526 if (addend & ((howto->src_mask + 1) >> 1))
1527 {
1528 signed_addend = -1;
1529 signed_addend &= ~ howto->src_mask;
1530 signed_addend |= addend;
1531 }
1532 else
1533 signed_addend = addend;
1534 /* The value in the insn has been right shifted. We need to
1535 undo this, so that we can perform the address calculation
1536 in terms of bytes. */
1537 signed_addend <<= howto->rightshift;
51c5503b 1538#endif
6cf9e9fe 1539 relocation = value + signed_addend;
51c5503b
NC
1540
1541 relocation -= (input_section->output_section->vma
1542 + input_section->output_offset
1543 + rel->r_offset);
1544
6cf9e9fe
NC
1545 relocation >>= howto->rightshift;
1546 signed_check = relocation;
1547 relocation &= howto->dst_mask;
51c5503b 1548 relocation |= (bfd_get_16 (input_bfd, hit_data) & (~ howto->dst_mask));
cedb70c5 1549
51c5503b
NC
1550 bfd_put_16 (input_bfd, relocation, hit_data);
1551
1552 /* Assumes two's complement. */
1553 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
1554 return bfd_reloc_overflow;
1555
1556 return bfd_reloc_ok;
1557 }
cedb70c5 1558
252b5132
RH
1559 case R_ARM_GNU_VTINHERIT:
1560 case R_ARM_GNU_VTENTRY:
1561 return bfd_reloc_ok;
1562
1563 case R_ARM_COPY:
1564 return bfd_reloc_notsupported;
1565
1566 case R_ARM_GLOB_DAT:
1567 return bfd_reloc_notsupported;
1568
1569 case R_ARM_JUMP_SLOT:
1570 return bfd_reloc_notsupported;
1571
1572 case R_ARM_RELATIVE:
1573 return bfd_reloc_notsupported;
1574
1575 case R_ARM_GOTOFF:
1576 /* Relocation is relative to the start of the
1577 global offset table. */
1578
1579 BFD_ASSERT (sgot != NULL);
1580 if (sgot == NULL)
1581 return bfd_reloc_notsupported;
9a5aca8c 1582
cedb70c5 1583 /* If we are addressing a Thumb function, we need to adjust the
ee29b9fb
RE
1584 address by one, so that attempts to call the function pointer will
1585 correctly interpret it as Thumb code. */
1586 if (sym_flags == STT_ARM_TFUNC)
1587 value += 1;
1588
252b5132
RH
1589 /* Note that sgot->output_offset is not involved in this
1590 calculation. We always want the start of .got. If we
1591 define _GLOBAL_OFFSET_TABLE in a different way, as is
1592 permitted by the ABI, we might have to change this
9b485d32 1593 calculation. */
252b5132 1594 value -= sgot->output_section->vma;
f21f3fe0 1595 return _bfd_final_link_relocate (howto, input_bfd, input_section,
99e4ae17
AJ
1596 contents, rel->r_offset, value,
1597 (bfd_vma) 0);
252b5132
RH
1598
1599 case R_ARM_GOTPC:
a7c10850 1600 /* Use global offset table as symbol value. */
252b5132 1601 BFD_ASSERT (sgot != NULL);
f21f3fe0 1602
252b5132
RH
1603 if (sgot == NULL)
1604 return bfd_reloc_notsupported;
1605
1606 value = sgot->output_section->vma;
f21f3fe0 1607 return _bfd_final_link_relocate (howto, input_bfd, input_section,
99e4ae17
AJ
1608 contents, rel->r_offset, value,
1609 (bfd_vma) 0);
f21f3fe0 1610
252b5132
RH
1611 case R_ARM_GOT32:
1612 /* Relocation is to the entry for this symbol in the
9b485d32 1613 global offset table. */
252b5132
RH
1614 if (sgot == NULL)
1615 return bfd_reloc_notsupported;
f21f3fe0 1616
252b5132
RH
1617 if (h != NULL)
1618 {
1619 bfd_vma off;
50d6c878 1620 bfd_boolean dyn = elf_hash_table (info)->dynamic_sections_created;
f21f3fe0 1621
252b5132
RH
1622 off = h->got.offset;
1623 BFD_ASSERT (off != (bfd_vma) -1);
f21f3fe0 1624
50d6c878
DJ
1625 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
1626 || (info->shared
1627 && (info->symbolic || h->dynindx == -1
1628 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
1629 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
252b5132
RH
1630 {
1631 /* This is actually a static link, or it is a -Bsymbolic link
1632 and the symbol is defined locally. We must initialize this
1633 entry in the global offset table. Since the offset must
1634 always be a multiple of 4, we use the least significant bit
1635 to record whether we have initialized it already.
f21f3fe0 1636
252b5132 1637 When doing a dynamic link, we create a .rel.got relocation
f21f3fe0 1638 entry to initialize the value. This is done in the
9b485d32 1639 finish_dynamic_symbol routine. */
252b5132
RH
1640 if ((off & 1) != 0)
1641 off &= ~1;
1642 else
1643 {
ee29b9fb
RE
1644 /* If we are addressing a Thumb function, we need to
1645 adjust the address by one, so that attempts to
1646 call the function pointer will correctly
1647 interpret it as Thumb code. */
1648 if (sym_flags == STT_ARM_TFUNC)
1649 value |= 1;
1650
252b5132
RH
1651 bfd_put_32 (output_bfd, value, sgot->contents + off);
1652 h->got.offset |= 1;
1653 }
1654 }
f21f3fe0 1655
252b5132
RH
1656 value = sgot->output_offset + off;
1657 }
1658 else
1659 {
1660 bfd_vma off;
f21f3fe0 1661
252b5132
RH
1662 BFD_ASSERT (local_got_offsets != NULL &&
1663 local_got_offsets[r_symndx] != (bfd_vma) -1);
f21f3fe0 1664
252b5132 1665 off = local_got_offsets[r_symndx];
f21f3fe0 1666
252b5132
RH
1667 /* The offset must always be a multiple of 4. We use the
1668 least significant bit to record whether we have already
9b485d32 1669 generated the necessary reloc. */
252b5132
RH
1670 if ((off & 1) != 0)
1671 off &= ~1;
1672 else
1673 {
1674 bfd_put_32 (output_bfd, value, sgot->contents + off);
f21f3fe0 1675
252b5132
RH
1676 if (info->shared)
1677 {
1678 asection * srelgot;
947216bf
AM
1679 Elf_Internal_Rela outrel;
1680 bfd_byte *loc;
f21f3fe0 1681
252b5132
RH
1682 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
1683 BFD_ASSERT (srelgot != NULL);
f21f3fe0 1684
252b5132 1685 outrel.r_offset = (sgot->output_section->vma
f21f3fe0 1686 + sgot->output_offset
252b5132
RH
1687 + off);
1688 outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
947216bf
AM
1689 loc = srelgot->contents;
1690 loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
1691 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
252b5132 1692 }
f21f3fe0 1693
252b5132
RH
1694 local_got_offsets[r_symndx] |= 1;
1695 }
f21f3fe0 1696
252b5132
RH
1697 value = sgot->output_offset + off;
1698 }
9a5aca8c 1699
f21f3fe0 1700 return _bfd_final_link_relocate (howto, input_bfd, input_section,
99e4ae17
AJ
1701 contents, rel->r_offset, value,
1702 (bfd_vma) 0);
f21f3fe0 1703
252b5132
RH
1704 case R_ARM_PLT32:
1705 /* Relocation is to the entry for this symbol in the
1706 procedure linkage table. */
1707
1708 /* Resolve a PLT32 reloc against a local symbol directly,
9b485d32 1709 without using the procedure linkage table. */
252b5132
RH
1710 if (h == NULL)
1711 return _bfd_final_link_relocate (howto, input_bfd, input_section,
99e4ae17
AJ
1712 contents, rel->r_offset, value,
1713 (bfd_vma) 0);
252b5132
RH
1714
1715 if (h->plt.offset == (bfd_vma) -1)
1716 /* We didn't make a PLT entry for this symbol. This
1717 happens when statically linking PIC code, or when
1718 using -Bsymbolic. */
1719 return _bfd_final_link_relocate (howto, input_bfd, input_section,
1720 contents, rel->r_offset, value,
1721 (bfd_vma) 0);
1722
1723 BFD_ASSERT(splt != NULL);
1724 if (splt == NULL)
1725 return bfd_reloc_notsupported;
1726
1727 value = (splt->output_section->vma
1728 + splt->output_offset
1729 + h->plt.offset);
1730 return _bfd_final_link_relocate (howto, input_bfd, input_section,
99e4ae17
AJ
1731 contents, rel->r_offset, value,
1732 (bfd_vma) 0);
f21f3fe0 1733
252b5132
RH
1734 case R_ARM_SBREL32:
1735 return bfd_reloc_notsupported;
1736
1737 case R_ARM_AMP_VCALL9:
1738 return bfd_reloc_notsupported;
1739
1740 case R_ARM_RSBREL32:
1741 return bfd_reloc_notsupported;
1742
1743 case R_ARM_THM_RPC22:
1744 return bfd_reloc_notsupported;
1745
1746 case R_ARM_RREL32:
1747 return bfd_reloc_notsupported;
1748
1749 case R_ARM_RABS32:
1750 return bfd_reloc_notsupported;
1751
1752 case R_ARM_RPC24:
1753 return bfd_reloc_notsupported;
1754
1755 case R_ARM_RBASE:
1756 return bfd_reloc_notsupported;
1757
1758 default:
1759 return bfd_reloc_notsupported;
1760 }
1761}
1762
acf8aed4 1763#if USE_REL
98c1d4aa
NC
1764/* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. */
1765static void
1766arm_add_to_rel (abfd, address, howto, increment)
1767 bfd * abfd;
59f2c4e7 1768 bfd_byte * address;
98c1d4aa
NC
1769 reloc_howto_type * howto;
1770 bfd_signed_vma increment;
1771{
98c1d4aa
NC
1772 bfd_signed_vma addend;
1773
9a5aca8c 1774 if (howto->type == R_ARM_THM_PC22)
98c1d4aa 1775 {
9a5aca8c
AM
1776 int upper_insn, lower_insn;
1777 int upper, lower;
98c1d4aa 1778
9a5aca8c
AM
1779 upper_insn = bfd_get_16 (abfd, address);
1780 lower_insn = bfd_get_16 (abfd, address + 2);
1781 upper = upper_insn & 0x7ff;
1782 lower = lower_insn & 0x7ff;
1783
1784 addend = (upper << 12) | (lower << 1);
ddda4409 1785 addend += increment;
9a5aca8c 1786 addend >>= 1;
98c1d4aa 1787
9a5aca8c
AM
1788 upper_insn = (upper_insn & 0xf800) | ((addend >> 11) & 0x7ff);
1789 lower_insn = (lower_insn & 0xf800) | (addend & 0x7ff);
1790
dc810e39
AM
1791 bfd_put_16 (abfd, (bfd_vma) upper_insn, address);
1792 bfd_put_16 (abfd, (bfd_vma) lower_insn, address + 2);
9a5aca8c
AM
1793 }
1794 else
1795 {
1796 bfd_vma contents;
1797
1798 contents = bfd_get_32 (abfd, address);
1799
1800 /* Get the (signed) value from the instruction. */
1801 addend = contents & howto->src_mask;
1802 if (addend & ((howto->src_mask + 1) >> 1))
1803 {
1804 bfd_signed_vma mask;
1805
1806 mask = -1;
1807 mask &= ~ howto->src_mask;
1808 addend |= mask;
1809 }
1810
1811 /* Add in the increment, (which is a byte value). */
1812 switch (howto->type)
1813 {
1814 default:
1815 addend += increment;
1816 break;
1817
1818 case R_ARM_PC24:
1819 addend <<= howto->size;
dc810e39 1820 addend += increment;
9a5aca8c
AM
1821
1822 /* Should we check for overflow here ? */
1823
1824 /* Drop any undesired bits. */
1825 addend >>= howto->rightshift;
1826 break;
1827 }
1828
1829 contents = (contents & ~ howto->dst_mask) | (addend & howto->dst_mask);
1830
1831 bfd_put_32 (abfd, contents, address);
ddda4409 1832 }
98c1d4aa
NC
1833}
1834#endif /* USE_REL */
252b5132
RH
1835
1836/* Relocate an ARM ELF section. */
b34976b6 1837static bfd_boolean
252b5132
RH
1838elf32_arm_relocate_section (output_bfd, info, input_bfd, input_section,
1839 contents, relocs, local_syms, local_sections)
b34976b6
AM
1840 bfd *output_bfd;
1841 struct bfd_link_info *info;
1842 bfd *input_bfd;
1843 asection *input_section;
1844 bfd_byte *contents;
1845 Elf_Internal_Rela *relocs;
1846 Elf_Internal_Sym *local_syms;
1847 asection **local_sections;
252b5132 1848{
b34976b6
AM
1849 Elf_Internal_Shdr *symtab_hdr;
1850 struct elf_link_hash_entry **sym_hashes;
1851 Elf_Internal_Rela *rel;
1852 Elf_Internal_Rela *relend;
1853 const char *name;
252b5132 1854
acf8aed4 1855#if !USE_REL
1049f94e 1856 if (info->relocatable)
b34976b6 1857 return TRUE;
b491616a
AM
1858#endif
1859
252b5132
RH
1860 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1861 sym_hashes = elf_sym_hashes (input_bfd);
1862
1863 rel = relocs;
1864 relend = relocs + input_section->reloc_count;
1865 for (; rel < relend; rel++)
1866 {
ba96a88f
NC
1867 int r_type;
1868 reloc_howto_type * howto;
1869 unsigned long r_symndx;
1870 Elf_Internal_Sym * sym;
1871 asection * sec;
252b5132 1872 struct elf_link_hash_entry * h;
ba96a88f
NC
1873 bfd_vma relocation;
1874 bfd_reloc_status_type r;
1875 arelent bfd_reloc;
f21f3fe0 1876
252b5132 1877 r_symndx = ELF32_R_SYM (rel->r_info);
ba96a88f 1878 r_type = ELF32_R_TYPE (rel->r_info);
252b5132 1879
ba96a88f
NC
1880 if ( r_type == R_ARM_GNU_VTENTRY
1881 || r_type == R_ARM_GNU_VTINHERIT)
252b5132
RH
1882 continue;
1883
dc810e39 1884 elf32_arm_info_to_howto (input_bfd, & bfd_reloc, rel);
ba96a88f 1885 howto = bfd_reloc.howto;
252b5132 1886
acf8aed4 1887#if USE_REL
1049f94e 1888 if (info->relocatable)
252b5132 1889 {
1049f94e 1890 /* This is a relocatable link. We don't have to change
252b5132
RH
1891 anything, unless the reloc is against a section symbol,
1892 in which case we have to adjust according to where the
1893 section symbol winds up in the output section. */
1894 if (r_symndx < symtab_hdr->sh_info)
1895 {
1896 sym = local_syms + r_symndx;
1897 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1898 {
1899 sec = local_sections[r_symndx];
98c1d4aa 1900 arm_add_to_rel (input_bfd, contents + rel->r_offset,
dc810e39
AM
1901 howto,
1902 (bfd_signed_vma) (sec->output_offset
1903 + sym->st_value));
252b5132
RH
1904 }
1905 }
1906
1907 continue;
1908 }
b491616a 1909#endif
252b5132
RH
1910
1911 /* This is a final link. */
1912 h = NULL;
1913 sym = NULL;
1914 sec = NULL;
9b485d32 1915
252b5132
RH
1916 if (r_symndx < symtab_hdr->sh_info)
1917 {
1918 sym = local_syms + r_symndx;
1919 sec = local_sections[r_symndx];
acf8aed4 1920#if USE_REL
252b5132
RH
1921 relocation = (sec->output_section->vma
1922 + sec->output_offset
1923 + sym->st_value);
f8df10f4
JJ
1924 if ((sec->flags & SEC_MERGE)
1925 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1926 {
1927 asection *msec;
1928 bfd_vma addend, value;
1929
1930 if (howto->rightshift)
1931 {
1932 (*_bfd_error_handler)
1933 (_("%s(%s+0x%lx): %s relocation against SEC_MERGE section"),
1934 bfd_archive_filename (input_bfd),
1935 bfd_get_section_name (input_bfd, input_section),
1936 (long) rel->r_offset, howto->name);
b34976b6 1937 return FALSE;
f8df10f4
JJ
1938 }
1939
1940 value = bfd_get_32 (input_bfd, contents + rel->r_offset);
1941
1942 /* Get the (signed) value from the instruction. */
1943 addend = value & howto->src_mask;
1944 if (addend & ((howto->src_mask + 1) >> 1))
1945 {
1946 bfd_signed_vma mask;
1947
1948 mask = -1;
1949 mask &= ~ howto->src_mask;
1950 addend |= mask;
1951 }
1952 msec = sec;
1953 addend =
c629eae0 1954 _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend)
f8df10f4
JJ
1955 - relocation;
1956 addend += msec->output_section->vma + msec->output_offset;
1957 value = (value & ~ howto->dst_mask) | (addend & howto->dst_mask);
1958 bfd_put_32 (input_bfd, value, contents + rel->r_offset);
1959 }
1960#else
1961 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
1962#endif
252b5132
RH
1963 }
1964 else
1965 {
560e09e9
NC
1966 bfd_boolean warned;
1967 bfd_boolean unresolved_reloc;
1968
1969 RELOC_FOR_GLOBAL_SYMBOL (h, sym_hashes, r_symndx,
1970 symtab_hdr, relocation,
1971 sec, unresolved_reloc, info,
1972 warned);
1973
1974 if (unresolved_reloc || relocation != 0)
252b5132 1975 {
252b5132 1976 /* In these cases, we don't need the relocation value.
f21f3fe0 1977 We check specially because in some obscure cases
9b485d32 1978 sec->output_section will be NULL. */
252b5132
RH
1979 switch (r_type)
1980 {
1981 case R_ARM_PC24:
1982 case R_ARM_ABS32:
6a360bf4 1983 case R_ARM_THM_PC22:
252b5132
RH
1984 if (info->shared
1985 && (
99e4ae17 1986 (!info->symbolic && h->dynindx != -1)
97eaf9de 1987 || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
252b5132 1988 )
05924f36
PB
1989 && ((input_section->flags & SEC_ALLOC) != 0
1990 /* DWARF will emit R_ARM_ABS32 relocations in its
1991 sections against symbols defined externally
1992 in shared libraries. We can't do anything
1993 with them here. */
1994 || ((input_section->flags & SEC_DEBUGGING) != 0
1995 && (h->elf_link_hash_flags
1996 & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
252b5132 1997 )
560e09e9 1998 relocation = 0;
252b5132 1999 break;
f21f3fe0 2000
252b5132 2001 case R_ARM_GOTPC:
560e09e9 2002 relocation = 0;
252b5132 2003 break;
f21f3fe0 2004
252b5132 2005 case R_ARM_GOT32:
50d6c878 2006 if ((WILL_CALL_FINISH_DYNAMIC_SYMBOL
560e09e9 2007 (elf_hash_table (info)->dynamic_sections_created,
50d6c878
DJ
2008 info->shared, h))
2009 && (!info->shared
252b5132 2010 || (!info->symbolic && h->dynindx != -1)
50d6c878
DJ
2011 || (h->elf_link_hash_flags
2012 & ELF_LINK_HASH_DEF_REGULAR) == 0))
560e09e9 2013 relocation = 0;
252b5132 2014 break;
f21f3fe0 2015
252b5132
RH
2016 case R_ARM_PLT32:
2017 if (h->plt.offset != (bfd_vma)-1)
560e09e9 2018 relocation = 0;
252b5132 2019 break;
f21f3fe0 2020
252b5132 2021 default:
560e09e9
NC
2022 if (unresolved_reloc)
2023 _bfd_error_handler
2024 (_("%s: warning: unresolvable relocation %d against symbol `%s' from %s section"),
2025 bfd_archive_filename (input_bfd),
2026 r_type,
2027 h->root.root.string,
2028 bfd_get_section_name (input_bfd, input_section));
2029 break;
252b5132 2030 }
252b5132
RH
2031 }
2032 }
2033
2034 if (h != NULL)
2035 name = h->root.root.string;
2036 else
2037 {
2038 name = (bfd_elf_string_from_elf_section
2039 (input_bfd, symtab_hdr->sh_link, sym->st_name));
2040 if (name == NULL || *name == '\0')
2041 name = bfd_section_name (input_bfd, sec);
2042 }
f21f3fe0 2043
252b5132
RH
2044 r = elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
2045 input_section, contents, rel,
2046 relocation, info, sec, name,
2047 (h ? ELF_ST_TYPE (h->type) :
780a67af 2048 ELF_ST_TYPE (sym->st_info)), h);
252b5132
RH
2049
2050 if (r != bfd_reloc_ok)
2051 {
2052 const char * msg = (const char *) 0;
2053
2054 switch (r)
2055 {
2056 case bfd_reloc_overflow:
cf919dfd
PB
2057 /* If the overflowing reloc was to an undefined symbol,
2058 we have already printed one error message and there
2059 is no point complaining again. */
2060 if ((! h ||
2061 h->root.type != bfd_link_hash_undefined)
2062 && (!((*info->callbacks->reloc_overflow)
2063 (info, name, howto->name, (bfd_vma) 0,
2064 input_bfd, input_section, rel->r_offset))))
b34976b6 2065 return FALSE;
252b5132
RH
2066 break;
2067
2068 case bfd_reloc_undefined:
2069 if (!((*info->callbacks->undefined_symbol)
2070 (info, name, input_bfd, input_section,
b34976b6
AM
2071 rel->r_offset, TRUE)))
2072 return FALSE;
252b5132
RH
2073 break;
2074
2075 case bfd_reloc_outofrange:
9b485d32 2076 msg = _("internal error: out of range error");
252b5132
RH
2077 goto common_error;
2078
2079 case bfd_reloc_notsupported:
9b485d32 2080 msg = _("internal error: unsupported relocation error");
252b5132
RH
2081 goto common_error;
2082
2083 case bfd_reloc_dangerous:
9b485d32 2084 msg = _("internal error: dangerous error");
252b5132
RH
2085 goto common_error;
2086
2087 default:
9b485d32 2088 msg = _("internal error: unknown error");
252b5132
RH
2089 /* fall through */
2090
2091 common_error:
2092 if (!((*info->callbacks->warning)
2093 (info, msg, name, input_bfd, input_section,
2094 rel->r_offset)))
b34976b6 2095 return FALSE;
252b5132
RH
2096 break;
2097 }
2098 }
2099 }
2100
b34976b6 2101 return TRUE;
252b5132
RH
2102}
2103
c178919b
NC
2104/* Set the right machine number. */
2105
2106static bfd_boolean
2107elf32_arm_object_p (abfd)
2108 bfd *abfd;
2109{
5a6c6817
NC
2110 unsigned int mach;
2111
2112 mach = bfd_arm_get_mach_from_notes (abfd, ARM_NOTE_SECTION);
c178919b 2113
5a6c6817
NC
2114 if (mach != bfd_mach_arm_unknown)
2115 bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
2116
2117 else if (elf_elfheader (abfd)->e_flags & EF_ARM_MAVERICK_FLOAT)
2118 bfd_default_set_arch_mach (abfd, bfd_arch_arm, bfd_mach_arm_ep9312);
e16bb312 2119
e16bb312 2120 else
5a6c6817 2121 bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
c178919b
NC
2122
2123 return TRUE;
2124}
2125
fc830a83 2126/* Function to keep ARM specific flags in the ELF header. */
b34976b6 2127static bfd_boolean
252b5132
RH
2128elf32_arm_set_private_flags (abfd, flags)
2129 bfd *abfd;
2130 flagword flags;
2131{
2132 if (elf_flags_init (abfd)
2133 && elf_elfheader (abfd)->e_flags != flags)
2134 {
fc830a83
NC
2135 if (EF_ARM_EABI_VERSION (flags) == EF_ARM_EABI_UNKNOWN)
2136 {
fd2ec330 2137 if (flags & EF_ARM_INTERWORK)
8f615d07 2138 (*_bfd_error_handler) (_("\
ae1a89b7 2139Warning: Not setting interworking flag of %s since it has already been specified as non-interworking"),
8f615d07 2140 bfd_archive_filename (abfd));
fc830a83 2141 else
63b0f745 2142 _bfd_error_handler (_("\
ae1a89b7 2143Warning: Clearing the interworking flag of %s due to outside request"),
63b0f745 2144 bfd_archive_filename (abfd));
fc830a83 2145 }
252b5132
RH
2146 }
2147 else
2148 {
2149 elf_elfheader (abfd)->e_flags = flags;
b34976b6 2150 elf_flags_init (abfd) = TRUE;
252b5132
RH
2151 }
2152
b34976b6 2153 return TRUE;
252b5132
RH
2154}
2155
fc830a83 2156/* Copy backend specific data from one object module to another. */
9b485d32 2157
b34976b6 2158static bfd_boolean
252b5132
RH
2159elf32_arm_copy_private_bfd_data (ibfd, obfd)
2160 bfd *ibfd;
2161 bfd *obfd;
2162{
2163 flagword in_flags;
2164 flagword out_flags;
2165
fc830a83 2166 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
252b5132 2167 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
b34976b6 2168 return TRUE;
252b5132 2169
fc830a83 2170 in_flags = elf_elfheader (ibfd)->e_flags;
252b5132
RH
2171 out_flags = elf_elfheader (obfd)->e_flags;
2172
fc830a83
NC
2173 if (elf_flags_init (obfd)
2174 && EF_ARM_EABI_VERSION (out_flags) == EF_ARM_EABI_UNKNOWN
2175 && in_flags != out_flags)
252b5132 2176 {
252b5132 2177 /* Cannot mix APCS26 and APCS32 code. */
fd2ec330 2178 if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
b34976b6 2179 return FALSE;
252b5132
RH
2180
2181 /* Cannot mix float APCS and non-float APCS code. */
fd2ec330 2182 if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
b34976b6 2183 return FALSE;
252b5132
RH
2184
2185 /* If the src and dest have different interworking flags
2186 then turn off the interworking bit. */
fd2ec330 2187 if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
252b5132 2188 {
fd2ec330 2189 if (out_flags & EF_ARM_INTERWORK)
63b0f745 2190 _bfd_error_handler (_("\
ae1a89b7 2191Warning: Clearing the interworking flag of %s because non-interworking code in %s has been linked with it"),
06317a27 2192 bfd_get_filename (obfd),
63b0f745 2193 bfd_archive_filename (ibfd));
252b5132 2194
fd2ec330 2195 in_flags &= ~EF_ARM_INTERWORK;
252b5132 2196 }
1006ba19
PB
2197
2198 /* Likewise for PIC, though don't warn for this case. */
fd2ec330
PB
2199 if ((in_flags & EF_ARM_PIC) != (out_flags & EF_ARM_PIC))
2200 in_flags &= ~EF_ARM_PIC;
252b5132
RH
2201 }
2202
2203 elf_elfheader (obfd)->e_flags = in_flags;
b34976b6 2204 elf_flags_init (obfd) = TRUE;
252b5132 2205
b34976b6 2206 return TRUE;
252b5132
RH
2207}
2208
2209/* Merge backend specific data from an object file to the output
2210 object file when linking. */
9b485d32 2211
b34976b6 2212static bfd_boolean
252b5132 2213elf32_arm_merge_private_bfd_data (ibfd, obfd)
fc830a83
NC
2214 bfd * ibfd;
2215 bfd * obfd;
252b5132
RH
2216{
2217 flagword out_flags;
2218 flagword in_flags;
b34976b6
AM
2219 bfd_boolean flags_compatible = TRUE;
2220 bfd_boolean null_input_bfd = TRUE;
cf919dfd 2221 asection *sec;
252b5132 2222
9b485d32 2223 /* Check if we have the same endianess. */
82e51918 2224 if (! _bfd_generic_verify_endian_match (ibfd, obfd))
b34976b6 2225 return FALSE;
1fe494a5 2226
252b5132
RH
2227 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2228 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
b34976b6 2229 return TRUE;
252b5132 2230
252b5132
RH
2231 /* The input BFD must have had its flags initialised. */
2232 /* The following seems bogus to me -- The flags are initialized in
2233 the assembler but I don't think an elf_flags_init field is
9b485d32 2234 written into the object. */
252b5132
RH
2235 /* BFD_ASSERT (elf_flags_init (ibfd)); */
2236
2237 in_flags = elf_elfheader (ibfd)->e_flags;
2238 out_flags = elf_elfheader (obfd)->e_flags;
2239
2240 if (!elf_flags_init (obfd))
2241 {
fe077fa6
NC
2242 /* If the input is the default architecture and had the default
2243 flags then do not bother setting the flags for the output
2244 architecture, instead allow future merges to do this. If no
2245 future merges ever set these flags then they will retain their
2246 uninitialised values, which surprise surprise, correspond
252b5132 2247 to the default values. */
fe077fa6
NC
2248 if (bfd_get_arch_info (ibfd)->the_default
2249 && elf_elfheader (ibfd)->e_flags == 0)
b34976b6 2250 return TRUE;
252b5132 2251
b34976b6 2252 elf_flags_init (obfd) = TRUE;
252b5132
RH
2253 elf_elfheader (obfd)->e_flags = in_flags;
2254
2255 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
2256 && bfd_get_arch_info (obfd)->the_default)
2257 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
2258
b34976b6 2259 return TRUE;
252b5132
RH
2260 }
2261
5a6c6817
NC
2262 /* Determine what should happen if the input ARM architecture
2263 does not match the output ARM architecture. */
2264 if (! bfd_arm_merge_machines (ibfd, obfd))
2265 return FALSE;
e16bb312 2266
1006ba19 2267 /* Identical flags must be compatible. */
252b5132 2268 if (in_flags == out_flags)
b34976b6 2269 return TRUE;
252b5132 2270
cf919dfd
PB
2271 /* Check to see if the input BFD actually contains any sections.
2272 If not, its flags may not have been initialised either, but it cannot
2273 actually cause any incompatibility. */
2274 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
2275 {
2276 /* Ignore synthetic glue sections. */
2277 if (strcmp (sec->name, ".glue_7")
2278 && strcmp (sec->name, ".glue_7t"))
2279 {
b34976b6 2280 null_input_bfd = FALSE;
cf919dfd
PB
2281 break;
2282 }
2283 }
2284 if (null_input_bfd)
b34976b6 2285 return TRUE;
cf919dfd 2286
252b5132 2287 /* Complain about various flag mismatches. */
fc830a83
NC
2288 if (EF_ARM_EABI_VERSION (in_flags) != EF_ARM_EABI_VERSION (out_flags))
2289 {
63b0f745 2290 _bfd_error_handler (_("\
6c571f00 2291ERROR: %s is compiled for EABI version %d, whereas %s is compiled for version %d"),
63b0f745
NC
2292 bfd_archive_filename (ibfd),
2293 (in_flags & EF_ARM_EABIMASK) >> 24,
06317a27 2294 bfd_get_filename (obfd),
63b0f745 2295 (out_flags & EF_ARM_EABIMASK) >> 24);
b34976b6 2296 return FALSE;
fc830a83 2297 }
252b5132 2298
1006ba19
PB
2299 /* Not sure what needs to be checked for EABI versions >= 1. */
2300 if (EF_ARM_EABI_VERSION (in_flags) == EF_ARM_EABI_UNKNOWN)
2301 {
fd2ec330 2302 if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
1006ba19 2303 {
63b0f745 2304 _bfd_error_handler (_("\
6c571f00 2305ERROR: %s is compiled for APCS-%d, whereas target %s uses APCS-%d"),
63b0f745
NC
2306 bfd_archive_filename (ibfd),
2307 in_flags & EF_ARM_APCS_26 ? 26 : 32,
06317a27 2308 bfd_get_filename (obfd),
63b0f745 2309 out_flags & EF_ARM_APCS_26 ? 26 : 32);
b34976b6 2310 flags_compatible = FALSE;
1006ba19 2311 }
252b5132 2312
fd2ec330 2313 if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
1006ba19 2314 {
5eefb65f
NC
2315 if (in_flags & EF_ARM_APCS_FLOAT)
2316 _bfd_error_handler (_("\
6c571f00 2317ERROR: %s passes floats in float registers, whereas %s passes them in integer registers"),
5eefb65f
NC
2318 bfd_archive_filename (ibfd),
2319 bfd_get_filename (obfd));
2320 else
2321 _bfd_error_handler (_("\
6c571f00 2322ERROR: %s passes floats in integer registers, whereas %s passes them in float registers"),
5eefb65f
NC
2323 bfd_archive_filename (ibfd),
2324 bfd_get_filename (obfd));
63b0f745 2325
b34976b6 2326 flags_compatible = FALSE;
1006ba19 2327 }
252b5132 2328
96a846ea 2329 if ((in_flags & EF_ARM_VFP_FLOAT) != (out_flags & EF_ARM_VFP_FLOAT))
1006ba19 2330 {
96a846ea
RE
2331 if (in_flags & EF_ARM_VFP_FLOAT)
2332 _bfd_error_handler (_("\
fde78edd 2333ERROR: %s uses VFP instructions, whereas %s does not"),
5eefb65f
NC
2334 bfd_archive_filename (ibfd),
2335 bfd_get_filename (obfd));
2336 else
96a846ea 2337 _bfd_error_handler (_("\
fde78edd
NC
2338ERROR: %s uses FPA instructions, whereas %s does not"),
2339 bfd_archive_filename (ibfd),
2340 bfd_get_filename (obfd));
2341
2342 flags_compatible = FALSE;
2343 }
2344
2345 if ((in_flags & EF_ARM_MAVERICK_FLOAT) != (out_flags & EF_ARM_MAVERICK_FLOAT))
2346 {
2347 if (in_flags & EF_ARM_MAVERICK_FLOAT)
2348 _bfd_error_handler (_("\
2349ERROR: %s uses Maverick instructions, whereas %s does not"),
2350 bfd_archive_filename (ibfd),
2351 bfd_get_filename (obfd));
2352 else
2353 _bfd_error_handler (_("\
2354ERROR: %s uses Maverick instructions, whereas %s does not"),
5eefb65f
NC
2355 bfd_archive_filename (ibfd),
2356 bfd_get_filename (obfd));
63b0f745 2357
b34976b6 2358 flags_compatible = FALSE;
1006ba19 2359 }
96a846ea
RE
2360
2361#ifdef EF_ARM_SOFT_FLOAT
2362 if ((in_flags & EF_ARM_SOFT_FLOAT) != (out_flags & EF_ARM_SOFT_FLOAT))
2363 {
2364 /* We can allow interworking between code that is VFP format
2365 layout, and uses either soft float or integer regs for
2366 passing floating point arguments and results. We already
2367 know that the APCS_FLOAT flags match; similarly for VFP
2368 flags. */
2369 if ((in_flags & EF_ARM_APCS_FLOAT) != 0
2370 || (in_flags & EF_ARM_VFP_FLOAT) == 0)
2371 {
2372 if (in_flags & EF_ARM_SOFT_FLOAT)
517662d4 2373 _bfd_error_handler (_("\
6c571f00 2374ERROR: %s uses software FP, whereas %s uses hardware FP"),
96a846ea
RE
2375 bfd_archive_filename (ibfd),
2376 bfd_get_filename (obfd));
2377 else
517662d4 2378 _bfd_error_handler (_("\
6c571f00 2379ERROR: %s uses hardware FP, whereas %s uses software FP"),
96a846ea
RE
2380 bfd_archive_filename (ibfd),
2381 bfd_get_filename (obfd));
2382
b34976b6 2383 flags_compatible = FALSE;
96a846ea
RE
2384 }
2385 }
ee43f35e 2386#endif
252b5132 2387
1006ba19 2388 /* Interworking mismatch is only a warning. */
fd2ec330 2389 if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
8f615d07 2390 {
e3c8793a
NC
2391 if (in_flags & EF_ARM_INTERWORK)
2392 {
2393 _bfd_error_handler (_("\
2394Warning: %s supports interworking, whereas %s does not"),
2395 bfd_archive_filename (ibfd),
cedb70c5 2396 bfd_get_filename (obfd));
e3c8793a
NC
2397 }
2398 else
2399 {
2400 _bfd_error_handler (_("\
2401Warning: %s does not support interworking, whereas %s does"),
2402 bfd_archive_filename (ibfd),
2403 bfd_get_filename (obfd));
2404 }
8f615d07 2405 }
252b5132 2406 }
63b0f745 2407
1006ba19 2408 return flags_compatible;
252b5132
RH
2409}
2410
9b485d32
NC
2411/* Display the flags field. */
2412
b34976b6 2413static bfd_boolean
252b5132
RH
2414elf32_arm_print_private_bfd_data (abfd, ptr)
2415 bfd *abfd;
2416 PTR ptr;
2417{
fc830a83
NC
2418 FILE * file = (FILE *) ptr;
2419 unsigned long flags;
252b5132
RH
2420
2421 BFD_ASSERT (abfd != NULL && ptr != NULL);
2422
2423 /* Print normal ELF private data. */
2424 _bfd_elf_print_private_bfd_data (abfd, ptr);
2425
fc830a83 2426 flags = elf_elfheader (abfd)->e_flags;
9b485d32
NC
2427 /* Ignore init flag - it may not be set, despite the flags field
2428 containing valid data. */
252b5132
RH
2429
2430 /* xgettext:c-format */
9b485d32 2431 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
252b5132 2432
fc830a83
NC
2433 switch (EF_ARM_EABI_VERSION (flags))
2434 {
2435 case EF_ARM_EABI_UNKNOWN:
2436 /* The following flag bits are GNU extenstions and not part of the
2437 official ARM ELF extended ABI. Hence they are only decoded if
2438 the EABI version is not set. */
fd2ec330 2439 if (flags & EF_ARM_INTERWORK)
9b485d32 2440 fprintf (file, _(" [interworking enabled]"));
9a5aca8c 2441
fd2ec330 2442 if (flags & EF_ARM_APCS_26)
6c571f00 2443 fprintf (file, " [APCS-26]");
fc830a83 2444 else
6c571f00 2445 fprintf (file, " [APCS-32]");
9a5aca8c 2446
96a846ea
RE
2447 if (flags & EF_ARM_VFP_FLOAT)
2448 fprintf (file, _(" [VFP float format]"));
fde78edd
NC
2449 else if (flags & EF_ARM_MAVERICK_FLOAT)
2450 fprintf (file, _(" [Maverick float format]"));
96a846ea
RE
2451 else
2452 fprintf (file, _(" [FPA float format]"));
2453
fd2ec330 2454 if (flags & EF_ARM_APCS_FLOAT)
9b485d32 2455 fprintf (file, _(" [floats passed in float registers]"));
9a5aca8c 2456
fd2ec330 2457 if (flags & EF_ARM_PIC)
9b485d32 2458 fprintf (file, _(" [position independent]"));
fc830a83 2459
fd2ec330 2460 if (flags & EF_ARM_NEW_ABI)
9b485d32 2461 fprintf (file, _(" [new ABI]"));
9a5aca8c 2462
fd2ec330 2463 if (flags & EF_ARM_OLD_ABI)
9b485d32 2464 fprintf (file, _(" [old ABI]"));
9a5aca8c 2465
fd2ec330 2466 if (flags & EF_ARM_SOFT_FLOAT)
9b485d32 2467 fprintf (file, _(" [software FP]"));
9a5aca8c 2468
96a846ea
RE
2469 flags &= ~(EF_ARM_INTERWORK | EF_ARM_APCS_26 | EF_ARM_APCS_FLOAT
2470 | EF_ARM_PIC | EF_ARM_NEW_ABI | EF_ARM_OLD_ABI
fde78edd
NC
2471 | EF_ARM_SOFT_FLOAT | EF_ARM_VFP_FLOAT
2472 | EF_ARM_MAVERICK_FLOAT);
fc830a83 2473 break;
9a5aca8c 2474
fc830a83 2475 case EF_ARM_EABI_VER1:
9b485d32 2476 fprintf (file, _(" [Version1 EABI]"));
9a5aca8c 2477
fc830a83 2478 if (flags & EF_ARM_SYMSARESORTED)
9b485d32 2479 fprintf (file, _(" [sorted symbol table]"));
fc830a83 2480 else
9b485d32 2481 fprintf (file, _(" [unsorted symbol table]"));
9a5aca8c 2482
fc830a83
NC
2483 flags &= ~ EF_ARM_SYMSARESORTED;
2484 break;
9a5aca8c 2485
fd2ec330
PB
2486 case EF_ARM_EABI_VER2:
2487 fprintf (file, _(" [Version2 EABI]"));
2488
2489 if (flags & EF_ARM_SYMSARESORTED)
2490 fprintf (file, _(" [sorted symbol table]"));
2491 else
2492 fprintf (file, _(" [unsorted symbol table]"));
2493
2494 if (flags & EF_ARM_DYNSYMSUSESEGIDX)
2495 fprintf (file, _(" [dynamic symbols use segment index]"));
2496
2497 if (flags & EF_ARM_MAPSYMSFIRST)
2498 fprintf (file, _(" [mapping symbols precede others]"));
2499
99e4ae17 2500 flags &= ~(EF_ARM_SYMSARESORTED | EF_ARM_DYNSYMSUSESEGIDX
fd2ec330
PB
2501 | EF_ARM_MAPSYMSFIRST);
2502 break;
2503
fc830a83 2504 default:
9b485d32 2505 fprintf (file, _(" <EABI version unrecognised>"));
fc830a83
NC
2506 break;
2507 }
252b5132 2508
fc830a83 2509 flags &= ~ EF_ARM_EABIMASK;
252b5132 2510
fc830a83 2511 if (flags & EF_ARM_RELEXEC)
9b485d32 2512 fprintf (file, _(" [relocatable executable]"));
252b5132 2513
fc830a83 2514 if (flags & EF_ARM_HASENTRY)
9b485d32 2515 fprintf (file, _(" [has entry point]"));
252b5132 2516
fc830a83
NC
2517 flags &= ~ (EF_ARM_RELEXEC | EF_ARM_HASENTRY);
2518
2519 if (flags)
9b485d32 2520 fprintf (file, _("<Unrecognised flag bits set>"));
9a5aca8c 2521
252b5132
RH
2522 fputc ('\n', file);
2523
b34976b6 2524 return TRUE;
252b5132
RH
2525}
2526
2527static int
2528elf32_arm_get_symbol_type (elf_sym, type)
2529 Elf_Internal_Sym * elf_sym;
2530 int type;
2531{
2f0ca46a
NC
2532 switch (ELF_ST_TYPE (elf_sym->st_info))
2533 {
2534 case STT_ARM_TFUNC:
2535 return ELF_ST_TYPE (elf_sym->st_info);
ce855c42 2536
2f0ca46a
NC
2537 case STT_ARM_16BIT:
2538 /* If the symbol is not an object, return the STT_ARM_16BIT flag.
2539 This allows us to distinguish between data used by Thumb instructions
2540 and non-data (which is probably code) inside Thumb regions of an
2541 executable. */
2542 if (type != STT_OBJECT)
2543 return ELF_ST_TYPE (elf_sym->st_info);
2544 break;
9a5aca8c 2545
ce855c42
NC
2546 default:
2547 break;
2f0ca46a
NC
2548 }
2549
2550 return type;
252b5132 2551}
f21f3fe0 2552
252b5132 2553static asection *
1e2f5b6e
AM
2554elf32_arm_gc_mark_hook (sec, info, rel, h, sym)
2555 asection *sec;
5f771d47 2556 struct bfd_link_info *info ATTRIBUTE_UNUSED;
252b5132
RH
2557 Elf_Internal_Rela *rel;
2558 struct elf_link_hash_entry *h;
2559 Elf_Internal_Sym *sym;
2560{
2561 if (h != NULL)
2562 {
2563 switch (ELF32_R_TYPE (rel->r_info))
2564 {
2565 case R_ARM_GNU_VTINHERIT:
2566 case R_ARM_GNU_VTENTRY:
2567 break;
2568
2569 default:
2570 switch (h->root.type)
2571 {
2572 case bfd_link_hash_defined:
2573 case bfd_link_hash_defweak:
2574 return h->root.u.def.section;
2575
2576 case bfd_link_hash_common:
2577 return h->root.u.c.p->section;
e049a0de
ILT
2578
2579 default:
2580 break;
252b5132
RH
2581 }
2582 }
2583 }
2584 else
1e2f5b6e 2585 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
9ad5cbcf 2586
252b5132
RH
2587 return NULL;
2588}
2589
780a67af
NC
2590/* Update the got entry reference counts for the section being removed. */
2591
b34976b6 2592static bfd_boolean
252b5132 2593elf32_arm_gc_sweep_hook (abfd, info, sec, relocs)
5f771d47
ILT
2594 bfd *abfd ATTRIBUTE_UNUSED;
2595 struct bfd_link_info *info ATTRIBUTE_UNUSED;
2596 asection *sec ATTRIBUTE_UNUSED;
2597 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
252b5132 2598{
780a67af 2599 /* We don't support garbage collection of GOT and PLT relocs yet. */
b34976b6 2600 return TRUE;
252b5132
RH
2601}
2602
780a67af
NC
2603/* Look through the relocs for a section during the first phase. */
2604
b34976b6 2605static bfd_boolean
252b5132 2606elf32_arm_check_relocs (abfd, info, sec, relocs)
b34976b6
AM
2607 bfd *abfd;
2608 struct bfd_link_info *info;
2609 asection *sec;
2610 const Elf_Internal_Rela *relocs;
252b5132 2611{
b34976b6
AM
2612 Elf_Internal_Shdr *symtab_hdr;
2613 struct elf_link_hash_entry **sym_hashes;
2614 struct elf_link_hash_entry **sym_hashes_end;
2615 const Elf_Internal_Rela *rel;
2616 const Elf_Internal_Rela *rel_end;
2617 bfd *dynobj;
2618 asection *sgot, *srelgot, *sreloc;
2619 bfd_vma *local_got_offsets;
9a5aca8c 2620
1049f94e 2621 if (info->relocatable)
b34976b6 2622 return TRUE;
9a5aca8c 2623
252b5132 2624 sgot = srelgot = sreloc = NULL;
9a5aca8c 2625
252b5132
RH
2626 dynobj = elf_hash_table (info)->dynobj;
2627 local_got_offsets = elf_local_got_offsets (abfd);
f21f3fe0 2628
252b5132
RH
2629 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2630 sym_hashes = elf_sym_hashes (abfd);
9b485d32
NC
2631 sym_hashes_end = sym_hashes
2632 + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
2633
252b5132
RH
2634 if (!elf_bad_symtab (abfd))
2635 sym_hashes_end -= symtab_hdr->sh_info;
9b485d32 2636
252b5132
RH
2637 rel_end = relocs + sec->reloc_count;
2638 for (rel = relocs; rel < rel_end; rel++)
2639 {
2640 struct elf_link_hash_entry *h;
2641 unsigned long r_symndx;
9a5aca8c 2642
252b5132
RH
2643 r_symndx = ELF32_R_SYM (rel->r_info);
2644 if (r_symndx < symtab_hdr->sh_info)
2645 h = NULL;
2646 else
2647 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
9a5aca8c 2648
252b5132
RH
2649 /* Some relocs require a global offset table. */
2650 if (dynobj == NULL)
2651 {
2652 switch (ELF32_R_TYPE (rel->r_info))
2653 {
2654 case R_ARM_GOT32:
2655 case R_ARM_GOTOFF:
2656 case R_ARM_GOTPC:
2657 elf_hash_table (info)->dynobj = dynobj = abfd;
2658 if (! _bfd_elf_create_got_section (dynobj, info))
b34976b6 2659 return FALSE;
252b5132
RH
2660 break;
2661
2662 default:
2663 break;
2664 }
2665 }
2666
2667 switch (ELF32_R_TYPE (rel->r_info))
2668 {
2669 case R_ARM_GOT32:
2670 /* This symbol requires a global offset table entry. */
2671 if (sgot == NULL)
2672 {
2673 sgot = bfd_get_section_by_name (dynobj, ".got");
2674 BFD_ASSERT (sgot != NULL);
2675 }
2676
2677 /* Get the got relocation section if necessary. */
2678 if (srelgot == NULL
2679 && (h != NULL || info->shared))
2680 {
2681 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
9a5aca8c 2682
252b5132
RH
2683 /* If no got relocation section, make one and initialize. */
2684 if (srelgot == NULL)
2685 {
2686 srelgot = bfd_make_section (dynobj, ".rel.got");
2687 if (srelgot == NULL
2688 || ! bfd_set_section_flags (dynobj, srelgot,
99e4ae17 2689 (SEC_ALLOC
252b5132
RH
2690 | SEC_LOAD
2691 | SEC_HAS_CONTENTS
2692 | SEC_IN_MEMORY
2693 | SEC_LINKER_CREATED
2694 | SEC_READONLY))
2695 || ! bfd_set_section_alignment (dynobj, srelgot, 2))
b34976b6 2696 return FALSE;
252b5132
RH
2697 }
2698 }
2699
2700 if (h != NULL)
2701 {
2702 if (h->got.offset != (bfd_vma) -1)
2703 /* We have already allocated space in the .got. */
2704 break;
f21f3fe0 2705
252b5132
RH
2706 h->got.offset = sgot->_raw_size;
2707
2708 /* Make sure this symbol is output as a dynamic symbol. */
2709 if (h->dynindx == -1)
2710 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
b34976b6 2711 return FALSE;
252b5132
RH
2712
2713 srelgot->_raw_size += sizeof (Elf32_External_Rel);
2714 }
2715 else
2716 {
99e4ae17 2717 /* This is a global offset table entry for a local
252b5132
RH
2718 symbol. */
2719 if (local_got_offsets == NULL)
2720 {
dc810e39 2721 bfd_size_type size;
63b0f745 2722 unsigned int i;
252b5132 2723
dc810e39
AM
2724 size = symtab_hdr->sh_info;
2725 size *= sizeof (bfd_vma);
252b5132
RH
2726 local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
2727 if (local_got_offsets == NULL)
b34976b6 2728 return FALSE;
252b5132
RH
2729 elf_local_got_offsets (abfd) = local_got_offsets;
2730 for (i = 0; i < symtab_hdr->sh_info; i++)
2731 local_got_offsets[i] = (bfd_vma) -1;
2732 }
f21f3fe0 2733
252b5132
RH
2734 if (local_got_offsets[r_symndx] != (bfd_vma) -1)
2735 /* We have already allocated space in the .got. */
2736 break;
2737
2738 local_got_offsets[r_symndx] = sgot->_raw_size;
2739
2740 if (info->shared)
2741 /* If we are generating a shared object, we need to
2742 output a R_ARM_RELATIVE reloc so that the dynamic
2743 linker can adjust this GOT entry. */
2744 srelgot->_raw_size += sizeof (Elf32_External_Rel);
2745 }
2746
2747 sgot->_raw_size += 4;
2748 break;
2749
99e4ae17 2750 case R_ARM_PLT32:
252b5132
RH
2751 /* This symbol requires a procedure linkage table entry. We
2752 actually build the entry in adjust_dynamic_symbol,
2753 because this might be a case of linking PIC code which is
2754 never referenced by a dynamic object, in which case we
2755 don't need to generate a procedure linkage table entry
2756 after all. */
2757
2758 /* If this is a local symbol, we resolve it directly without
2759 creating a procedure linkage table entry. */
2760 if (h == NULL)
2761 continue;
2762
2763 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2764 break;
2765
2766 case R_ARM_ABS32:
2767 case R_ARM_REL32:
2768 case R_ARM_PC24:
2769 /* If we are creating a shared library, and this is a reloc
2770 against a global symbol, or a non PC relative reloc
2771 against a local symbol, then we need to copy the reloc
2772 into the shared library. However, if we are linking with
2773 -Bsymbolic, we do not need to copy a reloc against a
2774 global symbol which is defined in an object we are
2775 including in the link (i.e., DEF_REGULAR is set). At
2776 this point we have not seen all the input files, so it is
2777 possible that DEF_REGULAR is not set now but will be set
2778 later (it is never cleared). We account for that
2779 possibility below by storing information in the
2780 pcrel_relocs_copied field of the hash table entry. */
2781 if (info->shared
2782 && (ELF32_R_TYPE (rel->r_info) != R_ARM_PC24
2783 || (h != NULL
2784 && (! info->symbolic
2785 || (h->elf_link_hash_flags
2786 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
2787 {
2788 /* When creating a shared object, we must copy these
2789 reloc types into the output file. We create a reloc
2790 section in dynobj and make room for this reloc. */
2791 if (sreloc == NULL)
2792 {
2793 const char * name;
2794
2795 name = (bfd_elf_string_from_elf_section
2796 (abfd,
2797 elf_elfheader (abfd)->e_shstrndx,
2798 elf_section_data (sec)->rel_hdr.sh_name));
2799 if (name == NULL)
b34976b6 2800 return FALSE;
252b5132
RH
2801
2802 BFD_ASSERT (strncmp (name, ".rel", 4) == 0
99e4ae17 2803 && strcmp (bfd_get_section_name (abfd, sec),
252b5132
RH
2804 name + 4) == 0);
2805
2806 sreloc = bfd_get_section_by_name (dynobj, name);
2807 if (sreloc == NULL)
2808 {
2809 flagword flags;
2810
2811 sreloc = bfd_make_section (dynobj, name);
2812 flags = (SEC_HAS_CONTENTS | SEC_READONLY
2813 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
2814 if ((sec->flags & SEC_ALLOC) != 0)
2815 flags |= SEC_ALLOC | SEC_LOAD;
2816 if (sreloc == NULL
2817 || ! bfd_set_section_flags (dynobj, sreloc, flags)
2818 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
b34976b6 2819 return FALSE;
252b5132 2820 }
99e4ae17
AJ
2821 if (sec->flags & SEC_READONLY)
2822 info->flags |= DF_TEXTREL;
252b5132
RH
2823 }
2824
2825 sreloc->_raw_size += sizeof (Elf32_External_Rel);
2826 /* If we are linking with -Bsymbolic, and this is a
2827 global symbol, we count the number of PC relative
2828 relocations we have entered for this symbol, so that
2829 we can discard them again if the symbol is later
2830 defined by a regular object. Note that this function
2831 is only called if we are using an elf_i386 linker
2832 hash table, which means that h is really a pointer to
2833 an elf_i386_link_hash_entry. */
2834 if (h != NULL && info->symbolic
2835 && ELF32_R_TYPE (rel->r_info) == R_ARM_PC24)
2836 {
2837 struct elf32_arm_link_hash_entry * eh;
2838 struct elf32_arm_pcrel_relocs_copied * p;
2839
2840 eh = (struct elf32_arm_link_hash_entry *) h;
2841
2842 for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
2843 if (p->section == sreloc)
2844 break;
2845
2846 if (p == NULL)
2847 {
2848 p = ((struct elf32_arm_pcrel_relocs_copied *)
dc810e39 2849 bfd_alloc (dynobj, (bfd_size_type) sizeof * p));
252b5132 2850 if (p == NULL)
b34976b6 2851 return FALSE;
252b5132
RH
2852 p->next = eh->pcrel_relocs_copied;
2853 eh->pcrel_relocs_copied = p;
2854 p->section = sreloc;
2855 p->count = 0;
2856 }
2857
2858 ++p->count;
2859 }
2860 }
2861 break;
2862
2863 /* This relocation describes the C++ object vtable hierarchy.
2864 Reconstruct it for later use during GC. */
2865 case R_ARM_GNU_VTINHERIT:
2866 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
b34976b6 2867 return FALSE;
252b5132 2868 break;
9a5aca8c 2869
252b5132
RH
2870 /* This relocation describes which C++ vtable entries are actually
2871 used. Record for later use during GC. */
2872 case R_ARM_GNU_VTENTRY:
d512aa07 2873 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
b34976b6 2874 return FALSE;
252b5132
RH
2875 break;
2876 }
2877 }
f21f3fe0 2878
b34976b6 2879 return TRUE;
252b5132
RH
2880}
2881
252b5132
RH
2882/* Find the nearest line to a particular section and offset, for error
2883 reporting. This code is a duplicate of the code in elf.c, except
9b485d32 2884 that it also accepts STT_ARM_TFUNC as a symbol that names a function. */
252b5132 2885
b34976b6 2886static bfd_boolean
252b5132
RH
2887elf32_arm_find_nearest_line
2888 (abfd, section, symbols, offset, filename_ptr, functionname_ptr, line_ptr)
b34976b6
AM
2889 bfd *abfd;
2890 asection *section;
2891 asymbol **symbols;
2892 bfd_vma offset;
2893 const char **filename_ptr;
2894 const char **functionname_ptr;
2895 unsigned int *line_ptr;
252b5132 2896{
b34976b6
AM
2897 bfd_boolean found;
2898 const char *filename;
2899 asymbol *func;
2900 bfd_vma low_func;
2901 asymbol **p;
252b5132
RH
2902
2903 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
f21f3fe0 2904 filename_ptr, functionname_ptr,
857ec808
NC
2905 line_ptr, 0,
2906 &elf_tdata (abfd)->dwarf2_find_line_info))
b34976b6 2907 return TRUE;
252b5132
RH
2908
2909 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
2910 &found, filename_ptr,
2911 functionname_ptr, line_ptr,
2912 &elf_tdata (abfd)->line_info))
b34976b6 2913 return FALSE;
f21f3fe0 2914
252b5132 2915 if (found)
b34976b6 2916 return TRUE;
252b5132
RH
2917
2918 if (symbols == NULL)
b34976b6 2919 return FALSE;
252b5132
RH
2920
2921 filename = NULL;
2922 func = NULL;
2923 low_func = 0;
2924
2925 for (p = symbols; *p != NULL; p++)
2926 {
2927 elf_symbol_type *q;
2928
2929 q = (elf_symbol_type *) *p;
2930
2931 if (bfd_get_section (&q->symbol) != section)
2932 continue;
2933
2934 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
2935 {
2936 default:
2937 break;
2938 case STT_FILE:
2939 filename = bfd_asymbol_name (&q->symbol);
2940 break;
2941 case STT_NOTYPE:
2942 case STT_FUNC:
2943 case STT_ARM_TFUNC:
2944 if (q->symbol.section == section
2945 && q->symbol.value >= low_func
2946 && q->symbol.value <= offset)
2947 {
2948 func = (asymbol *) q;
2949 low_func = q->symbol.value;
2950 }
2951 break;
2952 }
2953 }
2954
2955 if (func == NULL)
b34976b6 2956 return FALSE;
252b5132
RH
2957
2958 *filename_ptr = filename;
2959 *functionname_ptr = bfd_asymbol_name (func);
2960 *line_ptr = 0;
f21f3fe0 2961
b34976b6 2962 return TRUE;
252b5132
RH
2963}
2964
2965/* Adjust a symbol defined by a dynamic object and referenced by a
2966 regular object. The current definition is in some section of the
2967 dynamic object, but we're not including those sections. We have to
2968 change the definition to something the rest of the link can
2969 understand. */
2970
b34976b6 2971static bfd_boolean
252b5132
RH
2972elf32_arm_adjust_dynamic_symbol (info, h)
2973 struct bfd_link_info * info;
2974 struct elf_link_hash_entry * h;
2975{
2976 bfd * dynobj;
2977 asection * s;
2978 unsigned int power_of_two;
2979
2980 dynobj = elf_hash_table (info)->dynobj;
2981
2982 /* Make sure we know what is going on here. */
2983 BFD_ASSERT (dynobj != NULL
2984 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
2985 || h->weakdef != NULL
2986 || ((h->elf_link_hash_flags
2987 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2988 && (h->elf_link_hash_flags
2989 & ELF_LINK_HASH_REF_REGULAR) != 0
2990 && (h->elf_link_hash_flags
2991 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
2992
2993 /* If this is a function, put it in the procedure linkage table. We
2994 will fill in the contents of the procedure linkage table later,
2995 when we know the address of the .got section. */
24a1ba0f 2996 if (h->type == STT_FUNC
252b5132
RH
2997 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2998 {
9d7404b7
NC
2999 /* If we link a program (not a DSO), we'll get rid of unnecessary
3000 PLT entries; we point to the actual symbols -- even for pic
3001 relocs, because a program built with -fpic should have the same
3002 result as one built without -fpic, specifically considering weak
3003 symbols.
3004 FIXME: m68k and i386 differ here, for unclear reasons. */
252b5132 3005 if (! info->shared
9d7404b7 3006 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0)
252b5132
RH
3007 {
3008 /* This case can occur if we saw a PLT32 reloc in an input
9d7404b7
NC
3009 file, but the symbol was not defined by a dynamic object.
3010 In such a case, we don't actually need to build a
3011 procedure linkage table, and we can just do a PC32 reloc
3012 instead. */
252b5132 3013 BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
9d7404b7 3014 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
b34976b6 3015 return TRUE;
252b5132
RH
3016 }
3017
3018 /* Make sure this symbol is output as a dynamic symbol. */
3019 if (h->dynindx == -1)
3020 {
3021 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
b34976b6 3022 return FALSE;
252b5132
RH
3023 }
3024
24a1ba0f 3025 s = bfd_get_section_by_name (dynobj, ".plt");
252b5132
RH
3026 BFD_ASSERT (s != NULL);
3027
24a1ba0f 3028 /* If this is the first .plt entry, make room for the special
252b5132
RH
3029 first entry. */
3030 if (s->_raw_size == 0)
24a1ba0f 3031 s->_raw_size += PLT_ENTRY_SIZE;
252b5132
RH
3032
3033 /* If this symbol is not defined in a regular file, and we are
3034 not generating a shared library, then set the symbol to this
3035 location in the .plt. This is required to make function
3036 pointers compare as equal between the normal executable and
3037 the shared library. */
3038 if (! info->shared
3039 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3040 {
3041 h->root.u.def.section = s;
3042 h->root.u.def.value = s->_raw_size;
3043 }
3044
3045 h->plt.offset = s->_raw_size;
3046
3047 /* Make room for this entry. */
24a1ba0f 3048 s->_raw_size += PLT_ENTRY_SIZE;
252b5132
RH
3049
3050 /* We also need to make an entry in the .got.plt section, which
3051 will be placed in the .got section by the linker script. */
252b5132
RH
3052 s = bfd_get_section_by_name (dynobj, ".got.plt");
3053 BFD_ASSERT (s != NULL);
3054 s->_raw_size += 4;
3055
3056 /* We also need to make an entry in the .rel.plt section. */
3057
3058 s = bfd_get_section_by_name (dynobj, ".rel.plt");
3059 BFD_ASSERT (s != NULL);
3060 s->_raw_size += sizeof (Elf32_External_Rel);
3061
b34976b6 3062 return TRUE;
252b5132
RH
3063 }
3064
3065 /* If this is a weak symbol, and there is a real definition, the
3066 processor independent code will have arranged for us to see the
3067 real definition first, and we can just use the same value. */
3068 if (h->weakdef != NULL)
3069 {
3070 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
3071 || h->weakdef->root.type == bfd_link_hash_defweak);
3072 h->root.u.def.section = h->weakdef->root.u.def.section;
3073 h->root.u.def.value = h->weakdef->root.u.def.value;
b34976b6 3074 return TRUE;
252b5132
RH
3075 }
3076
3077 /* This is a reference to a symbol defined by a dynamic object which
3078 is not a function. */
3079
3080 /* If we are creating a shared library, we must presume that the
3081 only references to the symbol are via the global offset table.
3082 For such cases we need not do anything here; the relocations will
3083 be handled correctly by relocate_section. */
3084 if (info->shared)
b34976b6 3085 return TRUE;
252b5132
RH
3086
3087 /* We must allocate the symbol in our .dynbss section, which will
3088 become part of the .bss section of the executable. There will be
3089 an entry for this symbol in the .dynsym section. The dynamic
3090 object will contain position independent code, so all references
3091 from the dynamic object to this symbol will go through the global
3092 offset table. The dynamic linker will use the .dynsym entry to
3093 determine the address it must put in the global offset table, so
3094 both the dynamic object and the regular object will refer to the
3095 same memory location for the variable. */
252b5132
RH
3096 s = bfd_get_section_by_name (dynobj, ".dynbss");
3097 BFD_ASSERT (s != NULL);
3098
3099 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
3100 copy the initial value out of the dynamic object and into the
3101 runtime process image. We need to remember the offset into the
3102 .rel.bss section we are going to use. */
3103 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
3104 {
3105 asection *srel;
3106
3107 srel = bfd_get_section_by_name (dynobj, ".rel.bss");
3108 BFD_ASSERT (srel != NULL);
3109 srel->_raw_size += sizeof (Elf32_External_Rel);
3110 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
3111 }
3112
3113 /* We need to figure out the alignment required for this symbol. I
3114 have no idea how ELF linkers handle this. */
3115 power_of_two = bfd_log2 (h->size);
3116 if (power_of_two > 3)
3117 power_of_two = 3;
3118
3119 /* Apply the required alignment. */
3120 s->_raw_size = BFD_ALIGN (s->_raw_size,
3121 (bfd_size_type) (1 << power_of_two));
3122 if (power_of_two > bfd_get_section_alignment (dynobj, s))
3123 {
3124 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
b34976b6 3125 return FALSE;
252b5132
RH
3126 }
3127
3128 /* Define the symbol as being at this point in the section. */
3129 h->root.u.def.section = s;
3130 h->root.u.def.value = s->_raw_size;
3131
3132 /* Increment the section size to make room for the symbol. */
3133 s->_raw_size += h->size;
3134
b34976b6 3135 return TRUE;
252b5132
RH
3136}
3137
3138/* Set the sizes of the dynamic sections. */
3139
b34976b6 3140static bfd_boolean
252b5132 3141elf32_arm_size_dynamic_sections (output_bfd, info)
99e4ae17 3142 bfd * output_bfd ATTRIBUTE_UNUSED;
252b5132
RH
3143 struct bfd_link_info * info;
3144{
3145 bfd * dynobj;
3146 asection * s;
b34976b6
AM
3147 bfd_boolean plt;
3148 bfd_boolean relocs;
252b5132
RH
3149
3150 dynobj = elf_hash_table (info)->dynobj;
3151 BFD_ASSERT (dynobj != NULL);
3152
3153 if (elf_hash_table (info)->dynamic_sections_created)
3154 {
3155 /* Set the contents of the .interp section to the interpreter. */
3156 if (! info->shared)
3157 {
3158 s = bfd_get_section_by_name (dynobj, ".interp");
3159 BFD_ASSERT (s != NULL);
3160 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
3161 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3162 }
3163 }
3164 else
3165 {
3166 /* We may have created entries in the .rel.got section.
3167 However, if we are not creating the dynamic sections, we will
3168 not actually use these entries. Reset the size of .rel.got,
3169 which will cause it to get stripped from the output file
3170 below. */
3171 s = bfd_get_section_by_name (dynobj, ".rel.got");
3172 if (s != NULL)
3173 s->_raw_size = 0;
3174 }
3175
3176 /* If this is a -Bsymbolic shared link, then we need to discard all
3177 PC relative relocs against symbols defined in a regular object.
3178 We allocated space for them in the check_relocs routine, but we
3179 will not fill them in in the relocate_section routine. */
3180 if (info->shared && info->symbolic)
3181 elf32_arm_link_hash_traverse (elf32_arm_hash_table (info),
3182 elf32_arm_discard_copies,
3183 (PTR) NULL);
3184
3185 /* The check_relocs and adjust_dynamic_symbol entry points have
3186 determined the sizes of the various dynamic sections. Allocate
3187 memory for them. */
b34976b6
AM
3188 plt = FALSE;
3189 relocs = FALSE;
252b5132
RH
3190 for (s = dynobj->sections; s != NULL; s = s->next)
3191 {
3192 const char * name;
b34976b6 3193 bfd_boolean strip;
252b5132
RH
3194
3195 if ((s->flags & SEC_LINKER_CREATED) == 0)
3196 continue;
3197
3198 /* It's OK to base decisions on the section name, because none
3199 of the dynobj section names depend upon the input files. */
3200 name = bfd_get_section_name (dynobj, s);
3201
b34976b6 3202 strip = FALSE;
252b5132 3203
24a1ba0f 3204 if (strcmp (name, ".plt") == 0)
252b5132
RH
3205 {
3206 if (s->_raw_size == 0)
3207 {
3208 /* Strip this section if we don't need it; see the
3209 comment below. */
b34976b6 3210 strip = TRUE;
252b5132
RH
3211 }
3212 else
3213 {
3214 /* Remember whether there is a PLT. */
b34976b6 3215 plt = TRUE;
252b5132
RH
3216 }
3217 }
3218 else if (strncmp (name, ".rel", 4) == 0)
3219 {
3220 if (s->_raw_size == 0)
3221 {
3222 /* If we don't need this section, strip it from the
3223 output file. This is mostly to handle .rel.bss and
3224 .rel.plt. We must create both sections in
3225 create_dynamic_sections, because they must be created
3226 before the linker maps input sections to output
3227 sections. The linker does that before
3228 adjust_dynamic_symbol is called, and it is that
3229 function which decides whether anything needs to go
3230 into these sections. */
b34976b6 3231 strip = TRUE;
252b5132
RH
3232 }
3233 else
3234 {
252b5132
RH
3235 /* Remember whether there are any reloc sections other
3236 than .rel.plt. */
3237 if (strcmp (name, ".rel.plt") != 0)
b34976b6 3238 relocs = TRUE;
252b5132
RH
3239
3240 /* We use the reloc_count field as a counter if we need
3241 to copy relocs into the output file. */
3242 s->reloc_count = 0;
3243 }
3244 }
3245 else if (strncmp (name, ".got", 4) != 0)
3246 {
3247 /* It's not one of our sections, so don't allocate space. */
3248 continue;
3249 }
3250
3251 if (strip)
3252 {
52585bb8 3253 _bfd_strip_section_from_output (info, s);
252b5132
RH
3254 continue;
3255 }
3256
3257 /* Allocate memory for the section contents. */
3258 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
3259 if (s->contents == NULL && s->_raw_size != 0)
b34976b6 3260 return FALSE;
252b5132
RH
3261 }
3262
3263 if (elf_hash_table (info)->dynamic_sections_created)
3264 {
3265 /* Add some entries to the .dynamic section. We fill in the
3266 values later, in elf32_arm_finish_dynamic_sections, but we
3267 must add the entries now so that we get the correct size for
3268 the .dynamic section. The DT_DEBUG entry is filled in by the
3269 dynamic linker and used by the debugger. */
dc810e39
AM
3270#define add_dynamic_entry(TAG, VAL) \
3271 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
3272
3273 if (!info->shared)
252b5132 3274 {
dc810e39 3275 if (!add_dynamic_entry (DT_DEBUG, 0))
b34976b6 3276 return FALSE;
252b5132
RH
3277 }
3278
3279 if (plt)
3280 {
dc810e39
AM
3281 if ( !add_dynamic_entry (DT_PLTGOT, 0)
3282 || !add_dynamic_entry (DT_PLTRELSZ, 0)
3283 || !add_dynamic_entry (DT_PLTREL, DT_REL)
3284 || !add_dynamic_entry (DT_JMPREL, 0))
b34976b6 3285 return FALSE;
252b5132
RH
3286 }
3287
3288 if (relocs)
3289 {
dc810e39
AM
3290 if ( !add_dynamic_entry (DT_REL, 0)
3291 || !add_dynamic_entry (DT_RELSZ, 0)
3292 || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
b34976b6 3293 return FALSE;
252b5132
RH
3294 }
3295
99e4ae17 3296 if ((info->flags & DF_TEXTREL) != 0)
252b5132 3297 {
dc810e39 3298 if (!add_dynamic_entry (DT_TEXTREL, 0))
b34976b6 3299 return FALSE;
d6cf2879 3300 info->flags |= DF_TEXTREL;
252b5132
RH
3301 }
3302 }
dc810e39 3303#undef add_synamic_entry
252b5132 3304
b34976b6 3305 return TRUE;
252b5132
RH
3306}
3307
3308/* This function is called via elf32_arm_link_hash_traverse if we are
3309 creating a shared object with -Bsymbolic. It discards the space
3310 allocated to copy PC relative relocs against symbols which are
3311 defined in regular objects. We allocated space for them in the
3312 check_relocs routine, but we won't fill them in in the
3313 relocate_section routine. */
3314
b34976b6 3315static bfd_boolean
252b5132
RH
3316elf32_arm_discard_copies (h, ignore)
3317 struct elf32_arm_link_hash_entry * h;
5f771d47 3318 PTR ignore ATTRIBUTE_UNUSED;
252b5132
RH
3319{
3320 struct elf32_arm_pcrel_relocs_copied * s;
3321
e92d460e
AM
3322 if (h->root.root.type == bfd_link_hash_warning)
3323 h = (struct elf32_arm_link_hash_entry *) h->root.root.u.i.link;
3324
252b5132
RH
3325 /* We only discard relocs for symbols defined in a regular object. */
3326 if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
b34976b6 3327 return TRUE;
252b5132
RH
3328
3329 for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
3330 s->section->_raw_size -= s->count * sizeof (Elf32_External_Rel);
3331
b34976b6 3332 return TRUE;
252b5132
RH
3333}
3334
3335/* Finish up dynamic symbol handling. We set the contents of various
3336 dynamic sections here. */
3337
b34976b6 3338static bfd_boolean
252b5132
RH
3339elf32_arm_finish_dynamic_symbol (output_bfd, info, h, sym)
3340 bfd * output_bfd;
3341 struct bfd_link_info * info;
3342 struct elf_link_hash_entry * h;
3343 Elf_Internal_Sym * sym;
3344{
3345 bfd * dynobj;
3346
3347 dynobj = elf_hash_table (info)->dynobj;
3348
3349 if (h->plt.offset != (bfd_vma) -1)
3350 {
3351 asection * splt;
3352 asection * sgot;
3353 asection * srel;
24a1ba0f
NC
3354 bfd_vma plt_index;
3355 bfd_vma got_offset;
947216bf
AM
3356 Elf_Internal_Rela rel;
3357 bfd_byte *loc;
252b5132
RH
3358
3359 /* This symbol has an entry in the procedure linkage table. Set
3360 it up. */
3361
3362 BFD_ASSERT (h->dynindx != -1);
3363
3364 splt = bfd_get_section_by_name (dynobj, ".plt");
3365 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
3366 srel = bfd_get_section_by_name (dynobj, ".rel.plt");
24a1ba0f 3367 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
252b5132 3368
24a1ba0f
NC
3369 /* Get the index in the procedure linkage table which
3370 corresponds to this symbol. This is the index of this symbol
3371 in all the symbols for which we are making plt entries. The
3372 first entry in the procedure linkage table is reserved. */
3373 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
252b5132 3374
24a1ba0f
NC
3375 /* Get the offset into the .got table of the entry that
3376 corresponds to this function. Each .got entry is 4 bytes.
3377 The first three are reserved. */
3378 got_offset = (plt_index + 3) * 4;
252b5132
RH
3379
3380 /* Fill in the entry in the procedure linkage table. */
24a1ba0f
NC
3381 bfd_put_32 (output_bfd, elf32_arm_plt_entry[0],
3382 splt->contents + h->plt.offset + 0);
3383 bfd_put_32 (output_bfd, elf32_arm_plt_entry[1],
3384 splt->contents + h->plt.offset + 4);
3385 bfd_put_32 (output_bfd, elf32_arm_plt_entry[2],
3386 splt->contents + h->plt.offset + 8);
3387 bfd_put_32 (output_bfd,
252b5132
RH
3388 (sgot->output_section->vma
3389 + sgot->output_offset
24a1ba0f 3390 + got_offset
252b5132
RH
3391 - splt->output_section->vma
3392 - splt->output_offset
3393 - h->plt.offset - 12),
3394 splt->contents + h->plt.offset + 12);
3395
24a1ba0f
NC
3396 /* Fill in the entry in the global offset table. */
3397 bfd_put_32 (output_bfd,
3398 (splt->output_section->vma
3399 + splt->output_offset),
3400 sgot->contents + got_offset);
252b5132
RH
3401
3402 /* Fill in the entry in the .rel.plt section. */
3403 rel.r_offset = (sgot->output_section->vma
3404 + sgot->output_offset
24a1ba0f 3405 + got_offset);
252b5132 3406 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_JUMP_SLOT);
947216bf
AM
3407 loc = srel->contents + plt_index * sizeof (Elf32_External_Rel);
3408 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
252b5132
RH
3409
3410 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3411 {
3412 /* Mark the symbol as undefined, rather than as defined in
3413 the .plt section. Leave the value alone. */
3414 sym->st_shndx = SHN_UNDEF;
d982ba73
PB
3415 /* If the symbol is weak, we do need to clear the value.
3416 Otherwise, the PLT entry would provide a definition for
3417 the symbol even if the symbol wasn't defined anywhere,
3418 and so the symbol would never be NULL. */
3419 if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK)
3420 == 0)
3421 sym->st_value = 0;
252b5132
RH
3422 }
3423 }
3424
3425 if (h->got.offset != (bfd_vma) -1)
3426 {
3427 asection * sgot;
3428 asection * srel;
947216bf
AM
3429 Elf_Internal_Rela rel;
3430 bfd_byte *loc;
252b5132
RH
3431
3432 /* This symbol has an entry in the global offset table. Set it
3433 up. */
252b5132
RH
3434 sgot = bfd_get_section_by_name (dynobj, ".got");
3435 srel = bfd_get_section_by_name (dynobj, ".rel.got");
3436 BFD_ASSERT (sgot != NULL && srel != NULL);
3437
3438 rel.r_offset = (sgot->output_section->vma
3439 + sgot->output_offset
dc810e39 3440 + (h->got.offset &~ (bfd_vma) 1));
252b5132
RH
3441
3442 /* If this is a -Bsymbolic link, and the symbol is defined
3443 locally, we just want to emit a RELATIVE reloc. The entry in
3444 the global offset table will already have been initialized in
3445 the relocate_section function. */
3446 if (info->shared
3447 && (info->symbolic || h->dynindx == -1)
3448 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
3449 rel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
3450 else
3451 {
3452 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
3453 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
3454 }
3455
947216bf
AM
3456 loc = srel->contents + srel->reloc_count++ * sizeof (Elf32_External_Rel);
3457 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
252b5132
RH
3458 }
3459
3460 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
3461 {
3462 asection * s;
947216bf
AM
3463 Elf_Internal_Rela rel;
3464 bfd_byte *loc;
252b5132
RH
3465
3466 /* This symbol needs a copy reloc. Set it up. */
252b5132
RH
3467 BFD_ASSERT (h->dynindx != -1
3468 && (h->root.type == bfd_link_hash_defined
3469 || h->root.type == bfd_link_hash_defweak));
3470
3471 s = bfd_get_section_by_name (h->root.u.def.section->owner,
3472 ".rel.bss");
3473 BFD_ASSERT (s != NULL);
3474
3475 rel.r_offset = (h->root.u.def.value
3476 + h->root.u.def.section->output_section->vma
3477 + h->root.u.def.section->output_offset);
3478 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_COPY);
947216bf
AM
3479 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rel);
3480 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
252b5132
RH
3481 }
3482
3483 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3484 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3485 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3486 sym->st_shndx = SHN_ABS;
3487
b34976b6 3488 return TRUE;
252b5132
RH
3489}
3490
3491/* Finish up the dynamic sections. */
3492
b34976b6 3493static bfd_boolean
252b5132
RH
3494elf32_arm_finish_dynamic_sections (output_bfd, info)
3495 bfd * output_bfd;
3496 struct bfd_link_info * info;
3497{
3498 bfd * dynobj;
3499 asection * sgot;
3500 asection * sdyn;
3501
3502 dynobj = elf_hash_table (info)->dynobj;
3503
3504 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
3505 BFD_ASSERT (sgot != NULL);
3506 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3507
3508 if (elf_hash_table (info)->dynamic_sections_created)
3509 {
3510 asection *splt;
3511 Elf32_External_Dyn *dyncon, *dynconend;
3512
3513 splt = bfd_get_section_by_name (dynobj, ".plt");
24a1ba0f 3514 BFD_ASSERT (splt != NULL && sdyn != NULL);
252b5132
RH
3515
3516 dyncon = (Elf32_External_Dyn *) sdyn->contents;
3517 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
9b485d32 3518
252b5132
RH
3519 for (; dyncon < dynconend; dyncon++)
3520 {
3521 Elf_Internal_Dyn dyn;
3522 const char * name;
3523 asection * s;
3524
3525 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3526
3527 switch (dyn.d_tag)
3528 {
3529 default:
3530 break;
3531
3532 case DT_PLTGOT:
3533 name = ".got";
3534 goto get_vma;
3535 case DT_JMPREL:
3536 name = ".rel.plt";
3537 get_vma:
3538 s = bfd_get_section_by_name (output_bfd, name);
3539 BFD_ASSERT (s != NULL);
3540 dyn.d_un.d_ptr = s->vma;
3541 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3542 break;
3543
3544 case DT_PLTRELSZ:
3545 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
3546 BFD_ASSERT (s != NULL);
3547 if (s->_cooked_size != 0)
3548 dyn.d_un.d_val = s->_cooked_size;
3549 else
3550 dyn.d_un.d_val = s->_raw_size;
3551 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3552 break;
3553
3554 case DT_RELSZ:
3555 /* My reading of the SVR4 ABI indicates that the
3556 procedure linkage table relocs (DT_JMPREL) should be
3557 included in the overall relocs (DT_REL). This is
3558 what Solaris does. However, UnixWare can not handle
3559 that case. Therefore, we override the DT_RELSZ entry
3560 here to make it not include the JMPREL relocs. Since
3561 the linker script arranges for .rel.plt to follow all
3562 other relocation sections, we don't have to worry
3563 about changing the DT_REL entry. */
3564 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
3565 if (s != NULL)
3566 {
3567 if (s->_cooked_size != 0)
3568 dyn.d_un.d_val -= s->_cooked_size;
3569 else
3570 dyn.d_un.d_val -= s->_raw_size;
3571 }
3572 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3573 break;
88f7bcd5
NC
3574
3575 /* Set the bottom bit of DT_INIT/FINI if the
3576 corresponding function is Thumb. */
3577 case DT_INIT:
3578 name = info->init_function;
3579 goto get_sym;
3580 case DT_FINI:
3581 name = info->fini_function;
3582 get_sym:
3583 /* If it wasn't set by elf_bfd_final_link
3584 then there is nothing to ajdust. */
3585 if (dyn.d_un.d_val != 0)
3586 {
3587 struct elf_link_hash_entry * eh;
3588
3589 eh = elf_link_hash_lookup (elf_hash_table (info), name,
b34976b6 3590 FALSE, FALSE, TRUE);
88f7bcd5
NC
3591 if (eh != (struct elf_link_hash_entry *) NULL
3592 && ELF_ST_TYPE (eh->type) == STT_ARM_TFUNC)
3593 {
3594 dyn.d_un.d_val |= 1;
b34976b6 3595 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
88f7bcd5
NC
3596 }
3597 }
3598 break;
252b5132
RH
3599 }
3600 }
3601
24a1ba0f 3602 /* Fill in the first entry in the procedure linkage table. */
252b5132 3603 if (splt->_raw_size > 0)
f7a74f8c
NC
3604 {
3605 bfd_put_32 (output_bfd, elf32_arm_plt0_entry[0], splt->contents + 0);
3606 bfd_put_32 (output_bfd, elf32_arm_plt0_entry[1], splt->contents + 4);
3607 bfd_put_32 (output_bfd, elf32_arm_plt0_entry[2], splt->contents + 8);
3608 bfd_put_32 (output_bfd, elf32_arm_plt0_entry[3], splt->contents + 12);
3609 }
252b5132
RH
3610
3611 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3612 really seem like the right value. */
3613 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
3614 }
3615
3616 /* Fill in the first three entries in the global offset table. */
3617 if (sgot->_raw_size > 0)
3618 {
3619 if (sdyn == NULL)
3620 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
3621 else
3622 bfd_put_32 (output_bfd,
3623 sdyn->output_section->vma + sdyn->output_offset,
3624 sgot->contents);
3625 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
3626 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
3627 }
3628
3629 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
3630
b34976b6 3631 return TRUE;
252b5132
RH
3632}
3633
ba96a88f
NC
3634static void
3635elf32_arm_post_process_headers (abfd, link_info)
3636 bfd * abfd;
5f771d47 3637 struct bfd_link_info * link_info ATTRIBUTE_UNUSED;
ba96a88f 3638{
9b485d32 3639 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
ba96a88f
NC
3640
3641 i_ehdrp = elf_elfheader (abfd);
3642
3643 i_ehdrp->e_ident[EI_OSABI] = ARM_ELF_OS_ABI_VERSION;
3644 i_ehdrp->e_ident[EI_ABIVERSION] = ARM_ELF_ABI_VERSION;
3645}
3646
99e4ae17 3647static enum elf_reloc_type_class
f51e552e
AM
3648elf32_arm_reloc_type_class (rela)
3649 const Elf_Internal_Rela *rela;
99e4ae17 3650{
f51e552e 3651 switch ((int) ELF32_R_TYPE (rela->r_info))
99e4ae17
AJ
3652 {
3653 case R_ARM_RELATIVE:
3654 return reloc_class_relative;
3655 case R_ARM_JUMP_SLOT:
3656 return reloc_class_plt;
3657 case R_ARM_COPY:
3658 return reloc_class_copy;
3659 default:
3660 return reloc_class_normal;
3661 }
3662}
3663
e16bb312
NC
3664static bfd_boolean elf32_arm_section_flags PARAMS ((flagword *, Elf_Internal_Shdr *));
3665static void elf32_arm_final_write_processing PARAMS ((bfd *, bfd_boolean));
3666
3667/* Set the right machine number for an Arm ELF file. */
3668
3669static bfd_boolean
3670elf32_arm_section_flags (flags, hdr)
3671 flagword *flags;
3672 Elf_Internal_Shdr *hdr;
3673{
3674 if (hdr->sh_type == SHT_NOTE)
3675 *flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_CONTENTS;
3676
3677 return TRUE;
3678}
3679
3680void
3681elf32_arm_final_write_processing (abfd, linker)
3682 bfd *abfd;
3683 bfd_boolean linker ATTRIBUTE_UNUSED;
3684{
5a6c6817 3685 bfd_arm_update_notes (abfd, ARM_NOTE_SECTION);
e16bb312
NC
3686}
3687
252b5132
RH
3688#define ELF_ARCH bfd_arch_arm
3689#define ELF_MACHINE_CODE EM_ARM
d0facd1b
NC
3690#ifdef __QNXTARGET__
3691#define ELF_MAXPAGESIZE 0x1000
3692#else
f21f3fe0 3693#define ELF_MAXPAGESIZE 0x8000
d0facd1b 3694#endif
252b5132 3695
99e4ae17
AJ
3696#define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
3697#define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
252b5132
RH
3698#define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
3699#define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
3700#define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
dc810e39 3701#define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
252b5132
RH
3702#define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
3703
3704#define elf_backend_get_symbol_type elf32_arm_get_symbol_type
3705#define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
3706#define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
3707#define elf_backend_check_relocs elf32_arm_check_relocs
dc810e39 3708#define elf_backend_relocate_section elf32_arm_relocate_section
252b5132 3709#define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
24a1ba0f 3710#define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
252b5132
RH
3711#define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
3712#define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
3713#define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
ba96a88f 3714#define elf_backend_post_process_headers elf32_arm_post_process_headers
99e4ae17 3715#define elf_backend_reloc_type_class elf32_arm_reloc_type_class
c178919b 3716#define elf_backend_object_p elf32_arm_object_p
e16bb312
NC
3717#define elf_backend_section_flags elf32_arm_section_flags
3718#define elf_backend_final_write_processing elf32_arm_final_write_processing
252b5132
RH
3719
3720#define elf_backend_can_gc_sections 1
3721#define elf_backend_plt_readonly 1
3722#define elf_backend_want_got_plt 1
3723#define elf_backend_want_plt_sym 0
acf8aed4 3724#if !USE_REL
b491616a
AM
3725#define elf_backend_rela_normal 1
3726#endif
252b5132 3727
04f7c78d 3728#define elf_backend_got_header_size 12
24a1ba0f 3729#define elf_backend_plt_header_size PLT_ENTRY_SIZE
04f7c78d 3730
252b5132 3731#include "elf32-target.h"
7e392df6 3732
This page took 0.439144 seconds and 4 git commands to generate.