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