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