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