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