projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
gas/
[deliverable/binutils-gdb.git] / bfd / elf32-arm.c
1 /* 32-bit ELF support for ARM
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
3 2008 Free Software Foundation, Inc.
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 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
21
22 #include "sysdep.h"
23 #include "bfd.h"
24 #include "libiberty.h"
25 #include "libbfd.h"
26 #include "elf-bfd.h"
27 #include "elf-vxworks.h"
28 #include "elf/arm.h"
29
30 /* Return the relocation section associated with NAME. HTAB is the
31 bfd's elf32_arm_link_hash_entry. */
32 #define RELOC_SECTION(HTAB, NAME) \
33 ((HTAB)->use_rel ? ".rel" NAME : ".rela" NAME)
34
35 /* Return size of a relocation entry. HTAB is the bfd's
36 elf32_arm_link_hash_entry. */
37 #define RELOC_SIZE(HTAB) \
38 ((HTAB)->use_rel \
39 ? sizeof (Elf32_External_Rel) \
40 : sizeof (Elf32_External_Rela))
41
42 /* Return function to swap relocations in. HTAB is the bfd's
43 elf32_arm_link_hash_entry. */
44 #define SWAP_RELOC_IN(HTAB) \
45 ((HTAB)->use_rel \
46 ? bfd_elf32_swap_reloc_in \
47 : bfd_elf32_swap_reloca_in)
48
49 /* Return function to swap relocations out. HTAB is the bfd's
50 elf32_arm_link_hash_entry. */
51 #define SWAP_RELOC_OUT(HTAB) \
52 ((HTAB)->use_rel \
53 ? bfd_elf32_swap_reloc_out \
54 : bfd_elf32_swap_reloca_out)
55
56 #define elf_info_to_howto 0
57 #define elf_info_to_howto_rel elf32_arm_info_to_howto
58
59 #define ARM_ELF_ABI_VERSION 0
60 #define ARM_ELF_OS_ABI_VERSION ELFOSABI_ARM
61
62 static struct elf_backend_data elf32_arm_vxworks_bed;
63
64 /* Note: code such as elf32_arm_reloc_type_lookup expect to use e.g.
65 R_ARM_PC24 as an index into this, and find the R_ARM_PC24 HOWTO
66 in that slot. */
67
68 static reloc_howto_type elf32_arm_howto_table_1[] =
69 {
70 /* No relocation. */
71 HOWTO (R_ARM_NONE, /* type */
72 0, /* rightshift */
73 0, /* size (0 = byte, 1 = short, 2 = long) */
74 0, /* bitsize */
75 FALSE, /* pc_relative */
76 0, /* bitpos */
77 complain_overflow_dont,/* complain_on_overflow */
78 bfd_elf_generic_reloc, /* special_function */
79 "R_ARM_NONE", /* name */
80 FALSE, /* partial_inplace */
81 0, /* src_mask */
82 0, /* dst_mask */
83 FALSE), /* pcrel_offset */
84
85 HOWTO (R_ARM_PC24, /* type */
86 2, /* rightshift */
87 2, /* size (0 = byte, 1 = short, 2 = long) */
88 24, /* bitsize */
89 TRUE, /* pc_relative */
90 0, /* bitpos */
91 complain_overflow_signed,/* complain_on_overflow */
92 bfd_elf_generic_reloc, /* special_function */
93 "R_ARM_PC24", /* name */
94 FALSE, /* partial_inplace */
95 0x00ffffff, /* src_mask */
96 0x00ffffff, /* dst_mask */
97 TRUE), /* pcrel_offset */
98
99 /* 32 bit absolute */
100 HOWTO (R_ARM_ABS32, /* type */
101 0, /* rightshift */
102 2, /* size (0 = byte, 1 = short, 2 = long) */
103 32, /* bitsize */
104 FALSE, /* pc_relative */
105 0, /* bitpos */
106 complain_overflow_bitfield,/* complain_on_overflow */
107 bfd_elf_generic_reloc, /* special_function */
108 "R_ARM_ABS32", /* name */
109 FALSE, /* partial_inplace */
110 0xffffffff, /* src_mask */
111 0xffffffff, /* dst_mask */
112 FALSE), /* pcrel_offset */
113
114 /* standard 32bit pc-relative reloc */
115 HOWTO (R_ARM_REL32, /* type */
116 0, /* rightshift */
117 2, /* size (0 = byte, 1 = short, 2 = long) */
118 32, /* bitsize */
119 TRUE, /* pc_relative */
120 0, /* bitpos */
121 complain_overflow_bitfield,/* complain_on_overflow */
122 bfd_elf_generic_reloc, /* special_function */
123 "R_ARM_REL32", /* name */
124 FALSE, /* partial_inplace */
125 0xffffffff, /* src_mask */
126 0xffffffff, /* dst_mask */
127 TRUE), /* pcrel_offset */
128
129 /* 8 bit absolute - R_ARM_LDR_PC_G0 in AAELF */
130 HOWTO (R_ARM_LDR_PC_G0, /* type */
131 0, /* rightshift */
132 0, /* size (0 = byte, 1 = short, 2 = long) */
133 32, /* bitsize */
134 TRUE, /* pc_relative */
135 0, /* bitpos */
136 complain_overflow_dont,/* complain_on_overflow */
137 bfd_elf_generic_reloc, /* special_function */
138 "R_ARM_LDR_PC_G0", /* name */
139 FALSE, /* partial_inplace */
140 0xffffffff, /* src_mask */
141 0xffffffff, /* dst_mask */
142 TRUE), /* pcrel_offset */
143
144 /* 16 bit absolute */
145 HOWTO (R_ARM_ABS16, /* type */
146 0, /* rightshift */
147 1, /* size (0 = byte, 1 = short, 2 = long) */
148 16, /* bitsize */
149 FALSE, /* pc_relative */
150 0, /* bitpos */
151 complain_overflow_bitfield,/* complain_on_overflow */
152 bfd_elf_generic_reloc, /* special_function */
153 "R_ARM_ABS16", /* name */
154 FALSE, /* partial_inplace */
155 0x0000ffff, /* src_mask */
156 0x0000ffff, /* dst_mask */
157 FALSE), /* pcrel_offset */
158
159 /* 12 bit absolute */
160 HOWTO (R_ARM_ABS12, /* type */
161 0, /* rightshift */
162 2, /* size (0 = byte, 1 = short, 2 = long) */
163 12, /* bitsize */
164 FALSE, /* pc_relative */
165 0, /* bitpos */
166 complain_overflow_bitfield,/* complain_on_overflow */
167 bfd_elf_generic_reloc, /* special_function */
168 "R_ARM_ABS12", /* name */
169 FALSE, /* partial_inplace */
170 0x00000fff, /* src_mask */
171 0x00000fff, /* dst_mask */
172 FALSE), /* pcrel_offset */
173
174 HOWTO (R_ARM_THM_ABS5, /* type */
175 6, /* rightshift */
176 1, /* size (0 = byte, 1 = short, 2 = long) */
177 5, /* bitsize */
178 FALSE, /* pc_relative */
179 0, /* bitpos */
180 complain_overflow_bitfield,/* complain_on_overflow */
181 bfd_elf_generic_reloc, /* special_function */
182 "R_ARM_THM_ABS5", /* name */
183 FALSE, /* partial_inplace */
184 0x000007e0, /* src_mask */
185 0x000007e0, /* dst_mask */
186 FALSE), /* pcrel_offset */
187
188 /* 8 bit absolute */
189 HOWTO (R_ARM_ABS8, /* type */
190 0, /* rightshift */
191 0, /* size (0 = byte, 1 = short, 2 = long) */
192 8, /* bitsize */
193 FALSE, /* pc_relative */
194 0, /* bitpos */
195 complain_overflow_bitfield,/* complain_on_overflow */
196 bfd_elf_generic_reloc, /* special_function */
197 "R_ARM_ABS8", /* name */
198 FALSE, /* partial_inplace */
199 0x000000ff, /* src_mask */
200 0x000000ff, /* dst_mask */
201 FALSE), /* pcrel_offset */
202
203 HOWTO (R_ARM_SBREL32, /* type */
204 0, /* rightshift */
205 2, /* size (0 = byte, 1 = short, 2 = long) */
206 32, /* bitsize */
207 FALSE, /* pc_relative */
208 0, /* bitpos */
209 complain_overflow_dont,/* complain_on_overflow */
210 bfd_elf_generic_reloc, /* special_function */
211 "R_ARM_SBREL32", /* name */
212 FALSE, /* partial_inplace */
213 0xffffffff, /* src_mask */
214 0xffffffff, /* dst_mask */
215 FALSE), /* pcrel_offset */
216
217 HOWTO (R_ARM_THM_CALL, /* type */
218 1, /* rightshift */
219 2, /* size (0 = byte, 1 = short, 2 = long) */
220 25, /* bitsize */
221 TRUE, /* pc_relative */
222 0, /* bitpos */
223 complain_overflow_signed,/* complain_on_overflow */
224 bfd_elf_generic_reloc, /* special_function */
225 "R_ARM_THM_CALL", /* name */
226 FALSE, /* partial_inplace */
227 0x07ff07ff, /* src_mask */
228 0x07ff07ff, /* dst_mask */
229 TRUE), /* pcrel_offset */
230
231 HOWTO (R_ARM_THM_PC8, /* type */
232 1, /* rightshift */
233 1, /* size (0 = byte, 1 = short, 2 = long) */
234 8, /* bitsize */
235 TRUE, /* pc_relative */
236 0, /* bitpos */
237 complain_overflow_signed,/* complain_on_overflow */
238 bfd_elf_generic_reloc, /* special_function */
239 "R_ARM_THM_PC8", /* name */
240 FALSE, /* partial_inplace */
241 0x000000ff, /* src_mask */
242 0x000000ff, /* dst_mask */
243 TRUE), /* pcrel_offset */
244
245 HOWTO (R_ARM_BREL_ADJ, /* type */
246 1, /* rightshift */
247 1, /* size (0 = byte, 1 = short, 2 = long) */
248 32, /* bitsize */
249 FALSE, /* pc_relative */
250 0, /* bitpos */
251 complain_overflow_signed,/* complain_on_overflow */
252 bfd_elf_generic_reloc, /* special_function */
253 "R_ARM_BREL_ADJ", /* name */
254 FALSE, /* partial_inplace */
255 0xffffffff, /* src_mask */
256 0xffffffff, /* dst_mask */
257 FALSE), /* pcrel_offset */
258
259 HOWTO (R_ARM_SWI24, /* type */
260 0, /* rightshift */
261 0, /* size (0 = byte, 1 = short, 2 = long) */
262 0, /* bitsize */
263 FALSE, /* pc_relative */
264 0, /* bitpos */
265 complain_overflow_signed,/* complain_on_overflow */
266 bfd_elf_generic_reloc, /* special_function */
267 "R_ARM_SWI24", /* name */
268 FALSE, /* partial_inplace */
269 0x00000000, /* src_mask */
270 0x00000000, /* dst_mask */
271 FALSE), /* pcrel_offset */
272
273 HOWTO (R_ARM_THM_SWI8, /* type */
274 0, /* rightshift */
275 0, /* size (0 = byte, 1 = short, 2 = long) */
276 0, /* bitsize */
277 FALSE, /* pc_relative */
278 0, /* bitpos */
279 complain_overflow_signed,/* complain_on_overflow */
280 bfd_elf_generic_reloc, /* special_function */
281 "R_ARM_SWI8", /* name */
282 FALSE, /* partial_inplace */
283 0x00000000, /* src_mask */
284 0x00000000, /* dst_mask */
285 FALSE), /* pcrel_offset */
286
287 /* BLX instruction for the ARM. */
288 HOWTO (R_ARM_XPC25, /* type */
289 2, /* rightshift */
290 2, /* size (0 = byte, 1 = short, 2 = long) */
291 25, /* bitsize */
292 TRUE, /* pc_relative */
293 0, /* bitpos */
294 complain_overflow_signed,/* complain_on_overflow */
295 bfd_elf_generic_reloc, /* special_function */
296 "R_ARM_XPC25", /* name */
297 FALSE, /* partial_inplace */
298 0x00ffffff, /* src_mask */
299 0x00ffffff, /* dst_mask */
300 TRUE), /* pcrel_offset */
301
302 /* BLX instruction for the Thumb. */
303 HOWTO (R_ARM_THM_XPC22, /* type */
304 2, /* rightshift */
305 2, /* size (0 = byte, 1 = short, 2 = long) */
306 22, /* bitsize */
307 TRUE, /* pc_relative */
308 0, /* bitpos */
309 complain_overflow_signed,/* complain_on_overflow */
310 bfd_elf_generic_reloc, /* special_function */
311 "R_ARM_THM_XPC22", /* name */
312 FALSE, /* partial_inplace */
313 0x07ff07ff, /* src_mask */
314 0x07ff07ff, /* dst_mask */
315 TRUE), /* pcrel_offset */
316
317 /* Dynamic TLS relocations. */
318
319 HOWTO (R_ARM_TLS_DTPMOD32, /* type */
320 0, /* rightshift */
321 2, /* size (0 = byte, 1 = short, 2 = long) */
322 32, /* bitsize */
323 FALSE, /* pc_relative */
324 0, /* bitpos */
325 complain_overflow_bitfield,/* complain_on_overflow */
326 bfd_elf_generic_reloc, /* special_function */
327 "R_ARM_TLS_DTPMOD32", /* name */
328 TRUE, /* partial_inplace */
329 0xffffffff, /* src_mask */
330 0xffffffff, /* dst_mask */
331 FALSE), /* pcrel_offset */
332
333 HOWTO (R_ARM_TLS_DTPOFF32, /* type */
334 0, /* rightshift */
335 2, /* size (0 = byte, 1 = short, 2 = long) */
336 32, /* bitsize */
337 FALSE, /* pc_relative */
338 0, /* bitpos */
339 complain_overflow_bitfield,/* complain_on_overflow */
340 bfd_elf_generic_reloc, /* special_function */
341 "R_ARM_TLS_DTPOFF32", /* name */
342 TRUE, /* partial_inplace */
343 0xffffffff, /* src_mask */
344 0xffffffff, /* dst_mask */
345 FALSE), /* pcrel_offset */
346
347 HOWTO (R_ARM_TLS_TPOFF32, /* type */
348 0, /* rightshift */
349 2, /* size (0 = byte, 1 = short, 2 = long) */
350 32, /* bitsize */
351 FALSE, /* pc_relative */
352 0, /* bitpos */
353 complain_overflow_bitfield,/* complain_on_overflow */
354 bfd_elf_generic_reloc, /* special_function */
355 "R_ARM_TLS_TPOFF32", /* name */
356 TRUE, /* partial_inplace */
357 0xffffffff, /* src_mask */
358 0xffffffff, /* dst_mask */
359 FALSE), /* pcrel_offset */
360
361 /* Relocs used in ARM Linux */
362
363 HOWTO (R_ARM_COPY, /* type */
364 0, /* rightshift */
365 2, /* size (0 = byte, 1 = short, 2 = long) */
366 32, /* bitsize */
367 FALSE, /* pc_relative */
368 0, /* bitpos */
369 complain_overflow_bitfield,/* complain_on_overflow */
370 bfd_elf_generic_reloc, /* special_function */
371 "R_ARM_COPY", /* name */
372 TRUE, /* partial_inplace */
373 0xffffffff, /* src_mask */
374 0xffffffff, /* dst_mask */
375 FALSE), /* pcrel_offset */
376
377 HOWTO (R_ARM_GLOB_DAT, /* type */
378 0, /* rightshift */
379 2, /* size (0 = byte, 1 = short, 2 = long) */
380 32, /* bitsize */
381 FALSE, /* pc_relative */
382 0, /* bitpos */
383 complain_overflow_bitfield,/* complain_on_overflow */
384 bfd_elf_generic_reloc, /* special_function */
385 "R_ARM_GLOB_DAT", /* name */
386 TRUE, /* partial_inplace */
387 0xffffffff, /* src_mask */
388 0xffffffff, /* dst_mask */
389 FALSE), /* pcrel_offset */
390
391 HOWTO (R_ARM_JUMP_SLOT, /* type */
392 0, /* rightshift */
393 2, /* size (0 = byte, 1 = short, 2 = long) */
394 32, /* bitsize */
395 FALSE, /* pc_relative */
396 0, /* bitpos */
397 complain_overflow_bitfield,/* complain_on_overflow */
398 bfd_elf_generic_reloc, /* special_function */
399 "R_ARM_JUMP_SLOT", /* name */
400 TRUE, /* partial_inplace */
401 0xffffffff, /* src_mask */
402 0xffffffff, /* dst_mask */
403 FALSE), /* pcrel_offset */
404
405 HOWTO (R_ARM_RELATIVE, /* type */
406 0, /* rightshift */
407 2, /* size (0 = byte, 1 = short, 2 = long) */
408 32, /* bitsize */
409 FALSE, /* pc_relative */
410 0, /* bitpos */
411 complain_overflow_bitfield,/* complain_on_overflow */
412 bfd_elf_generic_reloc, /* special_function */
413 "R_ARM_RELATIVE", /* name */
414 TRUE, /* partial_inplace */
415 0xffffffff, /* src_mask */
416 0xffffffff, /* dst_mask */
417 FALSE), /* pcrel_offset */
418
419 HOWTO (R_ARM_GOTOFF32, /* type */
420 0, /* rightshift */
421 2, /* size (0 = byte, 1 = short, 2 = long) */
422 32, /* bitsize */
423 FALSE, /* pc_relative */
424 0, /* bitpos */
425 complain_overflow_bitfield,/* complain_on_overflow */
426 bfd_elf_generic_reloc, /* special_function */
427 "R_ARM_GOTOFF32", /* name */
428 TRUE, /* partial_inplace */
429 0xffffffff, /* src_mask */
430 0xffffffff, /* dst_mask */
431 FALSE), /* pcrel_offset */
432
433 HOWTO (R_ARM_GOTPC, /* type */
434 0, /* rightshift */
435 2, /* size (0 = byte, 1 = short, 2 = long) */
436 32, /* bitsize */
437 TRUE, /* pc_relative */
438 0, /* bitpos */
439 complain_overflow_bitfield,/* complain_on_overflow */
440 bfd_elf_generic_reloc, /* special_function */
441 "R_ARM_GOTPC", /* name */
442 TRUE, /* partial_inplace */
443 0xffffffff, /* src_mask */
444 0xffffffff, /* dst_mask */
445 TRUE), /* pcrel_offset */
446
447 HOWTO (R_ARM_GOT32, /* type */
448 0, /* rightshift */
449 2, /* size (0 = byte, 1 = short, 2 = long) */
450 32, /* bitsize */
451 FALSE, /* pc_relative */
452 0, /* bitpos */
453 complain_overflow_bitfield,/* complain_on_overflow */
454 bfd_elf_generic_reloc, /* special_function */
455 "R_ARM_GOT32", /* name */
456 TRUE, /* partial_inplace */
457 0xffffffff, /* src_mask */
458 0xffffffff, /* dst_mask */
459 FALSE), /* pcrel_offset */
460
461 HOWTO (R_ARM_PLT32, /* type */
462 2, /* rightshift */
463 2, /* size (0 = byte, 1 = short, 2 = long) */
464 24, /* bitsize */
465 TRUE, /* pc_relative */
466 0, /* bitpos */
467 complain_overflow_bitfield,/* complain_on_overflow */
468 bfd_elf_generic_reloc, /* special_function */
469 "R_ARM_PLT32", /* name */
470 FALSE, /* partial_inplace */
471 0x00ffffff, /* src_mask */
472 0x00ffffff, /* dst_mask */
473 TRUE), /* pcrel_offset */
474
475 HOWTO (R_ARM_CALL, /* type */
476 2, /* rightshift */
477 2, /* size (0 = byte, 1 = short, 2 = long) */
478 24, /* bitsize */
479 TRUE, /* pc_relative */
480 0, /* bitpos */
481 complain_overflow_signed,/* complain_on_overflow */
482 bfd_elf_generic_reloc, /* special_function */
483 "R_ARM_CALL", /* name */
484 FALSE, /* partial_inplace */
485 0x00ffffff, /* src_mask */
486 0x00ffffff, /* dst_mask */
487 TRUE), /* pcrel_offset */
488
489 HOWTO (R_ARM_JUMP24, /* type */
490 2, /* rightshift */
491 2, /* size (0 = byte, 1 = short, 2 = long) */
492 24, /* bitsize */
493 TRUE, /* pc_relative */
494 0, /* bitpos */
495 complain_overflow_signed,/* complain_on_overflow */
496 bfd_elf_generic_reloc, /* special_function */
497 "R_ARM_JUMP24", /* name */
498 FALSE, /* partial_inplace */
499 0x00ffffff, /* src_mask */
500 0x00ffffff, /* dst_mask */
501 TRUE), /* pcrel_offset */
502
503 HOWTO (R_ARM_THM_JUMP24, /* type */
504 1, /* rightshift */
505 2, /* size (0 = byte, 1 = short, 2 = long) */
506 24, /* bitsize */
507 TRUE, /* pc_relative */
508 0, /* bitpos */
509 complain_overflow_signed,/* complain_on_overflow */
510 bfd_elf_generic_reloc, /* special_function */
511 "R_ARM_THM_JUMP24", /* name */
512 FALSE, /* partial_inplace */
513 0x07ff2fff, /* src_mask */
514 0x07ff2fff, /* dst_mask */
515 TRUE), /* pcrel_offset */
516
517 HOWTO (R_ARM_BASE_ABS, /* type */
518 0, /* rightshift */
519 2, /* size (0 = byte, 1 = short, 2 = long) */
520 32, /* bitsize */
521 FALSE, /* pc_relative */
522 0, /* bitpos */
523 complain_overflow_dont,/* complain_on_overflow */
524 bfd_elf_generic_reloc, /* special_function */
525 "R_ARM_BASE_ABS", /* name */
526 FALSE, /* partial_inplace */
527 0xffffffff, /* src_mask */
528 0xffffffff, /* dst_mask */
529 FALSE), /* pcrel_offset */
530
531 HOWTO (R_ARM_ALU_PCREL7_0, /* type */
532 0, /* rightshift */
533 2, /* size (0 = byte, 1 = short, 2 = long) */
534 12, /* bitsize */
535 TRUE, /* pc_relative */
536 0, /* bitpos */
537 complain_overflow_dont,/* complain_on_overflow */
538 bfd_elf_generic_reloc, /* special_function */
539 "R_ARM_ALU_PCREL_7_0", /* name */
540 FALSE, /* partial_inplace */
541 0x00000fff, /* src_mask */
542 0x00000fff, /* dst_mask */
543 TRUE), /* pcrel_offset */
544
545 HOWTO (R_ARM_ALU_PCREL15_8, /* type */
546 0, /* rightshift */
547 2, /* size (0 = byte, 1 = short, 2 = long) */
548 12, /* bitsize */
549 TRUE, /* pc_relative */
550 8, /* bitpos */
551 complain_overflow_dont,/* complain_on_overflow */
552 bfd_elf_generic_reloc, /* special_function */
553 "R_ARM_ALU_PCREL_15_8",/* name */
554 FALSE, /* partial_inplace */
555 0x00000fff, /* src_mask */
556 0x00000fff, /* dst_mask */
557 TRUE), /* pcrel_offset */
558
559 HOWTO (R_ARM_ALU_PCREL23_15, /* type */
560 0, /* rightshift */
561 2, /* size (0 = byte, 1 = short, 2 = long) */
562 12, /* bitsize */
563 TRUE, /* pc_relative */
564 16, /* bitpos */
565 complain_overflow_dont,/* complain_on_overflow */
566 bfd_elf_generic_reloc, /* special_function */
567 "R_ARM_ALU_PCREL_23_15",/* name */
568 FALSE, /* partial_inplace */
569 0x00000fff, /* src_mask */
570 0x00000fff, /* dst_mask */
571 TRUE), /* pcrel_offset */
572
573 HOWTO (R_ARM_LDR_SBREL_11_0, /* type */
574 0, /* rightshift */
575 2, /* size (0 = byte, 1 = short, 2 = long) */
576 12, /* bitsize */
577 FALSE, /* pc_relative */
578 0, /* bitpos */
579 complain_overflow_dont,/* complain_on_overflow */
580 bfd_elf_generic_reloc, /* special_function */
581 "R_ARM_LDR_SBREL_11_0",/* name */
582 FALSE, /* partial_inplace */
583 0x00000fff, /* src_mask */
584 0x00000fff, /* dst_mask */
585 FALSE), /* pcrel_offset */
586
587 HOWTO (R_ARM_ALU_SBREL_19_12, /* type */
588 0, /* rightshift */
589 2, /* size (0 = byte, 1 = short, 2 = long) */
590 8, /* bitsize */
591 FALSE, /* pc_relative */
592 12, /* bitpos */
593 complain_overflow_dont,/* complain_on_overflow */
594 bfd_elf_generic_reloc, /* special_function */
595 "R_ARM_ALU_SBREL_19_12",/* name */
596 FALSE, /* partial_inplace */
597 0x000ff000, /* src_mask */
598 0x000ff000, /* dst_mask */
599 FALSE), /* pcrel_offset */
600
601 HOWTO (R_ARM_ALU_SBREL_27_20, /* type */
602 0, /* rightshift */
603 2, /* size (0 = byte, 1 = short, 2 = long) */
604 8, /* bitsize */
605 FALSE, /* pc_relative */
606 20, /* bitpos */
607 complain_overflow_dont,/* complain_on_overflow */
608 bfd_elf_generic_reloc, /* special_function */
609 "R_ARM_ALU_SBREL_27_20",/* name */
610 FALSE, /* partial_inplace */
611 0x0ff00000, /* src_mask */
612 0x0ff00000, /* dst_mask */
613 FALSE), /* pcrel_offset */
614
615 HOWTO (R_ARM_TARGET1, /* type */
616 0, /* rightshift */
617 2, /* size (0 = byte, 1 = short, 2 = long) */
618 32, /* bitsize */
619 FALSE, /* pc_relative */
620 0, /* bitpos */
621 complain_overflow_dont,/* complain_on_overflow */
622 bfd_elf_generic_reloc, /* special_function */
623 "R_ARM_TARGET1", /* name */
624 FALSE, /* partial_inplace */
625 0xffffffff, /* src_mask */
626 0xffffffff, /* dst_mask */
627 FALSE), /* pcrel_offset */
628
629 HOWTO (R_ARM_ROSEGREL32, /* type */
630 0, /* rightshift */
631 2, /* size (0 = byte, 1 = short, 2 = long) */
632 32, /* bitsize */
633 FALSE, /* pc_relative */
634 0, /* bitpos */
635 complain_overflow_dont,/* complain_on_overflow */
636 bfd_elf_generic_reloc, /* special_function */
637 "R_ARM_ROSEGREL32", /* name */
638 FALSE, /* partial_inplace */
639 0xffffffff, /* src_mask */
640 0xffffffff, /* dst_mask */
641 FALSE), /* pcrel_offset */
642
643 HOWTO (R_ARM_V4BX, /* type */
644 0, /* rightshift */
645 2, /* size (0 = byte, 1 = short, 2 = long) */
646 32, /* bitsize */
647 FALSE, /* pc_relative */
648 0, /* bitpos */
649 complain_overflow_dont,/* complain_on_overflow */
650 bfd_elf_generic_reloc, /* special_function */
651 "R_ARM_V4BX", /* name */
652 FALSE, /* partial_inplace */
653 0xffffffff, /* src_mask */
654 0xffffffff, /* dst_mask */
655 FALSE), /* pcrel_offset */
656
657 HOWTO (R_ARM_TARGET2, /* type */
658 0, /* rightshift */
659 2, /* size (0 = byte, 1 = short, 2 = long) */
660 32, /* bitsize */
661 FALSE, /* pc_relative */
662 0, /* bitpos */
663 complain_overflow_signed,/* complain_on_overflow */
664 bfd_elf_generic_reloc, /* special_function */
665 "R_ARM_TARGET2", /* name */
666 FALSE, /* partial_inplace */
667 0xffffffff, /* src_mask */
668 0xffffffff, /* dst_mask */
669 TRUE), /* pcrel_offset */
670
671 HOWTO (R_ARM_PREL31, /* type */
672 0, /* rightshift */
673 2, /* size (0 = byte, 1 = short, 2 = long) */
674 31, /* bitsize */
675 TRUE, /* pc_relative */
676 0, /* bitpos */
677 complain_overflow_signed,/* complain_on_overflow */
678 bfd_elf_generic_reloc, /* special_function */
679 "R_ARM_PREL31", /* name */
680 FALSE, /* partial_inplace */
681 0x7fffffff, /* src_mask */
682 0x7fffffff, /* dst_mask */
683 TRUE), /* pcrel_offset */
684
685 HOWTO (R_ARM_MOVW_ABS_NC, /* type */
686 0, /* rightshift */
687 2, /* size (0 = byte, 1 = short, 2 = long) */
688 16, /* bitsize */
689 FALSE, /* pc_relative */
690 0, /* bitpos */
691 complain_overflow_dont,/* complain_on_overflow */
692 bfd_elf_generic_reloc, /* special_function */
693 "R_ARM_MOVW_ABS_NC", /* name */
694 FALSE, /* partial_inplace */
695 0x000f0fff, /* src_mask */
696 0x000f0fff, /* dst_mask */
697 FALSE), /* pcrel_offset */
698
699 HOWTO (R_ARM_MOVT_ABS, /* type */
700 0, /* rightshift */
701 2, /* size (0 = byte, 1 = short, 2 = long) */
702 16, /* bitsize */
703 FALSE, /* pc_relative */
704 0, /* bitpos */
705 complain_overflow_bitfield,/* complain_on_overflow */
706 bfd_elf_generic_reloc, /* special_function */
707 "R_ARM_MOVT_ABS", /* name */
708 FALSE, /* partial_inplace */
709 0x000f0fff, /* src_mask */
710 0x000f0fff, /* dst_mask */
711 FALSE), /* pcrel_offset */
712
713 HOWTO (R_ARM_MOVW_PREL_NC, /* type */
714 0, /* rightshift */
715 2, /* size (0 = byte, 1 = short, 2 = long) */
716 16, /* bitsize */
717 TRUE, /* pc_relative */
718 0, /* bitpos */
719 complain_overflow_dont,/* complain_on_overflow */
720 bfd_elf_generic_reloc, /* special_function */
721 "R_ARM_MOVW_PREL_NC", /* name */
722 FALSE, /* partial_inplace */
723 0x000f0fff, /* src_mask */
724 0x000f0fff, /* dst_mask */
725 TRUE), /* pcrel_offset */
726
727 HOWTO (R_ARM_MOVT_PREL, /* type */
728 0, /* rightshift */
729 2, /* size (0 = byte, 1 = short, 2 = long) */
730 16, /* bitsize */
731 TRUE, /* pc_relative */
732 0, /* bitpos */
733 complain_overflow_bitfield,/* complain_on_overflow */
734 bfd_elf_generic_reloc, /* special_function */
735 "R_ARM_MOVT_PREL", /* name */
736 FALSE, /* partial_inplace */
737 0x000f0fff, /* src_mask */
738 0x000f0fff, /* dst_mask */
739 TRUE), /* pcrel_offset */
740
741 HOWTO (R_ARM_THM_MOVW_ABS_NC, /* type */
742 0, /* rightshift */
743 2, /* size (0 = byte, 1 = short, 2 = long) */
744 16, /* bitsize */
745 FALSE, /* pc_relative */
746 0, /* bitpos */
747 complain_overflow_dont,/* complain_on_overflow */
748 bfd_elf_generic_reloc, /* special_function */
749 "R_ARM_THM_MOVW_ABS_NC",/* name */
750 FALSE, /* partial_inplace */
751 0x040f70ff, /* src_mask */
752 0x040f70ff, /* dst_mask */
753 FALSE), /* pcrel_offset */
754
755 HOWTO (R_ARM_THM_MOVT_ABS, /* type */
756 0, /* rightshift */
757 2, /* size (0 = byte, 1 = short, 2 = long) */
758 16, /* bitsize */
759 FALSE, /* pc_relative */
760 0, /* bitpos */
761 complain_overflow_bitfield,/* complain_on_overflow */
762 bfd_elf_generic_reloc, /* special_function */
763 "R_ARM_THM_MOVT_ABS", /* name */
764 FALSE, /* partial_inplace */
765 0x040f70ff, /* src_mask */
766 0x040f70ff, /* dst_mask */
767 FALSE), /* pcrel_offset */
768
769 HOWTO (R_ARM_THM_MOVW_PREL_NC,/* type */
770 0, /* rightshift */
771 2, /* size (0 = byte, 1 = short, 2 = long) */
772 16, /* bitsize */
773 TRUE, /* pc_relative */
774 0, /* bitpos */
775 complain_overflow_dont,/* complain_on_overflow */
776 bfd_elf_generic_reloc, /* special_function */
777 "R_ARM_THM_MOVW_PREL_NC",/* name */
778 FALSE, /* partial_inplace */
779 0x040f70ff, /* src_mask */
780 0x040f70ff, /* dst_mask */
781 TRUE), /* pcrel_offset */
782
783 HOWTO (R_ARM_THM_MOVT_PREL, /* type */
784 0, /* rightshift */
785 2, /* size (0 = byte, 1 = short, 2 = long) */
786 16, /* bitsize */
787 TRUE, /* pc_relative */
788 0, /* bitpos */
789 complain_overflow_bitfield,/* complain_on_overflow */
790 bfd_elf_generic_reloc, /* special_function */
791 "R_ARM_THM_MOVT_PREL", /* name */
792 FALSE, /* partial_inplace */
793 0x040f70ff, /* src_mask */
794 0x040f70ff, /* dst_mask */
795 TRUE), /* pcrel_offset */
796
797 HOWTO (R_ARM_THM_JUMP19, /* type */
798 1, /* rightshift */
799 2, /* size (0 = byte, 1 = short, 2 = long) */
800 19, /* bitsize */
801 TRUE, /* pc_relative */
802 0, /* bitpos */
803 complain_overflow_signed,/* complain_on_overflow */
804 bfd_elf_generic_reloc, /* special_function */
805 "R_ARM_THM_JUMP19", /* name */
806 FALSE, /* partial_inplace */
807 0x043f2fff, /* src_mask */
808 0x043f2fff, /* dst_mask */
809 TRUE), /* pcrel_offset */
810
811 HOWTO (R_ARM_THM_JUMP6, /* type */
812 1, /* rightshift */
813 1, /* size (0 = byte, 1 = short, 2 = long) */
814 6, /* bitsize */
815 TRUE, /* pc_relative */
816 0, /* bitpos */
817 complain_overflow_unsigned,/* complain_on_overflow */
818 bfd_elf_generic_reloc, /* special_function */
819 "R_ARM_THM_JUMP6", /* name */
820 FALSE, /* partial_inplace */
821 0x02f8, /* src_mask */
822 0x02f8, /* dst_mask */
823 TRUE), /* pcrel_offset */
824
825 /* These are declared as 13-bit signed relocations because we can
826 address -4095 .. 4095(base) by altering ADDW to SUBW or vice
827 versa. */
828 HOWTO (R_ARM_THM_ALU_PREL_11_0,/* type */
829 0, /* rightshift */
830 2, /* size (0 = byte, 1 = short, 2 = long) */
831 13, /* bitsize */
832 TRUE, /* pc_relative */
833 0, /* bitpos */
834 complain_overflow_dont,/* complain_on_overflow */
835 bfd_elf_generic_reloc, /* special_function */
836 "R_ARM_THM_ALU_PREL_11_0",/* name */
837 FALSE, /* partial_inplace */
838 0xffffffff, /* src_mask */
839 0xffffffff, /* dst_mask */
840 TRUE), /* pcrel_offset */
841
842 HOWTO (R_ARM_THM_PC12, /* type */
843 0, /* rightshift */
844 2, /* size (0 = byte, 1 = short, 2 = long) */
845 13, /* bitsize */
846 TRUE, /* pc_relative */
847 0, /* bitpos */
848 complain_overflow_dont,/* complain_on_overflow */
849 bfd_elf_generic_reloc, /* special_function */
850 "R_ARM_THM_PC12", /* name */
851 FALSE, /* partial_inplace */
852 0xffffffff, /* src_mask */
853 0xffffffff, /* dst_mask */
854 TRUE), /* pcrel_offset */
855
856 HOWTO (R_ARM_ABS32_NOI, /* type */
857 0, /* rightshift */
858 2, /* size (0 = byte, 1 = short, 2 = long) */
859 32, /* bitsize */
860 FALSE, /* pc_relative */
861 0, /* bitpos */
862 complain_overflow_dont,/* complain_on_overflow */
863 bfd_elf_generic_reloc, /* special_function */
864 "R_ARM_ABS32_NOI", /* name */
865 FALSE, /* partial_inplace */
866 0xffffffff, /* src_mask */
867 0xffffffff, /* dst_mask */
868 FALSE), /* pcrel_offset */
869
870 HOWTO (R_ARM_REL32_NOI, /* type */
871 0, /* rightshift */
872 2, /* size (0 = byte, 1 = short, 2 = long) */
873 32, /* bitsize */
874 TRUE, /* pc_relative */
875 0, /* bitpos */
876 complain_overflow_dont,/* complain_on_overflow */
877 bfd_elf_generic_reloc, /* special_function */
878 "R_ARM_REL32_NOI", /* name */
879 FALSE, /* partial_inplace */
880 0xffffffff, /* src_mask */
881 0xffffffff, /* dst_mask */
882 FALSE), /* pcrel_offset */
883
884 /* Group relocations. */
885
886 HOWTO (R_ARM_ALU_PC_G0_NC, /* type */
887 0, /* rightshift */
888 2, /* size (0 = byte, 1 = short, 2 = long) */
889 32, /* bitsize */
890 TRUE, /* pc_relative */
891 0, /* bitpos */
892 complain_overflow_dont,/* complain_on_overflow */
893 bfd_elf_generic_reloc, /* special_function */
894 "R_ARM_ALU_PC_G0_NC", /* name */
895 FALSE, /* partial_inplace */
896 0xffffffff, /* src_mask */
897 0xffffffff, /* dst_mask */
898 TRUE), /* pcrel_offset */
899
900 HOWTO (R_ARM_ALU_PC_G0, /* type */
901 0, /* rightshift */
902 2, /* size (0 = byte, 1 = short, 2 = long) */
903 32, /* bitsize */
904 TRUE, /* pc_relative */
905 0, /* bitpos */
906 complain_overflow_dont,/* complain_on_overflow */
907 bfd_elf_generic_reloc, /* special_function */
908 "R_ARM_ALU_PC_G0", /* name */
909 FALSE, /* partial_inplace */
910 0xffffffff, /* src_mask */
911 0xffffffff, /* dst_mask */
912 TRUE), /* pcrel_offset */
913
914 HOWTO (R_ARM_ALU_PC_G1_NC, /* type */
915 0, /* rightshift */
916 2, /* size (0 = byte, 1 = short, 2 = long) */
917 32, /* bitsize */
918 TRUE, /* pc_relative */
919 0, /* bitpos */
920 complain_overflow_dont,/* complain_on_overflow */
921 bfd_elf_generic_reloc, /* special_function */
922 "R_ARM_ALU_PC_G1_NC", /* name */
923 FALSE, /* partial_inplace */
924 0xffffffff, /* src_mask */
925 0xffffffff, /* dst_mask */
926 TRUE), /* pcrel_offset */
927
928 HOWTO (R_ARM_ALU_PC_G1, /* type */
929 0, /* rightshift */
930 2, /* size (0 = byte, 1 = short, 2 = long) */
931 32, /* bitsize */
932 TRUE, /* pc_relative */
933 0, /* bitpos */
934 complain_overflow_dont,/* complain_on_overflow */
935 bfd_elf_generic_reloc, /* special_function */
936 "R_ARM_ALU_PC_G1", /* name */
937 FALSE, /* partial_inplace */
938 0xffffffff, /* src_mask */
939 0xffffffff, /* dst_mask */
940 TRUE), /* pcrel_offset */
941
942 HOWTO (R_ARM_ALU_PC_G2, /* type */
943 0, /* rightshift */
944 2, /* size (0 = byte, 1 = short, 2 = long) */
945 32, /* bitsize */
946 TRUE, /* pc_relative */
947 0, /* bitpos */
948 complain_overflow_dont,/* complain_on_overflow */
949 bfd_elf_generic_reloc, /* special_function */
950 "R_ARM_ALU_PC_G2", /* name */
951 FALSE, /* partial_inplace */
952 0xffffffff, /* src_mask */
953 0xffffffff, /* dst_mask */
954 TRUE), /* pcrel_offset */
955
956 HOWTO (R_ARM_LDR_PC_G1, /* type */
957 0, /* rightshift */
958 2, /* size (0 = byte, 1 = short, 2 = long) */
959 32, /* bitsize */
960 TRUE, /* pc_relative */
961 0, /* bitpos */
962 complain_overflow_dont,/* complain_on_overflow */
963 bfd_elf_generic_reloc, /* special_function */
964 "R_ARM_LDR_PC_G1", /* name */
965 FALSE, /* partial_inplace */
966 0xffffffff, /* src_mask */
967 0xffffffff, /* dst_mask */
968 TRUE), /* pcrel_offset */
969
970 HOWTO (R_ARM_LDR_PC_G2, /* type */
971 0, /* rightshift */
972 2, /* size (0 = byte, 1 = short, 2 = long) */
973 32, /* bitsize */
974 TRUE, /* pc_relative */
975 0, /* bitpos */
976 complain_overflow_dont,/* complain_on_overflow */
977 bfd_elf_generic_reloc, /* special_function */
978 "R_ARM_LDR_PC_G2", /* name */
979 FALSE, /* partial_inplace */
980 0xffffffff, /* src_mask */
981 0xffffffff, /* dst_mask */
982 TRUE), /* pcrel_offset */
983
984 HOWTO (R_ARM_LDRS_PC_G0, /* type */
985 0, /* rightshift */
986 2, /* size (0 = byte, 1 = short, 2 = long) */
987 32, /* bitsize */
988 TRUE, /* pc_relative */
989 0, /* bitpos */
990 complain_overflow_dont,/* complain_on_overflow */
991 bfd_elf_generic_reloc, /* special_function */
992 "R_ARM_LDRS_PC_G0", /* name */
993 FALSE, /* partial_inplace */
994 0xffffffff, /* src_mask */
995 0xffffffff, /* dst_mask */
996 TRUE), /* pcrel_offset */
997
998 HOWTO (R_ARM_LDRS_PC_G1, /* type */
999 0, /* rightshift */
1000 2, /* size (0 = byte, 1 = short, 2 = long) */
1001 32, /* bitsize */
1002 TRUE, /* pc_relative */
1003 0, /* bitpos */
1004 complain_overflow_dont,/* complain_on_overflow */
1005 bfd_elf_generic_reloc, /* special_function */
1006 "R_ARM_LDRS_PC_G1", /* name */
1007 FALSE, /* partial_inplace */
1008 0xffffffff, /* src_mask */
1009 0xffffffff, /* dst_mask */
1010 TRUE), /* pcrel_offset */
1011
1012 HOWTO (R_ARM_LDRS_PC_G2, /* type */
1013 0, /* rightshift */
1014 2, /* size (0 = byte, 1 = short, 2 = long) */
1015 32, /* bitsize */
1016 TRUE, /* pc_relative */
1017 0, /* bitpos */
1018 complain_overflow_dont,/* complain_on_overflow */
1019 bfd_elf_generic_reloc, /* special_function */
1020 "R_ARM_LDRS_PC_G2", /* name */
1021 FALSE, /* partial_inplace */
1022 0xffffffff, /* src_mask */
1023 0xffffffff, /* dst_mask */
1024 TRUE), /* pcrel_offset */
1025
1026 HOWTO (R_ARM_LDC_PC_G0, /* type */
1027 0, /* rightshift */
1028 2, /* size (0 = byte, 1 = short, 2 = long) */
1029 32, /* bitsize */
1030 TRUE, /* pc_relative */
1031 0, /* bitpos */
1032 complain_overflow_dont,/* complain_on_overflow */
1033 bfd_elf_generic_reloc, /* special_function */
1034 "R_ARM_LDC_PC_G0", /* name */
1035 FALSE, /* partial_inplace */
1036 0xffffffff, /* src_mask */
1037 0xffffffff, /* dst_mask */
1038 TRUE), /* pcrel_offset */
1039
1040 HOWTO (R_ARM_LDC_PC_G1, /* type */
1041 0, /* rightshift */
1042 2, /* size (0 = byte, 1 = short, 2 = long) */
1043 32, /* bitsize */
1044 TRUE, /* pc_relative */
1045 0, /* bitpos */
1046 complain_overflow_dont,/* complain_on_overflow */
1047 bfd_elf_generic_reloc, /* special_function */
1048 "R_ARM_LDC_PC_G1", /* name */
1049 FALSE, /* partial_inplace */
1050 0xffffffff, /* src_mask */
1051 0xffffffff, /* dst_mask */
1052 TRUE), /* pcrel_offset */
1053
1054 HOWTO (R_ARM_LDC_PC_G2, /* type */
1055 0, /* rightshift */
1056 2, /* size (0 = byte, 1 = short, 2 = long) */
1057 32, /* bitsize */
1058 TRUE, /* pc_relative */
1059 0, /* bitpos */
1060 complain_overflow_dont,/* complain_on_overflow */
1061 bfd_elf_generic_reloc, /* special_function */
1062 "R_ARM_LDC_PC_G2", /* name */
1063 FALSE, /* partial_inplace */
1064 0xffffffff, /* src_mask */
1065 0xffffffff, /* dst_mask */
1066 TRUE), /* pcrel_offset */
1067
1068 HOWTO (R_ARM_ALU_SB_G0_NC, /* type */
1069 0, /* rightshift */
1070 2, /* size (0 = byte, 1 = short, 2 = long) */
1071 32, /* bitsize */
1072 TRUE, /* pc_relative */
1073 0, /* bitpos */
1074 complain_overflow_dont,/* complain_on_overflow */
1075 bfd_elf_generic_reloc, /* special_function */
1076 "R_ARM_ALU_SB_G0_NC", /* name */
1077 FALSE, /* partial_inplace */
1078 0xffffffff, /* src_mask */
1079 0xffffffff, /* dst_mask */
1080 TRUE), /* pcrel_offset */
1081
1082 HOWTO (R_ARM_ALU_SB_G0, /* type */
1083 0, /* rightshift */
1084 2, /* size (0 = byte, 1 = short, 2 = long) */
1085 32, /* bitsize */
1086 TRUE, /* pc_relative */
1087 0, /* bitpos */
1088 complain_overflow_dont,/* complain_on_overflow */
1089 bfd_elf_generic_reloc, /* special_function */
1090 "R_ARM_ALU_SB_G0", /* name */
1091 FALSE, /* partial_inplace */
1092 0xffffffff, /* src_mask */
1093 0xffffffff, /* dst_mask */
1094 TRUE), /* pcrel_offset */
1095
1096 HOWTO (R_ARM_ALU_SB_G1_NC, /* type */
1097 0, /* rightshift */
1098 2, /* size (0 = byte, 1 = short, 2 = long) */
1099 32, /* bitsize */
1100 TRUE, /* pc_relative */
1101 0, /* bitpos */
1102 complain_overflow_dont,/* complain_on_overflow */
1103 bfd_elf_generic_reloc, /* special_function */
1104 "R_ARM_ALU_SB_G1_NC", /* name */
1105 FALSE, /* partial_inplace */
1106 0xffffffff, /* src_mask */
1107 0xffffffff, /* dst_mask */
1108 TRUE), /* pcrel_offset */
1109
1110 HOWTO (R_ARM_ALU_SB_G1, /* type */
1111 0, /* rightshift */
1112 2, /* size (0 = byte, 1 = short, 2 = long) */
1113 32, /* bitsize */
1114 TRUE, /* pc_relative */
1115 0, /* bitpos */
1116 complain_overflow_dont,/* complain_on_overflow */
1117 bfd_elf_generic_reloc, /* special_function */
1118 "R_ARM_ALU_SB_G1", /* name */
1119 FALSE, /* partial_inplace */
1120 0xffffffff, /* src_mask */
1121 0xffffffff, /* dst_mask */
1122 TRUE), /* pcrel_offset */
1123
1124 HOWTO (R_ARM_ALU_SB_G2, /* type */
1125 0, /* rightshift */
1126 2, /* size (0 = byte, 1 = short, 2 = long) */
1127 32, /* bitsize */
1128 TRUE, /* pc_relative */
1129 0, /* bitpos */
1130 complain_overflow_dont,/* complain_on_overflow */
1131 bfd_elf_generic_reloc, /* special_function */
1132 "R_ARM_ALU_SB_G2", /* name */
1133 FALSE, /* partial_inplace */
1134 0xffffffff, /* src_mask */
1135 0xffffffff, /* dst_mask */
1136 TRUE), /* pcrel_offset */
1137
1138 HOWTO (R_ARM_LDR_SB_G0, /* type */
1139 0, /* rightshift */
1140 2, /* size (0 = byte, 1 = short, 2 = long) */
1141 32, /* bitsize */
1142 TRUE, /* pc_relative */
1143 0, /* bitpos */
1144 complain_overflow_dont,/* complain_on_overflow */
1145 bfd_elf_generic_reloc, /* special_function */
1146 "R_ARM_LDR_SB_G0", /* name */
1147 FALSE, /* partial_inplace */
1148 0xffffffff, /* src_mask */
1149 0xffffffff, /* dst_mask */
1150 TRUE), /* pcrel_offset */
1151
1152 HOWTO (R_ARM_LDR_SB_G1, /* type */
1153 0, /* rightshift */
1154 2, /* size (0 = byte, 1 = short, 2 = long) */
1155 32, /* bitsize */
1156 TRUE, /* pc_relative */
1157 0, /* bitpos */
1158 complain_overflow_dont,/* complain_on_overflow */
1159 bfd_elf_generic_reloc, /* special_function */
1160 "R_ARM_LDR_SB_G1", /* name */
1161 FALSE, /* partial_inplace */
1162 0xffffffff, /* src_mask */
1163 0xffffffff, /* dst_mask */
1164 TRUE), /* pcrel_offset */
1165
1166 HOWTO (R_ARM_LDR_SB_G2, /* type */
1167 0, /* rightshift */
1168 2, /* size (0 = byte, 1 = short, 2 = long) */
1169 32, /* bitsize */
1170 TRUE, /* pc_relative */
1171 0, /* bitpos */
1172 complain_overflow_dont,/* complain_on_overflow */
1173 bfd_elf_generic_reloc, /* special_function */
1174 "R_ARM_LDR_SB_G2", /* name */
1175 FALSE, /* partial_inplace */
1176 0xffffffff, /* src_mask */
1177 0xffffffff, /* dst_mask */
1178 TRUE), /* pcrel_offset */
1179
1180 HOWTO (R_ARM_LDRS_SB_G0, /* type */
1181 0, /* rightshift */
1182 2, /* size (0 = byte, 1 = short, 2 = long) */
1183 32, /* bitsize */
1184 TRUE, /* pc_relative */
1185 0, /* bitpos */
1186 complain_overflow_dont,/* complain_on_overflow */
1187 bfd_elf_generic_reloc, /* special_function */
1188 "R_ARM_LDRS_SB_G0", /* name */
1189 FALSE, /* partial_inplace */
1190 0xffffffff, /* src_mask */
1191 0xffffffff, /* dst_mask */
1192 TRUE), /* pcrel_offset */
1193
1194 HOWTO (R_ARM_LDRS_SB_G1, /* type */
1195 0, /* rightshift */
1196 2, /* size (0 = byte, 1 = short, 2 = long) */
1197 32, /* bitsize */
1198 TRUE, /* pc_relative */
1199 0, /* bitpos */
1200 complain_overflow_dont,/* complain_on_overflow */
1201 bfd_elf_generic_reloc, /* special_function */
1202 "R_ARM_LDRS_SB_G1", /* name */
1203 FALSE, /* partial_inplace */
1204 0xffffffff, /* src_mask */
1205 0xffffffff, /* dst_mask */
1206 TRUE), /* pcrel_offset */
1207
1208 HOWTO (R_ARM_LDRS_SB_G2, /* type */
1209 0, /* rightshift */
1210 2, /* size (0 = byte, 1 = short, 2 = long) */
1211 32, /* bitsize */
1212 TRUE, /* pc_relative */
1213 0, /* bitpos */
1214 complain_overflow_dont,/* complain_on_overflow */
1215 bfd_elf_generic_reloc, /* special_function */
1216 "R_ARM_LDRS_SB_G2", /* name */
1217 FALSE, /* partial_inplace */
1218 0xffffffff, /* src_mask */
1219 0xffffffff, /* dst_mask */
1220 TRUE), /* pcrel_offset */
1221
1222 HOWTO (R_ARM_LDC_SB_G0, /* type */
1223 0, /* rightshift */
1224 2, /* size (0 = byte, 1 = short, 2 = long) */
1225 32, /* bitsize */
1226 TRUE, /* pc_relative */
1227 0, /* bitpos */
1228 complain_overflow_dont,/* complain_on_overflow */
1229 bfd_elf_generic_reloc, /* special_function */
1230 "R_ARM_LDC_SB_G0", /* name */
1231 FALSE, /* partial_inplace */
1232 0xffffffff, /* src_mask */
1233 0xffffffff, /* dst_mask */
1234 TRUE), /* pcrel_offset */
1235
1236 HOWTO (R_ARM_LDC_SB_G1, /* type */
1237 0, /* rightshift */
1238 2, /* size (0 = byte, 1 = short, 2 = long) */
1239 32, /* bitsize */
1240 TRUE, /* pc_relative */
1241 0, /* bitpos */
1242 complain_overflow_dont,/* complain_on_overflow */
1243 bfd_elf_generic_reloc, /* special_function */
1244 "R_ARM_LDC_SB_G1", /* name */
1245 FALSE, /* partial_inplace */
1246 0xffffffff, /* src_mask */
1247 0xffffffff, /* dst_mask */
1248 TRUE), /* pcrel_offset */
1249
1250 HOWTO (R_ARM_LDC_SB_G2, /* type */
1251 0, /* rightshift */
1252 2, /* size (0 = byte, 1 = short, 2 = long) */
1253 32, /* bitsize */
1254 TRUE, /* pc_relative */
1255 0, /* bitpos */
1256 complain_overflow_dont,/* complain_on_overflow */
1257 bfd_elf_generic_reloc, /* special_function */
1258 "R_ARM_LDC_SB_G2", /* name */
1259 FALSE, /* partial_inplace */
1260 0xffffffff, /* src_mask */
1261 0xffffffff, /* dst_mask */
1262 TRUE), /* pcrel_offset */
1263
1264 /* End of group relocations. */
1265
1266 HOWTO (R_ARM_MOVW_BREL_NC, /* type */
1267 0, /* rightshift */
1268 2, /* size (0 = byte, 1 = short, 2 = long) */
1269 16, /* bitsize */
1270 FALSE, /* pc_relative */
1271 0, /* bitpos */
1272 complain_overflow_dont,/* complain_on_overflow */
1273 bfd_elf_generic_reloc, /* special_function */
1274 "R_ARM_MOVW_BREL_NC", /* name */
1275 FALSE, /* partial_inplace */
1276 0x0000ffff, /* src_mask */
1277 0x0000ffff, /* dst_mask */
1278 FALSE), /* pcrel_offset */
1279
1280 HOWTO (R_ARM_MOVT_BREL, /* type */
1281 0, /* rightshift */
1282 2, /* size (0 = byte, 1 = short, 2 = long) */
1283 16, /* bitsize */
1284 FALSE, /* pc_relative */
1285 0, /* bitpos */
1286 complain_overflow_bitfield,/* complain_on_overflow */
1287 bfd_elf_generic_reloc, /* special_function */
1288 "R_ARM_MOVT_BREL", /* name */
1289 FALSE, /* partial_inplace */
1290 0x0000ffff, /* src_mask */
1291 0x0000ffff, /* dst_mask */
1292 FALSE), /* pcrel_offset */
1293
1294 HOWTO (R_ARM_MOVW_BREL, /* type */
1295 0, /* rightshift */
1296 2, /* size (0 = byte, 1 = short, 2 = long) */
1297 16, /* bitsize */
1298 FALSE, /* pc_relative */
1299 0, /* bitpos */
1300 complain_overflow_dont,/* complain_on_overflow */
1301 bfd_elf_generic_reloc, /* special_function */
1302 "R_ARM_MOVW_BREL", /* name */
1303 FALSE, /* partial_inplace */
1304 0x0000ffff, /* src_mask */
1305 0x0000ffff, /* dst_mask */
1306 FALSE), /* pcrel_offset */
1307
1308 HOWTO (R_ARM_THM_MOVW_BREL_NC,/* type */
1309 0, /* rightshift */
1310 2, /* size (0 = byte, 1 = short, 2 = long) */
1311 16, /* bitsize */
1312 FALSE, /* pc_relative */
1313 0, /* bitpos */
1314 complain_overflow_dont,/* complain_on_overflow */
1315 bfd_elf_generic_reloc, /* special_function */
1316 "R_ARM_THM_MOVW_BREL_NC",/* name */
1317 FALSE, /* partial_inplace */
1318 0x040f70ff, /* src_mask */
1319 0x040f70ff, /* dst_mask */
1320 FALSE), /* pcrel_offset */
1321
1322 HOWTO (R_ARM_THM_MOVT_BREL, /* type */
1323 0, /* rightshift */
1324 2, /* size (0 = byte, 1 = short, 2 = long) */
1325 16, /* bitsize */
1326 FALSE, /* pc_relative */
1327 0, /* bitpos */
1328 complain_overflow_bitfield,/* complain_on_overflow */
1329 bfd_elf_generic_reloc, /* special_function */
1330 "R_ARM_THM_MOVT_BREL", /* name */
1331 FALSE, /* partial_inplace */
1332 0x040f70ff, /* src_mask */
1333 0x040f70ff, /* dst_mask */
1334 FALSE), /* pcrel_offset */
1335
1336 HOWTO (R_ARM_THM_MOVW_BREL, /* type */
1337 0, /* rightshift */
1338 2, /* size (0 = byte, 1 = short, 2 = long) */
1339 16, /* bitsize */
1340 FALSE, /* pc_relative */
1341 0, /* bitpos */
1342 complain_overflow_dont,/* complain_on_overflow */
1343 bfd_elf_generic_reloc, /* special_function */
1344 "R_ARM_THM_MOVW_BREL", /* name */
1345 FALSE, /* partial_inplace */
1346 0x040f70ff, /* src_mask */
1347 0x040f70ff, /* dst_mask */
1348 FALSE), /* pcrel_offset */
1349
1350 EMPTY_HOWTO (90), /* Unallocated. */
1351 EMPTY_HOWTO (91),
1352 EMPTY_HOWTO (92),
1353 EMPTY_HOWTO (93),
1354
1355 HOWTO (R_ARM_PLT32_ABS, /* type */
1356 0, /* rightshift */
1357 2, /* size (0 = byte, 1 = short, 2 = long) */
1358 32, /* bitsize */
1359 FALSE, /* pc_relative */
1360 0, /* bitpos */
1361 complain_overflow_dont,/* complain_on_overflow */
1362 bfd_elf_generic_reloc, /* special_function */
1363 "R_ARM_PLT32_ABS", /* name */
1364 FALSE, /* partial_inplace */
1365 0xffffffff, /* src_mask */
1366 0xffffffff, /* dst_mask */
1367 FALSE), /* pcrel_offset */
1368
1369 HOWTO (R_ARM_GOT_ABS, /* type */
1370 0, /* rightshift */
1371 2, /* size (0 = byte, 1 = short, 2 = long) */
1372 32, /* bitsize */
1373 FALSE, /* pc_relative */
1374 0, /* bitpos */
1375 complain_overflow_dont,/* complain_on_overflow */
1376 bfd_elf_generic_reloc, /* special_function */
1377 "R_ARM_GOT_ABS", /* name */
1378 FALSE, /* partial_inplace */
1379 0xffffffff, /* src_mask */
1380 0xffffffff, /* dst_mask */
1381 FALSE), /* pcrel_offset */
1382
1383 HOWTO (R_ARM_GOT_PREL, /* type */
1384 0, /* rightshift */
1385 2, /* size (0 = byte, 1 = short, 2 = long) */
1386 32, /* bitsize */
1387 TRUE, /* pc_relative */
1388 0, /* bitpos */
1389 complain_overflow_dont, /* complain_on_overflow */
1390 bfd_elf_generic_reloc, /* special_function */
1391 "R_ARM_GOT_PREL", /* name */
1392 FALSE, /* partial_inplace */
1393 0xffffffff, /* src_mask */
1394 0xffffffff, /* dst_mask */
1395 TRUE), /* pcrel_offset */
1396
1397 HOWTO (R_ARM_GOT_BREL12, /* type */
1398 0, /* rightshift */
1399 2, /* size (0 = byte, 1 = short, 2 = long) */
1400 12, /* bitsize */
1401 FALSE, /* pc_relative */
1402 0, /* bitpos */
1403 complain_overflow_bitfield,/* complain_on_overflow */
1404 bfd_elf_generic_reloc, /* special_function */
1405 "R_ARM_GOT_BREL12", /* name */
1406 FALSE, /* partial_inplace */
1407 0x00000fff, /* src_mask */
1408 0x00000fff, /* dst_mask */
1409 FALSE), /* pcrel_offset */
1410
1411 HOWTO (R_ARM_GOTOFF12, /* type */
1412 0, /* rightshift */
1413 2, /* size (0 = byte, 1 = short, 2 = long) */
1414 12, /* bitsize */
1415 FALSE, /* pc_relative */
1416 0, /* bitpos */
1417 complain_overflow_bitfield,/* complain_on_overflow */
1418 bfd_elf_generic_reloc, /* special_function */
1419 "R_ARM_GOTOFF12", /* name */
1420 FALSE, /* partial_inplace */
1421 0x00000fff, /* src_mask */
1422 0x00000fff, /* dst_mask */
1423 FALSE), /* pcrel_offset */
1424
1425 EMPTY_HOWTO (R_ARM_GOTRELAX), /* reserved for future GOT-load optimizations */
1426
1427 /* GNU extension to record C++ vtable member usage */
1428 HOWTO (R_ARM_GNU_VTENTRY, /* type */
1429 0, /* rightshift */
1430 2, /* size (0 = byte, 1 = short, 2 = long) */
1431 0, /* bitsize */
1432 FALSE, /* pc_relative */
1433 0, /* bitpos */
1434 complain_overflow_dont, /* complain_on_overflow */
1435 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
1436 "R_ARM_GNU_VTENTRY", /* name */
1437 FALSE, /* partial_inplace */
1438 0, /* src_mask */
1439 0, /* dst_mask */
1440 FALSE), /* pcrel_offset */
1441
1442 /* GNU extension to record C++ vtable hierarchy */
1443 HOWTO (R_ARM_GNU_VTINHERIT, /* type */
1444 0, /* rightshift */
1445 2, /* size (0 = byte, 1 = short, 2 = long) */
1446 0, /* bitsize */
1447 FALSE, /* pc_relative */
1448 0, /* bitpos */
1449 complain_overflow_dont, /* complain_on_overflow */
1450 NULL, /* special_function */
1451 "R_ARM_GNU_VTINHERIT", /* name */
1452 FALSE, /* partial_inplace */
1453 0, /* src_mask */
1454 0, /* dst_mask */
1455 FALSE), /* pcrel_offset */
1456
1457 HOWTO (R_ARM_THM_JUMP11, /* type */
1458 1, /* rightshift */
1459 1, /* size (0 = byte, 1 = short, 2 = long) */
1460 11, /* bitsize */
1461 TRUE, /* pc_relative */
1462 0, /* bitpos */
1463 complain_overflow_signed, /* complain_on_overflow */
1464 bfd_elf_generic_reloc, /* special_function */
1465 "R_ARM_THM_JUMP11", /* name */
1466 FALSE, /* partial_inplace */
1467 0x000007ff, /* src_mask */
1468 0x000007ff, /* dst_mask */
1469 TRUE), /* pcrel_offset */
1470
1471 HOWTO (R_ARM_THM_JUMP8, /* type */
1472 1, /* rightshift */
1473 1, /* size (0 = byte, 1 = short, 2 = long) */
1474 8, /* bitsize */
1475 TRUE, /* pc_relative */
1476 0, /* bitpos */
1477 complain_overflow_signed, /* complain_on_overflow */
1478 bfd_elf_generic_reloc, /* special_function */
1479 "R_ARM_THM_JUMP8", /* name */
1480 FALSE, /* partial_inplace */
1481 0x000000ff, /* src_mask */
1482 0x000000ff, /* dst_mask */
1483 TRUE), /* pcrel_offset */
1484
1485 /* TLS relocations */
1486 HOWTO (R_ARM_TLS_GD32, /* type */
1487 0, /* rightshift */
1488 2, /* size (0 = byte, 1 = short, 2 = long) */
1489 32, /* bitsize */
1490 FALSE, /* pc_relative */
1491 0, /* bitpos */
1492 complain_overflow_bitfield,/* complain_on_overflow */
1493 NULL, /* special_function */
1494 "R_ARM_TLS_GD32", /* name */
1495 TRUE, /* partial_inplace */
1496 0xffffffff, /* src_mask */
1497 0xffffffff, /* dst_mask */
1498 FALSE), /* pcrel_offset */
1499
1500 HOWTO (R_ARM_TLS_LDM32, /* type */
1501 0, /* rightshift */
1502 2, /* size (0 = byte, 1 = short, 2 = long) */
1503 32, /* bitsize */
1504 FALSE, /* pc_relative */
1505 0, /* bitpos */
1506 complain_overflow_bitfield,/* complain_on_overflow */
1507 bfd_elf_generic_reloc, /* special_function */
1508 "R_ARM_TLS_LDM32", /* name */
1509 TRUE, /* partial_inplace */
1510 0xffffffff, /* src_mask */
1511 0xffffffff, /* dst_mask */
1512 FALSE), /* pcrel_offset */
1513
1514 HOWTO (R_ARM_TLS_LDO32, /* type */
1515 0, /* rightshift */
1516 2, /* size (0 = byte, 1 = short, 2 = long) */
1517 32, /* bitsize */
1518 FALSE, /* pc_relative */
1519 0, /* bitpos */
1520 complain_overflow_bitfield,/* complain_on_overflow */
1521 bfd_elf_generic_reloc, /* special_function */
1522 "R_ARM_TLS_LDO32", /* name */
1523 TRUE, /* partial_inplace */
1524 0xffffffff, /* src_mask */
1525 0xffffffff, /* dst_mask */
1526 FALSE), /* pcrel_offset */
1527
1528 HOWTO (R_ARM_TLS_IE32, /* type */
1529 0, /* rightshift */
1530 2, /* size (0 = byte, 1 = short, 2 = long) */
1531 32, /* bitsize */
1532 FALSE, /* pc_relative */
1533 0, /* bitpos */
1534 complain_overflow_bitfield,/* complain_on_overflow */
1535 NULL, /* special_function */
1536 "R_ARM_TLS_IE32", /* name */
1537 TRUE, /* partial_inplace */
1538 0xffffffff, /* src_mask */
1539 0xffffffff, /* dst_mask */
1540 FALSE), /* pcrel_offset */
1541
1542 HOWTO (R_ARM_TLS_LE32, /* type */
1543 0, /* rightshift */
1544 2, /* size (0 = byte, 1 = short, 2 = long) */
1545 32, /* bitsize */
1546 FALSE, /* pc_relative */
1547 0, /* bitpos */
1548 complain_overflow_bitfield,/* complain_on_overflow */
1549 bfd_elf_generic_reloc, /* special_function */
1550 "R_ARM_TLS_LE32", /* name */
1551 TRUE, /* partial_inplace */
1552 0xffffffff, /* src_mask */
1553 0xffffffff, /* dst_mask */
1554 FALSE), /* pcrel_offset */
1555
1556 HOWTO (R_ARM_TLS_LDO12, /* type */
1557 0, /* rightshift */
1558 2, /* size (0 = byte, 1 = short, 2 = long) */
1559 12, /* bitsize */
1560 FALSE, /* pc_relative */
1561 0, /* bitpos */
1562 complain_overflow_bitfield,/* complain_on_overflow */
1563 bfd_elf_generic_reloc, /* special_function */
1564 "R_ARM_TLS_LDO12", /* name */
1565 FALSE, /* partial_inplace */
1566 0x00000fff, /* src_mask */
1567 0x00000fff, /* dst_mask */
1568 FALSE), /* pcrel_offset */
1569
1570 HOWTO (R_ARM_TLS_LE12, /* type */
1571 0, /* rightshift */
1572 2, /* size (0 = byte, 1 = short, 2 = long) */
1573 12, /* bitsize */
1574 FALSE, /* pc_relative */
1575 0, /* bitpos */
1576 complain_overflow_bitfield,/* complain_on_overflow */
1577 bfd_elf_generic_reloc, /* special_function */
1578 "R_ARM_TLS_LE12", /* name */
1579 FALSE, /* partial_inplace */
1580 0x00000fff, /* src_mask */
1581 0x00000fff, /* dst_mask */
1582 FALSE), /* pcrel_offset */
1583
1584 HOWTO (R_ARM_TLS_IE12GP, /* type */
1585 0, /* rightshift */
1586 2, /* size (0 = byte, 1 = short, 2 = long) */
1587 12, /* bitsize */
1588 FALSE, /* pc_relative */
1589 0, /* bitpos */
1590 complain_overflow_bitfield,/* complain_on_overflow */
1591 bfd_elf_generic_reloc, /* special_function */
1592 "R_ARM_TLS_IE12GP", /* name */
1593 FALSE, /* partial_inplace */
1594 0x00000fff, /* src_mask */
1595 0x00000fff, /* dst_mask */
1596 FALSE), /* pcrel_offset */
1597 };
1598
1599 /* 112-127 private relocations
1600 128 R_ARM_ME_TOO, obsolete
1601 129-255 unallocated in AAELF.
1602
1603 249-255 extended, currently unused, relocations: */
1604
1605 static reloc_howto_type elf32_arm_howto_table_2[4] =
1606 {
1607 HOWTO (R_ARM_RREL32, /* type */
1608 0, /* rightshift */
1609 0, /* size (0 = byte, 1 = short, 2 = long) */
1610 0, /* bitsize */
1611 FALSE, /* pc_relative */
1612 0, /* bitpos */
1613 complain_overflow_dont,/* complain_on_overflow */
1614 bfd_elf_generic_reloc, /* special_function */
1615 "R_ARM_RREL32", /* name */
1616 FALSE, /* partial_inplace */
1617 0, /* src_mask */
1618 0, /* dst_mask */
1619 FALSE), /* pcrel_offset */
1620
1621 HOWTO (R_ARM_RABS32, /* type */
1622 0, /* rightshift */
1623 0, /* size (0 = byte, 1 = short, 2 = long) */
1624 0, /* bitsize */
1625 FALSE, /* pc_relative */
1626 0, /* bitpos */
1627 complain_overflow_dont,/* complain_on_overflow */
1628 bfd_elf_generic_reloc, /* special_function */
1629 "R_ARM_RABS32", /* name */
1630 FALSE, /* partial_inplace */
1631 0, /* src_mask */
1632 0, /* dst_mask */
1633 FALSE), /* pcrel_offset */
1634
1635 HOWTO (R_ARM_RPC24, /* type */
1636 0, /* rightshift */
1637 0, /* size (0 = byte, 1 = short, 2 = long) */
1638 0, /* bitsize */
1639 FALSE, /* pc_relative */
1640 0, /* bitpos */
1641 complain_overflow_dont,/* complain_on_overflow */
1642 bfd_elf_generic_reloc, /* special_function */
1643 "R_ARM_RPC24", /* name */
1644 FALSE, /* partial_inplace */
1645 0, /* src_mask */
1646 0, /* dst_mask */
1647 FALSE), /* pcrel_offset */
1648
1649 HOWTO (R_ARM_RBASE, /* type */
1650 0, /* rightshift */
1651 0, /* size (0 = byte, 1 = short, 2 = long) */
1652 0, /* bitsize */
1653 FALSE, /* pc_relative */
1654 0, /* bitpos */
1655 complain_overflow_dont,/* complain_on_overflow */
1656 bfd_elf_generic_reloc, /* special_function */
1657 "R_ARM_RBASE", /* name */
1658 FALSE, /* partial_inplace */
1659 0, /* src_mask */
1660 0, /* dst_mask */
1661 FALSE) /* pcrel_offset */
1662 };
1663
1664 static reloc_howto_type *
1665 elf32_arm_howto_from_type (unsigned int r_type)
1666 {
1667 if (r_type < ARRAY_SIZE (elf32_arm_howto_table_1))
1668 return &elf32_arm_howto_table_1[r_type];
1669
1670 if (r_type >= R_ARM_RREL32
1671 && r_type < R_ARM_RREL32 + ARRAY_SIZE (elf32_arm_howto_table_2))
1672 return &elf32_arm_howto_table_2[r_type - R_ARM_RREL32];
1673
1674 return NULL;
1675 }
1676
1677 static void
1678 elf32_arm_info_to_howto (bfd * abfd ATTRIBUTE_UNUSED, arelent * bfd_reloc,
1679 Elf_Internal_Rela * elf_reloc)
1680 {
1681 unsigned int r_type;
1682
1683 r_type = ELF32_R_TYPE (elf_reloc->r_info);
1684 bfd_reloc->howto = elf32_arm_howto_from_type (r_type);
1685 }
1686
1687 struct elf32_arm_reloc_map
1688 {
1689 bfd_reloc_code_real_type bfd_reloc_val;
1690 unsigned char elf_reloc_val;
1691 };
1692
1693 /* All entries in this list must also be present in elf32_arm_howto_table. */
1694 static const struct elf32_arm_reloc_map elf32_arm_reloc_map[] =
1695 {
1696 {BFD_RELOC_NONE, R_ARM_NONE},
1697 {BFD_RELOC_ARM_PCREL_BRANCH, R_ARM_PC24},
1698 {BFD_RELOC_ARM_PCREL_CALL, R_ARM_CALL},
1699 {BFD_RELOC_ARM_PCREL_JUMP, R_ARM_JUMP24},
1700 {BFD_RELOC_ARM_PCREL_BLX, R_ARM_XPC25},
1701 {BFD_RELOC_THUMB_PCREL_BLX, R_ARM_THM_XPC22},
1702 {BFD_RELOC_32, R_ARM_ABS32},
1703 {BFD_RELOC_32_PCREL, R_ARM_REL32},
1704 {BFD_RELOC_8, R_ARM_ABS8},
1705 {BFD_RELOC_16, R_ARM_ABS16},
1706 {BFD_RELOC_ARM_OFFSET_IMM, R_ARM_ABS12},
1707 {BFD_RELOC_ARM_THUMB_OFFSET, R_ARM_THM_ABS5},
1708 {BFD_RELOC_THUMB_PCREL_BRANCH25, R_ARM_THM_JUMP24},
1709 {BFD_RELOC_THUMB_PCREL_BRANCH23, R_ARM_THM_CALL},
1710 {BFD_RELOC_THUMB_PCREL_BRANCH12, R_ARM_THM_JUMP11},
1711 {BFD_RELOC_THUMB_PCREL_BRANCH20, R_ARM_THM_JUMP19},
1712 {BFD_RELOC_THUMB_PCREL_BRANCH9, R_ARM_THM_JUMP8},
1713 {BFD_RELOC_THUMB_PCREL_BRANCH7, R_ARM_THM_JUMP6},
1714 {BFD_RELOC_ARM_GLOB_DAT, R_ARM_GLOB_DAT},
1715 {BFD_RELOC_ARM_JUMP_SLOT, R_ARM_JUMP_SLOT},
1716 {BFD_RELOC_ARM_RELATIVE, R_ARM_RELATIVE},
1717 {BFD_RELOC_ARM_GOTOFF, R_ARM_GOTOFF32},
1718 {BFD_RELOC_ARM_GOTPC, R_ARM_GOTPC},
1719 {BFD_RELOC_ARM_GOT32, R_ARM_GOT32},
1720 {BFD_RELOC_ARM_PLT32, R_ARM_PLT32},
1721 {BFD_RELOC_ARM_TARGET1, R_ARM_TARGET1},
1722 {BFD_RELOC_ARM_ROSEGREL32, R_ARM_ROSEGREL32},
1723 {BFD_RELOC_ARM_SBREL32, R_ARM_SBREL32},
1724 {BFD_RELOC_ARM_PREL31, R_ARM_PREL31},
1725 {BFD_RELOC_ARM_TARGET2, R_ARM_TARGET2},
1726 {BFD_RELOC_ARM_PLT32, R_ARM_PLT32},
1727 {BFD_RELOC_ARM_TLS_GD32, R_ARM_TLS_GD32},
1728 {BFD_RELOC_ARM_TLS_LDO32, R_ARM_TLS_LDO32},
1729 {BFD_RELOC_ARM_TLS_LDM32, R_ARM_TLS_LDM32},
1730 {BFD_RELOC_ARM_TLS_DTPMOD32, R_ARM_TLS_DTPMOD32},
1731 {BFD_RELOC_ARM_TLS_DTPOFF32, R_ARM_TLS_DTPOFF32},
1732 {BFD_RELOC_ARM_TLS_TPOFF32, R_ARM_TLS_TPOFF32},
1733 {BFD_RELOC_ARM_TLS_IE32, R_ARM_TLS_IE32},
1734 {BFD_RELOC_ARM_TLS_LE32, R_ARM_TLS_LE32},
1735 {BFD_RELOC_VTABLE_INHERIT, R_ARM_GNU_VTINHERIT},
1736 {BFD_RELOC_VTABLE_ENTRY, R_ARM_GNU_VTENTRY},
1737 {BFD_RELOC_ARM_MOVW, R_ARM_MOVW_ABS_NC},
1738 {BFD_RELOC_ARM_MOVT, R_ARM_MOVT_ABS},
1739 {BFD_RELOC_ARM_MOVW_PCREL, R_ARM_MOVW_PREL_NC},
1740 {BFD_RELOC_ARM_MOVT_PCREL, R_ARM_MOVT_PREL},
1741 {BFD_RELOC_ARM_THUMB_MOVW, R_ARM_THM_MOVW_ABS_NC},
1742 {BFD_RELOC_ARM_THUMB_MOVT, R_ARM_THM_MOVT_ABS},
1743 {BFD_RELOC_ARM_THUMB_MOVW_PCREL, R_ARM_THM_MOVW_PREL_NC},
1744 {BFD_RELOC_ARM_THUMB_MOVT_PCREL, R_ARM_THM_MOVT_PREL},
1745 {BFD_RELOC_ARM_ALU_PC_G0_NC, R_ARM_ALU_PC_G0_NC},
1746 {BFD_RELOC_ARM_ALU_PC_G0, R_ARM_ALU_PC_G0},
1747 {BFD_RELOC_ARM_ALU_PC_G1_NC, R_ARM_ALU_PC_G1_NC},
1748 {BFD_RELOC_ARM_ALU_PC_G1, R_ARM_ALU_PC_G1},
1749 {BFD_RELOC_ARM_ALU_PC_G2, R_ARM_ALU_PC_G2},
1750 {BFD_RELOC_ARM_LDR_PC_G0, R_ARM_LDR_PC_G0},
1751 {BFD_RELOC_ARM_LDR_PC_G1, R_ARM_LDR_PC_G1},
1752 {BFD_RELOC_ARM_LDR_PC_G2, R_ARM_LDR_PC_G2},
1753 {BFD_RELOC_ARM_LDRS_PC_G0, R_ARM_LDRS_PC_G0},
1754 {BFD_RELOC_ARM_LDRS_PC_G1, R_ARM_LDRS_PC_G1},
1755 {BFD_RELOC_ARM_LDRS_PC_G2, R_ARM_LDRS_PC_G2},
1756 {BFD_RELOC_ARM_LDC_PC_G0, R_ARM_LDC_PC_G0},
1757 {BFD_RELOC_ARM_LDC_PC_G1, R_ARM_LDC_PC_G1},
1758 {BFD_RELOC_ARM_LDC_PC_G2, R_ARM_LDC_PC_G2},
1759 {BFD_RELOC_ARM_ALU_SB_G0_NC, R_ARM_ALU_SB_G0_NC},
1760 {BFD_RELOC_ARM_ALU_SB_G0, R_ARM_ALU_SB_G0},
1761 {BFD_RELOC_ARM_ALU_SB_G1_NC, R_ARM_ALU_SB_G1_NC},
1762 {BFD_RELOC_ARM_ALU_SB_G1, R_ARM_ALU_SB_G1},
1763 {BFD_RELOC_ARM_ALU_SB_G2, R_ARM_ALU_SB_G2},
1764 {BFD_RELOC_ARM_LDR_SB_G0, R_ARM_LDR_SB_G0},
1765 {BFD_RELOC_ARM_LDR_SB_G1, R_ARM_LDR_SB_G1},
1766 {BFD_RELOC_ARM_LDR_SB_G2, R_ARM_LDR_SB_G2},
1767 {BFD_RELOC_ARM_LDRS_SB_G0, R_ARM_LDRS_SB_G0},
1768 {BFD_RELOC_ARM_LDRS_SB_G1, R_ARM_LDRS_SB_G1},
1769 {BFD_RELOC_ARM_LDRS_SB_G2, R_ARM_LDRS_SB_G2},
1770 {BFD_RELOC_ARM_LDC_SB_G0, R_ARM_LDC_SB_G0},
1771 {BFD_RELOC_ARM_LDC_SB_G1, R_ARM_LDC_SB_G1},
1772 {BFD_RELOC_ARM_LDC_SB_G2, R_ARM_LDC_SB_G2},
1773 {BFD_RELOC_ARM_V4BX, R_ARM_V4BX}
1774 };
1775
1776 static reloc_howto_type *
1777 elf32_arm_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1778 bfd_reloc_code_real_type code)
1779 {
1780 unsigned int i;
1781
1782 for (i = 0; i < ARRAY_SIZE (elf32_arm_reloc_map); i ++)
1783 if (elf32_arm_reloc_map[i].bfd_reloc_val == code)
1784 return elf32_arm_howto_from_type (elf32_arm_reloc_map[i].elf_reloc_val);
1785
1786 return NULL;
1787 }
1788
1789 static reloc_howto_type *
1790 elf32_arm_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1791 const char *r_name)
1792 {
1793 unsigned int i;
1794
1795 for (i = 0; i < ARRAY_SIZE (elf32_arm_howto_table_1); i++)
1796 if (elf32_arm_howto_table_1[i].name != NULL
1797 && strcasecmp (elf32_arm_howto_table_1[i].name, r_name) == 0)
1798 return &elf32_arm_howto_table_1[i];
1799
1800 for (i = 0; i < ARRAY_SIZE (elf32_arm_howto_table_2); i++)
1801 if (elf32_arm_howto_table_2[i].name != NULL
1802 && strcasecmp (elf32_arm_howto_table_2[i].name, r_name) == 0)
1803 return &elf32_arm_howto_table_2[i];
1804
1805 return NULL;
1806 }
1807
1808 /* Support for core dump NOTE sections. */
1809
1810 static bfd_boolean
1811 elf32_arm_nabi_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
1812 {
1813 int offset;
1814 size_t size;
1815
1816 switch (note->descsz)
1817 {
1818 default:
1819 return FALSE;
1820
1821 case 148: /* Linux/ARM 32-bit. */
1822 /* pr_cursig */
1823 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
1824
1825 /* pr_pid */
1826 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
1827
1828 /* pr_reg */
1829 offset = 72;
1830 size = 72;
1831
1832 break;
1833 }
1834
1835 /* Make a ".reg/999" section. */
1836 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
1837 size, note->descpos + offset);
1838 }
1839
1840 static bfd_boolean
1841 elf32_arm_nabi_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
1842 {
1843 switch (note->descsz)
1844 {
1845 default:
1846 return FALSE;
1847
1848 case 124: /* Linux/ARM elf_prpsinfo. */
1849 elf_tdata (abfd)->core_program
1850 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
1851 elf_tdata (abfd)->core_command
1852 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
1853 }
1854
1855 /* Note that for some reason, a spurious space is tacked
1856 onto the end of the args in some (at least one anyway)
1857 implementations, so strip it off if it exists. */
1858 {
1859 char *command = elf_tdata (abfd)->core_command;
1860 int n = strlen (command);
1861
1862 if (0 < n && command[n - 1] == ' ')
1863 command[n - 1] = '\0';
1864 }
1865
1866 return TRUE;
1867 }
1868
1869 #define TARGET_LITTLE_SYM bfd_elf32_littlearm_vec
1870 #define TARGET_LITTLE_NAME "elf32-littlearm"
1871 #define TARGET_BIG_SYM bfd_elf32_bigarm_vec
1872 #define TARGET_BIG_NAME "elf32-bigarm"
1873
1874 #define elf_backend_grok_prstatus elf32_arm_nabi_grok_prstatus
1875 #define elf_backend_grok_psinfo elf32_arm_nabi_grok_psinfo
1876
1877 typedef unsigned long int insn32;
1878 typedef unsigned short int insn16;
1879
1880 /* In lieu of proper flags, assume all EABIv4 or later objects are
1881 interworkable. */
1882 #define INTERWORK_FLAG(abfd) \
1883 (EF_ARM_EABI_VERSION (elf_elfheader (abfd)->e_flags) >= EF_ARM_EABI_VER4 \
1884 || (elf_elfheader (abfd)->e_flags & EF_ARM_INTERWORK))
1885
1886 /* The linker script knows the section names for placement.
1887 The entry_names are used to do simple name mangling on the stubs.
1888 Given a function name, and its type, the stub can be found. The
1889 name can be changed. The only requirement is the %s be present. */
1890 #define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t"
1891 #define THUMB2ARM_GLUE_ENTRY_NAME "__%s_from_thumb"
1892
1893 #define ARM2THUMB_GLUE_SECTION_NAME ".glue_7"
1894 #define ARM2THUMB_GLUE_ENTRY_NAME "__%s_from_arm"
1895
1896 #define VFP11_ERRATUM_VENEER_SECTION_NAME ".vfp11_veneer"
1897 #define VFP11_ERRATUM_VENEER_ENTRY_NAME "__vfp11_veneer_%x"
1898
1899 #define ARM_BX_GLUE_SECTION_NAME ".v4_bx"
1900 #define ARM_BX_GLUE_ENTRY_NAME "__bx_r%d"
1901
1902 #define STUB_ENTRY_NAME "__%s_veneer"
1903
1904 /* The name of the dynamic interpreter. This is put in the .interp
1905 section. */
1906 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
1907
1908 #ifdef FOUR_WORD_PLT
1909
1910 /* The first entry in a procedure linkage table looks like
1911 this. It is set up so that any shared library function that is
1912 called before the relocation has been set up calls the dynamic
1913 linker first. */
1914 static const bfd_vma elf32_arm_plt0_entry [] =
1915 {
1916 0xe52de004, /* str lr, [sp, #-4]! */
1917 0xe59fe010, /* ldr lr, [pc, #16] */
1918 0xe08fe00e, /* add lr, pc, lr */
1919 0xe5bef008, /* ldr pc, [lr, #8]! */
1920 };
1921
1922 /* Subsequent entries in a procedure linkage table look like
1923 this. */
1924 static const bfd_vma elf32_arm_plt_entry [] =
1925 {
1926 0xe28fc600, /* add ip, pc, #NN */
1927 0xe28cca00, /* add ip, ip, #NN */
1928 0xe5bcf000, /* ldr pc, [ip, #NN]! */
1929 0x00000000, /* unused */
1930 };
1931
1932 #else
1933
1934 /* The first entry in a procedure linkage table looks like
1935 this. It is set up so that any shared library function that is
1936 called before the relocation has been set up calls the dynamic
1937 linker first. */
1938 static const bfd_vma elf32_arm_plt0_entry [] =
1939 {
1940 0xe52de004, /* str lr, [sp, #-4]! */
1941 0xe59fe004, /* ldr lr, [pc, #4] */
1942 0xe08fe00e, /* add lr, pc, lr */
1943 0xe5bef008, /* ldr pc, [lr, #8]! */
1944 0x00000000, /* &GOT[0] - . */
1945 };
1946
1947 /* Subsequent entries in a procedure linkage table look like
1948 this. */
1949 static const bfd_vma elf32_arm_plt_entry [] =
1950 {
1951 0xe28fc600, /* add ip, pc, #0xNN00000 */
1952 0xe28cca00, /* add ip, ip, #0xNN000 */
1953 0xe5bcf000, /* ldr pc, [ip, #0xNNN]! */
1954 };
1955
1956 #endif
1957
1958 /* The format of the first entry in the procedure linkage table
1959 for a VxWorks executable. */
1960 static const bfd_vma elf32_arm_vxworks_exec_plt0_entry[] =
1961 {
1962 0xe52dc008, /* str ip,[sp,#-8]! */
1963 0xe59fc000, /* ldr ip,[pc] */
1964 0xe59cf008, /* ldr pc,[ip,#8] */
1965 0x00000000, /* .long _GLOBAL_OFFSET_TABLE_ */
1966 };
1967
1968 /* The format of subsequent entries in a VxWorks executable. */
1969 static const bfd_vma elf32_arm_vxworks_exec_plt_entry[] =
1970 {
1971 0xe59fc000, /* ldr ip,[pc] */
1972 0xe59cf000, /* ldr pc,[ip] */
1973 0x00000000, /* .long @got */
1974 0xe59fc000, /* ldr ip,[pc] */
1975 0xea000000, /* b _PLT */
1976 0x00000000, /* .long @pltindex*sizeof(Elf32_Rela) */
1977 };
1978
1979 /* The format of entries in a VxWorks shared library. */
1980 static const bfd_vma elf32_arm_vxworks_shared_plt_entry[] =
1981 {
1982 0xe59fc000, /* ldr ip,[pc] */
1983 0xe79cf009, /* ldr pc,[ip,r9] */
1984 0x00000000, /* .long @got */
1985 0xe59fc000, /* ldr ip,[pc] */
1986 0xe599f008, /* ldr pc,[r9,#8] */
1987 0x00000000, /* .long @pltindex*sizeof(Elf32_Rela) */
1988 };
1989
1990 /* An initial stub used if the PLT entry is referenced from Thumb code. */
1991 #define PLT_THUMB_STUB_SIZE 4
1992 static const bfd_vma elf32_arm_plt_thumb_stub [] =
1993 {
1994 0x4778, /* bx pc */
1995 0x46c0 /* nop */
1996 };
1997
1998 /* The entries in a PLT when using a DLL-based target with multiple
1999 address spaces. */
2000 static const bfd_vma elf32_arm_symbian_plt_entry [] =
2001 {
2002 0xe51ff004, /* ldr pc, [pc, #-4] */
2003 0x00000000, /* dcd R_ARM_GLOB_DAT(X) */
2004 };
2005
2006 #define ARM_MAX_FWD_BRANCH_OFFSET ((((1 << 23) - 1) << 2) + 8)
2007 #define ARM_MAX_BWD_BRANCH_OFFSET ((-((1 << 23) << 2)) + 8)
2008 #define THM_MAX_FWD_BRANCH_OFFSET ((1 << 22) -2 + 4)
2009 #define THM_MAX_BWD_BRANCH_OFFSET (-(1 << 22) + 4)
2010 #define THM2_MAX_FWD_BRANCH_OFFSET (((1 << 24) - 2) + 4)
2011 #define THM2_MAX_BWD_BRANCH_OFFSET (-(1 << 24) + 4)
2012
2013 /* Arm/Thumb -> Arm/Thumb long branch stub. On V5T and above, use blx
2014 to reach the stub if necessary. */
2015 static const bfd_vma elf32_arm_stub_long_branch_any_any[] =
2016 {
2017 0xe51ff004, /* ldr pc, [pc, #-4] */
2018 0x00000000, /* dcd R_ARM_ABS32(X) */
2019 };
2020
2021 /* V4T Arm -> Thumb long branch stub. Used on V4T where blx is not
2022 available. */
2023 static const bfd_vma elf32_arm_stub_long_branch_v4t_arm_thumb[] =
2024 {
2025 0xe59fc000, /* ldr ip, [pc, #0] */
2026 0xe12fff1c, /* bx ip */
2027 0x00000000, /* dcd R_ARM_ABS32(X) */
2028 };
2029
2030 /* Thumb -> Thumb long branch stub. Used on architectures which
2031 support only this mode, or on V4T where it is expensive to switch
2032 to ARM. */
2033 static const bfd_vma elf32_arm_stub_long_branch_thumb_only[] =
2034 {
2035 0x4802b401, /* push {r0} */
2036 /* ldr r0, [pc, #8] */
2037 0xbc014684, /* mov ip, r0 */
2038 /* pop {r0} */
2039 0xbf004760, /* bx ip */
2040 /* nop */
2041 0x00000000, /* dcd R_ARM_ABS32(X) */
2042 };
2043
2044 /* V4T Thumb -> ARM long branch stub. Used on V4T where blx is not
2045 available. */
2046 static const bfd_vma elf32_arm_stub_long_branch_v4t_thumb_arm[] =
2047 {
2048 0x46c04778, /* bx pc */
2049 /* nop */
2050 0xe51ff004, /* ldr pc, [pc, #-4] */
2051 0x00000000, /* dcd R_ARM_ABS32(X) */
2052 };
2053
2054 /* V4T Thumb -> ARM short branch stub. Shorter variant of the above
2055 one, when the destination is close enough. */
2056 static const bfd_vma elf32_arm_stub_short_branch_v4t_thumb_arm[] =
2057 {
2058 0x46c04778, /* bx pc */
2059 /* nop */
2060 0xea000000, /* b (X) */
2061 };
2062
2063 /* ARM/Thumb -> ARM/Thumb long branch stub, PIC. On V5T and above, use
2064 blx to reach the stub if necessary. */
2065 static const bfd_vma elf32_arm_stub_long_branch_any_any_pic[] =
2066 {
2067 0xe59fc000, /* ldr r12, [pc] */
2068 0xe08ff00c, /* add pc, pc, ip */
2069 0x00000000, /* dcd R_ARM_REL32(X-4) */
2070 };
2071
2072 /* Section name for stubs is the associated section name plus this
2073 string. */
2074 #define STUB_SUFFIX ".stub"
2075
2076 enum elf32_arm_stub_type
2077 {
2078 arm_stub_none,
2079 arm_stub_long_branch_any_any,
2080 arm_stub_long_branch_v4t_arm_thumb,
2081 arm_stub_long_branch_thumb_only,
2082 arm_stub_long_branch_v4t_thumb_arm,
2083 arm_stub_short_branch_v4t_thumb_arm,
2084 arm_stub_long_branch_any_any_pic,
2085 };
2086
2087 struct elf32_arm_stub_hash_entry
2088 {
2089 /* Base hash table entry structure. */
2090 struct bfd_hash_entry root;
2091
2092 /* The stub section. */
2093 asection *stub_sec;
2094
2095 /* Offset within stub_sec of the beginning of this stub. */
2096 bfd_vma stub_offset;
2097
2098 /* Given the symbol's value and its section we can determine its final
2099 value when building the stubs (so the stub knows where to jump). */
2100 bfd_vma target_value;
2101 asection *target_section;
2102
2103 enum elf32_arm_stub_type stub_type;
2104
2105 /* The symbol table entry, if any, that this was derived from. */
2106 struct elf32_arm_link_hash_entry *h;
2107
2108 /* Destination symbol type (STT_ARM_TFUNC, ...) */
2109 unsigned char st_type;
2110
2111 /* Where this stub is being called from, or, in the case of combined
2112 stub sections, the first input section in the group. */
2113 asection *id_sec;
2114
2115 /* The name for the local symbol at the start of this stub. The
2116 stub name in the hash table has to be unique; this does not, so
2117 it can be friendlier. */
2118 char *output_name;
2119 };
2120
2121 /* Used to build a map of a section. This is required for mixed-endian
2122 code/data. */
2123
2124 typedef struct elf32_elf_section_map
2125 {
2126 bfd_vma vma;
2127 char type;
2128 }
2129 elf32_arm_section_map;
2130
2131 /* Information about a VFP11 erratum veneer, or a branch to such a veneer. */
2132
2133 typedef enum
2134 {
2135 VFP11_ERRATUM_BRANCH_TO_ARM_VENEER,
2136 VFP11_ERRATUM_BRANCH_TO_THUMB_VENEER,
2137 VFP11_ERRATUM_ARM_VENEER,
2138 VFP11_ERRATUM_THUMB_VENEER
2139 }
2140 elf32_vfp11_erratum_type;
2141
2142 typedef struct elf32_vfp11_erratum_list
2143 {
2144 struct elf32_vfp11_erratum_list *next;
2145 bfd_vma vma;
2146 union
2147 {
2148 struct
2149 {
2150 struct elf32_vfp11_erratum_list *veneer;
2151 unsigned int vfp_insn;
2152 } b;
2153 struct
2154 {
2155 struct elf32_vfp11_erratum_list *branch;
2156 unsigned int id;
2157 } v;
2158 } u;
2159 elf32_vfp11_erratum_type type;
2160 }
2161 elf32_vfp11_erratum_list;
2162
2163 typedef struct _arm_elf_section_data
2164 {
2165 struct bfd_elf_section_data elf;
2166 unsigned int mapcount;
2167 unsigned int mapsize;
2168 elf32_arm_section_map *map;
2169 unsigned int erratumcount;
2170 elf32_vfp11_erratum_list *erratumlist;
2171 }
2172 _arm_elf_section_data;
2173
2174 #define elf32_arm_section_data(sec) \
2175 ((_arm_elf_section_data *) elf_section_data (sec))
2176
2177 /* The size of the thread control block. */
2178 #define TCB_SIZE 8
2179
2180 struct elf_arm_obj_tdata
2181 {
2182 struct elf_obj_tdata root;
2183
2184 /* tls_type for each local got entry. */
2185 char *local_got_tls_type;
2186
2187 /* Zero to warn when linking objects with incompatible enum sizes. */
2188 int no_enum_size_warning;
2189
2190 /* Zero to warn when linking objects with incompatible wchar_t sizes. */
2191 int no_wchar_size_warning;
2192 };
2193
2194 #define elf_arm_tdata(bfd) \
2195 ((struct elf_arm_obj_tdata *) (bfd)->tdata.any)
2196
2197 #define elf32_arm_local_got_tls_type(bfd) \
2198 (elf_arm_tdata (bfd)->local_got_tls_type)
2199
2200 #define is_arm_elf(bfd) \
2201 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2202 && elf_tdata (bfd) != NULL \
2203 && elf_object_id (bfd) == ARM_ELF_TDATA)
2204
2205 static bfd_boolean
2206 elf32_arm_mkobject (bfd *abfd)
2207 {
2208 return bfd_elf_allocate_object (abfd, sizeof (struct elf_arm_obj_tdata),
2209 ARM_ELF_TDATA);
2210 }
2211
2212 /* The ARM linker needs to keep track of the number of relocs that it
2213 decides to copy in check_relocs for each symbol. This is so that
2214 it can discard PC relative relocs if it doesn't need them when
2215 linking with -Bsymbolic. We store the information in a field
2216 extending the regular ELF linker hash table. */
2217
2218 /* This structure keeps track of the number of relocs we have copied
2219 for a given symbol. */
2220 struct elf32_arm_relocs_copied
2221 {
2222 /* Next section. */
2223 struct elf32_arm_relocs_copied * next;
2224 /* A section in dynobj. */
2225 asection * section;
2226 /* Number of relocs copied in this section. */
2227 bfd_size_type count;
2228 /* Number of PC-relative relocs copied in this section. */
2229 bfd_size_type pc_count;
2230 };
2231
2232 #define elf32_arm_hash_entry(ent) ((struct elf32_arm_link_hash_entry *)(ent))
2233
2234 /* Arm ELF linker hash entry. */
2235 struct elf32_arm_link_hash_entry
2236 {
2237 struct elf_link_hash_entry root;
2238
2239 /* Number of PC relative relocs copied for this symbol. */
2240 struct elf32_arm_relocs_copied * relocs_copied;
2241
2242 /* We reference count Thumb references to a PLT entry separately,
2243 so that we can emit the Thumb trampoline only if needed. */
2244 bfd_signed_vma plt_thumb_refcount;
2245
2246 /* Some references from Thumb code may be eliminated by BL->BLX
2247 conversion, so record them separately. */
2248 bfd_signed_vma plt_maybe_thumb_refcount;
2249
2250 /* Since PLT entries have variable size if the Thumb prologue is
2251 used, we need to record the index into .got.plt instead of
2252 recomputing it from the PLT offset. */
2253 bfd_signed_vma plt_got_offset;
2254
2255 #define GOT_UNKNOWN 0
2256 #define GOT_NORMAL 1
2257 #define GOT_TLS_GD 2
2258 #define GOT_TLS_IE 4
2259 unsigned char tls_type;
2260
2261 /* The symbol marking the real symbol location for exported thumb
2262 symbols with Arm stubs. */
2263 struct elf_link_hash_entry *export_glue;
2264
2265 /* A pointer to the most recently used stub hash entry against this
2266 symbol. */
2267 struct elf32_arm_stub_hash_entry *stub_cache;
2268 };
2269
2270 /* Traverse an arm ELF linker hash table. */
2271 #define elf32_arm_link_hash_traverse(table, func, info) \
2272 (elf_link_hash_traverse \
2273 (&(table)->root, \
2274 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
2275 (info)))
2276
2277 /* Get the ARM elf linker hash table from a link_info structure. */
2278 #define elf32_arm_hash_table(info) \
2279 ((struct elf32_arm_link_hash_table *) ((info)->hash))
2280
2281 #define arm_stub_hash_lookup(table, string, create, copy) \
2282 ((struct elf32_arm_stub_hash_entry *) \
2283 bfd_hash_lookup ((table), (string), (create), (copy)))
2284
2285 /* ARM ELF linker hash table. */
2286 struct elf32_arm_link_hash_table
2287 {
2288 /* The main hash table. */
2289 struct elf_link_hash_table root;
2290
2291 /* The size in bytes of the section containing the Thumb-to-ARM glue. */
2292 bfd_size_type thumb_glue_size;
2293
2294 /* The size in bytes of the section containing the ARM-to-Thumb glue. */
2295 bfd_size_type arm_glue_size;
2296
2297 /* The size in bytes of section containing the ARMv4 BX veneers. */
2298 bfd_size_type bx_glue_size;
2299
2300 /* Offsets of ARMv4 BX veneers. Bit1 set if present, and Bit0 set when
2301 veneer has been populated. */
2302 bfd_vma bx_glue_offset[15];
2303
2304 /* The size in bytes of the section containing glue for VFP11 erratum
2305 veneers. */
2306 bfd_size_type vfp11_erratum_glue_size;
2307
2308 /* An arbitrary input BFD chosen to hold the glue sections. */
2309 bfd * bfd_of_glue_owner;
2310
2311 /* Nonzero to output a BE8 image. */
2312 int byteswap_code;
2313
2314 /* Zero if R_ARM_TARGET1 means R_ARM_ABS32.
2315 Nonzero if R_ARM_TARGET1 means R_ARM_REL32. */
2316 int target1_is_rel;
2317
2318 /* The relocation to use for R_ARM_TARGET2 relocations. */
2319 int target2_reloc;
2320
2321 /* 0 = Ignore R_ARM_V4BX.
2322 1 = Convert BX to MOV PC.
2323 2 = Generate v4 interworing stubs. */
2324 int fix_v4bx;
2325
2326 /* Nonzero if the ARM/Thumb BLX instructions are available for use. */
2327 int use_blx;
2328
2329 /* What sort of code sequences we should look for which may trigger the
2330 VFP11 denorm erratum. */
2331 bfd_arm_vfp11_fix vfp11_fix;
2332
2333 /* Global counter for the number of fixes we have emitted. */
2334 int num_vfp11_fixes;
2335
2336 /* Nonzero to force PIC branch veneers. */
2337 int pic_veneer;
2338
2339 /* The number of bytes in the initial entry in the PLT. */
2340 bfd_size_type plt_header_size;
2341
2342 /* The number of bytes in the subsequent PLT etries. */
2343 bfd_size_type plt_entry_size;
2344
2345 /* True if the target system is VxWorks. */
2346 int vxworks_p;
2347
2348 /* True if the target system is Symbian OS. */
2349 int symbian_p;
2350
2351 /* True if the target uses REL relocations. */
2352 int use_rel;
2353
2354 /* Short-cuts to get to dynamic linker sections. */
2355 asection *sgot;
2356 asection *sgotplt;
2357 asection *srelgot;
2358 asection *splt;
2359 asection *srelplt;
2360 asection *sdynbss;
2361 asection *srelbss;
2362
2363 /* The (unloaded but important) VxWorks .rela.plt.unloaded section. */
2364 asection *srelplt2;
2365
2366 /* Data for R_ARM_TLS_LDM32 relocations. */
2367 union
2368 {
2369 bfd_signed_vma refcount;
2370 bfd_vma offset;
2371 } tls_ldm_got;
2372
2373 /* Small local sym to section mapping cache. */
2374 struct sym_sec_cache sym_sec;
2375
2376 /* For convenience in allocate_dynrelocs. */
2377 bfd * obfd;
2378
2379 /* The stub hash table. */
2380 struct bfd_hash_table stub_hash_table;
2381
2382 /* Linker stub bfd. */
2383 bfd *stub_bfd;
2384
2385 /* Linker call-backs. */
2386 asection * (*add_stub_section) (const char *, asection *);
2387 void (*layout_sections_again) (void);
2388
2389 /* Array to keep track of which stub sections have been created, and
2390 information on stub grouping. */
2391 struct map_stub
2392 {
2393 /* This is the section to which stubs in the group will be
2394 attached. */
2395 asection *link_sec;
2396 /* The stub section. */
2397 asection *stub_sec;
2398 } *stub_group;
2399
2400 /* Assorted information used by elf32_arm_size_stubs. */
2401 unsigned int bfd_count;
2402 int top_index;
2403 asection **input_list;
2404 };
2405
2406 /* Create an entry in an ARM ELF linker hash table. */
2407
2408 static struct bfd_hash_entry *
2409 elf32_arm_link_hash_newfunc (struct bfd_hash_entry * entry,
2410 struct bfd_hash_table * table,
2411 const char * string)
2412 {
2413 struct elf32_arm_link_hash_entry * ret =
2414 (struct elf32_arm_link_hash_entry *) entry;
2415
2416 /* Allocate the structure if it has not already been allocated by a
2417 subclass. */
2418 if (ret == NULL)
2419 ret = bfd_hash_allocate (table, sizeof (struct elf32_arm_link_hash_entry));
2420 if (ret == NULL)
2421 return (struct bfd_hash_entry *) ret;
2422
2423 /* Call the allocation method of the superclass. */
2424 ret = ((struct elf32_arm_link_hash_entry *)
2425 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
2426 table, string));
2427 if (ret != NULL)
2428 {
2429 ret->relocs_copied = NULL;
2430 ret->tls_type = GOT_UNKNOWN;
2431 ret->plt_thumb_refcount = 0;
2432 ret->plt_maybe_thumb_refcount = 0;
2433 ret->plt_got_offset = -1;
2434 ret->export_glue = NULL;
2435
2436 ret->stub_cache = NULL;
2437 }
2438
2439 return (struct bfd_hash_entry *) ret;
2440 }
2441
2442 /* Initialize an entry in the stub hash table. */
2443
2444 static struct bfd_hash_entry *
2445 stub_hash_newfunc (struct bfd_hash_entry *entry,
2446 struct bfd_hash_table *table,
2447 const char *string)
2448 {
2449 /* Allocate the structure if it has not already been allocated by a
2450 subclass. */
2451 if (entry == NULL)
2452 {
2453 entry = bfd_hash_allocate (table,
2454 sizeof (struct elf32_arm_stub_hash_entry));
2455 if (entry == NULL)
2456 return entry;
2457 }
2458
2459 /* Call the allocation method of the superclass. */
2460 entry = bfd_hash_newfunc (entry, table, string);
2461 if (entry != NULL)
2462 {
2463 struct elf32_arm_stub_hash_entry *eh;
2464
2465 /* Initialize the local fields. */
2466 eh = (struct elf32_arm_stub_hash_entry *) entry;
2467 eh->stub_sec = NULL;
2468 eh->stub_offset = 0;
2469 eh->target_value = 0;
2470 eh->target_section = NULL;
2471 eh->stub_type = arm_stub_none;
2472 eh->h = NULL;
2473 eh->id_sec = NULL;
2474 }
2475
2476 return entry;
2477 }
2478
2479 /* Create .got, .gotplt, and .rel(a).got sections in DYNOBJ, and set up
2480 shortcuts to them in our hash table. */
2481
2482 static bfd_boolean
2483 create_got_section (bfd *dynobj, struct bfd_link_info *info)
2484 {
2485 struct elf32_arm_link_hash_table *htab;
2486
2487 htab = elf32_arm_hash_table (info);
2488 /* BPABI objects never have a GOT, or associated sections. */
2489 if (htab->symbian_p)
2490 return TRUE;
2491
2492 if (! _bfd_elf_create_got_section (dynobj, info))
2493 return FALSE;
2494
2495 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
2496 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
2497 if (!htab->sgot || !htab->sgotplt)
2498 abort ();
2499
2500 htab->srelgot = bfd_make_section_with_flags (dynobj,
2501 RELOC_SECTION (htab, ".got"),
2502 (SEC_ALLOC | SEC_LOAD
2503 | SEC_HAS_CONTENTS
2504 | SEC_IN_MEMORY
2505 | SEC_LINKER_CREATED
2506 | SEC_READONLY));
2507 if (htab->srelgot == NULL
2508 || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
2509 return FALSE;
2510 return TRUE;
2511 }
2512
2513 /* Create .plt, .rel(a).plt, .got, .got.plt, .rel(a).got, .dynbss, and
2514 .rel(a).bss sections in DYNOBJ, and set up shortcuts to them in our
2515 hash table. */
2516
2517 static bfd_boolean
2518 elf32_arm_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
2519 {
2520 struct elf32_arm_link_hash_table *htab;
2521
2522 htab = elf32_arm_hash_table (info);
2523 if (!htab->sgot && !create_got_section (dynobj, info))
2524 return FALSE;
2525
2526 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
2527 return FALSE;
2528
2529 htab->splt = bfd_get_section_by_name (dynobj, ".plt");
2530 htab->srelplt = bfd_get_section_by_name (dynobj,
2531 RELOC_SECTION (htab, ".plt"));
2532 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
2533 if (!info->shared)
2534 htab->srelbss = bfd_get_section_by_name (dynobj,
2535 RELOC_SECTION (htab, ".bss"));
2536
2537 if (htab->vxworks_p)
2538 {
2539 if (!elf_vxworks_create_dynamic_sections (dynobj, info, &htab->srelplt2))
2540 return FALSE;
2541
2542 if (info->shared)
2543 {
2544 htab->plt_header_size = 0;
2545 htab->plt_entry_size
2546 = 4 * ARRAY_SIZE (elf32_arm_vxworks_shared_plt_entry);
2547 }
2548 else
2549 {
2550 htab->plt_header_size
2551 = 4 * ARRAY_SIZE (elf32_arm_vxworks_exec_plt0_entry);
2552 htab->plt_entry_size
2553 = 4 * ARRAY_SIZE (elf32_arm_vxworks_exec_plt_entry);
2554 }
2555 }
2556
2557 if (!htab->splt
2558 || !htab->srelplt
2559 || !htab->sdynbss
2560 || (!info->shared && !htab->srelbss))
2561 abort ();
2562
2563 return TRUE;
2564 }
2565
2566 /* Copy the extra info we tack onto an elf_link_hash_entry. */
2567
2568 static void
2569 elf32_arm_copy_indirect_symbol (struct bfd_link_info *info,
2570 struct elf_link_hash_entry *dir,
2571 struct elf_link_hash_entry *ind)
2572 {
2573 struct elf32_arm_link_hash_entry *edir, *eind;
2574
2575 edir = (struct elf32_arm_link_hash_entry *) dir;
2576 eind = (struct elf32_arm_link_hash_entry *) ind;
2577
2578 if (eind->relocs_copied != NULL)
2579 {
2580 if (edir->relocs_copied != NULL)
2581 {
2582 struct elf32_arm_relocs_copied **pp;
2583 struct elf32_arm_relocs_copied *p;
2584
2585 /* Add reloc counts against the indirect sym to the direct sym
2586 list. Merge any entries against the same section. */
2587 for (pp = &eind->relocs_copied; (p = *pp) != NULL; )
2588 {
2589 struct elf32_arm_relocs_copied *q;
2590
2591 for (q = edir->relocs_copied; q != NULL; q = q->next)
2592 if (q->section == p->section)
2593 {
2594 q->pc_count += p->pc_count;
2595 q->count += p->count;
2596 *pp = p->next;
2597 break;
2598 }
2599 if (q == NULL)
2600 pp = &p->next;
2601 }
2602 *pp = edir->relocs_copied;
2603 }
2604
2605 edir->relocs_copied = eind->relocs_copied;
2606 eind->relocs_copied = NULL;
2607 }
2608
2609 if (ind->root.type == bfd_link_hash_indirect)
2610 {
2611 /* Copy over PLT info. */
2612 edir->plt_thumb_refcount += eind->plt_thumb_refcount;
2613 eind->plt_thumb_refcount = 0;
2614 edir->plt_maybe_thumb_refcount += eind->plt_maybe_thumb_refcount;
2615 eind->plt_maybe_thumb_refcount = 0;
2616
2617 if (dir->got.refcount <= 0)
2618 {
2619 edir->tls_type = eind->tls_type;
2620 eind->tls_type = GOT_UNKNOWN;
2621 }
2622 }
2623
2624 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
2625 }
2626
2627 /* Create an ARM elf linker hash table. */
2628
2629 static struct bfd_link_hash_table *
2630 elf32_arm_link_hash_table_create (bfd *abfd)
2631 {
2632 struct elf32_arm_link_hash_table *ret;
2633 bfd_size_type amt = sizeof (struct elf32_arm_link_hash_table);
2634
2635 ret = bfd_malloc (amt);
2636 if (ret == NULL)
2637 return NULL;
2638
2639 if (!_bfd_elf_link_hash_table_init (& ret->root, abfd,
2640 elf32_arm_link_hash_newfunc,
2641 sizeof (struct elf32_arm_link_hash_entry)))
2642 {
2643 free (ret);
2644 return NULL;
2645 }
2646
2647 ret->sgot = NULL;
2648 ret->sgotplt = NULL;
2649 ret->srelgot = NULL;
2650 ret->splt = NULL;
2651 ret->srelplt = NULL;
2652 ret->sdynbss = NULL;
2653 ret->srelbss = NULL;
2654 ret->srelplt2 = NULL;
2655 ret->thumb_glue_size = 0;
2656 ret->arm_glue_size = 0;
2657 ret->bx_glue_size = 0;
2658 memset (ret->bx_glue_offset, 0, sizeof (ret->bx_glue_offset));
2659 ret->vfp11_fix = BFD_ARM_VFP11_FIX_NONE;
2660 ret->vfp11_erratum_glue_size = 0;
2661 ret->num_vfp11_fixes = 0;
2662 ret->bfd_of_glue_owner = NULL;
2663 ret->byteswap_code = 0;
2664 ret->target1_is_rel = 0;
2665 ret->target2_reloc = R_ARM_NONE;
2666 #ifdef FOUR_WORD_PLT
2667 ret->plt_header_size = 16;
2668 ret->plt_entry_size = 16;
2669 #else
2670 ret->plt_header_size = 20;
2671 ret->plt_entry_size = 12;
2672 #endif
2673 ret->fix_v4bx = 0;
2674 ret->use_blx = 0;
2675 ret->vxworks_p = 0;
2676 ret->symbian_p = 0;
2677 ret->use_rel = 1;
2678 ret->sym_sec.abfd = NULL;
2679 ret->obfd = abfd;
2680 ret->tls_ldm_got.refcount = 0;
2681 ret->stub_bfd = NULL;
2682 ret->add_stub_section = NULL;
2683 ret->layout_sections_again = NULL;
2684 ret->stub_group = NULL;
2685 ret->bfd_count = 0;
2686 ret->top_index = 0;
2687 ret->input_list = NULL;
2688
2689 if (!bfd_hash_table_init (&ret->stub_hash_table, stub_hash_newfunc,
2690 sizeof (struct elf32_arm_stub_hash_entry)))
2691 {
2692 free (ret);
2693 return NULL;
2694 }
2695
2696 return &ret->root.root;
2697 }
2698
2699 /* Free the derived linker hash table. */
2700
2701 static void
2702 elf32_arm_hash_table_free (struct bfd_link_hash_table *hash)
2703 {
2704 struct elf32_arm_link_hash_table *ret
2705 = (struct elf32_arm_link_hash_table *) hash;
2706
2707 bfd_hash_table_free (&ret->stub_hash_table);
2708 _bfd_generic_link_hash_table_free (hash);
2709 }
2710
2711 /* Determine if we're dealing with a Thumb only architecture. */
2712
2713 static bfd_boolean
2714 using_thumb_only (struct elf32_arm_link_hash_table *globals)
2715 {
2716 int arch = bfd_elf_get_obj_attr_int (globals->obfd, OBJ_ATTR_PROC,
2717 Tag_CPU_arch);
2718 int profile;
2719
2720 if (arch != TAG_CPU_ARCH_V7)
2721 return FALSE;
2722
2723 profile = bfd_elf_get_obj_attr_int (globals->obfd, OBJ_ATTR_PROC,
2724 Tag_CPU_arch_profile);
2725
2726 return profile == 'M';
2727 }
2728
2729 /* Determine if we're dealing with a Thumb-2 object. */
2730
2731 static bfd_boolean
2732 using_thumb2 (struct elf32_arm_link_hash_table *globals)
2733 {
2734 int arch = bfd_elf_get_obj_attr_int (globals->obfd, OBJ_ATTR_PROC,
2735 Tag_CPU_arch);
2736 return arch == TAG_CPU_ARCH_V6T2 || arch >= TAG_CPU_ARCH_V7;
2737 }
2738
2739 static bfd_boolean
2740 arm_stub_is_thumb (enum elf32_arm_stub_type stub_type)
2741 {
2742 switch (stub_type)
2743 {
2744 case arm_stub_long_branch_thumb_only:
2745 case arm_stub_long_branch_v4t_thumb_arm:
2746 case arm_stub_short_branch_v4t_thumb_arm:
2747 return TRUE;
2748 case arm_stub_none:
2749 BFD_FAIL ();
2750 return FALSE;
2751 break;
2752 default:
2753 return FALSE;
2754 }
2755 }
2756
2757 /* Determine the type of stub needed, if any, for a call. */
2758
2759 static enum elf32_arm_stub_type
2760 arm_type_of_stub (struct bfd_link_info *info,
2761 asection *input_sec,
2762 const Elf_Internal_Rela *rel,
2763 unsigned char st_type,
2764 struct elf32_arm_link_hash_entry *hash,
2765 bfd_vma destination,
2766 asection *sym_sec,
2767 bfd *input_bfd,
2768 const char *name)
2769 {
2770 bfd_vma location;
2771 bfd_signed_vma branch_offset;
2772 unsigned int r_type;
2773 struct elf32_arm_link_hash_table * globals;
2774 int thumb2;
2775 int thumb_only;
2776 enum elf32_arm_stub_type stub_type = arm_stub_none;
2777
2778 /* We don't know the actual type of destination in case it is of
2779 type STT_SECTION: give up. */
2780 if (st_type == STT_SECTION)
2781 return stub_type;
2782
2783 globals = elf32_arm_hash_table (info);
2784
2785 thumb_only = using_thumb_only (globals);
2786
2787 thumb2 = using_thumb2 (globals);
2788
2789 /* Determine where the call point is. */
2790 location = (input_sec->output_offset
2791 + input_sec->output_section->vma
2792 + rel->r_offset);
2793
2794 branch_offset = (bfd_signed_vma)(destination - location);
2795
2796 r_type = ELF32_R_TYPE (rel->r_info);
2797
2798 /* If the call will go through a PLT entry then we do not need
2799 glue. */
2800 if (globals->splt != NULL && hash != NULL && hash->root.plt.offset != (bfd_vma) -1)
2801 return stub_type;
2802
2803 if (r_type == R_ARM_THM_CALL)
2804 {
2805 if ((!thumb2
2806 && (branch_offset > THM_MAX_FWD_BRANCH_OFFSET
2807 || (branch_offset < THM_MAX_BWD_BRANCH_OFFSET)))
2808 || (thumb2
2809 && (branch_offset > THM2_MAX_FWD_BRANCH_OFFSET
2810 || (branch_offset < THM2_MAX_BWD_BRANCH_OFFSET)))
2811 || ((st_type != STT_ARM_TFUNC) && !globals->use_blx))
2812 {
2813 if (st_type == STT_ARM_TFUNC)
2814 {
2815 /* Thumb to thumb. */
2816 if (!thumb_only)
2817 {
2818 stub_type = (info->shared | globals->pic_veneer)
2819 /* PIC stubs. */
2820 ? ((globals->use_blx)
2821 /* V5T and above. */
2822 ? arm_stub_long_branch_any_any_pic
2823 /* not yet supported on V4T. */
2824 : arm_stub_none)
2825
2826 /* non-PIC stubs. */
2827 : ((globals->use_blx)
2828 /* V5T and above. */
2829 ? arm_stub_long_branch_any_any
2830 /* V4T. */
2831 : arm_stub_long_branch_thumb_only);
2832 }
2833 else
2834 {
2835 stub_type = (info->shared | globals->pic_veneer)
2836 /* PIC stub not yet supported on V4T. */
2837 ? arm_stub_none
2838 /* non-PIC stub. */
2839 : arm_stub_long_branch_thumb_only;
2840 }
2841 }
2842 else
2843 {
2844 /* Thumb to arm. */
2845 if (sym_sec != NULL
2846 && sym_sec->owner != NULL
2847 && !INTERWORK_FLAG (sym_sec->owner))
2848 {
2849 (*_bfd_error_handler)
2850 (_("%B(%s): warning: interworking not enabled.\n"
2851 " first occurrence: %B: Thumb call to ARM"),
2852 sym_sec->owner, input_bfd, name);
2853 }
2854
2855 stub_type = (info->shared | globals->pic_veneer)
2856 /* PIC stubs. */
2857 ? ((globals->use_blx)
2858 /* V5T and above. */
2859 ? arm_stub_long_branch_any_any_pic
2860 /* not yet supported on V4T. */
2861 : arm_stub_none)
2862
2863 /* non-PIC stubs. */
2864 : ((globals->use_blx)
2865 /* V5T and above. */
2866 ? arm_stub_long_branch_any_any
2867 /* V4T. */
2868 : arm_stub_long_branch_v4t_thumb_arm);
2869
2870 /* Handle v4t short branches. */
2871 if ((stub_type == arm_stub_long_branch_v4t_thumb_arm)
2872 && (branch_offset <= THM_MAX_FWD_BRANCH_OFFSET)
2873 && (branch_offset >= THM_MAX_BWD_BRANCH_OFFSET))
2874 stub_type = arm_stub_short_branch_v4t_thumb_arm;
2875 }
2876 }
2877 }
2878 else if (r_type == R_ARM_CALL)
2879 {
2880 if (st_type == STT_ARM_TFUNC)
2881 {
2882 /* Arm to thumb. */
2883
2884 if (sym_sec != NULL
2885 && sym_sec->owner != NULL
2886 && !INTERWORK_FLAG (sym_sec->owner))
2887 {
2888 (*_bfd_error_handler)
2889 (_("%B(%s): warning: interworking not enabled.\n"
2890 " first occurrence: %B: ARM call to Thumb"),
2891 sym_sec->owner, input_bfd, name);
2892 }
2893
2894 /* We have an extra 2-bytes reach because of
2895 the mode change (bit 24 (H) of BLX encoding). */
2896 if (branch_offset > (ARM_MAX_FWD_BRANCH_OFFSET + 2)
2897 || (branch_offset < ARM_MAX_BWD_BRANCH_OFFSET)
2898 || !globals->use_blx)
2899 {
2900 stub_type = (info->shared | globals->pic_veneer)
2901 /* PIC stubs. */
2902 ? arm_stub_long_branch_any_any_pic
2903 /* non-PIC stubs. */
2904 : ((globals->use_blx)
2905 /* V5T and above. */
2906 ? arm_stub_long_branch_any_any
2907 /* V4T. */
2908 : arm_stub_long_branch_v4t_arm_thumb);
2909 }
2910 }
2911 else
2912 {
2913 /* Arm to arm. */
2914 if (branch_offset > ARM_MAX_FWD_BRANCH_OFFSET
2915 || (branch_offset < ARM_MAX_BWD_BRANCH_OFFSET))
2916 {
2917 stub_type = (info->shared | globals->pic_veneer)
2918 /* PIC stubs. */
2919 ? arm_stub_long_branch_any_any_pic
2920 /* non-PIC stubs. */
2921 : arm_stub_long_branch_any_any;
2922 }
2923 }
2924 }
2925
2926 return stub_type;
2927 }
2928
2929 /* Build a name for an entry in the stub hash table. */
2930
2931 static char *
2932 elf32_arm_stub_name (const asection *input_section,
2933 const asection *sym_sec,
2934 const struct elf32_arm_link_hash_entry *hash,
2935 const Elf_Internal_Rela *rel)
2936 {
2937 char *stub_name;
2938 bfd_size_type len;
2939
2940 if (hash)
2941 {
2942 len = 8 + 1 + strlen (hash->root.root.root.string) + 1 + 8 + 1;
2943 stub_name = bfd_malloc (len);
2944 if (stub_name != NULL)
2945 sprintf (stub_name, "%08x_%s+%x",
2946 input_section->id & 0xffffffff,
2947 hash->root.root.root.string,
2948 (int) rel->r_addend & 0xffffffff);
2949 }
2950 else
2951 {
2952 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
2953 stub_name = bfd_malloc (len);
2954 if (stub_name != NULL)
2955 sprintf (stub_name, "%08x_%x:%x+%x",
2956 input_section->id & 0xffffffff,
2957 sym_sec->id & 0xffffffff,
2958 (int) ELF32_R_SYM (rel->r_info) & 0xffffffff,
2959 (int) rel->r_addend & 0xffffffff);
2960 }
2961
2962 return stub_name;
2963 }
2964
2965 /* Look up an entry in the stub hash. Stub entries are cached because
2966 creating the stub name takes a bit of time. */
2967
2968 static struct elf32_arm_stub_hash_entry *
2969 elf32_arm_get_stub_entry (const asection *input_section,
2970 const asection *sym_sec,
2971 struct elf_link_hash_entry *hash,
2972 const Elf_Internal_Rela *rel,
2973 struct elf32_arm_link_hash_table *htab)
2974 {
2975 struct elf32_arm_stub_hash_entry *stub_entry;
2976 struct elf32_arm_link_hash_entry *h = (struct elf32_arm_link_hash_entry *) hash;
2977 const asection *id_sec;
2978
2979 if ((input_section->flags & SEC_CODE) == 0)
2980 return NULL;
2981
2982 /* If this input section is part of a group of sections sharing one
2983 stub section, then use the id of the first section in the group.
2984 Stub names need to include a section id, as there may well be
2985 more than one stub used to reach say, printf, and we need to
2986 distinguish between them. */
2987 id_sec = htab->stub_group[input_section->id].link_sec;
2988
2989 if (h != NULL && h->stub_cache != NULL
2990 && h->stub_cache->h == h
2991 && h->stub_cache->id_sec == id_sec)
2992 {
2993 stub_entry = h->stub_cache;
2994 }
2995 else
2996 {
2997 char *stub_name;
2998
2999 stub_name = elf32_arm_stub_name (id_sec, sym_sec, h, rel);
3000 if (stub_name == NULL)
3001 return NULL;
3002
3003 stub_entry = arm_stub_hash_lookup (&htab->stub_hash_table,
3004 stub_name, FALSE, FALSE);
3005 if (h != NULL)
3006 h->stub_cache = stub_entry;
3007
3008 free (stub_name);
3009 }
3010
3011 return stub_entry;
3012 }
3013
3014 /* Add a new stub entry to the stub hash. Not all fields of the new
3015 stub entry are initialised. */
3016
3017 static struct elf32_arm_stub_hash_entry *
3018 elf32_arm_add_stub (const char *stub_name,
3019 asection *section,
3020 struct elf32_arm_link_hash_table *htab)
3021 {
3022 asection *link_sec;
3023 asection *stub_sec;
3024 struct elf32_arm_stub_hash_entry *stub_entry;
3025
3026 link_sec = htab->stub_group[section->id].link_sec;
3027 stub_sec = htab->stub_group[section->id].stub_sec;
3028 if (stub_sec == NULL)
3029 {
3030 stub_sec = htab->stub_group[link_sec->id].stub_sec;
3031 if (stub_sec == NULL)
3032 {
3033 size_t namelen;
3034 bfd_size_type len;
3035 char *s_name;
3036
3037 namelen = strlen (link_sec->name);
3038 len = namelen + sizeof (STUB_SUFFIX);
3039 s_name = bfd_alloc (htab->stub_bfd, len);
3040 if (s_name == NULL)
3041 return NULL;
3042
3043 memcpy (s_name, link_sec->name, namelen);
3044 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
3045 stub_sec = (*htab->add_stub_section) (s_name, link_sec);
3046 if (stub_sec == NULL)
3047 return NULL;
3048 htab->stub_group[link_sec->id].stub_sec = stub_sec;
3049 }
3050 htab->stub_group[section->id].stub_sec = stub_sec;
3051 }
3052
3053 /* Enter this entry into the linker stub hash table. */
3054 stub_entry = arm_stub_hash_lookup (&htab->stub_hash_table, stub_name,
3055 TRUE, FALSE);
3056 if (stub_entry == NULL)
3057 {
3058 (*_bfd_error_handler) (_("%s: cannot create stub entry %s"),
3059 section->owner,
3060 stub_name);
3061 return NULL;
3062 }
3063
3064 stub_entry->stub_sec = stub_sec;
3065 stub_entry->stub_offset = 0;
3066 stub_entry->id_sec = link_sec;
3067
3068 return stub_entry;
3069 }
3070
3071 /* Store an Arm insn into an output section not processed by
3072 elf32_arm_write_section. */
3073
3074 static void
3075 put_arm_insn (struct elf32_arm_link_hash_table * htab,
3076 bfd * output_bfd, bfd_vma val, void * ptr)
3077 {
3078 if (htab->byteswap_code != bfd_little_endian (output_bfd))
3079 bfd_putl32 (val, ptr);
3080 else
3081 bfd_putb32 (val, ptr);
3082 }
3083
3084 /* Store a 16-bit Thumb insn into an output section not processed by
3085 elf32_arm_write_section. */
3086
3087 static void
3088 put_thumb_insn (struct elf32_arm_link_hash_table * htab,
3089 bfd * output_bfd, bfd_vma val, void * ptr)
3090 {
3091 if (htab->byteswap_code != bfd_little_endian (output_bfd))
3092 bfd_putl16 (val, ptr);
3093 else
3094 bfd_putb16 (val, ptr);
3095 }
3096
3097 static bfd_boolean
3098 arm_build_one_stub (struct bfd_hash_entry *gen_entry,
3099 void * in_arg)
3100 {
3101 struct elf32_arm_stub_hash_entry *stub_entry;
3102 struct bfd_link_info *info;
3103 struct elf32_arm_link_hash_table *htab;
3104 asection *stub_sec;
3105 bfd *stub_bfd;
3106 bfd_vma stub_addr;
3107 bfd_byte *loc;
3108 bfd_vma sym_value;
3109 int template_size;
3110 int size;
3111 const bfd_vma *template;
3112 int i;
3113 struct elf32_arm_link_hash_table * globals;
3114
3115 /* Massage our args to the form they really have. */
3116 stub_entry = (struct elf32_arm_stub_hash_entry *) gen_entry;
3117 info = (struct bfd_link_info *) in_arg;
3118
3119 globals = elf32_arm_hash_table (info);
3120
3121 htab = elf32_arm_hash_table (info);
3122 stub_sec = stub_entry->stub_sec;
3123
3124 /* Make a note of the offset within the stubs for this entry. */
3125 stub_entry->stub_offset = stub_sec->size;
3126 loc = stub_sec->contents + stub_entry->stub_offset;
3127
3128 stub_bfd = stub_sec->owner;
3129
3130 /* This is the address of the start of the stub. */
3131 stub_addr = stub_sec->output_section->vma + stub_sec->output_offset
3132 + stub_entry->stub_offset;
3133
3134 /* This is the address of the stub destination. */
3135 sym_value = (stub_entry->target_value
3136 + stub_entry->target_section->output_offset
3137 + stub_entry->target_section->output_section->vma);
3138
3139 switch (stub_entry->stub_type)
3140 {
3141 case arm_stub_long_branch_any_any:
3142 template = elf32_arm_stub_long_branch_any_any;
3143 template_size = (sizeof (elf32_arm_stub_long_branch_any_any) / sizeof (bfd_vma)) * 4;
3144 break;
3145 case arm_stub_long_branch_v4t_arm_thumb:
3146 template = elf32_arm_stub_long_branch_v4t_arm_thumb;
3147 template_size = (sizeof (elf32_arm_stub_long_branch_v4t_arm_thumb) / sizeof (bfd_vma)) * 4;
3148 break;
3149 case arm_stub_long_branch_thumb_only:
3150 template = elf32_arm_stub_long_branch_thumb_only;
3151 template_size = (sizeof (elf32_arm_stub_long_branch_thumb_only) / sizeof (bfd_vma)) * 4;
3152 break;
3153 case arm_stub_long_branch_v4t_thumb_arm:
3154 template = elf32_arm_stub_long_branch_v4t_thumb_arm;
3155 template_size = (sizeof (elf32_arm_stub_long_branch_v4t_thumb_arm) / sizeof (bfd_vma)) * 4;
3156 break;
3157 case arm_stub_short_branch_v4t_thumb_arm:
3158 template = elf32_arm_stub_short_branch_v4t_thumb_arm;
3159 template_size = (sizeof(elf32_arm_stub_short_branch_v4t_thumb_arm) / sizeof (bfd_vma)) * 4;
3160 break;
3161 case arm_stub_long_branch_any_any_pic:
3162 template = elf32_arm_stub_long_branch_any_any_pic;
3163 template_size = (sizeof (elf32_arm_stub_long_branch_any_any_pic) / sizeof (bfd_vma)) * 4;
3164 break;
3165 default:
3166 BFD_FAIL ();
3167 return FALSE;
3168 }
3169
3170 size = 0;
3171 for (i = 0; i < (template_size / 4); i++)
3172 {
3173 /* A 0 pattern is a placeholder, every other pattern is an
3174 instruction. */
3175 if (template[i] != 0)
3176 put_arm_insn (globals, stub_bfd, template[i], loc + size);
3177 else
3178 bfd_put_32 (stub_bfd, template[i], loc + size);
3179
3180 size += 4;
3181 }
3182 stub_sec->size += size;
3183
3184 /* Destination is Thumb. Force bit 0 to 1 to reflect this. */
3185 if (stub_entry->st_type == STT_ARM_TFUNC)
3186 sym_value |= 1;
3187
3188 switch (stub_entry->stub_type)
3189 {
3190 case arm_stub_long_branch_any_any:
3191 _bfd_final_link_relocate (elf32_arm_howto_from_type (R_ARM_ABS32),
3192 stub_bfd, stub_sec, stub_sec->contents,
3193 stub_entry->stub_offset + 4, sym_value, 0);
3194 break;
3195 case arm_stub_long_branch_v4t_arm_thumb:
3196 _bfd_final_link_relocate (elf32_arm_howto_from_type (R_ARM_ABS32),
3197 stub_bfd, stub_sec, stub_sec->contents,
3198 stub_entry->stub_offset + 8, sym_value, 0);
3199 break;
3200 case arm_stub_long_branch_thumb_only:
3201 _bfd_final_link_relocate (elf32_arm_howto_from_type (R_ARM_ABS32),
3202 stub_bfd, stub_sec, stub_sec->contents,
3203 stub_entry->stub_offset + 12, sym_value, 0);
3204 break;
3205 case arm_stub_long_branch_v4t_thumb_arm:
3206 _bfd_final_link_relocate (elf32_arm_howto_from_type (R_ARM_ABS32),
3207 stub_bfd, stub_sec, stub_sec->contents,
3208 stub_entry->stub_offset + 8, sym_value, 0);
3209 break;
3210 case arm_stub_short_branch_v4t_thumb_arm:
3211 {
3212 long int rel_offset;
3213 static const insn32 t2a3_b_insn = 0xea000000;
3214
3215 rel_offset = sym_value - (stub_addr + 8 + 4);
3216
3217 put_arm_insn (globals, stub_bfd,
3218 (bfd_vma) t2a3_b_insn | ((rel_offset >> 2) & 0x00FFFFFF),
3219 loc + 4);
3220 }
3221 break;
3222
3223 case arm_stub_long_branch_any_any_pic:
3224 /* We want the value relative to the address 8 bytes from the
3225 start of the stub. */
3226 _bfd_final_link_relocate (elf32_arm_howto_from_type (R_ARM_REL32),
3227 stub_bfd, stub_sec, stub_sec->contents,
3228 stub_entry->stub_offset + 8, sym_value, -4);
3229 break;
3230 default:
3231 BFD_FAIL();
3232 break;
3233 }
3234
3235 return TRUE;
3236 }
3237
3238 /* As above, but don't actually build the stub. Just bump offset so
3239 we know stub section sizes. */
3240
3241 static bfd_boolean
3242 arm_size_one_stub (struct bfd_hash_entry *gen_entry,
3243 void * in_arg)
3244 {
3245 struct elf32_arm_stub_hash_entry *stub_entry;
3246 struct elf32_arm_link_hash_table *htab;
3247 const bfd_vma *template;
3248 int template_size;
3249 int size;
3250 int i;
3251
3252 /* Massage our args to the form they really have. */
3253 stub_entry = (struct elf32_arm_stub_hash_entry *) gen_entry;
3254 htab = (struct elf32_arm_link_hash_table *) in_arg;
3255
3256 switch (stub_entry->stub_type)
3257 {
3258 case arm_stub_long_branch_any_any:
3259 template = elf32_arm_stub_long_branch_any_any;
3260 template_size = (sizeof (elf32_arm_stub_long_branch_any_any) / sizeof (bfd_vma)) * 4;
3261 break;
3262 case arm_stub_long_branch_v4t_arm_thumb:
3263 template = elf32_arm_stub_long_branch_v4t_arm_thumb;
3264 template_size = (sizeof (elf32_arm_stub_long_branch_v4t_arm_thumb) / sizeof (bfd_vma)) * 4;
3265 break;
3266 case arm_stub_long_branch_thumb_only:
3267 template = elf32_arm_stub_long_branch_thumb_only;
3268 template_size = (sizeof (elf32_arm_stub_long_branch_thumb_only) / sizeof (bfd_vma)) * 4;
3269 break;
3270 case arm_stub_long_branch_v4t_thumb_arm:
3271 template = elf32_arm_stub_long_branch_v4t_thumb_arm;
3272 template_size = (sizeof (elf32_arm_stub_long_branch_v4t_thumb_arm) / sizeof (bfd_vma)) * 4;
3273 break;
3274 case arm_stub_short_branch_v4t_thumb_arm:
3275 template = elf32_arm_stub_short_branch_v4t_thumb_arm;
3276 template_size = (sizeof(elf32_arm_stub_short_branch_v4t_thumb_arm) / sizeof (bfd_vma)) * 4;
3277 break;
3278 case arm_stub_long_branch_any_any_pic:
3279 template = elf32_arm_stub_long_branch_any_any_pic;
3280 template_size = (sizeof (elf32_arm_stub_long_branch_any_any_pic) / sizeof (bfd_vma)) * 4;
3281 break;
3282 default:
3283 BFD_FAIL ();
3284 return FALSE;
3285 break;
3286 }
3287
3288 size = 0;
3289 for (i = 0; i < (template_size / 4); i++)
3290 size += 4;
3291 size = (size + 7) & ~7;
3292 stub_entry->stub_sec->size += size;
3293 return TRUE;
3294 }
3295
3296 /* External entry points for sizing and building linker stubs. */
3297
3298 /* Set up various things so that we can make a list of input sections
3299 for each output section included in the link. Returns -1 on error,
3300 0 when no stubs will be needed, and 1 on success. */
3301
3302 int
3303 elf32_arm_setup_section_lists (bfd *output_bfd,
3304 struct bfd_link_info *info)
3305 {
3306 bfd *input_bfd;
3307 unsigned int bfd_count;
3308 int top_id, top_index;
3309 asection *section;
3310 asection **input_list, **list;
3311 bfd_size_type amt;
3312 struct elf32_arm_link_hash_table *htab = elf32_arm_hash_table (info);
3313
3314 if (! is_elf_hash_table (htab))
3315 return 0;
3316
3317 /* Count the number of input BFDs and find the top input section id. */
3318 for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
3319 input_bfd != NULL;
3320 input_bfd = input_bfd->link_next)
3321 {
3322 bfd_count += 1;
3323 for (section = input_bfd->sections;
3324 section != NULL;
3325 section = section->next)
3326 {
3327 if (top_id < section->id)
3328 top_id = section->id;
3329 }
3330 }
3331 htab->bfd_count = bfd_count;
3332
3333 amt = sizeof (struct map_stub) * (top_id + 1);
3334 htab->stub_group = bfd_zmalloc (amt);
3335 if (htab->stub_group == NULL)
3336 return -1;
3337
3338 /* We can't use output_bfd->section_count here to find the top output
3339 section index as some sections may have been removed, and
3340 _bfd_strip_section_from_output doesn't renumber the indices. */
3341 for (section = output_bfd->sections, top_index = 0;
3342 section != NULL;
3343 section = section->next)
3344 {
3345 if (top_index < section->index)
3346 top_index = section->index;
3347 }
3348
3349 htab->top_index = top_index;
3350 amt = sizeof (asection *) * (top_index + 1);
3351 input_list = bfd_malloc (amt);
3352 htab->input_list = input_list;
3353 if (input_list == NULL)
3354 return -1;
3355
3356 /* For sections we aren't interested in, mark their entries with a
3357 value we can check later. */
3358 list = input_list + top_index;
3359 do
3360 *list = bfd_abs_section_ptr;
3361 while (list-- != input_list);
3362
3363 for (section = output_bfd->sections;
3364 section != NULL;
3365 section = section->next)
3366 {
3367 if ((section->flags & SEC_CODE) != 0)
3368 input_list[section->index] = NULL;
3369 }
3370
3371 return 1;
3372 }
3373
3374 /* The linker repeatedly calls this function for each input section,
3375 in the order that input sections are linked into output sections.
3376 Build lists of input sections to determine groupings between which
3377 we may insert linker stubs. */
3378
3379 void
3380 elf32_arm_next_input_section (struct bfd_link_info *info,
3381 asection *isec)
3382 {
3383 struct elf32_arm_link_hash_table *htab = elf32_arm_hash_table (info);
3384
3385 if (isec->output_section->index <= htab->top_index)
3386 {
3387 asection **list = htab->input_list + isec->output_section->index;
3388
3389 if (*list != bfd_abs_section_ptr)
3390 {
3391 /* Steal the link_sec pointer for our list. */
3392 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
3393 /* This happens to make the list in reverse order,
3394 which is what we want. */
3395 PREV_SEC (isec) = *list;
3396 *list = isec;
3397 }
3398 }
3399 }
3400
3401 /* See whether we can group stub sections together. Grouping stub
3402 sections may result in fewer stubs. More importantly, we need to
3403 put all .init* and .fini* stubs at the beginning of the .init or
3404 .fini output sections respectively, because glibc splits the
3405 _init and _fini functions into multiple parts. Putting a stub in
3406 the middle of a function is not a good idea. */
3407
3408 static void
3409 group_sections (struct elf32_arm_link_hash_table *htab,
3410 bfd_size_type stub_group_size,
3411 bfd_boolean stubs_always_before_branch)
3412 {
3413 asection **list = htab->input_list + htab->top_index;
3414
3415 do
3416 {
3417 asection *tail = *list;
3418
3419 if (tail == bfd_abs_section_ptr)
3420 continue;
3421
3422 while (tail != NULL)
3423 {
3424 asection *curr;
3425 asection *prev;
3426 bfd_size_type total;
3427
3428 curr = tail;
3429 total = tail->size;
3430 while ((prev = PREV_SEC (curr)) != NULL
3431 && ((total += curr->output_offset - prev->output_offset)
3432 < stub_group_size))
3433 curr = prev;
3434
3435 /* OK, the size from the start of CURR to the end is less
3436 than stub_group_size and thus can be handled by one stub
3437 section. (Or the tail section is itself larger than
3438 stub_group_size, in which case we may be toast.)
3439 We should really be keeping track of the total size of
3440 stubs added here, as stubs contribute to the final output
3441 section size. */
3442 do
3443 {
3444 prev = PREV_SEC (tail);
3445 /* Set up this stub group. */
3446 htab->stub_group[tail->id].link_sec = curr;
3447 }
3448 while (tail != curr && (tail = prev) != NULL);
3449
3450 /* But wait, there's more! Input sections up to stub_group_size
3451 bytes before the stub section can be handled by it too. */
3452 if (!stubs_always_before_branch)
3453 {
3454 total = 0;
3455 while (prev != NULL
3456 && ((total += tail->output_offset - prev->output_offset)
3457 < stub_group_size))
3458 {
3459 tail = prev;
3460 prev = PREV_SEC (tail);
3461 htab->stub_group[tail->id].link_sec = curr;
3462 }
3463 }
3464 tail = prev;
3465 }
3466 }
3467 while (list-- != htab->input_list);
3468
3469 free (htab->input_list);
3470 #undef PREV_SEC
3471 }
3472
3473 /* Determine and set the size of the stub section for a final link.
3474
3475 The basic idea here is to examine all the relocations looking for
3476 PC-relative calls to a target that is unreachable with a "bl"
3477 instruction. */
3478
3479 bfd_boolean
3480 elf32_arm_size_stubs (bfd *output_bfd,
3481 bfd *stub_bfd,
3482 struct bfd_link_info *info,
3483 bfd_signed_vma group_size,
3484 asection * (*add_stub_section) (const char *, asection *),
3485 void (*layout_sections_again) (void))
3486 {
3487 bfd_size_type stub_group_size;
3488 bfd_boolean stubs_always_before_branch;
3489 bfd_boolean stub_changed = 0;
3490 struct elf32_arm_link_hash_table *htab = elf32_arm_hash_table (info);
3491
3492 /* Propagate mach to stub bfd, because it may not have been
3493 finalized when we created stub_bfd. */
3494 bfd_set_arch_mach (stub_bfd, bfd_get_arch (output_bfd),
3495 bfd_get_mach (output_bfd));
3496
3497 /* Stash our params away. */
3498 htab->stub_bfd = stub_bfd;
3499 htab->add_stub_section = add_stub_section;
3500 htab->layout_sections_again = layout_sections_again;
3501 stubs_always_before_branch = group_size < 0;
3502 if (group_size < 0)
3503 stub_group_size = -group_size;
3504 else
3505 stub_group_size = group_size;
3506
3507 if (stub_group_size == 1)
3508 {
3509 /* Default values. */
3510 /* Thumb branch range is +-4MB has to be used as the default
3511 maximum size (a given section can contain both ARM and Thumb
3512 code, so the worst case has to be taken into account).
3513
3514 This value is 24K less than that, which allows for 2025
3515 12-byte stubs. If we exceed that, then we will fail to link.
3516 The user will have to relink with an explicit group size
3517 option. */
3518 stub_group_size = 4170000;
3519 }
3520
3521 group_sections (htab, stub_group_size, stubs_always_before_branch);
3522
3523 while (1)
3524 {
3525 bfd *input_bfd;
3526 unsigned int bfd_indx;
3527 asection *stub_sec;
3528
3529 for (input_bfd = info->input_bfds, bfd_indx = 0;
3530 input_bfd != NULL;
3531 input_bfd = input_bfd->link_next, bfd_indx++)
3532 {
3533 Elf_Internal_Shdr *symtab_hdr;
3534 asection *section;
3535 Elf_Internal_Sym *local_syms = NULL;
3536
3537 /* We'll need the symbol table in a second. */
3538 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3539 if (symtab_hdr->sh_info == 0)
3540 continue;
3541
3542 /* Walk over each section attached to the input bfd. */
3543 for (section = input_bfd->sections;
3544 section != NULL;
3545 section = section->next)
3546 {
3547 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
3548
3549 /* If there aren't any relocs, then there's nothing more
3550 to do. */
3551 if ((section->flags & SEC_RELOC) == 0
3552 || section->reloc_count == 0
3553 || (section->flags & SEC_CODE) == 0)
3554 continue;
3555
3556 /* If this section is a link-once section that will be
3557 discarded, then don't create any stubs. */
3558 if (section->output_section == NULL
3559 || section->output_section->owner != output_bfd)
3560 continue;
3561
3562 /* Get the relocs. */
3563 internal_relocs
3564 = _bfd_elf_link_read_relocs (input_bfd, section, NULL,
3565 NULL, info->keep_memory);
3566 if (internal_relocs == NULL)
3567 goto error_ret_free_local;
3568
3569 /* Now examine each relocation. */
3570 irela = internal_relocs;
3571 irelaend = irela + section->reloc_count;
3572 for (; irela < irelaend; irela++)
3573 {
3574 unsigned int r_type, r_indx;
3575 enum elf32_arm_stub_type stub_type;
3576 struct elf32_arm_stub_hash_entry *stub_entry;
3577 asection *sym_sec;
3578 bfd_vma sym_value;
3579 bfd_vma destination;
3580 struct elf32_arm_link_hash_entry *hash;
3581 const char *sym_name;
3582 char *stub_name;
3583 const asection *id_sec;
3584 unsigned char st_type;
3585
3586 r_type = ELF32_R_TYPE (irela->r_info);
3587 r_indx = ELF32_R_SYM (irela->r_info);
3588
3589 if (r_type >= (unsigned int) R_ARM_max)
3590 {
3591 bfd_set_error (bfd_error_bad_value);
3592 error_ret_free_internal:
3593 if (elf_section_data (section)->relocs == NULL)
3594 free (internal_relocs);
3595 goto error_ret_free_local;
3596 }
3597
3598 /* Only look for stubs on call instructions. */
3599 if ((r_type != (unsigned int) R_ARM_CALL)
3600 && (r_type != (unsigned int) R_ARM_THM_CALL))
3601 continue;
3602
3603 /* Now determine the call target, its name, value,
3604 section. */
3605 sym_sec = NULL;
3606 sym_value = 0;
3607 destination = 0;
3608 hash = NULL;
3609 sym_name = NULL;
3610 if (r_indx < symtab_hdr->sh_info)
3611 {
3612 /* It's a local symbol. */
3613 Elf_Internal_Sym *sym;
3614 Elf_Internal_Shdr *hdr;
3615
3616 if (local_syms == NULL)
3617 {
3618 local_syms
3619 = (Elf_Internal_Sym *) symtab_hdr->contents;
3620 if (local_syms == NULL)
3621 local_syms
3622 = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
3623 symtab_hdr->sh_info, 0,
3624 NULL, NULL, NULL);
3625 if (local_syms == NULL)
3626 goto error_ret_free_internal;
3627 }
3628
3629 sym = local_syms + r_indx;
3630 hdr = elf_elfsections (input_bfd)[sym->st_shndx];
3631 sym_sec = hdr->bfd_section;
3632 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
3633 sym_value = sym->st_value;
3634 destination = (sym_value + irela->r_addend
3635 + sym_sec->output_offset
3636 + sym_sec->output_section->vma);
3637 st_type = ELF_ST_TYPE (sym->st_info);
3638 sym_name
3639 = bfd_elf_string_from_elf_section (input_bfd,
3640 symtab_hdr->sh_link,
3641 sym->st_name);
3642 }
3643 else
3644 {
3645 /* It's an external symbol. */
3646 int e_indx;
3647
3648 e_indx = r_indx - symtab_hdr->sh_info;
3649 hash = ((struct elf32_arm_link_hash_entry *)
3650 elf_sym_hashes (input_bfd)[e_indx]);
3651
3652 while (hash->root.root.type == bfd_link_hash_indirect
3653 || hash->root.root.type == bfd_link_hash_warning)
3654 hash = ((struct elf32_arm_link_hash_entry *)
3655 hash->root.root.u.i.link);
3656
3657 if (hash->root.root.type == bfd_link_hash_defined
3658 || hash->root.root.type == bfd_link_hash_defweak)
3659 {
3660 sym_sec = hash->root.root.u.def.section;
3661 sym_value = hash->root.root.u.def.value;
3662 if (sym_sec->output_section != NULL)
3663 destination = (sym_value + irela->r_addend
3664 + sym_sec->output_offset
3665 + sym_sec->output_section->vma);
3666 }
3667 else if (hash->root.root.type == bfd_link_hash_undefweak
3668 || hash->root.root.type == bfd_link_hash_undefined)
3669 /* For a shared library, these will need a PLT stub,
3670 which is treated separately.
3671 For absolute code, they cannot be handled. */
3672 continue;
3673 else
3674 {
3675 bfd_set_error (bfd_error_bad_value);
3676 goto error_ret_free_internal;
3677 }
3678 st_type = ELF_ST_TYPE (hash->root.type);
3679 sym_name = hash->root.root.root.string;
3680 }
3681
3682 /* Determine what (if any) linker stub is needed. */
3683 stub_type = arm_type_of_stub (info, section, irela, st_type,
3684 hash, destination, sym_sec,
3685 input_bfd, sym_name);
3686 if (stub_type == arm_stub_none)
3687 continue;
3688
3689 /* Support for grouping stub sections. */
3690 id_sec = htab->stub_group[section->id].link_sec;
3691
3692 /* Get the name of this stub. */
3693 stub_name = elf32_arm_stub_name (id_sec, sym_sec, hash, irela);
3694 if (!stub_name)
3695 goto error_ret_free_internal;
3696
3697 stub_entry = arm_stub_hash_lookup (&htab->stub_hash_table,
3698 stub_name,
3699 FALSE, FALSE);
3700 if (stub_entry != NULL)
3701 {
3702 /* The proper stub has already been created. */
3703 free (stub_name);
3704 continue;
3705 }
3706
3707 stub_entry = elf32_arm_add_stub (stub_name, section, htab);
3708 if (stub_entry == NULL)
3709 {
3710 free (stub_name);
3711 goto error_ret_free_internal;
3712 }
3713
3714 stub_entry->target_value = sym_value;
3715 stub_entry->target_section = sym_sec;
3716 stub_entry->stub_type = stub_type;
3717 stub_entry->h = hash;
3718 stub_entry->st_type = st_type;
3719
3720 if (sym_name == NULL)
3721 sym_name = "unnamed";
3722 stub_entry->output_name
3723 = bfd_alloc (htab->stub_bfd,
3724 sizeof (THUMB2ARM_GLUE_ENTRY_NAME)
3725 + strlen (sym_name));
3726 if (stub_entry->output_name == NULL)
3727 {
3728 free (stub_name);
3729 goto error_ret_free_internal;
3730 }
3731
3732 /* For historical reasons, use the existing names for
3733 ARM-to-Thumb and Thumb-to-ARM stubs. */
3734 if (r_type == (unsigned int) R_ARM_THM_CALL
3735 && st_type != STT_ARM_TFUNC)
3736 sprintf (stub_entry->output_name, THUMB2ARM_GLUE_ENTRY_NAME,
3737 sym_name);
3738 else if (r_type == (unsigned int) R_ARM_CALL
3739 && st_type == STT_ARM_TFUNC)
3740 sprintf (stub_entry->output_name, ARM2THUMB_GLUE_ENTRY_NAME,
3741 sym_name);
3742 else
3743 sprintf (stub_entry->output_name, STUB_ENTRY_NAME,
3744 sym_name);
3745
3746 stub_changed = TRUE;
3747 }
3748
3749 /* We're done with the internal relocs, free them. */
3750 if (elf_section_data (section)->relocs == NULL)
3751 free (internal_relocs);
3752 }
3753 }
3754
3755 if (!stub_changed)
3756 break;
3757
3758 /* OK, we've added some stubs. Find out the new size of the
3759 stub sections. */
3760 for (stub_sec = htab->stub_bfd->sections;
3761 stub_sec != NULL;
3762 stub_sec = stub_sec->next)
3763 stub_sec->size = 0;
3764
3765 bfd_hash_traverse (&htab->stub_hash_table, arm_size_one_stub, htab);
3766
3767 /* Ask the linker to do its stuff. */
3768 (*htab->layout_sections_again) ();
3769 stub_changed = FALSE;
3770 }
3771
3772 return TRUE;
3773
3774 error_ret_free_local:
3775 return FALSE;
3776 }
3777
3778 /* Build all the stubs associated with the current output file. The
3779 stubs are kept in a hash table attached to the main linker hash
3780 table. We also set up the .plt entries for statically linked PIC
3781 functions here. This function is called via arm_elf_finish in the
3782 linker. */
3783
3784 bfd_boolean
3785 elf32_arm_build_stubs (struct bfd_link_info *info)
3786 {
3787 asection *stub_sec;
3788 struct bfd_hash_table *table;
3789 struct elf32_arm_link_hash_table *htab;
3790
3791 htab = elf32_arm_hash_table (info);
3792
3793 for (stub_sec = htab->stub_bfd->sections;
3794 stub_sec != NULL;
3795 stub_sec = stub_sec->next)
3796 {
3797 bfd_size_type size;
3798
3799 /* Ignore non-stub sections. */
3800 if (!strstr (stub_sec->name, STUB_SUFFIX))
3801 continue;
3802
3803 /* Allocate memory to hold the linker stubs. */
3804 size = stub_sec->size;
3805 stub_sec->contents = bfd_zalloc (htab->stub_bfd, size);
3806 if (stub_sec->contents == NULL && size != 0)
3807 return FALSE;
3808 stub_sec->size = 0;
3809 }
3810
3811 /* Build the stubs as directed by the stub hash table. */
3812 table = &htab->stub_hash_table;
3813 bfd_hash_traverse (table, arm_build_one_stub, info);
3814
3815 return TRUE;
3816 }
3817
3818 /* Locate the Thumb encoded calling stub for NAME. */
3819
3820 static struct elf_link_hash_entry *
3821 find_thumb_glue (struct bfd_link_info *link_info,
3822 const char *name,
3823 char **error_message)
3824 {
3825 char *tmp_name;
3826 struct elf_link_hash_entry *hash;
3827 struct elf32_arm_link_hash_table *hash_table;
3828
3829 /* We need a pointer to the armelf specific hash table. */
3830 hash_table = elf32_arm_hash_table (link_info);
3831
3832 tmp_name = bfd_malloc ((bfd_size_type) strlen (name)
3833 + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1);
3834
3835 BFD_ASSERT (tmp_name);
3836
3837 sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
3838
3839 hash = elf_link_hash_lookup
3840 (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
3841
3842 if (hash == NULL
3843 && asprintf (error_message, _("unable to find THUMB glue '%s' for '%s'"),
3844 tmp_name, name) == -1)
3845 *error_message = (char *) bfd_errmsg (bfd_error_system_call);
3846
3847 free (tmp_name);
3848
3849 return hash;
3850 }
3851
3852 /* Locate the ARM encoded calling stub for NAME. */
3853
3854 static struct elf_link_hash_entry *
3855 find_arm_glue (struct bfd_link_info *link_info,
3856 const char *name,
3857 char **error_message)
3858 {
3859 char *tmp_name;
3860 struct elf_link_hash_entry *myh;
3861 struct elf32_arm_link_hash_table *hash_table;
3862
3863 /* We need a pointer to the elfarm specific hash table. */
3864 hash_table = elf32_arm_hash_table (link_info);
3865
3866 tmp_name = bfd_malloc ((bfd_size_type) strlen (name)
3867 + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
3868
3869 BFD_ASSERT (tmp_name);
3870
3871 sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
3872
3873 myh = elf_link_hash_lookup
3874 (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
3875
3876 if (myh == NULL
3877 && asprintf (error_message, _("unable to find ARM glue '%s' for '%s'"),
3878 tmp_name, name) == -1)
3879 *error_message = (char *) bfd_errmsg (bfd_error_system_call);
3880
3881 free (tmp_name);
3882
3883 return myh;
3884 }
3885
3886 /* ARM->Thumb glue (static images):
3887
3888 .arm
3889 __func_from_arm:
3890 ldr r12, __func_addr
3891 bx r12
3892 __func_addr:
3893 .word func @ behave as if you saw a ARM_32 reloc.
3894
3895 (v5t static images)
3896 .arm
3897 __func_from_arm:
3898 ldr pc, __func_addr
3899 __func_addr:
3900 .word func @ behave as if you saw a ARM_32 reloc.
3901
3902 (relocatable images)
3903 .arm
3904 __func_from_arm:
3905 ldr r12, __func_offset
3906 add r12, r12, pc
3907 bx r12
3908 __func_offset:
3909 .word func - . */
3910
3911 #define ARM2THUMB_STATIC_GLUE_SIZE 12
3912 static const insn32 a2t1_ldr_insn = 0xe59fc000;
3913 static const insn32 a2t2_bx_r12_insn = 0xe12fff1c;
3914 static const insn32 a2t3_func_addr_insn = 0x00000001;
3915
3916 #define ARM2THUMB_V5_STATIC_GLUE_SIZE 8
3917 static const insn32 a2t1v5_ldr_insn = 0xe51ff004;
3918 static const insn32 a2t2v5_func_addr_insn = 0x00000001;
3919
3920 #define ARM2THUMB_PIC_GLUE_SIZE 16
3921 static const insn32 a2t1p_ldr_insn = 0xe59fc004;
3922 static const insn32 a2t2p_add_pc_insn = 0xe08cc00f;
3923 static const insn32 a2t3p_bx_r12_insn = 0xe12fff1c;
3924
3925 /* Thumb->ARM: Thumb->(non-interworking aware) ARM
3926
3927 .thumb .thumb
3928 .align 2 .align 2
3929 __func_from_thumb: __func_from_thumb:
3930 bx pc push {r6, lr}
3931 nop ldr r6, __func_addr
3932 .arm mov lr, pc
3933 b func bx r6
3934 .arm
3935 ;; back_to_thumb
3936 ldmia r13! {r6, lr}
3937 bx lr
3938 __func_addr:
3939 .word func */
3940
3941 #define THUMB2ARM_GLUE_SIZE 8
3942 static const insn16 t2a1_bx_pc_insn = 0x4778;
3943 static const insn16 t2a2_noop_insn = 0x46c0;
3944 static const insn32 t2a3_b_insn = 0xea000000;
3945
3946 #define VFP11_ERRATUM_VENEER_SIZE 8
3947
3948 #define ARM_BX_VENEER_SIZE 12
3949 static const insn32 armbx1_tst_insn = 0xe3100001;
3950 static const insn32 armbx2_moveq_insn = 0x01a0f000;
3951 static const insn32 armbx3_bx_insn = 0xe12fff10;
3952
3953 #ifndef ELFARM_NABI_C_INCLUDED
3954 static void
3955 arm_allocate_glue_section_space (bfd * abfd, bfd_size_type size, const char * name)
3956 {
3957 asection * s;
3958 bfd_byte * contents;
3959
3960 if (size == 0)
3961 return;
3962
3963 BFD_ASSERT (abfd != NULL);
3964
3965 s = bfd_get_section_by_name (abfd, name);
3966 BFD_ASSERT (s != NULL);
3967
3968 contents = bfd_alloc (abfd, size);
3969
3970 BFD_ASSERT (s->size == size);
3971 s->contents = contents;
3972 }
3973
3974 bfd_boolean
3975 bfd_elf32_arm_allocate_interworking_sections (struct bfd_link_info * info)
3976 {
3977 struct elf32_arm_link_hash_table * globals;
3978
3979 globals = elf32_arm_hash_table (info);
3980 BFD_ASSERT (globals != NULL);
3981
3982 arm_allocate_glue_section_space (globals->bfd_of_glue_owner,
3983 globals->arm_glue_size,
3984 ARM2THUMB_GLUE_SECTION_NAME);
3985
3986 arm_allocate_glue_section_space (globals->bfd_of_glue_owner,
3987 globals->thumb_glue_size,
3988 THUMB2ARM_GLUE_SECTION_NAME);
3989
3990 arm_allocate_glue_section_space (globals->bfd_of_glue_owner,
3991 globals->vfp11_erratum_glue_size,
3992 VFP11_ERRATUM_VENEER_SECTION_NAME);
3993
3994 arm_allocate_glue_section_space (globals->bfd_of_glue_owner,
3995 globals->bx_glue_size,
3996 ARM_BX_GLUE_SECTION_NAME);
3997
3998 return TRUE;
3999 }
4000
4001 /* Allocate space and symbols for calling a Thumb function from Arm mode.
4002 returns the symbol identifying the stub. */
4003
4004 static struct elf_link_hash_entry *
4005 record_arm_to_thumb_glue (struct bfd_link_info * link_info,
4006 struct elf_link_hash_entry * h)
4007 {
4008 const char * name = h->root.root.string;
4009 asection * s;
4010 char * tmp_name;
4011 struct elf_link_hash_entry * myh;
4012 struct bfd_link_hash_entry * bh;
4013 struct elf32_arm_link_hash_table * globals;
4014 bfd_vma val;
4015 bfd_size_type size;
4016
4017 globals = elf32_arm_hash_table (link_info);
4018
4019 BFD_ASSERT (globals != NULL);
4020 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
4021
4022 s = bfd_get_section_by_name
4023 (globals->bfd_of_glue_owner, ARM2THUMB_GLUE_SECTION_NAME);
4024
4025 BFD_ASSERT (s != NULL);
4026
4027 tmp_name = bfd_malloc ((bfd_size_type) strlen (name) + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
4028
4029 BFD_ASSERT (tmp_name);
4030
4031 sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
4032
4033 myh = elf_link_hash_lookup
4034 (&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
4035
4036 if (myh != NULL)
4037 {
4038 /* We've already seen this guy. */
4039 free (tmp_name);
4040 return myh;
4041 }
4042
4043 /* The only trick here is using hash_table->arm_glue_size as the value.
4044 Even though the section isn't allocated yet, this is where we will be
4045 putting it. The +1 on the value marks that the stub has not been
4046 output yet - not that it is a Thumb function. */
4047 bh = NULL;
4048 val = globals->arm_glue_size + 1;
4049 _bfd_generic_link_add_one_symbol (link_info, globals->bfd_of_glue_owner,
4050 tmp_name, BSF_GLOBAL, s, val,
4051 NULL, TRUE, FALSE, &bh);
4052
4053 myh = (struct elf_link_hash_entry *) bh;
4054 myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
4055 myh->forced_local = 1;
4056
4057 free (tmp_name);
4058
4059 if (link_info->shared || globals->root.is_relocatable_executable
4060 || globals->pic_veneer)
4061 size = ARM2THUMB_PIC_GLUE_SIZE;
4062 else if (globals->use_blx)
4063 size = ARM2THUMB_V5_STATIC_GLUE_SIZE;
4064 else
4065 size = ARM2THUMB_STATIC_GLUE_SIZE;
4066
4067 s->size += size;
4068 globals->arm_glue_size += size;
4069
4070 return myh;
4071 }
4072
4073 static void
4074 record_thumb_to_arm_glue (struct bfd_link_info *link_info,
4075 struct elf_link_hash_entry *h)
4076 {
4077 const char *name = h->root.root.string;
4078 asection *s;
4079 char *tmp_name;
4080 struct elf_link_hash_entry *myh;
4081 struct bfd_link_hash_entry *bh;
4082 struct elf32_arm_link_hash_table *hash_table;
4083 bfd_vma val;
4084
4085 hash_table = elf32_arm_hash_table (link_info);
4086
4087 BFD_ASSERT (hash_table != NULL);
4088 BFD_ASSERT (hash_table->bfd_of_glue_owner != NULL);
4089
4090 s = bfd_get_section_by_name
4091 (hash_table->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
4092
4093 BFD_ASSERT (s != NULL);
4094
4095 tmp_name = bfd_malloc ((bfd_size_type) strlen (name)
4096 + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1);
4097
4098 BFD_ASSERT (tmp_name);
4099
4100 sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
4101
4102 myh = elf_link_hash_lookup
4103 (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
4104
4105 if (myh != NULL)
4106 {
4107 /* We've already seen this guy. */
4108 free (tmp_name);
4109 return;
4110 }
4111
4112 /* The only trick here is using hash_table->thumb_glue_size as the value.
4113 Even though the section isn't allocated yet, this is where we will be
4114 putting it. The +1 on the value marks that the stub has not been
4115 output yet - not that it is a Thumb function. */
4116 bh = NULL;
4117 val = hash_table->thumb_glue_size + 1;
4118 _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner,
4119 tmp_name, BSF_GLOBAL, s, val,
4120 NULL, TRUE, FALSE, &bh);
4121
4122 /* If we mark it 'Thumb', the disassembler will do a better job. */
4123 myh = (struct elf_link_hash_entry *) bh;
4124 myh->type = ELF_ST_INFO (STB_LOCAL, STT_ARM_TFUNC);
4125 myh->forced_local = 1;
4126
4127 free (tmp_name);
4128
4129 #define CHANGE_TO_ARM "__%s_change_to_arm"
4130 #define BACK_FROM_ARM "__%s_back_from_arm"
4131
4132 /* Allocate another symbol to mark where we switch to Arm mode. */
4133 tmp_name = bfd_malloc ((bfd_size_type) strlen (name)
4134 + strlen (CHANGE_TO_ARM) + 1);
4135
4136 BFD_ASSERT (tmp_name);
4137
4138 sprintf (tmp_name, CHANGE_TO_ARM, name);
4139
4140 bh = NULL;
4141 val = hash_table->thumb_glue_size + 4,
4142 _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner,
4143 tmp_name, BSF_LOCAL, s, val,
4144 NULL, TRUE, FALSE, &bh);
4145
4146 free (tmp_name);
4147
4148 s->size += THUMB2ARM_GLUE_SIZE;
4149 hash_table->thumb_glue_size += THUMB2ARM_GLUE_SIZE;
4150 }
4151
4152
4153 /* Allocate space for ARMv4 BX veneers. */
4154
4155 static void
4156 record_arm_bx_glue (struct bfd_link_info * link_info, int reg)
4157 {
4158 asection * s;
4159 struct elf32_arm_link_hash_table *globals;
4160 char *tmp_name;
4161 struct elf_link_hash_entry *myh;
4162 struct bfd_link_hash_entry *bh;
4163 bfd_vma val;
4164
4165 /* BX PC does not need a veneer. */
4166 if (reg == 15)
4167 return;
4168
4169 globals = elf32_arm_hash_table (link_info);
4170
4171 BFD_ASSERT (globals != NULL);
4172 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
4173
4174 /* Check if this veneer has already been allocated. */
4175 if (globals->bx_glue_offset[reg])
4176 return;
4177
4178 s = bfd_get_section_by_name
4179 (globals->bfd_of_glue_owner, ARM_BX_GLUE_SECTION_NAME);
4180
4181 BFD_ASSERT (s != NULL);
4182
4183 /* Add symbol for veneer. */
4184 tmp_name = bfd_malloc ((bfd_size_type) strlen (ARM_BX_GLUE_ENTRY_NAME) + 1);
4185
4186 BFD_ASSERT (tmp_name);
4187
4188 sprintf (tmp_name, ARM_BX_GLUE_ENTRY_NAME, reg);
4189
4190 myh = elf_link_hash_lookup
4191 (&(globals)->root, tmp_name, FALSE, FALSE, FALSE);
4192
4193 BFD_ASSERT (myh == NULL);
4194
4195 bh = NULL;
4196 val = globals->bx_glue_size;
4197 _bfd_generic_link_add_one_symbol (link_info, globals->bfd_of_glue_owner,
4198 tmp_name, BSF_FUNCTION | BSF_LOCAL, s, val,
4199 NULL, TRUE, FALSE, &bh);
4200
4201 myh = (struct elf_link_hash_entry *) bh;
4202 myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
4203 myh->forced_local = 1;
4204
4205 s->size += ARM_BX_VENEER_SIZE;
4206 globals->bx_glue_offset[reg] = globals->bx_glue_size | 2;
4207 globals->bx_glue_size += ARM_BX_VENEER_SIZE;
4208 }
4209
4210
4211 /* Add an entry to the code/data map for section SEC. */
4212
4213 static void
4214 elf32_arm_section_map_add (asection *sec, char type, bfd_vma vma)
4215 {
4216 struct _arm_elf_section_data *sec_data = elf32_arm_section_data (sec);
4217 unsigned int newidx;
4218
4219 if (sec_data->map == NULL)
4220 {
4221 sec_data->map = bfd_malloc (sizeof (elf32_arm_section_map));
4222 sec_data->mapcount = 0;
4223 sec_data->mapsize = 1;
4224 }
4225
4226 newidx = sec_data->mapcount++;
4227
4228 if (sec_data->mapcount > sec_data->mapsize)
4229 {
4230 sec_data->mapsize *= 2;
4231 sec_data->map = bfd_realloc_or_free (sec_data->map, sec_data->mapsize
4232 * sizeof (elf32_arm_section_map));
4233 }
4234
4235 if (sec_data->map)
4236 {
4237 sec_data->map[newidx].vma = vma;
4238 sec_data->map[newidx].type = type;
4239 }
4240 }
4241
4242
4243 /* Record information about a VFP11 denorm-erratum veneer. Only ARM-mode
4244 veneers are handled for now. */
4245
4246 static bfd_vma
4247 record_vfp11_erratum_veneer (struct bfd_link_info *link_info,
4248 elf32_vfp11_erratum_list *branch,
4249 bfd *branch_bfd,
4250 asection *branch_sec,
4251 unsigned int offset)
4252 {
4253 asection *s;
4254 struct elf32_arm_link_hash_table *hash_table;
4255 char *tmp_name;
4256 struct elf_link_hash_entry *myh;
4257 struct bfd_link_hash_entry *bh;
4258 bfd_vma val;
4259 struct _arm_elf_section_data *sec_data;
4260 int errcount;
4261 elf32_vfp11_erratum_list *newerr;
4262
4263 hash_table = elf32_arm_hash_table (link_info);
4264
4265 BFD_ASSERT (hash_table != NULL);
4266 BFD_ASSERT (hash_table->bfd_of_glue_owner != NULL);
4267
4268 s = bfd_get_section_by_name
4269 (hash_table->bfd_of_glue_owner, VFP11_ERRATUM_VENEER_SECTION_NAME);
4270
4271 sec_data = elf32_arm_section_data (s);
4272
4273 BFD_ASSERT (s != NULL);
4274
4275 tmp_name = bfd_malloc ((bfd_size_type) strlen
4276 (VFP11_ERRATUM_VENEER_ENTRY_NAME) + 10);
4277
4278 BFD_ASSERT (tmp_name);
4279
4280 sprintf (tmp_name, VFP11_ERRATUM_VENEER_ENTRY_NAME,
4281 hash_table->num_vfp11_fixes);
4282
4283 myh = elf_link_hash_lookup
4284 (&(hash_table)->root, tmp_name, FALSE, FALSE, FALSE);
4285
4286 BFD_ASSERT (myh == NULL);
4287
4288 bh = NULL;
4289 val = hash_table->vfp11_erratum_glue_size;
4290 _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner,
4291 tmp_name, BSF_FUNCTION | BSF_LOCAL, s, val,
4292 NULL, TRUE, FALSE, &bh);
4293
4294 myh = (struct elf_link_hash_entry *) bh;
4295 myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
4296 myh->forced_local = 1;
4297
4298 /* Link veneer back to calling location. */
4299 errcount = ++(sec_data->erratumcount);
4300 newerr = bfd_zmalloc (sizeof (elf32_vfp11_erratum_list));
4301
4302 newerr->type = VFP11_ERRATUM_ARM_VENEER;
4303 newerr->vma = -1;
4304 newerr->u.v.branch = branch;
4305 newerr->u.v.id = hash_table->num_vfp11_fixes;
4306 branch->u.b.veneer = newerr;
4307
4308 newerr->next = sec_data->erratumlist;
4309 sec_data->erratumlist = newerr;
4310
4311 /* A symbol for the return from the veneer. */
4312 sprintf (tmp_name, VFP11_ERRATUM_VENEER_ENTRY_NAME "_r",
4313 hash_table->num_vfp11_fixes);
4314
4315 myh = elf_link_hash_lookup
4316 (&(hash_table)->root, tmp_name, FALSE, FALSE, FALSE);
4317
4318 if (myh != NULL)
4319 abort ();
4320
4321 bh = NULL;
4322 val = offset + 4;
4323 _bfd_generic_link_add_one_symbol (link_info, branch_bfd, tmp_name, BSF_LOCAL,
4324 branch_sec, val, NULL, TRUE, FALSE, &bh);
4325
4326 myh = (struct elf_link_hash_entry *) bh;
4327 myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
4328 myh->forced_local = 1;
4329
4330 free (tmp_name);
4331
4332 /* Generate a mapping symbol for the veneer section, and explicitly add an
4333 entry for that symbol to the code/data map for the section. */
4334 if (hash_table->vfp11_erratum_glue_size == 0)
4335 {
4336 bh = NULL;
4337 /* FIXME: Creates an ARM symbol. Thumb mode will need attention if it
4338 ever requires this erratum fix. */
4339 _bfd_generic_link_add_one_symbol (link_info,
4340 hash_table->bfd_of_glue_owner, "$a",
4341 BSF_LOCAL, s, 0, NULL,
4342 TRUE, FALSE, &bh);
4343
4344 myh = (struct elf_link_hash_entry *) bh;
4345 myh->type = ELF_ST_INFO (STB_LOCAL, STT_NOTYPE);
4346 myh->forced_local = 1;
4347
4348 /* The elf32_arm_init_maps function only cares about symbols from input
4349 BFDs. We must make a note of this generated mapping symbol
4350 ourselves so that code byteswapping works properly in
4351 elf32_arm_write_section. */
4352 elf32_arm_section_map_add (s, 'a', 0);
4353 }
4354
4355 s->size += VFP11_ERRATUM_VENEER_SIZE;
4356 hash_table->vfp11_erratum_glue_size += VFP11_ERRATUM_VENEER_SIZE;
4357 hash_table->num_vfp11_fixes++;
4358
4359 /* The offset of the veneer. */
4360 return val;
4361 }
4362
4363 /* Note: we do not include the flag SEC_LINKER_CREATED, as that
4364 would prevent elf_link_input_bfd() from processing the contents
4365 of the section. */
4366 #define ARM_GLUE_SECTION_FLAGS \
4367 (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_CODE | SEC_READONLY)
4368
4369 /* Create a fake section for use by the ARM backend of the linker. */
4370
4371 static bfd_boolean
4372 arm_make_glue_section (bfd * abfd, const char * name)
4373 {
4374 asection * sec;
4375
4376 sec = bfd_get_section_by_name (abfd, name);
4377 if (sec != NULL)
4378 /* Already made. */
4379 return TRUE;
4380
4381 sec = bfd_make_section_with_flags (abfd, name, ARM_GLUE_SECTION_FLAGS);
4382
4383 if (sec == NULL
4384 || !bfd_set_section_alignment (abfd, sec, 2))
4385 return FALSE;
4386
4387 /* Set the gc mark to prevent the section from being removed by garbage
4388 collection, despite the fact that no relocs refer to this section. */
4389 sec->gc_mark = 1;
4390
4391 return TRUE;
4392 }
4393
4394 /* Add the glue sections to ABFD. This function is called from the
4395 linker scripts in ld/emultempl/{armelf}.em. */
4396
4397 bfd_boolean
4398 bfd_elf32_arm_add_glue_sections_to_bfd (bfd *abfd,
4399 struct bfd_link_info *info)
4400 {
4401 /* If we are only performing a partial
4402 link do not bother adding the glue. */
4403 if (info->relocatable)
4404 return TRUE;
4405
4406 /* Linker stubs don't need glue. */
4407 if (!strcmp (abfd->filename, "linker stubs"))
4408 return TRUE;
4409
4410 return arm_make_glue_section (abfd, ARM2THUMB_GLUE_SECTION_NAME)
4411 && arm_make_glue_section (abfd, THUMB2ARM_GLUE_SECTION_NAME)
4412 && arm_make_glue_section (abfd, VFP11_ERRATUM_VENEER_SECTION_NAME)
4413 && arm_make_glue_section (abfd, ARM_BX_GLUE_SECTION_NAME);
4414 }
4415
4416 /* Select a BFD to be used to hold the sections used by the glue code.
4417 This function is called from the linker scripts in ld/emultempl/
4418 {armelf/pe}.em. */
4419
4420 bfd_boolean
4421 bfd_elf32_arm_get_bfd_for_interworking (bfd *abfd, struct bfd_link_info *info)
4422 {
4423 struct elf32_arm_link_hash_table *globals;
4424
4425 /* If we are only performing a partial link
4426 do not bother getting a bfd to hold the glue. */
4427 if (info->relocatable)
4428 return TRUE;
4429
4430 /* Make sure we don't attach the glue sections to a dynamic object. */
4431 BFD_ASSERT (!(abfd->flags & DYNAMIC));
4432
4433 globals = elf32_arm_hash_table (info);
4434
4435 BFD_ASSERT (globals != NULL);
4436
4437 if (globals->bfd_of_glue_owner != NULL)
4438 return TRUE;
4439
4440 /* Save the bfd for later use. */
4441 globals->bfd_of_glue_owner = abfd;
4442
4443 return TRUE;
4444 }
4445
4446 static void
4447 check_use_blx (struct elf32_arm_link_hash_table *globals)
4448 {
4449 if (bfd_elf_get_obj_attr_int (globals->obfd, OBJ_ATTR_PROC,
4450 Tag_CPU_arch) > 2)
4451 globals->use_blx = 1;
4452 }
4453
4454 bfd_boolean
4455 bfd_elf32_arm_process_before_allocation (bfd *abfd,
4456 struct bfd_link_info *link_info)
4457 {
4458 Elf_Internal_Shdr *symtab_hdr;
4459 Elf_Internal_Rela *internal_relocs = NULL;
4460 Elf_Internal_Rela *irel, *irelend;
4461 bfd_byte *contents = NULL;
4462
4463 asection *sec;
4464 struct elf32_arm_link_hash_table *globals;
4465
4466 /* If we are only performing a partial link do not bother
4467 to construct any glue. */
4468 if (link_info->relocatable)
4469 return TRUE;
4470
4471 /* Here we have a bfd that is to be included on the link. We have a
4472 hook to do reloc rummaging, before section sizes are nailed down. */
4473 globals = elf32_arm_hash_table (link_info);
4474
4475 BFD_ASSERT (globals != NULL);
4476
4477 check_use_blx (globals);
4478
4479 if (globals->byteswap_code && !bfd_big_endian (abfd))
4480 {
4481 _bfd_error_handler (_("%B: BE8 images only valid in big-endian mode."),
4482 abfd);
4483 return FALSE;
4484 }
4485
4486 /* PR 5398: If we have not decided to include any loadable sections in
4487 the output then we will not have a glue owner bfd. This is OK, it
4488 just means that there is nothing else for us to do here. */
4489 if (globals->bfd_of_glue_owner == NULL)
4490 return TRUE;
4491
4492 /* Rummage around all the relocs and map the glue vectors. */
4493 sec = abfd->sections;
4494
4495 if (sec == NULL)
4496 return TRUE;
4497
4498 for (; sec != NULL; sec = sec->next)
4499 {
4500 if (sec->reloc_count == 0)
4501 continue;
4502
4503 if ((sec->flags & SEC_EXCLUDE) != 0)
4504 continue;
4505
4506 symtab_hdr = & elf_symtab_hdr (abfd);
4507
4508 /* Load the relocs. */
4509 internal_relocs
4510 = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL, FALSE);
4511
4512 if (internal_relocs == NULL)
4513 goto error_return;
4514
4515 irelend = internal_relocs + sec->reloc_count;
4516 for (irel = internal_relocs; irel < irelend; irel++)
4517 {
4518 long r_type;
4519 unsigned long r_index;
4520
4521 struct elf_link_hash_entry *h;
4522
4523 r_type = ELF32_R_TYPE (irel->r_info);
4524 r_index = ELF32_R_SYM (irel->r_info);
4525
4526 /* These are the only relocation types we care about. */
4527 if ( r_type != R_ARM_PC24
4528 && r_type != R_ARM_PLT32
4529 && r_type != R_ARM_JUMP24
4530 && r_type != R_ARM_THM_JUMP24
4531 && (r_type != R_ARM_V4BX || globals->fix_v4bx < 2))
4532 continue;
4533
4534 /* Get the section contents if we haven't done so already. */
4535 if (contents == NULL)
4536 {
4537 /* Get cached copy if it exists. */
4538 if (elf_section_data (sec)->this_hdr.contents != NULL)
4539 contents = elf_section_data (sec)->this_hdr.contents;
4540 else
4541 {
4542 /* Go get them off disk. */
4543 if (! bfd_malloc_and_get_section (abfd, sec, &contents))
4544 goto error_return;
4545 }
4546 }
4547
4548 if (r_type == R_ARM_V4BX)
4549 {
4550 int reg;
4551
4552 reg = bfd_get_32 (abfd, contents + irel->r_offset) & 0xf;
4553 record_arm_bx_glue (link_info, reg);
4554 continue;
4555 }
4556
4557 /* If the relocation is not against a symbol it cannot concern us. */
4558 h = NULL;
4559
4560 /* We don't care about local symbols. */
4561 if (r_index < symtab_hdr->sh_info)
4562 continue;
4563
4564 /* This is an external symbol. */
4565 r_index -= symtab_hdr->sh_info;
4566 h = (struct elf_link_hash_entry *)
4567 elf_sym_hashes (abfd)[r_index];
4568
4569 /* If the relocation is against a static symbol it must be within
4570 the current section and so cannot be a cross ARM/Thumb relocation. */
4571 if (h == NULL)
4572 continue;
4573
4574 /* If the call will go through a PLT entry then we do not need
4575 glue. */
4576 if (globals->splt != NULL && h->plt.offset != (bfd_vma) -1)
4577 continue;
4578
4579 switch (r_type)
4580 {
4581 case R_ARM_PC24:
4582 case R_ARM_PLT32:
4583 case R_ARM_JUMP24:
4584 /* This one is a call from arm code. We need to look up
4585 the target of the call. If it is a thumb target, we
4586 insert glue. */
4587 if (ELF_ST_TYPE (h->type) == STT_ARM_TFUNC
4588 && !(r_type == R_ARM_CALL && globals->use_blx))
4589 record_arm_to_thumb_glue (link_info, h);
4590 break;
4591
4592 case R_ARM_THM_JUMP24:
4593 /* This one is a call from thumb code. We look
4594 up the target of the call. If it is not a thumb
4595 target, we insert glue. */
4596 if (ELF_ST_TYPE (h->type) != STT_ARM_TFUNC
4597 && !(globals->use_blx && r_type == R_ARM_THM_CALL)
4598 && h->root.type != bfd_link_hash_undefweak)
4599 record_thumb_to_arm_glue (link_info, h);
4600 break;
4601
4602 default:
4603 abort ();
4604 }
4605 }
4606
4607 if (contents != NULL
4608 && elf_section_data (sec)->this_hdr.contents != contents)
4609 free (contents);
4610 contents = NULL;
4611
4612 if (internal_relocs != NULL
4613 && elf_section_data (sec)->relocs != internal_relocs)
4614 free (internal_relocs);
4615 internal_relocs = NULL;
4616 }
4617
4618 return TRUE;
4619
4620 error_return:
4621 if (contents != NULL
4622 && elf_section_data (sec)->this_hdr.contents != contents)
4623 free (contents);
4624 if (internal_relocs != NULL
4625 && elf_section_data (sec)->relocs != internal_relocs)
4626 free (internal_relocs);
4627
4628 return FALSE;
4629 }
4630 #endif
4631
4632
4633 /* Initialise maps of ARM/Thumb/data for input BFDs. */
4634
4635 void
4636 bfd_elf32_arm_init_maps (bfd *abfd)
4637 {
4638 Elf_Internal_Sym *isymbuf;
4639 Elf_Internal_Shdr *hdr;
4640 unsigned int i, localsyms;
4641
4642 /* PR 7093: Make sure that we are dealing with an arm elf binary. */
4643 if (! is_arm_elf (abfd))
4644 return;
4645
4646 if ((abfd->flags & DYNAMIC) != 0)
4647 return;
4648
4649 hdr = & elf_symtab_hdr (abfd);
4650 localsyms = hdr->sh_info;
4651
4652 /* Obtain a buffer full of symbols for this BFD. The hdr->sh_info field
4653 should contain the number of local symbols, which should come before any
4654 global symbols. Mapping symbols are always local. */
4655 isymbuf = bfd_elf_get_elf_syms (abfd, hdr, localsyms, 0, NULL, NULL,
4656 NULL);
4657
4658 /* No internal symbols read? Skip this BFD. */
4659 if (isymbuf == NULL)
4660 return;
4661
4662 for (i = 0; i < localsyms; i++)
4663 {
4664 Elf_Internal_Sym *isym = &isymbuf[i];
4665 asection *sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
4666 const char *name;
4667
4668 if (sec != NULL
4669 && ELF_ST_BIND (isym->st_info) == STB_LOCAL)
4670 {
4671 name = bfd_elf_string_from_elf_section (abfd,
4672 hdr->sh_link, isym->st_name);
4673
4674 if (bfd_is_arm_special_symbol_name (name,
4675 BFD_ARM_SPECIAL_SYM_TYPE_MAP))
4676 elf32_arm_section_map_add (sec, name[1], isym->st_value);
4677 }
4678 }
4679 }
4680
4681
4682 void
4683 bfd_elf32_arm_set_vfp11_fix (bfd *obfd, struct bfd_link_info *link_info)
4684 {
4685 struct elf32_arm_link_hash_table *globals = elf32_arm_hash_table (link_info);
4686 obj_attribute *out_attr = elf_known_obj_attributes_proc (obfd);
4687
4688 /* We assume that ARMv7+ does not need the VFP11 denorm erratum fix. */
4689 if (out_attr[Tag_CPU_arch].i >= TAG_CPU_ARCH_V7)
4690 {
4691 switch (globals->vfp11_fix)
4692 {
4693 case BFD_ARM_VFP11_FIX_DEFAULT:
4694 case BFD_ARM_VFP11_FIX_NONE:
4695 globals->vfp11_fix = BFD_ARM_VFP11_FIX_NONE;
4696 break;
4697
4698 default:
4699 /* Give a warning, but do as the user requests anyway. */
4700 (*_bfd_error_handler) (_("%B: warning: selected VFP11 erratum "
4701 "workaround is not necessary for target architecture"), obfd);
4702 }
4703 }
4704 else if (globals->vfp11_fix == BFD_ARM_VFP11_FIX_DEFAULT)
4705 /* For earlier architectures, we might need the workaround, but do not
4706 enable it by default. If users is running with broken hardware, they
4707 must enable the erratum fix explicitly. */
4708 globals->vfp11_fix = BFD_ARM_VFP11_FIX_NONE;
4709 }
4710
4711
4712 enum bfd_arm_vfp11_pipe
4713 {
4714 VFP11_FMAC,
4715 VFP11_LS,
4716 VFP11_DS,
4717 VFP11_BAD
4718 };
4719
4720 /* Return a VFP register number. This is encoded as RX:X for single-precision
4721 registers, or X:RX for double-precision registers, where RX is the group of
4722 four bits in the instruction encoding and X is the single extension bit.
4723 RX and X fields are specified using their lowest (starting) bit. The return
4724 value is:
4725
4726 0...31: single-precision registers s0...s31
4727 32...63: double-precision registers d0...d31.
4728
4729 Although X should be zero for VFP11 (encoding d0...d15 only), we might
4730 encounter VFP3 instructions, so we allow the full range for DP registers. */
4731
4732 static unsigned int
4733 bfd_arm_vfp11_regno (unsigned int insn, bfd_boolean is_double, unsigned int rx,
4734 unsigned int x)
4735 {
4736 if (is_double)
4737 return (((insn >> rx) & 0xf) | (((insn >> x) & 1) << 4)) + 32;
4738 else
4739 return (((insn >> rx) & 0xf) << 1) | ((insn >> x) & 1);
4740 }
4741
4742 /* Set bits in *WMASK according to a register number REG as encoded by
4743 bfd_arm_vfp11_regno(). Ignore d16-d31. */
4744
4745 static void
4746 bfd_arm_vfp11_write_mask (unsigned int *wmask, unsigned int reg)
4747 {
4748 if (reg < 32)
4749 *wmask |= 1 << reg;
4750 else if (reg < 48)
4751 *wmask |= 3 << ((reg - 32) * 2);
4752 }
4753
4754 /* Return TRUE if WMASK overwrites anything in REGS. */
4755
4756 static bfd_boolean
4757 bfd_arm_vfp11_antidependency (unsigned int wmask, int *regs, int numregs)
4758 {
4759 int i;
4760
4761 for (i = 0; i < numregs; i++)
4762 {
4763 unsigned int reg = regs[i];
4764
4765 if (reg < 32 && (wmask & (1 << reg)) != 0)
4766 return TRUE;
4767
4768 reg -= 32;
4769
4770 if (reg >= 16)
4771 continue;
4772
4773 if ((wmask & (3 << (reg * 2))) != 0)
4774 return TRUE;
4775 }
4776
4777 return FALSE;
4778 }
4779
4780 /* In this function, we're interested in two things: finding input registers
4781 for VFP data-processing instructions, and finding the set of registers which
4782 arbitrary VFP instructions may write to. We use a 32-bit unsigned int to
4783 hold the written set, so FLDM etc. are easy to deal with (we're only
4784 interested in 32 SP registers or 16 dp registers, due to the VFP version
4785 implemented by the chip in question). DP registers are marked by setting
4786 both SP registers in the write mask). */
4787
4788 static enum bfd_arm_vfp11_pipe
4789 bfd_arm_vfp11_insn_decode (unsigned int insn, unsigned int *destmask, int *regs,
4790 int *numregs)
4791 {
4792 enum bfd_arm_vfp11_pipe pipe = VFP11_BAD;
4793 bfd_boolean is_double = ((insn & 0xf00) == 0xb00) ? 1 : 0;
4794
4795 if ((insn & 0x0f000e10) == 0x0e000a00) /* A data-processing insn. */
4796 {
4797 unsigned int pqrs;
4798 unsigned int fd = bfd_arm_vfp11_regno (insn, is_double, 12, 22);
4799 unsigned int fm = bfd_arm_vfp11_regno (insn, is_double, 0, 5);
4800
4801 pqrs = ((insn & 0x00800000) >> 20)
4802 | ((insn & 0x00300000) >> 19)
4803 | ((insn & 0x00000040) >> 6);
4804
4805 switch (pqrs)
4806 {
4807 case 0: /* fmac[sd]. */
4808 case 1: /* fnmac[sd]. */
4809 case 2: /* fmsc[sd]. */
4810 case 3: /* fnmsc[sd]. */
4811 pipe = VFP11_FMAC;
4812 bfd_arm_vfp11_write_mask (destmask, fd);
4813 regs[0] = fd;
4814 regs[1] = bfd_arm_vfp11_regno (insn, is_double, 16, 7); /* Fn. */
4815 regs[2] = fm;
4816 *numregs = 3;
4817 break;
4818
4819 case 4: /* fmul[sd]. */
4820 case 5: /* fnmul[sd]. */
4821 case 6: /* fadd[sd]. */
4822 case 7: /* fsub[sd]. */
4823 pipe = VFP11_FMAC;
4824 goto vfp_binop;
4825
4826 case 8: /* fdiv[sd]. */
4827 pipe = VFP11_DS;
4828 vfp_binop:
4829 bfd_arm_vfp11_write_mask (destmask, fd);
4830 regs[0] = bfd_arm_vfp11_regno (insn, is_double, 16, 7); /* Fn. */
4831 regs[1] = fm;
4832 *numregs = 2;
4833 break;
4834
4835 case 15: /* extended opcode. */
4836 {
4837 unsigned int extn = ((insn >> 15) & 0x1e)
4838 | ((insn >> 7) & 1);
4839
4840 switch (extn)
4841 {
4842 case 0: /* fcpy[sd]. */
4843 case 1: /* fabs[sd]. */
4844 case 2: /* fneg[sd]. */
4845 case 8: /* fcmp[sd]. */
4846 case 9: /* fcmpe[sd]. */
4847 case 10: /* fcmpz[sd]. */
4848 case 11: /* fcmpez[sd]. */
4849 case 16: /* fuito[sd]. */
4850 case 17: /* fsito[sd]. */
4851 case 24: /* ftoui[sd]. */
4852 case 25: /* ftouiz[sd]. */
4853 case 26: /* ftosi[sd]. */
4854 case 27: /* ftosiz[sd]. */
4855 /* These instructions will not bounce due to underflow. */
4856 *numregs = 0;
4857 pipe = VFP11_FMAC;
4858 break;
4859
4860 case 3: /* fsqrt[sd]. */
4861 /* fsqrt cannot underflow, but it can (perhaps) overwrite
4862 registers to cause the erratum in previous instructions. */
4863 bfd_arm_vfp11_write_mask (destmask, fd);
4864 pipe = VFP11_DS;
4865 break;
4866
4867 case 15: /* fcvt{ds,sd}. */
4868 {
4869 int rnum = 0;
4870
4871 bfd_arm_vfp11_write_mask (destmask, fd);
4872
4873 /* Only FCVTSD can underflow. */
4874 if ((insn & 0x100) != 0)
4875 regs[rnum++] = fm;
4876
4877 *numregs = rnum;
4878
4879 pipe = VFP11_FMAC;
4880 }
4881 break;
4882
4883 default:
4884 return VFP11_BAD;
4885 }
4886 }
4887 break;
4888
4889 default:
4890 return VFP11_BAD;
4891 }
4892 }
4893 /* Two-register transfer. */
4894 else if ((insn & 0x0fe00ed0) == 0x0c400a10)
4895 {
4896 unsigned int fm = bfd_arm_vfp11_regno (insn, is_double, 0, 5);
4897
4898 if ((insn & 0x100000) == 0)
4899 {
4900 if (is_double)
4901 bfd_arm_vfp11_write_mask (destmask, fm);
4902 else
4903 {
4904 bfd_arm_vfp11_write_mask (destmask, fm);
4905 bfd_arm_vfp11_write_mask (destmask, fm + 1);
4906 }
4907 }
4908
4909 pipe = VFP11_LS;
4910 }
4911 else if ((insn & 0x0e100e00) == 0x0c100a00) /* A load insn. */
4912 {
4913 int fd = bfd_arm_vfp11_regno (insn, is_double, 12, 22);
4914 unsigned int puw = ((insn >> 21) & 0x1) | (((insn >> 23) & 3) << 1);
4915
4916 switch (puw)
4917 {
4918 case 0: /* Two-reg transfer. We should catch these above. */
4919 abort ();
4920
4921 case 2: /* fldm[sdx]. */
4922 case 3:
4923 case 5:
4924 {
4925 unsigned int i, offset = insn & 0xff;
4926
4927 if (is_double)
4928 offset >>= 1;
4929
4930 for (i = fd; i < fd + offset; i++)
4931 bfd_arm_vfp11_write_mask (destmask, i);
4932 }
4933 break;
4934
4935 case 4: /* fld[sd]. */
4936 case 6:
4937 bfd_arm_vfp11_write_mask (destmask, fd);
4938 break;
4939
4940 default:
4941 return VFP11_BAD;
4942 }
4943
4944 pipe = VFP11_LS;
4945 }
4946 /* Single-register transfer. Note L==0. */
4947 else if ((insn & 0x0f100e10) == 0x0e000a10)
4948 {
4949 unsigned int opcode = (insn >> 21) & 7;
4950 unsigned int fn = bfd_arm_vfp11_regno (insn, is_double, 16, 7);
4951
4952 switch (opcode)
4953 {
4954 case 0: /* fmsr/fmdlr. */
4955 case 1: /* fmdhr. */
4956 /* Mark fmdhr and fmdlr as writing to the whole of the DP
4957 destination register. I don't know if this is exactly right,
4958 but it is the conservative choice. */
4959 bfd_arm_vfp11_write_mask (destmask, fn);
4960 break;
4961
4962 case 7: /* fmxr. */
4963 break;
4964 }
4965
4966 pipe = VFP11_LS;
4967 }
4968
4969 return pipe;
4970 }
4971
4972
4973 static int elf32_arm_compare_mapping (const void * a, const void * b);
4974
4975
4976 /* Look for potentially-troublesome code sequences which might trigger the
4977 VFP11 denormal/antidependency erratum. See, e.g., the ARM1136 errata sheet
4978 (available from ARM) for details of the erratum. A short version is
4979 described in ld.texinfo. */
4980
4981 bfd_boolean
4982 bfd_elf32_arm_vfp11_erratum_scan (bfd *abfd, struct bfd_link_info *link_info)
4983 {
4984 asection *sec;
4985 bfd_byte *contents = NULL;
4986 int state = 0;
4987 int regs[3], numregs = 0;
4988 struct elf32_arm_link_hash_table *globals = elf32_arm_hash_table (link_info);
4989 int use_vector = (globals->vfp11_fix == BFD_ARM_VFP11_FIX_VECTOR);
4990
4991 /* We use a simple FSM to match troublesome VFP11 instruction sequences.
4992 The states transition as follows:
4993
4994 0 -> 1 (vector) or 0 -> 2 (scalar)
4995 A VFP FMAC-pipeline instruction has been seen. Fill
4996 regs[0]..regs[numregs-1] with its input operands. Remember this
4997 instruction in 'first_fmac'.
4998
4999 1 -> 2
5000 Any instruction, except for a VFP instruction which overwrites
5001 regs[*].
5002
5003 1 -> 3 [ -> 0 ] or
5004 2 -> 3 [ -> 0 ]
5005 A VFP instruction has been seen which overwrites any of regs[*].
5006 We must make a veneer! Reset state to 0 before examining next
5007 instruction.
5008
5009 2 -> 0
5010 If we fail to match anything in state 2, reset to state 0 and reset
5011 the instruction pointer to the instruction after 'first_fmac'.
5012
5013 If the VFP11 vector mode is in use, there must be at least two unrelated
5014 instructions between anti-dependent VFP11 instructions to properly avoid
5015 triggering the erratum, hence the use of the extra state 1. */
5016
5017 /* If we are only performing a partial link do not bother
5018 to construct any glue. */
5019 if (link_info->relocatable)
5020 return TRUE;
5021
5022 /* Skip if this bfd does not correspond to an ELF image. */
5023 if (! is_arm_elf (abfd))
5024 return TRUE;
5025
5026 /* We should have chosen a fix type by the time we get here. */
5027 BFD_ASSERT (globals->vfp11_fix != BFD_ARM_VFP11_FIX_DEFAULT);
5028
5029 if (globals->vfp11_fix == BFD_ARM_VFP11_FIX_NONE)
5030 return TRUE;
5031
5032 /* Skip this BFD if it corresponds to an executable or dynamic object. */
5033 if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
5034 return TRUE;
5035
5036 for (sec = abfd->sections; sec != NULL; sec = sec->next)
5037 {
5038 unsigned int i, span, first_fmac = 0, veneer_of_insn = 0;
5039 struct _arm_elf_section_data *sec_data;
5040
5041 /* If we don't have executable progbits, we're not interested in this
5042 section. Also skip if section is to be excluded. */
5043 if (elf_section_type (sec) != SHT_PROGBITS
5044 || (elf_section_flags (sec) & SHF_EXECINSTR) == 0
5045 || (sec->flags & SEC_EXCLUDE) != 0
5046 || sec->sec_info_type == ELF_INFO_TYPE_JUST_SYMS
5047 || sec->output_section == bfd_abs_section_ptr
5048 || strcmp (sec->name, VFP11_ERRATUM_VENEER_SECTION_NAME) == 0)
5049 continue;
5050
5051 sec_data = elf32_arm_section_data (sec);
5052
5053 if (sec_data->mapcount == 0)
5054 continue;
5055
5056 if (elf_section_data (sec)->this_hdr.contents != NULL)
5057 contents = elf_section_data (sec)->this_hdr.contents;
5058 else if (! bfd_malloc_and_get_section (abfd, sec, &contents))
5059 goto error_return;
5060
5061 qsort (sec_data->map, sec_data->mapcount, sizeof (elf32_arm_section_map),
5062 elf32_arm_compare_mapping);
5063
5064 for (span = 0; span < sec_data->mapcount; span++)
5065 {
5066 unsigned int span_start = sec_data->map[span].vma;
5067 unsigned int span_end = (span == sec_data->mapcount - 1)
5068 ? sec->size : sec_data->map[span + 1].vma;
5069 char span_type = sec_data->map[span].type;
5070
5071 /* FIXME: Only ARM mode is supported at present. We may need to
5072 support Thumb-2 mode also at some point. */
5073 if (span_type != 'a')
5074 continue;
5075
5076 for (i = span_start; i < span_end;)
5077 {
5078 unsigned int next_i = i + 4;
5079 unsigned int insn = bfd_big_endian (abfd)
5080 ? (contents[i] << 24)
5081 | (contents[i + 1] << 16)
5082 | (contents[i + 2] << 8)
5083 | contents[i + 3]
5084 : (contents[i + 3] << 24)
5085 | (contents[i + 2] << 16)
5086 | (contents[i + 1] << 8)
5087 | contents[i];
5088 unsigned int writemask = 0;
5089 enum bfd_arm_vfp11_pipe pipe;
5090
5091 switch (state)
5092 {
5093 case 0:
5094 pipe = bfd_arm_vfp11_insn_decode (insn, &writemask, regs,
5095 &numregs);
5096 /* I'm assuming the VFP11 erratum can trigger with denorm
5097 operands on either the FMAC or the DS pipeline. This might
5098 lead to slightly overenthusiastic veneer insertion. */
5099 if (pipe == VFP11_FMAC || pipe == VFP11_DS)
5100 {
5101 state = use_vector ? 1 : 2;
5102 first_fmac = i;
5103 veneer_of_insn = insn;
5104 }
5105 break;
5106
5107 case 1:
5108 {
5109 int other_regs[3], other_numregs;
5110 pipe = bfd_arm_vfp11_insn_decode (insn, &writemask,
5111 other_regs,
5112 &other_numregs);
5113 if (pipe != VFP11_BAD
5114 && bfd_arm_vfp11_antidependency (writemask, regs,
5115 numregs))
5116 state = 3;
5117 else
5118 state = 2;
5119 }
5120 break;
5121
5122 case 2:
5123 {
5124 int other_regs[3], other_numregs;
5125 pipe = bfd_arm_vfp11_insn_decode (insn, &writemask,
5126 other_regs,
5127 &other_numregs);
5128 if (pipe != VFP11_BAD
5129 && bfd_arm_vfp11_antidependency (writemask, regs,
5130 numregs))
5131 state = 3;
5132 else
5133 {
5134 state = 0;
5135 next_i = first_fmac + 4;
5136 }
5137 }
5138 break;
5139
5140 case 3:
5141 abort (); /* Should be unreachable. */
5142 }
5143
5144 if (state == 3)
5145 {
5146 elf32_vfp11_erratum_list *newerr
5147 = bfd_zmalloc (sizeof (elf32_vfp11_erratum_list));
5148 int errcount;
5149
5150 errcount = ++(elf32_arm_section_data (sec)->erratumcount);
5151
5152 newerr->u.b.vfp_insn = veneer_of_insn;
5153
5154 switch (span_type)
5155 {
5156 case 'a':
5157 newerr->type = VFP11_ERRATUM_BRANCH_TO_ARM_VENEER;
5158 break;
5159
5160 default:
5161 abort ();
5162 }
5163
5164 record_vfp11_erratum_veneer (link_info, newerr, abfd, sec,
5165 first_fmac);
5166
5167 newerr->vma = -1;
5168
5169 newerr->next = sec_data->erratumlist;
5170 sec_data->erratumlist = newerr;
5171
5172 state = 0;
5173 }
5174
5175 i = next_i;
5176 }
5177 }
5178
5179 if (contents != NULL
5180 && elf_section_data (sec)->this_hdr.contents != contents)
5181 free (contents);
5182 contents = NULL;
5183 }
5184
5185 return TRUE;
5186
5187 error_return:
5188 if (contents != NULL
5189 && elf_section_data (sec)->this_hdr.contents != contents)
5190 free (contents);
5191
5192 return FALSE;
5193 }
5194
5195 /* Find virtual-memory addresses for VFP11 erratum veneers and return locations
5196 after sections have been laid out, using specially-named symbols. */
5197
5198 void
5199 bfd_elf32_arm_vfp11_fix_veneer_locations (bfd *abfd,
5200 struct bfd_link_info *link_info)
5201 {
5202 asection *sec;
5203 struct elf32_arm_link_hash_table *globals;
5204 char *tmp_name;
5205
5206 if (link_info->relocatable)
5207 return;
5208
5209 /* Skip if this bfd does not correspond to an ELF image. */
5210 if (! is_arm_elf (abfd))
5211 return;
5212
5213 globals = elf32_arm_hash_table (link_info);
5214
5215 tmp_name = bfd_malloc ((bfd_size_type) strlen
5216 (VFP11_ERRATUM_VENEER_ENTRY_NAME) + 10);
5217
5218 for (sec = abfd->sections; sec != NULL; sec = sec->next)
5219 {
5220 struct _arm_elf_section_data *sec_data = elf32_arm_section_data (sec);
5221 elf32_vfp11_erratum_list *errnode = sec_data->erratumlist;
5222
5223 for (; errnode != NULL; errnode = errnode->next)
5224 {
5225 struct elf_link_hash_entry *myh;
5226 bfd_vma vma;
5227
5228 switch (errnode->type)
5229 {
5230 case VFP11_ERRATUM_BRANCH_TO_ARM_VENEER:
5231 case VFP11_ERRATUM_BRANCH_TO_THUMB_VENEER:
5232 /* Find veneer symbol. */
5233 sprintf (tmp_name, VFP11_ERRATUM_VENEER_ENTRY_NAME,
5234 errnode->u.b.veneer->u.v.id);
5235
5236 myh = elf_link_hash_lookup
5237 (&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
5238
5239 if (myh == NULL)
5240 (*_bfd_error_handler) (_("%B: unable to find VFP11 veneer "
5241 "`%s'"), abfd, tmp_name);
5242
5243 vma = myh->root.u.def.section->output_section->vma
5244 + myh->root.u.def.section->output_offset
5245 + myh->root.u.def.value;
5246
5247 errnode->u.b.veneer->vma = vma;
5248 break;
5249
5250 case VFP11_ERRATUM_ARM_VENEER:
5251 case VFP11_ERRATUM_THUMB_VENEER:
5252 /* Find return location. */
5253 sprintf (tmp_name, VFP11_ERRATUM_VENEER_ENTRY_NAME "_r",
5254 errnode->u.v.id);
5255
5256 myh = elf_link_hash_lookup
5257 (&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
5258
5259 if (myh == NULL)
5260 (*_bfd_error_handler) (_("%B: unable to find VFP11 veneer "
5261 "`%s'"), abfd, tmp_name);
5262
5263 vma = myh->root.u.def.section->output_section->vma
5264 + myh->root.u.def.section->output_offset
5265 + myh->root.u.def.value;
5266
5267 errnode->u.v.branch->vma = vma;
5268 break;
5269
5270 default:
5271 abort ();
5272 }
5273 }
5274 }
5275
5276 free (tmp_name);
5277 }
5278
5279
5280 /* Set target relocation values needed during linking. */
5281
5282 void
5283 bfd_elf32_arm_set_target_relocs (struct bfd *output_bfd,
5284 struct bfd_link_info *link_info,
5285 int target1_is_rel,
5286 char * target2_type,
5287 int fix_v4bx,
5288 int use_blx,
5289 bfd_arm_vfp11_fix vfp11_fix,
5290 int no_enum_warn, int no_wchar_warn,
5291 int pic_veneer)
5292 {
5293 struct elf32_arm_link_hash_table *globals;
5294
5295 globals = elf32_arm_hash_table (link_info);
5296
5297 globals->target1_is_rel = target1_is_rel;
5298 if (strcmp (target2_type, "rel") == 0)
5299 globals->target2_reloc = R_ARM_REL32;
5300 else if (strcmp (target2_type, "abs") == 0)
5301 globals->target2_reloc = R_ARM_ABS32;
5302 else if (strcmp (target2_type, "got-rel") == 0)
5303 globals->target2_reloc = R_ARM_GOT_PREL;
5304 else
5305 {
5306 _bfd_error_handler (_("Invalid TARGET2 relocation type '%s'."),
5307 target2_type);
5308 }
5309 globals->fix_v4bx = fix_v4bx;
5310 globals->use_blx |= use_blx;
5311 globals->vfp11_fix = vfp11_fix;
5312 globals->pic_veneer = pic_veneer;
5313
5314 BFD_ASSERT (is_arm_elf (output_bfd));
5315 elf_arm_tdata (output_bfd)->no_enum_size_warning = no_enum_warn;
5316 elf_arm_tdata (output_bfd)->no_wchar_size_warning = no_wchar_warn;
5317 }
5318
5319 /* Replace the target offset of a Thumb bl or b.w instruction. */
5320
5321 static void
5322 insert_thumb_branch (bfd *abfd, long int offset, bfd_byte *insn)
5323 {
5324 bfd_vma upper;
5325 bfd_vma lower;
5326 int reloc_sign;
5327
5328 BFD_ASSERT ((offset & 1) == 0);
5329
5330 upper = bfd_get_16 (abfd, insn);
5331 lower = bfd_get_16 (abfd, insn + 2);
5332 reloc_sign = (offset < 0) ? 1 : 0;
5333 upper = (upper & ~(bfd_vma) 0x7ff)
5334 | ((offset >> 12) & 0x3ff)
5335 | (reloc_sign << 10);
5336 lower = (lower & ~(bfd_vma) 0x2fff)
5337 | (((!((offset >> 23) & 1)) ^ reloc_sign) << 13)
5338 | (((!((offset >> 22) & 1)) ^ reloc_sign) << 11)
5339 | ((offset >> 1) & 0x7ff);
5340 bfd_put_16 (abfd, upper, insn);
5341 bfd_put_16 (abfd, lower, insn + 2);
5342 }
5343
5344 /* Thumb code calling an ARM function. */
5345
5346 static int
5347 elf32_thumb_to_arm_stub (struct bfd_link_info * info,
5348 const char * name,
5349 bfd * input_bfd,
5350 bfd * output_bfd,
5351 asection * input_section,
5352 bfd_byte * hit_data,
5353 asection * sym_sec,
5354 bfd_vma offset,
5355 bfd_signed_vma addend,
5356 bfd_vma val,
5357 char **error_message)
5358 {
5359 asection * s = 0;
5360 bfd_vma my_offset;
5361 long int ret_offset;
5362 struct elf_link_hash_entry * myh;
5363 struct elf32_arm_link_hash_table * globals;
5364
5365 myh = find_thumb_glue (info, name, error_message);
5366 if (myh == NULL)
5367 return FALSE;
5368
5369 globals = elf32_arm_hash_table (info);
5370
5371 BFD_ASSERT (globals != NULL);
5372 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
5373
5374 my_offset = myh->root.u.def.value;
5375
5376 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
5377 THUMB2ARM_GLUE_SECTION_NAME);
5378
5379 BFD_ASSERT (s != NULL);
5380 BFD_ASSERT (s->contents != NULL);
5381 BFD_ASSERT (s->output_section != NULL);
5382
5383 if ((my_offset & 0x01) == 0x01)
5384 {
5385 if (sym_sec != NULL
5386 && sym_sec->owner != NULL
5387 && !INTERWORK_FLAG (sym_sec->owner))
5388 {
5389 (*_bfd_error_handler)
5390 (_("%B(%s): warning: interworking not enabled.\n"
5391 " first occurrence: %B: thumb call to arm"),
5392 sym_sec->owner, input_bfd, name);
5393
5394 return FALSE;
5395 }
5396
5397 --my_offset;
5398 myh->root.u.def.value = my_offset;
5399
5400 put_thumb_insn (globals, output_bfd, (bfd_vma) t2a1_bx_pc_insn,
5401 s->contents + my_offset);
5402
5403 put_thumb_insn (globals, output_bfd, (bfd_vma) t2a2_noop_insn,
5404 s->contents + my_offset + 2);
5405
5406 ret_offset =
5407 /* Address of destination of the stub. */
5408 ((bfd_signed_vma) val)
5409 - ((bfd_signed_vma)
5410 /* Offset from the start of the current section
5411 to the start of the stubs. */
5412 (s->output_offset
5413 /* Offset of the start of this stub from the start of the stubs. */
5414 + my_offset
5415 /* Address of the start of the current section. */
5416 + s->output_section->vma)
5417 /* The branch instruction is 4 bytes into the stub. */
5418 + 4
5419 /* ARM branches work from the pc of the instruction + 8. */
5420 + 8);
5421
5422 put_arm_insn (globals, output_bfd,
5423 (bfd_vma) t2a3_b_insn | ((ret_offset >> 2) & 0x00FFFFFF),
5424 s->contents + my_offset + 4);
5425 }
5426
5427 BFD_ASSERT (my_offset <= globals->thumb_glue_size);
5428
5429 /* Now go back and fix up the original BL insn to point to here. */
5430 ret_offset =
5431 /* Address of where the stub is located. */
5432 (s->output_section->vma + s->output_offset + my_offset)
5433 /* Address of where the BL is located. */
5434 - (input_section->output_section->vma + input_section->output_offset
5435 + offset)
5436 /* Addend in the relocation. */
5437 - addend
5438 /* Biassing for PC-relative addressing. */
5439 - 8;
5440
5441 insert_thumb_branch (input_bfd, ret_offset, hit_data - input_section->vma);
5442
5443 return TRUE;
5444 }
5445
5446 /* Populate an Arm to Thumb stub. Returns the stub symbol. */
5447
5448 static struct elf_link_hash_entry *
5449 elf32_arm_create_thumb_stub (struct bfd_link_info * info,
5450 const char * name,
5451 bfd * input_bfd,
5452 bfd * output_bfd,
5453 asection * sym_sec,
5454 bfd_vma val,
5455 asection * s,
5456 char ** error_message)
5457 {
5458 bfd_vma my_offset;
5459 long int ret_offset;
5460 struct elf_link_hash_entry * myh;
5461 struct elf32_arm_link_hash_table * globals;
5462
5463 myh = find_arm_glue (info, name, error_message);
5464 if (myh == NULL)
5465 return NULL;
5466
5467 globals = elf32_arm_hash_table (info);
5468
5469 BFD_ASSERT (globals != NULL);
5470 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
5471
5472 my_offset = myh->root.u.def.value;
5473
5474 if ((my_offset & 0x01) == 0x01)
5475 {
5476 if (sym_sec != NULL
5477 && sym_sec->owner != NULL
5478 && !INTERWORK_FLAG (sym_sec->owner))
5479 {
5480 (*_bfd_error_handler)
5481 (_("%B(%s): warning: interworking not enabled.\n"
5482 " first occurrence: %B: arm call to thumb"),
5483 sym_sec->owner, input_bfd, name);
5484 }
5485
5486 --my_offset;
5487 myh->root.u.def.value = my_offset;
5488
5489 if (info->shared || globals->root.is_relocatable_executable
5490 || globals->pic_veneer)
5491 {
5492 /* For relocatable objects we can't use absolute addresses,
5493 so construct the address from a relative offset. */
5494 /* TODO: If the offset is small it's probably worth
5495 constructing the address with adds. */
5496 put_arm_insn (globals, output_bfd, (bfd_vma) a2t1p_ldr_insn,
5497 s->contents + my_offset);
5498 put_arm_insn (globals, output_bfd, (bfd_vma) a2t2p_add_pc_insn,
5499 s->contents + my_offset + 4);
5500 put_arm_insn (globals, output_bfd, (bfd_vma) a2t3p_bx_r12_insn,
5501 s->contents + my_offset + 8);
5502 /* Adjust the offset by 4 for the position of the add,
5503 and 8 for the pipeline offset. */
5504 ret_offset = (val - (s->output_offset
5505 + s->output_section->vma
5506 + my_offset + 12))
5507 | 1;
5508 bfd_put_32 (output_bfd, ret_offset,
5509 s->contents + my_offset + 12);
5510 }
5511 else if (globals->use_blx)
5512 {
5513 put_arm_insn (globals, output_bfd, (bfd_vma) a2t1v5_ldr_insn,
5514 s->contents + my_offset);
5515
5516 /* It's a thumb address. Add the low order bit. */
5517 bfd_put_32 (output_bfd, val | a2t2v5_func_addr_insn,
5518 s->contents + my_offset + 4);
5519 }
5520 else
5521 {
5522 put_arm_insn (globals, output_bfd, (bfd_vma) a2t1_ldr_insn,
5523 s->contents + my_offset);
5524
5525 put_arm_insn (globals, output_bfd, (bfd_vma) a2t2_bx_r12_insn,
5526 s->contents + my_offset + 4);
5527
5528 /* It's a thumb address. Add the low order bit. */
5529 bfd_put_32 (output_bfd, val | a2t3_func_addr_insn,
5530 s->contents + my_offset + 8);
5531
5532 my_offset += 12;
5533 }
5534 }
5535
5536 BFD_ASSERT (my_offset <= globals->arm_glue_size);
5537
5538 return myh;
5539 }
5540
5541 /* Arm code calling a Thumb function. */
5542
5543 static int
5544 elf32_arm_to_thumb_stub (struct bfd_link_info * info,
5545 const char * name,
5546 bfd * input_bfd,
5547 bfd * output_bfd,
5548 asection * input_section,
5549 bfd_byte * hit_data,
5550 asection * sym_sec,
5551 bfd_vma offset,
5552 bfd_signed_vma addend,
5553 bfd_vma val,
5554 char **error_message)
5555 {
5556 unsigned long int tmp;
5557 bfd_vma my_offset;
5558 asection * s;
5559 long int ret_offset;
5560 struct elf_link_hash_entry * myh;
5561 struct elf32_arm_link_hash_table * globals;
5562
5563 globals = elf32_arm_hash_table (info);
5564
5565 BFD_ASSERT (globals != NULL);
5566 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
5567
5568 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
5569 ARM2THUMB_GLUE_SECTION_NAME);
5570 BFD_ASSERT (s != NULL);
5571 BFD_ASSERT (s->contents != NULL);
5572 BFD_ASSERT (s->output_section != NULL);
5573
5574 myh = elf32_arm_create_thumb_stub (info, name, input_bfd, output_bfd,
5575 sym_sec, val, s, error_message);
5576 if (!myh)
5577 return FALSE;
5578
5579 my_offset = myh->root.u.def.value;
5580 tmp = bfd_get_32 (input_bfd, hit_data);
5581 tmp = tmp & 0xFF000000;
5582
5583 /* Somehow these are both 4 too far, so subtract 8. */
5584 ret_offset = (s->output_offset
5585 + my_offset
5586 + s->output_section->vma
5587 - (input_section->output_offset
5588 + input_section->output_section->vma
5589 + offset + addend)
5590 - 8);
5591
5592 tmp = tmp | ((ret_offset >> 2) & 0x00FFFFFF);
5593
5594 bfd_put_32 (output_bfd, (bfd_vma) tmp, hit_data - input_section->vma);
5595
5596 return TRUE;
5597 }
5598
5599 /* Populate Arm stub for an exported Thumb function. */
5600
5601 static bfd_boolean
5602 elf32_arm_to_thumb_export_stub (struct elf_link_hash_entry *h, void * inf)
5603 {
5604 struct bfd_link_info * info = (struct bfd_link_info *) inf;
5605 asection * s;
5606 struct elf_link_hash_entry * myh;
5607 struct elf32_arm_link_hash_entry *eh;
5608 struct elf32_arm_link_hash_table * globals;
5609 asection *sec;
5610 bfd_vma val;
5611 char *error_message;
5612
5613 eh = elf32_arm_hash_entry (h);
5614 /* Allocate stubs for exported Thumb functions on v4t. */
5615 if (eh->export_glue == NULL)
5616 return TRUE;
5617
5618 globals = elf32_arm_hash_table (info);
5619
5620 BFD_ASSERT (globals != NULL);
5621 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
5622
5623 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
5624 ARM2THUMB_GLUE_SECTION_NAME);
5625 BFD_ASSERT (s != NULL);
5626 BFD_ASSERT (s->contents != NULL);
5627 BFD_ASSERT (s->output_section != NULL);
5628
5629 sec = eh->export_glue->root.u.def.section;
5630
5631 BFD_ASSERT (sec->output_section != NULL);
5632
5633 val = eh->export_glue->root.u.def.value + sec->output_offset
5634 + sec->output_section->vma;
5635
5636 myh = elf32_arm_create_thumb_stub (info, h->root.root.string,
5637 h->root.u.def.section->owner,
5638 globals->obfd, sec, val, s,
5639 &error_message);
5640 BFD_ASSERT (myh);
5641 return TRUE;
5642 }
5643
5644 /* Populate ARMv4 BX veneers. Returns the absolute adress of the veneer. */
5645
5646 static bfd_vma
5647 elf32_arm_bx_glue (struct bfd_link_info * info, int reg)
5648 {
5649 bfd_byte *p;
5650 bfd_vma glue_addr;
5651 asection *s;
5652 struct elf32_arm_link_hash_table *globals;
5653
5654 globals = elf32_arm_hash_table (info);
5655
5656 BFD_ASSERT (globals != NULL);
5657 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
5658
5659 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
5660 ARM_BX_GLUE_SECTION_NAME);
5661 BFD_ASSERT (s != NULL);
5662 BFD_ASSERT (s->contents != NULL);
5663 BFD_ASSERT (s->output_section != NULL);
5664
5665 BFD_ASSERT (globals->bx_glue_offset[reg] & 2);
5666
5667 glue_addr = globals->bx_glue_offset[reg] & ~(bfd_vma)3;
5668
5669 if ((globals->bx_glue_offset[reg] & 1) == 0)
5670 {
5671 p = s->contents + glue_addr;
5672 bfd_put_32 (globals->obfd, armbx1_tst_insn + (reg << 16), p);
5673 bfd_put_32 (globals->obfd, armbx2_moveq_insn + reg, p + 4);
5674 bfd_put_32 (globals->obfd, armbx3_bx_insn + reg, p + 8);
5675 globals->bx_glue_offset[reg] |= 1;
5676 }
5677
5678 return glue_addr + s->output_section->vma + s->output_offset;
5679 }
5680
5681 /* Generate Arm stubs for exported Thumb symbols. */
5682 static void
5683 elf32_arm_begin_write_processing (bfd *abfd ATTRIBUTE_UNUSED,
5684 struct bfd_link_info *link_info)
5685 {
5686 struct elf32_arm_link_hash_table * globals;
5687
5688 if (link_info == NULL)
5689 /* Ignore this if we are not called by the ELF backend linker. */
5690 return;
5691
5692 globals = elf32_arm_hash_table (link_info);
5693 /* If blx is available then exported Thumb symbols are OK and there is
5694 nothing to do. */
5695 if (globals->use_blx)
5696 return;
5697
5698 elf_link_hash_traverse (&globals->root, elf32_arm_to_thumb_export_stub,
5699 link_info);
5700 }
5701
5702 /* Some relocations map to different relocations depending on the
5703 target. Return the real relocation. */
5704
5705 static int
5706 arm_real_reloc_type (struct elf32_arm_link_hash_table * globals,
5707 int r_type)
5708 {
5709 switch (r_type)
5710 {
5711 case R_ARM_TARGET1:
5712 if (globals->target1_is_rel)
5713 return R_ARM_REL32;
5714 else
5715 return R_ARM_ABS32;
5716
5717 case R_ARM_TARGET2:
5718 return globals->target2_reloc;
5719
5720 default:
5721 return r_type;
5722 }
5723 }
5724
5725 /* Return the base VMA address which should be subtracted from real addresses
5726 when resolving @dtpoff relocation.
5727 This is PT_TLS segment p_vaddr. */
5728
5729 static bfd_vma
5730 dtpoff_base (struct bfd_link_info *info)
5731 {
5732 /* If tls_sec is NULL, we should have signalled an error already. */
5733 if (elf_hash_table (info)->tls_sec == NULL)
5734 return 0;
5735 return elf_hash_table (info)->tls_sec->vma;
5736 }
5737
5738 /* Return the relocation value for @tpoff relocation
5739 if STT_TLS virtual address is ADDRESS. */
5740
5741 static bfd_vma
5742 tpoff (struct bfd_link_info *info, bfd_vma address)
5743 {
5744 struct elf_link_hash_table *htab = elf_hash_table (info);
5745 bfd_vma base;
5746
5747 /* If tls_sec is NULL, we should have signalled an error already. */
5748 if (htab->tls_sec == NULL)
5749 return 0;
5750 base = align_power ((bfd_vma) TCB_SIZE, htab->tls_sec->alignment_power);
5751 return address - htab->tls_sec->vma + base;
5752 }
5753
5754 /* Perform an R_ARM_ABS12 relocation on the field pointed to by DATA.
5755 VALUE is the relocation value. */
5756
5757 static bfd_reloc_status_type
5758 elf32_arm_abs12_reloc (bfd *abfd, void *data, bfd_vma value)
5759 {
5760 if (value > 0xfff)
5761 return bfd_reloc_overflow;
5762
5763 value |= bfd_get_32 (abfd, data) & 0xfffff000;
5764 bfd_put_32 (abfd, value, data);
5765 return bfd_reloc_ok;
5766 }
5767
5768 /* For a given value of n, calculate the value of G_n as required to
5769 deal with group relocations. We return it in the form of an
5770 encoded constant-and-rotation, together with the final residual. If n is
5771 specified as less than zero, then final_residual is filled with the
5772 input value and no further action is performed. */
5773
5774 static bfd_vma
5775 calculate_group_reloc_mask (bfd_vma value, int n, bfd_vma *final_residual)
5776 {
5777 int current_n;
5778 bfd_vma g_n;
5779 bfd_vma encoded_g_n = 0;
5780 bfd_vma residual = value; /* Also known as Y_n. */
5781
5782 for (current_n = 0; current_n <= n; current_n++)
5783 {
5784 int shift;
5785
5786 /* Calculate which part of the value to mask. */
5787 if (residual == 0)
5788 shift = 0;
5789 else
5790 {
5791 int msb;
5792
5793 /* Determine the most significant bit in the residual and
5794 align the resulting value to a 2-bit boundary. */
5795 for (msb = 30; msb >= 0; msb -= 2)
5796 if (residual & (3 << msb))
5797 break;
5798
5799 /* The desired shift is now (msb - 6), or zero, whichever
5800 is the greater. */
5801 shift = msb - 6;
5802 if (shift < 0)
5803 shift = 0;
5804 }
5805
5806 /* Calculate g_n in 32-bit as well as encoded constant+rotation form. */
5807 g_n = residual & (0xff << shift);
5808 encoded_g_n = (g_n >> shift)
5809 | ((g_n <= 0xff ? 0 : (32 - shift) / 2) << 8);
5810
5811 /* Calculate the residual for the next time around. */
5812 residual &= ~g_n;
5813 }
5814
5815 *final_residual = residual;
5816
5817 return encoded_g_n;
5818 }
5819
5820 /* Given an ARM instruction, determine whether it is an ADD or a SUB.
5821 Returns 1 if it is an ADD, -1 if it is a SUB, and 0 otherwise. */
5822
5823 static int
5824 identify_add_or_sub (bfd_vma insn)
5825 {
5826 int opcode = insn & 0x1e00000;
5827
5828 if (opcode == 1 << 23) /* ADD */
5829 return 1;
5830
5831 if (opcode == 1 << 22) /* SUB */
5832 return -1;
5833
5834 return 0;
5835 }
5836
5837 /* Perform a relocation as part of a final link. */
5838
5839 static bfd_reloc_status_type
5840 elf32_arm_final_link_relocate (reloc_howto_type * howto,
5841 bfd * input_bfd,
5842 bfd * output_bfd,
5843 asection * input_section,
5844 bfd_byte * contents,
5845 Elf_Internal_Rela * rel,
5846 bfd_vma value,
5847 struct bfd_link_info * info,
5848 asection * sym_sec,
5849 const char * sym_name,
5850 int sym_flags,
5851 struct elf_link_hash_entry * h,
5852 bfd_boolean * unresolved_reloc_p,
5853 char ** error_message)
5854 {
5855 unsigned long r_type = howto->type;
5856 unsigned long r_symndx;
5857 bfd_byte * hit_data = contents + rel->r_offset;
5858 bfd * dynobj = NULL;
5859 Elf_Internal_Shdr * symtab_hdr;
5860 struct elf_link_hash_entry ** sym_hashes;
5861 bfd_vma * local_got_offsets;
5862 asection * sgot = NULL;
5863 asection * splt = NULL;
5864 asection * sreloc = NULL;
5865 bfd_vma addend;
5866 bfd_signed_vma signed_addend;
5867 struct elf32_arm_link_hash_table * globals;
5868
5869 globals = elf32_arm_hash_table (info);
5870
5871 BFD_ASSERT (is_arm_elf (input_bfd));
5872
5873 /* Some relocation types map to different relocations depending on the
5874 target. We pick the right one here. */
5875 r_type = arm_real_reloc_type (globals, r_type);
5876 if (r_type != howto->type)
5877 howto = elf32_arm_howto_from_type (r_type);
5878
5879 /* If the start address has been set, then set the EF_ARM_HASENTRY
5880 flag. Setting this more than once is redundant, but the cost is
5881 not too high, and it keeps the code simple.
5882
5883 The test is done here, rather than somewhere else, because the
5884 start address is only set just before the final link commences.
5885
5886 Note - if the user deliberately sets a start address of 0, the
5887 flag will not be set. */
5888 if (bfd_get_start_address (output_bfd) != 0)
5889 elf_elfheader (output_bfd)->e_flags |= EF_ARM_HASENTRY;
5890
5891 dynobj = elf_hash_table (info)->dynobj;
5892 if (dynobj)
5893 {
5894 sgot = bfd_get_section_by_name (dynobj, ".got");
5895 splt = bfd_get_section_by_name (dynobj, ".plt");
5896 }
5897 symtab_hdr = & elf_symtab_hdr (input_bfd);
5898 sym_hashes = elf_sym_hashes (input_bfd);
5899 local_got_offsets = elf_local_got_offsets (input_bfd);
5900 r_symndx = ELF32_R_SYM (rel->r_info);
5901
5902 if (globals->use_rel)
5903 {
5904 addend = bfd_get_32 (input_bfd, hit_data) & howto->src_mask;
5905
5906 if (addend & ((howto->src_mask + 1) >> 1))
5907 {
5908 signed_addend = -1;
5909 signed_addend &= ~ howto->src_mask;
5910 signed_addend |= addend;
5911 }
5912 else
5913 signed_addend = addend;
5914 }
5915 else
5916 addend = signed_addend = rel->r_addend;
5917
5918 switch (r_type)
5919 {
5920 case R_ARM_NONE:
5921 /* We don't need to find a value for this symbol. It's just a
5922 marker. */
5923 *unresolved_reloc_p = FALSE;
5924 return bfd_reloc_ok;
5925
5926 case R_ARM_ABS12:
5927 if (!globals->vxworks_p)
5928 return elf32_arm_abs12_reloc (input_bfd, hit_data, value + addend);
5929
5930 case R_ARM_PC24:
5931 case R_ARM_ABS32:
5932 case R_ARM_ABS32_NOI:
5933 case R_ARM_REL32:
5934 case R_ARM_REL32_NOI:
5935 case R_ARM_CALL:
5936 case R_ARM_JUMP24:
5937 case R_ARM_XPC25:
5938 case R_ARM_PREL31:
5939 case R_ARM_PLT32:
5940 /* Handle relocations which should use the PLT entry. ABS32/REL32
5941 will use the symbol's value, which may point to a PLT entry, but we
5942 don't need to handle that here. If we created a PLT entry, all
5943 branches in this object should go to it. */
5944 if ((r_type != R_ARM_ABS32 && r_type != R_ARM_REL32
5945 && r_type != R_ARM_ABS32_NOI && r_type != R_ARM_REL32_NOI)
5946 && h != NULL
5947 && splt != NULL
5948 && h->plt.offset != (bfd_vma) -1)
5949 {
5950 /* If we've created a .plt section, and assigned a PLT entry to
5951 this function, it should not be known to bind locally. If
5952 it were, we would have cleared the PLT entry. */
5953 BFD_ASSERT (!SYMBOL_CALLS_LOCAL (info, h));
5954
5955 value = (splt->output_section->vma
5956 + splt->output_offset
5957 + h->plt.offset);
5958 *unresolved_reloc_p = FALSE;
5959 return _bfd_final_link_relocate (howto, input_bfd, input_section,
5960 contents, rel->r_offset, value,
5961 rel->r_addend);
5962 }
5963
5964 /* When generating a shared object or relocatable executable, these
5965 relocations are copied into the output file to be resolved at
5966 run time. */
5967 if ((info->shared || globals->root.is_relocatable_executable)
5968 && (input_section->flags & SEC_ALLOC)
5969 && !(elf32_arm_hash_table (info)->vxworks_p
5970 && strcmp (input_section->output_section->name,
5971 ".tls_vars") == 0)
5972 && ((r_type != R_ARM_REL32 && r_type != R_ARM_REL32_NOI)
5973 || !SYMBOL_CALLS_LOCAL (info, h))
5974 && (h == NULL
5975 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
5976 || h->root.type != bfd_link_hash_undefweak)
5977 && r_type != R_ARM_PC24
5978 && r_type != R_ARM_CALL
5979 && r_type != R_ARM_JUMP24
5980 && r_type != R_ARM_PREL31
5981 && r_type != R_ARM_PLT32)
5982 {
5983 Elf_Internal_Rela outrel;
5984 bfd_byte *loc;
5985 bfd_boolean skip, relocate;
5986
5987 *unresolved_reloc_p = FALSE;
5988
5989 if (sreloc == NULL)
5990 {
5991 sreloc = _bfd_elf_get_dynamic_reloc_section (input_bfd, input_section,
5992 ! globals->use_rel);
5993
5994 if (sreloc == NULL)
5995 return bfd_reloc_notsupported;
5996 }
5997
5998 skip = FALSE;
5999 relocate = FALSE;
6000
6001 outrel.r_addend = addend;
6002 outrel.r_offset =
6003 _bfd_elf_section_offset (output_bfd, info, input_section,
6004 rel->r_offset);
6005 if (outrel.r_offset == (bfd_vma) -1)
6006 skip = TRUE;
6007 else if (outrel.r_offset == (bfd_vma) -2)
6008 skip = TRUE, relocate = TRUE;
6009 outrel.r_offset += (input_section->output_section->vma
6010 + input_section->output_offset);
6011
6012 if (skip)
6013 memset (&outrel, 0, sizeof outrel);
6014 else if (h != NULL
6015 && h->dynindx != -1
6016 && (!info->shared
6017 || !info->symbolic
6018 || !h->def_regular))
6019 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
6020 else
6021 {
6022 int symbol;
6023
6024 /* This symbol is local, or marked to become local. */
6025 if (sym_flags == STT_ARM_TFUNC)
6026 value |= 1;
6027 if (globals->symbian_p)
6028 {
6029 asection *osec;
6030
6031 /* On Symbian OS, the data segment and text segement
6032 can be relocated independently. Therefore, we
6033 must indicate the segment to which this
6034 relocation is relative. The BPABI allows us to
6035 use any symbol in the right segment; we just use
6036 the section symbol as it is convenient. (We
6037 cannot use the symbol given by "h" directly as it
6038 will not appear in the dynamic symbol table.)
6039
6040 Note that the dynamic linker ignores the section
6041 symbol value, so we don't subtract osec->vma
6042 from the emitted reloc addend. */
6043 if (sym_sec)
6044 osec = sym_sec->output_section;
6045 else
6046 osec = input_section->output_section;
6047 symbol = elf_section_data (osec)->dynindx;
6048 if (symbol == 0)
6049 {
6050 struct elf_link_hash_table *htab = elf_hash_table (info);
6051
6052 if ((osec->flags & SEC_READONLY) == 0
6053 && htab->data_index_section != NULL)
6054 osec = htab->data_index_section;
6055 else
6056 osec = htab->text_index_section;
6057 symbol = elf_section_data (osec)->dynindx;
6058 }
6059 BFD_ASSERT (symbol != 0);
6060 }
6061 else
6062 /* On SVR4-ish systems, the dynamic loader cannot
6063 relocate the text and data segments independently,
6064 so the symbol does not matter. */
6065 symbol = 0;
6066 outrel.r_info = ELF32_R_INFO (symbol, R_ARM_RELATIVE);
6067 if (globals->use_rel)
6068 relocate = TRUE;
6069 else
6070 outrel.r_addend += value;
6071 }
6072
6073 loc = sreloc->contents;
6074 loc += sreloc->reloc_count++ * RELOC_SIZE (globals);
6075 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
6076
6077 /* If this reloc is against an external symbol, we do not want to
6078 fiddle with the addend. Otherwise, we need to include the symbol
6079 value so that it becomes an addend for the dynamic reloc. */
6080 if (! relocate)
6081 return bfd_reloc_ok;
6082
6083 return _bfd_final_link_relocate (howto, input_bfd, input_section,
6084 contents, rel->r_offset, value,
6085 (bfd_vma) 0);
6086 }
6087 else switch (r_type)
6088 {
6089 case R_ARM_ABS12:
6090 return elf32_arm_abs12_reloc (input_bfd, hit_data, value + addend);
6091
6092 case R_ARM_XPC25: /* Arm BLX instruction. */
6093 case R_ARM_CALL:
6094 case R_ARM_JUMP24:
6095 case R_ARM_PC24: /* Arm B/BL instruction. */
6096 case R_ARM_PLT32:
6097 {
6098 bfd_vma from;
6099 bfd_signed_vma branch_offset;
6100 struct elf32_arm_stub_hash_entry *stub_entry = NULL;
6101
6102 from = (input_section->output_section->vma
6103 + input_section->output_offset
6104 + rel->r_offset);
6105 branch_offset = (bfd_signed_vma)(value - from);
6106
6107 if (r_type == R_ARM_XPC25)
6108 {
6109 /* Check for Arm calling Arm function. */
6110 /* FIXME: Should we translate the instruction into a BL
6111 instruction instead ? */
6112 if (sym_flags != STT_ARM_TFUNC)
6113 (*_bfd_error_handler)
6114 (_("\%B: Warning: Arm BLX instruction targets Arm function '%s'."),
6115 input_bfd,
6116 h ? h->root.root.string : "(local)");
6117 }
6118 else if (r_type != R_ARM_CALL)
6119 {
6120 /* Check for Arm calling Thumb function. */
6121 if (sym_flags == STT_ARM_TFUNC)
6122 {
6123 if (elf32_arm_to_thumb_stub (info, sym_name, input_bfd,
6124 output_bfd, input_section,
6125 hit_data, sym_sec, rel->r_offset,
6126 signed_addend, value,
6127 error_message))
6128 return bfd_reloc_ok;
6129 else
6130 return bfd_reloc_dangerous;
6131 }
6132 }
6133
6134 /* Check if a stub has to be inserted because the
6135 destination is too far or we are changing mode. */
6136 if (r_type == R_ARM_CALL)
6137 {
6138 if (branch_offset > ARM_MAX_FWD_BRANCH_OFFSET
6139 || branch_offset < ARM_MAX_BWD_BRANCH_OFFSET
6140 || sym_flags == STT_ARM_TFUNC)
6141 {
6142 /* The target is out of reach, so redirect the
6143 branch to the local stub for this function. */
6144
6145 stub_entry = elf32_arm_get_stub_entry (input_section,
6146 sym_sec, h,
6147 rel, globals);
6148 if (stub_entry != NULL)
6149 value = (stub_entry->stub_offset
6150 + stub_entry->stub_sec->output_offset
6151 + stub_entry->stub_sec->output_section->vma);
6152 }
6153 }
6154
6155 /* The ARM ELF ABI says that this reloc is computed as: S - P + A
6156 where:
6157 S is the address of the symbol in the relocation.
6158 P is address of the instruction being relocated.
6159 A is the addend (extracted from the instruction) in bytes.
6160
6161 S is held in 'value'.
6162 P is the base address of the section containing the
6163 instruction plus the offset of the reloc into that
6164 section, ie:
6165 (input_section->output_section->vma +
6166 input_section->output_offset +
6167 rel->r_offset).
6168 A is the addend, converted into bytes, ie:
6169 (signed_addend * 4)
6170
6171 Note: None of these operations have knowledge of the pipeline
6172 size of the processor, thus it is up to the assembler to
6173 encode this information into the addend. */
6174 value -= (input_section->output_section->vma
6175 + input_section->output_offset);
6176 value -= rel->r_offset;
6177 if (globals->use_rel)
6178 value += (signed_addend << howto->size);
6179 else
6180 /* RELA addends do not have to be adjusted by howto->size. */
6181 value += signed_addend;
6182
6183 signed_addend = value;
6184 signed_addend >>= howto->rightshift;
6185
6186 /* A branch to an undefined weak symbol is turned into a jump to
6187 the next instruction. */
6188 if (h && h->root.type == bfd_link_hash_undefweak)
6189 {
6190 value = (bfd_get_32 (input_bfd, hit_data) & 0xf0000000)
6191 | 0x0affffff;
6192 }
6193 else
6194 {
6195 /* Perform a signed range check. */
6196 if ( signed_addend > ((bfd_signed_vma) (howto->dst_mask >> 1))
6197 || signed_addend < - ((bfd_signed_vma) ((howto->dst_mask + 1) >> 1)))
6198 return bfd_reloc_overflow;
6199
6200 addend = (value & 2);
6201
6202 value = (signed_addend & howto->dst_mask)
6203 | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask));
6204
6205 /* Set the H bit in the BLX instruction. */
6206 if (sym_flags == STT_ARM_TFUNC)
6207 {
6208 if (addend)
6209 value |= (1 << 24);
6210 else
6211 value &= ~(bfd_vma)(1 << 24);
6212 }
6213 if (r_type == R_ARM_CALL)
6214 {
6215 /* Select the correct instruction (BL or BLX). */
6216 /* Only if we are not handling a BL to a stub. In this
6217 case, mode switching is performed by the stub. */
6218 if (sym_flags == STT_ARM_TFUNC && !stub_entry)
6219 value |= (1 << 28);
6220 else
6221 {
6222 value &= ~(bfd_vma)(1 << 28);
6223 value |= (1 << 24);
6224 }
6225 }
6226 }
6227 }
6228 break;
6229
6230 case R_ARM_ABS32:
6231 value += addend;
6232 if (sym_flags == STT_ARM_TFUNC)
6233 value |= 1;
6234 break;
6235
6236 case R_ARM_ABS32_NOI:
6237 value += addend;
6238 break;
6239
6240 case R_ARM_REL32:
6241 value += addend;
6242 if (sym_flags == STT_ARM_TFUNC)
6243 value |= 1;
6244 value -= (input_section->output_section->vma
6245 + input_section->output_offset + rel->r_offset);
6246 break;
6247
6248 case R_ARM_REL32_NOI:
6249 value += addend;
6250 value -= (input_section->output_section->vma
6251 + input_section->output_offset + rel->r_offset);
6252 break;
6253
6254 case R_ARM_PREL31:
6255 value -= (input_section->output_section->vma
6256 + input_section->output_offset + rel->r_offset);
6257 value += signed_addend;
6258 if (! h || h->root.type != bfd_link_hash_undefweak)
6259 {
6260 /* Check for overflow. */
6261 if ((value ^ (value >> 1)) & (1 << 30))
6262 return bfd_reloc_overflow;
6263 }
6264 value &= 0x7fffffff;
6265 value |= (bfd_get_32 (input_bfd, hit_data) & 0x80000000);
6266 if (sym_flags == STT_ARM_TFUNC)
6267 value |= 1;
6268 break;
6269 }
6270
6271 bfd_put_32 (input_bfd, value, hit_data);
6272 return bfd_reloc_ok;
6273
6274 case R_ARM_ABS8:
6275 value += addend;
6276 if ((long) value > 0x7f || (long) value < -0x80)
6277 return bfd_reloc_overflow;
6278
6279 bfd_put_8 (input_bfd, value, hit_data);
6280 return bfd_reloc_ok;
6281
6282 case R_ARM_ABS16:
6283 value += addend;
6284
6285 if ((long) value > 0x7fff || (long) value < -0x8000)
6286 return bfd_reloc_overflow;
6287
6288 bfd_put_16 (input_bfd, value, hit_data);
6289 return bfd_reloc_ok;
6290
6291 case R_ARM_THM_ABS5:
6292 /* Support ldr and str instructions for the thumb. */
6293 if (globals->use_rel)
6294 {
6295 /* Need to refetch addend. */
6296 addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
6297 /* ??? Need to determine shift amount from operand size. */
6298 addend >>= howto->rightshift;
6299 }
6300 value += addend;
6301
6302 /* ??? Isn't value unsigned? */
6303 if ((long) value > 0x1f || (long) value < -0x10)
6304 return bfd_reloc_overflow;
6305
6306 /* ??? Value needs to be properly shifted into place first. */
6307 value |= bfd_get_16 (input_bfd, hit_data) & 0xf83f;
6308 bfd_put_16 (input_bfd, value, hit_data);
6309 return bfd_reloc_ok;
6310
6311 case R_ARM_THM_ALU_PREL_11_0:
6312 /* Corresponds to: addw.w reg, pc, #offset (and similarly for subw). */
6313 {
6314 bfd_vma insn;
6315 bfd_signed_vma relocation;
6316
6317 insn = (bfd_get_16 (input_bfd, hit_data) << 16)
6318 | bfd_get_16 (input_bfd, hit_data + 2);
6319
6320 if (globals->use_rel)
6321 {
6322 signed_addend = (insn & 0xff) | ((insn & 0x7000) >> 4)
6323 | ((insn & (1 << 26)) >> 15);
6324 if (insn & 0xf00000)
6325 signed_addend = -signed_addend;
6326 }
6327
6328 relocation = value + signed_addend;
6329 relocation -= (input_section->output_section->vma
6330 + input_section->output_offset
6331 + rel->r_offset);
6332
6333 value = abs (relocation);
6334
6335 if (value >= 0x1000)
6336 return bfd_reloc_overflow;
6337
6338 insn = (insn & 0xfb0f8f00) | (value & 0xff)
6339 | ((value & 0x700) << 4)
6340 | ((value & 0x800) << 15);
6341 if (relocation < 0)
6342 insn |= 0xa00000;
6343
6344 bfd_put_16 (input_bfd, insn >> 16, hit_data);
6345 bfd_put_16 (input_bfd, insn & 0xffff, hit_data + 2);
6346
6347 return bfd_reloc_ok;
6348 }
6349
6350 case R_ARM_THM_PC12:
6351 /* Corresponds to: ldr.w reg, [pc, #offset]. */
6352 {
6353 bfd_vma insn;
6354 bfd_signed_vma relocation;
6355
6356 insn = (bfd_get_16 (input_bfd, hit_data) << 16)
6357 | bfd_get_16 (input_bfd, hit_data + 2);
6358
6359 if (globals->use_rel)
6360 {
6361 signed_addend = insn & 0xfff;
6362 if (!(insn & (1 << 23)))
6363 signed_addend = -signed_addend;
6364 }
6365
6366 relocation = value + signed_addend;
6367 relocation -= (input_section->output_section->vma
6368 + input_section->output_offset
6369 + rel->r_offset);
6370
6371 value = abs (relocation);
6372
6373 if (value >= 0x1000)
6374 return bfd_reloc_overflow;
6375
6376 insn = (insn & 0xff7ff000) | value;
6377 if (relocation >= 0)
6378 insn |= (1 << 23);
6379
6380 bfd_put_16 (input_bfd, insn >> 16, hit_data);
6381 bfd_put_16 (input_bfd, insn & 0xffff, hit_data + 2);
6382
6383 return bfd_reloc_ok;
6384 }
6385
6386 case R_ARM_THM_XPC22:
6387 case R_ARM_THM_CALL:
6388 case R_ARM_THM_JUMP24:
6389 /* Thumb BL (branch long instruction). */
6390 {
6391 bfd_vma relocation;
6392 bfd_vma reloc_sign;
6393 bfd_boolean overflow = FALSE;
6394 bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
6395 bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
6396 bfd_signed_vma reloc_signed_max;
6397 bfd_signed_vma reloc_signed_min;
6398 bfd_vma check;
6399 bfd_signed_vma signed_check;
6400 int bitsize;
6401 int thumb2 = using_thumb2 (globals);
6402
6403 /* A branch to an undefined weak symbol is turned into a jump to
6404 the next instruction unless a PLT entry will be created. */
6405 if (h && h->root.type == bfd_link_hash_undefweak
6406 && !(splt != NULL && h->plt.offset != (bfd_vma) -1))
6407 {
6408 bfd_put_16 (input_bfd, 0xe000, hit_data);
6409 bfd_put_16 (input_bfd, 0xbf00, hit_data + 2);
6410 return bfd_reloc_ok;
6411 }
6412
6413 /* Fetch the addend. We use the Thumb-2 encoding (backwards compatible
6414 with Thumb-1) involving the J1 and J2 bits. */
6415 if (globals->use_rel)
6416 {
6417 bfd_vma s = (upper_insn & (1 << 10)) >> 10;
6418 bfd_vma upper = upper_insn & 0x3ff;
6419 bfd_vma lower = lower_insn & 0x7ff;
6420 bfd_vma j1 = (lower_insn & (1 << 13)) >> 13;
6421 bfd_vma j2 = (lower_insn & (1 << 11)) >> 11;
6422 bfd_vma i1 = j1 ^ s ? 0 : 1;
6423 bfd_vma i2 = j2 ^ s ? 0 : 1;
6424
6425 addend = (i1 << 23) | (i2 << 22) | (upper << 12) | (lower << 1);
6426 /* Sign extend. */
6427 addend = (addend | ((s ? 0 : 1) << 24)) - (1 << 24);
6428
6429 signed_addend = addend;
6430 }
6431
6432 if (r_type == R_ARM_THM_XPC22)
6433 {
6434 /* Check for Thumb to Thumb call. */
6435 /* FIXME: Should we translate the instruction into a BL
6436 instruction instead ? */
6437 if (sym_flags == STT_ARM_TFUNC)
6438 (*_bfd_error_handler)
6439 (_("%B: Warning: Thumb BLX instruction targets thumb function '%s'."),
6440 input_bfd,
6441 h ? h->root.root.string : "(local)");
6442 }
6443 else
6444 {
6445 /* If it is not a call to Thumb, assume call to Arm.
6446 If it is a call relative to a section name, then it is not a
6447 function call at all, but rather a long jump. Calls through
6448 the PLT do not require stubs. */
6449 if (sym_flags != STT_ARM_TFUNC && sym_flags != STT_SECTION
6450 && (h == NULL || splt == NULL
6451 || h->plt.offset == (bfd_vma) -1))
6452 {
6453 if (globals->use_blx && r_type == R_ARM_THM_CALL)
6454 {
6455 /* Convert BL to BLX. */
6456 lower_insn = (lower_insn & ~0x1000) | 0x0800;
6457 }
6458 else if (r_type != R_ARM_THM_CALL)
6459 {
6460 if (elf32_thumb_to_arm_stub
6461 (info, sym_name, input_bfd, output_bfd, input_section,
6462 hit_data, sym_sec, rel->r_offset, signed_addend, value,
6463 error_message))
6464 return bfd_reloc_ok;
6465 else
6466 return bfd_reloc_dangerous;
6467 }
6468 }
6469 else if (sym_flags == STT_ARM_TFUNC && globals->use_blx
6470 && r_type == R_ARM_THM_CALL)
6471 {
6472 /* Make sure this is a BL. */
6473 lower_insn |= 0x1800;
6474 }
6475 }
6476
6477 /* Handle calls via the PLT. */
6478 if (h != NULL && splt != NULL && h->plt.offset != (bfd_vma) -1)
6479 {
6480 value = (splt->output_section->vma
6481 + splt->output_offset
6482 + h->plt.offset);
6483 if (globals->use_blx && r_type == R_ARM_THM_CALL)
6484 {
6485 /* If the Thumb BLX instruction is available, convert the
6486 BL to a BLX instruction to call the ARM-mode PLT entry. */
6487 lower_insn = (lower_insn & ~0x1000) | 0x0800;
6488 }
6489 else
6490 /* Target the Thumb stub before the ARM PLT entry. */
6491 value -= PLT_THUMB_STUB_SIZE;
6492 *unresolved_reloc_p = FALSE;
6493 }
6494
6495 if (r_type == R_ARM_THM_CALL)
6496 {
6497 /* Check if a stub has to be inserted because the destination
6498 is too far. */
6499 bfd_vma from;
6500 bfd_signed_vma branch_offset;
6501 struct elf32_arm_stub_hash_entry *stub_entry = NULL;
6502
6503 from = (input_section->output_section->vma
6504 + input_section->output_offset
6505 + rel->r_offset);
6506 branch_offset = (bfd_signed_vma)(value - from);
6507
6508 if ((!thumb2
6509 && (branch_offset > THM_MAX_FWD_BRANCH_OFFSET
6510 || (branch_offset < THM_MAX_BWD_BRANCH_OFFSET)))
6511 ||
6512 (thumb2
6513 && (branch_offset > THM2_MAX_FWD_BRANCH_OFFSET
6514 || (branch_offset < THM2_MAX_BWD_BRANCH_OFFSET)))
6515 || ((sym_flags != STT_ARM_TFUNC) && !globals->use_blx))
6516 {
6517 /* The target is out of reach or we are changing modes, so
6518 redirect the branch to the local stub for this
6519 function. */
6520 stub_entry = elf32_arm_get_stub_entry (input_section,
6521 sym_sec, h,
6522 rel, globals);
6523 if (stub_entry != NULL)
6524 value = (stub_entry->stub_offset
6525 + stub_entry->stub_sec->output_offset
6526 + stub_entry->stub_sec->output_section->vma);
6527
6528 /* If this call becomes a call to Arm, force BLX. */
6529 if (globals->use_blx)
6530 {
6531 if ((stub_entry
6532 && !arm_stub_is_thumb (stub_entry->stub_type))
6533 || (sym_flags != STT_ARM_TFUNC))
6534 lower_insn = (lower_insn & ~0x1000) | 0x0800;
6535 }
6536 }
6537 }
6538
6539 relocation = value + signed_addend;
6540
6541 relocation -= (input_section->output_section->vma
6542 + input_section->output_offset
6543 + rel->r_offset);
6544
6545 check = relocation >> howto->rightshift;
6546
6547 /* If this is a signed value, the rightshift just dropped
6548 leading 1 bits (assuming twos complement). */
6549 if ((bfd_signed_vma) relocation >= 0)
6550 signed_check = check;
6551 else
6552 signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
6553
6554 /* Calculate the permissable maximum and minimum values for
6555 this relocation according to whether we're relocating for
6556 Thumb-2 or not. */
6557 bitsize = howto->bitsize;
6558 if (!thumb2)
6559 bitsize -= 2;
6560 reloc_signed_max = ((1 << (bitsize - 1)) - 1) >> howto->rightshift;
6561 reloc_signed_min = ~reloc_signed_max;
6562
6563 /* Assumes two's complement. */
6564 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
6565 overflow = TRUE;
6566
6567 if ((lower_insn & 0x5000) == 0x4000)
6568 /* For a BLX instruction, make sure that the relocation is rounded up
6569 to a word boundary. This follows the semantics of the instruction
6570 which specifies that bit 1 of the target address will come from bit
6571 1 of the base address. */
6572 relocation = (relocation + 2) & ~ 3;
6573
6574 /* Put RELOCATION back into the insn. Assumes two's complement.
6575 We use the Thumb-2 encoding, which is safe even if dealing with
6576 a Thumb-1 instruction by virtue of our overflow check above. */
6577 reloc_sign = (signed_check < 0) ? 1 : 0;
6578 upper_insn = (upper_insn & ~(bfd_vma) 0x7ff)
6579 | ((relocation >> 12) & 0x3ff)
6580 | (reloc_sign << 10);
6581 lower_insn = (lower_insn & ~(bfd_vma) 0x2fff)
6582 | (((!((relocation >> 23) & 1)) ^ reloc_sign) << 13)
6583 | (((!((relocation >> 22) & 1)) ^ reloc_sign) << 11)
6584 | ((relocation >> 1) & 0x7ff);
6585
6586 /* Put the relocated value back in the object file: */
6587 bfd_put_16 (input_bfd, upper_insn, hit_data);
6588 bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
6589
6590 return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
6591 }
6592 break;
6593
6594 case R_ARM_THM_JUMP19:
6595 /* Thumb32 conditional branch instruction. */
6596 {
6597 bfd_vma relocation;
6598 bfd_boolean overflow = FALSE;
6599 bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
6600 bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
6601 bfd_signed_vma reloc_signed_max = 0xffffe;
6602 bfd_signed_vma reloc_signed_min = -0x100000;
6603 bfd_signed_vma signed_check;
6604
6605 /* Need to refetch the addend, reconstruct the top three bits,
6606 and squish the two 11 bit pieces together. */
6607 if (globals->use_rel)
6608 {
6609 bfd_vma S = (upper_insn & 0x0400) >> 10;
6610 bfd_vma upper = (upper_insn & 0x003f);
6611 bfd_vma J1 = (lower_insn & 0x2000) >> 13;
6612 bfd_vma J2 = (lower_insn & 0x0800) >> 11;
6613 bfd_vma lower = (lower_insn & 0x07ff);
6614
6615 upper |= J1 << 6;
6616 upper |= J2 << 7;
6617 upper |= (!S) << 8;
6618 upper -= 0x0100; /* Sign extend. */
6619
6620 addend = (upper << 12) | (lower << 1);
6621 signed_addend = addend;
6622 }
6623
6624 /* Handle calls via the PLT. */
6625 if (h != NULL && splt != NULL && h->plt.offset != (bfd_vma) -1)
6626 {
6627 value = (splt->output_section->vma
6628 + splt->output_offset
6629 + h->plt.offset);
6630 /* Target the Thumb stub before the ARM PLT entry. */
6631 value -= PLT_THUMB_STUB_SIZE;
6632 *unresolved_reloc_p = FALSE;
6633 }
6634
6635 /* ??? Should handle interworking? GCC might someday try to
6636 use this for tail calls. */
6637
6638 relocation = value + signed_addend;
6639 relocation -= (input_section->output_section->vma
6640 + input_section->output_offset
6641 + rel->r_offset);
6642 signed_check = (bfd_signed_vma) relocation;
6643
6644 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
6645 overflow = TRUE;
6646
6647 /* Put RELOCATION back into the insn. */
6648 {
6649 bfd_vma S = (relocation & 0x00100000) >> 20;
6650 bfd_vma J2 = (relocation & 0x00080000) >> 19;
6651 bfd_vma J1 = (relocation & 0x00040000) >> 18;
6652 bfd_vma hi = (relocation & 0x0003f000) >> 12;
6653 bfd_vma lo = (relocation & 0x00000ffe) >> 1;
6654
6655 upper_insn = (upper_insn & 0xfbc0) | (S << 10) | hi;
6656 lower_insn = (lower_insn & 0xd000) | (J1 << 13) | (J2 << 11) | lo;
6657 }
6658
6659 /* Put the relocated value back in the object file: */
6660 bfd_put_16 (input_bfd, upper_insn, hit_data);
6661 bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
6662
6663 return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
6664 }
6665
6666 case R_ARM_THM_JUMP11:
6667 case R_ARM_THM_JUMP8:
6668 case R_ARM_THM_JUMP6:
6669 /* Thumb B (branch) instruction). */
6670 {
6671 bfd_signed_vma relocation;
6672 bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
6673 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
6674 bfd_signed_vma signed_check;
6675
6676 /* CZB cannot jump backward. */
6677 if (r_type == R_ARM_THM_JUMP6)
6678 reloc_signed_min = 0;
6679
6680 if (globals->use_rel)
6681 {
6682 /* Need to refetch addend. */
6683 addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
6684 if (addend & ((howto->src_mask + 1) >> 1))
6685 {
6686 signed_addend = -1;
6687 signed_addend &= ~ howto->src_mask;
6688 signed_addend |= addend;
6689 }
6690 else
6691 signed_addend = addend;
6692 /* The value in the insn has been right shifted. We need to
6693 undo this, so that we can perform the address calculation
6694 in terms of bytes. */
6695 signed_addend <<= howto->rightshift;
6696 }
6697 relocation = value + signed_addend;
6698
6699 relocation -= (input_section->output_section->vma
6700 + input_section->output_offset
6701 + rel->r_offset);
6702
6703 relocation >>= howto->rightshift;
6704 signed_check = relocation;
6705
6706 if (r_type == R_ARM_THM_JUMP6)
6707 relocation = ((relocation & 0x0020) << 4) | ((relocation & 0x001f) << 3);
6708 else
6709 relocation &= howto->dst_mask;
6710 relocation |= (bfd_get_16 (input_bfd, hit_data) & (~ howto->dst_mask));
6711
6712 bfd_put_16 (input_bfd, relocation, hit_data);
6713
6714 /* Assumes two's complement. */
6715 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
6716 return bfd_reloc_overflow;
6717
6718 return bfd_reloc_ok;
6719 }
6720
6721 case R_ARM_ALU_PCREL7_0:
6722 case R_ARM_ALU_PCREL15_8:
6723 case R_ARM_ALU_PCREL23_15:
6724 {
6725 bfd_vma insn;
6726 bfd_vma relocation;
6727
6728 insn = bfd_get_32 (input_bfd, hit_data);
6729 if (globals->use_rel)
6730 {
6731 /* Extract the addend. */
6732 addend = (insn & 0xff) << ((insn & 0xf00) >> 7);
6733 signed_addend = addend;
6734 }
6735 relocation = value + signed_addend;
6736
6737 relocation -= (input_section->output_section->vma
6738 + input_section->output_offset
6739 + rel->r_offset);
6740 insn = (insn & ~0xfff)
6741 | ((howto->bitpos << 7) & 0xf00)
6742 | ((relocation >> howto->bitpos) & 0xff);
6743 bfd_put_32 (input_bfd, value, hit_data);
6744 }
6745 return bfd_reloc_ok;
6746
6747 case R_ARM_GNU_VTINHERIT:
6748 case R_ARM_GNU_VTENTRY:
6749 return bfd_reloc_ok;
6750
6751 case R_ARM_GOTOFF32:
6752 /* Relocation is relative to the start of the
6753 global offset table. */
6754
6755 BFD_ASSERT (sgot != NULL);
6756 if (sgot == NULL)
6757 return bfd_reloc_notsupported;
6758
6759 /* If we are addressing a Thumb function, we need to adjust the
6760 address by one, so that attempts to call the function pointer will
6761 correctly interpret it as Thumb code. */
6762 if (sym_flags == STT_ARM_TFUNC)
6763 value += 1;
6764
6765 /* Note that sgot->output_offset is not involved in this
6766 calculation. We always want the start of .got. If we
6767 define _GLOBAL_OFFSET_TABLE in a different way, as is
6768 permitted by the ABI, we might have to change this
6769 calculation. */
6770 value -= sgot->output_section->vma;
6771 return _bfd_final_link_relocate (howto, input_bfd, input_section,
6772 contents, rel->r_offset, value,
6773 rel->r_addend);
6774
6775 case R_ARM_GOTPC:
6776 /* Use global offset table as symbol value. */
6777 BFD_ASSERT (sgot != NULL);
6778
6779 if (sgot == NULL)
6780 return bfd_reloc_notsupported;
6781
6782 *unresolved_reloc_p = FALSE;
6783 value = sgot->output_section->vma;
6784 return _bfd_final_link_relocate (howto, input_bfd, input_section,
6785 contents, rel->r_offset, value,
6786 rel->r_addend);
6787
6788 case R_ARM_GOT32:
6789 case R_ARM_GOT_PREL:
6790 /* Relocation is to the entry for this symbol in the
6791 global offset table. */
6792 if (sgot == NULL)
6793 return bfd_reloc_notsupported;
6794
6795 if (h != NULL)
6796 {
6797 bfd_vma off;
6798 bfd_boolean dyn;
6799
6800 off = h->got.offset;
6801 BFD_ASSERT (off != (bfd_vma) -1);
6802 dyn = globals->root.dynamic_sections_created;
6803
6804 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
6805 || (info->shared
6806 && SYMBOL_REFERENCES_LOCAL (info, h))
6807 || (ELF_ST_VISIBILITY (h->other)
6808 && h->root.type == bfd_link_hash_undefweak))
6809 {
6810 /* This is actually a static link, or it is a -Bsymbolic link
6811 and the symbol is defined locally. We must initialize this
6812 entry in the global offset table. Since the offset must
6813 always be a multiple of 4, we use the least significant bit
6814 to record whether we have initialized it already.
6815
6816 When doing a dynamic link, we create a .rel(a).got relocation
6817 entry to initialize the value. This is done in the
6818 finish_dynamic_symbol routine. */
6819 if ((off & 1) != 0)
6820 off &= ~1;
6821 else
6822 {
6823 /* If we are addressing a Thumb function, we need to
6824 adjust the address by one, so that attempts to
6825 call the function pointer will correctly
6826 interpret it as Thumb code. */
6827 if (sym_flags == STT_ARM_TFUNC)
6828 value |= 1;
6829
6830 bfd_put_32 (output_bfd, value, sgot->contents + off);
6831 h->got.offset |= 1;
6832 }
6833 }
6834 else
6835 *unresolved_reloc_p = FALSE;
6836
6837 value = sgot->output_offset + off;
6838 }
6839 else
6840 {
6841 bfd_vma off;
6842
6843 BFD_ASSERT (local_got_offsets != NULL &&
6844 local_got_offsets[r_symndx] != (bfd_vma) -1);
6845
6846 off = local_got_offsets[r_symndx];
6847
6848 /* The offset must always be a multiple of 4. We use the
6849 least significant bit to record whether we have already
6850 generated the necessary reloc. */
6851 if ((off & 1) != 0)
6852 off &= ~1;
6853 else
6854 {
6855 /* If we are addressing a Thumb function, we need to
6856 adjust the address by one, so that attempts to
6857 call the function pointer will correctly
6858 interpret it as Thumb code. */
6859 if (sym_flags == STT_ARM_TFUNC)
6860 value |= 1;
6861
6862 if (globals->use_rel)
6863 bfd_put_32 (output_bfd, value, sgot->contents + off);
6864
6865 if (info->shared)
6866 {
6867 asection * srelgot;
6868 Elf_Internal_Rela outrel;
6869 bfd_byte *loc;
6870
6871 srelgot = (bfd_get_section_by_name
6872 (dynobj, RELOC_SECTION (globals, ".got")));
6873 BFD_ASSERT (srelgot != NULL);
6874
6875 outrel.r_addend = addend + value;
6876 outrel.r_offset = (sgot->output_section->vma
6877 + sgot->output_offset
6878 + off);
6879 outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
6880 loc = srelgot->contents;
6881 loc += srelgot->reloc_count++ * RELOC_SIZE (globals);
6882 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
6883 }
6884
6885 local_got_offsets[r_symndx] |= 1;
6886 }
6887
6888 value = sgot->output_offset + off;
6889 }
6890 if (r_type != R_ARM_GOT32)
6891 value += sgot->output_section->vma;
6892
6893 return _bfd_final_link_relocate (howto, input_bfd, input_section,
6894 contents, rel->r_offset, value,
6895 rel->r_addend);
6896
6897 case R_ARM_TLS_LDO32:
6898 value = value - dtpoff_base (info);
6899
6900 return _bfd_final_link_relocate (howto, input_bfd, input_section,
6901 contents, rel->r_offset, value,
6902 rel->r_addend);
6903
6904 case R_ARM_TLS_LDM32:
6905 {
6906 bfd_vma off;
6907
6908 if (globals->sgot == NULL)
6909 abort ();
6910
6911 off = globals->tls_ldm_got.offset;
6912
6913 if ((off & 1) != 0)
6914 off &= ~1;
6915 else
6916 {
6917 /* If we don't know the module number, create a relocation
6918 for it. */
6919 if (info->shared)
6920 {
6921 Elf_Internal_Rela outrel;
6922 bfd_byte *loc;
6923
6924 if (globals->srelgot == NULL)
6925 abort ();
6926
6927 outrel.r_addend = 0;
6928 outrel.r_offset = (globals->sgot->output_section->vma
6929 + globals->sgot->output_offset + off);
6930 outrel.r_info = ELF32_R_INFO (0, R_ARM_TLS_DTPMOD32);
6931
6932 if (globals->use_rel)
6933 bfd_put_32 (output_bfd, outrel.r_addend,
6934 globals->sgot->contents + off);
6935
6936 loc = globals->srelgot->contents;
6937 loc += globals->srelgot->reloc_count++ * RELOC_SIZE (globals);
6938 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
6939 }
6940 else
6941 bfd_put_32 (output_bfd, 1, globals->sgot->contents + off);
6942
6943 globals->tls_ldm_got.offset |= 1;
6944 }
6945
6946 value = globals->sgot->output_section->vma + globals->sgot->output_offset + off
6947 - (input_section->output_section->vma + input_section->output_offset + rel->r_offset);
6948
6949 return _bfd_final_link_relocate (howto, input_bfd, input_section,
6950 contents, rel->r_offset, value,
6951 rel->r_addend);
6952 }
6953
6954 case R_ARM_TLS_GD32:
6955 case R_ARM_TLS_IE32:
6956 {
6957 bfd_vma off;
6958 int indx;
6959 char tls_type;
6960
6961 if (globals->sgot == NULL)
6962 abort ();
6963
6964 indx = 0;
6965 if (h != NULL)
6966 {
6967 bfd_boolean dyn;
6968 dyn = globals->root.dynamic_sections_created;
6969 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
6970 && (!info->shared
6971 || !SYMBOL_REFERENCES_LOCAL (info, h)))
6972 {
6973 *unresolved_reloc_p = FALSE;
6974 indx = h->dynindx;
6975 }
6976 off = h->got.offset;
6977 tls_type = ((struct elf32_arm_link_hash_entry *) h)->tls_type;
6978 }
6979 else
6980 {
6981 if (local_got_offsets == NULL)
6982 abort ();
6983 off = local_got_offsets[r_symndx];
6984 tls_type = elf32_arm_local_got_tls_type (input_bfd)[r_symndx];
6985 }
6986
6987 if (tls_type == GOT_UNKNOWN)
6988 abort ();
6989
6990 if ((off & 1) != 0)
6991 off &= ~1;
6992 else
6993 {
6994 bfd_boolean need_relocs = FALSE;
6995 Elf_Internal_Rela outrel;
6996 bfd_byte *loc = NULL;
6997 int cur_off = off;
6998
6999 /* The GOT entries have not been initialized yet. Do it
7000 now, and emit any relocations. If both an IE GOT and a
7001 GD GOT are necessary, we emit the GD first. */
7002
7003 if ((info->shared || indx != 0)
7004 && (h == NULL
7005 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
7006 || h->root.type != bfd_link_hash_undefweak))
7007 {
7008 need_relocs = TRUE;
7009 if (globals->srelgot == NULL)
7010 abort ();
7011 loc = globals->srelgot->contents;
7012 loc += globals->srelgot->reloc_count * RELOC_SIZE (globals);
7013 }
7014
7015 if (tls_type & GOT_TLS_GD)
7016 {
7017 if (need_relocs)
7018 {
7019 outrel.r_addend = 0;
7020 outrel.r_offset = (globals->sgot->output_section->vma
7021 + globals->sgot->output_offset
7022 + cur_off);
7023 outrel.r_info = ELF32_R_INFO (indx, R_ARM_TLS_DTPMOD32);
7024
7025 if (globals->use_rel)
7026 bfd_put_32 (output_bfd, outrel.r_addend,
7027 globals->sgot->contents + cur_off);
7028
7029 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
7030 globals->srelgot->reloc_count++;
7031 loc += RELOC_SIZE (globals);
7032
7033 if (indx == 0)
7034 bfd_put_32 (output_bfd, value - dtpoff_base (info),
7035 globals->sgot->contents + cur_off + 4);
7036 else
7037 {
7038 outrel.r_addend = 0;
7039 outrel.r_info = ELF32_R_INFO (indx,
7040 R_ARM_TLS_DTPOFF32);
7041 outrel.r_offset += 4;
7042
7043 if (globals->use_rel)
7044 bfd_put_32 (output_bfd, outrel.r_addend,
7045 globals->sgot->contents + cur_off + 4);
7046
7047
7048 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
7049 globals->srelgot->reloc_count++;
7050 loc += RELOC_SIZE (globals);
7051 }
7052 }
7053 else
7054 {
7055 /* If we are not emitting relocations for a
7056 general dynamic reference, then we must be in a
7057 static link or an executable link with the
7058 symbol binding locally. Mark it as belonging
7059 to module 1, the executable. */
7060 bfd_put_32 (output_bfd, 1,
7061 globals->sgot->contents + cur_off);
7062 bfd_put_32 (output_bfd, value - dtpoff_base (info),
7063 globals->sgot->contents + cur_off + 4);
7064 }
7065
7066 cur_off += 8;
7067 }
7068
7069 if (tls_type & GOT_TLS_IE)
7070 {
7071 if (need_relocs)
7072 {
7073 if (indx == 0)
7074 outrel.r_addend = value - dtpoff_base (info);
7075 else
7076 outrel.r_addend = 0;
7077 outrel.r_offset = (globals->sgot->output_section->vma
7078 + globals->sgot->output_offset
7079 + cur_off);
7080 outrel.r_info = ELF32_R_INFO (indx, R_ARM_TLS_TPOFF32);
7081
7082 if (globals->use_rel)
7083 bfd_put_32 (output_bfd, outrel.r_addend,
7084 globals->sgot->contents + cur_off);
7085
7086 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
7087 globals->srelgot->reloc_count++;
7088 loc += RELOC_SIZE (globals);
7089 }
7090 else
7091 bfd_put_32 (output_bfd, tpoff (info, value),
7092 globals->sgot->contents + cur_off);
7093 cur_off += 4;
7094 }
7095
7096 if (h != NULL)
7097 h->got.offset |= 1;
7098 else
7099 local_got_offsets[r_symndx] |= 1;
7100 }
7101
7102 if ((tls_type & GOT_TLS_GD) && r_type != R_ARM_TLS_GD32)
7103 off += 8;
7104 value = globals->sgot->output_section->vma + globals->sgot->output_offset + off
7105 - (input_section->output_section->vma + input_section->output_offset + rel->r_offset);
7106
7107 return _bfd_final_link_relocate (howto, input_bfd, input_section,
7108 contents, rel->r_offset, value,
7109 rel->r_addend);
7110 }
7111
7112 case R_ARM_TLS_LE32:
7113 if (info->shared)
7114 {
7115 (*_bfd_error_handler)
7116 (_("%B(%A+0x%lx): R_ARM_TLS_LE32 relocation not permitted in shared object"),
7117 input_bfd, input_section,
7118 (long) rel->r_offset, howto->name);
7119 return FALSE;
7120 }
7121 else
7122 value = tpoff (info, value);
7123
7124 return _bfd_final_link_relocate (howto, input_bfd, input_section,
7125 contents, rel->r_offset, value,
7126 rel->r_addend);
7127
7128 case R_ARM_V4BX:
7129 if (globals->fix_v4bx)
7130 {
7131 bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
7132
7133 /* Ensure that we have a BX instruction. */
7134 BFD_ASSERT ((insn & 0x0ffffff0) == 0x012fff10);
7135
7136 if (globals->fix_v4bx == 2 && (insn & 0xf) != 0xf)
7137 {
7138 /* Branch to veneer. */
7139 bfd_vma glue_addr;
7140 glue_addr = elf32_arm_bx_glue (info, insn & 0xf);
7141 glue_addr -= input_section->output_section->vma
7142 + input_section->output_offset
7143 + rel->r_offset + 8;
7144 insn = (insn & 0xf0000000) | 0x0a000000
7145 | ((glue_addr >> 2) & 0x00ffffff);
7146 }
7147 else
7148 {
7149 /* Preserve Rm (lowest four bits) and the condition code
7150 (highest four bits). Other bits encode MOV PC,Rm. */
7151 insn = (insn & 0xf000000f) | 0x01a0f000;
7152 }
7153
7154 bfd_put_32 (input_bfd, insn, hit_data);
7155 }
7156 return bfd_reloc_ok;
7157
7158 case R_ARM_MOVW_ABS_NC:
7159 case R_ARM_MOVT_ABS:
7160 case R_ARM_MOVW_PREL_NC:
7161 case R_ARM_MOVT_PREL:
7162 /* Until we properly support segment-base-relative addressing then
7163 we assume the segment base to be zero, as for the group relocations.
7164 Thus R_ARM_MOVW_BREL_NC has the same semantics as R_ARM_MOVW_ABS_NC
7165 and R_ARM_MOVT_BREL has the same semantics as R_ARM_MOVT_ABS. */
7166 case R_ARM_MOVW_BREL_NC:
7167 case R_ARM_MOVW_BREL:
7168 case R_ARM_MOVT_BREL:
7169 {
7170 bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
7171
7172 if (globals->use_rel)
7173 {
7174 addend = ((insn >> 4) & 0xf000) | (insn & 0xfff);
7175 signed_addend = (addend ^ 0x8000) - 0x8000;
7176 }
7177
7178 value += signed_addend;
7179
7180 if (r_type == R_ARM_MOVW_PREL_NC || r_type == R_ARM_MOVT_PREL)
7181 value -= (input_section->output_section->vma
7182 + input_section->output_offset + rel->r_offset);
7183
7184 if (r_type == R_ARM_MOVW_BREL && value >= 0x10000)
7185 return bfd_reloc_overflow;
7186
7187 if (sym_flags == STT_ARM_TFUNC)
7188 value |= 1;
7189
7190 if (r_type == R_ARM_MOVT_ABS || r_type == R_ARM_MOVT_PREL
7191 || r_type == R_ARM_MOVT_BREL)
7192 value >>= 16;
7193
7194 insn &= 0xfff0f000;
7195 insn |= value & 0xfff;
7196 insn |= (value & 0xf000) << 4;
7197 bfd_put_32 (input_bfd, insn, hit_data);
7198 }
7199 return bfd_reloc_ok;
7200
7201 case R_ARM_THM_MOVW_ABS_NC:
7202 case R_ARM_THM_MOVT_ABS:
7203 case R_ARM_THM_MOVW_PREL_NC:
7204 case R_ARM_THM_MOVT_PREL:
7205 /* Until we properly support segment-base-relative addressing then
7206 we assume the segment base to be zero, as for the above relocations.
7207 Thus R_ARM_THM_MOVW_BREL_NC has the same semantics as
7208 R_ARM_THM_MOVW_ABS_NC and R_ARM_THM_MOVT_BREL has the same semantics
7209 as R_ARM_THM_MOVT_ABS. */
7210 case R_ARM_THM_MOVW_BREL_NC:
7211 case R_ARM_THM_MOVW_BREL:
7212 case R_ARM_THM_MOVT_BREL:
7213 {
7214 bfd_vma insn;
7215
7216 insn = bfd_get_16 (input_bfd, hit_data) << 16;
7217 insn |= bfd_get_16 (input_bfd, hit_data + 2);
7218
7219 if (globals->use_rel)
7220 {
7221 addend = ((insn >> 4) & 0xf000)
7222 | ((insn >> 15) & 0x0800)
7223 | ((insn >> 4) & 0x0700)
7224 | (insn & 0x00ff);
7225 signed_addend = (addend ^ 0x8000) - 0x8000;
7226 }
7227
7228 value += signed_addend;
7229
7230 if (r_type == R_ARM_THM_MOVW_PREL_NC || r_type == R_ARM_THM_MOVT_PREL)
7231 value -= (input_section->output_section->vma
7232 + input_section->output_offset + rel->r_offset);
7233
7234 if (r_type == R_ARM_THM_MOVW_BREL && value >= 0x10000)
7235 return bfd_reloc_overflow;
7236
7237 if (sym_flags == STT_ARM_TFUNC)
7238 value |= 1;
7239
7240 if (r_type == R_ARM_THM_MOVT_ABS || r_type == R_ARM_THM_MOVT_PREL
7241 || r_type == R_ARM_THM_MOVT_BREL)
7242 value >>= 16;
7243
7244 insn &= 0xfbf08f00;
7245 insn |= (value & 0xf000) << 4;
7246 insn |= (value & 0x0800) << 15;
7247 insn |= (value & 0x0700) << 4;
7248 insn |= (value & 0x00ff);
7249
7250 bfd_put_16 (input_bfd, insn >> 16, hit_data);
7251 bfd_put_16 (input_bfd, insn & 0xffff, hit_data + 2);
7252 }
7253 return bfd_reloc_ok;
7254
7255 case R_ARM_ALU_PC_G0_NC:
7256 case R_ARM_ALU_PC_G1_NC:
7257 case R_ARM_ALU_PC_G0:
7258 case R_ARM_ALU_PC_G1:
7259 case R_ARM_ALU_PC_G2:
7260 case R_ARM_ALU_SB_G0_NC:
7261 case R_ARM_ALU_SB_G1_NC:
7262 case R_ARM_ALU_SB_G0:
7263 case R_ARM_ALU_SB_G1:
7264 case R_ARM_ALU_SB_G2:
7265 {
7266 bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
7267 bfd_vma pc = input_section->output_section->vma
7268 + input_section->output_offset + rel->r_offset;
7269 /* sb should be the origin of the *segment* containing the symbol.
7270 It is not clear how to obtain this OS-dependent value, so we
7271 make an arbitrary choice of zero. */
7272 bfd_vma sb = 0;
7273 bfd_vma residual;
7274 bfd_vma g_n;
7275 bfd_signed_vma signed_value;
7276 int group = 0;
7277
7278 /* Determine which group of bits to select. */
7279 switch (r_type)
7280 {
7281 case R_ARM_ALU_PC_G0_NC:
7282 case R_ARM_ALU_PC_G0:
7283 case R_ARM_ALU_SB_G0_NC:
7284 case R_ARM_ALU_SB_G0:
7285 group = 0;
7286 break;
7287
7288 case R_ARM_ALU_PC_G1_NC:
7289 case R_ARM_ALU_PC_G1:
7290 case R_ARM_ALU_SB_G1_NC:
7291 case R_ARM_ALU_SB_G1:
7292 group = 1;
7293 break;
7294
7295 case R_ARM_ALU_PC_G2:
7296 case R_ARM_ALU_SB_G2:
7297 group = 2;
7298 break;
7299
7300 default:
7301 abort ();
7302 }
7303
7304 /* If REL, extract the addend from the insn. If RELA, it will
7305 have already been fetched for us. */
7306 if (globals->use_rel)
7307 {
7308 int negative;
7309 bfd_vma constant = insn & 0xff;
7310 bfd_vma rotation = (insn & 0xf00) >> 8;
7311
7312 if (rotation == 0)
7313 signed_addend = constant;
7314 else
7315 {
7316 /* Compensate for the fact that in the instruction, the
7317 rotation is stored in multiples of 2 bits. */
7318 rotation *= 2;
7319
7320 /* Rotate "constant" right by "rotation" bits. */
7321 signed_addend = (constant >> rotation) |
7322 (constant << (8 * sizeof (bfd_vma) - rotation));
7323 }
7324
7325 /* Determine if the instruction is an ADD or a SUB.
7326 (For REL, this determines the sign of the addend.) */
7327 negative = identify_add_or_sub (insn);
7328 if (negative == 0)
7329 {
7330 (*_bfd_error_handler)
7331 (_("%B(%A+0x%lx): Only ADD or SUB instructions are allowed for ALU group relocations"),
7332 input_bfd, input_section,
7333 (long) rel->r_offset, howto->name);
7334 return bfd_reloc_overflow;
7335 }
7336
7337 signed_addend *= negative;
7338 }
7339
7340 /* Compute the value (X) to go in the place. */
7341 if (r_type == R_ARM_ALU_PC_G0_NC
7342 || r_type == R_ARM_ALU_PC_G1_NC
7343 || r_type == R_ARM_ALU_PC_G0
7344 || r_type == R_ARM_ALU_PC_G1
7345 || r_type == R_ARM_ALU_PC_G2)
7346 /* PC relative. */
7347 signed_value = value - pc + signed_addend;
7348 else
7349 /* Section base relative. */
7350 signed_value = value - sb + signed_addend;
7351
7352 /* If the target symbol is a Thumb function, then set the
7353 Thumb bit in the address. */
7354 if (sym_flags == STT_ARM_TFUNC)
7355 signed_value |= 1;
7356
7357 /* Calculate the value of the relevant G_n, in encoded
7358 constant-with-rotation format. */
7359 g_n = calculate_group_reloc_mask (abs (signed_value), group,
7360 &residual);
7361
7362 /* Check for overflow if required. */
7363 if ((r_type == R_ARM_ALU_PC_G0
7364 || r_type == R_ARM_ALU_PC_G1
7365 || r_type == R_ARM_ALU_PC_G2
7366 || r_type == R_ARM_ALU_SB_G0
7367 || r_type == R_ARM_ALU_SB_G1
7368 || r_type == R_ARM_ALU_SB_G2) && residual != 0)
7369 {
7370 (*_bfd_error_handler)
7371 (_("%B(%A+0x%lx): Overflow whilst splitting 0x%lx for group relocation %s"),
7372 input_bfd, input_section,
7373 (long) rel->r_offset, abs (signed_value), howto->name);
7374 return bfd_reloc_overflow;
7375 }
7376
7377 /* Mask out the value and the ADD/SUB part of the opcode; take care
7378 not to destroy the S bit. */
7379 insn &= 0xff1ff000;
7380
7381 /* Set the opcode according to whether the value to go in the
7382 place is negative. */
7383 if (signed_value < 0)
7384 insn |= 1 << 22;
7385 else
7386 insn |= 1 << 23;
7387
7388 /* Encode the offset. */
7389 insn |= g_n;
7390
7391 bfd_put_32 (input_bfd, insn, hit_data);
7392 }
7393 return bfd_reloc_ok;
7394
7395 case R_ARM_LDR_PC_G0:
7396 case R_ARM_LDR_PC_G1:
7397 case R_ARM_LDR_PC_G2:
7398 case R_ARM_LDR_SB_G0:
7399 case R_ARM_LDR_SB_G1:
7400 case R_ARM_LDR_SB_G2:
7401 {
7402 bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
7403 bfd_vma pc = input_section->output_section->vma
7404 + input_section->output_offset + rel->r_offset;
7405 bfd_vma sb = 0; /* See note above. */
7406 bfd_vma residual;
7407 bfd_signed_vma signed_value;
7408 int group = 0;
7409
7410 /* Determine which groups of bits to calculate. */
7411 switch (r_type)
7412 {
7413 case R_ARM_LDR_PC_G0:
7414 case R_ARM_LDR_SB_G0:
7415 group = 0;
7416 break;
7417
7418 case R_ARM_LDR_PC_G1:
7419 case R_ARM_LDR_SB_G1:
7420 group = 1;
7421 break;
7422
7423 case R_ARM_LDR_PC_G2:
7424 case R_ARM_LDR_SB_G2:
7425 group = 2;
7426 break;
7427
7428 default:
7429 abort ();
7430 }
7431
7432 /* If REL, extract the addend from the insn. If RELA, it will
7433 have already been fetched for us. */
7434 if (globals->use_rel)
7435 {
7436 int negative = (insn & (1 << 23)) ? 1 : -1;
7437 signed_addend = negative * (insn & 0xfff);
7438 }
7439
7440 /* Compute the value (X) to go in the place. */
7441 if (r_type == R_ARM_LDR_PC_G0
7442 || r_type == R_ARM_LDR_PC_G1
7443 || r_type == R_ARM_LDR_PC_G2)
7444 /* PC relative. */
7445 signed_value = value - pc + signed_addend;
7446 else
7447 /* Section base relative. */
7448 signed_value = value - sb + signed_addend;
7449
7450 /* Calculate the value of the relevant G_{n-1} to obtain
7451 the residual at that stage. */
7452 calculate_group_reloc_mask (abs (signed_value), group - 1, &residual);
7453
7454 /* Check for overflow. */
7455 if (residual >= 0x1000)
7456 {
7457 (*_bfd_error_handler)
7458 (_("%B(%A+0x%lx): Overflow whilst splitting 0x%lx for group relocation %s"),
7459 input_bfd, input_section,
7460 (long) rel->r_offset, abs (signed_value), howto->name);
7461 return bfd_reloc_overflow;
7462 }
7463
7464 /* Mask out the value and U bit. */
7465 insn &= 0xff7ff000;
7466
7467 /* Set the U bit if the value to go in the place is non-negative. */
7468 if (signed_value >= 0)
7469 insn |= 1 << 23;
7470
7471 /* Encode the offset. */
7472 insn |= residual;
7473
7474 bfd_put_32 (input_bfd, insn, hit_data);
7475 }
7476 return bfd_reloc_ok;
7477
7478 case R_ARM_LDRS_PC_G0:
7479 case R_ARM_LDRS_PC_G1:
7480 case R_ARM_LDRS_PC_G2:
7481 case R_ARM_LDRS_SB_G0:
7482 case R_ARM_LDRS_SB_G1:
7483 case R_ARM_LDRS_SB_G2:
7484 {
7485 bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
7486 bfd_vma pc = input_section->output_section->vma
7487 + input_section->output_offset + rel->r_offset;
7488 bfd_vma sb = 0; /* See note above. */
7489 bfd_vma residual;
7490 bfd_signed_vma signed_value;
7491 int group = 0;
7492
7493 /* Determine which groups of bits to calculate. */
7494 switch (r_type)
7495 {
7496 case R_ARM_LDRS_PC_G0:
7497 case R_ARM_LDRS_SB_G0:
7498 group = 0;
7499 break;
7500
7501 case R_ARM_LDRS_PC_G1:
7502 case R_ARM_LDRS_SB_G1:
7503 group = 1;
7504 break;
7505
7506 case R_ARM_LDRS_PC_G2:
7507 case R_ARM_LDRS_SB_G2:
7508 group = 2;
7509 break;
7510
7511 default:
7512 abort ();
7513 }
7514
7515 /* If REL, extract the addend from the insn. If RELA, it will
7516 have already been fetched for us. */
7517 if (globals->use_rel)
7518 {
7519 int negative = (insn & (1 << 23)) ? 1 : -1;
7520 signed_addend = negative * (((insn & 0xf00) >> 4) + (insn & 0xf));
7521 }
7522
7523 /* Compute the value (X) to go in the place. */
7524 if (r_type == R_ARM_LDRS_PC_G0
7525 || r_type == R_ARM_LDRS_PC_G1
7526 || r_type == R_ARM_LDRS_PC_G2)
7527 /* PC relative. */
7528 signed_value = value - pc + signed_addend;
7529 else
7530 /* Section base relative. */
7531 signed_value = value - sb + signed_addend;
7532
7533 /* Calculate the value of the relevant G_{n-1} to obtain
7534 the residual at that stage. */
7535 calculate_group_reloc_mask (abs (signed_value), group - 1, &residual);
7536
7537 /* Check for overflow. */
7538 if (residual >= 0x100)
7539 {
7540 (*_bfd_error_handler)
7541 (_("%B(%A+0x%lx): Overflow whilst splitting 0x%lx for group relocation %s"),
7542 input_bfd, input_section,
7543 (long) rel->r_offset, abs (signed_value), howto->name);
7544 return bfd_reloc_overflow;
7545 }
7546
7547 /* Mask out the value and U bit. */
7548 insn &= 0xff7ff0f0;
7549
7550 /* Set the U bit if the value to go in the place is non-negative. */
7551 if (signed_value >= 0)
7552 insn |= 1 << 23;
7553
7554 /* Encode the offset. */
7555 insn |= ((residual & 0xf0) << 4) | (residual & 0xf);
7556
7557 bfd_put_32 (input_bfd, insn, hit_data);
7558 }
7559 return bfd_reloc_ok;
7560
7561 case R_ARM_LDC_PC_G0:
7562 case R_ARM_LDC_PC_G1:
7563 case R_ARM_LDC_PC_G2:
7564 case R_ARM_LDC_SB_G0:
7565 case R_ARM_LDC_SB_G1:
7566 case R_ARM_LDC_SB_G2:
7567 {
7568 bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
7569 bfd_vma pc = input_section->output_section->vma
7570 + input_section->output_offset + rel->r_offset;
7571 bfd_vma sb = 0; /* See note above. */
7572 bfd_vma residual;
7573 bfd_signed_vma signed_value;
7574 int group = 0;
7575
7576 /* Determine which groups of bits to calculate. */
7577 switch (r_type)
7578 {
7579 case R_ARM_LDC_PC_G0:
7580 case R_ARM_LDC_SB_G0:
7581 group = 0;
7582 break;
7583
7584 case R_ARM_LDC_PC_G1:
7585 case R_ARM_LDC_SB_G1:
7586 group = 1;
7587 break;
7588
7589 case R_ARM_LDC_PC_G2:
7590 case R_ARM_LDC_SB_G2:
7591 group = 2;
7592 break;
7593
7594 default:
7595 abort ();
7596 }
7597
7598 /* If REL, extract the addend from the insn. If RELA, it will
7599 have already been fetched for us. */
7600 if (globals->use_rel)
7601 {
7602 int negative = (insn & (1 << 23)) ? 1 : -1;
7603 signed_addend = negative * ((insn & 0xff) << 2);
7604 }
7605
7606 /* Compute the value (X) to go in the place. */
7607 if (r_type == R_ARM_LDC_PC_G0
7608 || r_type == R_ARM_LDC_PC_G1
7609 || r_type == R_ARM_LDC_PC_G2)
7610 /* PC relative. */
7611 signed_value = value - pc + signed_addend;
7612 else
7613 /* Section base relative. */
7614 signed_value = value - sb + signed_addend;
7615
7616 /* Calculate the value of the relevant G_{n-1} to obtain
7617 the residual at that stage. */
7618 calculate_group_reloc_mask (abs (signed_value), group - 1, &residual);
7619
7620 /* Check for overflow. (The absolute value to go in the place must be
7621 divisible by four and, after having been divided by four, must
7622 fit in eight bits.) */
7623 if ((residual & 0x3) != 0 || residual >= 0x400)
7624 {
7625 (*_bfd_error_handler)
7626 (_("%B(%A+0x%lx): Overflow whilst splitting 0x%lx for group relocation %s"),
7627 input_bfd, input_section,
7628 (long) rel->r_offset, abs (signed_value), howto->name);
7629 return bfd_reloc_overflow;
7630 }
7631
7632 /* Mask out the value and U bit. */
7633 insn &= 0xff7fff00;
7634
7635 /* Set the U bit if the value to go in the place is non-negative. */
7636 if (signed_value >= 0)
7637 insn |= 1 << 23;
7638
7639 /* Encode the offset. */
7640 insn |= residual >> 2;
7641
7642 bfd_put_32 (input_bfd, insn, hit_data);
7643 }
7644 return bfd_reloc_ok;
7645
7646 default:
7647 return bfd_reloc_notsupported;
7648 }
7649 }
7650
7651 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. */
7652 static void
7653 arm_add_to_rel (bfd * abfd,
7654 bfd_byte * address,
7655 reloc_howto_type * howto,
7656 bfd_signed_vma increment)
7657 {
7658 bfd_signed_vma addend;
7659
7660 if (howto->type == R_ARM_THM_CALL
7661 || howto->type == R_ARM_THM_JUMP24)
7662 {
7663 int upper_insn, lower_insn;
7664 int upper, lower;
7665
7666 upper_insn = bfd_get_16 (abfd, address);
7667 lower_insn = bfd_get_16 (abfd, address + 2);
7668 upper = upper_insn & 0x7ff;
7669 lower = lower_insn & 0x7ff;
7670
7671 addend = (upper << 12) | (lower << 1);
7672 addend += increment;
7673 addend >>= 1;
7674
7675 upper_insn = (upper_insn & 0xf800) | ((addend >> 11) & 0x7ff);
7676 lower_insn = (lower_insn & 0xf800) | (addend & 0x7ff);
7677
7678 bfd_put_16 (abfd, (bfd_vma) upper_insn, address);
7679 bfd_put_16 (abfd, (bfd_vma) lower_insn, address + 2);
7680 }
7681 else
7682 {
7683 bfd_vma contents;
7684
7685 contents = bfd_get_32 (abfd, address);
7686
7687 /* Get the (signed) value from the instruction. */
7688 addend = contents & howto->src_mask;
7689 if (addend & ((howto->src_mask + 1) >> 1))
7690 {
7691 bfd_signed_vma mask;
7692
7693 mask = -1;
7694 mask &= ~ howto->src_mask;
7695 addend |= mask;
7696 }
7697
7698 /* Add in the increment, (which is a byte value). */
7699 switch (howto->type)
7700 {
7701 default:
7702 addend += increment;
7703 break;
7704
7705 case R_ARM_PC24:
7706 case R_ARM_PLT32:
7707 case R_ARM_CALL:
7708 case R_ARM_JUMP24:
7709 addend <<= howto->size;
7710 addend += increment;
7711
7712 /* Should we check for overflow here ? */
7713
7714 /* Drop any undesired bits. */
7715 addend >>= howto->rightshift;
7716 break;
7717 }
7718
7719 contents = (contents & ~ howto->dst_mask) | (addend & howto->dst_mask);
7720
7721 bfd_put_32 (abfd, contents, address);
7722 }
7723 }
7724
7725 #define IS_ARM_TLS_RELOC(R_TYPE) \
7726 ((R_TYPE) == R_ARM_TLS_GD32 \
7727 || (R_TYPE) == R_ARM_TLS_LDO32 \
7728 || (R_TYPE) == R_ARM_TLS_LDM32 \
7729 || (R_TYPE) == R_ARM_TLS_DTPOFF32 \
7730 || (R_TYPE) == R_ARM_TLS_DTPMOD32 \
7731 || (R_TYPE) == R_ARM_TLS_TPOFF32 \
7732 || (R_TYPE) == R_ARM_TLS_LE32 \
7733 || (R_TYPE) == R_ARM_TLS_IE32)
7734
7735 /* Relocate an ARM ELF section. */
7736
7737 static bfd_boolean
7738 elf32_arm_relocate_section (bfd * output_bfd,
7739 struct bfd_link_info * info,
7740 bfd * input_bfd,
7741 asection * input_section,
7742 bfd_byte * contents,
7743 Elf_Internal_Rela * relocs,
7744 Elf_Internal_Sym * local_syms,
7745 asection ** local_sections)
7746 {
7747 Elf_Internal_Shdr *symtab_hdr;
7748 struct elf_link_hash_entry **sym_hashes;
7749 Elf_Internal_Rela *rel;
7750 Elf_Internal_Rela *relend;
7751 const char *name;
7752 struct elf32_arm_link_hash_table * globals;
7753
7754 globals = elf32_arm_hash_table (info);
7755
7756 symtab_hdr = & elf_symtab_hdr (input_bfd);
7757 sym_hashes = elf_sym_hashes (input_bfd);
7758
7759 rel = relocs;
7760 relend = relocs + input_section->reloc_count;
7761 for (; rel < relend; rel++)
7762 {
7763 int r_type;
7764 reloc_howto_type * howto;
7765 unsigned long r_symndx;
7766 Elf_Internal_Sym * sym;
7767 asection * sec;
7768 struct elf_link_hash_entry * h;
7769 bfd_vma relocation;
7770 bfd_reloc_status_type r;
7771 arelent bfd_reloc;
7772 char sym_type;
7773 bfd_boolean unresolved_reloc = FALSE;
7774 char *error_message = NULL;
7775
7776 r_symndx = ELF32_R_SYM (rel->r_info);
7777 r_type = ELF32_R_TYPE (rel->r_info);
7778 r_type = arm_real_reloc_type (globals, r_type);
7779
7780 if ( r_type == R_ARM_GNU_VTENTRY
7781 || r_type == R_ARM_GNU_VTINHERIT)
7782 continue;
7783
7784 bfd_reloc.howto = elf32_arm_howto_from_type (r_type);
7785 howto = bfd_reloc.howto;
7786
7787 h = NULL;
7788 sym = NULL;
7789 sec = NULL;
7790
7791 if (r_symndx < symtab_hdr->sh_info)
7792 {
7793 sym = local_syms + r_symndx;
7794 sym_type = ELF32_ST_TYPE (sym->st_info);
7795 sec = local_sections[r_symndx];
7796 if (globals->use_rel)
7797 {
7798 relocation = (sec->output_section->vma
7799 + sec->output_offset
7800 + sym->st_value);
7801 if (!info->relocatable
7802 && (sec->flags & SEC_MERGE)
7803 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
7804 {
7805 asection *msec;
7806 bfd_vma addend, value;
7807
7808 switch (r_type)
7809 {
7810 case R_ARM_MOVW_ABS_NC:
7811 case R_ARM_MOVT_ABS:
7812 value = bfd_get_32 (input_bfd, contents + rel->r_offset);
7813 addend = ((value & 0xf0000) >> 4) | (value & 0xfff);
7814 addend = (addend ^ 0x8000) - 0x8000;
7815 break;
7816
7817 case R_ARM_THM_MOVW_ABS_NC:
7818 case R_ARM_THM_MOVT_ABS:
7819 value = bfd_get_16 (input_bfd, contents + rel->r_offset)
7820 << 16;
7821 value |= bfd_get_16 (input_bfd,
7822 contents + rel->r_offset + 2);
7823 addend = ((value & 0xf7000) >> 4) | (value & 0xff)
7824 | ((value & 0x04000000) >> 15);
7825 addend = (addend ^ 0x8000) - 0x8000;
7826 break;
7827
7828 default:
7829 if (howto->rightshift
7830 || (howto->src_mask & (howto->src_mask + 1)))
7831 {
7832 (*_bfd_error_handler)
7833 (_("%B(%A+0x%lx): %s relocation against SEC_MERGE section"),
7834 input_bfd, input_section,
7835 (long) rel->r_offset, howto->name);
7836 return FALSE;
7837 }
7838
7839 value = bfd_get_32 (input_bfd, contents + rel->r_offset);
7840
7841 /* Get the (signed) value from the instruction. */
7842 addend = value & howto->src_mask;
7843 if (addend & ((howto->src_mask + 1) >> 1))
7844 {
7845 bfd_signed_vma mask;
7846
7847 mask = -1;
7848 mask &= ~ howto->src_mask;
7849 addend |= mask;
7850 }
7851 break;
7852 }
7853
7854 msec = sec;
7855 addend =
7856 _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend)
7857 - relocation;
7858 addend += msec->output_section->vma + msec->output_offset;
7859
7860 /* Cases here must match those in the preceeding
7861 switch statement. */
7862 switch (r_type)
7863 {
7864 case R_ARM_MOVW_ABS_NC:
7865 case R_ARM_MOVT_ABS:
7866 value = (value & 0xfff0f000) | ((addend & 0xf000) << 4)
7867 | (addend & 0xfff);
7868 bfd_put_32 (input_bfd, value, contents + rel->r_offset);
7869 break;
7870
7871 case R_ARM_THM_MOVW_ABS_NC:
7872 case R_ARM_THM_MOVT_ABS:
7873 value = (value & 0xfbf08f00) | ((addend & 0xf700) << 4)
7874 | (addend & 0xff) | ((addend & 0x0800) << 15);
7875 bfd_put_16 (input_bfd, value >> 16,
7876 contents + rel->r_offset);
7877 bfd_put_16 (input_bfd, value,
7878 contents + rel->r_offset + 2);
7879 break;
7880
7881 default:
7882 value = (value & ~ howto->dst_mask)
7883 | (addend & howto->dst_mask);
7884 bfd_put_32 (input_bfd, value, contents + rel->r_offset);
7885 break;
7886 }
7887 }
7888 }
7889 else
7890 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
7891 }
7892 else
7893 {
7894 bfd_boolean warned;
7895
7896 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
7897 r_symndx, symtab_hdr, sym_hashes,
7898 h, sec, relocation,
7899 unresolved_reloc, warned);
7900
7901 sym_type = h->type;
7902 }
7903
7904 if (sec != NULL && elf_discarded_section (sec))
7905 {
7906 /* For relocs against symbols from removed linkonce sections,
7907 or sections discarded by a linker script, we just want the
7908 section contents zeroed. Avoid any special processing. */
7909 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
7910 rel->r_info = 0;
7911 rel->r_addend = 0;
7912 continue;
7913 }
7914
7915 if (info->relocatable)
7916 {
7917 /* This is a relocatable link. We don't have to change
7918 anything, unless the reloc is against a section symbol,
7919 in which case we have to adjust according to where the
7920 section symbol winds up in the output section. */
7921 if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
7922 {
7923 if (globals->use_rel)
7924 arm_add_to_rel (input_bfd, contents + rel->r_offset,
7925 howto, (bfd_signed_vma) sec->output_offset);
7926 else
7927 rel->r_addend += sec->output_offset;
7928 }
7929 continue;
7930 }
7931
7932 if (h != NULL)
7933 name = h->root.root.string;
7934 else
7935 {
7936 name = (bfd_elf_string_from_elf_section
7937 (input_bfd, symtab_hdr->sh_link, sym->st_name));
7938 if (name == NULL || *name == '\0')
7939 name = bfd_section_name (input_bfd, sec);
7940 }
7941
7942 if (r_symndx != 0
7943 && r_type != R_ARM_NONE
7944 && (h == NULL
7945 || h->root.type == bfd_link_hash_defined
7946 || h->root.type == bfd_link_hash_defweak)
7947 && IS_ARM_TLS_RELOC (r_type) != (sym_type == STT_TLS))
7948 {
7949 (*_bfd_error_handler)
7950 ((sym_type == STT_TLS
7951 ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
7952 : _("%B(%A+0x%lx): %s used with non-TLS symbol %s")),
7953 input_bfd,
7954 input_section,
7955 (long) rel->r_offset,
7956 howto->name,
7957 name);
7958 }
7959
7960 r = elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
7961 input_section, contents, rel,
7962 relocation, info, sec, name,
7963 (h ? ELF_ST_TYPE (h->type) :
7964 ELF_ST_TYPE (sym->st_info)), h,
7965 &unresolved_reloc, &error_message);
7966
7967 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
7968 because such sections are not SEC_ALLOC and thus ld.so will
7969 not process them. */
7970 if (unresolved_reloc
7971 && !((input_section->flags & SEC_DEBUGGING) != 0
7972 && h->def_dynamic))
7973 {
7974 (*_bfd_error_handler)
7975 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
7976 input_bfd,
7977 input_section,
7978 (long) rel->r_offset,
7979 howto->name,
7980 h->root.root.string);
7981 return FALSE;
7982 }
7983
7984 if (r != bfd_reloc_ok)
7985 {
7986 switch (r)
7987 {
7988 case bfd_reloc_overflow:
7989 /* If the overflowing reloc was to an undefined symbol,
7990 we have already printed one error message and there
7991 is no point complaining again. */
7992 if ((! h ||
7993 h->root.type != bfd_link_hash_undefined)
7994 && (!((*info->callbacks->reloc_overflow)
7995 (info, (h ? &h->root : NULL), name, howto->name,
7996 (bfd_vma) 0, input_bfd, input_section,
7997 rel->r_offset))))
7998 return FALSE;
7999 break;
8000
8001 case bfd_reloc_undefined:
8002 if (!((*info->callbacks->undefined_symbol)
8003 (info, name, input_bfd, input_section,
8004 rel->r_offset, TRUE)))
8005 return FALSE;
8006 break;
8007
8008 case bfd_reloc_outofrange:
8009 error_message = _("out of range");
8010 goto common_error;
8011
8012 case bfd_reloc_notsupported:
8013 error_message = _("unsupported relocation");
8014 goto common_error;
8015
8016 case bfd_reloc_dangerous:
8017 /* error_message should already be set. */
8018 goto common_error;
8019
8020 default:
8021 error_message = _("unknown error");
8022 /* Fall through. */
8023
8024 common_error:
8025 BFD_ASSERT (error_message != NULL);
8026 if (!((*info->callbacks->reloc_dangerous)
8027 (info, error_message, input_bfd, input_section,
8028 rel->r_offset)))
8029 return FALSE;
8030 break;
8031 }
8032 }
8033 }
8034
8035 return TRUE;
8036 }
8037
8038 /* Set the right machine number. */
8039
8040 static bfd_boolean
8041 elf32_arm_object_p (bfd *abfd)
8042 {
8043 unsigned int mach;
8044
8045 mach = bfd_arm_get_mach_from_notes (abfd, ARM_NOTE_SECTION);
8046
8047 if (mach != bfd_mach_arm_unknown)
8048 bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
8049
8050 else if (elf_elfheader (abfd)->e_flags & EF_ARM_MAVERICK_FLOAT)
8051 bfd_default_set_arch_mach (abfd, bfd_arch_arm, bfd_mach_arm_ep9312);
8052
8053 else
8054 bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
8055
8056 return TRUE;
8057 }
8058
8059 /* Function to keep ARM specific flags in the ELF header. */
8060
8061 static bfd_boolean
8062 elf32_arm_set_private_flags (bfd *abfd, flagword flags)
8063 {
8064 if (elf_flags_init (abfd)
8065 && elf_elfheader (abfd)->e_flags != flags)
8066 {
8067 if (EF_ARM_EABI_VERSION (flags) == EF_ARM_EABI_UNKNOWN)
8068 {
8069 if (flags & EF_ARM_INTERWORK)
8070 (*_bfd_error_handler)
8071 (_("Warning: Not setting interworking flag of %B since it has already been specified as non-interworking"),
8072 abfd);
8073 else
8074 _bfd_error_handler
8075 (_("Warning: Clearing the interworking flag of %B due to outside request"),
8076 abfd);
8077 }
8078 }
8079 else
8080 {
8081 elf_elfheader (abfd)->e_flags = flags;
8082 elf_flags_init (abfd) = TRUE;
8083 }
8084
8085 return TRUE;
8086 }
8087
8088 /* Copy backend specific data from one object module to another. */
8089
8090 static bfd_boolean
8091 elf32_arm_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
8092 {
8093 flagword in_flags;
8094 flagword out_flags;
8095
8096 if (! is_arm_elf (ibfd) || ! is_arm_elf (obfd))
8097 return TRUE;
8098
8099 in_flags = elf_elfheader (ibfd)->e_flags;
8100 out_flags = elf_elfheader (obfd)->e_flags;
8101
8102 if (elf_flags_init (obfd)
8103 && EF_ARM_EABI_VERSION (out_flags) == EF_ARM_EABI_UNKNOWN
8104 && in_flags != out_flags)
8105 {
8106 /* Cannot mix APCS26 and APCS32 code. */
8107 if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
8108 return FALSE;
8109
8110 /* Cannot mix float APCS and non-float APCS code. */
8111 if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
8112 return FALSE;
8113
8114 /* If the src and dest have different interworking flags
8115 then turn off the interworking bit. */
8116 if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
8117 {
8118 if (out_flags & EF_ARM_INTERWORK)
8119 _bfd_error_handler
8120 (_("Warning: Clearing the interworking flag of %B because non-interworking code in %B has been linked with it"),
8121 obfd, ibfd);
8122
8123 in_flags &= ~EF_ARM_INTERWORK;
8124 }
8125
8126 /* Likewise for PIC, though don't warn for this case. */
8127 if ((in_flags & EF_ARM_PIC) != (out_flags & EF_ARM_PIC))
8128 in_flags &= ~EF_ARM_PIC;
8129 }
8130
8131 elf_elfheader (obfd)->e_flags = in_flags;
8132 elf_flags_init (obfd) = TRUE;
8133
8134 /* Also copy the EI_OSABI field. */
8135 elf_elfheader (obfd)->e_ident[EI_OSABI] =
8136 elf_elfheader (ibfd)->e_ident[EI_OSABI];
8137
8138 /* Copy object attributes. */
8139 _bfd_elf_copy_obj_attributes (ibfd, obfd);
8140
8141 return TRUE;
8142 }
8143
8144 /* Values for Tag_ABI_PCS_R9_use. */
8145 enum
8146 {
8147 AEABI_R9_V6,
8148 AEABI_R9_SB,
8149 AEABI_R9_TLS,
8150 AEABI_R9_unused
8151 };
8152
8153 /* Values for Tag_ABI_PCS_RW_data. */
8154 enum
8155 {
8156 AEABI_PCS_RW_data_absolute,
8157 AEABI_PCS_RW_data_PCrel,
8158 AEABI_PCS_RW_data_SBrel,
8159 AEABI_PCS_RW_data_unused
8160 };
8161
8162 /* Values for Tag_ABI_enum_size. */
8163 enum
8164 {
8165 AEABI_enum_unused,
8166 AEABI_enum_short,
8167 AEABI_enum_wide,
8168 AEABI_enum_forced_wide
8169 };
8170
8171 /* Determine whether an object attribute tag takes an integer, a
8172 string or both. */
8173
8174 static int
8175 elf32_arm_obj_attrs_arg_type (int tag)
8176 {
8177 if (tag == Tag_compatibility)
8178 return ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL;
8179 else if (tag == Tag_nodefaults)
8180 return ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_NO_DEFAULT;
8181 else if (tag == Tag_CPU_raw_name || tag == Tag_CPU_name)
8182 return ATTR_TYPE_FLAG_STR_VAL;
8183 else if (tag < 32)
8184 return ATTR_TYPE_FLAG_INT_VAL;
8185 else
8186 return (tag & 1) != 0 ? ATTR_TYPE_FLAG_STR_VAL : ATTR_TYPE_FLAG_INT_VAL;
8187 }
8188
8189 /* The ABI defines that Tag_conformance should be emitted first, and that
8190 Tag_nodefaults should be second (if either is defined). This sets those
8191 two positions, and bumps up the position of all the remaining tags to
8192 compensate. */
8193 static int
8194 elf32_arm_obj_attrs_order (int num)
8195 {
8196 if (num == 4)
8197 return Tag_conformance;
8198 if (num == 5)
8199 return Tag_nodefaults;
8200 if ((num - 2) < Tag_nodefaults)
8201 return num - 2;
8202 if ((num - 1) < Tag_conformance)
8203 return num - 1;
8204 return num;
8205 }
8206
8207 /* Read the architecture from the Tag_also_compatible_with attribute, if any.
8208 Returns -1 if no architecture could be read. */
8209
8210 static int
8211 get_secondary_compatible_arch (bfd *abfd)
8212 {
8213 obj_attribute *attr =
8214 &elf_known_obj_attributes_proc (abfd)[Tag_also_compatible_with];
8215
8216 /* Note: the tag and its argument below are uleb128 values, though
8217 currently-defined values fit in one byte for each. */
8218 if (attr->s
8219 && attr->s[0] == Tag_CPU_arch
8220 && (attr->s[1] & 128) != 128
8221 && attr->s[2] == 0)
8222 return attr->s[1];
8223
8224 /* This tag is "safely ignorable", so don't complain if it looks funny. */
8225 return -1;
8226 }
8227
8228 /* Set, or unset, the architecture of the Tag_also_compatible_with attribute.
8229 The tag is removed if ARCH is -1. */
8230
8231 static void
8232 set_secondary_compatible_arch (bfd *abfd, int arch)
8233 {
8234 obj_attribute *attr =
8235 &elf_known_obj_attributes_proc (abfd)[Tag_also_compatible_with];
8236
8237 if (arch == -1)
8238 {
8239 attr->s = NULL;
8240 return;
8241 }
8242
8243 /* Note: the tag and its argument below are uleb128 values, though
8244 currently-defined values fit in one byte for each. */
8245 if (!attr->s)
8246 attr->s = bfd_alloc (abfd, 3);
8247 attr->s[0] = Tag_CPU_arch;
8248 attr->s[1] = arch;
8249 attr->s[2] = '\0';
8250 }
8251
8252 /* Combine two values for Tag_CPU_arch, taking secondary compatibility tags
8253 into account. */
8254
8255 static int
8256 tag_cpu_arch_combine (bfd *ibfd, int oldtag, int *secondary_compat_out,
8257 int newtag, int secondary_compat)
8258 {
8259 #define T(X) TAG_CPU_ARCH_##X
8260 int tagl, tagh, result;
8261 const int v6t2[] =
8262 {
8263 T(V6T2), /* PRE_V4. */
8264 T(V6T2), /* V4. */
8265 T(V6T2), /* V4T. */
8266 T(V6T2), /* V5T. */
8267 T(V6T2), /* V5TE. */
8268 T(V6T2), /* V5TEJ. */
8269 T(V6T2), /* V6. */
8270 T(V7), /* V6KZ. */
8271 T(V6T2) /* V6T2. */
8272 };
8273 const int v6k[] =
8274 {
8275 T(V6K), /* PRE_V4. */
8276 T(V6K), /* V4. */
8277 T(V6K), /* V4T. */
8278 T(V6K), /* V5T. */
8279 T(V6K), /* V5TE. */
8280 T(V6K), /* V5TEJ. */
8281 T(V6K), /* V6. */
8282 T(V6KZ), /* V6KZ. */
8283 T(V7), /* V6T2. */
8284 T(V6K) /* V6K. */
8285 };
8286 const int v7[] =
8287 {
8288 T(V7), /* PRE_V4. */
8289 T(V7), /* V4. */
8290 T(V7), /* V4T. */
8291 T(V7), /* V5T. */
8292 T(V7), /* V5TE. */
8293 T(V7), /* V5TEJ. */
8294 T(V7), /* V6. */
8295 T(V7), /* V6KZ. */
8296 T(V7), /* V6T2. */
8297 T(V7), /* V6K. */
8298 T(V7) /* V7. */
8299 };
8300 const int v6_m[] =
8301 {
8302 -1, /* PRE_V4. */
8303 -1, /* V4. */
8304 T(V6K), /* V4T. */
8305 T(V6K), /* V5T. */
8306 T(V6K), /* V5TE. */
8307 T(V6K), /* V5TEJ. */
8308 T(V6K), /* V6. */
8309 T(V6KZ), /* V6KZ. */
8310 T(V7), /* V6T2. */
8311 T(V6K), /* V6K. */
8312 T(V7), /* V7. */
8313 T(V6_M) /* V6_M. */
8314 };
8315 const int v6s_m[] =
8316 {
8317 -1, /* PRE_V4. */
8318 -1, /* V4. */
8319 T(V6K), /* V4T. */
8320 T(V6K), /* V5T. */
8321 T(V6K), /* V5TE. */
8322 T(V6K), /* V5TEJ. */
8323 T(V6K), /* V6. */
8324 T(V6KZ), /* V6KZ. */
8325 T(V7), /* V6T2. */
8326 T(V6K), /* V6K. */
8327 T(V7), /* V7. */
8328 T(V6S_M), /* V6_M. */
8329 T(V6S_M) /* V6S_M. */
8330 };
8331 const int v4t_plus_v6_m[] =
8332 {
8333 -1, /* PRE_V4. */
8334 -1, /* V4. */
8335 T(V4T), /* V4T. */
8336 T(V5T), /* V5T. */
8337 T(V5TE), /* V5TE. */
8338 T(V5TEJ), /* V5TEJ. */
8339 T(V6), /* V6. */
8340 T(V6KZ), /* V6KZ. */
8341 T(V6T2), /* V6T2. */
8342 T(V6K), /* V6K. */
8343 T(V7), /* V7. */
8344 T(V6_M), /* V6_M. */
8345 T(V6S_M), /* V6S_M. */
8346 T(V4T_PLUS_V6_M) /* V4T plus V6_M. */
8347 };
8348 const int *comb[] =
8349 {
8350 v6t2,
8351 v6k,
8352 v7,
8353 v6_m,
8354 v6s_m,
8355 /* Pseudo-architecture. */
8356 v4t_plus_v6_m
8357 };
8358
8359 /* Check we've not got a higher architecture than we know about. */
8360
8361 if (oldtag >= MAX_TAG_CPU_ARCH || newtag >= MAX_TAG_CPU_ARCH)
8362 {
8363 _bfd_error_handler (_("ERROR: %B: Unknown CPU architecture"), ibfd);
8364 return -1;
8365 }
8366
8367 /* Override old tag if we have a Tag_also_compatible_with on the output. */
8368
8369 if ((oldtag == T(V6_M) && *secondary_compat_out == T(V4T))
8370 || (oldtag == T(V4T) && *secondary_compat_out == T(V6_M)))
8371 oldtag = T(V4T_PLUS_V6_M);
8372
8373 /* And override the new tag if we have a Tag_also_compatible_with on the
8374 input. */
8375
8376 if ((newtag == T(V6_M) && secondary_compat == T(V4T))
8377 || (newtag == T(V4T) && secondary_compat == T(V6_M)))
8378 newtag = T(V4T_PLUS_V6_M);
8379
8380 tagl = (oldtag < newtag) ? oldtag : newtag;
8381 result = tagh = (oldtag > newtag) ? oldtag : newtag;
8382
8383 /* Architectures before V6KZ add features monotonically. */
8384 if (tagh <= TAG_CPU_ARCH_V6KZ)
8385 return result;
8386
8387 result = comb[tagh - T(V6T2)][tagl];
8388
8389 /* Use Tag_CPU_arch == V4T and Tag_also_compatible_with (Tag_CPU_arch V6_M)
8390 as the canonical version. */
8391 if (result == T(V4T_PLUS_V6_M))
8392 {
8393 result = T(V4T);
8394 *secondary_compat_out = T(V6_M);
8395 }
8396 else
8397 *secondary_compat_out = -1;
8398
8399 if (result == -1)
8400 {
8401 _bfd_error_handler (_("ERROR: %B: Conflicting CPU architectures %d/%d"),
8402 ibfd, oldtag, newtag);
8403 return -1;
8404 }
8405
8406 return result;
8407 #undef T
8408 }
8409
8410 /* Merge EABI object attributes from IBFD into OBFD. Raise an error if there
8411 are conflicting attributes. */
8412
8413 static bfd_boolean
8414 elf32_arm_merge_eabi_attributes (bfd *ibfd, bfd *obfd)
8415 {
8416 obj_attribute *in_attr;
8417 obj_attribute *out_attr;
8418 obj_attribute_list *in_list;
8419 obj_attribute_list *out_list;
8420 obj_attribute_list **out_listp;
8421 /* Some tags have 0 = don't care, 1 = strong requirement,
8422 2 = weak requirement. */
8423 static const int order_021[3] = {0, 2, 1};
8424 /* For use with Tag_VFP_arch. */
8425 static const int order_01243[5] = {0, 1, 2, 4, 3};
8426 int i;
8427 bfd_boolean result = TRUE;
8428
8429 if (!elf_known_obj_attributes_proc (obfd)[0].i)
8430 {
8431 /* This is the first object. Copy the attributes. */
8432 _bfd_elf_copy_obj_attributes (ibfd, obfd);
8433
8434 /* Use the Tag_null value to indicate the attributes have been
8435 initialized. */
8436 elf_known_obj_attributes_proc (obfd)[0].i = 1;
8437
8438 return TRUE;
8439 }
8440
8441 in_attr = elf_known_obj_attributes_proc (ibfd);
8442 out_attr = elf_known_obj_attributes_proc (obfd);
8443 /* This needs to happen before Tag_ABI_FP_number_model is merged. */
8444 if (in_attr[Tag_ABI_VFP_args].i != out_attr[Tag_ABI_VFP_args].i)
8445 {
8446 /* Ignore mismatches if the object doesn't use floating point. */
8447 if (out_attr[Tag_ABI_FP_number_model].i == 0)
8448 out_attr[Tag_ABI_VFP_args].i = in_attr[Tag_ABI_VFP_args].i;
8449 else if (in_attr[Tag_ABI_FP_number_model].i != 0)
8450 {
8451 _bfd_error_handler
8452 (_("ERROR: %B uses VFP register arguments, %B does not"),
8453 ibfd, obfd);
8454 result = FALSE;
8455 }
8456 }
8457
8458 for (i = 4; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++)
8459 {
8460 /* Merge this attribute with existing attributes. */
8461 switch (i)
8462 {
8463 case Tag_CPU_raw_name:
8464 case Tag_CPU_name:
8465 /* These are merged after Tag_CPU_arch. */
8466 break;
8467
8468 case Tag_ABI_optimization_goals:
8469 case Tag_ABI_FP_optimization_goals:
8470 /* Use the first value seen. */
8471 break;
8472
8473 case Tag_CPU_arch:
8474 {
8475 int secondary_compat = -1, secondary_compat_out = -1;
8476 unsigned int saved_out_attr = out_attr[i].i;
8477 static const char *name_table[] = {
8478 /* These aren't real CPU names, but we can't guess
8479 that from the architecture version alone. */
8480 "Pre v4",
8481 "ARM v4",
8482 "ARM v4T",
8483 "ARM v5T",
8484 "ARM v5TE",
8485 "ARM v5TEJ",
8486 "ARM v6",
8487 "ARM v6KZ",
8488 "ARM v6T2",
8489 "ARM v6K",
8490 "ARM v7",
8491 "ARM v6-M",
8492 "ARM v6S-M"
8493 };
8494
8495 /* Merge Tag_CPU_arch and Tag_also_compatible_with. */
8496 secondary_compat = get_secondary_compatible_arch (ibfd);
8497 secondary_compat_out = get_secondary_compatible_arch (obfd);
8498 out_attr[i].i = tag_cpu_arch_combine (ibfd, out_attr[i].i,
8499 &secondary_compat_out,
8500 in_attr[i].i,
8501 secondary_compat);
8502 set_secondary_compatible_arch (obfd, secondary_compat_out);
8503
8504 /* Merge Tag_CPU_name and Tag_CPU_raw_name. */
8505 if (out_attr[i].i == saved_out_attr)
8506 ; /* Leave the names alone. */
8507 else if (out_attr[i].i == in_attr[i].i)
8508 {
8509 /* The output architecture has been changed to match the
8510 input architecture. Use the input names. */
8511 out_attr[Tag_CPU_name].s = in_attr[Tag_CPU_name].s
8512 ? _bfd_elf_attr_strdup (obfd, in_attr[Tag_CPU_name].s)
8513 : NULL;
8514 out_attr[Tag_CPU_raw_name].s = in_attr[Tag_CPU_raw_name].s
8515 ? _bfd_elf_attr_strdup (obfd, in_attr[Tag_CPU_raw_name].s)
8516 : NULL;
8517 }
8518 else
8519 {
8520 out_attr[Tag_CPU_name].s = NULL;
8521 out_attr[Tag_CPU_raw_name].s = NULL;
8522 }
8523
8524 /* If we still don't have a value for Tag_CPU_name,
8525 make one up now. Tag_CPU_raw_name remains blank. */
8526 if (out_attr[Tag_CPU_name].s == NULL
8527 && out_attr[i].i < ARRAY_SIZE (name_table))
8528 out_attr[Tag_CPU_name].s =
8529 _bfd_elf_attr_strdup (obfd, name_table[out_attr[i].i]);
8530 }
8531 break;
8532
8533 case Tag_ARM_ISA_use:
8534 case Tag_THUMB_ISA_use:
8535 case Tag_WMMX_arch:
8536 case Tag_Advanced_SIMD_arch:
8537 /* ??? Do Advanced_SIMD (NEON) and WMMX conflict? */
8538 case Tag_ABI_FP_rounding:
8539 case Tag_ABI_FP_exceptions:
8540 case Tag_ABI_FP_user_exceptions:
8541 case Tag_ABI_FP_number_model:
8542 case Tag_VFP_HP_extension:
8543 case Tag_CPU_unaligned_access:
8544 case Tag_T2EE_use:
8545 case Tag_Virtualization_use:
8546 case Tag_MPextension_use:
8547 /* Use the largest value specified. */
8548 if (in_attr[i].i > out_attr[i].i)
8549 out_attr[i].i = in_attr[i].i;
8550 break;
8551
8552 case Tag_ABI_align8_preserved:
8553 case Tag_ABI_PCS_RO_data:
8554 /* Use the smallest value specified. */
8555 if (in_attr[i].i < out_attr[i].i)
8556 out_attr[i].i = in_attr[i].i;
8557 break;
8558
8559 case Tag_ABI_align8_needed:
8560 if ((in_attr[i].i > 0 || out_attr[i].i > 0)
8561 && (in_attr[Tag_ABI_align8_preserved].i == 0
8562 || out_attr[Tag_ABI_align8_preserved].i == 0))
8563 {
8564 /* This error message should be enabled once all non-conformant
8565 binaries in the toolchain have had the attributes set
8566 properly.
8567 _bfd_error_handler
8568 (_("ERROR: %B: 8-byte data alignment conflicts with %B"),
8569 obfd, ibfd);
8570 result = FALSE; */
8571 }
8572 /* Fall through. */
8573 case Tag_ABI_FP_denormal:
8574 case Tag_ABI_PCS_GOT_use:
8575 /* Use the "greatest" from the sequence 0, 2, 1, or the largest
8576 value if greater than 2 (for future-proofing). */
8577 if ((in_attr[i].i > 2 && in_attr[i].i > out_attr[i].i)
8578 || (in_attr[i].i <= 2 && out_attr[i].i <= 2
8579 && order_021[in_attr[i].i] > order_021[out_attr[i].i]))
8580 out_attr[i].i = in_attr[i].i;
8581 break;
8582
8583
8584 case Tag_CPU_arch_profile:
8585 if (out_attr[i].i != in_attr[i].i)
8586 {
8587 /* 0 will merge with anything.
8588 'A' and 'S' merge to 'A'.
8589 'R' and 'S' merge to 'R'.
8590 'M' and 'A|R|S' is an error. */
8591 if (out_attr[i].i == 0
8592 || (out_attr[i].i == 'S'
8593 && (in_attr[i].i == 'A' || in_attr[i].i == 'R')))
8594 out_attr[i].i = in_attr[i].i;
8595 else if (in_attr[i].i == 0
8596 || (in_attr[i].i == 'S'
8597 && (out_attr[i].i == 'A' || out_attr[i].i == 'R')))
8598 ; /* Do nothing. */
8599 else
8600 {
8601 _bfd_error_handler
8602 (_("ERROR: %B: Conflicting architecture profiles %c/%c"),
8603 ibfd,
8604 in_attr[i].i ? in_attr[i].i : '0',
8605 out_attr[i].i ? out_attr[i].i : '0');
8606 result = FALSE;
8607 }
8608 }
8609 break;
8610 case Tag_VFP_arch:
8611 /* Use the "greatest" from the sequence 0, 1, 2, 4, 3, or the
8612 largest value if greater than 4 (for future-proofing). */
8613 if ((in_attr[i].i > 4 && in_attr[i].i > out_attr[i].i)
8614 || (in_attr[i].i <= 4 && out_attr[i].i <= 4
8615 && order_01243[in_attr[i].i] > order_01243[out_attr[i].i]))
8616 out_attr[i].i = in_attr[i].i;
8617 break;
8618 case Tag_PCS_config:
8619 if (out_attr[i].i == 0)
8620 out_attr[i].i = in_attr[i].i;
8621 else if (in_attr[i].i != 0 && out_attr[i].i != 0)
8622 {
8623 /* It's sometimes ok to mix different configs, so this is only
8624 a warning. */
8625 _bfd_error_handler
8626 (_("Warning: %B: Conflicting platform configuration"), ibfd);
8627 }
8628 break;
8629 case Tag_ABI_PCS_R9_use:
8630 if (in_attr[i].i != out_attr[i].i
8631 && out_attr[i].i != AEABI_R9_unused
8632 && in_attr[i].i != AEABI_R9_unused)
8633 {
8634 _bfd_error_handler
8635 (_("ERROR: %B: Conflicting use of R9"), ibfd);
8636 result = FALSE;
8637 }
8638 if (out_attr[i].i == AEABI_R9_unused)
8639 out_attr[i].i = in_attr[i].i;
8640 break;
8641 case Tag_ABI_PCS_RW_data:
8642 if (in_attr[i].i == AEABI_PCS_RW_data_SBrel
8643 && out_attr[Tag_ABI_PCS_R9_use].i != AEABI_R9_SB
8644 && out_attr[Tag_ABI_PCS_R9_use].i != AEABI_R9_unused)
8645 {
8646 _bfd_error_handler
8647 (_("ERROR: %B: SB relative addressing conflicts with use of R9"),
8648 ibfd);
8649 result = FALSE;
8650 }
8651 /* Use the smallest value specified. */
8652 if (in_attr[i].i < out_attr[i].i)
8653 out_attr[i].i = in_attr[i].i;
8654 break;
8655 case Tag_ABI_PCS_wchar_t:
8656 if (out_attr[i].i && in_attr[i].i && out_attr[i].i != in_attr[i].i
8657 && !elf_arm_tdata (obfd)->no_wchar_size_warning)
8658 {
8659 _bfd_error_handler
8660 (_("warning: %B uses %u-byte wchar_t yet the output is to use %u-byte wchar_t; use of wchar_t values across objects may fail"),
8661 ibfd, in_attr[i].i, out_attr[i].i);
8662 }
8663 else if (in_attr[i].i && !out_attr[i].i)
8664 out_attr[i].i = in_attr[i].i;
8665 break;
8666 case Tag_ABI_enum_size:
8667 if (in_attr[i].i != AEABI_enum_unused)
8668 {
8669 if (out_attr[i].i == AEABI_enum_unused
8670 || out_attr[i].i == AEABI_enum_forced_wide)
8671 {
8672 /* The existing object is compatible with anything.
8673 Use whatever requirements the new object has. */
8674 out_attr[i].i = in_attr[i].i;
8675 }
8676 else if (in_attr[i].i != AEABI_enum_forced_wide
8677 && out_attr[i].i != in_attr[i].i
8678 && !elf_arm_tdata (obfd)->no_enum_size_warning)
8679 {
8680 static const char *aeabi_enum_names[] =
8681 { "", "variable-size", "32-bit", "" };
8682 const char *in_name =
8683 in_attr[i].i < ARRAY_SIZE(aeabi_enum_names)
8684 ? aeabi_enum_names[in_attr[i].i]
8685 : "<unknown>";
8686 const char *out_name =
8687 out_attr[i].i < ARRAY_SIZE(aeabi_enum_names)
8688 ? aeabi_enum_names[out_attr[i].i]
8689 : "<unknown>";
8690 _bfd_error_handler
8691 (_("warning: %B uses %s enums yet the output is to use %s enums; use of enum values across objects may fail"),
8692 ibfd, in_name, out_name);
8693 }
8694 }
8695 break;
8696 case Tag_ABI_VFP_args:
8697 /* Aready done. */
8698 break;
8699 case Tag_ABI_WMMX_args:
8700 if (in_attr[i].i != out_attr[i].i)
8701 {
8702 _bfd_error_handler
8703 (_("ERROR: %B uses iWMMXt register arguments, %B does not"),
8704 ibfd, obfd);
8705 result = FALSE;
8706 }
8707 break;
8708 case Tag_compatibility:
8709 /* Merged in target-independent code. */
8710 break;
8711 case Tag_ABI_HardFP_use:
8712 /* 1 (SP) and 2 (DP) conflict, so combine to 3 (SP & DP). */
8713 if ((in_attr[i].i == 1 && out_attr[i].i == 2)
8714 || (in_attr[i].i == 2 && out_attr[i].i == 1))
8715 out_attr[i].i = 3;
8716 else if (in_attr[i].i > out_attr[i].i)
8717 out_attr[i].i = in_attr[i].i;
8718 break;
8719 case Tag_ABI_FP_16bit_format:
8720 if (in_attr[i].i != 0 && out_attr[i].i != 0)
8721 {
8722 if (in_attr[i].i != out_attr[i].i)
8723 {
8724 _bfd_error_handler
8725 (_("ERROR: fp16 format mismatch between %B and %B"),
8726 ibfd, obfd);
8727 result = FALSE;
8728 }
8729 }
8730 if (in_attr[i].i != 0)
8731 out_attr[i].i = in_attr[i].i;
8732 break;
8733
8734 case Tag_nodefaults:
8735 /* This tag is set if it exists, but the value is unused (and is
8736 typically zero). We don't actually need to do anything here -
8737 the merge happens automatically when the type flags are merged
8738 below. */
8739 break;
8740 case Tag_also_compatible_with:
8741 /* Already done in Tag_CPU_arch. */
8742 break;
8743 case Tag_conformance:
8744 /* Keep the attribute if it matches. Throw it away otherwise.
8745 No attribute means no claim to conform. */
8746 if (!in_attr[i].s || !out_attr[i].s
8747 || strcmp (in_attr[i].s, out_attr[i].s) != 0)
8748 out_attr[i].s = NULL;
8749 break;
8750
8751 default:
8752 {
8753 bfd *err_bfd = NULL;
8754
8755 /* The "known_obj_attributes" table does contain some undefined
8756 attributes. Ensure that there are unused. */
8757 if (out_attr[i].i != 0 || out_attr[i].s != NULL)
8758 err_bfd = obfd;
8759 else if (in_attr[i].i != 0 || in_attr[i].s != NULL)
8760 err_bfd = ibfd;
8761
8762 if (err_bfd != NULL)
8763 {
8764 /* Attribute numbers >=64 (mod 128) can be safely ignored. */
8765 if ((i & 127) < 64)
8766 {
8767 _bfd_error_handler
8768 (_("%B: Unknown mandatory EABI object attribute %d"),
8769 err_bfd, i);
8770 bfd_set_error (bfd_error_bad_value);
8771 result = FALSE;
8772 }
8773 else
8774 {
8775 _bfd_error_handler
8776 (_("Warning: %B: Unknown EABI object attribute %d"),
8777 err_bfd, i);
8778 }
8779 }
8780
8781 /* Only pass on attributes that match in both inputs. */
8782 if (in_attr[i].i != out_attr[i].i
8783 || in_attr[i].s != out_attr[i].s
8784 || (in_attr[i].s != NULL && out_attr[i].s != NULL
8785 && strcmp (in_attr[i].s, out_attr[i].s) != 0))
8786 {
8787 out_attr[i].i = 0;
8788 out_attr[i].s = NULL;
8789 }
8790 }
8791 }
8792
8793 /* If out_attr was copied from in_attr then it won't have a type yet. */
8794 if (in_attr[i].type && !out_attr[i].type)
8795 out_attr[i].type = in_attr[i].type;
8796 }
8797
8798 /* Merge Tag_compatibility attributes and any common GNU ones. */
8799 _bfd_elf_merge_object_attributes (ibfd, obfd);
8800
8801 /* Check for any attributes not known on ARM. */
8802 in_list = elf_other_obj_attributes_proc (ibfd);
8803 out_listp = &elf_other_obj_attributes_proc (obfd);
8804 out_list = *out_listp;
8805
8806 for (; in_list || out_list; )
8807 {
8808 bfd *err_bfd = NULL;
8809 int err_tag = 0;
8810
8811 /* The tags for each list are in numerical order. */
8812 /* If the tags are equal, then merge. */
8813 if (out_list && (!in_list || in_list->tag > out_list->tag))
8814 {
8815 /* This attribute only exists in obfd. We can't merge, and we don't
8816 know what the tag means, so delete it. */
8817 err_bfd = obfd;
8818 err_tag = out_list->tag;
8819 *out_listp = out_list->next;
8820 out_list = *out_listp;
8821 }
8822 else if (in_list && (!out_list || in_list->tag < out_list->tag))
8823 {
8824 /* This attribute only exists in ibfd. We can't merge, and we don't
8825 know what the tag means, so ignore it. */
8826 err_bfd = ibfd;
8827 err_tag = in_list->tag;
8828 in_list = in_list->next;
8829 }
8830 else /* The tags are equal. */
8831 {
8832 /* As present, all attributes in the list are unknown, and
8833 therefore can't be merged meaningfully. */
8834 err_bfd = obfd;
8835 err_tag = out_list->tag;
8836
8837 /* Only pass on attributes that match in both inputs. */
8838 if (in_list->attr.i != out_list->attr.i
8839 || in_list->attr.s != out_list->attr.s
8840 || (in_list->attr.s && out_list->attr.s
8841 && strcmp (in_list->attr.s, out_list->attr.s) != 0))
8842 {
8843 /* No match. Delete the attribute. */
8844 *out_listp = out_list->next;
8845 out_list = *out_listp;
8846 }
8847 else
8848 {
8849 /* Matched. Keep the attribute and move to the next. */
8850 out_list = out_list->next;
8851 in_list = in_list->next;
8852 }
8853 }
8854
8855 if (err_bfd)
8856 {
8857 /* Attribute numbers >=64 (mod 128) can be safely ignored. */
8858 if ((err_tag & 127) < 64)
8859 {
8860 _bfd_error_handler
8861 (_("%B: Unknown mandatory EABI object attribute %d"),
8862 err_bfd, err_tag);
8863 bfd_set_error (bfd_error_bad_value);
8864 result = FALSE;
8865 }
8866 else
8867 {
8868 _bfd_error_handler
8869 (_("Warning: %B: Unknown EABI object attribute %d"),
8870 err_bfd, err_tag);
8871 }
8872 }
8873 }
8874 return result;
8875 }
8876
8877
8878 /* Return TRUE if the two EABI versions are incompatible. */
8879
8880 static bfd_boolean
8881 elf32_arm_versions_compatible (unsigned iver, unsigned over)
8882 {
8883 /* v4 and v5 are the same spec before and after it was released,
8884 so allow mixing them. */
8885 if ((iver == EF_ARM_EABI_VER4 && over == EF_ARM_EABI_VER5)
8886 || (iver == EF_ARM_EABI_VER5 && over == EF_ARM_EABI_VER4))
8887 return TRUE;
8888
8889 return (iver == over);
8890 }
8891
8892 /* Merge backend specific data from an object file to the output
8893 object file when linking. */
8894
8895 static bfd_boolean
8896 elf32_arm_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
8897 {
8898 flagword out_flags;
8899 flagword in_flags;
8900 bfd_boolean flags_compatible = TRUE;
8901 asection *sec;
8902
8903 /* Check if we have the same endianess. */
8904 if (! _bfd_generic_verify_endian_match (ibfd, obfd))
8905 return FALSE;
8906
8907 if (! is_arm_elf (ibfd) || ! is_arm_elf (obfd))
8908 return TRUE;
8909
8910 if (!elf32_arm_merge_eabi_attributes (ibfd, obfd))
8911 return FALSE;
8912
8913 /* The input BFD must have had its flags initialised. */
8914 /* The following seems bogus to me -- The flags are initialized in
8915 the assembler but I don't think an elf_flags_init field is
8916 written into the object. */
8917 /* BFD_ASSERT (elf_flags_init (ibfd)); */
8918
8919 in_flags = elf_elfheader (ibfd)->e_flags;
8920 out_flags = elf_elfheader (obfd)->e_flags;
8921
8922 /* In theory there is no reason why we couldn't handle this. However
8923 in practice it isn't even close to working and there is no real
8924 reason to want it. */
8925 if (EF_ARM_EABI_VERSION (in_flags) >= EF_ARM_EABI_VER4
8926 && !(ibfd->flags & DYNAMIC)
8927 && (in_flags & EF_ARM_BE8))
8928 {
8929 _bfd_error_handler (_("ERROR: %B is already in final BE8 format"),
8930 ibfd);
8931 return FALSE;
8932 }
8933
8934 if (!elf_flags_init (obfd))
8935 {
8936 /* If the input is the default architecture and had the default
8937 flags then do not bother setting the flags for the output
8938 architecture, instead allow future merges to do this. If no
8939 future merges ever set these flags then they will retain their
8940 uninitialised values, which surprise surprise, correspond
8941 to the default values. */
8942 if (bfd_get_arch_info (ibfd)->the_default
8943 && elf_elfheader (ibfd)->e_flags == 0)
8944 return TRUE;
8945
8946 elf_flags_init (obfd) = TRUE;
8947 elf_elfheader (obfd)->e_flags = in_flags;
8948
8949 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
8950 && bfd_get_arch_info (obfd)->the_default)
8951 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
8952
8953 return TRUE;
8954 }
8955
8956 /* Determine what should happen if the input ARM architecture
8957 does not match the output ARM architecture. */
8958 if (! bfd_arm_merge_machines (ibfd, obfd))
8959 return FALSE;
8960
8961 /* Identical flags must be compatible. */
8962 if (in_flags == out_flags)
8963 return TRUE;
8964
8965 /* Check to see if the input BFD actually contains any sections. If
8966 not, its flags may not have been initialised either, but it
8967 cannot actually cause any incompatiblity. Do not short-circuit
8968 dynamic objects; their section list may be emptied by
8969 elf_link_add_object_symbols.
8970
8971 Also check to see if there are no code sections in the input.
8972 In this case there is no need to check for code specific flags.
8973 XXX - do we need to worry about floating-point format compatability
8974 in data sections ? */
8975 if (!(ibfd->flags & DYNAMIC))
8976 {
8977 bfd_boolean null_input_bfd = TRUE;
8978 bfd_boolean only_data_sections = TRUE;
8979
8980 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8981 {
8982 /* Ignore synthetic glue sections. */
8983 if (strcmp (sec->name, ".glue_7")
8984 && strcmp (sec->name, ".glue_7t"))
8985 {
8986 if ((bfd_get_section_flags (ibfd, sec)
8987 & (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
8988 == (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
8989 only_data_sections = FALSE;
8990
8991 null_input_bfd = FALSE;
8992 break;
8993 }
8994 }
8995
8996 if (null_input_bfd || only_data_sections)
8997 return TRUE;
8998 }
8999
9000 /* Complain about various flag mismatches. */
9001 if (!elf32_arm_versions_compatible (EF_ARM_EABI_VERSION (in_flags),
9002 EF_ARM_EABI_VERSION (out_flags)))
9003 {
9004 _bfd_error_handler
9005 (_("ERROR: Source object %B has EABI version %d, but target %B has EABI version %d"),
9006 ibfd, obfd,
9007 (in_flags & EF_ARM_EABIMASK) >> 24,
9008 (out_flags & EF_ARM_EABIMASK) >> 24);
9009 return FALSE;
9010 }
9011
9012 /* Not sure what needs to be checked for EABI versions >= 1. */
9013 /* VxWorks libraries do not use these flags. */
9014 if (get_elf_backend_data (obfd) != &elf32_arm_vxworks_bed
9015 && get_elf_backend_data (ibfd) != &elf32_arm_vxworks_bed
9016 && EF_ARM_EABI_VERSION (in_flags) == EF_ARM_EABI_UNKNOWN)
9017 {
9018 if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
9019 {
9020 _bfd_error_handler
9021 (_("ERROR: %B is compiled for APCS-%d, whereas target %B uses APCS-%d"),
9022 ibfd, obfd,
9023 in_flags & EF_ARM_APCS_26 ? 26 : 32,
9024 out_flags & EF_ARM_APCS_26 ? 26 : 32);
9025 flags_compatible = FALSE;
9026 }
9027
9028 if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
9029 {
9030 if (in_flags & EF_ARM_APCS_FLOAT)
9031 _bfd_error_handler
9032 (_("ERROR: %B passes floats in float registers, whereas %B passes them in integer registers"),
9033 ibfd, obfd);
9034 else
9035 _bfd_error_handler
9036 (_("ERROR: %B passes floats in integer registers, whereas %B passes them in float registers"),
9037 ibfd, obfd);
9038
9039 flags_compatible = FALSE;
9040 }
9041
9042 if ((in_flags & EF_ARM_VFP_FLOAT) != (out_flags & EF_ARM_VFP_FLOAT))
9043 {
9044 if (in_flags & EF_ARM_VFP_FLOAT)
9045 _bfd_error_handler
9046 (_("ERROR: %B uses VFP instructions, whereas %B does not"),
9047 ibfd, obfd);
9048 else
9049 _bfd_error_handler
9050 (_("ERROR: %B uses FPA instructions, whereas %B does not"),
9051 ibfd, obfd);
9052
9053 flags_compatible = FALSE;
9054 }
9055
9056 if ((in_flags & EF_ARM_MAVERICK_FLOAT) != (out_flags & EF_ARM_MAVERICK_FLOAT))
9057 {
9058 if (in_flags & EF_ARM_MAVERICK_FLOAT)
9059 _bfd_error_handler
9060 (_("ERROR: %B uses Maverick instructions, whereas %B does not"),
9061 ibfd, obfd);
9062 else
9063 _bfd_error_handler
9064 (_("ERROR: %B does not use Maverick instructions, whereas %B does"),
9065 ibfd, obfd);
9066
9067 flags_compatible = FALSE;
9068 }
9069
9070 #ifdef EF_ARM_SOFT_FLOAT
9071 if ((in_flags & EF_ARM_SOFT_FLOAT) != (out_flags & EF_ARM_SOFT_FLOAT))
9072 {
9073 /* We can allow interworking between code that is VFP format
9074 layout, and uses either soft float or integer regs for
9075 passing floating point arguments and results. We already
9076 know that the APCS_FLOAT flags match; similarly for VFP
9077 flags. */
9078 if ((in_flags & EF_ARM_APCS_FLOAT) != 0
9079 || (in_flags & EF_ARM_VFP_FLOAT) == 0)
9080 {
9081 if (in_flags & EF_ARM_SOFT_FLOAT)
9082 _bfd_error_handler
9083 (_("ERROR: %B uses software FP, whereas %B uses hardware FP"),
9084 ibfd, obfd);
9085 else
9086 _bfd_error_handler
9087 (_("ERROR: %B uses hardware FP, whereas %B uses software FP"),
9088 ibfd, obfd);
9089
9090 flags_compatible = FALSE;
9091 }
9092 }
9093 #endif
9094
9095 /* Interworking mismatch is only a warning. */
9096 if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
9097 {
9098 if (in_flags & EF_ARM_INTERWORK)
9099 {
9100 _bfd_error_handler
9101 (_("Warning: %B supports interworking, whereas %B does not"),
9102 ibfd, obfd);
9103 }
9104 else
9105 {
9106 _bfd_error_handler
9107 (_("Warning: %B does not support interworking, whereas %B does"),
9108 ibfd, obfd);
9109 }
9110 }
9111 }
9112
9113 return flags_compatible;
9114 }
9115
9116 /* Display the flags field. */
9117
9118 static bfd_boolean
9119 elf32_arm_print_private_bfd_data (bfd *abfd, void * ptr)
9120 {
9121 FILE * file = (FILE *) ptr;
9122 unsigned long flags;
9123
9124 BFD_ASSERT (abfd != NULL && ptr != NULL);
9125
9126 /* Print normal ELF private data. */
9127 _bfd_elf_print_private_bfd_data (abfd, ptr);
9128
9129 flags = elf_elfheader (abfd)->e_flags;
9130 /* Ignore init flag - it may not be set, despite the flags field
9131 containing valid data. */
9132
9133 /* xgettext:c-format */
9134 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
9135
9136 switch (EF_ARM_EABI_VERSION (flags))
9137 {
9138 case EF_ARM_EABI_UNKNOWN:
9139 /* The following flag bits are GNU extensions and not part of the
9140 official ARM ELF extended ABI. Hence they are only decoded if
9141 the EABI version is not set. */
9142 if (flags & EF_ARM_INTERWORK)
9143 fprintf (file, _(" [interworking enabled]"));
9144
9145 if (flags & EF_ARM_APCS_26)
9146 fprintf (file, " [APCS-26]");
9147 else
9148 fprintf (file, " [APCS-32]");
9149
9150 if (flags & EF_ARM_VFP_FLOAT)
9151 fprintf (file, _(" [VFP float format]"));
9152 else if (flags & EF_ARM_MAVERICK_FLOAT)
9153 fprintf (file, _(" [Maverick float format]"));
9154 else
9155 fprintf (file, _(" [FPA float format]"));
9156
9157 if (flags & EF_ARM_APCS_FLOAT)
9158 fprintf (file, _(" [floats passed in float registers]"));
9159
9160 if (flags & EF_ARM_PIC)
9161 fprintf (file, _(" [position independent]"));
9162
9163 if (flags & EF_ARM_NEW_ABI)
9164 fprintf (file, _(" [new ABI]"));
9165
9166 if (flags & EF_ARM_OLD_ABI)
9167 fprintf (file, _(" [old ABI]"));
9168
9169 if (flags & EF_ARM_SOFT_FLOAT)
9170 fprintf (file, _(" [software FP]"));
9171
9172 flags &= ~(EF_ARM_INTERWORK | EF_ARM_APCS_26 | EF_ARM_APCS_FLOAT
9173 | EF_ARM_PIC | EF_ARM_NEW_ABI | EF_ARM_OLD_ABI
9174 | EF_ARM_SOFT_FLOAT | EF_ARM_VFP_FLOAT
9175 | EF_ARM_MAVERICK_FLOAT);
9176 break;
9177
9178 case EF_ARM_EABI_VER1:
9179 fprintf (file, _(" [Version1 EABI]"));
9180
9181 if (flags & EF_ARM_SYMSARESORTED)
9182 fprintf (file, _(" [sorted symbol table]"));
9183 else
9184 fprintf (file, _(" [unsorted symbol table]"));
9185
9186 flags &= ~ EF_ARM_SYMSARESORTED;
9187 break;
9188
9189 case EF_ARM_EABI_VER2:
9190 fprintf (file, _(" [Version2 EABI]"));
9191
9192 if (flags & EF_ARM_SYMSARESORTED)
9193 fprintf (file, _(" [sorted symbol table]"));
9194 else
9195 fprintf (file, _(" [unsorted symbol table]"));
9196
9197 if (flags & EF_ARM_DYNSYMSUSESEGIDX)
9198 fprintf (file, _(" [dynamic symbols use segment index]"));
9199
9200 if (flags & EF_ARM_MAPSYMSFIRST)
9201 fprintf (file, _(" [mapping symbols precede others]"));
9202
9203 flags &= ~(EF_ARM_SYMSARESORTED | EF_ARM_DYNSYMSUSESEGIDX
9204 | EF_ARM_MAPSYMSFIRST);
9205 break;
9206
9207 case EF_ARM_EABI_VER3:
9208 fprintf (file, _(" [Version3 EABI]"));
9209 break;
9210
9211 case EF_ARM_EABI_VER4:
9212 fprintf (file, _(" [Version4 EABI]"));
9213 goto eabi;
9214
9215 case EF_ARM_EABI_VER5:
9216 fprintf (file, _(" [Version5 EABI]"));
9217 eabi:
9218 if (flags & EF_ARM_BE8)
9219 fprintf (file, _(" [BE8]"));
9220
9221 if (flags & EF_ARM_LE8)
9222 fprintf (file, _(" [LE8]"));
9223
9224 flags &= ~(EF_ARM_LE8 | EF_ARM_BE8);
9225 break;
9226
9227 default:
9228 fprintf (file, _(" <EABI version unrecognised>"));
9229 break;
9230 }
9231
9232 flags &= ~ EF_ARM_EABIMASK;
9233
9234 if (flags & EF_ARM_RELEXEC)
9235 fprintf (file, _(" [relocatable executable]"));
9236
9237 if (flags & EF_ARM_HASENTRY)
9238 fprintf (file, _(" [has entry point]"));
9239
9240 flags &= ~ (EF_ARM_RELEXEC | EF_ARM_HASENTRY);
9241
9242 if (flags)
9243 fprintf (file, _("<Unrecognised flag bits set>"));
9244
9245 fputc ('\n', file);
9246
9247 return TRUE;
9248 }
9249
9250 static int
9251 elf32_arm_get_symbol_type (Elf_Internal_Sym * elf_sym, int type)
9252 {
9253 switch (ELF_ST_TYPE (elf_sym->st_info))
9254 {
9255 case STT_ARM_TFUNC:
9256 return ELF_ST_TYPE (elf_sym->st_info);
9257
9258 case STT_ARM_16BIT:
9259 /* If the symbol is not an object, return the STT_ARM_16BIT flag.
9260 This allows us to distinguish between data used by Thumb instructions
9261 and non-data (which is probably code) inside Thumb regions of an
9262 executable. */
9263 if (type != STT_OBJECT && type != STT_TLS)
9264 return ELF_ST_TYPE (elf_sym->st_info);
9265 break;
9266
9267 default:
9268 break;
9269 }
9270
9271 return type;
9272 }
9273
9274 static asection *
9275 elf32_arm_gc_mark_hook (asection *sec,
9276 struct bfd_link_info *info,
9277 Elf_Internal_Rela *rel,
9278 struct elf_link_hash_entry *h,
9279 Elf_Internal_Sym *sym)
9280 {
9281 if (h != NULL)
9282 switch (ELF32_R_TYPE (rel->r_info))
9283 {
9284 case R_ARM_GNU_VTINHERIT:
9285 case R_ARM_GNU_VTENTRY:
9286 return NULL;
9287 }
9288
9289 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
9290 }
9291
9292 /* Update the got entry reference counts for the section being removed. */
9293
9294 static bfd_boolean
9295 elf32_arm_gc_sweep_hook (bfd * abfd,
9296 struct bfd_link_info * info,
9297 asection * sec,
9298 const Elf_Internal_Rela * relocs)
9299 {
9300 Elf_Internal_Shdr *symtab_hdr;
9301 struct elf_link_hash_entry **sym_hashes;
9302 bfd_signed_vma *local_got_refcounts;
9303 const Elf_Internal_Rela *rel, *relend;
9304 struct elf32_arm_link_hash_table * globals;
9305
9306 if (info->relocatable)
9307 return TRUE;
9308
9309 globals = elf32_arm_hash_table (info);
9310
9311 elf_section_data (sec)->local_dynrel = NULL;
9312
9313 symtab_hdr = & elf_symtab_hdr (abfd);
9314 sym_hashes = elf_sym_hashes (abfd);
9315 local_got_refcounts = elf_local_got_refcounts (abfd);
9316
9317 check_use_blx (globals);
9318
9319 relend = relocs + sec->reloc_count;
9320 for (rel = relocs; rel < relend; rel++)
9321 {
9322 unsigned long r_symndx;
9323 struct elf_link_hash_entry *h = NULL;
9324 int r_type;
9325
9326 r_symndx = ELF32_R_SYM (rel->r_info);
9327 if (r_symndx >= symtab_hdr->sh_info)
9328 {
9329 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
9330 while (h->root.type == bfd_link_hash_indirect
9331 || h->root.type == bfd_link_hash_warning)
9332 h = (struct elf_link_hash_entry *) h->root.u.i.link;
9333 }
9334
9335 r_type = ELF32_R_TYPE (rel->r_info);
9336 r_type = arm_real_reloc_type (globals, r_type);
9337 switch (r_type)
9338 {
9339 case R_ARM_GOT32:
9340 case R_ARM_GOT_PREL:
9341 case R_ARM_TLS_GD32:
9342 case R_ARM_TLS_IE32:
9343 if (h != NULL)
9344 {
9345 if (h->got.refcount > 0)
9346 h->got.refcount -= 1;
9347 }
9348 else if (local_got_refcounts != NULL)
9349 {
9350 if (local_got_refcounts[r_symndx] > 0)
9351 local_got_refcounts[r_symndx] -= 1;
9352 }
9353 break;
9354
9355 case R_ARM_TLS_LDM32:
9356 elf32_arm_hash_table (info)->tls_ldm_got.refcount -= 1;
9357 break;
9358
9359 case R_ARM_ABS32:
9360 case R_ARM_ABS32_NOI:
9361 case R_ARM_REL32:
9362 case R_ARM_REL32_NOI:
9363 case R_ARM_PC24:
9364 case R_ARM_PLT32:
9365 case R_ARM_CALL:
9366 case R_ARM_JUMP24:
9367 case R_ARM_PREL31:
9368 case R_ARM_THM_CALL:
9369 case R_ARM_THM_JUMP24:
9370 case R_ARM_THM_JUMP19:
9371 case R_ARM_MOVW_ABS_NC:
9372 case R_ARM_MOVT_ABS:
9373 case R_ARM_MOVW_PREL_NC:
9374 case R_ARM_MOVT_PREL:
9375 case R_ARM_THM_MOVW_ABS_NC:
9376 case R_ARM_THM_MOVT_ABS:
9377 case R_ARM_THM_MOVW_PREL_NC:
9378 case R_ARM_THM_MOVT_PREL:
9379 /* Should the interworking branches be here also? */
9380
9381 if (h != NULL)
9382 {
9383 struct elf32_arm_link_hash_entry *eh;
9384 struct elf32_arm_relocs_copied **pp;
9385 struct elf32_arm_relocs_copied *p;
9386
9387 eh = (struct elf32_arm_link_hash_entry *) h;
9388
9389 if (h->plt.refcount > 0)
9390 {
9391 h->plt.refcount -= 1;
9392 if (r_type == R_ARM_THM_CALL)
9393 eh->plt_maybe_thumb_refcount--;
9394
9395 if (r_type == R_ARM_THM_JUMP24
9396 || r_type == R_ARM_THM_JUMP19)
9397 eh->plt_thumb_refcount--;
9398 }
9399
9400 if (r_type == R_ARM_ABS32
9401 || r_type == R_ARM_REL32
9402 || r_type == R_ARM_ABS32_NOI
9403 || r_type == R_ARM_REL32_NOI)
9404 {
9405 for (pp = &eh->relocs_copied; (p = *pp) != NULL;
9406 pp = &p->next)
9407 if (p->section == sec)
9408 {
9409 p->count -= 1;
9410 if (ELF32_R_TYPE (rel->r_info) == R_ARM_REL32
9411 || ELF32_R_TYPE (rel->r_info) == R_ARM_REL32_NOI)
9412 p->pc_count -= 1;
9413 if (p->count == 0)
9414 *pp = p->next;
9415 break;
9416 }
9417 }
9418 }
9419 break;
9420
9421 default:
9422 break;
9423 }
9424 }
9425
9426 return TRUE;
9427 }
9428
9429 /* Look through the relocs for a section during the first phase. */
9430
9431 static bfd_boolean
9432 elf32_arm_check_relocs (bfd *abfd, struct bfd_link_info *info,
9433 asection *sec, const Elf_Internal_Rela *relocs)
9434 {
9435 Elf_Internal_Shdr *symtab_hdr;
9436 struct elf_link_hash_entry **sym_hashes;
9437 const Elf_Internal_Rela *rel;
9438 const Elf_Internal_Rela *rel_end;
9439 bfd *dynobj;
9440 asection *sreloc;
9441 bfd_vma *local_got_offsets;
9442 struct elf32_arm_link_hash_table *htab;
9443 bfd_boolean needs_plt;
9444
9445 if (info->relocatable)
9446 return TRUE;
9447
9448 BFD_ASSERT (is_arm_elf (abfd));
9449
9450 htab = elf32_arm_hash_table (info);
9451 sreloc = NULL;
9452
9453 /* Create dynamic sections for relocatable executables so that we can
9454 copy relocations. */
9455 if (htab->root.is_relocatable_executable
9456 && ! htab->root.dynamic_sections_created)
9457 {
9458 if (! _bfd_elf_link_create_dynamic_sections (abfd, info))
9459 return FALSE;
9460 }
9461
9462 dynobj = elf_hash_table (info)->dynobj;
9463 local_got_offsets = elf_local_got_offsets (abfd);
9464
9465 symtab_hdr = & elf_symtab_hdr (abfd);
9466 sym_hashes = elf_sym_hashes (abfd);
9467
9468 rel_end = relocs + sec->reloc_count;
9469 for (rel = relocs; rel < rel_end; rel++)
9470 {
9471 struct elf_link_hash_entry *h;
9472 struct elf32_arm_link_hash_entry *eh;
9473 unsigned long r_symndx;
9474 int r_type;
9475
9476 r_symndx = ELF32_R_SYM (rel->r_info);
9477 r_type = ELF32_R_TYPE (rel->r_info);
9478 r_type = arm_real_reloc_type (htab, r_type);
9479
9480 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
9481 {
9482 (*_bfd_error_handler) (_("%B: bad symbol index: %d"), abfd,
9483 r_symndx);
9484 return FALSE;
9485 }
9486
9487 if (r_symndx < symtab_hdr->sh_info)
9488 h = NULL;
9489 else
9490 {
9491 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
9492 while (h->root.type == bfd_link_hash_indirect
9493 || h->root.type == bfd_link_hash_warning)
9494 h = (struct elf_link_hash_entry *) h->root.u.i.link;
9495 }
9496
9497 eh = (struct elf32_arm_link_hash_entry *) h;
9498
9499 switch (r_type)
9500 {
9501 case R_ARM_GOT32:
9502 case R_ARM_GOT_PREL:
9503 case R_ARM_TLS_GD32:
9504 case R_ARM_TLS_IE32:
9505 /* This symbol requires a global offset table entry. */
9506 {
9507 int tls_type, old_tls_type;
9508
9509 switch (r_type)
9510 {
9511 case R_ARM_TLS_GD32: tls_type = GOT_TLS_GD; break;
9512 case R_ARM_TLS_IE32: tls_type = GOT_TLS_IE; break;
9513 default: tls_type = GOT_NORMAL; break;
9514 }
9515
9516 if (h != NULL)
9517 {
9518 h->got.refcount++;
9519 old_tls_type = elf32_arm_hash_entry (h)->tls_type;
9520 }
9521 else
9522 {
9523 bfd_signed_vma *local_got_refcounts;
9524
9525 /* This is a global offset table entry for a local symbol. */
9526 local_got_refcounts = elf_local_got_refcounts (abfd);
9527 if (local_got_refcounts == NULL)
9528 {
9529 bfd_size_type size;
9530
9531 size = symtab_hdr->sh_info;
9532 size *= (sizeof (bfd_signed_vma) + sizeof (char));
9533 local_got_refcounts = bfd_zalloc (abfd, size);
9534 if (local_got_refcounts == NULL)
9535 return FALSE;
9536 elf_local_got_refcounts (abfd) = local_got_refcounts;
9537 elf32_arm_local_got_tls_type (abfd)
9538 = (char *) (local_got_refcounts + symtab_hdr->sh_info);
9539 }
9540 local_got_refcounts[r_symndx] += 1;
9541 old_tls_type = elf32_arm_local_got_tls_type (abfd) [r_symndx];
9542 }
9543
9544 /* We will already have issued an error message if there is a
9545 TLS / non-TLS mismatch, based on the symbol type. We don't
9546 support any linker relaxations. So just combine any TLS
9547 types needed. */
9548 if (old_tls_type != GOT_UNKNOWN && old_tls_type != GOT_NORMAL
9549 && tls_type != GOT_NORMAL)
9550 tls_type |= old_tls_type;
9551
9552 if (old_tls_type != tls_type)
9553 {
9554 if (h != NULL)
9555 elf32_arm_hash_entry (h)->tls_type = tls_type;
9556 else
9557 elf32_arm_local_got_tls_type (abfd) [r_symndx] = tls_type;
9558 }
9559 }
9560 /* Fall through. */
9561
9562 case R_ARM_TLS_LDM32:
9563 if (r_type == R_ARM_TLS_LDM32)
9564 htab->tls_ldm_got.refcount++;
9565 /* Fall through. */
9566
9567 case R_ARM_GOTOFF32:
9568 case R_ARM_GOTPC:
9569 if (htab->sgot == NULL)
9570 {
9571 if (htab->root.dynobj == NULL)
9572 htab->root.dynobj = abfd;
9573 if (!create_got_section (htab->root.dynobj, info))
9574 return FALSE;
9575 }
9576 break;
9577
9578 case R_ARM_ABS12:
9579 /* VxWorks uses dynamic R_ARM_ABS12 relocations for
9580 ldr __GOTT_INDEX__ offsets. */
9581 if (!htab->vxworks_p)
9582 break;
9583 /* Fall through. */
9584
9585 case R_ARM_PC24:
9586 case R_ARM_PLT32:
9587 case R_ARM_CALL:
9588 case R_ARM_JUMP24:
9589 case R_ARM_PREL31:
9590 case R_ARM_THM_CALL:
9591 case R_ARM_THM_JUMP24:
9592 case R_ARM_THM_JUMP19:
9593 needs_plt = 1;
9594 goto normal_reloc;
9595
9596 case R_ARM_ABS32:
9597 case R_ARM_ABS32_NOI:
9598 case R_ARM_REL32:
9599 case R_ARM_REL32_NOI:
9600 case R_ARM_MOVW_ABS_NC:
9601 case R_ARM_MOVT_ABS:
9602 case R_ARM_MOVW_PREL_NC:
9603 case R_ARM_MOVT_PREL:
9604 case R_ARM_THM_MOVW_ABS_NC:
9605 case R_ARM_THM_MOVT_ABS:
9606 case R_ARM_THM_MOVW_PREL_NC:
9607 case R_ARM_THM_MOVT_PREL:
9608 needs_plt = 0;
9609 normal_reloc:
9610
9611 /* Should the interworking branches be listed here? */
9612 if (h != NULL)
9613 {
9614 /* If this reloc is in a read-only section, we might
9615 need a copy reloc. We can't check reliably at this
9616 stage whether the section is read-only, as input
9617 sections have not yet been mapped to output sections.
9618 Tentatively set the flag for now, and correct in
9619 adjust_dynamic_symbol. */
9620 if (!info->shared)
9621 h->non_got_ref = 1;
9622
9623 /* We may need a .plt entry if the function this reloc
9624 refers to is in a different object. We can't tell for
9625 sure yet, because something later might force the
9626 symbol local. */
9627 if (needs_plt)
9628 h->needs_plt = 1;
9629
9630 /* If we create a PLT entry, this relocation will reference
9631 it, even if it's an ABS32 relocation. */
9632 h->plt.refcount += 1;
9633
9634 /* It's too early to use htab->use_blx here, so we have to
9635 record possible blx references separately from
9636 relocs that definitely need a thumb stub. */
9637
9638 if (r_type == R_ARM_THM_CALL)
9639 eh->plt_maybe_thumb_refcount += 1;
9640
9641 if (r_type == R_ARM_THM_JUMP24
9642 || r_type == R_ARM_THM_JUMP19)
9643 eh->plt_thumb_refcount += 1;
9644 }
9645
9646 /* If we are creating a shared library or relocatable executable,
9647 and this is a reloc against a global symbol, or a non PC
9648 relative reloc against a local symbol, then we need to copy
9649 the reloc into the shared library. However, if we are linking
9650 with -Bsymbolic, we do not need to copy a reloc against a
9651 global symbol which is defined in an object we are
9652 including in the link (i.e., DEF_REGULAR is set). At
9653 this point we have not seen all the input files, so it is
9654 possible that DEF_REGULAR is not set now but will be set
9655 later (it is never cleared). We account for that
9656 possibility below by storing information in the
9657 relocs_copied field of the hash table entry. */
9658 if ((info->shared || htab->root.is_relocatable_executable)
9659 && (sec->flags & SEC_ALLOC) != 0
9660 && ((r_type == R_ARM_ABS32 || r_type == R_ARM_ABS32_NOI)
9661 || (h != NULL && ! h->needs_plt
9662 && (! info->symbolic || ! h->def_regular))))
9663 {
9664 struct elf32_arm_relocs_copied *p, **head;
9665
9666 /* When creating a shared object, we must copy these
9667 reloc types into the output file. We create a reloc
9668 section in dynobj and make room for this reloc. */
9669 if (sreloc == NULL)
9670 {
9671 sreloc = _bfd_elf_make_dynamic_reloc_section
9672 (sec, dynobj, 2, abfd, ! htab->use_rel);
9673
9674 if (sreloc == NULL)
9675 return FALSE;
9676
9677 /* BPABI objects never have dynamic relocations mapped. */
9678 if (! htab->symbian_p)
9679 {
9680 flagword flags;
9681
9682 flags = bfd_get_section_flags (dynobj, sreloc);
9683 flags |= (SEC_LOAD | SEC_ALLOC);
9684 bfd_set_section_flags (dynobj, sreloc, flags);
9685 }
9686 }
9687
9688 /* If this is a global symbol, we count the number of
9689 relocations we need for this symbol. */
9690 if (h != NULL)
9691 {
9692 head = &((struct elf32_arm_link_hash_entry *) h)->relocs_copied;
9693 }
9694 else
9695 {
9696 /* Track dynamic relocs needed for local syms too.
9697 We really need local syms available to do this
9698 easily. Oh well. */
9699
9700 asection *s;
9701 void *vpp;
9702
9703 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
9704 sec, r_symndx);
9705 if (s == NULL)
9706 return FALSE;
9707
9708 vpp = &elf_section_data (s)->local_dynrel;
9709 head = (struct elf32_arm_relocs_copied **) vpp;
9710 }
9711
9712 p = *head;
9713 if (p == NULL || p->section != sec)
9714 {
9715 bfd_size_type amt = sizeof *p;
9716
9717 p = bfd_alloc (htab->root.dynobj, amt);
9718 if (p == NULL)
9719 return FALSE;
9720 p->next = *head;
9721 *head = p;
9722 p->section = sec;
9723 p->count = 0;
9724 p->pc_count = 0;
9725 }
9726
9727 if (r_type == R_ARM_REL32 || r_type == R_ARM_REL32_NOI)
9728 p->pc_count += 1;
9729 p->count += 1;
9730 }
9731 break;
9732
9733 /* This relocation describes the C++ object vtable hierarchy.
9734 Reconstruct it for later use during GC. */
9735 case R_ARM_GNU_VTINHERIT:
9736 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
9737 return FALSE;
9738 break;
9739
9740 /* This relocation describes which C++ vtable entries are actually
9741 used. Record for later use during GC. */
9742 case R_ARM_GNU_VTENTRY:
9743 BFD_ASSERT (h != NULL);
9744 if (h != NULL
9745 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
9746 return FALSE;
9747 break;
9748 }
9749 }
9750
9751 return TRUE;
9752 }
9753
9754 /* Unwinding tables are not referenced directly. This pass marks them as
9755 required if the corresponding code section is marked. */
9756
9757 static bfd_boolean
9758 elf32_arm_gc_mark_extra_sections (struct bfd_link_info *info,
9759 elf_gc_mark_hook_fn gc_mark_hook)
9760 {
9761 bfd *sub;
9762 Elf_Internal_Shdr **elf_shdrp;
9763 bfd_boolean again;
9764
9765 /* Marking EH data may cause additional code sections to be marked,
9766 requiring multiple passes. */
9767 again = TRUE;
9768 while (again)
9769 {
9770 again = FALSE;
9771 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
9772 {
9773 asection *o;
9774
9775 if (! is_arm_elf (sub))
9776 continue;
9777
9778 elf_shdrp = elf_elfsections (sub);
9779 for (o = sub->sections; o != NULL; o = o->next)
9780 {
9781 Elf_Internal_Shdr *hdr;
9782
9783 hdr = &elf_section_data (o)->this_hdr;
9784 if (hdr->sh_type == SHT_ARM_EXIDX
9785 && hdr->sh_link
9786 && hdr->sh_link < elf_numsections (sub)
9787 && !o->gc_mark
9788 && elf_shdrp[hdr->sh_link]->bfd_section->gc_mark)
9789 {
9790 again = TRUE;
9791 if (!_bfd_elf_gc_mark (info, o, gc_mark_hook))
9792 return FALSE;
9793 }
9794 }
9795 }
9796 }
9797
9798 return TRUE;
9799 }
9800
9801 /* Treat mapping symbols as special target symbols. */
9802
9803 static bfd_boolean
9804 elf32_arm_is_target_special_symbol (bfd * abfd ATTRIBUTE_UNUSED, asymbol * sym)
9805 {
9806 return bfd_is_arm_special_symbol_name (sym->name,
9807 BFD_ARM_SPECIAL_SYM_TYPE_ANY);
9808 }
9809
9810 /* This is a copy of elf_find_function() from elf.c except that
9811 ARM mapping symbols are ignored when looking for function names
9812 and STT_ARM_TFUNC is considered to a function type. */
9813
9814 static bfd_boolean
9815 arm_elf_find_function (bfd * abfd ATTRIBUTE_UNUSED,
9816 asection * section,
9817 asymbol ** symbols,
9818 bfd_vma offset,
9819 const char ** filename_ptr,
9820 const char ** functionname_ptr)
9821 {
9822 const char * filename = NULL;
9823 asymbol * func = NULL;
9824 bfd_vma low_func = 0;
9825 asymbol ** p;
9826
9827 for (p = symbols; *p != NULL; p++)
9828 {
9829 elf_symbol_type *q;
9830
9831 q = (elf_symbol_type *) *p;
9832
9833 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
9834 {
9835 default:
9836 break;
9837 case STT_FILE:
9838 filename = bfd_asymbol_name (&q->symbol);
9839 break;
9840 case STT_FUNC:
9841 case STT_ARM_TFUNC:
9842 case STT_NOTYPE:
9843 /* Skip mapping symbols. */
9844 if ((q->symbol.flags & BSF_LOCAL)
9845 && bfd_is_arm_special_symbol_name (q->symbol.name,
9846 BFD_ARM_SPECIAL_SYM_TYPE_ANY))
9847 continue;
9848 /* Fall through. */
9849 if (bfd_get_section (&q->symbol) == section
9850 && q->symbol.value >= low_func
9851 && q->symbol.value <= offset)
9852 {
9853 func = (asymbol *) q;
9854 low_func = q->symbol.value;
9855 }
9856 break;
9857 }
9858 }
9859
9860 if (func == NULL)
9861 return FALSE;
9862
9863 if (filename_ptr)
9864 *filename_ptr = filename;
9865 if (functionname_ptr)
9866 *functionname_ptr = bfd_asymbol_name (func);
9867
9868 return TRUE;
9869 }
9870
9871
9872 /* Find the nearest line to a particular section and offset, for error
9873 reporting. This code is a duplicate of the code in elf.c, except
9874 that it uses arm_elf_find_function. */
9875
9876 static bfd_boolean
9877 elf32_arm_find_nearest_line (bfd * abfd,
9878 asection * section,
9879 asymbol ** symbols,
9880 bfd_vma offset,
9881 const char ** filename_ptr,
9882 const char ** functionname_ptr,
9883 unsigned int * line_ptr)
9884 {
9885 bfd_boolean found = FALSE;
9886
9887 /* We skip _bfd_dwarf1_find_nearest_line since no known ARM toolchain uses it. */
9888
9889 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
9890 filename_ptr, functionname_ptr,
9891 line_ptr, 0,
9892 & elf_tdata (abfd)->dwarf2_find_line_info))
9893 {
9894 if (!*functionname_ptr)
9895 arm_elf_find_function (abfd, section, symbols, offset,
9896 *filename_ptr ? NULL : filename_ptr,
9897 functionname_ptr);
9898
9899 return TRUE;
9900 }
9901
9902 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
9903 & found, filename_ptr,
9904 functionname_ptr, line_ptr,
9905 & elf_tdata (abfd)->line_info))
9906 return FALSE;
9907
9908 if (found && (*functionname_ptr || *line_ptr))
9909 return TRUE;
9910
9911 if (symbols == NULL)
9912 return FALSE;
9913
9914 if (! arm_elf_find_function (abfd, section, symbols, offset,
9915 filename_ptr, functionname_ptr))
9916 return FALSE;
9917
9918 *line_ptr = 0;
9919 return TRUE;
9920 }
9921
9922 static bfd_boolean
9923 elf32_arm_find_inliner_info (bfd * abfd,
9924 const char ** filename_ptr,
9925 const char ** functionname_ptr,
9926 unsigned int * line_ptr)
9927 {
9928 bfd_boolean found;
9929 found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
9930 functionname_ptr, line_ptr,
9931 & elf_tdata (abfd)->dwarf2_find_line_info);
9932 return found;
9933 }
9934
9935 /* Adjust a symbol defined by a dynamic object and referenced by a
9936 regular object. The current definition is in some section of the
9937 dynamic object, but we're not including those sections. We have to
9938 change the definition to something the rest of the link can
9939 understand. */
9940
9941 static bfd_boolean
9942 elf32_arm_adjust_dynamic_symbol (struct bfd_link_info * info,
9943 struct elf_link_hash_entry * h)
9944 {
9945 bfd * dynobj;
9946 asection * s;
9947 struct elf32_arm_link_hash_entry * eh;
9948 struct elf32_arm_link_hash_table *globals;
9949
9950 globals = elf32_arm_hash_table (info);
9951 dynobj = elf_hash_table (info)->dynobj;
9952
9953 /* Make sure we know what is going on here. */
9954 BFD_ASSERT (dynobj != NULL
9955 && (h->needs_plt
9956 || h->u.weakdef != NULL
9957 || (h->def_dynamic
9958 && h->ref_regular
9959 && !h->def_regular)));
9960
9961 eh = (struct elf32_arm_link_hash_entry *) h;
9962
9963 /* If this is a function, put it in the procedure linkage table. We
9964 will fill in the contents of the procedure linkage table later,
9965 when we know the address of the .got section. */
9966 if (h->type == STT_FUNC || h->type == STT_ARM_TFUNC
9967 || h->needs_plt)
9968 {
9969 if (h->plt.refcount <= 0
9970 || SYMBOL_CALLS_LOCAL (info, h)
9971 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
9972 && h->root.type == bfd_link_hash_undefweak))
9973 {
9974 /* This case can occur if we saw a PLT32 reloc in an input
9975 file, but the symbol was never referred to by a dynamic
9976 object, or if all references were garbage collected. In
9977 such a case, we don't actually need to build a procedure
9978 linkage table, and we can just do a PC24 reloc instead. */
9979 h->plt.offset = (bfd_vma) -1;
9980 eh->plt_thumb_refcount = 0;
9981 eh->plt_maybe_thumb_refcount = 0;
9982 h->needs_plt = 0;
9983 }
9984
9985 return TRUE;
9986 }
9987 else
9988 {
9989 /* It's possible that we incorrectly decided a .plt reloc was
9990 needed for an R_ARM_PC24 or similar reloc to a non-function sym
9991 in check_relocs. We can't decide accurately between function
9992 and non-function syms in check-relocs; Objects loaded later in
9993 the link may change h->type. So fix it now. */
9994 h->plt.offset = (bfd_vma) -1;
9995 eh->plt_thumb_refcount = 0;
9996 eh->plt_maybe_thumb_refcount = 0;
9997 }
9998
9999 /* If this is a weak symbol, and there is a real definition, the
10000 processor independent code will have arranged for us to see the
10001 real definition first, and we can just use the same value. */
10002 if (h->u.weakdef != NULL)
10003 {
10004 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
10005 || h->u.weakdef->root.type == bfd_link_hash_defweak);
10006 h->root.u.def.section = h->u.weakdef->root.u.def.section;
10007 h->root.u.def.value = h->u.weakdef->root.u.def.value;
10008 return TRUE;
10009 }
10010
10011 /* If there are no non-GOT references, we do not need a copy
10012 relocation. */
10013 if (!h->non_got_ref)
10014 return TRUE;
10015
10016 /* This is a reference to a symbol defined by a dynamic object which
10017 is not a function. */
10018
10019 /* If we are creating a shared library, we must presume that the
10020 only references to the symbol are via the global offset table.
10021 For such cases we need not do anything here; the relocations will
10022 be handled correctly by relocate_section. Relocatable executables
10023 can reference data in shared objects directly, so we don't need to
10024 do anything here. */
10025 if (info->shared || globals->root.is_relocatable_executable)
10026 return TRUE;
10027
10028 if (h->size == 0)
10029 {
10030 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
10031 h->root.root.string);
10032 return TRUE;
10033 }
10034
10035 /* We must allocate the symbol in our .dynbss section, which will
10036 become part of the .bss section of the executable. There will be
10037 an entry for this symbol in the .dynsym section. The dynamic
10038 object will contain position independent code, so all references
10039 from the dynamic object to this symbol will go through the global
10040 offset table. The dynamic linker will use the .dynsym entry to
10041 determine the address it must put in the global offset table, so
10042 both the dynamic object and the regular object will refer to the
10043 same memory location for the variable. */
10044 s = bfd_get_section_by_name (dynobj, ".dynbss");
10045 BFD_ASSERT (s != NULL);
10046
10047 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
10048 copy the initial value out of the dynamic object and into the
10049 runtime process image. We need to remember the offset into the
10050 .rel(a).bss section we are going to use. */
10051 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
10052 {
10053 asection *srel;
10054
10055 srel = bfd_get_section_by_name (dynobj, RELOC_SECTION (globals, ".bss"));
10056 BFD_ASSERT (srel != NULL);
10057 srel->size += RELOC_SIZE (globals);
10058 h->needs_copy = 1;
10059 }
10060
10061 return _bfd_elf_adjust_dynamic_copy (h, s);
10062 }
10063
10064 /* Allocate space in .plt, .got and associated reloc sections for
10065 dynamic relocs. */
10066
10067 static bfd_boolean
10068 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
10069 {
10070 struct bfd_link_info *info;
10071 struct elf32_arm_link_hash_table *htab;
10072 struct elf32_arm_link_hash_entry *eh;
10073 struct elf32_arm_relocs_copied *p;
10074 bfd_signed_vma thumb_refs;
10075
10076 eh = (struct elf32_arm_link_hash_entry *) h;
10077
10078 if (h->root.type == bfd_link_hash_indirect)
10079 return TRUE;
10080
10081 if (h->root.type == bfd_link_hash_warning)
10082 /* When warning symbols are created, they **replace** the "real"
10083 entry in the hash table, thus we never get to see the real
10084 symbol in a hash traversal. So look at it now. */
10085 h = (struct elf_link_hash_entry *) h->root.u.i.link;
10086
10087 info = (struct bfd_link_info *) inf;
10088 htab = elf32_arm_hash_table (info);
10089
10090 if (htab->root.dynamic_sections_created
10091 && h->plt.refcount > 0)
10092 {
10093 /* Make sure this symbol is output as a dynamic symbol.
10094 Undefined weak syms won't yet be marked as dynamic. */
10095 if (h->dynindx == -1
10096 && !h->forced_local)
10097 {
10098 if (! bfd_elf_link_record_dynamic_symbol (info, h))
10099 return FALSE;
10100 }
10101
10102 if (info->shared
10103 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
10104 {
10105 asection *s = htab->splt;
10106
10107 /* If this is the first .plt entry, make room for the special
10108 first entry. */
10109 if (s->size == 0)
10110 s->size += htab->plt_header_size;
10111
10112 h->plt.offset = s->size;
10113
10114 /* If we will insert a Thumb trampoline before this PLT, leave room
10115 for it. */
10116 thumb_refs = eh->plt_thumb_refcount;
10117 if (!htab->use_blx)
10118 thumb_refs += eh->plt_maybe_thumb_refcount;
10119
10120 if (thumb_refs > 0)
10121 {
10122 h->plt.offset += PLT_THUMB_STUB_SIZE;
10123 s->size += PLT_THUMB_STUB_SIZE;
10124 }
10125
10126 /* If this symbol is not defined in a regular file, and we are
10127 not generating a shared library, then set the symbol to this
10128 location in the .plt. This is required to make function
10129 pointers compare as equal between the normal executable and
10130 the shared library. */
10131 if (! info->shared
10132 && !h->def_regular)
10133 {
10134 h->root.u.def.section = s;
10135 h->root.u.def.value = h->plt.offset;
10136
10137 /* Make sure the function is not marked as Thumb, in case
10138 it is the target of an ABS32 relocation, which will
10139 point to the PLT entry. */
10140 if (ELF_ST_TYPE (h->type) == STT_ARM_TFUNC)
10141 h->type = ELF_ST_INFO (ELF_ST_BIND (h->type), STT_FUNC);
10142 }
10143
10144 /* Make room for this entry. */
10145 s->size += htab->plt_entry_size;
10146
10147 if (!htab->symbian_p)
10148 {
10149 /* We also need to make an entry in the .got.plt section, which
10150 will be placed in the .got section by the linker script. */
10151 eh->plt_got_offset = htab->sgotplt->size;
10152 htab->sgotplt->size += 4;
10153 }
10154
10155 /* We also need to make an entry in the .rel(a).plt section. */
10156 htab->srelplt->size += RELOC_SIZE (htab);
10157
10158 /* VxWorks executables have a second set of relocations for
10159 each PLT entry. They go in a separate relocation section,
10160 which is processed by the kernel loader. */
10161 if (htab->vxworks_p && !info->shared)
10162 {
10163 /* There is a relocation for the initial PLT entry:
10164 an R_ARM_32 relocation for _GLOBAL_OFFSET_TABLE_. */
10165 if (h->plt.offset == htab->plt_header_size)
10166 htab->srelplt2->size += RELOC_SIZE (htab);
10167
10168 /* There are two extra relocations for each subsequent
10169 PLT entry: an R_ARM_32 relocation for the GOT entry,
10170 and an R_ARM_32 relocation for the PLT entry. */
10171 htab->srelplt2->size += RELOC_SIZE (htab) * 2;
10172 }
10173 }
10174 else
10175 {
10176 h->plt.offset = (bfd_vma) -1;
10177 h->needs_plt = 0;
10178 }
10179 }
10180 else
10181 {
10182 h->plt.offset = (bfd_vma) -1;
10183 h->needs_plt = 0;
10184 }
10185
10186 if (h->got.refcount > 0)
10187 {
10188 asection *s;
10189 bfd_boolean dyn;
10190 int tls_type = elf32_arm_hash_entry (h)->tls_type;
10191 int indx;
10192
10193 /* Make sure this symbol is output as a dynamic symbol.
10194 Undefined weak syms won't yet be marked as dynamic. */
10195 if (h->dynindx == -1
10196 && !h->forced_local)
10197 {
10198 if (! bfd_elf_link_record_dynamic_symbol (info, h))
10199 return FALSE;
10200 }
10201
10202 if (!htab->symbian_p)
10203 {
10204 s = htab->sgot;
10205 h->got.offset = s->size;
10206
10207 if (tls_type == GOT_UNKNOWN)
10208 abort ();
10209
10210 if (tls_type == GOT_NORMAL)
10211 /* Non-TLS symbols need one GOT slot. */
10212 s->size += 4;
10213 else
10214 {
10215 if (tls_type & GOT_TLS_GD)
10216 /* R_ARM_TLS_GD32 needs 2 consecutive GOT slots. */
10217 s->size += 8;
10218 if (tls_type & GOT_TLS_IE)
10219 /* R_ARM_TLS_IE32 needs one GOT slot. */
10220 s->size += 4;
10221 }
10222
10223 dyn = htab->root.dynamic_sections_created;
10224
10225 indx = 0;
10226 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
10227 && (!info->shared
10228 || !SYMBOL_REFERENCES_LOCAL (info, h)))
10229 indx = h->dynindx;
10230
10231 if (tls_type != GOT_NORMAL
10232 && (info->shared || indx != 0)
10233 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
10234 || h->root.type != bfd_link_hash_undefweak))
10235 {
10236 if (tls_type & GOT_TLS_IE)
10237 htab->srelgot->size += RELOC_SIZE (htab);
10238
10239 if (tls_type & GOT_TLS_GD)
10240 htab->srelgot->size += RELOC_SIZE (htab);
10241
10242 if ((tls_type & GOT_TLS_GD) && indx != 0)
10243 htab->srelgot->size += RELOC_SIZE (htab);
10244 }
10245 else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
10246 || h->root.type != bfd_link_hash_undefweak)
10247 && (info->shared
10248 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
10249 htab->srelgot->size += RELOC_SIZE (htab);
10250 }
10251 }
10252 else
10253 h->got.offset = (bfd_vma) -1;
10254
10255 /* Allocate stubs for exported Thumb functions on v4t. */
10256 if (!htab->use_blx && h->dynindx != -1
10257 && h->def_regular
10258 && ELF_ST_TYPE (h->type) == STT_ARM_TFUNC
10259 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
10260 {
10261 struct elf_link_hash_entry * th;
10262 struct bfd_link_hash_entry * bh;
10263 struct elf_link_hash_entry * myh;
10264 char name[1024];
10265 asection *s;
10266 bh = NULL;
10267 /* Create a new symbol to regist the real location of the function. */
10268 s = h->root.u.def.section;
10269 sprintf (name, "__real_%s", h->root.root.string);
10270 _bfd_generic_link_add_one_symbol (info, s->owner,
10271 name, BSF_GLOBAL, s,
10272 h->root.u.def.value,
10273 NULL, TRUE, FALSE, &bh);
10274
10275 myh = (struct elf_link_hash_entry *) bh;
10276 myh->type = ELF_ST_INFO (STB_LOCAL, STT_ARM_TFUNC);
10277 myh->forced_local = 1;
10278 eh->export_glue = myh;
10279 th = record_arm_to_thumb_glue (info, h);
10280 /* Point the symbol at the stub. */
10281 h->type = ELF_ST_INFO (ELF_ST_BIND (h->type), STT_FUNC);
10282 h->root.u.def.section = th->root.u.def.section;
10283 h->root.u.def.value = th->root.u.def.value & ~1;
10284 }
10285
10286 if (eh->relocs_copied == NULL)
10287 return TRUE;
10288
10289 /* In the shared -Bsymbolic case, discard space allocated for
10290 dynamic pc-relative relocs against symbols which turn out to be
10291 defined in regular objects. For the normal shared case, discard
10292 space for pc-relative relocs that have become local due to symbol
10293 visibility changes. */
10294
10295 if (info->shared || htab->root.is_relocatable_executable)
10296 {
10297 /* The only relocs that use pc_count are R_ARM_REL32 and
10298 R_ARM_REL32_NOI, which will appear on something like
10299 ".long foo - .". We want calls to protected symbols to resolve
10300 directly to the function rather than going via the plt. If people
10301 want function pointer comparisons to work as expected then they
10302 should avoid writing assembly like ".long foo - .". */
10303 if (SYMBOL_CALLS_LOCAL (info, h))
10304 {
10305 struct elf32_arm_relocs_copied **pp;
10306
10307 for (pp = &eh->relocs_copied; (p = *pp) != NULL; )
10308 {
10309 p->count -= p->pc_count;
10310 p->pc_count = 0;
10311 if (p->count == 0)
10312 *pp = p->next;
10313 else
10314 pp = &p->next;
10315 }
10316 }
10317
10318 if (elf32_arm_hash_table (info)->vxworks_p)
10319 {
10320 struct elf32_arm_relocs_copied **pp;
10321
10322 for (pp = &eh->relocs_copied; (p = *pp) != NULL; )
10323 {
10324 if (strcmp (p->section->output_section->name, ".tls_vars") == 0)
10325 *pp = p->next;
10326 else
10327 pp = &p->next;
10328 }
10329 }
10330
10331 /* Also discard relocs on undefined weak syms with non-default
10332 visibility. */
10333 if (eh->relocs_copied != NULL
10334 && h->root.type == bfd_link_hash_undefweak)
10335 {
10336 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
10337 eh->relocs_copied = NULL;
10338
10339 /* Make sure undefined weak symbols are output as a dynamic
10340 symbol in PIEs. */
10341 else if (h->dynindx == -1
10342 && !h->forced_local)
10343 {
10344 if (! bfd_elf_link_record_dynamic_symbol (info, h))
10345 return FALSE;
10346 }
10347 }
10348
10349 else if (htab->root.is_relocatable_executable && h->dynindx == -1
10350 && h->root.type == bfd_link_hash_new)
10351 {
10352 /* Output absolute symbols so that we can create relocations
10353 against them. For normal symbols we output a relocation
10354 against the section that contains them. */
10355 if (! bfd_elf_link_record_dynamic_symbol (info, h))
10356 return FALSE;
10357 }
10358
10359 }
10360 else
10361 {
10362 /* For the non-shared case, discard space for relocs against
10363 symbols which turn out to need copy relocs or are not
10364 dynamic. */
10365
10366 if (!h->non_got_ref
10367 && ((h->def_dynamic
10368 && !h->def_regular)
10369 || (htab->root.dynamic_sections_created
10370 && (h->root.type == bfd_link_hash_undefweak
10371 || h->root.type == bfd_link_hash_undefined))))
10372 {
10373 /* Make sure this symbol is output as a dynamic symbol.
10374 Undefined weak syms won't yet be marked as dynamic. */
10375 if (h->dynindx == -1
10376 && !h->forced_local)
10377 {
10378 if (! bfd_elf_link_record_dynamic_symbol (info, h))
10379 return FALSE;
10380 }
10381
10382 /* If that succeeded, we know we'll be keeping all the
10383 relocs. */
10384 if (h->dynindx != -1)
10385 goto keep;
10386 }
10387
10388 eh->relocs_copied = NULL;
10389
10390 keep: ;
10391 }
10392
10393 /* Finally, allocate space. */
10394 for (p = eh->relocs_copied; p != NULL; p = p->next)
10395 {
10396 asection *sreloc = elf_section_data (p->section)->sreloc;
10397 sreloc->size += p->count * RELOC_SIZE (htab);
10398 }
10399
10400 return TRUE;
10401 }
10402
10403 /* Find any dynamic relocs that apply to read-only sections. */
10404
10405 static bfd_boolean
10406 elf32_arm_readonly_dynrelocs (struct elf_link_hash_entry * h, void * inf)
10407 {
10408 struct elf32_arm_link_hash_entry * eh;
10409 struct elf32_arm_relocs_copied * p;
10410
10411 if (h->root.type == bfd_link_hash_warning)
10412 h = (struct elf_link_hash_entry *) h->root.u.i.link;
10413
10414 eh = (struct elf32_arm_link_hash_entry *) h;
10415 for (p = eh->relocs_copied; p != NULL; p = p->next)
10416 {
10417 asection *s = p->section;
10418
10419 if (s != NULL && (s->flags & SEC_READONLY) != 0)
10420 {
10421 struct bfd_link_info *info = (struct bfd_link_info *) inf;
10422
10423 info->flags |= DF_TEXTREL;
10424
10425 /* Not an error, just cut short the traversal. */
10426 return FALSE;
10427 }
10428 }
10429 return TRUE;
10430 }
10431
10432 void
10433 bfd_elf32_arm_set_byteswap_code (struct bfd_link_info *info,
10434 int byteswap_code)
10435 {
10436 struct elf32_arm_link_hash_table *globals;
10437
10438 globals = elf32_arm_hash_table (info);
10439 globals->byteswap_code = byteswap_code;
10440 }
10441
10442 /* Set the sizes of the dynamic sections. */
10443
10444 static bfd_boolean
10445 elf32_arm_size_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED,
10446 struct bfd_link_info * info)
10447 {
10448 bfd * dynobj;
10449 asection * s;
10450 bfd_boolean plt;
10451 bfd_boolean relocs;
10452 bfd *ibfd;
10453 struct elf32_arm_link_hash_table *htab;
10454
10455 htab = elf32_arm_hash_table (info);
10456 dynobj = elf_hash_table (info)->dynobj;
10457 BFD_ASSERT (dynobj != NULL);
10458 check_use_blx (htab);
10459
10460 if (elf_hash_table (info)->dynamic_sections_created)
10461 {
10462 /* Set the contents of the .interp section to the interpreter. */
10463 if (info->executable)
10464 {
10465 s = bfd_get_section_by_name (dynobj, ".interp");
10466 BFD_ASSERT (s != NULL);
10467 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
10468 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
10469 }
10470 }
10471
10472 /* Set up .got offsets for local syms, and space for local dynamic
10473 relocs. */
10474 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10475 {
10476 bfd_signed_vma *local_got;
10477 bfd_signed_vma *end_local_got;
10478 char *local_tls_type;
10479 bfd_size_type locsymcount;
10480 Elf_Internal_Shdr *symtab_hdr;
10481 asection *srel;
10482 bfd_boolean is_vxworks = elf32_arm_hash_table (info)->vxworks_p;
10483
10484 if (! is_arm_elf (ibfd))
10485 continue;
10486
10487 for (s = ibfd->sections; s != NULL; s = s->next)
10488 {
10489 struct elf32_arm_relocs_copied *p;
10490
10491 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
10492 {
10493 if (!bfd_is_abs_section (p->section)
10494 && bfd_is_abs_section (p->section->output_section))
10495 {
10496 /* Input section has been discarded, either because
10497 it is a copy of a linkonce section or due to
10498 linker script /DISCARD/, so we'll be discarding
10499 the relocs too. */
10500 }
10501 else if (is_vxworks
10502 && strcmp (p->section->output_section->name,
10503 ".tls_vars") == 0)
10504 {
10505 /* Relocations in vxworks .tls_vars sections are
10506 handled specially by the loader. */
10507 }
10508 else if (p->count != 0)
10509 {
10510 srel = elf_section_data (p->section)->sreloc;
10511 srel->size += p->count * RELOC_SIZE (htab);
10512 if ((p->section->output_section->flags & SEC_READONLY) != 0)
10513 info->flags |= DF_TEXTREL;
10514 }
10515 }
10516 }
10517
10518 local_got = elf_local_got_refcounts (ibfd);
10519 if (!local_got)
10520 continue;
10521
10522 symtab_hdr = & elf_symtab_hdr (ibfd);
10523 locsymcount = symtab_hdr->sh_info;
10524 end_local_got = local_got + locsymcount;
10525 local_tls_type = elf32_arm_local_got_tls_type (ibfd);
10526 s = htab->sgot;
10527 srel = htab->srelgot;
10528 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
10529 {
10530 if (*local_got > 0)
10531 {
10532 *local_got = s->size;
10533 if (*local_tls_type & GOT_TLS_GD)
10534 /* TLS_GD relocs need an 8-byte structure in the GOT. */
10535 s->size += 8;
10536 if (*local_tls_type & GOT_TLS_IE)
10537 s->size += 4;
10538 if (*local_tls_type == GOT_NORMAL)
10539 s->size += 4;
10540
10541 if (info->shared || *local_tls_type == GOT_TLS_GD)
10542 srel->size += RELOC_SIZE (htab);
10543 }
10544 else
10545 *local_got = (bfd_vma) -1;
10546 }
10547 }
10548
10549 if (htab->tls_ldm_got.refcount > 0)
10550 {
10551 /* Allocate two GOT entries and one dynamic relocation (if necessary)
10552 for R_ARM_TLS_LDM32 relocations. */
10553 htab->tls_ldm_got.offset = htab->sgot->size;
10554 htab->sgot->size += 8;
10555 if (info->shared)
10556 htab->srelgot->size += RELOC_SIZE (htab);
10557 }
10558 else
10559 htab->tls_ldm_got.offset = -1;
10560
10561 /* Allocate global sym .plt and .got entries, and space for global
10562 sym dynamic relocs. */
10563 elf_link_hash_traverse (& htab->root, allocate_dynrelocs, info);
10564
10565 /* Here we rummage through the found bfds to collect glue information. */
10566 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10567 {
10568 if (! is_arm_elf (ibfd))
10569 continue;
10570
10571 /* Initialise mapping tables for code/data. */
10572 bfd_elf32_arm_init_maps (ibfd);
10573
10574 if (!bfd_elf32_arm_process_before_allocation (ibfd, info)
10575 || !bfd_elf32_arm_vfp11_erratum_scan (ibfd, info))
10576 /* xgettext:c-format */
10577 _bfd_error_handler (_("Errors encountered processing file %s"),
10578 ibfd->filename);
10579 }
10580
10581 /* The check_relocs and adjust_dynamic_symbol entry points have
10582 determined the sizes of the various dynamic sections. Allocate
10583 memory for them. */
10584 plt = FALSE;
10585 relocs = FALSE;
10586 for (s = dynobj->sections; s != NULL; s = s->next)
10587 {
10588 const char * name;
10589
10590 if ((s->flags & SEC_LINKER_CREATED) == 0)
10591 continue;
10592
10593 /* It's OK to base decisions on the section name, because none
10594 of the dynobj section names depend upon the input files. */
10595 name = bfd_get_section_name (dynobj, s);
10596
10597 if (strcmp (name, ".plt") == 0)
10598 {
10599 /* Remember whether there is a PLT. */
10600 plt = s->size != 0;
10601 }
10602 else if (CONST_STRNEQ (name, ".rel"))
10603 {
10604 if (s->size != 0)
10605 {
10606 /* Remember whether there are any reloc sections other
10607 than .rel(a).plt and .rela.plt.unloaded. */
10608 if (s != htab->srelplt && s != htab->srelplt2)
10609 relocs = TRUE;
10610
10611 /* We use the reloc_count field as a counter if we need
10612 to copy relocs into the output file. */
10613 s->reloc_count = 0;
10614 }
10615 }
10616 else if (! CONST_STRNEQ (name, ".got")
10617 && strcmp (name, ".dynbss") != 0)
10618 {
10619 /* It's not one of our sections, so don't allocate space. */
10620 continue;
10621 }
10622
10623 if (s->size == 0)
10624 {
10625 /* If we don't need this section, strip it from the
10626 output file. This is mostly to handle .rel(a).bss and
10627 .rel(a).plt. We must create both sections in
10628 create_dynamic_sections, because they must be created
10629 before the linker maps input sections to output
10630 sections. The linker does that before
10631 adjust_dynamic_symbol is called, and it is that
10632 function which decides whether anything needs to go
10633 into these sections. */
10634 s->flags |= SEC_EXCLUDE;
10635 continue;
10636 }
10637
10638 if ((s->flags & SEC_HAS_CONTENTS) == 0)
10639 continue;
10640
10641 /* Allocate memory for the section contents. */
10642 s->contents = bfd_zalloc (dynobj, s->size);
10643 if (s->contents == NULL)
10644 return FALSE;
10645 }
10646
10647 if (elf_hash_table (info)->dynamic_sections_created)
10648 {
10649 /* Add some entries to the .dynamic section. We fill in the
10650 values later, in elf32_arm_finish_dynamic_sections, but we
10651 must add the entries now so that we get the correct size for
10652 the .dynamic section. The DT_DEBUG entry is filled in by the
10653 dynamic linker and used by the debugger. */
10654 #define add_dynamic_entry(TAG, VAL) \
10655 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10656
10657 if (info->executable)
10658 {
10659 if (!add_dynamic_entry (DT_DEBUG, 0))
10660 return FALSE;
10661 }
10662
10663 if (plt)
10664 {
10665 if ( !add_dynamic_entry (DT_PLTGOT, 0)
10666 || !add_dynamic_entry (DT_PLTRELSZ, 0)
10667 || !add_dynamic_entry (DT_PLTREL,
10668 htab->use_rel ? DT_REL : DT_RELA)
10669 || !add_dynamic_entry (DT_JMPREL, 0))
10670 return FALSE;
10671 }
10672
10673 if (relocs)
10674 {
10675 if (htab->use_rel)
10676 {
10677 if (!add_dynamic_entry (DT_REL, 0)
10678 || !add_dynamic_entry (DT_RELSZ, 0)
10679 || !add_dynamic_entry (DT_RELENT, RELOC_SIZE (htab)))
10680 return FALSE;
10681 }
10682 else
10683 {
10684 if (!add_dynamic_entry (DT_RELA, 0)
10685 || !add_dynamic_entry (DT_RELASZ, 0)
10686 || !add_dynamic_entry (DT_RELAENT, RELOC_SIZE (htab)))
10687 return FALSE;
10688 }
10689 }
10690
10691 /* If any dynamic relocs apply to a read-only section,
10692 then we need a DT_TEXTREL entry. */
10693 if ((info->flags & DF_TEXTREL) == 0)
10694 elf_link_hash_traverse (& htab->root, elf32_arm_readonly_dynrelocs,
10695 info);
10696
10697 if ((info->flags & DF_TEXTREL) != 0)
10698 {
10699 if (!add_dynamic_entry (DT_TEXTREL, 0))
10700 return FALSE;
10701 }
10702 if (htab->vxworks_p
10703 && !elf_vxworks_add_dynamic_entries (output_bfd, info))
10704 return FALSE;
10705 }
10706 #undef add_dynamic_entry
10707
10708 return TRUE;
10709 }
10710
10711 /* Finish up dynamic symbol handling. We set the contents of various
10712 dynamic sections here. */
10713
10714 static bfd_boolean
10715 elf32_arm_finish_dynamic_symbol (bfd * output_bfd,
10716 struct bfd_link_info * info,
10717 struct elf_link_hash_entry * h,
10718 Elf_Internal_Sym * sym)
10719 {
10720 bfd * dynobj;
10721 struct elf32_arm_link_hash_table *htab;
10722 struct elf32_arm_link_hash_entry *eh;
10723
10724 dynobj = elf_hash_table (info)->dynobj;
10725 htab = elf32_arm_hash_table (info);
10726 eh = (struct elf32_arm_link_hash_entry *) h;
10727
10728 if (h->plt.offset != (bfd_vma) -1)
10729 {
10730 asection * splt;
10731 asection * srel;
10732 bfd_byte *loc;
10733 bfd_vma plt_index;
10734 Elf_Internal_Rela rel;
10735
10736 /* This symbol has an entry in the procedure linkage table. Set
10737 it up. */
10738
10739 BFD_ASSERT (h->dynindx != -1);
10740
10741 splt = bfd_get_section_by_name (dynobj, ".plt");
10742 srel = bfd_get_section_by_name (dynobj, RELOC_SECTION (htab, ".plt"));
10743 BFD_ASSERT (splt != NULL && srel != NULL);
10744
10745 /* Fill in the entry in the procedure linkage table. */
10746 if (htab->symbian_p)
10747 {
10748 put_arm_insn (htab, output_bfd,
10749 elf32_arm_symbian_plt_entry[0],
10750 splt->contents + h->plt.offset);
10751 bfd_put_32 (output_bfd,
10752 elf32_arm_symbian_plt_entry[1],
10753 splt->contents + h->plt.offset + 4);
10754
10755 /* Fill in the entry in the .rel.plt section. */
10756 rel.r_offset = (splt->output_section->vma
10757 + splt->output_offset
10758 + h->plt.offset + 4);
10759 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
10760
10761 /* Get the index in the procedure linkage table which
10762 corresponds to this symbol. This is the index of this symbol
10763 in all the symbols for which we are making plt entries. The
10764 first entry in the procedure linkage table is reserved. */
10765 plt_index = ((h->plt.offset - htab->plt_header_size)
10766 / htab->plt_entry_size);
10767 }
10768 else
10769 {
10770 bfd_vma got_offset, got_address, plt_address;
10771 bfd_vma got_displacement;
10772 asection * sgot;
10773 bfd_byte * ptr;
10774
10775 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
10776 BFD_ASSERT (sgot != NULL);
10777
10778 /* Get the offset into the .got.plt table of the entry that
10779 corresponds to this function. */
10780 got_offset = eh->plt_got_offset;
10781
10782 /* Get the index in the procedure linkage table which
10783 corresponds to this symbol. This is the index of this symbol
10784 in all the symbols for which we are making plt entries. The
10785 first three entries in .got.plt are reserved; after that
10786 symbols appear in the same order as in .plt. */
10787 plt_index = (got_offset - 12) / 4;
10788
10789 /* Calculate the address of the GOT entry. */
10790 got_address = (sgot->output_section->vma
10791 + sgot->output_offset
10792 + got_offset);
10793
10794 /* ...and the address of the PLT entry. */
10795 plt_address = (splt->output_section->vma
10796 + splt->output_offset
10797 + h->plt.offset);
10798
10799 ptr = htab->splt->contents + h->plt.offset;
10800 if (htab->vxworks_p && info->shared)
10801 {
10802 unsigned int i;
10803 bfd_vma val;
10804
10805 for (i = 0; i != htab->plt_entry_size / 4; i++, ptr += 4)
10806 {
10807 val = elf32_arm_vxworks_shared_plt_entry[i];
10808 if (i == 2)
10809 val |= got_address - sgot->output_section->vma;
10810 if (i == 5)
10811 val |= plt_index * RELOC_SIZE (htab);
10812 if (i == 2 || i == 5)
10813 bfd_put_32 (output_bfd, val, ptr);
10814 else
10815 put_arm_insn (htab, output_bfd, val, ptr);
10816 }
10817 }
10818 else if (htab->vxworks_p)
10819 {
10820 unsigned int i;
10821 bfd_vma val;
10822
10823 for (i = 0; i != htab->plt_entry_size / 4; i++, ptr += 4)
10824 {
10825 val = elf32_arm_vxworks_exec_plt_entry[i];
10826 if (i == 2)
10827 val |= got_address;
10828 if (i == 4)
10829 val |= 0xffffff & -((h->plt.offset + i * 4 + 8) >> 2);
10830 if (i == 5)
10831 val |= plt_index * RELOC_SIZE (htab);
10832 if (i == 2 || i == 5)
10833 bfd_put_32 (output_bfd, val, ptr);
10834 else
10835 put_arm_insn (htab, output_bfd, val, ptr);
10836 }
10837
10838 loc = (htab->srelplt2->contents
10839 + (plt_index * 2 + 1) * RELOC_SIZE (htab));
10840
10841 /* Create the .rela.plt.unloaded R_ARM_ABS32 relocation
10842 referencing the GOT for this PLT entry. */
10843 rel.r_offset = plt_address + 8;
10844 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_ARM_ABS32);
10845 rel.r_addend = got_offset;
10846 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
10847 loc += RELOC_SIZE (htab);
10848
10849 /* Create the R_ARM_ABS32 relocation referencing the
10850 beginning of the PLT for this GOT entry. */
10851 rel.r_offset = got_address;
10852 rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_ARM_ABS32);
10853 rel.r_addend = 0;
10854 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
10855 }
10856 else
10857 {
10858 bfd_signed_vma thumb_refs;
10859 /* Calculate the displacement between the PLT slot and the
10860 entry in the GOT. The eight-byte offset accounts for the
10861 value produced by adding to pc in the first instruction
10862 of the PLT stub. */
10863 got_displacement = got_address - (plt_address + 8);
10864
10865 BFD_ASSERT ((got_displacement & 0xf0000000) == 0);
10866
10867 thumb_refs = eh->plt_thumb_refcount;
10868 if (!htab->use_blx)
10869 thumb_refs += eh->plt_maybe_thumb_refcount;
10870
10871 if (thumb_refs > 0)
10872 {
10873 put_thumb_insn (htab, output_bfd,
10874 elf32_arm_plt_thumb_stub[0], ptr - 4);
10875 put_thumb_insn (htab, output_bfd,
10876 elf32_arm_plt_thumb_stub[1], ptr - 2);
10877 }
10878
10879 put_arm_insn (htab, output_bfd,
10880 elf32_arm_plt_entry[0]
10881 | ((got_displacement & 0x0ff00000) >> 20),
10882 ptr + 0);
10883 put_arm_insn (htab, output_bfd,
10884 elf32_arm_plt_entry[1]
10885 | ((got_displacement & 0x000ff000) >> 12),
10886 ptr+ 4);
10887 put_arm_insn (htab, output_bfd,
10888 elf32_arm_plt_entry[2]
10889 | (got_displacement & 0x00000fff),
10890 ptr + 8);
10891 #ifdef FOUR_WORD_PLT
10892 bfd_put_32 (output_bfd, elf32_arm_plt_entry[3], ptr + 12);
10893 #endif
10894 }
10895
10896 /* Fill in the entry in the global offset table. */
10897 bfd_put_32 (output_bfd,
10898 (splt->output_section->vma
10899 + splt->output_offset),
10900 sgot->contents + got_offset);
10901
10902 /* Fill in the entry in the .rel(a).plt section. */
10903 rel.r_addend = 0;
10904 rel.r_offset = got_address;
10905 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_JUMP_SLOT);
10906 }
10907
10908 loc = srel->contents + plt_index * RELOC_SIZE (htab);
10909 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
10910
10911 if (!h->def_regular)
10912 {
10913 /* Mark the symbol as undefined, rather than as defined in
10914 the .plt section. Leave the value alone. */
10915 sym->st_shndx = SHN_UNDEF;
10916 /* If the symbol is weak, we do need to clear the value.
10917 Otherwise, the PLT entry would provide a definition for
10918 the symbol even if the symbol wasn't defined anywhere,
10919 and so the symbol would never be NULL. */
10920 if (!h->ref_regular_nonweak)
10921 sym->st_value = 0;
10922 }
10923 }
10924
10925 if (h->got.offset != (bfd_vma) -1
10926 && (elf32_arm_hash_entry (h)->tls_type & GOT_TLS_GD) == 0
10927 && (elf32_arm_hash_entry (h)->tls_type & GOT_TLS_IE) == 0)
10928 {
10929 asection * sgot;
10930 asection * srel;
10931 Elf_Internal_Rela rel;
10932 bfd_byte *loc;
10933 bfd_vma offset;
10934
10935 /* This symbol has an entry in the global offset table. Set it
10936 up. */
10937 sgot = bfd_get_section_by_name (dynobj, ".got");
10938 srel = bfd_get_section_by_name (dynobj, RELOC_SECTION (htab, ".got"));
10939 BFD_ASSERT (sgot != NULL && srel != NULL);
10940
10941 offset = (h->got.offset & ~(bfd_vma) 1);
10942 rel.r_addend = 0;
10943 rel.r_offset = (sgot->output_section->vma
10944 + sgot->output_offset
10945 + offset);
10946
10947 /* If this is a static link, or it is a -Bsymbolic link and the
10948 symbol is defined locally or was forced to be local because
10949 of a version file, we just want to emit a RELATIVE reloc.
10950 The entry in the global offset table will already have been
10951 initialized in the relocate_section function. */
10952 if (info->shared
10953 && SYMBOL_REFERENCES_LOCAL (info, h))
10954 {
10955 BFD_ASSERT ((h->got.offset & 1) != 0);
10956 rel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
10957 if (!htab->use_rel)
10958 {
10959 rel.r_addend = bfd_get_32 (output_bfd, sgot->contents + offset);
10960 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + offset);
10961 }
10962 }
10963 else
10964 {
10965 BFD_ASSERT ((h->got.offset & 1) == 0);
10966 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + offset);
10967 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
10968 }
10969
10970 loc = srel->contents + srel->reloc_count++ * RELOC_SIZE (htab);
10971 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
10972 }
10973
10974 if (h->needs_copy)
10975 {
10976 asection * s;
10977 Elf_Internal_Rela rel;
10978 bfd_byte *loc;
10979
10980 /* This symbol needs a copy reloc. Set it up. */
10981 BFD_ASSERT (h->dynindx != -1
10982 && (h->root.type == bfd_link_hash_defined
10983 || h->root.type == bfd_link_hash_defweak));
10984
10985 s = bfd_get_section_by_name (h->root.u.def.section->owner,
10986 RELOC_SECTION (htab, ".bss"));
10987 BFD_ASSERT (s != NULL);
10988
10989 rel.r_addend = 0;
10990 rel.r_offset = (h->root.u.def.value
10991 + h->root.u.def.section->output_section->vma
10992 + h->root.u.def.section->output_offset);
10993 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_COPY);
10994 loc = s->contents + s->reloc_count++ * RELOC_SIZE (htab);
10995 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
10996 }
10997
10998 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. On VxWorks,
10999 the _GLOBAL_OFFSET_TABLE_ symbol is not absolute: it is relative
11000 to the ".got" section. */
11001 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
11002 || (!htab->vxworks_p && h == htab->root.hgot))
11003 sym->st_shndx = SHN_ABS;
11004
11005 return TRUE;
11006 }
11007
11008 /* Finish up the dynamic sections. */
11009
11010 static bfd_boolean
11011 elf32_arm_finish_dynamic_sections (bfd * output_bfd, struct bfd_link_info * info)
11012 {
11013 bfd * dynobj;
11014 asection * sgot;
11015 asection * sdyn;
11016
11017 dynobj = elf_hash_table (info)->dynobj;
11018
11019 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
11020 BFD_ASSERT (elf32_arm_hash_table (info)->symbian_p || sgot != NULL);
11021 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
11022
11023 if (elf_hash_table (info)->dynamic_sections_created)
11024 {
11025 asection *splt;
11026 Elf32_External_Dyn *dyncon, *dynconend;
11027 struct elf32_arm_link_hash_table *htab;
11028
11029 htab = elf32_arm_hash_table (info);
11030 splt = bfd_get_section_by_name (dynobj, ".plt");
11031 BFD_ASSERT (splt != NULL && sdyn != NULL);
11032
11033 dyncon = (Elf32_External_Dyn *) sdyn->contents;
11034 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
11035
11036 for (; dyncon < dynconend; dyncon++)
11037 {
11038 Elf_Internal_Dyn dyn;
11039 const char * name;
11040 asection * s;
11041
11042 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
11043
11044 switch (dyn.d_tag)
11045 {
11046 unsigned int type;
11047
11048 default:
11049 if (htab->vxworks_p
11050 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
11051 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
11052 break;
11053
11054 case DT_HASH:
11055 name = ".hash";
11056 goto get_vma_if_bpabi;
11057 case DT_STRTAB:
11058 name = ".dynstr";
11059 goto get_vma_if_bpabi;
11060 case DT_SYMTAB:
11061 name = ".dynsym";
11062 goto get_vma_if_bpabi;
11063 case DT_VERSYM:
11064 name = ".gnu.version";
11065 goto get_vma_if_bpabi;
11066 case DT_VERDEF:
11067 name = ".gnu.version_d";
11068 goto get_vma_if_bpabi;
11069 case DT_VERNEED:
11070 name = ".gnu.version_r";
11071 goto get_vma_if_bpabi;
11072
11073 case DT_PLTGOT:
11074 name = ".got";
11075 goto get_vma;
11076 case DT_JMPREL:
11077 name = RELOC_SECTION (htab, ".plt");
11078 get_vma:
11079 s = bfd_get_section_by_name (output_bfd, name);
11080 BFD_ASSERT (s != NULL);
11081 if (!htab->symbian_p)
11082 dyn.d_un.d_ptr = s->vma;
11083 else
11084 /* In the BPABI, tags in the PT_DYNAMIC section point
11085 at the file offset, not the memory address, for the
11086 convenience of the post linker. */
11087 dyn.d_un.d_ptr = s->filepos;
11088 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
11089 break;
11090
11091 get_vma_if_bpabi:
11092 if (htab->symbian_p)
11093 goto get_vma;
11094 break;
11095
11096 case DT_PLTRELSZ:
11097 s = bfd_get_section_by_name (output_bfd,
11098 RELOC_SECTION (htab, ".plt"));
11099 BFD_ASSERT (s != NULL);
11100 dyn.d_un.d_val = s->size;
11101 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
11102 break;
11103
11104 case DT_RELSZ:
11105 case DT_RELASZ:
11106 if (!htab->symbian_p)
11107 {
11108 /* My reading of the SVR4 ABI indicates that the
11109 procedure linkage table relocs (DT_JMPREL) should be
11110 included in the overall relocs (DT_REL). This is
11111 what Solaris does. However, UnixWare can not handle
11112 that case. Therefore, we override the DT_RELSZ entry
11113 here to make it not include the JMPREL relocs. Since
11114 the linker script arranges for .rel(a).plt to follow all
11115 other relocation sections, we don't have to worry
11116 about changing the DT_REL entry. */
11117 s = bfd_get_section_by_name (output_bfd,
11118 RELOC_SECTION (htab, ".plt"));
11119 if (s != NULL)
11120 dyn.d_un.d_val -= s->size;
11121 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
11122 break;
11123 }
11124 /* Fall through. */
11125
11126 case DT_REL:
11127 case DT_RELA:
11128 /* In the BPABI, the DT_REL tag must point at the file
11129 offset, not the VMA, of the first relocation
11130 section. So, we use code similar to that in
11131 elflink.c, but do not check for SHF_ALLOC on the
11132 relcoation section, since relocations sections are
11133 never allocated under the BPABI. The comments above
11134 about Unixware notwithstanding, we include all of the
11135 relocations here. */
11136 if (htab->symbian_p)
11137 {
11138 unsigned int i;
11139 type = ((dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ)
11140 ? SHT_REL : SHT_RELA);
11141 dyn.d_un.d_val = 0;
11142 for (i = 1; i < elf_numsections (output_bfd); i++)
11143 {
11144 Elf_Internal_Shdr *hdr
11145 = elf_elfsections (output_bfd)[i];
11146 if (hdr->sh_type == type)
11147 {
11148 if (dyn.d_tag == DT_RELSZ
11149 || dyn.d_tag == DT_RELASZ)
11150 dyn.d_un.d_val += hdr->sh_size;
11151 else if ((ufile_ptr) hdr->sh_offset
11152 <= dyn.d_un.d_val - 1)
11153 dyn.d_un.d_val = hdr->sh_offset;
11154 }
11155 }
11156 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
11157 }
11158 break;
11159
11160 /* Set the bottom bit of DT_INIT/FINI if the
11161 corresponding function is Thumb. */
11162 case DT_INIT:
11163 name = info->init_function;
11164 goto get_sym;
11165 case DT_FINI:
11166 name = info->fini_function;
11167 get_sym:
11168 /* If it wasn't set by elf_bfd_final_link
11169 then there is nothing to adjust. */
11170 if (dyn.d_un.d_val != 0)
11171 {
11172 struct elf_link_hash_entry * eh;
11173
11174 eh = elf_link_hash_lookup (elf_hash_table (info), name,
11175 FALSE, FALSE, TRUE);
11176 if (eh != NULL
11177 && ELF_ST_TYPE (eh->type) == STT_ARM_TFUNC)
11178 {
11179 dyn.d_un.d_val |= 1;
11180 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
11181 }
11182 }
11183 break;
11184 }
11185 }
11186
11187 /* Fill in the first entry in the procedure linkage table. */
11188 if (splt->size > 0 && elf32_arm_hash_table (info)->plt_header_size)
11189 {
11190 const bfd_vma *plt0_entry;
11191 bfd_vma got_address, plt_address, got_displacement;
11192
11193 /* Calculate the addresses of the GOT and PLT. */
11194 got_address = sgot->output_section->vma + sgot->output_offset;
11195 plt_address = splt->output_section->vma + splt->output_offset;
11196
11197 if (htab->vxworks_p)
11198 {
11199 /* The VxWorks GOT is relocated by the dynamic linker.
11200 Therefore, we must emit relocations rather than simply
11201 computing the values now. */
11202 Elf_Internal_Rela rel;
11203
11204 plt0_entry = elf32_arm_vxworks_exec_plt0_entry;
11205 put_arm_insn (htab, output_bfd, plt0_entry[0],
11206 splt->contents + 0);
11207 put_arm_insn (htab, output_bfd, plt0_entry[1],
11208 splt->contents + 4);
11209 put_arm_insn (htab, output_bfd, plt0_entry[2],
11210 splt->contents + 8);
11211 bfd_put_32 (output_bfd, got_address, splt->contents + 12);
11212
11213 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_. */
11214 rel.r_offset = plt_address + 12;
11215 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_ARM_ABS32);
11216 rel.r_addend = 0;
11217 SWAP_RELOC_OUT (htab) (output_bfd, &rel,
11218 htab->srelplt2->contents);
11219 }
11220 else
11221 {
11222 got_displacement = got_address - (plt_address + 16);
11223
11224 plt0_entry = elf32_arm_plt0_entry;
11225 put_arm_insn (htab, output_bfd, plt0_entry[0],
11226 splt->contents + 0);
11227 put_arm_insn (htab, output_bfd, plt0_entry[1],
11228 splt->contents + 4);
11229 put_arm_insn (htab, output_bfd, plt0_entry[2],
11230 splt->contents + 8);
11231 put_arm_insn (htab, output_bfd, plt0_entry[3],
11232 splt->contents + 12);
11233
11234 #ifdef FOUR_WORD_PLT
11235 /* The displacement value goes in the otherwise-unused
11236 last word of the second entry. */
11237 bfd_put_32 (output_bfd, got_displacement, splt->contents + 28);
11238 #else
11239 bfd_put_32 (output_bfd, got_displacement, splt->contents + 16);
11240 #endif
11241 }
11242 }
11243
11244 /* UnixWare sets the entsize of .plt to 4, although that doesn't
11245 really seem like the right value. */
11246 if (splt->output_section->owner == output_bfd)
11247 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
11248
11249 if (htab->vxworks_p && !info->shared && htab->splt->size > 0)
11250 {
11251 /* Correct the .rel(a).plt.unloaded relocations. They will have
11252 incorrect symbol indexes. */
11253 int num_plts;
11254 unsigned char *p;
11255
11256 num_plts = ((htab->splt->size - htab->plt_header_size)
11257 / htab->plt_entry_size);
11258 p = htab->srelplt2->contents + RELOC_SIZE (htab);
11259
11260 for (; num_plts; num_plts--)
11261 {
11262 Elf_Internal_Rela rel;
11263
11264 SWAP_RELOC_IN (htab) (output_bfd, p, &rel);
11265 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_ARM_ABS32);
11266 SWAP_RELOC_OUT (htab) (output_bfd, &rel, p);
11267 p += RELOC_SIZE (htab);
11268
11269 SWAP_RELOC_IN (htab) (output_bfd, p, &rel);
11270 rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_ARM_ABS32);
11271 SWAP_RELOC_OUT (htab) (output_bfd, &rel, p);
11272 p += RELOC_SIZE (htab);
11273 }
11274 }
11275 }
11276
11277 /* Fill in the first three entries in the global offset table. */
11278 if (sgot)
11279 {
11280 if (sgot->size > 0)
11281 {
11282 if (sdyn == NULL)
11283 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
11284 else
11285 bfd_put_32 (output_bfd,
11286 sdyn->output_section->vma + sdyn->output_offset,
11287 sgot->contents);
11288 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
11289 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
11290 }
11291
11292 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
11293 }
11294
11295 return TRUE;
11296 }
11297
11298 static void
11299 elf32_arm_post_process_headers (bfd * abfd, struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
11300 {
11301 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
11302 struct elf32_arm_link_hash_table *globals;
11303
11304 i_ehdrp = elf_elfheader (abfd);
11305
11306 if (EF_ARM_EABI_VERSION (i_ehdrp->e_flags) == EF_ARM_EABI_UNKNOWN)
11307 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_ARM;
11308 else
11309 i_ehdrp->e_ident[EI_OSABI] = 0;
11310 i_ehdrp->e_ident[EI_ABIVERSION] = ARM_ELF_ABI_VERSION;
11311
11312 if (link_info)
11313 {
11314 globals = elf32_arm_hash_table (link_info);
11315 if (globals->byteswap_code)
11316 i_ehdrp->e_flags |= EF_ARM_BE8;
11317 }
11318 }
11319
11320 static enum elf_reloc_type_class
11321 elf32_arm_reloc_type_class (const Elf_Internal_Rela *rela)
11322 {
11323 switch ((int) ELF32_R_TYPE (rela->r_info))
11324 {
11325 case R_ARM_RELATIVE:
11326 return reloc_class_relative;
11327 case R_ARM_JUMP_SLOT:
11328 return reloc_class_plt;
11329 case R_ARM_COPY:
11330 return reloc_class_copy;
11331 default:
11332 return reloc_class_normal;
11333 }
11334 }
11335
11336 /* Set the right machine number for an Arm ELF file. */
11337
11338 static bfd_boolean
11339 elf32_arm_section_flags (flagword *flags, const Elf_Internal_Shdr *hdr)
11340 {
11341 if (hdr->sh_type == SHT_NOTE)
11342 *flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_CONTENTS;
11343
11344 return TRUE;
11345 }
11346
11347 static void
11348 elf32_arm_final_write_processing (bfd *abfd, bfd_boolean linker ATTRIBUTE_UNUSED)
11349 {
11350 bfd_arm_update_notes (abfd, ARM_NOTE_SECTION);
11351 }
11352
11353 /* Return TRUE if this is an unwinding table entry. */
11354
11355 static bfd_boolean
11356 is_arm_elf_unwind_section_name (bfd * abfd ATTRIBUTE_UNUSED, const char * name)
11357 {
11358 return (CONST_STRNEQ (name, ELF_STRING_ARM_unwind)
11359 || CONST_STRNEQ (name, ELF_STRING_ARM_unwind_once));
11360 }
11361
11362
11363 /* Set the type and flags for an ARM section. We do this by
11364 the section name, which is a hack, but ought to work. */
11365
11366 static bfd_boolean
11367 elf32_arm_fake_sections (bfd * abfd, Elf_Internal_Shdr * hdr, asection * sec)
11368 {
11369 const char * name;
11370
11371 name = bfd_get_section_name (abfd, sec);
11372
11373 if (is_arm_elf_unwind_section_name (abfd, name))
11374 {
11375 hdr->sh_type = SHT_ARM_EXIDX;
11376 hdr->sh_flags |= SHF_LINK_ORDER;
11377 }
11378 return TRUE;
11379 }
11380
11381 /* Handle an ARM specific section when reading an object file. This is
11382 called when bfd_section_from_shdr finds a section with an unknown
11383 type. */
11384
11385 static bfd_boolean
11386 elf32_arm_section_from_shdr (bfd *abfd,
11387 Elf_Internal_Shdr * hdr,
11388 const char *name,
11389 int shindex)
11390 {
11391 /* There ought to be a place to keep ELF backend specific flags, but
11392 at the moment there isn't one. We just keep track of the
11393 sections by their name, instead. Fortunately, the ABI gives
11394 names for all the ARM specific sections, so we will probably get
11395 away with this. */
11396 switch (hdr->sh_type)
11397 {
11398 case SHT_ARM_EXIDX:
11399 case SHT_ARM_PREEMPTMAP:
11400 case SHT_ARM_ATTRIBUTES:
11401 break;
11402
11403 default:
11404 return FALSE;
11405 }
11406
11407 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
11408 return FALSE;
11409
11410 return TRUE;
11411 }
11412
11413 /* A structure used to record a list of sections, independently
11414 of the next and prev fields in the asection structure. */
11415 typedef struct section_list
11416 {
11417 asection * sec;
11418 struct section_list * next;
11419 struct section_list * prev;
11420 }
11421 section_list;
11422
11423 /* Unfortunately we need to keep a list of sections for which
11424 an _arm_elf_section_data structure has been allocated. This
11425 is because it is possible for functions like elf32_arm_write_section
11426 to be called on a section which has had an elf_data_structure
11427 allocated for it (and so the used_by_bfd field is valid) but
11428 for which the ARM extended version of this structure - the
11429 _arm_elf_section_data structure - has not been allocated. */
11430 static section_list * sections_with_arm_elf_section_data = NULL;
11431
11432 static void
11433 record_section_with_arm_elf_section_data (asection * sec)
11434 {
11435 struct section_list * entry;
11436
11437 entry = bfd_malloc (sizeof (* entry));
11438 if (entry == NULL)
11439 return;
11440 entry->sec = sec;
11441 entry->next = sections_with_arm_elf_section_data;
11442 entry->prev = NULL;
11443 if (entry->next != NULL)
11444 entry->next->prev = entry;
11445 sections_with_arm_elf_section_data = entry;
11446 }
11447
11448 static struct section_list *
11449 find_arm_elf_section_entry (asection * sec)
11450 {
11451 struct section_list * entry;
11452 static struct section_list * last_entry = NULL;
11453
11454 /* This is a short cut for the typical case where the sections are added
11455 to the sections_with_arm_elf_section_data list in forward order and
11456 then looked up here in backwards order. This makes a real difference
11457 to the ld-srec/sec64k.exp linker test. */
11458 entry = sections_with_arm_elf_section_data;
11459 if (last_entry != NULL)
11460 {
11461 if (last_entry->sec == sec)
11462 entry = last_entry;
11463 else if (last_entry->next != NULL
11464 && last_entry->next->sec == sec)
11465 entry = last_entry->next;
11466 }
11467
11468 for (; entry; entry = entry->next)
11469 if (entry->sec == sec)
11470 break;
11471
11472 if (entry)
11473 /* Record the entry prior to this one - it is the entry we are most
11474 likely to want to locate next time. Also this way if we have been
11475 called from unrecord_section_with_arm_elf_section_data() we will not
11476 be caching a pointer that is about to be freed. */
11477 last_entry = entry->prev;
11478
11479 return entry;
11480 }
11481
11482 static _arm_elf_section_data *
11483 get_arm_elf_section_data (asection * sec)
11484 {
11485 struct section_list * entry;
11486
11487 entry = find_arm_elf_section_entry (sec);
11488
11489 if (entry)
11490 return elf32_arm_section_data (entry->sec);
11491 else
11492 return NULL;
11493 }
11494
11495 static void
11496 unrecord_section_with_arm_elf_section_data (asection * sec)
11497 {
11498 struct section_list * entry;
11499
11500 entry = find_arm_elf_section_entry (sec);
11501
11502 if (entry)
11503 {
11504 if (entry->prev != NULL)
11505 entry->prev->next = entry->next;
11506 if (entry->next != NULL)
11507 entry->next->prev = entry->prev;
11508 if (entry == sections_with_arm_elf_section_data)
11509 sections_with_arm_elf_section_data = entry->next;
11510 free (entry);
11511 }
11512 }
11513
11514
11515 typedef struct
11516 {
11517 void *finfo;
11518 struct bfd_link_info *info;
11519 asection *sec;
11520 int sec_shndx;
11521 bfd_boolean (*func) (void *, const char *, Elf_Internal_Sym *,
11522 asection *, struct elf_link_hash_entry *);
11523 } output_arch_syminfo;
11524
11525 enum map_symbol_type
11526 {
11527 ARM_MAP_ARM,
11528 ARM_MAP_THUMB,
11529 ARM_MAP_DATA
11530 };
11531
11532
11533 /* Output a single mapping symbol. */
11534
11535 static bfd_boolean
11536 elf32_arm_output_map_sym (output_arch_syminfo *osi,
11537 enum map_symbol_type type,
11538 bfd_vma offset)
11539 {
11540 static const char *names[3] = {"$a", "$t", "$d"};
11541 struct elf32_arm_link_hash_table *htab;
11542 Elf_Internal_Sym sym;
11543
11544 htab = elf32_arm_hash_table (osi->info);
11545 sym.st_value = osi->sec->output_section->vma
11546 + osi->sec->output_offset
11547 + offset;
11548 sym.st_size = 0;
11549 sym.st_other = 0;
11550 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_NOTYPE);
11551 sym.st_shndx = osi->sec_shndx;
11552 if (!osi->func (osi->finfo, names[type], &sym, osi->sec, NULL))
11553 return FALSE;
11554 return TRUE;
11555 }
11556
11557
11558 /* Output mapping symbols for PLT entries associated with H. */
11559
11560 static bfd_boolean
11561 elf32_arm_output_plt_map (struct elf_link_hash_entry *h, void *inf)
11562 {
11563 output_arch_syminfo *osi = (output_arch_syminfo *) inf;
11564 struct elf32_arm_link_hash_table *htab;
11565 struct elf32_arm_link_hash_entry *eh;
11566 bfd_vma addr;
11567
11568 htab = elf32_arm_hash_table (osi->info);
11569
11570 if (h->root.type == bfd_link_hash_indirect)
11571 return TRUE;
11572
11573 if (h->root.type == bfd_link_hash_warning)
11574 /* When warning symbols are created, they **replace** the "real"
11575 entry in the hash table, thus we never get to see the real
11576 symbol in a hash traversal. So look at it now. */
11577 h = (struct elf_link_hash_entry *) h->root.u.i.link;
11578
11579 if (h->plt.offset == (bfd_vma) -1)
11580 return TRUE;
11581
11582 eh = (struct elf32_arm_link_hash_entry *) h;
11583 addr = h->plt.offset;
11584 if (htab->symbian_p)
11585 {
11586 if (!elf32_arm_output_map_sym (osi, ARM_MAP_ARM, addr))
11587 return FALSE;
11588 if (!elf32_arm_output_map_sym (osi, ARM_MAP_DATA, addr + 4))
11589 return FALSE;
11590 }
11591 else if (htab->vxworks_p)
11592 {
11593 if (!elf32_arm_output_map_sym (osi, ARM_MAP_ARM, addr))
11594 return FALSE;
11595 if (!elf32_arm_output_map_sym (osi, ARM_MAP_DATA, addr + 8))
11596 return FALSE;
11597 if (!elf32_arm_output_map_sym (osi, ARM_MAP_ARM, addr + 12))
11598 return FALSE;
11599 if (!elf32_arm_output_map_sym (osi, ARM_MAP_DATA, addr + 20))
11600 return FALSE;
11601 }
11602 else
11603 {
11604 bfd_signed_vma thumb_refs;
11605
11606 thumb_refs = eh->plt_thumb_refcount;
11607 if (!htab->use_blx)
11608 thumb_refs += eh->plt_maybe_thumb_refcount;
11609
11610 if (thumb_refs > 0)
11611 {
11612 if (!elf32_arm_output_map_sym (osi, ARM_MAP_THUMB, addr - 4))
11613 return FALSE;
11614 }
11615 #ifdef FOUR_WORD_PLT
11616 if (!elf32_arm_output_map_sym (osi, ARM_MAP_ARM, addr))
11617 return FALSE;
11618 if (!elf32_arm_output_map_sym (osi, ARM_MAP_DATA, addr + 12))
11619 return FALSE;
11620 #else
11621 /* A three-word PLT with no Thumb thunk contains only Arm code,
11622 so only need to output a mapping symbol for the first PLT entry and
11623 entries with thumb thunks. */
11624 if (thumb_refs > 0 || addr == 20)
11625 {
11626 if (!elf32_arm_output_map_sym (osi, ARM_MAP_ARM, addr))
11627 return FALSE;
11628 }
11629 #endif
11630 }
11631
11632 return TRUE;
11633 }
11634
11635 /* Output a single local symbol for a generated stub. */
11636
11637 static bfd_boolean
11638 elf32_arm_output_stub_sym (output_arch_syminfo *osi, const char *name,
11639 bfd_vma offset, bfd_vma size)
11640 {
11641 struct elf32_arm_link_hash_table *htab;
11642 Elf_Internal_Sym sym;
11643
11644 htab = elf32_arm_hash_table (osi->info);
11645 sym.st_value = osi->sec->output_section->vma
11646 + osi->sec->output_offset
11647 + offset;
11648 sym.st_size = size;
11649 sym.st_other = 0;
11650 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
11651 sym.st_shndx = osi->sec_shndx;
11652 if (!osi->func (osi->finfo, name, &sym, osi->sec, NULL))
11653 return FALSE;
11654 return TRUE;
11655 }
11656
11657 static bfd_boolean
11658 arm_map_one_stub (struct bfd_hash_entry * gen_entry,
11659 void * in_arg)
11660 {
11661 struct elf32_arm_stub_hash_entry *stub_entry;
11662 struct bfd_link_info *info;
11663 struct elf32_arm_link_hash_table *htab;
11664 asection *stub_sec;
11665 bfd_vma addr;
11666 char *stub_name;
11667 output_arch_syminfo *osi;
11668
11669 /* Massage our args to the form they really have. */
11670 stub_entry = (struct elf32_arm_stub_hash_entry *) gen_entry;
11671 osi = (output_arch_syminfo *) in_arg;
11672
11673 info = osi->info;
11674
11675 htab = elf32_arm_hash_table (info);
11676 stub_sec = stub_entry->stub_sec;
11677
11678 /* Ensure this stub is attached to the current section being
11679 processed. */
11680 if (stub_sec != osi->sec)
11681 return TRUE;
11682
11683 addr = (bfd_vma) stub_entry->stub_offset;
11684 stub_name = stub_entry->output_name;
11685
11686 switch (stub_entry->stub_type)
11687 {
11688 case arm_stub_long_branch_any_any:
11689 if (!elf32_arm_output_stub_sym (osi, stub_name, addr, 8))
11690 return FALSE;
11691 if (!elf32_arm_output_map_sym (osi, ARM_MAP_ARM, addr))
11692 return FALSE;
11693 if (!elf32_arm_output_map_sym (osi, ARM_MAP_DATA, addr + 4))
11694 return FALSE;
11695 break;
11696 case arm_stub_long_branch_v4t_arm_thumb:
11697 if (!elf32_arm_output_stub_sym (osi, stub_name, addr, 12))
11698 return FALSE;
11699 if (!elf32_arm_output_map_sym (osi, ARM_MAP_ARM, addr))
11700 return FALSE;
11701 if (!elf32_arm_output_map_sym (osi, ARM_MAP_DATA, addr + 8))
11702 return FALSE;
11703 break;
11704 case arm_stub_long_branch_thumb_only:
11705 if (!elf32_arm_output_stub_sym (osi, stub_name, addr | 1, 16))
11706 return FALSE;
11707 if (!elf32_arm_output_map_sym (osi, ARM_MAP_THUMB, addr))
11708 return FALSE;
11709 if (!elf32_arm_output_map_sym (osi, ARM_MAP_DATA, addr + 12))
11710 return FALSE;
11711 break;
11712 case arm_stub_long_branch_v4t_thumb_arm:
11713 if (!elf32_arm_output_stub_sym (osi, stub_name, addr | 1, 20))
11714 return FALSE;
11715 if (!elf32_arm_output_map_sym (osi, ARM_MAP_THUMB, addr))
11716 return FALSE;
11717 if (!elf32_arm_output_map_sym (osi, ARM_MAP_ARM, addr + 4))
11718 return FALSE;
11719 if (!elf32_arm_output_map_sym (osi, ARM_MAP_DATA, addr + 8))
11720 return FALSE;
11721 break;
11722 case arm_stub_short_branch_v4t_thumb_arm:
11723 if (!elf32_arm_output_stub_sym (osi, stub_name, addr | 1, 8))
11724 return FALSE;
11725 if (!elf32_arm_output_map_sym (osi, ARM_MAP_THUMB, addr))
11726 return FALSE;
11727 if (!elf32_arm_output_map_sym (osi, ARM_MAP_ARM, addr + 4))
11728 return FALSE;
11729 break;
11730 case arm_stub_long_branch_any_any_pic:
11731 if (!elf32_arm_output_stub_sym (osi, stub_name, addr, 12))
11732 return FALSE;
11733 if (!elf32_arm_output_map_sym (osi, ARM_MAP_ARM, addr))
11734 return FALSE;
11735 if (!elf32_arm_output_map_sym (osi, ARM_MAP_DATA, addr + 8))
11736 return FALSE;
11737 break;
11738 default:
11739 BFD_FAIL ();
11740 }
11741
11742 return TRUE;
11743 }
11744
11745 /* Output mapping symbols for linker generated sections. */
11746
11747 static bfd_boolean
11748 elf32_arm_output_arch_local_syms (bfd *output_bfd,
11749 struct bfd_link_info *info,
11750 void *finfo,
11751 bfd_boolean (*func) (void *, const char *,
11752 Elf_Internal_Sym *,
11753 asection *,
11754 struct elf_link_hash_entry *))
11755 {
11756 output_arch_syminfo osi;
11757 struct elf32_arm_link_hash_table *htab;
11758 bfd_vma offset;
11759 bfd_size_type size;
11760
11761 htab = elf32_arm_hash_table (info);
11762 check_use_blx (htab);
11763
11764 osi.finfo = finfo;
11765 osi.info = info;
11766 osi.func = func;
11767
11768 /* ARM->Thumb glue. */
11769 if (htab->arm_glue_size > 0)
11770 {
11771 osi.sec = bfd_get_section_by_name (htab->bfd_of_glue_owner,
11772 ARM2THUMB_GLUE_SECTION_NAME);
11773
11774 osi.sec_shndx = _bfd_elf_section_from_bfd_section
11775 (output_bfd, osi.sec->output_section);
11776 if (info->shared || htab->root.is_relocatable_executable
11777 || htab->pic_veneer)
11778 size = ARM2THUMB_PIC_GLUE_SIZE;
11779 else if (htab->use_blx)
11780 size = ARM2THUMB_V5_STATIC_GLUE_SIZE;
11781 else
11782 size = ARM2THUMB_STATIC_GLUE_SIZE;
11783
11784 for (offset = 0; offset < htab->arm_glue_size; offset += size)
11785 {
11786 elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, offset);
11787 elf32_arm_output_map_sym (&osi, ARM_MAP_DATA, offset + size - 4);
11788 }
11789 }
11790
11791 /* Thumb->ARM glue. */
11792 if (htab->thumb_glue_size > 0)
11793 {
11794 osi.sec = bfd_get_section_by_name (htab->bfd_of_glue_owner,
11795 THUMB2ARM_GLUE_SECTION_NAME);
11796
11797 osi.sec_shndx = _bfd_elf_section_from_bfd_section
11798 (output_bfd, osi.sec->output_section);
11799 size = THUMB2ARM_GLUE_SIZE;
11800
11801 for (offset = 0; offset < htab->thumb_glue_size; offset += size)
11802 {
11803 elf32_arm_output_map_sym (&osi, ARM_MAP_THUMB, offset);
11804 elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, offset + 4);
11805 }
11806 }
11807
11808 /* ARMv4 BX veneers. */
11809 if (htab->bx_glue_size > 0)
11810 {
11811 osi.sec = bfd_get_section_by_name (htab->bfd_of_glue_owner,
11812 ARM_BX_GLUE_SECTION_NAME);
11813
11814 osi.sec_shndx = _bfd_elf_section_from_bfd_section
11815 (output_bfd, osi.sec->output_section);
11816
11817 elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, 0);
11818 }
11819
11820 /* Long calls stubs. */
11821 if (htab->stub_bfd && htab->stub_bfd->sections)
11822 {
11823 asection* stub_sec;
11824
11825 for (stub_sec = htab->stub_bfd->sections;
11826 stub_sec != NULL;
11827 stub_sec = stub_sec->next)
11828 {
11829 /* Ignore non-stub sections. */
11830 if (!strstr (stub_sec->name, STUB_SUFFIX))
11831 continue;
11832
11833 osi.sec = stub_sec;
11834
11835 osi.sec_shndx = _bfd_elf_section_from_bfd_section
11836 (output_bfd, osi.sec->output_section);
11837
11838 bfd_hash_traverse (&htab->stub_hash_table, arm_map_one_stub, &osi);
11839 }
11840 }
11841
11842 /* Finally, output mapping symbols for the PLT. */
11843 if (!htab->splt || htab->splt->size == 0)
11844 return TRUE;
11845
11846 osi.sec_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
11847 htab->splt->output_section);
11848 osi.sec = htab->splt;
11849 /* Output mapping symbols for the plt header. SymbianOS does not have a
11850 plt header. */
11851 if (htab->vxworks_p)
11852 {
11853 /* VxWorks shared libraries have no PLT header. */
11854 if (!info->shared)
11855 {
11856 if (!elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, 0))
11857 return FALSE;
11858 if (!elf32_arm_output_map_sym (&osi, ARM_MAP_DATA, 12))
11859 return FALSE;
11860 }
11861 }
11862 else if (!htab->symbian_p)
11863 {
11864 if (!elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, 0))
11865 return FALSE;
11866 #ifndef FOUR_WORD_PLT
11867 if (!elf32_arm_output_map_sym (&osi, ARM_MAP_DATA, 16))
11868 return FALSE;
11869 #endif
11870 }
11871
11872 elf_link_hash_traverse (&htab->root, elf32_arm_output_plt_map, (void *) &osi);
11873 return TRUE;
11874 }
11875
11876 /* Allocate target specific section data. */
11877
11878 static bfd_boolean
11879 elf32_arm_new_section_hook (bfd *abfd, asection *sec)
11880 {
11881 if (!sec->used_by_bfd)
11882 {
11883 _arm_elf_section_data *sdata;
11884 bfd_size_type amt = sizeof (*sdata);
11885
11886 sdata = bfd_zalloc (abfd, amt);
11887 if (sdata == NULL)
11888 return FALSE;
11889 sec->used_by_bfd = sdata;
11890 }
11891
11892 record_section_with_arm_elf_section_data (sec);
11893
11894 return _bfd_elf_new_section_hook (abfd, sec);
11895 }
11896
11897
11898 /* Used to order a list of mapping symbols by address. */
11899
11900 static int
11901 elf32_arm_compare_mapping (const void * a, const void * b)
11902 {
11903 const elf32_arm_section_map *amap = (const elf32_arm_section_map *) a;
11904 const elf32_arm_section_map *bmap = (const elf32_arm_section_map *) b;
11905
11906 if (amap->vma > bmap->vma)
11907 return 1;
11908 else if (amap->vma < bmap->vma)
11909 return -1;
11910 else if (amap->type > bmap->type)
11911 /* Ensure results do not depend on the host qsort for objects with
11912 multiple mapping symbols at the same address by sorting on type
11913 after vma. */
11914 return 1;
11915 else if (amap->type < bmap->type)
11916 return -1;
11917 else
11918 return 0;
11919 }
11920
11921
11922 /* Do code byteswapping. Return FALSE afterwards so that the section is
11923 written out as normal. */
11924
11925 static bfd_boolean
11926 elf32_arm_write_section (bfd *output_bfd,
11927 struct bfd_link_info *link_info,
11928 asection *sec,
11929 bfd_byte *contents)
11930 {
11931 int mapcount, errcount;
11932 _arm_elf_section_data *arm_data;
11933 struct elf32_arm_link_hash_table *globals = elf32_arm_hash_table (link_info);
11934 elf32_arm_section_map *map;
11935 elf32_vfp11_erratum_list *errnode;
11936 bfd_vma ptr;
11937 bfd_vma end;
11938 bfd_vma offset = sec->output_section->vma + sec->output_offset;
11939 bfd_byte tmp;
11940 int i;
11941
11942 /* If this section has not been allocated an _arm_elf_section_data
11943 structure then we cannot record anything. */
11944 arm_data = get_arm_elf_section_data (sec);
11945 if (arm_data == NULL)
11946 return FALSE;
11947
11948 mapcount = arm_data->mapcount;
11949 map = arm_data->map;
11950 errcount = arm_data->erratumcount;
11951
11952 if (errcount != 0)
11953 {
11954 unsigned int endianflip = bfd_big_endian (output_bfd) ? 3 : 0;
11955
11956 for (errnode = arm_data->erratumlist; errnode != 0;
11957 errnode = errnode->next)
11958 {
11959 bfd_vma index = errnode->vma - offset;
11960
11961 switch (errnode->type)
11962 {
11963 case VFP11_ERRATUM_BRANCH_TO_ARM_VENEER:
11964 {
11965 bfd_vma branch_to_veneer;
11966 /* Original condition code of instruction, plus bit mask for
11967 ARM B instruction. */
11968 unsigned int insn = (errnode->u.b.vfp_insn & 0xf0000000)
11969 | 0x0a000000;
11970
11971 /* The instruction is before the label. */
11972 index -= 4;
11973
11974 /* Above offset included in -4 below. */
11975 branch_to_veneer = errnode->u.b.veneer->vma
11976 - errnode->vma - 4;
11977
11978 if ((signed) branch_to_veneer < -(1 << 25)
11979 || (signed) branch_to_veneer >= (1 << 25))
11980 (*_bfd_error_handler) (_("%B: error: VFP11 veneer out of "
11981 "range"), output_bfd);
11982
11983 insn |= (branch_to_veneer >> 2) & 0xffffff;
11984 contents[endianflip ^ index] = insn & 0xff;
11985 contents[endianflip ^ (index + 1)] = (insn >> 8) & 0xff;
11986 contents[endianflip ^ (index + 2)] = (insn >> 16) & 0xff;
11987 contents[endianflip ^ (index + 3)] = (insn >> 24) & 0xff;
11988 }
11989 break;
11990
11991 case VFP11_ERRATUM_ARM_VENEER:
11992 {
11993 bfd_vma branch_from_veneer;
11994 unsigned int insn;
11995
11996 /* Take size of veneer into account. */
11997 branch_from_veneer = errnode->u.v.branch->vma
11998 - errnode->vma - 12;
11999
12000 if ((signed) branch_from_veneer < -(1 << 25)
12001 || (signed) branch_from_veneer >= (1 << 25))
12002 (*_bfd_error_handler) (_("%B: error: VFP11 veneer out of "
12003 "range"), output_bfd);
12004
12005 /* Original instruction. */
12006 insn = errnode->u.v.branch->u.b.vfp_insn;
12007 contents[endianflip ^ index] = insn & 0xff;
12008 contents[endianflip ^ (index + 1)] = (insn >> 8) & 0xff;
12009 contents[endianflip ^ (index + 2)] = (insn >> 16) & 0xff;
12010 contents[endianflip ^ (index + 3)] = (insn >> 24) & 0xff;
12011
12012 /* Branch back to insn after original insn. */
12013 insn = 0xea000000 | ((branch_from_veneer >> 2) & 0xffffff);
12014 contents[endianflip ^ (index + 4)] = insn & 0xff;
12015 contents[endianflip ^ (index + 5)] = (insn >> 8) & 0xff;
12016 contents[endianflip ^ (index + 6)] = (insn >> 16) & 0xff;
12017 contents[endianflip ^ (index + 7)] = (insn >> 24) & 0xff;
12018 }
12019 break;
12020
12021 default:
12022 abort ();
12023 }
12024 }
12025 }
12026
12027 if (mapcount == 0)
12028 return FALSE;
12029
12030 if (globals->byteswap_code)
12031 {
12032 qsort (map, mapcount, sizeof (* map), elf32_arm_compare_mapping);
12033
12034 ptr = map[0].vma;
12035 for (i = 0; i < mapcount; i++)
12036 {
12037 if (i == mapcount - 1)
12038 end = sec->size;
12039 else
12040 end = map[i + 1].vma;
12041
12042 switch (map[i].type)
12043 {
12044 case 'a':
12045 /* Byte swap code words. */
12046 while (ptr + 3 < end)
12047 {
12048 tmp = contents[ptr];
12049 contents[ptr] = contents[ptr + 3];
12050 contents[ptr + 3] = tmp;
12051 tmp = contents[ptr + 1];
12052 contents[ptr + 1] = contents[ptr + 2];
12053 contents[ptr + 2] = tmp;
12054 ptr += 4;
12055 }
12056 break;
12057
12058 case 't':
12059 /* Byte swap code halfwords. */
12060 while (ptr + 1 < end)
12061 {
12062 tmp = contents[ptr];
12063 contents[ptr] = contents[ptr + 1];
12064 contents[ptr + 1] = tmp;
12065 ptr += 2;
12066 }
12067 break;
12068
12069 case 'd':
12070 /* Leave data alone. */
12071 break;
12072 }
12073 ptr = end;
12074 }
12075 }
12076
12077 free (map);
12078 arm_data->mapcount = 0;
12079 arm_data->mapsize = 0;
12080 arm_data->map = NULL;
12081 unrecord_section_with_arm_elf_section_data (sec);
12082
12083 return FALSE;
12084 }
12085
12086 static void
12087 unrecord_section_via_map_over_sections (bfd * abfd ATTRIBUTE_UNUSED,
12088 asection * sec,
12089 void * ignore ATTRIBUTE_UNUSED)
12090 {
12091 unrecord_section_with_arm_elf_section_data (sec);
12092 }
12093
12094 static bfd_boolean
12095 elf32_arm_close_and_cleanup (bfd * abfd)
12096 {
12097 if (abfd->sections)
12098 bfd_map_over_sections (abfd,
12099 unrecord_section_via_map_over_sections,
12100 NULL);
12101
12102 return _bfd_elf_close_and_cleanup (abfd);
12103 }
12104
12105 static bfd_boolean
12106 elf32_arm_bfd_free_cached_info (bfd * abfd)
12107 {
12108 if (abfd->sections)
12109 bfd_map_over_sections (abfd,
12110 unrecord_section_via_map_over_sections,
12111 NULL);
12112
12113 return _bfd_free_cached_info (abfd);
12114 }
12115
12116 /* Display STT_ARM_TFUNC symbols as functions. */
12117
12118 static void
12119 elf32_arm_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
12120 asymbol *asym)
12121 {
12122 elf_symbol_type *elfsym = (elf_symbol_type *) asym;
12123
12124 if (ELF_ST_TYPE (elfsym->internal_elf_sym.st_info) == STT_ARM_TFUNC)
12125 elfsym->symbol.flags |= BSF_FUNCTION;
12126 }
12127
12128
12129 /* Mangle thumb function symbols as we read them in. */
12130
12131 static bfd_boolean
12132 elf32_arm_swap_symbol_in (bfd * abfd,
12133 const void *psrc,
12134 const void *pshn,
12135 Elf_Internal_Sym *dst)
12136 {
12137 if (!bfd_elf32_swap_symbol_in (abfd, psrc, pshn, dst))
12138 return FALSE;
12139
12140 /* New EABI objects mark thumb function symbols by setting the low bit of
12141 the address. Turn these into STT_ARM_TFUNC. */
12142 if ((ELF_ST_TYPE (dst->st_info) == STT_FUNC)
12143 && (dst->st_value & 1))
12144 {
12145 dst->st_info = ELF_ST_INFO (ELF_ST_BIND (dst->st_info), STT_ARM_TFUNC);
12146 dst->st_value &= ~(bfd_vma) 1;
12147 }
12148 return TRUE;
12149 }
12150
12151
12152 /* Mangle thumb function symbols as we write them out. */
12153
12154 static void
12155 elf32_arm_swap_symbol_out (bfd *abfd,
12156 const Elf_Internal_Sym *src,
12157 void *cdst,
12158 void *shndx)
12159 {
12160 Elf_Internal_Sym newsym;
12161
12162 /* We convert STT_ARM_TFUNC symbols into STT_FUNC with the low bit
12163 of the address set, as per the new EABI. We do this unconditionally
12164 because objcopy does not set the elf header flags until after
12165 it writes out the symbol table. */
12166 if (ELF_ST_TYPE (src->st_info) == STT_ARM_TFUNC)
12167 {
12168 newsym = *src;
12169 newsym.st_info = ELF_ST_INFO (ELF_ST_BIND (src->st_info), STT_FUNC);
12170 if (newsym.st_shndx != SHN_UNDEF)
12171 {
12172 /* Do this only for defined symbols. At link type, the static
12173 linker will simulate the work of dynamic linker of resolving
12174 symbols and will carry over the thumbness of found symbols to
12175 the output symbol table. It's not clear how it happens, but
12176 the thumbness of undefined symbols can well be different at
12177 runtime, and writing '1' for them will be confusing for users
12178 and possibly for dynamic linker itself.
12179 */
12180 newsym.st_value |= 1;
12181 }
12182
12183 src = &newsym;
12184 }
12185 bfd_elf32_swap_symbol_out (abfd, src, cdst, shndx);
12186 }
12187
12188 /* Add the PT_ARM_EXIDX program header. */
12189
12190 static bfd_boolean
12191 elf32_arm_modify_segment_map (bfd *abfd,
12192 struct bfd_link_info *info ATTRIBUTE_UNUSED)
12193 {
12194 struct elf_segment_map *m;
12195 asection *sec;
12196
12197 sec = bfd_get_section_by_name (abfd, ".ARM.exidx");
12198 if (sec != NULL && (sec->flags & SEC_LOAD) != 0)
12199 {
12200 /* If there is already a PT_ARM_EXIDX header, then we do not
12201 want to add another one. This situation arises when running
12202 "strip"; the input binary already has the header. */
12203 m = elf_tdata (abfd)->segment_map;
12204 while (m && m->p_type != PT_ARM_EXIDX)
12205 m = m->next;
12206 if (!m)
12207 {
12208 m = bfd_zalloc (abfd, sizeof (struct elf_segment_map));
12209 if (m == NULL)
12210 return FALSE;
12211 m->p_type = PT_ARM_EXIDX;
12212 m->count = 1;
12213 m->sections[0] = sec;
12214
12215 m->next = elf_tdata (abfd)->segment_map;
12216 elf_tdata (abfd)->segment_map = m;
12217 }
12218 }
12219
12220 return TRUE;
12221 }
12222
12223 /* We may add a PT_ARM_EXIDX program header. */
12224
12225 static int
12226 elf32_arm_additional_program_headers (bfd *abfd,
12227 struct bfd_link_info *info ATTRIBUTE_UNUSED)
12228 {
12229 asection *sec;
12230
12231 sec = bfd_get_section_by_name (abfd, ".ARM.exidx");
12232 if (sec != NULL && (sec->flags & SEC_LOAD) != 0)
12233 return 1;
12234 else
12235 return 0;
12236 }
12237
12238 /* We have two function types: STT_FUNC and STT_ARM_TFUNC. */
12239
12240 static bfd_boolean
12241 elf32_arm_is_function_type (unsigned int type)
12242 {
12243 return (type == STT_FUNC) || (type == STT_ARM_TFUNC);
12244 }
12245
12246 /* We use this to override swap_symbol_in and swap_symbol_out. */
12247 const struct elf_size_info elf32_arm_size_info =
12248 {
12249 sizeof (Elf32_External_Ehdr),
12250 sizeof (Elf32_External_Phdr),
12251 sizeof (Elf32_External_Shdr),
12252 sizeof (Elf32_External_Rel),
12253 sizeof (Elf32_External_Rela),
12254 sizeof (Elf32_External_Sym),
12255 sizeof (Elf32_External_Dyn),
12256 sizeof (Elf_External_Note),
12257 4,
12258 1,
12259 32, 2,
12260 ELFCLASS32, EV_CURRENT,
12261 bfd_elf32_write_out_phdrs,
12262 bfd_elf32_write_shdrs_and_ehdr,
12263 bfd_elf32_checksum_contents,
12264 bfd_elf32_write_relocs,
12265 elf32_arm_swap_symbol_in,
12266 elf32_arm_swap_symbol_out,
12267 bfd_elf32_slurp_reloc_table,
12268 bfd_elf32_slurp_symbol_table,
12269 bfd_elf32_swap_dyn_in,
12270 bfd_elf32_swap_dyn_out,
12271 bfd_elf32_swap_reloc_in,
12272 bfd_elf32_swap_reloc_out,
12273 bfd_elf32_swap_reloca_in,
12274 bfd_elf32_swap_reloca_out
12275 };
12276
12277 #define ELF_ARCH bfd_arch_arm
12278 #define ELF_MACHINE_CODE EM_ARM
12279 #ifdef __QNXTARGET__
12280 #define ELF_MAXPAGESIZE 0x1000
12281 #else
12282 #define ELF_MAXPAGESIZE 0x8000
12283 #endif
12284 #define ELF_MINPAGESIZE 0x1000
12285 #define ELF_COMMONPAGESIZE 0x1000
12286
12287 #define bfd_elf32_mkobject elf32_arm_mkobject
12288
12289 #define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
12290 #define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
12291 #define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
12292 #define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
12293 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
12294 #define bfd_elf32_bfd_link_hash_table_free elf32_arm_hash_table_free
12295 #define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
12296 #define bfd_elf32_bfd_reloc_name_lookup elf32_arm_reloc_name_lookup
12297 #define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
12298 #define bfd_elf32_find_inliner_info elf32_arm_find_inliner_info
12299 #define bfd_elf32_new_section_hook elf32_arm_new_section_hook
12300 #define bfd_elf32_bfd_is_target_special_symbol elf32_arm_is_target_special_symbol
12301 #define bfd_elf32_close_and_cleanup elf32_arm_close_and_cleanup
12302 #define bfd_elf32_bfd_free_cached_info elf32_arm_bfd_free_cached_info
12303
12304 #define elf_backend_get_symbol_type elf32_arm_get_symbol_type
12305 #define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
12306 #define elf_backend_gc_mark_extra_sections elf32_arm_gc_mark_extra_sections
12307 #define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
12308 #define elf_backend_check_relocs elf32_arm_check_relocs
12309 #define elf_backend_relocate_section elf32_arm_relocate_section
12310 #define elf_backend_write_section elf32_arm_write_section
12311 #define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
12312 #define elf_backend_create_dynamic_sections elf32_arm_create_dynamic_sections
12313 #define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
12314 #define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
12315 #define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
12316 #define elf_backend_init_index_section _bfd_elf_init_2_index_sections
12317 #define elf_backend_post_process_headers elf32_arm_post_process_headers
12318 #define elf_backend_reloc_type_class elf32_arm_reloc_type_class
12319 #define elf_backend_object_p elf32_arm_object_p
12320 #define elf_backend_section_flags elf32_arm_section_flags
12321 #define elf_backend_fake_sections elf32_arm_fake_sections
12322 #define elf_backend_section_from_shdr elf32_arm_section_from_shdr
12323 #define elf_backend_final_write_processing elf32_arm_final_write_processing
12324 #define elf_backend_copy_indirect_symbol elf32_arm_copy_indirect_symbol
12325 #define elf_backend_symbol_processing elf32_arm_symbol_processing
12326 #define elf_backend_size_info elf32_arm_size_info
12327 #define elf_backend_modify_segment_map elf32_arm_modify_segment_map
12328 #define elf_backend_additional_program_headers elf32_arm_additional_program_headers
12329 #define elf_backend_output_arch_local_syms elf32_arm_output_arch_local_syms
12330 #define elf_backend_begin_write_processing elf32_arm_begin_write_processing
12331 #define elf_backend_is_function_type elf32_arm_is_function_type
12332
12333 #define elf_backend_can_refcount 1
12334 #define elf_backend_can_gc_sections 1
12335 #define elf_backend_plt_readonly 1
12336 #define elf_backend_want_got_plt 1
12337 #define elf_backend_want_plt_sym 0
12338 #define elf_backend_may_use_rel_p 1
12339 #define elf_backend_may_use_rela_p 0
12340 #define elf_backend_default_use_rela_p 0
12341
12342 #define elf_backend_got_header_size 12
12343
12344 #undef elf_backend_obj_attrs_vendor
12345 #define elf_backend_obj_attrs_vendor "aeabi"
12346 #undef elf_backend_obj_attrs_section
12347 #define elf_backend_obj_attrs_section ".ARM.attributes"
12348 #undef elf_backend_obj_attrs_arg_type
12349 #define elf_backend_obj_attrs_arg_type elf32_arm_obj_attrs_arg_type
12350 #undef elf_backend_obj_attrs_section_type
12351 #define elf_backend_obj_attrs_section_type SHT_ARM_ATTRIBUTES
12352 #define elf_backend_obj_attrs_order elf32_arm_obj_attrs_order
12353
12354 #include "elf32-target.h"
12355
12356 /* VxWorks Targets. */
12357
12358 #undef TARGET_LITTLE_SYM
12359 #define TARGET_LITTLE_SYM bfd_elf32_littlearm_vxworks_vec
12360 #undef TARGET_LITTLE_NAME
12361 #define TARGET_LITTLE_NAME "elf32-littlearm-vxworks"
12362 #undef TARGET_BIG_SYM
12363 #define TARGET_BIG_SYM bfd_elf32_bigarm_vxworks_vec
12364 #undef TARGET_BIG_NAME
12365 #define TARGET_BIG_NAME "elf32-bigarm-vxworks"
12366
12367 /* Like elf32_arm_link_hash_table_create -- but overrides
12368 appropriately for VxWorks. */
12369
12370 static struct bfd_link_hash_table *
12371 elf32_arm_vxworks_link_hash_table_create (bfd *abfd)
12372 {
12373 struct bfd_link_hash_table *ret;
12374
12375 ret = elf32_arm_link_hash_table_create (abfd);
12376 if (ret)
12377 {
12378 struct elf32_arm_link_hash_table *htab
12379 = (struct elf32_arm_link_hash_table *) ret;
12380 htab->use_rel = 0;
12381 htab->vxworks_p = 1;
12382 }
12383 return ret;
12384 }
12385
12386 static void
12387 elf32_arm_vxworks_final_write_processing (bfd *abfd, bfd_boolean linker)
12388 {
12389 elf32_arm_final_write_processing (abfd, linker);
12390 elf_vxworks_final_write_processing (abfd, linker);
12391 }
12392
12393 #undef elf32_bed
12394 #define elf32_bed elf32_arm_vxworks_bed
12395
12396 #undef bfd_elf32_bfd_link_hash_table_create
12397 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_vxworks_link_hash_table_create
12398 #undef elf_backend_add_symbol_hook
12399 #define elf_backend_add_symbol_hook elf_vxworks_add_symbol_hook
12400 #undef elf_backend_final_write_processing
12401 #define elf_backend_final_write_processing elf32_arm_vxworks_final_write_processing
12402 #undef elf_backend_emit_relocs
12403 #define elf_backend_emit_relocs elf_vxworks_emit_relocs
12404
12405 #undef elf_backend_may_use_rel_p
12406 #define elf_backend_may_use_rel_p 0
12407 #undef elf_backend_may_use_rela_p
12408 #define elf_backend_may_use_rela_p 1
12409 #undef elf_backend_default_use_rela_p
12410 #define elf_backend_default_use_rela_p 1
12411 #undef elf_backend_want_plt_sym
12412 #define elf_backend_want_plt_sym 1
12413 #undef ELF_MAXPAGESIZE
12414 #define ELF_MAXPAGESIZE 0x1000
12415
12416 #include "elf32-target.h"
12417
12418
12419 /* Symbian OS Targets. */
12420
12421 #undef TARGET_LITTLE_SYM
12422 #define TARGET_LITTLE_SYM bfd_elf32_littlearm_symbian_vec
12423 #undef TARGET_LITTLE_NAME
12424 #define TARGET_LITTLE_NAME "elf32-littlearm-symbian"
12425 #undef TARGET_BIG_SYM
12426 #define TARGET_BIG_SYM bfd_elf32_bigarm_symbian_vec
12427 #undef TARGET_BIG_NAME
12428 #define TARGET_BIG_NAME "elf32-bigarm-symbian"
12429
12430 /* Like elf32_arm_link_hash_table_create -- but overrides
12431 appropriately for Symbian OS. */
12432
12433 static struct bfd_link_hash_table *
12434 elf32_arm_symbian_link_hash_table_create (bfd *abfd)
12435 {
12436 struct bfd_link_hash_table *ret;
12437
12438 ret = elf32_arm_link_hash_table_create (abfd);
12439 if (ret)
12440 {
12441 struct elf32_arm_link_hash_table *htab
12442 = (struct elf32_arm_link_hash_table *)ret;
12443 /* There is no PLT header for Symbian OS. */
12444 htab->plt_header_size = 0;
12445 /* The PLT entries are each one instruction and one word. */
12446 htab->plt_entry_size = 4 * ARRAY_SIZE (elf32_arm_symbian_plt_entry);
12447 htab->symbian_p = 1;
12448 /* Symbian uses armv5t or above, so use_blx is always true. */
12449 htab->use_blx = 1;
12450 htab->root.is_relocatable_executable = 1;
12451 }
12452 return ret;
12453 }
12454
12455 static const struct bfd_elf_special_section
12456 elf32_arm_symbian_special_sections[] =
12457 {
12458 /* In a BPABI executable, the dynamic linking sections do not go in
12459 the loadable read-only segment. The post-linker may wish to
12460 refer to these sections, but they are not part of the final
12461 program image. */
12462 { STRING_COMMA_LEN (".dynamic"), 0, SHT_DYNAMIC, 0 },
12463 { STRING_COMMA_LEN (".dynstr"), 0, SHT_STRTAB, 0 },
12464 { STRING_COMMA_LEN (".dynsym"), 0, SHT_DYNSYM, 0 },
12465 { STRING_COMMA_LEN (".got"), 0, SHT_PROGBITS, 0 },
12466 { STRING_COMMA_LEN (".hash"), 0, SHT_HASH, 0 },
12467 /* These sections do not need to be writable as the SymbianOS
12468 postlinker will arrange things so that no dynamic relocation is
12469 required. */
12470 { STRING_COMMA_LEN (".init_array"), 0, SHT_INIT_ARRAY, SHF_ALLOC },
12471 { STRING_COMMA_LEN (".fini_array"), 0, SHT_FINI_ARRAY, SHF_ALLOC },
12472 { STRING_COMMA_LEN (".preinit_array"), 0, SHT_PREINIT_ARRAY, SHF_ALLOC },
12473 { NULL, 0, 0, 0, 0 }
12474 };
12475
12476 static void
12477 elf32_arm_symbian_begin_write_processing (bfd *abfd,
12478 struct bfd_link_info *link_info)
12479 {
12480 /* BPABI objects are never loaded directly by an OS kernel; they are
12481 processed by a postlinker first, into an OS-specific format. If
12482 the D_PAGED bit is set on the file, BFD will align segments on
12483 page boundaries, so that an OS can directly map the file. With
12484 BPABI objects, that just results in wasted space. In addition,
12485 because we clear the D_PAGED bit, map_sections_to_segments will
12486 recognize that the program headers should not be mapped into any
12487 loadable segment. */
12488 abfd->flags &= ~D_PAGED;
12489 elf32_arm_begin_write_processing (abfd, link_info);
12490 }
12491
12492 static bfd_boolean
12493 elf32_arm_symbian_modify_segment_map (bfd *abfd,
12494 struct bfd_link_info *info)
12495 {
12496 struct elf_segment_map *m;
12497 asection *dynsec;
12498
12499 /* BPABI shared libraries and executables should have a PT_DYNAMIC
12500 segment. However, because the .dynamic section is not marked
12501 with SEC_LOAD, the generic ELF code will not create such a
12502 segment. */
12503 dynsec = bfd_get_section_by_name (abfd, ".dynamic");
12504 if (dynsec)
12505 {
12506 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
12507 if (m->p_type == PT_DYNAMIC)
12508 break;
12509
12510 if (m == NULL)
12511 {
12512 m = _bfd_elf_make_dynamic_segment (abfd, dynsec);
12513 m->next = elf_tdata (abfd)->segment_map;
12514 elf_tdata (abfd)->segment_map = m;
12515 }
12516 }
12517
12518 /* Also call the generic arm routine. */
12519 return elf32_arm_modify_segment_map (abfd, info);
12520 }
12521
12522 /* Return address for Ith PLT stub in section PLT, for relocation REL
12523 or (bfd_vma) -1 if it should not be included. */
12524
12525 static bfd_vma
12526 elf32_arm_symbian_plt_sym_val (bfd_vma i, const asection *plt,
12527 const arelent *rel ATTRIBUTE_UNUSED)
12528 {
12529 return plt->vma + 4 * ARRAY_SIZE (elf32_arm_symbian_plt_entry) * i;
12530 }
12531
12532
12533 #undef elf32_bed
12534 #define elf32_bed elf32_arm_symbian_bed
12535
12536 /* The dynamic sections are not allocated on SymbianOS; the postlinker
12537 will process them and then discard them. */
12538 #undef ELF_DYNAMIC_SEC_FLAGS
12539 #define ELF_DYNAMIC_SEC_FLAGS \
12540 (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED)
12541
12542 #undef elf_backend_add_symbol_hook
12543 #undef elf_backend_emit_relocs
12544
12545 #undef bfd_elf32_bfd_link_hash_table_create
12546 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_symbian_link_hash_table_create
12547 #undef elf_backend_special_sections
12548 #define elf_backend_special_sections elf32_arm_symbian_special_sections
12549 #undef elf_backend_begin_write_processing
12550 #define elf_backend_begin_write_processing elf32_arm_symbian_begin_write_processing
12551 #undef elf_backend_final_write_processing
12552 #define elf_backend_final_write_processing elf32_arm_final_write_processing
12553
12554 #undef elf_backend_modify_segment_map
12555 #define elf_backend_modify_segment_map elf32_arm_symbian_modify_segment_map
12556
12557 /* There is no .got section for BPABI objects, and hence no header. */
12558 #undef elf_backend_got_header_size
12559 #define elf_backend_got_header_size 0
12560
12561 /* Similarly, there is no .got.plt section. */
12562 #undef elf_backend_want_got_plt
12563 #define elf_backend_want_got_plt 0
12564
12565 #undef elf_backend_plt_sym_val
12566 #define elf_backend_plt_sym_val elf32_arm_symbian_plt_sym_val
12567
12568 #undef elf_backend_may_use_rel_p
12569 #define elf_backend_may_use_rel_p 1
12570 #undef elf_backend_may_use_rela_p
12571 #define elf_backend_may_use_rela_p 0
12572 #undef elf_backend_default_use_rela_p
12573 #define elf_backend_default_use_rela_p 0
12574 #undef elf_backend_want_plt_sym
12575 #define elf_backend_want_plt_sym 0
12576 #undef ELF_MAXPAGESIZE
12577 #define ELF_MAXPAGESIZE 0x8000
12578
12579 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.372233 seconds and 5 git commands to generate.