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