]> Git Repo - binutils.git/blame - bfd/elf32-arm.c
projects / binutils.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* m68kbsd-nat.c: Include "inf-ptrace.h".
[binutils.git] / bfd / elf32-arm.c
CommitLineData
252b5132 1/* 32-bit ELF support for ARM
d1f161ea
NC		 2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004
3 Free Software Foundation, Inc.
252b5132
RH		 4
5 This file is part of BFD, the Binary File Descriptor library.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20
7f266840
DJ		 21#include "elf/arm.h"
22#include "bfd.h"
23#include "sysdep.h"
24#include "libbfd.h"
25#include "elf-bfd.h"
26
27#ifndef NUM_ELEM
28#define NUM_ELEM(a) (sizeof (a) / (sizeof (a)[0]))
29#endif
30
31#define USE_REL 1
32
33#define elf_info_to_howto 0
34#define elf_info_to_howto_rel elf32_arm_info_to_howto
35
36#define ARM_ELF_ABI_VERSION 0
37#define ARM_ELF_OS_ABI_VERSION ELFOSABI_ARM
38
39static reloc_howto_type * elf32_arm_reloc_type_lookup
40 PARAMS ((bfd * abfd, bfd_reloc_code_real_type code));
41static bfd_boolean elf32_arm_nabi_grok_prstatus
42 PARAMS ((bfd *abfd, Elf_Internal_Note *note));
43static bfd_boolean elf32_arm_nabi_grok_psinfo
44 PARAMS ((bfd *abfd, Elf_Internal_Note *note));
45
46/* Note: code such as elf32_arm_reloc_type_lookup expect to use e.g.
47 R_ARM_PC24 as an index into this, and find the R_ARM_PC24 HOWTO
48 in that slot. */
49
50static reloc_howto_type elf32_arm_howto_table[] =
51{
52 /* No relocation */
53 HOWTO (R_ARM_NONE, /* type */
54 0, /* rightshift */
55 0, /* size (0 = byte, 1 = short, 2 = long) */
56 0, /* bitsize */
57 FALSE, /* pc_relative */
58 0, /* bitpos */
59 complain_overflow_dont,/* complain_on_overflow */
60 bfd_elf_generic_reloc, /* special_function */
61 "R_ARM_NONE", /* name */
62 FALSE, /* partial_inplace */
63 0, /* src_mask */
64 0, /* dst_mask */
65 FALSE), /* pcrel_offset */
66
67 HOWTO (R_ARM_PC24, /* type */
68 2, /* rightshift */
69 2, /* size (0 = byte, 1 = short, 2 = long) */
70 24, /* bitsize */
71 TRUE, /* pc_relative */
72 0, /* bitpos */
73 complain_overflow_signed,/* complain_on_overflow */
74 bfd_elf_generic_reloc, /* special_function */
75 "R_ARM_PC24", /* name */
76 FALSE, /* partial_inplace */
77 0x00ffffff, /* src_mask */
78 0x00ffffff, /* dst_mask */
79 TRUE), /* pcrel_offset */
80
81 /* 32 bit absolute */
82 HOWTO (R_ARM_ABS32, /* type */
83 0, /* rightshift */
84 2, /* size (0 = byte, 1 = short, 2 = long) */
85 32, /* bitsize */
86 FALSE, /* pc_relative */
87 0, /* bitpos */
88 complain_overflow_bitfield,/* complain_on_overflow */
89 bfd_elf_generic_reloc, /* special_function */
90 "R_ARM_ABS32", /* name */
91 FALSE, /* partial_inplace */
92 0xffffffff, /* src_mask */
93 0xffffffff, /* dst_mask */
94 FALSE), /* pcrel_offset */
95
96 /* standard 32bit pc-relative reloc */
97 HOWTO (R_ARM_REL32, /* type */
98 0, /* rightshift */
99 2, /* size (0 = byte, 1 = short, 2 = long) */
100 32, /* bitsize */
101 TRUE, /* pc_relative */
102 0, /* bitpos */
103 complain_overflow_bitfield,/* complain_on_overflow */
104 bfd_elf_generic_reloc, /* special_function */
105 "R_ARM_REL32", /* name */
106 FALSE, /* partial_inplace */
107 0xffffffff, /* src_mask */
108 0xffffffff, /* dst_mask */
109 TRUE), /* pcrel_offset */
110
111 /* 8 bit absolute */
112 HOWTO (R_ARM_PC13, /* type */
113 0, /* rightshift */
114 0, /* size (0 = byte, 1 = short, 2 = long) */
115 8, /* bitsize */
116 FALSE, /* pc_relative */
117 0, /* bitpos */
118 complain_overflow_bitfield,/* complain_on_overflow */
119 bfd_elf_generic_reloc, /* special_function */
120 "R_ARM_PC13", /* name */
121 FALSE, /* partial_inplace */
122 0x000000ff, /* src_mask */
123 0x000000ff, /* dst_mask */
124 FALSE), /* pcrel_offset */
125
126 /* 16 bit absolute */
127 HOWTO (R_ARM_ABS16, /* type */
128 0, /* rightshift */
129 1, /* size (0 = byte, 1 = short, 2 = long) */
130 16, /* bitsize */
131 FALSE, /* pc_relative */
132 0, /* bitpos */
133 complain_overflow_bitfield,/* complain_on_overflow */
134 bfd_elf_generic_reloc, /* special_function */
135 "R_ARM_ABS16", /* name */
136 FALSE, /* partial_inplace */
137 0x0000ffff, /* src_mask */
138 0x0000ffff, /* dst_mask */
139 FALSE), /* pcrel_offset */
140
141 /* 12 bit absolute */
142 HOWTO (R_ARM_ABS12, /* type */
143 0, /* rightshift */
144 2, /* size (0 = byte, 1 = short, 2 = long) */
145 12, /* bitsize */
146 FALSE, /* pc_relative */
147 0, /* bitpos */
148 complain_overflow_bitfield,/* complain_on_overflow */
149 bfd_elf_generic_reloc, /* special_function */
150 "R_ARM_ABS12", /* name */
151 FALSE, /* partial_inplace */
152 0x000008ff, /* src_mask */
153 0x000008ff, /* dst_mask */
154 FALSE), /* pcrel_offset */
155
156 HOWTO (R_ARM_THM_ABS5, /* type */
157 6, /* rightshift */
158 1, /* size (0 = byte, 1 = short, 2 = long) */
159 5, /* bitsize */
160 FALSE, /* pc_relative */
161 0, /* bitpos */
162 complain_overflow_bitfield,/* complain_on_overflow */
163 bfd_elf_generic_reloc, /* special_function */
164 "R_ARM_THM_ABS5", /* name */
165 FALSE, /* partial_inplace */
166 0x000007e0, /* src_mask */
167 0x000007e0, /* dst_mask */
168 FALSE), /* pcrel_offset */
169
170 /* 8 bit absolute */
171 HOWTO (R_ARM_ABS8, /* type */
172 0, /* rightshift */
173 0, /* size (0 = byte, 1 = short, 2 = long) */
174 8, /* bitsize */
175 FALSE, /* pc_relative */
176 0, /* bitpos */
177 complain_overflow_bitfield,/* complain_on_overflow */
178 bfd_elf_generic_reloc, /* special_function */
179 "R_ARM_ABS8", /* name */
180 FALSE, /* partial_inplace */
181 0x000000ff, /* src_mask */
182 0x000000ff, /* dst_mask */
183 FALSE), /* pcrel_offset */
184
185 HOWTO (R_ARM_SBREL32, /* type */
186 0, /* rightshift */
187 2, /* size (0 = byte, 1 = short, 2 = long) */
188 32, /* bitsize */
189 FALSE, /* pc_relative */
190 0, /* bitpos */
191 complain_overflow_dont,/* complain_on_overflow */
192 bfd_elf_generic_reloc, /* special_function */
193 "R_ARM_SBREL32", /* name */
194 FALSE, /* partial_inplace */
195 0xffffffff, /* src_mask */
196 0xffffffff, /* dst_mask */
197 FALSE), /* pcrel_offset */
198
199 HOWTO (R_ARM_THM_PC22, /* type */
200 1, /* rightshift */
201 2, /* size (0 = byte, 1 = short, 2 = long) */
202 23, /* bitsize */
203 TRUE, /* pc_relative */
204 0, /* bitpos */
205 complain_overflow_signed,/* complain_on_overflow */
206 bfd_elf_generic_reloc, /* special_function */
207 "R_ARM_THM_PC22", /* name */
208 FALSE, /* partial_inplace */
209 0x07ff07ff, /* src_mask */
210 0x07ff07ff, /* dst_mask */
211 TRUE), /* pcrel_offset */
212
213 HOWTO (R_ARM_THM_PC8, /* type */
214 1, /* rightshift */
215 1, /* size (0 = byte, 1 = short, 2 = long) */
216 8, /* bitsize */
217 TRUE, /* pc_relative */
218 0, /* bitpos */
219 complain_overflow_signed,/* complain_on_overflow */
220 bfd_elf_generic_reloc, /* special_function */
221 "R_ARM_THM_PC8", /* name */
222 FALSE, /* partial_inplace */
223 0x000000ff, /* src_mask */
224 0x000000ff, /* dst_mask */
225 TRUE), /* pcrel_offset */
226
227 HOWTO (R_ARM_AMP_VCALL9, /* type */
228 1, /* rightshift */
229 1, /* size (0 = byte, 1 = short, 2 = long) */
230 8, /* bitsize */
231 TRUE, /* pc_relative */
232 0, /* bitpos */
233 complain_overflow_signed,/* complain_on_overflow */
234 bfd_elf_generic_reloc, /* special_function */
235 "R_ARM_AMP_VCALL9", /* name */
236 FALSE, /* partial_inplace */
237 0x000000ff, /* src_mask */
238 0x000000ff, /* dst_mask */
239 TRUE), /* pcrel_offset */
240
241 HOWTO (R_ARM_SWI24, /* type */
242 0, /* rightshift */
243 0, /* size (0 = byte, 1 = short, 2 = long) */
244 0, /* bitsize */
245 FALSE, /* pc_relative */
246 0, /* bitpos */
247 complain_overflow_signed,/* complain_on_overflow */
248 bfd_elf_generic_reloc, /* special_function */
249 "R_ARM_SWI24", /* name */
250 FALSE, /* partial_inplace */
251 0x00000000, /* src_mask */
252 0x00000000, /* dst_mask */
253 FALSE), /* pcrel_offset */
254
255 HOWTO (R_ARM_THM_SWI8, /* type */
256 0, /* rightshift */
257 0, /* size (0 = byte, 1 = short, 2 = long) */
258 0, /* bitsize */
259 FALSE, /* pc_relative */
260 0, /* bitpos */
261 complain_overflow_signed,/* complain_on_overflow */
262 bfd_elf_generic_reloc, /* special_function */
263 "R_ARM_SWI8", /* name */
264 FALSE, /* partial_inplace */
265 0x00000000, /* src_mask */
266 0x00000000, /* dst_mask */
267 FALSE), /* pcrel_offset */
268
269 /* BLX instruction for the ARM. */
270 HOWTO (R_ARM_XPC25, /* type */
271 2, /* rightshift */
272 2, /* size (0 = byte, 1 = short, 2 = long) */
273 25, /* bitsize */
274 TRUE, /* pc_relative */
275 0, /* bitpos */
276 complain_overflow_signed,/* complain_on_overflow */
277 bfd_elf_generic_reloc, /* special_function */
278 "R_ARM_XPC25", /* name */
279 FALSE, /* partial_inplace */
280 0x00ffffff, /* src_mask */
281 0x00ffffff, /* dst_mask */
282 TRUE), /* pcrel_offset */
283
284 /* BLX instruction for the Thumb. */
285 HOWTO (R_ARM_THM_XPC22, /* type */
286 2, /* rightshift */
287 2, /* size (0 = byte, 1 = short, 2 = long) */
288 22, /* bitsize */
289 TRUE, /* pc_relative */
290 0, /* bitpos */
291 complain_overflow_signed,/* complain_on_overflow */
292 bfd_elf_generic_reloc, /* special_function */
293 "R_ARM_THM_XPC22", /* name */
294 FALSE, /* partial_inplace */
295 0x07ff07ff, /* src_mask */
296 0x07ff07ff, /* dst_mask */
297 TRUE), /* pcrel_offset */
298
299 /* These next three relocs are not defined, but we need to fill the space. */
300
301 HOWTO (R_ARM_NONE, /* type */
302 0, /* rightshift */
303 0, /* size (0 = byte, 1 = short, 2 = long) */
304 0, /* bitsize */
305 FALSE, /* pc_relative */
306 0, /* bitpos */
307 complain_overflow_dont,/* complain_on_overflow */
308 bfd_elf_generic_reloc, /* special_function */
309 "R_ARM_unknown_17", /* name */
310 FALSE, /* partial_inplace */
311 0, /* src_mask */
312 0, /* dst_mask */
313 FALSE), /* pcrel_offset */
314
315 HOWTO (R_ARM_NONE, /* type */
316 0, /* rightshift */
317 0, /* size (0 = byte, 1 = short, 2 = long) */
318 0, /* bitsize */
319 FALSE, /* pc_relative */
320 0, /* bitpos */
321 complain_overflow_dont,/* complain_on_overflow */
322 bfd_elf_generic_reloc, /* special_function */
323 "R_ARM_unknown_18", /* name */
324 FALSE, /* partial_inplace */
325 0, /* src_mask */
326 0, /* dst_mask */
327 FALSE), /* pcrel_offset */
328
329 HOWTO (R_ARM_NONE, /* type */
330 0, /* rightshift */
331 0, /* size (0 = byte, 1 = short, 2 = long) */
332 0, /* bitsize */
333 FALSE, /* pc_relative */
334 0, /* bitpos */
335 complain_overflow_dont,/* complain_on_overflow */
336 bfd_elf_generic_reloc, /* special_function */
337 "R_ARM_unknown_19", /* name */
338 FALSE, /* partial_inplace */
339 0, /* src_mask */
340 0, /* dst_mask */
341 FALSE), /* pcrel_offset */
342
343 /* Relocs used in ARM Linux */
344
345 HOWTO (R_ARM_COPY, /* type */
346 0, /* rightshift */
347 2, /* size (0 = byte, 1 = short, 2 = long) */
348 32, /* bitsize */
349 FALSE, /* pc_relative */
350 0, /* bitpos */
351 complain_overflow_bitfield,/* complain_on_overflow */
352 bfd_elf_generic_reloc, /* special_function */
353 "R_ARM_COPY", /* name */
354 TRUE, /* partial_inplace */
355 0xffffffff, /* src_mask */
356 0xffffffff, /* dst_mask */
357 FALSE), /* pcrel_offset */
358
359 HOWTO (R_ARM_GLOB_DAT, /* type */
360 0, /* rightshift */
361 2, /* size (0 = byte, 1 = short, 2 = long) */
362 32, /* bitsize */
363 FALSE, /* pc_relative */
364 0, /* bitpos */
365 complain_overflow_bitfield,/* complain_on_overflow */
366 bfd_elf_generic_reloc, /* special_function */
367 "R_ARM_GLOB_DAT", /* name */
368 TRUE, /* partial_inplace */
369 0xffffffff, /* src_mask */
370 0xffffffff, /* dst_mask */
371 FALSE), /* pcrel_offset */
372
373 HOWTO (R_ARM_JUMP_SLOT, /* type */
374 0, /* rightshift */
375 2, /* size (0 = byte, 1 = short, 2 = long) */
376 32, /* bitsize */
377 FALSE, /* pc_relative */
378 0, /* bitpos */
379 complain_overflow_bitfield,/* complain_on_overflow */
380 bfd_elf_generic_reloc, /* special_function */
381 "R_ARM_JUMP_SLOT", /* name */
382 TRUE, /* partial_inplace */
383 0xffffffff, /* src_mask */
384 0xffffffff, /* dst_mask */
385 FALSE), /* pcrel_offset */
386
387 HOWTO (R_ARM_RELATIVE, /* type */
388 0, /* rightshift */
389 2, /* size (0 = byte, 1 = short, 2 = long) */
390 32, /* bitsize */
391 FALSE, /* pc_relative */
392 0, /* bitpos */
393 complain_overflow_bitfield,/* complain_on_overflow */
394 bfd_elf_generic_reloc, /* special_function */
395 "R_ARM_RELATIVE", /* name */
396 TRUE, /* partial_inplace */
397 0xffffffff, /* src_mask */
398 0xffffffff, /* dst_mask */
399 FALSE), /* pcrel_offset */
400
401 HOWTO (R_ARM_GOTOFF, /* type */
402 0, /* rightshift */
403 2, /* size (0 = byte, 1 = short, 2 = long) */
404 32, /* bitsize */
405 FALSE, /* pc_relative */
406 0, /* bitpos */
407 complain_overflow_bitfield,/* complain_on_overflow */
408 bfd_elf_generic_reloc, /* special_function */
409 "R_ARM_GOTOFF", /* name */
410 TRUE, /* partial_inplace */
411 0xffffffff, /* src_mask */
412 0xffffffff, /* dst_mask */
413 FALSE), /* pcrel_offset */
414
415 HOWTO (R_ARM_GOTPC, /* type */
416 0, /* rightshift */
417 2, /* size (0 = byte, 1 = short, 2 = long) */
418 32, /* bitsize */
419 TRUE, /* pc_relative */
420 0, /* bitpos */
421 complain_overflow_bitfield,/* complain_on_overflow */
422 bfd_elf_generic_reloc, /* special_function */
423 "R_ARM_GOTPC", /* name */
424 TRUE, /* partial_inplace */
425 0xffffffff, /* src_mask */
426 0xffffffff, /* dst_mask */
427 TRUE), /* pcrel_offset */
428
429 HOWTO (R_ARM_GOT32, /* type */
430 0, /* rightshift */
431 2, /* size (0 = byte, 1 = short, 2 = long) */
432 32, /* bitsize */
433 FALSE, /* pc_relative */
434 0, /* bitpos */
435 complain_overflow_bitfield,/* complain_on_overflow */
436 bfd_elf_generic_reloc, /* special_function */
437 "R_ARM_GOT32", /* name */
438 TRUE, /* partial_inplace */
439 0xffffffff, /* src_mask */
440 0xffffffff, /* dst_mask */
441 FALSE), /* pcrel_offset */
442
443 HOWTO (R_ARM_PLT32, /* type */
444 2, /* rightshift */
445 2, /* size (0 = byte, 1 = short, 2 = long) */
446 26, /* bitsize */
447 TRUE, /* pc_relative */
448 0, /* bitpos */
449 complain_overflow_bitfield,/* complain_on_overflow */
450 bfd_elf_generic_reloc, /* special_function */
451 "R_ARM_PLT32", /* name */
452 TRUE, /* partial_inplace */
453 0x00ffffff, /* src_mask */
454 0x00ffffff, /* dst_mask */
455 TRUE), /* pcrel_offset */
456
457 HOWTO (R_ARM_CALL, /* type */
458 2, /* rightshift */
459 2, /* size (0 = byte, 1 = short, 2 = long) */
460 24, /* bitsize */
461 TRUE, /* pc_relative */
462 0, /* bitpos */
463 complain_overflow_signed,/* complain_on_overflow */
464 bfd_elf_generic_reloc, /* special_function */
465 "R_ARM_CALL", /* name */
466 FALSE, /* partial_inplace */
467 0x00ffffff, /* src_mask */
468 0x00ffffff, /* dst_mask */
469 TRUE), /* pcrel_offset */
470
471 HOWTO (R_ARM_JUMP24, /* type */
472 2, /* rightshift */
473 2, /* size (0 = byte, 1 = short, 2 = long) */
474 24, /* bitsize */
475 TRUE, /* pc_relative */
476 0, /* bitpos */
477 complain_overflow_signed,/* complain_on_overflow */
478 bfd_elf_generic_reloc, /* special_function */
479 "R_ARM_JUMP24", /* name */
480 FALSE, /* partial_inplace */
481 0x00ffffff, /* src_mask */
482 0x00ffffff, /* dst_mask */
483 TRUE), /* pcrel_offset */
484
485 HOWTO (R_ARM_NONE, /* type */
486 0, /* rightshift */
487 0, /* size (0 = byte, 1 = short, 2 = long) */
488 0, /* bitsize */
489 FALSE, /* pc_relative */
490 0, /* bitpos */
491 complain_overflow_dont,/* complain_on_overflow */
492 bfd_elf_generic_reloc, /* special_function */
493 "R_ARM_unknown_30", /* name */
494 FALSE, /* partial_inplace */
495 0, /* src_mask */
496 0, /* dst_mask */
497 FALSE), /* pcrel_offset */
498
499 HOWTO (R_ARM_NONE, /* type */
500 0, /* rightshift */
501 0, /* size (0 = byte, 1 = short, 2 = long) */
502 0, /* bitsize */
503 FALSE, /* pc_relative */
504 0, /* bitpos */
505 complain_overflow_dont,/* complain_on_overflow */
506 bfd_elf_generic_reloc, /* special_function */
507 "R_ARM_unknown_31", /* name */
508 FALSE, /* partial_inplace */
509 0, /* src_mask */
510 0, /* dst_mask */
511 FALSE), /* pcrel_offset */
512
513 HOWTO (R_ARM_ALU_PCREL7_0, /* type */
514 0, /* rightshift */
515 2, /* size (0 = byte, 1 = short, 2 = long) */
516 12, /* bitsize */
517 TRUE, /* pc_relative */
518 0, /* bitpos */
519 complain_overflow_dont,/* complain_on_overflow */
520 bfd_elf_generic_reloc, /* special_function */
521 "R_ARM_ALU_PCREL_7_0", /* name */
522 FALSE, /* partial_inplace */
523 0x00000fff, /* src_mask */
524 0x00000fff, /* dst_mask */
525 TRUE), /* pcrel_offset */
526
527 HOWTO (R_ARM_ALU_PCREL15_8, /* type */
528 0, /* rightshift */
529 2, /* size (0 = byte, 1 = short, 2 = long) */
530 12, /* bitsize */
531 TRUE, /* pc_relative */
532 8, /* bitpos */
533 complain_overflow_dont,/* complain_on_overflow */
534 bfd_elf_generic_reloc, /* special_function */
535 "R_ARM_ALU_PCREL_15_8",/* name */
536 FALSE, /* partial_inplace */
537 0x00000fff, /* src_mask */
538 0x00000fff, /* dst_mask */
539 TRUE), /* pcrel_offset */
540
541 HOWTO (R_ARM_ALU_PCREL23_15, /* type */
542 0, /* rightshift */
543 2, /* size (0 = byte, 1 = short, 2 = long) */
544 12, /* bitsize */
545 TRUE, /* pc_relative */
546 16, /* bitpos */
547 complain_overflow_dont,/* complain_on_overflow */
548 bfd_elf_generic_reloc, /* special_function */
549 "R_ARM_ALU_PCREL_23_15",/* name */
550 FALSE, /* partial_inplace */
551 0x00000fff, /* src_mask */
552 0x00000fff, /* dst_mask */
553 TRUE), /* pcrel_offset */
554
555 HOWTO (R_ARM_LDR_SBREL_11_0, /* type */
556 0, /* rightshift */
557 2, /* size (0 = byte, 1 = short, 2 = long) */
558 12, /* bitsize */
559 FALSE, /* pc_relative */
560 0, /* bitpos */
561 complain_overflow_dont,/* complain_on_overflow */
562 bfd_elf_generic_reloc, /* special_function */
563 "R_ARM_LDR_SBREL_11_0",/* name */
564 FALSE, /* partial_inplace */
565 0x00000fff, /* src_mask */
566 0x00000fff, /* dst_mask */
567 FALSE), /* pcrel_offset */
568
569 HOWTO (R_ARM_ALU_SBREL_19_12, /* type */
570 0, /* rightshift */
571 2, /* size (0 = byte, 1 = short, 2 = long) */
572 8, /* bitsize */
573 FALSE, /* pc_relative */
574 12, /* bitpos */
575 complain_overflow_dont,/* complain_on_overflow */
576 bfd_elf_generic_reloc, /* special_function */
577 "R_ARM_ALU_SBREL_19_12",/* name */
578 FALSE, /* partial_inplace */
579 0x000ff000, /* src_mask */
580 0x000ff000, /* dst_mask */
581 FALSE), /* pcrel_offset */
582
583 HOWTO (R_ARM_ALU_SBREL_27_20, /* type */
584 0, /* rightshift */
585 2, /* size (0 = byte, 1 = short, 2 = long) */
586 8, /* bitsize */
587 FALSE, /* pc_relative */
588 20, /* bitpos */
589 complain_overflow_dont,/* complain_on_overflow */
590 bfd_elf_generic_reloc, /* special_function */
591 "R_ARM_ALU_SBREL_27_20",/* name */
592 FALSE, /* partial_inplace */
593 0x0ff00000, /* src_mask */
594 0x0ff00000, /* dst_mask */
595 FALSE), /* pcrel_offset */
596
597 HOWTO (R_ARM_TARGET1, /* type */
598 0, /* rightshift */
599 2, /* size (0 = byte, 1 = short, 2 = long) */
600 32, /* bitsize */
601 FALSE, /* pc_relative */
602 0, /* bitpos */
603 complain_overflow_dont,/* complain_on_overflow */
604 bfd_elf_generic_reloc, /* special_function */
605 "R_ARM_TARGET1", /* name */
606 FALSE, /* partial_inplace */
607 0xffffffff, /* src_mask */
608 0xffffffff, /* dst_mask */
609 FALSE), /* pcrel_offset */
610
611 HOWTO (R_ARM_ROSEGREL32, /* type */
612 0, /* rightshift */
613 2, /* size (0 = byte, 1 = short, 2 = long) */
614 32, /* bitsize */
615 FALSE, /* pc_relative */
616 0, /* bitpos */
617 complain_overflow_dont,/* complain_on_overflow */
618 bfd_elf_generic_reloc, /* special_function */
619 "R_ARM_ROSEGREL32", /* name */
620 FALSE, /* partial_inplace */
621 0xffffffff, /* src_mask */
622 0xffffffff, /* dst_mask */
623 FALSE), /* pcrel_offset */
624
625 HOWTO (R_ARM_V4BX, /* type */
626 0, /* rightshift */
627 2, /* size (0 = byte, 1 = short, 2 = long) */
628 32, /* bitsize */
629 FALSE, /* pc_relative */
630 0, /* bitpos */
631 complain_overflow_dont,/* complain_on_overflow */
632 bfd_elf_generic_reloc, /* special_function */
633 "R_ARM_V4BX", /* name */
634 FALSE, /* partial_inplace */
635 0xffffffff, /* src_mask */
636 0xffffffff, /* dst_mask */
637 FALSE), /* pcrel_offset */
638
639 HOWTO (R_ARM_TARGET2, /* type */
640 0, /* rightshift */
641 2, /* size (0 = byte, 1 = short, 2 = long) */
642 32, /* bitsize */
643 FALSE, /* pc_relative */
644 0, /* bitpos */
645 complain_overflow_signed,/* complain_on_overflow */
646 bfd_elf_generic_reloc, /* special_function */
647 "R_ARM_TARGET2", /* name */
648 FALSE, /* partial_inplace */
649 0xffffffff, /* src_mask */
650 0xffffffff, /* dst_mask */
651 TRUE), /* pcrel_offset */
652
653 HOWTO (R_ARM_PREL31, /* type */
654 0, /* rightshift */
655 2, /* size (0 = byte, 1 = short, 2 = long) */
656 31, /* bitsize */
657 TRUE, /* pc_relative */
658 0, /* bitpos */
659 complain_overflow_signed,/* complain_on_overflow */
660 bfd_elf_generic_reloc, /* special_function */
661 "R_ARM_PREL31", /* name */
662 FALSE, /* partial_inplace */
663 0x7fffffff, /* src_mask */
664 0x7fffffff, /* dst_mask */
665 TRUE), /* pcrel_offset */
666};
667
668 /* GNU extension to record C++ vtable hierarchy */
669static reloc_howto_type elf32_arm_vtinherit_howto =
670 HOWTO (R_ARM_GNU_VTINHERIT, /* type */
671 0, /* rightshift */
672 2, /* size (0 = byte, 1 = short, 2 = long) */
673 0, /* bitsize */
674 FALSE, /* pc_relative */
675 0, /* bitpos */
676 complain_overflow_dont, /* complain_on_overflow */
677 NULL, /* special_function */
678 "R_ARM_GNU_VTINHERIT", /* name */
679 FALSE, /* partial_inplace */
680 0, /* src_mask */
681 0, /* dst_mask */
682 FALSE); /* pcrel_offset */
683
684 /* GNU extension to record C++ vtable member usage */
685static reloc_howto_type elf32_arm_vtentry_howto =
686 HOWTO (R_ARM_GNU_VTENTRY, /* type */
687 0, /* rightshift */
688 2, /* size (0 = byte, 1 = short, 2 = long) */
689 0, /* bitsize */
690 FALSE, /* pc_relative */
691 0, /* bitpos */
692 complain_overflow_dont, /* complain_on_overflow */
693 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
694 "R_ARM_GNU_VTENTRY", /* name */
695 FALSE, /* partial_inplace */
696 0, /* src_mask */
697 0, /* dst_mask */
698 FALSE); /* pcrel_offset */
699
700 /* 12 bit pc relative */
701static reloc_howto_type elf32_arm_thm_pc11_howto =
702 HOWTO (R_ARM_THM_PC11, /* type */
703 1, /* rightshift */
704 1, /* size (0 = byte, 1 = short, 2 = long) */
705 11, /* bitsize */
706 TRUE, /* pc_relative */
707 0, /* bitpos */
708 complain_overflow_signed, /* complain_on_overflow */
709 bfd_elf_generic_reloc, /* special_function */
710 "R_ARM_THM_PC11", /* name */
711 FALSE, /* partial_inplace */
712 0x000007ff, /* src_mask */
713 0x000007ff, /* dst_mask */
714 TRUE); /* pcrel_offset */
715
716 /* 12 bit pc relative */
717static reloc_howto_type elf32_arm_thm_pc9_howto =
718 HOWTO (R_ARM_THM_PC9, /* type */
719 1, /* rightshift */
720 1, /* size (0 = byte, 1 = short, 2 = long) */
721 8, /* bitsize */
722 TRUE, /* pc_relative */
723 0, /* bitpos */
724 complain_overflow_signed, /* complain_on_overflow */
725 bfd_elf_generic_reloc, /* special_function */
726 "R_ARM_THM_PC9", /* name */
727 FALSE, /* partial_inplace */
728 0x000000ff, /* src_mask */
729 0x000000ff, /* dst_mask */
730 TRUE); /* pcrel_offset */
731
732/* Place relative GOT-indirect. */
733static reloc_howto_type elf32_arm_got_prel =
734 HOWTO (R_ARM_GOT_PREL, /* type */
735 0, /* rightshift */
736 2, /* size (0 = byte, 1 = short, 2 = long) */
737 32, /* bitsize */
738 TRUE, /* pc_relative */
739 0, /* bitpos */
740 complain_overflow_dont, /* complain_on_overflow */
741 bfd_elf_generic_reloc, /* special_function */
742 "R_ARM_GOT_PREL", /* name */
743 FALSE, /* partial_inplace */
744 0xffffffff, /* src_mask */
745 0xffffffff, /* dst_mask */
746 TRUE); /* pcrel_offset */
747
748/* Currently unused relocations. */
749static reloc_howto_type elf32_arm_r_howto[4] =
750{
751 HOWTO (R_ARM_RREL32, /* type */
752 0, /* rightshift */
753 0, /* size (0 = byte, 1 = short, 2 = long) */
754 0, /* bitsize */
755 FALSE, /* pc_relative */
756 0, /* bitpos */
757 complain_overflow_dont,/* complain_on_overflow */
758 bfd_elf_generic_reloc, /* special_function */
759 "R_ARM_RREL32", /* name */
760 FALSE, /* partial_inplace */
761 0, /* src_mask */
762 0, /* dst_mask */
763 FALSE), /* pcrel_offset */
764
765 HOWTO (R_ARM_RABS32, /* type */
766 0, /* rightshift */
767 0, /* size (0 = byte, 1 = short, 2 = long) */
768 0, /* bitsize */
769 FALSE, /* pc_relative */
770 0, /* bitpos */
771 complain_overflow_dont,/* complain_on_overflow */
772 bfd_elf_generic_reloc, /* special_function */
773 "R_ARM_RABS32", /* name */
774 FALSE, /* partial_inplace */
775 0, /* src_mask */
776 0, /* dst_mask */
777 FALSE), /* pcrel_offset */
778
779 HOWTO (R_ARM_RPC24, /* type */
780 0, /* rightshift */
781 0, /* size (0 = byte, 1 = short, 2 = long) */
782 0, /* bitsize */
783 FALSE, /* pc_relative */
784 0, /* bitpos */
785 complain_overflow_dont,/* complain_on_overflow */
786 bfd_elf_generic_reloc, /* special_function */
787 "R_ARM_RPC24", /* name */
788 FALSE, /* partial_inplace */
789 0, /* src_mask */
790 0, /* dst_mask */
791 FALSE), /* pcrel_offset */
792
793 HOWTO (R_ARM_RBASE, /* type */
794 0, /* rightshift */
795 0, /* size (0 = byte, 1 = short, 2 = long) */
796 0, /* bitsize */
797 FALSE, /* pc_relative */
798 0, /* bitpos */
799 complain_overflow_dont,/* complain_on_overflow */
800 bfd_elf_generic_reloc, /* special_function */
801 "R_ARM_RBASE", /* name */
802 FALSE, /* partial_inplace */
803 0, /* src_mask */
804 0, /* dst_mask */
805 FALSE) /* pcrel_offset */
806};
807
808static reloc_howto_type *
809elf32_arm_howto_from_type (unsigned int r_type)
810{
811 if (r_type < NUM_ELEM (elf32_arm_howto_table))
812 return &elf32_arm_howto_table[r_type];
813
814 switch (r_type)
815 {
816 case R_ARM_GOT_PREL:
817 return &elf32_arm_got_prel;
818
819 case R_ARM_GNU_VTINHERIT:
820 return &elf32_arm_vtinherit_howto;
821
822 case R_ARM_GNU_VTENTRY:
823 return &elf32_arm_vtentry_howto;
824
825 case R_ARM_THM_PC11:
826 return &elf32_arm_thm_pc11_howto;
827
828 case R_ARM_THM_PC9:
829 return &elf32_arm_thm_pc9_howto;
830
831 case R_ARM_RREL32:
832 case R_ARM_RABS32:
833 case R_ARM_RPC24:
834 case R_ARM_RBASE:
835 return &elf32_arm_r_howto[r_type - R_ARM_RREL32];
836
837 default:
838 return NULL;
839 }
840}
841
842static void
843elf32_arm_info_to_howto (bfd * abfd ATTRIBUTE_UNUSED, arelent * bfd_reloc,
844 Elf_Internal_Rela * elf_reloc)
845{
846 unsigned int r_type;
847
848 r_type = ELF32_R_TYPE (elf_reloc->r_info);
849 bfd_reloc->howto = elf32_arm_howto_from_type (r_type);
850}
851
852struct elf32_arm_reloc_map
853 {
854 bfd_reloc_code_real_type bfd_reloc_val;
855 unsigned char elf_reloc_val;
856 };
857
858/* All entries in this list must also be present in elf32_arm_howto_table. */
859static const struct elf32_arm_reloc_map elf32_arm_reloc_map[] =
860 {
861 {BFD_RELOC_NONE, R_ARM_NONE},
862 {BFD_RELOC_ARM_PCREL_BRANCH, R_ARM_PC24},
863 {BFD_RELOC_ARM_PCREL_BLX, R_ARM_XPC25},
864 {BFD_RELOC_THUMB_PCREL_BLX, R_ARM_THM_XPC22},
865 {BFD_RELOC_32, R_ARM_ABS32},
866 {BFD_RELOC_32_PCREL, R_ARM_REL32},
867 {BFD_RELOC_8, R_ARM_ABS8},
868 {BFD_RELOC_16, R_ARM_ABS16},
869 {BFD_RELOC_ARM_OFFSET_IMM, R_ARM_ABS12},
870 {BFD_RELOC_ARM_THUMB_OFFSET, R_ARM_THM_ABS5},
871 {BFD_RELOC_THUMB_PCREL_BRANCH23, R_ARM_THM_PC22},
872 {BFD_RELOC_ARM_COPY, R_ARM_COPY},
873 {BFD_RELOC_ARM_GLOB_DAT, R_ARM_GLOB_DAT},
874 {BFD_RELOC_ARM_JUMP_SLOT, R_ARM_JUMP_SLOT},
875 {BFD_RELOC_ARM_RELATIVE, R_ARM_RELATIVE},
876 {BFD_RELOC_ARM_GOTOFF, R_ARM_GOTOFF},
877 {BFD_RELOC_ARM_GOTPC, R_ARM_GOTPC},
878 {BFD_RELOC_ARM_GOT32, R_ARM_GOT32},
879 {BFD_RELOC_ARM_PLT32, R_ARM_PLT32},
880 {BFD_RELOC_ARM_TARGET1, R_ARM_TARGET1},
881 {BFD_RELOC_ARM_ROSEGREL32, R_ARM_ROSEGREL32},
882 {BFD_RELOC_ARM_SBREL32, R_ARM_SBREL32},
883 {BFD_RELOC_ARM_PREL31, R_ARM_PREL31},
884 {BFD_RELOC_ARM_TARGET2, R_ARM_TARGET2}
885 };
886
887static reloc_howto_type *
888elf32_arm_reloc_type_lookup (abfd, code)
889 bfd *abfd ATTRIBUTE_UNUSED;
890 bfd_reloc_code_real_type code;
891{
892 unsigned int i;
893
894 switch (code)
895 {
896 case BFD_RELOC_VTABLE_INHERIT:
897 return & elf32_arm_vtinherit_howto;
898
899 case BFD_RELOC_VTABLE_ENTRY:
900 return & elf32_arm_vtentry_howto;
901
902 case BFD_RELOC_THUMB_PCREL_BRANCH12:
903 return & elf32_arm_thm_pc11_howto;
904
905 case BFD_RELOC_THUMB_PCREL_BRANCH9:
906 return & elf32_arm_thm_pc9_howto;
907
908 default:
909 for (i = 0; i < NUM_ELEM (elf32_arm_reloc_map); i ++)
910 if (elf32_arm_reloc_map[i].bfd_reloc_val == code)
911 return & elf32_arm_howto_table[elf32_arm_reloc_map[i].elf_reloc_val];
912
913 return NULL;
914 }
915}
916
917/* Support for core dump NOTE sections */
918static bfd_boolean
919elf32_arm_nabi_grok_prstatus (abfd, note)
920 bfd *abfd;
921 Elf_Internal_Note *note;
922{
923 int offset;
924 size_t size;
925
926 switch (note->descsz)
927 {
928 default:
929 return FALSE;
930
931 case 148: /* Linux/ARM 32-bit*/
932 /* pr_cursig */
933 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
934
935 /* pr_pid */
936 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
937
938 /* pr_reg */
939 offset = 72;
940 size = 72;
941
942 break;
943 }
944
945 /* Make a ".reg/999" section. */
946 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
947 size, note->descpos + offset);
948}
949
950static bfd_boolean
951elf32_arm_nabi_grok_psinfo (abfd, note)
952 bfd *abfd;
953 Elf_Internal_Note *note;
954{
955 switch (note->descsz)
956 {
957 default:
958 return FALSE;
959
960 case 124: /* Linux/ARM elf_prpsinfo */
961 elf_tdata (abfd)->core_program
962 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
963 elf_tdata (abfd)->core_command
964 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
965 }
966
967 /* Note that for some reason, a spurious space is tacked
968 onto the end of the args in some (at least one anyway)
969 implementations, so strip it off if it exists. */
970
971 {
972 char *command = elf_tdata (abfd)->core_command;
973 int n = strlen (command);
974
975 if (0 < n && command[n - 1] == ' ')
976 command[n - 1] = '\0';
977 }
978
979 return TRUE;
980}
981
982#define TARGET_LITTLE_SYM bfd_elf32_littlearm_vec
983#define TARGET_LITTLE_NAME "elf32-littlearm"
984#define TARGET_BIG_SYM bfd_elf32_bigarm_vec
985#define TARGET_BIG_NAME "elf32-bigarm"
986
987#define elf_backend_grok_prstatus elf32_arm_nabi_grok_prstatus
988#define elf_backend_grok_psinfo elf32_arm_nabi_grok_psinfo
989
acf8aed4
AM		 990#ifndef USE_REL
991#define USE_REL 0
992#endif
993
252b5132
RH		 994typedef unsigned long int insn32;
995typedef unsigned short int insn16;
996
8cb51566 997/* In lieu of proper flags, assume all EABIv4 objects are interworkable. */
57e8b36a 998#define INTERWORK_FLAG(abfd) \
8cb51566 999 (EF_ARM_EABI_VERSION (elf_elfheader (abfd)->e_flags) == EF_ARM_EABI_VER4 \
85a84e7a 1000 || (elf_elfheader (abfd)->e_flags & EF_ARM_INTERWORK))
9b485d32 1001
252b5132
RH		 1002/* The linker script knows the section names for placement.
1003 The entry_names are used to do simple name mangling on the stubs.
1004 Given a function name, and its type, the stub can be found. The
9b485d32 1005 name can be changed. The only requirement is the %s be present. */
252b5132
RH		 1006#define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t"
1007#define THUMB2ARM_GLUE_ENTRY_NAME "__%s_from_thumb"
1008
1009#define ARM2THUMB_GLUE_SECTION_NAME ".glue_7"
1010#define ARM2THUMB_GLUE_ENTRY_NAME "__%s_from_arm"
1011
1012/* The name of the dynamic interpreter. This is put in the .interp
1013 section. */
1014#define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
1015
5e681ec4
PB		 1016#ifdef FOUR_WORD_PLT
1017
252b5132
RH		 1018/* The first entry in a procedure linkage table looks like
1019 this. It is set up so that any shared library function that is
59f2c4e7 1020 called before the relocation has been set up calls the dynamic
9b485d32 1021 linker first. */
e5a52504 1022static const bfd_vma elf32_arm_plt0_entry [] =
5e681ec4
PB		 1023 {
1024 0xe52de004, /* str lr, [sp, #-4]! */
1025 0xe59fe010, /* ldr lr, [pc, #16] */
1026 0xe08fe00e, /* add lr, pc, lr */
1027 0xe5bef008, /* ldr pc, [lr, #8]! */
1028 };
1029
1030/* Subsequent entries in a procedure linkage table look like
1031 this. */
e5a52504 1032static const bfd_vma elf32_arm_plt_entry [] =
5e681ec4
PB		 1033 {
1034 0xe28fc600, /* add ip, pc, #NN */
1035 0xe28cca00, /* add ip, ip, #NN */
1036 0xe5bcf000, /* ldr pc, [ip, #NN]! */
1037 0x00000000, /* unused */
1038 };
1039
1040#else
1041
5e681ec4
PB		 1042/* The first entry in a procedure linkage table looks like
1043 this. It is set up so that any shared library function that is
1044 called before the relocation has been set up calls the dynamic
1045 linker first. */
e5a52504 1046static const bfd_vma elf32_arm_plt0_entry [] =
917583ad 1047 {
5e681ec4
PB		 1048 0xe52de004, /* str lr, [sp, #-4]! */
1049 0xe59fe004, /* ldr lr, [pc, #4] */
1050 0xe08fe00e, /* add lr, pc, lr */
1051 0xe5bef008, /* ldr pc, [lr, #8]! */
1052 0x00000000, /* &GOT[0] - . */
917583ad 1053 };
252b5132
RH		 1054
1055/* Subsequent entries in a procedure linkage table look like
1056 this. */
e5a52504 1057static const bfd_vma elf32_arm_plt_entry [] =
5e681ec4
PB		 1058 {
1059 0xe28fc600, /* add ip, pc, #0xNN00000 */
1060 0xe28cca00, /* add ip, ip, #0xNN000 */
1061 0xe5bcf000, /* ldr pc, [ip, #0xNNN]! */
1062 };
1063
1064#endif
252b5132 1065
e5a52504
MM		 1066/* The entries in a PLT when using a DLL-based target with multiple
1067 address spaces. */
1068static const bfd_vma elf32_arm_symbian_plt_entry [] =
1069 {
1070 0xe51ff004, /* ldr pr, [pc, #-4] */
1071 0x00000000, /* dcd R_ARM_GLOB_DAT(X) */
1072 };
1073
e489d0ae
PB		 1074/* Used to build a map of a section. This is required for mixed-endian
1075 code/data. */
1076
1077typedef struct elf32_elf_section_map
1078{
1079 bfd_vma vma;
1080 char type;
1081}
1082elf32_arm_section_map;
1083
1084struct _arm_elf_section_data
1085{
1086 struct bfd_elf_section_data elf;
1087 int mapcount;
1088 elf32_arm_section_map *map;
1089};
1090
1091#define elf32_arm_section_data(sec) \
1092 ((struct _arm_elf_section_data *) elf_section_data (sec))
1093
252b5132
RH		 1094/* The ARM linker needs to keep track of the number of relocs that it
1095 decides to copy in check_relocs for each symbol. This is so that
1096 it can discard PC relative relocs if it doesn't need them when
1097 linking with -Bsymbolic. We store the information in a field
1098 extending the regular ELF linker hash table. */
1099
1100/* This structure keeps track of the number of PC relative relocs we
1101 have copied for a given symbol. */
5e681ec4 1102struct elf32_arm_relocs_copied
917583ad
NC		 1103 {
1104 /* Next section. */
5e681ec4 1105 struct elf32_arm_relocs_copied * next;
917583ad
NC		 1106 /* A section in dynobj. */
1107 asection * section;
1108 /* Number of relocs copied in this section. */
1109 bfd_size_type count;
1110 };
252b5132 1111
ba96a88f 1112/* Arm ELF linker hash entry. */
252b5132 1113struct elf32_arm_link_hash_entry
917583ad
NC		 1114 {
1115 struct elf_link_hash_entry root;
252b5132 1116
917583ad 1117 /* Number of PC relative relocs copied for this symbol. */
5e681ec4 1118 struct elf32_arm_relocs_copied * relocs_copied;
917583ad 1119 };
252b5132 1120
252b5132 1121/* Traverse an arm ELF linker hash table. */
252b5132
RH		 1122#define elf32_arm_link_hash_traverse(table, func, info) \
1123 (elf_link_hash_traverse \
1124 (&(table)->root, \
57e8b36a 1125 (bfd_boolean (*) (struct elf_link_hash_entry *, void *))) (func), \
252b5132
RH		 1126 (info)))
1127
1128/* Get the ARM elf linker hash table from a link_info structure. */
1129#define elf32_arm_hash_table(info) \
1130 ((struct elf32_arm_link_hash_table *) ((info)->hash))
1131
9b485d32 1132/* ARM ELF linker hash table. */
252b5132 1133struct elf32_arm_link_hash_table
917583ad
NC		 1134 {
1135 /* The main hash table. */
1136 struct elf_link_hash_table root;
252b5132 1137
4cc11e76 1138 /* The size in bytes of the section containing the Thumb-to-ARM glue. */
dc810e39 1139 bfd_size_type thumb_glue_size;
252b5132 1140
4cc11e76 1141 /* The size in bytes of the section containing the ARM-to-Thumb glue. */
dc810e39 1142 bfd_size_type arm_glue_size;
252b5132 1143
4cc11e76 1144 /* An arbitrary input BFD chosen to hold the glue sections. */
917583ad 1145 bfd * bfd_of_glue_owner;
ba96a88f 1146
917583ad
NC		 1147 /* A boolean indicating whether knowledge of the ARM's pipeline
1148 length should be applied by the linker. */
1149 int no_pipeline_knowledge;
5e681ec4 1150
e489d0ae
PB		 1151 /* Nonzero to output a BE8 image. */
1152 int byteswap_code;
1153
9c504268
PB		 1154 /* Zero if R_ARM_TARGET1 means R_ARM_ABS32.
1155 Nonzero if R_ARM_TARGET1 means R_ARM_ABS32. */
1156 int target1_is_rel;
1157
eb043451
PB		 1158 /* The relocation to use for R_ARM_TARGET2 relocations. */
1159 int target2_reloc;
1160
e5a52504
MM		 1161 /* The number of bytes in the initial entry in the PLT. */
1162 bfd_size_type plt_header_size;
1163
1164 /* The number of bytes in the subsequent PLT etries. */
1165 bfd_size_type plt_entry_size;
1166
1167 /* True if the target system is Symbian OS. */
1168 int symbian_p;
1169
5e681ec4
PB		 1170 /* Short-cuts to get to dynamic linker sections. */
1171 asection *sgot;
1172 asection *sgotplt;
1173 asection *srelgot;
1174 asection *splt;
1175 asection *srelplt;
1176 asection *sdynbss;
1177 asection *srelbss;
1178
1179 /* Small local sym to section mapping cache. */
1180 struct sym_sec_cache sym_sec;
917583ad 1181 };
252b5132 1182
780a67af
NC		 1183/* Create an entry in an ARM ELF linker hash table. */
1184
1185static struct bfd_hash_entry *
57e8b36a
NC		 1186elf32_arm_link_hash_newfunc (struct bfd_hash_entry * entry,
1187 struct bfd_hash_table * table,
1188 const char * string)
780a67af
NC		 1189{
1190 struct elf32_arm_link_hash_entry * ret =
1191 (struct elf32_arm_link_hash_entry *) entry;
1192
1193 /* Allocate the structure if it has not already been allocated by a
1194 subclass. */
1195 if (ret == (struct elf32_arm_link_hash_entry *) NULL)
57e8b36a
NC		 1196 ret = bfd_hash_allocate (table, sizeof (struct elf32_arm_link_hash_entry));
1197 if (ret == NULL)
780a67af
NC		 1198 return (struct bfd_hash_entry *) ret;
1199
1200 /* Call the allocation method of the superclass. */
1201 ret = ((struct elf32_arm_link_hash_entry *)
1202 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
1203 table, string));
57e8b36a 1204 if (ret != NULL)
5e681ec4 1205 ret->relocs_copied = NULL;
780a67af
NC		 1206
1207 return (struct bfd_hash_entry *) ret;
1208}
1209
5e681ec4
PB		 1210/* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
1211 shortcuts to them in our hash table. */
1212
1213static bfd_boolean
57e8b36a 1214create_got_section (bfd *dynobj, struct bfd_link_info *info)
5e681ec4
PB		 1215{
1216 struct elf32_arm_link_hash_table *htab;
1217
e5a52504
MM		 1218 htab = elf32_arm_hash_table (info);
1219 /* BPABI objects never have a GOT, or associated sections. */
1220 if (htab->symbian_p)
1221 return TRUE;
1222
5e681ec4
PB		 1223 if (! _bfd_elf_create_got_section (dynobj, info))
1224 return FALSE;
1225
5e681ec4
PB		 1226 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
1227 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
1228 if (!htab->sgot || !htab->sgotplt)
1229 abort ();
1230
1231 htab->srelgot = bfd_make_section (dynobj, ".rel.got");
1232 if (htab->srelgot == NULL
1233 || ! bfd_set_section_flags (dynobj, htab->srelgot,
1234 (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
1235 | SEC_IN_MEMORY | SEC_LINKER_CREATED
1236 | SEC_READONLY))
1237 || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
1238 return FALSE;
1239 return TRUE;
1240}
1241
1242/* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
1243 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
1244 hash table. */
1245
1246static bfd_boolean
57e8b36a 1247elf32_arm_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
5e681ec4
PB		 1248{
1249 struct elf32_arm_link_hash_table *htab;
1250
1251 htab = elf32_arm_hash_table (info);
1252 if (!htab->sgot && !create_got_section (dynobj, info))
1253 return FALSE;
1254
1255 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
1256 return FALSE;
1257
1258 htab->splt = bfd_get_section_by_name (dynobj, ".plt");
1259 htab->srelplt = bfd_get_section_by_name (dynobj, ".rel.plt");
1260 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
1261 if (!info->shared)
1262 htab->srelbss = bfd_get_section_by_name (dynobj, ".rel.bss");
1263
e5a52504
MM		 1264 if (!htab->splt
1265 || !htab->srelplt
1266 || !htab->sdynbss
5e681ec4
PB		 1267 || (!info->shared && !htab->srelbss))
1268 abort ();
1269
1270 return TRUE;
1271}
1272
1273/* Copy the extra info we tack onto an elf_link_hash_entry. */
1274
1275static void
1276elf32_arm_copy_indirect_symbol (const struct elf_backend_data *bed,
1277 struct elf_link_hash_entry *dir,
1278 struct elf_link_hash_entry *ind)
1279{
1280 struct elf32_arm_link_hash_entry *edir, *eind;
1281
1282 edir = (struct elf32_arm_link_hash_entry *) dir;
1283 eind = (struct elf32_arm_link_hash_entry *) ind;
1284
1285 if (eind->relocs_copied != NULL)
1286 {
1287 if (edir->relocs_copied != NULL)
1288 {
1289 struct elf32_arm_relocs_copied **pp;
1290 struct elf32_arm_relocs_copied *p;
1291
1292 if (ind->root.type == bfd_link_hash_indirect)
1293 abort ();
1294
1295 /* Add reloc counts against the weak sym to the strong sym
1296 list. Merge any entries against the same section. */
1297 for (pp = &eind->relocs_copied; (p = *pp) != NULL; )
1298 {
1299 struct elf32_arm_relocs_copied *q;
1300
1301 for (q = edir->relocs_copied; q != NULL; q = q->next)
1302 if (q->section == p->section)
1303 {
5e681ec4
PB		 1304 q->count += p->count;
1305 *pp = p->next;
1306 break;
1307 }
1308 if (q == NULL)
1309 pp = &p->next;
1310 }
1311 *pp = edir->relocs_copied;
1312 }
1313
1314 edir->relocs_copied = eind->relocs_copied;
1315 eind->relocs_copied = NULL;
1316 }
1317
1318 _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
1319}
1320
9b485d32 1321/* Create an ARM elf linker hash table. */
252b5132
RH		 1322
1323static struct bfd_link_hash_table *
57e8b36a 1324elf32_arm_link_hash_table_create (bfd *abfd)
252b5132
RH		 1325{
1326 struct elf32_arm_link_hash_table *ret;
dc810e39 1327 bfd_size_type amt = sizeof (struct elf32_arm_link_hash_table);
252b5132 1328
57e8b36a
NC		 1329 ret = bfd_malloc (amt);
1330 if (ret == NULL)
252b5132
RH		 1331 return NULL;
1332
57e8b36a 1333 if (!_bfd_elf_link_hash_table_init (& ret->root, abfd,
780a67af 1334 elf32_arm_link_hash_newfunc))
252b5132 1335 {
e2d34d7d 1336 free (ret);
252b5132
RH		 1337 return NULL;
1338 }
1339
5e681ec4
PB		 1340 ret->sgot = NULL;
1341 ret->sgotplt = NULL;
1342 ret->srelgot = NULL;
1343 ret->splt = NULL;
1344 ret->srelplt = NULL;
1345 ret->sdynbss = NULL;
1346 ret->srelbss = NULL;
252b5132
RH		 1347 ret->thumb_glue_size = 0;
1348 ret->arm_glue_size = 0;
1349 ret->bfd_of_glue_owner = NULL;
ba96a88f 1350 ret->no_pipeline_knowledge = 0;
e489d0ae 1351 ret->byteswap_code = 0;
9c504268 1352 ret->target1_is_rel = 0;
eb043451 1353 ret->target2_reloc = R_ARM_NONE;
e5a52504
MM		 1354#ifdef FOUR_WORD_PLT
1355 ret->plt_header_size = 16;
1356 ret->plt_entry_size = 16;
1357#else
1358 ret->plt_header_size = 20;
1359 ret->plt_entry_size = 12;
1360#endif
1361 ret->symbian_p = 0;
5e681ec4 1362 ret->sym_sec.abfd = NULL;
252b5132
RH		 1363
1364 return &ret->root.root;
1365}
1366
9b485d32
NC		 1367/* Locate the Thumb encoded calling stub for NAME. */
1368
252b5132 1369static struct elf_link_hash_entry *
57e8b36a
NC		 1370find_thumb_glue (struct bfd_link_info *link_info,
1371 const char *name,
1372 bfd *input_bfd)
252b5132
RH		 1373{
1374 char *tmp_name;
1375 struct elf_link_hash_entry *hash;
1376 struct elf32_arm_link_hash_table *hash_table;
1377
1378 /* We need a pointer to the armelf specific hash table. */
1379 hash_table = elf32_arm_hash_table (link_info);
1380
57e8b36a
NC		 1381 tmp_name = bfd_malloc ((bfd_size_type) strlen (name)
1382 + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1);
252b5132
RH		 1383
1384 BFD_ASSERT (tmp_name);
1385
1386 sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
1387
1388 hash = elf_link_hash_lookup
b34976b6 1389 (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
252b5132
RH		 1390
1391 if (hash == NULL)
1392 /* xgettext:c-format */
d003868e
AM		 1393 (*_bfd_error_handler) (_("%B: unable to find THUMB glue '%s' for `%s'"),
1394 input_bfd, tmp_name, name);
252b5132
RH		 1395
1396 free (tmp_name);
1397
1398 return hash;
1399}
1400
9b485d32
NC		 1401/* Locate the ARM encoded calling stub for NAME. */
1402
252b5132 1403static struct elf_link_hash_entry *
57e8b36a
NC		 1404find_arm_glue (struct bfd_link_info *link_info,
1405 const char *name,
1406 bfd *input_bfd)
252b5132
RH		 1407{
1408 char *tmp_name;
1409 struct elf_link_hash_entry *myh;
1410 struct elf32_arm_link_hash_table *hash_table;
1411
1412 /* We need a pointer to the elfarm specific hash table. */
1413 hash_table = elf32_arm_hash_table (link_info);
1414
57e8b36a
NC		 1415 tmp_name = bfd_malloc ((bfd_size_type) strlen (name)
1416 + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
252b5132
RH		 1417
1418 BFD_ASSERT (tmp_name);
1419
1420 sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
1421
1422 myh = elf_link_hash_lookup
b34976b6 1423 (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
252b5132
RH		 1424
1425 if (myh == NULL)
1426 /* xgettext:c-format */
d003868e
AM		 1427 (*_bfd_error_handler) (_("%B: unable to find ARM glue '%s' for `%s'"),
1428 input_bfd, tmp_name, name);
252b5132
RH		 1429
1430 free (tmp_name);
1431
1432 return myh;
1433}
1434
9b485d32 1435/* ARM->Thumb glue:
252b5132
RH		 1436
1437 .arm
1438 __func_from_arm:
1439 ldr r12, __func_addr
1440 bx r12
1441 __func_addr:
9b485d32 1442 .word func @ behave as if you saw a ARM_32 reloc. */
252b5132
RH		 1443
1444#define ARM2THUMB_GLUE_SIZE 12
1445static const insn32 a2t1_ldr_insn = 0xe59fc000;
1446static const insn32 a2t2_bx_r12_insn = 0xe12fff1c;
1447static const insn32 a2t3_func_addr_insn = 0x00000001;
1448
9b485d32 1449/* Thumb->ARM: Thumb->(non-interworking aware) ARM
252b5132
RH		 1450
1451 .thumb .thumb
1452 .align 2 .align 2
1453 __func_from_thumb: __func_from_thumb:
1454 bx pc push {r6, lr}
1455 nop ldr r6, __func_addr
1456 .arm mov lr, pc
1457 __func_change_to_arm: bx r6
1458 b func .arm
1459 __func_back_to_thumb:
1460 ldmia r13! {r6, lr}
1461 bx lr
1462 __func_addr:
9b485d32 1463 .word func */
252b5132
RH		 1464
1465#define THUMB2ARM_GLUE_SIZE 8
1466static const insn16 t2a1_bx_pc_insn = 0x4778;
1467static const insn16 t2a2_noop_insn = 0x46c0;
1468static const insn32 t2a3_b_insn = 0xea000000;
1469
7e392df6 1470#ifndef ELFARM_NABI_C_INCLUDED
b34976b6 1471bfd_boolean
57e8b36a 1472bfd_elf32_arm_allocate_interworking_sections (struct bfd_link_info * info)
252b5132
RH		 1473{
1474 asection * s;
1475 bfd_byte * foo;
1476 struct elf32_arm_link_hash_table * globals;
1477
1478 globals = elf32_arm_hash_table (info);
1479
1480 BFD_ASSERT (globals != NULL);
1481
1482 if (globals->arm_glue_size != 0)
1483 {
1484 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
1485
dc810e39
AM		 1486 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
1487 ARM2THUMB_GLUE_SECTION_NAME);
252b5132
RH		 1488
1489 BFD_ASSERT (s != NULL);
1490
57e8b36a 1491 foo = bfd_alloc (globals->bfd_of_glue_owner, globals->arm_glue_size);
252b5132 1492
eea6121a 1493 s->size = globals->arm_glue_size;
252b5132
RH		 1494 s->contents = foo;
1495 }
1496
1497 if (globals->thumb_glue_size != 0)
1498 {
1499 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
1500
1501 s = bfd_get_section_by_name
1502 (globals->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
1503
1504 BFD_ASSERT (s != NULL);
1505
57e8b36a 1506 foo = bfd_alloc (globals->bfd_of_glue_owner, globals->thumb_glue_size);
252b5132 1507
eea6121a 1508 s->size = globals->thumb_glue_size;
252b5132
RH		 1509 s->contents = foo;
1510 }
1511
b34976b6 1512 return TRUE;
252b5132
RH		 1513}
1514
1515static void
57e8b36a
NC		 1516record_arm_to_thumb_glue (struct bfd_link_info * link_info,
1517 struct elf_link_hash_entry * h)
252b5132
RH		 1518{
1519 const char * name = h->root.root.string;
63b0f745 1520 asection * s;
252b5132
RH		 1521 char * tmp_name;
1522 struct elf_link_hash_entry * myh;
14a793b2 1523 struct bfd_link_hash_entry * bh;
252b5132 1524 struct elf32_arm_link_hash_table * globals;
dc810e39 1525 bfd_vma val;
252b5132
RH		 1526
1527 globals = elf32_arm_hash_table (link_info);
1528
1529 BFD_ASSERT (globals != NULL);
1530 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
1531
1532 s = bfd_get_section_by_name
1533 (globals->bfd_of_glue_owner, ARM2THUMB_GLUE_SECTION_NAME);
1534
252b5132
RH		 1535 BFD_ASSERT (s != NULL);
1536
57e8b36a 1537 tmp_name = bfd_malloc ((bfd_size_type) strlen (name) + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
252b5132
RH		 1538
1539 BFD_ASSERT (tmp_name);
1540
1541 sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
1542
1543 myh = elf_link_hash_lookup
b34976b6 1544 (&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
252b5132
RH		 1545
1546 if (myh != NULL)
1547 {
9b485d32 1548 /* We've already seen this guy. */
252b5132 1549 free (tmp_name);
9b485d32 1550 return;
252b5132
RH		 1551 }
1552
57e8b36a
NC		 1553 /* The only trick here is using hash_table->arm_glue_size as the value.
1554 Even though the section isn't allocated yet, this is where we will be
1555 putting it. */
14a793b2 1556 bh = NULL;
dc810e39
AM		 1557 val = globals->arm_glue_size + 1;
1558 _bfd_generic_link_add_one_symbol (link_info, globals->bfd_of_glue_owner,
1559 tmp_name, BSF_GLOBAL, s, val,
b34976b6 1560 NULL, TRUE, FALSE, &bh);
252b5132
RH		 1561
1562 free (tmp_name);
1563
1564 globals->arm_glue_size += ARM2THUMB_GLUE_SIZE;
1565
1566 return;
1567}
1568
1569static void
57e8b36a
NC		 1570record_thumb_to_arm_glue (struct bfd_link_info *link_info,
1571 struct elf_link_hash_entry *h)
252b5132
RH		 1572{
1573 const char *name = h->root.root.string;
63b0f745 1574 asection *s;
252b5132
RH		 1575 char *tmp_name;
1576 struct elf_link_hash_entry *myh;
14a793b2 1577 struct bfd_link_hash_entry *bh;
252b5132
RH		 1578 struct elf32_arm_link_hash_table *hash_table;
1579 char bind;
dc810e39 1580 bfd_vma val;
252b5132
RH		 1581
1582 hash_table = elf32_arm_hash_table (link_info);
1583
1584 BFD_ASSERT (hash_table != NULL);
1585 BFD_ASSERT (hash_table->bfd_of_glue_owner != NULL);
1586
1587 s = bfd_get_section_by_name
1588 (hash_table->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
1589
1590 BFD_ASSERT (s != NULL);
1591
57e8b36a
NC		 1592 tmp_name = bfd_malloc ((bfd_size_type) strlen (name)
1593 + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1);
252b5132
RH		 1594
1595 BFD_ASSERT (tmp_name);
1596
1597 sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
1598
1599 myh = elf_link_hash_lookup
b34976b6 1600 (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
252b5132
RH		 1601
1602 if (myh != NULL)
1603 {
9b485d32 1604 /* We've already seen this guy. */
252b5132 1605 free (tmp_name);
9b485d32 1606 return;
252b5132
RH		 1607 }
1608
14a793b2 1609 bh = NULL;
dc810e39
AM		 1610 val = hash_table->thumb_glue_size + 1;
1611 _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner,
1612 tmp_name, BSF_GLOBAL, s, val,
b34976b6 1613 NULL, TRUE, FALSE, &bh);
252b5132 1614
9b485d32 1615 /* If we mark it 'Thumb', the disassembler will do a better job. */
14a793b2 1616 myh = (struct elf_link_hash_entry *) bh;
252b5132
RH		 1617 bind = ELF_ST_BIND (myh->type);
1618 myh->type = ELF_ST_INFO (bind, STT_ARM_TFUNC);
1619
1620 free (tmp_name);
1621
252b5132
RH		 1622#define CHANGE_TO_ARM "__%s_change_to_arm"
1623#define BACK_FROM_ARM "__%s_back_from_arm"
1624
9b485d32 1625 /* Allocate another symbol to mark where we switch to Arm mode. */
57e8b36a
NC		 1626 tmp_name = bfd_malloc ((bfd_size_type) strlen (name)
1627 + strlen (CHANGE_TO_ARM) + 1);
252b5132
RH		 1628
1629 BFD_ASSERT (tmp_name);
1630
1631 sprintf (tmp_name, CHANGE_TO_ARM, name);
1632
14a793b2 1633 bh = NULL;
dc810e39
AM		 1634 val = hash_table->thumb_glue_size + 4,
1635 _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner,
1636 tmp_name, BSF_LOCAL, s, val,
b34976b6 1637 NULL, TRUE, FALSE, &bh);
252b5132
RH		 1638
1639 free (tmp_name);
1640
1641 hash_table->thumb_glue_size += THUMB2ARM_GLUE_SIZE;
1642
1643 return;
1644}
1645
8afb0e02
NC		 1646/* Add the glue sections to ABFD. This function is called from the
1647 linker scripts in ld/emultempl/{armelf}.em. */
9b485d32 1648
b34976b6 1649bfd_boolean
57e8b36a
NC		 1650bfd_elf32_arm_add_glue_sections_to_bfd (bfd *abfd,
1651 struct bfd_link_info *info)
252b5132 1652{
252b5132
RH		 1653 flagword flags;
1654 asection *sec;
1655
8afb0e02
NC		 1656 /* If we are only performing a partial
1657 link do not bother adding the glue. */
1049f94e 1658 if (info->relocatable)
b34976b6 1659 return TRUE;
252b5132 1660
252b5132
RH		 1661 sec = bfd_get_section_by_name (abfd, ARM2THUMB_GLUE_SECTION_NAME);
1662
1663 if (sec == NULL)
1664 {
57db232e
NC		 1665 /* Note: we do not include the flag SEC_LINKER_CREATED, as this
1666 will prevent elf_link_input_bfd() from processing the contents
1667 of this section. */
811b4bf6 1668 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_CODE | SEC_READONLY;
252b5132
RH		 1669
1670 sec = bfd_make_section (abfd, ARM2THUMB_GLUE_SECTION_NAME);
1671
1672 if (sec == NULL
1673 || !bfd_set_section_flags (abfd, sec, flags)
1674 || !bfd_set_section_alignment (abfd, sec, 2))
b34976b6 1675 return FALSE;
9a5aca8c 1676
57db232e
NC		 1677 /* Set the gc mark to prevent the section from being removed by garbage
1678 collection, despite the fact that no relocs refer to this section. */
1679 sec->gc_mark = 1;
252b5132
RH		 1680 }
1681
1682 sec = bfd_get_section_by_name (abfd, THUMB2ARM_GLUE_SECTION_NAME);
1683
1684 if (sec == NULL)
1685 {
57e8b36a
NC		 1686 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1687 | SEC_CODE | SEC_READONLY;
252b5132
RH		 1688
1689 sec = bfd_make_section (abfd, THUMB2ARM_GLUE_SECTION_NAME);
1690
1691 if (sec == NULL
1692 || !bfd_set_section_flags (abfd, sec, flags)
1693 || !bfd_set_section_alignment (abfd, sec, 2))
b34976b6 1694 return FALSE;
9a5aca8c 1695
57db232e 1696 sec->gc_mark = 1;
252b5132
RH		 1697 }
1698
b34976b6 1699 return TRUE;
8afb0e02
NC		 1700}
1701
1702/* Select a BFD to be used to hold the sections used by the glue code.
1703 This function is called from the linker scripts in ld/emultempl/
1704 {armelf/pe}.em */
1705
b34976b6 1706bfd_boolean
57e8b36a 1707bfd_elf32_arm_get_bfd_for_interworking (bfd *abfd, struct bfd_link_info *info)
8afb0e02
NC		 1708{
1709 struct elf32_arm_link_hash_table *globals;
1710
1711 /* If we are only performing a partial link
1712 do not bother getting a bfd to hold the glue. */
1049f94e 1713 if (info->relocatable)
b34976b6 1714 return TRUE;
8afb0e02
NC		 1715
1716 globals = elf32_arm_hash_table (info);
1717
1718 BFD_ASSERT (globals != NULL);
1719
1720 if (globals->bfd_of_glue_owner != NULL)
b34976b6 1721 return TRUE;
8afb0e02 1722
252b5132
RH		 1723 /* Save the bfd for later use. */
1724 globals->bfd_of_glue_owner = abfd;
cedb70c5 1725
b34976b6 1726 return TRUE;
252b5132
RH		 1727}
1728
b34976b6 1729bfd_boolean
57e8b36a
NC		 1730bfd_elf32_arm_process_before_allocation (bfd *abfd,
1731 struct bfd_link_info *link_info,
1732 int no_pipeline_knowledge,
eb043451 1733 int byteswap_code)
252b5132
RH		 1734{
1735 Elf_Internal_Shdr *symtab_hdr;
6cdc0ccc 1736 Elf_Internal_Rela *internal_relocs = NULL;
252b5132
RH		 1737 Elf_Internal_Rela *irel, *irelend;
1738 bfd_byte *contents = NULL;
252b5132
RH		 1739
1740 asection *sec;
1741 struct elf32_arm_link_hash_table *globals;
1742
1743 /* If we are only performing a partial link do not bother
1744 to construct any glue. */
1049f94e 1745 if (link_info->relocatable)
b34976b6 1746 return TRUE;
252b5132
RH		 1747
1748 /* Here we have a bfd that is to be included on the link. We have a hook
1749 to do reloc rummaging, before section sizes are nailed down. */
252b5132
RH		 1750 globals = elf32_arm_hash_table (link_info);
1751
1752 BFD_ASSERT (globals != NULL);
1753 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
1754
ba96a88f 1755 globals->no_pipeline_knowledge = no_pipeline_knowledge;
eb043451 1756
e489d0ae
PB		 1757 if (byteswap_code && !bfd_big_endian (abfd))
1758 {
d003868e
AM		 1759 _bfd_error_handler (_("%B: BE8 images only valid in big-endian mode."),
1760 abfd);
e489d0ae
PB		 1761 return FALSE;
1762 }
1763 globals->byteswap_code = byteswap_code;
f21f3fe0 1764
252b5132
RH		 1765 /* Rummage around all the relocs and map the glue vectors. */
1766 sec = abfd->sections;
1767
1768 if (sec == NULL)
b34976b6 1769 return TRUE;
252b5132
RH		 1770
1771 for (; sec != NULL; sec = sec->next)
1772 {
1773 if (sec->reloc_count == 0)
1774 continue;
1775
1776 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
252b5132 1777
9b485d32 1778 /* Load the relocs. */
6cdc0ccc 1779 internal_relocs
57e8b36a 1780 = _bfd_elf_link_read_relocs (abfd, sec, (void *) NULL,
45d6a902 1781 (Elf_Internal_Rela *) NULL, FALSE);
252b5132 1782
6cdc0ccc
AM		 1783 if (internal_relocs == NULL)
1784 goto error_return;
252b5132 1785
6cdc0ccc
AM		 1786 irelend = internal_relocs + sec->reloc_count;
1787 for (irel = internal_relocs; irel < irelend; irel++)
252b5132
RH		 1788 {
1789 long r_type;
1790 unsigned long r_index;
252b5132
RH		 1791
1792 struct elf_link_hash_entry *h;
1793
1794 r_type = ELF32_R_TYPE (irel->r_info);
1795 r_index = ELF32_R_SYM (irel->r_info);
1796
9b485d32 1797 /* These are the only relocation types we care about. */
ba96a88f 1798 if ( r_type != R_ARM_PC24
5b5bb741
PB		 1799#ifndef OLD_ARM_ABI
1800 && r_type != R_ARM_CALL
1801 && r_type != R_ARM_JUMP24
1802#endif
252b5132
RH		 1803 && r_type != R_ARM_THM_PC22)
1804 continue;
1805
1806 /* Get the section contents if we haven't done so already. */
1807 if (contents == NULL)
1808 {
1809 /* Get cached copy if it exists. */
1810 if (elf_section_data (sec)->this_hdr.contents != NULL)
1811 contents = elf_section_data (sec)->this_hdr.contents;
1812 else
1813 {
1814 /* Go get them off disk. */
57e8b36a 1815 if (! bfd_malloc_and_get_section (abfd, sec, &contents))
252b5132
RH		 1816 goto error_return;
1817 }
1818 }
1819
a7c10850 1820 /* If the relocation is not against a symbol it cannot concern us. */
252b5132
RH		 1821 h = NULL;
1822
9b485d32 1823 /* We don't care about local symbols. */
252b5132
RH		 1824 if (r_index < symtab_hdr->sh_info)
1825 continue;
1826
9b485d32 1827 /* This is an external symbol. */
252b5132
RH		 1828 r_index -= symtab_hdr->sh_info;
1829 h = (struct elf_link_hash_entry *)
1830 elf_sym_hashes (abfd)[r_index];
1831
1832 /* If the relocation is against a static symbol it must be within
1833 the current section and so cannot be a cross ARM/Thumb relocation. */
1834 if (h == NULL)
1835 continue;
1836
1837 switch (r_type)
1838 {
1839 case R_ARM_PC24:
5b5bb741
PB		 1840#ifndef OLD_ARM_ABI
1841 case R_ARM_CALL:
1842 case R_ARM_JUMP24:
1843#endif
252b5132 1844 /* This one is a call from arm code. We need to look up
2f0ca46a 1845 the target of the call. If it is a thumb target, we
252b5132 1846 insert glue. */
252b5132
RH		 1847 if (ELF_ST_TYPE(h->type) == STT_ARM_TFUNC)
1848 record_arm_to_thumb_glue (link_info, h);
1849 break;
1850
1851 case R_ARM_THM_PC22:
f21f3fe0 1852 /* This one is a call from thumb code. We look
2f0ca46a 1853 up the target of the call. If it is not a thumb
bcbdc74c 1854 target, we insert glue. */
252b5132
RH		 1855 if (ELF_ST_TYPE (h->type) != STT_ARM_TFUNC)
1856 record_thumb_to_arm_glue (link_info, h);
1857 break;
1858
1859 default:
1860 break;
1861 }
1862 }
6cdc0ccc
AM		 1863
1864 if (contents != NULL
1865 && elf_section_data (sec)->this_hdr.contents != contents)
1866 free (contents);
1867 contents = NULL;
1868
1869 if (internal_relocs != NULL
1870 && elf_section_data (sec)->relocs != internal_relocs)
1871 free (internal_relocs);
1872 internal_relocs = NULL;
252b5132
RH		 1873 }
1874
b34976b6 1875 return TRUE;
9a5aca8c 1876
252b5132 1877error_return:
6cdc0ccc
AM		 1878 if (contents != NULL
1879 && elf_section_data (sec)->this_hdr.contents != contents)
1880 free (contents);
1881 if (internal_relocs != NULL
1882 && elf_section_data (sec)->relocs != internal_relocs)
1883 free (internal_relocs);
9a5aca8c 1884
b34976b6 1885 return FALSE;
252b5132 1886}
7e392df6 1887#endif
252b5132 1888
eb043451
PB		 1889
1890#ifndef OLD_ARM_ABI
1891/* Set target relocation values needed during linking. */
1892
1893void
1894bfd_elf32_arm_set_target_relocs (struct bfd_link_info *link_info,
1895 int target1_is_rel,
1896 char * target2_type)
1897{
1898 struct elf32_arm_link_hash_table *globals;
1899
1900 globals = elf32_arm_hash_table (link_info);
1901
1902 globals->target1_is_rel = target1_is_rel;
1903 if (strcmp (target2_type, "rel") == 0)
1904 globals->target2_reloc = R_ARM_REL32;
eeac373a
PB		 1905 else if (strcmp (target2_type, "abs") == 0)
1906 globals->target2_reloc = R_ARM_ABS32;
eb043451
PB		 1907 else if (strcmp (target2_type, "got-rel") == 0)
1908 globals->target2_reloc = R_ARM_GOT_PREL;
1909 else
1910 {
1911 _bfd_error_handler (_("Invalid TARGET2 relocation type '%s'."),
1912 target2_type);
1913 }
1914}
1915#endif
1916
252b5132
RH		 1917/* The thumb form of a long branch is a bit finicky, because the offset
1918 encoding is split over two fields, each in it's own instruction. They
f21f3fe0 1919 can occur in any order. So given a thumb form of long branch, and an
252b5132 1920 offset, insert the offset into the thumb branch and return finished
f21f3fe0 1921 instruction.
252b5132 1922
f21f3fe0 1923 It takes two thumb instructions to encode the target address. Each has
4cc11e76 1924 11 bits to invest. The upper 11 bits are stored in one (identified by
f21f3fe0
UD		 1925 H-0.. see below), the lower 11 bits are stored in the other (identified
1926 by H-1).
252b5132 1927
f21f3fe0 1928 Combine together and shifted left by 1 (it's a half word address) and
252b5132
RH		 1929 there you have it.
1930
1931 Op: 1111 = F,
1932 H-0, upper address-0 = 000
1933 Op: 1111 = F,
1934 H-1, lower address-0 = 800
1935
f21f3fe0 1936 They can be ordered either way, but the arm tools I've seen always put
252b5132
RH		 1937 the lower one first. It probably doesn't matter. [email protected]
1938
1939 XXX: Actually the order does matter. The second instruction (H-1)
1940 moves the computed address into the PC, so it must be the second one
1941 in the sequence. The problem, however is that whilst little endian code
1942 stores the instructions in HI then LOW order, big endian code does the
dfc5f959 1943 reverse. [email protected]. */
252b5132 1944
dfc5f959
NC		 1945#define LOW_HI_ORDER 0xF800F000
1946#define HI_LOW_ORDER 0xF000F800
252b5132
RH		 1947
1948static insn32
57e8b36a 1949insert_thumb_branch (insn32 br_insn, int rel_off)
252b5132
RH		 1950{
1951 unsigned int low_bits;
1952 unsigned int high_bits;
1953
252b5132
RH		 1954 BFD_ASSERT ((rel_off & 1) != 1);
1955
dfc5f959
NC		 1956 rel_off >>= 1; /* Half word aligned address. */
1957 low_bits = rel_off & 0x000007FF; /* The bottom 11 bits. */
1958 high_bits = (rel_off >> 11) & 0x000007FF; /* The top 11 bits. */
252b5132
RH		 1959
1960 if ((br_insn & LOW_HI_ORDER) == LOW_HI_ORDER)
1961 br_insn = LOW_HI_ORDER | (low_bits << 16) | high_bits;
1962 else if ((br_insn & HI_LOW_ORDER) == HI_LOW_ORDER)
1963 br_insn = HI_LOW_ORDER | (high_bits << 16) | low_bits;
1964 else
9b485d32 1965 /* FIXME: abort is probably not the right call. [email protected] */
57e8b36a 1966 abort (); /* Error - not a valid branch instruction form. */
252b5132 1967
252b5132
RH		 1968 return br_insn;
1969}
1970
9b485d32
NC		 1971/* Thumb code calling an ARM function. */
1972
252b5132 1973static int
57e8b36a
NC		 1974elf32_thumb_to_arm_stub (struct bfd_link_info * info,
1975 const char * name,
1976 bfd * input_bfd,
1977 bfd * output_bfd,
1978 asection * input_section,
1979 bfd_byte * hit_data,
1980 asection * sym_sec,
1981 bfd_vma offset,
1982 bfd_signed_vma addend,
1983 bfd_vma val)
252b5132 1984{
bcbdc74c 1985 asection * s = 0;
dc810e39 1986 bfd_vma my_offset;
252b5132
RH		 1987 unsigned long int tmp;
1988 long int ret_offset;
bcbdc74c
NC		 1989 struct elf_link_hash_entry * myh;
1990 struct elf32_arm_link_hash_table * globals;
252b5132
RH		 1991
1992 myh = find_thumb_glue (info, name, input_bfd);
1993 if (myh == NULL)
b34976b6 1994 return FALSE;
252b5132
RH		 1995
1996 globals = elf32_arm_hash_table (info);
1997
1998 BFD_ASSERT (globals != NULL);
1999 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2000
2001 my_offset = myh->root.u.def.value;
2002
2003 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
2004 THUMB2ARM_GLUE_SECTION_NAME);
2005
2006 BFD_ASSERT (s != NULL);
2007 BFD_ASSERT (s->contents != NULL);
2008 BFD_ASSERT (s->output_section != NULL);
2009
2010 if ((my_offset & 0x01) == 0x01)
2011 {
2012 if (sym_sec != NULL
2013 && sym_sec->owner != NULL
2014 && !INTERWORK_FLAG (sym_sec->owner))
2015 {
8f615d07 2016 (*_bfd_error_handler)
d003868e
AM		 2017 (_("%B(%s): warning: interworking not enabled.\n"
2018 " first occurrence: %B: thumb call to arm"),
2019 sym_sec->owner, input_bfd, name);
252b5132 2020
b34976b6 2021 return FALSE;
252b5132
RH		 2022 }
2023
2024 --my_offset;
2025 myh->root.u.def.value = my_offset;
2026
dc810e39 2027 bfd_put_16 (output_bfd, (bfd_vma) t2a1_bx_pc_insn,
252b5132
RH		 2028 s->contents + my_offset);
2029
dc810e39 2030 bfd_put_16 (output_bfd, (bfd_vma) t2a2_noop_insn,
252b5132
RH		 2031 s->contents + my_offset + 2);
2032
2033 ret_offset =
9b485d32
NC		 2034 /* Address of destination of the stub. */
2035 ((bfd_signed_vma) val)
252b5132 2036 - ((bfd_signed_vma)
57e8b36a
NC		 2037 /* Offset from the start of the current section
2038 to the start of the stubs. */
9b485d32
NC		 2039 (s->output_offset
2040 /* Offset of the start of this stub from the start of the stubs. */
2041 + my_offset
2042 /* Address of the start of the current section. */
2043 + s->output_section->vma)
2044 /* The branch instruction is 4 bytes into the stub. */
2045 + 4
2046 /* ARM branches work from the pc of the instruction + 8. */
2047 + 8);
252b5132
RH		 2048
2049 bfd_put_32 (output_bfd,
dc810e39 2050 (bfd_vma) t2a3_b_insn | ((ret_offset >> 2) & 0x00FFFFFF),
252b5132
RH		 2051 s->contents + my_offset + 4);
2052 }
2053
2054 BFD_ASSERT (my_offset <= globals->thumb_glue_size);
2055
427bfd90
NC		 2056 /* Now go back and fix up the original BL insn to point to here. */
2057 ret_offset =
2058 /* Address of where the stub is located. */
2059 (s->output_section->vma + s->output_offset + my_offset)
2060 /* Address of where the BL is located. */
57e8b36a
NC		 2061 - (input_section->output_section->vma + input_section->output_offset
2062 + offset)
427bfd90
NC		 2063 /* Addend in the relocation. */
2064 - addend
2065 /* Biassing for PC-relative addressing. */
2066 - 8;
252b5132
RH		 2067
2068 tmp = bfd_get_32 (input_bfd, hit_data
2069 - input_section->vma);
2070
2071 bfd_put_32 (output_bfd,
dc810e39 2072 (bfd_vma) insert_thumb_branch (tmp, ret_offset),
252b5132
RH		 2073 hit_data - input_section->vma);
2074
b34976b6 2075 return TRUE;
252b5132
RH		 2076}
2077
9b485d32
NC		 2078/* Arm code calling a Thumb function. */
2079
252b5132 2080static int
57e8b36a
NC		 2081elf32_arm_to_thumb_stub (struct bfd_link_info * info,
2082 const char * name,
2083 bfd * input_bfd,
2084 bfd * output_bfd,
2085 asection * input_section,
2086 bfd_byte * hit_data,
2087 asection * sym_sec,
2088 bfd_vma offset,
2089 bfd_signed_vma addend,
2090 bfd_vma val)
252b5132
RH		 2091{
2092 unsigned long int tmp;
dc810e39 2093 bfd_vma my_offset;
bcbdc74c 2094 asection * s;
252b5132 2095 long int ret_offset;
bcbdc74c
NC		 2096 struct elf_link_hash_entry * myh;
2097 struct elf32_arm_link_hash_table * globals;
252b5132
RH		 2098
2099 myh = find_arm_glue (info, name, input_bfd);
2100 if (myh == NULL)
b34976b6 2101 return FALSE;
252b5132
RH		 2102
2103 globals = elf32_arm_hash_table (info);
2104
2105 BFD_ASSERT (globals != NULL);
2106 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2107
2108 my_offset = myh->root.u.def.value;
2109 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
2110 ARM2THUMB_GLUE_SECTION_NAME);
2111 BFD_ASSERT (s != NULL);
2112 BFD_ASSERT (s->contents != NULL);
2113 BFD_ASSERT (s->output_section != NULL);
2114
2115 if ((my_offset & 0x01) == 0x01)
2116 {
2117 if (sym_sec != NULL
2118 && sym_sec->owner != NULL
2119 && !INTERWORK_FLAG (sym_sec->owner))
2120 {
8f615d07 2121 (*_bfd_error_handler)
d003868e
AM		 2122 (_("%B(%s): warning: interworking not enabled.\n"
2123 " first occurrence: %B: arm call to thumb"),
2124 sym_sec->owner, input_bfd, name);
252b5132 2125 }
9b485d32 2126
252b5132
RH		 2127 --my_offset;
2128 myh->root.u.def.value = my_offset;
2129
dc810e39 2130 bfd_put_32 (output_bfd, (bfd_vma) a2t1_ldr_insn,
252b5132
RH		 2131 s->contents + my_offset);
2132
dc810e39 2133 bfd_put_32 (output_bfd, (bfd_vma) a2t2_bx_r12_insn,
252b5132
RH		 2134 s->contents + my_offset + 4);
2135
2136 /* It's a thumb address. Add the low order bit. */
2137 bfd_put_32 (output_bfd, val | a2t3_func_addr_insn,
2138 s->contents + my_offset + 8);
2139 }
2140
2141 BFD_ASSERT (my_offset <= globals->arm_glue_size);
2142
2143 tmp = bfd_get_32 (input_bfd, hit_data);
2144 tmp = tmp & 0xFF000000;
2145
9b485d32 2146 /* Somehow these are both 4 too far, so subtract 8. */
dc810e39
AM		 2147 ret_offset = (s->output_offset
2148 + my_offset
2149 + s->output_section->vma
2150 - (input_section->output_offset
2151 + input_section->output_section->vma
2152 + offset + addend)
2153 - 8);
9a5aca8c 2154
252b5132
RH		 2155 tmp = tmp | ((ret_offset >> 2) & 0x00FFFFFF);
2156
dc810e39 2157 bfd_put_32 (output_bfd, (bfd_vma) tmp, hit_data - input_section->vma);
252b5132 2158
b34976b6 2159 return TRUE;
252b5132
RH		 2160}
2161
eb043451
PB		 2162
2163#ifndef OLD_ARM_ABI
2164/* Some relocations map to different relocations depending on the
2165 target. Return the real relocation. */
2166static int
2167arm_real_reloc_type (struct elf32_arm_link_hash_table * globals,
2168 int r_type)
2169{
2170 switch (r_type)
2171 {
2172 case R_ARM_TARGET1:
2173 if (globals->target1_is_rel)
2174 return R_ARM_REL32;
2175 else
2176 return R_ARM_ABS32;
2177
2178 case R_ARM_TARGET2:
2179 return globals->target2_reloc;
2180
2181 default:
2182 return r_type;
2183 }
2184}
2185#endif /* OLD_ARM_ABI */
2186
2187
252b5132 2188/* Perform a relocation as part of a final link. */
9b485d32 2189
252b5132 2190static bfd_reloc_status_type
57e8b36a
NC		 2191elf32_arm_final_link_relocate (reloc_howto_type * howto,
2192 bfd * input_bfd,
2193 bfd * output_bfd,
2194 asection * input_section,
2195 bfd_byte * contents,
2196 Elf_Internal_Rela * rel,
2197 bfd_vma value,
2198 struct bfd_link_info * info,
2199 asection * sym_sec,
2200 const char * sym_name,
2201 int sym_flags,
2202 struct elf_link_hash_entry * h)
252b5132
RH		 2203{
2204 unsigned long r_type = howto->type;
2205 unsigned long r_symndx;
2206 bfd_byte * hit_data = contents + rel->r_offset;
2207 bfd * dynobj = NULL;
2208 Elf_Internal_Shdr * symtab_hdr;
2209 struct elf_link_hash_entry ** sym_hashes;
2210 bfd_vma * local_got_offsets;
2211 asection * sgot = NULL;
2212 asection * splt = NULL;
2213 asection * sreloc = NULL;
252b5132 2214 bfd_vma addend;
ba96a88f
NC		 2215 bfd_signed_vma signed_addend;
2216 struct elf32_arm_link_hash_table * globals;
f21f3fe0 2217
9c504268
PB		 2218 globals = elf32_arm_hash_table (info);
2219
2220#ifndef OLD_ARM_ABI
2221 /* Some relocation type map to different relocations depending on the
2222 target. We pick the right one here. */
eb043451
PB		 2223 r_type = arm_real_reloc_type (globals, r_type);
2224 if (r_type != howto->type)
2225 howto = elf32_arm_howto_from_type (r_type);
9c504268
PB		 2226#endif /* OLD_ARM_ABI */
2227
cac15327
NC		 2228 /* If the start address has been set, then set the EF_ARM_HASENTRY
2229 flag. Setting this more than once is redundant, but the cost is
2230 not too high, and it keeps the code simple.
99e4ae17 2231
cac15327
NC		 2232 The test is done here, rather than somewhere else, because the
2233 start address is only set just before the final link commences.
2234
2235 Note - if the user deliberately sets a start address of 0, the
2236 flag will not be set. */
2237 if (bfd_get_start_address (output_bfd) != 0)
2238 elf_elfheader (output_bfd)->e_flags |= EF_ARM_HASENTRY;
99e4ae17 2239
252b5132
RH		 2240 dynobj = elf_hash_table (info)->dynobj;
2241 if (dynobj)
2242 {
2243 sgot = bfd_get_section_by_name (dynobj, ".got");
2244 splt = bfd_get_section_by_name (dynobj, ".plt");
2245 }
2246 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
2247 sym_hashes = elf_sym_hashes (input_bfd);
2248 local_got_offsets = elf_local_got_offsets (input_bfd);
2249 r_symndx = ELF32_R_SYM (rel->r_info);
2250
acf8aed4 2251#if USE_REL
ba96a88f
NC		 2252 addend = bfd_get_32 (input_bfd, hit_data) & howto->src_mask;
2253
2254 if (addend & ((howto->src_mask + 1) >> 1))
2255 {
2256 signed_addend = -1;
2257 signed_addend &= ~ howto->src_mask;
2258 signed_addend |= addend;
2259 }
2260 else
2261 signed_addend = addend;
252b5132 2262#else
ba96a88f 2263 addend = signed_addend = rel->r_addend;
252b5132 2264#endif
f21f3fe0 2265
252b5132
RH		 2266 switch (r_type)
2267 {
2268 case R_ARM_NONE:
2269 return bfd_reloc_ok;
2270
2271 case R_ARM_PC24:
2272 case R_ARM_ABS32:
2273 case R_ARM_REL32:
dfc5f959 2274#ifndef OLD_ARM_ABI
5b5bb741
PB		 2275 case R_ARM_CALL:
2276 case R_ARM_JUMP24:
dfc5f959 2277 case R_ARM_XPC25:
eb043451 2278 case R_ARM_PREL31:
dfc5f959 2279#endif
7359ea65 2280 case R_ARM_PLT32:
5e681ec4
PB		 2281 /* r_symndx will be zero only for relocs against symbols
2282 from removed linkonce sections, or sections discarded by
2283 a linker script. */
2284 if (r_symndx == 0)
2285 return bfd_reloc_ok;
2286
7359ea65
DJ		 2287 /* Handle relocations which should use the PLT entry. ABS32/REL32
2288 will use the symbol's value, which may point to a PLT entry, but we
2289 don't need to handle that here. If we created a PLT entry, all
2290 branches in this object should go to it. */
eb043451
PB		 2291 if ((r_type != R_ARM_ABS32 && r_type != R_ARM_REL32
2292#ifndef OLD_ARM_ABI
2293 && r_type != R_ARM_PREL31
2294#endif
2295 )
7359ea65 2296 && h != NULL
c84cd8ee 2297 && splt != NULL
7359ea65
DJ		 2298 && h->plt.offset != (bfd_vma) -1)
2299 {
c84cd8ee
DJ		 2300 /* If we've created a .plt section, and assigned a PLT entry to
2301 this function, it should not be known to bind locally. If
2302 it were, we would have cleared the PLT entry. */
7359ea65
DJ		 2303 BFD_ASSERT (!SYMBOL_CALLS_LOCAL (info, h));
2304
2305 value = (splt->output_section->vma
2306 + splt->output_offset
2307 + h->plt.offset);
2308 return _bfd_final_link_relocate (howto, input_bfd, input_section,
2309 contents, rel->r_offset, value,
2310 (bfd_vma) 0);
2311 }
2312
252b5132 2313 /* When generating a shared object, these relocations are copied
9b485d32 2314 into the output file to be resolved at run time. */
7359ea65
DJ		 2315 if (info->shared
2316 && (input_section->flags & SEC_ALLOC)
eb043451
PB		 2317 && ((r_type != R_ARM_REL32
2318#ifndef OLD_ARM_ABI
2319 && r_type != R_ARM_PREL31
2320#endif
2321 ) || !SYMBOL_CALLS_LOCAL (info, h))
7359ea65
DJ		 2322 && (h == NULL
2323 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2324 || h->root.type != bfd_link_hash_undefweak)
2325 && r_type != R_ARM_PC24
5b5bb741
PB		 2326#ifndef OLD_ARM_ABI
2327 && r_type != R_ARM_CALL
2328 && r_type != R_ARM_JUMP24
2329#endif
7359ea65 2330 && r_type != R_ARM_PLT32)
252b5132 2331 {
947216bf
AM		 2332 Elf_Internal_Rela outrel;
2333 bfd_byte *loc;
b34976b6 2334 bfd_boolean skip, relocate;
f21f3fe0 2335
252b5132
RH		 2336 if (sreloc == NULL)
2337 {
2338 const char * name;
f21f3fe0 2339
252b5132
RH		 2340 name = (bfd_elf_string_from_elf_section
2341 (input_bfd,
2342 elf_elfheader (input_bfd)->e_shstrndx,
2343 elf_section_data (input_section)->rel_hdr.sh_name));
2344 if (name == NULL)
2345 return bfd_reloc_notsupported;
f21f3fe0 2346
252b5132
RH		 2347 BFD_ASSERT (strncmp (name, ".rel", 4) == 0
2348 && strcmp (bfd_get_section_name (input_bfd,
2349 input_section),
2350 name + 4) == 0);
f21f3fe0 2351
252b5132
RH		 2352 sreloc = bfd_get_section_by_name (dynobj, name);
2353 BFD_ASSERT (sreloc != NULL);
2354 }
f21f3fe0 2355
b34976b6
AM		 2356 skip = FALSE;
2357 relocate = FALSE;
f21f3fe0 2358
c629eae0
JJ		 2359 outrel.r_offset =
2360 _bfd_elf_section_offset (output_bfd, info, input_section,
2361 rel->r_offset);
2362 if (outrel.r_offset == (bfd_vma) -1)
b34976b6 2363 skip = TRUE;
0bb2d96a 2364 else if (outrel.r_offset == (bfd_vma) -2)
b34976b6 2365 skip = TRUE, relocate = TRUE;
252b5132
RH		 2366 outrel.r_offset += (input_section->output_section->vma
2367 + input_section->output_offset);
f21f3fe0 2368
252b5132 2369 if (skip)
0bb2d96a 2370 memset (&outrel, 0, sizeof outrel);
5e681ec4
PB		 2371 else if (h != NULL
2372 && h->dynindx != -1
7359ea65 2373 && (!info->shared
5e681ec4 2374 || !info->symbolic
f5385ebf 2375 || !h->def_regular))
5e681ec4 2376 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
252b5132
RH		 2377 else
2378 {
5e681ec4
PB		 2379 /* This symbol is local, or marked to become local. */
2380 relocate = TRUE;
2381 outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
252b5132 2382 }
f21f3fe0 2383
947216bf
AM		 2384 loc = sreloc->contents;
2385 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
2386 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
9a5aca8c 2387
f21f3fe0 2388 /* If this reloc is against an external symbol, we do not want to
252b5132 2389 fiddle with the addend. Otherwise, we need to include the symbol
9b485d32 2390 value so that it becomes an addend for the dynamic reloc. */
252b5132
RH		 2391 if (! relocate)
2392 return bfd_reloc_ok;
9a5aca8c 2393
f21f3fe0 2394 return _bfd_final_link_relocate (howto, input_bfd, input_section,
252b5132
RH		 2395 contents, rel->r_offset, value,
2396 (bfd_vma) 0);
2397 }
2398 else switch (r_type)
2399 {
dfc5f959
NC		 2400#ifndef OLD_ARM_ABI
2401 case R_ARM_XPC25: /* Arm BLX instruction. */
5b5bb741
PB		 2402 case R_ARM_CALL:
2403 case R_ARM_JUMP24:
dfc5f959
NC		 2404#endif
2405 case R_ARM_PC24: /* Arm B/BL instruction */
7359ea65 2406 case R_ARM_PLT32:
dfc5f959
NC		 2407#ifndef OLD_ARM_ABI
2408 if (r_type == R_ARM_XPC25)
252b5132 2409 {
dfc5f959
NC		 2410 /* Check for Arm calling Arm function. */
2411 /* FIXME: Should we translate the instruction into a BL
2412 instruction instead ? */
2413 if (sym_flags != STT_ARM_TFUNC)
d003868e
AM		 2414 (*_bfd_error_handler)
2415 (_("\%B: Warning: Arm BLX instruction targets Arm function '%s'."),
2416 input_bfd,
2417 h ? h->root.root.string : "(local)");
dfc5f959
NC		 2418 }
2419 else
2420#endif
2421 {
2422 /* Check for Arm calling Thumb function. */
2423 if (sym_flags == STT_ARM_TFUNC)
2424 {
57e8b36a
NC		 2425 elf32_arm_to_thumb_stub (info, sym_name, input_bfd,
2426 output_bfd, input_section,
2427 hit_data, sym_sec, rel->r_offset,
dfc5f959
NC		 2428 signed_addend, value);
2429 return bfd_reloc_ok;
2430 }
252b5132 2431 }
ba96a88f
NC		 2432
2433 if ( strcmp (bfd_get_target (input_bfd), "elf32-littlearm-oabi") == 0
2434 || strcmp (bfd_get_target (input_bfd), "elf32-bigarm-oabi") == 0)
2435 {
2436 /* The old way of doing things. Trearing the addend as a
2437 byte sized field and adding in the pipeline offset. */
ba96a88f
NC		 2438 value -= (input_section->output_section->vma
2439 + input_section->output_offset);
2440 value -= rel->r_offset;
2441 value += addend;
f21f3fe0 2442
ba96a88f
NC		 2443 if (! globals->no_pipeline_knowledge)
2444 value -= 8;
2445 }
2446 else
2447 {
2448 /* The ARM ELF ABI says that this reloc is computed as: S - P + A
2449 where:
2450 S is the address of the symbol in the relocation.
2451 P is address of the instruction being relocated.
2452 A is the addend (extracted from the instruction) in bytes.
f21f3fe0 2453
ba96a88f 2454 S is held in 'value'.
57e8b36a
NC		 2455 P is the base address of the section containing the
2456 instruction plus the offset of the reloc into that
2457 section, ie:
ba96a88f
NC		 2458 (input_section->output_section->vma +
2459 input_section->output_offset +
2460 rel->r_offset).
2461 A is the addend, converted into bytes, ie:
2462 (signed_addend * 4)
2463
2464 Note: None of these operations have knowledge of the pipeline
57e8b36a
NC		 2465 size of the processor, thus it is up to the assembler to
2466 encode this information into the addend. */
ba96a88f
NC		 2467 value -= (input_section->output_section->vma
2468 + input_section->output_offset);
2469 value -= rel->r_offset;
2470 value += (signed_addend << howto->size);
f21f3fe0 2471
57e8b36a
NC		 2472 /* Previous versions of this code also used to add in the
2473 pipeline offset here. This is wrong because the linker is
2474 not supposed to know about such things, and one day it might
2475 change. In order to support old binaries that need the old
2476 behaviour however, so we attempt to detect which ABI was
2477 used to create the reloc. */
ba96a88f 2478 if (! globals->no_pipeline_knowledge)
f21f3fe0 2479 {
ba96a88f 2480 Elf_Internal_Ehdr * i_ehdrp; /* Elf file header, internal form */
f21f3fe0 2481
ba96a88f 2482 i_ehdrp = elf_elfheader (input_bfd);
f21f3fe0 2483
ba96a88f
NC		 2484 if (i_ehdrp->e_ident[EI_OSABI] == 0)
2485 value -= 8;
2486 }
2487 }
23080146 2488
dcb5e6e6
NC		 2489 signed_addend = value;
2490 signed_addend >>= howto->rightshift;
9a5aca8c 2491
59f2c4e7
NC		 2492 /* It is not an error for an undefined weak reference to be
2493 out of range. Any program that branches to such a symbol
9a5aca8c
AM		 2494 is going to crash anyway, so there is no point worrying
2495 about getting the destination exactly right. */
59f2c4e7
NC		 2496 if (! h || h->root.type != bfd_link_hash_undefweak)
2497 {
9b485d32 2498 /* Perform a signed range check. */
dcb5e6e6 2499 if ( signed_addend > ((bfd_signed_vma) (howto->dst_mask >> 1))
59f2c4e7
NC		 2500 || signed_addend < - ((bfd_signed_vma) ((howto->dst_mask + 1) >> 1)))
2501 return bfd_reloc_overflow;
2502 }
9a5aca8c 2503
dcb5e6e6
NC		 2504#ifndef OLD_ARM_ABI
2505 /* If necessary set the H bit in the BLX instruction. */
2506 if (r_type == R_ARM_XPC25 && ((value & 2) == 2))
2507 value = (signed_addend & howto->dst_mask)
2508 | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask))
2509 | (1 << 24);
2510 else
2511#endif
2512 value = (signed_addend & howto->dst_mask)
2513 | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask));
252b5132 2514 break;
f21f3fe0 2515
252b5132
RH		 2516 case R_ARM_ABS32:
2517 value += addend;
2518 if (sym_flags == STT_ARM_TFUNC)
2519 value |= 1;
2520 break;
f21f3fe0 2521
252b5132
RH		 2522 case R_ARM_REL32:
2523 value -= (input_section->output_section->vma
62efb346 2524 + input_section->output_offset + rel->r_offset);
252b5132
RH		 2525 value += addend;
2526 break;
eb043451
PB		 2527
2528#ifndef OLD_ARM_ABI
2529 case R_ARM_PREL31:
2530 value -= (input_section->output_section->vma
2531 + input_section->output_offset + rel->r_offset);
2532 value += signed_addend;
2533 if (! h || h->root.type != bfd_link_hash_undefweak)
2534 {
2535 /* Check for overflow */
2536 if ((value ^ (value >> 1)) & (1 << 30))
2537 return bfd_reloc_overflow;
2538 }
2539 value &= 0x7fffffff;
2540 value |= (bfd_get_32 (input_bfd, hit_data) & 0x80000000);
2541 if (sym_flags == STT_ARM_TFUNC)
2542 value |= 1;
2543 break;
2544#endif
252b5132 2545 }
f21f3fe0 2546
252b5132
RH		 2547 bfd_put_32 (input_bfd, value, hit_data);
2548 return bfd_reloc_ok;
2549
2550 case R_ARM_ABS8:
2551 value += addend;
2552 if ((long) value > 0x7f || (long) value < -0x80)
2553 return bfd_reloc_overflow;
2554
2555 bfd_put_8 (input_bfd, value, hit_data);
2556 return bfd_reloc_ok;
2557
2558 case R_ARM_ABS16:
2559 value += addend;
2560
2561 if ((long) value > 0x7fff || (long) value < -0x8000)
2562 return bfd_reloc_overflow;
2563
2564 bfd_put_16 (input_bfd, value, hit_data);
2565 return bfd_reloc_ok;
2566
2567 case R_ARM_ABS12:
2568 /* Support ldr and str instruction for the arm */
2569 /* Also thumb b (unconditional branch). ??? Really? */
2570 value += addend;
2571
2572 if ((long) value > 0x7ff || (long) value < -0x800)
2573 return bfd_reloc_overflow;
2574
2575 value |= (bfd_get_32 (input_bfd, hit_data) & 0xfffff000);
2576 bfd_put_32 (input_bfd, value, hit_data);
2577 return bfd_reloc_ok;
2578
2579 case R_ARM_THM_ABS5:
9b485d32 2580 /* Support ldr and str instructions for the thumb. */
acf8aed4 2581#if USE_REL
252b5132
RH		 2582 /* Need to refetch addend. */
2583 addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
2584 /* ??? Need to determine shift amount from operand size. */
2585 addend >>= howto->rightshift;
2586#endif
2587 value += addend;
2588
2589 /* ??? Isn't value unsigned? */
2590 if ((long) value > 0x1f || (long) value < -0x10)
2591 return bfd_reloc_overflow;
2592
2593 /* ??? Value needs to be properly shifted into place first. */
2594 value |= bfd_get_16 (input_bfd, hit_data) & 0xf83f;
2595 bfd_put_16 (input_bfd, value, hit_data);
2596 return bfd_reloc_ok;
2597
dfc5f959
NC		 2598#ifndef OLD_ARM_ABI
2599 case R_ARM_THM_XPC22:
2600#endif
252b5132 2601 case R_ARM_THM_PC22:
dfc5f959 2602 /* Thumb BL (branch long instruction). */
252b5132 2603 {
b34976b6
AM		 2604 bfd_vma relocation;
2605 bfd_boolean overflow = FALSE;
2606 bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
2607 bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
df212a7e 2608 bfd_signed_vma reloc_signed_max = ((1 << (howto->bitsize - 1)) - 1) >> howto->rightshift;
ba96a88f 2609 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
b34976b6 2610 bfd_vma check;
252b5132 2611 bfd_signed_vma signed_check;
252b5132 2612
acf8aed4 2613#if USE_REL
252b5132
RH		 2614 /* Need to refetch the addend and squish the two 11 bit pieces
2615 together. */
2616 {
ba96a88f
NC		 2617 bfd_vma upper = upper_insn & 0x7ff;
2618 bfd_vma lower = lower_insn & 0x7ff;
9b485d32 2619 upper = (upper ^ 0x400) - 0x400; /* Sign extend. */
252b5132 2620 addend = (upper << 12) | (lower << 1);
ba96a88f 2621 signed_addend = addend;
252b5132
RH		 2622 }
2623#endif
dfc5f959
NC		 2624#ifndef OLD_ARM_ABI
2625 if (r_type == R_ARM_THM_XPC22)
2626 {
2627 /* Check for Thumb to Thumb call. */
2628 /* FIXME: Should we translate the instruction into a BL
2629 instruction instead ? */
2630 if (sym_flags == STT_ARM_TFUNC)
d003868e
AM		 2631 (*_bfd_error_handler)
2632 (_("%B: Warning: Thumb BLX instruction targets thumb function '%s'."),
2633 input_bfd,
2634 h ? h->root.root.string : "(local)");
dfc5f959
NC		 2635 }
2636 else
2637#endif
252b5132 2638 {
dfc5f959
NC		 2639 /* If it is not a call to Thumb, assume call to Arm.
2640 If it is a call relative to a section name, then it is not a
2641 function call at all, but rather a long jump. */
2642 if (sym_flags != STT_ARM_TFUNC && sym_flags != STT_SECTION)
2643 {
2644 if (elf32_thumb_to_arm_stub
2645 (info, sym_name, input_bfd, output_bfd, input_section,
2646 hit_data, sym_sec, rel->r_offset, signed_addend, value))
2647 return bfd_reloc_ok;
2648 else
2649 return bfd_reloc_dangerous;
2650 }
252b5132 2651 }
f21f3fe0 2652
ba96a88f 2653 relocation = value + signed_addend;
f21f3fe0 2654
252b5132 2655 relocation -= (input_section->output_section->vma
ba96a88f
NC		 2656 + input_section->output_offset
2657 + rel->r_offset);
9a5aca8c 2658
ba96a88f
NC		 2659 if (! globals->no_pipeline_knowledge)
2660 {
9b485d32 2661 Elf_Internal_Ehdr * i_ehdrp; /* Elf file header, internal form. */
9a5aca8c 2662
ba96a88f 2663 i_ehdrp = elf_elfheader (input_bfd);
f21f3fe0 2664
ba96a88f
NC		 2665 /* Previous versions of this code also used to add in the pipline
2666 offset here. This is wrong because the linker is not supposed
2667 to know about such things, and one day it might change. In order
2668 to support old binaries that need the old behaviour however, so
2669 we attempt to detect which ABI was used to create the reloc. */
2670 if ( strcmp (bfd_get_target (input_bfd), "elf32-littlearm-oabi") == 0
2671 || strcmp (bfd_get_target (input_bfd), "elf32-bigarm-oabi") == 0
2672 || i_ehdrp->e_ident[EI_OSABI] == 0)
2673 relocation += 4;
2674 }
f21f3fe0 2675
252b5132
RH		 2676 check = relocation >> howto->rightshift;
2677
2678 /* If this is a signed value, the rightshift just dropped
2679 leading 1 bits (assuming twos complement). */
2680 if ((bfd_signed_vma) relocation >= 0)
2681 signed_check = check;
2682 else
2683 signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
2684
252b5132 2685 /* Assumes two's complement. */
ba96a88f 2686 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
b34976b6 2687 overflow = TRUE;
252b5132 2688
df425bc0 2689#ifndef OLD_ARM_ABI
4f3c3dbb
NC		 2690 if (r_type == R_ARM_THM_XPC22
2691 && ((lower_insn & 0x1800) == 0x0800))
c62e1cc3
NC		 2692 /* For a BLX instruction, make sure that the relocation is rounded up
2693 to a word boundary. This follows the semantics of the instruction
2694 which specifies that bit 1 of the target address will come from bit
2695 1 of the base address. */
2696 relocation = (relocation + 2) & ~ 3;
99e4ae17 2697#endif
c62e1cc3
NC		 2698 /* Put RELOCATION back into the insn. */
2699 upper_insn = (upper_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 12) & 0x7ff);
2700 lower_insn = (lower_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 1) & 0x7ff);
2701
252b5132
RH		 2702 /* Put the relocated value back in the object file: */
2703 bfd_put_16 (input_bfd, upper_insn, hit_data);
2704 bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
2705
2706 return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
2707 }
2708 break;
2709
51c5503b
NC		 2710 case R_ARM_THM_PC11:
2711 /* Thumb B (branch) instruction). */
2712 {
6cf9e9fe 2713 bfd_signed_vma relocation;
51c5503b
NC		 2714 bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
2715 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
51c5503b
NC		 2716 bfd_signed_vma signed_check;
2717
acf8aed4 2718#if USE_REL
51c5503b
NC		 2719 /* Need to refetch addend. */
2720 addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
6cf9e9fe
NC		 2721 if (addend & ((howto->src_mask + 1) >> 1))
2722 {
2723 signed_addend = -1;
2724 signed_addend &= ~ howto->src_mask;
2725 signed_addend |= addend;
2726 }
2727 else
2728 signed_addend = addend;
2729 /* The value in the insn has been right shifted. We need to
2730 undo this, so that we can perform the address calculation
2731 in terms of bytes. */
2732 signed_addend <<= howto->rightshift;
51c5503b 2733#endif
6cf9e9fe 2734 relocation = value + signed_addend;
51c5503b
NC		 2735
2736 relocation -= (input_section->output_section->vma
2737 + input_section->output_offset
2738 + rel->r_offset);
2739
6cf9e9fe
NC		 2740 relocation >>= howto->rightshift;
2741 signed_check = relocation;
2742 relocation &= howto->dst_mask;
51c5503b 2743 relocation |= (bfd_get_16 (input_bfd, hit_data) & (~ howto->dst_mask));
cedb70c5 2744
51c5503b
NC		 2745 bfd_put_16 (input_bfd, relocation, hit_data);
2746
2747 /* Assumes two's complement. */
2748 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
2749 return bfd_reloc_overflow;
2750
2751 return bfd_reloc_ok;
2752 }
cedb70c5 2753
1f433d93 2754#ifndef OLD_ARM_ABI
8375c36b
PB		 2755 case R_ARM_ALU_PCREL7_0:
2756 case R_ARM_ALU_PCREL15_8:
2757 case R_ARM_ALU_PCREL23_15:
2758 {
2759 bfd_vma insn;
2760 bfd_vma relocation;
2761
2762 insn = bfd_get_32 (input_bfd, hit_data);
2763#if USE_REL
2764 /* Extract the addend. */
2765 addend = (insn & 0xff) << ((insn & 0xf00) >> 7);
2766 signed_addend = addend;
2767#endif
2768 relocation = value + signed_addend;
2769
2770 relocation -= (input_section->output_section->vma
2771 + input_section->output_offset
2772 + rel->r_offset);
2773 insn = (insn & ~0xfff)
2774 | ((howto->bitpos << 7) & 0xf00)
2775 | ((relocation >> howto->bitpos) & 0xff);
2776 bfd_put_32 (input_bfd, value, hit_data);
2777 }
2778 return bfd_reloc_ok;
1f433d93 2779#endif
8375c36b 2780
252b5132
RH		 2781 case R_ARM_GNU_VTINHERIT:
2782 case R_ARM_GNU_VTENTRY:
2783 return bfd_reloc_ok;
2784
2785 case R_ARM_COPY:
2786 return bfd_reloc_notsupported;
2787
2788 case R_ARM_GLOB_DAT:
2789 return bfd_reloc_notsupported;
2790
2791 case R_ARM_JUMP_SLOT:
2792 return bfd_reloc_notsupported;
2793
2794 case R_ARM_RELATIVE:
2795 return bfd_reloc_notsupported;
2796
2797 case R_ARM_GOTOFF:
2798 /* Relocation is relative to the start of the
2799 global offset table. */
2800
2801 BFD_ASSERT (sgot != NULL);
2802 if (sgot == NULL)
2803 return bfd_reloc_notsupported;
9a5aca8c 2804
cedb70c5 2805 /* If we are addressing a Thumb function, we need to adjust the
ee29b9fb
RE		 2806 address by one, so that attempts to call the function pointer will
2807 correctly interpret it as Thumb code. */
2808 if (sym_flags == STT_ARM_TFUNC)
2809 value += 1;
2810
252b5132
RH		 2811 /* Note that sgot->output_offset is not involved in this
2812 calculation. We always want the start of .got. If we
2813 define _GLOBAL_OFFSET_TABLE in a different way, as is
2814 permitted by the ABI, we might have to change this
9b485d32 2815 calculation. */
252b5132 2816 value -= sgot->output_section->vma;
f21f3fe0 2817 return _bfd_final_link_relocate (howto, input_bfd, input_section,
99e4ae17
AJ		 2818 contents, rel->r_offset, value,
2819 (bfd_vma) 0);
252b5132
RH		 2820
2821 case R_ARM_GOTPC:
a7c10850 2822 /* Use global offset table as symbol value. */
252b5132 2823 BFD_ASSERT (sgot != NULL);
f21f3fe0 2824
252b5132
RH		 2825 if (sgot == NULL)
2826 return bfd_reloc_notsupported;
2827
2828 value = sgot->output_section->vma;
f21f3fe0 2829 return _bfd_final_link_relocate (howto, input_bfd, input_section,
99e4ae17
AJ		 2830 contents, rel->r_offset, value,
2831 (bfd_vma) 0);
f21f3fe0 2832
252b5132 2833 case R_ARM_GOT32:
eb043451
PB		 2834#ifndef OLD_ARM_ABI
2835 case R_ARM_GOT_PREL:
2836#endif
252b5132 2837 /* Relocation is to the entry for this symbol in the
9b485d32 2838 global offset table. */
252b5132
RH		 2839 if (sgot == NULL)
2840 return bfd_reloc_notsupported;
f21f3fe0 2841
252b5132
RH		 2842 if (h != NULL)
2843 {
2844 bfd_vma off;
5e681ec4 2845 bfd_boolean dyn;
f21f3fe0 2846
252b5132
RH		 2847 off = h->got.offset;
2848 BFD_ASSERT (off != (bfd_vma) -1);
5e681ec4 2849 dyn = globals->root.dynamic_sections_created;
f21f3fe0 2850
5e681ec4 2851 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
50d6c878 2852 || (info->shared
5e681ec4
PB		 2853 && SYMBOL_REFERENCES_LOCAL (info, h))
2854 || (ELF_ST_VISIBILITY (h->other)
2855 && h->root.type == bfd_link_hash_undefweak))
252b5132
RH		 2856 {
2857 /* This is actually a static link, or it is a -Bsymbolic link
2858 and the symbol is defined locally. We must initialize this
2859 entry in the global offset table. Since the offset must
2860 always be a multiple of 4, we use the least significant bit
2861 to record whether we have initialized it already.
f21f3fe0 2862
252b5132 2863 When doing a dynamic link, we create a .rel.got relocation
f21f3fe0 2864 entry to initialize the value. This is done in the
9b485d32 2865 finish_dynamic_symbol routine. */
252b5132
RH		 2866 if ((off & 1) != 0)
2867 off &= ~1;
2868 else
2869 {
ee29b9fb
RE		 2870 /* If we are addressing a Thumb function, we need to
2871 adjust the address by one, so that attempts to
2872 call the function pointer will correctly
2873 interpret it as Thumb code. */
2874 if (sym_flags == STT_ARM_TFUNC)
2875 value |= 1;
2876
252b5132
RH		 2877 bfd_put_32 (output_bfd, value, sgot->contents + off);
2878 h->got.offset |= 1;
2879 }
2880 }
f21f3fe0 2881
252b5132
RH		 2882 value = sgot->output_offset + off;
2883 }
2884 else
2885 {
2886 bfd_vma off;
f21f3fe0 2887
252b5132
RH		 2888 BFD_ASSERT (local_got_offsets != NULL &&
2889 local_got_offsets[r_symndx] != (bfd_vma) -1);
f21f3fe0 2890
252b5132 2891 off = local_got_offsets[r_symndx];
f21f3fe0 2892
252b5132
RH		 2893 /* The offset must always be a multiple of 4. We use the
2894 least significant bit to record whether we have already
9b485d32 2895 generated the necessary reloc. */
252b5132
RH		 2896 if ((off & 1) != 0)
2897 off &= ~1;
2898 else
2899 {
2900 bfd_put_32 (output_bfd, value, sgot->contents + off);
f21f3fe0 2901
252b5132
RH		 2902 if (info->shared)
2903 {
2904 asection * srelgot;
947216bf
AM		 2905 Elf_Internal_Rela outrel;
2906 bfd_byte *loc;
f21f3fe0 2907
252b5132
RH		 2908 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
2909 BFD_ASSERT (srelgot != NULL);
f21f3fe0 2910
252b5132 2911 outrel.r_offset = (sgot->output_section->vma
f21f3fe0 2912 + sgot->output_offset
252b5132
RH		 2913 + off);
2914 outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
947216bf
AM		 2915 loc = srelgot->contents;
2916 loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
2917 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
252b5132 2918 }
f21f3fe0 2919
252b5132
RH		 2920 local_got_offsets[r_symndx] |= 1;
2921 }
f21f3fe0 2922
252b5132
RH		 2923 value = sgot->output_offset + off;
2924 }
eb043451
PB		 2925 if (r_type != R_ARM_GOT32)
2926 value += sgot->output_section->vma;
9a5aca8c 2927
f21f3fe0 2928 return _bfd_final_link_relocate (howto, input_bfd, input_section,
99e4ae17
AJ		 2929 contents, rel->r_offset, value,
2930 (bfd_vma) 0);
f21f3fe0 2931
252b5132
RH		 2932 case R_ARM_SBREL32:
2933 return bfd_reloc_notsupported;
2934
2935 case R_ARM_AMP_VCALL9:
2936 return bfd_reloc_notsupported;
2937
2938 case R_ARM_RSBREL32:
2939 return bfd_reloc_notsupported;
2940
2941 case R_ARM_THM_RPC22:
2942 return bfd_reloc_notsupported;
2943
2944 case R_ARM_RREL32:
2945 return bfd_reloc_notsupported;
2946
2947 case R_ARM_RABS32:
2948 return bfd_reloc_notsupported;
2949
2950 case R_ARM_RPC24:
2951 return bfd_reloc_notsupported;
2952
2953 case R_ARM_RBASE:
2954 return bfd_reloc_notsupported;
2955
2956 default:
2957 return bfd_reloc_notsupported;
2958 }
2959}
2960
acf8aed4 2961#if USE_REL
98c1d4aa
NC		 2962/* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. */
2963static void
57e8b36a
NC		 2964arm_add_to_rel (bfd * abfd,
2965 bfd_byte * address,
2966 reloc_howto_type * howto,
2967 bfd_signed_vma increment)
98c1d4aa 2968{
98c1d4aa
NC		 2969 bfd_signed_vma addend;
2970
9a5aca8c 2971 if (howto->type == R_ARM_THM_PC22)
98c1d4aa 2972 {
9a5aca8c
AM		 2973 int upper_insn, lower_insn;
2974 int upper, lower;
98c1d4aa 2975
9a5aca8c
AM		 2976 upper_insn = bfd_get_16 (abfd, address);
2977 lower_insn = bfd_get_16 (abfd, address + 2);
2978 upper = upper_insn & 0x7ff;
2979 lower = lower_insn & 0x7ff;
2980
2981 addend = (upper << 12) | (lower << 1);
ddda4409 2982 addend += increment;
9a5aca8c 2983 addend >>= 1;
98c1d4aa 2984
9a5aca8c
AM		 2985 upper_insn = (upper_insn & 0xf800) | ((addend >> 11) & 0x7ff);
2986 lower_insn = (lower_insn & 0xf800) | (addend & 0x7ff);
2987
dc810e39
AM		 2988 bfd_put_16 (abfd, (bfd_vma) upper_insn, address);
2989 bfd_put_16 (abfd, (bfd_vma) lower_insn, address + 2);
9a5aca8c
AM		 2990 }
2991 else
2992 {
2993 bfd_vma contents;
2994
2995 contents = bfd_get_32 (abfd, address);
2996
2997 /* Get the (signed) value from the instruction. */
2998 addend = contents & howto->src_mask;
2999 if (addend & ((howto->src_mask + 1) >> 1))
3000 {
3001 bfd_signed_vma mask;
3002
3003 mask = -1;
3004 mask &= ~ howto->src_mask;
3005 addend |= mask;
3006 }
3007
3008 /* Add in the increment, (which is a byte value). */
3009 switch (howto->type)
3010 {
3011 default:
3012 addend += increment;
3013 break;
3014
3015 case R_ARM_PC24:
5b5bb741
PB		 3016#ifndef OLD_ARM_ABI
3017 case R_ARM_CALL:
3018 case R_ARM_JUMP24:
3019#endif
9a5aca8c 3020 addend <<= howto->size;
dc810e39 3021 addend += increment;
9a5aca8c
AM		 3022
3023 /* Should we check for overflow here ? */
3024
3025 /* Drop any undesired bits. */
3026 addend >>= howto->rightshift;
3027 break;
3028 }
3029
3030 contents = (contents & ~ howto->dst_mask) | (addend & howto->dst_mask);
3031
3032 bfd_put_32 (abfd, contents, address);
ddda4409 3033 }
98c1d4aa
NC		 3034}
3035#endif /* USE_REL */
252b5132
RH		 3036
3037/* Relocate an ARM ELF section. */
b34976b6 3038static bfd_boolean
57e8b36a
NC		 3039elf32_arm_relocate_section (bfd * output_bfd,
3040 struct bfd_link_info * info,
3041 bfd * input_bfd,
3042 asection * input_section,
3043 bfd_byte * contents,
3044 Elf_Internal_Rela * relocs,
3045 Elf_Internal_Sym * local_syms,
3046 asection ** local_sections)
252b5132 3047{
b34976b6
AM		 3048 Elf_Internal_Shdr *symtab_hdr;
3049 struct elf_link_hash_entry **sym_hashes;
3050 Elf_Internal_Rela *rel;
3051 Elf_Internal_Rela *relend;
3052 const char *name;
252b5132 3053
acf8aed4 3054#if !USE_REL
1049f94e 3055 if (info->relocatable)
b34976b6 3056 return TRUE;
b491616a
AM		 3057#endif
3058
252b5132
RH		 3059 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
3060 sym_hashes = elf_sym_hashes (input_bfd);
3061
3062 rel = relocs;
3063 relend = relocs + input_section->reloc_count;
3064 for (; rel < relend; rel++)
3065 {
ba96a88f
NC		 3066 int r_type;
3067 reloc_howto_type * howto;
3068 unsigned long r_symndx;
3069 Elf_Internal_Sym * sym;
3070 asection * sec;
252b5132 3071 struct elf_link_hash_entry * h;
ba96a88f
NC		 3072 bfd_vma relocation;
3073 bfd_reloc_status_type r;
3074 arelent bfd_reloc;
f21f3fe0 3075
252b5132 3076 r_symndx = ELF32_R_SYM (rel->r_info);
ba96a88f 3077 r_type = ELF32_R_TYPE (rel->r_info);
252b5132 3078
ba96a88f
NC		 3079 if ( r_type == R_ARM_GNU_VTENTRY
3080 || r_type == R_ARM_GNU_VTINHERIT)
252b5132
RH		 3081 continue;
3082
dc810e39 3083 elf32_arm_info_to_howto (input_bfd, & bfd_reloc, rel);
ba96a88f 3084 howto = bfd_reloc.howto;
252b5132 3085
acf8aed4 3086#if USE_REL
1049f94e 3087 if (info->relocatable)
252b5132 3088 {
1049f94e 3089 /* This is a relocatable link. We don't have to change
252b5132
RH		 3090 anything, unless the reloc is against a section symbol,
3091 in which case we have to adjust according to where the
3092 section symbol winds up in the output section. */
3093 if (r_symndx < symtab_hdr->sh_info)
3094 {
3095 sym = local_syms + r_symndx;
3096 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
3097 {
3098 sec = local_sections[r_symndx];
98c1d4aa 3099 arm_add_to_rel (input_bfd, contents + rel->r_offset,
dc810e39
AM		 3100 howto,
3101 (bfd_signed_vma) (sec->output_offset
3102 + sym->st_value));
252b5132
RH		 3103 }
3104 }
3105
3106 continue;
3107 }
b491616a 3108#endif
252b5132
RH		 3109
3110 /* This is a final link. */
3111 h = NULL;
3112 sym = NULL;
3113 sec = NULL;
9b485d32 3114
252b5132
RH		 3115 if (r_symndx < symtab_hdr->sh_info)
3116 {
3117 sym = local_syms + r_symndx;
3118 sec = local_sections[r_symndx];
acf8aed4 3119#if USE_REL
252b5132
RH		 3120 relocation = (sec->output_section->vma
3121 + sec->output_offset
3122 + sym->st_value);
f8df10f4
JJ		 3123 if ((sec->flags & SEC_MERGE)
3124 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
3125 {
3126 asection *msec;
3127 bfd_vma addend, value;
3128
3129 if (howto->rightshift)
3130 {
3131 (*_bfd_error_handler)
d003868e
AM		 3132 (_("%B(%A+0x%lx): %s relocation against SEC_MERGE section"),
3133 input_bfd, input_section,
f8df10f4 3134 (long) rel->r_offset, howto->name);
b34976b6 3135 return FALSE;
f8df10f4
JJ		 3136 }
3137
3138 value = bfd_get_32 (input_bfd, contents + rel->r_offset);
3139
3140 /* Get the (signed) value from the instruction. */
3141 addend = value & howto->src_mask;
3142 if (addend & ((howto->src_mask + 1) >> 1))
3143 {
3144 bfd_signed_vma mask;
3145
3146 mask = -1;
3147 mask &= ~ howto->src_mask;
3148 addend |= mask;
3149 }
3150 msec = sec;
3151 addend =
c629eae0 3152 _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend)
f8df10f4
JJ		 3153 - relocation;
3154 addend += msec->output_section->vma + msec->output_offset;
3155 value = (value & ~ howto->dst_mask) | (addend & howto->dst_mask);
3156 bfd_put_32 (input_bfd, value, contents + rel->r_offset);
3157 }
3158#else
8517fae7 3159 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
f8df10f4 3160#endif
252b5132
RH		 3161 }
3162 else
3163 {
560e09e9
NC		 3164 bfd_boolean warned;
3165 bfd_boolean unresolved_reloc;
3166
b2a8e766
AM		 3167 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3168 r_symndx, symtab_hdr, sym_hashes,
3169 h, sec, relocation,
3170 unresolved_reloc, warned);
57e8b36a 3171
560e09e9 3172 if (unresolved_reloc || relocation != 0)
252b5132 3173 {
252b5132 3174 /* In these cases, we don't need the relocation value.
f21f3fe0 3175 We check specially because in some obscure cases
9b485d32 3176 sec->output_section will be NULL. */
252b5132
RH		 3177 switch (r_type)
3178 {
3179 case R_ARM_PC24:
5b5bb741
PB		 3180#ifndef OLD_ARM_ABI
3181 case R_ARM_CALL:
3182 case R_ARM_JUMP24:
3183#endif
252b5132 3184 case R_ARM_ABS32:
6a360bf4 3185 case R_ARM_THM_PC22:
ecb2d096
DJ		 3186 case R_ARM_PLT32:
3187
252b5132 3188 if (info->shared
f5385ebf
AM		 3189 && ((!info->symbolic && h->dynindx != -1)
3190 || !h->def_regular)
5e681ec4 3191 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
05924f36
PB		 3192 && ((input_section->flags & SEC_ALLOC) != 0
3193 /* DWARF will emit R_ARM_ABS32 relocations in its
3194 sections against symbols defined externally
3195 in shared libraries. We can't do anything
3196 with them here. */
3197 || ((input_section->flags & SEC_DEBUGGING) != 0
f5385ebf 3198 && h->def_dynamic))
252b5132 3199 )
560e09e9 3200 relocation = 0;
252b5132 3201 break;
f21f3fe0 3202
252b5132 3203 case R_ARM_GOTPC:
560e09e9 3204 relocation = 0;
252b5132 3205 break;
f21f3fe0 3206
252b5132 3207 case R_ARM_GOT32:
eb043451
PB		 3208#ifndef OLD_ARM_ABI
3209 case R_ARM_GOT_PREL:
3210#endif
50d6c878 3211 if ((WILL_CALL_FINISH_DYNAMIC_SYMBOL
560e09e9 3212 (elf_hash_table (info)->dynamic_sections_created,
50d6c878
DJ		 3213 info->shared, h))
3214 && (!info->shared
252b5132 3215 || (!info->symbolic && h->dynindx != -1)
f5385ebf 3216 || !h->def_regular))
560e09e9 3217 relocation = 0;
252b5132 3218 break;
f21f3fe0 3219
252b5132 3220 default:
560e09e9
NC		 3221 if (unresolved_reloc)
3222 _bfd_error_handler
d003868e
AM		 3223 (_("%B(%A): warning: unresolvable relocation %d against symbol `%s'"),
3224 input_bfd, input_section,
560e09e9 3225 r_type,
d003868e 3226 h->root.root.string);
560e09e9 3227 break;
252b5132 3228 }
252b5132
RH		 3229 }
3230 }
3231
3232 if (h != NULL)
3233 name = h->root.root.string;
3234 else
3235 {
3236 name = (bfd_elf_string_from_elf_section
3237 (input_bfd, symtab_hdr->sh_link, sym->st_name));
3238 if (name == NULL || *name == '\0')
3239 name = bfd_section_name (input_bfd, sec);
3240 }
f21f3fe0 3241
252b5132
RH		 3242 r = elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
3243 input_section, contents, rel,
3244 relocation, info, sec, name,
3245 (h ? ELF_ST_TYPE (h->type) :
780a67af 3246 ELF_ST_TYPE (sym->st_info)), h);
252b5132
RH		 3247
3248 if (r != bfd_reloc_ok)
3249 {
3250 const char * msg = (const char *) 0;
3251
3252 switch (r)
3253 {
3254 case bfd_reloc_overflow:
cf919dfd
PB		 3255 /* If the overflowing reloc was to an undefined symbol,
3256 we have already printed one error message and there
3257 is no point complaining again. */
3258 if ((! h ||
3259 h->root.type != bfd_link_hash_undefined)
3260 && (!((*info->callbacks->reloc_overflow)
dfeffb9f
L		 3261 (info, (h ? &h->root : NULL), name, howto->name,
3262 (bfd_vma) 0, input_bfd, input_section,
3263 rel->r_offset))))
b34976b6 3264 return FALSE;
252b5132
RH		 3265 break;
3266
3267 case bfd_reloc_undefined:
3268 if (!((*info->callbacks->undefined_symbol)
3269 (info, name, input_bfd, input_section,
b34976b6
AM		 3270 rel->r_offset, TRUE)))
3271 return FALSE;
252b5132
RH		 3272 break;
3273
3274 case bfd_reloc_outofrange:
9b485d32 3275 msg = _("internal error: out of range error");
252b5132
RH		 3276 goto common_error;
3277
3278 case bfd_reloc_notsupported:
9b485d32 3279 msg = _("internal error: unsupported relocation error");
252b5132
RH		 3280 goto common_error;
3281
3282 case bfd_reloc_dangerous:
9b485d32 3283 msg = _("internal error: dangerous error");
252b5132
RH		 3284 goto common_error;
3285
3286 default:
9b485d32 3287 msg = _("internal error: unknown error");
252b5132
RH		 3288 /* fall through */
3289
3290 common_error:
3291 if (!((*info->callbacks->warning)
3292 (info, msg, name, input_bfd, input_section,
3293 rel->r_offset)))
b34976b6 3294 return FALSE;
252b5132
RH		 3295 break;
3296 }
3297 }
3298 }
3299
b34976b6 3300 return TRUE;
252b5132
RH		 3301}
3302
c178919b
NC		 3303/* Set the right machine number. */
3304
3305static bfd_boolean
57e8b36a 3306elf32_arm_object_p (bfd *abfd)
c178919b 3307{
5a6c6817 3308 unsigned int mach;
57e8b36a 3309
5a6c6817 3310 mach = bfd_arm_get_mach_from_notes (abfd, ARM_NOTE_SECTION);
c178919b 3311
5a6c6817
NC		 3312 if (mach != bfd_mach_arm_unknown)
3313 bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
3314
3315 else if (elf_elfheader (abfd)->e_flags & EF_ARM_MAVERICK_FLOAT)
3316 bfd_default_set_arch_mach (abfd, bfd_arch_arm, bfd_mach_arm_ep9312);
e16bb312 3317
e16bb312 3318 else
5a6c6817 3319 bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
c178919b
NC		 3320
3321 return TRUE;
3322}
3323
fc830a83 3324/* Function to keep ARM specific flags in the ELF header. */
3c9458e9 3325
b34976b6 3326static bfd_boolean
57e8b36a 3327elf32_arm_set_private_flags (bfd *abfd, flagword flags)
252b5132
RH		 3328{
3329 if (elf_flags_init (abfd)
3330 && elf_elfheader (abfd)->e_flags != flags)
3331 {
fc830a83
NC		 3332 if (EF_ARM_EABI_VERSION (flags) == EF_ARM_EABI_UNKNOWN)
3333 {
fd2ec330 3334 if (flags & EF_ARM_INTERWORK)
d003868e
AM		 3335 (*_bfd_error_handler)
3336 (_("Warning: Not setting interworking flag of %B since it has already been specified as non-interworking"),
3337 abfd);
fc830a83 3338 else
d003868e
AM		 3339 _bfd_error_handler
3340 (_("Warning: Clearing the interworking flag of %B due to outside request"),
3341 abfd);
fc830a83 3342 }
252b5132
RH		 3343 }
3344 else
3345 {
3346 elf_elfheader (abfd)->e_flags = flags;
b34976b6 3347 elf_flags_init (abfd) = TRUE;
252b5132
RH		 3348 }
3349
b34976b6 3350 return TRUE;
252b5132
RH		 3351}
3352
fc830a83 3353/* Copy backend specific data from one object module to another. */
9b485d32 3354
b34976b6 3355static bfd_boolean
57e8b36a 3356elf32_arm_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
252b5132
RH		 3357{
3358 flagword in_flags;
3359 flagword out_flags;
3360
fc830a83 3361 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
252b5132 3362 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
b34976b6 3363 return TRUE;
252b5132 3364
fc830a83 3365 in_flags = elf_elfheader (ibfd)->e_flags;
252b5132
RH		 3366 out_flags = elf_elfheader (obfd)->e_flags;
3367
fc830a83
NC		 3368 if (elf_flags_init (obfd)
3369 && EF_ARM_EABI_VERSION (out_flags) == EF_ARM_EABI_UNKNOWN
3370 && in_flags != out_flags)
252b5132 3371 {
252b5132 3372 /* Cannot mix APCS26 and APCS32 code. */
fd2ec330 3373 if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
b34976b6 3374 return FALSE;
252b5132
RH		 3375
3376 /* Cannot mix float APCS and non-float APCS code. */
fd2ec330 3377 if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
b34976b6 3378 return FALSE;
252b5132
RH		 3379
3380 /* If the src and dest have different interworking flags
3381 then turn off the interworking bit. */
fd2ec330 3382 if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
252b5132 3383 {
fd2ec330 3384 if (out_flags & EF_ARM_INTERWORK)
d003868e
AM		 3385 _bfd_error_handler
3386 (_("Warning: Clearing the interworking flag of %B because non-interworking code in %B has been linked with it"),
3387 obfd, ibfd);
252b5132 3388
fd2ec330 3389 in_flags &= ~EF_ARM_INTERWORK;
252b5132 3390 }
1006ba19
PB		 3391
3392 /* Likewise for PIC, though don't warn for this case. */
fd2ec330
PB		 3393 if ((in_flags & EF_ARM_PIC) != (out_flags & EF_ARM_PIC))
3394 in_flags &= ~EF_ARM_PIC;
252b5132
RH		 3395 }
3396
3397 elf_elfheader (obfd)->e_flags = in_flags;
b34976b6 3398 elf_flags_init (obfd) = TRUE;
252b5132 3399
b34976b6 3400 return TRUE;
252b5132
RH		 3401}
3402
3403/* Merge backend specific data from an object file to the output
3404 object file when linking. */
9b485d32 3405
b34976b6 3406static bfd_boolean
57e8b36a 3407elf32_arm_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
252b5132
RH		 3408{
3409 flagword out_flags;
3410 flagword in_flags;
b34976b6 3411 bfd_boolean flags_compatible = TRUE;
cf919dfd 3412 asection *sec;
252b5132 3413
9b485d32 3414 /* Check if we have the same endianess. */
82e51918 3415 if (! _bfd_generic_verify_endian_match (ibfd, obfd))
b34976b6 3416 return FALSE;
1fe494a5 3417
252b5132
RH		 3418 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3419 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
b34976b6 3420 return TRUE;
252b5132 3421
252b5132
RH		 3422 /* The input BFD must have had its flags initialised. */
3423 /* The following seems bogus to me -- The flags are initialized in
3424 the assembler but I don't think an elf_flags_init field is
9b485d32 3425 written into the object. */
252b5132
RH		 3426 /* BFD_ASSERT (elf_flags_init (ibfd)); */
3427
3428 in_flags = elf_elfheader (ibfd)->e_flags;
3429 out_flags = elf_elfheader (obfd)->e_flags;
3430
3431 if (!elf_flags_init (obfd))
3432 {
fe077fa6
NC		 3433 /* If the input is the default architecture and had the default
3434 flags then do not bother setting the flags for the output
3435 architecture, instead allow future merges to do this. If no
3436 future merges ever set these flags then they will retain their
3437 uninitialised values, which surprise surprise, correspond
252b5132 3438 to the default values. */
fe077fa6
NC		 3439 if (bfd_get_arch_info (ibfd)->the_default
3440 && elf_elfheader (ibfd)->e_flags == 0)
b34976b6 3441 return TRUE;
252b5132 3442
b34976b6 3443 elf_flags_init (obfd) = TRUE;
252b5132
RH		 3444 elf_elfheader (obfd)->e_flags = in_flags;
3445
3446 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
3447 && bfd_get_arch_info (obfd)->the_default)
3448 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
3449
b34976b6 3450 return TRUE;
252b5132
RH		 3451 }
3452
5a6c6817
NC		 3453 /* Determine what should happen if the input ARM architecture
3454 does not match the output ARM architecture. */
3455 if (! bfd_arm_merge_machines (ibfd, obfd))
3456 return FALSE;
e16bb312 3457
1006ba19 3458 /* Identical flags must be compatible. */
252b5132 3459 if (in_flags == out_flags)
b34976b6 3460 return TRUE;
252b5132 3461
35a0f415
DJ		 3462 /* Check to see if the input BFD actually contains any sections. If
3463 not, its flags may not have been initialised either, but it
3464 cannot actually cause any incompatibility. Do not short-circuit
3465 dynamic objects; their section list may be emptied by
d1f161ea 3466 elf_link_add_object_symbols.
35a0f415 3467
d1f161ea
NC		 3468 Also check to see if there are no code sections in the input.
3469 In this case there is no need to check for code specific flags.
3470 XXX - do we need to worry about floating-point format compatability
3471 in data sections ? */
35a0f415 3472 if (!(ibfd->flags & DYNAMIC))
cf919dfd 3473 {
35a0f415 3474 bfd_boolean null_input_bfd = TRUE;
d1f161ea 3475 bfd_boolean only_data_sections = TRUE;
35a0f415
DJ		 3476
3477 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
cf919dfd 3478 {
35a0f415
DJ		 3479 /* Ignore synthetic glue sections. */
3480 if (strcmp (sec->name, ".glue_7")
3481 && strcmp (sec->name, ".glue_7t"))
3482 {
d1f161ea
NC		 3483 if ((bfd_get_section_flags (ibfd, sec)
3484 & (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
3485 == (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
3486 only_data_sections = FALSE;
3487
35a0f415
DJ		 3488 null_input_bfd = FALSE;
3489 break;
3490 }
cf919dfd 3491 }
d1f161ea
NC		 3492
3493 if (null_input_bfd || only_data_sections)
35a0f415 3494 return TRUE;
cf919dfd 3495 }
cf919dfd 3496
252b5132 3497 /* Complain about various flag mismatches. */
fc830a83
NC		 3498 if (EF_ARM_EABI_VERSION (in_flags) != EF_ARM_EABI_VERSION (out_flags))
3499 {
d003868e 3500 _bfd_error_handler
3656d5e3 3501 (_("ERROR: Source object %B has EABI version %d, but target %B has EABI version %d"),
d003868e
AM		 3502 ibfd, obfd,
3503 (in_flags & EF_ARM_EABIMASK) >> 24,
3504 (out_flags & EF_ARM_EABIMASK) >> 24);
b34976b6 3505 return FALSE;
fc830a83 3506 }
252b5132 3507
1006ba19
PB		 3508 /* Not sure what needs to be checked for EABI versions >= 1. */
3509 if (EF_ARM_EABI_VERSION (in_flags) == EF_ARM_EABI_UNKNOWN)
3510 {
fd2ec330 3511 if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
1006ba19 3512 {
d003868e
AM		 3513 _bfd_error_handler
3514 (_("ERROR: %B is compiled for APCS-%d, whereas target %B uses APCS-%d"),
3515 ibfd, obfd,
3516 in_flags & EF_ARM_APCS_26 ? 26 : 32,
3517 out_flags & EF_ARM_APCS_26 ? 26 : 32);
b34976b6 3518 flags_compatible = FALSE;
1006ba19 3519 }
252b5132 3520
fd2ec330 3521 if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
1006ba19 3522 {
5eefb65f 3523 if (in_flags & EF_ARM_APCS_FLOAT)
d003868e
AM		 3524 _bfd_error_handler
3525 (_("ERROR: %B passes floats in float registers, whereas %B passes them in integer registers"),
3526 ibfd, obfd);
5eefb65f 3527 else
d003868e
AM		 3528 _bfd_error_handler
3529 (_("ERROR: %B passes floats in integer registers, whereas %B passes them in float registers"),
3530 ibfd, obfd);
63b0f745 3531
b34976b6 3532 flags_compatible = FALSE;
1006ba19 3533 }
252b5132 3534
96a846ea 3535 if ((in_flags & EF_ARM_VFP_FLOAT) != (out_flags & EF_ARM_VFP_FLOAT))
1006ba19 3536 {
96a846ea 3537 if (in_flags & EF_ARM_VFP_FLOAT)
d003868e
AM		 3538 _bfd_error_handler
3539 (_("ERROR: %B uses VFP instructions, whereas %B does not"),
3540 ibfd, obfd);
5eefb65f 3541 else
d003868e
AM		 3542 _bfd_error_handler
3543 (_("ERROR: %B uses FPA instructions, whereas %B does not"),
3544 ibfd, obfd);
fde78edd
NC		 3545
3546 flags_compatible = FALSE;
3547 }
3548
3549 if ((in_flags & EF_ARM_MAVERICK_FLOAT) != (out_flags & EF_ARM_MAVERICK_FLOAT))
3550 {
3551 if (in_flags & EF_ARM_MAVERICK_FLOAT)
d003868e
AM		 3552 _bfd_error_handler
3553 (_("ERROR: %B uses Maverick instructions, whereas %B does not"),
3554 ibfd, obfd);
fde78edd 3555 else
d003868e
AM		 3556 _bfd_error_handler
3557 (_("ERROR: %B does not use Maverick instructions, whereas %B does"),
3558 ibfd, obfd);
63b0f745 3559
b34976b6 3560 flags_compatible = FALSE;
1006ba19 3561 }
96a846ea
RE		 3562
3563#ifdef EF_ARM_SOFT_FLOAT
3564 if ((in_flags & EF_ARM_SOFT_FLOAT) != (out_flags & EF_ARM_SOFT_FLOAT))
3565 {
3566 /* We can allow interworking between code that is VFP format
3567 layout, and uses either soft float or integer regs for
3568 passing floating point arguments and results. We already
3569 know that the APCS_FLOAT flags match; similarly for VFP
3570 flags. */
3571 if ((in_flags & EF_ARM_APCS_FLOAT) != 0
3572 || (in_flags & EF_ARM_VFP_FLOAT) == 0)
3573 {
3574 if (in_flags & EF_ARM_SOFT_FLOAT)
d003868e
AM		 3575 _bfd_error_handler
3576 (_("ERROR: %B uses software FP, whereas %B uses hardware FP"),
3577 ibfd, obfd);
96a846ea 3578 else
d003868e
AM		 3579 _bfd_error_handler
3580 (_("ERROR: %B uses hardware FP, whereas %B uses software FP"),
3581 ibfd, obfd);
96a846ea 3582
b34976b6 3583 flags_compatible = FALSE;
96a846ea
RE		 3584 }
3585 }
ee43f35e 3586#endif
252b5132 3587
1006ba19 3588 /* Interworking mismatch is only a warning. */
fd2ec330 3589 if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
8f615d07 3590 {
e3c8793a
NC		 3591 if (in_flags & EF_ARM_INTERWORK)
3592 {
d003868e
AM		 3593 _bfd_error_handler
3594 (_("Warning: %B supports interworking, whereas %B does not"),
3595 ibfd, obfd);
e3c8793a
NC		 3596 }
3597 else
3598 {
d003868e
AM		 3599 _bfd_error_handler
3600 (_("Warning: %B does not support interworking, whereas %B does"),
3601 ibfd, obfd);
e3c8793a 3602 }
8f615d07 3603 }
252b5132 3604 }
63b0f745 3605
1006ba19 3606 return flags_compatible;
252b5132
RH		 3607}
3608
9b485d32
NC		 3609/* Display the flags field. */
3610
b34976b6 3611static bfd_boolean
57e8b36a 3612elf32_arm_print_private_bfd_data (bfd *abfd, void * ptr)
252b5132 3613{
fc830a83
NC		 3614 FILE * file = (FILE *) ptr;
3615 unsigned long flags;
252b5132
RH		 3616
3617 BFD_ASSERT (abfd != NULL && ptr != NULL);
3618
3619 /* Print normal ELF private data. */
3620 _bfd_elf_print_private_bfd_data (abfd, ptr);
3621
fc830a83 3622 flags = elf_elfheader (abfd)->e_flags;
9b485d32
NC		 3623 /* Ignore init flag - it may not be set, despite the flags field
3624 containing valid data. */
252b5132
RH		 3625
3626 /* xgettext:c-format */
9b485d32 3627 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
252b5132 3628
fc830a83
NC		 3629 switch (EF_ARM_EABI_VERSION (flags))
3630 {
3631 case EF_ARM_EABI_UNKNOWN:
4cc11e76 3632 /* The following flag bits are GNU extensions and not part of the
fc830a83
NC		 3633 official ARM ELF extended ABI. Hence they are only decoded if
3634 the EABI version is not set. */
fd2ec330 3635 if (flags & EF_ARM_INTERWORK)
9b485d32 3636 fprintf (file, _(" [interworking enabled]"));
9a5aca8c 3637
fd2ec330 3638 if (flags & EF_ARM_APCS_26)
6c571f00 3639 fprintf (file, " [APCS-26]");
fc830a83 3640 else
6c571f00 3641 fprintf (file, " [APCS-32]");
9a5aca8c 3642
96a846ea
RE		 3643 if (flags & EF_ARM_VFP_FLOAT)
3644 fprintf (file, _(" [VFP float format]"));
fde78edd
NC		 3645 else if (flags & EF_ARM_MAVERICK_FLOAT)
3646 fprintf (file, _(" [Maverick float format]"));
96a846ea
RE		 3647 else
3648 fprintf (file, _(" [FPA float format]"));
3649
fd2ec330 3650 if (flags & EF_ARM_APCS_FLOAT)
9b485d32 3651 fprintf (file, _(" [floats passed in float registers]"));
9a5aca8c 3652
fd2ec330 3653 if (flags & EF_ARM_PIC)
9b485d32 3654 fprintf (file, _(" [position independent]"));
fc830a83 3655
fd2ec330 3656 if (flags & EF_ARM_NEW_ABI)
9b485d32 3657 fprintf (file, _(" [new ABI]"));
9a5aca8c 3658
fd2ec330 3659 if (flags & EF_ARM_OLD_ABI)
9b485d32 3660 fprintf (file, _(" [old ABI]"));
9a5aca8c 3661
fd2ec330 3662 if (flags & EF_ARM_SOFT_FLOAT)
9b485d32 3663 fprintf (file, _(" [software FP]"));
9a5aca8c 3664
96a846ea
RE		 3665 flags &= ~(EF_ARM_INTERWORK | EF_ARM_APCS_26 | EF_ARM_APCS_FLOAT
3666 | EF_ARM_PIC | EF_ARM_NEW_ABI | EF_ARM_OLD_ABI
fde78edd
NC		 3667 | EF_ARM_SOFT_FLOAT | EF_ARM_VFP_FLOAT
3668 | EF_ARM_MAVERICK_FLOAT);
fc830a83 3669 break;
9a5aca8c 3670
fc830a83 3671 case EF_ARM_EABI_VER1:
9b485d32 3672 fprintf (file, _(" [Version1 EABI]"));
9a5aca8c 3673
fc830a83 3674 if (flags & EF_ARM_SYMSARESORTED)
9b485d32 3675 fprintf (file, _(" [sorted symbol table]"));
fc830a83 3676 else
9b485d32 3677 fprintf (file, _(" [unsorted symbol table]"));
9a5aca8c 3678
fc830a83
NC		 3679 flags &= ~ EF_ARM_SYMSARESORTED;
3680 break;
9a5aca8c 3681
fd2ec330
PB		 3682 case EF_ARM_EABI_VER2:
3683 fprintf (file, _(" [Version2 EABI]"));
3684
3685 if (flags & EF_ARM_SYMSARESORTED)
3686 fprintf (file, _(" [sorted symbol table]"));
3687 else
3688 fprintf (file, _(" [unsorted symbol table]"));
3689
3690 if (flags & EF_ARM_DYNSYMSUSESEGIDX)
3691 fprintf (file, _(" [dynamic symbols use segment index]"));
3692
3693 if (flags & EF_ARM_MAPSYMSFIRST)
3694 fprintf (file, _(" [mapping symbols precede others]"));
3695
99e4ae17 3696 flags &= ~(EF_ARM_SYMSARESORTED | EF_ARM_DYNSYMSUSESEGIDX
fd2ec330
PB		 3697 | EF_ARM_MAPSYMSFIRST);
3698 break;
3699
d507cf36
PB		 3700 case EF_ARM_EABI_VER3:
3701 fprintf (file, _(" [Version3 EABI]"));
8cb51566
PB		 3702 break;
3703
3704 case EF_ARM_EABI_VER4:
3705 fprintf (file, _(" [Version4 EABI]"));
d507cf36
PB		 3706
3707 if (flags & EF_ARM_BE8)
3708 fprintf (file, _(" [BE8]"));
3709
3710 if (flags & EF_ARM_LE8)
3711 fprintf (file, _(" [LE8]"));
3712
3713 flags &= ~(EF_ARM_LE8 | EF_ARM_BE8);
3714 break;
3715
fc830a83 3716 default:
9b485d32 3717 fprintf (file, _(" <EABI version unrecognised>"));
fc830a83
NC		 3718 break;
3719 }
252b5132 3720
fc830a83 3721 flags &= ~ EF_ARM_EABIMASK;
252b5132 3722
fc830a83 3723 if (flags & EF_ARM_RELEXEC)
9b485d32 3724 fprintf (file, _(" [relocatable executable]"));
252b5132 3725
fc830a83 3726 if (flags & EF_ARM_HASENTRY)
9b485d32 3727 fprintf (file, _(" [has entry point]"));
252b5132 3728
fc830a83
NC		 3729 flags &= ~ (EF_ARM_RELEXEC | EF_ARM_HASENTRY);
3730
3731 if (flags)
9b485d32 3732 fprintf (file, _("<Unrecognised flag bits set>"));
9a5aca8c 3733
252b5132
RH		 3734 fputc ('\n', file);
3735
b34976b6 3736 return TRUE;
252b5132
RH		 3737}
3738
3739static int
57e8b36a 3740elf32_arm_get_symbol_type (Elf_Internal_Sym * elf_sym, int type)
252b5132 3741{
2f0ca46a
NC		 3742 switch (ELF_ST_TYPE (elf_sym->st_info))
3743 {
3744 case STT_ARM_TFUNC:
3745 return ELF_ST_TYPE (elf_sym->st_info);
ce855c42 3746
2f0ca46a
NC		 3747 case STT_ARM_16BIT:
3748 /* If the symbol is not an object, return the STT_ARM_16BIT flag.
3749 This allows us to distinguish between data used by Thumb instructions
3750 and non-data (which is probably code) inside Thumb regions of an
3751 executable. */
3752 if (type != STT_OBJECT)
3753 return ELF_ST_TYPE (elf_sym->st_info);
3754 break;
9a5aca8c 3755
ce855c42
NC		 3756 default:
3757 break;
2f0ca46a
NC		 3758 }
3759
3760 return type;
252b5132 3761}
f21f3fe0 3762
252b5132 3763static asection *
57e8b36a
NC		 3764elf32_arm_gc_mark_hook (asection * sec,
3765 struct bfd_link_info * info ATTRIBUTE_UNUSED,
3766 Elf_Internal_Rela * rel,
3767 struct elf_link_hash_entry * h,
3768 Elf_Internal_Sym * sym)
252b5132
RH		 3769{
3770 if (h != NULL)
3771 {
3772 switch (ELF32_R_TYPE (rel->r_info))
3773 {
3774 case R_ARM_GNU_VTINHERIT:
3775 case R_ARM_GNU_VTENTRY:
3776 break;
3777
3778 default:
3779 switch (h->root.type)
3780 {
3781 case bfd_link_hash_defined:
3782 case bfd_link_hash_defweak:
3783 return h->root.u.def.section;
3784
3785 case bfd_link_hash_common:
3786 return h->root.u.c.p->section;
e049a0de
ILT		 3787
3788 default:
3789 break;
252b5132
RH		 3790 }
3791 }
3792 }
3793 else
1e2f5b6e 3794 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
9ad5cbcf 3795
252b5132
RH		 3796 return NULL;
3797}
3798
780a67af
NC		 3799/* Update the got entry reference counts for the section being removed. */
3800
b34976b6 3801static bfd_boolean
57e8b36a
NC		 3802elf32_arm_gc_sweep_hook (bfd * abfd ATTRIBUTE_UNUSED,
3803 struct bfd_link_info * info ATTRIBUTE_UNUSED,
3804 asection * sec ATTRIBUTE_UNUSED,
3805 const Elf_Internal_Rela * relocs ATTRIBUTE_UNUSED)
252b5132 3806{
5e681ec4
PB		 3807 Elf_Internal_Shdr *symtab_hdr;
3808 struct elf_link_hash_entry **sym_hashes;
3809 bfd_signed_vma *local_got_refcounts;
3810 const Elf_Internal_Rela *rel, *relend;
3811 unsigned long r_symndx;
3812 struct elf_link_hash_entry *h;
eb043451
PB		 3813 struct elf32_arm_link_hash_table * globals;
3814
3815 globals = elf32_arm_hash_table (info);
5e681ec4
PB		 3816
3817 elf_section_data (sec)->local_dynrel = NULL;
3818
3819 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3820 sym_hashes = elf_sym_hashes (abfd);
3821 local_got_refcounts = elf_local_got_refcounts (abfd);
3822
3823 relend = relocs + sec->reloc_count;
3824 for (rel = relocs; rel < relend; rel++)
eb043451
PB		 3825 {
3826 int r_type;
5e681ec4 3827
eb043451 3828 r_type = ELF32_R_TYPE (rel->r_info);
b6ee372a 3829#ifndef OLD_ARM_ABI
eb043451 3830 r_type = arm_real_reloc_type (globals, r_type);
b6ee372a 3831#endif
eb043451
PB		 3832 switch (r_type)
3833 {
3834 case R_ARM_GOT32:
3835#ifndef OLD_ARM_ABI
3836 case R_ARM_GOT_PREL:
3837#endif
3838 r_symndx = ELF32_R_SYM (rel->r_info);
3839 if (r_symndx >= symtab_hdr->sh_info)
3840 {
3841 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3842 if (h->got.refcount > 0)
3843 h->got.refcount -= 1;
3844 }
3845 else if (local_got_refcounts != NULL)
3846 {
3847 if (local_got_refcounts[r_symndx] > 0)
3848 local_got_refcounts[r_symndx] -= 1;
3849 }
3850 break;
3851
3852 case R_ARM_ABS32:
3853 case R_ARM_REL32:
3854 case R_ARM_PC24:
3855 case R_ARM_PLT32:
3856#ifndef OLD_ARM_ABI
5b5bb741
PB		 3857 case R_ARM_CALL:
3858 case R_ARM_JUMP24:
eb043451
PB		 3859 case R_ARM_PREL31:
3860#endif
3861 r_symndx = ELF32_R_SYM (rel->r_info);
3862 if (r_symndx >= symtab_hdr->sh_info)
3863 {
3864 struct elf32_arm_link_hash_entry *eh;
3865 struct elf32_arm_relocs_copied **pp;
3866 struct elf32_arm_relocs_copied *p;
5e681ec4 3867
eb043451 3868 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5e681ec4 3869
eb043451
PB		 3870 if (h->plt.refcount > 0)
3871 h->plt.refcount -= 1;
5e681ec4 3872
eb043451 3873 if (r_type == R_ARM_ABS32
b6ee372a 3874#ifndef OLD_ARM_ABI
eb043451 3875 || r_type == R_ARM_PREL31
b6ee372a 3876#endif
eb043451
PB		 3877 || r_type == R_ARM_REL32)
3878 {
3879 eh = (struct elf32_arm_link_hash_entry *) h;
3880
3881 for (pp = &eh->relocs_copied; (p = *pp) != NULL;
3882 pp = &p->next)
3883 if (p->section == sec)
3884 {
3885 p->count -= 1;
3886 if (p->count == 0)
3887 *pp = p->next;
3888 break;
3889 }
3890 }
3891 }
3892 break;
5e681ec4 3893
eb043451
PB		 3894 default:
3895 break;
3896 }
3897 }
5e681ec4 3898
b34976b6 3899 return TRUE;
252b5132
RH		 3900}
3901
780a67af
NC		 3902/* Look through the relocs for a section during the first phase. */
3903
b34976b6 3904static bfd_boolean
57e8b36a
NC		 3905elf32_arm_check_relocs (bfd *abfd, struct bfd_link_info *info,
3906 asection *sec, const Elf_Internal_Rela *relocs)
252b5132 3907{
b34976b6
AM		 3908 Elf_Internal_Shdr *symtab_hdr;
3909 struct elf_link_hash_entry **sym_hashes;
3910 struct elf_link_hash_entry **sym_hashes_end;
3911 const Elf_Internal_Rela *rel;
3912 const Elf_Internal_Rela *rel_end;
3913 bfd *dynobj;
5e681ec4 3914 asection *sreloc;
b34976b6 3915 bfd_vma *local_got_offsets;
5e681ec4 3916 struct elf32_arm_link_hash_table *htab;
9a5aca8c 3917
1049f94e 3918 if (info->relocatable)
b34976b6 3919 return TRUE;
9a5aca8c 3920
5e681ec4
PB		 3921 htab = elf32_arm_hash_table (info);
3922 sreloc = NULL;
9a5aca8c 3923
252b5132
RH		 3924 dynobj = elf_hash_table (info)->dynobj;
3925 local_got_offsets = elf_local_got_offsets (abfd);
f21f3fe0 3926
252b5132
RH		 3927 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3928 sym_hashes = elf_sym_hashes (abfd);
9b485d32
NC		 3929 sym_hashes_end = sym_hashes
3930 + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
3931
252b5132
RH		 3932 if (!elf_bad_symtab (abfd))
3933 sym_hashes_end -= symtab_hdr->sh_info;
9b485d32 3934
252b5132
RH		 3935 rel_end = relocs + sec->reloc_count;
3936 for (rel = relocs; rel < rel_end; rel++)
3937 {
3938 struct elf_link_hash_entry *h;
3939 unsigned long r_symndx;
eb043451 3940 int r_type;
9a5aca8c 3941
252b5132 3942 r_symndx = ELF32_R_SYM (rel->r_info);
eb043451
PB		 3943 r_type = ELF32_R_TYPE (rel->r_info);
3944#ifndef OLD_ARM_ABI
3945 r_type = arm_real_reloc_type (htab, r_type);
3946#endif
252b5132
RH		 3947 if (r_symndx < symtab_hdr->sh_info)
3948 h = NULL;
3949 else
3950 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
9a5aca8c 3951
eb043451 3952 switch (r_type)
252b5132 3953 {
5e681ec4 3954 case R_ARM_GOT32:
eb043451
PB		 3955#ifndef OLD_ARM_ABI
3956 case R_ARM_GOT_PREL:
3957#endif
5e681ec4 3958 /* This symbol requires a global offset table entry. */
252b5132
RH		 3959 if (h != NULL)
3960 {
5e681ec4 3961 h->got.refcount++;
252b5132
RH		 3962 }
3963 else
3964 {
5e681ec4
PB		 3965 bfd_signed_vma *local_got_refcounts;
3966
3967 /* This is a global offset table entry for a local symbol. */
3968 local_got_refcounts = elf_local_got_refcounts (abfd);
3969 if (local_got_refcounts == NULL)
252b5132 3970 {
dc810e39 3971 bfd_size_type size;
252b5132 3972
dc810e39 3973 size = symtab_hdr->sh_info;
57e8b36a
NC		 3974 size *= (sizeof (bfd_signed_vma) + sizeof (char));
3975 local_got_refcounts = bfd_zalloc (abfd, size);
5e681ec4 3976 if (local_got_refcounts == NULL)
b34976b6 3977 return FALSE;
5e681ec4 3978 elf_local_got_refcounts (abfd) = local_got_refcounts;
252b5132 3979 }
5e681ec4 3980 local_got_refcounts[r_symndx] += 1;
252b5132 3981 }
eb043451
PB		 3982 if (r_type == R_ARM_GOT32)
3983 break;
3984 /* Fall through. */
252b5132 3985
5e681ec4
PB		 3986 case R_ARM_GOTOFF:
3987 case R_ARM_GOTPC:
3988 if (htab->sgot == NULL)
3989 {
3990 if (htab->root.dynobj == NULL)
3991 htab->root.dynobj = abfd;
3992 if (!create_got_section (htab->root.dynobj, info))
3993 return FALSE;
3994 }
252b5132
RH		 3995 break;
3996
3997 case R_ARM_ABS32:
3998 case R_ARM_REL32:
3999 case R_ARM_PC24:
7359ea65 4000 case R_ARM_PLT32:
eb043451 4001#ifndef OLD_ARM_ABI
5b5bb741
PB		 4002 case R_ARM_CALL:
4003 case R_ARM_JUMP24:
eb043451
PB		 4004 case R_ARM_PREL31:
4005#endif
7359ea65 4006 if (h != NULL)
5e681ec4
PB		 4007 {
4008 /* If this reloc is in a read-only section, we might
4009 need a copy reloc. We can't check reliably at this
4010 stage whether the section is read-only, as input
4011 sections have not yet been mapped to output sections.
4012 Tentatively set the flag for now, and correct in
4013 adjust_dynamic_symbol. */
7359ea65 4014 if (!info->shared)
f5385ebf 4015 h->non_got_ref = 1;
7359ea65 4016
5e681ec4 4017 /* We may need a .plt entry if the function this reloc
c84cd8ee
DJ		 4018 refers to is in a different object. We can't tell for
4019 sure yet, because something later might force the
4020 symbol local. */
eb043451 4021 if (r_type == R_ARM_PC24
5b5bb741
PB		 4022#ifndef OLD_ARM_ABI
4023 || r_type == R_ARM_CALL
4024 || r_type == R_ARM_JUMP24
4025#endif
eb043451 4026 || r_type == R_ARM_PLT32)
f5385ebf 4027 h->needs_plt = 1;
4f199be3
DJ		 4028
4029 /* If we create a PLT entry, this relocation will reference
4030 it, even if it's an ABS32 relocation. */
4031 h->plt.refcount += 1;
5e681ec4
PB		 4032 }
4033
252b5132
RH		 4034 /* If we are creating a shared library, and this is a reloc
4035 against a global symbol, or a non PC relative reloc
4036 against a local symbol, then we need to copy the reloc
4037 into the shared library. However, if we are linking with
4038 -Bsymbolic, we do not need to copy a reloc against a
4039 global symbol which is defined in an object we are
4040 including in the link (i.e., DEF_REGULAR is set). At
4041 this point we have not seen all the input files, so it is
4042 possible that DEF_REGULAR is not set now but will be set
4043 later (it is never cleared). We account for that
4044 possibility below by storing information in the
5e681ec4 4045 relocs_copied field of the hash table entry. */
252b5132 4046 if (info->shared
5e681ec4 4047 && (sec->flags & SEC_ALLOC) != 0
eb043451
PB		 4048 && ((r_type != R_ARM_PC24
4049 && r_type != R_ARM_PLT32
b6ee372a 4050#ifndef OLD_ARM_ABI
5b5bb741
PB		 4051 && r_type != R_ARM_CALL
4052 && r_type != R_ARM_JUMP24
eb043451 4053 && r_type != R_ARM_PREL31
b6ee372a 4054#endif
eb043451 4055 && r_type != R_ARM_REL32)
5e681ec4
PB		 4056 || (h != NULL
4057 && (! info->symbolic
f5385ebf 4058 || !h->def_regular))))
252b5132 4059 {
5e681ec4
PB		 4060 struct elf32_arm_relocs_copied *p, **head;
4061
252b5132
RH		 4062 /* When creating a shared object, we must copy these
4063 reloc types into the output file. We create a reloc
4064 section in dynobj and make room for this reloc. */
4065 if (sreloc == NULL)
4066 {
4067 const char * name;
4068
4069 name = (bfd_elf_string_from_elf_section
4070 (abfd,
4071 elf_elfheader (abfd)->e_shstrndx,
4072 elf_section_data (sec)->rel_hdr.sh_name));
4073 if (name == NULL)
b34976b6 4074 return FALSE;
252b5132
RH		 4075
4076 BFD_ASSERT (strncmp (name, ".rel", 4) == 0
99e4ae17 4077 && strcmp (bfd_get_section_name (abfd, sec),
252b5132
RH		 4078 name + 4) == 0);
4079
4080 sreloc = bfd_get_section_by_name (dynobj, name);
4081 if (sreloc == NULL)
4082 {
4083 flagword flags;
4084
4085 sreloc = bfd_make_section (dynobj, name);
4086 flags = (SEC_HAS_CONTENTS | SEC_READONLY
4087 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
e5a52504
MM		 4088 if ((sec->flags & SEC_ALLOC) != 0
4089 /* BPABI objects never have dynamic
4090 relocations mapped. */
4091 && !htab->symbian_p)
252b5132
RH		 4092 flags |= SEC_ALLOC | SEC_LOAD;
4093 if (sreloc == NULL
4094 || ! bfd_set_section_flags (dynobj, sreloc, flags)
4095 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
b34976b6 4096 return FALSE;
252b5132 4097 }
5e681ec4
PB		 4098
4099 elf_section_data (sec)->sreloc = sreloc;
252b5132
RH		 4100 }
4101
5e681ec4
PB		 4102 /* If this is a global symbol, we count the number of
4103 relocations we need for this symbol. */
4104 if (h != NULL)
252b5132 4105 {
5e681ec4
PB		 4106 head = &((struct elf32_arm_link_hash_entry *) h)->relocs_copied;
4107 }
4108 else
4109 {
4110 /* Track dynamic relocs needed for local syms too.
4111 We really need local syms available to do this
4112 easily. Oh well. */
57e8b36a 4113
5e681ec4
PB		 4114 asection *s;
4115 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
4116 sec, r_symndx);
4117 if (s == NULL)
4118 return FALSE;
57e8b36a 4119
5e681ec4
PB		 4120 head = ((struct elf32_arm_relocs_copied **)
4121 &elf_section_data (s)->local_dynrel);
4122 }
57e8b36a 4123
5e681ec4
PB		 4124 p = *head;
4125 if (p == NULL || p->section != sec)
4126 {
4127 bfd_size_type amt = sizeof *p;
57e8b36a 4128
5e681ec4 4129 p = bfd_alloc (htab->root.dynobj, amt);
252b5132 4130 if (p == NULL)
5e681ec4
PB		 4131 return FALSE;
4132 p->next = *head;
4133 *head = p;
4134 p->section = sec;
4135 p->count = 0;
252b5132 4136 }
57e8b36a 4137
eb043451 4138 if (r_type == R_ARM_ABS32
b6ee372a 4139#ifndef OLD_ARM_ABI
eb043451 4140 || r_type == R_ARM_PREL31
b6ee372a 4141#endif
eb043451 4142 || r_type == R_ARM_REL32)
7359ea65 4143 p->count += 1;
252b5132
RH		 4144 }
4145 break;
4146
4147 /* This relocation describes the C++ object vtable hierarchy.
4148 Reconstruct it for later use during GC. */
4149 case R_ARM_GNU_VTINHERIT:
c152c796 4150 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
b34976b6 4151 return FALSE;
252b5132 4152 break;
9a5aca8c 4153
252b5132
RH		 4154 /* This relocation describes which C++ vtable entries are actually
4155 used. Record for later use during GC. */
4156 case R_ARM_GNU_VTENTRY:
c152c796 4157 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
b34976b6 4158 return FALSE;
252b5132
RH		 4159 break;
4160 }
4161 }
f21f3fe0 4162
b34976b6 4163 return TRUE;
252b5132
RH		 4164}
4165
b34976b6 4166static bfd_boolean
0367ecfb 4167is_arm_mapping_symbol_name (const char * name)
252b5132 4168{
0367ecfb
NC		 4169 return (name != NULL)
4170 && (name[0] == '$')
4171 && ((name[1] == 'a') || (name[1] == 't') || (name[1] == 'd'))
4172 && (name[2] == 0);
4173}
f21f3fe0 4174
3c9458e9
NC		 4175/* Treat mapping symbols as special target symbols. */
4176
4177static bfd_boolean
4178elf32_arm_is_target_special_symbol (bfd * abfd ATTRIBUTE_UNUSED, asymbol * sym)
4179{
4180 return is_arm_mapping_symbol_name (sym->name);
4181}
4182
0367ecfb
NC		 4183/* This is a copy of elf_find_function() from elf.c except that
4184 ARM mapping symbols are ignored when looking for function names
4185 and STT_ARM_TFUNC is considered to a function type. */
252b5132 4186
0367ecfb
NC		 4187static bfd_boolean
4188arm_elf_find_function (bfd * abfd ATTRIBUTE_UNUSED,
4189 asection * section,
4190 asymbol ** symbols,
4191 bfd_vma offset,
4192 const char ** filename_ptr,
4193 const char ** functionname_ptr)
4194{
4195 const char * filename = NULL;
4196 asymbol * func = NULL;
4197 bfd_vma low_func = 0;
4198 asymbol ** p;
252b5132
RH		 4199
4200 for (p = symbols; *p != NULL; p++)
4201 {
4202 elf_symbol_type *q;
4203
4204 q = (elf_symbol_type *) *p;
4205
252b5132
RH		 4206 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
4207 {
4208 default:
4209 break;
4210 case STT_FILE:
4211 filename = bfd_asymbol_name (&q->symbol);
4212 break;
252b5132
RH		 4213 case STT_FUNC:
4214 case STT_ARM_TFUNC:
0367ecfb
NC		 4215 /* Skip $a and $t symbols. */
4216 if ((q->symbol.flags & BSF_LOCAL)
4217 && is_arm_mapping_symbol_name (q->symbol.name))
4218 continue;
4219 /* Fall through. */
4220 case STT_NOTYPE:
6b40fcba 4221 if (bfd_get_section (&q->symbol) == section
252b5132
RH		 4222 && q->symbol.value >= low_func
4223 && q->symbol.value <= offset)
4224 {
4225 func = (asymbol *) q;
4226 low_func = q->symbol.value;
4227 }
4228 break;
4229 }
4230 }
4231
4232 if (func == NULL)
b34976b6 4233 return FALSE;
252b5132 4234
0367ecfb
NC		 4235 if (filename_ptr)
4236 *filename_ptr = filename;
4237 if (functionname_ptr)
4238 *functionname_ptr = bfd_asymbol_name (func);
4239
4240 return TRUE;
4241}
4242
4243
4244/* Find the nearest line to a particular section and offset, for error
4245 reporting. This code is a duplicate of the code in elf.c, except
4246 that it uses arm_elf_find_function. */
4247
4248static bfd_boolean
4249elf32_arm_find_nearest_line (bfd * abfd,
4250 asection * section,
4251 asymbol ** symbols,
4252 bfd_vma offset,
4253 const char ** filename_ptr,
4254 const char ** functionname_ptr,
4255 unsigned int * line_ptr)
4256{
4257 bfd_boolean found = FALSE;
4258
4259 /* We skip _bfd_dwarf1_find_nearest_line since no known ARM toolchain uses it. */
4260
4261 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
4262 filename_ptr, functionname_ptr,
4263 line_ptr, 0,
4264 & elf_tdata (abfd)->dwarf2_find_line_info))
4265 {
4266 if (!*functionname_ptr)
4267 arm_elf_find_function (abfd, section, symbols, offset,
4268 *filename_ptr ? NULL : filename_ptr,
4269 functionname_ptr);
f21f3fe0 4270
0367ecfb
NC		 4271 return TRUE;
4272 }
4273
4274 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
4275 & found, filename_ptr,
4276 functionname_ptr, line_ptr,
4277 & elf_tdata (abfd)->line_info))
4278 return FALSE;
4279
4280 if (found && (*functionname_ptr || *line_ptr))
4281 return TRUE;
4282
4283 if (symbols == NULL)
4284 return FALSE;
4285
4286 if (! arm_elf_find_function (abfd, section, symbols, offset,
4287 filename_ptr, functionname_ptr))
4288 return FALSE;
4289
4290 *line_ptr = 0;
b34976b6 4291 return TRUE;
252b5132
RH		 4292}
4293
4294/* Adjust a symbol defined by a dynamic object and referenced by a
4295 regular object. The current definition is in some section of the
4296 dynamic object, but we're not including those sections. We have to
4297 change the definition to something the rest of the link can
4298 understand. */
4299
b34976b6 4300static bfd_boolean
57e8b36a
NC		 4301elf32_arm_adjust_dynamic_symbol (struct bfd_link_info * info,
4302 struct elf_link_hash_entry * h)
252b5132
RH		 4303{
4304 bfd * dynobj;
4305 asection * s;
4306 unsigned int power_of_two;
4307
4308 dynobj = elf_hash_table (info)->dynobj;
4309
4310 /* Make sure we know what is going on here. */
4311 BFD_ASSERT (dynobj != NULL
f5385ebf 4312 && (h->needs_plt
f6e332e6 4313 || h->u.weakdef != NULL
f5385ebf
AM		 4314 || (h->def_dynamic
4315 && h->ref_regular
4316 && !h->def_regular)));
252b5132
RH		 4317
4318 /* If this is a function, put it in the procedure linkage table. We
4319 will fill in the contents of the procedure linkage table later,
4320 when we know the address of the .got section. */
24a1ba0f 4321 if (h->type == STT_FUNC
f5385ebf 4322 || h->needs_plt)
252b5132 4323 {
5e681ec4
PB		 4324 if (h->plt.refcount <= 0
4325 || SYMBOL_CALLS_LOCAL (info, h)
4326 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
4327 && h->root.type == bfd_link_hash_undefweak))
252b5132
RH		 4328 {
4329 /* This case can occur if we saw a PLT32 reloc in an input
5e681ec4
PB		 4330 file, but the symbol was never referred to by a dynamic
4331 object, or if all references were garbage collected. In
4332 such a case, we don't actually need to build a procedure
4333 linkage table, and we can just do a PC24 reloc instead. */
4334 h->plt.offset = (bfd_vma) -1;
f5385ebf 4335 h->needs_plt = 0;
252b5132
RH		 4336 }
4337
b34976b6 4338 return TRUE;
252b5132 4339 }
5e681ec4
PB		 4340 else
4341 /* It's possible that we incorrectly decided a .plt reloc was
5b5bb741
PB		 4342 needed for an R_ARM_PC24 or similar reloc to a non-function sym
4343 in check_relocs. We can't decide accurately between function
4344 and non-function syms in check-relocs; Objects loaded later in
5e681ec4
PB		 4345 the link may change h->type. So fix it now. */
4346 h->plt.offset = (bfd_vma) -1;
252b5132
RH		 4347
4348 /* If this is a weak symbol, and there is a real definition, the
4349 processor independent code will have arranged for us to see the
4350 real definition first, and we can just use the same value. */
f6e332e6 4351 if (h->u.weakdef != NULL)
252b5132 4352 {
f6e332e6
AM		 4353 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
4354 || h->u.weakdef->root.type == bfd_link_hash_defweak);
4355 h->root.u.def.section = h->u.weakdef->root.u.def.section;
4356 h->root.u.def.value = h->u.weakdef->root.u.def.value;
b34976b6 4357 return TRUE;
252b5132
RH		 4358 }
4359
4360 /* This is a reference to a symbol defined by a dynamic object which
4361 is not a function. */
4362
4363 /* If we are creating a shared library, we must presume that the
4364 only references to the symbol are via the global offset table.
4365 For such cases we need not do anything here; the relocations will
4366 be handled correctly by relocate_section. */
4367 if (info->shared)
b34976b6 4368 return TRUE;
252b5132
RH		 4369
4370 /* We must allocate the symbol in our .dynbss section, which will
4371 become part of the .bss section of the executable. There will be
4372 an entry for this symbol in the .dynsym section. The dynamic
4373 object will contain position independent code, so all references
4374 from the dynamic object to this symbol will go through the global
4375 offset table. The dynamic linker will use the .dynsym entry to
4376 determine the address it must put in the global offset table, so
4377 both the dynamic object and the regular object will refer to the
4378 same memory location for the variable. */
252b5132
RH		 4379 s = bfd_get_section_by_name (dynobj, ".dynbss");
4380 BFD_ASSERT (s != NULL);
4381
4382 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
4383 copy the initial value out of the dynamic object and into the
4384 runtime process image. We need to remember the offset into the
4385 .rel.bss section we are going to use. */
4386 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
4387 {
4388 asection *srel;
4389
4390 srel = bfd_get_section_by_name (dynobj, ".rel.bss");
4391 BFD_ASSERT (srel != NULL);
eea6121a 4392 srel->size += sizeof (Elf32_External_Rel);
f5385ebf 4393 h->needs_copy = 1;
252b5132
RH		 4394 }
4395
4396 /* We need to figure out the alignment required for this symbol. I
4397 have no idea how ELF linkers handle this. */
4398 power_of_two = bfd_log2 (h->size);
4399 if (power_of_two > 3)
4400 power_of_two = 3;
4401
4402 /* Apply the required alignment. */
eea6121a 4403 s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
252b5132
RH		 4404 if (power_of_two > bfd_get_section_alignment (dynobj, s))
4405 {
4406 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
b34976b6 4407 return FALSE;
252b5132
RH		 4408 }
4409
4410 /* Define the symbol as being at this point in the section. */
4411 h->root.u.def.section = s;
eea6121a 4412 h->root.u.def.value = s->size;
252b5132
RH		 4413
4414 /* Increment the section size to make room for the symbol. */
eea6121a 4415 s->size += h->size;
252b5132 4416
b34976b6 4417 return TRUE;
252b5132
RH		 4418}
4419
5e681ec4
PB		 4420/* Allocate space in .plt, .got and associated reloc sections for
4421 dynamic relocs. */
4422
4423static bfd_boolean
57e8b36a 4424allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
5e681ec4
PB		 4425{
4426 struct bfd_link_info *info;
4427 struct elf32_arm_link_hash_table *htab;
4428 struct elf32_arm_link_hash_entry *eh;
4429 struct elf32_arm_relocs_copied *p;
4430
4431 if (h->root.type == bfd_link_hash_indirect)
4432 return TRUE;
4433
4434 if (h->root.type == bfd_link_hash_warning)
4435 /* When warning symbols are created, they **replace** the "real"
4436 entry in the hash table, thus we never get to see the real
4437 symbol in a hash traversal. So look at it now. */
4438 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4439
4440 info = (struct bfd_link_info *) inf;
4441 htab = elf32_arm_hash_table (info);
4442
4443 if (htab->root.dynamic_sections_created
4444 && h->plt.refcount > 0)
4445 {
4446 /* Make sure this symbol is output as a dynamic symbol.
4447 Undefined weak syms won't yet be marked as dynamic. */
4448 if (h->dynindx == -1
f5385ebf 4449 && !h->forced_local)
5e681ec4 4450 {
c152c796 4451 if (! bfd_elf_link_record_dynamic_symbol (info, h))
5e681ec4
PB		 4452 return FALSE;
4453 }
4454
4455 if (info->shared
7359ea65 4456 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
5e681ec4
PB		 4457 {
4458 asection *s = htab->splt;
4459
4460 /* If this is the first .plt entry, make room for the special
4461 first entry. */
eea6121a 4462 if (s->size == 0)
e5a52504 4463 s->size += htab->plt_header_size;
5e681ec4 4464
eea6121a 4465 h->plt.offset = s->size;
5e681ec4
PB		 4466
4467 /* If this symbol is not defined in a regular file, and we are
4468 not generating a shared library, then set the symbol to this
4469 location in the .plt. This is required to make function
4470 pointers compare as equal between the normal executable and
4471 the shared library. */
4472 if (! info->shared
f5385ebf 4473 && !h->def_regular)
5e681ec4
PB		 4474 {
4475 h->root.u.def.section = s;
4476 h->root.u.def.value = h->plt.offset;
4477 }
4478
4479 /* Make room for this entry. */
e5a52504 4480 s->size += htab->plt_entry_size;
5e681ec4 4481
e5a52504
MM		 4482 if (!htab->symbian_p)
4483 /* We also need to make an entry in the .got.plt section, which
4484 will be placed in the .got section by the linker script. */
4485 htab->sgotplt->size += 4;
5e681ec4
PB		 4486
4487 /* We also need to make an entry in the .rel.plt section. */
eea6121a 4488 htab->srelplt->size += sizeof (Elf32_External_Rel);
5e681ec4
PB		 4489 }
4490 else
4491 {
4492 h->plt.offset = (bfd_vma) -1;
f5385ebf 4493 h->needs_plt = 0;
5e681ec4
PB		 4494 }
4495 }
4496 else
4497 {
4498 h->plt.offset = (bfd_vma) -1;
f5385ebf 4499 h->needs_plt = 0;
5e681ec4
PB		 4500 }
4501
4502 if (h->got.refcount > 0)
4503 {
4504 asection *s;
4505 bfd_boolean dyn;
4506
4507 /* Make sure this symbol is output as a dynamic symbol.
4508 Undefined weak syms won't yet be marked as dynamic. */
4509 if (h->dynindx == -1
f5385ebf 4510 && !h->forced_local)
5e681ec4 4511 {
c152c796 4512 if (! bfd_elf_link_record_dynamic_symbol (info, h))
5e681ec4
PB		 4513 return FALSE;
4514 }
4515
e5a52504
MM		 4516 if (!htab->symbian_p)
4517 {
4518 s = htab->sgot;
4519 h->got.offset = s->size;
4520 s->size += 4;
4521 dyn = htab->root.dynamic_sections_created;
4522 if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
4523 || h->root.type != bfd_link_hash_undefweak)
4524 && (info->shared
4525 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
4526 htab->srelgot->size += sizeof (Elf32_External_Rel);
4527 }
5e681ec4
PB		 4528 }
4529 else
4530 h->got.offset = (bfd_vma) -1;
4531
4532 eh = (struct elf32_arm_link_hash_entry *) h;
4533 if (eh->relocs_copied == NULL)
4534 return TRUE;
4535
4536 /* In the shared -Bsymbolic case, discard space allocated for
4537 dynamic pc-relative relocs against symbols which turn out to be
4538 defined in regular objects. For the normal shared case, discard
4539 space for pc-relative relocs that have become local due to symbol
4540 visibility changes. */
4541
4542 if (info->shared)
4543 {
7359ea65
DJ		 4544 /* Discard relocs on undefined weak syms with non-default
4545 visibility. */
5e681ec4
PB		 4546 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
4547 && h->root.type == bfd_link_hash_undefweak)
4548 eh->relocs_copied = NULL;
4549 }
4550 else
4551 {
4552 /* For the non-shared case, discard space for relocs against
4553 symbols which turn out to need copy relocs or are not
4554 dynamic. */
4555
f5385ebf
AM		 4556 if (!h->non_got_ref
4557 && ((h->def_dynamic
4558 && !h->def_regular)
5e681ec4
PB		 4559 || (htab->root.dynamic_sections_created
4560 && (h->root.type == bfd_link_hash_undefweak
4561 || h->root.type == bfd_link_hash_undefined))))
4562 {
4563 /* Make sure this symbol is output as a dynamic symbol.
4564 Undefined weak syms won't yet be marked as dynamic. */
4565 if (h->dynindx == -1
f5385ebf 4566 && !h->forced_local)
5e681ec4 4567 {
c152c796 4568 if (! bfd_elf_link_record_dynamic_symbol (info, h))
5e681ec4
PB		 4569 return FALSE;
4570 }
4571
4572 /* If that succeeded, we know we'll be keeping all the
4573 relocs. */
4574 if (h->dynindx != -1)
4575 goto keep;
4576 }
4577
4578 eh->relocs_copied = NULL;
4579
4580 keep: ;
4581 }
4582
4583 /* Finally, allocate space. */
4584 for (p = eh->relocs_copied; p != NULL; p = p->next)
4585 {
4586 asection *sreloc = elf_section_data (p->section)->sreloc;
eea6121a 4587 sreloc->size += p->count * sizeof (Elf32_External_Rel);
5e681ec4
PB		 4588 }
4589
4590 return TRUE;
4591}
4592
252b5132
RH		 4593/* Set the sizes of the dynamic sections. */
4594
b34976b6 4595static bfd_boolean
57e8b36a
NC		 4596elf32_arm_size_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED,
4597 struct bfd_link_info * info)
252b5132
RH		 4598{
4599 bfd * dynobj;
4600 asection * s;
b34976b6
AM		 4601 bfd_boolean plt;
4602 bfd_boolean relocs;
5e681ec4
PB		 4603 bfd *ibfd;
4604 struct elf32_arm_link_hash_table *htab;
252b5132 4605
5e681ec4 4606 htab = elf32_arm_hash_table (info);
252b5132
RH		 4607 dynobj = elf_hash_table (info)->dynobj;
4608 BFD_ASSERT (dynobj != NULL);
4609
4610 if (elf_hash_table (info)->dynamic_sections_created)
4611 {
4612 /* Set the contents of the .interp section to the interpreter. */
893c4fe2 4613 if (info->executable)
252b5132
RH		 4614 {
4615 s = bfd_get_section_by_name (dynobj, ".interp");
4616 BFD_ASSERT (s != NULL);
eea6121a 4617 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
252b5132
RH		 4618 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
4619 }
4620 }
5e681ec4
PB		 4621
4622 /* Set up .got offsets for local syms, and space for local dynamic
4623 relocs. */
4624 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
252b5132 4625 {
5e681ec4
PB		 4626 bfd_signed_vma *local_got;
4627 bfd_signed_vma *end_local_got;
4628 char *local_tls_type;
4629 bfd_size_type locsymcount;
4630 Elf_Internal_Shdr *symtab_hdr;
4631 asection *srel;
4632
4633 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
4634 continue;
4635
4636 for (s = ibfd->sections; s != NULL; s = s->next)
4637 {
4638 struct elf32_arm_relocs_copied *p;
4639
4640 for (p = *((struct elf32_arm_relocs_copied **)
4641 &elf_section_data (s)->local_dynrel);
4642 p != NULL;
4643 p = p->next)
4644 {
4645 if (!bfd_is_abs_section (p->section)
4646 && bfd_is_abs_section (p->section->output_section))
4647 {
4648 /* Input section has been discarded, either because
4649 it is a copy of a linkonce section or due to
4650 linker script /DISCARD/, so we'll be discarding
4651 the relocs too. */
4652 }
4653 else if (p->count != 0)
4654 {
4655 srel = elf_section_data (p->section)->sreloc;
eea6121a 4656 srel->size += p->count * sizeof (Elf32_External_Rel);
5e681ec4
PB		 4657 if ((p->section->output_section->flags & SEC_READONLY) != 0)
4658 info->flags |= DF_TEXTREL;
4659 }
4660 }
4661 }
4662
4663 local_got = elf_local_got_refcounts (ibfd);
4664 if (!local_got)
4665 continue;
4666
4667 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
4668 locsymcount = symtab_hdr->sh_info;
4669 end_local_got = local_got + locsymcount;
4670 s = htab->sgot;
4671 srel = htab->srelgot;
4672 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
4673 {
4674 if (*local_got > 0)
4675 {
eea6121a
AM		 4676 *local_got = s->size;
4677 s->size += 4;
5e681ec4 4678 if (info->shared)
eea6121a 4679 srel->size += sizeof (Elf32_External_Rel);
5e681ec4
PB		 4680 }
4681 else
4682 *local_got = (bfd_vma) -1;
4683 }
252b5132
RH		 4684 }
4685
5e681ec4
PB		 4686 /* Allocate global sym .plt and .got entries, and space for global
4687 sym dynamic relocs. */
57e8b36a 4688 elf_link_hash_traverse (& htab->root, allocate_dynrelocs, info);
252b5132
RH		 4689
4690 /* The check_relocs and adjust_dynamic_symbol entry points have
4691 determined the sizes of the various dynamic sections. Allocate
4692 memory for them. */
b34976b6
AM		 4693 plt = FALSE;
4694 relocs = FALSE;
252b5132
RH		 4695 for (s = dynobj->sections; s != NULL; s = s->next)
4696 {
4697 const char * name;
b34976b6 4698 bfd_boolean strip;
252b5132
RH		 4699
4700 if ((s->flags & SEC_LINKER_CREATED) == 0)
4701 continue;
4702
4703 /* It's OK to base decisions on the section name, because none
4704 of the dynobj section names depend upon the input files. */
4705 name = bfd_get_section_name (dynobj, s);
4706
b34976b6 4707 strip = FALSE;
252b5132 4708
24a1ba0f 4709 if (strcmp (name, ".plt") == 0)
252b5132 4710 {
eea6121a 4711 if (s->size == 0)
252b5132
RH		 4712 {
4713 /* Strip this section if we don't need it; see the
4714 comment below. */
b34976b6 4715 strip = TRUE;
252b5132
RH		 4716 }
4717 else
4718 {
4719 /* Remember whether there is a PLT. */
b34976b6 4720 plt = TRUE;
252b5132
RH		 4721 }
4722 }
4723 else if (strncmp (name, ".rel", 4) == 0)
4724 {
eea6121a 4725 if (s->size == 0)
252b5132
RH		 4726 {
4727 /* If we don't need this section, strip it from the
4728 output file. This is mostly to handle .rel.bss and
4729 .rel.plt. We must create both sections in
4730 create_dynamic_sections, because they must be created
4731 before the linker maps input sections to output
4732 sections. The linker does that before
4733 adjust_dynamic_symbol is called, and it is that
4734 function which decides whether anything needs to go
4735 into these sections. */
b34976b6 4736 strip = TRUE;
252b5132
RH		 4737 }
4738 else
4739 {
252b5132
RH		 4740 /* Remember whether there are any reloc sections other
4741 than .rel.plt. */
4742 if (strcmp (name, ".rel.plt") != 0)
b34976b6 4743 relocs = TRUE;
252b5132
RH		 4744
4745 /* We use the reloc_count field as a counter if we need
4746 to copy relocs into the output file. */
4747 s->reloc_count = 0;
4748 }
4749 }
4750 else if (strncmp (name, ".got", 4) != 0)
4751 {
4752 /* It's not one of our sections, so don't allocate space. */
4753 continue;
4754 }
4755
4756 if (strip)
4757 {
52585bb8 4758 _bfd_strip_section_from_output (info, s);
252b5132
RH		 4759 continue;
4760 }
4761
4762 /* Allocate memory for the section contents. */
eea6121a
AM		 4763 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
4764 if (s->contents == NULL && s->size != 0)
b34976b6 4765 return FALSE;
252b5132
RH		 4766 }
4767
4768 if (elf_hash_table (info)->dynamic_sections_created)
4769 {
4770 /* Add some entries to the .dynamic section. We fill in the
4771 values later, in elf32_arm_finish_dynamic_sections, but we
4772 must add the entries now so that we get the correct size for
4773 the .dynamic section. The DT_DEBUG entry is filled in by the
4774 dynamic linker and used by the debugger. */
dc810e39 4775#define add_dynamic_entry(TAG, VAL) \
5a580b3a 4776 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
dc810e39
AM		 4777
4778 if (!info->shared)
252b5132 4779 {
dc810e39 4780 if (!add_dynamic_entry (DT_DEBUG, 0))
b34976b6 4781 return FALSE;
252b5132
RH		 4782 }
4783
4784 if (plt)
4785 {
dc810e39
AM		 4786 if ( !add_dynamic_entry (DT_PLTGOT, 0)
4787 || !add_dynamic_entry (DT_PLTRELSZ, 0)
4788 || !add_dynamic_entry (DT_PLTREL, DT_REL)
4789 || !add_dynamic_entry (DT_JMPREL, 0))
b34976b6 4790 return FALSE;
252b5132
RH		 4791 }
4792
4793 if (relocs)
4794 {
dc810e39
AM		 4795 if ( !add_dynamic_entry (DT_REL, 0)
4796 || !add_dynamic_entry (DT_RELSZ, 0)
4797 || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
b34976b6 4798 return FALSE;
252b5132
RH		 4799 }
4800
99e4ae17 4801 if ((info->flags & DF_TEXTREL) != 0)
252b5132 4802 {
dc810e39 4803 if (!add_dynamic_entry (DT_TEXTREL, 0))
b34976b6 4804 return FALSE;
d6cf2879 4805 info->flags |= DF_TEXTREL;
252b5132
RH		 4806 }
4807 }
dc810e39 4808#undef add_synamic_entry
252b5132 4809
b34976b6 4810 return TRUE;
252b5132
RH		 4811}
4812
252b5132
RH		 4813/* Finish up dynamic symbol handling. We set the contents of various
4814 dynamic sections here. */
4815
b34976b6 4816static bfd_boolean
57e8b36a
NC		 4817elf32_arm_finish_dynamic_symbol (bfd * output_bfd, struct bfd_link_info * info,
4818 struct elf_link_hash_entry * h, Elf_Internal_Sym * sym)
252b5132
RH		 4819{
4820 bfd * dynobj;
e5a52504 4821 struct elf32_arm_link_hash_table *htab;
252b5132
RH		 4822
4823 dynobj = elf_hash_table (info)->dynobj;
e5a52504 4824 htab = elf32_arm_hash_table (info);
252b5132
RH		 4825
4826 if (h->plt.offset != (bfd_vma) -1)
4827 {
4828 asection * splt;
252b5132 4829 asection * srel;
e5a52504 4830 bfd_byte *loc;
24a1ba0f 4831 bfd_vma plt_index;
947216bf 4832 Elf_Internal_Rela rel;
252b5132
RH		 4833
4834 /* This symbol has an entry in the procedure linkage table. Set
4835 it up. */
4836
4837 BFD_ASSERT (h->dynindx != -1);
4838
4839 splt = bfd_get_section_by_name (dynobj, ".plt");
252b5132 4840 srel = bfd_get_section_by_name (dynobj, ".rel.plt");
e5a52504 4841 BFD_ASSERT (splt != NULL && srel != NULL);
252b5132 4842
24a1ba0f
NC		 4843 /* Get the index in the procedure linkage table which
4844 corresponds to this symbol. This is the index of this symbol
4845 in all the symbols for which we are making plt entries. The
4846 first entry in the procedure linkage table is reserved. */
e5a52504
MM		 4847 plt_index = ((h->plt.offset - htab->plt_header_size)
4848 / htab->plt_entry_size);
252b5132 4849
e5a52504
MM		 4850 /* Fill in the entry in the procedure linkage table. */
4851 if (htab->symbian_p)
4852 {
4853 unsigned i;
4854 for (i = 0; i < htab->plt_entry_size / 4; ++i)
4855 bfd_put_32 (output_bfd,
4856 elf32_arm_symbian_plt_entry[i],
4857 splt->contents + h->plt.offset + 4 * i);
4858
4859 /* Fill in the entry in the .rel.plt section. */
2a1b9a48
MM		 4860 rel.r_offset = (splt->output_section->vma
4861 + splt->output_offset
e5a52504
MM		 4862 + h->plt.offset + 4 * (i - 1));
4863 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
4864 }
4865 else
4866 {
4867 bfd_vma got_offset;
4868 bfd_vma got_displacement;
4869 asection * sgot;
4870
4871 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
4872 BFD_ASSERT (sgot != NULL);
4873
4874 /* Get the offset into the .got table of the entry that
4875 corresponds to this function. Each .got entry is 4 bytes.
4876 The first three are reserved. */
4877 got_offset = (plt_index + 3) * 4;
4878
4879 /* Calculate the displacement between the PLT slot and the
4880 entry in the GOT. */
4881 got_displacement = (sgot->output_section->vma
4882 + sgot->output_offset
4883 + got_offset
4884 - splt->output_section->vma
4885 - splt->output_offset
4886 - h->plt.offset
4887 - 8);
5e681ec4 4888
e5a52504 4889 BFD_ASSERT ((got_displacement & 0xf0000000) == 0);
5e681ec4 4890
e5a52504
MM		 4891 bfd_put_32 (output_bfd, elf32_arm_plt_entry[0] | ((got_displacement & 0x0ff00000) >> 20),
4892 splt->contents + h->plt.offset + 0);
4893 bfd_put_32 (output_bfd, elf32_arm_plt_entry[1] | ((got_displacement & 0x000ff000) >> 12),
4894 splt->contents + h->plt.offset + 4);
4895 bfd_put_32 (output_bfd, elf32_arm_plt_entry[2] | (got_displacement & 0x00000fff),
4896 splt->contents + h->plt.offset + 8);
5e681ec4 4897#ifdef FOUR_WORD_PLT
e5a52504
MM		 4898 bfd_put_32 (output_bfd, elf32_arm_plt_entry[3],
4899 splt->contents + h->plt.offset + 12);
5e681ec4 4900#endif
252b5132 4901
e5a52504
MM		 4902 /* Fill in the entry in the global offset table. */
4903 bfd_put_32 (output_bfd,
4904 (splt->output_section->vma
4905 + splt->output_offset),
4906 sgot->contents + got_offset);
4907
4908 /* Fill in the entry in the .rel.plt section. */
4909 rel.r_offset = (sgot->output_section->vma
4910 + sgot->output_offset
4911 + got_offset);
4912 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_JUMP_SLOT);
4913 }
57e8b36a 4914
947216bf
AM		 4915 loc = srel->contents + plt_index * sizeof (Elf32_External_Rel);
4916 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
252b5132 4917
f5385ebf 4918 if (!h->def_regular)
252b5132
RH		 4919 {
4920 /* Mark the symbol as undefined, rather than as defined in
4921 the .plt section. Leave the value alone. */
4922 sym->st_shndx = SHN_UNDEF;
d982ba73
PB		 4923 /* If the symbol is weak, we do need to clear the value.
4924 Otherwise, the PLT entry would provide a definition for
4925 the symbol even if the symbol wasn't defined anywhere,
4926 and so the symbol would never be NULL. */
f5385ebf 4927 if (!h->ref_regular_nonweak)
d982ba73 4928 sym->st_value = 0;
252b5132
RH		 4929 }
4930 }
4931
4932 if (h->got.offset != (bfd_vma) -1)
4933 {
4934 asection * sgot;
4935 asection * srel;
947216bf
AM		 4936 Elf_Internal_Rela rel;
4937 bfd_byte *loc;
252b5132
RH		 4938
4939 /* This symbol has an entry in the global offset table. Set it
4940 up. */
252b5132
RH		 4941 sgot = bfd_get_section_by_name (dynobj, ".got");
4942 srel = bfd_get_section_by_name (dynobj, ".rel.got");
4943 BFD_ASSERT (sgot != NULL && srel != NULL);
4944
4945 rel.r_offset = (sgot->output_section->vma
4946 + sgot->output_offset
dc810e39 4947 + (h->got.offset &~ (bfd_vma) 1));
252b5132 4948
5e681ec4
PB		 4949 /* If this is a static link, or it is a -Bsymbolic link and the
4950 symbol is defined locally or was forced to be local because
4951 of a version file, we just want to emit a RELATIVE reloc.
4952 The entry in the global offset table will already have been
4953 initialized in the relocate_section function. */
252b5132 4954 if (info->shared
5e681ec4
PB		 4955 && SYMBOL_REFERENCES_LOCAL (info, h))
4956 {
4957 BFD_ASSERT((h->got.offset & 1) != 0);
4958 rel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
4959 }
252b5132
RH		 4960 else
4961 {
5e681ec4 4962 BFD_ASSERT((h->got.offset & 1) == 0);
252b5132
RH		 4963 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
4964 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
4965 }
4966
947216bf
AM		 4967 loc = srel->contents + srel->reloc_count++ * sizeof (Elf32_External_Rel);
4968 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
252b5132
RH		 4969 }
4970
f5385ebf 4971 if (h->needs_copy)
252b5132
RH		 4972 {
4973 asection * s;
947216bf
AM		 4974 Elf_Internal_Rela rel;
4975 bfd_byte *loc;
252b5132
RH		 4976
4977 /* This symbol needs a copy reloc. Set it up. */
252b5132
RH		 4978 BFD_ASSERT (h->dynindx != -1
4979 && (h->root.type == bfd_link_hash_defined
4980 || h->root.type == bfd_link_hash_defweak));
4981
4982 s = bfd_get_section_by_name (h->root.u.def.section->owner,
4983 ".rel.bss");
4984 BFD_ASSERT (s != NULL);
4985
4986 rel.r_offset = (h->root.u.def.value
4987 + h->root.u.def.section->output_section->vma
4988 + h->root.u.def.section->output_offset);
4989 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_COPY);
947216bf
AM		 4990 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rel);
4991 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
252b5132
RH		 4992 }
4993
4994 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
4995 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
4996 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
4997 sym->st_shndx = SHN_ABS;
4998
b34976b6 4999 return TRUE;
252b5132
RH		 5000}
5001
5002/* Finish up the dynamic sections. */
5003
b34976b6 5004static bfd_boolean
57e8b36a 5005elf32_arm_finish_dynamic_sections (bfd * output_bfd, struct bfd_link_info * info)
252b5132
RH		 5006{
5007 bfd * dynobj;
5008 asection * sgot;
5009 asection * sdyn;
5010
5011 dynobj = elf_hash_table (info)->dynobj;
5012
5013 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
229fcec5 5014 BFD_ASSERT (elf32_arm_hash_table (info)->symbian_p || sgot != NULL);
252b5132
RH		 5015 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
5016
5017 if (elf_hash_table (info)->dynamic_sections_created)
5018 {
5019 asection *splt;
5020 Elf32_External_Dyn *dyncon, *dynconend;
229fcec5 5021 struct elf32_arm_link_hash_table *htab;
252b5132 5022
229fcec5 5023 htab = elf32_arm_hash_table (info);
252b5132 5024 splt = bfd_get_section_by_name (dynobj, ".plt");
24a1ba0f 5025 BFD_ASSERT (splt != NULL && sdyn != NULL);
252b5132
RH		 5026
5027 dyncon = (Elf32_External_Dyn *) sdyn->contents;
eea6121a 5028 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
9b485d32 5029
252b5132
RH		 5030 for (; dyncon < dynconend; dyncon++)
5031 {
5032 Elf_Internal_Dyn dyn;
5033 const char * name;
5034 asection * s;
5035
5036 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
5037
5038 switch (dyn.d_tag)
5039 {
229fcec5
MM		 5040 unsigned int type;
5041
252b5132
RH		 5042 default:
5043 break;
5044
229fcec5
MM		 5045 case DT_HASH:
5046 name = ".hash";
5047 goto get_vma_if_bpabi;
5048 case DT_STRTAB:
5049 name = ".dynstr";
5050 goto get_vma_if_bpabi;
5051 case DT_SYMTAB:
5052 name = ".dynsym";
5053 goto get_vma_if_bpabi;
c0042f5d
MM		 5054 case DT_VERSYM:
5055 name = ".gnu.version";
5056 goto get_vma_if_bpabi;
5057 case DT_VERDEF:
5058 name = ".gnu.version_d";
5059 goto get_vma_if_bpabi;
5060 case DT_VERNEED:
5061 name = ".gnu.version_r";
5062 goto get_vma_if_bpabi;
5063
252b5132
RH		 5064 case DT_PLTGOT:
5065 name = ".got";
5066 goto get_vma;
5067 case DT_JMPREL:
5068 name = ".rel.plt";
5069 get_vma:
5070 s = bfd_get_section_by_name (output_bfd, name);
5071 BFD_ASSERT (s != NULL);
229fcec5
MM		 5072 if (!htab->symbian_p)
5073 dyn.d_un.d_ptr = s->vma;
5074 else
5075 /* In the BPABI, tags in the PT_DYNAMIC section point
5076 at the file offset, not the memory address, for the
5077 convenience of the post linker. */
5078 dyn.d_un.d_ptr = s->filepos;
252b5132
RH		 5079 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5080 break;
5081
229fcec5
MM		 5082 get_vma_if_bpabi:
5083 if (htab->symbian_p)
5084 goto get_vma;
5085 break;
5086
252b5132
RH		 5087 case DT_PLTRELSZ:
5088 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
5089 BFD_ASSERT (s != NULL);
eea6121a 5090 dyn.d_un.d_val = s->size;
252b5132
RH		 5091 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5092 break;
229fcec5 5093
252b5132 5094 case DT_RELSZ:
229fcec5
MM		 5095 if (!htab->symbian_p)
5096 {
5097 /* My reading of the SVR4 ABI indicates that the
5098 procedure linkage table relocs (DT_JMPREL) should be
5099 included in the overall relocs (DT_REL). This is
5100 what Solaris does. However, UnixWare can not handle
5101 that case. Therefore, we override the DT_RELSZ entry
5102 here to make it not include the JMPREL relocs. Since
5103 the linker script arranges for .rel.plt to follow all
5104 other relocation sections, we don't have to worry
5105 about changing the DT_REL entry. */
5106 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
5107 if (s != NULL)
5108 dyn.d_un.d_val -= s->size;
5109 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5110 break;
5111 }
5112 /* Fall through */
5113
5114 case DT_REL:
5115 case DT_RELA:
5116 case DT_RELASZ:
5117 /* In the BPABI, the DT_REL tag must point at the file
5118 offset, not the VMA, of the first relocation
5119 section. So, we use code similar to that in
5120 elflink.c, but do not check for SHF_ALLOC on the
5121 relcoation section, since relocations sections are
5122 never allocated under the BPABI. The comments above
5123 about Unixware notwithstanding, we include all of the
5124 relocations here. */
5125 if (htab->symbian_p)
5126 {
5127 unsigned int i;
5128 type = ((dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ)
5129 ? SHT_REL : SHT_RELA);
5130 dyn.d_un.d_val = 0;
5131 for (i = 1; i < elf_numsections (output_bfd); i++)
5132 {
5133 Elf_Internal_Shdr *hdr
5134 = elf_elfsections (output_bfd)[i];
5135 if (hdr->sh_type == type)
5136 {
5137 if (dyn.d_tag == DT_RELSZ
5138 || dyn.d_tag == DT_RELASZ)
5139 dyn.d_un.d_val += hdr->sh_size;
5140 else if (dyn.d_un.d_val == 0
5141 || hdr->sh_offset < dyn.d_un.d_val)
5142 dyn.d_un.d_val = hdr->sh_offset;
5143 }
5144 }
5145 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5146 }
252b5132 5147 break;
88f7bcd5
NC		 5148
5149 /* Set the bottom bit of DT_INIT/FINI if the
5150 corresponding function is Thumb. */
5151 case DT_INIT:
5152 name = info->init_function;
5153 goto get_sym;
5154 case DT_FINI:
5155 name = info->fini_function;
5156 get_sym:
5157 /* If it wasn't set by elf_bfd_final_link
4cc11e76 5158 then there is nothing to adjust. */
88f7bcd5
NC		 5159 if (dyn.d_un.d_val != 0)
5160 {
5161 struct elf_link_hash_entry * eh;
5162
5163 eh = elf_link_hash_lookup (elf_hash_table (info), name,
b34976b6 5164 FALSE, FALSE, TRUE);
88f7bcd5
NC		 5165 if (eh != (struct elf_link_hash_entry *) NULL
5166 && ELF_ST_TYPE (eh->type) == STT_ARM_TFUNC)
5167 {
5168 dyn.d_un.d_val |= 1;
b34976b6 5169 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
88f7bcd5
NC		 5170 }
5171 }
5172 break;
252b5132
RH		 5173 }
5174 }
5175
24a1ba0f 5176 /* Fill in the first entry in the procedure linkage table. */
e5a52504 5177 if (splt->size > 0 && elf32_arm_hash_table (info)->plt_header_size)
f7a74f8c 5178 {
5e681ec4
PB		 5179 bfd_vma got_displacement;
5180
5181 /* Calculate the displacement between the PLT slot and &GOT[0]. */
5182 got_displacement = (sgot->output_section->vma
5183 + sgot->output_offset
5184 - splt->output_section->vma
5185 - splt->output_offset
5186 - 16);
5187
f7a74f8c
NC		 5188 bfd_put_32 (output_bfd, elf32_arm_plt0_entry[0], splt->contents + 0);
5189 bfd_put_32 (output_bfd, elf32_arm_plt0_entry[1], splt->contents + 4);
5190 bfd_put_32 (output_bfd, elf32_arm_plt0_entry[2], splt->contents + 8);
5191 bfd_put_32 (output_bfd, elf32_arm_plt0_entry[3], splt->contents + 12);
5e681ec4
PB		 5192#ifdef FOUR_WORD_PLT
5193 /* The displacement value goes in the otherwise-unused last word of
5194 the second entry. */
5195 bfd_put_32 (output_bfd, got_displacement, splt->contents + 28);
5196#else
5197 bfd_put_32 (output_bfd, got_displacement, splt->contents + 16);
5198#endif
f7a74f8c 5199 }
252b5132
RH		 5200
5201 /* UnixWare sets the entsize of .plt to 4, although that doesn't
5202 really seem like the right value. */
5203 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
5204 }
5205
5206 /* Fill in the first three entries in the global offset table. */
229fcec5 5207 if (sgot)
252b5132 5208 {
229fcec5
MM		 5209 if (sgot->size > 0)
5210 {
5211 if (sdyn == NULL)
5212 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
5213 else
5214 bfd_put_32 (output_bfd,
5215 sdyn->output_section->vma + sdyn->output_offset,
5216 sgot->contents);
5217 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
5218 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
5219 }
252b5132 5220
229fcec5
MM		 5221 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
5222 }
252b5132 5223
b34976b6 5224 return TRUE;
252b5132
RH		 5225}
5226
ba96a88f 5227static void
57e8b36a 5228elf32_arm_post_process_headers (bfd * abfd, struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
ba96a88f 5229{
9b485d32 5230 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
e489d0ae 5231 struct elf32_arm_link_hash_table *globals;
ba96a88f
NC		 5232
5233 i_ehdrp = elf_elfheader (abfd);
5234
5235 i_ehdrp->e_ident[EI_OSABI] = ARM_ELF_OS_ABI_VERSION;
5236 i_ehdrp->e_ident[EI_ABIVERSION] = ARM_ELF_ABI_VERSION;
e489d0ae 5237
93204d3a
PB		 5238 if (link_info)
5239 {
5240 globals = elf32_arm_hash_table (link_info);
5241 if (globals->byteswap_code)
5242 i_ehdrp->e_flags |= EF_ARM_BE8;
5243 }
ba96a88f
NC		 5244}
5245
99e4ae17 5246static enum elf_reloc_type_class
57e8b36a 5247elf32_arm_reloc_type_class (const Elf_Internal_Rela *rela)
99e4ae17 5248{
f51e552e 5249 switch ((int) ELF32_R_TYPE (rela->r_info))
99e4ae17
AJ		 5250 {
5251 case R_ARM_RELATIVE:
5252 return reloc_class_relative;
5253 case R_ARM_JUMP_SLOT:
5254 return reloc_class_plt;
5255 case R_ARM_COPY:
5256 return reloc_class_copy;
5257 default:
5258 return reloc_class_normal;
5259 }
5260}
5261
e16bb312
NC		 5262/* Set the right machine number for an Arm ELF file. */
5263
5264static bfd_boolean
57e8b36a 5265elf32_arm_section_flags (flagword *flags, const Elf_Internal_Shdr *hdr)
e16bb312
NC		 5266{
5267 if (hdr->sh_type == SHT_NOTE)
5268 *flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_CONTENTS;
5269
5270 return TRUE;
5271}
5272
e489d0ae 5273static void
57e8b36a 5274elf32_arm_final_write_processing (bfd *abfd, bfd_boolean linker ATTRIBUTE_UNUSED)
e16bb312 5275{
5a6c6817 5276 bfd_arm_update_notes (abfd, ARM_NOTE_SECTION);
e16bb312
NC		 5277}
5278
40a18ebd
NC		 5279/* Return TRUE if this is an unwinding table entry. */
5280
5281static bfd_boolean
5282is_arm_elf_unwind_section_name (bfd * abfd ATTRIBUTE_UNUSED, const char * name)
5283{
5284 size_t len1, len2;
5285
5286 len1 = sizeof (ELF_STRING_ARM_unwind) - 1;
5287 len2 = sizeof (ELF_STRING_ARM_unwind_once) - 1;
5288 return (strncmp (name, ELF_STRING_ARM_unwind, len1) == 0
5289 || strncmp (name, ELF_STRING_ARM_unwind_once, len2) == 0);
5290}
5291
5292
5293/* Set the type and flags for an ARM section. We do this by
5294 the section name, which is a hack, but ought to work. */
5295
5296static bfd_boolean
5297elf32_arm_fake_sections (bfd * abfd, Elf_Internal_Shdr * hdr, asection * sec)
5298{
5299 const char * name;
5300
5301 name = bfd_get_section_name (abfd, sec);
5302
5303 if (is_arm_elf_unwind_section_name (abfd, name))
5304 {
5305 hdr->sh_type = SHT_ARM_EXIDX;
5306 hdr->sh_flags |= SHF_LINK_ORDER;
5307 }
5308 return TRUE;
5309}
5310
5311/* Handle an ARM specific section when reading an object file.
5312 This is called when elf.c finds a section with an unknown type. */
5313
5314static bfd_boolean
5315elf32_arm_section_from_shdr (bfd *abfd,
5316 Elf_Internal_Shdr * hdr,
5317 const char *name)
5318{
5319 /* There ought to be a place to keep ELF backend specific flags, but
5320 at the moment there isn't one. We just keep track of the
5321 sections by their name, instead. Fortunately, the ABI gives
5322 names for all the ARM specific sections, so we will probably get
5323 away with this. */
5324 switch (hdr->sh_type)
5325 {
5326 case SHT_ARM_EXIDX:
5327 break;
5328
5329 default:
5330 return FALSE;
5331 }
5332
5333 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
5334 return FALSE;
5335
5336 return TRUE;
5337}
e489d0ae
PB		 5338
5339/* Called for each symbol. Builds a section map based on mapping symbols.
5340 Does not alter any of the symbols. */
5341
5342static bfd_boolean
5343elf32_arm_output_symbol_hook (struct bfd_link_info *info,
5344 const char *name,
5345 Elf_Internal_Sym *elfsym,
5346 asection *input_sec,
5347 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
5348{
5349 int mapcount;
5350 elf32_arm_section_map *map;
5351 struct elf32_arm_link_hash_table *globals;
5352
5353 /* Only do this on final link. */
5354 if (info->relocatable)
5355 return TRUE;
5356
5357 /* Only build a map if we need to byteswap code. */
5358 globals = elf32_arm_hash_table (info);
5359 if (!globals->byteswap_code)
5360 return TRUE;
5361
5362 /* We only want mapping symbols. */
0367ecfb 5363 if (! is_arm_mapping_symbol_name (name))
e489d0ae
PB		 5364 return TRUE;
5365
5366 mapcount = ++(elf32_arm_section_data (input_sec)->mapcount);
5367 map = elf32_arm_section_data (input_sec)->map;
5368 /* TODO: This may be inefficient, but we probably don't usually have many
5369 mapping symbols per section. */
5370 map = bfd_realloc (map, mapcount * sizeof (elf32_arm_section_map));
5371 elf32_arm_section_data (input_sec)->map = map;
57e8b36a 5372
e489d0ae
PB		 5373 map[mapcount - 1].vma = elfsym->st_value;
5374 map[mapcount - 1].type = name[1];
5375 return TRUE;
5376}
5377
5378
5379/* Allocate target specific section data. */
5380
5381static bfd_boolean
5382elf32_arm_new_section_hook (bfd *abfd, asection *sec)
5383{
5384 struct _arm_elf_section_data *sdata;
5385 bfd_size_type amt = sizeof (*sdata);
5386
5387 sdata = bfd_zalloc (abfd, amt);
5388 if (sdata == NULL)
5389 return FALSE;
5390 sec->used_by_bfd = sdata;
5391
5392 return _bfd_elf_new_section_hook (abfd, sec);
5393}
5394
5395
5396/* Used to order a list of mapping symbols by address. */
5397
5398static int
5399elf32_arm_compare_mapping (const void * a, const void * b)
5400{
5401 return ((const elf32_arm_section_map *) a)->vma
5402 > ((const elf32_arm_section_map *) b)->vma;
5403}
5404
5405
5406/* Do code byteswapping. Return FALSE afterwards so that the section is
5407 written out as normal. */
5408
5409static bfd_boolean
5410elf32_arm_write_section (bfd *output_bfd ATTRIBUTE_UNUSED, asection *sec,
5411 bfd_byte *contents)
5412{
5413 int mapcount;
5414 elf32_arm_section_map *map;
5415 bfd_vma ptr;
5416 bfd_vma end;
5417 bfd_vma offset;
5418 bfd_byte tmp;
5419 int i;
57e8b36a 5420
e489d0ae
PB		 5421 mapcount = elf32_arm_section_data (sec)->mapcount;
5422 map = elf32_arm_section_data (sec)->map;
5423
5424 if (mapcount == 0)
5425 return FALSE;
5426
5427 qsort (map, mapcount, sizeof (elf32_arm_section_map),
5428 elf32_arm_compare_mapping);
5429
5430 offset = sec->output_section->vma + sec->output_offset;
5431 ptr = map[0].vma - offset;
5432 for (i = 0; i < mapcount; i++)
5433 {
5434 if (i == mapcount - 1)
eea6121a 5435 end = sec->size;
e489d0ae
PB		 5436 else
5437 end = map[i + 1].vma - offset;
57e8b36a 5438
e489d0ae
PB		 5439 switch (map[i].type)
5440 {
5441 case 'a':
5442 /* Byte swap code words. */
5443 while (ptr + 3 < end)
5444 {
5445 tmp = contents[ptr];
5446 contents[ptr] = contents[ptr + 3];
5447 contents[ptr + 3] = tmp;
5448 tmp = contents[ptr + 1];
5449 contents[ptr + 1] = contents[ptr + 2];
5450 contents[ptr + 2] = tmp;
5451 ptr += 4;
5452 }
5453 break;
5454
5455 case 't':
5456 /* Byte swap code halfwords. */
5457 while (ptr + 1 < end)
5458 {
5459 tmp = contents[ptr];
5460 contents[ptr] = contents[ptr + 1];
5461 contents[ptr + 1] = tmp;
5462 ptr += 2;
5463 }
5464 break;
5465
5466 case 'd':
5467 /* Leave data alone. */
5468 break;
5469 }
5470 ptr = end;
5471 }
93204d3a 5472 free (map);
e489d0ae
PB		 5473 return FALSE;
5474}
5475
252b5132
RH		 5476#define ELF_ARCH bfd_arch_arm
5477#define ELF_MACHINE_CODE EM_ARM
d0facd1b
NC		 5478#ifdef __QNXTARGET__
5479#define ELF_MAXPAGESIZE 0x1000
5480#else
f21f3fe0 5481#define ELF_MAXPAGESIZE 0x8000
d0facd1b 5482#endif
252b5132 5483
99e4ae17
AJ		 5484#define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
5485#define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
252b5132
RH		 5486#define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
5487#define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
5488#define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
dc810e39 5489#define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
252b5132 5490#define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
e489d0ae 5491#define bfd_elf32_new_section_hook elf32_arm_new_section_hook
3c9458e9 5492#define bfd_elf32_bfd_is_target_special_symbol elf32_arm_is_target_special_symbol
252b5132
RH		 5493
5494#define elf_backend_get_symbol_type elf32_arm_get_symbol_type
5495#define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
5496#define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
5497#define elf_backend_check_relocs elf32_arm_check_relocs
dc810e39 5498#define elf_backend_relocate_section elf32_arm_relocate_section
e489d0ae 5499#define elf_backend_write_section elf32_arm_write_section
252b5132 5500#define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
5e681ec4 5501#define elf_backend_create_dynamic_sections elf32_arm_create_dynamic_sections
252b5132
RH		 5502#define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
5503#define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
e489d0ae 5504#define elf_backend_link_output_symbol_hook elf32_arm_output_symbol_hook
252b5132 5505#define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
ba96a88f 5506#define elf_backend_post_process_headers elf32_arm_post_process_headers
99e4ae17 5507#define elf_backend_reloc_type_class elf32_arm_reloc_type_class
c178919b 5508#define elf_backend_object_p elf32_arm_object_p
e16bb312 5509#define elf_backend_section_flags elf32_arm_section_flags
40a18ebd
NC		 5510#define elf_backend_fake_sections elf32_arm_fake_sections
5511#define elf_backend_section_from_shdr elf32_arm_section_from_shdr
e16bb312 5512#define elf_backend_final_write_processing elf32_arm_final_write_processing
5e681ec4 5513#define elf_backend_copy_indirect_symbol elf32_arm_copy_indirect_symbol
252b5132 5514
5e681ec4 5515#define elf_backend_can_refcount 1
252b5132
RH		 5516#define elf_backend_can_gc_sections 1
5517#define elf_backend_plt_readonly 1
5518#define elf_backend_want_got_plt 1
5519#define elf_backend_want_plt_sym 0
acf8aed4 5520#if !USE_REL
b491616a
AM		 5521#define elf_backend_rela_normal 1
5522#endif
252b5132 5523
04f7c78d 5524#define elf_backend_got_header_size 12
04f7c78d 5525
252b5132 5526#include "elf32-target.h"
7f266840
DJ		 5527
5528/* Symbian OS Targets */
5529
5530#undef TARGET_LITTLE_SYM
5531#define TARGET_LITTLE_SYM bfd_elf32_littlearm_symbian_vec
5532#undef TARGET_LITTLE_NAME
5533#define TARGET_LITTLE_NAME "elf32-littlearm-symbian"
5534#undef TARGET_BIG_SYM
5535#define TARGET_BIG_SYM bfd_elf32_bigarm_symbian_vec
5536#undef TARGET_BIG_NAME
5537#define TARGET_BIG_NAME "elf32-bigarm-symbian"
5538
5539/* Like elf32_arm_link_hash_table_create -- but overrides
5540 appropriately for Symbian OS. */
5541static struct bfd_link_hash_table *
5542elf32_arm_symbian_link_hash_table_create (bfd *abfd)
5543{
5544 struct bfd_link_hash_table *ret;
5545
5546 ret = elf32_arm_link_hash_table_create (abfd);
5547 if (ret)
5548 {
5549 struct elf32_arm_link_hash_table *htab
5550 = (struct elf32_arm_link_hash_table *)ret;
5551 /* There is no PLT header for Symbian OS. */
5552 htab->plt_header_size = 0;
5553 /* The PLT entries are each three instructions. */
5554 htab->plt_entry_size = 4 * NUM_ELEM (elf32_arm_symbian_plt_entry);
5555 htab->symbian_p = 1;
5556 }
5557 return ret;
5558}
5559
5560/* In a BPABI executable, the dynamic linking sections do not go in
5561 the loadable read-only segment. The post-linker may wish to refer
5562 to these sections, but they are not part of the final program
5563 image. */
5564static struct bfd_elf_special_section const
5565 elf32_arm_symbian_special_sections[]=
5566{
5567 { ".dynamic", 8, 0, SHT_DYNAMIC, 0 },
5568 { ".dynstr", 7, 0, SHT_STRTAB, 0 },
5569 { ".dynsym", 7, 0, SHT_DYNSYM, 0 },
5570 { ".got", 4, 0, SHT_PROGBITS, 0 },
5571 { ".hash", 5, 0, SHT_HASH, 0 },
5572 { NULL, 0, 0, 0, 0 }
5573};
5574
5575static bfd_boolean
5576elf32_arm_symbian_modify_segment_map
5577 PARAMS ((bfd *, struct bfd_link_info *));
c3c76620
MM		 5578static void
5579elf32_arm_symbian_begin_write_processing
5580 PARAMS ((bfd *, bfd_boolean));
5581
5582static void
5583elf32_arm_symbian_begin_write_processing (abfd, linker)
5584 bfd *abfd;
5585 bfd_boolean linker;
5586{
5587 /* BPABI objects are never loaded directly by an OS kernel; they are
5588 processed by a postlinker first, into an OS-specific format. If
5589 the D_PAGED bit is set on the file, BFD will align segments on
5590 page boundaries, so that an OS can directly map the file. With
5591 BPABI objects, that just results in wasted space. In addition,
5592 because we clear the D_PAGED bit, map_sections_to_segments will
5593 recognize that the program headers should not be mapped into any
5594 loadable segment. */
5595 abfd->flags &= ~D_PAGED;
5596}
7f266840
DJ		 5597
5598static bfd_boolean
5599elf32_arm_symbian_modify_segment_map (abfd, info)
5600 bfd *abfd;
5601 struct bfd_link_info *info ATTRIBUTE_UNUSED;
5602{
5603 struct elf_segment_map *m;
5604 asection *dynsec;
5605
7f266840
DJ		 5606 /* BPABI shared libraries and executables should have a PT_DYNAMIC
5607 segment. However, because the .dynamic section is not marked
5608 with SEC_LOAD, the generic ELF code will not create such a
5609 segment. */
5610 dynsec = bfd_get_section_by_name (abfd, ".dynamic");
5611 if (dynsec)
5612 {
5613 m = _bfd_elf_make_dynamic_segment (abfd, dynsec);
5614 m->next = elf_tdata (abfd)->segment_map;
5615 elf_tdata (abfd)->segment_map = m;
5616 }
5617
5618 return TRUE;
5619}
5620
5621#undef elf32_bed
5622#define elf32_bed elf32_arm_symbian_bed
5623
5624/* The dynamic sections are not allocated on SymbianOS; the postlinker
5625 will process them and then discard them. */
5626#undef ELF_DYNAMIC_SEC_FLAGS
5627#define ELF_DYNAMIC_SEC_FLAGS \
5628 (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED)
5629
5630#undef bfd_elf32_bfd_link_hash_table_create
5631#define bfd_elf32_bfd_link_hash_table_create \
5632 elf32_arm_symbian_link_hash_table_create
5633
5634#undef elf_backend_special_sections
5635#define elf_backend_special_sections elf32_arm_symbian_special_sections
5636
c3c76620
MM		 5637#undef elf_backend_begin_write_processing
5638#define elf_backend_begin_write_processing \
5639 elf32_arm_symbian_begin_write_processing
5640
7f266840
DJ		 5641#undef elf_backend_modify_segment_map
5642#define elf_backend_modify_segment_map elf32_arm_symbian_modify_segment_map
5643
5644/* There is no .got section for BPABI objects, and hence no header. */
5645#undef elf_backend_got_header_size
5646#define elf_backend_got_header_size 0
5647
5648/* Similarly, there is no .got.plt section. */
5649#undef elf_backend_want_got_plt
5650#define elf_backend_want_got_plt 0
5651
5652#include "elf32-target.h"
5653
Empty description
This page took 1.374984 seconds and 4 git commands to generate.