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