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